text:
Benfords Law of Words
Background
Benford's Law is freaky!
Of all the numbers in the world, roughly 30% of them start with a 1! 17.6% start with a 2, 12.5% start with a 3, and so on, and so on.
For example, take a look at the following graph. Take the largest 120000 towns in the world, take their altitude, and voila - they obey Benford's law. Divide these numbers by ~3 to convert them into meters, and amazingly, they still obey this law!

In fact, it can be generalized past the first digit:

Source

Challenge
So I wondered, how does this apply to letters and words?
Your challenge is to parse the big list of words below and formulate the table above (printing a matrix will suffice). Unlike this work, you will not only need to find the occurrence of the first letter, but also the second, third, fourth, and fifth. If a word does not have the nth digit, you can ignore that word (i.e. if you are compiling the 5th column (looking at the fifth digit), you should ignore all words less than 5 characters long)
Big List of Words: https://raw.githubusercontent.com/kevina/wordlist/master/alt12dicts/2of4brif.txt
Due to suggestion in the comments, this contest is now a code golf competiton, so shortest code in bytes wins. The entry must be a complete program and must output the table specified above. Built-ins are allowed.
Good luck!

I think it's confusing that you have a table of numbers and talk about Benford's Law, but the challenge isn't about that at all. (Benford's Law applies to numbers, not to words.)

Can I just output a 2D matrix of the data (percentages)?

@mbomb007 Surely, I'd assume the rows are a-z, and the columns are char# 1-5? Preferably, it would say what the rows/columns are next to/on top of the data

Incidentally, Benford's law comes from the fact that units are arbitrary, and so the distribution should stay the same if you change the units. Since words don't have units, and most certainly can't be converted to 'different units', there's really no way to have an equivalent pattern for words. On the other hand, there might be something possible within cryptography... (that is, cryptography as the equivalent of a change of units)

Challenge seems to relate more to Zipf's Law

R: 88, 95, or 126 bytes
z=sapply(readr::read_lines("http://tinyurl.com/pshoqyo"),Vectorize(substr),1:5,1:5)
y=apply(z,1,table,exclude="")
y/colSums(y)

That's 126 bytes where that the data is downloaded from the provided URL (a tinyurl equivalent to be exact).
I can shorten the code to 88 bytes if you allow to read the input from stdin:
z=sapply(scan(,""),Vectorize(substr),1:5,1:5)
y=apply(z,1,table,exclude="")
y/colSums(y)

or 95 bytes if the data is provided via a t.txt file:
z=sapply(scan("t.txt",""),Vectorize(substr),1:5,1:5)
y=apply(z,1,table,exclude="")
y/colSums(y)

The output:
          aah         <NA>        <NA>        <NA>         <NA>
a 0.054250087 0.1366519284 0.091410860 0.062576399 0.0656915218
b 0.057777336 0.0070112047 0.023141714 0.020833697 0.0171560104
c 0.099582311 0.0178502654 0.053853798 0.046119198 0.0308013314
d 0.065925417 0.0080894018 0.032457317 0.040240449 0.0279619439
e 0.044177897 0.1499494924 0.068491563 0.115709739 0.1336258142
f 0.045208406 0.0035603690 0.019392694 0.018553559 0.0122387071
g 0.033566827 0.0028011669 0.026038614 0.031346432 0.0212462947
h 0.035818471 0.0396356269 0.009065709 0.021577492 0.0288307086
i 0.042716723 0.1027737583 0.061586103 0.079272029 0.1020188291
j 0.009065709 0.0002815175 0.002997334 0.001872970 0.0003181567
k 0.006557703 0.0032954113 0.004342637 0.025971634 0.0180791157
l 0.030602613 0.0469071140 0.057569618 0.058683031 0.0625465746
m 0.050139230 0.0185368141 0.045014732 0.032771954 0.0237633928
n 0.017230697 0.0724559354 0.080629937 0.054978721 0.0516144003
o 0.026307990 0.1417192442 0.067001176 0.058609030 0.0616554195
p 0.082236243 0.0202858231 0.041453955 0.040891509 0.0257849684
q 0.004835478 0.0032155407 0.002880155 0.002475636 0.0009935913
r 0.056736060 0.0873758770 0.099060304 0.069567953 0.0749333466
s 0.124834642 0.0096061647 0.069021478 0.057992614 0.0674600544
t 0.053731760 0.0237137132 0.066835577 0.085112378 0.0682529848
u 0.022802921 0.0768211701 0.043144600 0.036018688 0.0333164804
v 0.014224916 0.0093814228 0.018101442 0.014540002 0.0068392204
w 0.026536498 0.0070329376 0.010477867 0.009521917 0.0073194562
x 0.000184196 0.0124653498 0.004669879 0.001490387 0.0012265464
y 0.003312471 0.0105155083 0.009124480 0.006613406 0.0145012475
z 0.001506947 0.0003146373 0.003828814 0.004336978 0.0029114873

You seem to have the shortest answer. Please provide a printout and I will accept your solution!

Mathematica 246 bytes
The probabilities are based on all the words in the file.
p=Prepend;t=Transpose;d="Digit";
p[t[p[N[#/Total@#,5]&/@ t[Sort[Cases[Tally[Position[Characters
@Import["t.txt","List"],#][[All,2]]],{n_,_} /;n<6]]/.{_,k_}->k&/@
(c=CharacterRange["a","z"])],c]],{d,"1st "<> d,"2nd "<>d,"3rd "<>d,"4th "<>d,"5th "<>d}]
//Grid

In the given list of 60387 words, the occurrences are distributed as follows. Letters "s" and "c" are the most likely to appear at the beginning of a word (7455 and 6008, respectively). Only 11 words begin with the letter "x".

Without headers in table  162 bytes
t=Transpose;t[N[#/Total@#]&/@t[Sort[Cases[Tally[Position[Characters@Import["t.txt", "List"], #][[All,2]]],{n_,_} /;n<6]]/.{_,k_}->k&/@CharacterRange["a","z"]]]//Grid

Nice work. Your numbers match mine, too. https://docs.google.com/spreadsheets/d/1uBH53giSP_2l7Xm97jJ9hxi5CSpaDMEC0mPLXrCvMo0 . Good job!

MATLAB, 113 117 bytes
I made this a script that loads our text file, conveniently called t.txt, and prints the table without headers to the screen.
Old version (113 bytes) contained an error:
D=max(1,strvcat(importdata('t.txt'))-95);F=[];for n=1:5,F=[F,accumarray(D(:,n),1)/length(D)];end;disp(F(2:end,:))

New corrected version is slightly longer unfortunately.
D=max(1,strvcat(importdata('t.txt'))-95);F=[];for n=1:5,E=D(:,n);F=[F,accumarray(E,1)/sum(E~=1)];end;disp(F(2:end,:))

Giving the output:
0.0543    0.1367    0.0914    0.0626    0.0657
0.0578    0.0070    0.0229    0.0200    0.0181
0.0995    0.0177    0.0512    0.0466    0.0324
0.0652    0.0077    0.0325    0.0407    0.0294
0.0420    0.1499    0.0686    0.1169    0.1391
0.0452    0.0036    0.0194    0.0186    0.0122
0.0336    0.0028    0.0258    0.0301    0.0224
0.0358    0.0392    0.0086    0.0218    0.0304
0.0422    0.0976    0.0616    0.0802    0.1073
0.0086    0.0003    0.0030    0.0019    0.0003
0.0066    0.0033    0.0043    0.0260    0.0181
0.0306    0.0469    0.0570    0.0564    0.0658
0.0501    0.0183    0.0428    0.0331    0.0250
0.0170    0.0688    0.0807    0.0556    0.0543
0.0250    0.1417    0.0671    0.0592    0.0642
0.0822    0.0203    0.0415    0.0409    0.0258
0.0048    0.0032    0.0029    0.0024    0.0010
0.0567    0.0864    0.0942    0.0703    0.0789
0.1235    0.0091    0.0691    0.0586    0.0710
0.0510    0.0237    0.0669    0.0860    0.0711
0.0228    0.0768    0.0431    0.0360    0.0333
0.0142    0.0094    0.0179    0.0140    0.0072
0.0265    0.0070    0.0100    0.0096    0.0077
0.0002    0.0118    0.0047    0.0015    0.0013
0.0031    0.0105    0.0091    0.0067    0.0151
0.0015    0.0003    0.0038    0.0043    0.0029

Nice use of accumarray!

Kind of cheating by downloading the file first, but that's alright. I bet you can remove the extension and save four chars.

@dberm22 Do you mean it should be obtained directly from the intenet?

It looks like you are not disregarding short in the count of each position, so the computed frequencies are too low

@LuisMendo thanks for pointing that out. Fixed it now at the cost of 4 bytes.

@dberm22 I guess I'm not the only one doing so. I like to keep it a .txt file though :)

@slvrbld Now that I see my comment, I see I didn't explain myself very well, but yes, that's the correction I meant :-) You had my upvote already, so I can't upvote now

Python 3, 143 129 bytes
This is taking a long time to run on the provided data. I have no idea if it will finish any time soon.
I think the interpreter I'm using is refusing to run the program because of the input size. My program did the first 1000 words in 1 second.
Edit: Now stops at 5 letters/columns.
s=input().split()
l=96
while l<122:l+=1;print([sum(i<len(w)and w[i]==chr(l)for w in s)/sum(i<len(w)for w in s)for i in range(5)])

With the letters on the left (136):
s=input().split()
l=96
while l<122:l+=1;print(chr(l),[sum(i<len(w)and w[i]==chr(l)for w in s)/sum(i<len(w)for w in s)for i in range(5)])

Example Output
This is the output for input of hello\nworld:
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.5]
[0.0, 0.5, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.5, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.5, 1.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.5, 0.0, 0.0, 0.5]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.5, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.5, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 0.0, 0.0, 0.0, 0.0]

