Observe que isso não é o mesmo que Imprimir o alfabeto quatro vezes .

Esta tarefa é escrever um programa para gerar quatro cópias de cada letra do alfabeto inglês, uma letra por linha, na saída padrão:

A
A
A
A
B
B
B
B

etc.

A saída deve incluir novas linhas após cada letra.

Letras maiúsculas sem saída extra são preferidas; no entanto, letras minúsculas e / ou espaços em branco extras são aceitáveis ​​se a capitalização / remoção prolongar sua solução.

EDITADO PARA ADICIONAR: A solução deve estar completa o suficiente para ser executada. Eu deveria conseguir invocar uma implementação do idioma, colar o código da resposta e obter resultados, sem digitar nenhum código adicional.

A questão acima sobre integridade surgiu no contexto de uma solução C. Certamente deve haver uma regra ou convenção permanente sobre isso em um site de golfe com código? Nesse caso, terei prazer em ceder às diretrizes da comunidade. Mas esta é a minha opinião:

1. No que diz respeito especificamente ao C, você precisa incluir (e contar) o main(){... em }torno do código, pois ele não será compilado de outra forma. Os avisos porque não existem #include <stdio.h>são bons, desde que o código ainda seja compilado. Em geral, uma linguagem compilada requer uma unidade compilável.

2. Uma expressão simples que produz os resultados desejados é aceitável se houver uma maneira de executar a expressão diretamente; por exemplo, se o idioma tiver um REPL. Portanto, você pode enviar o Haskell sem a main=condição de que ele realmente funcione conforme escrito, por exemplo, no ghciprompt. Mas como isso significa colocar letsuas declarações, pode ser uma vitória líquida manter o runhaskellformato.

3. Da mesma forma, os awkscripts devem estar nos blocos BEGIN(ou END, com a suposição de que stdin está anexado /dev/null), já que não estamos processando nenhuma entrada.

etc.

APL (5)

⍪4/⎕A

Formato de matriz ( ⍪) de 4 réplicas ( 4/) do alfabeto ( ⎕A).

Python - 37

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

ivai de 0 a 104; é dividido por quatro e adicionado ao valor ascii para A, e o caractere resultante é impresso.

R, 30 28 27

write(rep(LETTERS,e=4),1,1)

Versão anterior com 30 bytes:

cat(rep(LETTERS,e=4),sep="\n")

C, 59

Eu envio isso, uma resposta longa e não competitiva, simplesmente porque ainda não vejo um envio em C. E isso me deixa triste. : - /

MAIS TARDE: Adota o @moala por fazer uma versão int "/ 4" disso, economizando 13 caracteres!

float i;main(){while(i<26)printf("%c\n",65+(int)i),i+=.25;}

J: 18 13

4#u:65+i.26 1

^{Ainda estou bem instável com J, então isso provavelmente poderia ser melhorado}

Ruby, 23

puts ([*?A..?Z]*4).sort

Todo o crédito para @manatwork - votou positivamente no seu comentário, não neste. :)

PowerShell: 32 23

Código de golfe:

[char[]](65..90*4)|Sort

Passo a passo:

[char[]](... )pega uma matriz de objetos e os converte em caracteres ASCII.
65..90são os códigos ASCII para AZ.
*4repete a série 4 vezes.
|Sortclassifica a saída.

Nota:

Se você quiser que isso seja gravado em um arquivo, basta jogar >, seguido por um nome de arquivo, no final.

Haskell, 46

x a=a++a
main=putStr$['A'..'Z']>>=x.x.(:"\n")

Befunge 98-18

1+::'g`#@_4/'A+,a,

Funciona armazenando um número e terminando quando atingir 104. Imprime o caractere correspondente do alfabeto para o número dividido por 4, seguido por uma nova linha. Mas se eu não precisar adicionar uma nova linha após cada letra, serão 16 caracteres:

1+::'g`#@_4/'A+,

Pode ser reduzido se eu conseguir imprimir mais caracteres (ou seja, todos eles quatro vezes) ( 7 6 caracteres, até funciona no Befunge 93):

1+:4/,

Com nova linha:

1+:4/,a,

GolfScript: 17 15 caracteres

