Scrivi un programma o una funzione che emetta questo testo esatto, senza distinzione tra maiuscole e minuscole:

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.

(Basato sulla canzone dell'alfabeto che molti bambini americani imparano ad aiutare a memorizzare l'alfabeto, anche se modificato per una maggiore comprimibilità.)

L'output deve essere identico a quello precedente (di nuovo, senza distinzione tra maiuscole e minuscole), ma può contenere spazi finali su ciascuna riga e / o linee finali finali. Si noti il ​​periodo alla fine.

Questo è code-golf, quindi vince il codice più breve in byte.

Vim, 42 , 40 sequenze di tasti / byte

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

Grazie a Lynn e alla sua fantastica risposta vim per il suggerimento di prendere l'alfabeto dall'aiuto.

Grazie a RomanGräf per aver salvato due byte!

Spiegazione:

: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

Quindi, spostiamo la fine della linea con $, cambiamo di nuovo un carattere con che inseriamo un punto.

05AB1E , 16 byte

Codice

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

Spiegazione:

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.

Utilizza la codifica CP-1252 . Provalo online!

Utilità Bash + GNU, 36

• 5 byte salvati grazie a Neil.

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

Ideone.

JavaScript (ES6), 66 65 byte

Battere @Neil era impossibile ... Ecco perché l'ho fatto. :-)

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

Golfato 1 byte grazie a un trucco di @LevelRiverSt . L'uso di String.fromCharCode7 byte è più lungo:

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

Come funziona

Questo genera in modo ricorsivo ogni carattere dell'alfabeto da aa y, usando .toString(). Una virgola viene aggiunta dopo ogni lettera, più una nuova riga se 9568512>>i-9&1è 1 o uno spazio altrimenti. Quando la ricorsione supera 34, ovvero a z, la funzione ritorna semplicemente "z.".

Python 2.7, 67 66 63 byte

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

Dennis ha salvato un byte.

Gelatina , 19 18 byte

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

Grazie a @Adnan per il golf off 1 byte!

Provalo online!

Come funziona

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

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

Probabilmente è possibile accorciarlo con atob / btoa se riesci a capire come usare la codifica ISO-8859-1. Modifica: salvato 6 byte grazie a @RickHitchcock.

Pyke, 23 19 17 byte

G\,J\.+2cu  /P

Provalo qui!

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 byte

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

Provalo online!

