Napisz program lub funkcję, która wyświetli ten dokładny tekst, bez rozróżniania wielkości liter:

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.

(Na podstawie piosenki alfabetu którą wiele amerykańskich dzieci uczy się zapamiętywać alfabet, choć edytowaną dla większej kompresji).

Dane wyjściowe muszą wyglądać dokładnie tak samo jak powyżej (ponownie, bez rozróżniania wielkości liter), ale mogą zawierać końcowe spacje w każdej linii i / lub końcowe nowe linie. Zauważ okres na końcu.

To jest golf golfowy, więc wygrywa najkrótszy kod w bajtach.

Vim, 42 , 40 klawiszy / bajtów

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

Dzięki Lynn i jej niesamowitej odpowiedzi vima na wskazówkę, jak zdobyć alfabet z pomocy.

Dzięki RomanGräf za zapisanie dwóch bajtów!

Wyjaśnienie:

: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

Następnie przesuwamy koniec linii za pomocą $, zmieniamy znak za pomocą chi wstawiamy kropkę.

05AB1E , 16 bajtów

Kod

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

Wyjaśnienie:

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.

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Narzędzia Bash + GNU, 36

• 5 bajtów zaoszczędzonych dzięki Neilowi.

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

Ideone.

JavaScript (ES6), 66 65 bajtów

Pokonując @Neil było niemożliwe ... to dlaczego to zrobiłem. :-)

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

Grał w golfa 1 bajt dzięki lewie @LevelRiverSt . Używanie String.fromCharCodejest o 7 bajtów dłuższe:

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

Jak to działa

To rekurencyjnie generuje każdy znak alfabetu od ado y, używając .toString(). Przecinek jest dodawany po każdej literze, plus nowa linia, jeśli 9568512>>i-9&1jest 1, lub spacja w przeciwnym razie. Kiedy rekurencja przekroczy 34, tzn. Do z, funkcja po prostu powraca "z.".

Python 2.7, 67 66 63 bajtów

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

Dennis uratował bajt.

Galaretka , 19 18 bajtów

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

Dzięki @Adnan za grę w golfa przy 1 bajcie!

Wypróbuj online!

Jak to działa

Ø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 bajtów

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

Prawdopodobnie można to skrócić za pomocą atob / btoa, jeśli potrafisz dowiedzieć się, jak używać kodowania ISO-8859-1. Edycja: Zapisano 6 bajtów dzięki @RickHitchcock.

Pyke, 23 19 17 bajtów

G\,J\.+2cu  /P

Wypróbuj tutaj!

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 bajtów

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

Wypróbuj online!

Tworzy macierz 3 wierszy (jeden z literami, jeden z przecinkami, a drugi ze spacją lub znakiem nowej linii).

Edycja : Dzięki Billywob!

CJam, 26 bajtów

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

Tłumacz 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 bajtów

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

Pierwsze cztery linie mają spację końcową, a program przyjmuje 8-bitowe komórki. Wypróbuj online!

^{(Obsługa ostatniej linii jest trudna ...)}

Perl, 37 bajtów

Kredyty dla @Dom Hastings za to rozwiązanie (3 bajty krótsze niż moje, patrz poniżej).

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

Uruchom z flagą -E(lub -M5.010):

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

Moja poprzednia wersja, 3 bajty dłużej (łącznie 40 bajtów):

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

JavaScript (ES6), 66 64 bajtów

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

Regex dopasowuje znaki, ale nie zwraca karetki, więc używając regex replace, mogę dodać znak „,” do każdego znaku.

Edycja: Usunięto 2 postacie dzięki ETHProductions

Cheddar, 70 bajtów

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

Wygląda na to, że nie jest krótszy niż ten. Stworzyłem inne wersje tego, które wykorzystują dość interesujące metody, ale to jest najkrótsze

Wypróbuj online!

Wyjaśnienie

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

@"Operator jest wykorzystywany do generowania znaków wynosiła. Generuje ciąg znaków, zaczynając od lewego kodu znaków do prawego kodu znaków.

Na przykład 65to kod char dla Ai 90dla Z. Wykonanie 65 @" 90spowoduje wygenerowanie litery A do Z lub alfabetu.

DO, 112 102 81 bajtów

Dzięki cleblanc i 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 bajtów

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

Wypróbuj online

Rubin, 56 54 bajtów

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

Pierwsza linia kończy się dosłownie nową linią.

Edycja: zapisano dwa bajty, zastępując 'A'..'Y'je ?A..?Y.

Vim, 32 bajty

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