Output for the first 2000 words (not so nice to look at :/):
[1.0, 0.0015, 0.082164328657314628, 0.045523520485584217, 0.067875647668393782]
[0.0, 0.11899999999999999, 0.027555110220440882, 0.0096105209914011131, 0.017616580310880828]
[0.0, 0.1565, 0.096192384769539077, 0.015680323722812341, 0.046632124352331605]
[0.0, 0.14499999999999999, 0.03406813627254509, 0.019221041982802226, 0.042487046632124353]
[0.0, 0.019, 0.04458917835671343, 0.17653009610520992, 0.098963730569948186]
[0.0, 0.050000000000000003, 0.033066132264529056, 0.0030349013657056147, 0.0020725388601036268]
[0.0, 0.049000000000000002, 0.037575150300601205, 0.0096105209914011131, 0.03367875647668394]
[0.0, 0.0030000000000000001, 0.016533066132264528, 0.032372281234193223, 0.021243523316062177]
[0.0, 0.052499999999999998, 0.045591182364729456, 0.13606474456246839, 0.09689119170984456]
[0.0, 0.00050000000000000001, 0.025050100200400802, 0.0, 0.0]
[0.0, 0.00050000000000000001, 0.0075150300601202402, 0.00050581689428426911, 0.00051813471502590671]
[0.0, 0.123, 0.050601202404809621, 0.084977238239757211, 0.034715025906735753]
[0.0, 0.094, 0.036072144288577156, 0.027314112291350532, 0.030569948186528497]
[0.0, 0.1865, 0.03406813627254509, 0.030349013657056147, 0.080310880829015538]
[0.0, 0.0, 0.077655310621242479, 0.11987860394537178, 0.053886010362694303]
[0.0, 0.0, 0.027555110220440882, 0.018715225088517955, 0.013471502590673576]
[0.0, 0.0, 0.014529058116232466, 0.0015174506828528073, 0.0041450777202072537]
[0.0, 0.0, 0.095190380761523044, 0.076884167931208905, 0.11968911917098446]
[0.0, 0.0, 0.039579158316633264, 0.036418816388467376, 0.078238341968911912]
[0.0, 0.0, 0.10671342685370741, 0.039453717754172987, 0.077720207253886009]
[0.0, 0.0, 0.030561122244488977, 0.098128477491148211, 0.029015544041450778]
[0.0, 0.0, 0.033567134268537073, 0.0015174506828528073, 0.013989637305699482]
[0.0, 0.0, 0.00050100200400801599, 0.0075872534142640367, 0.0041450777202072537]
[0.0, 0.0, 0.0, 0.0, 0.0067357512953367879]
[0.0, 0.0, 0.002004008016032064, 0.0040465351542741529, 0.024352331606217616]
[0.0, 0.0, 0.0015030060120240481, 0.0050581689428426911, 0.0010362694300518134]

Ungolfed
s=input().split()
m=[]
l=96
while l<122:
    l+=1;r=[]
    for i in range(max(map(len,s))):                # Max length of words in list
        L=sum(i<len(w)for w in s)                   # How many words of this length
        f=sum(i<len(w)and w[i]==chr(l)for w in s)   # Number of char in that pos
        r+=[f/L]
    m+=[r]
for r in m:print(r)

What percent of the words began with "a"?  (I'm having trouble understanding the table.)

@DavidCarraher 100%. I only have output for the first 2000 words (all beginning with a). Neither interpreter I tried (repl.it and ideone) will work for much larger input.

I see. Why not save the file on your hard disk, then import the file and work on it?

@DavidCarraher Because many people cough are at work cough cough. >.>

bash with gawk 4 and sort, 125
Pretty much what awk was made for
awk '{for(;NF;c[NF--]++)a[$NF][NF]++}END{for(i in a){printf i;for(j=0;j++<5;)printf" %.9f",a[i][j]/c[j];print""}}' FS= wordlist.txt|sort

"wordlist.txt" needs to be replaced by the name of your file containing the list of words, and I counted the whole filename as one character, because it could be ;)
Be sure to leave the space between FS= and the filename.
It takes into account, that not all words have five letters. So for the average of the second to fifth position it divides only by the number of words with at least that much letters.
awk part readable
{
    for(;NF;c[NF--]++)    # count number of words with at least that length
        a[$NF][NF]++      # count occurences of character at that position
}

END{
    for(i in a)
    {
        printf i;
        for(j=0;j++<5;)
            printf" %.5f",a[i][j]/c[j];    # print averages
        print""
    }
}

You can easily utilize the sort to gather some information. For instance the option -rk2 sorts by the most common letter in the first position, -rk3 sorts by the most common letter in the second position and so on.
Output without sort options

a 0.054250087 0.136651928 0.091410860 0.062576399 0.065691522
b 0.057777336 0.007004819 0.022906584 0.020010382 0.018061682
c 0.099491612 0.017652806 0.051200027 0.046635074 0.032427344
d 0.065196151 0.007683773 0.032486906 0.040690567 0.029411252
e 0.041962674 0.149949492 0.068554001 0.116897470 0.139123764
f 0.045208406 0.003560369 0.019392694 0.018553559 0.012238707
g 0.033566827 0.002798616 0.025774050 0.030107671 0.022367893
h 0.035785848 0.039197178 0.008618975 0.021818852 0.030352691
i 0.042244192 0.097620349 0.061642246 0.080158743 0.107306613
j 0.008611125 0.000281518 0.003000066 0.001892195 0.000331247
k 0.006557703 0.003295411 0.004342637 0.025971634 0.018079116
l 0.030602613 0.046864391 0.056984685 0.056363971 0.065848428
m 0.050093563 0.018331760 0.042796526 0.033138532 0.025017870
n 0.017040091 0.068822760 0.080703441 0.055593697 0.054289649
o 0.024988822 0.141719244 0.067062256 0.059210636 0.064192193
p 0.082236243 0.020285823 0.041453955 0.040891509 0.025784968
q 0.004835478 0.003212612 0.002850892 0.002377803 0.001046043
r 0.056684386 0.086409327 0.094178877 0.070346121 0.078889102
s 0.123453723 0.009124480 0.069084400 0.058641303 0.070956607
t 0.051037475 0.023713713 0.066896506 0.085986035 0.071061211
u 0.022802921 0.076821170 0.043144600 0.036018688 0.033316480
v 0.014224916 0.009372878 0.017917523 0.013965405 0.007200265
w 0.026512329 0.006955139 0.009961546 0.009628426 0.007705853
x 0.000182158 0.011840297 0.004674136 0.001507058 0.001290120
y 0.003146373 0.010515508 0.009132799 0.006681291 0.015097892
z 0.001506947 0.000314637 0.003828814 0.004336978 0.002911487

Output sorted after occurrence as first letter

s 0.123453723 0.009124480 0.069084400 0.058641303 0.070956607
c 0.099491612 0.017652806 0.051200027 0.046635074 0.032427344
p 0.082236243 0.020285823 0.041453955 0.040891509 0.025784968
d 0.065196151 0.007683773 0.032486906 0.040690567 0.029411252
b 0.057777336 0.007004819 0.022906584 0.020010382 0.018061682
r 0.056684386 0.086409327 0.094178877 0.070346121 0.078889102
a 0.054250087 0.136651928 0.091410860 0.062576399 0.065691522
t 0.051037475 0.023713713 0.066896506 0.085986035 0.071061211
m 0.050093563 0.018331760 0.042796526 0.033138532 0.025017870
f 0.045208406 0.003560369 0.019392694 0.018553559 0.012238707
i 0.042244192 0.097620349 0.061642246 0.080158743 0.107306613
e 0.041962674 0.149949492 0.068554001 0.116897470 0.139123764
h 0.035785848 0.039197178 0.008618975 0.021818852 0.030352691
g 0.033566827 0.002798616 0.025774050 0.030107671 0.022367893
l 0.030602613 0.046864391 0.056984685 0.056363971 0.065848428
w 0.026512329 0.006955139 0.009961546 0.009628426 0.007705853
o 0.024988822 0.141719244 0.067062256 0.059210636 0.064192193
u 0.022802921 0.076821170 0.043144600 0.036018688 0.033316480
n 0.017040091 0.068822760 0.080703441 0.055593697 0.054289649
v 0.014224916 0.009372878 0.017917523 0.013965405 0.007200265
j 0.008611125 0.000281518 0.003000066 0.001892195 0.000331247
k 0.006557703 0.003295411 0.004342637 0.025971634 0.018079116
q 0.004835478 0.003212612 0.002850892 0.002377803 0.001046043
y 0.003146373 0.010515508 0.009132799 0.006681291 0.015097892
z 0.001506947 0.000314637 0.003828814 0.004336978 0.002911487
x 0.000182158 0.011840297 0.004674136 0.001507058 0.001290120

Second letter

e 0.041962674 0.149949492 0.068554001 0.116897470 0.139123764
o 0.024988822 0.141719244 0.067062256 0.059210636 0.064192193
a 0.054250087 0.136651928 0.091410860 0.062576399 0.065691522
i 0.042244192 0.097620349 0.061642246 0.080158743 0.107306613
r 0.056684386 0.086409327 0.094178877 0.070346121 0.078889102

Third letter

r 0.056684386 0.086409327 0.094178877 0.070346121 0.078889102
a 0.054250087 0.136651928 0.091410860 0.062576399 0.065691522
n 0.017040091 0.068822760 0.080703441 0.055593697 0.054289649
s 0.123453723 0.009124480 0.069084400 0.058641303 0.070956607
e 0.041962674 0.149949492 0.068554001 0.116897470 0.139123764

Fourth letter

e 0.041962674 0.149949492 0.068554001 0.116897470 0.139123764
t 0.051037475 0.023713713 0.066896506 0.085986035 0.071061211
i 0.042244192 0.097620349 0.061642246 0.080158743 0.107306613
r 0.056684386 0.086409327 0.094178877 0.070346121 0.078889102
a 0.054250087 0.136651928 0.091410860 0.062576399 0.065691522

