text:
Now I know my ABCs, won't you come and golf with me?
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.

For regex based languages consider a 0 width lookahead... /(?=[HQTW])/

I thought it was H, I, J, K, LMNO, P?

Shouldn't the last line end with "Y and Z."?

@KM. This was discussed in the sandbox, and we decided to stick with this version to make the challenge less complicated.

Golf seems boring. Cricket is better.

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.

You mustn't convert to uppercase. The OP said " this exact text, case-insensitive".

@RomanGräf Thanks for the tip!

Ha! Getting the alphabet from vim help is genius! Did you know that or did you look it up for this challenge?

@christianRondeau I did not come up with it. Lynn did in this answer

@RomanGräf +1 for using mustn't

I would finish with $xr. instead of $ch. so that I don't need to include ESC to exit insert mode.

@MartinKealey I'm not including the final esc.

I can plainly see that you're not including ESC, which is fair game under the rules, but if I was typing it I would feel obliged to include ESC so as to return to the same mode as when I began; hence my preference to use $xr. instead.

Bash + GNU utilities, 36

5 bytes saved thanks to Neil.

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

Ideone.

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

@Neil Ooh very good!  thanks!

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!

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

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.

Using exec instead of for should save a byte.

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.

31 seconds? Dang...

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

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

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.

if you have an issue with a policy (or a lack thereof), take it up on meta, not in an 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.

@RickHitchcock Yes, I just realised that myself after reading the PHP answer.

@RickHitchcock You wanted .join\, ``? Put backslashes before the backticks. (Yes, comment markdown is different, sigh...)

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"$_."'

Slightly different approach (still uses the regex...) for 37 bytes: say+(map"$_, ".$/x/[GPSV]/,A..Y),"Z."

@DomHastings Nice one, Well done. And it's more beautiful to have one statement instead of three! ;-)

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!

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

Thanks! That helped a lot! Using the [-26] on LETTERS directly saves yet another byte.

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

Brainfuck, 157 bytes
+++++[>+>+++<<-]>>[->+>++++>+++>++<<<<]>----->+++++.>-.>++.<<<<<+[->>>+.>.>.<<<<<]+++++++++>>.<<[->>>+.>.>.<<<<<]<---[+>+++>>.<<[->>>+.>.>.<<<<<]<]>>>>+.>++.

Try it online

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

I have no idea why the other JS golfers didn't go for this solution first. Here, have an upvote.

Dang, nice one! I think you can remove the parens in the regex if you change $1 to $&.

I disagree with your byte count: you seem to count bytes as if a line is \r\n. But if you use \n only, you can shave 4 bytes off your count. So your bytecount is not 64, but 60, without changing anything in your code.

Thank you.   I changed line endings locally and tested, just to be certain, and updated the  count

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

27 bytes: Try it Online!

23 bytes

17 bytes

15 bytes. Chunk Wrap doesn't need the last 4 in this case

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

You can golf it by 7 bytes: All three || to | (-3); changing c==90 to c>89 (-1); changing '.' to 46 (-1); and changing '\n' to 10 (-2).

@KevinCruijssen thanks, I tried using decimals but it looks like if I replace both character constants in a ternary it changes the expression type to integer, which broke it. Changing one constant worked and squeezed out a few bytes.

No problem. Don't forget to change the 116 to <s>116</s> 109 bytes. ;)

@KevinCruijssen thanks. If I had enough coffee in me I would have remembered to update it myself.

2 more bytes: "GPSV".contains(""+c) instead of c==71|c==80|c==83|c==86.

@TNT I was able to do slightly better. I knew that part could be improved, thanks for the push in the right direction.

You can golf one more byte I now notice. You can remove the ++c from the for-loop, and put it at the last usage inside the for-body: .indexOf(c++).

@KevinCruijssen thanks. I always overlook that. I also do a bit of C++ programming and that wanders into UB in C++, but not in Java.

84 bytes but outgolfed anyway

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.

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

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

Nice solution.  you can save a few bytes as 44 is 1 less than ',' and 46 1 less than '.'

There's no need to declare int and you can make can d implicit ints as well, this is only 101 bytes i,c,d;main(){for(c=65;c<91;++c){if(c-"GPSVZ"[i])d=32;else d=10,++i;printf("%c%c%c",c,c-90?44:46,d);}}

You can get this approach down to 82 bytes: i,c;main(){for(c=64;++c<91;)printf("%c%c%c",c,44+c/90*2,c=="GPSVZ"[i]?++i,10:32);} . Note that you can stick absolutely anything between the ?: of a ternary operator, even several expressions separated by commas (it evaluates to the last one.)

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

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.

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

Requires 0.5 or better for broadcasting .()

On the one hand, this currently does not have a trailing period, and doesn't it need a print/function definition? On the other hand, not saving join to a variable saves a byte.

My bad wrt missing the ".", and thanks for the pointer on join. I misscounted. Running the program returns the string.
Isn't a program returning a string a valid output?
(Or is it only functions that are allowed to return things to count as output.
if so f()= is shorter thant print())

Sure, f()= or ()-> is fine - I think the idea is that functions are assignable and can be run multiple times, and in contrast this would be a code snippet.

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

Try it online! Isn't that beautiful? It's a nice rectangle.
Two regex substitutions. (65@"90) is the uppercase alphabet, .sub(/[GPSV]/g,"$0\n") replaces GPSV with itself and "\n", .sub(/[^Z\n]/g,"$0, ") replaces all non newline and Z characters with itself and ", ", and "." adds a final ..

Nice technique, and nice job outgolfing Downgoat ;)

TI-Basic, 86 bytes
Cheers to anyone who can compress it further :3
Disp "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.

I think this is optimal, unfortunately.

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

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.

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.";

You can save a byte by using an actual newline in place of the \n.

As you're allowed trailing spaces on each line you can save a byte by dropping the space from the regex.
Also you can save a byte by using the (deprecated and removed in 7.0) ereg_replace as it lets you skip the delimiters in the regex.

@user59178 I could save 3 Bytes but i would avoid this. Yes the trailing space is allowed. I could wrote as regex "# (?=[HQTW])#" and short the replace to "\n" same bytes and makes it clearer. To use a deprecated function can confuse beginners. And the physical break can interpreted wrong on other systems then Unix. You can  post it as your own sugesstion.

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

The raw output is only 77 bytes long. Printing that directly might be shorter...

@Lynn, I know, but here I see some golfing possibilities.

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

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)

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

MathGolf, 20 bytes
'A[793∙]öæ└╣·\n\\;'.

Try it online!
Explanation
'A                    Push "A"
  [793∙]              Push [7, 9, 3, 3, 3]
        ö             Start foreach-loop over index array using next 7 instructions
         æ            Start for-loop for current item of index array, using next 4 instructions
          └           Duplicate and increment, e.g. "A" -> "A", "B"
           ╣·         Push ", "
             \        Swap top two, keeping the letter on top after inner loop
              n\      Push newline and swap top two, keeping the letter on top
                \;'.  Swap top two, discard top, and push "." (remove trailing comma)

Japt -R, 17 bytes
;LiB¬q,ú2¹óÏk`qw

Test it
;LiB¬q,ú2¹óÏk`qw
;L                   :"."
  i                  :Prepend