26,{65+...}%+n*

Perl 5, 21

map{print"$_
"x4}A..Z

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 também:

i=260;main(j){while(j=i++>>2,j<91)puts(&j);}

Graças a @marinus, 43:

i=260;main(j){while(j=i++/4,j<91)puts(&j);}

Devo adicionar uma recompensa por chegar aos 42? :)

Java: 56

for(int i=0;i<104;)System.out.println((char)(i++/4+65));

edit: alterado de 'print' para 'println'

Adiante, 37

'h 0 [do] [i] 4 / 'A + emit cr [loop]

Na verdade, 6 bytes

4ú*SÖi

Experimente aqui!

Explicação

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 com letras minúsculas e sem nova linha:

4ú*S

Código de máquina x86 de 16 bits MS-DOS COM, 25 bytes

Em hexadecimal:

B409BA160189D7B96800F6C1037502FE05CD21E2F5C3400A24

Este é um programa completo do MS-DOS .COM. Copie a sequência de bytes para o arquivo com extensão .com e execute-a no DOSBox

Desmontagem:

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

BrainF * , 79 60

+++++++++++++[->++>+>+++++<<<]>>---<[->>>++++[-<.<.>>]<+<<]

AWK, 48

Vamos tentar com AWK ...

END{s=65;for(i=104;i--;s+=0==i%4)printf"%c\n",s}

Como sugerido por manatwork , podemos nos livrar de 2 caracteres

AWK, 46 (Editar)

END{for(i=104;i--;s+=0==i%4)printf"%c\n",s+65}

AWK, 40 (editando o código do MarkReed )

END{for(;i<104;){printf"%c\n",i++/4+65}}

PowerShell, 21

65..90|%{,[char]$_*4}

Uma abordagem ligeiramente diferente da de Iszi. E mais curto :-)

C # LINQ 115 bytes 110 bytes

Enumerable.Range(65, 26).SelectMany(i => Enumerable.Repeat(i,4))
.ToList().ForEach(i=> Console.WriteLine((char)i));

05AB1E, 6 bytes

A4×{S»

Explicação:

A       # Push 'abcdefghijklmnopqrstuvwxyz'
 4×     # Repeat four times
   {    # Sort
    S   # Split into list
     »  # Join by newlines
        # Implicit print

Sem novas linhas, 4 bytes

A4×{

Experimente online!

Gelatina , 5 bytes (não concorrente?)

ØAx4Y

Experimente online!

Explicação:

ØAx4Y Main link
ØA    “ABCDEFGHIJKLMNOPQRSTUVWXYZ”
   4  4
  x   Repeat each element of x y times
    Y Join x with newlines

Perl 6, 32

.say for (('A'..'Z') »xx»4)[*;*]

Tela , 5 bytes

Ｚ４１＊⟳

Experimente aqui!

Code        | Explanation                                  | Stack
------------+----------------------------------------------+------------------------------
Ｚ          | The uppercase alphabet                       | "ABC..."
  ４１＊     | Stretched by 4 horizontally and 1 vertically | "AAAABBBBCCCC..."
        ⟳  | Rotated clockwise                            | "A¶A¶A¶A¶B¶B¶B¶B¶C¶C¶C¶C¶..."
            | Print ToS (implicit)                         |

Com ¶substituído por \napós a impressão.

Kotlin , 66 59 bytes

Salve 7 bytes removendo o loop.

fun main(a:Array<String>){repeat(104){println('A'+(it/4))}}

Experimente online!

brainfuck , 48 bytes

+++[[-<+>>++<]+>]<<<<<<+[->,++++[->.<<<.>>]>+<<]

Experimente online!

Imprime em letras minúsculas, separadas por retornos de carro. Usa quebra automática de células de 8 bits, bem como células deixadas na origem, embora você possa acrescentar a >para contrariar a última.

Bash: 24 caracteres

printf %s\\n {A..Z}{,,,}

Dc: 35 caracteres

[rdP10Pr1-d1<p]sp65[5lpx+d91>l]dslx

Scala, 42

('A'to'Z')map(x=>List.fill(4)(println(x)))

Julia, 39 , 36

println([char(i/4+64.5)for i=0:103])