Fifth letter

e 0.041962674 0.149949492 0.068554001 0.116897470 0.139123764
i 0.042244192 0.097620349 0.061642246 0.080158743 0.107306613
r 0.056684386 0.086409327 0.094178877 0.070346121 0.078889102
t 0.051037475 0.023713713 0.066896506 0.085986035 0.071061211
s 0.123453723 0.009124480 0.069084400 0.058641303 0.070956607

So it looks like there is no Benfords Law of Words ;)

Great outputs/ sorting. It certainly looks like there is no Benford's Law of Words. Oh well =/

Well, thanks. I was forced to use the formatting string there, since some averages were too short for just using tab, which would have messed up the whole table. About the law: I like it netter that way. With numbers it is at least somehow intuitively comprehensible. With letters it would be only spooky. ;)

Dyalog APL (76)
⎕ML←3⋄L{R÷+⌿R←0 1↓K[⍋⊃K←,∘≢⌸⍺⌷¨⍵;]}¨(↓(L←⍳5)∘.≤≢¨G)/¨⊂G←W⊂⍨10≠W←83 ¯1⎕MAP'w'

This assumes the input is in a file called w in the working directory.
Output:
      ⎕ML←3⋄L{R÷+⌿R←0 1↓K[⍋⊃K←,∘≢⌸⍺⌷¨⍵;]}¨(↓(L←⍳5)∘.≤≢¨G)/¨⊂G←W⊂⍨10≠W←83 ¯1⎕MAP'w'
 0.05425008694    0.1366519284     0.09141085991   0.06257639947   0.06569152182
 0.05777733618    0.007004818918   0.02290658357   0.02001038196   0.01806168169
 0.09949161243    0.01765280607    0.05120002652   0.04663507426   0.03242734357
 0.06519615149    0.007683772997   0.03248690579   0.04069056749   0.02941125194
 0.04196267409    0.1499494924     0.06855400119   0.1168974698    0.1391237644
 0.04520840578    0.003560368954   0.01939269376   0.01855355917   0.01223870709
 0.0335668273     0.002798615596   0.02577405026   0.03010767093   0.02236789344
 0.03578584795    0.0391971782     0.008618975005  0.02181885162   0.03035269095
 0.04224419163    0.09762034875    0.06164224624   0.08015874345   0.1073066127
 0.008611124911   0.0002815175452  0.0030000663    0.001892195114  0.000331247058
 0.006557702817   0.003295411264   0.004342637406  0.02597163382   0.01807911574
 0.03060261315    0.04686439134    0.05698468474   0.05636397127   0.06584842832
 0.05009356318    0.01833176015    0.04279652589   0.03313853213   0.02501786991
 0.01704009141    0.06882275987    0.08070344096   0.05559369715   0.0542896494
 0.0249888221     0.1417192442     0.06706225552   0.05921063648   0.06419219303
 0.0822362429     0.02028582311    0.04145395478   0.04089150857   0.02578496836
 0.004835477835   0.003212611986   0.002850891732  0.002377802709  0.001046043341
 0.05668438571    0.08640932651    0.09417887688   0.070346121     0.07888910197
 0.1234537235     0.009124480435   0.06908439966   0.05864130344   0.07095660664
 0.05103747495    0.02371371322    0.066896506     0.0859860346    0.07106121097
 0.02280292116    0.07682117012    0.04314459988   0.03601868752   0.03331648041
 0.01422491596    0.009372878269   0.01791752304   0.01396540465   0.007200264998
 0.02651232881    0.006955139351   0.009961546112  0.009628426464  0.007705852612
 0.0001821584116  0.01184029675    0.004674136445  0.001507058055  0.001290120121
 0.003146372564   0.0105155083     0.009132798515  0.006681290711  0.01509789222
 0.001506946859   0.0003146372564  0.003828813896  0.004336978181  0.002911487299

Explanation:

⎕ML←3: set migration level to 3. (Among other things, this changes the behaviour of ⊂ from 'split' into 'partition', so we don't have to get rid of the linefeeds.)
W←83 ¯1⎕MAP'w': read the file w as a string of ASCII values, store it in W.
G←W⊂⍨10≠W: partition W on linefeeds (character 10) and store the words in G.
(↓(L←⍳5)∘.≤≢¨G)/¨⊂G: store the numbers 1 to 5 in L, and for each number, select those words from G which have at least that many letters.
L{...}¨: for each of the numbers 1 to 5, and the matching list of words,:

⍺⌷¨⍵: for each word, select the ⍺-th letter
K←,∘≢⌸: for each letter, find out how many times it occurs, store this in K.
K[⍋⊃K...;]: sort K by the value of the letter (so a is at the top, and z at the bottom).
R←0 1↓: drop the first column (the letter), leaving only the amount of times it occurred. Store this in R.
R÷+⌿R: divide the value for each letter by the total amount.


text:
Generate Dennis Numbers
This challenge is a tribute to PPCG user Dennis for winning the robbers' part of The Programming Language Quiz.
Looking at Dennis' PPCG profile page we can see some pretty impressive stuff:

He currently has over sixty-eight thousand reputation, making him second in rep overall, surpassing third place by almost thirty thousand. He recently won our election for a new moderator and got a shiny new diamond next to his name. But I personally think the most interesting part about Dennis is his PPCG user ID number: 12012.
At first glance 12012 almost looks like a palindrome, a number that reads the same when reversed, but it's a little off. It can become the palindrome 21012 if we swap the positions of the first 1 and 2, and it can become the palindrome 12021 if we swap the last 1 and 2. Also, following the convention that leading zeroes in a number are not written, swapping the first 1 and the 0 results in 02112 or rather 2112 which is another palindrome.
Let's define a Dennis number as a positive integer that is not palindromic itself but can be made into a palindrome by swapping the positions of at least one pair of any two digits. The order of a Dennis number is the number of distinct pairs of digits that can be swapped to make a (not necessarily distinct) palindrome.
So the order of 12012 is 3 since 3 distinct pairs of its digits (12012, 12012, 12012) can be swapped around to produce palindromes. 12012 happens to be the smallest order 3 Dennis number.
10 is the smallest Dennis number and has order 1 because switching around the 1 and 0 gives 01 a.k.a. 1 which is a palindrome.
The imaginary leading zeroes of a number don't count as switchable digits. For example, changing 8908 to 08908 and swapping the first two digits to get the palindrome 80908 is invalid. 8908 is not a Dennis number.
Non-Dennis numbers could be said to have order 0.
Challenge
Write a program or function that takes in a positive integer N and prints or returns the Nth smallest Dennis number along with its order in some reasonable format such as 12012 3 or (12012, 3).
For example, 12012 is the 774th Dennis number so if 774 is the input to your program, the output should be something like 12012 3. (Curiously, 774 is another Dennis number.)
The shortest code in bytes wins.
Here is are the first 20 Dennis numbers and their orders for reference:
N       Dennis  Order
1       10      1
2       20      1
3       30      1
4       40      1
5       50      1
6       60      1
7       70      1
8       80      1
9       90      1
10      100     1
11      110     2
12      112     1
13      113     1
14      114     1
15      115     1
16      116     1
17      117     1
18      118     1
19      119     1
20      122     1

Here is the same list up to N = 1000.

This has got to be added to OEIS

@Claudiu this is added to the OEIS.

Pyth, 44 bytes
L/lf_ITs.e.e`sXXNkZYbN=N`b2,Je.f&!_I`ZyZQ0yJ

Try it online: Demonstration or Test Suite
A stupid little bug (?) in Pyth ruined a 41 byte solution.
Explanation:
L/lf_ITs.e.e`sXXNkZYbN=N`b2
L                             define a function y(b), which returns:
                      =N`b       assign the string representation of b to N
        .e             N         map each (k=Index, b=Value) of N to:
          .e         N             map each (Y=Index, Z=Value) of N to:
              XXNkZbN                switch the kth and Yth value in N
            `s                       get rid of leading zeros
       s                         combine these lists
   f_IT                          filter for palindromes
  l                              length
 /                        2      and divide by 2

,Je.f&!_I`ZyZQ0yJ
   .f        Q0     find the first input() numbers Z >= 0, which satisfy
      !_I`Z            Z is not a palindrom
     &                 and
           yZ          y(Z) != 0
  e                 get the last number
 J                  and store in J
,J             yJ   print the pair [J, y(J)]

And what is this 'stupid little bug (?)'

@CatsAreFluffy Had to look up the Github history. It concerns .f. Here's the pull request that I made because of this question: https://github.com/isaacg1/pyth/pull/151

CJam, 45 bytes
0{{)_s:C,2m*{~Ce\is_W%=},,2/:O!CCW%=|}g}ri*SO

Try it online!
How it works
0          e# Push 0 (candidate).
{          e# Loop:
  {        e#   Loop:
    )_     e#     Increment the candidate and push a copy.
    s:C    e#     Cast to string and save in C.
    ,      e#     Get the length of C, i.e., the number of digits.
    2m*    e#     Push all pairs [i j] where 0 ≤ i,j < length(C).
    {      e#     Filter:
      ~    e#       Unwrap, pushing i and j on the stack.
      Ce\  e#       Swap the elements of C at those indices.
      is   e#       Cast to int, then to string, removing leading zeroes.
      _W%= e#       Copy, reverse and compare.
    },     e#     Keep the pairs for which = returned 1, i.e., palindromes.
    ,2/    e#     Count them and divide the count by 2 ([i j] ~ [j i]).
    :O     e#     Save the result (the order) in O.
    !      e#     Negate logically, so 0 -> 1.
    CCW%=  e#     Compare C with C reversed.
    |      e#     Compute the bitwise NOT of both Booleans.
           e#     This gives 0 iff O is 0 or C is a palindrome.
  }g       e#   Repeat the loop while the result is non-zero.
}ri*       e# Repeat the loop n times, where n is an integer read from STDIN.
           e# This leaves the last candidate (the n-th Dennis number) on the stack.
SO         e# Push a space and the order.

I've hit the rep cap already, but I had to post the first answer.

Ugh. How do I force myself to upvote a comment with 42 upvotes?

I got the 42nd upvote :P

Haskell, 174 bytes
import Data.List
p x=x==reverse x
x!y=sum[1|(a,b)<-zip x y,a/=b]==2
o n|x<-show n=sum[1|v<-nub$permutations x,x!v,p$snd$span(<'1')v,not$p x]
f=([(x,o x)|x<-[-10..],o x>0]!!)

p checks whether a list is a palindrome.
x!y is True iff the lists x and y (which should have the same length) differ in exactly two places. Specifically, if x is a permutation of y, x!y determines whether it is a "swap".
o n finds the Dennis-order of n. It filters for swaps among the permutations of x = show n, and then counts how many of those swaps are palindromes. The list comprehension that performs this count has an extra guard not (p x), which means it will return 0 if n was a palindrome to begin with.
The snd (span (<'1') v) bit is just dropWhile but one byte shorter; it turns "01221" into "1221".
f indexes from a list of (i, o i) where o i > 0 (i.e. i is a Dennis number.) There would normally be an off-by-one error here, as (!!) counts from 0 but the problem counts from 1. I managed to remedy this by starting the search from -10 (which turned out to be considered a Dennis number by my program!) thereby pushing all the numbers into the right spots.
f 774 is (12012,3).

Rust, 390 bytes
fn d(mut i:u64)->(u64,i32){for n in 1..{let mut o=0;if n.to_string()==n.to_string().chars().rev().collect::<String>(){continue}let mut s=n.to_string().into_bytes();for a in 0..s.len(){for b in a+1..s.len(){s.swap(a,b);{let t=s.iter().skip_while(|&x|*x==48).collect::<Vec<&u8>>();if t.iter().cloned().rev().collect::<Vec<&u8>>()==t{o+=1}}s.swap(a,b);}}if o>0{i-=1;if i<1{return(n,o)}}}(0,0)}

The new Java? :/
Ungolfed and commented:
fn main() {
    let (num, order) = dennis_ungolfed(774);
    println!("{} {}", num, order);  //=> 12012 3
}

fn dennis_ungolfed(mut i: u64) -> (u64, i32) {
    for n in 1.. {
        let mut o = 0;  // the order of the Dennis number
        if n.to_string() == n.to_string().chars().rev().collect::<String>() {
            // already a palindrome
            continue
        }
        let mut s = n.to_string().into_bytes();  // so we can use swap()
        for a in 0..s.len() {  // iterate over every combination of (i, j)
            for b in a+1..s.len() {
                s.swap(a, b);
                // need to start a new block because we're borrowing s
                {
                    let t = s.iter().skip_while(|&x| *x == 48).collect::<Vec<&u8>>();
                    if t.iter().cloned().rev().collect::<Vec<&u8>>() == t { o += 1 }
                }
                s.swap(a, b);
            }
        }
        // is this a Dennis number (order at least 1)?
        if o > 0 {
            // if this is the i'th Dennis number, return
            i -= 1;
            if i == 0 { return (n, o) }
        }
    }
    (0, 0)  // grr this is necessary
}

323 bytes

Python 2, 176
i=input()
n=9
c=lambda p:`p`[::-1]==`p`
while i:n+=1;x=`n`;R=range(len(x));r=[c(int(x[:s]+x[t]+x[s+1:t]+x[s]+x[t+1:]))for s in R for t in R[s+1:]];i-=any(r)^c(n)
print n,sum(r)

I can't imagine that my swapping code is particularly optimal, but this is the best I've been able to get. I also don't like how often I convert between string and integer...
For each number, it creates a list of a whether all of the swaps of two digits are palindromes. It decrements the counter when at least one of these values is true, and the original number is not a palindrome. Since 0+True in python evaluates to 1 the sum of the final list works for the order of the Dennis number.

Jelly, 33 bytes
ṚḌ=
=ċ0^2°;ḌÇ
DŒ!Qç@ÐfDL©Ṡ>Ñµ#Ṫ,®

Try it online!
How it works
DŒ!Qç@ÐfDL©Ṡ>Ñµ#Ṫ,®  Main link. No arguments.

              µ      Combine the chain to the left into a link.
               #     Find; execute the chain with arguments k = 0, 1, 2, ...
                     until n values of k result in a truthy value, where n is an
                     integer read implicitly from STDIN. Return those n values.

D                      Decimal; convert k to the list of its digits in base 10.
 Œ!                    Generate all permutations of the digits.
   Q                   Unique; deduplicate the list of permutations.
      Ðf               Filter:
    ç@  D                Call the helper link on the second line with the
                         unpermuted digits (D) as left argument, and each
                         permutation as the right one.
                       Keep permutations for which ç returns a truthy value.
         L©            Compute the length (amount of kept permutations) and save
                       it in the register.
           Ṡ           Sign; yield 1 if the length is positive, and 0 otherwise.
            >Ṅ         Compare the sign with the result from the helper link on
                       the first line. This will return 1 if and only if the
                       length is positive and Ñ returns 0.
                Ṫ      Tail; extract the last value of k.
                 ,®    Pair it with the value in the register.

=ċ0^2°;ḌÇ              Helper link. Arguments: A, B (lists of digits)

=                      Compare the corresponding integers in A and B.
 ċ0                    Count the zeroes, i.e., the non-matching integers.
   ^2                  Bitwise XOR the amount with 2.
     °                 Convert to radians. This will yield 0 if exactly two
                       corresponding items of A and B are different ,and a
                       non-integral number otherwise.
      ;                Prepend the result to B.
       Ḍ               Convert the result from decimal to integer. Note that
                       leading zeroes in the argument won't alter the outcome.
        Ç              Call the helper link on the first line.

ṚḌ=                    Helper link. Argument: m (integer)

Ṛ                      Convert m to decimal and reverse the digits.
 Ḍ                     Convert back to integer.
  =                    Compare the result with m.

APL, 87
2↓⎕{⍺(2⊃⍵+K⌊~A∧.=⌽A)X,K←+/{⍵∧.=⌽⍵}¨1↓∪,{⍕⍎Y⊣Y[⌽⍵]←⍵⊃¨⊂Y←A}¨∘.,⍨⍳⍴A←⍕X←1+3⊃⍵}⍣{=/2↑⍺}3⍴0

The body of the loop returns a vector of 4 numbers: 1) its left argument ⍺ read from input, 2) count of Dennis numbers so far, 3) current value of X — the loop counter, and 4) its order K computed as sum of palindromes within 1-swap permutations.  It terminates when the first two elements become equal and last two are then returned as result.

JavaScript (ES6), 229
As usual, JavaScript shines for its ineptitude for combinatorics (or, maybe it's my ineptitude...). Here I get all possibile swap positions finding all binary numbers of the given length and just 2 ones set.
Test running the snippet below in Firefox (as MSIE is far from EcmaScript 6 compliant and Chrome is still missing default parameters)

F=c=>(P=>{for(a=9;c;o&&--c)if(P(n=++a+'',o=0))for(i=1<<n.length;k=--i;[x,y,z]=q,u=n[x],v=n[y],!z&&u-v&&(m=[...n],m[x]=v,m[y]=u,P(+(m.join``))||++o))for(j=0,q=[];k&1?q.push(j):k;k>>=1)++j;})(x=>x-[...x+''].reverse().join``)||[a,o]

// TEST

function go(){ O.innerHTML=F(I.value)}

// Less Golfed
U=c=>{
  P=x=>x-[...x+''].reverse().join``; // return 0 if palindrome

  for(a = 9; // start at 9 to get the first that is known == 10
      c; // loop while counter > 0
      o && --c // decrement only if a Dennis number found
      )
  {
    o = 0; // reset order count
    ++a;
    if (P(a)) // if not palindrome
    {
      n = a+''; // convert a to string
      for(i = 1 << n.length; --i; )
      {
        j = 0;
        q = [];
        for(k = i; k; k >>= 1)
        {
          if (k & 1) q.push(j); // if bit set, add bit position to q
          ++j;
        }
        [x,y,z] = q; // position of first,second and third '1' (x,y must be present, z must be undefined)
        u = n[x], v = n[y]; // digits to swap (not valid if they are equal)
        if (!z && u - v) // fails if z>0 and if u==v or u or v are undefined
        {
          m=[...n]; // convert to array
          m[x] = v, m[y] = u; // swap digits
          m = +(m.join``); // from array to number (evenutally losing leading zeroes)
          if (!P(m)) // If palindrome ...
            ++o; // increase order count
        }
      }
    }
  }
  return [a,o];
}

//////
go()
<input id=I value=774><button onclick="go()">-></button>

awk, 199
{for(;++i&&d<$0;d+=o>0)for(o=j=_;j++<l=length(i);)for(k=j;k++<l;o+=v!=i&&+r~s){split(t=i,c,v=s=r=_);c[j]+=c[k]-(c[k]=c[j]);for(e in c){r=r c[e];s=s||c[e]?c[e]s:s;v=t?v t%10:v;t=int(t/10)}}print--i,o}

Structure
{
    for(;++i&&d<$0;d+=o>0)
        for(o=j=_;j++<l=length(i);)
            for(k=j;k++<l;o+=v!=i&&+r~s)
            {
                split(t=i,c,v=s=r=_);
                c[j]+=c[k]-(c[k]=c[j]);
                for(e in c)
                {
                    r=r c[e];
                    s=s||c[e]?c[e]s:s;
                    v=t?v t%10:v;
                    t=int(t/10)
                }
            }
    print--i,o
}

Usage
Paste this to your console and replace the number after echo, if you want
echo 20 | awk '{for(;++i&&d<$0;d+=o>0)for(o=j=_;j++<l=length(i);)for(k=j;k++<l;o+=v!=i&&+r~s){split(t=i,c,v=s=r=_);c[j]+=c[k]-(c[k]=c[j]);for(e in c){r=r c[e];s=s||c[e]?c[e]s:s;v=t?v t%10:v;t=int(t/10)}}print--i,o}'

It gets slow at higher numbers ;)
Ungolfed reusable version
{
    dennisFound=0

    for(i=0; dennisFound<$0; )
    {
        i++
        order=0

        for(j=0; j++<length(i); )
        {
            for(k=j; k++<length(i); )
            {
                split(i, digit, "")
                digit[j]+=digit[k]-(digit[k]=digit[j]) # swap digits

                tmp=i
                iRev=iFlip=iFlipRev=""

                for(e in digit)
                {
                    if(tmp>0)                        # assemble reversed i
                        iRev=iRev tmp%10
                    tmp = int( tmp/10 )

                    iFlip=iFlip digit[e]             # assemble flipped i

                    if(iFlipRev>0 || digit[e]>0)     # assemble reversed flipped i
                        iFlipRev=digit[e] iFlipRev   # without leading zeros
                }
                if(iRev!=i && 0+iFlip==iFlipRev) order++  # i is not a palindrome,
            }                                             # but flipped i is
        }
        if(order>0) dennisFound++
    }
    print i, order
}

Ruby, 156
->i{s=?9
(o=0;(a=0...s.size).map{|x|a.map{|y|j=s+'';j[x],j[y]=j[y],j[x];x>y&&j[/[^0].*/]==$&.reverse&&o+=1}}
o<1||s==s.reverse||i-=1)while i>0&&s.next!;[s,o]}

Uses the Ruby feature where calling "19".next! returns "20" to avoid having to convert types back and forth; we just use a regex to ignore leading 0s. Iterates over all pairs of string positions to check for palindromic switches. I originally wrote this a recursive function but it busts the stack.
Output for 774 is ["12012", 3] (removing the quotation marks would cost 4 more bytes but I think the spec allows them).

05AB1E, 34 bytes
∞ʒÂÊ}ε©ā<2.Æε®DrèRyǝïÂQ}O‚}ʒθĀ}I<è

Try it online or output the first \$n\$ Dennis numbers.
Explanation:
∞            # Push an infinite positive list: [1,2,3,...]
 ʒ           # Filter it by:
  Â          #  Bifurcate the current number (short for Duplicate & Reverse Copy)
   Ê         #  Check that the reverse copy does NOT equal the number itself
 }ε          # After we've filtered out all palindromes: map over the remaining numbers:
   ©         #  Store it in variable `®` (without popping)
    ā        #  Push a list in the range [1, length] (without popping)
     <       #  Decrease each by 1 to make the range [0, length)
      2.Æ    #  Get all possible pairs of this list
    ε        #  Map each pair of indices to:
     ®D      #   Push the number from variable `®` twice
       r     #   Reverse the stack order from [indices,nr,nr] to [nr,nr,indices]
        è    #   Get the digits of the number at these indices
         R   #   Reverse this pair
          y  #   Push the indices we're mapping over again
           ǝ #   And insert the reversed digits back into the number at the indices
     ï       #   Cast it to an integer to remove leading 0s
      Â      #   Bifurcate it (short for Duplicate & Reverse Copy)
       Q     #   Check that the reverse copy equals the number itself,
             #   resulting in 1 if its a palindrome, and 0 if not
    }O       #  After the inner map: sum all truthy values together
      ‚      #  And pair it with the number
 }ʒ          # After the outer map: filter again:
   θ         #  Where the last value of the pair (the calculated order)
    Ā        #  Is not 0
  }I         # After the filter: push the input-integer
    <        # Decrease it by 1 (because 05AB1E uses 0-based indexing)
     è       # And get the pair at that index in the infinite list
             # (after which it is output implicitly as result)

JavaScript (ES6), 151 bytes
f=(n,x)=>(g=a=>(a=[...+a.join``+''])+''==a.reverse(k=0))(a=[...x+''])|a.map((p,i)=>a.map((q,j)=>k+=g(b=[...a],b[i]=q,b[j]=p)))|!k||--n?f(n,-~x):[x,k/2]

Try it online!

Perl 5 -alp, 148 bytes
$_=9;while(!$o||--$F[0]){$o=0;if(++$_ ne reverse){for$i(0..(@a=/./g)){map{@b=@a;@b[$i,$_]=@b[$_,$i];$o+=($t=1*join'',@b)eq reverse$t}$i..$#a}}}say$o

Try it online!
Output is on two lines.  First line is the order; second line is the number.

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:
Generate ordered binary combinations without repetitions
Challenge
Write the shortest program that receives two signed integers n and i and for each i between 1 and 2^n - 1 returns the next ordered permutation based on the binary representation of the number.  There is no specific order of the combinations but the number of 1s in the binary representation must always stay the same or grow and numbers each output may happen only once
Clarification
The goal of this program is to generate all the combinations without repetitions of a set. To do so you may consider that each item is represented by a bit in a bit mask, that way if you have three items, A, B and C represented by 001, 010 and 100 respectively the combinations ABC, ACB, BCA, BAC, CAB and CBA are all represented as 111.
For increasing values of i your program should output a new combinations always with the same number of elements or more.
Input
You may read the input in the format

n i

or just use n and i variables, whichever suits you best.
Output
You may output a single number k
Sample cases
Each test case is two lines, input followed by output with a binary representation here for demonstration purposes:
3 1
1 (001)

3 2
4 (100)

3 3
2 (010)

3 4
6 (110)

3 7
7 (111)

Rules

Shortest code wins (bytes)
The result can be returned by a function or printed by your program.
You may assume n and i variables already exist, there's no need to handle input if you don't want to.
The answers with the same number of 1 bits can be output in any order
The input is guaranteed to be well formed and 1 <= i <= 2^n - 1.

Happy Golfing!

I don't get it. Can you explain a little more how you derive the output?

The first sentence is quite confusing, because you seem to be talking about two different is (one from input, and one which is a loop variable). On the third read-through of that sentence I came to the conclusion the "for each i" is actually intended to express a constraint on the possible inputs, and that seems to fit the rules at the end. But I'm still not sure what you mean by ordered permutation based on the binary representation of the number, and your example output doesn't seem to show a next-in-list function which the first sentence asks for.

I added a clarification, is it better to understand now?

The example still seems to contradict the spec. Since the number of 1s must be non-decreasing, the next bitmask after 3 can't be 2.

Pyth, 13 bytes
i@o/N1^U2vzQ2

Just constructs a cartesian power of [0, 1], sorts it by number of 1s, and indexes before converting to base10.

Ruby, 72 bytes
p [0,1].repeated_permutation(n).sort_by{|x|x.count 1}[i].join('').to_i 2

How it works:
irb(main):001:0> [0, 1].repeated_permutation(3).to_a  # generate permutations
=> [[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1],
    [1, 1, 0], [1, 1, 1]]

irb(main):002:0> _.sort_by {|x| x.count 1 }           # sort by number of 1's
=> [[0, 0, 0], [0, 0, 1], [0, 1, 0], [1, 0, 0], [0, 1, 1], [1, 0, 1],
    [1, 1, 0], [1, 1, 1]]

irb(main):003:0> _[2].join ''  # convert array of binary digits to string
=> "010"
irb(main):004:0> _.to_i 2      # interpret string as binary number
=> 2

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


text:
Work it harder, make it better
In this challenge your goal will be to output the lyrics to Daft Punk's Harder, Better, Faster, Stronger. Specifically, output this text:
Work It
Make It
Do It
Makes Us
Harder
Better
Faster
Stronger
More Than
Hour
Our
Never
Ever
After
Work Is
Over

Work It
Make It
Do It
Makes Us
Harder
Better
Faster
Stronger
More Than
Hour
Our
Never
Ever
After
Work Is
Over

Work It Harder Make It Better
Do It Faster, Makes Us Stronger
More Than Ever Hour After
Our Work Is Never Over

Work It Harder Make It Better
Do It Faster, Makes Us Stronger
More Than Ever Hour After
Our Work Is Never Over

Work It Harder Make It Better
Do It Faster, Makes Us Stronger
More Than Ever Hour After
Our Work Is Never Over

Work It Harder Make It Better
Do It Faster, Makes Us Stronger
More Than Ever Hour After
Our Work Is Never Over

Work It Harder Make It Better
Do It Faster, Makes Us Stronger
More Than Ever Hour After
Our Work Is Never Over

Work It Harder Make It Better
Do It Faster, Makes Us Stronger
More Than Ever Hour After
Our Work Is Never Over

Work It Harder Make It Better
Do It Faster, Makes Us Stronger
More Than Ever Hour After
Our Work Is Never Over

Work It Harder, Make It
Do It Faster, Makes Us
More Than Ever, Hour
Our Work Is Never Over

Work It Harder Make It Better
Do It Faster, Makes Us Stronger
More Than Ever Hour Af-
Our Work Is Never Over

Work It Harder Make It Better
Do It Faster, Makes Us Stronger
More Than Ever Hour Af-
Our Work Is Never Over

Work It Harder Make It Better
Do It Faster, Makes Us Stronger
More Than Ever Hour Af-
Our Work Is Never Over

Work It Harder
Make It Better
Do It Faster Makes Us Stronger
More Than Ever Hour
Our Work Is Never Over

Work It Harder
Do It Faster
More Than Ever
Our Work Is Never Over

Work It Harder
Make It Better
Do It Faster
Makes Us Stronger
More Than Ever
Hour After
Our Work Is Never Over

Your output may have a trailing newline or trailing whitespace.
Built in compression methods are not allowed.
This is code golf, so shortest code wins!

Is Af- supposed to be one of the words?

@feersum Yes, if you listen to the song you can see he starts to say After and then pauses. I added the hyphen to show the break and to infuriate people. I can remove it if you want, though.

I'm shocked there's no esolang like HQ9+Daft-Punk that prints this...

I think you should at least disallow built in compression methods.

@flawr I knew I was forgetting something! Thanks. Edited.

The lyrics to "Around the World" would have been easier. ;)

You have some lowercase 'stronger's hanging around

Is the newline between Work It Harder and Make It Better in the 3rd-to-last paragraph intended (because of a pause or something)?

@mbomb007 Yes, because there is a long pause there in the song.

There's also a lowercase ever in 2nd-to-last paragraph that you should fix, as well as those lowercase strongers wherever they occur.

Great. Now I can't post my answer. I was just typing it up. Oh well... it would've been ~430 bytes, I think.

In case anyone wants to see it, it's in Retina (the newlines will be hard to read here). I was going to try turning off silent mode and see if I could use it to shorten the answer:`.*
XXYYYYYYY
W H m B
D F, M S
T E h
o w N O
ZZZ
W H
m B
D F M S
T E h
o w N O
W H
D F
T E
o w N O
W H
m B
D F
M S
T E
h A
o w N O
X
W
m
D
M
H
B
F
S
T
h
o
N
E
A
w
O
Y
W H m B
D F, M S
T E h A
o w N O
Z
W H m B
D F, M S
T E h -
o w N O
W
Work It
m
Make It
D
Do It
M
Makes Us
H
Harder
B
Better
F
Faster
S
Stronger
T
More Than
h
Hour
o
Our
N
Never
E
Ever
A
After
w
Work is
O
Over
Af-`

@mbomb007 I'm voting to reopen. The structure of these lyrics (intercalation etc) is quite different to the linked question. If we follow the logic that we should close all songs because of one, then we should also be closing all new ascii art questions.

that said OP should clarify what should be done about the inconsistent capitalization. Is it required to reproduce the capitalization exactly as shown or not?

This song is the first one in a while that in my mind, isn't a duplicate of the rickroll. I've taken it to meta http://meta.codegolf.stackexchange.com/q/6956/15599

@steveverrill My intention was for every word to be capitalized. I'll edit it, but if I miss anything please feel free to edit and correct.

How should I post an answer with non-printable characters?

@Roboter people usually post a hexdump for non-printable answers.

Ruby, 308 303
puts a='Work It|Make It|Do It|Makes Us|Harder|Better|Faster|Stronger|More Than|Hour|Our|Never|Ever|After|Work Is|Over

'.split(?|),a
56.times{|i|puts a[j=i%4/2*4+i%4*2]+' '+a[j+4]+[[' ',', ','
']["l4yq62lhgnizb0kfu".to_i(36)/3**i%3]+a[j+1]+' ',''][i%51/48]+[a[j+5],['','Af-'][i%44/32]][7619655>>i-28&1]}

Algorithm
Song intro: Take 16 tokens, and print them twice (last one bears an extra newline)
Verses: Riffle the tokens together to make the verses, 4 tokens per line, in the following order:
 0  4  1  5
 2  6  3  7
 8 12  9 13
10 14 11 15

In some lines, the last token is omitted, or exchanged for Af-. These lines are noted with a 1 bit in the magic number 0x744447=7619655.
In three lines, the penultimate token is also omitted, those where i%51/48==1
The punctuation in the middle of the line can be one of ' ' ', ' '\n'. These are encoded in the number 02220010000200100010001001110010001000100010001000100010 (base 3) = "l4yq62lhgnizb0kfu" (base 36.)
With comments
puts a='Work It|Make It|Do It|Makes Us|Harder|Better|Faster|Stronger|More Than|Hour|Our|Never|Ever|After|Work Is|Over

'.split(?|),a                                                    #Set up array containing all 16 tokens, print it, and print it again (note newlines at end of last token.)

56.times{|i|                                                     #14 verses, 4 lines each

puts a[j=i%4/2*4+i%4*2]+                                         #expression cycles through 0,2,8,10. Print the first token on the line.

' '+a[j+4]+                                                      #print a space, and the second token on the line.

[[' ',', ','
']["l4yq62lhgnizb0kfu".to_i(36)/3**i%3]+a[j+1]+' ',''][i%51/48]+ #if i%51/48==1,print nothing. Otherwise print the 3rd token, followed by a space, and preceded by one of ' ' or ', ' or '\n'

[a[j+5],['','Af-'][i%44/32]][7619655>>i-28&1]                    #if 7619655>>i-28&1==0 print the fourth token. Otherwise print either nothing or Af- depending on the value of i%44/32

}

Perl, 316 309 308 307 bytes
The source must be encoded as Latin-1.
@c=split b,'
Â×
Ô
ÚáÐÙáÒ
ÅOÆÖáEváAftáØ
bÑÏábÝà
bÑÈ-
bÈÇÈÇbHoÆbur
btáÑbÏßËÌÊßÉbHoÜAfbÔ ÒÍbÝà ÐÎber, b Evb× ÙbÓ ÚbBettábOÜØ ÖßbStrongáÛbÕ
ÞàbÝs UsbOvábNevbDoàbÞ IsbFastbHardbMore Thanbur bMakebWorkber b Itber
';$e='ÞàÀÓÀÄÄÄÈÇÏÌÂÎÌÔ
ÛÍÌÅÃÃÃÁËßÊßÅÁÎáÛÍáÁËáÊáÉÇÕ';$f=chr$_+192,$e=~s/$f/$c[$_]/g for 0..34;print$e

Explanation
We start out with the original lyrics. For brevity, let’s assume they are
lyrics = "Work Work Harder Harder"

Now we find short substrings (≥ 3 characters) that occur often. In this case, "Work " occurs twice. We replace each occurrence with character 0xE1. We also remember the replaced string in an array:
lyrics = "ááHarder Harder"
substs = ["Work "]

The next substring, "Harder", is replaced with 0xE0. The substs array grows towards the front:
lyrics = "ááà à"
substs = ["Harder", "Work "]

This continues for a total of 34 iterations until we get to character 0xC0.
Now we concatenate the substs using the character b (which doesn’t occur in the lyrics) as a separator. In the Perl code, the substs array is stored in @c (using the bareword b to tell split where to split), the new jumbled lyrics are in $e, and the code simply reverses the 34 substitutions.

Any explanations?

@feersum: Done.

Sprects, 302 bytes
:xxnnnnnnnmW12603 27428 3s59qp wb12604280qpb12603 2742803s59qp0wjb:ncvb:mcQb:WcEb:x1203 204203s50607809q0w0y0i0p0j01l0z00:c1263 27428, 3s59:vqp wj:Qqp, w:Eqp wAf-:b0y1liz00:0\n:1Work :2It :3Make:4Do :5 Us :6Harder :7Better\n:8Faster:9Stronger\n:qMore Than :wHour :yOur :iNever :pEver:jAfter :lIs :zOver

I just recently made this language and I decided to test it out with this challenge. It outputs \ns instead of new lines because it outputs into HTML, but the interpreter is written in JavaScript. Because of this, here's a version with
s instead of \ns:
:xxnnnnnnnmW12603 27428 3s59qp wb12604280qpb12603 2742803s59qp0wjb:ncvb:mcQb:WcEb:x1203 204203s50607809q0w0y0i0p0j01l0z00:c1263 27428, 3s59:vqp wj:Qqp, w:Eqp wAf-:b0y1liz00:0
:1Work :2It :3Make:4Do :5 Us :6Harder :7Better
:8Faster:9Stronger
:qMore Than :wHour :yOur :iNever :pEver:jAfter :lIs :zOver

Very interesting. We have a rule here that the language/interpreter/compiler must exist before the challenge. I don't see a date on you interpreter, when was it published?

@steveverrill I made it yesterday. I guess my answer is invalid then.

Consensus on Meta is that this can still be posted but isn't applicable for winning. You should probably add a disclaimer to your answer to inform OP

Can you make er a single token?

GolfScript (275 bytes)
This contains non-printable ASCII characters, so here's a hexdump:
0000000: 3a6b 2757 6f72 6b20 4974 0a4d 616b 6586  :k'Work It.Make.
0000010: 0444 6f8c 0873 2055 730a 4861 7264 6572  .Do..s Us.Harder
0000020: 0a42 6574 7485 0346 6173 8504 5374 726f  .Bett..Fas..Stro
0000030: 6e67 9503 4d6f 7265 2054 6861 6e0a 486f  ng..More Than.Ho
0000040: 7572 0a4f 8203 4e65 76ae 0345 8304 4166  ur.O..Nev..E..Af
0000050: b204 df06 730a 4f96 048c 07ed 7020 d606  ....s.O.....p ..
0000060: 20f4 0720 de07 fb05 20e4 062c 9b05 7320   .. .... ..,..s
0000070: 5573 20ee 1220 df04 20f3 0420 e406 f903  Us .. .. .. ....
0000080: 20e8 0720 4e65 9b04 eeff eeff eeb6 d206   .. Ne..........
0000090: fe03 e817 df0f 2ce0 05da 5c27 d908 2042  ......,...\'.. B
00000a0: 6574 d303 e017 2053 7472 6f6e 67bd 03e9  et.... Strong...
00000b0: 0ee8 0520 4166 2dec ffec 040a ec1b eb26  ... Af-........&
00000c0: e728 d80c c60f c128 4d61 6b65 d004 4265  .(.....(Make..Be
00000d0: 74c3 04d0 0e9a 0373 2055 7320 5374 726f  t......s Us Stro
00000e0: 6e67 e212 486f e303 4166 fc04 ed16 277b  ng..Ho..Af....'{
00000f0: 6b7b 7b6b 247d 2a30 3a6b 3b7d 7b31 3237  k{{k$}*0:k;}{127
0000100: 2e32 243c 7b2d 3a6b 7d2a 3b7d 6966 7d2f  .2$<{-:k}*;}if}/
0000110: 5d28 2b                                  ](+

How does this work? As far as I can tell it seems I'm the only one using a "riffle and omit" strategy, which surprises me. Still, it means I'm in second place behind this answer.

Hand-coded Lempel-Ziv. Nothing interesting. Which was pretty much the point I tried to make in meta, but clearly not convincingly enough.

Well I am indeed disappointed that few people took full advantage of the structure of the song. The opportunity was there, as evidenced by the fact that I'm in second place in Ruby, only 28 bytes behind you. I'm inclined to believe that a port of my answer into golfscript would come in shorter than 275 bytes. Do you think otherwise?

I tried my full battery of grammar generators on it, and was surprised that LZ came out ahead (although the greedy grammar builder was only one byte behind). But I wouldn't be surprised if one of a port of this GolfScript or a port of the 276-byte greedy grammar approach into Ruby came out at less than 303 bytes.

JavaScript ES6, 440 bytes 438 bytes
This is a bunch of simple compression optimizations. As a one-liner:
eval("a='w_m_d_u_h_b_f_s_M_H_O_N_E_A_W_VX';b='w hTm b_d f,Tu s_M ETH A_O W N VX';c=bRA/,'Y');o={};'wWork It|mMake It|dDo It|uMakes Us|hHard&bBett&fFast&sStrong&MMore Than|HHour|OOur|NNev&EEv&AAft&WWork Is|VOv&X\\n\\n|YAf-|_\\n|T 'R&/g,'er|').split('|').map(x=>o[x[0]]=x.slice(1));console.log((a+a+b.repeat(7)+bR._/g,'_')R,?T/g,',T')+c+c+c+bRT/,'_')R,/,'')+bR,?T. ._/g,'_')+bR,?T/g,'_'))R\\w/g,x=>o[x]).trim())".replace(/R/g,'.replace(/'))

This was written to be an executable script via iojs --harmony_arrow_functions file.js; you can shave off the console.log() overhead depending on the meaning of "output the lyrics".
Explanation
After performing the outer .replace(), the code fed to eval is:
// The first three lines, with each phrase compressed to a single character, newlines
// compressed to _, and block-endings compressed to X. Call this compressed-format.
a = 'w_m_d_u_h_b_f_s_M_H_O_N_E_A_W_VX';

// The compressed-format main block: this is repeated seven times literally but
// every other stanza, besides `a` above, ultimately uses some simple variant
// of this block.
b = 'w hTm b_d f,Tu s_M ETH A_O W N VX';
// The new character T above is a new character we're adding to compressed-format, it is
// a space in the main block but also a hook for some regular expressions later.

// We need one more entry in compressed-format: some blocks, here assigned to
// the variable `c`, shorten "After" to Y = "Af-".
c = b.replace(/A/, 'Y');

// Now we want to build a lookup table for this compressed format above. That is done by
// these lines, which have also been compressed:
o={};
'wWork It|mMake It|dDo It|uMakes Us|hHard&bBett&fFast&sStrong&MMore Than|HHour|OOur|NNev&EEv&AAft&WWork Is|VOv&X\n\n|YAf-|_\n|T '
    .replace(/&/g, 'er|')
    .split('|')
    .map(x => o[x[0]] = x.slice(1));
// The fact that so many fragments end in 'er' allows us to actually shave a couple
// bytes above, but the compression scheme is fundamentally creating a dict like
//     {a: "Phrase 1", b: "Phrase 2", c: "Phrase 3", d: "Phrase 4"}
// from the string "aPhrase 1|bPhrase 2|cPhrase 3|dPhrase4".

// Now we have the part that actually does the work:
console.log(
    ( // build-string phase
        // first two opening blocks `a`
        a + a +

        // seven repetitions of `b`
        b.repeat(7) +

        // a version of `b` without final words and with commas before each T.
        b.replace(/._/g, '_').replace(/,?T/g, ',T') +

        // three repetitions with the 'Af-' suffix.
        c + c + c +

        // one with the first T converted into a newline and no commas
        b.replace(/T/, '_').replace(/,/, '') +

        // one with only the first halfs of the three lines
        b.replace(/,?T. ._/g, '_') +

        // one with no commas and all T's converted to newlines.
        b.replace(/,?T/g, '_')
    ) // end build-string phase
    // Now we convert from compressed-format to actual format
    .replace(/\w/g, x => o[x])
    // We are only told that one trailing newline is allowed; we have two extra:
    .trim()
)

Kudos

@vihan, who reminded me that ES6 also has this shiny new .repeat function for strings, saving 2 bytes.

You can probably use b.repeat(7) instead of b+b+b+b+b+b+b

JAVA 518/490Bytes
Edit: unneeded 7 Bytes and added a Java 6 version with the static{} trick
Edit2: Explanation expand
class E{public static void main(String[]_){String l="\n#, #Work#Make#Do#Makes Us#Hard#Bett#Fast#Strong#More#Than#Hour#Our#Nev#Ev#Aft#Af-#Work Is#Ov# #er# It",a="cwadwaewafagvahvaivajvakulamanaovapvaqvasatvaa",z="anusuovutvaa",y="kulupvu",x="cwugv",w="fujva",b=x+"udwuhvuaewuivb"+w,c=b+y+"muqvu"+z,d=x+"bdwaewuivbfakulupvbm"+z,e=b+y+"mur"+z,f=x+"adwuhvaewuivu"+w+y+z+x+"aewuivakulupv"+z+x+"adwuhvaewuiva"+w+"kulupvamuqv"+z,r=a+a+c+c+c+c+c+c+c+d+e+e+e+f;for(char o:r.toCharArray())System.out.print(l.split("#")[o-97]);}}

java6:
class E{static{String l="\n#, #Work#Make#Do#Makes Us#Hard#Bett#Fast#Strong#More#Than#Hour#Our#Nev#Ev#Aft#Af-#Work Is#Ov# #er# It",a="cwadwaewafagvahvaivajvakulamanaovapvaqvasatvaa",z="anusuovutvaa",y="kulupvu",x="cwugv",w="fujva",b=x+"udwuhvuaewuivb"+w,c=b+y+"muqvu"+z,d=x+"bdwaewuivbfakulupvbm"+z,e=b+y+"mur"+z,f=x+"adwuhvaewuivu"+w+y+z+x+"aewuivakulupv"+z+x+"adwuhvaewuiva"+w+"kulupvamuqv"+z,r=a+a+c+c+c+c+c+c+c+d+e+e+e+f;for(char o:r.toCharArray())System.out.print(l.split("#")[o-97]);}}

Thanks to @Chris Drost for the hint with the many "ER"s in the text.
First String is a lookup table, second part uses the lowercase letters (which are a sequential block in ascii) as a index into the table by subtracting the magic value of a from the value.
Second part consists of multiple Strings of different length (short ones are common parts shared between multiple verses) which get assembled to a long one before the looping through the chars happens

Nice answer! +1 And I know it's been about 1.5 years, but you can golf two things: Remove l and use the String containing all the # directly in the for-each loop, and change the char in the for-each loop to int: for(int o:r.toCharArray())System.out.print("\n#, #Work#Make#Do#Makes Us#Hard#Bett#Fast#Strong#More#Than#Hour#Our#Nev#Ev#Aft#Af-#Work Is#Ov# #er# It".split("#")[o-97]); Which results in -5 bytes / 513 bytes.

Ruby - 643 bytes
Edit: Golfed down from 899 to 830.
Edit2: 830 -> 755.
Edit3: 755 -> 684.
Edit4: 684 -> 670.
Edit5: 670 -> 643.
I haven't really used ruby, so I'm sure this could be golfed down, this is just an attempt:
l=%w[Work Make Do Harder Better Faster Stronger More Than Hour Our Never Ever After Over Faster,]
i,j,f,u,d=->x{l[x]+' It'},->x,y{l[x]+' It '+l[y]+' '},->a,b,c,d,e{a+' '+b+' '+c+' '+d+' '+e},'s Us ',l[6]
s,q,w,e,r,y,k=f[l[10],l[0],'Is',l[11],l[14]],j[0,3],j[1,4],j[2,15],j[2,5],->d,e{f[l[7],l[8],l[12],d,e]},l[1]+u
t,z,m=e+k,->a{puts q+w,t+d,y[l[9],a],s,''},y['','']
2.times{puts i[0],i[1],i[2],k,l[3],l[4],l[5],d,l[7]+' '+l[8],l[9],l[10],l[11],l[12],l[13],l[0]+' Is',l[14],''}
7.times{z[l[13]]}
puts q+i[1],t,f[l[7],l[8],l[12]+',',l[9],''],s,''
3.times{z['Af-']}
puts q,w,r+k+d,y[l[9],''],s,'',q,r,m,s,'',q,w,r,k+d,m,l[9]+' '+l[13],s

PowerShell, 659 Bytes
$a=@(" ","`n",",","Stronger","Make It","Do It","Makes Us","Harder","Better","Faster","Work It","More Than","Hour","Our","Never","Ever","After","Work Is","Over","Af-")
$z="1000070"
$y="01130017001400180101"
$x="010500090200060"
$v="00301110015001200"
$b="100104010501060107010801090103011101120113011401150116011701180101"
$c=$z+"0040008$x$v"+"16$y"
$d=$z+"20004$x"+"1110015020012$y"
$e=$z+"0040008$x$v"+"19$y"
$f=$z+"10400080105000900060003011100150012$y"
$g=$z+"105000901110015$y"+"10000701040008010500090106000301110015011200160113001700140018"
$($b,$b,$c,$c,$c,$c,$c,$c,$c,$d,$e,$e,$e,$f,$g|%{for($i=0;$i-lt$_.length;$i+=2){$a[$_.Substring($i,2)]}})-join''

Creates an array of keywords $a, then encodes the lyrics using a series of numerical strings which are sent into a for loop. The loop takes two-digit substrings, pulls the corresponding keyword from the $a array, and finally the -join'' concatenates it all together.
I think this is about as good as this method can be done, as every time I tried to golf further (e.g., replacing 040008 with a new variable), it turned out to be a couple bytes longer because the substring length wasn't enough to account for all the extra quotes needed. Though there have been some new answers posted since I started that have slightly different methods that look like they might be shorter in PowerShell (like using ASCII characters to encode, rather than two-digits, maybe?), I'm going to stick with this one.
Edit - forgot the replacement encoding I used:
00  <space>
01  `n
02  ,
10  Work It
04  Make It
05  Do It
06  Makes Us
07  Harder
08  Better
09  Faster
03  Stronger
11  More Than
12  Hour
13  Our
14  Never
15  Ever
16  After
17  Work Is
18  Over
19  Af-

if you got a way to get ascii code of a character thats easy to use then that should work out to shave off a bunch of bytes

GolfScript, 251 bytes golfed
'Work It
Make It
Do It
Makes Us
Harder
Better
Faster
Stronger
More Than
Hour
Our
Never
Ever
After
Work Is
Over

'2*.n/:a;56,{:@4%.2&+2*:^a=' ':|4^+a='jSRSSS]SSSSSST'81base 3@?/3%[|', 'n]=^)a=+@ 51%48/!*|237118176 2 55@-?/1&@44%32/'Af-'*5^+a=if^9/n*n}/

Try it online!
Eliminated unnecessary [] and simplified code accordingly. Changed i and j to @ and ^ to permit removal of whitespace. Assigned first occurence of ' ' to variable | to avoid repeating the same three characters.
GolfScript, First working version 262 bytes
'Work It
Make It
Do It
Makes Us
Harder
Better
Faster
Stronger
More Than
Hour
Our
Never
Ever
After
Work Is
Over

'2*.n/:a;56,{:i;[i 4%.2&+2*:j a=' '4j+a='jSRSSS]SSSSSST'81base 3i?/3%[' '', 'n]=j)a=+i 51%48/!*' '237118176 2 55i-?/1&i 44%32/'Af-'*5j+a=if j 9/n*n]}/

Try it online!
This is a port of my Ruby answer into golfscript using the same basic algorithm:  output the list of tokens twice, then riffle them into the verses and build the verses line by line, adjusting for the peculiarities of each.
There are a couple of differences. The number for the correct mid-line punctuation is in base 81 (conveniently this makes one printable ascii character per verse); and the number encoding whether or not to print the last token is modified because the index is 55-iinstead of i-28 (the latter was found to cause problems with negative powers generating fractional numbers instead of truncating to integer.)
Commented
'Work It
Make It
Do It
Makes Us
Harder
Better
Faster
Stronger
More Than
Hour
Our
Never
Ever
After
Work Is
Over

'2*                                               #make a string of all the tokens twice and push on the stack
.n/:a;                                            #duplicate the string, split into tokens at newline to form array. Assign to a
56,{:i;                                           #iterate through i= (0..55)
  [i 4%.2&+2*:j                                   #calculate j=(i%4+(i%4&2))*2 to cycle through 0 2 8 10.
  a=' '                                           #leave a[j] on stack followed by space (token A)
  4j+a=                                           #leave a[j+4] on stack (token B))
  'jSRSSS]SSSSSST'81base 3i?/3%[' '', 'n]=j)a=+   #leave ' ' ', ' or newline on stack as appropriate followed by a[j+1] (token C)
  i 51%48/!*                                      #multiply the data described in the previous line by  !(i%51/48)  (1 or 0)
  ' '                                             #leave a space on the stack
  237118176 2 55i-?/1&                            #leave 237118176/2**55-i & 1 on stack (true or false indicates token D required)
  i 44%32/'Af-'*5j+a=                             #leave i%44/32= 0 or 1 copies of 'Af-' on the stack. Leave a[j+5] on the stack.
  if                                              #depending on value of last but one line, select an option from the previous line.
  j 9/n*n]                                        #leave a newline on the stack. if 9/n is 1 or more (last line of verse) leave an additional newline
}/                                                #close the loop
                                                  #printing done by implied stack dump on program exit.

252 bytes. Use unused symbols as variable names to avoid whitespace, and store space (" ") in a variable. Also, don't pop after assigning to a variable out of habit.

@EriktheOutgolfer thanks for the tips, but I already posted a 251 byte version incorporating most of them. You spotted a space before 51 that I missed though. I will fix it later, and possibly look for other ways to shorten it. This is my first golfscript program, and I find them very hard to read when symbols are used as variables, hence I also left my 262-byte first working version up at least for now.

Ah you apparently did, lol.

Ruby, 486 Bytes
i=%w(Work\ It Make\ It Do\ It Makes\ Us Harder Better Faster Stronger More\ Than Hour Our Never Ever After Work\ Is Over)
z=i[1]+p+i[5]
y=i[2]+p+i[6]
x=z+n+y
w=i[3]+p+i[7]
v=i[8]+p+i[12]
u=w+n+v
t="Our "+i[14]+" Never Over"
s=i[0]+p+i[4]
r=i[9]+p+i[13]
n="\n"
p=' '
m=', '
a=i.join n
q=n+t
l=s+n
b=s+p+x+m+u+p+r+q
c=s+m+i[1]+n+y+m+i[3]+n+v+m+i[9]+q
d=b.gsub("After","Af-")
e=l+x+p+u+p+i[9]+q
f=l+y+n+v+q
g=l+x+n+u+n+r+q
def o s
s+"

"
end
puts o(a)*2+o(b)*7+o(c)+o(d)*2+o(d)+o(e)+o(f)+g

Python - 1056 Charaters
a,b,d,s,w,i,t,e,f,h,H,mi,mu,mt,ad,n,o,O="After","Better","Do It ","Stronger","Work ","Is ","It ","Ever ","Faster ","Harder ","Hour ","Make It ","Makes Us ","More Than ","Af-","Never ","Our ","Over"
owinO=o+w+i+n+O
mus=mu+s
df=d+f
dfmu=df[0:-1]+", "+mu
dfmus=df+mus
dfcmus=df[0:-1]+", "+mus
ha=h+a
Ha=H+a
mib=mi+b
mte=mt+e
mteh=mte+H
mtech=mte[0:-1]+", "+H
mtehad=mteh+ad
mteha=mteh+a
wi=w+i
wt=w+t
wth=wt+h
wthmt=wth[0:-1]+", "+mi
wthmib=wth+mi+b
E = ""
l =[wt,mi,d,mu,h,b,f,s,mt,H,o,n,e,a,wi,O,E,wt,mi,d,mu,h,b,f,s,mt,H,o,n,e,a,wi,O,E,wthmib,dfcmus,mteha,owinO,E,wthmib,dfcmus,mteha,owinO,E,wthmib,dfcmus,mteha,owin
O,E,wthmib,dfcmus,mteha,owinO,E,wthmib,dfcmus,mteha,owinO,E,wthmib,dfcmus,mteha,owinO,E,wthmib,dfcmus,mteha,owinO,E,wthmt,dfmu,mtech,owinO,E,wthmib,dfcmus,mteha
d,owinO,E,wthmib,dfcmus,mtehad,owinO,E,wthmib,dfcmus,mtehad,owinO,E,wth,mib,dfmus,mteh,owinO,E,wth,df,mte,owinO,E,wth,mib,df,mus,mte,Ha,owinO]

for ln in l:
    print ln

Still room for improvement with variable names, but its a start.

Might it help to separately write out a list of all your variable names so you can easily see which single letters haven't been used yet and then search-replace your long variable names?

Ruby, 483 bytes
puts "#{'a buc bud bucs eufuguhuiuj kulumuoupuqua rutuu'*2}#{'a b f c b gud b h, cs e iuj k p l qum a r o tuu'*7}a b f, c bud b h, cs euj k p, lum a r o tuu#{'a b f c b gud b h, cs e iuj k p l num a r o tuu'*3}a b fuc b gud b h cs e iuj k p lum a r o tuua b fud b huj k pum a r o tuua b fuc b gud b hucs e iuj k pul qum a r o tu".gsub /./,Hash[[*?a..?u,' ',','].zip %w{Work It Make Do Us Harder Better Faster Stronger More Than Hour Our Af- Never Ever After Is s Over}+[?\n,' ',',']]

Works by encoding every word used in the song to a single letter, multiplying some stanzas, then substituting the encoded letters with the actual lyrics. Commas, spaces are left as is. u is a newline.

Easter egg: contains the phrase fuc b gud

PHP, 434 Bytes
$m="Make It";$b="$m Better";$o="Our Work Is Never Over
";$u="Makes Us";$s="$u Stronger";$d="Do It";$f="$d Faster";$e="More Than Ever";$h="Hour";$w="Work It Harder";echo strtr("001111111$w, $m
$f, $u
$e, $h
$o
222$w
$b
$f $s
$e $h
$o
$w
$f
$e
$o
$w
$b
$f
$s
$e
$h After
$o",["Work It
$m
$d
$u
Harder
Better
Faster
Stronger
More Than
$h
Our
Never
Ever
After
Work Is
Over

","$w $b
$f, $s
$e $h After
$o
","$w $b
$f, $s
$e $h Af-
$o
"]);

Try it online!

PowerShell, 489 431 bytes
$d='8t11 4our Aft93t93t93t93t93t93t96Harder, Make It
Do It Faster, 0
More Than Ever, Hour
3-
3-
3-
6Hard95er 0 7n Ever Hour
6Hard9Do It Fast9More Than Ev96Hard9590 7n Ev9Hour Aft9Our 8s Never Over';'Makes Us~
Make2r
Our
Nev9Ev9Aft98s
Ov9
8t~ It
Do It
Makes Us
Hard9Bett9Fast97n
Hou~64our Af~Harder 5er, Makes Us 7n Ever H~Make It Bett9Do It Fast~Our 8s Never Ov9
8t ~Strong9More Tha~Work I~er
'-split'~'|%{$d=$d-replace+$i++,$_}
$d

Try it online!