Escreva um programa ou função que produz esse texto exato, sem distinção entre maiúsculas e 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.

(Com base na música do alfabeto que muitas crianças americanas aprendem a ajudar a memorizar o alfabeto, embora editadas para maior compressibilidade.)

A saída deve ser exatamente igual à acima (novamente, sem distinção entre maiúsculas e minúsculas), mas pode conter espaços à direita em cada linha e / ou novas linhas à direita. Observe o período no final.

Isso é código-golfe, então o código mais curto em bytes vence.

Vim, 42 , 40 pressionamentos de tecla / bytes

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

Agradecemos a Lynn e sua resposta impressionante do vim pela dica de pegar o alfabeto da ajuda.

Obrigado ao RomanGräf por salvar dois bytes!

Explicação:

: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

Em seguida, movemos o final da linha com $, alteramos um caractere che inserimos um ponto.

05AB1E , 16 bytes

Código

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

Explicação:

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.

Usa a codificação CP-1252 . Experimente online!

Utilitários Bash + GNU, 36

• 5 bytes salvos graças a Neil.

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

Ideone.

JavaScript (ES6), 66 65 bytes

Derrotar @ Nee era impossível ... Foi por isso que fiz. :-)

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

Golpeou 1 byte graças a um truque de @LevelRiverSt . O uso String.fromCharCodeé de 7 bytes mais:

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

Como funciona

Isso gera recursivamente cada caractere do alfabeto de apara y, usando .toString(). Uma vírgula é anexada após cada letra, mais uma nova linha se 9568512>>i-9&1for 1 ou um espaço caso contrário. Quando a recursão ultrapassa 34, ou seja z, para , a função simplesmente retorna "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 salvou um byte.

Geléia , 19 18 bytes

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

Obrigado a @Adnan por jogar fora 1 byte!

Experimente online!

Como 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,`
$&`)+`.`

Provavelmente é possível encurtar isso com atob / btoa se você puder descobrir como usar a codificação ISO-8859-1. Editar: salvou 6 bytes graças a @RickHitchcock.

Pyke, 23 19 17 bytes

G\,J\.+2cu  /P

Experimente aqui!

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 bytes

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

Experimente online!

Cria uma matriz de 3 linhas (uma com as letras, uma com vírgulas e outra com um espaço ou uma nova linha).

Edit : Obrigado Billywob!

CJam, 26 bytes

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

Intérprete online

'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

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

As quatro primeiras linhas têm espaço à direita e o programa assume células de 8 bits. Experimente online!

^{(Lidar com a última linha é complicado ...)}

Perl, 37 bytes

Créditos ao @Dom Hastings para esta solução (3 bytes mais curto que o meu, veja abaixo).

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

Executar com o sinalizador -E(ou -M5.010):

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

