Tenga en cuenta que esto no es lo mismo que Imprimir el alfabeto cuatro veces .

Esta tarea es escribir un programa para generar cuatro copias de cada letra del alfabeto inglés, una letra por línea, en la salida estándar:

A
A
A
A
B
B
B
B

etc.

El resultado debe incluir nuevas líneas después de cada letra.

Se prefieren letras mayúsculas sin salida adicional; sin embargo, las letras minúsculas y / o los espacios en blanco adicionales son aceptables si las mayúsculas / despojo alargarían su solución.

EDITADO PARA AGREGAR: La solución debe ser lo suficientemente completa como para ejecutarse. Debería poder invocar una implementación del lenguaje, pegar el código de la respuesta y obtener resultados, sin escribir ningún código adicional.

La pregunta anterior de completitud surgió en el contexto de una solución C. ¿Seguramente debe haber una regla o convención permanente sobre esto en un sitio de golf de código? Si es así, con gusto cederé a las pautas de la comunidad. Pero esta es mi opinión:

1. Con respecto a C específicamente, debe incluir (y contar) el main(){... }alrededor del código, ya que de lo contrario no se compilará. Las advertencias porque no hay #include <stdio.h>están bien siempre y cuando el código aún se compile. En general, un lenguaje compilado requiere una unidad compilable.

2. Una expresión desnuda que produce los resultados deseados es aceptable si hay una manera de ejecutar la expresión directamente; por ejemplo, si el idioma tiene un REPL. Por lo tanto, puede enviar Haskell sin una main=, siempre y cuando realmente funcione como está escrito, por ejemplo, en el ghciindicador. Pero dado que eso significa poner letsus declaraciones, puede ser una ganancia neta quedarse con el runhaskellformato.

3. Del mismo modo, los awkscripts deben estar en bloques BEGIN(o ENDcon el supuesto de que stdin está adjunto /dev/null) ya que no estamos procesando ninguna entrada.

etc.

APL (5)

⍪4/⎕A

Formato matricial ( ⍪) de 4 réplicas ( 4/) del alfabeto ( ⎕A).

Python - 37

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

iva de 0 a 104; se divide entre cuatro y se agrega al valor ascii para A, y se imprime el carácter resultante.

R, 30 28 27

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

Versión anterior con 30 bytes:

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

C, 59

Presento esto, una respuesta poco competitiva, simplemente porque todavía no veo una presentación en C. Y eso me pone triste. : - /

MÁS TARDE: ¡Apoya a @moala por hacer una versión int "/ 4" de esto, ahorrando 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

^{Todavía estoy bastante tembloroso con J, por lo que esto probablemente podría mejorarse}

Ruby, 23

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

Todo el crédito a @manatwork - votó su comentario, no esto. :)

PowerShell: 32 23

Código de golf:

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

Tutorial:

[char[]](... )toma una matriz de objetos y los convierte en caracteres ASCII.
65..90son los códigos ASCII para AZ.
*4repite la serie 4 veces.
|Sortordena la salida.

Nota:

Si desea que esto se escriba en un archivo, simplemente arroje >, seguido de un nombre de archivo, al final.

Haskell, 46

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

Befunge 98-18

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

Funciona almacenando un número y terminando cuando llega a 104. Imprime el carácter correspondiente del alfabeto para el número dividido por 4, seguido de una nueva línea. Pero si no necesito agregar una nueva línea después de cada letra, entonces son 16 caracteres:

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

Se puede reducir si puedo imprimir más caracteres (es decir, todos ellos cuatro veces) ( 7 6 caracteres, incluso funciona en Befunge 93):

1+:4/,

Con nueva línea:

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 también:

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

Gracias a @marinus, 43:

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

¿Debo agregar una recompensa por llegar a 42? :)

Java: 56

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

editar: cambiado de 'print' a 'println'

Adelante, 37

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

En realidad, 6 bytes

4ú*SÖi

Pruébalo aquí!

Explicación

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 con minúsculas y sin nueva línea:

4ú*S

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

En hexadecimal:

B409BA160189D7B96800F6C1037502FE05CD21E2F5C3400A24

Este es un programa completo de MS-DOS .COM. Copie la secuencia de bytes al archivo con extensión .com y ejecútelo desde DOSBox

Desmontaje

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 a probarlo con AWK ...

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

Como sugiere manatwork , podemos deshacernos de 2 caracteres

AWK, 46 (Editar)

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

AWK, 40 (editando el código de MarkReed )

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

PowerShell, 21

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

Un enfoque ligeramente diferente al de Iszi. Y más corto :-)

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»

Explicación:

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

Sin saltos de línea, 4 bytes

A4×{

Pruébalo en línea!

Jelly , 5 bytes (¿no compite?)

ØAx4Y

Pruébalo en línea!

Explicación:

Ø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)[*;*]

Lienzo , 5 bytes.

Ｚ４１＊⟳

Pruébalo aquí!

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)                         |

Con ¶reemplazado por \nal imprimir.

Kotlin , 66 59 bytes

Ahorre 7 bytes eliminando para el bucle.

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

Pruébalo en línea!

brainfuck , 48 bytes

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

Pruébalo en línea!

Imprime en minúsculas, separadas por retornos de carro. Utiliza envolver celdas de 8 bits y celdas a la izquierda del origen, aunque puede anteponer a >para contrarrestar la ú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])