Ecrivez un programme ou une fonction qui affiche ce texte exact, sans distinction de casse:

A, B, C, D, E, F, G,
H, I, J, K, L, M, N, O, P,
Q, R, S,
T, U, V,
W, X, Y, Z.

(Basé sur la chanson de l' alphabet que de nombreux enfants américains apprennent à mémoriser l'alphabet, bien que modifié pour plus de compressibilité.)

La sortie doit avoir exactement le même aspect que ci-dessus (là encore, insensible à la casse), mais peut contenir des espaces de fin sur chaque ligne et / ou des nouvelles lignes. Notez la période à la fin.

C'est le code-golf, donc le code le plus court en octets gagne.

Vim, 42 , 40 frappes / octets

:h<_<cr>jjYZZP:s/./&, /g<cr>7f r<cr>9;.3;.3;.$ch.

Merci à Lynn et à sa réponse géniale vim pour le conseil de saisir l’alphabet de l’aide.

Merci à RomanGräf d'avoir économisé deux octets!

Explication:

:h<_<cr>                                      " Open up vim-help
        jj                                    " Move down two lines
          Y                                   " Yank this line (containing the alphabet)
           ZZ                                 " Close this buffer
             P                                " Paste the line we just yanked
              :s/./&, /g<cr>                  " Replace every character with that character followed by a comma and a space
                            7f                " Find the seven space on this line
                               r<cr>          " And replace it with a newline
                                    9;        " Repeat the last search (space) 9 times
                                      .       " Repeat the last edit (replace with a newline)
                                       3;     " Third space
                                         .    " Replace with newline
                                          3;  " Third space
                                            . " Replace with newline

Ensuite, nous déplaçons la fin de la ligne avec $, inversons un caractère chet insérons un point.

05AB1E , 16 octets

Code

A',â79334S£»¨'.J

Explication:

A                  # Push the alphabet.
 ',â               # Cartesian product with ','.
    79334S         # Push [7, 9, 3, 3, 4].
          £        # Contigious substring, pushes the substrings [0:7], [7:7+9], 
                     [7+9:7+9+3], [7+9+3:7+9+3+3], [7+9+3+3:7+9+3+3+4].
           »       # Gridify, join the inner arrays with spaces and join those arrays
                     with newlines.
            ¨      # Remove the last character.
             '.J   # Append a '.'-character.

Utilise le codage CP-1252 . Essayez-le en ligne!

Utilitaires Bash + GNU, 36

• 5 octets sauvés grâce à Neil.

echo {A..Y}, Z.|sed 's/[HQTW]/\n&/g'

Idéone.

JavaScript (ES6), 66 à 65 octets

Battre @Neil était impossible ... C'est pourquoi je l'ai fait. :-)

f=(i=10)=>i>34?"z.":i.toString(++i)+","+` 
`[9568512>>i-9&1]+f(i)

Golfé 1 octet grâce à un tour de @LevelRiverSt . L'utilisation String.fromCharCodeest 7 octets plus long:

f=(i=65)=>i>89?"Z.":String.fromCharCode(i,44,i%86%83%80%71?32:10)+f(i+1)

Comment ça fonctionne

Cela génère récursivement chaque caractère de l'alphabet de aà y, en utilisant .toString(). Une virgule est ajoutée après chaque lettre, plus une nouvelle ligne si 9568512>>i-9&1vaut 1 ou un espace sinon. Lorsque la récursion dépasse 34, c'est-à-dire z, la fonction revient simplement "z.".

Python 2.7, 67 66 63 octets

a=65;exec"print'%c'%a+',.'[a>89]+'\\n'[a%42%39%9^2:],;a+=1;"*26

Dennis a sauvegardé un octet.

Gelée , 19 à 18 octets

ØAp”,ṁ79334DR¤GṖ”.

Merci à @Adnan d'avoir joué 1 octet!

Essayez-le en ligne!

Comment ça fonctionne

ØAp”,ṁ79334DR¤GṖ”.  Main link. No arguments.

ØA                  Yield "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
  p”,               Cartesian product with ','; append a comma to each letter.
             ¤      Combine the two links to the left into a niladic chain.
      79334D          Decimal; yield [7, 9, 3, 3, 4].
            R         Range; yield [[1, 2, 3, 4, 5, 6, 7], ..., [1, 2, 3, 4]].
     ṁ              Mold; reshape the array of letters with commata like the
                    generated 2D array.
              G     Grid; separate rows by spaces, columns by linefeeds.
               Ṗ    Pop; discard the last comma.
                ”.  Print the previous result and set the return value to '.'.
                     (implicit) Print the return value.

