[Question]
  [
Note that this is not the same as [Print the alphabet four times](https://codegolf.stackexchange.com/questions/2167/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](/questions/tagged/code-golf "show questions tagged 'code-golf'") so answers will be scored in bytes with a lower score being the goal.
  
[Answer]
## APL (5)
```
⍪4/⎕A
```
Matrix format (`⍪`) of 4-replication (`4/`) of alphabet (`⎕A`).
[Answer]
# Python 2 - 37
```
for i in range(104):print chr(i/4+65)
```
As `i` goes from 0 to 104, it is divided by four and added to the ASCII value for `A`, and the resulting character is printed.
[Answer]
# R, 30 28 27 25
```
write(rep(LETTERS,e=4),1)
```
---
Former version with 30 bytes:
```
cat(rep(LETTERS,e=4),sep="\n")
```
[Answer]
## C, 59
I submit this, an uncompetitively long answer, simply because I don't see a C submission yet. And that makes me sad. :-/
LATER: Props to @moala for doing a "/4" int version of this, saving 13 chars!
```
float i;main(){while(i<26)printf("%c\n",65+(int)i),i+=.25;}
```
[Answer]
# J: ~~18~~ 13
```
4#u:65+i.26 1
```
I'm still pretty shaky with J, so this could probably be improved
[Answer]
## Ruby, 23
```
puts ([*?A..?Z]*4).sort
```
All credit to @manatwork -- upvote his comment, not this. :)
[Answer]
# PowerShell: 32 23
**Golfed code:**
```
[char[]](65..90*4)|Sort
```
**Walkthrough:**
`[char[]](`...`)` takes an array of objects and converts them to ASCII characters.  
`65..90` are the ASCII codes for A-Z.  
`*4` repeats the series 4 times.  
`|Sort` sorts the output.
**Note:**
If you want this written to a file, just throw `>`, followed by a file name, at the end.
[Answer]
## Haskell, 46
```
x a=a++a
main=putStr$['A'..'Z']>>=x.x.(:"\n")
```
[Answer]
# Befunge 98 - 18
```
1+::'g`#@_4/'A+,a,
```
Works by storing a number and ending when it reaches 104. Prints out the corresponding character of the alphabet for the number divided by 4, followed by a newline. But if I need not add a newline after each letter, then it is 16 chars:
```
1+::'g`#@_4/'A+,
```
Can be reduced if I can print more characters (ie all of them four times)(~~7~~ 6 chars, even works in Befunge 93):
```
1+:4/,
```
With newline:
```
1+:4/,a,
```
[Answer]
# C, ~~46~~ ~~44~~ 43
~~46~~:
```
i;main(){while(i<104)printf("%c\n",65+i++/4);}
```
~~44~~:
```
i=260;main(j){for(;(j=i++>>2)<91;puts(&j));}
```
44 too:
```
i=260;main(j){while(j=i++>>2,j<91)puts(&j);}
```
Thanks to @marinus, 43:
```
i=260;main(j){while(j=i++/4,j<91)puts(&j);}
```
Should I add a bounty for getting to 42? :)
[Answer]
**Java: 56**
```
for(int i=0;i<104;)System.out.println((char)(i++/4+65));
```
edit: changed from 'print' to 'println'
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 48 bytes
```
+++[[-<+>>++<]+>]<<<<<<+[->,++++[->.<<<.>>]>+<<]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fW1s7OlrXRtvOTlvbJlbbLtYGDLSjde10tEGSunZ6QL6enV2snbaNTez//wA "brainfuck – Try It Online")
Prints in lowercase, separated by carriage returns. Uses wrapping 8 bit cells as well as cells left of the origin, though you can prepend a `>` to counter the latter.
[Answer]
# GolfScript: ~~17~~ 15 characters
```
26,{65+...}%+n*
```
[Answer]
# Bash: 24 characters
```
printf %s\\n {A..Z}{,,,}
```
[Answer]
**BrainF\*** ,79 60
```
+++++++++++++[->++>+>+++++<<<]>>---<[->>>++++[-<.<.>>]<+<<]
```
[Answer]
## Forth, 37
```
'h 0 [do] [i] 4 / 'A + emit cr [loop]
```
[Answer]
# Actually, 6 bytes
```
4ú*SÖi
```
[Try it here!](http://actually.tryitonline.net/#code=NMO6KlPDlmk&input=)
Explanation
```
4ú*SÖi
4 *         Do 4 times
 ú          Create string of alphabet in lowercase
   S        Sort it
    Ö       Switch Case
     i      Push each character of string
```
4 Bytes with lowercase and no newline:
```
4ú*S
```
[Answer]
# 16-bit x86 machine code MS-DOS COM, 25 bytes
In hex:
```
B409BA160189D7B96800F6C1037502FE05CD21E2F5C3400A24
```
This is a complete MS-DOS .COM program. Copy the byte sequence to the file with .com extension and run it from DOSBox
Disassembly:
```
00: B4 09        mov    ah,0x09         ;INT 21h "Write string to STDOUT" function
02: BA 16 01     mov    dx,0x116        ;Address of the string s ('$'-terminated)
05: 89 D7        mov    di,dx           ;Because there's no way to dereference address in DX
07: B9 68 00     mov    cx,104          ;CX=26*4
_0000000A:
0A: F6 C1 03     test   cl,0x03         ;When lower two bits are zero...
0D: 75 02        jne    _00000011       ;...do not skip the next instruction
0F: FE 05        inc    b,[di]          ;*s++
_00000011:
11: CD 21        int    21              ;Print the string
13: E2 F5        loop   _0000000A       ;Until --CX==0
15: C3           retn
16: 40           db     0x40            ;s[0], starts with 'A'-1
17: 0A           db     0x0A            ;'\n'
18: 24           db     '$'             ;Terminator required by the print function
```
[Answer]
# [Perl 5](https://www.perl.org/), 20 bytes
```
print"$_
"x4for A..Z
```
[Try it online!](https://tio.run/##K0gtyjH9/7@gKDOvREklnkupwiQtv0jBUU8v6v9/AA "Perl 5 – Try It Online")
---
# [Perl 5](https://www.perl.org/) + `-M5.10.0`, 20 bytes
```
eval"say;"x4for A..Z
```
[Try it online!](https://tio.run/##K0gtyjH9/z@1LDFHqTix0lqpwiQtv0jBUU8v6v//f/kFJZn5ecX/dX1N9QwN9AwA "Perl 5 – Try It Online")
[Answer]
# x86-16 ASM, IBM PC DOS, ~~22~~ 19 bytes
**Binary:**
```
00000000: 400a 24b8 1109 8bd6 b168 d0c8 102c cd21  @.$......h...,.!
00000010: e2f8 c3                                  ...
```
Build with `xxd -r` and test in DOSBox or your favorite DOS VM.
**Unassembled:**
```
40 0A 24    DB   '@', 0AH, '$'      ; the letter + NL + '$' string terminator
B8 0911     MOV  AX, 0911H          ; AH = DOS print string; AL = 0001 0001 bit pattern
8B D6       MOV  DX, SI             ; DX to output string
B1 68       MOV  CL, 26*4           ; Loop 4 times for each letter in alphabet
        ALOOP:
D0 C8       ROR  AL, 1              ; roll repeating bit pattern to the right
10 2C       ADC  BYTE PTR[SI], CH   ; add rightmost bit to ASCII character
CD 21       INT  21H                ; print letter to console
E2 F8       LOOP ALOOP              ; continue looping
C3          RET                     ; return to DOS
```
**Notes:**
For most flavors of DOS, we know the values of many CPU registers at the [start of execution](http://www.fysnet.net/yourhelp.htm) and we know `SI` is `0100H`, and `CH` is `0`. So by placing the output string in the beginning of the program, `[SI]` will already be pointing to it. These bytes (`'@',0AH,'$'`) decode to two benign instructions (`INC AX`, `OR AH, [SI]`), which have no effect on the program.
`AL` contains the bit pattern of `0001 0001` which is bit rolled right each time and the rightmost bit added to the ASCII value of the output char in memory.
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `j`, 5 bytes
```
kAdds
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=j&code=kAdds&inputs=&header=&footer=)
Look ma, no Unicode!
```
kA    # Uppercase output
  dd  # Quadruple
    s # Sorted
      # (j flag) join by newlines
```
[Answer]
# [Jelly](//github.com/DennisMitchell/jelly), 5 bytes
```
ØAx4Y
```
[Try it online!](//jelly.tryitonline.net#code=w5hBeDRZ)
Explanation:
```
ØAx4Y Main link
ØA    “ABCDEFGHIJKLMNOPQRSTUVWXYZ”
   4  4
  x   Repeat each element of x y times
    Y Join x with newlines
```
[Answer]
# Q (13)
.........
```
-1@''4#'.Q.A;
```
[Answer]
**AWK, 48**
Lets try it with AWK...
```
END{s=65;for(i=104;i--;s+=0==i%4)printf"%c\n",s}
```
As suggested by [manatwork](https://codegolf.stackexchange.com/users/4198/manatwork) we can get rid of 2 chars
**AWK, 46 (Edit)**
```
END{for(i=104;i--;s+=0==i%4)printf"%c\n",s+65}
```
**AWK,40** (editing [MarkReed](https://codegolf.stackexchange.com/users/4133/mark-reed)'s code) 
```
END{for(;i<104;){printf"%c\n",i++/4+65}}
```
[Answer]
## PowerShell, 21
```
65..90|%{,[char]$_*4}
```
A slightly different approach to Iszi's. And shorter :-)
[Answer]
**C# LINQ ~~115 Bytes~~110 Bytes**
```
Enumerable.Range(65, 26).SelectMany(i => Enumerable.Repeat(i,4))
.ToList().ForEach(i=> Console.WriteLine((char)i));
```
[Answer]
# 05AB1E, 6 bytes
```
A4×{S»
```
Explanation:
```
A       # Push 'abcdefghijklmnopqrstuvwxyz'
 4×     # Repeat four times
   {    # Sort
    S   # Split into list
     »  # Join by newlines
        # Implicit print
```
Without newlines, 4 bytes
```
A4×{
```
[Try it online!](http://05ab1e.tryitonline.net/#code=QTTDl3tTwrs)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
Aε4F=
```
[Try it online!](https://tio.run/##MzBNTDJM/f/f8dxWEzfb//8B "05AB1E – Try It Online")
[Answer]
# Mathematica ~~50 41~~ 30
With help from alephalpha and Mark S.
```
Print/@{#,#,#,#}&/@Alphabet[];
```
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 46 bytes
```
for(var a=259;a++<363;WriteLine((char)(a/4)));
```
[Try it online!](https://tio.run/##Sy7WTS7O/P8/Lb9IoyyxSCHR1sjU0jpRW9vG2MzYOrwosyTVJzMvVUMjOSOxSFMjUd9EU1PT@v9/AA "C# (Visual C# Interactive Compiler) – Try It Online")
]