Escriba un programa o función que genere este texto exacto, sin distinción entre mayúsculas y minúsculas:

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.

(Basado en la canción del alfabeto que muchos niños estadounidenses aprenden a memorizar el alfabeto, aunque editado para mayor compresibilidad).

El resultado debe verse exactamente igual que el anterior (de nuevo, sin distinción entre mayúsculas y minúsculas), pero puede contener espacios finales en cada línea y / o nuevas líneas finales. Observe el período al final.

Este es el código de golf, por lo que gana el código más corto en bytes.

Vim, 42 , 40 pulsaciones de teclas / bytes

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

Gracias a Lynn y su increíble respuesta vim por el consejo para obtener el alfabeto de la ayuda.

¡Gracias a RomanGräf por guardar dos bytes!

Explicación:

: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

Luego, movemos el final de la línea con $, cambiamos un carácter con che insertamos un punto.

05AB1E , 16 bytes

Código

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

Explicación:

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.

Utiliza la codificación CP-1252 . Pruébalo en línea!

Bash + utilidades GNU, 36

• 5 bytes guardados gracias a Neil.

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

Ideona

JavaScript (ES6), 66 65 bytes

Vencer a @Neil era imposible ... Por eso lo hice. :-)

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

Golfé 1 byte gracias a un truco de @LevelRiverSt . El uso String.fromCharCodees de 7 bytes más:

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

Cómo funciona

Esto genera de forma recursiva cada carácter del alfabeto de aa y, usando .toString(). Se agrega una coma después de cada letra, más una nueva línea si 9568512>>i-9&1es 1, o un espacio en caso contrario. Cuando la recursividad pasa de 34, es decir z, a , la función simplemente regresa "z.".

Python 2.7, 67 66 63 bytes

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

Dennis guardó un byte.

Jalea , 19 18 bytes

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

¡Gracias a @Adnan por jugar golf en 1 byte!

Pruébalo en línea!

Cómo funciona

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

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

Probablemente sea posible acortar esto con atob / btoa si puede averiguar cómo usar la codificación ISO-8859-1. Editar: guardado 6 bytes gracias a @RickHitchcock.

Pyke, 23 19 17 bytes

G\,J\.+2cu  /P

Pruébalo aquí!

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 bytes

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

Pruébalo en línea!

Hace una matriz de 3 filas (una con las letras, una con las comas y la otra con un espacio o una nueva línea).

Editar : Gracias Billywob!

CJam, 26 bytes

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

Intérprete en línea

'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 bytes

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

Cada una de las primeras cuatro líneas tiene un espacio final, y el programa asume celdas de 8 bits. Pruébalo en línea!

^{(Manejar la última línea es complicado ...)}

Perl, 37 bytes

Créditos a @Dom Hastings para esta solución (3 bytes más cortos que los míos, ver más abajo).

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

Ejecutar con -E(o -M5.010) bandera:

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

Mi versión anterior, 3 bytes más (total de 40 bytes):

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

JavaScript (ES6), 66 64 bytes

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

Regex coincide con los caracteres pero no con los retornos de carro, por lo que, usando el reemplazo de expresiones regulares, puedo agregar el "," a cada carácter.

Editar: se eliminaron 2 caracteres gracias a ETHProductions

Cheddar, 70 bytes

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

Parece que no se está acortando más que esto. He hecho otras versiones de esto que usan métodos bastante interesantes, pero esto es más corto

Pruébalo en línea!

Explicación

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

El @"operador se utiliza para generar cadenas a distancia. Genera una cadena que comienza desde el código de caracteres izquierdo al código de caracteres derecho.

Por ejemplo, 65es el código char para Ay 90para Z. Hacerlo 65 @" 90generaría de la A a la Z o el alfabeto.

C, 112 102 81 bytes

Gracias a cleblanc y 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 bytes

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

Pruébalo en línea

Ruby, 56 54 bytes

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

La primera línea termina con una nueva línea literal.

Editar: guardado dos bytes reemplazando 'A'..'Y'con ?A..?Y.

Vim, 32 bytes

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