Minha versão anterior, 3 bytes mais (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 corresponde aos caracteres, mas não o retorno de carro; portanto, usando a substituição de regex, posso adicionar o "," a cada caractere.

Edit: Removidos 2 caracteres graças a ETHProductions

Queijo Cheddar, 70 bytes

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

Parece que não está ficando mais curto que isso. Eu fiz outras versões disso que usam métodos bastante interessantes, mas isso é o mais curto

Experimente online!

Explicação

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

O @"operador é usado para gerar seqüência de caracteres variada. Ele gera uma sequência iniciando do código de caracteres esquerdo para o código de caracteres direito.

Por exemplo, 65é o código de char para Ae 90para Z. Fazer 65 @" 90geraria de A a Z ou o alfabeto.

C, 112 102 81 bytes

Graças a cleblanc e 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

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

Experimente online

Ruby, 56 54 bytes

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

A primeira linha termina com uma nova linha literal.

Editar: salvou dois bytes substituindo 'A'..'Y'por ?A..?Y.

Vim, 32 bytes

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

Deixa uma linha em branco no final, o que foi permitido, mas é estranho ser tão desajeitado. Pior ainda, estou terminando no modo de inserção. Eu já vi outras pessoas fazendo isso aqui, então acho que é permitido? Parece sujo.

• 26o<C-V><C-V>64,<Esc>: O primeiro <C-V>faz o segundo inserir literalmente. Os <C-V>64s que isso deixa no buffer serão transformados em pontos de código ASCII e depois em letras. Vírgulas já estão em.
• r.: Nunca mais chegará ao fim, o mesmo acontece .agora.
• V{g<C-A>: Usa incremento visual para transformar todos os 64s nos pontos de código ASCII das letras maiúsculas.
• 8Jj9Jj3Jj.j4J: A linha arbitrária se junta. O primeiro é em 8Jvez de 7Jporque estamos lidando com a linha em branco. Os 3Js repetidos são elegíveis para uma repetição de pontos.
• cH<C-R>": As pessoas geralmente pensam i<C-R>como uma pasta no modo de inserção, mas é mais como uma macro no modo de inserção. Coisas como <C-V>65serão executadas como se digitadas e interpretadas como um ponto de código decimal. Isso deixa uma linha extra (permitida) no final e permanece no modo de inserção.

PowerShell v3 +, 60 78 67 bytes

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

ESTÁ BEM. Eu realmente li, entendi e acompanhei as especificações dessa vez. Promessa. : D

Pega a matriz 65..90e faz um loop sobre cada elemento |%{...}. A cada iteração, estamos construindo uma nova string usando concatenação, indexação e multiplicação.

Primeiro, pegamos o número atual e o charconvertemos para torná-lo uma letra ASCII. Isso é concatenado com outro caractere, com base na indexação na cadeia de caracteres, '.,'quer estejamos 90ou não (ou seja, contabilizar Z.enquanto o resto é vírgula). Essa é a sequência concatenada " "para separar as letras em espaço e a multiplicação de sequência com "`n"base no valor booleano para saber se o elemento atual é -ina matriz especificada (ou seja, se precisamos concatenar em um caractere de nova linha). A sequência resultante é deixada no pipeline.

Essas strings são encapsuladas em parênteses e -joinagrupadas em uma nova string, que também é deixada no pipeline e implícita Write-Outputno final, imprime o resultado. Como temos `na string, ela é automaticamente convertida em novas linhas após a impressão.

Requer v3 + para o -inoperador. Tem um espaço à direita em cada linha, o que é bom para as especificações do desafio.

Exemplo

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)));?>.

apenas para comparação 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 salvos graças ao @Luis!

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

Experimente Online!

Explicação

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

Explicação:

LETTERSé predefinido para letras maiúsculas.
A ffunção é concatenar o vetor x ,com adicional y(usado para novas linhas).
O gato é o usado como ele imprime \ncomo novas linhas. fé chamado nas letras para formar linhas e, em seguida, nas linhas novamente para formar toda a saída.

Provavelmente golfable - eu não gosto das várias chamadas de f ...

CJam, 31 bytes

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

Explicação:

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

Experimente online

Julia, 71 bytes

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

Requer 0,5 ou superior para transmissão .()

Cheddar, 57 bytes

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

Experimente online! Isso não é lindo? É um belo retângulo.

Duas substituições regex. (65@"90)é o alfabeto maiúsculo, .sub(/[GPSV]/g,"$0\n")substitui GPSVpor si próprio e "\n", .sub(/[^Z\n]/g,"$0, ")substitui todos os Zcaracteres não-nova linha e por si mesmo ", "e "."adiciona uma final ..

Japonês, 24 bytes

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

Teste online!

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

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 bytes

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

Retina, 43 bytes

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

A nova linha principal é significativa. Experimente online!

Esta é a primeira vez que uso o Retina, então qualquer dica de golfe é apreciada ...

Pitão, 25 bytes

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

Um programa que imprime o resultado em STDOUT.

Experimente online

Como 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