;  B                 :  Uppercase alphabet
    ¬                :  Split
     q               :  Join with
      ,ú2            :    "," right padded with spaces to length 2
         ¹           :End prepend
          ó          :Partition before characters that return a falsey value (empty string)
           Ï         :When passed through the following function
            k        :  Case insensitively remove
             `qw     :  Characters in the compressed string "qthw"
                     :Implicit output joined with newlines

Java (JDK), 66 bytes
v->"ABCDEFG\nHIJKLMNOP\nQRS\nTUV\nWXY".replaceAll(".","$0, ")+"Z."

Try it online!

C (76 bytes)
c;main(){for(c=64;++c<90;)printf("%c,%c",c," \n"[4784256>>c&1]);puts("Z.");}

This relies on

implicit-int declarations (for c, main, puts and printf without #include<stdio.h>);
ASCII;
>> being modulo the size of an integer in bits, either 32 or 64, so that X>>'A' gives "X shifted by 1" and X>>'Z' gives "X shifted by 26".

4784256 is 2⁷+2¹⁶+2¹⁹+2²² (or equivalently 1<<7 | 1<<16 | 1<<19 | 1<<22), because 'G', 'P', 'S', and 'V' are respectively the 7th, 16th, 19th, and 22nd letters of the alphabet.

Fourier, 56 bytes
|~S44a32aS^|f|(iaf~i)10a|L65~i72L81L84L87L90(iaf~i)ia46a

Again, uses functions to take out repeated parts of the code.
Try it FourIDE!

Clojure, 154 bytes
#(print(loop[a(map char(range 65 91))[c & d][7 9 3 3 4]s""](if c(let[[l r](split-at c a)e(if d\,\.)](recur r d(str s(clojure.string/join", "l)e"\n")))s)))

That call to clojure.string/join is killer, although this wasn't competitive to begin with. Basically, it cuts the generated alphabet string a at the predefined line lengths, then adds each line to the acc.
It would have been significantly shorter for me to just "cheat" and print the string (91 bytes):
(print "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.")

But where's the fun in that?
Ungolfed:
(defn abcs []
  (print
    (loop [alpha (map char (range 65 91))
           [c & cuts] [7 9 3 3 4]
           acc ""]
      (if c
        (let [[a-line a-rest] (split-at c alpha)
              e (if cuts \, \.)]
          (recur a-rest cuts (str acc (clojure.string/join ", " a-line) e "\n")))
        acc))))

GameMaker Language, 85 bytes
b=""for(a=65;a<90;a++){d=chr(a)c=", "if string_pos(d,"GPSV")c=",#"b+=d+c}return b+"Z.

Boring alternate (94 bytes)
return string_replace_all("AaBaCaDaEaFaG,#HaIaJaKaLaMaNaOaP,#QaRaS,#TaUaV,#WaXaYaZ.","a",", ")

Pretty straightforward. Note that # is newline literal (think \n in most languages). Use \# for #.

><>, 52 bytes
79334"A"\
or:?!~r&>:o1+:}&a" ,.["{=:}?$~o{?;{1-:}?$~

Try it online!

PHP, 61 58 55 50 bytes
Note: uses Windows 1252 encoding.
for($a=A;$a<Z;)echo"$a,",~ßõ[!trim($a++,GPSV)]?>Z.

Run like this:
php -r 'for($a=A;$a<Z;)echo"$a,",~ßõ[!trim($a++,GPSV)]?>Z.' 2>/dev/null;echo

If your terminal is set to UTF-8, this shows that it works:
php -r 'for($a=A;$a<Z;)echo"$a,"," \n"[!trim($a++,GPSV)]?>Z.' 2>/dev/null;echo

Explanation
Iterates over the alphabet until Y is reached. Prints the letter with a comma, then prints a space, unless the letter is one of GPSV (found by !trim($a,"GPSV")). After the loop, print Z..
Tweaks

Saved 3 bytes by using strpos instead of char count
Saved 3 bytes by using trim instead of strpos
Saved 5 bytes by using the closing tag to print a literal Z. instead of echo

PHP, 90 chars
A<?for($i=66;$i<91;$i++){echo", ";if(in_array($i,[72,81,84,87]))echo"\n";echo chr($i);}?>.

I know it's longer than 77 chars, but this is as short as it gets.

timmyRS, When I noticed the "." outside your closing tag, I thought  for a split second that you had an error, but I realized you were saving the trouble of concatenating that into your existing string. But, that also made me realize that anything greater than 77 bytes is overkill because you could to the whole thing as plain text and it would work just as well as your ".".

@TecBrat Well I fixed it now ;P

Retina, 43 bytes

Z
{2`
$`
}T01`L`_L
.
$&,
[HQTW]
¶$&
, $
.
Leading newline is significant. Try it online!
This is my first time using Retina, so any golfing tips are appreciated...

PHP, 67 65 64 bytes
Not exactly short, but it works.
This assumes that all errors are going to stderr.
foreach(range(A,Z)as$C)echo$C,",."[$C>Y],"
 "[!strstr(GPSV,$C)];

You can try it on http://ideone.com/VSK8Yu.
Thanks to @Jörg Hülsermann for saving 2 bytes!
And thanks to @Titus for saving me 1 byte!

$C>Y instead of $C==Z saves one Byte and 'strstr(GPSV,$C)' instead of strpos(zGPSV,$C) should also save one Byte

@JörgHülsermann That is pure genious! I should have though about that!

@ETHproductions Duh, stupid me. Thanks, I totally forgot about it.

Uhm ... don´t you need all doublequotes for -r?

@Titus Why would you? But, if you want, I can use doublequotes. It doesn't change the meaning at all.

because you need the single quotes to hide the code from the shell.

@Titus You can always escape them, but I've made the change.

@Titus What byte?

You can save one more byte by swapping newline and space and removing one of the exclams. That´ll beat ETHproductions´ JavaScript answer.

@Titus I tried it, it gives me bizarre outputs in PHP 7.0.5.

works fine for me in php 5.6.23 and php 7.0.11. Did you forget to swap the characters? Tryp copy & paste "\n "[!strstr(GPSV,$c)]

@Titus http://sandbox.onlinephpfunctions.com/code/8d778160ea897b462d64b332a77a150ff18d33fa gives a different output when compared to http://ideone.com/VSK8Yu which is SO weird!

Unix LF Windows CR LF Apple CR can only works on an unix system "\n "[!strstr(GPSV,$c)] should work on every system. By the way the solution you have found Ismael is more genious

Yep. But that´d cost the byte that the swapping saved. I tend to not use physical linebreaks anymore anyway, because in CLI it has to be escaped, which adds - in my understanding - one byte to the count.

@JörgHülsermann To be honest, yours is better. Also, all answers assume that you are using *NIX newlines. Using \n is 1 more byte than I want. If you really need Windows-style or Linux-style, just use \r\n or just state that you assume Windows newlines.

Ismael your way is more interesting that the way I've found. You can take @Titus proposal and forget the output of the sandbox site

@JörgHülsermann I found your way more interesting. I really didn't remember about using preg_filter(). And i will use Titus' suggestion. I didn't use it at first since it was spitting trashy output, but I will use now and give the link to ideone. An answer is valid as long as it is reproducible in, at least, 1 environment.

It seems so we need judjes which way is more interesting. Normally I would use preg_replace (interest approaches zero) and the variation with preg_filter saves 1 Byte in some cases. You can be proud to find your way that is more genious

@JörgHülsermann I think yours is more interesting because of preg_filter. In fact, I didn't even knew that that function existed.

Beauty is in the eye of the beholder. :D

@Titus Agreed. But what would be trully beautiful would be to reduce strstr(GPSV,$C) to a single bitwise operation.

Forth, 85 bytes
This is a function that prints the string. Checking for when to print a new line is costly. This is still shorter than simply printing the required string, because it has new lines in it. The code does not need to be on this many lines, but there does need to be a line break within the DO LOOP somewhere. I don't know why.
: f 90 65 DO
I 72 = I 81 = I 84 = I 87 = + + +
if CR then
I emit ." , "
LOOP ." Z." ;

Try it online
The code is case-insensitive.

Ruby, 57 bytes
26.times{|i|$><<(i+65).chr+",."[i/25]+"
"[2392128>>i&1]}

The space at the end of the first line is required: it's a literal [space][newline.]
C,74 bytes
c;main(){for(;++c<27;)printf("%c%c%c",64+c,44+c/26*2,4784256>>c&1?10:32);}

Basic bitshift and mask to determine when to print a space and when to print a newline. I noted that with the A and Z removed all groups are a multiple of 3 letters long, but I was unable to make use of this.

That 4784256>>c&1 is a great idea. But you should probably post the two languages as two separate answers.

Racket 173 bytes
(λ()(let((l(list 7 9 3 3 4))(s 65))(for((i 5))(define e(+ s(list-ref l i)))(for((j(range s e)))
(printf"~a~a "(integer->char j)(if(= j 90)"."",")))(printf"~n")(set! s e))))

Ungolfed:
(define f
  (λ()
    (let ((l (list 7 9 3 3 4))
          (s 65))
      (for ((i 5))
        (define e (+ s (list-ref l i)))
        (for ((j (range s e)))
          (printf "~a~a " (integer->char j) (if(= j 90) "." ",")))
        (printf "~n")
        (set! s e)
        ))))

Testing:
(f)

Output:
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.

Haskell, 60 bytes
putStr$(['A'..'Y']>>= \x->x:", "++['\n'|elem x"GPSV"])++"Z."

Try it on Ideone.
putStr$(['A'..'Y']>>= \x->x:", "++['\n'|elem x"GPSV"])++"Z."
        ['A'..'Y']                                          --String "ABC...XY"
                      \x->x:", "++['\n'|elem x"GPSV"]       --function to append ", " and a "\n" when needed
       (          >>=                                )      --map function over the string and concat
                                                      ++"Z."--append "Z."
putStr$                                                     --print

q, 41 bytes
@[", "sv,:'[.Q.A];20 47 56 65;:;"\n"],"."

How it works:
            .Q.A                          / Built-in alphabet
        ,:'[    ]                         / Flip data (to 1-row matrix)
  ", "sv                                  / Join with ", "
@[               ;20 47 56 65;:;"\n"]     / Replace spaces with newlines at indices
                                     ,"." / Append period

PowerShell 6, 53 52 47 bytes
"$('A'..'Y'|%{"$_,"-replace'[HQTW]','
$&'}) Z."

Try it online!
I believe PowerShell 6 is newer than this challenge. Originally posted as a suggestion for @mazzy's solution.

Stax, 16 bytes
é╡₧!D☻àw╟`«▒Σ╪░↓