Crea una matrice di 3 righe (una con le lettere, una con le virgole e l'altra con uno spazio o una nuova riga).

Modifica : grazie Billywob!

CJam, 26 byte

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

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

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

Le prime quattro righe hanno ciascuna uno spazio finale e il programma assume celle a 8 bit. Provalo online!

^{(Gestire l'ultima riga è complicato ...)}

Perl, 37 byte

Ringraziamenti a @Dom Hastings per questa soluzione (3 byte in meno del mio, vedi sotto).

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

Esegui con -E(o -M5.010) flag:

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

La mia versione precedente, 3 byte più lunghi (totale di 40 byte):

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

JavaScript (ES6), 66 64 byte

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

Regex abbina i caratteri ma non i ritorni a capo, quindi, usando regex sostituisci, posso aggiungere "," a ciascun personaggio.

Modifica: rimossi 2 caratteri grazie a ETHProductions

Cheddar, 70 byte

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

Sembra che non stia diventando più breve di così. Ho realizzato altre versioni di questo che usano metodi piuttosto interessanti ma questo è il più breve

Provalo online!

Spiegazione

->                        // 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' @"operatore viene utilizzato per generare un intervallo di stringhe. Genera una stringa che inizia dal codice char sinistro al codice char destro.

Ad esempio, 65è il codice char per Ae 90per Z. Fare 65 @" 90genererebbe dalla A alla Z o l'alfabeto.

C, 112 102 81 byte

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

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

Provalo online

Rubino, 56 54 byte

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

La prima riga termina con una nuova riga letterale.

Modifica: salvato due byte sostituendolo 'A'..'Y'con ?A..?Y.

Vim, 32 byte

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

Lascia una riga vuota alla fine, che è stato permesso, ma è strano essere così goffo. Ancora peggio, sto finendo in modalità insert. Ho visto altre persone farlo qui, quindi immagino sia permesso? Sembra sporco.

• 26o<C-V><C-V>64,<Esc>: Il primo <C-V>inserisce letteralmente il secondo. Le <C-V>64s che rimangono nel buffer verranno trasformate in punti di codice ASCII, quindi in lettere. Virgole già presenti.
• r.: Non sarà mai più alla fine, quindi fallo .adesso.
• V{g<C-A>: Utilizza l'incremento visivo per trasformare tutte le 64s nei punti di codice ASCII delle lettere maiuscole.
• 8Jj9Jj3Jj.j4J: La linea arbitraria si unisce. Il primo è 8Jinvece 7Jperché abbiamo a che fare con la riga vuota. I ripetuti 3Jsono idonei per una ripetizione punto.
• cH<C-R>": Le persone di solito pensano i<C-R>come un incolla in modalità inserimento, ma è più simile a una macro in modalità inserimento. Roba come <C-V>65verrà eseguita come se digitata e interpretata come un punto di codice decimale. Ciò lascia una riga extra (consentita) alla fine e rimane nella modalità di inserimento.

PowerShell v3 +, 60 78 67 byte

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

OK. Questa volta ho letto, compreso e seguito le specifiche. Promettere. : D

Prende l'array 65..90e passa su ogni elemento |%{...}. Ogni iterazione, stiamo costruendo una nuova stringa usando concatenazione, indicizzazione e moltiplicazione.

Innanzitutto, prendiamo il numero corrente e lo charlanciamo per renderlo una lettera ASCII. Questo è concatenato con un altro carattere, basato sull'indicizzazione nella stringa, '.,'indipendentemente dal fatto che ci troviamo 90o meno (vale a dire, da tenere in considerazione Z.mentre tutte le altre sono virgole). Questa è una stringa concatenata " "per separare le lettere nello spazio e la moltiplicazione di stringhe in "`n"base al valore booleano per stabilire se l'elemento corrente è -inl'array specificato (ovvero se dobbiamo concatenare un carattere di nuova riga). La stringa risultante viene lasciata sulla pipeline.

Quelle stringhe sono incapsulate in parentesi e -joinriunite in una nuova stringa, che viene quindi lasciata sulla pipeline e implicita Write-Outputalla fine stampa il risultato. Dal momento che abbiamo `nnella stringa, viene automaticamente convertito in newline al momento della stampa.

Richiede v3 + per l' -inoperatore. Ha uno spazio finale su ogni riga, il che è OK per le specifiche della sfida.

Esempio

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 byte

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

solo per confronto 87 byte

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

9 byte salvati grazie a @Luis!

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

Provalo online!

Spiegazione

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 byte

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

Spiegazione:

LETTERSè predefinito per le lettere maiuscole.
La ffunzione serve per concatenare il vettore x su ,con ulteriore y(usato per le nuove linee).
Il gatto è usato in quanto stampa \ncome newline. fviene chiamato sulle lettere per formare le righe e quindi nuovamente sulle righe per formare l'intero output.

Probabilmente golfable - Non mi piacciono le chiamate multiple di f ...

CJam, 31 byte

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

Spiegazione:

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

Provalo online

Julia, 71 byte

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

Richiede 0,5 o superiore per la trasmissione .()

Cheddar, 57 byte

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

Provalo online! Non è bellissimo? È un bel rettangolo.

Due sostituzioni regex. (65@"90)è l'alfabeto maiuscolo, .sub(/[GPSV]/g,"$0\n")sostituisce GPSVcon se stesso e "\n", .sub(/[^Z\n]/g,"$0, ")sostituisce tutti i caratteri non newline e Zcaratteri con se stesso ", "e "."aggiunge un finale ..

Japt, 24 byte

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

Provalo online!

Come funziona

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

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

Retina, 43 byte

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

La newline leader è significativa. Provalo online!

Questa è la prima volta che utilizzo Retina, quindi ogni consiglio sul golf è apprezzato ...

Pyth, 25 byte

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

Un programma che stampa il risultato su STDOUT.

Provalo online

Come funziona

+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