JavaScript (ES6), 80 74 octets

_=>[...`ABCDEFGHIJKLMNOPQRSTUVWXYZ`].join`, `.replace(/[HQTW]/g,`
$&`)+`.`

Probablement possible de raccourcir cela avec atob / btoa si vous pouvez comprendre comment utiliser le codage ISO-8859-1. Edit: 6 octets enregistrés grâce à @RickHitchcock.

Pyke, 23 19 17 octets

G\,J\.+2cu  /P

Essayez-le ici!

G\,J\.+        -    ",".join(alphabet)+"."
       2c      -   split(^, size=2)
            /  -  split_sized(^, V)
         u     -   yield list [7,9,3,3] (actual bytes `u%04%07%09%03%03`)
             P - print(^)

R, 83 71 octets

a=rbind(LETTERS[-26],","," ");a[3,7+3*c(0,3:5)]="\n";cat(a,"Z.",sep="")

Essayez-le en ligne!

Crée une matrice de 3 lignes (une avec les lettres, une avec les virgules et l’autre avec un espace ou une nouvelle ligne).

Edit : Merci Billywob!

CJam, 26 octets

'A79333Ab{{',S2$)}*N\}/'.@

Interprète en ligne

'A                             Push 'A'
  79333Ab                      Push [7 9 3 3 3]
         {           }/        For each number n in the previous array...
          {      }*              Execute n times...
           ',S                     Push a comma and a space
              2$)                  Copy last letter and increment
                   N\            Place a newline under the letter on top
                       '.@     Push '.' and rotate

Brainfuck, 117 octets

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

Les quatre premières lignes ont chacune un espace de fin et le programme suppose des cellules de 8 bits. Essayez-le en ligne!

^{(Manipuler la dernière ligne est délicat ...)}

Perl, 37 octets

Crédits à @Dom Hastings pour cette solution (3 octets de moins que le mien, voir ci-dessous).

say+(map"$_, ".$/x/[GPSV]/,A..Y),"Z."

Courir avec -E(ou -M5.010) drapeau:

perl -E 'say+(map"$_, ".$/x/[GPSV]/,A..Y),"Z."'

Ma version précédente, 3 octets de plus (total de 40 octets):

perl -E '$_=join", ",A..Z;s/[HQTW]/\n$&/g;say"$_."'

JavaScript (ES6), 66 64 octets

_=>`ABCDEFG
HIJKLMNOP
QRS
TUV
WXY`.replace(/./g,"$&, ")+"Z."

L'expression régulière correspond aux caractères, mais pas au retour chariot, aussi, en utilisant l'expression régulière, je peux ajouter le "," à chaque caractère.

Edit: Suppression de 2 caractères grâce à ETHProductions

Cheddar, 70 octets

->[65@"71,72@"80,"QRS","TUV","WXYZ"].map(@.chars.join(", ")).vfuse+'.'

On dirait que ça ne devient pas plus court que ça. J'ai fait d'autres versions de cette méthode qui utilisent des méthodes assez intéressantes mais la plus courte

Essayez-le en ligne!

Explication

->                        // Function with no arguments
  [                       // Array, each item represents a line
   65@"71,                // See below on what @" does
   72@"80,
   "QRS",
   "TUV",
   "WXYZ"
  ].map(                  // On each item...
    @.chars.join(", ")    // Join the characters on ", "
  ).vfuse                 // Vertical fuse or join by newlines
  + '.'                   // The period at the end

L' @"opérateur est utilisé pour générer une chaîne de caractères à distance. Il génère une chaîne allant du code de caractère de gauche au code de droite.

Par exemple, 65est le code de caractère pour Aet 90pour Z. Faire 65 @" 90générerait de A à Z ou l'alphabet.

C 112 102 81 octets

Merci à Cleblanc & LevelRiverSt!

i,c;main(){for(c=64;++c<91;)printf("%c%c%c",c,44+c/90*2,c=="‌​GPSVZ"[i]?++i,10:32)‌​;}

Brainfuck, 157 octets

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

Essayez-le en ligne

Ruby, 56 54 octets

