Move python solutions to separate directory

py/2017/01/input.txt

@@ -0,0 +1 @@
+237369991482346124663395286354672985457326865748533412179778188397835279584149971999798512279429268727171755461418974558538246429986747532417846157526523238931351898548279549456694488433438982744782258279173323381571985454236569393975735715331438256795579514159946537868358735936832487422938678194757687698143224139243151222475131337135843793611742383267186158665726927967655583875485515512626142935357421852953775733748941926983377725386196187486131337458574829848723711355929684625223564489485597564768317432893836629255273452776232319265422533449549956244791565573727762687439221862632722277129613329167189874939414298584616496839223239197277563641853746193232543222813298195169345186499866147586559781523834595683496151581546829112745533347796213673814995849156321674379644323159259131925444961296821167483628812395391533572555624159939279125341335147234653572977345582135728994395631685618135563662689854691976843435785879952751266627645653981281891643823717528757341136747881518611439246877373935758151119185587921332175189332436522732144278613486716525897262879287772969529445511736924962777262394961547579248731343245241963914775991292177151554446695134653596633433171866618541957233463548142173235821168156636824233487983766612338498874251672993917446366865832618475491341253973267556113323245113845148121546526396995991171739837147479978645166417988918289287844384513974369397974378819848552153961651881528134624869454563488858625261356763562723261767873542683796675797124322382732437235544965647934514871672522777378931524994784845817584793564974285139867972185887185987353468488155283698464226415951583138352839943621294117262483559867661596299753986347244786339543174594266422815794658477629829383461829261994591318851587963554829459353892825847978971823347219468516784857348649693185172199398234123745415271222891161175788713733444497592853221743138324235934216658323717267715318744537689459113188549896737581637879552568829548365738314593851221113932919767844137362623398623853789938824592

py/2017/01/solve.py

