text:
Find the area of the largest convex polygon
Given a list of integer coordinates, find the area of the biggest convex polygon you can construct from the list such that -

every vertex is in the list
no element of the list is contained within the polygon.

Example:

(0, 0) (8, 0) (0, 1) (3, 1) (7, 1) (1, 2) (5, 2) (9, 2) (2, 3) (5, 3) (7, 3) (3, 4) (5, 5) (11, 5)

Visualized:
o       o
o  o   o
 o   o   o
  o  o o
   o
     o     o

The biggest convex polygon you can make from this is this:
o
o  o
 o   o
  o  o
   o
     o

With an area of 12.

You may take the list of coordinates in any reasonable format, and should output (in an appropriate way for your language of choice) the area of the largest convex polygon, rounded to no less than 2 digits after the decimal point.
Additionally, you must employ some sort of algorithm, and not simply brute force all subsets of the points. To enforce this, your program must solve a list of 50 vertices in under a minute on a modern PC.
Shortest code in bytes wins.

Do you know of a fast algorithm for the worst case?

If you want to enforce a time limit on 100 vertices, you should probably include at least one such test case (ideally several, e.g. one where all 100 vertices are part of the solution, one where 99 are, and one where only 10 are).

@MartinBüttner Sadly, I can not generate this test case as I do not have a working implementation myself. The problem is rather tricky :)

@xnor A couple examples can be found here.

"rounded to no less than 2 digits after the decimal point"?

@DavidCarraher Your answer must be precise to 2 digits after the decimal point. So if the answer is 12 you may output 12, 12.00, 12.001 but not 12.01.

I think it'd also be interesting to see a version of this question, but instead the program must take an integer N and find the largest convex polygon contained in the image generated from primes up to N with a fixed width.

This is the kind of problem that should be posted on ProjectEuler.

You should have additional test cases.  In your test case, the vertices of the largest convex hull form a convex chain, namely, {{5, 2}, {3, 1}, {0, 0}, {0, 1}, {1, 2}, {2, 3}, {3, 4}, {5, 5}, {5, 3}}, on the "shortest tour" of the set.  Solutions do not always fall on the shortest tour, as I discovered after some effort.

@DavidCarraher I'm not exactly certain what you mean, but you're free to add test cases yourself.

It would have been better for me to say the "largest empty convex hull", that is, the "largest convex hole".

Javascript ES6, 738 bytes
((V,C,L,r,k,n,A,G,F,e,i,j,q)=>p=>{p=p.map((p,i)=>({i:i,x:p[0],y:p[1]}));A=(f,p,a,b,v,i)=>{for(i=p[n],v=V(a,b);i--;)if(f(v,V(a,p[i])))return 1};G=(p,i,a)=>{for(i=p[n]-1,a=C(p[i],p[0]);i--;)a+=C(p[i],p[i+1]);if((a/=2)>r)r=a};F=(p,s,l,f,a,b,v)=>(l=s[n],f=s[0],a=s[l-2],b=s[l-1],e[a.i][b.i]||A((a,b)=>C(a,b)?0:a.x<0==b.x<0&&a.y<0==b.y<0&&L(a)>L(b),p,a,b)?0:(p=(v=V(a,b),p[k](x=>C(v,V(a,x))>=0)),A((a,b)=>C(a,b)>0,p,b,f)?0:(p.map(q=>F(p[k](r=>q!==r),[...s,q])),s[2]&&!p[n]&&!e[b.i][f.i]?G(s):0)));e=p.map(x=>p.map(y=>x===y));for(i=p[n];i--;){for(j=i;j--;){q=p[k]((p,x)=>x-i&&x-j);F(q,[p[i],p[j]]);F(q,[p[j],p[i]]);e[i][j]=e[j][i]=1}}console.log(r)})((a,b)=>({x:b.x-a.x,y:b.y-a.y}),(a,b)=>a.x*b.y-a.y*b.x,v=>v.x*v.x+v.y*v.y,0,'filter','length')

Here's an ES5 or less version that should work in most browsers and node without tweaking: 827 bytes
eval("(%V,C,L,r,k,n,A,G,F,e,i,j,q){@%p){p=p.map(%p,i){@{i:i,x:p[0],y:p[1]}});A=%f,p,a,b,v,i){for(i=p[n],v=V(a,b);i--;)if(f(v,V(a,p[i])))@1};G=%p,i,a){for(i=p[n]-1,a=C(p[i],p[0]);i--;)a+=C(p[i],p[i+1]);if((a/=2)>r)r=a};F=%p,s,l,f,a,b,v){@(l=s[n],f=s[0],a=s[l-2],b=s[l-1],e[a.i][b.i]||A(%a,b){@C(a,b)!=0?0:a.x<0==b.x<0&&a.y<0==b.y<0&&L(a)>L(b)},p,a,b)?0:(p=(v=V(a,b),p[k](%x){@C(v,V(a,x))>=0})),A(%a,b){@C(a,b)>0},p,b,f)?0:(p.forEach(%q){@F(p[k](%r){@q!==r}),s.concat([q]))}),s[2]&&p[n]==0&&!e[b.i][f.i]?G(s):0)))};e=p.map(%x,i){@p.map(%y,j){@i==j})});for(i=p[n];i--;){for(j=i;j--;){q=p[k](%p,x){@x!=i&&x!=j});F(q,[p[i],p[j]]);F(q,[p[j],p[i]]);e[i][j]=e[j][i]=1}}console.log(r)}})(%a,b){@{x:b.x-a.x,y:b.y-a.y}},%a,b){@a.x*b.y-a.y*b.x},%v){@v.x*v.x+v.y*v.y},0,'filter','length')".replace(/%/g,'function(').replace(/@/g,'return '))

Code returns an anonymous function. As a parameter, it takes an array of points, like [[0,1],[2,3],[4,5]]. To use it you can place var f= before it, or if you want to use it from the command line, add (process.argv[2].replace(/ /g,'').slice(1,-1).split(')(').map((x)=>x.split(','))) to the end, and call it like node convpol.js '(1,2)(3,4)(5,6)'
Thanks for the challenge! As there is no reference implementation, I can't prove this is correct, but it is consistent at least for permutations of the point list. I almost didn't think this was going to work, as versions with debugging code, even disabled, were way too slow with exponential time increase. I decided to golf it anyway, and was pleased to see that it dropped down to under 2 seconds for 50 points on my machine. It can calculate approximately 130 points in 1 minute.
The algorithm is similar to the Graham scan, except that it has to search for empty convex hulls everywhere.
Explanation
Here's a high-level overview of how the algorithm works. The meat of this algorithm is just searching for counter-clockwise convex loops that don't enclose a point. The procedure is something like this:

Start with a pair of points, and a list of all other points.
If the current pair of points goes exactly through any point in the list, stop.
Filter out all points clockwise of the current pair, since they would make the polygon concave.
For all points left, do the following:

If a line from this point to the first point of the chain goes through or encloses any points counter-clockwise, skip this point, since any polygons would enclose the point.
Add this point to the chain, recurse from step 1 with the current chain and list of points.

If there were no points left, and the chain has at least 3 points, this is a valid convex polygon. Remember the largest area of these polygons.

Also, as an optimization, we record the initial pair of the chain as checked, so any searches afterwards upon seeing this pair anywhere in the chain can immediately stop searching, since the largest polygon with this pair has already been found.
This algorithm should never find a polygon twice, and I've experimentally verified this.

How many cases did you test it on?  And of what sizes?

I made a random point generator, which I've used to test up to 50x50 and 70 points, which runs in under 5 seconds. I'm not sure how to verify that it always finds the largest polygon, but it has in every test I've examined.

Sounds like you did a careful job.

+1, this is an amazing answer. You might be able to replace === and !== with == and !=, but I couldn't be sure without understanding your code...

Thanks! Those particular === and !== are comparing objects, so nope, sadly. It used to compare indices, but (x,i)=>p.i==i (13 chars) is quite a bit longer than x=>p===x (8 chars) even after optimization.

Ah well, that makes sense. Oddly that seemed to work when I tested the example. Seems you've done a thorough golfing job!

The algorithm is surprisingly sensitive to little things. While golfing, I would periodically alter the logic just enough to break some samples, but not others, particularly those with many co-linear points. Some of my logic-altering optimizations seemed to still work, but make me nervous.

Would you mind describing your solution in more detail? It looks very interesting.

There's an explanation for you @Lembik

You seem to have beaten the O(n^3) record mentioned in the comments of the linked SO question!

Alright, I'm getting to where I don't believe it is possible that this runs in less than O(n^3). I'm very new to algorithmic complexity.

After doing some perf testing, the algorithm is actually about O(n^4), it just works really fast on small numbers of points.


text:
Print all 2 letter Scrabble Words
The Challenge:
Print every 2 letter word acceptable in Scrabble using as few bytes as possible. I have created a text file list here. See also below. There are 101 words. No word starts with C or V. Creative, even if nonoptimal, solutions are encouraged.
AA
AB
AD
...
ZA

Rules:

The outputted words must be separated somehow.
Case does not matter, but should be consistent.
Trailing spaces and newlines are allowed. No other characters should be outputted.
The program should not take any input. External resources (dictionaries) cannot be used.
No standard loopholes.

Wordlist:
AA AB AD AE AG AH AI AL AM AN AR AS AT AW AX AY
BA BE BI BO BY
DE DO
ED EF EH EL EM EN ER ES ET EX
FA FE
GO
HA HE HI HM HO
ID IF IN IS IT
JO
KA KI
LA LI LO
MA ME MI MM MO MU MY
NA NE NO NU
OD OE OF OH OI OM ON OP OR OS OW OX OY
PA PE PI
QI
RE
SH SI SO
TA TI TO
UH UM UN UP US UT
WE WO
XI XU
YA YE YO
ZA

Do the words have to be outputted in the same order?

@Sp3000 I'll say no, if something interesting can be thought up

To avoid link rot, I've added your list to the question.Your list is the 2006 US list. The 2015 UK list contains significant differences, for example, it includes the words CH and ZO and has only very recently included ZA. I'm not clear what you mean by "something interesting." I think that means any order is acceptable, because you would be saying that some orders are arbitrarily acceptable and others not.

Would an at-sign be an acceptable separator? If the answer is yes, can I have a trailing at-sign?

Please clarify what exactly counts as separated somehow. Does it have to be whitespace? If so, would non-breaking spaces be allowed?

Similar idea to http://codegolf.stackexchange.com/q/39787/29750

Is there a site for looking up what these words mean? I've searched for "ZA" and ... short for Pizza. Really? I'd slap someone if they tried to use that "word" in scrabble

Ok, found a translation

Note that not only no word starts with C or V but no word really contain C or V. Maybe is useful for someone looking at bit optimization.

Vaguely related: http://codegolf.stackexchange.com/q/39787/15599

Is there a limit on running time, or can I proof that within a finite running time, a valid answer is given?

Vi isn't a word? News to me...

Any answers to this challenge from after 2018 should include the six new words DA EW GI OK PO TE :^)

Python 3, 194 188 bytes
s="BI ODEXIF BAAX ASOHER LOXUMOPAGOR KI US AMY BOITONOSI MMEMINANEHI UPI AYAHOYOWOMUNUHAID PEFARED QIS BEN JOFETAE KAT ABYESHMALI UTI ZADOELAWE "
while s:" "in s[:2]or print(s[:2]);s=s[1:]

Almost definitely not the shortest method, but I thought this would be a good start. Try to pack each pair into paths by overlapping as much as possible (e.g. "ODEX..." = ["OD", "DE", "EX", ...]). Spaces are used to separate paths, and any pairs with a space in it is removed (the trailing space is to prevent a single E from being printed at the end).
I also tried regex golfing this but it was longer.

+1 nice approach! I Borrowed your string for a Ruby answer

I also made an answer based on your idea using bash and regex

+1 for AYAHOYOWOMUNUHAID!

