text:
Print the Capitals without the Capitals
Whoa, whoa, whoa ... stop typing your program. No, I don't mean "print ABC...." I'm talking the capitals of the United States.
Specifically, print all the city/state combinations given in the following list

in any order
with your choice of delimiters (e.g., Baton Rouge`LA_Indianapolis`IN_... is acceptable), so long as it's unambiguous which words are cities, which are states, and which are different entries
without using any of ABCDEFGHIJKLMNOPQRSTUVWXYZ in your source code

Output should be to STDOUT or equivalent.
EDIT - Whoops!
<edit>
While typing up the list from memory (thanks to the Animaniacs, as described below), I apparently neglected Washington, DC, which isn't a state capital, but is in the song, and is sometimes included in "lists of capitals" (like the Mathematica answer below). I had intended to include that city in this list, but missed it, somehow. As a result, answers that don't have that city won't be penalized, and answers that do have that city won't be penalized, either. Essentially, it's up to you whether Washington, DC is included in your ouput or not. Sorry about that, folks!
</edit>
Baton Rouge, LA
Indianapolis, IN
Columbus, OH
Montgomery, AL
Helena, MT
Denver, CO
Boise, ID
Austin, TX
Boston, MA
Albany, NY
Tallahassee, FL
Santa Fe, NM
Nashville, TN
Trenton, NJ
Jefferson, MO
Richmond, VA
Pierre, SD
Harrisburg, PA
Augusta, ME
Providence, RI
Dover, DE
Concord, NH
Montpelier, VT
Hartford, CT
Topeka, KS
Saint Paul, MN
Juneau, AK
Lincoln, NE
Raleigh, NC
Madison, WI
Olympia, WA
Phoenix, AZ
Lansing, MI
Honolulu, HI
Jackson, MS
Springfield, IL
Columbia, SC
Annapolis, MD
Cheyenne, WY
Salt Lake City, UT
Atlanta, GA
Bismarck, ND
Frankfort, KY
Salem, OR
Little Rock, AR
Des Moines, IA
Sacramento, CA
Oklahoma City, OK
Charleston, WV
Carson City, NV

(h/t to Animaniacs for the list of capitals)
Take a bonus of -20% if your submission doesn't explicitly have the numbers 65 through 90 or the number 1 in the code. Generating these numbers (e.g., a=5*13 or a="123"[0] or a=64;a++ or the like) is allowed under this bonus, explicitly having them (e.g., a=65 or a="1 23 456"[0]) is not.
Leaderboard

var QUESTION_ID=60650,OVERRIDE_USER=42963;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+(?:[.]\d+)?)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

This challenge was made for Mathematica.

@Skyler not easy to do it in Mathematica without using capitals though!

Is a functional return a valid form of output (for JS, for example)?

Does use of the variable name $1 count as an occurrence of the number 1?

@Mwr247 alert(...) is traditionally the JS equivalent of STDOUT.

@plasticinsect Yes - you'd need to do something like $11 or the like instead.

@TimmyD Indeed, but arrow functions save a few characters, so I figured it wouldn't hurt to ask ;)

Those cities are not capitols. They are capitals.  A capitol is a building where a legislative body meets.  A capital is the city that holds governmental headquarters, such as a capitol.

@MontyHarder I blame Alex. Rolled back.

Is this output acceptable?

@Dennis Looks good.

so if "123" is not counting as 1, would be char a = 65.f be fine too? Since it isnt the explicit number 65, more its some expansion on it.

@Zaibis That would count as 65 since the logical atomic breakpoint is the period. a=165.f or a=656.f etc. would be OK.

Would this be acceptable: wget -q -O - http://tinyurl.com/pcg1-65-90 | awk '/Baton Rouge, LA/{a=1} a; /Carson City, NV/{a=0}'?

@Moreaki In addition to that being a loophole forbidden by default, your code also contains capital letters.

@TimmyD Apologies for the noise. I'll definitely keep the loophole in mind the next time. In fact it would be rather pointless to allow such a feature.

@Moreaki Don't worry. And welcome to PPCG!

I'm definitely going to have to re-find that animaniacs video now.

Please god no brainfuck entries before I get home...

R, 96 bytes 98 bytes -20% -> 78.4
Thanks to @plasticinsect for the bonus!
library(maps);data(us.cities);cat(gsub("()( \\w+)$",",\\2",us.cities$n[us.cities$ca==2]),sep="\n")

Previous code at 96 bytes:
library(maps);data(us.cities);cat(gsub("( \\w+)$",",\\1",us.cities$n[us.cities$ca==2]),sep="\n")

From package maps, it loads a dataset of US cities. Column capital contains a 2 if it is a state capital. The names of the cities are given is column name in the form "City StateAbbreviation" (i. e. Albany NY), so one need to add an explicit delimiter in between before output. To do so I eventually use the regex \1 meaning I can't have the bonus I suppose. To avoid using \1 in the regex I added an empty group so that I can use \2.
Usage:
> library(maps);data(us.cities);cat(gsub("()( \\w+)$",",\\2",us.cities$n[us.cities$ca>1]),sep="\n")
Albany, NY
Annapolis, MD
Atlanta, GA
Augusta, ME
Austin, TX
Baton Rouge, LA
Bismarck, ND
Boise, ID
Boston, MA
Carson City, NV
Charleston, WV
Cheyenne, WY
Columbia, SC
Columbus, OH
Concord, NH
Denver, CO
Des Moines, IA
Dover, DE
Frankfort, KY
Harrisburg, PA
Hartford, CT
Helena, MT
Honolulu, HI
Indianapolis, IN
Jackson, MS
Jefferson City, MO
Juneau, AK
Lansing, MI
Lincoln, NE
Little Rock, AR
Madison, WI
Montgomery, AL
Montpelier, VT
Nashville, TN
Oklahoma City, OK
Olympia, WA
Phoenix, AZ
Pierre, SD
Providence, RI
Raleigh, NC
Richmond, VA
Sacramento, CA
Saint Paul, MN
Salem, OR
Salt Lake City, UT
Santa Fe, NM
Springfield, IL
Tallahassee, FL
Topeka, KS
Trenton, NJ

If you add an empty capture group to the beginning of your regex, you could use \2 instead of \1. It would cost you two bytes, but gain you the bonus.

@plasticinsect Thanks! I wouldn't have thought of that.

Great use of built-in. Three things: 1. you can type the newline within the code instead of \n for 1 byte, >0 instead of ``==2and also I don't think you needdata(us.cities)`, on my machine it loads when you load the pacakage. Try it out!

Even shorter by renaming the data.