@@ -0,0 +1,37 @@
+import sys
+
+def load_line(filename):
+	with open(filename, "r") as f:
+		return list(map(int, f.read()[:-1]))
+
+# PART 1
+
+def sum_matching(digits):
+	offset = digits[1:] + digits
+	total = 0
+	for x, y in zip(digits, offset):
+		if x == y:
+			total += x
+	return total
+
+# PART 2
+
+def sum_matching_2(digits):
+	offset = digits[len(digits)//2:] + digits
+	total = 0
+	for x, y in zip(digits, offset):
+		if x == y:
+			total += x
+	return total
+
+def main(filename):
+	digits = load_line(filename)
+	print(f"Solutions for {filename}")
+	total = sum_matching(digits)
+	print(f"Part 1: {total}")
+	total_2 = sum_matching_2(digits)
+	print(f"Part 2: {total_2}")
+
+if __name__ == "__main__":
+	for filename in sys.argv[1:]:
+		main(filename)

py/2017/02/input.txt

@@ -0,0 +1,16 @@
+1640	590	93	958	73	1263	1405	1363	737	712	1501	390	68	1554	959	79
+4209	128	131	2379	2568	2784	2133	145	3618	1274	3875	158	1506	3455	1621	3799
+206	1951	2502	2697	2997	74	76	78	1534	81	2775	2059	3026	77	2600	3067
+373	1661	94	102	2219	1967	1856	417	1594	75	100	2251	2200	1825	1291	1021
+57	72	51	1101	1303	60	1227	421	970	1058	138	333	1320	1302	402	1210
+4833	5427	179	3934	4533	5124	4832	2088	94	200	199	1114	4151	1795	208	3036
+759	876	110	79	1656	1691	185	544	616	312	757	1712	92	97	1513	1683
+1250	1186	284	107	1190	1233	573	1181	1041	655	132	547	395	146	119	515
+505	1726	79	180	86	1941	1597	1785	1608	1692	968	1177	94	184	91	31
+1366	2053	1820	1570	70	506	53	415	717	1263	82	366	74	1255	2020	1985
+2365	5585	2285	4424	5560	3188	3764	187	88	223	1544	5023	4013	5236	214	196
+1487	1305	1359	1615	6579	2623	4591	150	5030	188	146	4458	5724	5828	1960	221
+3114	688	3110	334	1921	153	4083	131	2234	3556	3573	3764	127	919	3293	104
+1008	78	1196	607	135	1409	296	475	915	157	1419	1304	153	423	163	704
+235	4935	4249	3316	1202	221	1835	380	249	1108	1922	5607	4255	238	211	3973
+1738	207	179	137	226	907	1468	1341	1582	1430	851	213	393	1727	1389	632

py/2017/02/solve.py

@@ -0,0 +1,44 @@
+import sys
+
+def load_rows(filename):
+	rows = []
+	with open(filename, "r") as f:
+		for line in f:
+			digits = line[:-1].split("\t")
+			row = list(map(int, digits))
+			rows.append(row)
+	return rows
+
+# PART 1
+
+def checksum(rows):
+	total = 0
+	for row in rows:
+		total += max(row) - min(row)
+	return total
+
+# PART 2
+
+def divide_evenly(row):
+	for a in row:
+		for b in row:
+			if a != b and a % b == 0:
+				return a // b
+
+def checksum_even(rows):
+	total = 0
+	for row in rows:
+		total += divide_evenly(row)
+	return total
+
+def main(filename):
+	rows = load_rows(filename)
+	print(f"Solutions for {filename}")
+	check = checksum(rows)
+	print(f"Part 1: {check}")
+	check_even = checksum_even(rows)
+	print(f"Part 2: {check_even}")
+
+if __name__ == "__main__":
+	for filename in sys.argv[1:]:
+		main(filename)

py/2017/02/test_input.txt

@@ -0,0 +1,3 @@
+5	9	2	8
+9	4	7	3
+3	8	6	5

py/2017/03/solve.py

@@ -0,0 +1,64 @@
+import sys
+
+# PART 1
+
+def spiral(nth):
+	length = 1
+	nth -= 1
+	x = 0
+	y = 0
+	while True:
+		x += min(length, nth)
+		nth -= min(length, nth)
+		if nth == 0: return x, y
+		y += min(length, nth)
+		nth -= min(length, nth)
+		if nth == 0: return x, y
+
+		length += 1
+
+		x -= min(length, nth)
+		nth -= min(length, nth)
+		if nth == 0: return x, y
+		y -= min(length, nth)
+		nth -= min(length, nth)
+		if nth == 0: return x, y
+
+		length += 1
+
+def manhattan(x, y):
+	return abs(x) + abs(y)
+
+# PART 2
+
+def store(cap):
+	stored = {(0, 0): 1}
+	nth = 2
+	while True:
+		x, y = spiral(nth)
+		adjacent = 0
+		adjacent += stored.get((x-1, y-1), 0)
+		adjacent += stored.get((x  , y-1), 0)
+		adjacent += stored.get((x+1, y-1), 0)
+		adjacent += stored.get((x-1, y  ), 0)
+		adjacent += stored.get((x+1, y  ), 0)
+		adjacent += stored.get((x-1, y+1), 0)
+		adjacent += stored.get((x  , y+1), 0)
+		adjacent += stored.get((x+1, y+1), 0)
+		stored[(x, y)] = adjacent
+		nth += 1
+
+		if adjacent > cap:
+			return adjacent
+
+def main():
+	nth = 277678
+	print(f"Solutions")
+	x, y = spiral(nth)
+	dist = manhattan(x, y)
+	print(f"Part 1: {dist}")
+	adjacent = store(nth)
+	print(f"Part 2: {adjacent}")
+
+if __name__ == "__main__":
+	main()

py/2017/04/input.txt

@@ -0,0 +1,512 @@
+bdwdjjo avricm cjbmj ran lmfsom ivsof
+mxonybc fndyzzi gmdp gdfyoi inrvhr kpuueel wdpga vkq
+bneh ylltsc vhryov lsd hmruxy ebnh pdln vdprrky
+fumay zbccai qymavw zwoove hqpd rcxyvy
+bcuo khhkkro mpt dxrebym qwum zqp lhmbma esmr qiyomu
+qjs giedut mzsubkn rcbugk voxk yrlp rqxfvz kspz vxg zskp
+srceh xdwao reshc shecr
+dcao isz wwse bbdgn ewsw qkze pwu
+lbnvl lviftmr zqiv iadanl fdhrldn dlaani lxy dhfndrl fkoukx
+raovmz pdysjsw hqps orsyqw rrwnzcz vrzoam jjljt
+wgt gzi icpwp qeefgbe msadakj jbbrma sbj dufuujx zex
+cfzx bvyu eswr hafcfy klw bgnhynv qrf aop
+rzlq atrzcpb hpl pajjw cdxep ean aptzcrb rzcbapt
+xogpf ucc nsukoz umtfbw xfvth ozusnk fopxg ubp iflb
+xot nqcdyu kpwix szo cyxv hpmp hwtrc zso nyuqdc aha
+mkzf cat tkjprc izxdggf obspan lmlbg bsyspf twox
+lfmfrd ooclx tcl clt
+dxvnyd nxwojj arutn eyqocj swzao tmh juvpezm
+teu eman rlmdmk xkbodv fvrcm zorgy wmwe
+hmo fdayx duciqf cgt duciqf
+imjnv vfmsha cyrusow xjswoq nclrmjy sjxowq ynjrcml
+rwbsay alsi bmzpvw ozq aduui nihwx glwdiz ixmkgfx
+vtjzc ntkh zekj qrbkjhn zekj lyfnbg
+afaig jqhli oie lhwyduh kqfnraz nfrzaqk mayfg iljqh
+inb zum zmu dnl zjxg vrdziq ypdnsvt
+uhbzmre mpdxm alkbmsq aopjmkl mqxenry ayvkrf zxvs qkfqva
+fimjr ccv cnug crdsv
+bqyve lhxdj ydu qbyve vihwjr vyodhc
+vmng dyttyf noagpji tdtyfy ewiest ogg
+kgscfj klmsv vmksl vmlks
+qlvh veo wruft wtm fbrlvjr evo wvwmny dhp bvrlrfj lvt vgzuyyw
+mxuro orxmu tivu tjdq ojjvju cdd
+kjexme gxbysxp yxrum hinrklv fxehytd qkt tqk umryx nim
+kywnux wab tzrft dsaz jgwuw dubarmi fle wjguvr umjp uzncwj mzz
+qokwh zrda xywufk tbxhhj eejqaoa hwoqk zer hwt hbjxth xyf hmh
+eregs qdx tdequa agrlrg mwwpba qjie yrjvhr txujk
+iyot fxwdcb zvwfv vfzwv wvkw ncwbr wdejrr ltcdza
+waix eza znmonya ldfghws ialwfvc dey ubsz uhbnh svgekg nonzyam
+bryz tfbqn xznfmw xiplgww wwxigpl jxzcgxl rzyb
+cqvl rrcoqxs staeuqr hzzow cwv tsvol dio coc ddavii uuojy
+txbn qvkkyh gbqnjtq ndpkqr srt bkpqfmm ytycev ypcv bpqmmfk
+uqkjmul dour zgq ztango yrrjhrg ufxnmuw
+ekxbcv vkxbec xbcevk jiq bar
+wczff qdu cwffz hhk wlvyg
+zjlconc osgsro dajzo hqih ehml
+hnio shccluw cpu ivaby tormn vkef abv vkef ivaby
+xgbdeso xiizs omqwy sbtnnt khago evviclw xyu dtvg wsyxfuc humewp
+cnzu bia vdyqrf wwb qveum hmh ouupgc owli
+pjpmfxa dvd lxgh ndy gwph oebfkqv vtlxdg efl ekj dyn
+mvan nmdkc ucyshia mavn ecst poo
+oybm pjwm bmyo wovgu xykziaq obmy eiirhqd
+xkvomx yxvv oxxpth elh vxvy lhe ycn
+okxglw gmaangx gnxaamg yduzrr nzwxtnd rcxcu xjjvno yat cin gaxnamg yss
+oicgs rrol zvnbna rrol
+abb edpnxuo peoudxn bab ceay
+ncpkfz gvwunb fckpzn caafx pkcfzn tsfl
+fnrt ymenkpq wodubcm niv nvi ziluu cuowbdm zocg pdakwt mlzxkex nuxqclo
+uouxcgl stgua otadr ideannq wizxunv iqsdpj mxddt ldst ucxogul
+rbrwyhk wqoz zqwo ikwgexl atpu iza
+smo yolp pcahlu muljxkq cbkljmz zlbcmkj zvbmgz eaiv ncv zplifm yplo
+ocutdhz zmnaap llgv llzpl loavju guzkfq saay rxyhng cwxzx lcv anrnzs
+etyzx tcm upxrtvd imyoiu rdpj fed dmm
+gonqa szteh szteh razdqh phyff upf knfqfaf knfqfaf fpsgl kakag
+mcju mixskop isrwat lcr nfyi lcr aaevr nfyi pqrbk gnful
+xfmr fkmnq fbnhd mxrf litniid xbae frxm zcenf
+yuh lzojtj rqsh hyu
+vbjgql yeshsuv lokt efqota wpwjfu ykyq rxc fxxh ycqfkk gndts vdf
+wnylmr kkuruxm azr xukrkum dohkwx dmdb
+bjiyrwf dvf fdv vdf gnokekr
+jsaq hcww iayqtu llv gdpxdrd hwlo nosjit wpm lcab fcgwr
+fxjp bys nnf xzllckh bys hvojw zcwtgwz wye ccyvjv
+grafa hbb ghk wkdpsf ufa uoqmysd
+yvacf kssbff iovrm mvrio cfbpb avh zzje
+gqd qmsen wkvrfz vhtsa zrwfkv gul zkvwrf
+hrbi svaogb aogsvb bgrk hibr jbtkr
+ljl ryc mrewrge yky
+fcqyymt emk qcmyytf mcfvusb luy qany cbsvumf
+oknt mcozuc ccmuoz uoccmz
+uziil xobutwf acnof iqgwl diso
+sekq fxbtsuv ddnnqg rnemlt dngnqd hhgjfus stxvubf
+lajcp qgiw fyz blrlcd pviwv buh wnkk
+wolqfk nvpapfc rwcqxfz xobno yzjfz irpj wolqfk wbnwjt
+vmabj noiljne hhqf holxkbk swwzx ylgj lnmxy lqodhk abjvm bmsrf
+bpnp yrz pjepxxs jlmhuy vihlx zacm inuazhc xsxjepp
+tryl kryh eonvaad ucevssk umkxg lqej nswopjj svkeucs bmh stosxxz
+cfdwd dmfdrvm ibuhsz nwtgmb pjt dmfdrvm cqdcm fzjjz afa ibuhsz
+erwp abn jwx ynmkkj rhgg abn epd atqhs rst rhgg
+jtnp cegdsoy gfuvfbg gdmn ahlsc
+jgrp diu jrgp onjnml nojmnl vxockc
+lakqyuw khq dcpiwt ykwlqua hkq plklx ujbckec hjcvur jnp pvyf
+usuvoo jkih ylafyy yhio jureyj
+uazisdf cnwlfnf ewodatr woaddkd wbla qmn atdrowe
+bnyepaa ntqh xppe ydtsw ppex
+yewjwsp jxylmtk ijese ewry ijese kbja nfml zeuwcsh juimz
+qbvmf nca zsfreo uurgaiz twe fbqmv ncwi etdcsk atowfp
+jeotslx kgdpzp wxlcww pdd dcn ddp
+macllv ldl kyluine lbt hbxbr wxcaspp ezwvc qxkeu
+ivg gxv zsf ucr uff yrz
+tdlwbny bqlrlz tbynwdl lwtbdny
+tnekq pdaievs ttwpfh xfm fcaa
+zqqhl zbf fbz uqrv bfz ffwavhk foccg
+vcw ebqdd cwv eddbq nrmq
+hpiusz sizphu xzq sgyehk wgagkv hsygek
+vagkxa iou frqdnnr ipcg uxvh vvh eskf katgpiq aqktigp gzvseyi
+xkwgd kzfxk pgdy fmtvq ngf rshx zti pamviob ely knz
+hwo rteohu qzwoe rotuhe wzb
+bsqgg tid dti gtats dit
+sjtux djwxv dljwjq xwvjd xnqfvx veqdrtl uxtsj nnkjn wnhilaf unirrp
+fruuqjk gtote gooklg bzwhim zfnccmm ezipnf cxwdxa wfu fdca
+zcyxb byzxc cxbyz pgcqco ivlxz
+wrjh zfdinsf ihw xwosiah hdg xpiabno bilyy azdeczg javuwa
+rinlv dcpt qhencba mmb njxw gadc
+qwcpua qzyzt cxjsgh kumh byiimas qhsgf qytzz rqqruwp ismyiba xydcxz rwkscqa
+xbzefi hltca ibzxfe fkx xizbfe wvaynts
+oyuce vzk ouxvj gfh efgbv ubc nyb bxnbhd mtwboe whksy ovmrt
+ljrebp tacn bpjler utphw wmfw rcnha
+drdnic eyodes rcnidd yseeod
+umxmsf kfroz ukhjin awpnnnu ooyyohh tuv rafano jze
+bakz lfzpjyg gfkqcgn kzh zwpvk gqfngck
+jpaony ojpnya hmro xaaz tovary aaxz iel pbg
+swvbgc bbhjp yvrcddd rhj clfu eao afrkegn qvvb yvcx nxjmdo rcvtx
+conbjy jeqtri wvujt jeqtri rkhllgw tsdt zowreo qxr qbpragn kuzmplw wvujt
+jrpxyp hchljy rkowqb eeaf ltllebb gtksrwx iazx vnsfmc zzrxw hlcjyh
+piehb cjdzt eqn kuje rls oaewoz lrqwt lcrrq
+hdjowxv uknhlv hluknv pokxg
+txiqxfr fyyp pyyf xfxtrqi tvm rtvby cfx trx nwrf kqrxtat alwot
+wdaadr stexpow ardawd uejqxc
+wwgwjel wwgwjel mtjt wwgwjel
+mczx uua lgceb dqru vkcea tcet ruz
+jkt yroojr qdrtdu wze ovwz fdmqnr xxsyfd kchytwl hctlkwy gyd
+eif irnrce iamhxgh bmis uxye azrwdi sznv yuowb vdlqqxu
+dxdjyj hngqwzs yhwku qhsctfe rhbc rchb tqhcfse
+fxyxnzs qtxevin rvtxtc iqnxtve
+zgbpk mwzxx bgpkz wkpkn
+rjiym iub lcyw agbtlb bzhx osv rbtf
+emmyu uoflio tinih skpqaj rbor gezbhhv ine mij qlqte uuj ycns
+owmwc uhxv pyho ftjh jzsg blqn bszyo bob trbycy mkru
+mwgz bbqsmpp fgzs bihhg bbn pjxxexs qrqmt htsxfwo qltqp vqqaxi
+lpr wcvy sxjqq ltd rftdgv pdnog ymu
+qhcos shuy icdhucu lrikh rwslv yxbgibl rcomhn wakirz
+civdmee owlzocl vedecim rogmjnn pix pohcmk dsjm yworm
+vzdpxp lvt inufv yofqt omm qfoty qrlseqy amkt kjcvg vgkjc
+huhq quhh levzsws sjuun ofgqr cjhp nfxbbft rnt wtbd tbzab
+tjftkx xpfcv hvftvhw lpypbjg batrn fhwhtvv uthl arbtn brb sthv
+ogr uyuxdco bpjgir edztxv sxtgu jzfmx ihnauz zwegqkr kvkw
+mhxthf pervvn gshy jig ezjteq ckkcpy gww
+tiljyki rpe prcojy tjkylii moxu
+pjsdqc lgqydfd lohck emrtejw axwmo wuuv rfi qzyncmw gjijdfb bljfd xrs
+ywjab gynzi relf kziy xmsby izyk ocwoho kqnyh bwayj
+bhjlz uonz jhmzuq eiajoos zjnbj tomj bmyv hjlbz fgw jjbnz
+kszz xzw xzw prtznyb
+ghzk vxhwt thxwv slwpayp qxegmi dawdwo kgzh
+ibpcvuf wnuwxu sbf jsj bfjynl cdp jbylnf
+epaxr vfhf hvff azepadz pwf sbo pgfzya hslyo rqqj rmklw hwtta
+yyolko pwbvxvg xdwl yfje hftep kzzsr kho jeyf yvslxpw kfyv
+xmk juyjxy eqno mdwklum reg dgn cirh wmxfyj bnxlgo dlobk
+oyv gshqyot jgcqe dsf gyohqst gqgeojo egoogjq dmqpyp
+sypianq yss lmhu ulmh itilh ndkda lhiit
+qbxxl bxxql ikald nfap qixwbqq
+jtqhqty ljysnl nwoj toa bmmyj pal
+ahktew sxody nkvsf pbxyt baws wgwfwej bevgzm jus hcvajfy kzrb jwgwewf
+jzsb szbj ujngwf nfuuf lfiuxdu uufnf orsy
+vgo hto isstyul gau wsmxoqw
+uxw itwf epaw hec wape hemol rpwyosc xzxmrll eetz zui kagca
+mjncux muv rygdeis rygdeis
+qgkqjvf iprzibd fkvqqgj llcrl vbh vlf lllrc zwrunt
+dslsa wvoex eqbwj tjem gbx ayn xcan fnacl xggxon gnwjlh
+yzosv hcxjiz yvon gcgd
+bixpny ecln sda eymt bjiwk
+rlcad lrdca adoqfzs rgty mds pwb kmwj
+wkai pmryffq rrdmodc wgyx taz yxwg nkap
+auynzwc vzg uapdv qkrh
+ldmuysp oyu kpn ejbl mfifa bzs hwyn brlw qpzqx uyilao ysdumpl
+czoxoj pwnultl wezolbw lyk aonesgb
+nqy nhb nle yycp lgtbo ojf dytwyh ufa
+rwr eph obg peh pejret prjtee ovgz
+vdqf vdqf ycjrg ovzl lelbe vdqf
+gvagdqm gvdgqam dmb zaxe nepzwn
+emwh bkkbgec qwdgk mhvfsrf wmdfpp ekzuua
+mbqw lgkyazt ckyhvnq uladwo owt
+qwiwd pbo tkjoqda zapo dygqopv zzdlwfn
+qty dhb iinncba ytq kvh idgoevt chx waq
+ulffsvk vplsz ulffsvk uxsh cpwgxd ikgcacx nrirke uowcjvn
+gknmxr grkxnm fco dilyyj grmxkn
+saqxkh uhue nvu fef xsuxq ekyyoc bcaavd
+qltwqa vrmpv vhra nof yprauc vkreojm eaq igiy mec
+wvheiyg uthy gpvcs nhnjrne mqaejr tfnsly zfbhn entcc nystfl cpq
+zxv jzk dwsjgrd gqqxhp xqxu naunwc yeh qzpkz awcnnu aoosa icadax
+vpmqmg qmvpgm tqs mvpqmg
+inehzu zwxeoy jxia fcyzxc hwikd
+bzwnp kamsen ajpn kdls bzh xqcb bzwnp cmjnfa wmgx
+hbuhc qgvhxy smzkxh zzebox hbcuh net wyrdppc yvgxqh
+oeum oemu iyags xaipdi euom
+tqljgoq ghtdhw xhnni lux qltojqg lki zxztda pcqjif acpzvwy
+ydijaq kbyjxpu onyd hsfgz geqvbg
+rwoih xog dtbzyr ryzbdt tdbyzr
+vcdxf zosw pardxfz bmb mscmain lwfc jvq hbszcqh fxomsmm ahnugx
+zutsemg pqzil ddv nsstz gmeuzst bedvy xkzzjpw xlqbd
+xxf ltnnu yeb hbml agj meovtjr qrul kexerkw xxf
+tqrpd hhcx bmdv nlmr pnu pajdtc rpatqi yekedx oeiuew epsshog
+ttbfpv plairk toh jagfsg njnqpa tmwh vwqp irtxv
+vdky uwc tkkkztp vdky vdky qlcw lza
+rzie yundymy pwgx wtwtbg kpiw mewnb liveysj uvsbn
+jgfvyny hacg pzra arpz uowswu puzsfu hoe heo vrq naup
+hqv vrl uko qgpikho lligvxa wdld qgpikho
+whvby yomxwj dieffc jkprinh dsaqy yfrnba woyq yexeb mjn cbszn xeswvvo
+wowtgu rciyg rlas bra quyfec ihe thuu asxhscu bsbdpbi ogxosu
+vydsaet tvnkjq piedkzj foeiqz zqivt iatsju tjnqvk drauaf vqitz invoz
+cppn jqzw zmxr qksuas iifmjg xtkgf cppn cppn jpsd
+nkifpsq cxdx bokxhm ebww kghagrp bofhrl grc cheuzyj
+ibgrlvm hrcx jjuoh ipmt
+hcoqkh fzt rgravb cimauj jxjq blct qhc vjxw pqpg qzp
+jycxz xcv czxjy vxc
+liljaur cgmg neldxb xfummcq yfhiukd dnqhl iolxn cmewhb
+hpvoihj fkwokod txy uuktw vmqqb dpldzh yxmcay cyaxmy xycaym wekr
+ccnaf wuxc ecadb vbgpt ccntf sezo skjdkbf fnctc
+hqdtwho kdhyman bjtcjvr bwllva ncyffyr
+xprn jrrvmj pdw yvexm ewbflbe eapml rvrmjj xmevy rxyzhf
+wjcbpy qdgtcp cfjh muww fhg sgfdleo nelpte yucqa aavev
+rci vqypsqt xmg rzii
+gramh wwprtc ampdhw dajr
+ovrm mdyhpbl mdylbph aykz
+cbmo fxs nuugu guunu upt ljjuhjw nituh utp kxqc
+rhabal rhabal rhabal vah lfrs
+nrq qway ftzp rtjcks mbygdtd hsiqbh wypqb rtjcks cllp hsiqbh
+ywa anhcf nvd puqkwg molrwck wsctx xvd molrwck
+wox jzq jfen wcvus cswvu oxw irg lmu tpj viahm jesic
+qenad neqad smlgi ydwzq ppdemvs ucyuf qtunm eoqx jlgv
+sucpl nrdwbl ltvetok npbw ozzw hafyay sjmui sjmui jkqlq pyn pbuopx
+nxgaiu ybyl meo kgh saqjaz xhbqr otelcyp vkwc
+iqrl ldjlwvl ajhrl dnhutr gkknyqs mcvluet fgyu ogiz cxo aiunl orb
+psd cyq xpoyqny yqc kozqh vonfd uhozwz pds hcpw
+tvaxder tulwmw qiw avddbmh irog vynjzcc refx efxr emnvk
+myjx npqk whm egw kpy igrrohg ukglx ldnuqw caqg ynx fckhnsh
+dafv bkdoqg zcqvbco xgikoac cvbqczo
+rtzhpwk ukuyp bayhzp upkuy ahbpyz
+oarcuv pnlkxvw fqdkj hwzsz nauwl lpufibz vzfbgc unkluxy rwh xuknuyl
+vxhsaj ppdxw qrswqtu ulwv uqtqwsr ppxwd
+cww cww cww scu
+wiiikwa bfpewt zbgxfkl iqpk tpbwfe aazdcxj ipqk icggn fwn fjr
+net ovxuwpz yvzmzd yvzmzd
+xgar czuhp vuhisaq fgrqxy evvrtf mnmar lsk
+hld mxuedug itswju vmmejqx snzslqj toe bbmugph mgubhpb mowj nrjnzu
+qbz ouhye hsldmp lcf hyhlrb ewvle zko
+cke mupaq quapm eck
+owu zdt lales tzd apjjo fhpx bmuktbw dvehpz
+libvl zxypk azazc vtsom ohdzycb
+kiowxnc scxygrf ckxnwio ycxsrgf
+vcjj fqz lfawfx mps zhv qykch vhz psu zud spu fnpvkx
+scfvum fuktgk tua ieosetl wwmjtt exnsw wwmttj plvd pfb kku pdbom
+wkfw snukd wkfw gyaojdf bjw htagy cdsp
+beh gatqxcu ibrooxr ssww orrioxb eenkqz
+jlv affah mtbemf tylh aafhf
+zqfajd uwzrw csouuip qzadjf
+gsnlrw tcel hha tfbzrp ild aenqa
+iirfxef kdux yvj vbzgj
+ibx pfll rgkp nancij llpf xib gbkfy
+uvw kkbavj pznsnk okigtxl ogitxkl eobbs xhaz wroabn ltogxki
+bivdf lotvmoh vrb kpaeeue tdab qhukcb qmy kuqf kesu
+egs hbsfeu esg twxko uib
+ocraimu qilp ijmx eco nhevqp juxf ksejr bcqqau uhpt
+pyx jmpglf juokd dxszjw cml vcjge pfg
+gxwrt btmimse dkpbha idmz mtignka ngakmti
+dpjhm jyalra hukf imocr lkgt rqywn quhe fukh
+nbau xyc bdh yni xaawxm cyx xwaaxm akx gyodqe htbifc
+bywdxe bfrp rvb rndl onal jghiwb nuta aint qlciwcx
+fpic yrqce land soxhci qzc zoebsq hcdohcc fzhcl iyxb dqinum hchdcoc
+zok ghgp zok lmk
+ozfz zofz dkdekzb sqc
+gfti zuqvg cexmtyl qwuqnj stepb erduqhy cuoizcs qudyreh kqvfdd guzqv
+jrugz jzugr lmqu jgihgo hjfbz duxkn unxkd
+ckiys dbqmi ckiys ckiys
+iylp uvvdp pluifaa djo
+esxec rwvel djxppqf jymwt ilm aiz upn aiz wrfefwi rwvel
+nitgjr pokxuy puhdwg qtxpb veylp zqvzkbd lrvpcgu zuy rnigjt ibci
+jboyzq ogcldr hlon ywav jqqtz qjzqt vyaw cok
+aqdw jxn hqknh azbylg
+jya qpxtmsj hqrtsgg qjtpxsm
+pofcs sxw dlvru dlvur swx
+yphvvb qqyyfsp sjkbff dqyerxe jxzes oof
+pwbya txk bbwsj ywgimd kmdpc bawpy lbnt
+bkbazff ldmaq tyfl acqurpy ndnrp
+asw ctiv mnxzyc weeuwb gsn bzk irbyhxl cgqomj izy zbk
+yrxcrbt bcrryxt pofe wwzl
+vuaqez kbtuyai vuaqez dxqud uvo gmhtg dxqud
+tpzs gqdxpxo zzpgta uurjx xpqxodg
+cil lsv vznqw vro zqzvjhm jhgauzw uxnwk lci zpgpu frjvyzo tsv
+zfvcuim gwn gnw dxfppok
+btb goof iwadca aac tbb jha uvzi
+qah ned ipmure kyta ffhrwe njz paq kaag xmlui
+rkmw vrblwyy gpax hxsf zpbza gypuwf jbib ypcjwd vrlybyw
+yfjljn uxpvg huik jsnah nkhsg yfjljn lqzsz
+hagjlqx agnax jqalxgh rvjgtc mjrmph azznzcq gxajlqh
+ipki bhoabp rmiyl dmjyxl zzsmap aju
+tyjrr rigrf ciq qic avmwu jtr wpq
+vuf cosgytm toycgms ufv qzpcbrs
+epzgxr lydrsj ezxrpg expzgr
+ecm prj kmak makk jpr
+ccwyq txy okj matxa socoa
+zrjphq gigayv ywkfmru yrwukmf fxjjrha gqkxx zhjy tisutx kufrywm izjfj igg
+lfhgsro gsroflh wrpo lofhgsr
+kgkgj wkhnab ubrjaoa ubrjaoa ubrjaoa ggdgh
+hztutpn epnqmz ffcroq mnqpez niibpn kdloak xjui ozttj lyzsc pzgq inpnib
+kruz sjqp mmd hhdxjgc mauouma asevvo upjwqi hxcgjhd etqzagp
+zylf qime cho oraid svytv gqrjufv mker cho vnkyiin tjms
+dotjul qyv hnh cibtg gdpauyx wzp
+fabtira ejxoeor cqyethv ndjrq hnxn joq otng lrr csytrub
+txhgepd fwdaanm nawdamf pxine qqrn pronw exnip qwkimt rvy
+kuxzhi jln urzxtw rzu ebsuylm tscru qwlhfgq nnu nuchvz vuht
+cqgu camlr umkltcf stx izp rtdwxff wkfvs
+jhje cxix lefcrsu nebv idfzhic xqri xkft
+utzxb znb ietupd uqgbhje aobip oawjwm hetyan uqtqv hpwzyri kwxyu
+jvzvbt xuyvp aegdkb srbw bzabpf lyfriez cruyfu
+nhi nih aeb ihn
+hcf zypt djcm pkjx pvhh
+rhvxcfk exydvk ids hybme hnk yfchvs mjbo meocn
+rpboxr rxoprb hdzje zhedj
+ziildbo apzvatr vsv isndq ebxyy ntm tdttg wkvdh qnids vkdhw xxolip
+ywu uyw ipcjz pjzci xjn kvgk vsocprw
+euzo njlpv ndrlhi drlnhi ivmjkb fjrtxta skvgmrd
+gbyvj dkck gevpfvb lhadhx rgjcdn yraxh bdk oen vqryd bkr
+vgkp hncttxb wgxh gdyjo bbdfzvc xhgw rznzgda yxrrlo gxhw
+ifjlb fpecyic svhjp ilmj oxgr svhaf
+vbqky lhccj xtmm xzjyykn oqmdq qywir bswly
+euxxziv totzer vsxfx leo djho uoeaz edaig fbu lumbi
+ooqtwq pvo kid vpo jxin bod btqc fbyuz
+jhabi mronu htqqyz umjcbv sgnbp wyn cetmt pcjf
+tnrkcyl dduuhxh rylkctn pwj rtynkcl mzzfomr
+rxx ldqffi ulappk nltawbn tplhb kyb cqyi
+vzkw gviooah vxh xeae ohvcad oaiwcj dkx
+sdofdjt hcifv dqws sia mlwm vfich kavh myzue roops mzuye
+uxs nlbmjp nlbmjp tlaxa tlaxa
+ynnisp twx xtw jgkc yinpns
+kumorsm wav xhx bpvz clqc ffmadzl ndny ymslo lobv
+ljzabj tqhves mezh pwn wue dwfqq lynvtt boeknvi xqbd pkud tzlanis
+lgq qiikzl oihnsr pivtjmu qhic yvmeebg rxu qgl yuxnqse dvu faxqez
+ldk mlwja vmdqr yzlxiua amlubt ejmzfx nonm zhkxbn gaqbnqq
+ttc ctt kneknx smtnaft abljip tct
+uybhbiw zwojzlm cfxoopp abulenj znz zzn opllzmm yufk witwxzp
+qvkybwi rdbxb qiuizmo fqgne jgot jxz dqhapn
+vzinf ehaley amnk laheye invfz
+pedakl ivld agzyhr wmzba tzzzg bazwm wjwgux thrnxkn
+cmyhae nwfs nfsw kmh pxkaffq
+vdf szupev tyunp qiiu deevxmy wozvtt nelnr kgdexy gparqj hajavz biizn
+pwspk skpwp ontbjee pkspw cfbj
+ihsmh djxtak wkzllao oyr djxtak prc
+uhvihqq jrgf hdfek pdrfpt tghz gthz awae wcygi wujti svq fhedk
+gnfhsj odqlt netmsul rviio nkzw nkzw
+xyvc clxw cyxv lxcw
+duegck pkviu npwsp zdx wpvn dmxgnv ixv fybs xteru
+vih kgk hads boaddu daiwo hozoufv nef vtcplc isiw
+tzqoo dqlgvno jzlay sywx ecej addt ecej addt mnfcu
+ymgmby zegudpx ipsjai ger wcwjw brzebb
+eqekxlx itra xekelxq exqkexl
+rciu ojaa ircu nxjga puvmwou remgu
+sltth pprimb slnxopq avtir hvpv ppww fhfap wisn kzs jcuuuuf
+xbppc ydpbq zhjh oym iljzvk vsb
+ueye shtps uccehi ccheiu dqm yeeu
+gwywf lcpv qza qza gzuovj jfzffyh oybfxqv
+aawi ynsvdco azdoz cqr tnyquq xlyvbx eca kcalpes
+zumgzhy rou kguqa vubw bwgd qprxcg etnbev nqmi
+fyd tuoz uwclqn cgl lrpkf irz dizv nxze clg jghx jbpt
+kwuanos eorjr tcahp kwuanos cyrpfji zxayggd kwuanos jkqt qqvbork lizk
+vtu ovje vhg ovje vtu zcy hrhtr puawfgv
+bliz exp wot svxv epx
+jiqgxwj yips hjsatc jgsrno msfp vxvbt bba bqmw xjgpgog
+vpvypp ggwp wggp gndp hedpse afji hcqgof
+hxueubt hiynoa qqzaj ohb qway
+akq nfnes sdrlza nfnes weq
+udxpdpx gctuv llhxuow rqtetm hdbnpte oebapv civy oeobu ftgivd pykj
+pbgbvn jgmr xrz dfn gosjobw ndf
+gnf dtbsnc fwcmml tscdnb fgn qgadusl eifpk
+vmnv yuxrup qcphi tanc tnca kjrv cphqi
+hclggs sghglc fgplp odn pfglp emkrulf whwtmbs qnuyg
+wcxtr ani ain sha hsa zxbkf bzxokat qezo ljqxi xqcwfmd dxo
+waiq smpbu dbyka uibxjrg nze wiqa rfpts ddjsjv jqqjez bpusm
+lpcxf vsbj owjwc tuqj vkrgrh jsjdepv oil lxrjox frsxsi clr
+vzunp prwk nnd rfs vpuzn
+pqpqv lvsk sqxf nhobsm hakbn ywj
+xxu uxx szqnmi lnwtmx
+akq nmlw fupwsth jduvhva
+nac wwlxqck hpbce vxxqa fyp xvxqa kxwclqw yvlmv bfwi
+pzxjbj nvwv mdooiez vvftp enjrsck iypu uhru fpx omtd
+llxgp qwf pwaj cuhb scloot hbcu jgp vjw ooclst
+sisd akawvzd wvdzkaa gyoij ikt eeeosb jiwiup
+tche vxj sbctqv jvx gosur usgor ibo yqxo qqgd zspl
+cidd welisl fxblxqk qxbklfx fbdoqcz glhq iylodvz zvds ghlq
+cnsa hrxst mrnkqtj bptq jmi cpbcofs kveyeur uzmga modphm rtx kntqjrm
+dvyup usfaq rtghoec bvcos fqsua zohwwg
+onf vncybi dlaxni oqyqqkn
+okfwa qyyx ebnv llql nphq etdt ytgivlo jwgwz kiob
+ann vqnqvpx wth lpwid bjvzw xpwqxcj azg ioeyzzp onwf
+smy epzomx xep yid zctvrfj astdj cfg fgc eriuxt
+rljqgin wzobzrh cuwtx vcsbx tmg tuysq vxipgho
+ewp rsrnsj wgeyin lrji ddgt utol xxwut fjiwopa
+upu ftvqbk tfkvbq fdwga rmu puu hbiasjw
+cfl lmqkb lfc wbtlfi uqsjs ejgmphi tbliwf nzcela gzb
+zop unwmiu acull mkwh hvruknw rfk mmhaz iqmenq fifino
+iczua bjut tlgf zicau jtbu
+mtka ipd mdifj kps
+irqkysw xfsjl tedx yckkbx iktxb sqxn pbfvubv uudzppz
+mdrn cihat wcext kufs awwtjok pfjg
+wdevt tyo zzbp pqlqq wdevt
+yhatqkv ntuhw tdfd buxazh xbcsv bas gkv rbzi tddf jbj bsa
+malip hiiy qezz yhii wlfojre
+zqnfll bssveq lprwbep bhqml tztbt
+npnxotu yupdytb jptqo klfydfe fpucmfq svxcqr unopxnt
+gdpz gwj iytiohu efk ctjzf asade abhotq brmhu tbtdur zzksbh
+kxft klzslf tjdzciy lzslkf
+ejei ezmemvg xlt zte tbwhz dgnfpao zotck wus uaz gbwbb
+dgednf vypmbs eiytot empfmny
+uopmui uehue wdvzt adpfcif mutl ifaztka vydi xumtz orstno
+dleero olxiq gxnlfm nfmxlg wloeavr olhrwg hrjd yicj ymyeex qav gxyjgfq
+hevj rqcne zycgb qgqtn rqcne ptfvu yyyu zlm hevj
+zrkhuh sttnkt hkuzhr vqtu
+ppsfm kcao qjq dgadglx cxaawjn pbucfu fed qgioarc dfe ricoaqg
+vmawf oktunea zraoir gkt zraoir jcvkqoq
+mqgml ecawug ugwace szwul iwbmooj owmiojb
+auggaw cypcuw npci vuyxijd pofswjx vdkrgx xylk rom ksj
+qmwx jgsrdj ikva xzxw avik
+zzhcqu rbg pywjdn wyndpj zchuqz
+wzd wqycftu yldezp zovuy oydia hovewe
+kfid qkkk thak qhbf rvzlzvu uuxh pbj hkat gow oeqcw knqqzha
+sua itv hfpg bdqye bznlrk hfpg bdqye kvir kaai ggtz jqn
+ulggl guitamm tkpckso fupacz otxtqpd jxnqc
+ueesb ndyik vjftz jgqqv nrcf
+krh dqpmsw fybzynl zhjbvkw exefc rhs neq ldprb bhhvxm pjwirun
+ymavl qwxr yavml wagwc ekokrpq zewppw iumcgin cxdvwx
+wwdukav kuawvwd kowv dkwvuwa
+eazot bil tzu vdwwbm fvauwrq
+esq tixokph yspf ztoxfut lgzush pwv swh pwv auqhuu tixokph
+pdbeyxi poio mugfkb brwbbx aao uszw fokjeb uswz
+sbs ryjr ptispi tvnhu htunv vthnu
+czjmg hbdjhvi jrkoy fpgwc syafy aar kvnq eaecsb wqzpx
+twtp dvl uvyje qtlzj dsvyr qpjnj eyoigx bhgpccy gwn dtuf
+mxit xunctu vbyks wmqc jriuupl ybvks uncutx nsoxwrb ykt prc
+yye mgf uhc irowpc dsdv iwaxod ftavlj dxzp tcch tcch mefz
+rxe xwrrgl xwrrgl duu rxe xbbgoe
+ucsz akswcd ojrmqq cox hgfh lxwu ltnnf cenikcp
+opjhdp svwezr svwezr opjhdp
+qojlkl ircxqnt utfmdg fcvr vehkcvt ufmzcpv xwlh ddavv xel bwlz fii
+rzkayeh iursm zhily hdnq fqydfvt uwoy hptpiqu tdqy bgr xdr
+ymruz umzry hbltwya jhwhzk flh tahylbw bdbaimb qscbp ntkuf
+uxpato owsqyao vaog oenomkc usrmnc epua vzkppls
+qxqczbk qyguz alawj xgjawtw wxtjgwa snfcdmz
+fjfgos rmpd mgs vbk dlls jkljao eoovdfb ucdvaoq qmjmqku ney porr
+nmcrqz zcoxpk dlnzksd ymh zyg spxss ruyk bychq gsgv eusiuid mnrqcz
+jbzadnx lzl sdamer okoico frqisrm lxet agriw
+xceoqr qai vahc jjzifsn exg
+igjpn wfy ukn aag quro wklsq cjq bgtjrdz gmub wyhh
+fzlwnm mygfn vkzwvw zvhsex gfki
+ijvzgai ebmeq wssfmbq uguh sfuutm nwkgmex dxael liakdxs rnf sky yowpxc
+bjzkyjh fced nji esowk qxsubsk qgtts
+nkdgo bbjfq fgnxnhd gfjchl jetdb xubsgj eiju ldlm oxsx znft bbqfj
+xovcnob pxfe pmstes yzkdm iqlvha nmcziix fexp ivqalh rxecqps
+xpyew xudfud wwqe qhfjlcu epv fnrbgyv ihli qngtx yjlfg ozqbzn esp
+timl gcohx vqzic gzm shwlkkv icqzv urchuc
+xpqq gaqzwo cci dowahsr gaqzwo
+jjsagdl umbpxre kyre zvaryft tmw pxpnjy
+aqovcz nunq nnuq xjrvvh autjmit jiatumt
+elg lps lge zjjot hwz tmqrup xaxxmo zlbzp uftd fukdad kvpymsm
+iokwzal ywti zbdmzbu lprywe wbgbwza ypogbga kzliwao wstqi eqm keaeaj gbabwwz
+lwfpk mhufe eddzgd ljxyqy vhzkct uemhf
+lwqil fzugdo faq feppo usl llwqi
+nje hthr ropq qvcepu bexszfj avmzjvv zajmvvv fhcd xnc cnx qnuaux
+kvksn dphbyz nsx wrcc ccrw
+nzpa pzzunfv ygzjy gxrrtcj hrt trh pwxpg yifgjmo fnupzzv wbzx
+aepti rbojui ypvhe ubojri tcema aan dntkw qjx bfvmyos tcm hvoqytn
+qpwq exu jvsiwj gsw avr vbemldy
+xsbzpf xbzyvx xax sxh vpxt gccy xxa zhgbwoa hwwxoky fhvdxfc pvtx
+pnsa ovtjolz tyutl eyjjzt jvtoolz owbypvr tytlu ewtzgec
+cyg dwwk eihsp aeuk bbnay aluwyz hdmv uaek mwt ihpse wjhnkeg
+fhzx vjetz vjub tejvz
+ewwyb jidhu pyvyenn igtnyd tiwr akwkkbi myz xxjwb jjrdeg
+jbkuw kwir rkiw ubwkj
+bltffuw lftwufb hhsh wfbtulf nrxaa rlszi toijxnz czlci
+bqrm pga zgblgcw pgwhhn lcgzwbg bcgzlgw yqb
+mhjj vjoa gnjlc kclcr ito ofksy giavy fpqeioj
+bkiqmif izidbui sttxxi bswhkxp sduuw
+mjgnvw mjgwnv ojzyuv gvj
+qxn kkhc whd fgwk auzugg augzgu kqfov wfgk
+spdxbnu xpfofsb bpfsoxf ahjywql spbxoff
+bwqxhlm wbqlxmh kqgpl fyzgf guhkvgx ovk qhmp gnrmu wvd wedj
+vvwf hcnc vvwsngj qedzoxm hcnc qedzoxm kjthdi cbwqep qtvu
+gio iqklmro noqablo bab jiqc rwebyg rqkloim wzmgs uunl amqs iwj
+snxj szobqt zcgvwv wiyqknu
+uto jteikwd cew gqsks hmvjtcy sach
+zpgl qnkoex amhufmr figns upv xezrl rjleak nwrna
+pzkvrdz dtonazj gtr gfxucuf lstjl lsjtl rgkope kzpdzrv lyptn zfxjys ttk
+ddxgm lumlgki jhv doft kok swy ckds swy ddxgm lbfbdv
+qfs rcufzgz iaiqw qfs qfs
+nvkbo sgv mquwb ritpye nbkov poex hraorm qrrr qdt qefl
+irxannd fiud ehyb ggx plqg pvvn uuptop tcvbm abuf bcfnmw
+qwya ukblz epmbfr vmlon yqwa
+hlo mmv vmm mvm
+svzpxun yugbbe sbbpxs dmy xspbbs zhpovyf fyovhzp cpbt pke
+zgk gft zybs zrgcoo ypu bue htgo
+xnesq srsx pkzaoh cfqzugh
+lntd nvxetbv clykjpd svmibpx evxtvnb yldkpjc
+jsqq tzwak hephg eqwczd ioisa yim tmdifn mceip
+kuwqz wzkqu zwchmj lfec uexne iztp llityt
+kvamkpc pvbryqh ion cwizjde gln kcpvmak pzzlw gnl
+ydeqf bfaab sydqhbp smsxdjr pynrs cqymt
+onb eiab bno nob
+mqslq scnelxv hyllrf scnelxv mqslq wmnbk
+pttu kubby lgop bbyuk gsk skg ikktlbb inbyvz
+xznvl zwtdj vbxdyd clhw
+hgy zudelp ickc drfjgn iyws xhc
+zzv wik iorhat qkb kjb lykdz vrce yjsjwj
+gyw xzgbi efus uuy
+hwcy ujdun bjjuvd jbdvju onnk xeyy mmp onkn qyzl
+jwfm ptjwrbl hhuv uolz adyweh qpj wxyogp igvnojq jmfw pqs fsnirby

py/2017/04/solve.py

@@ -0,0 +1,36 @@
+import collections
+import sys
+
+# PART 1
+
+def load_phrases(filename):
+	phrases = []
+	with open(filename, "r") as f:
+		for line in f:
+			phrase = line[:-1].split(" ")
+			phrases.append(phrase)
+	return phrases
+
+def is_valid(phrase):
+	return len(phrase) == len(set(phrase))
+
+def count(what, when):
+	return len(list(filter(when, what)))
+
+# PART 2
+
+def is_valid_2(phrase):
+	phrase = ["".join(sorted(word)) for word in phrase]
+	return len(phrase) == len(set(phrase))
+
+def main(filename):
+	print(f"Solutions for {filename}")
+	phrases = load_phrases(filename)
+	correct = count(phrases, is_valid)
+	print(f"Part 1: {correct}")
+	correct_2 = count(phrases, is_valid_2)
+	print(f"Part 2: {correct_2}")
+
+if __name__ == "__main__":
+	for filename in sys.argv[1:]:
+		main(filename)

py/2017/05/solve.py

@@ -0,0 +1,56 @@
+import sys
+
+# PART 1
+
+def load_jumps(filename):
+	jumps = []
+	with open(filename, "r") as f:
+		for line in f:
+			jumps.append(int(line[:-1]))
+	return jumps
+
+def perform_jumps(jumps):
+	jumps = jumps.copy()
+	pos = 0
+	steps = 0
+
+	while 0 <= pos < len(jumps):
+		next_pos = pos + jumps[pos]
+		jumps[pos] += 1
+		pos = next_pos
+		steps += 1
+
+	return steps
+
+# PART 2
+
+def perform_jumps_2(jumps):
+	jumps = jumps.copy()
+	pos = 0
+	steps = 0
+
+	while 0 <= pos < len(jumps):
+		next_pos = pos + jumps[pos]
+		if jumps[pos] >= 3:
+			jumps[pos] -= 1
+		else:
+			jumps[pos] += 1
+		pos = next_pos
+		steps += 1
+
+	return steps
+
+def main(filename):
+	jumps = load_jumps(filename)
+	print("Previously calculated")
+	print("Part 1: 343467")
+	print("Part 2: 24774780")
+	print(f"Solutions for {filename}")
+	steps = perform_jumps(jumps)
+	print(f"Part 1: {steps}")
+	steps_2 = perform_jumps_2(jumps)
+	print(f"Part 2: {steps_2}")
+
+if __name__ == "__main__":
+	for filename in sys.argv[1:]:
+		main(filename)

py/2017/05/test_input.txt

@@ -0,0 +1,5 @@
+0
+3
+0
+1
+-3

py/2017/06/input.txt

@@ -0,0 +1 @@
+0	5	10	0	11	14	13	4	11	8	8	7	1	4	12	11

py/2017/06/solve.py

@@ -0,0 +1,49 @@
+import sys
+
+# PART 1
+
+def load_buckets(filename):
+	with open(filename, "r") as f:
+		return tuple(map(int, f.read()[:-1].split("\t")))
+
+def redistribute(buckets):
+	l = list(buckets)
+	i = l.index(max(l))
+	n = l[i]
+	l[i] = 0
+
+	while n > 0:
+		i = (i + 1) % len(l)
+		l[i] += 1
+		n -= 1
+
+	return tuple(l)
+
+def find_repeat(buckets):
+	cycles = 0
+	states = {buckets: 0}
+	while True:
+		buckets = redistribute(buckets)
+		cycles += 1
+		if buckets in states:
+			return cycles, states[buckets]
+		else:
+			states[buckets] = cycles
+
+# PART 2
+
+def loop_cycles(buckets):
+	cycles, start_cycle = find_repeat(buckets)
+	return cycles - start_cycle
+
+def main(filename):
+	print(f"Solutions for {filename}")
+	buckets = load_buckets(filename)
+	cycles, _ = find_repeat(buckets)
+	print(f"Part 1: {cycles}")
+	cycles_2 = loop_cycles(buckets)
+	print(f"Part 2: {cycles_2}")
+
+if __name__ == "__main__":
+	for filename in sys.argv[1:]:
+		main(filename)

py/2017/06/test_input.txt

@@ -0,0 +1 @@
+0	2	7	0

py/2017/07/solve.py

@@ -0,0 +1,116 @@
+import re
+import sys
+
+# PART 1
+
+def any_key(d):
+	return list(d)[0]
+
+class Tower:
+	PROG_RE = r"(\S+) \((\d+)\)( -> (.*))?\n"
+
+	def __init__(self, weight_of, children_of, parent_of):
+		self.wo = weight_of
+		self.co = children_of
+		self.po = parent_of
+
+	@classmethod
+	def from_file(cls, filename):
+		weight_of = {} # name -> weight
+		children_of = {} # name -> children
+		parent_of = {} # name -> parent
+
+		with open(filename, "r") as f:
+			for line in f:
+				match = re.fullmatch(cls.PROG_RE, line)
+
+				name = match.group(1)
+				weight = int(match.group(2))
+				if match.group(4):
+					children = match.group(4).split(", ")
+				else:
+					children = []
+
+				weight_of[name] = weight
+				children_of[name] = children
+				for child in children:
+					parent_of[child] = name
+
+		return cls(weight_of, children_of, parent_of)
+
+	def find_root(self):
+		program = any_key(self.po)
+		while program in self.po:
+			program = self.po[program]
+		return program
+
+# PART 2
+
+# This part is implemented really shitty. It makes a lot of assumptions and
+# will probably break the second the input changes or you're just unlucky.
+# For my particular input, it worked though.
+#
+# The basic idea of the algorithm is:
+#
+# 1. Find the plate where one branch has a different weight from all the others
+# 2. Find out which branch weight is wrong and whic weights are correct
+# 3. Fix the branch's root program's weight
+
+	def weight(self, name):
+		return self.wo[name] + sum(self.weight(c) for c in self.co[name])
+
+	def balanced(self, name):
+		cs = self.co[name]
+		ws = [self.weight(c) for c in cs]
+		return min(ws) == max(ws)
+
+	def unbalanced_child(self, name):
+		for c in self.co[name]:
+			if not self.balanced(c):
+				return c
+
+	def find_imbalance(self, name):
+		c = self.unbalanced_child(name)
+		if c is None:
+			weights = [(c, self.weight(c)) for c in self.co[name]]
+			return weights
+		else:
+			return self.find_imbalance(c)
+
+	def fix_imbalance(self, weights):
+		# Which weight do we need to correct?
+		ws = [weight for (c, weight) in weights]
+		if ws.count(max(ws)) < ws.count(min(ws)):
+			weight = max(ws)
+			other = min(ws)
+		else:
+			weight = min(ws)
+			other = max(ws)
+
+		# Wich program has that weight?
+		prog = None
+		for (p, w) in weights:
+			if w == weight:
+				prog = p
+				break
+
+		# w_prog_soll - w_prog = w_soll - w_branch
+		# w_prog_soll = w_soll - w_branch + w_prog
+		# w_prog_soll = w_soll - (w_branch - w_prog)
+		w_prog = self.wo[prog]
+		w_soll = other
+		w_branch = self.weight(prog)
+		return w_soll - (w_branch - w_prog)
+
+def main(filename):
+	print(f"Solutions for {filename}")
+	tower = Tower.from_file(filename)
+	root = tower.find_root()
+	print(f"Part 1: {root}")
+	weights = tower.find_imbalance(root)
+	fixed = tower.fix_imbalance(weights)
+	print(f"Part 2: {fixed}")
+
+if __name__ == "__main__":
+	for filename in sys.argv[1:]:
+		main(filename)

py/2017/07/test_input.txt

@@ -0,0 +1,13 @@
+pbga (66)
+xhth (57)
+ebii (61)
+havc (66)
+ktlj (57)
+fwft (72) -> ktlj, cntj, xhth
+qoyq (66)
+padx (45) -> pbga, havc, qoyq
+tknk (41) -> ugml, padx, fwft
+jptl (61)
+ugml (68) -> gyxo, ebii, jptl
+gyxo (61)
+cntj (57)

py/2017/08/solve.py

@@ -0,0 +1,96 @@
+import collections
+import re
+import sys
+
+# PART 1
+
+class Instruction:
+	INSTRUCTION_RE = r"(\S+) (inc|dec) (-?\d+) if (\S+) (<|<=|>|>=|==|!=) (-?\d+)\n"
+
+	def __init__(self, register, mode, amount, c_register, c_operator, c_amount):
+		self.register = register
+		self.mode = mode
+		self.amount = amount
+		self.c_register = c_register
+		self.c_operator = c_operator
+		self.c_amount = c_amount
+
+	@classmethod
+	def from_line(cls, line):
+		match = re.fullmatch(cls.INSTRUCTION_RE, line)
+
+		register   =     match.group(1)
+		mode       =     match.group(2)
+		amount     = int(match.group(3))
+		c_register =     match.group(4)
+		c_operator =     match.group(5)
+		c_amount   = int(match.group(6))
+
+		return cls(register, mode, amount, c_register, c_operator, c_amount)
+
+	def compare_to(self, n):
+		if self.c_operator == "<":
+			return n < self.c_amount
+		elif self.c_operator == "<=":
+			return n <= self.c_amount
+		elif self.c_operator == ">":
+			return n > self.c_amount
+		elif self.c_operator == ">=":
+			return n >= self.c_amount
+		elif self.c_operator == "==":
+			return n == self.c_amount
+		elif self.c_operator == "!=":
+			return n != self.c_amount
+
+	def total(self):
+		if self.mode == "inc":
+			return self.amount
+		elif self.mode == "dec":
+			return -self.amount
+
+class Machine:
+	def __init__(self, instructions):
+		self.instructions = instructions
+		self.reset()
+
+	def reset(self):
+		self.registers = collections.defaultdict(lambda: 0)
+		self.max_all_time = 0
+
+	@classmethod
+	def from_file(cls, filename):
+		instructions = []
+
+		with open(filename, "r") as f:
+			for line in f:
+				instructions.append(Instruction.from_line(line))
+
+		return cls(instructions)
+
+	def execute_instruction(self, i):
+		c_amount = self.registers.get(i.c_register, 0)
+		if i.compare_to(c_amount):
+			self.registers[i.register] += i.total()
+			self.max_all_time = max(self.max_all_time, self.registers[i.register])
+
+	def execute(self):
+		for i in self.instructions:
+			self.execute_instruction(i)
+
+	def max_register(self):
+		return max(self.registers.values())
+
+# PART 2
+
+def main(filename):
+	print(f"Solutions for {filename}")
+	machine = Machine.from_file(filename)
+	machine.reset()
+	machine.execute()
+	max_register = machine.max_register()
+	print(f"Part 1: {max_register}")
+	print(f"Part 2: {machine.max_all_time}")
+
+if __name__ == "__main__":
+	for filename in sys.argv[1:]:
+		main(filename)

py/2017/08/test_input.txt

@@ -0,0 +1,4 @@
+b inc 5 if a > 1
+a inc 1 if b < 5
+c dec -10 if a >= 1
+c inc -20 if c == 10

py/2017/09/solve.py

@@ -0,0 +1,95 @@
+import sys
+
+# PART 1
+
+class Stream:
+	def __init__(self, string):
+		self.content = list(string)
+		self.content.reverse()
+
+	def peek(self):
+		return self.content[-1]
+
+	def pop(self):
+		return self.content.pop()
+
+def load_groups(filename):
+	groups = []
+	with open(filename, "r") as f:
+		for line in f:
+			stream = Stream(line[:-1])
+			group, garbage = parse_group(stream)
+			groups.append((group, garbage))
+	return groups
+
+def parse_group(stream):
+	assert stream.pop() == "{"
+
+	if stream.peek() == "}":
+		assert stream.pop() == "}"
+		return [], 0
+
+	groups = []
+	garbage = 0
+
+	while True:
+		# Determine which sub-parser to use
+		if stream.peek() == "{":
+			group, more_garbage = parse_group(stream)
+			groups.append(group)
+			garbage += more_garbage
+		elif stream.peek() == "<":
+			garbage += parse_garbage(stream)
+		else:
+			raise Exception("Incorrectly formatted input")
+
+		# Determine whether to stop parsing
+		if stream.peek() == "}":
+			break
+		elif stream.peek() == ",":
+			assert stream.pop() == ","
+		else:
+			raise Exception("Incorrectly formatted input")
+
+	assert stream.pop() == "}"
+	return groups, garbage
+
+def parse_garbage(stream):
+	assert stream.pop() == "<"
+
+	escaped = False
+	garbage = 0
+
+	while True:
+		if escaped:
+			stream.pop()
+			escaped = False
+		elif stream.peek() == "!":
+			assert stream.pop() == "!"
+			escaped = True
+		elif stream.peek() == ">":
+			break
+		else:
+			stream.pop()
+			garbage += 1
+
+	assert stream.pop() == ">"
+
+	return garbage
+
+def group_score(group, level=1):
+	return sum(group_score(subgroup, level + 1) for subgroup in group) + level
+
+# PART 2
+
+def main(filename):
+	print(f"Solutions for {filename}")
+	groups = load_groups(filename)
+	for group, garbage in groups:
+		score = group_score(group)
+		print(f"Part 1: {score}")
+		print(f"Part 2: {garbage}")
+
+if __name__ == "__main__":
+	for filename in sys.argv[1:]:
+		main(filename)