Run and debug it
Unpacked, ungolfed, and commented, it looks like this.
'.          push "."
VA          push "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
',\         repeat zip alphabet with comma, yielding ["A,", "B,", ...]
J           join with spaces
)           overwrite end of joined string with period (pushed first)
"r!WEF"!    crammed array literal for [20, 47, 56, 65]
A&          assign 10 to these array indices.  10 is the codepoint for newline.

Run this one

APL (Dyalog Unicode), 30 29 bytesSBCS
Full program.
↑'AHQTW'(∊⍨⊂⊢)'.',⍨∊', '∘,¨⎕a

Try it online!
⎕a the uppercase alphabet
', '∘,¨ prepend ", " to each letter
∊ ϵnlist (flatten)
'.',⍨ append a period
'AHQTW'(…) apply the following tacit function with the string as left argument:
 ⊢ the right argument (", A, B…")
 ⊂ partitioned so a new partition begins at each True in
 ∊⍨ the Boolean mask indicating argument elements that are members of the left argument
↑ mix the list of strings into a character matrix
solved together with Adam

PowerShell, 56 bytes
('ABCDEFG
HIJKLMNOP
QRS
TUV
WXY'-replace'.','$0, ')+'Z.'

Try it online!

53 bytes?

Thanks. It's cool. A char range allowed in Powershell 6+ only. I think it would be better if you create a new post with Powershell 6.

Ok, I will. Thanks.

><>, 45 bytes
4339"A"7v$oa~<
"&+oo1+$>:1(?^1-$:o:"Z"=2*&" ,

Try it online!

ReRegex, 47 bytes
-/,\n/\w\B/$0, /ABCDEFG-HIJKLMNOP-QRS-TUV-WXYZ.

Ungolfed
-/,\n/                             # Replace all dashes with a comma and newline
\w\B/$0, /                         # Replace all letters preceeding a letter with itself and a comma space.
ABCDEFG-HIJKLMNOP-QRS-TUV-WXYZ.    # The default code.

Try it online!

sed, 54 bytes
No further tricks take us down, I'm afraid:
s/^/ABCDEFG\
HIJKLMNOP\
QRS\
TUV\
WXYZ./
s/[A-Y]/&, /g

Try it online!

Ly, 29 bytes
'A043397[[r:o`r' ',oo,]p9`o];

Try it online!
This code pushes the number of letters to print on each line onto the stack. It also keeps the current character on the end of the stack, iterating it each time it prints.  The code loops until the "number of letters to print on the next line" is zero.
'A                            - push "A" on the stack
  0                           - add 0 divider to stop loop
   43397                      - push number of chars per line
        [                  ]  - loop while number of chars>0
         [           ,]       - loop for one line of chars
          r                   - reverse stack
           :                  - duplicate current char
            o                 - print
             `                - increment to next char
              r               - reverse stack again
               ' ',oo         - push/print " ,"
                       p      - delete iterator var
                        9`o   - push/print LF
                            ; - exit to abandon junk on stack

ListSharp, 88 bytes
SHOW="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."

Couldn't you put the \n in the string? It looks like that would be shorter.

@Timtech oh dang, I thought im smart but im not

It's ok. Just something like SHOW="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." is 88 bytes instead of 113.

///, 62 bytes
/c/, /AcBcCcDcEcFcG,
HcIcJcKcLcMcNcOcP,
QcRcS,
TcUcV,
WcXcYcZ.

Try it online!
Not much to golf here, but I reduced it from 77 bytes to 62 just by replacing ,  with c.

What would //, /ABCDE... do?

@ETHproductions It might crash your computer. I put a c for comma.

@ETHproductions Substitutions are repeated until the search string is no longer found. So //.../ will always result in an infinite loop.

Julia 1.0, 53 bytes
_->replace(join('A':'Z',", "),r"(?=[HQTW])"=>"
")*'.'

Try it online!


text:
Least Common Multiple
The least common multiple of a set of positive integers A is the smallest postive integer B such that, for each k in A, there exists a positive integer n such that k*n = B.
Given at least two positive integers as input, output their least common multiple.
Rules

Builtins are allowed, but if your solution uses one, you are encouraged to include an alternate solution that does not use GCD/LCM builtins. However, the alternate solution will not count towards your score at all, so it is entirely optional.
All inputs and outputs will be within the natively-representable range for your language. If your language is natively capable of arbitrarily-large integers, then your solution must work with arbitrarily large inputs and outputs.

Test cases
[7, 2] -> 14
[8, 1] -> 8
[6, 4, 8] -> 24
[8, 2, 1, 10] -> 40
[9, 6, 2, 1, 5] -> 90
[5, 5, 7, 1, 1] -> 35
[4, 13, 8, 8, 11, 1] -> 1144
[7, 2, 2, 11, 11, 8, 5] -> 3080
[1, 6, 10, 3, 4, 10, 7] -> 420
[5, 2, 9, 10, 3, 4, 4, 4, 7] -> 1260
[9, 7, 10, 9, 7, 8, 5, 10, 1] -> 2520

Because it's a reasonably frequent misconception: the formula LCM(a,b) = ab/GCD(a,b) does not extend to more than two numbers (or, for that matter, to one number!).

Actually, 12 1 byte
Golfing suggestions are still welcome, though I'm not sure how to improve on the raw LCM built-in. Try it online!
▲

A 12-byte version without the built-in. Golfing suggestions welcome. Try it online!
╗2`╜@♀%ΣY`╓N

Ungolfing
          Implicit input array.
╗         Save array in register 0.
2`...`╓   Starting with f(0), find the first (two) x where f(x) returns a truthy value.
          These two values will be 0 and our LCM.
  ╜         Push array from register 0.
  @         Swap the top two values. Stack: x, array
  ♀%        Map % over x and array, returning (x % item) for each item in array.
  ΣY        If the sum of all the modulos equals 0, x is either 0 or our LCM.

N         Push the last (second) value of our results. This is our LCM.
          Implicit return.

You do realize you're allowed to use the builtin, right?

@Mego I'll add it in, but my understanding was that builtins were discouraged, so I didn't use it at first.

Builtins are allowed. They're not discouraged at all - I simply wanted to encourage non-builtin solutions to also be included because they are often much more interesting than the builtin.

I read that as actually, 1 byte.

@programmer5000 I think that may be why the language is called actually...

JavaScript (ES6), 36 bytes
f=(a,i=1)=>a.some(v=>i%v)?f(a,i+1):i

Starting from 1 it's the first number that can be divided by all.

f=(a,i=1)=>a.some(v=>i%v)?f(a,i+1):i
;

console.log(f([7, 2]));
console.log(f([8, 1]));
console.log(f([6, 4, 8]));
console.log(f([8, 2, 1, 10]));
console.log(f([9, 6, 2, 1, 5]));
console.log(f([5, 5, 7, 1, 1]));
console.log(f([4, 13, 8, 8, 11, 1]));
console.log(f([7, 2, 2, 11, 11, 8, 5]));
console.log(f([1, 6, 10, 3, 4, 10, 7]));
console.log(f([5, 2, 9, 10, 3, 4, 4, 4, 7]));
console.log(f([9, 7, 10, 9, 7, 8, 5, 10, 1]));

Of course... I thought about doing a loop with this technique, but recursion is way shorter.

This is genius... If I recall, some returns true if at least one element in the array satisfies the condition, right?

05AB1E/2sable, 2 bytes
.¿

Try it online! in 05AB1E
or 2sable

Jelly, 3 bytes
æl/

Reduces by LCM. Try it online! or verify all test cases.
Alternate version, 6 bytes
ÆE»/ÆẸ

Try it online! or verify all test cases.
How it works
ÆE»/ÆẸ  Main link. Argument: A (array)

ÆE      Yield all prime exponents of each integer in A.
  »/    Reduce columns (exponents that correspond to the same prime) by maximum.
    ÆẸ  Turn the resulting array of prime exponents into the corresponding integer.

Python, 69 65 52 50 bytes
A=lambda l,i=1:any(i%a for a in l)and A(l,i+1)or i

2 bytes saved thanks to Dennis!
Pretty straightforward recursive solution, you will need to make the recursion limit a bit higher for some of the test cases to work.

any takes a generator; you don't need the brackets.

A=lambda l,i=1:all(i%a<1for a in l)or-~A(l,i+1) saves a few more bytes.

MATL, 7 bytes
&YFX>^p

No builtin.
Try it online!
Explanation
Let's take input [8, 2, 1, 10] as an example.
&YF    % Take array implicitly. Push vector of prime factors and matrix of exponents
       % of factorization, where each row represents one of the input numbers
       %   STACK: [2 3 5], [3 0 0; 1 0 0; 0 0 0; 1 0 1]
X>     % Maximum of each column
       %   STACK: [2 3 5], [3 0 1]
^      % Element-wise power
       %   STACK: [8 1 5]
p      % Product of array
       %   STACK: 40
       % Implicitly display

EDIT (June 9, 2017): YF with two outputs has been modified in release 20.1.0: non-factor primes and their (zero) exponents are skipped. This doesn't affect the above code, which works without requiring any changes.

PowerShell v2+, 73 60 bytes
param($a)for($i=1;($a|?{!($i%$_)}).count-ne$a.count){$i++}$i

Takes input $a, loops upward from $i=1 with $i++, based on a conditional. The condition is ($a|?{!($i%$_)}).count being -notequal to $a.count. Meaning, the loop ends when the elements of $a that are divisors of $i is equal to the elements of $a. Then, a solitary $i is left on the pipeline, and output is implicit.
Test Cases
PS C:\Tools\Scripts\golfing> @(7,2),@(8,1),@(6,4,8),@(8,2,1,10),@(9,6,2,1,5),@(5,5,7,1,1),@(4,13,8,8,11,1)|%{($_-join',')+" -> "+(.\least-common-multiple.ps1 $_)}
7,2 -> 14
8,1 -> 8
6,4,8 -> 24
8,2,1,10 -> 40
9,6,2,1,5 -> 90
5,5,7,1,1 -> 35
4,13,8,8,11,1 -> 1144

PS C:\Tools\Scripts\golfing> @(7,2,2,11,11,8,5),@(1,6,10,3,4,10,7),@(5,2,9,10,3,4,4,4,7),@(9,7,10,9,7,8,5,10,1)|%{($_-join',')+" -> "+(.\least-common-multiple.ps1 $_)}
7,2,2,11,11,8,5 -> 3080
1,6,10,3,4,10,7 -> 420
5,2,9,10,3,4,4,4,7 -> 1260
9,7,10,9,7,8,5,10,1 -> 2520

Julia (3 Bytes) [Working on Non-Built-in]
lcm     # Using LCM built-in (3 Bytes)

As Dennis pointed out, I keep forgetting that Julia automatically vectorizes inputs.
Example:
println(lcm(1,2,3,4,5,6,7,8,9)) #Prints 2520

JavaScript (ES6), 63 59 bytes
f=([x,...a])=>a[0]?x*f(a)/(g=(m,n)=>n?g(n,m%n):m)(x,f(a)):x

Recursively finds the LCM of the last two elements.

This is what my solution would have been: a=>a.reduce((l,n)=>l*n/(g=(m,n)=>n?g(n,m%n):m)(l,n))

@Neil You can post that if you'd like. I doubt my technique can get that short...

Cheddar, 33 bytes
(n,i=1)f->n.any(i&(%))?f(n,i+1):i

Nothing super new.
Ungolfed
(n, i = 1) f ->
  n.any(j -> i % j) ?
    f(n, i + 1) :
    i

Basically this starts at one and keeps increasing until it finds an LCM

Mathematica, 3 bytes
LCM

Usage:
In[1]:= LCM[9, 7, 10, 9, 7, 8, 5, 10, 1]

Out[1]= 2520

The day that Mathematica matched Jelly is a day I never thought I'd see.

Brachylog v2, 8 bytes
{×↙Xℕ₁}ᵛ

Try it online!
It's funny just how directly this maps on to the definition given in the challenge.
{     }ᵛ    Each element of
            the input
 ×          multiplied by
  ↙X        some arbitrary and inconsistent integer
    ℕ₁      is a natural number,
       ᵛ    which is the same for each element,
            and is the output.

A suspiciously slow but significantly shorter solution:
Brachylog v2, 5 bytes
f⊇p~d

Try it online!
Takes input through the output variable and gives output through the input variable. Rips right through the first four test cases but I'm still waiting on the fifth... Ordinarily, I'd still make it my primary solution and just trust that it works correctly, but I don't know why it hasn't confirmed that 90 is the LCM of 9, 6, 2, 1, 5 when I gave it 90 twenty minutes ago.
(Edit: It confirmed the answer after no more than 16 hours, and generated it alongside the LCM of 5, 5, 7, 1, 1 after about two days.)
         The output variable
   ~d    with duplicates removed
  p      is a permutation of
 ⊇       a sublist of
f        the factors of
         the input variable.

And another completely different predicate that accidentally more-or-less translates Fatalize's Brachylog v1 solution:
Brachylog v2, 10 bytes
;.gᵗ↔z%ᵛ0<

Try it online!
This was salvaged from a solution I'd made for this challenge before I realized the output wasn't restricted to being an integer.
 .            The output
; gᵗ↔z        paired with each element of
              the input,
      %ᵛ      when the first element of each pair is taken mod the second, is always
        0     zero.
              Furthermore, the output
         <    is strictly greater than
        0     zero.

Dyalog APL, 2 bytes
∧/

Reduces by LCM. Test it on TryAPL.

Congrats on 100k!

Java 8, 75 59 121 89 bytes
Uses the Euclidean Algorithm and the fact that
LCM(A, B)= A * B / GCD(A, B)

16 bytes off. Thanks to @carusocomputing
Added Multi-Input +62 bytes
32 bytes off. Thanks to @Olivier Grégoire

Code:
public static int lcm(int l, int c){
  for(int i=1;i<=l&&i<=c;++i)
    if (i%l==0&&i%c==0)
      return l*c/i;
}
public static int lcm(int...x){
  int y=x[0];
  for(int j:x){
    y=lcm(j,y);
  }
  return y;
}

Remove line-breaks:
int g(int a,int b){return b<1?a:g(b,a%b);}

l->{int l=1;for(int n:a)l=l*n/g(l,n);return l;}

Technically a snippet, but if you add n->{...} I believe it becomes valid Java 8.

Thanks. I'm trying to get used to see lambda in Java. With lambda you can probably golf some of the for-loop. But I don't know how.

Yeah, all that stuff is an afterthought in Java; you'd likely be better off learning it in Python :).

Unless I'm missing something, this doesn't support more than two inputs

If you compute the GCD, you can golf much more: int g(int a,int b){return b<1?a:g(b,a%b);}. LCM can then become int l(int[]a){int l=1;for(int n:a)l=l*n/g(l,n);return l;}, for a total of 99 bytes.

Your declarations are totally wrong with your try to include my updates. You have simply golfed for Java 8 without checking if anything would compile. If you had compiled, you'd have seen that you need to fully declare int g(int a,int b) and then use it in a Java 8 version of the lcm. Reason: you can't declare g=(a,b)->{} and use it as g(a,b): you can only use it as g.applyAsInt(a,b). That's why I fully declared the function. TLDR: your code doesn't compile.

JavaScript (ES6), 52 bytes
a=>a.reduce((l,n)=>l*n/(g=(m,n)=>n?g(n,m%n):m)(l,n))

I reduced this answer as much as I could but I'm obviously not going to get anywhere near the simplicity of @Hedi's answer.

a=>a.reduce(g=(x,y)=>x*=(x%=y)?g(y,x)/x:1); still longer than Hedi's

CJam, 18 17 16 bytes
1 byte saved thanks to Martin Ender.
Incrementing until the LCM is found.
q~0{)_2$f%:+}g\;

Try it online

I'm not entirely familiar with CJam, but the reusability rule is for functions, not full programs. If your 17-byte solution is a full program that consistently works across runs, it's fine.

MATL, 3 bytes
&Zm

This uses the builtin function with array input.
Try it online!

Brachylog, 17 bytes
,.#>=g:?z:%a#=h0,

Try it online!
Explanation
,.#>=               Output is a strictly positive integer
     g:?z           Zip the Output with the Input
         :%a        Compute Output mod I for each I in the Input
            #=h0,   All results must be equal to 0

C#, 50+18 = 68 bytes
50 bytes for method defintion, +18 bytes for LINQ import.
using System.Linq;int L(int[]n,int i=1)=>n.All(x=>1>i%x)?i:L(n,i+1);

Pretty much the same as a lot of other answers. Counts up recursively until it finds the LCM. I was a bit surprised this didn't get a StackOverflowException, so I also have a non-recursive version which is actually just 1 byte longer.
using System.Linq;n=>{for(int i=1;;i++)if(n.All(x=>1>i%x))return i;};

Ungolfed:
using System.Linq;            // Import LINQ
int L(int[] n, int i = 1) =>  // Function declaration
    n.All(x => 1 > i % x)     // Check if each x in n divides i
        ? i                   // And if so return i
        : L(n, i + 1)         // Otherwise increment i and recurse
;

Perl 6, 10 bytes
{[lcm] @_}

basically the same as:
sub ( *@_ ) { @_.reduce: &infix:< lcm > }

J, 11 bytes
>./&.(_&q:)

There is a solution for 3 bytes using the LCM builtin.
*./

Explanation
>./&.(_&q:)  Input: array of integers A
      _&q:   Get the prime exponents of each integer in A
>./&         Reduce by maximum on the lists
   &. _&q:   Convert the list of exponents back to an integer

*./  Input: array of integers A
  /  Reduce using
*.     LCM

Racket 13 bytes
lcm is a built-in function in Racket:
(apply lcm l)

Testing:
(define (f l)
   (apply lcm l))

(f (list 7 2))
(f (list 8 1))
(f (list 6 4 8))
(f (list 8 2 1 10))
(f (list 9 6 2 1 5))
(f (list 5 5 7 1 1))
(f (list 4 13 8 8 11 1))
(f (list 7 2 2 11 11 8 5))
(f (list 1 6 10 3 4 10 7))
(f (list 5 2 9 10 3 4 4 4 7))
(f (list 9 7 10 9 7 8 5 10 1))

Output:
14
8
24
40
90
35
1144
3080
420
1260
2520

Ahh. How can you use that syntax. I always gave up when I tried to learn Racket.

First word in brackets is a procedure name, rest are its arguments. If an argument is a procedure, it has to be in its own brackets. Values (non-procedures) are written without brackets. I find it to be an excellent general-purpose language with additional advantage of stress on functional programming. Being derived from Lisp, one also gets a sense of covering that area of programming.

I find coding keywords and language to be easier in Racket & Scheme than Lisp.

Yes, but did I said I understand Lisp? I more like languages like Jelly or Java.

Main syntax difference between Java and Racket is f(a, b) vs (f a b), x+y+z vs (+ x y z), x == y vs (eq? x y) and x=2 vs (define x 2), or if already defined, (set! x 2). Also no need to declare types like public static void or int char string etc. Hope that gets you interested in Racket again.

Clojure https://en.wikipedia.org/wiki/Clojure is combination of Lisp and Java.

R, 36 bytes (not builtin)
v=scan();i=1;while(any(i%%v))i=i+1;i

Takes the input. Then tests each positive integer by taking the mod.

I believe you need a cat around  your last i

@Giuseppe when I run it, the value prints fine.

see the discussion here, but I suppose ec=T is fine for +4 rather than +5 for cat().

regardless, this can be golfed down some v=scan();while(any((F=F+1)%%v)){};F with cat() or ec=T making it 40 or 39 bytes, respectively. And +1, very nice approach.

APOL, 49 bytes
v(0 1);v(1 i);w(⊕(ƒ(s(¹) %(⁰ I(∋)))) ∆(0));-(⁰ 1)
This could almost certaintly be made shorter, maybe I'll come back to it later.

Pip, 10 bytes
W$+o%g++oo

Uses the "try every number until one works" strategy. Try it online!
            o is preinitialized to 1, g is list of cmdline args
   o%g      Mod o by each arg
 $+         Sum (truthy if any nonzero, falsy if all zero)
W           Loop while that expression is truthy:
      ++o     Increment o
         o  Autoprint o

Pyth, 9 bytes
.U/*bZibZ

A program that takes input of a list on STDIN and prints the result.
Try it online or verify all test cases
How it works
.U/*bZibZ  Program. Input: Q
.U         Reduce Q by (implicit input fill):
   *bZ      Product of current and next value
  /   ibZ   divided by GCD of current and next value
           Implicitly print

Haskell, 10 bytes
foldr1 lcm

Usage example: foldl1 lcm [5,2,9,10,3,4,4,4,7] -> 1260.

PHP, 42 74 bytes
for(;($p=++$f*$argv[1])%$argv[2];);echo$p;

straight forward:
loop $f from 1 upwards; if $f*$a divides through $b without a remainder, the LCM is found.

I totally had overread the at least ... here´s the code for any number of parameters:
for(;$i<$argc;)for($p=$argv[$i=1]*++$f;++$i<$argc&$p%$argv[$i]<1;);echo$p;

Loop $f from 1 upwards while inner loop has not run to $argc.
Loop $i from 2 to $argc-1 while $f*$argv[1] divides through $argv[$i] without a remainder.
both loops broken: print $f*$argument 1.

Prolog (SWI), 46 bytes
l([],1).
l([X|Y],P):-l(Y,Q),P is X*Q/gcd(X,Q).

Try it online!
Another solution, 59 bytes:
l(A,X):-between(1,inf,X),forall(member(Y,A),X mod Y=:=0),!.

J, 34 bytes
*/@((0 1+])^:(*@+/@:|*/)^:_>./,1:)

