Nota che questo non è lo stesso di Stampa l'alfabeto quattro volte .

Questa attività consiste nel scrivere un programma per generare quattro copie di ogni lettera dell'alfabeto inglese, una lettera per riga, sull'output standard:

A
A
A
A
B
B
B
B

eccetera.

L'output dovrebbe includere newline dopo ogni lettera.

Sono preferite lettere maiuscole senza output aggiuntivo; tuttavia, lettere minuscole e / o spazi bianchi extra sono accettabili se le maiuscole / minuscole allungerebbero la soluzione.

MODIFICATO PER AGGIUNGERE: la soluzione deve essere abbastanza completa per essere eseguita. Dovrei essere in grado di invocare un'implementazione della lingua, incollare il codice dalla risposta e ottenere risultati, senza digitare alcun codice aggiuntivo.

La precedente domanda di completezza è emersa nel contesto di una soluzione C. Sicuramente ci deve essere una regola permanente o una convenzione al riguardo su un sito di golf a codice? Se è così, mi arrenderò volentieri alle linee guida della community. Ma questa è la mia opinione:

1. Per quanto riguarda specificamente C, è necessario includere (e contare) il main(){... }intorno al codice, poiché altrimenti non verrà compilato. Avvertimenti perché non ci #include <stdio.h>sono problemi finché il codice viene ancora compilato. In generale, una lingua compilata richiede un'unità compilabile.

2. Un'espressione nuda che produce i risultati desiderati è accettabile se esiste un modo per eseguire direttamente l'espressione; ad esempio, se la lingua ha un REPL. Quindi è possibile inviare Haskell senza main=fintanto che in realtà funziona come scritto , ad esempio il ghcimessaggio. Ma dal momento che ciò significa mettere le lettue dichiarazioni, potrebbe essere una vittoria netta attenersi al runhaskellformato.

3. Allo stesso modo, gli awkscript dovrebbero trovarsi in BEGIN(o END, supponendo che lo stdin sia collegato /dev/null) a blocchi poiché non stiamo elaborando alcun input.

eccetera.

APL (5)

⍪4/⎕A

Formato matrice ( ⍪) di 4 repliche ( 4/) di alfabeto ( ⎕A).

Python - 37

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

iva da 0 a 104; viene diviso per quattro e aggiunto al valore ASCII per Ae il carattere risultante viene stampato.

R, 30 28 27

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

Versione precedente con 30 byte:

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

C, 59

Inoltro questa, una risposta non competitiva, semplicemente perché non vedo ancora un invio C. E questo mi rende triste. : - /

DOPO: Propone a @moala per aver fatto una versione "/ 4" int di questo, risparmiando 13 caratteri!

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

J: 18 13

4#u:65+i.26 1

^{Sono ancora piuttosto traballante con J, quindi probabilmente questo potrebbe essere migliorato}

Ruby, 23 anni

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

Tutto merito a @manatwork - ha votato il suo commento, non questo. :)

PowerShell: 32 23

Codice golfizzato:

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

Procedura dettagliata:

[char[]](... )prende una matrice di oggetti e li converte in caratteri ASCII.
65..90sono i codici ASCII per AZ.
*4ripete la serie 4 volte.
|Sortordina l'output.

Nota:

Se vuoi che questo sia scritto su un file, lancia >, seguito da un nome di file, alla fine.

Haskell, 46

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

Befunge 98-18

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

Funziona memorizzando un numero e terminando quando raggiunge 104. Stampa il carattere corrispondente dell'alfabeto per il numero diviso per 4, seguito da una nuova riga. Ma se non ho bisogno di aggiungere una nuova riga dopo ogni lettera, allora sono 16 caratteri:

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

Può essere ridotto se riesco a stampare più caratteri (cioè tutti quattro volte) ( 7 6 caratteri, funziona anche in Befunge 93):

1+:4/,

Con newline:

1+:4/,a,

GolfScript: 17 15 caratteri

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 anche:

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

Grazie a @marinus, 43:

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

Devo aggiungere una taglia per arrivare a 42? :)

Java: 56

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

modifica: cambiato da 'stampa' a 'println'

Avanti, 37

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

In realtà, 6 byte

4ú*SÖi

Provalo qui!

Spiegazione

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 byte con lettere minuscole e nessuna riga nuova:

4ú*S

Codice macchina x86 a 16 bit MS-DOS COM, 25 byte

In esadecimale:

B409BA160189D7B96800F6C1037502FE05CD21E2F5C3400A24

Questo è un programma MSC-DOS completo. Copia la sequenza di byte nel file con estensione .com ed eseguila da DOSBox

Smontaggio:

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

Proviamo con AWK ...

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

Come suggerito dall'uomo, possiamo sbarazzarci di 2 caratteri

AWK, 46 (Modifica)

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

AWK, 40 (modifica del codice di MarkReed )

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

PowerShell, 21

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

Un approccio leggermente diverso a quello di Iszi. E più breve :-)

C # LINQ 115 byte 110 byte

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

05AB1E, 6 byte

A4×{S»

Spiegazione:

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

Senza newline, 4 byte

A4×{

Provalo online!

Gelatina , 5 byte (non competitiva?)

ØAx4Y

Provalo online!

Spiegazione:

Ø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 byte

Ｚ４１＊⟳

Provalo qui!

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 ¶sostituito con \nal momento della stampa.

Kotlin , 66 59 byte

Salva 7 byte rimuovendo per il ciclo.

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

Provalo online!

Brainfuck , 48 byte

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

Provalo online!

Stampa in minuscolo, separato da ritorni a capo. Utilizza il wrapping di celle a 8 bit e celle a sinistra dell'origine, sebbene sia possibile anteporre a >per contrastare quest'ultima.

Bash: 24 caratteri

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

Dc: 35 caratteri

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