Na końcu pozostawia pustą linię, co było dozwolone, ale to dziwne, że jest tak niezdarny. Co gorsza, kończę w trybie wstawiania. Widziałem, jak robią to inni ludzie, więc myślę, że to dozwolone? Czuje się brudny.

• 26o<C-V><C-V>64,<Esc>: Pierwsza <C-V>sprawia, że ​​druga wstawia dosłownie. Te <C-V>64pozostawiane w buforze zostaną zamienione na punkty kodowe ASCII, a następnie na litery. Przecinki już są.
• r.: Nigdy więcej nie będzie na końcu, więc .teraz.
• V{g<C-A>: Używa przyrostu wizualnego, aby zamienić wszystkie 64s na punkty kodu ASCII wielkich liter.
• 8Jj9Jj3Jj.j4J: Dowolna linia łączy się. Pierwszy z nich to 8Jzamiast 7Jponieważ mamy do czynienia z pustym wierszu. Powtórzone 3Js kwalifikują się do powtórzenia kropki.
• cH<C-R>": Ludzie zwykle myślą o i<C-R>wklejaniu w trybie wstawiania, ale bardziej przypomina to makro w trybie wstawiania. Rzeczy podobne <C-V>65będą działać, jakby zostały wpisane i zinterpretowane jako przecinek dziesiętny. To pozostawia dodatkową (dozwoloną) linię na końcu i pozostaje w trybie wstawiania.

PowerShell v3 +, 60 78 67 bajtów

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

DOBRZE. Tym razem przeczytałem, zrozumiałem i postępowałem zgodnie ze specyfikacją. Obietnica. :RE

Przejmuje tablicę 65..90i zapętla każdy element |%{...}. W każdej iteracji tworzymy nowy ciąg przy użyciu konkatenacji, indeksowania i mnożenia.

Najpierw bierzemy bieżący numer i charrzucamy nim, aby był literą ASCII. Jest to połączone z innym char, opartym na indeksowaniu do łańcucha, '.,'niezależnie od tego, czy jesteśmy przy, 90czy nie (tj. Aby uwzględnić, Z.podczas gdy cała reszta to przecinki). Jest to łańcuch połączony z " "separacją spacji liter i mnożenie łańcucha w "`n"oparciu o wartość logiczną dla tego, czy bieżący element jest -inokreśloną tablicą (tj. Czy musimy konkatenować znak nowego wiersza). Powstały ciąg zostaje pozostawiony w potoku.

Ciągi te są enkapsulowane w pareny i -joinłączone razem w nowy ciąg, który jest następnie pozostawiany w potoku i domyślnie Write-Outputna końcu drukuje wynik. Ponieważ mamy `nten ciąg, jest on automatycznie konwertowany na znaki nowej linii podczas drukowania.

Wymaga v3 + dla -inoperatora. Ma końcowe miejsce w każdej linii, co jest OK zgodnie ze specyfikacją wyzwania.

Przykład

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 bajty

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

tylko dla porównania 87 bajtów

<?="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 bajtów

9 bajtów zapisanych dzięki @Luis!

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

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

Wyjaśnienie:

LETTERSjest predefiniowany dla wielkich liter.
Ta ffunkcja służy do łączenia wektora x ,z dodatkowym y(wykorzystywanym do znaków nowej linii).
Kot jest używany, ponieważ drukuje się \njako nowy wiersz. fjest wywoływany na literach w celu utworzenia wierszy, a następnie w wierszach ponownie w celu utworzenia całego wyniku.

Prawdopodobnie gra w golfa - nie lubię wielu połączeń f ...

CJam, 31 bajtów

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

Wyjaśnienie:

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

Wypróbuj online

Julia, 71 bajtów

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

Wymaga 0,5 lub wyższej do nadawania .()

Cheddar, 57 bajtów

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

Wypróbuj online! Czy to nie jest piękne? To ładny prostokąt.

Dwie substytucje wyrażeń regularnych. (65@"90)jest wielkimi literami, .sub(/[GPSV]/g,"$0\n")zamienia GPSVsię na siebie i "\n", .sub(/[^Z\n]/g,"$0, ")zastępuje wszystkie nie-nowy wiersz i Zznaki na siebie ", "i "."dodaje znak końcowy ..

Japt, 24 bajty

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

Przetestuj online!

Jak to działa

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

Nie golfowany:

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 bajtów

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

Siatkówka, 43 bajty

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

Wiodąca nowa linia jest znacząca. Wypróbuj online!

Po raz pierwszy używam Retiny, więc wszelkie wskazówki dotyczące golfa są doceniane ...

Pyth, 25 bajtów

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

Program, który drukuje wynik do STDOUT.

Wypróbuj online

Jak to działa

+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