CJam, 96 94 bytes
0000000: 31 30 31 2c 22 5a 0a d0 fd 64 f6 07 a3 81 30 f2  101,"Z...d....0.
0000010: c2 a5 60 0c 59 0f 14 3c 01 dd d1 69 7d 66 47 6e  ..`.Y..<...i}fGn
0000020: db 54 e5 8f 85 97 de b9 79 11 35 34 21 cb 26 c3  .T......y.54!.&.
0000030: f0 36 41 2b b4 51 fb 98 48 fc cb 52 75 1f 1d b1  .6A+.Q..H..Ru...
0000040: 6b c3 0c d9 0f 22 32 36 30 62 33 36 62 66 7b 3c  k...."260b36bf{<
0000050: 31 62 32 35 6d 64 2d 35 35 7d 27 41 66 2b        1b25md-55}'Af+

The above is a hexdump, which can be reversed with xxd -r -c 16 -g 1.
Try it online in the CJam interpreter.
Depending on what exactly counts as separated somehow, the byte count could be lowered to 93 or even 92:

If we replace -55 with 59, the words will be separated by non-breaking spaces (0xA0).
If we replace -55 with W, the words will be separated by at-signs (0x40).

Idea
We can encode each pair of letters xy as (ord(x) - 65) × 25 + (ord(y) - 65).1
Instead of storing the resulting integers, we'll store the differences of all pairs that correspond to two adjacent words (sorted alphabetically).
The highest difference is 35, so we consider them digits of a base 36 integer and convert that integer into a a byte string.
Code
101,   e# Push [0 ... 100].
"…"    e# Push the string that encodes the differences/increments.
260b   e# Convert from base 260 to integer.
36b    e# Convert from integer to base 36 (array).
f{     e# For each I in [0 ... 100]:
       e#   Push the base 36 array.
  <    e#   Keep it's first I elements.
  1b   e#   Compute their sum.
  25md e#   Push quotient and residue of the sum's division by 25.
  -55  e#   Push -55 = '\n' - 'A'.
}      e#
'Af+   e# Add 'A' to all resulting integers. This casts to Character.

1 Since the second letter is never a Z, using 25 instead of 26 is enough.

PHP 224, 218, 210 206
foreach(explode(",","I19SR,9ZY8H,,CNK,5JRU0,H,CN4,G0H,H160,CN4,75,CU9,AMIHD,MTQP,HQOXK,7L,74,G,CXS,CU9,HTOG,,CNK,MHA8,CNL,1")as$a){$b++;for($c=0;$c<26;$c++)echo base_convert($a,36,10)&pow(2,$c)?chr(96+$b).chr(97+$c)." ":"";}

aa ab ad ae ag ah ai al am an ar as at aw ax ay ba be bi bo by de do ed ef eh el em en er es et ex fa fe go ha he hi hm ho id if in is it jo ka ki la li lo ma me mi mm mo mu my na ne no nu od oe of oh oi om on op or os ow ox oy pa pe pi qi re sh si so ta ti to uh um un up us ut we wo xi xu ya ye yo za

Definitely not a great score, but I liked the challenge.
I create a table of the options, created a bitwise system to flag which options are valid.

Then I base-36 encoded those options to get the string:
"I19SR,9ZY8H,,CNK,5JRU0,H,CN4,G0H,H160,CN4,75,CU9,AMIHD,MTQP,HQOXK,7L,74,G,CXS,CU9,HTOG,,CNK,MHA8,CNL,1"

Note the 3rd entry in that string array doesn't have a value, because C has no options.
To print the values, I just convert the valid options to chars.
There might be something I could do to reduce recognising that there are no words ending in C, J, K, Q, V or Z, but I can't think of a method to reduce it atm.

By transposing the table, there are more empty elements and the data encodes a little more compactly which shaved off a few bytes. The array is now printed in a different order:
foreach(explode(",","UB1YB,1,,CUP,CLMEJ,CUO,1,SG0H,5J9MR,,,H,MX01,MTXT,CYO5M,MTQ8,,CNL,MTXT,MHAP,50268,,CN5,CNL,FSZ,,")as$a){$b++;for($c=0;$c<26;$c++)echo base_convert($a,36,10)&pow(2,$c)?chr(97+$c).chr(96+$b)." ":"";}

aa ba fa ha ka la ma na pa ta ya za ab ad ed id od ae be de fe he me ne oe pe re we ye ef if of ag ah eh oh sh uh ai bi hi ki li mi oi pi qi si ti xi al el am em hm mm om um an en in on un bo do go ho jo lo mo no so to wo yo op up ar er or as es is os us at et it ut mu nu xu aw ow ax ex ox ay by my oy

Thanks to Ismael for the explode and for loop hints.
foreach(explode(3,UB1YB3133CUP3CLMEJ3CUO313SG0H35J9MR333H3MX013MTXT3CYO5M3MTQ833CNL3MTXT3MHAP35026833CN53CNL3FSZ)as$d)for($e++,$f=0;$f<26;$f++)echo base_convert($d,36,10)&pow(2,$f)?chr(97+$f).chr(96+$e)." ":"";

With an update to php5.6, pow(,) can be replaced by ** saving another 4 bytes.
foreach(explode(3,UB1YB3133CUP3CLMEJ3CUO313SG0H35J9MR333H3MX013MTXT3CYO5M3MTQ833CNL3MTXT3MHAP35026833CN53CNL3FSZ)as$d)for($e++,$f=0;$f<26;$f++)echo base_convert($d,36,10)&2**$f?chr(97+$f).chr(96+$e)." ":"";

Instead of exploding by ",", you can use explode(0,UB1YB0100CUP[...])

Wouldn't that break since there are 0s in the encoding?

However.. there isn't a 3 I can use that! Thanks

Also, you can replace $e++;for($f=0;$f<26;$f++) with for($e++,$f=0;$f<26;$f++), and now you can remove those pesky {}. And if you want to convert chars to lowercase, use $e^' '.

Good catch! I wouldn't have got that one.

I'm glad I've helped you. I'm trying to find what else to reduce

Ruby, 166 bytes
Borrowing sp3000's neat method for encoding the words into a compact string. The kicker here is the short method for decoding it back into the two-letter words: Using a lookahead in the regex passed to String's scan method in order to extract  overlapping matches, not containg space:
puts "BI ODEXIF BAAX ASOHER LOXUMOPAGOR KI US AMY BOITONOSI MMEMINANEHI UPI AYAHOYOWOMUNUHAID PEFARED QIS BEN JOFETAE KAT ABYESHMALI UTI ZADOELAWE".scan /(?=(\w\w))/

Ruby, 179 bytes
My own approach: Generate all two-letter words between AA and ZA, and select the valid ones using a base 36 encoded bitmask:
i=-1
puts ("AA".."ZA").select{|w|"djmsjr5pfw2omzrfgydo01w2cykswsrjaiwj9f2moklc7okcn4u2uxyjenr7o3ub90fk7ipdq16dyttg8qdxajdthd6i0dk8zlmn5cmdkczrg0xxk6lzie1i45mod7".to_i(36)[i+=1]>0}

Perl, 167 164 157 bytes
"AMAEDOXUHALAXISHENUNUPABEFAHIDEMYESOHOSITAAGOYAYAWOWETOINODOREX KIFEHMMER BYONELI BOEMUS PELOMI UMOFAD BATAR KANAS JOPI UTI ZAI BI QI"=~/$_/&&say for AA..ZZ

Wrote a separate script to group the letters together as compact as possible into a string that contained all the valid 2 letter words. This then iterates over all of the two letter words and prints the valid ones, one per line. Run with perl -M5.10.1 script.pl.

I can't get this to work in an online compiler.

@mbomb007 Depending on the version, you either need the command line flag -M5.10.1 to use the say keyword added in that version, or add use feature 'say'; in the body of the script.

C,155 bytes
Golfed version
i,v;main(){for(;++i-408;" >b  Ùc :oÒ¹ i ;¹ w so@)ia ¥g¨¸ ´k¦ase    Ù{§k {"[i/8]>>i%8&1||printf("%c%c%c ",i/8%2*v,i/16+65,!(i/8%2)*v))v="YUOIEMHA"[i%8];}

Output
YA HA AA BY BO BI BE BA AB DO DE OD ID ED AD YE OE HE AE FE FA OF IF EF GO AG UH OH EH AH OI HI AI JO KI KA LO LI LA EL AL MY MU MO MI ME MM MA UM OM EM HM AM NU NO NE NA UN ON IN EN AN YO HO PI PE PA UP OP QI RE OR ER AR SO SI SH US OS IS ES AS TO TI TA UT IT ET AT WO WE OW AW XU XI OX EX AX OY AY ZA

Ungolfed version
The 51-byte magic string in the golfed version contains many characters beyond ASCII 126, which have almost certainly been mangled into Unicode equivalents. The ungolfed version uses hex instead, and as a constant rather than a literal. Also, the ungolfed version separates the words with a newline, which makes it easier to copy and paste into Excel, order the list and compare with the required one.
char a[]=
{0xFF,0x3E ,0x62,0x7F ,0xFF,0xFF ,0xEB,0x63 ,0xFF,0x3A ,0x6F,0xE3 ,0xFB,0x7F ,0xFF,0x69 ,0xFF,0x3B
,0xFB,0xFF ,0x77,0xFF ,0x73,0x6F ,0x40,0x29 ,0x69,0x61 ,0xFF,0xBE ,0x67,0xF9 ,0xF7,0xFF ,0xEF,0x6B
,0xB3,0x61 ,0x73,0x65 ,0xFF,0xFF ,0xFF,0xFF ,0xEB,0x7B ,0xF5,0x6B ,0xFF,0x7B ,0x7F};

//iterate through i = 16*letter + 8*order + vowel
i,v;main(){for(;i++-408;a[i/8]>>i%8&1||printf("%c%c%c\n",i/8%2*v,i/16+65,!(i/8%2)*v))v="YUOIEMHA"[i%8];}

Explanation
If we expand the definition of vowel to include the 8 letters AHMEIOUY, we observe that all words consist of one vowel and one other letter (which may or may not be a vowel.) Therefore, for all the words ending in a vowel, we need a table of 26 bytes, one for each first letter, with the individual bits corresponding to the vowel. We need a similar table for the words starting with a vowel, except that this time we only need 25 bytes, as there is no word ending in Z. The two tables are riffled together to create the final table.
In order to avoid any ASCII codes in the region 0..31, the two least common "vowels" M and H are assigned to the 6th and 7th bit, and the encoding considers 1 for an invalid word and 0 for a valid word. Since there is no consonant which pairs with both M and H it is possible to ensure at least one of these bits is a 1.
The 8th bit is assigned to A, which is the most common vowel, to try to limit the non-ASCII characters (still there are rather a lot of them.)
The tables used are below. For words containing 2 vowels, I gave priority to the first letter as being considered the "vowel" and the second letter as the "letter." An exception to this is words starting with M, as this avoids a clash between MM and HM.
Hex encoding of words starting with a vowel
3E 7F FF 63 3A E3 7F 69 3B FF FF 6F 29 61 BE F9 FF 6B 61 65 FF FF 7B 6B 7B

AA AB    AD AE    AG AH AI       AL AM AN          AR AS AT       AW AX AY
HA          HE          HI          HM    HO

         ED    EF    EH          EL EM EN          ER ES ET          EX
         ID    IF                      IN             IS IT
         OD OE OF    OH OI          OM ON     OP   OR OS          OW OX OY
                     UH             UM UN     UP       US UT
YA          YE                            YO

Hex encoding of words ending with a vowel
 A  H  M  E  I  O  U  Y
                         FF
BA       BE BI BO    BY  62
                         FF
         DE    DO        EB
                         FF
FA       FE              6F
               GO        FB
                         FF
                         FF
               JO        FB
KA          KI           77
LA          LI LO        73
MA    MM ME MI MO MU MY  40
NA       NE    NO NU     69
                         FF
PA       PE PI           67
            QI           F7
         RE              EF
    SH      SI  SO       B3
TA          TI  TO       73
                         FF
                         FF
         WE     WO       EB
            XI     XU    F5
                         FF
ZA                       7F

Maybe make a hexdump of the golfed version so the mangling can be reverted easily

Java, 484 448 407 391 389 bytes
My first try
public static void main(String[]a){int[]x={57569742,35784706,0,2099200,5534148,35651584,2048,35792896,5247168,2048,33685504,33687552,35794978,35653664,7746958,35782656,131072,2097152,395264,33687552,551296,0,2099200,131104,35653632,33554432};for(Integer i=0;i<26;i++){for(int z=0;z<26;z++){if("".format("%26s",i.toString(x[i],2)).charAt(z)=='1'){System.out.format("%c%c ",'A'+i,'A'+z);}}}}

Formatted:
public static void main(String[] a) {
    int[] x = { 57569742, 35784706, 0, 2099200, 5534148, 35651584, 2048, 35792896, 5247168, 2048, 33685504, 33687552, 35794978, 35653664,
            7746958, 35782656, 131072, 2097152, 395264, 33687552, 551296, 0, 2099200, 131104, 35653632, 33554432 };
    for (Integer i = 0; i < 26; i++) {
        for (int z = 0; z < 26; z++) {
            if ("".format("%26s", i.toString(x[i], 2)).charAt(z) == '1') {
                System.out.format("%c%c ", 'A' + i, 'A' + z);
            }
        }
    }
}

Try it online

Nice job! Some suggestions: java.lang.Exception can just be called Exception. "args" can be just "a". String.format() can be "".format(). There is also a little extra spacing in the main() declaration. Nice approach overall though, +1 from me :)

I've just been playing with the print statement, but you beat me to it! You can save another byte by replacing \n with just a space. They don't have to be separated by new lines.

You've also missed a few spaces that you can remove.

@JamesWebster thx for the hints.

"".format is painful to look at, but hilarious.

just figured out, I can save 2 characters by making the counter variable i an Integer and call the static toString(...) on i

also String[] a gpt one unneeded whitespace, after []s you can shave em off

Malbolge, 2118 bytes
D'``_#>nI||38h6/vdtO*)_^mI7)"XWfB#z@Q=`<)\xwvuWm32ponmfN+ibJfe^$\[`Y}@VUySXQPUNSLpJINMLEiC+G@EDCB;_?>=}|492765.R210p(-,+*#G'&feB"baw=u]sxq7Xnsrkjoh.fNdchgf_%]\a`Y^W{>=YXWPOsSRQ3OHMLKJIBfF('C<`#"8=<;:3W1w5.R2+q/('&J$)"'~D$#"baw=utsxq7Xnsrkjoh.fNdchgf_%c\D`_X|\>=YXWPOsSRQ3OHMLKJIBfFEDC%$@9]=6|:32V6/.3210)M-m+$)"'&%|Bcb~w|u;yxwvuWm3kpinmfe+ihgfH%cb[ZY}]?UZYRWVOs65KPIHGkKJIH*)?c&BA@?8\6|:32V6/.3210)M-,lk)"F&feBzbxw=uzyrwpon4Ukpi/mfkdc)g`ed]#DZ_^]VzZ<;QPt7MLQPOHlFEJIHAe(>C<;_?>765:981Uv.32+*)Mnm%$)(!Efe{zy?}|{zyxqpo5mrkpoh.fNdihg`ed]#DZ_^]Vz=YRQuUTMqQ32NMLEDhHG@(>C<;_?>76;:3W76v43,+O/.nm+*)"Fgf${z@a}v{zyr8vo5Vrqj0nmfN+Lhg`_%cbDCY}@VUySRWPt76Lp3ONMLEDhHG@(>C<;_"8\6|:32V0v.Rs10/.'&+$H('&feB"!x>|^]srwvun4Ukpi/gfe+Lbaf_%cE[`Y}@?[TxRWPUNMLKo2NGFjD,BAeED&<A:^>=6|:32V6v.R21*/(L,+*#"!E}|{z@xw|{t:[qpotsrk1Rhmlkd*Kgfe^$bDZ_^]VzZ<;QuUTMqKJOHGkEJCBA@dD=<;:^>=6|:32V654t,+O).',+*#G'&feBzbx>|^]yr8vXnsrkjoh.fkdcbg`&^Fba`Y^WVzZ<XWPUTMqQ3INMFjD,BAe?>=B;_9>7<54X8765u-Q10)o'&J$)"!~%${A!x}v<]\xwpun4rTpoh.leMchgf_d]#DZ_^]VzZYR:Pt7SLKPOHlFEJIHAeED&<`@"87<5Y98165.3,P*/(-&+$H(!~}C#c!x}|u;\[wvun4lTjih.fN+Lbgfe^c\"CY}@VUyYXWPOsSRKJIHlLE-IBAeE'&<`@"87<5Y98165.3,Pq/.-,+*#G'&fe#"!x>|{zyr8Yotml2ponPlkdcb(fH%]\[`Y^W{zZ<XWPUTMq4JIHMLEi,BA@d>=B;:9]7};:3W7wv.3,+O)o'&J*)('g%${Ay~}v{zyrq7otmrqpoh.fejiha'eG]\[ZY}@VUy<;WVOsSRQPImM/KJIBAe(>=aA:^>=6|:32V65u-Qr0/.'K+$j"'~De#zy~wv<]yrqpo5srkjohg-kdib(feG]b[Z~^]\UTYRvP8TSRKJIHlLKD,BAe?>=B;_?>7<;:981U54t,+O)o'&Jkj('&}C#"bx>_{tyr8vuWVl2pihgle+ihgfH%cEDZ~XWVUy<XWPUTMqQP2NGLEiCBGF?>b%A@?87[;:zy1U54t210/.'K+$j"'~De#zy~wv<zyxwp6Wmlqpohg-kdib(feG]ba`Y^W{>=YXWPOs65KJIHl/KJIBA@dDCB;:9]=<;:zy1Uvu3,P0)o'&J$#(!~D|#"y?}v{zyr8vXnml2ponPledc)gfH%c\D`_^]VzZ<;QVOTSLpPIHGkKJCBG@dD=<;:^>=6|:32Vw543,+*N.nm+*)"F&feB"y~}|{ts9qvonsl2ponmfN+Lha`e^$\[Z_X|\UTYRQVOsM5KJOHGFjD,BA@d>=B;:9]=};4X81w5.R210)o'&J$j"'~%|{"y?w_u;y[wpun4Ukponmfe+Lha'eGc\[!B^WV[TxXQ9ONrRQ32NMLEDh+AeE'&<`#"8=<;:3W7wv.3,+O/.'m+*)(!EfeBcbx>_{tsxwvun4Ukpi/POkdcha'_d]#DZ_^]VzZ<RQPUNMqQ3ONGkE-IBAeED=BA:9]=<|43870/St,+O/.-ml*)(!Ef|Bcb~w|u;y[Zvun4rTpoh.fN+cKgf_%cE[!BXWV[ZSwWP8TSLpJIHMLEJIBf)d'=aA@">=<5Y98165.3,Pq)('K%*#"!EfeBcyxwvu;yxwvuWm3~

Try it online!

Matlab, 177 bytes
Generate a binary matrix defining all allowed pairs of letters, reshape it and base-64 encode it. The base-64 encoded string ('CR+ ... %  ') is used as data in the program. The program reverses operations to unpack the matrix, and then reads the allowed pairs:
x=de2bi('CR+"''        1$$ L*\"%$!! !   $!04P@<W(        0$   1"%$$100@RZP4  $$    0$ ! 1$$$$1 0  P (    $ 0 0$ ! # %  '-32)';[i,j]=find(reshape(x(1:650),26,[])');char([j i]+64)