Deja una línea en blanco al final, lo que estaba permitido, pero es extraño ser tan torpe. Peor aún, estoy terminando en modo de inserción. He visto a otras personas hacerlo aquí, ¿así que supongo que está permitido? Se siente sucio

• 26o<C-V><C-V>64,<Esc>: El primero <C-V>hace que el segundo se inserte literalmente. Los <C-V>64mensajes que esto deja en el búfer se convertirán en puntos de código ASCII y luego en letras. Comas ya en.
• r.: Nunca volveré a estar al final, así que hazlo .ahora.
• V{g<C-A>: Utiliza el incremento visual para convertir todos los 64s en los puntos de código ASCII de las letras mayúsculas.
• 8Jj9Jj3Jj.j4J: La línea arbitraria se une. El primero es en 8Jlugar de 7Jporque estamos lidiando con la línea en blanco. Los 3Js repetidos son elegibles para una repetición de puntos.
• cH<C-R>": Las personas generalmente piensan i<C-R>como un modo de inserción pegar, pero es más como una macro de modo de inserción. Las cosas como <C-V>65se ejecutarán como si estuvieran escritas e interpretadas como un punto de código decimal. Esto deja una línea adicional (permitida) al final y permanece en modo de inserción.

PowerShell v3 +, 60 78 67 bytes

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

OKAY. Esta vez he leído, entendido y seguido las especificaciones. Promesa. :RE

Toma la matriz 65..90y recorre cada elemento |%{...}. Cada iteración, estamos construyendo una nueva cadena usando concatenación, indexación y multiplicación.

Primero, tomamos el número actual y lo charemitimos para convertirlo en una letra ASCII. Eso se concatena con otro carácter, basado en la indexación en la cadena '.,'si estamos 90o no (es decir, para tener en cuenta Z.mientras todo el resto son comas). Esa es una cadena concatenada " "para separar las letras en el espacio y la multiplicación de cadenas "`n"basada en el valor booleano para determinar si el elemento actual es -inla matriz especificada (es decir, si necesitamos concatenar en un carácter de nueva línea). La cadena resultante se deja en la tubería.

Esas cadenas se encapsulan en parens y se -joineditan juntas en una nueva cadena, que luego también se deja en la tubería e implícita Write-Outputal final imprime el resultado. Como tenemos `nen la cadena, se convierte automáticamente en nuevas líneas al imprimir.

Requiere v3 + para el -inoperador. Tiene un espacio final en cada línea, lo cual está bien según las especificaciones del desafío.

Ejemplo

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 bytes

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

solo para comparación 87 Bytes

<?="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 bytes

¡9 bytes guardados gracias a @Luis!

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

Pruébalo en línea!

Explicación

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 bytes

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

Explicación:

LETTERSestá predefinido para letras mayúsculas.
La ffunción es para concatenar el vector x ,con adicional y(usado para líneas nuevas).
El gato es el utilizado, ya que imprime \ncomo líneas nuevas. fse llama en las letras para formar filas y luego en las filas nuevamente para formar toda la salida.

Probablemente golfable - No me gustan las múltiples llamadas de f ...

CJam, 31 bytes

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

Explicación:

'[,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 "."

Pruébalo en línea

Julia, 71 bytes

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

Requiere 0.5 o mejor para transmitir .()

Cheddar, 57 bytes

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

Pruébalo en línea! ¿No es eso hermoso? Es un bonito rectángulo.

Dos sustituciones de expresiones regulares. (65@"90)es el alfabeto en mayúscula, se .sub(/[GPSV]/g,"$0\n")reemplaza GPSVa sí mismo y "\n", .sub(/[^Z\n]/g,"$0, ")reemplaza a todos los Zcaracteres que no son de nueva línea y a sí mismo ", "y "."agrega un final ..

Japt, 24 bytes

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

¡Pruébelo en línea!

Cómo funciona

;                        // 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;}

Sin golf:

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 bytes

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

Retina, 43 bytes

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

La nueva línea principal es significativa. Pruébalo en línea!

Esta es la primera vez que uso Retina, por lo que se agradece cualquier consejo de golf ...

Pyth, 25 bytes

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

Un programa que imprime el resultado en STDOUT.

Pruébalo en línea

Cómo funciona

+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