A while loop iterating through multiples of the largest number in input.
Try it online!

Scala, 44 bytes
Stream.from(1).find(i=>x.forall(i%_==0)).get

Try it online!

Python 3, 83 bytes
import math,functools as i
t=lambda t:i.reduce(lambda a,b:int(a*b/math.gcd(a,b)),t)

Welcome to PPCG!

You may want to include a link to an online testing site like Try it online! so it's easier for others to verify your answer.

Pyth, 7 bytes
f!s%LTQ

Try it online!

Python 3.9, 20 bytes
import math
math.lcm

Now Python 3.9 has a builtin in math module to calculate LCM of two or more integers.

Rust, 45 bytes
|i:&[_]|(1..).find(|v|i.iter().all(|a|v%a<1))

Try it online!
Iterates over all numbers until finding the first one which is divisible by all the numbers in the given slice. Hey, it saves bytes!

Vyxal, 2 bytes
∆Ŀ

Try it Online!

Ruby, 17 bytes
->x{x.inject:lcm}
Attempt This Online!

PARI/GP, 3 bytes
lcm
Without builtins, 50 bytes:
v->fold((a,b)->for(k=a,a*b,k%b||k%a||return(k)),v)

The forstep version is 1 byte longer. Older versions can shave 2 bytes with | in place of ||.