Nice one Luis! Golfing is actually kind of fun... =P

Nice! There is no alphabet!

hats off. This is the most cryptic matlab code i've seen in ages ...

Thanks guys! It's only cryptic because of the base-64 encoding. That string actually packs the 26x25 binary matrix of allowed letter pairs

(Warning, this answer is not programmatically interesting)
Since all words are two characters long, we can smash them all together and then rip them apart again using a simple regular expression.
Any regex-friendly language can do this, some more efficiently than others:
Grep (via Bash), 215 bytes
grep -o ..<<<AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATIT

Javascript, 224 bytes
alert("AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATITOUHUMUNUPUSUTWEWOXIXUYAYEYOZA".match(/../g))

Perl, 225 bytes
 $_="AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATITOUHUMUNUPUSUTWEWOXIXUYAYEYOZA";s/../$&\n/g;print

Python, 245 bytes
import re
print re.sub(r'..','\g<0>\n',"AAABADAEAGAHAIALAMANARASATAWAXAYBABEBIBOBYDEDOEDEFEHELEMENERESETEXFAFEGOHAHEHIHMHOIDIFINISITJOKAKILALILOMAMEMIMMMOMUMYNANENONUODOEOFOHOIOMONOPOROSOWOXOYPAPEPIQIRESHSISOTATITOUHUMUNUPUSUTWEWOXIXUYAYEYOZA")

As a note, some of the answers here are longer than echo, which I'd consider a baseline:
POSIX shell, 307 bytes
echo AA AB AD AE AG AH AI AL AM AN AR AS AT AW AX AY BA BE BI BO BY DE DO ED EF EH EL EM EN ER ES ET EX FA FE GO HA HE HI HM HO ID IF IN IS IT JO KA KI LA LI LO MA ME MI MM MO MU MY NA NE NO NU OD OE OF OH OI OM ON OP OR OS OW OX OY PA PE PI QI RE SH SI SO TA TI TO UH UM UN UP US UT WE WO XI XU YA YE YO ZA

+1 for being practical. Really, providing the base echo is the point everyone should start from.

+1 on easy answer, but you should be marking that as non competing, shouldn't you?

@MatthewRoh – If there were a leader-board parser, it would probably fail to find anything since I intentionally didn't start with a heading.  I'm not worried, especially since there are shorter answers for every language I've posted.

Bash, 179 bytes
echo U`sed -r 's/./& &/g'<<<HAABADEDOEFAEHELAGOFEMAHINAISHMENERESITALOHOMMONOPAMUMYAWETOSOWOYOXUNUPEXI`F `grep -o ..<<<ANARASATAXAYBEBIBOBYJOKAKILIMIOIDOIDORPIQITIUSUTYEZA`

Saved 7 bytes thanks to Adam Katz comment

It uses sed to do regex replacement. First regex input is based on Sp3000 idea while second regex uses common input without spaces.
Explanation:
echo              print to standard output the following
U                 boundary U character
sed -r [etc]      the result of replacing regex
    .             select a character
    & &           replace it for: matched char, space, matched char
    g             do it globaly for every character
    <<<HAAB[etc]  string input based on Sp3000 idea => HA AA AB ...
F                 boundary F character
sed -r [etc]      the result of replacing regex
    ..            every two characters
    <space>&      for space+matched character
    g             do it globally
    <<<ANAR       normal input => AN AR ...

You can shrink that by seven bytes using a space and then \grep -o ..in place of`sed -r 's/  / &/g'`, a trick from my answer below.

CJam, 100 98 bytes
'A'@" ©Ô&ñ±ð¨9_AÚá¼thÁätÑû¨HÙH&J3p¼ÛèVçckùá%´}xà41"260bGb{_{+N2$2$}{;;)'@}?}%-3<

(permalink)

Saved two bytes via preinitialized variables (thanks Dennis!)

This is my first CJam entry, so there is probably the potential for some more golfing.  However, I came up with a way to compress the list of characters down to 63 bytes which, hopefully, someone else will find helpful.
Compression Method
So far most methods that I saw encoded both letters of each word.  However, when we put the words in alphabetical order, the first letter doesn't change very often, so it seems wasteful to encode it explicitly.
I encode only the last character of each word, and include a special item whenever the first character should increment.  The characters are encoded as the first character, then a list of differences.  Since there are no duplicate words, the differences must all be at least 1.  Thus I can use 0 as a separator item.  (Note that I must then store the first letter of each subsequence as one-indexed, otherwise there would be confusion between 'rollover first character 0' and 'start with A 0'.)
Since the differences in this case are never greater than 15, we can use base-16 and pack two (4-bit) items into each (8-bit) byte.  (In the actual code I converted from base-260 instead of base-256 to avoid issues with unprintable characters.)

You can save a couple of bytes by using G and N, which push 16 and a linefeed.

@Dennis Thanks, didn't realize variables were preinitialized!

All 26 uppercase letters are preinitialized variables. You can see the complete list here.

You can save more bytes by replacing %-3< with /;; or even /&. (The second option will generate an error message. Consensus on meta is that it's OK to do this.)

Zsh --braceccl, 163 bytes
s=(ABDEGHILMNRSTWXY AEIOY EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST EO IU AEO A)
for c ({ABD-UW-Z})echo $c{$s[++i]}

Try it Online!
Previously: 169 bytes
, 175 bytes
, 182 bytes

A few simple golfs

Python 3, 148 bytes
a=97
for n in b"!B$E'Hil-Nr3TWx9aEio9eodfHl-Nr3TxaEOaEi-odfN3TOaiaioaEi-ou9aEoudEfHi-N0r3Wx9aEiI%(ioaio(-N03TeoIuaEoa":a+=n%3;print("%c%c"%(a,n|96))

Try it online!
Prints lowercase.
The idea is to encode, for each of the 101 two-letter Scrabble words in order:

Whether the first letter is 0, 1, or 2 positions higher than the previous word's (3 options)
The second letter (26 options)

The 78 potential values fit easily in one byte per each entry n, and moreover within printable 7-bit ASCII.
The second letter is encoded in the last five bits, which lets the expression 96|n set the first two bits to ones to get its lowercase ASCII value. The first letter delta (0, 1, or 2) could be encoded in the first two bits, but it's golfier to extract it as n%3 by setting those two bits to whichever of 01, 10, or 11 gives the right value. Avoiding 00 let us avoid hitting unprintable characters in the range 0 to 31.
This answer uses 101 bytes for the hardcode data string and the other 47 bytes for extraction logic, so it's over 2/3 data. The data can surely be compressed further, but of course at a tradeoff to extraction.
Thanks to mousetail for posting a Python answer whose incremental-delta technique inspired this one.

C#, 348 bytes
I had a go:
using System;class A{static void Main(){var a=new System.Collections.BitArray(Convert.FromBase64String("tnOciwgCCAAAAAggAFBxHIkAAAAACICIKABQQBgAAAIgIACAgCAAIqIgigCCADfWuIgAAAACAIAAAAAwCICAIAAAYRkAAAAAAggAgAAIIoAACA=="));int c, d;for(var i=0;i<652;i++){if(a[i]){c=Math.DivRem(i,26,out d);Console.Write("{0}{1} ",(char)('A' + c),(char)('@' + d));}}}}

Ungolfed:
using System;

class A
{
    static void Main()
    {
        var a = new System.Collections.BitArray(Convert.FromBase64String(
            "tnOciwgCCAAAAAggAFBxHIkAAAAACICIKABQQBgAAAIgIACAgCAAIqIgigCCADfWuIgAAAACAI" +
            "AAAAAwCICAIAAAYRkAAAAAAggAgAAIIoAACA=="));
        int c, d;
        for(var i = 0; i < 652; i++)
        {
            if(a[i])
            {
                c = Math.DivRem(i, 26, out d);
                Console.Write("{0}{1} ", (char)('A' + c), (char)('@' + d));
            }
        }
    }
}

This is a codegolf challenge, so you should post your byte-count (length of your code). Also try to shorten it a bit, for instance by removing whitespace.

@Jakube, is that better?

Yes, looks o.k.

C - 228 217 Bytes - GCC
 _;main(){char *z,*i="AABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EOU IEO A A ";for(z=i;_++^26;)for(;*++z^32;putchar(_+64),putchar(*z),puts(""));}

Will update if I can get it smaller, just compile with gcc -w, ./a.out outputs perfectly. If there's any interest in an ungolfed, let me know.
I can't think of any way to shorten it off the top of my head, (you can technically remove the quotes in puts and you'll still get a correct answer, the output just looks like garbage) so please let me know of anyways to shorten it

Here's a few suggestions, it runs fine for me (don't just copy and paste, stack exchange inserts weird control characters into comments)_;main(){char*z="AABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EOU IEO A A ";for(;_++^26;)for(;*++z^32;printf("%c%c ",_+64,*z));} I've changed the output delimiter from a newline to a space, but if you prefer a newline (one extra byte) change the printf format string to "%c%c\n"

