Generate alphabet with 4 copies of each letter

Question

Note that this is not the same as Print the alphabet four times.

This task is to write a program to generate four copies of each letter of the English alphabet, one letter per line, on standard output:

A
A
A
A
B
B
B
B

etc.

The output should include newlines after each letter.

Lowercase letters and/or extra whitespace are acceptable.

The solution must be a complete program.

This is code-golf so answers will be scored in bytes with a lower score being the goal.

Answer 1

GolfScript, 17 bytes

91,65>''+{...}%n*

Try it online!

Explanation

91,65>            # Genearate initial alphabet
      ''+         # Convert to a string
         {...}%   # For every item, copy 3 times
               n* # Join the resulting string by newlines
                  # (because a string is a codepoint array)

Answer 2

Burlesque, 16 bytes

@AZr@4?*{)'
}\mQ

Try it online!

@AZr@ # Array of A-Z as chars
4?*   # 4 of each as strings
{
 )'   # Add a newline between each letter
}\m   # Map for each string of 4 and concatenate
Q     # Pretty print for newlines instead of "\n"

Answer 3

Clojure 41 45 bytes

(doseq[i(range 65 91 0.25)](println(char i)))

Answer 4

Google Sheets, 40

Output per cell:

=ArrayFormula(CHAR(SEQUENCE(104,1,260)/4

If newlines are important, 49:

=ArrayFormula(JOIN("
",CHAR(SEQUENCE(104,1,260)/4

No, Sequence does not support floating point steps.

Answer 5

Julia 1.0, 26 bytes

@.print((('A':'Z')*"
")^4)

Try it online!

Answer 6

Haskell, 43 bytes

main=mapM(putStrLn.pure)$['A'..'Z']<*[1..4]

Try it online!

This has two parts mapM(putStrLn.pure) takes a list of characters and prints each on it's own line.

['A'..'Z']<*[1..4] produces the list of desired characters. It does this with the monadic operator (<*) which works like (>>) except it keeps the values from the first arguement instead of the second.

Answer 7

Excel, 21 bytes

=CHAR(ROW(260:363)/4)

Link to Spreadsheet

I think this would have worked when the question was asked if 104 cells were selected and Ctrl+Shift+Enter were used.

Answer 8

Python 3, 46 45 bytes

print(*["\n%c"%(i//4+65)for i in range(104)])

Python 3, 39 bytes

for i in range(104):print(chr(i//4+65))

I prefer the first solution for being a true one-liner. But a correction of Justin's answer leads to a shorter solution.

Answer 9

F#, 57 bytes

for i in 97..122 do for _ in 0..3 do printf"%c\n"(char i)

Try it online!

Loop through the alphabet (for i in 97..122), then through 4 times (for _ in 0..3), and finally print the character with a newline (printf"%c\n"(char i)).

Here is another one, 71 bytes:

for i in 97..122 do printf"%s"(String.replicate 4(string(char i)+"\n"))

Ungolfed code:

for i in 97..122 do for _ in 0..3 do printf "%c\n" (char i)

Answer 10

Noether, 22 bytes

65~i91(0~l4(iBP?!l)!i)

Try it online!

Answer 11

Zsh, 21 bytes

eval '<<<'{A..Z}{,,,}

Attempt This Online!

Answer 12

Google Sheets, 48 bytes

=flatten(sort(if({1,1,1,1},char(row(A65:A90)))))

Answer 13

Pip -n, 10 bytes

_MWV(zRL4)

Try It Online!

_MWV(zRL4)
    (zRL4)     ; repeat z="abcde...xyz" 4 times, forming the list [z,z,z,z]
  WV           ; weave the the 4 z's together, forming the string "aaaabbbb...yyyyzzzz"
_M             ; convert to a list
               ; implicitly joined by newlines by the -n flag and printed

Answer 14

Excel, 28 bytes.

=CHAR(SEQUENCE(104,,65,1/4))

No need to drag it will spill if one uses MS365 or Excel 2021.

Answer 15

///, 207 bytes

A
A
A
A
B
B
B
B
C
C
C
C
D
D
D
D
E
E
E
E
F
F
F
F
G
G
G
G
H
H
H
H
I
I
I
I
J
J
J
J
K
K
K
K
L
L
L
L
M
M
M
M
N
N
N
N
O
O
O
O
P
P
P
P
Q
Q
Q
Q
R
R
R
R
S
S
S
S
T
T
T
T
U
U
U
U
V
V
V
V
W
W
W
W
X
X
X
X
Y
Y
Y
Y
Z
Z
Z
Z

Answer 16

bash shell, 19 bytes

echo {A..Z}{,,,}'
'

Answer 17

Factor + sequences.repeating spelling, 38 bytes

ALPHABET 4 repeat 10 interleaved print

Attempt This Online!

ALPHABET       ! "abcdefghijklmnopqrstuvwxyz"
4 repeat       ! "aaaabbbbccccddddeeeeffffgggghhhhiiiijjjjkkkkllllmmmmnnnnooooppppqqqqrrrrssssttttuuuuvvvvwwwwxxxxyyyyzzzz"
10 interleaved ! "a\na\na\na\nb\nb\nb\nb\nc\nc\nc\nc\nd\nd\nd\nd\ne\ne\ne\ne\nf\nf\nf\nf\ng\ng\ng\ng\nh\nh\nh\nh\ni\ni\ni\ni\nj\nj\nj\nj\nk\nk\nk\nk\nl\nl\nl\nl\nm\nm\nm\nm\nn\nn\nn\nn\no\no\no\no\np\np\np\np\nq\nq\nq\nq\nr\nr\nr\nr\ns\ns\ns\ns\nt\nt\nt\nt\nu\nu\nu\nu\nv\nv\nv\nv\nw\nw\nw\nw\nx\nx\nx\nx\ny\ny\ny\ny\nz\nz\nz\nz"
print          ! (print to stdout)

Answer 18

Wren, 57 bytes

for(c in 65..90)System.write((String.fromByte(c)+"\n")*4)

Try Wren

Answer 19

Headascii, 59 bytes

+++++[]]ONE.+++++[]]]]]++^[]]+[U{D-^)!:RP]PRP]PRP]PRP]PN][}

"Try it" on DSO (links to a version which only supports number output, but should get the point across)

Alternatively, try it here, but code will have to be pasted in as shown:

erun("+++++[]]ONE.+++++[]]]]]++^[]]+[U{D-^)!:RP]PRP]PRP]PRP]PN][}")

short breakdown:

+++++[]]O                                        save 10 to global array
         NE                                      go to next code block
.                                                code block separator
+++++[]]]]]++^                                   set r1 to 27
              []]+[                              set r2 to 55
                   U                             grab 10 from the global array
                    {D-^) :                   }  while --r1 + 1 != 0
                           RP                      send out ascii 10 (newline)
                             ]P                    send out ascii 10 + r2 (letter)
                               RP]PRP]PRP]P        (four times total)
                                           N][     r2++
                         !                       finally, print all 'send out' chars

However, I must note that if instead of using erun we run it with lrun, newlines are automatically appended at the end of each print (and ! is no longer required because technically it's a Headass program), making this 38 byter possible:

Headass lrun, 38 bytes

+++++[]]]]]++^+++++[]][{D-^):N][]PPPP}

DSO link, still prints as numbers, must-paste-in-code interpreter link

Which... I guess its just dawning on me that that's a different.. Version? ...But I'm not going to go and mark all my Headas(s|cii) answers based on which "interpreter" they use unless it's actually relevant to the challenge :P

Oh and of course, a breakdown:

+++++[]]]]]++^                          set r1 to 27
              +++++[]][                 set r2 to 64
                       {D-^):        }  while --r1 != 0
                             N][]PPPP     print ++r2 four times