Now I know my ABCs, won't you come and golf with me?

Question

Write a program or function that outputs this exact text, case-insensitive:

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.

(Based on the alphabet song that many American kids learn to help memorize the alphabet, though edited for more compressibility.)

The output must look exactly the same as the above (again, case-insensitive), but may contain trailing spaces on each line and/or trailing newlines. Notice the period at the end.

This is code-golf, so the shortest code in bytes wins.

Answer 1

Vim, 42, 40 keystrokes/bytes

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

Thanks to Lynn and her awesome vim answer for the tip to grab the alphabet from help.

Thanks to RomanGräf for saving two bytes!

Explanation:

: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

Then, we move the end of the of the line with $, change back a character with ch and insert a dot.

Answer 2

05AB1E, 16 bytes

Code

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

Explanation:

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.

Uses the CP-1252 encoding. Try it online!

Answer 3

Bash + GNU utilities, 36

• 5 bytes saved thanks to Neil.

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

Ideone.

Answer 4

JavaScript (ES6), 66 65 bytes

Beating @Neil was impossible... That's why I did it. :-)

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

Golfed 1 byte thanks to a trick from @LevelRiverSt. Using String.fromCharCode is 7 bytes longer:

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

How it works

This recursively generates each character of the alphabet from a to y, using .toString(). A comma is appended after each letter, plus a newline if 9568512>>i-9&1 is 1, or a space otherwise. When the recursion gets past 34, i.e. to z, the function simply returns "z.".

Answer 5

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 saved a byte.

Answer 6

Jelly, 19 18 bytes

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

Thanks to @Adnan for golfing off 1 byte!

Try it online!

How it works

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

Answer 7

Pyke, 23 19 17 bytes

G\,J\.+2cu  /P

Try it here!

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(^)

Answer 8

Brainfuck, 117 bytes

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

The first four lines each have a trailing space, and the program assumes 8-bit cells. Try it online!

^{(Handling the last line is tricky...)}

Answer 9

Vim, 32 bytes

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

Leaves a blank line at the end, which was allowed, but it's weird being this clumsy. Even worse, I'm ending in insert mode. I've seen some other folks do it here, so I guess it's allowed? It feels dirty.

• 26o<C-V><C-V>64,<Esc>: The first <C-V> makes the second one insert literally. The <C-V>64s this leaves in the buffer will be turned into ASCII code points, then into letters. Commas already in.
• r.: Never going to be at the end again, so do the . now.
• V{g<C-A>: Uses visual increment to turn all the 64s into the ASCII code points of the capital letters.
• 8Jj9Jj3Jj.j4J: The arbitrary line joins. First one is 8J instead of 7J because we're dealing with the blank line. The repeated 3Js are eligible for a dot repeat.
• cH<C-R>": People usually think of i<C-R> as an insert mode paste, but it's more like an insert mode macro. Stuff like <C-V>65 will run as if typed, and interpreted as a decimal code point. This leaves an extra (allowed) line at the end, and stays in insert mode.

Answer 10

JavaScript (ES6), 80 74 bytes

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

Probably possible to shorten this with atob/btoa if you can work out how to use ISO-8859-1 encoding. Edit: Saved 6 bytes thanks to @RickHitchcock.

Answer 11

CJam, 26 bytes

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

Online interpreter

'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

Answer 12

Perl, 37 bytes

Credits to @Dom Hastings for this solution (3 bytes shorter than mine, see bellow).

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

Run with -E (or -M5.010) flag :

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

My previous version, 3 bytes longer (total of 40 bytes) :

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

Answer 13

R, 83 71 bytes

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

Try it online!

Makes a matrix of 3 rows (one with the letters, one with the commas and the other with either a space or a newline).

Edit: Thanks Billywob!

Answer 14

Brainfuck, 157 bytes

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

Try it online

Answer 15

JavaScript (ES6), 66 64 60 bytes

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

Regex matches the characters but not the carriage returns, so, using regex replace, I can add the ", " to each character.

Edit: Removed 2 characters thanks to ETHProductions

Edit: Changed from CRLF to LF, thanks @Olivier Grégoire

Answer 16

Vyxal, 15 bytes

n\,Ẋ7933fẇ⁋Ṫ\.+

Try it Online! -2 thanks to lyxal. -1 thanks to ffseq

n               # Uppercase alphabet
   Ẋ            # Each prepended to
 \,             # ","
         ẇ      # Cut into chunks of lengths
    7933f       # Digits of 7933 (+ rest, which is 4)
          ⁋     # Join by newlines
           Ṫ    # Remove the last character
            \.+ # Append a dot

Answer 17

Cheddar, 70 bytes

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

Looks like it's not getting shorter than this. I've made other versions of this which use quite interesting methods but this is shortest

Try it online!

Explanation

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

---

The @" operator is used to generate string ranged. It generates a string starting from the left char code to the right char code.

For example, 65 is the char code for A and 90 for Z. Doing 65 @" 90 would generate A through Z or the alphabet.

Answer 18

MATL, 38 29 bytes

9 bytes saved thanks to @Luis!

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

Try it Online!

Explanation

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

Answer 19

C, 112 102 81 bytes

Thanks to 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)‌​;}

Answer 20

Japt, 24 bytes

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

Test it online!

How it works

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

Answer 21

Ruby, 56 54 bytes

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

The first line ends with a literal newline.

Edit: saved two bytes by replacing 'A'..'Y' with ?A..?Y.

Answer 22

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

Answer 23

q, 46 bytes

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

Answer 24

PowerShell v3+, 60 78 67 bytes

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

OK. I've actually read, understood, and followed the spec this time. Promise. :D

Takes the array 65..90 and loops over each element |%{...}. Each iteration, we're constructing a new string using concatenation, indexing, and multiplication.

First, we take the current number and char cast it to make it an ASCII letter. That's concatenated with another char, based on indexing into the string '.,' whether we're at 90 or not (i.e., to account for Z. while having all the rest be commas). That's string concatenated with " " to space-separate the letters, and string multiplication of "`n" based on Boolean value for whether the current element is -in the specified array (i.e., whether we need to concatenate on a newline character). The resulting string is left on the pipeline.

Those strings are encapsulated in parens, and -joined together into a new string, which is then also left on the pipeline and implicit Write-Output at the end prints the result. Since we have `n in the string, it's automatically converted to newlines upon printing.

Requires v3+ for the -in operator. Has a trailing space on each line, which is OK per the challenge specs.

Example

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. 

Answer 25

PHP, 62 Bytes

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

only for comparison 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.";

Answer 26

Pyth, 25 bytes

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

A program that prints the result to STDOUT.

Try it online

How it works

+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

Answer 27

Pip, 19 bytes

18 bytes of code, +1 for the -n flag. Outputs in lowercase.

(zJk).'.^@A*"?09B"

The ? represents a non-printing character, ASCII code 21. Try it online!

Explanation

 z                  Lowercase alphabet
  Jk                Join on ", "
(   ).'.            Append a period
          A*"?09B"  Map ascval() over that string, results in list: [21 48 57 66]
        ^@          Split at those indices
                    Join on newline and print (implicit, -n flag)

Answer 28

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

Explanation:

LETTERS is predefined for uppercase letters.
The f function is for concatenating vector x on , with additional y (used for newlines).
The cat is the used as it prints \n as newlines. f is called on the letters to form rows and then on the rows again to form the whole output.

Probably golfable - I don't like the multiple calls of f...

Answer 29

CJam, 31 bytes

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

Explanation:

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

Try it online

Answer 30

Julia, 71 bytes

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

Requires 0.5 or better for broadcasting .()