Pyth, 140 bytes
K"aeiou"=H+-G+K\zKL.[`Z25.Bib32jdSfTs.e.e?nZ`0+@Gk@HY""byMc"ljjns 1u  a 6jji0 o 2 100u 60hg0 2 k m 101v r 6hr7c s 4 8 g006 m hpg0  a 5 q g"d

Try it online!
Compression method: Since there's no Z in the second position of any word, use the reordered alphabet bcdfghjklmnpqrstvwxyaeiou to encode the validity of each of those letters as a second letter for each first letter (first letters are in alphabetical order).
This is 25 bits per letter, or exactly 5 Base-32 digits. Since most consonants only take vowels as the second letter, I put vowels at the end to get mostly 1-digit numbers for them. I'm sure it could overall be improved by further analysis and reordering of the alphabet, although then the definition of the reordered alphabet would take up more bytes.
Explanation
K"aeiou"=H+-G+K\zK # Define the reordered alphabet
K"aeiou"           # K := "aeiou"
        =H         # H :=
           -G      #      G.removeAll(
             +K\z  #                   K + "z"
          +      K #                           ) + K

L.[`Z25.Bib32      # Define a lambda function for decompression
L                  # y = lambda b:
         ib32      # convert b to int using Base 32
       .B          # convert to binary string
 .[`Z25            # pad to the left with "0" to the nearest multiple of 25 in length

                           c"..."d # split the compressed string on " "
                         yM        # Apply y (above lambda) to each element
                                   #   Intermediate result: List of binary strings
                                   #   with 1s for allowed combinations
      .e                           # map over ^ lambda b (current element), k (current index):
        .e              b          # map over b: lambda Z (cur. elem.), Y (cur. ind.):
               +@Gk@HY             # G[k] + H[Y] (G is the regular alphabet)
          ?nZ`0       ""           #     if Z != "0" else ""
     s                             # combine into one large list
   fT                              # remove all falsy values (empty strings)
  S                                # sort (if any order is possible, remove this)
jd                                 # join on spaces (if a normal list with the words is
                                   #   allowed, remove this)

Python, 174 158 bytes
-16 bytes thanks to @xnor
a=0
for x in b"BCBCBBDBBEBBDBBDEEGKcKQCCEBBEBBEEEfNEEECQCIFBWNITIGNEEECGEDEKGKBBCBEBCCBEBBDEE\X_BGNIGUFBCDBhKVMHEKN_":print('%c%c'%(a//27+65,a%27+65));a+=x-65

Attempt This Online!
String encodes the difference between each successive word. To find the word we need to sum all the letters then divmod 27. I beleive this is the shortest python answer so far.

Neat approach! Down to 158 bytes

Python 3, 169 bytes
p,a="z",96
for i in "abdeghilmnrstwxyaeioy!!eodfhlmnrstxae!oaeimodfnstoaiaioaeimouyaeoudefhimnprswxyaeiie!hioaiohmnpst!!eoiuaeoa":print((chr(a:=a+(i<=p))+i)*(i>"_"));p=i

My first code golf. Uses a list of the second letter for each combination alphabetically, and changes the first letter if the next character is smaller than the previous (new set of words). Exclamation points are added to break up sections where the next character would be larger than the previous and to skip C and V.

Welcome to Code Golf, and nice answer!

163 bytes, moving the logic outside the print and using operator chaining to make it happen conditionally.

You can save a byte with the initial condition p,a="",97. Python 2 would allow p=a=97, but Python 3 isn't as permissive in comparing objects of different types.

Python 3, 224 bytes
s='';i=int("AQHU9HU1X0313T1J9OMYMZZSRFWLCYT3POSE06UGHXDZN6H5SQSZIFCE6VEB",36)
for c in range(26):
 b=i%6;i//=6;k=(1<<b)-1;j=i%(1<<k);i>>=k
 for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':
  if j&1:s+=chr(c+65)+d+' '
  j>>=1
print s

Uses bit masks of variable length to encode which second letters exist for each possible first letter. The bit masks can be 0,1,3,7,15 or 31 bits long. Bits are mapped to letters with for d in 'AOIEHMUSTMNDFPYBCGJKLQRVWXZ':, earlier bits are used for more common letters so that the bit masks can be short in most cases (usually 3 or 7 bits since most consonants are only followed by one of 5 vowels or Y M or H). Unfortunately the code to decode it negates the savings compared to more simple methods (the original list is only 303 bytes).

I discovered it's better to encode which first letter exists for each possible second letter in my solution. Might be worth trying in yours.

PHP: 211 209 204
You have to turn warnings off, otherwise one will print in regards to the implicit creation of $b
for($a=65;$b<strlen($c="ABDEGHILMNRSTWXY!AEIOY!EO!DFHLMNRSTX!AE!O!AEIMO!DFNST!O!AI!AIO!AEIMOUY!AEOU!DEFHIMNPRSWXY!AEI!I!E!HIO!AIO!HMNPST!EO!IU!AEO!A");$b++)if($c[$b]!='!')echo chr($a).$c[$b].' ';else$a++;

Very fun. Early attempts were in the 250 range, but this is my slimmest yet.

Try this byte counter. Note that turning off whitespace counting is incorrect, since it also discounts any spaces you have in strings, so your score should be more than 186.

Good catch. I've updated my submission accordingly

I can't see why.. but this now just prints "A A A A A..."

You've taken out the ! on the if.. you needed that.

Right. I just noticed that. I was using ! delimiter earlier and I did a quick find-replace without considering what would happen first.

But there are plenty of places this can be reduced. $b=0 can be omitted completely, it doesn't need initialising. The parenthesis around $c=.. can be removed.

I think the entire if.. echo could be in a ternary, but I'm yet to figure it out. And even then it might not be shorter.

As far as I am aware, the if.. cannot be removed (php does not like an echo inside the ternary, and you can't echo the result of the ternary because $a will be echoed)
Additionally not explicitly setting b produces a "stack notice" warning which breaks the output. If that's fine, then it goes down to 204 or 205 I believe. I've updated my response to include your other suggestions, however

Yeah I haven't found a way to reduce the if without printing the $a++ When I tried it without the $b=0 I didn't get any warnings.. I'd say that counts. You can require specific set ups for your answer to work.

I like this and @Jake's answer - it's a simple approach that has very little overhead. Good job :)

CJam (99 bytes)
This includes a few special characters, so it's safest to give a hexdump. (In particular, the character with value 0xa0, corresponding to a non-breaking space, caused me quite a bit of trouble in setting up the online demo).
00000000  36 37 36 22 c4 b2 2d 51  3f 04 93 5c 64 6c 8d 6e  |676"..-Q?..\dl.n|
00000010  d7 f9 7d 97 29 aa 43 ef  04 41 12 e1 aa ce 12 4d  |..}.).C..A.....M|
00000020  05 f3 1c 2b 73 43 a0 f0  41 c0 a7 33 24 06 37 a3  |...+sC..A..3$.7.|
00000030  83 96 57 69 9b 91 c4 09  c3 93 e1 ed 05 3b 84 55  |..Wi.........;.U|
00000040  d9 26 fd 47 68 22 32 35  36 62 33 38 62 7b 31 24  |.&.Gh"256b38b{1$|
00000050  2b 7d 2f 5d 7b 32 36 62  28 3b 36 35 66 2b 3a 63  |+}/]{26b(;65f+:c|
00000060  4e 7d 2f                                          |N}/|
00000063

Online demo.
The approach is difference-encoding in base-26.

Adding a character to an integer yields a character, so you can replace 65f+:c with 'Af+.

True. And md is a brilliant improvement, but I hadn't realised how close my answer is to yours.

Stax, 91 bytes
âG→æ£ilæα¿:√▒▓uøD¶[│█æä║¢v┼T↨σªΩ■&*φòb¡CÆ?ì▀┬6ù═╦±qBF!╘π╓╙'♣*ù&↕!£ä3±r⌡W-╓D╬☺╝ï╜²á5Æ÷§═ôφF;

Run and debug it
The only neat trick this answer uses is using the "," token to show a change in the first letter, rather than storing it for every word.
Thanks to recursive for the idea of using the m operator

Nicely done.  There are a couple of small optimizations I can see.  Use M instead of 1/, and use a shorthand map m instead of explicit foreach and print { ... PF. This one packs to 89.

brainfuck, 1371 bytes
Quite golfable, but I didn't put too much effort into it.
>+[+[<]>>+<+]>[-<<+<+>>>]-[-[-<]>>+<]>-[-<<<<+>>>>]<<<<<<..>>.<<.>+.>.<<.>++.>.<
<.>+.>.<<.>++.>.<<.>+.>.<<.>+.>.<<.>+++.>.<<.>+.>.<<.>+.>.<<.>++++.>.<<.>+.>.<<.
>+.>.<<.>+++.>.<<.>+.>.<<.>+.>.<------------------------<+.>.>.<<.>++++.>.<<.>++
++.>.<<.>++++++.>.<<.>++++++++++.>.<--------------------<++.>.>.<<.>++++++++++.>
.<-----------<+.>.>.<<.>++.>.<<.>++.>.<<.>++++.>.<<.>+.>.<<.>+.>.<<.>++++.>.<<.>
+.>.<<.>+.>.<<.>++++.>.<-----------------------<+.>.>.<<.>++++.>.<<+.>++++++++++
.>.<--------------<+.>.>.<<.>++++.>.<<.>++++.>.<<.>++++.>.<<.>++.>.<-----------<
+.>.>.<<.>++.>.<<.>++++++++.>.<<.>+++++.>.<<.>+.>.<-----<+.>.>.<--------------<+
.>.>.<<.>++++++++.>.<--------<+.>.>.<<.>++++++++.>.<<.>+.>.<---------<+.>.>.<<.>
++++.>.<<.>++++.>.<<.>++++.>.<<.>++.>.<<.>++++++.>.<<.>++++.>.<-----------------
-------<+.>.>.<<.>++++.>.<<.>++++++++++.>.<<.>++++++.>.<-----------------<+.>.>.
<<.>+.>.<<.>+.>.<<.>++.>.<<.>+.>.<<.>++++.>.<<.>+.>.<<.>++.>.<<.>++.>.<<.>+.>.<<
.>++++.>.<<.>+.>.<<.>+.>.<------------------------<+.>.>.<<.>++++.>.<<.>++++.>.<
<+.>.>.<----<+.>.>.<<+.>+++.>.<<.>+.>.<<.>++++++.>.<--------------<+.>.>.<<.>+++
+++++.>.<<.>++++++.>.<-------<+.>.>.<<.>+++++.>.<<.>+.>.<<.>++.>.<<.>+++.>.<<.>+
.>.<---------------<++.>.>.<<.>++++++++++.>.<------<+.>.>.<<.>++++++++++++.>.<--
------------------<+.>.>.<<.>++++.>.<<.>++++++++++.>.<--------------<+.>.>.

Try it online!

Well for one thing, you can get rid of the newlines

@JoKing there is no real way I could outgolf someone, I don't think there is much sense in shaving off a couple of bytes on this big scale.

Vyxal, 78 bytes
kaf»⌐±ẋ∆ṡẊ⊍¬5=↔ε{→₇-¥Kkṡw¹ǔ„L²Fŀwɖ"≠₌Ǎ›ꜝ%ǐ[Q∑)fĠλ=WτṪṫ¨≤‹r≬|{gǔs⁼∵2»16τ0€v¦øA+

Try it Online!
This uses a strategy similar to the CJam answer of storing differences between the second letters and signalling a new first letter with a 0.
   »...»           # Large integer
        16τ        # Convert from base 16
           0€      # Split on zeroes
             v¦    # Take the cumulative sums of each list of numbers
               øA  # For each each number, get the nth letter
                 + # Prepend each of corresponding items of...
kaf                # The lowercase alphabet, as a list of characters

Regenerate -a, 148 bytes
A[BDGHLMNRSTWXY]|E[DFHLMNRSTX]|I[DFNST]|O[DFHIMNPRSWXY]|U[HMNPST]|[ABFHK-NPTYZ]A|[ABDFHM-PRWY]E|[ABHKLMPQSTX]I|[BDGHJLMNSTWY]O|[BM]Y|[HM]M|[MNX]U|SH

Attempt This Online!
Or
BY|HM|SH|NU|XU|A[BDGHLMNRSTWXY]|E[DFHLMNRSTX]|I[DFNST]|M[MUY]|O[DFHIMNPRSWXY]|U[HMNPST]|[ABFHK-NPTYZ]A|[ABDFHM-PRWY]E|[ABHKLMPQSTX]I|[BDGHJLMNSTWY]O

Attempt This Online!
I'm under the impression this is close to optimal, but I plan on writing a program to verify / discover the shortest solution which uses only this strategy. What I have here is as far as I could manage by hand.
Not a full code breakdown but everything here is basically just
XY|X[YZ]|[XY]Z

XY             // print XY
  |            // then
   X[YZ]       // print XY and XZ
        |      // then
         [XY]Z // print XZ and YZ

R, 199 198 bytes
In 2018 six new two-letter words were added to the Official Scrabble Players' Dictionary: DA, EW, GI, OK, PO, and TE. This answer would have had 192 bytes in 2015 but I wanted to include the new words!
`/`=strsplit;cat(unlist(Map(paste0,LETTERS[-22][-3],el('ABDEGHILMNRSTWXY,AEIOY,AEO,DFHLMNRSTWX,AE,IO,AEIMO,DFNST,O,AI,AIO,AEIMOUY,AEOU,DEFHIKMNPRSWXY,AEIO,I,E,HIO,AEIO,HMNPST,EOI,U,AEO,A'/',')/'')))

This answer is adapted from my answer at this related challenge about element names. First we overload the / operator with the strsplit() function. Then for the first letters of the words, we use the builtin LETTERS to get a vector of uppercase letters, removing elements 3 and 22 (C and V). For the second letters, we split a string by the , character to get a list of the second letters going with each first letter. Then we split it again by an empty string to get a list of vectors of individual characters. Map() is used to apply paste0() to the first elements of the first-letters vector and the second-letters list, then the second elements, etc. unlist() flattens and cat() prints without any quotes.
Attempt this online!

Haskell, 333 308 298 bytes
Just for fun!
Evaluating s will print all of the words in a weird order - I used the fact that most combinations are vowel-consonant or vice versa, could probably optimize even more with custom character "classes", shortening the encoded matrix (here, w and k).
Does anybody know a shorter way to print strings without quotes and brackets than my monadic one? Type classes are even longer as far as I can tell.
Also, there might also be a shorter way of doing p's job...
v="AEIOU"
c="BCDFGHJKLMNPQRSTVWXYZ"
w=[976693,321324,50188,945708,52768]
k=[15,0,10,3,8,15,8,5,13,31,27,7,4,2,12,13,0,10,20,11,1]
z a b x=[[c:[e]|(e,f)<-b#p d,f]|(c,d)<-a#x]
(#)=zip
p 0=[]
p n=((n`mod`2)>0):p(n`div`2)
s=mapM_ putStrLn$concat$z v c w++z c v k++[words"AA AE AI BY HM MM MY OE OI SH"]

Isn't sequence_ the same as void$sequence? Then you can omit also the import.

That's oddly packaged, but yes. Thanks!

Isn't, void had to be imported. Anyways, gonna/gotta remember this.

Ah, and sequence_$map putStrLn is mapM_ putStrLn. Replace the (, ) around concat$... with another $.

Haskell, 192 bytes
putStr$(\(a:b)->((a:).(:" "))=<<b)=<<words"AABDEGHILMNRSTWXY BAEIOY DEO EDFHLMNRSTX FAE GO HAEIMO IDFNST JO KAI LAIO MAEIMOUY NAEOU ODEFHIMNPRSWXY PAEI QI RE SHIO TAIO UHMNPST WEO XIU YAEO ZA"

For every space separated word in the string put the first letter in front of all other letters and add a space, e.g SHIO -> SH SI SO.

Java, 334 bytes
public class C{public static void main(String[]a){for(int i=0;i<26;i++){for(int j=0;j<26;j++){if(java.util.BitSet.valueOf(java.util.Base64.getDecoder().decode("2znORQQBBAAAAAQQAKg4jkQAAAAABEBEFAAoIAwAAAEQEABAQBAAEVEQRQBBgBtrXEQAAAABAEAAAAAYBEBAEACAsAwAAAAAAQQAQAAEEUAABA==")).get(i*26+j)){System.out.format("%c%c\n",'a'+i,'a'+j);}}}}}

Formatted:
public class Code {
    public static void main(String[] a) {
        for (int i = 0; i < 26; i++) {
            for (int j = 0; j < 26; j++) {
                if (java.util.BitSet.valueOf(
                        java.util.Base64.getDecoder()
                            .decode("2znORQQBBAAAAAQQAKg4jkQAAAAABEBEFAAoIAwAAAEQEABAQBAAEVEQRQBBgBtrXEQAAAABAEAAAAAYBEBAEACAsAwAAAAAAQQAQAAEEUAABA=="))
                        .get(i * 26 + j)) {
                    System.out.format("%c%c\n", 'a' + i, 'a' + j);
                }
            }
        }
    }
}

Separately, I encoded the word list into a length 26x26=676 BitSet, converted it to a byte array, and then finally to Base 64.  That string is hard-coded in this program, and the reverse procedure is used to reproduce the BitSet, and ultimately print out the list of words

Java, 356 bytes
Uses the random number generator to get the words:
import java.util.Random;class X{public static void main(String[]a){int j,n,m=9,x;for(String u:"rgzza 2u2hh r2rxs qs5f fwiag 26i33y 2xqmje 5h94v 16ld2a 17buv 4zvdi 1elb3y 2t108q 5wne9 1mrbfe 1ih89 fh9ts r0gh".split(" ")){x=Integer.parseInt(u,36);Random r=new Random(x/2);j=m-=x%2;while(j-->0){n=r.nextInt(676);System.out.format(" %c%c",65+n/26,65+n%26);}}}}

Ungolfed:
import java.util.Random;
class X{
    public static void main(String[]a){
        int j,n,m=9,x;
        for(String u:"rgzza 2u2hh r2rxs qs5f fwiag 26i33y 2xqmje 5h94v 16ld2a 17buv 4zvdi 1elb3y 2t108q 5wne9 1mrbfe 1ih89 fh9ts r0gh".split(" ")){
            x=Integer.parseInt(u,36);
            Random r=new Random(x/2);
            j=m-=x%2;
            while(j-->0){
                n=r.nextInt(676);
                System.out.format(" %c%c",65+n/26,65+n%26);
            }
        }
    }
}

You can try it here: http://ideone.com/Qni32q

Perl, 248 bytes
@v=split(//,"AEIOU");@s=split(' ',"ADEGIRSWX LSTX DFN EFIPRX HPST BHLMNTY DFHMNR ST DHMNSWY MN ZFKP WYPB KQXLHPMB LGJTB X");for(0..14){foreach $c(split(//,@s[$_])){$_<10?print @v[$_%5].$c." ":a;$_>4?print $c.@v[$_%5]." ":a;}}print "MM MY BY HM SH";

First time using perl (and first time golfing), so there's definitely room for improvement.  Factored out the vowels and grouped the remaining letters based on how the resulting word was created - adding the vowel first, last, or both vowel first and last create a word on the list.

I don't know Perl, but  I assume you are separating the output by spaces. It seems "MM "."MY "."BY "."HM "."SH " could be shortened to "MM MY BY HM SH".

@steveverrill Thanks! I got so caught up in the rest of the code that I overlooked how redundant that was.

Javascript (ES6), 214
Perhaps not the shortest way to do it, but definitely interesting.
_=>(i=0,[...'ABDEFGHILMNOPRSTUWXY'].map(z=>[...`ABFHKLMNPTYZ
A
AEIO
ABDFHMNOPRWY
EIO
A
AEOSU
ABHKLMOPQSTX
AE
AEHMOU
AEIOU
BDGHJLMNSTWY
OU
AEO
AEIOU
AEIU
MNX
AO
AEO
ABMO`.split`
`[i++]].map(g=>g+z).join` `).join`
`)

Loops through each letter in the first string, adding it onto each letter in the corresponding line of the second. This returns the words in order of their last letter, like so:
AA BA FA HA KA LA MA NA PA TA YA ZA
AB
AD ED ID OD
AE BE DE FE HE ME NE OE PE RE WE YE
EF IF OF
AG
AH EH OH SH UH
AI BI HI KI LI MI OI PI QI SI TI XI
AL EL
AM EM HM MM OM UM
AN EN IN ON UN
BO DO GO HO JO LO MO NO SO TO WO YO
OP UP
AR ER OR
AS ES IS OS US
AT ET IT UT
MU NU XU
AW OW
AX EX OX
AY BY MY OY

Suggestions welcome!

Java, 255 254 bytes
Found a way to squeeze one more byte out of it.
class C{public static void main(String[]a){char c='A';for(char l:"ABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EO IU AEO A".toCharArray())if(l<'A')c++;else System.out.print(" "+c+l);}}

Or (though not much clearer):
class C {
    public static void main(String[] a) {
        char c = 'A';
        for (char l : "ABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EO IU AEO A"
                .toCharArray())
            if (l < 'A')
                c++;
            else
                System.out.print(" " + c + l);
    }
}

You can save two bytes by changing both occurrences of 'A' into 65.

05AB1E, 143 bytes
•ZÐFý8ù6„=4ÅœÿWì±7Ë5Œ¾`ó/îAnµ%Ñ¥Ëø±/ÀéNzÖ„Ñ§IJ¶D—ÙVEStvÖò…¸¾6F³#EXŠm¯CÄµ±ÓoÊ°}^€Ftåß€ðŒ=«j;F-Â1;xX3i&QZÒ'Ü”>lwìlOs>íÙVÇI)~î‰Hç²?Öd0È^ÝQ°•36B2ô»

Try it online!

95 bytes by porting @Sp3000's Python 3 answer.

@KevinCruijssen 91 (and I'm sure this method can get lower, but I hand-picked the dictionary words for humor).

PHP, 170 bytes
shortest approach I could find so far ...
for(;$c=ABFHKLMNPTYZ1A2AEIO1ABDFHMNOPRWY1EIO1A1AEOSU1ABHKJMOPQSTX3AE1AEHMOU1AEIOU1BDGHJLMNSTWY1OU11AEO1AEIOU1AEIU1MNX2AO1AEO1ABMO[$i++];)$c<1?print$c.chr($k+65)._:$k+=$c;

breakdown
for(;$c=CHARACTERS[$i++];)  // loop $c through map
    $c<1                            // if $c is a letter (integer value < 1)
        ?print$c.chr($k+65)._           // print first letter, second letter, delimiter
        :$k+=$c                         // else increase second letter
    ;

Note The shortest bit-mapping version with printable ascii costs 190 bytes (113 bytes data+77 bytes decoding) using 6 bits=base 64, 174 bytes (97 data, 77 decoding) using 7 bits (base 128); possibly some more for escaping.
for(;$p<676;)                   // loop through combinations
    ord("MAPPING"[$p/6])-32>>$p%6&1     // test bit
        ?                                       // if set, do nothing
        :print chr($p/26+65).chr($p++%26+65)._; // if not, print combination+delimiter

Base 224 (using ascii 32..255) takes 87 bytes data (+ escaping); but I guess the decoding will cost more than 10 bytes extra.
Excluding C and V from the map would save 16/14/13 bytes on the data but cost a lot in decoding.

Python 2, 202 200 bytes
for s in'AABALIFEN KITOELOPE LAYAINUNEREMI AMANAHI MOHMYEX UPI UTAGOFAWOWETI BY OR BI ZAXI PAS BE AD AEDEHAT QI UMMUS JOIDONOSHOYOD BOMESISOXUHEF KAR'.split():
 for i in range(len(s)-1):print s[i:i+2]

Try it online!
Try to join up overlapping pairs; i.e. ZAXI encodes ZA, AX, XI. Looks like 140 bytes of encoded text is about the best possible with this approach.

140 bytes is the theoretical limit for this approach.

Python 3, 182 bytes
[print(f+l)for*F,l in'ABFHKLMNPTYZA AB AEIOD ABDFHMNOPRWYE EIOF AG AEOSUH ABHKLMOPQSTXI AEL AEHMOUM AEIOUN BDGHJLMNSTWYO OUP AEOR AEIOUS AEIUT MNXU AOW AEOX ABMOY'.split()for f in F]

Try it online!
This was briefly the shortest Python 3 solution :)
Each section of the magic string, e.g. AEIOD, encodes e.g. AD ED ID OD. (The last letter of the section should be combined with each other letter.)
Equivalent to:
for *FIRSTS, last in (
    'ABFHKLMNPTYZA AB AEIOD ABDFHMNOPRWYE EIOF AG AEOSUH ABHKLMOPQSTXI AEL AEHMOUM AEIOUN BDGHJLMNSTWYO OUP AEOR AEIOUS AEIUT MNXU AOW AEOX ABMOY'
    .split()
):
    for first in FIRSTS:
        print(first+last)

Java, 288
class E{public static void main(String[]a){a="ABDEGHILMNRSTWXY,AEIOY,,EO,DFHLMNRSTX,AE,O,AEIMO,DFNST,O,AI,AIO,AEIMOUY,AEOU,DEFHIMNPRSWXY,AEI,I,E,HIO,AIO,HMNPST,,EO,IU,AEO,A".split(",");for(int i=26,j;i-->0;)for(j=0;j<a[i].length();)System.out.println((char)('A'+i)+""+a[i].charAt(j++));}}

By just stringing together the second letters of each word (plus a delimiter), you just loop through while keeping track of the first. Not as fancy as the base-encoded versions, but much simpler and a good score for Java. Prints in order by descending-first-letter (ZA YA YE YO XI XU), one word per line.
With line breaks:
class E{
    public static void main(String[]a){
        a="ABDEGHILMNRSTWXY,AEIOY,,EO,DFHLMNRSTX,AE,O,AEIMO,DFNST,O,AI,AIO,AEIMOUY,AEOU,DEFHIMNPRSWXY,AEI,I,E,HIO,AIO,HMNPST,,EO,IU,AEO,A".split(",");
        for(int i=26,j;i-->0;)
            for(j=0;j<a[i].length();)
                System.out.println((char)('A'+i)+""+a[i].charAt(j++));
    }
}

scala, 223 bytes
print(("AABDEGHILMNRSTWXY BAEIOY DEO EDFHLMNRSTX FAE GO HAEIMO IDFNST JO KAI LAIO MAEIMOUY NAEOU ODEFHIMNPRSWXY PAEI QI RE SHIO TAIO UHMNPST WEO XIU YAEO ZA".split(" ").flatMap(a=>a.tail.map(a(0).toString+_))).mkString(" "))

Not especially compact, but vaguely idiomatic .. eval with
scala -e '...'

Python 239 bytes
import re;f=lambdax:''.join(re.findall('..',x));a,b='ABAHALAMANATAYDEDOEFEHEMENERHOISITMOMUNONUOSOWOY','AAADAEAGAIARASAWAXBEBIBOBYELESETEXFAGOHIHMIDIFINJOKAKILILOMIMMMYOEOFOIOPOROXPAPEPIQISHTOUHUPUSUTWEXIXUYEZA';print f(a),f(a[::-1]),f(b)

This is a bit long, but I've given it a try. I've counted all the patterns that also have the reversed counterparts. Ex) 'AB'/'BA' and so on.

F#, 205 bytes
Seq.iteri(fun i s->Seq.iter(printf"%c%c "((char)i+'A'))s;printfn"")("ABDEGHILMNRSTWXY AEIOY  EO DFHLMNRSTX AE O AEIMO DFNST O AI AIO AEIMOUY AEOU DEFHIMNPRSWXY AEI I E HIO AIO HMNPST  EO IU AEO A".Split())

Live version.

Python 3, 248 bytes
e=enumerate
[print(*(chr(x+65)+chr(j+65)+" "for j,i in e(bin(k)[2:])if int(i)))for x,k in e([30292443,16793873,0,16400,9320616,17,16384,20753,794664,16384,257,16641,17846545,1064977,29798840,273,256,16,16768,16641, 831616,0,16400,1048832,16401,1])]

The numbers were generated by an additional script
I'm sure that it can be optimized further

Retina, 167 bytes

¶AABDEGHIcWXY¶BbOY¶DEaEDFHcX¶FAE¶GaHbMaIDFNST¶JaKAI¶LAIaMbMOUY¶NAEOU¶ODEFHIMNPRSWXY¶Pb¶QI¶RE¶SHIaTAIaUHMNPST¶WEaXIU¶YAEaZA
c
LMNRST
b
AEI
a
O¶
+`(¶(.)\S+)(\S)
$1 $2$3

Try it online!

C# (Visual C# Interactive Compiler), 208 bytes
()=>"ABDEGHILMNRSTWXY,AEIOY,EO,DFHLMNRSTX,AE,O,AEIMO,DFNST,O,AI,AIO,AEIMOUY,AEOU,DEFHIMNPRSWXY,AEI,I,E,HIO,AIO,HMNPST,EO,IU,AEO,A".Split(',').SelectMany((x,y)=>x.Select(z=>""+"ABDEFGHIJKLMNOPQRSTUWXYZ"[y]+z))

Try it online!

PHP, 187 bytes
for($n=A,$l=ABDEGHILMNRSTWXYAEIOY1EODFHLMNRSTXAEGOAEIMODFNS2TOAIAIOAEIMOUYAEOUDEFFHIMNPRSWXYAEI3IE4HIOAIOHMNPST5EOIUAEOA;$q=$l[$x++];){if($q<A)$n++;else{if($q<$p)$n++;$p=$q;echo"$n$q
";}}

Try it online!
Basically, the list is mostly just the second letters in the word list - I noticed in almost all cases, when incrementing the first letter, the second letter is before the one before it. For example going from AY to BA, A is before Y in the alphabet, and going from QI to RE, E is before I in the alphabet. In the very few cases where the second letter was the same or after the previous one, or to skip C and V, I put a number in the string so it knows to increment the first letter.

C#, 161 bytes
w=>"aBFHKLMNPTYZeBDFHMNOPRWYiBHKLMOPQSTXmEHMOUhEOSUnEIOUsEIOUdEIOtEIUyBMOrEOxEOlEwObgoBDGHJLMNSTWYfEIOuMNXpOU".Select((x,i)=>x>90&&w!=(w=""+x)?i>80?"":"a"+w:x+w)

The string is every possible second letter (lowercase) followed by each of its valid first letters (uppercase).
Every time a lowercase letter is reached, var w is updated to store that letter, and return "". Each time an uppercase letter is reached, return that letter + w.
Additionally, "a" + w is automatically added every time a new lowercase letter is reached, unless that letter is one of f, o, p or u (this is achieved by putting these 4 at the end of the string and conditionally adding "a"+w based on index).
Try it online!

JavaScript (V8), 182 bytes
"A ABFHKLMNPTYZB AD AEIOE ABDFHMNOPRWYG AH AEOSUI ABHKLMOPQSTXL AEM AEHMOUN AEIOUR AEOS AEIOUT AEIUW AOX AEOY ABMOO BDGHJLMNSTWYF EIOU MNXP OU".replace(/. ?/g,c=>c[1]?a=c:print(c+a))

Try it online!
Not that bad

gzip compress this best (comparing to other compress) to 172:(

Python 2, 23+176 = 199 bytes
print('...'.decode('zip'))

Try it online!
Hexdump of the string in place of ...:
['0x78', '0x9c', '0x0d', '0xc7', '0xd1', '0x8d', '0xc3', '0x30', '0x0c', '0x44',
 '0xc1', '0x56', '0x5e', '0x2b', '0x6b', '0x88', '0x8e', '0x78', '0x31', '0x45',
 '0x9f', '0x25', '0xc1', '0x56', '0xfa', '0x2f', '0x24', '0xf9', '0x19', '0x60',
 '0x24', '0xb4', '0xa1', '0x82', '0x0c', '0xbd', '0x50', '0x45', '0x8e', '0x0e',
 '0x14', '0xa8', '0xa1', '0x0b', '0x75', '0x34', '0xd0', '0x8d', '0x1e', '0xb4',
 '0xd8', '0xc4', '0x66', '0x6c', '0xce', '0x96', '0x6c', '0x8b', '0x62', '0x94',
 '0xc4', '0x0a', '0xb6', '0x63', '0x15', '0x3b', '0xb0', '0xc0', '0x1a', '0x76',
 '0x61', '0x1d', '0x1b', '0xd8', '0xc3', '0x2e', '0x76', '0xe3', '0x95', '0x54',
 '0x51', '0x8d', '0xea', '0xd4', '0xa0', '0x26', '0x5e', '0xf0', '0x1d', '0x6f',
 '0x78', '0xc7', '0x07', '0x7f', '0xc9', '0x5b', '0xbc', '0x9d', '0x43', '0x1c',
 '0x3f', '0x93', '0x10', '0x61', '0x84', '0x13', '0x41', '0xfc', '0x3a', '0x89',
 '0x45', '0x13', '0xcd', '0x68', '0x49', '0x9b', '0x64', '0x21', '0x8d', '0xdc',
 '0xc9', '0x4a', '0x3a', '0x19', '0x64', '0x23', '0x4f', '0xf2', '0x22', '0x3b',
 '0x79', '0x93', '0x0f', '0xb9', '0x38', '0xc5', '0x69', '0x9c', '0xce', '0xbf',
 '0x73', '0x19', '0xbd', '0xd2', '0x9d', '0x9e', '0x0c', '0x31', '0x9c', '0x91',
 '0xcc', '0xca', '0x0c', '0x66', '0x63', '0x9e', '0xcc', '0xce', '0x1c', '0xdc',
 '0xc6', '0x9d', '0x3c', '0xce', '0x33', '0x59', '0x62', '0x19', '0x2b', '0xf9',
 '0xe8', '0x0b', '0x93', '0x2f', '0x47', '0xe5']

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:
Golf Wars Episode I: The Phantom Lightsabers

Background theme
Introduction
Obi-Wan Kenobi, Qui-Gon Jinn and Darth Maul are about to fight! However, they've all forgotten to bring their respective lightsabers. Write a program or function which, given the string Jedi as input, generates an image similar to this*:

and given the string Sith, generates an image similar to this:

Images specifications

Any of the 3 lightsabers (the white blade including the round edge at the end(2 round edges for the red one) and including the handle) is 900px long (This does not include the color gradient around the blade).
The round edge at the end of the blade is a halfcircle (a discrete approximation of it, obviously) with a diameter equal to the width of the blade.
The blade (i.e. the white part of the lightsaber) is 12px wide.
The green and blue lightsabers are separated by 200 px (from the center line of the green blade to the center line of the blue blade).
The handle for all 3 lightsabers is 180px (1/5 of the total length). Therefore the blade itself including the round edge(s) is 720px long for the blue and green lightsabers and 360px long for the two blades of the red lightsaber.
The handle for the blue and green lightsabers is at the bottom of the lightsaber. The handle for the red lightsaber is horizontaly centered.
The length of the gradient from the edge of the white blade to a completely white color is 1.5 * the width of the blade (e.g. 18px for the linear parts).
The green gradient goes from RGB (0,255,0) to white (255,255,255) (or transparent if it's easier for you to implement). The red gradient goes from (255,0,0) to white, and the blue gradient goes from (0,0,255) to white.
The color of the handle is RGB (128,128,128).
There can be white empty space around the lightsaber(s).

Inputs
Either Sith or Jedi as a string. You can take this string from STDIN, as a function argument, command line parameter, or anything similar. You may assume that the input will always be exactly Sith or Jedi and nothing else.
Output
You must generate an image file containing the image corresponding to the input string. You are relatively free to choose whatever image format you want, as long as it is a True Color image.
Scoring
This is code-golf, so the shortest answer in bytes wins. May the force be with you.

* The images in this post are not displayed full size.

Do we have to save the file to disk or can we write it to stdout? What about just displaying it on screen?

Displaying it on screen is fine, if your language can do that easily. As for writing the file itself to STDOUT, I guess it's acceptable for languages which can't easily save files to disk

I think the title should be Golf Wars Episode I: The Phantom Dennis.

HTML/CSS solution, 765 740 541 bytes

The recent refactor uses the :target pseudo-class rather than a <form> and Javascript.
To enter either input, add it to the end of the URL as a target, e.g. test.html#Jedi or test.html#Sith
Here it is again with whitespace and a few comments:

The lightsabers are
 elements with one cell per part (blade/handle) that are unhidden via their id attributes.
The blades are colored with CSS box-shadows and the Jedi lightsabers undergo a transform: rotate().
Pictures or it didn't happen (click for full res):

If you add td{background:#fff}body{background:#000} to the CSS, you'll get a cool dark view.
Tested in Firefox and Chrome (on Linux).  Note that this is not at all standards-compliant, as I was trying to shrink the size as much as possible.
Thanks to @manatwork for border-spacing and :target.

You could use the :target pseudo-class, like I did once. http://pastebin.com/WtxbSsr3 then access it like file:///tmp/test.html#Jedi and file:///tmp/test.html#Sith (BTW, the HTML cellspacing=0 → CSS border-spacing:0 change looks correct in my Firefox, but not checked in other browsers.)

Thanks, I've been looking for border-spacing for a long time (this saved 25 chars).  The :target advice allowed removing the <form> and all JS. In my last edit, I also tightened it up even further. It could get smaller still if we use
 with float:left and clear:left, but this should do.

It will still work if you delete the first and last chars: style>[id]:not(:target){display:none}table{width:900px;height:12px;border-spacing:0}td:last-child{border-radius:0 12px 12px 0}#Sith td:first-child{border-radius:12px 0 0 12px}#Sith td{box-shadow:0 0 18px red}#Jedi{transform:rotate(-90deg);margin:350px 0}#Jedi td{box-shadow:0 0 18px #0f0}*+table{margin:200px 0 0 0}#Jedi *+table td{box-shadow:0 0 18px #00f}td:nth-last-child(2){background:#888;width:180px;box-shadow:none!important}</style>

</table

@RudolfL.Jelínek That's crazy! I'm not comfortable with that shortcut, and I'm not sure of how many browsers support it, but if it is universally supported, you've successfully cut two characters off of the code.  There are other tweaks that would similarly shave off a bit here and there with only minimal visual degradation, including the potential of using
s in place of
s.

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


text:
ASCII Art Chessboard
In this challenge, you are to draw the chessboard below, and allow for moves to be made.
1. Drawing
Each white square has 5x9 spaces.
Each black square has 5x9 colons.
The board is surrounded by a border of colons.
The pieces are 5 characters wide and sit on the bottom row of the square in the centre.
The pawns are 4 characters wide. They sit slightly off centre to the right, with 3 blank squares on the left and 2 blank squares on the right. They sit one line above the bottom of the square.
There shall be no whitespace outside the area of the board, with the exception of an optional trailing newline.
The board and the chessmen shall be drawn exactly as shown, except that:

You may subsitute the : in the black squares and border for a different symbol, and you may substitute the @ in the black pieces for a different symbol (but not the same one used for the black squares.)
You may move the pawns one character to the left if you wish.

.
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:         :::::::::         :::www:::   _+_   :::::::::         ::::::::::
:  |_|_|  :: _,,:::   (/)   :::)@(:::   )@(   :::(/):::   _,,   ::|_|_|:::
:   |@|   ::"- \~::   |@|   :::|@|:::   |@|   :::|@|:::  "- \~  :::|@|::::
:   |@|   :::|@|:::   |@|   :::|@|:::   |@|   :::|@|:::   |@|   :::|@|::::
:  /@@@\  ::/@@@\::  /@@@\  ::/@@@\::  /@@@\  ::/@@@\::  /@@@\  ::/@@@\:::
::::::::::         :::::::::         :::::::::         :::::::::         :
:::::():::    ()   ::::():::    ()   ::::():::    ()   ::::():::    ()   :
:::::)(:::    )(   ::::)(:::    )(   ::::)(:::    )(   ::::)(:::    )(   :
::::/@@\::   /@@\  :::/@@\::   /@@\  :::/@@\::   /@@\  :::/@@\::   /@@\  :
::::::::::         :::::::::         :::::::::         :::::::::         :
:         :::::::::         :::::::::         :::::::::         ::::::::::
:         :::::::::         :::::::::         :::::::::         ::::::::::
:         :::::::::         :::::::::         :::::::::         ::::::::::
:         :::::::::         :::::::::         :::::::::         ::::::::::
:         :::::::::         :::::::::         :::::::::         ::::::::::
::::::::::         :::::::::         :::::::::         :::::::::         :
::::::::::         :::::::::         :::::::::         :::::::::         :
::::::::::         :::::::::         :::::::::         :::::::::         :
::::::::::         :::::::::         :::::::::         :::::::::         :
::::::::::         :::::::::         :::::::::         :::::::::         :
:         :::::::::         :::::::::         :::::::::         ::::::::::
:         :::::::::         :::::::::         :::::::::         ::::::::::
:         :::::::::         :::::::::         :::::::::         ::::::::::
:         :::::::::         :::::::::         :::::::::         ::::::::::
:         :::::::::         :::::::::         :::::::::         ::::::::::
::::::::::         :::::::::         :::::::::         :::::::::         :
::::::::::         :::::::::         :::::::::         :::::::::         :
::::::::::         :::::::::         :::::::::         :::::::::         :
::::::::::         :::::::::         :::::::::         :::::::::         :
::::::::::         :::::::::         :::::::::         :::::::::         :
:         :::::::::         :::::::::         :::::::::         ::::::::::
:    ()   ::::():::    ()   ::::():::    ()   ::::():::    ()   ::::()::::
:    )(   ::::)(:::    )(   ::::)(:::    )(   ::::)(:::    )(   ::::)(::::
:   /__\  :::/__\::   /__\  :::/__\::   /__\  :::/__\::   /__\  :::/__\:::
:         :::::::::         :::::::::         :::::::::         ::::::::::
::::::::::         :::::::::   www   :::_+_:::         :::::::::         :
:::|_|_|::   _,,   :::(/):::   ) (   :::) (:::   (/)   :::_,,:::  |_|_|  :
::::| |:::  "- \~  :::| |:::   | |   :::| |:::   | |   ::"- \~::   | |   :
::::| |:::   | |   :::| |:::   | |   :::| |:::   | |   :::| |:::   | |   :
:::/___\::  /___\  ::/___\::  /___\  ::/___\::  /___\  ::/___\::  /___\  :
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

2. Moving
The columns are labelled A-H from left to right and 1 to 8 from bottom to top. The user shall be able to enter a move in the following form:
<start column><start row><space><destination column><destination row>

For example B1 C3 means move the knight to the square in front of the bishop's pawn (assuming the game has just started).
Alternatively the ICCF system can be used, in which the columns are labelled 1 to 8 instead of A to H. So the knight move mentioned above becomes 21 33.
The following image (source) clarifies both systems:

The move shall be executed and the new board displayed. Any resulting capture shall occur with the moving chessman removing the chessman on the destination square from the board.
There is no need to check for a legal chess move, as that has been covered in other challenges: Smallest chess program and The smallest Chess arbiter If the user tries to move from an empty square, your program or function should ignore the move. If the user tries to capture a friendly piece, you can either ignore the move or allow the stationary piece to be captured.
There is no need to support en passant or castling.
You may assume the input will be well formed, i.e. always in the format described above. Letters will always be in the same case, you can decide what case that is.
3. Scoring and Bonuses
This is code golf. Shortest code wins.
-10% bonus if your program or function allows for promotion. The user enters a third input, this time one of the following letters: Q B R N. This should only be allowed if the move ends with a pawn on the last row. The pawn is exchanged for the named piece. QBRN.
-10% bonus if your program or function implements a special "undo" move for reversal of moves (as far back as the beginning of the game if required.) Obviously it is possible for amateur players to make illegal moves, and they may wish to undo them. You may define the input  the user must give for this "undo" move (it must always be the same.) Behaviour is undefined if the user tries to undo beyond the beginning of the game.
Bonuses sum, i.e. if you go for both bonuses you get -20%.

At first you say "enter a move", and for me it means "just 1 move". Then there is the bonus for undo "as far as the beginning": so it's a complete serie of moves, not just one... please clarify

@edc65 it's a complete series of moves. See the first line "allow for moves to be made." The one thing I didn't specify is the exit condition for the loop. It might have been an idea to stop when one of the kings is captured, but the existing answer has an infinite loop, which is acceptable under the spec as written, so I'll leave it.

The formatting on the two knights on black squares does not match. Which is correct?

@JWT wow, no-one noticed before! At this stage I'll have to accept both. I see you've golfed your answer a bit more. Before I test your answer and change the acceptance, have you finished?

@ steveverril I'm finished, yes.

Octave, 776 688 bytes
688:

functions inlined into main loop (both were used only once),
used cell notation {'foo','bar'}{i} in place of slightly longer ['foo';'bar'](i,:)

Still none of bonuses implemented.

Uses ICCF system.
There may be no leading spaces in the move description and the source and destination field must be separated by a single whitespace, so 42 44 is correct, while   42 44 and 42   44 are not.
R=@repmat;s=[t='BFJbRJFB';R(('@    A')',1,8);t+1]';while 1q=' ';c=R(':',42,74);m=R([m=R(q,5,9) l=m+26;l m],4,4);c(2:41,2:73)=m;for i=1:8 for j=1:8 f=s(i,j);z=@(c)bitand(+f,c);if z(64)b=z(1)+1;W={') (',')@('}{b};U=43-5*j;Z=9*i-2;T=Z-2:Z;Q=Z-3:Z+1;if z(2)c(U+3,Q)={'/___\','/@@@\'}{b};a=c(U+2,T)={'| |','|@|'}{b};if z(4)c(U+1,Q)='"- \~';c(U,Z-3:Z)=' _,,';else c(U+1,T)=a;if z(8)c(U,T)='(/)';elseif z(16)||z(32)c(U,T)=W;c(U-1,T)={'_+_','www'}{1+z(32)/32};else c(U,Q)='|_|_|';end
end
else c(U+2,Z-2:Z+1)={'/__\','/@@\'}{b};c(U:U+1,Z-1:Z)=['()';')('];end;end;end;end;c
m=input(q,'s')-'0';x=m(1);y=m(2);X=m(4);Y=m(5);if s(x,y)~=q&&(s(X,Y)==q||mod(s(x,y)-s(X,Y),2))s(X,Y)=s(x,y);s(x,y)=q;end
end

Somewhat ungolfed version:
# draw an empty chessboard
function n=cb
R=@repmat;
n=R(':',42,74);
m=R([m=R(' ',5,9) m+26;m+26 m],4,4);
n(2:41,2:73)=m;
end

# function n=put(n,f,c,r) :
#
# put a chessman f on column c and row r of chessboard n,
# returning new chessboard
# chessman is described by single character defined following way
# (please excuse naming bits by value rather than position):
# bit valued  127 -     unused
# bit valued  64  -     0 = field empty, 64 = field occupied.
# bits valued 32,16,8 - 0 = rook, 8 = bishop, 16 = king, 32 = queen
# bit valued  4 -       0 = not knight 4 = knight (only checked if "other piece" bit is set)
# bit valued  2 -       0 = pawn       2 = other piece
# bit valued  1 -       0 = white      1 = black

# this gives the following chars:

# pawns   - 64      (+1)  => @ , A
# knights - 64+4+2  (+1)  => F , G
# rooks   - 64+2    (+1)  => B , C
# bishops - 64+8+2  (+1)  => J , K
# kings   - 64+16+2 (+1)  => R , S
# queens  - 64+32+2 (+1) =>  b , a
# empty space - any character with bit valued 64 unset (space char does)

function n=put(n,f,c,r)
z=@(n)bitand(f-0,n);
if z(64)
    b=z(1);
    W=') ()@('(1+3*b:3+3*b);
    R=5*r;C=9*c;
    if z(2)
            n(46-R,C-5:C-1)='/___\/@@@\'(1+5*b:5+5*b);
            a=n(45-R,C-4:C-2)='| ||@|'(1+3*b:3+3*b);
            if z(4) # knight
                    n(44-R,C-5:C-1)='"- \~';
                    n(43-R,C-5:C-2)=' _,,';
            else
                    n(44-R,C-4:C-2)=a;
                    if z(8) # bishop
                            n(43-R,C-4:C-2)='(/)';
                    elseif z(16) # king
                            n(43-R,C-4:C-2)=W;
                            n(42-R,C-4:C-2)='_+_';
                    elseif z(32) # queen
                            n(43-R,C-4:C-2)=W;
                            n(42-R,C-4:C-2)='www';
                    else  # rook
                            n(43-R,C-5:C-1)='|_|_|';
                    end
            end
    else
            n(45-R,C-4:C-1)='/  \/@@\'(1+4*b:4+4*b);
            n(43-R:44-R,C-3:C-2)=['()';')('];
    end
end
end

# here we can easily define the chessboard.
s=['BFJbRJFB';repmat(('@    A')',1,8);'CGKcSKGC']';
c=cb;for i=1:8 for j=1:8 c=put(c,s(i,j),i,j);end;end
c

# We scan five characters. They must be positions in ICCF without leading spaces separated by single space.
while m=input('','s')-'0'
x=m(1)
y=m(2)
X=m(4)
Y=m(5)
# if the move is not allowed (capture piece of the same color or the start field is blank,
# do nothing
if s(x,y)==' ' || (s(X,Y) ~=' ' && mod(s(x,y)-s(X,Y),2)==0) continue; end;
# make the move
s(X,Y)=s(x,y);
s(x,y)=' ';
# redraw the board
c=cb;for i=1:8 for j=1:8 c=put(c,s(i,j),i,j);
end end
c
end

I ran this on ideone.com and got the board displayed but couldn't get it to accept any input. It works great at http://www.tutorialspoint.com/codingground.htm (except you have the king and queen reversed - any seasoned chess player will tell you it makes a difference.) I'd give you an extra +1 for not allowing capture of a friendly piece, and one more for the decent explanation, if I could.

@steveverrill Indeed, king and queen positions were reversed, thanks for pointing this out. It's fixed now.

Ruby, 715 696 693 683  bytes
This is a fairly messy solution but I don't have the patience to clean it up further at the moment.
Neither of the bonuses done.
Uses ICCF system.
a,b,c=->f,x,y,p{p.map{|ln|ln.gsub(/\d/){|z|f*(z.to_i)}.tr('AB',x+y)}},Array.new(64){|i|((i%56<8?[4,2,3,5,6,3,2,4][i%56]:(i-8)%40<8?1:0)<<2)+(i<16?2:0)},':'*74
loop{puts c
b.each_slice(8).with_index{|r,y|d,*e=r.map.with_index{|v,x|a[*([[' '],[':']][(x+y)%2]+[[' ','_'],['@','@']][v&2==2?1:0]+[('9@9@9@9@9;9@4()3@4)(3@3/BB\2@9;9@3_,,3@2"- \~2@3|A|3@2/BBB\2;9@3(/)3@3|A|3@3|A|3@2/BBB\2;9@2|_|_|2@3|A|3@3|A|3@2/BBB\2;3www3@3)A(3@3|A|3@3|A|3@2/BBB\2;3_+_3@3)A(3@3|A|3@3|A|3@2/BBB\2'.split(';').map{|s|s.split '@'})[v>>2]])]}
d.zip(*e).each{|r|puts ":#{r.join}:"}}
puts c
gets.scan(/(.)(.) (.)(.)/){|f,g,h,i|j,k=63+(f.to_i)-(g.to_i)*8,63+(h.to_i)-(i.to_i)*8
b[k],b[j]=b[j]>0?b[j]: b[k],0}}

Excellent, seems to work perfectly!

@LevelRiverSt Looks like this answer is shorter than the currently accepted one.

Python, 1136 890 753 bytes
Apologies for the partial answer but I'm a newbie and I really enjoyed this challenge. I know it's probably really verbose but here's my rough draft:
y=':'*9
z=' '*9
b='::/___\::'
c=':::|@|:::'
d=':::)@(:::'

ps = {'r': [y,'::|*|*|::', c, c,b],'n': [y,':::,,::::', '::"- \~::', c,b],'b': [y,':::(/):::',c,c,b],'k': [':::www:::',d,c,c,b],'q': [':::*+*:::',d,c,c,b],'p': [y, '::::():::','::::)(:::',':::/__\::',y]}

def cell(p,c):
  if p == '!':
    return ([z]*5,[y]*5)[c]
  s = []
  for l in ps[p.lower()]:
    l = (l.replace('@', ' '), l.replace('_', '@'))[p.islower()]
    l = (l.replace(':', ' '), l)[c].replace('*', '_')
    s.append(l)
  return s

b = {8:'rnbkqbnr',7:'p'*8,2:'P'*8}
b[1] = b[8].upper()
for i in range(3,7):
  b[i] = '!'*8

o=[y*8]
c=0
for r in b:
  l=['']*5
  for p in b[r]:
    cc=cell(p,c)
    for i in range(0,5):
      l[i]+=cc[i]
    c=not c
  o.extend(l)
  c=not c
o.append(o[0])
for l in o:
  print ':'+l+':'

Thanks for the answer. It is our custom to include a title line on answers, with the language and byte count. What language is this? It looks like python but I can't get it to run on ideone.com

Remove all spaces around =, and if a for or an if only has one line inside it, it can all go on the same line. Take a look at Tips for Golfing in Python.


text:
Switch program flow from external pulse
You work for the military as a coder and are responsible for writing software to control missiles. Your task is to write a program or function that will output a code sequence (any length ASCII string) to launch a missile. The program should be based on a loop taking the code sequence from memory and output it in a particular order. Then the code is sent to the missile controller, which launches the missile.
However, you work as one of our spies. We believe that writing the sequence in reverse order will cause the missile to explode in the silo as a form of sabotage!  We are able to change by some way (the method is top secret and it is not important how we can do it) one byte of code in the missile controller software. You need to write such a program that changing one byte during the loop will change the loop so that the text will be typed in reverse order.
The task
Write a program or function in any language of your choice that will use a loop to return ASCII sequence. The sequence can be stored in the memory or given from stdin or equivalent, function arguments, being a string or array of any length (>0, <=255 characters).
Changing one character or byte in the loop, in any iteration, should reverse the loop direction, making characters that have already been returned show again, from last to first.
For example, if the input text (the missile code sequence) would be abcdefgh and the loop switch begins in the 5th iteration, the result should be abcdedcba. We believe this would be enough to destroy the missiles.
However, we know that they are aware of our new weapon. We are not able to switch from or to any of the following characters, in your code:

+ (plus sign, addition)
- (minus sign, subtraction, or unary negative operator)
> and < (greater than, less than), we also expect this won't work for << and >> operators (bit shift left/right), however you can change commands doing bit shift, if there are any in your language (eg. change shr to shl).

You may not change a whitespace character to a non-whitespace character (eg. you cannot change [space]or to xor).
You may not assign any constants or variables to values or codes so you will bypass the said characters (e.g. you cannot say p = 1; n = -1; and change p to n in such a line i = i + p).
If necessary, after the character switch, you are allowed to leave the loop and output the rest of the string in any way you like.
You are free to choose if one and only one character/byte will be switched or all of the same value. For example, you may switch all occurrences of * to /.
Any GOTO, DJNZ and equivalents also do count as loops.
The program must return no errors, so the enemy will never realize what has happened. The program should return the whole string if no switch would be made.
This is a codegolf, so shortest answer in bytes wins.
To make program simpler, you may insert in your code a conditional statement to switch program flow in particular iteration. This must simulate the line to be changed. If so, you do not have to count the bytes of the conditional in your code. However, you cannot modify anything in this part of code and use it for any other purposes.
Example
The example below was written in PHP. Note, it is invalid, because it changes + sign to - sign, which is not allowed, however I hope it would be clear to understand what I mean.
function f($s){
   $result = ''; // initialize result
   $array = str_split($s); // convert string to array
   $char = 0; // loop start
   $increase = 1; // loop direction
   while($char>=0 && $char < strlen($s)){ // start loop
     $result = $result . $array[$char]; // add next character for the output

     // The conditional statements below simulate character switch
     // The number 5 means it will happen in the 5th iteration
     // The lines in if... and else... statements must have exactly the same length
     if(strlen($result) < 5){ // for iteration 5 and lower...
       $char = $char + $increase;  // count only this line in the block
     }
     else{
       $char = $char - $increase;
     }
     // end of the block

   } // end while loop
   return $result; // end of program
}

The usage of the function is to call it echo f("abcdefghijkl"); which returns abcdedcba. Golfed a bit (removed some whitespaces and the conditional block):
function f($s){$result='';$array=str_split($s);$char=0;$increase=1;while($char>=0 && $char<strlen($s)){
$result=$result.$array[$char];
$char=$char+$increase; // this line instead of the block
}
return$result;}

(175 bytes)
Note, that the golfed version, without the conditional block (or 5 is replaced with 13 or more), returns abcdefghijkl.
This is my very first task here. Let me know if I did something wrong.

The main task must be done in a loop. You must return the result string by copying it one by one character. After the character change, in any possible iteration, you are allowed to return the reversed part using reverse() method or anything like this (then no loop is necessary, but you have to quit it somehow).

You may not change a whitespace character to a non-whitespace character  does this mean i can change non-whitespace to a whitespace?

@Kamehameha yes, you can (you can make xor to [space]or or 12 to \n2)

I thought for a second we could choose our own sequence … R.I.P, echo 'a';

Python 76 63 Bytes
This anon-function basically prints it's input as is.
lambda x:`[x[(~~e,e)[e<len(x)/2]]for e in range(len(x))]`[2::5]

Outputs - z("123456") -> 123456
But by changing the ~ to whitespace , it prints the second part of the string in reverse.
lambda x:`[x[( ~e,e)[e<len(x)/2]]for e in range(len(x))]`[2::5]
              ^

Outputs - z("123456") -> 123321

The output of the first function should have the string only once (z("123456") -> 123456), exactly as it was given. Also, number 6 should be returned once, as in my examples (however it is not clearly stated in the question, so I will accept if you return two 6s)

@Voitcus check the edit


text:
Lossless English language text compression challenge
Challenge:
Your challenge (should you choose to accept it) is to compress and decompress the 5MB "Complete Works of William Shakespeare" as found here:
http://www.gutenberg.org/cache/epub/100/pg100.txt
(MD5: a810f89e9f8e213aebd06b9f8c5157d8)
Rules:

You must take input via STDIN and output via STDOUT...
...and you must provide an identical decompressed result to the input.

(This is to say you must be able to cat inpt.txt | ./cmprss | ./dcmpress | md5 and get the same MD5 as above.)
(Anything via STDERR is to be discarded.)

You must use less than 2048 characters for your total source code.

(This is not code-golf.  You are not being scored based on length of source-code.  This is was just a rule to keep things finite.)
(Take the concatenated length of all source code if you have split it out.)

You must be able to (theoretically) process similar plain-text inputs too.

(e.g. hard coding a mechanism which is only capable of outputting the provided Shakespeare input is unacceptable.)
(The compressed size of other documents is irrelevant - provided the decompressed result is identical to the alternative input.)

You may use any choice of language(s).

(e.g. feel free to compress using awk and decompress using java)

You may write two separate programs or combine them with some form of "switch" as you please.

(There must be clear demonstrations of how to invoke both the compression and decompression modes)

You may not use any external commands (e.g. through exec()).

(If you are using a shell language - sorry.  You'll have to make do with built-ins.  You're welcome to post an "unacceptable" answer for the sake of sharing and enjoyment - but it won't be judged!)

You may not use any built-in or library provided functions who's stated purpose is to compress data (like gz, etc)

(Altering the encoding is not considered compression in this context.  Some discretion may be applied here.  Feel free to argue the acceptableness of your solution in the submission.)

Please try to have fun if choose to participate!

All good competitions have an objective definition of winning; ergo:

Provided all rules are adhered to, the smallest compressed output (in STDOUT bytes) wins.

(Report your output please via ./cmprss | wc -c)

In the event of a draw (identical output sizes), the most community up-voted wins.
In the event of a second draw (identical community up-votes), I'll pick a winner based on completely subjective examination of elegance and pure genius. ;-)

How to submit:
Please format your entry using this template:
<language>, <compressed_size>
-----------------------------

<description>  (Detail is encouraged!)

    <CODE...
    ...>

<run instructions>

I would encourage readers and submitters to converse through comments - I believe there's real opportunity for people to learn and become better programmers through codegolf.stack.
Winning:
I'm away on vacation soon: I may (or may not) be monitoring submissions over the next few weeks and will draw the challenge to a close on the 19th September.  I hope this offers a good opportunity for people to think and submit - and for a positive sharing of techniques and ideas.
If you've learned something new from participating (as a reader or submitter) please leave a comment of encouragement.

You should tag this code-challenge.

Thank-you @kirbyfan64sos!  First time submitting.  Appreciate the (extremely prompt) feedback.

Is taking the input as an function argument allowed? E.g. A solution in languages such as JavaScript couldn't be run from the command line, AFAIK. In my case, it would simply be much easier to run in the browser.

We could change the rules for that.  I think for JS specifically it could be done in node though?  Thoughts?

Can we remove the disclaimer part of the txt?

Why the template? Are you going to create a stack snippet which depends on it?

@PeterTaylor - programmer's habit I guess!  Thought it would keep things tidier - and allow an easy statistic report if desired.

@RobertoNicbaAnićBanić - I thought about this myself.  Given keeping it in makes the challenge slightly harder (increases dictionary sizes etc) and given the license detail etc, I figured there was no harm keeping it.  Makes the challenge simpler to describe too (just take the raw .txt and have fun).

@ETHproductions nodejs has a readline plugin...

Could you remove the 2048 bytes limit? It might be too low for really verbose or joke languages if someone wants to answer with them and do something competitive

@Fatalize - I'm more than happy to - should we keep some sort of limit to keep things sane?  What would you propose?

Well I personally don't see the benefit of having any limit at all for this challenge

@Fatalize - I did some playing, and it seems I was being hugely optimistic to have suggestions in even a C-like language in <2k chars.  Along with your recommendation, I've dropped the rule.  Thanks!

@wally while 2k might be optimisitc... I find having no limit is actually worse for three reasons: 1. makes it difficult to determine know when to stop, 2. there is too much possibility, so hard to start, 3. necessity is the mother of invention... so without a limit, invention suffers. I would suggest perhaps changing the scoring to be something like (bytes saved)/(size of source code) so that there is benefit for more efficient code

@Moogie - that's where I started when I posted yesterday. The loop I infinitely traverse is "code-golf makes the code hard to read and there's already many such puzzles posted" (voteing against any code length limit/scoring) but equally (as you say) "no code length limit makes the task extremely broad".  I also don't want to unfairly penalize naturally-verbose languages.  Arguably for compression the speed and memory requirements are most important in "real world scenarios".  Maybe I should have scored on those too.  Perhaps someone would care to follow this challenge with a better follow-up?

@wally - i understand. I will try to participate with the original 2048 characters just to constrain myself :P

If there is no code size limit, what stops me from writing a compress program that prints 0 bytes, and a decompress program that's hard-coded to print the entire works of Shakespeare?

A rule could be added that says that the code should theoretically work with other inputs, which solves the problem @Mauris pointed out.

@kirbyfan64sos - done!  Thank you for the help.

That doesn't fix the problem at all. The only sensible way to handle it is to score on length of code + length of compressed text, but then it's a duplicate of this question.

Perl 5, 3651284
Just a simple word-based dictionary scheme. Analyzes the word frequency of
the corpus, and uses that to determine whether to use one or two bytes of
overhead per word. Uses two special symbols for the bytes \0 and \1 since
they do not appear in the corpus. There are plenty of other symbols that
could be used. This was not done. Does not do any huffman encoding or any
of that jazz.
Compression script shakespeare.pl:
use strict;
use warnings;
use bytes;

my $text = join "", <>;
my @words = split/([^a-zA-Z0-9]+)/, $text;

my %charfreq;
for( my $i = 0; $i<length($text); ++$i ) {
    $charfreq{ substr($text, $i, 1) }++
}
for my $i ( 0..255 ) {
    my $c = chr($i);
    my $cnt = $charfreq{$c} // 0;
}

my %word_freq;
foreach my $word ( @words ) {
    $word_freq{ $word }++;
}

my $cnt = 0;
my ( @dict, %rdict );
foreach my $word ( sort { $word_freq{$b} <=> $word_freq{$a} || $b cmp $a } keys %word_freq ) {
    last if $word_freq{ $word } == 1;

    my $repl_length = $cnt < 127 ? 2 : 3;
    if( length( $word ) > $repl_length ) {
        push @dict, $word;
        $rdict{ $word } = $cnt;
        $cnt++;
    }
}

foreach my $index ( 0..$
    print "$dict[$index]\0";
}
print "\1";

foreach my $word ( @words ) {
    my $index = $rdict{ $word };
    if ( defined $index && $index <= 127 ) {
        print "\0" . chr( $index );
    } elsif ( defined $index ) {
        my $byte1 = $index & 127;
        my $byte2 = $index >> 7;
        print "\1" . chr( $byte2 ) . chr( $byte1 );
    } else {
        print $word;
    }
}

Decompression script deshakespeare.pl:
use strict;
use warnings;
use bytes;

local $/;
my $compressed = <>;
my $text = $compressed;
$text =~ s/^.+?\x{1}//ms;
my $dictionary = $compressed;
$dictionary =~ s/\x{1}.*$//ms;

my $cnt = 0;
my @dict;
foreach my $word ( split "\0", $dictionary ) {

    push @dict, $word;
}

my @words = split /(\x{0}.|\x{1}..)/ms, $text;
foreach my $word ( @words ) {
    if( $word =~ /^\x{0}(.)/ms ) {
        print $dict[ ord( $1 ) ];
    } elsif( $word =~ /^\x{1}(.)(.)/ms ) {
        my $byte1 = ord( $1 );
        my $byte2 = ord( $2 );
        my $index = ( $byte1 << 7 ) + $byte2;
        print $dict[ $index ];
    } else {
        print $word;
    }
}

Run using:
perl shakespeare.pl < pg100.txt >pg100.txt.compressed
perl deshakespeare.pl <pg100.txt.compressed >pg100.txt.restored
diff pg100.txt pg100.txt.restored