Mathematica, 168 153 149 bytes - 20% = 119.2 bytes
u="\.55nited\.53tates";\.41dministrative\.44ivision\.44ata[{#,u}&/@\.43ountry\.44ata[u,"\.52egions"],{"\.43apital\.4eame","\.53tate\.41bbreviation"}]

Obligatory, but I did not know that any character can be replaced by \.xx or \:xxxx with the appropriate hex code.
Edit: Cut of 4 more characters by replacing Thread with a pure function.
Output:
{{Montgomery,AL},{Juneau,AK},{Phoenix,AZ},{Little Rock,AR},{Sacramento,CA},{Denver,CO},{Hartford,CT},{Dover,DE},{Washington,DC},{Tallahassee,FL},{Atlanta,GA},{Honolulu,HI},{Boise,ID},{Springfield,IL},{Indianapolis,IN},{Des Moines,IA},{Topeka,KS},{Frankfort,KY},{Baton Rouge,LA},{Augusta,ME},{Annapolis,MD},{Boston,MA},{Lansing,MI},{Saint Paul,MN},{Jackson,MS},{Jefferson City,MO},{Helena,MT},{Lincoln,NE},{Carson City,NV},{Concord,NH},{Trenton,NJ},{Santa Fe,NM},{Albany,NY},{Raleigh,NC},{Bismarck,ND},{Columbus,OH},{Oklahoma City,OK},{Salem,OR},{Harrisburg,PA},{Providence,RI},{Columbia,SC},{Pierre,SD},{Nashville,TN},{Austin,TX},{Salt Lake City,UT},{Montpelier,VT},{Richmond,VA},{Olympia,WA},{Charleston,WV},{Madison,WI},{Cheyenne,WY}}

I don't think the forbidden numbers are used either

Very clear way to capitalise.  I wasn't aware of that use of hex codes. How do you get them not to immediately display as capitals in the code?

This may save some code, even after you replace the caps:EntityValue[EntityList[EntityClass["AdministrativeDivision", "AllUSStatesPlusDC"]], {"CapitalName","StateAbbreviation"}]

@DavidCarraher Too many capitals in AllUSStatesPlusDC I'm afraid!

Yes. I see what you mean.

Similar to @David's, you can also try #/@{"CapitalName","StateAbbreviation"}&/@CountryData["US"]["AdministrativeDivisions"].  This one includes DC like your current solution, to get rid of it you can add DeleteCases[%, {_, "DC"}].

CJam, 312 bytes
".ýç9.5i-jæ¤þ¸«Ã«cj|ù;ÎüÄ`Ñ¯Äÿçsøi4ÔÚ0;¾o'ÈàÚãÕ»®¼v{Ðù·*ñfiö\^é]ù¬ðö¸qÚpÿ©a$ÿÆhk¥½éØ×ïÕ{ñ9ÁÛ%Ðø¦ð·âßxâj   Öë¬¯,Ð+?Û¡!ù%Âí©Úfx`¤|}¼>qñµÉÎ4Óæj-wöÄÆ 4,üÖáÌxsÍ·üãýÛêmÁj±æ0?³¢¶§%Û57Ëmc.~`b=´á¥ÉpË,ôb¶ÌsÁì¾*§òÿ_Ö©;<tíèz6ljç¸b§èäø>`ÍÚ×¤ÒòÔ§~hÝ®Ú8¼}8Ì7rÿé×ÔÎîæ¡©)Ô@"'[fm256,f=)b27b'`f+'`/{_2>'q/32af.^' *o2<eup}/

The code is 390 bytes long and qualifies for the 20% bonus.
Note that the code is riddled with unprintable characters. Try it online in the CJam interpreter.
Idea
We have to encode the output somehow without using uppercase letters or the numbers 1 and 65 to 90 anywhere in the code.
We start by rewriting the desired output as
akjuneau`paharrisburg`txaustin`maboston`wvcharleston`azphoenix`kyfrankfort`msjackson`mdannapolis`vtmontpelier`ndbismarck`hihonolulu`meaugusta`nvcarsonqcity`sccolumbia`ohcolumbus`wycheyenne`casacramento`arlittleqrock`nmsantaqfe`mnsaintqpaul`idboise`tnnashville`codenver`nhconcord`almontgomery`inindianapolis`riprovidence`utsaltqlakeqcity`ilspringfield`ncraleigh`labatonqrouge`sdpierre`dedover`orsalem`waolympia`kstopeka`varichmond`cthartford`nyalbany`milansing`njtrenton`mthelena`iadesqmoines`gaatlanta`wimadison`nelincoln`fltallahassee`okoklahomaqcity`mojefferson

By subtracting the character ` from all characters of that string, we obtain an array containing integers from 0 to 26. We can convert this array from base 27 to base 229, yielding an array of integers from 0 to 228.
If we add 91 to each base-229 digit and take the results modulo 256, we map the range [0, …, 164] to [91, … 255], and the range [165, …, 228] to [0, …, 63]. This leaves the characters with code points from 64 (@) to 90 (Z) unused.
The string to encode is not in the same order as the sample output in the question. I tried several permutation until I found one that contains no null bytes, linefeeds, carriage returns or non-breaking spaces (problematic with the online interpreter), and no double quotes (require escaping).
Code
"…@"   e# Push a string of 342 ISO-8859-1 characters.
'[fm   e# Subtract the char '[' (code point 91) from each char of the string.
256,f= e# Compute the remainder of the differences divided by 256.
)      e# Pop the last integer from the array ('@' -> 27 -> 229).
b27b   e# Convert the remaining array from base 229 to base 27.
'`f+   e# Add the character '`' to the resulting digits.
       e# This pushes the string from the "Idea" section.
'`/    e# Split the result at backticks.
{      e# For each resulting chunk C:
  _2>  e#   Copy C and remove its first to characters.
  'q/  e#   Split at occurrences of 'q'.
  32a  e#   Push [32].
  f.^  e#   Mapped, vectorized XOR; XOR the first character of each chunk
       e#   with 32. This changes its case.
  ' *  e#   Join the resulting chunks, separating by spaces.
  o    e#   Print.
  2<   e#   Reduce the original C to its first two characters.
  eu   e#   Convert to uppercase.
  p    e#   Print, enclosed in double quotes, and followed by a linefeed.
}/     e#

So how does this work? How are the capitals generated without being coded in?

@MathiasFoster I've updated my answer.

javascript, 727 687 bytes - 20% = 549.6
alert('baton rouge;indianapolis;columbus;montgomery;helena;denver;boise;austin;boston;albany;tallahassee;santa fe;nashville;trenton;jefferson;richmond;pierre;harrisburg;augusta;providence;dover;concord;montpelier;hartford;topeka;saint paul;juneau;lincoln;raleigh;madison;olympia;phoenix;lansing;honolulu;jackson;springfield;columbia;annapolis;cheyenne;salt lake city;atlanta;bismarck;frankfort;salem;little rock;des moines;sacramento;oklahoma city;charleston;carson city'.split`;`.map((a,i)=>a.split` `.map(b=>b[0][u='to\x55pper\x43ase']()+b.slice(-~0)).join` `+0+'lainohalmtcoidtxmanyflnmtnnjmovasdpameridenhvtctksmnaknencwiwaazmihimsilscmdwyutgandkyorariacaokwvnv'[u]().substr(i*2,2)))

javascript is particularly tough as well, considering their long function names and camelcase. splitting out the states saved a ton on delimiters, and made it easier to work with all around.
@mbomb007 nothing in the post capitalized for a reason ;)

Perl, 605 bytes - 20% = 484
$_="baton rouge,laindianapolis,incolumbus,ohmontgomery,alhelena,mtdenver,coboise,idaustin,txboston,maalbany,nytallahassee,flsanta fe,nmnashville,tntrenton,njjefferson,morichmond,vapierre,sdharrisburg,paaugusta,meprovidence,ridover,deconcord,nhmontpelier,vthartford,cttopeka,kssaint paul,mnjuneau,aklincoln,neraleigh,ncmadison,wiolympia,waphoenix,azlansing,mihonolulu,hijackson,msspringfield,ilcolumbia,scannapolis,mdcheyenne,wysalt lake city,utatlanta,gabismarck,ndfrankfort,kysalem,orlittle rock,ardes moines,iasacramento,caoklahoma city,okcharleston,wvcarson city,nv";s/,../uc"$&;"/eg;s/\b./\u$&/g;print

My first version was invalid because it used \U to convert to uppercase. This one uses \u on each letter of the state abbreviation. I also had to add a dummy capture group to avoid using $1.
Edit: I was able to shave off 8 bytes by using uc() with the e flag. (Thank you Dom Hastings.)

C, 703 700 bytes - 20% = 560 bytes
main(){int c=!0;char*p="@baton@rouge[la*indianapolis[in*columbus[oh*montgomery[al*helena[mt*denver[co*boise[id*austin[tx*boston[ma*albany[ny*tallahassee[fl*santa@fe[nm*nashville[tn*trenton[nj*jefferson[mo*richmond[va*pierre[sd*harrisburg[pa*augusta[me*providence[ri*dover[de*concord[nh*montpelier[vt*hartford[ct*topeka[ks*saint@paul[mn*juneau[ak*lincoln[ne*raleigh[nc*madison[wi*olympia[wa*phoenix[az*lansing[mi*honolulu[hi*jackson[ms*springfield[il*columbia[sc*annapolis[md*cheyenne[wy*salt@lake@city[ut*atlanta[ga*bismarck[nd*frankfort[ky*salem[or*little@rock[ar*des@moines[ia*sacramento[ca*oklahoma@city[ok*charleston[wv*carson@city[nv*";while(*++p)c+=*p<97?2+*p/91:0,printf("%c",c?--c,*p-32:*p);}

I changed the loop a bit to make it compile with non-C99 compilers. Online version

Finally, the comma operator is useful.

Python 3, 1416 793 785 779 771 755 734 characters - 20% = 587.2
No algorithmic cleverness here, I just took the required output, sorted it (this lets zlib do a better job), compressed it (using zopfli --deflate), base64-encoded the result, and then changed the encoding around to avoid capital letters.
import zlib,base64;print(zlib.decompress(base64.b64decode('>_"@sq*w%>yf^+?!|#-#rii*hezbdf9()#_&m&",s;bb74@n7_93,t>d09rek;+~<l1":+>sr!m~qgv?0[,)z;?>$|p5.i)hegtak<&:db9hg9(xat3yp%x_(j}m]<j7^d?-2$g]5.l:-:g/{da?ow+ykpu}..8g)9"b+h7/[p]ex%x#rp!7u0w3*66|/%:{idbsh|$v/&0^9l!?v8hn-m8%"l^7wx]%_k>h1k(xh~1))h/<x0wdr7")7024.f6~qb;<;$5{tby$>_nid-d!x+,pl0zt[yj5bv"/<+^,$ti>}]3q!gd6>:h/sw}<#x>-lj5#h@w:i01d?m^ks2|,v"^coy^p.l{l{6jxbs,a??m14/h0%/m3j-q_zm@;uu[rgx<(4{{s,en/":1oc|!]fvpsjt$}9z?b&#^;58%@m78i8wf<*u",mizg7;3.3*l7o{0,._oyz0&y5d#afpgc38_-ww_7jx;xd;,:ooajzt54ohq@y,aw2|20s)$k"|dso*<ra](%%jm<+&upl%[)y/?+{[|<jr8!w=='.translate({ord(x):y+60+5 for x,y in zip('!"#$%&()*,-.:;<>?@[]^_{|}~',range(26))})),-9).decode('u8'))

Un-golfed:
import zlib, base64

DATA = '>_"@sq*w%>yf^+?!|#-#rii*hezbdf9()#_&m&",s;bb74@n7_93,t>d09rek;+~<l1":+>sr!m~qgv?0[,)z;?>$|p5.i)hegtak<&:db9hg9(xat3yp%x_(j}m]<j7^d?-2$g]5.l:-:g/{da?ow+ykpu}..8g)9"b+h7/[p]ex%x#rp!7u0w3*66|/%:{idbsh|$v/&0^9l!?v8hn-m8%"l^7wx]%_k>h1k(xh~1))h/<x0wdr7")7024.f6~qb;<;$5{tby$>_nid-d!x+,pl0zt[yj5bv"/<+^,$ti>}]3q!gd6>:h/sw}<#x>-lj5#h@w:i01d?m^ks2|,v"^coy^p.l{l{6jxbs,a??m14/h0%/m3j-q_zm@;uu[rgx<(4{{s,en/":1oc|!]fvpsjt$}9z?b&#^;58%@m78i8wf<*u",mizg7;3.3*l7o{0,._oyz0&y5d#afpgc38_-ww_7jx;xd;,:ooajzt54ohq@y,aw2|20s)$k"|dso*<ra](%%jm<+&upl%[)y/?+{[|<jr8!w=='

TR = { ord(x) : y+60+5
       for x,y in zip('!"#$%&()*,-.:;<>?@[]^_{|}~', range(26)) }

print(zlib.decompress(base64.b64decode(DATA.translate(TR)),
                      -9)
      .decode('utf-8'))

There is probably more to be squeezed out of this, especially if you can express the argument to translate() more compactly.  Note that the punctuation in there is carefully chosen to avoid base64's own punctuation (+/=) and anything that would need backwhacking in a string literal.
Fun fact: the bz2 and lzma modules both do worse on this input than zlib:
>>> z = base64.b64decode('>_"@sq*w%>yf^+?!|#-#rii*hezbdf9()#_&m&",s;bb74@n7_93,t>d09rek;+~<l1":+>sr!m~qgv?0[,)z;?>$|p5.i)hegtak<&:db9hg9(xat3yp%x_(j}m]<j7^d?-2$g]5.l:-:g/{da?ow+ykpu}..8g)9"b+h7/[p]ex%x#rp!7u0w3*66|/%:{idbsh|$v/&0^9l!?v8hn-m8%"l^7wx]%_k>h1k(xh~1))h/<x0wdr7")7024.f6~qb;<;$5{tby$>_nid-d!x+,pl0zt[yj5bv"/<+^,$ti>}]3q!gd6>:h/sw}<#x>-lj5#h@w:i01d?m^ks2|,v"^coy^p.l{l{6jxbs,a??m14/h0%/m3j-q_zm@;uu[rgx<(4{{s,en/":1oc|!]fvpsjt$}9z?b&#^;58%@m78i8wf<*u",mizg7;3.3*l7o{0,._oyz0&y5d#afpgc38_-ww_7jx;xd;,:ooajzt54ohq@y,aw2|20s)$k"|dso*<ra](%%jm<+&upl%[)y/?+{[|<jr8!w=='.translate({ord(x):ord(y)-32 for x,y in zip('!"#$%&()*,-.:;<>?@[]^_{|}~','abcdefghijklmnopqrstuvwxyz')}))
>>> u = zlib.decompress(x,-9)
>>> len(u)
663
>>> len(z)
427
>>> len(zlib.compress(z))
437
>>> len(bz2.compress(z))
456
>>> len(lzma.compress(z))
620

At least it's nice and readable. ;-)

You can remove the import zlib,base6 at the beginning and do DATA.translate(tr).decode('base64').decode('zlib').decode('utf-8') Why do you need that decode('utf-8') at all?

@ppperry Sadly, your suggestion only works in Python 2; and in Python 2, .translate works differently and { x:y for x,y in ... } is not available.  Without the .decode('u8'), in Python 3, the output is the repr() of the byte string, which is far enough off from the requested output that I didn't think it should count.

javascript (es6) 516 (645-20%) 532 (664-20%)
test running the snippet below in any recent browser: the only es6 feature used is template strings

alert(`
labaton rouge
inindianapolis
ohcolumbus
almontgomery
mthelena
codenver
idboise
txaustin
maboston
nyalbany
fltallahassee
nmsanta fe
tnnashville
njtrenton
mojefferson
varichmond
sdpierre
paharrisburg
meaugusta
riprovidence
dedover
nhconcord
vtmontpelier
cthartford
kstopeka
mnsaint paul
akjuneau
nelincoln
ncraleigh
wimadison
waolympia
azphoenix
milansing
hihonolulu
msjackson
ilspringfield
sccolumbia
mdannapolis
wycheyenne
utsalt lake city
gaatlanta
ndbismarck
kyfrankfort
orsalem
arlittle rock
iades moines
casacramento
okoklahoma city
wvcharleston
nvcarson city
`.replace(/(\n..)(.)| ./g,(w,x,y)=>(y?x+','+y:w)['to\x55pper\x43ase']()))

very clever! hadn't thought of replace for whatever reason...

Funciton, 5045 − 20% = 4036 bytes
This code contains only one number, and it’s not in the range 65 through 90. Nor is it the number 1. In fact, this number is 4187 decimal digits, which cleanly factorizes into primes 79×53.
As always, get nicer rendering by executing $('pre').css('line-height',1); in your browser console.
╔═══════════════════════════════════════════════════════════════════════════════╗
║7136715096855386138244201921379984522081157959387689102965666099527710666770872║
║8632405046019650473694855863386057142772501332293800147289916078651647760772443║
║8725652766505885348060772769789231580343563435533130895917300237406562638030980║
║3711194146648873765244744781953334585902685570475123886704870369061449702689564║
║3595572359214492754563209811697465519112054922140302657793458997381684588970868║
║7793823212145990790477442216616349142872430200820970858787998435483524660584416║
║6164882066597488329789212167115912389108306700132767580336075847661452995278441║
║4608506136620095732142590833871485553260077395557115141102093496100483811080395║
║6552804273104384398276311006450509670233242612250087379855689038722276735360412║
║6878753848057526563710344191563893599886868947829201220173418232286377514939888║
║5826479634935379423693839085984565815131964110239432620200938530722481854602826║
║9037704900171802579729347376622932167603510862768435434759967894116610786905139║
║7412487476129828359043674372610945304257752777678880166233522176263310236004692║
║0559345181857154078616512980811741354072155133642234106705715867670036797456411║
║3264775046807948785891163930492821367841190494057926544207551600789781134233199║
║4931373746463823081063091455500394879663289567724955802959562627212816895887920║
║2489552640528826478935177736926106383314641517898028085103843993947923512080284║
║1297634633899484758145253947029431905171166312060063580822580997396575916969283║
║8159188436765390151074141915725490631912068692580040188837785831216953037087556║
║0321645257600479747768084542577912902995339088536912361110657756023624089620615║
║5158613866208649015722071421838484405731207470388752536584022013701916919845375║
║3209922919010373613440766178725948038885270419846274466164969481905438092706837║
║6125745847739006120558864887675350117798119205719776692338137137532239709753293║
║8995102505657504327982204450387974737246780507128822708181598416111438056330283║
║4785530759635414792062372089201435348108257958259667891277855066169836153935818║
║4849044313927545256942990267263122642672090579649898429311837755460330426123991║
║0865666851722460685754104973378688314066186075716326618952555696686125861179585╟
║7767008528632788251800639156553539356488180142086268151130154661765322967918167║
║6359863162328432204277806522752416226370770476079674225817370337594249020946663║
║1822184578010876426310754786368155838502939742370374540683825491575130213369657║
║2120804668997619419445916101731942338784683470192383635854329364775377151471990║
║2655205750667024595911951526939478313795716952326483704217123605616832952264503║
║8356212760984291960912048067411637475389334580447270650407546381067041317195274║
║3658815060537830411410963930585836537141345277217896786840243174681916988181583║
║8390084258839955570465021603546831767108002881554379542200508579678822598563892║
║8621176190864640015677903257299296220003472794175916462345690686103548377723578║
║6760505049046712538526435515066511975271300115330547105472335029933058732991785║
║5589232894601143279598099962031945524489480851133384138840761826907713777131329║
║9653475711559777326388996740771947433446060772704682592783253818915955015393899║
║8513366910314301930539317844646403762279062435716757707854074235922915355490960║
║9007713445763282900095169953058848056683723033266818136479787173846475991012202║
║9462375527766882809250645176534521094942659081258046722219759280486004661723805║
║6786432900677055552677470564184679327084173152258835307889916896828977570843423║
║3265510347632679682249919679555731735198061941806081777484490821424077128775482║
║4866960679621740266038712499696089430677992126743925060145440886995190894304525║
║3469457565680576996559817327023534136403178656947913819462072799063875416015296║
║0646268276069839972076911667210841845209380552353634062961962574981823297845248║
║7817510295701815725710777747052257272070773995280590130309991890195320939352205║
║3629070121725848802522009518874134452415909082137665653417182020188245139223466║
║1804690429428088774753298257855093982064922470661344462996583642233273038068537║
║5899655675409028134860922908216970845189239846431322757349357911553610461726138║
║9065104191927373357937390905721074233359257891159853454407258925428691711525208║
║0898360915775189300266760522953739009955921695946386500512104598494398514200642║
╚═══════════════════════════════════════════════════════════════════════════════╝

Edit: Kiri-ban! This answer is codegolf.SE post #61000!

Uncaught TypeError: $(...).css is not a function(…)

x86 machine code, 764 bytes
612 if bonus awarded
Totally self-contained program. Only relies upon (a) Bios int 0x10 being available to print each char and (b) DS, ES, SP and SS being initialized before program is called, DOS does this.(and DOS-Box too) Otherwise, the code relies on nothing.
The absolute minimum without any dependencies at all except for the BIOS rom, would be about 2 floppy disk sectors @512 bytes each.
It doesn't seem to exploit any of the standard loop-holes, though while some bytes of the program are 01, these are not numbers in the source. However, since I'd like to submit the binary code as my solution, I imagine that would disallow the 01 bytes.?
Hex-editor view of binary:
68 98 01 E8 1D 00 CD 20 B3 62 FE CB 88 DF 80 C7 19 38 D8 72 0D 38 F8 77 09 30 DB FE C3 C0 E3 05 -   h˜.è..Í ³bþËˆß€Ç.8Ør.8øw.0ÛþÃÀã.
28 D8 C3 55 89 E5 81 C5 04 00 8B 76 00 89 F7 AC A8 FF 74 3E 80 3E 96 01 00 75 0A E8 CA FF AA A2 -   (ØÃU‰å.Å..‹v.‰÷¬¨ÿt>€>–..u.èÊÿª¢
96 01 E9 EA FF 3C 2C 75 18 AA AC E8 BA FF AA AC E8 B5 FF AA AC AA AC E8 AE FF AA A2 96 01 E9 CE -   –.éêÿ<,u.ª¬èºÿª¬èµÿª¬ª¬è®ÿª¢–.éÎ
FF 80 3E 96 01 20 75 03 E8 9D FF AA A2 96 01 E9 BD FF 8B 76 00 AC A8 FF 74 1A 3C 2D 75 0F B0 0D -   ÿ€>–. u.è.ÿª¢–.é½ÿ‹v.¬¨ÿt.<-u.°.
B4 0E CD 10 B0 0A B4 0E CD 10 E9 E8 FF B4 0E CD 10 E9 E1 FF 5D C3 00 00 62 61 74 6F 6E 72 6F 75 -   ´.Í.°.´.Í.éèÿ´.Í.éáÿ]Ã..batonrou
67 65 2C 6C 61 2D 69 6E 64 69 61 6E 61 70 6F 6C 69 73 2C 69 6E 2D 63 6F 6C 75 6D 62 75 73 2C 6F -   ge,la-indianapolis,in-columbus,o
68 2D 6D 6F 6E 74 67 6F 6D 65 72 79 2C 61 6C 2D 68 65 6C 65 6E 61 2C 6D 74 2D 64 65 6E 76 65 72 -   h-montgomery,al-helena,mt-denver
2C 63 6F 2D 62 6F 69 73 65 2C 69 64 2D 61 75 73 74 69 6E 2C 74 78 2D 62 6F 73 74 6F 6E 2C 6D 61 -   ,co-boise,id-austin,tx-boston,ma
2D 61 6C 62 61 6E 79 2C 6E 79 2D 74 61 6C 6C 61 68 61 73 73 65 65 2C 66 6C 2D 73 61 6E 74 61 66 -   -albany,ny-tallahassee,fl-santaf
65 2C 6E 6D 2D 6E 61 73 68 76 69 6C 6C 65 2C 74 6E 2D 74 72 65 6E 74 6F 6E 2C 6E 6A 2D 6A 65 66 -   e,nm-nashville,tn-trenton,nj-jef
66 65 72 73 6F 6E 2C 6D 6F 2D 72 69 63 68 6D 6F 6E 64 2C 76 61 2D 70 69 65 72 72 65 2C 73 64 2D -   ferson,mo-richmond,va-pierre,sd-
68 61 72 72 69 73 62 75 72 67 2C 70 61 2D 61 75 67 75 73 74 61 2C 6D 65 2D 70 72 6F 76 69 64 65 -   harrisburg,pa-augusta,me-provide
6E 63 65 2C 72 69 2D 64 6F 76 65 72 2C 64 65 2D 63 6F 6E 63 6F 72 64 2C 6E 68 2D 6D 6F 6E 74 70 -   nce,ri-dover,de-concord,nh-montp
65 6C 69 65 72 2C 76 74 2D 68 61 72 74 66 6F 72 64 2C 63 74 2D 74 6F 70 65 6B 61 2C 6B 73 2D 73 -   elier,vt-hartford,ct-topeka,ks-s
61 69 6E 74 20 70 61 75 6C 2C 6D 6E 2D 6A 75 6E 65 61 75 2C 61 6B 2D 6C 69 6E 63 6F 6C 6E 2C 6E -   aint paul,mn-juneau,ak-lincoln,n
65 2D 72 61 6C 65 69 67 68 2C 6E 63 2D 6D 61 64 69 73 6F 6E 2C 77 69 2D 6F 6C 79 6D 70 69 61 2C -   e-raleigh,nc-madison,wi-olympia,
77 61 2D 70 68 6F 65 6E 69 78 2C 61 7A 2D 6C 61 6E 73 69 6E 67 2C 6D 69 2D 68 6F 6E 6F 6C 75 6C -   wa-phoenix,az-lansing,mi-honolul
75 2C 68 69 2D 6A 61 63 6B 73 6F 6E 2C 6D 73 2D 73 70 72 69 6E 67 66 69 65 6C 64 2C 69 6C 2D 63 -   u,hi-jackson,ms-springfield,il-c
6F 6C 75 6D 62 69 61 2C 73 63 2D 61 6E 6E 61 70 6F 6C 69 73 2C 6D 64 2D 63 68 65 79 65 6E 6E 65 -   olumbia,sc-annapolis,md-cheyenne
2C 77 79 2D 73 61 6C 74 20 6C 61 6B 65 20 63 69 74 79 2C 75 74 2D 61 74 6C 61 6E 74 61 2C 67 61 -   ,wy-salt lake city,ut-atlanta,ga
2D 62 69 73 6D 61 72 63 6B 2C 6E 64 2D 66 72 61 6E 6B 66 6F 72 74 2C 6B 79 2D 73 61 6C 65 6D 2C -   -bismarck,nd-frankfort,ky-salem,
6F 72 2D 6C 69 74 74 6C 65 20 72 6F 63 6B 2C 61 72 2D 64 65 73 20 6D 6F 69 6E 65 73 2C 69 61 2D -   or-little rock,ar-des moines,ia-
73 61 63 72 61 6D 65 6E 74 6F 2C 63 61 2D 6F 6B 6C 61 68 6F 6D 61 20 63 69 74 79 2C 6F 6B 2D 63 -   sacramento,ca-oklahoma city,ok-c
68 61 72 6C 65 73 74 6F 6E 2C 77 76 2D 63 61 72 73 6F 6E 20 63 69 74 79 2C 6E 76 00             -   harleston,wv-carson city,nv.

'Un-golfed' version (source - 3126 bytes)
[section .text]
[bits 16]
[org 0x100]
entry_point:
    push    word capital_list
    call    output_string
    int 0x20

; input:
;       al = char
; outpt:
;       if al if an alpha char, ensures it is in range [capital-a .. capital-z]
toupper:
    mov     bl, 98
    dec     bl              ; bl = 'a'
    mov     bh, bl
    add     bh, 25          ; bh = 'z'
    cmp     al, bl          ;'a'
    jb      .toupperdone
    cmp     al, bh
    ja      .toupperdone
    xor     bl, bl
    inc     bl
    shl     bl, 5           ; bl = 32
    sub     al, bl          ;capital'a' - 'a' (32)
.toupperdone:
    ret

;void outputstring(char *str)
outputstring:
    push    bp
    mov     bp, sp
    add     bp, 4

    mov     si, [bp + 0]        ; si --> string
    mov     di, si

; I run over the text in two passes - because I'm too tired right now to make it
;   a tighter, more efficient loop. Perhaps after some sleep.
; In the first pass, I just convert the appropriate chars to upper-case
.get_char_pass_1:
    lodsb
    test    al, 0xff
    jz      .pass_1_done
    cmp     [last_char], byte 0
    jne     .not_first_char
    call    toupper
    stosb
    mov     [last_char], al
    jmp     .get_char_pass_1
.not_first_char:
.check_if_sep:
    cmp     al, ','             ; if this char is a comma, the next 2 need to be uppercase
    jne     .not_seperator
    stosb                       ; spit out the comma, unchanged
    lodsb
    call    toupper
    stosb
    lodsb
    call    toupper
    stosb
.gobble_delim:
    lodsb                       ; take care of the '-' delimiter
    stosb
.capitalize_first_letter_of_city:
    lodsb                       ; the following char is the first char of the city, capitalize it
    call    toupper
    stosb
    mov     [last_char], al
    jmp     .get_char_pass_1    ; go back for more
.not_seperator:
    cmp     [last_char], byte ' '
    jne     .output_this_char
    call    toupper
.output_this_char:
    stosb
    mov     [last_char], al
    jmp     .get_char_pass_1
.pass_1_done:

; In the second pass, I print the characters, except for the delimiters, which are skipped and
;   instead print a CRLF pair so that each city/state pair begins on a new line.
;
pass_2:
    mov     si, [bp+0]          ; point to string again
.pass_2_load_char:
    lodsb
    test    al, 0xff
    jz      .pass_2_done
    cmp     al, '-'             ; current char is a delimiter, dont print it - instead,
                                ;  print a carriage-return/line-feed pair
    jne     .not_delim_2
    mov     al, 0xd             ; LF
    mov     ah, 0xe
    int     0x10
    mov     al, 0xa             ; CR
    mov     ah, 0xe
    int     0x10
    jmp     .pass_2_load_char
.not_delim_2:
    mov     ah, 0xe
    int     0x10
    jmp     .pass_2_load_char
.pass_2_done:
    pop     bp
    ret
last_char   db  0

[section .data]
capital_list    db  'batonrouge,la-indianapolis,in-columbus,oh-montgomery,al-helena,mt-denver,co-boise,id-'
                db  'austin,tx-boston,ma-albany,ny-tallahassee,fl-santafe,nm-nashville,tn-trenton,nj-'
                db  'jefferson,mo-richmond,va-pierre,sd-harrisburg,pa-augusta,me-providence,ri-dover,de-'
                db  'concord,nh-montpelier,vt-hartford,ct-topeka,ks-saint paul,mn-juneau,ak-lincoln,ne-'
                db  'raleigh,nc-madison,wi-olympia,wa-phoenix,az-lansing,mi-honolulu,hi-jackson,ms-'
                db  'springfield,il-columbia,sc-annapolis,md-cheyenne,wy-salt lake city,ut-atlanta,ga-'
                db  'bismarck,nd-frankfort,ky-salem,or-little rock,ar-des moines,ia-sacramento,ca-'
                db  'oklahoma city,ok-charleston,wv-carson city,nv',0

Output:
Baton Rouge,LA
Indianapolis,IN
Columbus,OH
Montgomery,AL
Helena,MT
Denver,CO
Boise,ID
Austin,TX
Boston,MA
Albany,NY
Tallahassee,FL
Santa Fe,NM
Nashville,TN
Trenton,NJ
Jefferson,MO
Richmond,VA
Pierre,SD
Harrisburg,PA
Augusta,ME
Providence,RI
Dover,DE
Concord,NH
Montpelier,VT
Hartford,CT
Topeka,KS
Saint Paul,MN
Juneau,AK
Lincoln,NE
Raleigh,NC
Madison,WI
Olympia,WA
Phoenix,AZ
Lansing,MI
Honolulu,HI
Jackson,MS
Springfield,IL
Columbia,SC
Annapolis,MD
Cheyenne,WY
Salt Lake City,UT
Atlanta,GA
Bismarck,ND
Frankfort,KY
Salem,OR
Little Rock,AR
Des Moines,IA
Sacramento,CA
Oklahoma City,OK
Charleston,WV
Carson City,NV

Pyth, (631 -20%) = 504.8
=k!kmrd=k-6kc"baton rouge,la,indianapolis,in,columbus,oh,montgomery,al,helena,mt,denver,co,boise,id,austin,tx,boston,ma,albany,ny,tallahassee,fl,santa fe,nm,nashville,tn,trenton,nj,jefferson,mo,richmond,va,pierre,sd,harrisburg,pa,augusta,me,providence,ri,dover,de,concord,nh,montpelier,vt,hartford,ct,topeka,ks,saint paul,mn,juneau,ak,lincoln,ne,raleigh,nc,madison,wi,olympia,wa,phoenix,az,lansing,mi,honolulu,hi,jackson,ms,springfield,il,columbia,sc,annapolis,md,cheyenne,wy,salt lake city,ut,atlanta,ga,bismarck,nd,frankfort,ky,salem,or,little rock,ar,des moines,ia,sacramento,ca,oklahoma city,ok,charleston,wv,carson city,nv"","

Output:
['Baton Rouge', 'LA', 'Indianapolis', 'IN', 'Columbus', 'OH', 'Montgomery', 'AL', 'Helena', 'MT', 'Denver', 'CO', 'Boise', 'ID', 'Austin', 'TX', 'Boston', 'MA', 'Albany', 'NY', 'Tallahassee', 'FL', 'Santa Fe', 'NM', 'Nashville', 'TN', 'Trenton', 'NJ', 'Jefferson', 'MO', 'Richmond', 'VA', 'Pierre', 'SD', 'Harrisburg', 'PA', 'Augusta', 'ME', 'Providence', 'RI', 'Dover', 'DE', 'Concord', 'NH', 'Montpelier', 'VT', 'Hartford', 'CT', 'Topeka', 'KS', 'Saint Paul', 'MN', 'Juneau', 'AK', 'Lincoln', 'NE', 'Raleigh', 'NC', 'Madison', 'WI', 'Olympia', 'WA', 'Phoenix', 'AZ', 'Lansing', 'MI', 'Honolulu', 'HI', 'Jackson', 'MS', 'Springfield', 'IL', 'Columbia', 'SC', 'Annapolis', 'MD', 'Cheyenne', 'WY', 'Salt Lake City', 'UT', 'Atlanta', 'GA', 'Bismarck', 'ND', 'Frankfort', 'KY', 'Salem', 'OR', 'Little Rock', 'AR', 'Des Moines', 'IA', 'Sacramento', 'CA', 'Oklahoma City', 'OK', 'Charleston', 'WV', 'Carson City', 'NV']

The second parameter for r alternates between 5 (capwords()) and 1 (upper())

Oops, bad variable name. Luckily, they can be changed to lower case k

PowerShell, 1038 976 925 904 813 768 758 749 745 -20% = 596
"labaton rouge;inindianapolis;ohcolumbus;almontgomery;mthelena;codenver;idboise;txaustin;maboston;nyalbany;fltallahassee;nmsanta fe;tnnashville;njtrenton;mojefferson;varichmond;sdpierre;paharrisburg;meaugusta;riprovidence;dedover;nhconcord;vtmontpelier;cthartford;kstopeka;mnsaint paul;akjuneau;nelincoln;ncraleigh;wimadison;waolympia;azphoenix;milansing;hihonolulu;msjackson;ilspringfield;sccolumbia;mdannapolis;wycheyenne;utsalt lake city;gaatlanta;ndbismarck;kyfrankfort;orsalem;arlittle rock;iades moines;casacramento;okoklahoma city;wvcharleston;nvcarson city"-split";"|%{$a=-split$_;$b={$n,$i=$args;if($a[$n]){" "+(""+$a[$n][$i++]).toupper()+$a[$n].substring($i)}};$(&$b(0)2).trim()+$(&$b(3-2)0)+$(&$b(2)0)+","+$_.substring(0,2).toupper()}

Ungolfed:
"labaton rouge;inindianapolis;ohcolumbus;almontgomery;mthelena;codenver;idboise;txaustin;maboston;nyalbany;fltallahassee;nmsanta fe;tnnashville;njtrenton;mojefferson;varichmond;sdpierre;paharrisburg;meaugusta;riprovidence;dedover;nhconcord;vtmontpelier;cthartford;kstopeka;mnsaint paul;akjuneau;nelincoln;ncraleigh;wimadison;waolympia;azphoenix;milansing;hihonolulu;msjackson;ilspringfield;sccolumbia;mdannapolis;wycheyenne;utsalt lake city;gaatlanta;ndbismarck;kyfrankfort;orsalem;arlittle rock;iades moines;casacramento;okoklahoma city;wvcharleston;nvcarson city"-split";"|%{
   $a=-split$_;
   $b={
        $n,$i=$args;
        if($a[$n]){
          " "+
          (""+$a[$n][$i++]).toupper()+
          $a[$n].substring($i)
         }
      };
   $(&$b(0)2).trim()+
   $(&$b(3-2)0)+
   $(&$b(2)0)+
   ","+
   $_.substring(0,2).toupper()
 }

@TessellatingHeckler Thanks, but I can't use a literal 1 without losing the bonus.
And also, thanks for the earlier suggestions that enabled the 749 599.2 entry.

@TessellatingHeckler I did use your idea to use $_ on that last segment of the string - thanks!

Minkolang 0.7, 660 705 708 * 0.8 = 566.4
99*32-+58*0p467+35*44*55*d8+d5+(99*2-23-r32-p)"baton rouge, laindianapolis, incolumbus, ohmontgomery, alhelena, mtdenver, coboise, idaustin, txboston, maalbany, nytallahassee, flsanta fe, nmnashville, tntrenton, njjefferson, morichmond, vapierre, sdharrisburg, paaugusta, meprovidence, ridover, deconcord, nhmontpelier, vthartford, cttopeka, kssaint paul, mnjuneau, aklincoln, neraleigh, ncmadison, wiolympia, waphoenix, azlansing, mihonolulu, hijackson, msspringfield, ilcolumbia, scannapolis, mdcheyenne, wysalt lake city, utatlanta, gabismarck, ndfrankfort, kysalem, orlittle rock, ardes moines, iasacramento, caoklahoma city, okcharleston, wvcarson city, nv"032-w
48*-o(d","=2&o)oo22$[48*-o]d?.25*o48*-o)