Thunno 2, 1 byte
ŀ

Try it online!
Non built-in,  6 5  4 bytes:
ƘŒS~

Try it online!
-1 thanks to @Jacob
Explanation
ŀ  # Implicit input. Built-in to calculate LCM. Implicit output.

ƘŒS~  # Implicit input
Ƙ     # Find the first positive integer where:
 Œ    #  The number mod the input (vectorises)
  S~  #  Has a sum of 0 (i.e. it contains only zeros)
      # Implicit output

Replace $% with Œ for -1

@Jacob oh, I got what you're saying now. Yes, that would work because inputs are reusable in Thunno 2. Thanks!

Java 7, 75 bytes
int f(int[]a){int i=1,s=1;for(;s>0;i++){s=0;for(int b:a)s+=i%b;}return--i;}

A simple two-loop method. Start at one and check to see when all the remainders add to zero.
I had to jump through some dumb hoops with s. There's probably a better way to do that, but it's 1:00 AM and it'll have to wait :/

Pyth - 7 6 bytes
No builtin.
*F{sPM

Try it online here.

Fails on [4], or anything else with a repeated prime factor.

PHP, 65 Bytes
<?for($t=1;$t&&++$i;$t=!$t)foreach($_GET as$v)$t*=$i%$v<1;echo$i;

Try it online!
or

for(;++$i;!$t?:die("$i"))for($n=$t=1;$v=$argv[$n++];)$t*=$i%$v<1;

or

<?for($t=1;++$i;$t=!$t?:die("$i"))foreach($_GET as$v)$t*=$i%$v<1;

PHP, 96 Bytes
with 2 loops

while(1<count($a=&$_GET[i])){$e=array_pop($a);for($i=0;($m=++$i*$e)%$a[0];);$a[0]=$m;}echo$a[0];

based on set theory 128 Bytes

$p=array_product($a=$_GET[i]);echo min(array_intersect(...array_map($r=function($n)use($p){return range($n,$p,$n);},$_GET[i])));

R, 30 21 bytes
Using the mLCM function from the numbers package:
numbers::mLCM(scan())

Or without builtins (81 bytes):
L=function(x,y,g=function(x,y,r=x%%y)`if`(r,g(y,r),y))x*y/g(x,y)
Reduce(L,scan())

We first define a function L for the pair-wise LCM and then apply it iteratively using Reduce.

How would this work for testcases with more than 2 numbers as input?

@JarkoDubbeldam Thanks for pointing that out. Missed that part of the spec.

Axiom, 19 bytes
f(x)==reduce(lcm,x)

Could be perhaps better and right but longer
f(x:List PI):PI==reduce(lcm,x)

J, 27 bytes
not using built ins, naive solution
>:0 i.~+/"1 i|"1 0>:i.*/i=.

usage
>:0 i.~+/"1 i|"1 0>:i.*/i=.9 6 2 1 5

returns 90

Japt, 8 bytes
@e!vX}a1