$><<(?A..?Y).map{|c|c+('GPSV'[c]?",
":", ")}.join+"Z."

La première ligne se termine par une nouvelle ligne.

Edit: sauvegardé deux octets en remplaçant 'A'..'Y'par ?A..?Y.

Vim, 32 octets

26o<C-V><C-V>64,<Esc>r.V{g<C-A>8Jj9Jj3Jj.j4JcH<C-R>"

Laisse une ligne blanche à la fin, ce qui était autorisé, mais c'est bizarre d'être aussi maladroit. Pire encore, je termine en mode insertion. J'ai vu d'autres personnes le faire ici, alors je suppose que c'est permis? C'est sale.

• 26o<C-V><C-V>64,<Esc>: Le premier <C-V>fait que le second insère littéralement. Le <C-V>64s que cela laisse dans le tampon sera transformé en points de code ASCII, puis en lettres. Virgule déjà dedans.
• r.: Ne sera jamais à la fin, alors faites le .maintenant.
• V{g<C-A>: Utilise l’incrément visuel pour transformer tous les 64s en points de code ASCII des lettres majuscules.
• 8Jj9Jj3Jj.j4J: La ligne arbitraire rejoint. Le premier est 8Jau lieu de 7Jparce que nous avons affaire à la ligne blanche. Les 3Js répétés sont éligibles pour une répétition de points.
• cH<C-R>": Les gens pensent généralement i<C-R>comme une pâte en mode insertion, mais plutôt comme une macro en mode insertion. Les choses comme <C-V>65se dérouleront comme si elles étaient tapées et interprétées comme un point de code décimal. Cela laisse une ligne supplémentaire (autorisée) à la fin et reste en mode insertion.

PowerShell v3 +, 60 78 67 octets

-join(65..90|%{[char]$_+'.,'[$_-le89]+" "+"`n"*($_-in71,80,83,86)})

D'ACCORD. En fait, j'ai lu, compris et suivi les spécifications cette fois-ci. Promettre. :RÉ

Prend le tableau 65..90et les boucles sur chaque élément |%{...}. À chaque itération, nous construisons une nouvelle chaîne à l'aide de la concaténation, de l'indexation et de la multiplication.

Premièrement, prenons le nombre actuel et le charconvertissons pour en faire une lettre ASCII. Cela est concaténé avec un autre caractère, basé sur l'indexation dans la chaîne, '.,'que nous en soyons 90ou non (c.-à-d., À prendre en compte Z.tout en laissant le reste sous forme de virgules). Il s'agit d'une chaîne concaténée avec " "pour séparer les lettres des espaces, et d'une multiplication de chaîne "`n"basée sur la valeur booléenne pour déterminer si l'élément actuel est -inle tableau spécifié (c'est-à-dire, si nous devons concaténer un caractère de nouvelle ligne). La chaîne résultante est laissée sur le pipeline.

Ces chaînes sont encapsulées dans des parenthèses et -joinéditées ensemble dans une nouvelle chaîne, qui est également laissée sur le pipeline et implicite Write-Outputà la fin de l’impression du résultat. Comme nous avons `ndans la chaîne, elle est automatiquement convertie en nouvelles lignes lors de l'impression.

Nécessite v3 + pour l' -inopérateur. Dispose d'un espace de fin sur chaque ligne, ce qui est acceptable pour les spécifications du challenge.

Exemple

PS C:\Tools\Scripts\golfing> .\now-i-know-my-abc.ps1
A, B, C, D, E, F, G, 
H, I, J, K, L, M, N, O, P, 
Q, R, S, 
T, U, V, 
W, X, Y, Z. 

PHP, 62 octets

<?=preg_filter("# ([HQTW])#","\n$1",join(", ",range(A,Z)));?>.

seulement pour comparaison 87 octets

<?="A, B, C, D, E, F, G,\nH, I, J, K, L, M, N, O, P,\nQ, R, S,\nT, U, V,\nW, X, Y, Z.";

MATL, 38 29 octets

9 octets sauvés grâce à @Luis!

1Y2X{', '&Zc46h1[CEII]I*11hY{

Essayez-le en ligne!

Explication

1Y2     % Push the upper-case alphabet to the stack
X{      % Break the character array into a cell array (similar to a list)
        % where each element is a letter
', '&Zc % Combine back into a string with ', ' between each element
46h     % Append '.' (via ASCII code) to the end of the string
1       % Push the number 1
[CEII]  % Push the array: [7, 9, 3, 3]
I*      % Multiply this array by 3: [21, 27, 9, 9]  
llh     % Append an 11 to this array: [21, 27, 9, 9, 11] 
Y{      % Break our comma-separated list of characters into groups of this size
        % Implicitly display the result

R, 146 octets

L=LETTERS
f=function(x,y=""){paste(x,collapse=paste0(", ",y))}
cat(f(c(f(L[1:7]),f(L[8:16]),f(L[17:19]),f(L[20:22]),f(L[23:26])),"\n"),".",sep="")

Explication:

LETTERSest prédéfini pour les lettres majuscules.
La ffonction sert à concaténer le vecteur x sur ,avec additionnel y(utilisé pour les nouvelles lignes).
Le chat est utilisé car il imprime \nen nouvelles lignes. fest appelé sur les lettres pour former des lignes, puis à nouveau sur les lignes pour former la sortie entière.

Probablement golfable - Je n'aime pas les multiples appels de f ...

CJam, 31 octets

'[,65>", "*7933Ab{3*/(\:+}%N*'.

Explication:

'[,65>                             push uppercase alphabet
      ", "*                        ", " between all letters
           7933Ab                  push [7 9 3 3]
                 {3*/(\:+}%        slices of lengths 21, 27, 9, 9
                           N*'.    join slices with newlines, add final "."

Essayez-le en ligne

Julia, 71 octets

f()=join(join.(['A':'G','H':'P',"QRS","TUV","WXYZ"],[", "]),",\n")*"."

Nécessite 0,5 ou plus pour la diffusion .()

Cheddar, 57 octets

->(65@"90).sub(/[GPSV]/g,"$0
").sub(/[^Z\n]/g,"$0, ")+"."

Essayez-le en ligne! N'est-ce pas beau? C'est un joli rectangle.

Deux substitutions de regex. (65@"90)est l'alphabet majuscule, .sub(/[GPSV]/g,"$0\n")remplace GPSVpar lui-même et "\n", .sub(/[^Z\n]/g,"$0, ")remplace tous les Zcaractères non newline et par lui-même et ", ", et "."ajoute une finale ..

Japt, 24 octets

;B¬qJ+S r"[HQTW]"@R+XÃ+L

Testez-le en ligne!

Comment ça fonctionne

;                        // Reset various variables. B is set to "ABC...XYZ", J is set to ",", and L is set to ".".
 B¬                      // Take the uppercase alphabet and split into chars.
   qJ+S                  // Join with ", ".
        r"[HQTW]"        // Replace each H, Q, T, or W with
                 @R+XÃ   //   a newline plus the character.
                      +L // Append a period to the result.
                         // Implicit: output last expression

Java, 116 109 105 104

String f(){String s="";for(char c=65;c<91;)s=s+c+(c>89?46:',')+("GPSV".indexOf(c++)<0?' ':10);return s;}

Ungolfed:

String f() {
  String s = "";
  for (char c = 65; c < 91;) {
    s = s + c
      + (c > 89 ? 46 : ',')
      + ("GPSV".indexOf(c++) < 0 ? ' ' : 10);
  }
  return s;
}

q, 46 octets

-1@'(", "sv/:0 7 16 19 22_,:'[.Q.A]),'",,,,.";

Retina, 43 octets

Z
{2`
$`
}T01`L`_L
.
$&, 
[HQTW]
¶$&
, $
.

La nouvelle ligne est importante. Essayez-le en ligne!

C'est la première fois que j'utilise Retina. Tous les conseils relatifs au golf sont donc appréciés ...

Pyth, 25 octets

+Pjmj\ dc*G\,j94092 23)\.

Un programme qui imprime le résultat sur STDOUT.

Essayez-le en ligne

Comment ça fonctionne

+Pjmj\ dc*G\,j94092 23)\.  Program. Input: none
          G                Yield string literal'abcdefghijklmnopqrstuvwxyz'
         * \,              Cartesian product of that with ',', yielding a list of
                           characters with appended commas
             j94092 23)    Yield the integer 94092 in base-23, giving [7, 16, 19, 22]
        c                  Split the comma-appended character list at those indices
   mj\                     Join each element of that on spaces
  j                        Join that on newlines
 P                         All but the last element of that, removing trailing ','
+                      \.  Append '.'
                           Implicitly print