[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](https://en.wikipedia.org/wiki/Alphabet_song#The_A.B.C._.28Verse_1.29) 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]
# 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](https://codegolf.stackexchange.com/a/87010/31716) 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]
# [05AB1E](http://github.com/Adriandmen/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!](http://05ab1e.tryitonline.net/#code=QScsw6I3OTMzNFPCo8K7wqgnLko&input=)
[Answer]
# Bash + GNU utilities, 36
* 5 bytes saved thanks to Neil.
```
echo {A..Y}, Z.|sed 's/[HQTW]/\n&/g'
```
[Ideone.](https://ideone.com/6YcyW7)
[Answer]
# JavaScript (ES6), ~~66~~ 65 bytes
Beating [@Neil](https://codegolf.stackexchange.com/a/95006/42545) 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](https://codegolf.stackexchange.com/a/95044/42545). 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]
# 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]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~19~~ 18 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ØAp”,ṁ79334DR¤GṖ”.
```
*Thanks to @Adnan for golfing off 1 byte!*
[Try it online!](http://jelly.tryitonline.net/#code=w5hBcOKAnSzhuYE3OTMzNERSwqRH4bmW4oCdLg&input=)
### 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]
## Pyke, ~~23~~ ~~19~~ 17 bytes
```
G\,J\.+2cu  /P
```
[Try it here!](http://pyke.catbus.co.uk/?code=G%5C%2CJ%5C.%2B2cu%04%07%09%03%03%2FP)
```
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]
## Brainfuck, 117 bytes
```
+[++[-<]-[->->]<]+++[->++>+++>+>+<<<<<--<<->>>]>+[[-<<<<<+.>-.+>.>>>]>[[-<+>]>]<<[<]<.>>]<<-[---<<<+.>-.+>.>]<<<+.>+.
```
The first four lines each have a trailing space, and the program assumes 8-bit cells. [Try it online!](http://brainfuck.tryitonline.net/#code=K1srK1stPF0tWy0-LT5dPF0rKytbLT4rKz4rKys-Kz4rPDw8PDwtLTw8LT4-Pl0-K1tbLTw8PDw8Ky4-LS4rPi4-Pj5dPltbLTwrPl0-XTw8WzxdPC4-Pl08PC1bLS0tPDw8Ky4-LS4rPi4-XTw8PCsuPisu&input=)
(Handling the last line is tricky...)
[Answer]
# 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>64`s 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 `64`s 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 `3J`s 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]
## 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]
## CJam, 26 bytes
```
'A79333Ab{{',S2$)}*N\}/'.@
```
[Online interpreter](http://cjam.aditsu.net/#code='A79333Ab%7B%7B'%2CS2%24%29%7D*N%5C%7D%2F'.%40)
```
'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]
## Perl, 37 bytes
*Credits to [@Dom Hastings](https://codegolf.stackexchange.com/users/9365/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]
# R, ~~83~~ 71 bytes
```
a=rbind(LETTERS[-26],","," ");a[3,7+3*c(0,3:5)]="\n";cat(a,"Z.",sep="")
```
[Try it online!](https://tio.run/##K/r/P9G2KCkzL0XDxzUkxDUoOFrXyCxWRwkEFZQ0rROjjXXMtY21kjUMdIytTDVjbZVi8pSskxNLNBJ1lKL0lHSKUwtslZQ0//8HAA "R – 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]
# Brainfuck, 157 bytes
```
+++++[>+>+++<<-]>>[->+>++++>+++>++<<<<]>----->+++++.>-.>++.<<<<<+[->>>+.>.>.<<<<<]+++++++++>>.<<[->>>+.>.>.<<<<<]<---[+>+++>>.<<[->>>+.>.>.<<<<<]<]>>>>+.>++.
```
[Try it online](http://brainfuck.tryitonline.net/#code=KysrKytbPis-KysrPDwtXT4-Wy0-Kz4rKysrPisrKz4rKzw8PDxdPi0tLS0tPisrKysrLj4tLj4rKy48PDw8PCtbLT4-PisuPi4-Ljw8PDw8XSsrKysrKysrKz4-Ljw8Wy0-Pj4rLj4uPi48PDw8PF08LS0tWys-KysrPj4uPDxbLT4-PisuPi4-Ljw8PDw8XTxdPj4-PisuPisrLg&input=)
[Answer]
# 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]
# [Vyxal](https://github.com/Vyxal/Vyxal), 15 bytes
```
n\,Ẋ7933fẇ⁋Ṫ\.+
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyIiLCIiLCJuXFws4bqKNzkzM2bhuofigYvhuapcXC4rIiwiIiwiIl0=) -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]
# 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!](http://cheddar.tryitonline.net/#code=LT5bNjVAIjcxLDcyQCI4MCwiUVJTIiwiVFVWIiwiV1hZWiJdLm1hcChALmNoYXJzLmpvaW4oIiwgIikpLnZmdXNlKycuJw&input=)
## 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]
# MATL, ~~38~~ 29 bytes
*9 bytes saved thanks to @Luis!*
```
1Y2X{', '&Zc46h1[CEII]I*11hY{
```
[**Try it Online!**](http://matl.tryitonline.net/#code=MVkyWHsnLCAnJlpjNDZoMVtDRUlJXUkqMTFoWXs&input=)
**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]
## 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]
# Japt, 24 bytes
```
;B¬qJ+S r"[HQTW]"@R+XÃ+L
```
[Test it online!](http://ethproductions.github.io/japt/?v=master&code=O0KscUorUyByIltIUVRXXSJAUitYwytM&input=)
### 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]
# 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]
# 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]
# q, 46 bytes
```
-1@'(", "sv/:0 7 16 19 22_,:'[.Q.A]),'",,,,.";
```
[Answer]
## 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 `-join`ed 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]
# 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]
# Pyth, 25 bytes
```
+Pjmj\ dc*G\,j94092 23)\.
```
A program that prints the result to STDOUT.
[Try it online](http://pyth.herokuapp.com/?code=%2BPjmj%5C+dc%2aG%5C%2Cj94092+23%29%5C.&debug=0)
**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]
## [Pip](http://github.com/dloscutoff/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!](http://pip.tryitonline.net/#code=KHpKaykuJy5eQEEqIhUwOUIi&input=&args=LW4)
### 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]
## 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]
# 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](http://cjam.tryitonline.net/#code=J1ssNjU-IiwgIio3OTMzQWJ7MyovKFw6K30lTionLg&input=)
[Answer]
# Julia, 71 bytes
```
f()=join(join.(['A':'G','H':'P',"QRS","TUV","WXYZ"],[", "]),",\n")*"."
```
Requires 0.5 or better for broadcasting `.()`
]