Try it

Perl 5, 52 + 2 (-pa) = 54 bytes
$r=$\=$_;while($r){$r=0;$r||=$\%$_ for@F;$r&&$\++}}{

Try it online!

A little late to the party, but I didn't see an AWK answer.
AWK, 49 bytes
{for(x=1;x&&++m;)for(x=i=0;i++<NF;)x+=m%$i;$0=m}1

Try it online!
NOTE: The link has 2 extra bytes m= in front of the x=1;x... to simplify testing/allow multiple inputs/outputs. However, the m= fails for single/repeated input value of 1. The code as written handles 1 fine.

Jq 1.5, 67 bytes
Not very smart.  Just tests each i from 2 to product of numbers.
first(range(2;1+reduce.[]as$x(1;.*$x))as$i|select(all($i%.==0))|$i)

More efficient but longer:
def g(a;b):if b<1then a else g(b;a%b)end;reduce.[]as$x(1;.*$x/g(.;$x))

Try it online!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Unlucky Numbers!
Things to know:
First, lucky numbers.
Lucky numbers are generated like so:
Take all the natural numbers:
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20...

Then, remove each second number.
1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39...

Now, 3 is safe.
Remove every 3rd number:
1, 3, 7, 9, 13, 15, 19, 21, 25, 27, 31, 33, 37, 39, 43, 45, 49, 51, 55, 59...

Now, 7 is safe.
Remove every 7th number.
Continue, and remove every nth number, where n is the first safe number after an elimination.
The final list of safe numbers is the lucky numbers.

The unlucky numbers is composed of separate lists of numbers, which are [U1, U2, U3... Un].
U1 is the first set of numbers removed from the lucky "candidates", so they are:
2, 4, 6, 8, 10, 12, 14, 16, 18, 20...

U2 is the second set of numbers removed:
5, 11, 17, 23, 29, 35, 41, 47, 53, 59...

And so on and so forth (U3 is the third list, U4 is the fourth, etc.)

Challenge:
Your task is, when given two inputs m and n, generate the mth number in the list Un.
Example inputs and outputs:
(5, 2) -> 29
(10, 1) -> 20

Specs:

Your program must work for m up to 1e6, and n up to 100.

You are guaranteed that both m and n are positive integers.
If you're curious, U(1e6, 100) = 5,333,213,163. (Thank you @pacholik!)

Your program must compute that within 1 day on a reasonable modern computer.

This is code-golf, so shortest code in bytes wins!
PS: It would be nice if someone came up with a general formula for generating these. If you do have a formula, please put it in your answer!

On OEIS: A219178 and A255543

Also A050505 (the complement of the lucky numbers).

Related.

Have you implemented code that can actually perform (1e6,1e6)?

... and what is the result for (1e6,1e6)?

Its been 10 min already. Maybe the computer has to be put somewhere cold first

Ah crap, sorry guys, I changed the thing so that it's easier.

@JonathanAllan I'm not sure... I'll probably extend this challenge to a day. I'm not extending it to "as long as possible" though, since that's just not good enough... I believe that pacholik's answer (or any other answer, in fact) could be optimised.

If you're going to have a time requirement, you need to specify the timing environment (such as your machine, a freely-available online VM, or "a reasonable modern computer").

Is it acceptable for the function not to work for the n=1 case? As this is special-- for all other cases, the 0-based index of the next lucky number is n-1.

@Myridium I'm going to have to say "no", but post both versions of your code (the one that works for n=1 and the one that doesn't).