Thanks to Sp3000 for reminding me that I can use p to put capital Os in the code!
Explanation
The bit of the first line before the " does nothing but put a R (rotate stack) in place of r and then replace all of the instances of o with O on the second line.
After that, it's the list of capitals without newlines and all letters lowercased, which is pushed onto the stack in reverse order by Minkolang. There is a 01w at the end which is a "wormhole" to the beginning of the second line. All capital letters are outputted by subtracting 32 from the lowercase letter, which is why 48*- shows up four times.
48*-O outputs B, then ( begins a while loop. The top of stack is checked against ,. If it's not ,, then O) outputs the character and jumps back to the beginning of the loop. If the top of stack is ,, then the program counter jumps over O) because of 2&, a conditional trampoline that jumps two spaces.
Now, I jump when I encounter a , because I know the next six characters are , AB\nC, which is what the rest of the loop does. There is a check to see if the stack is empty in the middle (after AB is printed, before \nC): d?. If it is, then the conditional trampoline is not taken and the program exits upon hitting the .. Otherwise, it's skipped and the loop continues.

PHP 520 bytes (650 bytes - 20%)
foreach(explode(',','baton rouge,indianapolis,columbus,montgomery,helena,denver,boise,austin,boston,albany,tallahassee,santa fe,nashville,trenton,jefferson,richmond,pierre,harrisburg,augusta,providence,dover,concord,montpelier,hartford,topeka,saint paul,juneau,lincoln,raleigh,madison,olympia,phoenix,lansing,honolulu,jackson,springfield,columbia,annapolis,cheyenne,salt lake city,atlanta,bismarck,frankfort,salem,little rock,des moines,sacramento,oklahoma city,charleston,carson city')as$k=>$v)echo ucwords($v).','.strtoupper(substr('lainohalmtcoidtxmanyflnmtnnjmovasdpameridenhvtctksmnaknencwiwaazmihimsilscmdwyutgandkyorariacaokwvnv',$k*2,2)).'_';

Result

Baton Rouge,LA_Indianapolis,IN_ …

Ungolfed:
$cities = 'baton rouge,indianapolis,columbus,montgomery,helena,denver,boise,austin,boston,albany,tallahassee,santa fe,nashville,trenton,jefferson,richmond,pierre,harrisburg,augusta,providence,dover,concord,montpelier,hartford,topeka,saint paul,juneau,lincoln,raleigh,madison,olympia,phoenix,lansing,honolulu,jackson,springfield,columbia,annapolis,cheyenne,salt lake city,atlanta,bismarck,frankfort,salem,little rock,des moines,sacramento,oklahoma city,charleston,carson city';
$states = 'lainohalmtcoidtxmanyflnmtnnjmovasdpameridenhvtctksmnaknencwiwaazmihimsilscmdwyutgandkyorariacaokwvnv';

foreach(explode(',',$cities) as $k => $v)
    echo ucwords($v)
         . ','
         . strtoupper(
             substr($states, $k * 2, 2)
         )
         . '_';

I tried various ways to compress the string, but in the end all solutions were longer than this straight forward approach.

Python 2, 658 bytes * 0.8 = 526.4
print zip([c.title()for c in"baton rouge.indianapolis.columbus.montgomery.helena.denver.boise.austin.boston.albany.tallahassee.santa fe.nashville.trenton.jefferson.richmond.pierre.harrisburg.augusta.providence.dover.concord.montpelier.hartford.topeka.saint paul.juneau.lincoln.raleigh.madison.olympia.phoenix.lansing.honolulu.jackson.springfield.columbia.annapolis.cheyenne.salt lake city.atlanta.bismarck.frankfurt.salem.little rock.des moines.sacramento.oklahoma city.charleston.carson city".split('.')],[s.upper()for s in map(''.join,zip(*[iter("lainohalmtcoidtxmanyflnmtnnjmovasdpameridenhvtctksmnaknencwiwaazmihimsilscmdwyutgandkyorariacaokwvnv")]*2))])

Prints the result as a Python list of Python tuples. They are also enclosed in quotes. This definitely qualifies for the bonus since the only number in the code is 2.
Output:
[('Baton Rouge', 'LA'), ('Indianapolis', 'IN'), ('Columbus', 'OH'), ('Montgomery', 'AL'), ('Helena', 'MT'), ('Denver', 'CO'), ('Boise', 'ID'), ('Austin', 'TX'), ('Boston', 'MA'), ('Albany', 'NY'), ('Tallahassee', 'FL'), ('Santa Fe', 'NM'), ('Nashville', 'TN'), ('Trenton', 'NJ'), ('Jefferson', 'MO'), ('Richmond', 'VA'), ('Pierre', 'SD'), ('Harrisburg', 'PA'), ('Augusta', 'ME'), ('Providence', 'RI'), ('Dover', 'DE'), ('Concord', 'NH'), ('Montpelier', 'VT'), ('Hartford', 'CT'), ('Topeka', 'KS'), ('Saint Paul', 'MN'), ('Juneau', 'AK'), ('Lincoln', 'NE'), ('Raleigh', 'NC'), ('Madison', 'WI'), ('Olympia', 'WA'), ('Phoenix', 'AZ'), ('Lansing', 'MI'), ('Honolulu', 'HI'), ('Jackson', 'MS'), ('Springfield', 'IL'), ('Columbia', 'SC'), ('Annapolis', 'MD'), ('Cheyenne', 'WY'), ('Salt Lake City', 'UT'), ('Atlanta', 'GA'), ('Bismarck', 'ND'), ('Frankfurt', 'KY'), ('Salem', 'OR'), ('Little Rock', 'AR'), ('Des Moines', 'IA'), ('Sacramento', 'CA'), ('Oklahoma City', 'OK'), ('Charleston', 'WV'), ('Carson City', 'NV')]

I hope this is within the acceptable bounds of formatting.

Groovy, 724 681 - 20% = 545 bytes
c={it.capitalize()}
'labaton rouge,inindianapolis,ohcolumbus,almontgomery,mthelena,codenver,idboise,txaustin,maboston,nyalbany,fltallahassee,nmsanta fe,tnnashville,njtrenton,mojefferson,varichmond,sdpierre,paharrisburg,meaugusta,riprovidence,dedover,nhconcord,vtmontpelier,cthartford,kstopeka,mnsaint paul,akjuneau,nelincoln,ncraleigh,wimadison,waolympia,azphoenix,milansing,hihonolulu,msjackson,ilspringfield,sccolumbia,mdannapolis,wycheyenne,utsalt lake city,gaatlanta,ndbismarck,kyfrankfort,orsalem,arlittle rock,iades moines,casacramento,okoklahoma city,wvcharleston,nvcarson city'.split(',').each{it.substring(2).split(' ').each{print c(it) + ' '}println c(it[0])+c(it[3-2])}

Inspired by Edc65's clever smushing together of state and city name!

Sorry about that. The code should now qualify for the bonus. I guess I should have read the bonus section more closely.

PowerShell, 627 -20% = 502 bytes
[regex]::replace('baton rougela;indianapolisin;columbusoh;montgomeryal;helenamt;denverco;boiseid;austintx;bostonma;albanyny;tallahasseefl;santa fenm;nashvilletn;trentonnj;jeffersonmo;richmondva;pierresd;harrisburgpa;augustame;providenceri;doverde;concordnh;montpeliervt;hartfordct;topekaks;saint paulmn;juneauak;lincolnne;raleighnc;madisonwi;olympiawa;phoenixaz;lansingmi;honoluluhi;jacksonms;springfieldil;columbiasc;annapolismd;cheyennewy;salt lake cityut;atlantaga;bismarcknd;frankfortky;salemor;little rockar;des moinesia;sacramentoca;oklahoma cityok;charlestonwv;carson citynv;','\b\w|..;',{"$args,"[3]+"$args".toupper()})

Which is this pattern:
[regex]::replace('baton rougela;','\b\w|..;',{"$args,"[3]+"$args".toupper()})

Uppercase the single letter after a word boundary, or the double letters before a colon. The "$args,"[3] selects either the comma in the case of a double letter state code, or overselects and returns null, and adds the state separators, saving ~50 in separators from the code line.

Ruby, (925 * 80%) = 740 bytes
require "zlib";eval "puts \x5alib::inflate('789c35925db2da300c85dfb50a16a04d98044a203f0ca450faa64b44e2892333b6c394dd57e1b66fdfb1251fe98c8dfb2279637d0323424fef6cc42a07931c4922fc61c0ccfd1c15ab8d624c56b0fd056b4a5e56273ff78ca581b58d1385fb88750e6b6f2363b140d422ac0c6414a2966736a9d305b28182e3cfe57551fc6611c6eb0d32efe6e9cb129eb37f3c476c76ca72f7a1c37a0739cb8b03668d525c55de0a472c0ce47e39ce37b00d24e3c38784871bec28041bbfe6d0e3d12c2a3d9677b21676ec58742b252f6ae566dc15504867e97f0e450d7bba8f7159e20c7b7e3c387c4403fb59986634072849a2951eab024aab533ac17aa39892630d48333127a8a8b34be7b580ca4beafdc4e18da6fca8273baba35f5aa8290e2feb1c635b43333a1afc44dfb1350768dc7b7a6a365703c7c1b3d83f687ec3517b03e3398763f02fdbb1dc194f059cc8b1ed07ac3338d9fb3079e9f062e04cf740134bf2982dca4a5a1d697658d5aa1c4fd89c1648ab9246fef6fed9ea89fe86d596b1aee0fc0cbaf0c3b2ebb028a125a783528cccb855e99f3c121eced086c546e3d8c35f3dcecbfd'.scan(/.{2}/).map {|i|i.hex.chr}.join)"

Oof, this one was hard. This is a Zlib compressed string in hex encoded bytes, which is then decompressed, turned into an array of strings by the scan regex, then each string is converted to a decimal integer, then to a character, and finally this array is joined into a string. I might post a better version later that uses a modified base64 encoding.
Though the encoded string may have some instances of 65-90 or 1's, I don't count those because the string is one huge number in hexadecimal. Thus this qualifies for the 20% bonus.

Python 2, 639 bytes - 20% = 511.2
t="labaton rouge,inindianapolis,ohcolumbus,almontgomery,mthelena,codenver,idboise,txaustin,maboston,nyalbany,fltallahassee,nmsanta fe,tnnashville,njtrenton,mojefferson,varichmond,sdpierre,paharrisburg,meaugusta,riprovidence,dedover,nhconcord,vtmontpelier,cthartford,kstopeka,mnsaint paul,akjuneau,nelincoln,ncraleigh,wimadison,waolympia,azphoenix,milansing,hihonolulu,msjackson,ilspringfield,sccolumbia,mdannapolis,wycheyenne,utsalt lake city,gaatlanta,ndbismarck,kyfrankfurt,orsalem,arlittle rock,iades moines,casacramento,okoklahoma city,wvcharleston,nvcarson city".split(",");print[(t[n][:2].upper(),t[n][2:].title())for n in range(50)]

The version bellow (675 bytes) has ''.join([w.capitalize()for w in t[n][2:].split()]) in it, which I just discovered can be replace by .title(), and is an anonymous function. In both answers, the state abbreviations are attached to the capitals.
lambda t="labaton rouge,inindianapolis,ohcolumbus,almontgomery,mthelena,codenver,idboise,txaustin,maboston,nyalbany,fltallahassee,nmsanta fe,tnnashville,njtrenton,mojefferson,varichmond,sdpierre,paharrisburg,meaugusta,riprovidence,dedover,nhconcord,vtmontpelier,cthartford,kstopeka,mnsaint paul,akjuneau,nelincoln,ncraleigh,wimadison,waolympia,azphoenix,milansing,hihonolulu,msjackson,ilspringfield,sccolumbia,mdannapolis,wycheyenne,utsalt lake city,gaatlanta,ndbismarck,kyfrankfurt,orsalem,arlittle rock,iades moines,casacramento,okoklahoma city,wvcharleston,nvcarson city".split(","):[(t[n][:2].upper(),''.join([w.capitalize()for w in t[n][2:].split()]))for n in range(50)]

x86 machine-code - 585 bytes, 468 with bonus
Dissapointed with how large my last entry was, I decided to try something very different this time. Drawing on insertusernamehere's idea of separating the city names from the state names, thus avoiding unnecessary logic and unneeded terminators, I still thought I've gotta be able to make the program smaller than the raw strings are. UPX wouldn't help me to cheat, complaining that the program was already too small. Thinking about compression, I tried to compress the 662 byte text output with WinRar but still only got 543 bytes - and that was without anything to decompress it with. It still seemed far too large, given that it was just the result, without any code.
Then I realized - I'm only using 26 chars for the letters and another 2 for the spaces and the commas. Hmm, that fits into 32, which needs just 5 bits. So, I wrote a quick javascript program to encode the strings, assigning a-z to 0-25 and space and comma got 26 and 27. To keep things simple, every character is encoded in 5 bits, whether it needs this many or not. From there, I just stuck
all the bits together and broke them back into byte-sized chunks. This allowed me to pack the 563 bytes of strings into 353 bytes - a saving of 37.5% or some 210 bytes. I didn't quite manage to squeeze the program and data into the same space as just the unpacked data, but I came close enough to be happy.
Hxd view of binary:
68 3F 00 68 E8 01 68 4F 03 E8 1C 00 68 22 01 68 27 02 68 B3 03 E8 10 00     -   h?.hè.hO.è..h".h'.h³.è..
BE 83 05 C6 04 00 68 4F 03 68 B3 03 E8 62 00 C3 55 89 E5 81 C5 04 00 8B     -   ¾ƒ.Æ..hO.h³.èb.ÃU‰å.Å..‹
76 02 8B 7E 00 B6 05 30 DB AC B2 08 D0 D0 D0 D3 FE CA FE CE 75 1E 80 FB     -   v.‹~.¶.0Û¬².ÐÐÐÓþÊþÎu.€û
1A 75 05 B3 20 E9 0D 00 80 FB 1B 75 05 B3 2C E9 03 00 80 C3 61 88 1D 47     -   .u.³ é..€û.u.³,é..€Ãaˆ.G
B6 05 30 DB 08 D2 75 D4 FF 4E 04 75 CC 5D C2 06 00 53 B3 62 FE CB 88 DF     -   ¶.0Û.ÒuÔÿN.uÌ]Â..S³bþËˆß
80 C7 19 38 D8 72 08 38 F8 77 04 B3 20 28 D8 5B C3 55 89 E5 81 C5 04 00     -   €Ç.8Ør.8øw.³ (Ø[ÃU‰å.Å..
8B 76 00 31 C0 88 C2 89 C1 AC A8 FF 74 46 80 FA 20 74 35 08 D2 74 31 3C     -   ‹v.1ÀˆÂ‰Á¬¨ÿtF€ú t5.Òt1<
2C 75 30 B4 0E CD 10 89 CB 01 DB 03 5E 02 8A 07 E8 B6 FF CD 10 43 8A 07     -   ,u0´.Í.‰Ë.Û.^.Š.è¶ÿÍ.CŠ.
E8 AE FF CD 10 B0 0D CD 10 B0 0A CD 10 C6 06 4C 03 00 30 D2 41 E9 C1 FF     -   è®ÿÍ.°.Í.°.Í.Æ.L..0ÒAéÁÿ
E8 96 FF B4 0E CD 10 88 C2 E9 B5 FF 5D C2 04 00 58 10 D7 1C 0B 64 C4 E4     -   è–ÿ´.Í.ˆÂéµÿ]Â..X.×..dÄä
0E 77 60 1B 82 AD AC 9B 5A 96 3A A0 90 DE 06 12 28 19 1A 7A CC 53 54 98     -   .w`.‚.¬›Z–: .Þ..(..zÌST˜
D0 29 A4 68 AC 8B 00 19 62 0E 86 49 0B 90 98 3B 62 93 30 1A 35 61 D1 04     -   Ð)¤h¬‹..b.†I..˜;b“0.5aÑ.
50 01 01 CA B5 5B 50 08 26 E6 EA 2E A1 89 B4 34 68 03 40 F7 2D 12 D8 9C     -   P..Êµ[P.&æê.¡‰´4h.@÷-.Øœ
BA 30 34 96 D8 E6 CC CE 61 23 8D 9C 8B 23 41 B1 91 B5 24 76 17 22 44 D8     -   º04–ØæÌÎa#.œ‹#A±‘µ$v."DØ
29 29 A1 BB 0B A5 37 37 60 58 40 DC 6E 60 5A C0 70 4A 44 26 E4 06 CC 1A     -   ))¡».¥77`X@Ün`ZÀpJD&ä.Ì.
29 36 D0 48 F5 42 D6 4D CE 24 6C DC DD A4 85 29 23 27 37 71 40 8E C7 34     -   )6ÐHõBÖMÎ$lÜÝ¤…)#'7q@ŽÇ4
7B 7A 09 18 93 67 04 62 89 06 91 36 C1 43 52 53 06 DF 17 55 03 23 44 4D     -   {z..“g.b‰.‘6ÁCRS.ß.U.#DM
8D D5 24 76 27 34 4E 88 F6 C7 36 6F 22 D0 48 EC E0 8C CA E8 8F 73 73 C8     -   .Õ$v'4NˆöÇ6o"ÐHìàŒÊè.ssÈ
A0 6E 40 43 67 A7 82 8B DA 68 D2 02 9B 5A 1A 27 2D BB 88 16 44 18 FB 60     -    n@Cg§‚‹ÚhÒ.›Z.'-»ˆ.D.û`
06 89 39 BB 72 F0 C7 A0 1B 79 DC 46 A2 FB 58 1B 24 34 DB 3B 9A E5 D1 74     -   .‰9»rðÇ .yÜF¢ûX.$4Û;šåÑt
DA 40 25 49 CD DC 9F 14 34 C5 41 16 3D 89 CB A3 02 80 6C 0D 68 1E E5 A2     -   Ú@%IÍÜŸ.4ÅA.=‰Ë£.€l.h.å¢
5B 11 C9 82 35 A4 DC 80 B9 E9 60 51 34 24 4F 1B 04 D6 06 CC 1B 0A 24 C0     -   [.É‚5¤Ü€¹é`Q4$O..Ö.Ì..$À
44 4A D9 62 06 A8 AE 8C F7 20 2C 8C DA D1 39 AC 9A 8B 84 AD 8C 92 D3 1C     -   DJÙb.¨®Œ÷ ,ŒÚÑ9¬š‹„.Œ’Ó.
86 92 5B 90 05 10 30 8D 9B B6 E5 2C 07 73 01 A1 22 78 D8 8E 08 AC 92 9B     -   †’[...0.›¶å,.s.¡"xØŽ.¬’›
9B B1 02 32 73 74 24 4F 1B                                                  -   ›±.2st$O.

Source-code:
[section .text]
[bits 16]
[org 0x100]
entry_point:
    push    word 63                 ; no of bytes of packed data = (5/8) * unpacked_length    - rounded up tp nearest byte
    push    word states_packed
    push    word states_unpacked
    call    unpack_bytes

    push    word 290                ; no bytes of packed data
    push    word capitals_packed
    push    word capitals_unpacked
    call    unpack_bytes

    ; ensure there's a terminating null after the capitals
    mov     si, nullTerminator
    mov     [si], byte 0

    ;void outputStrings(char *cities, char *states)
    push    word states_unpacked
    push    word capitals_unpacked
    call    output_strings

;   int 0x20
    ret

;void unpack_states(char *unpackedDest, char *packedInput, int packed_length)
;unpack_capitals:
unpack_bytes:
    push    bp
    mov     bp, sp
    add     bp, 4

    mov     si, [bp + 2]        ; point to the packed input
    mov     di, [bp + 0]        ; point to the output buffer

    mov     dh, 5               ; number of bits remaining until we have a full output byte, ready to be translated from [0..25] --> [A..Z] (+65) or 26-->' ' or 27-->','
    xor     bl, bl              ; clear our output accumalator
.unpack_get_byte:
    lodsb
    mov     dl, 8           ; number of bits remaining in this packed byte before we need another one
.unpack_get_next_bit:
    rcl     al, 1           ; put most significant bit into carry flag
    rcl     bl, 1           ; and put it into the least significant bit of our accumalator
    dec     dl              ; 1 bit less before we need another packed byte
    dec     dh              ; 1 bit less until this output byte is done
    jnz     .checkInputBitsRemaining

.transform_output_byte:
    cmp     bl, 26          ; space is encoded as 26
    jne     .notSpace
    mov     bl, ' '
    jmp     .store_output_byte
.notSpace:
    cmp     bl, 27          ; comma is encoded as 27
    jne     .notComma
    mov     bl, ','
    jmp     .store_output_byte
.notComma:
.alphaChar:
    add     bl, 'a'         ; change from [0..25] to [A..Z]
.store_output_byte:
    mov     [di], bl        ; store it
    inc     di              ; point to the next output element
    mov     dh, 5           ; and reset the count of bits till we get here again
    xor     bl, bl
.checkInputBitsRemaining:
    or      dl,dl           ; see if we've emptied the packed byte yet
    jnz     .unpack_get_next_bit

    dec     word [bp + 4]       ; decrement the number of bytes of input remaining to be processed
    jnz     .unpack_get_byte    ; if we still have some, go back for more

.unpack_input_processed:

    pop     bp
    ret     6

; input:
;       al = char
; outpt:
;       if al if an alpha char, ensures it is in range [capital-a .. capital-z]
toupper:
    push    bx
    mov     bl, 98
    dec     bl              ; bl = 'a'
    mov     bh, bl
    add     bh, 25          ; bh = 'z'
    cmp     al, bl          ;'a'
    jb      .toupperdone
    cmp     al, bh
    ja      .toupperdone
    mov     bl, 32
    sub     al, bl          ;'A' - 'a'
.toupperdone:
    pop     bx
    ret

;void outputStrings(char *cities, char *states)
output_strings:
    push    bp
    mov     bp, sp
    add     bp, 4

    mov     si, [bp + 0]            ; si --> array of cities
    xor     ax, ax
;   mov     [lastChar], al          ; last printed char is undefined at this point - we'll use this to know if we're processing the first entry
    mov     dl, al
;   mov     [string_index], ax      ; zero the string_index too
    mov     cx, ax                  ; zero the string_index too
.getOutputChar:
    lodsb
    test    al, 0xff
    jz      .outputDone             ; if we've got a NULL, it's the string terminator so exit

;   cmp     byte [lastChar], ' '    ; if the last char was a space, we have to capitalize this one
    cmp     dl, ' '                 ; if the last char was a space, we have to capitalize this one
    je      .make_ucase

;   cmp     byte [lastChar], 0
    or      dl, dl                  ; if this is 0, then it's the first char we've printed, therefore we know it should be capitalized
    jz      .make_ucase

    cmp     al, ','                 ; if this is a comma, the city is done, so print the comma then do the state and a crlf, finally, increment the string_index
    jne     .printChar

    mov     ah, 0xe                 ; code for print-char, teletype output
    int     0x10                    ; print the char held in al

;   mov     bx, [string_index]
    mov     bx, cx;[string_index]
    add     bx,bx                   ; x2 since each state is 2 bytes long
    add     bx, [bp+2]              ; bx --> states_unpacked[string_index]
    mov     al, [bx]                ; get the first char of the state
    call    toupper                 ; upper case it
;   mov     ah, 0xe         ;not needed, still set from above
    int     0x10                    ; and print it
    inc     bx

    mov     al, [bx]                ; get the 2nd char of the state
    call    toupper                 ; uppercase it
;   mov     ah, 0xe         ;not needed, still set from above
    int     0x10                    ; and print it

    mov     al, 0x0d                ; print a CRLF
    int     0x10
    mov     al, 0x0a
    int     0x10

    mov     byte [lastChar], 0      ; zero this, so that the first letter of the new city will be capitalized, just like the first char in the string was
    xor     dl, dl                  ; zero this, so that the first letter of the new city will be capitalized, just like the first char in the string was

;   inc     word [string_index]     ; increment our index, ready for the next city's state
    inc     cx  ;word [string_index]        ; increment our index, ready for the next city's state
    jmp     .getOutputChar          ; go back and get the next char of the next city

.make_ucase:
    call    toupper

.printChar:
    mov     ah, 0xe
    int     0x10
;   mov     [lastChar], al
    mov     dl, al
    jmp     .getOutputChar          ; go back and get the next char of the next city

.outputDone:
    pop     bp
    ret     4                       ; return and clean-up the two vars from the stack

[section .data]

; 63 packed bytes, 100 unpacked (saved 37)
states_packed:
    db  01011000b, 00010000b, 11010111b, 00011100b, 00001011b, 01100100b, 11000100b, 11100100b
    db  00001110b, 01110111b, 01100000b, 00011011b, 10000010b, 10101101b, 10101100b, 10011011b
    db  01011010b, 10010110b, 00111010b, 10100000b, 10010000b, 11011110b, 00000110b, 00010010b
    db  00101000b, 00011001b, 00011010b, 01111010b, 11001100b, 01010011b, 01010100b, 10011000b
    db  11010000b, 00101001b, 10100100b, 01101000b, 10101100b, 10001011b, 00000000b, 00011001b
    db  01100010b, 00001110b, 10000110b, 01001001b, 00001011b, 10010000b, 10011000b, 00111011b
    db  01100010b, 10010011b, 00110000b, 00011010b, 00110101b, 01100001b, 11010001b, 00000100b
    db  01010000b, 00000001b, 00000001b, 11001010b, 10110101b, 01011011b, 01010000b

; 290 packed bytes, 463 unpacked (saved 173)
capitals_packed:
    db  00001000b, 00100110b, 11100110b, 11101010b, 00101110b, 10100001b, 10001001b, 10110100b, 00110100b, 01101000b, 00000011b, 01000000b, 11110111b, 00101101b
    db  00010010b, 11011000b, 10011100b, 10111010b, 00110000b, 00110100b, 10010110b, 11011000b, 11100110b, 11001100b, 11001110b, 01100001b, 00100011b, 10001101b
    db  10011100b, 10001011b, 00100011b, 01000001b, 10110001b, 10010001b, 10110101b, 00100100b, 01110110b, 00010111b, 00100010b, 01000100b, 11011000b, 00101001b
    db  00101001b, 10100001b, 10111011b, 00001011b, 10100101b, 00110111b, 00110111b, 01100000b, 01011000b, 01000000b, 11011100b, 01101110b, 01100000b, 01011010b
    db  11000000b, 01110000b, 01001010b, 01000100b, 00100110b, 11100100b, 00000110b, 11001100b, 00011010b, 00101001b, 00110110b, 11010000b, 01001000b, 11110101b
    db  01000010b, 11010110b, 01001101b, 11001110b, 00100100b, 01101100b, 11011100b, 11011101b, 10100100b, 10000101b, 00101001b, 00100011b, 00100111b, 00110111b
    db  01110001b, 01000000b, 10001110b, 11000111b, 00110100b, 01111011b, 01111010b, 00001001b, 00011000b, 10010011b, 01100111b, 00000100b, 01100010b, 10001001b
    db  00000110b, 10010001b, 00110110b, 11000001b, 01000011b, 01010010b, 01010011b, 00000110b, 11011111b, 00010111b, 01010101b, 00000011b, 00100011b, 01000100b
    db  01001101b, 10001101b, 11010101b, 00100100b, 01110110b, 00100111b, 00110100b, 01001110b, 10001000b, 11110110b, 11000111b, 00110110b, 01101111b, 00100010b
    db  11010000b, 01001000b, 11101100b, 11100000b, 10001100b, 11001010b, 11101000b, 10001111b, 01110011b, 01110011b, 11001000b, 10100000b, 01101110b, 01000000b
    db  01000011b, 01100111b, 10100111b, 10000010b, 10001011b, 11011010b, 01101000b, 11010010b, 00000010b, 10011011b, 01011010b, 00011010b, 00100111b, 00101101b
    db  10111011b, 10001000b, 00010110b, 01000100b, 00011000b, 11111011b, 01100000b, 00000110b, 10001001b, 00111001b, 10111011b, 01110010b, 11110000b, 11000111b
    db  10100000b, 00011011b, 01111001b, 11011100b, 01000110b, 10100010b, 11111011b, 01011000b, 00011011b, 00100100b, 00110100b, 11011011b, 00111011b, 10011010b
    db  11100101b, 11010001b, 01110100b, 11011010b, 01000000b, 00100101b, 01001001b, 11001101b, 11011100b, 10011111b, 00010100b, 00110100b, 11000101b, 01000001b
    db  00010110b, 00111101b, 10001001b, 11001011b, 10100011b, 00000010b, 10000000b, 01101100b, 00001101b, 01101000b, 00011110b, 11100101b, 10100010b, 01011011b
    db  00010001b, 11001001b, 10000010b, 00110101b, 10100100b, 11011100b, 10000000b, 10111001b, 11101001b, 01100000b, 01010001b, 00110100b, 00100100b, 01001111b
    db  00011011b, 00000100b, 11010110b, 00000110b, 11001100b, 00011011b, 00001010b, 00100100b, 11000000b, 01000100b, 01001010b, 11011001b, 01100010b, 00000110b
    db  10101000b, 10101110b, 10001100b, 11110111b, 00100000b, 00101100b, 10001100b, 11011010b, 11010001b, 00111001b, 10101100b, 10011010b, 10001011b, 10000100b
    db  10101101b, 10001100b, 10010010b, 11010011b, 00011100b, 10000110b, 10010010b, 01011011b, 10010000b, 00000101b, 00010000b, 00110000b, 10001101b, 10011011b
    db  10110110b, 11100101b, 00101100b, 00000111b, 01110011b, 00000001b, 10100001b, 00100010b, 01111000b, 11011000b, 10001110b, 00001000b, 10101100b, 10010010b
    db  10011011b, 10011011b, 10110001b, 00000010b, 00110010b, 01110011b, 01110100b, 00100100b, 01001111b, 00011011b

[section .bss]
lastChar        resb    1       ; last printed char - used to capitalize chars after a space (i.e the 2nd or third word of a city name)
string_index    resw    1       ; used to index into the array of states, which are each two bytes

states_unpacked         resb 100            ; 50 states, 2 bytes each
capitals_unpacked       resb 464
nullTerminator          resb   1

I see a lot of uppercase chars in your dump.

Ugggh. Of course, so do I now that I look. I was so obsessed with generating them I've overlooked the fact I've inadvertently created some. The first 232 bytes is code the rest data. I see I've got caps in each. I may just have sunk myself, with no chance of fixing it. :( I'll investigate some self-modifying code later, though the offset table I'll need may consume any gains made. :sighs: - oh well.Thanks for pointing it out though,I appreciate it.


text:
Rotating Spirals
Given a square of text representing a spiral of characters, rotate it!
The spiral starts at the center and moves counterclockwise to the outer edge, starting to the left of center:
987
216
345

This translates to the string 123456789. Rotation is done to the left, so if you rotate it one position, it will be 234567891. This is represented by:
198
327
456

Input
Input consists of the spiral and the distance to rotate it.
Distance will always be a positive integer or zero, and can be capped at your language's data type limit.
The spiral should be taken as a string, with a line delimiter of your choice (including no delimiter). It will always be a square, not including delimiters, and have an odd side length.
Assume all characters are alphanumeric [A-Za-z0-9].
Output
Output is the rotated spiral. It should be a square on multiple lines (whether printed or returned).
Examples
Input
3
tne
atd
bin

Output
bat
nit
den

Input
18
efilr
naepo
umshf
tootr
butte

Output
rettu
omseb
oofft
trliu
hpean

This is code golf, with score counted in bytes as usual.

CJam, 45 44 bytes
]]l~LqN/{(W%@+\zW%}h;m<{1$,/(W%a@W%z+\s}h;N*

Test it here.
Explanation
The lazy solution: unwrap the spiral, use CJam's built-in array rotation, roll the spiral up again.
]]       e# Push [""]. We'll later use this to roll up the spiral.
l~       e# Read the integer and evaluate it.
L        e# Push an empty string: we'll unroll the input into this.
qN/      e# Read the spiral and split it into lines.
{        e# While the top of the stack is truthy...
  (W%    e#   Pull the first line off the spiral and reverse it.
  @+     e#   Pull up the string we've built so far and prepend the reversed line.
  \zW%   e#   Swap with the remaining spiral, and rotate the spiral.
}h       e# This terminates when the centre character has been added to the string and
         e# the spiral becomes an empty array.
;        e# Discard the empty array.
         e# Note that we've unrolled the spiral from outside in, but we've also built up
         e# the string in reverse, which gives us the string from inside out.
m<       e# Rotate to the left by the given number of characters.
{        e# While the top of the stack is truthy...
  1$,    e#   Copy the spiral so far and get the number of lines.
  /      e#   Split the string into chunks of that size.
  (W%a   e#   Pull off the first chunk, reverse it and wrap it in an array.
  @zW%   e#   Pull up the spiral so far, rotate it.
  +      e#   Prepend the chunk to the spiral as a line.
  \s     e#   Swap with the other chunks and flatten them into a string again.
}h       e# This terminates when the string has been used up completely.
;        e# Discard the empty string.
N*       e# Join the lines with linefeed characters.

Haskell, 188 bytes
import Data.List;r=reverse;t=transpose;f=take;g=drop
u[[c]]=[c];u(a:b)=a++u(r.t$b)
w k[]=k;w[](a:b)=w[[a]]b;w k l=w((r.f h$l):(t.r$k))$g h l where h=length k
s n=w[].(\s->g n s++f n s).r.u

Try it online!

Python3, 336 bytes:
R=range
def S(N):
 x,y=N//2,N//2;r=[(x,y)]
 for i in R(2,N,2):
  y-=1;F=0;r+=[(x,y)]
  for X,Y in[(1,0),(0,1),(-1,0),(0,-1)]:
   for _ in R(i):
    if F:x+=X;y+=Y;r+=[(x,y)]
    F=1
 return r
def f(n,s):
 s=[[*i]for i in s.split('\n')];T=[s[x][y]for x,y in S(len(s[0]))];T=T[n:]+T[:n]
 for x,y in S(len(s[0])):s[x][y]=T.pop(0)
 return s

Try it online!

320 bytes

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:
Home improvement for the Minotaur
Home improvement for the Minotaur
The cretan labyrinth is quite easy to draw. Just start with a symmetric shape (here in red). Let us call all the endpoints of those lines 'nodes'. Then you begin drawing the arches (black): The first one alway begins in the top middle node and connects to the node next to it on the right side, then the two nodes closest to the previous arch are connected. This is repeated untill all nodes are covered.

Now we can generalize this concept: We can easily generate new initial patterns by adding more L shapes. I enumerated the initial shapes as follows:

The most left pattern will produce a cretan labyrinth of degree 0. The next one will create a cretan labyrinth of degree 1 (the original one) etc.
Task
Given a nonnegative integer n, your program should output the ascii representation of a cretan labyrinth of degree n, that is shown in the following examples. Trailing spaces/newlines do not matter. You have to include a short explanation of how your code works.
Examples
The output for the original cretan labyrith (degree 1) is following:
+-----------------------------+
| +-------------------------+ |
| | +---------------------+ | |
| | | +-----------------+ | | |
| | | | +-------------+ | | | |
| | | | | +---------+ | | | | |
| | | | | | +-----+ | | | | | |
| | | | | | | +-+ | | | | | | |
| | | | | + | | | + | | | | | |
| | | | +---+ | +---+ | | | | |
| | | +-------+-------+ | | | |
| | +-------+ | +-------+ | | |
| +-------+ | | | +-------+ | |
+-----------+ | +-----------+ |
              +---------------+

Initial pattern:
+ | | | +
--+ | +--
----+----
--+ | +--
+ | | | +

The cretian labyrinth of degree 0 should look like so:
+-------------+
| +---------+ |
| | +-----+ | |
| | | +-+ | | |
| | + | + | | |
| +---+---+ | |
+---+ | +---+ |
      +-------+

Initial pattern:
+ | +
--+--
+ | +

Perl 5, 349 bytes
say$p="| "x$_,"+","-"x(16*$n-4*$_+13),"+ $p"for 0..4*($n=pop)+3;say$p="| "x(3*$n+2),"+ | ","| "x2x$n,"+ $p|";$p=~s/..//,$q="-"x(4*$_-1),say"$p+$q+ ","| "x(2*$n-2*$_+1),"+$q+ $p|"for 1..$n;$p=~s/..//;say$p,("+---"."-"x4x$n)x2,"+ $p|";$p=~s/..//,$q="-"x(4*$n+3)."-"x4x$_,say"$p+$q+ | ","| "x2x($n-abs$_),"+$q+ $p|"for-$n..$n;say" "x(8*$n+6),"+----$q+"

(Pass n as a command line argument.)
Computes the maze line-by-line in six sections:

first 4n + 4 lines,
next line (the only line with no -),
next n lines,
next line (the line at the middle of the initial pattern),
next 2n + 1 lines,
final line (the line with leading spaces).

Python 3.5, 703 695 676 648 587 581 542 535 500 486 462 431 423 411 bytes:
(Thanks to @flawr for advice on saving 55 bytes (486 -> 431)!)
def j(r):R=range;Z=zip;B=r+r+2;P,M='+-';X='| ';q=[*Z(R(0,B-1,2),R(B-1,0,-2))];L=r+1;A=2+r;print('\n'.join([X*w+P+M*v+P+' |'*w for v,w in Z(R(4*L*4-3,0,-4),R(4*L))]+[X*g+P*o+M*k+u+M*k+P*o+' |'*-~g for g,o,k,u in Z([*R(4*L-A,0,-1),*R(4*L-A)],[0]+[1]*(3*r+2),[0,*R(1,4*L,2),*R(4*L+1,11*r,2)],[M*y+'+ '+X*b+P+M*y for y,b in q]+[M*B+P+M*B]+[M*y+'+ '+X*b+P+M*y for y,b in q[::-1]+q[1:]])]+[' '*(8*r+6)+P+M*(8*r+7)+P]))

Not very much of a contender for the title, but I still gave it a shot, and it works perfectly. I will try to shorten it more over time where I can, but for now, I love it and could not be happier.
Try it online! (Ideone) (May look a little bit different on here because of apparent online compiler limitations. However, it's still very much the same.)
Explanation:
For the purposes of this explanation, let's assume that the above function was executed with the input, r, being equal to 1. That being said, basically what's happening, step-by-step, is...

q=[*Z(R(0,B-1,2),R(B-1,0,-2))]
A zip object, q, is created with 2 range objects, one consisting of every second integer in the range 0=>r+r+1 and another consisting of every second integer in the range r+r+1=>0. This is because every starting pattern of a cretan labyrinth of a specific degree will always have an even number of - in each line. For instance, for a cretan labyrinth of degree 1, r+r+1 equals 3, and thus, its pattern will always start with 0 dashes, followed by another line with 4 (2+2) dashes. This zip object will be used for the first r+1 lines of the labyrinth's pattern.
Note: The only reason q is a list and separated from the rest is because q is referenced a few times and subscripted, and to save a lot of repetition and allow subscripting, I simply created a zip object q in the form of a list.
print('\n'.join([X*w+P+M*v+P+' |'*w for v,w in Z(R(4*L*4-3,0,-4),R(4*L))]+[X*g+P*o+M*k+u+M*k+P*o+' |'*-~g for g,o,k,u in Z([*R(4*L-A,0,-1),*R(4*L-A)],[0]+[1]*(3*r+2),[0,*R(1,4*L,2),*R(4*L+1,11*r,2)],[M*y+'+ '+X*b+P+M*y for y,b in q]+[M*B+P+M*B]+[M*y+'+ '+X*b+P+M*y for y,b in q[::-1]+q[1:]])]+[' '*(8*r+6)+P+M*(8*r+7)+P]))
This is the last step, in which the labyrinth is built and put together. Here, three lists, the first consisting of the top 4*r+1 lines of the labyrinth, the second consisting of the middle 3*r+3 lines of the labyrinth, and the last list consisting of the very last line of the labyrinth are joined together, with line breaks (\n) into one long string. Finally, this one huge string consisting of the entire labyrinth is printed out. Let us go more in depth into what these 2 lists and 1 string actually contain:

The 1st list, in which another zipped object is used in list comprehension to create each line one by one, with leading |or + symbols, an odd number of dashes in the range 0=>4*(r+1), trailing | or + symbols, and then a newline (\n). In the case of a degree 1 labyrinth, this list returns:
+-----------------------------+
| +-------------------------+ |
| | +---------------------+ | |
| | | +-----------------+ | | |
| | | | +-------------+ | | | |
| | | | | +---------+ | | | | |
| | | | | | +-----+ | | | | | |
| | | | | | | +-+ | | | | | | |

The 2nd list, which consists of a zip object containing 4 lists, and each list corresponds to the number of leading/trailing | symbols, the number of + symbols, the number of dashes, and finally, the last list, which contains the first r+1 lines of the pattern created according to zip object q, the line in the middle of the pattern (the one with no |), and the last r+2 lines of the symmetrical pattern. In this specific case, the last list used in this list's zip object would return:
+ | | | +
--+ | +--
----+----
--+ | +--
+ | | | +
--+ | +--  <- Last line created especially for use in the middle of the labyrinth itself.

And therefore, in the case of a 1 degree labyrinth, this entire list would return:
| | | | | + | | | + | | | | | |
| | | | +---+ | +---+ | | | | |
| | | +-------+-------+ | | | |
| | +-------+ | +-------+ | | |
| +-------+ | | | +-------+ | |
+-----------+ | +-----------+ | <- Here is where the extra line of the pattern is used.

This final list, in which the last line is created. Here, the first segment (the one before the first space) length of the last line of list P number of spaces are created. Then, the length of the last segment (the ending segment) of the same line + 4 number of dashes are added, all of which are preceded and followed by a single + symbol. In the case of a degree 1 labyrinth, this last list returns:
              +---------------+

After joining all this together, this step finally returns the completed labyrinth. In the case of a 1 degree labyrinth, it would finally return this:
+-----------------------------+
| +-------------------------+ |
| | +---------------------+ | |
| | | +-----------------+ | | |
| | | | +-------------+ | | | |
| | | | | +---------+ | | | | |
| | | | | | +-----+ | | | | | |
| | | | | | | +-+ | | | | | | |
| | | | | + | | | + | | | | | |
| | | | +---+ | +---+ | | | | |
| | | +-------+-------+ | | | |
| | +-------+ | +-------+ | | |
| +-------+ | | | +-------+ | |
+-----------+ | +-----------+ |
              +---------------+

Can you perhaps first define R=range or something like that? The same for P='+'?

I think you should take the golden opportunity to say for g,o,k,u in Z

@Sherlock9 Haha! Good idea! Added. :)

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


text:
One goes up, the other comes down
Introduction
In this challenge, your task is to decide whether a given sequence of numbers can be separated into two subsequences, one of which is increasing, and the other decreasing.
As an example, consider the sequence 8 3 5 5 4 12 3.
It can be broken into two subsequences as follows:
  3 5 5   12
8       4    3

The subsequence on the first row is increasing, and the one on the second row is decreasing.
Furthermore, you should perform this task efficiently.
Input
Your input is a non-empty list L of integers in the range 0 – 99999 inclusive.
It is given in the native format of your language, or simply delimited by spaces.
Output
Your output is a truthy value if L can be broken into an increasing and a decreasing subsequence, and a falsy value otherwise.
The subsequences need not be strictly increasing or decreasing, and either of them may be empty.
Rules and bonuses
You can write a full program or a function.
The lowest byte count wins, and standard loopholes are disallowed.
Furthermore, brute forcing is forbidden in this challenge: your program must run in polynomial time in the length of the input.
You are not required to actually return the two subsequences, but there is a bonus of -20% for doing so.
To make the bonus easier to claim in statically typed languages, it is acceptable to return a pair of empty lists for the falsy instances.
Test cases
Given in the format input -> None for falsy inputs and input -> inc dec for truthy inputs.
Only one possible pair of subsequences is given here; there may be more.
[4,9,2,8,3,7,4,6,5] -> None
[0,99999,23423,5252,27658,8671,43245,53900,22339] -> None
[10,20,30,20,32,40,31,40,50] -> None
[49,844,177,974,654,203,65,493,844,767,304,353,415,425,857,207,871,823,768,110,400,710,35,37,88,587,254,680,454,240,316,47,964,953,345,644,582,704,373,36,114,224,45,354,172,671,977,85,127,341,268,506,455,6,677,438,690,309,270,567,11,16,725,38,700,611,194,246,34,677,50,660,135,233,462,777,48,709,799,929,600,297,98,39,750,606,859,46,839,51,601,499,176,610,388,358,790,948,583,39] -> None
[0,1,2,3,4] -> [0,1,2,3,4] []
[4,3,2,1,0] -> [] [4,3,2,1,0]
[1,9,2,8,3,7,4,6,5] -> [1,2,3,4,6] [9,8,7,5]
[71414,19876,23423,54252,27658,48671,43245,53900,22339] -> [19876,23423,27658,48671,53900] [71414,54252,43245,22339]
[10,20,30,20,30,40,30,40,50] -> [10,20,20,30,40,40,50] [30,30]
[0,3,7,13,65,87,112,43,22,1] -> [0,3,7,13,65,87,112] [43,22,1]
[7,4,4,7,4,7,7,4,7,4,4,4,7,7] -> [7,7,7,7,7,7,7] [4,4,4,4,4,4,4]
[7,997,991,957,956,952,7,8,21,924,21,923,22,38,42,44,920,49,58,67,71,83,84,85,917,89,907,896,878,878,90,861,115,860,125,128,140,148,858,155,160,836,164,182,826,191,824,805,195,792,205,782,206,210,769,213,756,748,214,745,724,701,234,241,693,268,685,293,679,297,334,671,336,669,341,652,356,648,362,364,370,375,386,630,622,388,389,618,398,408,468,615,470,533,611,539,544,609,586,582,572,565,547,602,536,619,624,528,512,631,640,649,669,671,677,505,678,723,743,489,489,473,454,757,446,445,758,759,764,445,431,770,429,426,418,409,790,383,379,366,363,791,358,795,809,827,835,356,353,841,844,333,867,323,317,879,311,881,309,896,282,281,897,263,904,237,236,226,202,195,914,186,177,917,920,157,926,936,154,138,943,131,945,100,98,947,957,964,95,973,989,57,43,32,21,16,13,11,8,0] -> [7,7,8,21,21,22,38,42,44,49,58,67,71,83,84,85,89,90,115,125,128,140,148,155,160,164,182,191,195,205,206,210,213,214,234,241,268,293,297,334,336,341,356,362,364,370,375,386,388,389,398,408,468,470,533,539,544,586,602,619,624,631,640,649,669,671,677,678,723,743,757,758,759,764,770,790,791,795,809,827,835,841,844,867,879,881,896,897,904,914,917,920,926,936,943,945,947,957,964,973,989] [997,991,957,956,952,924,923,920,917,907,896,878,878,861,860,858,836,826,824,805,792,782,769,756,748,745,724,701,693,685,679,671,669,652,648,630,622,618,615,611,609,582,572,565,547,536,528,512,505,489,489,473,454,446,445,445,431,429,426,418,409,383,379,366,363,358,356,353,333,323,317,311,309,282,281,263,237,236,226,202,195,186,177,157,154,138,131,100,98,95,57,43,32,21,16,13,11,8,0]

Pyth, 34 bytes
.N|!N|&ghNT:tNhNY&gYhN:tNThN:QZ^T5

Test Suite
Uses memoized recursion to keep the runtime down. Defines a 3 input function :, which takes inputs `list suffix, end of increasing sequence, end of decreasing sequence.

Brachylog, 16 bytes - 20% = 12.8 (but it's almost certainly not polynomial)
⊇≥₁X&⊇≤₁Y;X.cp?∧

Try it online!
Fails if there's no pair of compliant subsequences and outputs them through its output variable if there is one (but will just print true. if it's run as a program). I say it's almost certainly not polynomial because the beauty of Brachylog is that since it's a declarative language, you don't do so much in the way of implementing an algorithm as you do just describing relationships between variables and asking the computer to crank out results. So chances are this is hardcore brute force, but I spent long enough copy pasting the test cases (two of which it just times out on) that I feel like I should submit this anyhow, if for no other reason than to drag this challenge up from the back of the decision-problem "Newest" list.
   X                X is a
 ≥₁                 non-increasing
⊇                   sublist of the input
    &               and
        Y           Y is a
      ≤₁            non-decreasing
     ⊇              sublist of the input
         ;X         which paired with X
           .        is the output variable
            c       which when its elements are concatenated
             p      is a permutation of
              ?     the input
               ∧    which is not unified with the output.

Haskell, 65 bytes
(>[]).foldl(%)[(0,9^6)]
p%x=do(u,d)<-p;[(x,d)|x>=u]++[(u,x)|x<=d]

Try it online!
Iterates through the list, tracking the possible pairs (u,d) of the max of the increasing sequence and the min of the decreasing one. Each new element x replaces either u or d, which corresponds to it being append to that subsequence. It could be that both or neither options are valid. In the end, we check that the list of possibilities is nonempty.
The initial bounds (0,9^6) use that the problem specifies the numbers to be in the range 0 – 99999. A more general solution could do (1/0,-1/0) to makes (-inf,inf).


text:
Counting cycles in a folding and squashing process
In chaos theory, the horseshoe map is an example of how chaos arises in a simple process of folding and squashing. It goes like this: take an imaginary piece of dough, fold it, and finally squash it to its original size. Chaos arises in the pattern of how the pieces of dough end up in the final arrangement after n iterations.

In our case, we'll take a look at how a simple binary pattern behaves when we fold and squash it. Here are the steps with an 8-bit example (the binary representation of 201 or 11001001).

Cut the bits in two pieces of equal length (add a '0' at the beginning if there is an odd number of bits).
1100 | 1001

Fold the first half over the second half. Note that the order of the first half is reversed, as we rotate it while folding.
0011
1001

Squash to its original shape. While squashing, the upper bits are shifted left to the bits under their original position.
01001011

If we repeat this for this example, we can see that after 4 iterations, we are back to the original bitstring:
Start  bits: 11001001
Iteration 1: 01001011
Iteration 2: 01001101
Iteration 3: 01011001
Iteration 4: 11001001

So, for the decimal value of 201, the number of cycles is 4.
The challenge

Write a full program that takes a decimal number as input and outputs the number of cycles it takes to repeat in the above described binary squash-and-fold process.
The (decimal) input must be taken from stdin (range: from 1 up to Googol or 10^100).
The (decimal) output must be written to stdout.
Your score is the number of bytes of your code.
Your answer must begin with [Programming language] - [Score in bytes]
Standard loopholes are not allowed.

Examples
7 --> 3
43 --> 5
178 --> 4
255 --> 1
65534 --> 1
65537 --> 12
1915195950546866338219593388801304344938837974777392666909760090332935537657862595345445466245217915 --> 329

Final note
What's interesting is that the number of cycles is related to the length of the binary representation, except for a few exceptions where the number of cycles is shorter because of the pattern in the bitstring (for example 111110 cycles after 1 iteration). This creates an interesting opportunity to optimize code length using the underlying pattern instead of calculating the number of cycles.

If the bit length of the number shortens during iteration, do we cut and fold using the original bit length, or the current one?

@xnor I would assume the original one, otherwise you would never complete cycle, right?

Related: http://codegolf.stackexchange.com/questions/48027/discrete-bakers-map/48078#48078

CJam, 34 bytes
q~2b_,2%,\+{__,2//~\W%.\_W$=!}g;],

Nothing fancy, it just applies the map until we get back to the input, and print the number of iterations that took.
Test it here.

First in! Look at you, shooting code faster than your shadow!

Python 2, 175 154 149 bytes
i=bin(input())[2:]
i=o='0'+i if len(i)%2 else i
c=0
j=len(i)/2
while i!=o or c==0:
 a=''
 for x,y in zip(i[:j][::-1],i[j:]):a+=x+y
 i,c=a,c+1
print c

Ideone link
Thanks to agtoever for 27 bytes!

No need for the lambda. Once the length is even, it stays even.

Excellent point, thanks!

Change  while 1 with while i!=o|c==0 and drop the if i==o:break. Saves 5. Maybe (note sure) you also don't need a. Just use i. Saves an assignment (4 bytes). Also the assignment of j can be put outside the loop.

Thanks for the additional saves, @agtoever. I got a TypeError when attempting to implement the while i!=c|c==0 replacement, but still was able to save some bytes with a standard or.

Pyth, 21 bytes
I'm typing this on my phone, so please make sure to notify me of any mistakes.
fqu.i_hc2Gec2GTJ.BQJ1

Try it online.

APL (Dyalog Extended), 37 bytes
≢{⊃,/↓⍉⌽@1⊢2 ¯1⍴{2|≢⍵:0,⍵⋄⍵}⍵}⌂traj⊤⎕

Try it online!
A full program which takes a single number as input.
The traj function does a lot of heavy lifting here(thanks to Bubbler for suggesting it and helping ot golf this).
The (,,⍤0)/ idiom from APLcart is used to interleave lists together, but instead  this uses ,/↓⍉⌽ since it is a matrix.
Explanation
≢{⊃,/↓⍉⌽@1⊢2 ¯1⍴{2|≢⍵:0,⍵⋄⍵}⍵}⌂traj⊤⎕
                                   ⊤⎕ convert input to base-2
 {                           }⌂traj   calculate trajectory when the following function is applied repeatedly:
                {2|≢⍵:0,⍵⋄⍵}⍵         prepend a 0 if there are an odd number of bits
           2 ¯1⍴                     cut into two rows
       ⌽@1⊢                          apply reverse to first row
   ,/↓⍉                              transpose, concatenate into a vector
  ⊃                                  unenclose
≢                                    get length of the resulting list


text:
The jumping digits to letters transformation
Imagine you have an infinite sequence of the alphabet repeated infinitely many times:
abcdefghijklmnopqrstuvwxyzabcd...

You start at index 0, which corresponds to the letter a, and the should_write boolean flag is False.
The input is a list or string of single-digit numbers. For each number n in the input, you should:

Print (or add to the return value) the n-th item of the list if the should_write flag is set to True
If n is 0, swap the should_write flag.
Otherwise move (jump) the index n places forward.

At the end of the input, stop (and return the result if using a function).
Input
A sequence of digits (list or string).
Output
The text that comes out after applying the above procedure.
Examples
>>> g('99010')
st
>>> g('100')
b
>>> g('2300312')
f
>>> g('390921041912042041010')
mvxyptvab
>>> g('1')
>>> g('1045')
bf
>>> g('33005780')
g
>>> g('100100102')
bcd
>>> g('012')
ab

Does the input have to be a string of digits, as in your test cases, or can it be a list of numbers?

Are you sure about your test cases? Several of them seem wrong to me.

@xnor a list of digits

@Caridorc In '33005780', how is more than 1 char printed? The should_write flag starts off, is turned on for one digit and turned back off immediately, and then only turned on again at the end.

@xnor found obvious bug in my reference implementation and facepalmed, will correct testcases asap...

@PeterTaylor Taylor there was a bug in my reference implementation, testcases fixed now.

@Zgarb thanks, already fixed :)

"Print (or add to the return value) the n-th item of the list" did you mean the item currently pointed at by the index? Because you're using n for the current digit in the string.

With the '012' and '100100102' examples, why is the last incremented value not printed?  So for '012' I would interpret as 0 swap flag and print a, increment 1 print b, increment 2 print d.  Or is the last integer essentially ignored?

@MickyT You should really apply the operations in the order listed in the challenge: first you print (if the flag as set), then you toggle the flag (if applicable), then you move the index forward.

@MartinBüttner  Thanks, I just needed to adjust my thinking:)

Python 3, 60
i=b=0
for c in input():b and print(chr(97+i%26));b^=c<1;i+=c

Takes a list of numbers and prints the chars on separate lines.
Basically just follows the instructions. The index is i and the should_write flag is b. The expression b and short-circuits to print only when b is true.

Pip, 20 bytes
Takes a string of digits as command-line argument.
Fda{IyOz@id?i+:dY!y}

This code uses a number of Pip's preinitialized variables. i is initially 0, y is initially "" (falsy) and z contains the lowercase alphabet. a gets the first command-line arg.
Fda{               }  For each digit d in a:
    IyOz@i              If y (the flag) is truthy, output letter of z at index i
                        Pip's cyclic indexing takes care of the infinite effect
          d?            If d is truthy (digit is nonzero),
            i+:d          then increment i by d;
                Y!y       otherwise, yank !y into y (thus swapping the flag)

An alternate way of swapping the flag would be !:y, with !: being a compute-and-assign operator just like +:.
C:\Users\dlosc> pip.py -e Fda{IyOz@id?i+:dY!y} 390921041912042041010
mvxyptvab

CJam, 28 bytes
0q{~U{1$'a+o}&_!U^:U;+26%}/;

Test it here.
Nothing really special here. Like xnor, I don't have a string of letters but simply a running total (mod 26) which I add to a when I need to print it. The should_write flag is kept track of in U.

R, 73 bytes
Once I got it sorted in my head:)
(letters[cumsum(a<-head(scan()),-1)%%26+1])[which(cumprod(-(a<1)*2+1)<0)]

This takes a vector of integers from STDIN and returns a vector of letters.
Ungolfed and explanation
a <- head(scan()),-1)    # get integers from stdin and drop last one
a <- cumsum(a) %% 26 + 1 # do the cumulative sum of the vector to use as a vector of letter indexes
l <- letters[a]          # vector of potential letters
p <- -(a<1)*2+1          # turns 0's into -1 and everything else into 1
p <- cumprod(p)          # the cumlative prod then creates a vector of on and off values
f <- which(p<0)          # index values of the returned characters
l[f]                     # return vector of characters

Tests
> (letters[cumsum(a<-head(scan(),-1))%%26+1])[which(cumprod(-(a<1)*2+1)<0)]
1: 9 9 0 1 0
6:
Read 5 items
[1] "s" "t"
> (letters[cumsum(a<-head(scan(),-1))%%26+1])[which(cumprod(-(a<1)*2+1)<0)]
1: 1 0 0
4:
Read 3 items
[1] "b"
> (letters[cumsum(a<-head(scan(),-1))%%26+1])[which(cumprod(-(a<1)*2+1)<0)]
1: 2 3 0 0 3 1 2
8:
Read 7 items
[1] "f"
> (letters[cumsum(a<-head(scan(),-1))%%26+1])[which(cumprod(-(a<1)*2+1)<0)]
1: 1
2:
Read 1 item
character(0)
> (letters[cumsum(a<-head(scan(),-1))%%26+1])[which(cumprod(-(a<1)*2+1)<0)]
1: 1 0 4 5
5:
Read 4 items
[1] "b" "f"
> (letters[cumsum(a<-head(scan(),-1))%%26+1])[which(cumprod(-(a<1)*2+1)<0)]
1: 0 1 2
4:
Read 3 items
[1] "a" "b"
>

JavaScript (ES6) 76
(note: the fromCharCode function is so lengthy that for lowercase letters it's better a conversion to base 36)
Test running the snippet below in any EcmaScript 6 compliant browser

g=l=>l.replace(/./g,n=>[f?(p%26+10).toString(36):'',-n?p-=-n:f=!f][0],p=f=0)

console.log=x=>O.innerHTML+=x+'\n'

;['99010','100','2300312','390921041912042041010','1','1045','33005780','100100102','012']
.forEach(t=>console.log(t+' ['+g(t)+']'))

Ruby, 59 bytes
Port of xnor's Python answer.
->a{i=0
b=p
a.map{b&&$><<(97+i%26).chr
b=!b if _1<1
i+=_1}}

Attempt This Online!


text:
Given a list of lengths, and a string representing those lengths, do they match?
Given a pattern representing a list of lengths, and a string representing those lengths, do they match?
For those interested, this is question equivalent to verifying if a row or column of a Nonogram may be correct. However, I have omitted all language relating to Nonograms to make the question less confusing for those unfamiliar with these puzzles.
Input
Two lines of data, separated by a newline.

The first line will be a space separated list of integers, example:
3 6 1 4 6

This line describes a pattern of filled spaces of size equal to the integer list, separated by empty spaces of unknown, positive length that the second line must match. There may also be empty spaces at the beginning and end of the matched string.
The second line will be a line that that may or may not match the pattern in line one. It consists entirely of #, x, and _. This line is guaranteed to be at least as long as the sum of the integers in the first line, plus the number of distinct integers, minus 1, and can be longer. So the second line in this case is guaranteed to be at least (3+6+1+4+6) + (5) - 1, or 24 characters long. Here is an example 24 character line that matches the pattern in the first line:
###_######_#_####_######

Meaning of symbols:

# This represents a filled box
x This represents a box marked as "guaranteed to be empty"
_ This represents an unknown / unmarked box.

Goal
The idea is to:

Validate that the second line could be a valid row that meets the pattern of the first line.

You must print an unambiguous error message (how you choose to do this is up to you; the examples below write ERROR but it doesn't need to be those 5 characters) if the unknown spaces cannot be filled out with either # or x to match the first line.

Print the zero-indexed indices of the integers that have been completely placed in the row, space delimited. If there is ambiguity, do not print the index.

Examples:
Input:                    |  Output:    |  Reason:
--------------------------------------------------------------------------
3 6 1 4 6                 | 0 1 2 3 4   |  This is a complete string that
###x######x#x####x######  |             |  matches perfectly.
--------------------------------------------------------------------------
1 2 1                     | 0 1 2       |  There is no ambiguity which filled cells
#____xx___##__x_#         |             |  correspond to which parts of the pattern.
--------------------------------------------------------------------------
1 2 1                     |             |  I don't know whether the filled block is
____#___x                 |             |  part of the 1, 2, or 1, so output nothing.
--------------------------------------------------------------------------
1 2 1                     | ERROR       | The first unknown cell will create a block that
#_#x_#                    |             | matches either 1 1 or 3, but not 1 2.
--------------------------------------------------------------------------
1 2 1                     | 0 2         | Even though we know where all the filled cells
#____#                    |             | must be, only 0 and 2 are actually filled here.
--------------------------------------------------------------------------
1 1 1 1                   |             | There are so many possible ways to do fill this,
__#_______#____           |             | we don't know which indices are actually matched.
--------------------------------------------------------------------------
4 4                       |             | Again, we don't know WHICH 4 is matched here,
______x####________       |             | so output nothing.
--------------------------------------------------------------------------
4 4                       | 0           | However, here, there's no room for a previous 4,
__x####________           |             | so the displayed 4 must be index 0.
--------------------------------------------------------------------------
3                         | ERROR       | We can't fit a 3 into a space before or after
__x__                     |             | the x, so this is impossible to match.
--------------------------------------------------------------------------
5 1 3                     | 0           | While we can match the 5, we don't know whether
x#####x____#____          |             | the single block matches the 1 or the 3.
--------------------------------------------------------------------------
3 2 3                     | 1           | The two has been completely placed,
____##x##____             |             | even though we don't know which it is.

Rules:
You may write a program or function, which receives the input as a newline delimited String or from STDIN (or closest alternative), and returns the output as an space delimited String or printing it to STDOUT (or closest alternative). You may optionally include a single trailing newline in the output.
Additionally, standard loopholes which are no longer funny are banned.

This is for solving nonograms, right? It might help to mention nongrams since that makes the challenge make immediate sense for those who solve them.

@jimmy23013 Edited in response.

Perl, 134 bytes
(includes 1 switch)
perl -pe '$p.="([#_]{$_})[x_]+"for@l=split;chop$p,$_=<>;/^[x_]*$p*$(?{$h[$_-1].=$$_ for 1..@l})(?!)/;$_=@h?join$",grep{$h[$_]!~/_/}0..$#l:ERROR'

Takes two lines of input from STDIN. Must be re-executed for every input.
The idea is to first extract all possible patterns that match the given lengths. For example, if we have the lengths 1 2 and the pattern #_x_#_, then the matching patterns are (#, _#) and (#, #_). Then, concatenate the matched patterns for every index - for the example the result is the list (##, _##_). Now, print the indices of all the strings in the list which have only '#' characters.
I got the method to extract all possible matches from a regex in Perl here.

Ungolfed and extended explanation
ideone.com

Cool. Could you add an ungolfed version and an ideone link please?

Sure, I have added the link at the end of my answer.

True example of how horrible a golfed code snippet can look! At least to me.

@Arjun Golfing tends to obfuscate code. There's beauty in golfed code, but only if you know the language it is written in.

I added a new example because one scenario was still ambiguous in the problem description. Fortunately, your program still works correctly in that case too.

@durron597 thank you for the bounty! I had a lot of fun working on this problem :)

Yeah, certainly there is! And you even get rep for clever solutions, adding to your achievements! (I am Arjun).