Notez que ce n'est pas la même chose que Imprimer l'alphabet quatre fois .

Cette tâche consiste à écrire un programme pour générer quatre copies de chaque lettre de l'alphabet anglais, une lettre par ligne, sur la sortie standard:

A
A
A
A
B
B
B
B

etc.

La sortie doit inclure des retours à la ligne après chaque lettre.

Les lettres majuscules sans sortie supplémentaire sont préférées; cependant, les lettres minuscules et / ou les espaces blancs supplémentaires sont acceptables si la mise en majuscule / suppression allongerait votre solution.

MODIFIÉ POUR AJOUTER: La solution doit être suffisamment complète pour être exécutée. Je devrais pouvoir invoquer une implémentation de la langue, coller le code de la réponse et obtenir des résultats, sans taper de code supplémentaire.

La question ci-dessus de l'exhaustivité s'est posée dans le contexte d'une solution C. Il doit sûrement y avoir une règle ou une convention permanente à ce sujet sur un site de golf à code? Si c'est le cas, je me plierai volontiers aux directives de la communauté. Mais c'est mon point de vue:

1. En ce qui concerne spécifiquement C, vous devez inclure (et compter) le main(){... }autour du code, car il ne compilera pas autrement. Les avertissements car il n'y a pas de #include <stdio.h>problème tant que le code compile toujours. En général, un langage compilé nécessite une unité compilable.

2. Une expression nue qui donne les résultats souhaités est acceptable s'il existe un moyen d'exécuter directement l'expression; par exemple, si la langue a un REPL. Vous pouvez donc soumettre Haskell sans un main=tant qu'il fonctionne réellement comme écrit, par exemple à l' ghciinvite. Mais puisque cela signifie mettre letvos déclarations, ce peut être une victoire nette de s'en tenir au runhaskellformat.

3. De même, les awkscripts doivent être dans BEGIN(ou END, avec l'hypothèse que stdin est attaché à /dev/null) des blocs car nous ne traitons aucune entrée.

etc.

APL (5)

⍪4/⎕A

Format matriciel ( ⍪) de 4 réplications ( 4/) de l'alphabet ( ⎕A).

Python - 37

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

iva de 0 à 104; il est divisé par quatre et ajouté à la valeur ascii pour A, et le caractère résultant est imprimé.

R, 30 28 27

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

Ancienne version avec 30 octets:

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

C, 59

Je soumets ceci, une réponse non compétitive, simplement parce que je ne vois pas encore de soumission C. Et cela me rend triste. : - /

PLUS TARD: Props à @moala pour avoir fait une version int "/ 4" de ceci, économisant 13 caractères!

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

J: 18 13

4#u:65+i.26 1

^{Je suis encore assez fragile avec J, donc cela pourrait probablement être amélioré}

Rubis, 23

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

Tout le crédit à @manatwork - voter pour son commentaire, pas celui-ci. :)

PowerShell: 32 23

Code golf:

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

Procédure pas à pas:

[char[]](... )prend un tableau d'objets et les convertit en caractères ASCII.
65..90sont les codes ASCII pour AZ.
*4répète la série 4 fois.
|Sorttrie la sortie.

Remarque:

Si vous voulez que cela soit écrit dans un fichier, jetez simplement >, suivi d'un nom de fichier, à la fin.

Haskell, 46

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

Befunge 98-18

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

Fonctionne en stockant un nombre et en terminant quand il atteint 104. Imprime le caractère correspondant de l'alphabet pour le nombre divisé par 4, suivi d'une nouvelle ligne. Mais si je n'ai pas besoin d'ajouter une nouvelle ligne après chaque lettre, alors c'est 16 caractères:

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

Peut être réduit si je peux imprimer plus de personnages (c'est-à-dire tous quatre fois) ( 7 6 caractères, fonctionne même dans Befunge 93):

1+:4/,

Avec newline:

1+:4/,a,

GolfScript: 17 15 caractères

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

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

Merci à @marinus, 43 ans:

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

Dois-je ajouter une prime pour arriver à 42? :)

Java: 56

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

edit: changé de 'print' en 'println'

Forth, 37

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

En fait, 6 octets

4ú*SÖi

Essayez-le ici!

Explication

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 octets en minuscules et sans nouvelle ligne:

4ú*S

Code machine MS-DOS 16 bits x86 COM, 25 octets

En hex:

B409BA160189D7B96800F6C1037502FE05CD21E2F5C3400A24

Il s'agit d'un programme MS-DOS .COM complet. Copiez la séquence d'octets dans le fichier avec l'extension .com et exécutez-la à partir de DOSBox

Démontage:

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

Essayons avec AWK ...

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

Comme suggéré par manatwork, nous pouvons nous débarrasser de 2 caractères

AWK, 46 (modifier)

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

AWK, 40 (modification du code de MarkReed )

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

PowerShell, 21

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

Une approche légèrement différente de celle d'Iszi. Et plus court :-)

C # LINQ 115 octets 110 octets

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

05AB1E, 6 octets

A4×{S»

Explication:

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

Sans nouvelle ligne, 4 octets

A4×{

Essayez-le en ligne!

Gelée , 5 octets (non concurrentiel?)

ØAx4Y

Essayez-le en ligne!

Explication:

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

Canevas , 5 octets

Ｚ４１＊⟳

Essayez-le ici!

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

Avec ¶remplacé par \nlors de l'impression.

Kotlin , 66 59 octets

Économisez 7 octets en supprimant la boucle.

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

Essayez-le en ligne!

brainfuck , 48 octets

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

Essayez-le en ligne!

Imprime en minuscules, séparés par des retours chariot. Utilise le wrapping de cellules 8 bits ainsi que les cellules restantes de l'origine, bien que vous puissiez ajouter un >pour contrer ce dernier.

Bash: 24 caractères

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

Dc: 35 caractères

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