@Mego Ah... I thought the "reasonable modern computer" is implied if you put in a time... Well, it's fixed now.

Aren't these "lucky numbers" just the sieve of Eratosthenes for generating prime numbers?

CJam, 74 bytes
ri0Lri:U{1$W%{1$\(1e>/+}/)+}/2t:A0@{@:B:(_0#):D{D(_A=tD<BD>+}&@)@DU=-}h]1=

Try it online! Will time out for larger cases, more on time constraints below.

Explanation:
Our program shamelessly borrows for aditsu's code to generate a list of N lucky numbers, replacing 1 with a 2 gives the increment in each phase of the sieve. The remaining code decrements on every element until a zero is found (by slicing and appending an un-decremented tail) and effectively counts the steps in each of N phases of the sieve at once.
ri                               e# read M
0Lri:U{1$W%{1$\(1e>/+}/)+}/2t:A  e# list steps (also becomes B)
0@                               e# arrange stack [B I M]
{                                e# while M
   @:B                           e#   get current B
   :(                            e#   decrement every element in B
   _0#):D                        e#   find first 0
   {                             e#   if there is a 0
      D(_A=t                     e#     reset that element in B
      D<BD>+                     e#     replace tail after 0
   }&                            e#   end if
   @)                            e#   increment I
   @DU=-                         e#   decrement M if N-th phase of sieve
}h                               e# end loop
]1=                              e# return I

Timing:
If you absolutely must run the program in browser for larger numbers you can use this interpreter and allow the script to continue if prompted, but this maybe too slow to qualify. Using (M,N)=(100,100) takes ~247s. The programs iteration is relatively linear in terms of M, so computing (1e6,100) could take ~29 days.
Using the shell interpreter on a PC the program computes (100,100) in ~6s and computes (1e4,100) in ~463s. The program should be able to compute (1e6,100) in ~13-17hrs. In this case I'll assume the program qualifies.
Note all times were rounded up in both measurements and calculations.

Python 3, 170
from itertools import*
def L(n,k=1):
 if n<2:yield from count(2+k,2)
 t=L(n-1);l=next(t)
 for i in t:
  n+=1
  if(n%l>0)==k:yield i
U=lambda m,n:sum(islice(L(n,0),m-1,m))

Function L generates the row of possible lucky numbers (if k is True) or Un (if False). Evaluated lazily (so I don't have to generate n-1 infinite lists if I want Un).
Run function U.
Speed
U(1,000,000; 100) takes about 1h 45min to run on my machine with PyPy. I suspect some four hours with CPython. (Yes, 4h 20min to be precise.)
If I used a list instead of generators, I might gain some speed, but I would need a list of greater size than Python allows me. And if it did, it would need dozens of gigabytes of RAM.

Yes, and U(1,000,000; 100) = 5,333,213,163.

Should be valid now.

Perl, 87 85 82 81 bytes
Includes +4 for -pX
Give input on STDIN as one line with n first (notice this is the reverse of the order suggested in the challenge). So to calculate U(1000000, 100):
unlucky.pl <<< "100 1000000"

Algorithm based on aditsu's lucky numbers answer
The time complexity is O(n^2) so it's rather fast for the required range. The 100, 1000000 case gives 5333213163 in 0.7 seconds. Due to the problems perl has with do$0 based recursion it uses a lot of memory. Rewriting it as a function would make the memory use O(n) but is a number of bytes longer
unlucky.pl:
#!/usr/bin/perl -pX
$_=$a{$_}||=/\d+$/>--$_?2*$&+$^S:($_=$_.A.(do$0,$^S?0|$&+$&/~-$_:$&*$_-1),do$0)

This works as shown, but use literal ^S to get the claimed score.
I am not aware of any earlier use of $^S in perlgolf.

But how long does this take for (1e6,100)?

@Myridium Due to the memory explosion caused by do$0 it is basically unreachable on any realistic computer. But if that much memory existed about 2 years. I haven't really written out and tested a normal subroutine based version, but I would expect that to finish in a few months and run even on computers with very little memory. So it's a good thing these values are not in the required range for this challenge.

Isn't the challenge to compute for (1e6,100) within a day? What do you mean these values are not required?

@Myridium Notice that in my program n and m are given in reverse order. The 100 1000000 input calculatesU(1000000, 100) and gives 5,333,213,163 in 0.7 seconds. It is by far the fastest program of these currently posted

Ah okay, I expected (100,1e6) to be much faster than (1e6,100), and thought this was the explanation for the lightning fast 0.7 seconds!

I'm still amazed that you can get an answer that runs so fast. Can you give more of an explanation for those of us who don't understand Perl?

Haskell
Not able to compute for n=1: 175 160 bytes
When compiled, it took my computer 2h 35m to compute for an input of (1000000,100) using this:
n#s=y:(n#p)where y:p=drop(n-1)s
n%s=f n s$[]where f n s=(take(n-1)s++).f n(drop n s)
l 2=[1,3..]
l m=((l$m-1)!!(m-2))%(l$m-1)
m?n=(((l n)!!(n-1))#(l$n))!!(m-1)

I tried ridding the where modules, but they seem to affect the speed and I'm not sure why... But I think there is more pruning to be done here.
The method to use is m?n for querying the answer given an m and n.
Ungolfed
everynth n xs = y:(everynth n ys) -- Takes every nth element from a list 'xs'
  where y:ys = drop (n-1) xs

skipeverynth n xs = f' n xs $ []  -- Removes every nth element from a list 'xs'
  where f' n xs = (take (n-1) xs ++) . f' n (drop n xs)

l 2 = [1,3..] -- The base case of the list of lucky numbers for 'n=2'
l m = skipeverynth ((l$m-1)!!(m-2)) (l$m-1) -- Recursively defining next case as being the last one with every 'ath' element skipped. Here, 'a' is the (m-1)th elemnent of the (l (m-1)) list.
ul m = everynth ((l m)!!(m-1)) (l$m) -- This is not used other than to compute the final, required unlucky number list. It picks out every 'ath' element.

ans m n = (ul n)!!(m-1) -- The function giving the answer.

I reckon it may be possible to combine the 'skipeverynth' and 'everynth' functions into a single function which returns a pair.
I used this kind person's code for skipping every nth element. I did it myself a few times, but it was always much more inefficient and I couldn't figure out why.
Able to compute for all n: 170 bytes
This is basically the same, but a couple of max functions had to be thrown in to handle the special case of n=1.
n#s=y:(n#p)where y:p=drop(n-1)s
n%s=f n s$[]where f n s=(take(n-1)s++).f n(drop n s)
l 1=[1..]
l m=((l$m-1)!!(max 1$m-2))%(l$m-1)
m?n=(((l n)!!(max 1$n-1))#(l$n))!!(m-1)

R 82 bytes
f<-function(m,n){a=1:2e8
i=1
while(i<n){a=c(0,a)[c(F,rep(T,i))]
i=i+1}
a[(n+1)*m]}

Usage
f(5,2)
Returns 29

This needs to have a large enough vector to start with so there are enough numbers left to return the value. The vector created is already about 800Mb and the function can handle upto m=1e4 and n=100 so still well short of the goal.
To create a large enough vector to calculate f(1e6,100) would take a starting vector of 1:2e10.  Due to Rs data allocation procedures this creates a vector >70Gb which can't be run on any computer I know although the code would run.
Error: cannot allocate vector of size 74.5 Gb

For reference f(1e4,100) runs in about in about 30 seconds.  Based on this and a couple smaller tests f(1e6,100) would take about an hour.

Marking your answer as non-competing does not excuse it from failing to meet the challenge requirements.

@Mego Ive seen plenty of answers that fail to meet requirements (there is at least 1 other in this challenge).  I coded it and I feel it meets the spirit of the coding request, I also clearly stated where it fell short.  Also as you mention in your comments to the question it doesnt state what type of computer it needs to test on.  Im sure there are computers out there that could write 7 Gb to memory and process it.  The one I was on couldnt do it but i still wanted to post and i thought the clear statement was a valid compromise.

We have a clear policy about answers not meeting the challenge specification. That being said, I'm not sure why you labelled your answer as non-competing. If I understand correctly, this should work given enough memory, but you couldn't test it because you don't have enough RAM. Is that correct?

@dennis then i suggest you enforce it.  As i mentioned there is at least one answer here, about half the answers on the pyramid matrix question dont meet the specs correctly plus countless other questions.  I could also just take away the non-competing header if it makes people happy.  I just did it for fun and as i couldnt meet the specs i thought it was fair to let people know. And thinking about it it was a factor of 100 i was off by so it would need about 70Gb of ram.  I dont plan on learning jelly or another golfing language so anything i do is really just for fun not winning.

1. This policy is being enforced, but four moderators cannot test all answers on the site. If you find a submission that doesn't comply with the rules, be flag it for moderator attention so we can take a look. 2. You don't have to learn a golfing language to participate. Production languages like R are just as welcome. I post Python answers myself on a regular basis.

3. The spec doesn't mention any memory limits, but there is a 24 hour time limit. In the absence of a computer with 70 GiB (or did you mean gigabits) to test this on, it's hard to determine if this answer is valid or not. I suggest trying to extrapolate the runtime as well as you can. If it's less than a day, remove the non-competing header and include your extrapolation in the post. If it takes longer, your submission should be optimized or removed.

Racket 332 bytes
(λ(N m n)(let loop((l(filter odd?(range 1 N)))(i 1))(define x (list-ref l i))(if(= i (sub1 n))
(begin(set! l(for/list((j(length l))#:when(= 0(modulo(add1 j)x)))(list-ref l j)))(list-ref l(sub1 m)))
(begin(set! l(for/list((j(length l))#:unless(= 0(modulo(add1 j) x)))(list-ref l j)))(if(>= i(sub1 (length l)))l
(loop l(add1 i)))))))

Ungolfed version:
(define f
  (λ(N m n)
    (let loop ((l (filter odd? (range 1 N))) (i 1))
      (define x (list-ref l i))
      (if (= i (sub1 n))
          (begin (set! l (for/list ((j (length l))
                                   #:when (= 0 (modulo (add1 j) x)))
                           (list-ref l j)))
                 (list-ref l (sub1 m)))
          (begin (set! l (for/list ((j (length l))
                                   #:unless (= 0 (modulo (add1 j) x)))
                           (list-ref l j)))
                 (if (>= i (sub1 (length l)))
                     l
                     (loop l (add1 i))))))))

Testing:
(f 100 5 2)

Output:
29

Clojure, 221 bytes
Mighty long but handles the case (f 1). Without that special case it was 183 bytes. This was too much effort not to have it posted.
(defn f([n](if(< n 2)(take-nth 2(drop 2(range)))(f n 1(take-nth 2(rest(range))))))([n i c](if (< n 2)c(let[N(first(drop i c))F #((if(= 2 n)= >)(mod(inc %)N)0)](f(dec n)(inc i)(filter some?(map-indexed #(if(F %)%2)c)))))))

Sample outputs:
(pprint (map #(take 10 (f %)) (range 1 10)))
((2 4 6 8 10 12 14 16 18 20)
 (5 11 17 23 29 35 41 47 53 59)
 (19 39 61 81 103 123 145 165 187 207)
 (27 57 91 121 153 183 217 247 279 309)
 (45 97 147 199 253 301 351 403 453 507)
 (55 117 181 243 315 379 441 505 571 633)
 (85 177 277 369 471 567 663 757 853 949)
 (109 225 345 465 589 705 829 945 1063 1185)
 (139 295 447 603 765 913 1075 1227 1377 1537))

1000000 100 case was calculated in about 4.7 hours, at least it didn't crash.
java -jar target\stackoverflow-0.0.1-SNAPSHOT-standalone.jar 1000000 100
5333213163
"Elapsed time: 1.7227805535565E7 msecs"

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/