From 757b98fb30e75d7698a0986184d0303224db156c Mon Sep 17 00:00:00 2001 From: Prefetch Date: Tue, 26 Mar 2024 21:41:32 +0100 Subject: Publish days 6-10 --- 06/input.txt | 1 + 06/lib.scm | 82 ++++ 06/main.scm | 14 + 06/test.scm | 29 ++ 07/input.txt | 1193 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 07/lib.scm | 192 ++++++++++ 07/main.scm | 20 + 07/test.scm | 43 +++ 08/input.txt | 1000 ++++++++++++++++++++++++++++++++++++++++++++++++ 08/lib.scm | 105 ++++++ 08/main.scm | 20 + 08/test.scm | 34 ++ 09/input.txt | 1 + 09/lib.scm | 70 ++++ 09/main.scm | 14 + 09/test.scm | 68 ++++ 10/input.txt | 1 + 10/lib.scm | 123 ++++++ 10/main.scm | 14 + 10/test.scm | 42 +++ 20 files changed, 3066 insertions(+) create mode 100644 06/input.txt create mode 100644 06/lib.scm create mode 100644 06/main.scm create mode 100644 06/test.scm create mode 100644 07/input.txt create mode 100644 07/lib.scm create mode 100644 07/main.scm create mode 100644 07/test.scm create mode 100644 08/input.txt create mode 100644 08/lib.scm create mode 100644 08/main.scm create mode 100644 08/test.scm create mode 100644 09/input.txt create mode 100644 09/lib.scm create mode 100644 09/main.scm create mode 100644 09/test.scm create mode 100644 10/input.txt create mode 100644 10/lib.scm create mode 100644 10/main.scm create mode 100644 10/test.scm diff --git a/06/input.txt b/06/input.txt new file mode 100644 index 0000000..04f1425 --- /dev/null +++ b/06/input.txt @@ -0,0 +1 @@ +4 1 15 12 0 9 9 5 5 8 7 3 14 5 12 3 diff --git a/06/lib.scm b/06/lib.scm new file mode 100644 index 0000000..76bd34d --- /dev/null +++ b/06/lib.scm @@ -0,0 +1,82 @@ +(library (lib) + (export solve-part1 solve-part2) + (import (chezscheme)) + + ; Split list at first delimiter into `prefix' and `suffix' + ; Return value is a pair like `((p r e f i x) s u f f i x)' + (define (list-split-left delimiter? xs) + (let loop ((prefix '()) + (suffix xs)) + (if (null? suffix) + (cons prefix suffix) + (let ((x (car suffix))) + (if (delimiter? x) + ; Found first delimiter, so return immediately + (cons prefix (cdr suffix)) + ; `x' isn't a delimiter, so append it to `prefix' + (loop (append prefix (list x)) (cdr suffix))))))) + + ; Split list at given delimiter into list of sublists + (define (list-split delimiter? xs) + (let loop ((pieces '()) + (rest xs)) + (if (null? rest) + ; Fix order and remove all empty sublists from output + ; (which are caused by consecutive delimiters in `xs') + (reverse (remp null? pieces)) + ; Extract next piece from `rest' and prepend it to `pieces' + (let ((next (list-split-left delimiter? rest))) + (loop (cons (car next) pieces) (cdr next)))))) + + ; Split string at whitespace into list of words + (define (string-split str) + (map list->string (list-split char-whitespace? (string->list str)))) + + ; Find the index at which `needle' occurs in `haystack', or `#f' + (define (find-index needle haystack) + (let loop ((xs haystack) (i 0)) + (if (null? xs) + #f + (if (equal? needle (car xs)) + i + (loop (cdr xs) (+ i 1)))))) + + ; `apply' but for vectors, assuming `proc' returns a scalar + (define (vector-apply proc vec) + (apply proc (vector->list vec))) + + ; Redistribute the items according to the puzzle description + (define (redistribute old) + (let* ((n-max (vector-apply max old)) ; largest value in `old' + (i-max (find-index n-max (vector->list old))) ; index of `n-max' in `old' + (new (vector-apply vector old)) ; allocate copy of `old' + (len (vector-length old))) ; number of slots in `old' + ; Clear the slot that had the most items + (vector-set! new i-max 0) + ; Add those items to the other slots one by one + (let loop ((i (mod (+ i-max 1) len)) + (remaining n-max)) + (if (= remaining 0) + new + (let ((n (vector-ref new i))) + (vector-set! new i (+ n 1)) + (loop (mod (+ i 1) len) (- remaining 1))))))) + + ; Keep redistributing items until a previous state is revisited + (define (solve-puzzle str) + (let ((init (list->vector (map string->number (string-split str))))) + (let loop ((states (list init))) + (if (find-index (car states) (cdr states)) + states + (loop (cons (redistribute (car states)) states)))))) + + ; Loop detected after `(length states)' cycles, minus initial state + (define (solve-part1 str) + (- (length (solve-puzzle str)) 1)) + + ; Loop start state first seen somewhere in `(cdr states)', at which index? + (define (solve-part2 str) + (let ((states (solve-puzzle str))) + (+ (find-index (car states) (cdr states)) 1))) + +) diff --git a/06/main.scm b/06/main.scm new file mode 100644 index 0000000..4e58151 --- /dev/null +++ b/06/main.scm @@ -0,0 +1,14 @@ +(import (chezscheme)) + +; Where the magic happens +(import (lib)) + +; Read my personal puzzle input +(define input + (call-with-input-file "input.txt" get-line)) + +; Part 1 gives 6681 for me +(printf "Part 1 solution: ~a\n" (solve-part1 input)) + +; Part 2 gives 2392 for me +(printf "Part 2 solution: ~a\n" (solve-part2 input)) diff --git a/06/test.scm b/06/test.scm new file mode 100644 index 0000000..e8efb7c --- /dev/null +++ b/06/test.scm @@ -0,0 +1,29 @@ +(import (chezscheme)) + +; Where the magic happens +(import (lib)) + +; My quick-and-dirty unit testing framework (copied for each day) +(define (run-test name proc input expected) + (let ((result (proc input))) + (if (equal? result expected) + (printf "\x1b;[32;1mPASS\x1b;[0m: ~a\n" + name) + (printf "\x1b;[31;1mFAIL\x1b;[0m: ~a: got ~a, expected ~a\n" + name result expected)))) + +(printf "Part 1 tests:\n") + +(define (test-part1 name input expected) + (run-test name solve-part1 input expected)) + +(test-part1 "part 1 example 1" + "0 2 7 0" 5) + +(printf "Part 2 tests:\n") + +(define (test-part2 name input expected) + (run-test name solve-part2 input expected)) + +(test-part2 "part 2 example 1" + "0 2 7 0" 4) diff --git a/07/input.txt b/07/input.txt new file mode 100644 index 0000000..4f6dd1c --- /dev/null +++ b/07/input.txt @@ -0,0 +1,1193 @@ +yvpwz (50) +vfosh (261) -> aziwd, tubze, dhjrv +xtvawvt (19) +nspsk (24) +sgtfap (19) -> bohjocj, bqvzg +oyuteie (52) +irrpz (226) -> cibfe, hemjsj, upbldz +vtvku (426) +vbsfwqh (6055) -> govhrck, pglpu, rwuflbi, ppgaoz +nupmnv (47) -> cngdg, olgsb, lmvmb +ulndqey (71) +fujgzbt (198) -> fbesgp, hewtnrw +nsbvvsi (39) +ajvtdl (36) +xrgca (85) +mksrqb (45) +ozfsktz (56) -> xzwjii, uhxjy +peretma (15) -> suzsw, ycvvjgc, cdyhvr, jixggay +boplau (77) -> boggvxt, cnyasj +rzqffr (84) -> tbppaj, htyeqf, pgnyu, ruhqn +shkkwp (5) +bpptuqh (68) -> ugxls, zlshut, ltqljtw +bngres (944) -> ktwby, tblhhg, jzgpty, skbprng +tjnyo (55) +ujfeg (13) -> vldxkw, kfbsjv, rlqwaz, dvwsrc, ymxlwf, zvmhx, wfdxfxq +mxplky (35) +ezkqh (91) +kozgi (48) +pgnyu (94) +yhunajf (25) +pvpmt (77) +cvitrpt (88) +zjwih (46) -> cvitrpt, chtamif +mhfnxk (6) -> jddyhz, gvrhj, ctpdk, oprvyxy, luzjys +dbrnqc (77) +iorlbdv (43) +twwzhwf (118) -> ndgupvi, aumbaa +mvngvtg (67) +kwkprrw (187) -> uobxcai, aklrjg +wtvffu (120) -> vzxvex, mtsbrje, slfile +vjwivnq (52) +cbwbdsv (157) -> przuau, atjtgjx +rwuflbi (8) -> lapoix, dkdovw, spgcwtn +upbldz (27) +xgnqi (64) +ksotbs (48) -> cqbvru, tqbvdu +romrjs (55) -> vhilqk, gzxuw +ftmwqqj (76) +kqpvqie (63) -> qomhp, fwvsi +xxrsnzv (39) +trqfblp (85) +rmjktk (28) -> wtkfiw, mlrdsj, pnicdos, woujz, psrzr +lwygknn (96) +ctgbkrb (76) -> iavuhwe, onvkja +iqbrs (67) -> tghoyv, hoheog, kjpzwp, wwvad, ezmjqnt +efuqu (136) -> umljkr, qblnh +egwjjg (85) +dgtvwiy (27) +ndgupvi (28) +zdvai (85) +auhio (82) +dywjt (40) +hhboca (18) +pptbkz (96) +iqsvbk (73) +nwjibjk (31) +veclzy (308) -> dohjma, hbiwkt +repak (139) -> bcjxhps, eyckbl +xguqlvl (74) +rkjmp (59) +eqviuw (171) -> mqlsvih, lrnjjfq, njgkkxo +zogylog (80) +kroqr (38) +onvkja (49) +tedehrz (94) -> ipqjff, dmiqf +lhwyt (287) -> jbwbw, htyyatf, ppvwkei, vtbzq, pynomi, uswsg +mrbqk (64) +aoxtau (64) +gvrhj (59) -> qurrva, xrgca +lfksu (72) +tnwle (49) +dgnpr (93) +ucsxzhl (21) -> tpefei, ntkeax, jvayv, yuobv +wbibf (183) -> pvtat, ygnww, akngdu, swpkkpi +ljaktj (21939) -> seeqikh, mqrfbqc, ihnus +agqkf (69) +tubze (48) +fcapw (105) -> nkhzrd, shkkwp +sdied (47) +zfmeblt (56) +wqyzjzi (41) +zxjeza (185) -> ioumv, pjersb +vecxd (56) -> civozek, qzsypj +dkxebg (73) -> atrmuc, mhfnxk, zwwbw, ryaotx, yqhmb, yztqpc +oqiye (35) +edyqn (60) +fujwzoc (404) +llcbiqi (79) +yejkld (41) +utbev (25) -> hsxru, jfuxeo, zyshq, eznabc, lgsda, uobxonm +ojxyv (79) +vbpde (20) +fyjowg (26) +yfzjc (31) +obwzec (41) +zcanxq (85) +woujz (125) -> qntvn, kwzrzn +adhwzp (305) -> agqkf, yallk +zvcfznz (184) -> rjuhrpu, yzwnh, hikik +dxbrl (66) +appays (423) -> nupmnv, cyppxr, rqoczb +rgndu (81) -> tsbbzu, dtxrjg +jncex (74) -> rrdczem, bhhgpe, gtvnow, vndrx +cfvbuip (53) +vsqfx (29) +zocaag (38) +ppymmsf (19) +amwxj (69) -> pptbkz, kweqtf, jwmbs +svadhfo (99) +xdsbnr (8) +duvrzrl (22) +dfaro (8) +vgugdtt (220) -> nxpakq, fhsecp +fwddmmv (43) +igaww (28) +bbxbrsh (31) +swpkkpi (13) +bkqexxz (77) +ovfduq (16) +rtzce (39) +gmwto (119) -> wbeizj, refgrip +rmdhj (24) +yeref (77) +ifstrgw (23) -> qpixldb, tukirqp, bwcyqb, bzbmt +untdpje (45) -> owimy, yejkld +esiwujq (41) +emvxet (131) -> vecdh, ftgvx +mztuzb (764) -> jgzvrf, eaqiocy, fsagr +bwnabqh (83) +gypsfc (43) +bhemin (44) +imydd (164) -> iabqb, vdpnsak +qajpehv (49) +oxnfnsv (76) -> twwzhwf, uiyyc, gfaamu, umhcrc, bcjpzpk, vrqeade +qfdldyu (231) +dmsmgs (29) +oqady (7) -> mhtzh, cpreh +zbhwrc (759) -> esrilo, dcngdo +cyppxr (272) -> pitmcu, nvlqab +jtzjrke (45) +przuau (59) +eexkce (44) +xsewlv (124) -> fwfpmti, rszjhxn +fbesgp (28) +sxegjbz (297) -> yhycc, gxmry, favzt +nxpakq (17) +hbvvse (98) +ygzwut (83) +cngdg (93) +tfzum (69) +ccghjn (58) +ylbpwah (190) -> htlpx, eduzave, peqgox, fkqkfdu +mobbhp (141) -> clgbo, jtzjrke +icdlpb (62) +wkrtcw (1663) -> qqzhz, ybewhak, mazbb +uswsg (312) +zdvlgn (63) -> rmpryj, qrtdtt +hfcifm (107) -> tpfuxx, wdivd +cltqhc (25) +gnrnwtz (513) -> efxakc, jxlgwb, ksotbs, gvayfu, wqvtdc +rdufpid (25) +kszmj (137) -> eemfgbx, amvjukd +ykuto (662) -> pvuoltd, kcyiwqs, kbjnzw, kszmj +ckswvj (264) -> cleanrs, ntixh +czhsx (51) +luayjsp (47) -> alhjba, qjghc +djnsvq (295) -> nbnqidn, ijjfn +qxzfv (57) +qyzja (94) +rmpryj (96) +eyreht (45) +vzkii (216) +rwheyic (68) +rjmdre (21) +qntvn (71) +lescv (32) +qomhp (32) +oegwh (70) +tukirqp (85) +pumxr (103) -> wvpwez, kiuiq +fjrpc (89) +gmoliax (1327) -> jniisu, cfafhwl +wsrwgvc (80) +zhgzg (62) -> aonfu, vqiqglo +fxcuah (208) -> uofigyp, kfxyzqc +fnjnhmk (76) +zlshut (62) +hsnbry (26) +pjnyxo (30) +luzjys (115) -> kisjb, owsosl +vecdh (14) +vfrqc (13) +udjcwm (18) +twpmx (30) +oiysq (64) +lcazsyd (78) +ryaotx (399) -> lmctbp, imydd, wlkatbq, sikzsc +rbnfwkf (51) +kdtpg (4260) -> lymwlyg, xgqzb, appays +djvps (30) +vjqjwk (76) +pbrdt (66) +rciilr (33) +heumdl (75) +whqvs (146) -> ttxrd, qxuakjr +zvtxa (77) +cpkkq (18) -> romrjs, xmpdevf, nnofr, qgqou, nmkjx, nbvwta +sxada (7) -> dgrwv, irlfj, rmjpia, ciafn +frbmr (67) -> tnwle, nnyqes +tgksxw (53) -> dkffgot, yvpwz +ijvux (77) +tblhhg (44) +xxsivgz (17) -> kkhfzgn, rbqcbvl +ylxxmlt (83) -> qxzfv, dacbtyf, aqhcy +vndrx (248) -> xecqd, tznkdt +jwezuh (57) -> kxrxtq, cijfsu +ztqvzwj (86) +dluyef (1987) -> zcicmp, qkhhg, eivrwbt, iqzdu, rmvry +ybzvav (873) -> agwyte, kawloxz, bmdxyf +pvuoltd (115) -> glgrdm, gfizf, bnehbkl, lkyeyn +ceefghr (21) -> mksrqb, saqjax, llild, qwvvha +khphs (101) -> qwlepd, acgrw +yxvgj (13) +zifogt (85) +wgwlbz (83) -> uwaij, qklota +xlyvge (235) -> zgnoqml, trqfblp +qaxvec (41) +ylkfgx (6) +pzgvdt (37) +vtzdfjg (77) +tyiekxm (24) +jaiqusy (18) +avhkram (73) +akluijb (77) +bohjocj (73) +ofoto (1287) -> sgrcmj, jxykl +qgqou (227) +xtoaq (18) +peqgox (25) +kobcmy (64) -> haeymgy, egwjjg, zcanxq, zifogt +namzy (79) +vldxkw (463) -> gmwto, aflmt, boplau, khphs, qlthpj, epqsj +chtamif (88) +vqsuh (92) +iofsrh (35) +njgkkxo (17) +zsqqhe (94) +xupdam (64) +bqvzg (73) +hmetm (889) -> aklagd, ceefghr, whcxfwf, guztl +hoheog (296) +llsvd (18) +giupn (30) +dfzfwun (64) +nmfvmam (125) -> qxwlhxh, obwzec +ioumv (86) +gxmry (143) -> cyvplfd, wmcusr +ywgvsdb (131) -> fzfxs, yvdkbo, igaww +pwsye (49) +mywezi (407) -> gimkyms, bnxvusb +fzfxs (28) +kurgrkq (76) +txeucf (61) +gjwflt (84) -> xmfzu, gcbjhu, xxnannn, bwnabqh +vrgxe (1226) -> zbfyg, rocbcw, zouml, wbibf +izwze (16) +jwmbs (96) +euvev (46) +dgzvf (30) +iezdimc (82) +zkhll (992) -> bbqtwv, xupdam +jhxxfq (71) +hemjsj (27) +ryxkvxj (124) -> bhemin, apghde +qxuakjr (54) +aonfu (95) +dvopaww (98) +uobwwa (69) +dojvyuv (96) +ezcmm (886) -> ntjmwf, qfdldyu, vokxlx +yzwnh (15) +jfqanu (302) -> dcgarog, tcpqh +gfizf (14) +kvbdsv (46) +qzsypj (98) +vyffcrm (24) +iuoxs (13) +zitfb (23) -> ctagl, ddpgq +yueoma (46) +bbqtwv (64) +hgsng (45) +wgehfu (77) -> lescv, hnjbsg, bxvwe, evmuxia +arwqmho (66) +amvjukd (17) +ntixh (10) +zfzblty (47) +cxzuprb (592) -> texfyi, dvgstr, irhxzg +ekqux (76) +abxalr (697) -> zjwih, gjwuf, eqviuw +choiui (65) +tgjdwlh (24) +glhsr (60) +rtymngs (66) +rocbcw (169) -> djizg, dtnaqds +bjwws (46) -> evgtp, ztqvzwj +gowbiey (78) +yqhmb (497) -> njgrpbo, tedehrz, bjwws +lapoix (240) -> xkizl, dyhate, disan +vckqsrm (30) +sxdljm (66) +frpmd (13) +uwhwsv (86) +wknic (47) +pnicdos (165) -> czhsx, rbnfwkf +wrsik (80) +wbogdd (66) -> eibtll, ppmvpn +fyrqw (28) -> ekqux, zxoqwjv, ipogzy, dhzuvup +uttjzap (22) +gqjkk (41) +gcbjhu (83) +bnxvusb (21) +bxvwe (32) +difjqqd (47) +xxnannn (83) +lxzucvk (94) +ehynj (98) -> ijvuozb, wutdi +vwkbje (25) +ciafn (62) +pyyuj (34) +zofljd (685) -> hfcifm, emvxet, ahrdgu +zyshq (140) -> dpcmm, eosuf +zgslahq (101) -> ximrxj, auvxopo +xszci (72) +fomxzjj (47) +mcduoz (6) +rcltx (73) -> djnsvq, hqmum, ifstrgw +pemna (98) +fgnsyw (39) +tfppg (77) -> uwhwsv, fmapm +tohlady (84) +gzxuw (86) +mkdiuil (96) +qfhkgt (52) +csxwyly (47) +intuzzk (82) -> jqqxv, dlnyi, pbides, qtcqtv +bfxhl (78) -> qvmorke, pazbvum +eduzave (25) +kwbni (74) -> abxalr, bbsuv, gnrnwtz, rmjktk, eqcnl, pdwesa, sunvhgy +hhnvuv (83) +ismgnve (68) +alhjba (84) +mspkmg (94) +rszjhxn (34) +frleu (60) +mewfm (48) -> gowbiey, yevks +mpulnxr (42) -> eziuhsd, xsewlv, tckcxhb, bfxhl +mzksj (68) +shnqfh (1649) -> wnnov, mdtniv, fwpuy +bxpfop (153) +zucsr (26) +gmpqmio (93) +wzjbp (174) +zcicmp (301) +ppvwkei (93) -> eqjfyj, lghygm, grrycy +tcsoaw (239) -> kzfzp, oypzs +nnsial (78) +mazbb (98) -> dsxhhub, fqoqkzk +lclbeiq (81) -> bwxicc, uttjzap +jddyhz (91) -> vmmww, mvalh +umqrwk (132) -> itvhd, jbuxnpr, mxopf +qxfan (34) +cdafdq (26) +drrjnr (80) +kxrxtq (68) +cnyasj (56) +kpdbki (38) +dgzoyx (72) +zwwbw (155) -> eqbvn, qcghv, tfppg, xaanoft +zsxbg (22) +fwvsi (32) +hefgter (6) -> pirieql, hikocbe +mwelezd (81) +eptcqns (16) +jmbiky (96) +gnozwfo (242) -> vqsuh, cxlfgl +wtkfiw (48) -> owresw, grqjew, okbzzwd +ltqljtw (62) +lymwlyg (72) -> snkox, adhwzp, cvdjts +mgeizij (60) -> sbcuc, rqrfl +zghvta (57) +uqcqc (85) +tozwp (19) +nqjrds (81) +cfufhn (11) +yznhjg (60) -> choiui, yhecio, lprpgxe +qtbhnxr (27) +bwdfws (27) +kiuiq (89) +zjfrc (141) -> zghvta, lkqiqa +ooiyeep (80) +xiawjb (38) +wgzdt (216) -> vfrqc, frpmd +lugkrb (36) +mvalh (69) +cruxrmy (52) +azwmkej (33) +tqbvdu (61) +szvlte (21) +bzbmt (85) +gcczhgd (43) -> eecoekq, kwpnxyh +jxlgwb (24) -> pzahn, yadtxl +gfaamu (8) -> ygzwut, hhnvuv +ntjmwf (211) -> owqdo, umvvwsq +rqhrb (19) +jixggay (28) +gavjzk (91) +mbydswv (69) +unqbwiz (10) -> rixge, lkwapf, phvbwg +veycd (62) +lmctbp (106) -> wqyzjzi, gqjkk +jwpjy (94) -> ywlub, rtymngs +febjzqn (46461) -> mwtojre, iqmqju, dkxebg +yvdkbo (28) +iayzdx (7181) -> fakyd, fjwmd, uzicvdh +uobxonm (118) -> wrsik, wsrwgvc +sehxgj (41) -> wpezjoi, dcnuouj, vrpqev, kjwvqdz, vzkii +eziuhsd (192) +gcichoe (79) +jwzmsv (45) +fmapm (86) +rbtvx (53) +sgkksme (94) +zmces (86) +rmjpia (62) +feiki (376) -> oqady, fcymcb, wlleabp +sgrcmj (54) +dohjma (76) +kgzqclo (71) +eqjfyj (73) +zcjrk (1009) -> zdvlgn, sxada, yznhjg, pnoxhe +zhudrmb (78) -> mvngvtg, kvags +iylwxgn (98) -> edebwk, gjwflt, rlapq +beraoor (10) -> pumxr, gasnep, ulznkvm +gxnoomf (185) -> ihrhkj, cfufhn +fhoprd (71) +pbides (59) +xqgjvz (192) -> twpmx, zwofu +mexuge (52) +rbfbf (47) +oprvyxy (125) -> oyuteie, yibxqhs +eqcnl (637) -> kgjcj, wgzdt, rrgffal +kikfs (40) +ntvul (77) +bwxicc (22) +rttwea (55) -> fnjnhmk, kurgrkq +kfxyzqc (9) +ddmrgzp (69) +clgbo (45) +qoapjhr (173) +kkhfzgn (88) +njgrpbo (74) -> dgzoyx, rlywif +bwcyqb (85) +esrilo (47) +blutjw (717) -> fxcuah, efuqu, jwpjy +owimy (41) +oeeqrsd (62) +akoqk (16) +owqdo (10) +fwpuy (26) -> eqnpvwk, lbhxdbr, lqqkjjr, tlvpv +tzqzk (52) +gxobd (91) +npqroe (36) +pstaxvr (761) -> peretma, kqpvqie, untdpje +boggvxt (56) +uobxcai (10) +vmyda (63912) -> rcltx, ajwxaa, yvqasth +jznrci (51) -> mclgebd, emdsyso +ktgfsm (50) +kweqtf (96) +mtsbrje (66) +rjuhrpu (15) +zgnoqml (85) +qlthpj (57) -> arwqmho, yydyjr +cdudjbj (128) -> iofsrh, nuuwbui, mxplky +estwket (94) +adjlg (67) +jbwbw (114) -> dxbrl, lhdhko, fdjhpq +ezfky (71) +rrdczem (71) -> dgrfhvi, adjlg, ajyqxh +xqrmgdk (6543) -> unqbwiz, cxzuprb, rmkhel +nmkjx (213) -> wycesn, gpfipvk +qklota (16) +jbuxnpr (30) +xtzqooh (27) +vbcfe (49938) -> yuepckc, ybzvav, sxapjc, cfvlt, dluyef +drzrtpi (96) -> nuuqqqy, scqutwb +xkfps (7) +nvxlr (49) +hazbs (31) +ajyqxh (67) +guhyk (66) +ipwxws (190) -> difjqqd, wknic +akngdu (13) +evgtp (86) +eznabc (150) -> dvhbwl, xnuoisk +limjm (52) +bykjeka (71) -> sdied, zfzblty, csxwyly, fomxzjj +gpfipvk (7) +cpreh (86) +qurrva (85) +sikzsc (46) -> dpetvw, pridma +vokxlx (69) -> gadnfmt, nqjrds +scbycx (193) +qjghc (84) +ctpjjsh (964) -> thlbs, wgehfu, fetns +uzicvdh (42) -> altsh, xhhhix, calvq, bykjeka, iucuw +tpefei (109) -> qtznzyx, myznok +sizfqfs (116) -> vsqfx, dmsmgs +qumahjn (71) +ctagl (97) +hewtnrw (28) +ocpzltp (67) +ihnus (40) -> vrgxe, shnqfh, auzded, hkhsc, jwddn, mcxki, lhwyt +iuydxn (253) -> fhoaub, kmnjo +evubadn (49) +wpezjoi (112) -> zpxqtrg, tzqzk +qtznzyx (57) +dcnuouj (76) -> oegwh, ztzfled +ddpgq (97) +ktrkhe (67) +podcsx (71) +univhdj (26) +puxaz (60) +jadome (50) +uplbokf (5475) -> vbxqhoy, cpkkq, iqozz +llild (45) +lylaoh (170) -> lomhz, tzjzmmv, cefbp +owsosl (57) +iqozz (681) -> syykbn, mbmzme, cdudjbj +nvdon (345) -> dgzvf, djvps +iigqfh (327) +ctatrbo (279) -> tyiekxm, rmdhj +yevks (78) +cipxwb (85) +edmljb (134) -> ligev, glhsr +yallk (69) +owtxsq (71) -> zxjeza, pzgvsxu, amwxj +pejmc (151) -> fjvoff, esgqip +pridma (71) +vdpnsak (12) +hlfbt (200) -> univhdj, xnxdmdb +wyuwk (315) -> ibcbvy, ztaff +phvbwg (86) -> yachdf, utncpu, tohlady +nbnqidn (34) +tnyjkok (93) +kwpnxyh (41) +yachdf (84) +ximrxj (42) +appok (73) +rrgffal (78) -> trxgpy, zmjfa +uiyyc (126) -> nspsk, plxdglq +rcxtjte (210) -> drrvse, szvlte +ruild (9) -> zqdezgy, cxpoqyu +mqlsvih (17) +xgqzb (451) -> mgeizij, hefgter, ajtjnwp, ljhezx, pwwqvhw +gmdcbyg (214) -> mexuge, limjm +mxopf (30) +wnnov (170) +qgwcfll (95) +smtbsys (49) +jiyuw (40) +sunvhgy (218) -> fmlhgs, clmyzsu, zvcfznz, xrkca, jznrci +wycesn (7) +sbgwln (66) +dkffgot (50) +ximrdyg (217) -> tpbgp, ibmcytl +mvqfvit (38) +spgcwtn (63) -> yeref, itxaax, ntvul +apmpzd (46) +njkeu (67) -> vecxd, rpcoxd, emqoxss, elusirt, hlfbt, xqgjvz +irlfj (62) +zxoqwjv (76) +vjwlck (28) +ezmjqnt (146) -> wdssrl, gwcig +plzfjy (41) +beeeaye (71) +nqkwmyd (254) +hbiwkt (76) +hspol (20) +ntjawca (63) +yuobv (91) -> vtdpkof, basjwp, pfvpb +lqqkjjr (36) +zzqwzy (48) -> cnbzj, vftqnj, mywezi +goyzt (22) +apghde (44) +ahrdgu (23) -> ismgnve, rwheyic +vqiqglo (95) +ruclz (25) +wuqbe (98) +nedbkp (49) +fpmipcr (40) +gadnfmt (81) +kxrfley (55) +thlbs (59) -> iqsvbk, tbyihc +wqvtdc (126) -> uyjre, dvkrlzc +omfvqhv (29) -> iorlbdv, fwddmmv +lihivo (81) +ligev (60) +iabqb (12) +zwjqar (71) +ddsqd (61) +wwvad (23) -> owzybm, gavjzk, gxobd +plhybj (48) +rgyamx (79) +trxgpy (82) +vzxvex (66) +favzt (69) -> qxfan, pyyuj, lhahl +atrmuc (1081) -> qrsgca, bhthbfj +mqrfbqc (9769) -> vbqtd, ykuto, mgktiii, iylwxgn +ihkcni (66) +ttxrd (54) +dvhbwl (64) +nlhxju (31) +kjwvqdz (140) -> zocaag, gszqlv +gulset (80) +vubst (114) -> giupn, vckqsrm +pvejq (52) +lhahl (34) +rqoczb (310) -> ropzx, xdsbnr +xhhhix (259) +ictdnyf (1551) -> ezfky, ckxblyq +jexvtb (15) +fmlhgs (103) -> ntjawca, jwpwt +fcymcb (17) -> mwelezd, jaoiiae +cepddei (195) -> ppymmsf, mcdmpq, tozwp +suzsw (28) +dlnyi (59) +nzrfhb (198) -> xwpwer, vjwlck +kmnjo (35) +itvhd (30) +tpbgp (11) +syykbn (127) -> teastj, ntazqjk +vhilqk (86) +ctpdk (31) -> yzciq, ljlotlp +putpp (92) -> pbrdt, ihkcni, sxdljm +peydhei (737) -> dojvyuv, nnogow, lwygknn, ndajgou +yzciq (99) +xmfzu (83) +plzgfx (98) +qckem (28) +kuakyv (77) +qpixldb (85) +nnjbjm (23) -> cgwnn, veclzy, rzqffr +nrkdm (200) -> dgtvwiy, qtbhnxr +xwkski (59) +mgktiii (827) -> ggbxd, gjfoe, qoapjhr +elusirt (106) -> appok, avhkram +ttkboa (24) +ckxblyq (71) +disan (18) +owresw (73) +pyuuxw (39) +hwsrjah (176) -> pvejq, cruxrmy, vjwivnq +skbprng (44) +lkyeyn (14) +mdtniv (82) -> eexkce, oiiagw +ljhezx (130) -> jpxogsl, pjnyxo +upsiumf (18) +glgrdm (14) +rvcmif (288) -> jdmjou, ddmrgzp +wvsspk (25) -> lqnwffm, edgplu, qyzja +umljkr (45) +ggbxd (67) -> jikpfbk, siqksje +kuujprz (67) -> ctatrbo, xibdlh, wyuwk, siflauk, iigqfh, jhwltnv +aklagd (201) +lprpgxe (65) +auvxopo (42) +uorika (69) +avbgwvm (81) +nnogow (96) +iybvphk (85) +sxapjc (129) -> peydhei, sehxgj, lgtffok +utrdhz (75) +nbvwta (153) -> bbviexo, pzgvdt +jzgpty (44) +qqzhz (32) -> eyreht, xxswgx +ropzx (8) +xaanoft (42) -> cwgrjoh, uorika, uobwwa +ybnpc (307) -> dibqua, ozfsktz, txrxyqh +cfvlt (753) -> rusayd, feiki, ucsxzhl +ruxuw (43) +ywpjusg (64) -> joxmxc, mzksj +qtcqtv (59) +qwddgc (82) +eyckbl (58) +lgsda (44) -> lcazsyd, mwdfwe, nnsial +tlvpv (36) +rlqwaz (901) -> sizfqfs, ehynj, wzjbp, vubst +fgbnlu (66) +zvmhx (105) -> tcsoaw, rtnpvf, lbkvgme, xtttnfp +oiiagw (44) +jpxogsl (30) +lomhz (78) +calvq (85) -> ccghjn, lpascsz, zkecjv +ljlotlp (99) +jqqxv (59) +iqzdu (187) -> itygd, cdvmqs +ugkey (86) +tjjrys (94) +dtjhnzr (85) +tqeeva (214) -> xwkski, rkjmp +tznkdt (12) +daiah (26) +cwgrjoh (69) +dibqua (24) -> rgyamx, gcichoe +scqutwb (94) +yeifw (71) +dyhate (18) +acgrw (44) +fndpz (18) +pynomi (170) -> kgzqclo, ygvkw +kcyiwqs (35) -> givljl, yntnjp +lbkvgme (223) -> jadome, dtwbpl, ktgfsm +ygvkw (71) +dgsutv (25) +rlywif (72) +nevpm (49) +xtttnfp (73) -> heumdl, axgpyq, utrdhz, paeea +ptmqo (284) +ibmcytl (11) +ejwno (80) +mcdmpq (19) +azvke (170) -> wscktm, jexvtb +govhrck (176) -> vuqriq, crfse, eoditdi +tzjzmmv (78) +dhjrv (48) +dlifqat (49) +ruhqn (94) +mhtzh (86) +bhhgpe (124) -> bywwy, xguqlvl +ucicsdu (199) -> itvizjy, wsnqied +agwyte (498) -> gcczhgd, lclbeiq, rgndu +gapjnb (200) +pitmcu (27) +vtdpkof (44) +joxmxc (68) +mclgebd (89) +refgrip (35) +hsxru (30) -> oeeqrsd, icdlpb, veycd, dlrpnot +jikpfbk (53) +usztpox (160) -> goyzt, eagggd +aqhcy (57) +umhcrc (174) +qwvvha (45) +crxnz (10) +mbmzme (37) -> qajpehv, dlifqat, bponwxc, hjzehyw +uyjre (22) +tsbbzu (22) +tenzzu (67) +ijvuozb (38) +oypzs (67) +ymxlwf (327) -> nzrfhb, wbogdd, fujgzbt, nqkwmyd, vgugdtt +dvgstr (87) -> rqhrb, xtvawvt, receu +yzuygum (57) -> oiysq, jibdphs +vuqriq (238) +lsysd (68) +meayff (35) +guztl (73) -> mrbqk, aoxtau +rtnpvf (177) -> pwsye, nevpm, nvxlr, smtbsys +zbqpk (112) -> apmpzd, yueoma +bbviexo (37) +gimkyms (21) +fjwmd (692) -> luayjsp, njqzaxg, ywgvsdb +igfhu (31) +qkhhg (105) -> yknwap, qqqsv +ybewhak (122) +xkizl (18) +siqksje (53) +vtbzq (178) -> tenzzu, ocpzltp +giblwzi (7) +atjtgjx (59) +bjlwfmo (49) +jibdphs (64) +cxlfgl (92) +wltlu (1495) -> swumt, qeosq, guhyk +lkqiqa (57) +qwlepd (44) +rmvry (145) -> ejzfwt, pknjpc, qfhkgt +xmpdevf (185) -> rjmdre, abcyotz +utwzg (10) +lpascsz (58) +abcyotz (21) +grqjew (73) +vindom (25) +tzmes (28) +ktwby (44) +gfsnsdu (38) +ywlub (66) +iryrfjs (31) +fwfpmti (34) +givljl (68) +edebwk (161) -> dtjhnzr, cipxwb, uqcqc +aziwd (48) +ajtjnwp (46) -> clfrs, qdwkxia +nvlqab (27) +dvwsrc (1517) -> jiyuw, dvtdje +basjwp (44) +rhchuf (67) -> sedysm, nedbkp +cdvmqs (57) +dkdovw (262) -> afglbpz, ovfduq +seeqikh (10944) -> mztuzb, zovbvcr, nnjbjm +bgcrdqu (174) +huqpiix (121) -> eptcqns, aiget +bywwy (74) +aujxmm (89) +xecqd (12) +tbppaj (94) +zkecjv (58) +utncpu (84) +grrycy (73) +htlpx (25) +pvtat (13) +dfdlzzt (71) +uwaij (16) +edgplu (94) +aflmt (153) -> puyiail, jaiqusy +eoditdi (10) -> boqtohm, odsrv, iblrer +imshim (39) +nioeugr (38) +eagggd (22) +ulznkvm (211) -> meayff, oqiye +psrzr (213) -> bwdfws, sdrhiyo +vmmww (69) +blofdav (18) +zbfyg (49) -> xoqxrbl, dgnpr +qzhyumq (25) +dpcmm (69) +qvmorke (57) +exuwhfs (89) -> qumahjn, kkvkz +rdqvi (56) +axlgwj (38) +vbxqhoy (744) -> nquonb, zhudrmb, ryxkvxj +rqlaf (67) +mlrdsj (107) -> tzdtm, etmvojh +tnzqj (1057) -> nbpic, ctgbkrb, bgcrdqu +lghygm (73) +wvjjht (60) +wmvht (36) +xibdlh (255) -> tgjdwlh, vyffcrm, ahridq +pjersb (86) +pdwesa (407) -> ximrdyg, xaebyo, qqpsrts, ucicsdu +tflulu (3299) -> ezcmm, tnzqj, njkeu, ctpjjsh +rmkhel (55) -> olkcm, yquqk, iuydxn +odsrv (76) +kfbsjv (73) -> ylxxmlt, whqvs, edmljb, bpptuqh, jwjggy, nrkdm +vywqra (18) +bnehbkl (14) +lkwapf (290) -> ttkboa, xvcikqe +kawloxz (45) -> rttwea, nmfvmam, kwkprrw, gxnoomf +drrvse (21) +tklfj (465) -> fcapw, omfvqhv, wgwlbz +receu (19) +zqdezgy (72) +ntkeax (91) -> sbgwln, fgbnlu +boqtohm (76) +rpcoxd (252) +hiqqg (82) +cdyhvr (28) +snkox (67) -> mspkmg, lxzucvk, zsqqhe, sgkksme +zpxqtrg (52) +olgsb (93) +hikocbe (92) +xwpwer (28) +kzfzp (67) +dfyyjta (33822) -> hvhjh, ujfeg, iayzdx +hvhjh (6551) -> uveybq, iqbrs, zrnnyet +kjpzwp (160) -> fmvyjwj, lsysd +htyyatf (240) -> fndpz, xtoaq, hhboca, llsvd +uveybq (947) -> ywpjusg, gapjnb, azvke +cqbvru (61) +saqjax (45) +emlqbo (18) +jvayv (171) -> daiah, fyjowg +dtnaqds (33) +rxuwet (92) +xnuoisk (64) +etmvojh (80) +eqnpvwk (36) +puyiail (18) +ijrzzr (77) +jfuxeo (150) -> xgnqi, dfzfwun +pzgvsxu (282) -> cltqhc, ruclz, vindom +tqpgc (1018) -> bbxbrsh, uwxbv, nlhxju, hazbs +nadbbgx (258) -> akoqk, izwze +qdwkxia (72) +rbqcbvl (88) +wutdi (38) +mlrjfy (38) +efxakc (154) -> dfaro, lcsqgx +dacbtyf (57) +mevea (303) -> qaxvec, esiwujq, plzfjy +dsxhhub (12) +wjzyxt (252) +pnoxhe (27) -> vjqjwk, enpprra, ftmwqqj +kkvkz (71) +clfrs (72) +zovbvcr (383) -> diyvlug, xhodnx, repak, zjfrc +jwjggy (210) -> duvrzrl, zsxbg +xjfkrjs (33) -> ibzalz, rxuwet +gtvnow (180) -> euvev, kvbdsv +etfuhz (123) -> zoicqbj, ajvtdl, wmvht +afglbpz (16) +nquonb (50) -> avbgwvm, lihivo +nbpic (148) -> iuoxs, yxvgj +eivrwbt (17) -> yeifw, podcsx, fhoprd, beeeaye +gszqlv (38) +yhycc (121) -> vwkbje, qzhyumq +gjzddf (38) +cxpoqyu (72) +emdsyso (89) +qqpsrts (85) -> doudbv, mmzdk +gjwuf (124) -> bjlwfmo, evubadn +hkhsc (171) -> ipwxws, yrdgv, ckswvj, yjlrwzu, ptmqo, ojishwt, drzrtpi +mwtojre (207) -> hmetm, utbev, wltlu, ictdnyf +fqoqkzk (12) +nkhzrd (5) +enpprra (76) +gwcig (75) +uqcpah (91) +koued (75) -> kxrfley, tjnyo +dtxrjg (22) +pnkag (93) -> ofoto, zzqwzy, zobjfxe, blutjw, aisfhs, gmoliax +iucuw (99) -> gulset, drrjnr +fhsecp (17) +dgrwv (62) +ibzalz (92) +tbyihc (73) +cleanrs (10) +cibfe (27) +ycvvjgc (28) +dnphyfm (7185) -> mpulnxr, sxegjbz, tklfj +xnxdmdb (26) +jniisu (34) +eaqiocy (93) -> dywjt, kikfs, fpmipcr +bugtxto (26) +pprkvq (26) +myznok (57) +iblrer (76) +bhmzx (64) -> tgoeoh, ojxyv +yibxqhs (52) +xoqxrbl (93) +hoeqoas (99) +oxvfpna (222) +okbzzwd (73) +yhecio (65) +esgqip (62) +zwofu (30) +nnyqes (49) +yydyjr (66) +ztzfled (70) +yvqasth (1018) -> lfksu, xszci +eqbvn (153) -> plhybj, kozgi +hqmum (79) -> dfdlzzt, ulndqey, zwjqar, jhxxfq +gvayfu (64) -> cfvbuip, rbtvx +fsagr (141) -> lugkrb, npqroe +pfvpb (44) +cvdjts (271) -> zmces, ugkey +bcjpzpk (174) +jxykl (54) +mwdfwe (78) +diyvlug (133) -> ddsqd, txeucf +wbeizj (35) +xxswgx (45) +wfdxfxq (676) -> irrpz, wvsspk, dqtthnn +lcsqgx (8) +lmvmb (93) +cyvplfd (14) +olkcm (131) -> mkdiuil, msbsjpj +kloumi (39) +xzwjii (63) +zmjfa (82) +fakyd (842) -> sgtfap, frbmr, rhchuf +jgzvrf (173) -> hspol, vbpde +slfile (66) +jwpwt (63) +xhodnx (67) -> estwket, tjjrys +ihrhkj (11) +wlkatbq (188) +cijfsu (68) +ipqjff (62) +ztaff (6) +eecoekq (41) +oaxskk (266) -> azwmkej, rciilr +sedysm (49) +jhwltnv (19) -> akluijb, zvtxa, pvpmt, bkqexxz +xhqgsro (6) +bmdxyf (318) -> zgslahq, koued, yzuygum +dmyzfr (18) +rqrfl (65) +clmyzsu (115) -> mlrjfy, xiawjb, kroqr +rusayd (901) -> ylkfgx, lxsurts +tzdtm (80) +dpetvw (71) +eccwi (6) +wdssrl (75) +uofigyp (9) +aisfhs (183) -> lylaoh, fujwzoc, kobcmy +dcgarog (15) +eosuf (69) +qeosq (66) +itxaax (77) +mmzdk (77) +dvtdje (40) +aumbaa (28) +wdivd (26) +eemfgbx (17) +dlrpnot (62) +ugxls (62) +qqqsv (98) +lfhaqdn (27) +qblnh (45) +yknwap (98) +ipogzy (76) +irhxzg (124) -> utwzg, crxnz +dtwbpl (50) +lqnwffm (94) +ygnww (13) +xrkca (217) -> xhqgsro, avymjz +qrsgca (35) +ftgvx (14) +fhoaub (35) +nuuqqqy (94) +ppmvpn (94) +kisjb (57) +owzybm (91) +jwddn (134) -> vfosh, nvdon, kopmae, inhqoxd, xlyvge +cnbzj (141) -> kuakyv, vnsrv, ijrzzr, dbrnqc +wlleabp (179) +lhdhko (66) +bbsuv (439) -> ionnpk, etfuhz, mobbhp, exuwhfs +umvvwsq (10) +eibtll (94) +otuwt (35) -> ejwno, zogylog, ooiyeep +epqsj (137) -> bugtxto, hsnbry +yuepckc (66) -> tqpgc, pstaxvr, owtxsq +dhzuvup (76) +crfse (238) +ibcbvy (6) +cefbp (78) +uhxjy (63) +bponwxc (49) +mcxki (29) -> rvcmif, gnozwfo, mevea, vtvku, dmtzxui +emqoxss (66) -> tnyjkok, gmpqmio +ionnpk (97) -> rqlaf, ktrkhe +gasnep (91) -> qgwcfll, nkcet +avymjz (6) +fetns (37) -> zfmeblt, jtsyj, rdqvi +altsh (89) -> zdvai, iybvphk +kgjcj (242) +bltmlm (93) -> xdlvys, tflulu, xqrmgdk, dnphyfm, kwbni, uplbokf, vbsfwqh +hikik (15) +nnofr (71) -> xxrsnzv, pucsbv, rtzce, kloumi +siflauk (271) -> qckem, tzmes +nkcet (95) +ijjfn (34) +itvizjy (20) +numadl (98) +jkjsi (98) +xaebyo (41) -> svadhfo, hoeqoas +yntnjp (68) +axgpyq (75) +civozek (98) +djizg (33) +qrtdtt (96) +kopmae (13) -> pemna, vuzsg, numadl, wuqbe +yztqpc (572) -> xxsivgz, scbycx, jwezuh +msbsjpj (96) +yjlrwzu (77) -> mbydswv, tfzum, kwhwph +tcpqh (15) +fkqkfdu (25) +vbqtd (86) -> cepddei, rcxtjte, zkibug, wjzyxt, zhgzg +wmcusr (14) +zrnnyet (731) -> zbqpk, tayyz, usztpox, mewfm +yadtxl (73) +eqctwan (511) -> zitfb, xjfkrjs, xddom +evmuxia (32) +lbhxdbr (36) +fjvoff (62) +wsnqied (20) +vftqnj (57) -> dvopaww, hbvvse, plzgfx, jkjsi +pwwqvhw (34) -> fgnsyw, pyuuxw, nsbvvsi, imshim +hnjbsg (32) +pglpu (224) -> oxvfpna, umqrwk, bhmzx +etcces (4977) -> eqctwan, jncex, zofljd +fmvyjwj (68) +lgtffok (509) -> ruild, bxpfop, huqpiix, tgksxw +iqmqju (3619) -> oxnfnsv, bngres, zkhll +xvcikqe (24) +wvpwez (89) +saijc (96) +aiget (16) +fdjhpq (66) +adcbil (47) +lrnjjfq (17) +teastj (53) +csybv (33546) -> kdtpg, wseyo, etcces, pnkag +zkibug (238) -> xkfps, giblwzi +pzahn (73) +auzded (499) -> tqeeva, fyrqw, oaxskk, hwsrjah, jfqanu +bhthbfj (35) +dvkrlzc (22) +dgrfhvi (67) +qcghv (67) -> ezkqh, uqcpah +sdrhiyo (27) +kwhwph (69) +ejzfwt (52) +vuzsg (98) +tgoeoh (79) +vrpqev (64) -> axlgwj, gfsnsdu, kpdbki, mvqfvit +vrydu (43) +vnsrv (77) +gjfoe (161) -> mcduoz, eccwi +ppgaoz (65) -> pejmc, cbwbdsv, otuwt +xddom (39) -> aujxmm, fjrpc +lxsurts (6) +tayyz (50) -> vtzdfjg, ijvux +kwzrzn (71) +doudbv (77) +ahridq (24) +dqtthnn (217) -> hgsng, jwzmsv +haeymgy (85) +zoicqbj (36) +bcjxhps (58) +swumt (66) +iywwyn (43) +pirieql (92) +ntazqjk (53) +ajwxaa (208) -> wtvffu, gmdcbyg, intuzzk +wscktm (15) +itygd (57) +hjzehyw (49) +jdmjou (69) +iavuhwe (49) +tpfuxx (26) +wseyo (5904) -> beraoor, zbhwrc, ybnpc +rlapq (322) -> adcbil, rbfbf +jtsyj (56) +zouml (199) -> dmyzfr, udjcwm +txrxyqh (107) -> rdufpid, yhunajf, dgsutv +zobjfxe (525) -> ylbpwah, nadbbgx, putpp +inhqoxd (327) -> cdafdq, zucsr, pprkvq +ndajgou (96) +paeea (75) +yrdgv (284) +sbcuc (65) +aklrjg (10) +kbjnzw (117) -> xtzqooh, lfhaqdn +cfafhwl (34) +htyeqf (94) +dmiqf (62) +tghoyv (210) -> iywwyn, gypsfc +plxdglq (24) +qxwlhxh (41) +pknjpc (52) +njqzaxg (23) -> saijc, jmbiky +tckcxhb (68) -> yfzjc, nwjibjk, igfhu, iryrfjs +xdlvys (3528) -> zcjrk, wkrtcw, kuujprz +dcngdo (47) +pazbvum (57) +kvags (67) +nuuwbui (35) +whcxfwf (115) -> vrydu, ruxuw +ojishwt (126) -> llcbiqi, namzy +uwxbv (31) +vrqeade (102) -> emlqbo, vywqra, upsiumf, blofdav +rixge (338) +dmtzxui (98) -> auhio, qwddgc, hiqqg, iezdimc +texfyi (144) +cgwnn (384) -> nioeugr, gjzddf +mwzaxaj (59) -> csybv, febjzqn, bltmlm, dfyyjta, ljaktj, vmyda, vbcfe +yquqk (83) -> wvjjht, edyqn, frleu, puxaz +jaoiiae (81) +pucsbv (39) diff --git a/07/lib.scm b/07/lib.scm new file mode 100644 index 0000000..52847a0 --- /dev/null +++ b/07/lib.scm @@ -0,0 +1,192 @@ +(library (lib) + (export solve-part1 solve-part2) + (import (chezscheme)) + + ; Split list at first delimiter into `prefix' and `suffix' + ; Return value is a pair like `((p r e f i x) s u f f i x)' + (define (list-split-left delimiter? xs) + (let loop ((prefix '()) + (suffix xs)) + (if (null? suffix) + (cons prefix suffix) + (let ((x (car suffix))) + (if (delimiter? x) + ; Found first delimiter, so return immediately + (cons prefix (cdr suffix)) + ; `x' isn't a delimiter, so append it to `prefix' + (loop (append prefix (list x)) (cdr suffix))))))) + + ; Split list at given delimiter into list of sublists + (define (list-split delimiter? xs) + (let loop ((pieces '()) + (rest xs)) + (if (null? rest) + ; Fix order and remove all empty sublists from output + ; (which are caused by consecutive delimiters in `xs') + (reverse (remp null? pieces)) + ; Extract next piece from `rest' and prepend it to `pieces' + (let ((next (list-split-left delimiter? rest))) + (loop (cons (car next) pieces) (cdr next)))))) + + ; Split string at whitespace into list of words + (define (string-split str) + (map list->string (list-split char-whitespace? (string->list str)))) + + ; Remove the first character from `str' + (define (string-strip-first str) + (substring str 1 (string-length str))) + + ; Remove the last character from `str' + (define (string-strip-last str) + (substring str 0 (- (string-length str) 1))) + + ; Strip the parenthesis on each side and parse the number + (define (parse-weight str) + (string->number (string-strip-first (string-strip-last str)))) + + ; Parse the current node's optional children into a list of names + (define (parse-children words) + (let loop ((input words) + (output '())) + (cond + ; If there are no children, or we've exhausted the input list + ((= (length input) 0) + output) + ; If this is is the last child, we can read its name directly + ((= (length input) 1) + (loop (cdr input) (cons (car input) output))) + ; The input contains multiple words, possibly including "->" + (else + (if (string=? "->" (car input)) + ; Ignore the first "->" + (loop (cdr input) output) + ; This isn't the last child, so must strip comma from name + (loop + (cdr input) + (cons (string-strip-last (car input)) output))))))) + + ; Record type representing a single tree node. Implicitly defines + ; `make-tree-node', `tree-node-children', and `tree-node-weight'. + (define-record-type tree-node + (fields + (immutable weight) + (immutable children))) + + ; Parse each line of the input into a `(name . tree-node)' pair + (define (parse lines) + (let loop ((input lines) + (output '())) + (if (null? input) + output + (let ((words (string-split (car input)))) + (let ((name (car words)) + (weight (parse-weight (cadr words))) + (children (parse-children (cddr words)))) + (loop + (cdr input) + (cons + (cons name (make-tree-node weight children)) + output))))))) + + ; Given a node name, find its parent according to `tree' + (define (find-parent name tree) + (let loop ((candidates tree)) + (if (null? candidates) + #f + (if (find + (lambda (child-name) (string=? name child-name)) + (tree-node-children (cdar candidates))) + (caar candidates) + (loop (cdr candidates)))))) + + ; Find the root node name of the tree stored in `tree' + (define (find-root tree) + (let loop ((name (caar tree))) + (let ((parent-name (find-parent name tree))) + (if (not parent-name) + name + (loop parent-name))))) + + ; Return the `(name . weight)' pair for the `name' + ; that has the lowest `weight' in `child-weights'. + (define (find-lightest child-weights) + (define target-weight (apply min (map cdr child-weights))) + (find (lambda (cw) (= (cdr cw) target-weight)) child-weights)) + + ; Return the `(name . weight)' pair for the `name' + ; that has the highest `weight' in `child-weights'. + (define (find-heaviest child-weights) + (define target-weight (apply max (map cdr child-weights))) + (find (lambda (cw) (= (cdr cw) target-weight)) child-weights)) + + ; Count how many times `needle' occurs in `haystack' + (define (count needle haystack) + (length (filter (lambda (h) (equal? h needle)) haystack))) + + ; For `child-weights', i.e. a list of `(name . total-weight)' pairs + ; for several nodes with a common parent, we find the "bad" child + ; whose `total-weight' differs from the others. If there are only + ; two children, this can't be decided; then `known-error' tells us + ; whether the "bad" child is lighter or heavier than a "good" one. + ; `known-error' is the bad-good weight difference, calculated by + ; the caller at a time when there were more than two children. + (define (odd-one-out child-weights known-error) + (let ((lightest (find-lightest child-weights)) + (heaviest (find-heaviest child-weights))) + (if (equal? lightest heaviest) + ; If all children have the same weight, the parent must be bad + #f + (if known-error + ; If we already know that the bad node is too light, + ; always pick the lightest child, and vice versa. + (if (< known-error 0) + lightest + heaviest) + ; If we don't know yet whether the bad node is too light or heavy, + ; pray that `(length child-weights)' > 2 and pick the rarest weight. + (if (< (count (cdr lightest) (map cdr child-weights)) + (count (cdr heaviest) (map cdr child-weights))) + lightest + heaviest))))) + + ; Add up the weight of `name' and all of its descendants + (define (subtree-weight name tree) + (define node (cdr (assoc name tree))) + (let loop ((children (tree-node-children node)) + (total (tree-node-weight node))) + (if (null? children) + total + (loop + (cdr children) + (+ total (subtree-weight (car children) tree)))))) + + ; Given `name', create a list of `(child-name . total-weight)' pairs + (define (filter-child-weights name tree) + (map + (lambda (child-name) + (cons child-name (subtree-weight child-name tree))) + (tree-node-children (cdr (assoc name tree))))) + + (define (solve-part1 lines) + (define tree (parse lines)) + (find-root tree)) + + (define (solve-part2 lines) + (define tree (parse lines)) + (define root (find-root tree)) + ; Traverse the tree until we find the "bad" node with the wrong weight + (let loop ((subtree-root root) + (weight-error #f)) + ; Figure out which branch of `subtree-root' contains the bad node + (let* ((child-weights (filter-child-weights subtree-root tree)) + (wrong-subtree (odd-one-out child-weights weight-error)) + (right-subtree (car (remove wrong-subtree child-weights)))) + (if (not wrong-subtree) + ; If we can't find the bad branch, `subtree-root' itself is bad + (- (tree-node-weight (cdr (assoc subtree-root tree))) weight-error) + ; Recurse into the bad branch (N.B. `weight-error' doesn't change) + (loop + (car wrong-subtree) + (- (cdr wrong-subtree) (cdr right-subtree))))))) + +) diff --git a/07/main.scm b/07/main.scm new file mode 100644 index 0000000..d639aed --- /dev/null +++ b/07/main.scm @@ -0,0 +1,20 @@ +(import (chezscheme)) + +; Where the magic happens +(import (lib)) + +; Read my personal puzzle input +(define input + (call-with-input-file "input.txt" + (lambda (port) + (let loop ((line (get-line port)) + (result '())) + (if (eof-object? line) + (reverse result) + (loop (get-line port) (cons line result))))))) + +; Part 1 gives "mwzaxaj" for me +(printf "Part 1 solution: ~a\n" (solve-part1 input)) + +; Part 2 gives 1219 for me +(printf "Part 2 solution: ~a\n" (solve-part2 input)) diff --git a/07/test.scm b/07/test.scm new file mode 100644 index 0000000..ed299f8 --- /dev/null +++ b/07/test.scm @@ -0,0 +1,43 @@ +(import (chezscheme)) + +; Where the magic happens +(import (lib)) + +; My quick-and-dirty unit testing framework (copied for each day) +(define (run-test name proc input expected) + (let ((result (proc input))) + (if (equal? result expected) + (printf "\x1b;[32;1mPASS\x1b;[0m: ~a\n" + name) + (printf "\x1b;[31;1mFAIL\x1b;[0m: ~a: got ~a, expected ~a\n" + name result expected)))) + +(define input '("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)")) + +(printf "Part 1 tests:\n") + +(define (test-part1 name input expected) + (run-test name solve-part1 input expected)) + +(test-part1 "part 1 example 1" + input "tknk") + +(printf "Part 2 tests:\n") + +(define (test-part2 name input expected) + (run-test name solve-part2 input expected)) + +(test-part2 "part 2 example 1" + input 60) diff --git a/08/input.txt b/08/input.txt new file mode 100644 index 0000000..767fcba --- /dev/null +++ b/08/input.txt @@ -0,0 +1,1000 @@ +n dec 271 if az < 3 +f inc -978 if nm <= 9 +g inc -336 if ga < 2 +egk dec 437 if y < 5 +z dec -550 if g == -336 +mx dec 12 if bqr == 0 +mx dec 433 if ns == 0 +ic inc 506 if g <= -327 +ga dec -560 if ic != 506 +bqr dec 570 if az >= -9 +g dec 372 if egk != -429 +f dec -863 if b >= -9 +gyc inc 844 if av >= 7 +cr inc -781 if mx >= -453 +ga dec 346 if cr == -781 +b inc -162 if z < 554 +nno inc 504 if g <= -700 +mx dec -32 if vkg <= 6 +mx dec -961 if nno < 509 +az dec 320 if ic < 510 +nm dec 594 if ga != -354 +cr inc -784 if az <= -311 +bqr inc -321 if mx > 547 +y inc -951 if egk > -438 +y inc 703 if y <= -950 +vkg inc -852 if g > -716 +n dec -596 if az < -316 +n dec 410 if e <= 4 +f inc -693 if ic <= 510 +egk dec 498 if zqo != 7 +rn inc 626 if u == 0 +bqr dec -770 if bqr > -898 +n dec 193 if ic == 506 +egk inc -263 if e == 0 +cr dec -473 if mx <= 554 +vkg inc 667 if e != 10 +ga dec 793 if v <= 5 +f dec -673 if v != 0 +g inc 797 if g >= -708 +n inc 361 if v == 0 +y inc 399 if zqo == 0 +av dec -894 if zqo == 0 +az dec 785 if z <= 559 +y inc -121 if nm < -593 +v inc 873 if vkg > -189 +ns inc -205 if n >= 80 +cr dec 452 if ns != -202 +nm dec -35 if f < -799 +ic inc 790 if zqo > 3 +gyc dec 456 if nm <= -565 +rn inc 198 if y != 32 +y dec -917 if f == -806 +e dec -694 if zqo != 7 +nno inc 676 if rn < 825 +u inc 414 if ns >= -213 +f dec -405 if bqr <= -113 +g dec 456 if ga > -1145 +by inc 613 if nno != 1185 +n dec 414 if ga >= -1131 +ga dec 844 if u <= 418 +av dec -404 if ga >= -1974 +g dec -171 if ns > -208 +av dec -302 if f == -403 +ic inc -935 if y >= 30 +u inc -807 if bqr > -126 +az inc -536 if v >= 865 +vkg dec -77 if vkg == -185 +n dec 209 if n == 83 +u inc -92 if y >= 26 +ic dec 43 if u != -491 +ic inc 701 if z == 550 +bqr inc -473 if e != 699 +av dec -44 if egk != -1198 +e dec 134 if ga == -1974 +v dec 479 if mx <= 544 +n inc -748 if y >= 21 +bqr inc 726 if u >= -492 +z dec -368 if ns == -205 +y inc -296 if e >= 694 +f inc 271 if nno >= 1177 +y dec -881 if cr < -1535 +nno inc -493 if az > -1649 +z dec -434 if v != 882 +bqr inc 783 if e <= 694 +gyc inc 930 if gyc != -1 +nm dec -712 if e < 696 +mx inc -342 if nno > 685 +av inc -292 if gyc > 927 +rn inc -269 if rn <= 831 +vkg dec -799 if nno == 687 +v inc 31 if vkg < 694 +egk dec -227 if v != 913 +ga inc -248 if u == -485 +ga dec -655 if ic >= 228 +nm inc 335 if by != 613 +av inc 251 if u >= -477 +bqr inc 834 if ns >= -209 +gyc dec -580 if rn > 549 +u dec 390 if e < 701 +cr inc -936 if b > -170 +nm dec -60 if g < -188 +ic inc -226 if by < 615 +y dec -698 if zqo != 0 +vkg inc -938 if av == 904 +vkg inc -131 if zqo == 0 +y inc -792 if zqo < -3 +gyc dec -43 if ns < -211 +ga dec 783 if az <= -1637 +az inc -359 if cr <= -2479 +e inc -117 if v != 908 +rn inc 231 if av < 898 +nno inc -594 if z != 1354 +egk inc -119 if b >= -170 +mx dec 866 if mx != 214 +g inc -688 if mx < -655 +ga inc 451 if z <= 1352 +bqr inc 315 if g != -876 +vkg dec -636 if egk != -1090 +bqr inc -395 if by < 610 +mx inc 914 if ga < -1908 +by dec -623 if egk > -1090 +ns dec 219 if vkg >= -380 +egk dec -976 if av >= 896 +egk dec -681 if ic != -1 +vkg inc 971 if nno < 101 +nno dec 490 if bqr > 2060 +u inc 479 if z <= 1358 +z dec -552 if nno < -389 +y inc 696 if nno <= -405 +nm dec 876 if nno >= -399 +f dec 197 if nm > -670 +f inc 584 if e <= 575 +av dec -548 if y <= 616 +cr dec -975 if mx >= -664 +vkg dec -532 if egk > 567 +cr inc 115 if zqo <= 2 +e inc 315 if nm <= -663 +e inc -850 if ns > -430 +vkg inc -72 if z < 1906 +b inc 7 if y != 618 +cr dec -270 if by < 613 +v inc 505 if ns > -430 +ga dec 51 if nm != -670 +z dec -657 if zqo <= 1 +u inc -777 if nm == -663 +y dec -37 if nno < -396 +gyc inc 62 if f < -322 +z inc -565 if az > -1996 +e dec -223 if vkg <= 516 +nno inc 481 if e == 34 +rn inc 316 if nno >= -406 +e dec 531 if ns <= -423 +vkg inc -940 if v >= 1408 +by inc 935 if b <= -152 +rn inc 254 if ns < -416 +gyc dec 822 if zqo > -6 +n inc 334 if b < -155 +by inc 987 if nno == -397 +gyc dec -701 if ic >= -6 +nno inc -764 if z <= 2568 +nno inc -541 if mx == -660 +ns dec -327 if ns != -424 +z inc -328 if bqr == 2064 +cr inc 550 if cr != -1385 +ga dec -441 if rn <= 1123 +gyc inc -461 if zqo == 0 +egk dec 554 if ic < -6 +av inc 300 if zqo == 0 +nno dec 324 if av <= 1754 +y dec 235 if b > -165 +rn inc -1 if v < 1415 +b dec 230 if y > 413 +mx inc -836 if b <= -384 +av dec 464 if zqo != -7 +rn inc 208 if egk >= 563 +e dec 385 if v >= 1413 +g dec -443 if z < 2240 +v dec 296 if nno < -2027 +nm dec 394 if az != -1992 +u dec 609 if nno == -2026 +nno dec -178 if ns > -428 +f dec -340 if z >= 2231 +e dec 124 if u > -1783 +bqr dec -221 if bqr == 2064 +rn dec -427 if by != 2539 +n dec -242 if cr == -840 +az dec 267 if y < 418 +by inc 737 if cr <= -833 +rn inc -938 if ic >= 1 +az inc 181 if zqo >= -6 +f inc -874 if z >= 2233 +cr inc -867 if vkg <= -414 +mx inc 424 if ic >= -6 +f inc -125 if g <= -435 +az inc 30 if n < -625 +av inc -575 if y < 418 +ga dec -726 if ns <= -418 +u dec 1000 if b >= -393 +ns inc -88 if av < 720 +ns inc -80 if f < -983 +z dec 73 if e != -613 +bqr dec 350 if nm > -1065 +az inc 247 if gyc > 980 +v dec -156 if g != -435 +mx inc 32 if f > -996 +b dec 349 if mx < -1032 +mx dec -934 if nm != -1067 +ga inc -502 if egk < 573 +gyc inc -106 if nm == -1057 +ga inc 669 if mx != -102 +nno dec -335 if g >= -438 +g dec -757 if v != 1566 +cr dec -887 if z == 2233 +rn dec -768 if by < 3280 +bqr dec -289 if gyc < 890 +u inc 817 if by > 3265 +nm dec -136 if by <= 3270 +b dec 192 if y == 417 +f inc -787 if b <= -929 +f dec 188 if f == -988 +cr inc -488 if nno != -1846 +nno inc -116 if az > -1807 +cr inc 899 if by < 3278 +nno dec -454 if b >= -928 +f dec 237 if cr != -409 +e inc -910 if b != -926 +zqo dec -710 if egk > 564 +v dec 651 if cr != -407 +z inc 45 if ic < 10 +rn inc -16 if n > -633 +u dec -433 if n != -636 +z inc -55 if vkg >= -425 +y inc 536 if v <= 916 +nm dec 269 if cr == -409 +vkg inc -811 if gyc > 875 +y inc -269 if rn <= 1576 +rn inc -445 if av >= 709 +av inc -131 if ic != 1 +egk dec -35 if y <= 687 +mx dec -947 if nm == -1326 +bqr inc -296 if nno >= -1399 +vkg inc -176 if az == -1809 +z inc -7 if ga <= -1058 +v dec -105 if v != 908 +by dec -935 if g > 315 +y dec -674 if rn <= 1132 +ga dec -482 if v <= 1026 +nm dec 500 if f >= -1176 +by dec 653 if f < -1177 +cr dec 156 if mx == 841 +ns inc 446 if u > -1535 +e inc 256 if mx < 840 +av dec -883 if nm == -1826 +gyc inc 204 if by < 4198 +g dec 158 if av > 1456 +z dec -314 if av <= 1466 +egk inc -367 if cr > -568 +by dec -847 if f <= -1171 +f dec -361 if z < 2532 +z dec 647 if ns == -146 +z inc -416 if z <= 1892 +e dec 138 if cr <= -571 +ic inc -393 if gyc < 891 +zqo dec 338 if e < -605 +zqo dec -644 if ic == -390 +ns inc -790 if b != -917 +az dec 136 if av == 1465 +nm inc 971 if gyc != 884 +av inc 171 if ic != -390 +u inc -715 if zqo <= 1024 +av inc 27 if zqo != 1021 +n inc 845 if zqo < 1023 +cr inc -576 if v == 1019 +y inc 456 if ga >= -583 +mx dec 843 if f > -823 +v dec -589 if ns != -926 +e dec -797 if nno > -1395 +g dec 828 if bqr >= 1925 +vkg inc 176 if az > -1949 +nno inc 261 if zqo < 1017 +f inc -429 if b == -926 +f dec 658 if mx == -2 +e dec -221 if gyc < 890 +y dec 362 if v < 1605 +rn inc 849 if v != 1610 +b inc -650 if y <= 1363 +ic inc 39 if g != -668 +by dec -365 if u > -2248 +nm dec 779 if u == -2247 +nm inc -482 if cr <= -1137 +ns dec -873 if nm == -3087 +e dec -993 if rn <= 1979 +vkg dec 291 if n <= 220 +nno inc 937 if nno > -1139 +bqr inc -321 if b <= -1570 +av inc 86 if v < 1612 +by inc 872 if gyc > 878 +egk inc 858 if bqr > 1603 +e inc -199 if ns <= -62 +az dec 600 if v >= 1615 +nno inc -115 if g < -660 +ga inc 614 if f > -1910 +g inc 950 if zqo > 1009 +f dec -319 if cr == -1141 +gyc dec 498 if nm <= -3078 +u inc 61 if z != 1464 +av inc 127 if zqo > 1012 +ic inc -78 if f < -1573 +b dec -601 if nm <= -3082 +av inc -475 if gyc < 396 +av dec 613 if gyc < 383 +vkg inc 425 if rn <= 1981 +nno inc 543 if az >= -1946 +rn dec 280 if vkg >= -1096 +ns dec -366 if gyc <= 388 +v dec -558 if egk == 1093 +vkg inc -446 if ns <= 301 +y dec 617 if b <= -970 +n dec -890 if az != -1947 +vkg dec -102 if nm != -3092 +e inc -668 if ga < 33 +zqo inc -305 if e >= 529 +vkg inc -97 if vkg != -997 +rn inc 188 if nm < -3087 +cr dec 613 if rn < 1700 +v dec 647 if g < 284 +az dec -205 if e == 531 +av inc -359 if vkg == -1091 +y dec 252 if ns >= 301 +n inc 251 if f != -1593 +mx inc 438 if gyc < 385 +by dec -984 if nm != -3087 +mx dec 354 if ic < -425 +by dec 395 if ns > 298 +egk inc 119 if b == -966 +gyc inc -887 if vkg == -1091 +rn inc 898 if ga != 30 +mx dec 35 if y >= 485 +e inc 889 if ns != 300 +ga dec 992 if b > -968 +g dec 432 if cr > -1755 +nno dec -669 if gyc > -504 +bqr inc -442 if rn == 1697 +u inc -44 if b > -976 +u inc 5 if gyc <= -497 +gyc inc 36 if ns <= 304 +nm inc -528 if b >= -973 +y inc -617 if mx <= -400 +g dec 47 if e >= 1418 +b inc 292 if egk != 1083 +vkg inc 734 if ga <= 30 +n inc -678 if b != -691 +ic dec 581 if vkg >= -365 +u dec 562 if b == -683 +nno dec 751 if cr > -1757 +egk inc 709 if gyc != -461 +n inc -347 if rn == 1697 +gyc inc 960 if cr <= -1751 +z dec 627 if ns < 310 +gyc dec -190 if z < 842 +v inc 868 if mx == -398 +n inc -280 if b != -683 +n inc -302 if e == 1420 +av dec -389 if g != -209 +nm inc 241 if ic == -1018 +n inc -493 if nno <= 157 +f dec -932 if n == -466 +u inc -880 if y >= 480 +y dec -697 if egk < 1807 +az dec 332 if nno != 149 +g dec 971 if z <= 848 +by inc -510 if z >= 849 +u inc 103 if bqr < 1161 +av inc -830 if gyc > 678 +rn inc 110 if ns < 306 +b dec 616 if ga < 40 +egk inc -749 if y <= 1176 +z inc 669 if ns != 301 +n dec 365 if nno >= 152 +ns inc -464 if egk > 1801 +e inc -516 if by > 5894 +bqr inc 934 if g < -1165 +nno inc 224 if cr < -1744 +f inc -480 if n >= -456 +gyc inc 101 if g > -1168 +cr inc 501 if e == 905 +z dec -836 if f < -643 +ic dec 750 if rn != 1808 +u dec -318 if gyc <= 687 +ga inc -631 if av >= 430 +nno inc -261 if ga > -606 +b dec 723 if by >= 5889 +ns inc -109 if bqr != 2095 +cr dec 731 if e >= 903 +nno dec -251 if b >= -2024 +mx dec -206 if rn > 1810 +ns dec 249 if rn > 1799 +u inc 201 if egk < 1809 +vkg dec 283 if z > 2338 +rn dec -759 if u >= -3141 +f dec 540 if y != 1186 +by dec -523 if z == 2345 +by inc -894 if ga > -608 +rn inc -418 if cr >= -2489 +bqr inc -837 if nno > 361 +cr inc -485 if zqo == 711 +y dec -672 if nno == 364 +g inc 159 if nm == -3087 +vkg inc 873 if az >= -2074 +b inc 83 if z != 2347 +gyc inc 321 if e < 904 +e dec 283 if gyc < 689 +f dec 257 if b >= -1948 +by inc -526 if az < -2063 +cr dec 119 if b == -1939 +e inc -534 if g <= -1016 +bqr dec 923 if av == 430 +gyc dec 513 if bqr > 334 +u inc -756 if z > 2339 +nm dec 343 if gyc >= 165 +bqr inc -114 if ga <= -601 +gyc inc 355 if cr >= -3091 +gyc dec -458 if mx >= -398 +by dec 24 if v != 1519 +cr inc -155 if v <= 1526 +v dec 512 if av >= 427 +f dec 297 if f > -911 +nno dec 783 if ns <= -524 +az inc 985 if ga > -592 +cr inc 300 if egk >= 1800 +vkg dec 542 if mx == -391 +zqo dec -844 if bqr == 218 +av inc 860 if gyc == 985 +nno dec -253 if nno != 366 +v dec 542 if b >= -1941 +z dec -76 if ns > -526 +y inc -336 if az == -2073 +nm inc 995 if egk > 1793 +f inc -95 if e < 622 +zqo inc -46 if rn > 1379 +b dec 470 if av <= 1299 +gyc inc 839 if f >= -1304 +bqr inc -766 if bqr < 227 +n inc 980 if v < 460 +bqr dec -757 if ns >= -528 +g dec -507 if f > -1308 +mx inc 249 if ns > -522 +av dec 524 if g < -507 +e dec -962 if rn > 1397 +ns inc 139 if zqo < 666 +av inc -443 if zqo <= 656 +z dec -753 if rn != 1391 +g inc 616 if v <= 474 +ga dec 196 if nno < 618 +av dec -317 if gyc > 1826 +f dec -673 if cr < -2939 +b inc -670 if zqo > 670 +cr inc -948 if ga <= -795 +av dec -977 if zqo == 665 +f dec 521 if ic != -1764 +ga inc 342 if nno != 618 +av dec -989 if gyc >= 1823 +rn inc -118 if mx < -137 +ic inc 874 if nm < -2429 +cr dec 441 if by > 4996 +az dec 920 if cr == -4333 +by inc 486 if z >= 3168 +zqo dec -614 if u <= -3897 +zqo inc -359 if g > 105 +cr inc 725 if av <= 3257 +nm dec 816 if mx >= -133 +f inc -174 if az < -2996 +n dec -832 if egk <= 1803 +z dec -351 if av > 3257 +rn inc 814 if egk == 1802 +rn dec 516 if bqr > 206 +ic inc -181 if ns >= -383 +cr dec 476 if av < 3261 +rn dec -446 if mx > -141 +rn dec 966 if bqr > 213 +u dec 426 if b != -2408 +ic inc 841 if ic >= -1071 +u inc -990 if n < 371 +gyc inc -436 if az != -2991 +egk inc 673 if by == 5485 +g dec -510 if egk >= 2474 +v inc -104 if ic != -225 +b dec 862 if ga != -452 +n dec -733 if mx != -132 +b dec -726 if nno > 618 +f dec -259 if rn == 597 +e inc 51 if nm == -2435 +y inc -251 if ns >= -388 +bqr inc -684 if u >= -5325 +bqr inc -427 if b > -3278 +n inc 526 if mx >= -149 +f inc -727 if egk != 2475 +ga inc 345 if g >= 622 +ic dec -398 if ga > -113 +rn dec 581 if egk < 2478 +rn inc 926 if g < 614 +ns inc 469 if nno != 615 +n inc -870 if vkg > -311 +mx inc 124 if ga <= -103 +z dec -983 if ns != 96 +vkg dec 530 if mx < -18 +rn dec -899 if g < 625 +gyc dec 98 if g < 627 +av inc -497 if n < 760 +nno dec -115 if egk >= 2470 +z inc 610 if z > 4156 +mx inc -184 if ns > 91 +cr dec 724 if nm != -2438 +ns dec 527 if nno > 727 +ns inc -177 if cr >= -4811 +v dec 423 if rn != 921 +vkg dec 658 if av >= 2755 +y inc -464 if bqr > -890 +nm dec 440 if e < 673 +ic dec -963 if mx == -18 +n dec -613 if by < 5488 +v inc -412 if egk < 2482 +vkg inc -278 if y < 1609 +by inc 200 if e == 672 +ns inc -627 if v == -51 +n dec -176 if e == 672 +n inc -511 if gyc <= 1289 +zqo inc 589 if ga == -108 +v dec 533 if egk < 2485 +zqo dec -93 if n > 1536 +e dec -618 if nno < 742 +gyc inc 258 if f != -1139 +ga inc 562 if vkg >= -1254 +n inc -492 if f > -1158 +rn dec -267 if nno < 738 +v dec -263 if y < 1603 +vkg inc 206 if mx == -18 +av dec -610 if n <= 1060 +by dec -352 if mx <= -24 +zqo dec 74 if vkg >= -1046 +ns inc -251 if ga > 457 +cr dec 531 if n != 1047 +ga inc 892 if by < 5683 +vkg inc -687 if b >= -3273 +av inc -208 if v <= -580 +g dec 550 if az != -2985 +ga dec -595 if gyc >= 1548 +egk dec -240 if zqo >= 930 +b dec 262 if az == -2992 +egk dec 831 if ga < 1055 +zqo inc 928 if ga > 1044 +nno inc -90 if gyc >= 1542 +e inc -47 if f < -1144 +u dec 131 if zqo > 1871 +g dec 268 if f != -1148 +b dec -964 if n <= 1045 +gyc dec -952 if az > -3001 +egk inc 324 if vkg != -1735 +by inc -460 if av == 3167 +bqr inc 494 if nm >= -2878 +by inc -616 if rn < 1191 +ga dec -150 if u != -5312 +ns dec -535 if av == 3161 +rn inc -720 if ic > 1135 +n inc -821 if gyc < 2508 +n inc 670 if ns < -705 +f inc 419 if ga == 1197 +mx dec -96 if nm >= -2876 +vkg inc -270 if n < 909 +z dec -907 if ns < -700 +ns inc 160 if gyc >= 2491 +av dec -250 if e > 1240 +f inc 768 if ns >= -542 +ga inc 443 if gyc > 2498 +rn dec 107 if g == 72 +ga inc -420 if mx != 74 +mx dec -763 if ic == 1140 +b inc 586 if gyc <= 2505 +mx dec -948 if gyc > 2509 +zqo dec -384 if vkg < -1991 +z dec 234 if rn > 1072 +gyc dec -821 if v > -590 +z inc 83 if v == -584 +egk dec -835 if b <= -2941 +cr dec -495 if v > -590 +by inc 259 if cr <= -4852 +cr inc 530 if mx != 77 +vkg inc 381 if g <= 80 +by dec -71 if az == -2992 +mx inc -453 if g > 64 +ic inc 410 if vkg > -1618 +f inc 945 if n == 901 +y dec 409 if nm >= -2884 +z inc 870 if vkg >= -1606 +av inc 187 if z >= 5521 +nno inc -852 if ga > 1212 +cr inc 788 if av < 3608 +e dec -182 if by != 5143 +nno inc -706 if ga >= 1228 +vkg inc 782 if z < 5532 +mx dec 839 if nno > -219 +v dec 267 if b > -2952 +v inc 901 if gyc == 3321 +g dec -820 if rn != 1079 +ic dec -221 if zqo <= 2259 +ga inc -784 if e == 1425 +ga inc -569 if bqr >= -404 +u inc -206 if mx <= -1212 +gyc inc -685 if nm == -2881 +e dec 269 if mx <= -1208 +av dec -207 if by >= 5137 +nno inc -109 if ga != -131 +ga dec 3 if ic != 1761 +zqo inc 181 if nm < -2866 +y inc -15 if by >= 5140 +rn dec -617 if g != 884 +g dec 574 if mx < -1213 +ga dec -775 if bqr >= -404 +ic dec 186 if v < 55 +gyc dec 497 if ns >= -552 +z dec 619 if nno >= -319 +b dec -753 if av == 3809 +by inc -890 if n != 901 +b inc -714 if z == 4902 +n inc 927 if v <= 43 +b inc -107 if b <= -2947 +nno dec 707 if y == 1183 +vkg dec 199 if az <= -2996 +gyc inc -684 if cr <= -3523 +z dec -518 if zqo == 2429 +ga inc -220 if cr >= -3527 +zqo inc -922 if y <= 1183 +rn dec 852 if gyc != 2138 +nno inc 419 if ic == 1577 +rn dec -951 if by <= 5130 +av inc -557 if z == 4904 +mx dec 599 if g > 327 +az dec -594 if u != -5525 +gyc dec 187 if y > 1173 +v dec 2 if e >= 1153 +gyc inc -814 if ns < -540 +zqo dec -401 if av != 3249 +ic dec -511 if g == 318 +g dec -447 if g == 318 +zqo dec 965 if by != 5146 +gyc inc 658 if vkg != -824 +nm inc -663 if e > 1156 +n inc -974 if zqo <= 954 +n dec 363 if az <= -2389 +ga dec 300 if v <= 53 +n inc -402 if y > 1186 +b dec 839 if bqr >= -406 +rn inc -188 if v > 57 +av inc 952 if rn < 852 +bqr inc 973 if v == 56 +f dec -234 if b > -3899 +nm dec -96 if zqo != 949 +e dec 141 if ic != 2084 +ga dec 146 if g > 755 +av inc -333 if ga > -33 +z dec 698 if e == 1015 +e dec -493 if z >= 4200 +v dec 234 if v >= 48 +az dec 572 if vkg < -831 +vkg dec 164 if u >= -5527 +ga dec -933 if rn != 846 +gyc inc -180 if ic > 2081 +vkg dec -305 if z >= 4198 +ic inc 50 if cr == -3526 +egk inc -956 if zqo <= 939 +n inc 265 if z >= 4215 +az inc -574 if nm <= -2776 +bqr dec -19 if ic == 2141 +ga inc -682 if cr != -3525 +g dec 864 if g > 764 +ns inc -746 if f < 452 +g inc -969 if f >= 450 +ga inc -127 if e < 1518 +v inc -903 if egk == 3043 +cr dec 714 if nm < -2775 +f inc 33 if ga != -835 +bqr inc 919 if bqr != -382 +nm dec -489 if z < 4210 +vkg dec 962 if gyc != 1611 +z inc -698 if ga >= -844 +z dec 645 if e <= 1510 +ns dec -501 if y != 1174 +az inc -314 if av < 3868 +mx inc -207 if ns == -792 +z inc -604 if zqo < 952 +g inc 466 if g > -1067 +b inc -704 if nm >= -2295 +nno dec 284 if e != 1500 +cr dec 58 if z < 2263 +rn dec 494 if ic > 2148 +nm dec 211 if by < 5141 +by inc 150 if av >= 3862 +gyc inc -716 if b <= -4596 +u dec 466 if ns > -798 +mx inc -935 if cr == -4288 +bqr inc 275 if b < -4587 +v dec 771 if egk == 3043 +vkg inc -902 if u != -6000 +b dec -683 if nno == -1311 +egk dec 525 if v == -1860 +az inc 708 if by > 5284 +y inc -820 if ic >= 2137 +az inc -720 if zqo <= 940 +u inc -299 if zqo < 955 +bqr inc 248 if rn == 846 +g inc 148 if n > -441 +nm dec 213 if egk >= 2509 +ic inc -840 if g < -928 +f inc 98 if by >= 5287 +nm inc 909 if v != -1863 +vkg dec -856 if y >= 360 +v inc -156 if zqo == 946 +bqr dec 908 if gyc >= 900 +zqo inc 836 if f == 581 +ns inc -157 if ns == -792 +egk inc -899 if z == 2259 +ga dec 658 if ic < 2142 +nno inc -278 if by < 5291 +egk inc 502 if f > 580 +z dec 807 if y >= 363 +nm dec 612 if nno == -1583 +y inc 914 if ns <= -942 +gyc inc 419 if v != -2013 +g inc 897 if v <= -2015 +gyc inc 107 if vkg >= -1709 +bqr inc 224 if z < 1460 +mx dec 809 if ga < -1488 +cr inc -401 if av < 3875 +ns inc -521 if by == 5290 +az inc -269 if ga == -1494 +b dec -688 if by != 5294 +n inc -746 if mx < -2225 +y inc -452 if e < 1509 +z dec 495 if n <= -1175 +av dec 204 if egk != 2117 +cr inc 30 if ga >= -1498 +y dec -821 if gyc < 1437 +av dec -105 if bqr != -543 +by inc -897 if egk < 2130 +az inc 392 if vkg != -1703 +egk inc -34 if ga <= -1490 +mx dec -635 if av >= 3658 +gyc inc 307 if zqo < 1787 +v dec 263 if v >= -2018 +n dec 574 if f < 582 +f inc -432 if g < -28 +z dec 259 if av == 3663 +zqo inc 472 if b == -3909 +e inc -779 if bqr > -545 +zqo inc 187 if v > -2282 +e dec -395 if y != 1652 +y inc 312 if az < -3021 +ga dec -324 if egk < 2082 +cr dec -409 if az < -3023 +nm inc -790 if bqr != -533 +ga dec 252 if ga <= -1493 +ic inc -932 if u <= -6292 +e inc -547 if vkg >= -1698 +nno inc -171 if b != -3909 +g dec -891 if vkg < -1690 +ga inc 441 if egk < 2089 +z dec -708 if ic != 2147 +nm inc -402 if b == -3919 +f inc -374 if u != -6291 +ic inc -48 if ga >= -1312 +egk dec -19 if b > -3911 +av dec 305 if ga >= -1313 +g inc -475 if mx < -1588 +vkg inc -269 if vkg == -1700 +gyc inc -535 if f > 572 +nno dec -382 if ns >= -1475 +nno dec 650 if y <= 1959 +y inc 148 if zqo <= 2442 +by dec -223 if u != -6286 +y inc -319 if ga > -1313 +nno dec 13 if av == 3358 +ga inc -402 if gyc > 1198 +rn inc 37 if f == 581 +gyc inc -884 if rn > 882 +ic dec 676 if zqo <= 2438 +u inc 417 if ic != 2098 +n inc 930 if zqo <= 2449 +av inc 509 if ns >= -1477 +y dec -981 if y < 1779 +az inc -780 if ns < -1472 +f dec -834 if by != 4622 +ic inc 721 if av == 3867 +e dec 916 if g <= 400 +zqo inc 169 if cr > -4254 +nno inc -685 if z == 1406 +v dec -920 if zqo > 2440 +nno inc 91 if gyc < 317 +n inc -395 if nno != -2459 +egk inc -746 if v == -1359 +av inc 66 if cr == -4260 +gyc inc 40 if ga > -1711 +egk inc 914 if y < 1788 +g dec 176 if u != -5869 +b dec -550 if vkg >= -1974 +g inc -545 if ic < 2824 +nm inc -645 if cr <= -4256 +b inc -103 if ns >= -1477 +g dec 166 if zqo >= 2436 +nno dec 665 if by <= 4618 +rn dec 622 if nno > -3130 +nno inc -591 if b < -3461 +az inc -807 if egk >= 2272 +g dec -417 if f >= 1425 +by dec 547 if by != 4606 +cr inc -579 if e != 212 +nm dec 650 if e == 208 +b dec -65 if by > 4064 +b inc -263 if ns <= -1473 +az inc -784 if g >= -494 +b dec -193 if z > 1415 +bqr dec 143 if zqo >= 2443 +nno dec 385 if g >= -496 +v dec 352 if ic != 2814 +nno dec -521 if by != 4065 +ga dec 198 if az <= -4612 +by inc 926 if b > -3404 +bqr inc -697 if zqo == 2441 +vkg inc 124 if mx < -1588 +u dec -564 if bqr < -1237 +v inc -763 if ic >= 2812 +egk inc 339 if az > -4611 +z dec -617 if mx <= -1588 +av inc -876 if cr >= -4837 +n dec -600 if mx == -1595 +v inc -354 if vkg > -1850 +v inc 194 if vkg <= -1841 +bqr dec -206 if av <= 3934 +rn dec 547 if z != 2033 +b inc 217 if u <= -5305 +v dec -230 if egk != 2264 +n inc -447 if b != -3180 +az inc 497 if g >= -499 +e inc -527 if v < -2051 +u inc -889 if by == 4995 +b inc 74 if egk < 2282 +ga dec -65 if v == -2052 +nno inc 156 if av != 3933 +rn inc -880 if av != 3934 +cr dec 825 if ga == -1840 +y inc 499 if e == -319 +b inc 525 if mx > -1604 +f inc -731 if zqo >= 2437 +cr inc 398 if gyc < 360 +f inc 286 if vkg > -1846 +zqo inc 761 if ic > 2816 +y dec -877 if rn != -1166 +vkg inc -405 if ga != -1838 +vkg dec -522 if v <= -2060 +mx inc 281 if nno > -3586 +vkg dec -203 if bqr >= -1043 +vkg inc 278 if az >= -4125 +rn dec 544 if b < -2573 +av dec 730 if mx > -1318 +ic inc 49 if n < -620 +f dec -599 if nno != -3583 +e inc -871 if gyc == 355 +e dec -735 if mx != -1307 +n dec -73 if rn <= -1707 +ns inc 896 if g >= -502 +z dec -480 if z <= 2023 +zqo inc 595 if v < -2043 +mx dec 647 if vkg == -1769 +n inc 743 if nno > -3589 +gyc inc 129 if cr > -5267 +vkg inc 703 if mx > -1966 +bqr inc 378 if g <= -487 +ga dec 852 if zqo > 3035 +zqo dec -43 if y > 2280 +ga dec 849 if cr != -5259 +gyc inc -363 if av >= 3203 +vkg dec 481 if nm <= -3884 +g dec 609 if f < 964 +av inc -951 if n != 187 +ns inc -676 if zqo == 3079 +nno dec -998 if av == 2252 +n dec -624 if vkg > -1544 +y inc -262 if ns == -1250 +av dec 248 if ns < -1250 +f dec 351 if z == 2503 +bqr inc 535 if ic > 2858 +f inc -725 if nno > -2589 +ic inc 860 if v == -2052 +nno inc -211 if v >= -2055 +ic dec -324 if bqr <= -126 +az dec 746 if f <= -99 +g dec 985 if e <= -454 +f dec 434 if z < 2495 +egk dec 842 if bqr == -121 +gyc inc 715 if y >= 2022 +ns inc -573 if nm != -3888 +b dec 415 if mx >= -1951 +by inc -719 if ga == -3551 +n dec -783 if cr >= -5268 +nm dec 409 if by > 4988 +u inc -72 if av >= 2246 +ns inc 338 if v <= -2050 +e inc 12 if rn < -1706 +ns dec -354 if nm == -4299 +egk inc -589 if zqo >= 3084 +egk dec 856 if vkg != -1555 +ns inc -439 if zqo >= 3076 +by inc -942 if cr != -5272 +z inc 119 if b >= -2588 +cr inc -864 if ga != -3537 +nno inc -333 if gyc > 828 +z inc -530 if e > -451 +nno inc -113 if u > -6271 +g inc -213 if mx <= -1953 +y inc 107 if ga < -3536 +y dec -971 if az < -4859 +n dec -424 if av < 2258 +ic dec 632 if rn <= -1705 +az dec -701 if ns > -1576 +by dec -45 if egk > 581 +z inc 111 if vkg == -1547 +ic dec -737 if u <= -6266 +v dec 13 if nm != -4289 +b inc -616 if ic < 3838 +av inc 266 if b <= -3190 +nno dec -699 if gyc >= 834 +y dec 400 if gyc >= 835 +y dec -119 if ns <= -1567 +n dec 452 if rn < -1703 +egk inc -254 if vkg == -1556 +az inc 568 if ns <= -1580 +f dec -399 if bqr < -115 +zqo dec 948 if nno > -2440 +rn inc 154 if zqo == 2131 +f dec -21 if b != -3190 +nno inc -204 if g > -1683 +v dec 190 if az >= -4168 +bqr inc 236 if v > -2263 +cr dec 554 if nm >= -4303 +gyc inc -657 if e > -449 +e inc 65 if nm != -4306 +v inc 340 if az > -4171 +mx dec 527 if nm <= -4296 +g dec -426 if ic > 3819 +b dec -766 if z < 2205 +ic inc 822 if cr < -6677 +cr inc -733 if n != 958 +rn inc -759 if vkg == -1547 +nm dec 588 if rn == -2315 +n dec 310 if ic < 4641 +n dec -24 if g >= -1274 +n dec 341 if nm == -4887 +cr dec 131 if av > 2513 +zqo inc -78 if gyc < 181 +mx inc 368 if vkg < -1537 +gyc inc 157 if zqo >= 2053 +rn inc -871 if vkg <= -1544 +bqr dec 299 if egk == 576 +cr dec 27 if b <= -2423 +rn dec 848 if az < -4170 +av dec 836 if egk <= 577 +v dec -334 if cr < -7576 +f dec -820 if u == -6271 +az dec -367 if egk == 576 +by inc -267 if bqr != -192 +bqr dec 95 if cr == -7575 +ga dec -641 if bqr == -279 +ns inc -776 if y != 2821 +by dec 177 if cr != -7575 +nno dec 656 if g >= -1261 +z inc -641 if az >= -3789 +rn dec 93 if v != -1911 +az dec -664 if f > 1139 +ic dec -565 if e >= -380 +by inc -600 if ga == -2894 +zqo dec 580 if g <= -1263 +zqo dec -324 if by != 3784 +gyc dec -987 if ns != -1570 +gyc dec -921 if mx >= -2111 +by inc -529 if ic < 5211 +av dec 272 if ic == 5210 +nno inc 745 if e < -374 +ga inc 893 if by >= 3782 +egk dec -936 if bqr >= -284 +vkg dec -146 if nno <= -1679 +y inc -686 if ga != -2000 +b dec -659 if u < -6265 +b dec 418 if n < 629 +az inc 613 if ns == -1563 +vkg inc 385 if ga != -2017 +egk dec 54 if az == -3802 +vkg inc 330 if by == 3786 +f inc -243 if u != -6271 +gyc dec 751 if ns != -1574 +nno dec -285 if ga <= -2006 +vkg inc -257 if v >= -1921 diff --git a/08/lib.scm b/08/lib.scm new file mode 100644 index 0000000..6e402c3 --- /dev/null +++ b/08/lib.scm @@ -0,0 +1,105 @@ +(library (lib) + (export solve-part1 solve-part2) + (import (chezscheme)) + + ; Split list at first delimiter into `prefix' and `suffix' + ; Return value is a pair like `((p r e f i x) s u f f i x)' + (define (list-split-left delimiter? xs) + (let loop ((prefix '()) + (suffix xs)) + (if (null? suffix) + (cons prefix suffix) + (let ((x (car suffix))) + (if (delimiter? x) + ; Found first delimiter, so return immediately + (cons prefix (cdr suffix)) + ; `x' isn't a delimiter, so append it to `prefix' + (loop (append prefix (list x)) (cdr suffix))))))) + + ; Split list at given delimiter into list of sublists + (define (list-split delimiter? xs) + (let loop ((pieces '()) + (rest xs)) + (if (null? rest) + ; Fix order and remove all empty sublists from output + ; (which are caused by consecutive delimiters in `xs') + (reverse (remp null? pieces)) + ; Extract next piece from `rest' and prepend it to `pieces' + (let ((next (list-split-left delimiter? rest))) + (loop (cons (car next) pieces) (cdr next)))))) + + ; Split string at whitespace into list of words + (define (string-split str) + (map list->string (list-split char-whitespace? (string->list str)))) + + ; Evaluate a test of the form: `rval' `test' `rlit' + (define (satisfied? rval test rlit) + (cond + ((string=? test "<" ) (< rval rlit)) + ((string=? test "<=") (<= rval rlit)) + ((string=? test "==") ( = rval rlit)) + ((string=? test ">=") (>= rval rlit)) + ((string=? test ">" ) (> rval rlit)) + (else (not (= rval rlit))))) + + ; To copy the register state list from one cycle to the next, the usual + ; `(apply list xs)' trick isn't good enough, because `xs' contains pairs. + (define (list-deep-copy xs) + (if (not (pair? xs)) + xs + (cons (list-deep-copy (car xs)) (list-deep-copy (cdr xs))))) + + ; Execute one instruction (`words') given current state (`registers-old') + (define (execute words registers-old) + ; Make a copy of the input state, to be modified and returned. + ; The state is an association list of (register . value) pairs. + (define registers-new (list-deep-copy registers-old)) + ; "Parse" the instruction, which has the following form: + ; `wreg' (inc|dec) `wlit' if `rreg' `test' `rlit' + (define wreg (list-ref words 0)) + (define inc? (string=? "inc" (list-ref words 1))) + (define wlit (string->number (list-ref words 2))) + (define rreg (list-ref words 4)) + (define test (list-ref words 5)) + (define rlit (string->number (list-ref words 6))) + ; If register `wreg' isn't initialized yet, set it to zero + (if (not (assoc wreg registers-old)) + (set! registers-new (cons (cons wreg 0) registers-new))) + ; If register `rreg' isn't initialized yet, set it to zero + (if (not (assoc rreg registers-old)) + (set! registers-new (cons (cons rreg 0) registers-new))) + ; Read the values stored in registers `rreg' and `wreg' + (let ((wval (cdr (assoc wreg registers-new))) + (rval (cdr (assoc rreg registers-new)))) + (if (satisfied? rval test rlit) + ; If the test condition is true, apply the increment/decrement + (set-cdr! (assoc wreg registers-new) + (if inc? + (+ wval wlit) + (- wval wlit)))) + ; Return the new state + registers-new)) + + ; Execute the "program" and return the history of register states + (define (solve-puzzle lines) + (let loop ((instructions (map string-split lines)) + (registers '()) + (history '())) + (if (null? instructions) + history + (let ((state (execute (car instructions) registers))) + (loop (cdr instructions) state (cons state history)))))) + + (define (solve-part1 lines) + (define history (solve-puzzle lines)) + (apply max (map cdr (car history)))) + + (define (solve-part2 lines) + (define history (solve-puzzle lines)) + (let loop ((states history) + (highest -999999)) + (if (null? states) + highest + (loop (cdr states) (max highest (apply max (map cdr (car states)))))))) + +) diff --git a/08/main.scm b/08/main.scm new file mode 100644 index 0000000..fbcd10e --- /dev/null +++ b/08/main.scm @@ -0,0 +1,20 @@ +(import (chezscheme)) + +; Where the magic happens +(import (lib)) + +; Read my personal puzzle input +(define input + (call-with-input-file "input.txt" + (lambda (port) + (let loop ((line (get-line port)) + (result '())) + (if (eof-object? line) + (reverse result) + (loop (get-line port) (cons line result))))))) + +; Part 1 gives 5215 for me +(printf "Part 1 solution: ~a\n" (solve-part1 input)) + +; Part 2 gives 6419 for me +(printf "Part 2 solution: ~a\n" (solve-part2 input)) diff --git a/08/test.scm b/08/test.scm new file mode 100644 index 0000000..b18ae33 --- /dev/null +++ b/08/test.scm @@ -0,0 +1,34 @@ +(import (chezscheme)) + +; Where the magic happens +(import (lib)) + +; My quick-and-dirty unit testing framework (copied for each day) +(define (run-test name proc input expected) + (let ((result (proc input))) + (if (equal? result expected) + (printf "\x1b;[32;1mPASS\x1b;[0m: ~a\n" + name) + (printf "\x1b;[31;1mFAIL\x1b;[0m: ~a: got ~a, expected ~a\n" + name result expected)))) + +(define input '("b inc 5 if a > 1" + "a inc 1 if b < 5" + "c dec -10 if a >= 1" + "c inc -20 if c == 10")) + +(printf "Part 1 tests:\n") + +(define (test-part1 name input expected) + (run-test name solve-part1 input expected)) + +(test-part1 "part 1 example 1" + input 1) + +(printf "Part 2 tests:\n") + +(define (test-part2 name input expected) + (run-test name solve-part2 input expected)) + +(test-part2 "part 2 example 1" + input 10) diff --git a/09/input.txt b/09/input.txt new file mode 100644 index 0000000..da21895 --- /dev/null +++ b/09/input.txt @@ -0,0 +1 @@ +{{},{{{{{},{{!<",!>},,<'e">},{!!a!!a!>},ue!>,<"!!!>!}>,<}!!!>,ii>}}},{},{}},{{},{{!>,},{},{<{}}!>},}},{{{{<}i<}"">},{>}},uo{}!!'!!o!>>},{!>},!>,<>,{{,<>}}}},{{{},{{}}}},{{<{u'""o>,{!!!!e{uea!>!!i>}},{!!!!e},,,<>}}},{{{{},{{{},{<}<{!>},},!!}},{},},<>}}},{,{}},{!>eie!>,"!!!,,!>,<}},<>,<>}},{{{}}},{},{{{,,}!>},<"ai>,{!!u{{!{!>},<<{o!>,}}},{{{},{<<,"!>},au!o>,'!!!>,},<'oaaou!!!!!>},!>,},{{{{{},}},{,},}},{{},{{},ie"e!>},!"i!>{!>},<>},{{{{,<}}!>},},},,<,'!>!!<,}{e>},{,<>,<}!>!!!>"!>},<'!!!>}<>}},{{!>},},<>}},{{{},{<}"a}!>,!>},,<<}{o""!!a!!,a>}},{{<>}},{{}}}},{},},!>{>},{<>,<<>}}}}}}}},{{{{},<}}'!>,}>}},{<"!!!!!>,'!!i}{o!>ai{"!!!>>,},">}},{{}},{{{{},,{<}!!!>,,}},{{,}!e>},{<}a'!,}>}}},{{{},!!u"}>},{!>,},,i,!i}'!!!!'">},{{},,,<"!>!{}a{"!!o<"'!!!>o}{a>},{},<"!{<'>}}},{{{{{},{},<>}},{{}}},{{{{{{}},{}},},{{!!ua!>oa}uia>}}}},{{,,<}"!!!!ei!!!>!>!"ii}>}}},{{{{u!!!!!>,o",!!!>!u!>,<>},!!!>!!o!>,<{,!>!>},<>}},{'>,{!>,!!}!>,,<>,{}}},{}},{{<>},{!>},o!>},},<>},{{,aa!!>},{<>}}}},{{{{},,<'!>},!!<>}},{{},,{{!!!>a!!!>!!{>},!>},!>,}}},{<'oei!>},!{e!>,,{<>,{,,!>,},<}>}}}}}},{{{{,},!!!>},<{!!!>>,{!>"ua!!!>!!,}'!!ai,e!>},}},{<>},{}},{{{{<}},{}},{<,,o!"uu",,!{'>,!!!>},<'!i!>},},}}},{{},<!!{!>}"a>}}}},{},{{{{{{,},<<>}},{{<}!!!>}!!>}},{{,{<}!!i!'eu}},{{}},{!},ii!!},<"!!!>!'o>}}},{{{},,}},{},{{},!!!>}!>,<>},},,,<}'>}},{{{},!>,},}},{{},<{!!!>!"},<"!!!!a!!e!>,e}>},{{},<>},<">}}},{{<o}>}}},{{{{{<>}},{{a'>},{,<}i}"{}!<,e>}}},{{{}},{{,!!o!!!'u{!!!>},u!,!!"i}>},{{<"!!}{u',,<{!!!>eu!!!!!>>},{{}}}},{{{{<'i!!},a!>,!>!>,,<"!>},>,{ou},!!!>"a!!o!{a!!'"}!!">}},{{<<,!!>},{{,},{!!i}'!!!>!>,,i!!!>>}}}}}}}},{{{<}uo!!!>i!!ii!>{!!o">}},{{{{,!!!>>},{}},{{<,!!>},{},{{},<"!!!>!!!>'o"o{!!e'"a>},{}}},{},<,u!>,!!!><{au}!>>,{}}}},{<{!!ee!!!>!!a!i!>ei!!e!!!!!>!!!>e!!a">}},{{{{{},{{<"o!!{>},{}}},{,,,<{,}{!<{>}}},{{{{o}i!!i!>},<}'>,{}}},{},,},},}},{}},{{{{}},<{!!},{{>}}},{{{{{,},,},!!},},{{!!e",""'a!!o}!!!>"!!!>}>}},{{},<{',{a>}}},{{{},<{i!!!!!>,<>}},<}!!!!'>},{{,<>,{},o!!"'!>,}},{{<{"!!o!!!>!!!,>}},{{}}}},{{{},{},{}},{{},{{}},{{{!>},,{<,a!!!>}oa<'ii>}}},{},{!!!>{oiu>}}},{{{{{},}!!">,{<},!>,<<}}}},{{{{{}}},{{!>},},,>}},{{},<>},},"!>!!!>!>e>}},{{{{,<<">}},{{,},<}!>,!!!>,,!>},<,!>,o>}}}},{{},,{}}},{{},{}}},{{!!!>>},{{},{,},<,{>}},{<,!!!>},},<<>,,<"a>}}},{{{<,i'"!!u}!>,<,o!!{!>,<{ou,,<'!!}>}},{{{}},{{{},!!a!!!>e>,{<,>}},{{},u!>>}}},{<"!!''"!>,,<}',!>e!>,u>},{<}}}},{{{,},,,!!!>"!>,>},{{,<"!>},,,{!i"a!e{!!>}}},{{<,,"!!o!>ei"''u>,{{<!!u!>!>!>,!'!}}}},{{{{{ea!!!!!!!>},<'!>},<>},!!,'e!>,<,}!!">}}},{{,},,},e{ie>,{{>}}},{!!i"u!!!!o!>},<}e!u{!>{u!>},<'i}>}},{,<}},{<,!>!!!>},<!!!eu!>!>},<{!!}ao"iu>,'e!>!>},},<}},{{{{,oa},{e!!!!a!!!>,,<','"a!!!!!a!u>},{{!!!>,>}},{{{{{eoi>}}},{{{!>,<>},}},{{,!!a!>},<{,}!!!>e!>>},{},!!i!!!>'a>}}},{{,!>},<}">},},'o!!!>}'!!,>}}},{{u{i}>,{',}!,ia!!i,!!!!>}},{},{}},{{{{{<"e!!!!}!!!>!>},<>}}}},{<{{,"}!'o!!a!!!>!!!!""{}!!!>>,{}}}}},{{},},{{},!>},<}!!!>!!i,!>{!>a!"{!!!>!!>},<<{!>,<"o!>,'!>o}>},{,!i,>,<}!>!!o!!!>{!!'o!!i>}}}},{{{},,{{'}{!!!!>}}},{{},!>,},<'{o"!!!!o!>o,<{,o{!!!>,},{{},{},{{,<"!!{iu"i!>euoa}!!!!},{!!u'!>,<"!!!!},}}}},{{{<>},<}'"o!!!>""!!!>},<',{},<>},{{,uao!>},<>,{{},},<,!>i!!!>o<{!e,i>,},oei!>,}},<,!!!>'!!!!{o>}},{{<'u!!!>!>},},{{{{,},,,'!!o!!u>},{}},{{<'!u!!!>"}!ui!uo!{!!!>!>,'e>}}},{},{,<<'>}},{{<{u'}'!>i!!i!!!"!!'!>},},}}!!e!>,},{<'a{o!>},<,!!>}}},{{},{{},{{},!!!>},,e!!!!!>'!!!!!>!!o!!{!!{,<>},{},<>}}},{,<}>}}},{{,<,'u'e>,{{}}},{,iae{>}}},{{{{{{<}}o!!,"{},o{!>},<"!!!>,<>}},{}}},{{{{euu!>,<>,{<,!>},!>!>},{!>},<,!!!!"!>,}},},<{!>,},<,u"!!u,!!{}ouo>},{{{{}}},{},},!!e!!{a>}}},{{},},}!!'i!>"!!e"',!!'!>>},{{{{{!ae!!"}!>},<<'!}!!'!!!>},}},<>},,>},{>},{{{{},}u>},{}},}}}}}},{{,,{o!!ie}!!>}},{}},{{{{,e!{!e,<,,<>}},{<<}!!e!!e!!''oa>}},{{{,i!>,!'>},{,<"u!>},<'},<,}},{,<}!!'!>,<>}},{{{<{!!!>}a!>},},!!!!u,<'a!>,<>}},{{},a!!'!!!>e'!!>}}}}},{{{{{{}},{<"i!>},,<"{o}"{!!a!>},<>,,!>!>},!>},{{,<,<"!!!!io{}o"e!>o!!o}{u>}}},{{{{{}},{{},},}!,"{<'{a>},{{,{<"'!,!},,},<}>}},{}}},{,,!>,!!!u>},{,<{a"euu>,{<'>}}},{<}ia!>},!>!!!>!!!!!o!!!>,">,<"u'>}},{},{{<'!>{a}!>},!o!e}!>"e!e}!!!>},<>,{},},},,<{!{e!!!!!>a!!!!!>>}},{{{,{!!!!a<>}}}}},{{}},{{{{<'!>,{{i!!i!!!>!!!!{!""},{<}{e!!,e"',{<,,},,},<'>}}},{{{}},<{"a!!!>!e>},{{{{!>,<}!>},,!!!>!>,,<}!!!{e,<>},'o!!!!a!>!>,},<>},}!!ei!!!!},},<,}},{{{},!>},<},{}},{<},},a"!!"!"!>,<'!!!>,<>,!!!>,<}!!i!!!}"!>,!!!!!>,<>}}},{{,<>,{}},{{,<,!>!!!>!!!!!ae!>},>},{{},<,',{!>,<<>},{{<'!>},,!!{<>},{{}!""a!!!>!>,!!!!!!!>>}},{{},<,'!!uu"{o!!!>"ea!!e!>},},u!>i!}}!{},},!>},<{!>,<>}}}}},{{{},u!!"!!!>}a{!!!>oie!!!u!!!>ua,!!o<>}},{{{{{},!!!>!>,<>},}},{{{}}}}}}},{{{{{{},!!!>!!a!o,}i{o!!!>!!!>,<>},},,!!!>!o,"!>euu!>!!!>!>},!>,<>},{{>},{}},{{<{>},{}}},{{{{}},{{{{},<<{i!!ao!!!>'!"e">},{{{}},{}}}},{{{<<'!!!>"!!!!!o!>},<{'oi!!o!!!>},<>},,',!{e{>},{{{<>}},{,},},i>},{,o!!!!}!!!>>,{}}},{,{!>,<,!>},i!!!>iei>}}}},{}},{{u<{e!!{e">},>}},{}},{{{{{<},},},<<}},{!!!>i!>>,{{},{<'!>,,<>}}}},{{!!!>!>,,},,iu>,{!!!!!>!au!>'>}},<>},{{},<"!o!>},<,},<,e>},{{}}}},{{{{,!>'}i!>},>,},},{{{{},},{}}},{,{<,"{!!!!,o"},!>},,!!"!!!>,>}}}},{},,<,u"!>,u>,<,!!!}!>,!"!>,<>}},{{{{!!"!!!!"!i,{<{!!o!!{!>,}},{}},{{<{e!!!!,,!!e}!e!>,,""!>},}},{{{{}},u!{>}}}},{{{{}},{{},{{},{<"!!!>!>,,<,e!,a>}},{"u<>,{},},,<>,,!!<}{!!!,"uo>}}},{}},{{{{<{"a!>},},,<,>},!!a!>,<}!!!!!>!!!!o!>,<}!!{oe!u">},{{{<{!>},o!",>},},{{<}>},<<}""a!!!>},>}}},{{,<"i!>},<>},{<'>}},{{{,!,e<!>},<o!>},!!i!>>},{<,i">}}}},{{<>},{<>}},{{{},{{{<,,,}}},{{<,}'!!!!!!'!!!>},<>,>},{<'e!>}},,{}},{{},{{,o!>aa>},{>}}}}},{{{{a!ie>},au!>"!!{!{i!!i,'{!!!>!!'>},{!!!!e>,{}}},{{}}},{<'a!o!>},<>}}},{{{!!ae!u!!,{{,<}!!u!>,,u!!e!!"!o>},,,,,<>}},{e!}'!>,<,!"u!!ou{}>}},{{{<{!!!>a'!>,},}},{<}a!!!!,!!io!{>,<}u!>!!!>i!>!eu!>},<{!!}!!!>{!!!>u>}}},{{{},{{}}},{{{{<{},,},,,}}},{},{<}!!!>}i!!}u!>,},}},{{},{},{{<>}}},{{{{,<<{i!!!>!!>},<{!>},'u"e<,!!i!">},{{},{}},{!>},<">,{,<>}}},{{{<',<,},!>>,{}}}}}}},{{{{<}e"!>{!!!>!!,a}!<>},{{,{,,<>}},{<,}>,,},<'!!'>},{>,{{!>"!>,<{ue<'}{>}}}}}},{{{{{!!ea!"!i>,{,<>}},{},{{{{,,<,,ii!u!>},<,i!>,,>}},!>,<'!!!!!>{!>,<>},{},,<""uo!!!>!>"!!aa,o!uu>,},}}!i!!"!!!!!>!!!>!>},<>},{<>}}},{{{>,},<},!>,},<<,{!,}},{},,<}}!!<>}}}},{{{<>,{{}}},{{o"u!!!!!!e!!io},<>},{{!>,<,!!!!'ei!>{>},!!!>o!>},},}},{{},<'u"e}u>},},!>,!!!>!!!>!!,o!>i!!>}},{{{e'!>},,"!>!>,<>},{},{},<}u!!!a"!>}>}},{},{{{{!!"!!'!ou!>},"uuio!u{>},<,!>,}{!ae'!!!>e}>},{{},<}!!i!i{}i!ii>}}},{{{{{},>},{{{<,u"!!!>aae!u},},<{<>}}},{{{},},}},{},<,',,,<}}},{{{{,!!!!'!>,<,!!}!!!>!>,}}},{}}}},{{{{{<,!!!>},},{<>,},<'"!>,,<>}},}},{{{{{},<'i>}}},{{},{},<'!!!>,,{}}}}},{{<',{u,>,{!>!ia!>},}},{{},{!>,!>,!!!>o,o{}o>,{<>}},{{},{{<{'!>},,}}}},{{<}!>!>},},<>}}},{{{{>,},,!>},,,},{{{,!!!>,,,,,{{},<<,!!!>e!!!>'}!}!><'>}}}}}},{{{{{{},{}},i'!!!>},<}o>},{<{!>i!>},<>,,<},<>},{{{<{!!!>}!>},<'>},{{{{},},<,}!>,}e>}},{{{{!!a'{i!>},<>}}},,aa{!>},},},,<'!!!!!<,>}},<'e!!{!>},!>,<}>}}}},{}},{,}aa}>},{{'!{,'u,!>,},,},{}}},{<}"}e}!!'!>},<,!!!>}!!}>}},{{,},{{},<<}"}},{{<"!!}},!>,},,},},},,!!e!>,<>}}},{{{{{{}},{{}}},{{},{}},{{{{>},{<,!!!!!>'!,a'!!i!"aooo>}},{<'!!!!!{au!!'!eaueuo!!i'!!!!!>{!!e>},{,<'uu!>},{!>,,<>,{}}},{{<,>}},{{<"a>},{<'!!!>"!>,,},,}i!>},},,<}{,i>},{{,},}}}},{{,,<,a!!,!>!!!>'!>},<}!>,<{ua}"o>},{{},{!}">}},{,!>,,ei!>,,,<}}},{{{{{{,<">}},{},{{{{{{}}}},{,{<"iu!<<,!>"{au>}}},{{{}}}}},{{{{{{<,u}a!>,<,!>},i!>,},<,>,!<>}}},{{!>!!!>>,{}},{{}}}},{{}}},{{{<>}},{{,<<>},},>},{}},{{!>},'>},{}},{{<}{e!>},}i!>,,!!{>,<>},{{<>},!>,">}}},{{},{{{>}}}},{{{{},<!>},},<>},{}},{{},},<>},{}},{}},{{}}}},{{{,<,!!!>!!}!!!>,<"a<},{}},{{},{{!'!>e!!!>!>},,,,>,{!!{!!e!>!}>}},<'o!}!>},!e<,,},<>}},{}},{},{{{}e!!!!io!!,}},{{{'{,!!u}>},{}}}}},{{{{}},<>},{{<{!>,iu!>,}!>},<,!>">}},{{},{{{{"!>!!!!!!>}},{<'o}u>,{<}!!i!!!>},},oo>}},{{},{{{},,<"{{>},{!!!>o,,>}}}},{{<}!>},,!!}!!!oi!!>},{{<>}}}},{{{{}}},{<"!!!>},<{>,{}}}}},{{{"!>,!!}!au!!>},{{<>},{>}},{{,,ui>},{<,!>,<'!e>}}}}},{{{{<'{}u}u!>,,e!!o!o!>},<}!>}>,{!!u!!"<,!>!>!!",{>},{{{!!!>!>e}!>,,<"!!}}ii!>!!!>}>}}},{{}}},{{{{}},{<<}>}}}},{{{{{<}!}},<>},{{{{}},{{},,{,<>}}}},!!aa!>>}}},{{<{'ia}!>},},},,{}},{{{{},<>}}},{}},{,{,}}}},{{{{<}">}}}},{{{},{{{{<,{!>{!>},},,}},},""!>,,<"e!!!>},}}},{{{!>!>!>,!!!>!>,<>},{}},{{},{{{}}}},{},,{<>}}}},{{<"!e<,i>,ia,uu>}}}}},{{{{},i!!!>!>,!>!!!>!!!!>}!>},},},{,}},{<'a">,{},<>}}}},{{{{{}},{!>"o>,<>},{{},{<>,>}}},{{},!>}}>},{{<{!!!!,'e>}}},{{<{eea'!!ui"a}},{{<',!>>}}}},{{{{<,},<}<,>}},{{{}}},{{u'!!uaa!!!>},},{{<,!>},!e!!!>!!>},{<"}!!!>"}!!!><>,{}}},{{!>,!e!!!>eu,>,{}},{{!>,<,!!'},}!!!>},}}}}},{{},{},{{},{},<"io>}}},{{{>}},{{{{},{}}},{<}oo<}!!!!i<>,{}},{}}},{{},{{i!i!oi!>o"!>,},<<'>},{{},<{u!u!>{<>}}}}},{{},{{{{{{,<{!!!>!>,},<,!'{,'}},<,>},{!{>,<<}!!!>!>,e!>},<{!!!<}!!<},>},{{},{{{}}}}}},{}},{{{{{<{!!!>>},!"<"!>},{},{}},{},{{<{'io!>},<>,{},<!oa'>}}},{{{<>,},<}{a!>,<>},{{{'!>oa!>!>},!!!>!!!>a!>,,{<,}<,"i!>,<""!>!!!!!au!!}i!!>}},{<>,},{{{,,,o!!!!>}}}},{{!!!>e}i!!!>,}}'}<>},{{},{{{<{e!>}!>,{i!>,!>},,,{}}},{{{},{<'a!!{"au!!!>!>{!<}!>!>,<{>}}},{{{<}!"!!a"e>}}}},{{},i!e!!!!!!!>>}}}},{,}o!!!!!!!>,{!>,},<},!>},}}},{{<'o<'>},<>}},{{{},{}}},{{},{{'!!ouee,},<<>}},{{{}},{oee!!!>!>!>},<'!>,}}}}},{{{{{!!!>!!u!>},<>},{<,uo!!!>a>}},{{{},},,!>,!!!!!o!,>},{}},{{},<}!>iu!!a!!'e,"">}}}},{{<'!{,}a!a'!!a!><}!i}>,{<,{aii!u!!!i>}},{},{{,},{,}}}},{{{{{{<>,{,<,i,!>,,<'{>}}},{{<"u>},{},<{!},!!e!!!>!>},<>}}},{}},{{{,},<>,{,{!!!>!!>}},{{!>,!>,<">,<"i<>}}},{{{!!!>o{>,{{<}i"i}!!i{a,<}}},{{{,!!!>!!!>{!>ia>}},<,!i,u!!!>!u!>,,<>}},{{},{},{<e},,,{>}}},{{{!!!!!!!!!!!>},<,!!!>!!>}},{<}o">,{}},{<<}""}!>,<>}},{{{<"!{'a>,{o!!!!oa!>,}},{<,!>{,ii"u,!>!!!>!!!>"o"ui!'>}},{},{{!!!>,},<>},,,>}}},{{!>ae},{}},{{{},,!oie!>!>},<'!!u'!}>,{}},{{,,a{ae<}e!!,!>},!>,<>},{,},<{a!>,},>}},{<}!>},<>,!!e!u!>'a!!!!!>a!!'>}},{{{{},,,!>,'>}},{}},{{{{<"!>,!,!>},}i,a>}},{},<>}}},{{},},}},{{{{{<'!!{!>},!,a,ia!!e!>,<'}!>,<'!!!>,<>}}},{<{e!>,},}},{{{},{},,{{{{},{<"!!!>'!>''!!!>!!{{>}},},<<,,i!>},}i>}}},<',u"o,'uou!!!>,!!!u!>,>},{<"i!!'<>}}}},{{{},<},{}},{{<>,{<>}},{"!!!>,},<,<<}!>},,{}},{!'{o!!!>},!>},<>,},}}},{{{{<>},{},<<'e>}},{{{},{{},{{}}}},},!!{{u'o!>!>},,},<},!!a}>},{},''o,,{,<<',,!!!>>,{i!>},},!>},}}}},{{{},<}>},,{!>},},{{{},{{,{{},<>},{>}}}},{{u"a"'}e!>}>,{}}}},{{<}>,},{,,!!,!!ue!>!>>}},{{<"'}"!!!>>},<<"{!>aie"!>,<"e!>>}}},{{{{{<},!!!>!!!!a!>,<>},,!>,<}}},{}},{}},{{!!}!!},e{{>,{{!>,}}},{{}},{},<'{ii>,},,<,au!},e!}!>>}},{{{},{}},{{},{}},{{},{}}}},{{{{,}}},{{<"!!!>!>,,},<'>}}},{{},{{{},<{'{,!'{<>}},{{},{<"!,!}{{{!>,<>}},{{,{}}}}},{{{{{!!oe!>,'!!!>!!!>o>},},},{<<!}>,},<}!!!}u!>},!!!>!!!>!!a!!!!!!ou!>!>,<>},{}},{}},{{}}},{{{,,},!>},>,{!>"!>!>,<}}}},{{{{<'!}}>,{}},{},{{o!!"!>!!>},},},u'!{"!>,}},{{,},!!!>!>a!>},u>}}},{{{{>,{<,a''a,!!}>}},<,},<>}},{{},{{{"o{'"{}!!!>!>},<>},{,},e!>},<}"!>!!!!!o!,{<,,a!!}!!!uiuai!!!>!!,>}}},},},{{},{{<>}}}},{},{{,!!!!i!!,>},{{{},<},<<'<>},{}}},{{,<>}}}},{{},{{<e}o>},{{{,!!u!!''>},!!}iu}>},{i,!'{au{'!!!eueu>}}},{{,{!!e>,!>}!>},e!!"!"!!!!!>!e}{>},{,o!>},<'}!>},,a<"u>},{<"{!!!>,<<>,{},},<,!!eaa',<{uo>}}}},{{{{}!>},<'!e!!"a!>!<}!>,,,>},<,<,},{{{{{}},{}},{},!>"o",u'!"!!!!>>,{!!!>'{u!>},}},{{},<'!!'!>},},!e'u,>}},{{{},{},{,}''!!!ae}!>,<"o">,!>},!>},<'!>},<},a!!!>>}}}}},{{{"i!>!>e!>},<>,{{<'{!!!!<"a'ou!>},<>},{{}}}},{{,,{}},{<,!!!>!>},,,<},{}}}},{{<,o!!o!}'!!!>},<,!!!!o}!>},,>}},{{{<,!!a!>>}}}}}}},{{{},{}},{{},{}},{{{},<'!!!!!>!!,<'u!!u'!>!!}!>,<>},{{{<}"u!>!>,i<"'i!i{!!!>!>},},{<{,!>!!oa{,a,'!>},}},{{},<""!>,},<"!!!>!!!!!"!>},},<>}}}}}},{{{{{},{}}}},{{!i!!""""e>,<}>}},{{{},<,ue"eoo}"!!!>},!><>}},{{{}},{}}}},{{{{!>!>,!>},iue!>},<}!>},<},i>},{<{",},!!!>!>!!!!!>!!!>>,{i!>,,}}}},{{<"}!>},<''{!}ie}!au"},},,{{<>},{}}},{{{!!!>},},,,<'!>},},},<,u>}},{{{},<}!>},<,a<'u{,!>u!>!!!>!>},,}},{{{{}ou>}},<},{{},,>},{{!>}!a'!>,!!!!{>},{{!!!!<,!>u}!!!!e!!!>!i>}}}}},{{{,<}!a>,!!,"}<"!!,ai!>,<}u>},{},{{},},,<>},{u!!i!!!>!>"""!'ou>}}},{{{{},},}}},{{{{},<!!!!!>},a,!},{},{<"'{!>},u!!!>!'!}e!!aaa>,{}}},{{{},{},{{},},<>}},{{{{{{''{},<>}},{ei!>},<"e!!!>!!oo!>!!i>}},{{,<{ioi!>,<>,<,>},{{{eu'<>,!>!!a,>},{}},{},<{!o}'!!!!!!!>u!>!>u!!!!">,{}},{{},<}>}},{{}}}}},{{}},{{,{}oa!!!>!>,,<"!!'>}}},{{{{}},!e>},{,,!>,<<}},{{,e!{u<"!!'!!ioo},ei!!o,!!!>>},{}}},{{{,>}},{{},{{{!!!!!>!>}!>},}}},{<},}},{<{>}}},{{{},<>,!>,}}}}},{{{{{<{!u!!!aa,},,<>},{<},}},{{{{{},{<{","!!,o}!!,i!!u>,,<,a!!!!!>!!!>},!>},}},{}},!,'u!>,<},{<>,<>}},{,e!,}},{{{{{{<}{!a"!>},},!!!!u!'!>,!>!>,}},{,<"}iu!!!!!>!}>}},{<{o{!}>}},{}},{<>,<>},{{{}}}},{{<,!><{ii}!>,!>},<">},{{<'},,<>,},<{!!''}u!>i>},{},<{,{>}}},{!{!>},<<<{au!!!>e!!'!>,<,{i,>,{'},!!u"!e!!!!!>!>!,u,{!>,>}}},{{{{{a'<"!>,e!!"!!!!!>>},{{},{}}}},{{{{<'"o{!i!<,!"!,{<"!!o!>,!>!!!>{!>,,}}}},{{{{{,},},},'"}!>{'!a!>,}>},{},iu!u>,oa{'>}},{{{{},{{}}},{<{!!'>}},{{<>}}}},{{{}}},{{}!!"!!>,<',!i!,<!>,a!>},,<{!!!>{>},{{{!}e<'!>,,{}},{{,!>!>,<>}},{{{!!!>!!!>!'!!a{a!>},},}eae}},{},},!!>,{<'u,aeu!>},}}}}}},{{}}}}},{{{{},{<{!,>}},{{ui"!!i'au!>},e!!!>>},{{{!>},!}"!>!>,!!!'iee!!}>}}}},{{{},{<"!!,aa,{}}},{},{{,'!!!>!!<}!>,,<>}}},{{{<},iu!!a!>>},{{{<"i!!!>>},{{,e}!>,<"!>!o}!>,},{}}}}},{{,},,},eo!!e!u'!!!!!>{!!!!!!">,<{!!!>,o!!u"!!!>e>},!>,!!!{'!>},"i,},{,<>,<{aau{!!'"!!!!!i!!}}}},{},{{{{{,<'!>>}},{{{,<{>},{}},<}e>}},{},<{}},u!!}!{},{i'!>},<>},{{{<{'!>,<"!!,!}>}}}},{{{{{},},<{,u<>}},{<",!!!>!>},<"!!o!>!}!!!!i>,e!!!>},<}!!!>!!!!!>!!!>a!>},}},{{,<{>},{{},!!}!!i{!>,>}}},{}},{{{},{}},{{<,o'"{}!>},,{{!!io!!!>!>,},u!!"{!>},},!!{o!!!u}"!!!>u!i},,<>}},{}}},{{{},<''!u!>,<,!>!}"!>!!!>},!>},<>}}},{}},{{{},{{{{{},<'!!!>a!o!>},<>},{!!!>u!>,}},<"}!>,},!>,},{{},<{!>!>oiia!!!>,a!!u!>!!a!>},<>}}}}},{{{{<>}},{{{},<,<},e<>}},{{{<{!>,<{>}},<>}}},{{{},{{{},,<'i!>},!!!>!!{}>},{{<,ui!>,!!}}!'!!!!!>>}}},{{{},<,{!!",},,{},<'"!>},!>},},},<{!>},'aa>}},{,a!!!>!!a'}>}},{<''!"e{,,<>}}}}}},{{{{{{},{}},{},{{},<,!!,o'!!!>ea!>,!!!!!!!!!>,<>}}}},{{!>},a!>,,"!>,>,u!>>}},{{{{<!>}!!!!!!!!!!e<,{{o!!!>!!!>'"e'>},{,}}},{{<}!>},{!>},>}}},{}}},{{,<""!!!!!>">,{}},{{},,}}uoou!'!>},<'>}}}},{{{{,,<,,<!>,},{},{{{!!!!oe!>""},<,>}},<,!e!<>}},{,<"!!!>ii}"!!o!!!>!!!{!i!!!>},<"!o!!u!}>},{{{<'!!"!>ea'}!>},<>,<}!>,<>},{{},,,},,,<,<}>}},{{{{<"}!!e>}},<}!>},!!!!""e'!!!>u'!!!i!!!>!!!o!>,,<>}}}}},{{{{!>},<{!>!!{>},{{u!>},>}}},{{}},{a>}}}},{{{}i>,{,<!!'i!!,a!a}>}},{{{}},>},{{{{,,<}}}}},{{{<{,,<'!>,!>},<,>},,<>},{{},<>,,e!>},<}"!>!{!!!!}i!i!!!>u>},{{{},{{}}},}a,{'!>,<{>},{{,<"u}>}}},{{<'u!>,},<},>},<{e>}}},{{{{<{ouu},,!!e}i!!a!!">},{},!!!!!>},},},{{{>},{{a!>,,,!!e!>,<>}},{{{a'a>},<>},{,!"!!!>,,>}},{{{{<'a!!a!iae}u!!!!a!!"!!!>'!>},<>}}}}},{{{{},{!'>}}},{{{{},<{,oaa!>{,}},{{{!!"{>},},}},{{<'!ia!!!>>}}},{{ea!!,<}!>!'i"!!e'}!{!!>,,!!{!>!!!>},}},{{<{}!!!>"!},{{{{<{e'e"!>},,,<',!o!!!>,!!!>oe,{<'!!!>!>!>,}}},{{<'!>},u!>!!!!{!>},<{'!>},<">},{}},{{<'!{"!!!>!!"">,<'ei"!!oa>}}}},{{!'e"i{i!!">},{}}}}},{{{{<"i>,{}},{},{o>}},{{{!!!>},!>,},{}},{},,<>,{}},{!>o"!>},}},{{{<}!!'o{!>},},}},{{{,},{{,}}},,<'o},a{!>u!!!>},},!>,},<>},{{{<,{},},<},!!}!!!!!>">}}},{<>,{,!>!>}!>,},}},{},o{<}!<,e!>,>}}}},{{'!>",u,!}<,!!!>},<>,{{},{,<}o{"!!!!u!!o!>o>}}}},{{{},{<'!e'!!!>!!!>a!>},!!!!i>,!!!!!!!>!>,<"!!!>!"',}uo"!!o>},{{!>a"o',>},{{{{},<}!>},},<'!>,<>}}}},{,!>!!!>!!i>}}},{{<{oa<}ou!!aa!!!{>,{}},{{{<{!!e}e!>!>,,!!!><>}},{}},{<>,{!>},!!!!ae''!!"u!!!>,}}},{{<}oi"uue!}eiu>,{!!}o,>},{{},{{<}!>,},!!!'>},{{},o>},{<,!"'!>'e'!>!>},"!>>}}}},{>}}},{{<}!>},<'!>,!!}!>,,},{{{,}},{{{u,>},{a'!!i!!!>u>}},{{},{}},{<"o!!'<,<}},{<,o!!!>!<,>,{}}},{{<}>},{<"!!o'!!a!!!>'>},{{{{,,},{},<>}}},{}}}}}},{},{{{{},{}},{{,,<}o'!>,,>,{{!!!>}}{!!!>!!i!>},<>}}},{}},{<,<'!!!>ei!>,},},<>,{}}},{{{},<}!<'{!au!!{!!}>},{<'u!!{a,!!'!}oo}},{{{<'!!!{!!!>!!a!>>,<'<"'!i}o!u>}},{{!!!!!>a}!!!!i!!!>}>},{>}},{{{{,<>},<,!u,!!e{!!i!>,<,!>},!"!!!>>},{},{{{<,}}"!!!>u<>},{}},{{!!<>},{}},{<{!>},},,,!{!!!>},}}}}},{{},{}}},{{{},<{}'{}!!ao,>},{{,},<{!!!>u!!!!!>,<},{{},{<,>}}}}}},{{{{{{},ui!!}!>ao!,>,{<,o'a!!!!!!!>'i>}},,<{au!a!>,,<>}},{{{,,},}},{{<"!!u"!!!ao'>,{},<o!!!>e>}},{{{{},{,{,<>}}}},{{},<"{>}},{{,!>,,},<{>}},{{{,<>},{<{!>,!!a!!e!!',i>}}}}},{{}}},{{!>},!>,<'o<,i'!>,,<,!uo>,,'{i!>"!>},,<}!'!iu>},{{},}}},{{}},{{{{},<,!>},},{}},{{}},{{,eee!!!>!>},,<"!!>},{}}},{{{{,},},,{!>!!!>'!>},}}}},!>,}u!!>},{{},},<'o!!!>{!!!>},!>},<,"!!!>i'>}}},{{{<,!!},,<,!!!!!>,!>,'!>},<>,{!ai!>},}}},{{{,,<'!"},>},{}},{{},{ao'{!}<>}}},{{<"a!!!<',!,ou>,},<,!}"!!!i!>,<},},<>},{{{},"!!o">},{{<}!>},,o!!e{,<{>}}},{<>,,<}!>!,ouiou!!'o!!!!!>i{>}}},{{{{<"!'}>}},{},,!!!>au!!}e!>>,<"!!a!!!>,},{},<},<{>,{{},}"{"!>,},<>}}}},{{},{{{{!>},<""'o!>!>>}},<},<{!!!>o!!{'!>,},},{{{<,<",au!!!>!!"!>!!!>!>},<'e!>u>}}},{{!!!>,!o!},<>},!>,!>},,},},}}}}},{{{<>},{{},<,!>},},},,,},{{<},{},}}},{{{},>}},{{o>,{,,!>!!e!!!!}'>}},{{}}},{{{{,,,<"!!!!!>a{,!!!!!!"a'>,}},{{{{}},{},{,}!!},<'ou!>,,}},{{{{,,<,!o}">},}},{{<}!!,!>,"!>,},a!'!!!>!!!>>,}e!!u!!!>}}},<<>},{<{,>}},{{},'!>!!!>!!>}}},{{!>},!>,<'!!!>'!!e!!{i>,},"i!>i'!!,e!>,},<},},{{{<"!!},<,!>,}},{{},<"!!i!!!>,},{{{<}{!>,},<>}}}},{{,!>,,<'o!>,<,,!!!>i!>},},!>!!!>,},},<}o'!>,,<>},{,,<,!!!>u!!!>,>},{{!,{!>},},,e!'oe!>,<'!>},},{{},<}"!!!>!>,,},{{}}}}}},{{<>},{<{!>!>!!!>!!!>!>,>}}},{{}},{{{{}}},{}},{{},{{{},{<{!>,<''!>,<',,>}}},{{<e,!!!!a!!<"u{!>},},},<'>}}}}}},{{{{{},},!>,<>},{},},<}>}},{{<{!!">},{<<>}}},{{{},{'!>!!'i!!!>},}},{{!!>}}},{{},,,a,>,{{},<,{e{!>,}e!>,}}},{}},{{{{{{<{e!!!>!!!>!!!>,,<"{>},<}<},{{},<}!!!>'!!ee!>!"a!!a'a!!!>},!>},<>},{!!!>!!!>!!!!!>!{!>>}},{}},{{{ue""!>,<>}},{{},,},,},<>,<>},{{{}o!!"i!>,<"!!!>{"o!!!>>},,<"!>},<}!!o'!>{e">},{{!u},{',!!!>!eo{oe!>{>}},{{!!!>i!!!>!!!}'>,},<"o>},{},{{{<}a!!}!!}u!>,e'!!!>,<,<>},<}!>!>},!>},<,},o"u!!!!!'{!!!>>},{{{,{{<{}'>}}},{{{u>},{{<>},{<{!>},<>}}},{{!}!!!>!"!>},<"<<>,{!},!!!>!>},},>}},{{},<},<>,{<>}},{},},,<}u>}}}},{<}'!>},<<"u!!!>!o!>a>,{<'{a>}}},{<<,!!{!!!>,!!,'ua!!!!!!!>,,},<'!!!!!!>,{}},{{<"e!o!!a,!>,!u{<>,,,},,<a!>},,<}o>}}}}}},{{<'{!>,<}""!>,!e"e>},{>}}}},{{{<"!!!,u,!,!<},>},{}},{,,<}'{"!e'o!!a!!!>!!{}!!!!>,},>},{}},{{{{},!>,,<'e!!!>!!o!>!"!>},},<"a!>,<'>},{},,{<'o!>!}}},{{{},,<,}i!>,<{!>},},<},<>},{{{{},<,,{!>,},<',u"!o>},}},{<'i!>},,,{}},{{{{}}}}}},{{{{{}}}},{},{}}}},{{},{}}},{{,!!!>!!u'i!>!!!>!!!>u{!>},!!!!!!!>>,{}},{{},{{{{},{}}}}},{<,!!!>'}eu<}!ii!>,,<'i}!>o>}}}}}} diff --git a/09/lib.scm b/09/lib.scm new file mode 100644 index 0000000..5eac027 --- /dev/null +++ b/09/lib.scm @@ -0,0 +1,70 @@ +(library (lib) + (export solve-part1 solve-part2) + (import (chezscheme)) + + ; Global state... a sin, but very convenient in this case! + (define chars '()) ; Characters still to be parsed + (define part1-total 0) ; Total score of groups in input + (define part2-total 0) ; Total non-escaped garbage chars + + ; Is the next character in the stream equal to `c'? + (define (peek? c) + (char=? c (car chars))) + + ; Blindly accept character and pop it. We do all detection + ; via `peek?', so we don't care what gets discarded here. + (define (next) + (set! chars (cdr chars))) + + ; Parse a "group". We can assume all input is well-formed, + ; which really helps keep this code as simple as possible. + (define (parse-group depth) + (next) ; Accept initial #\{ + (let loop () + ; Expect start of "group" or "garbage" + (cond + ((peek? #\{) + (parse-group (+ depth 1))) + ((peek? #\<) + (parse-garbage))) + ; Expect comma or end of current "group" + (cond + ((peek? #\,) + (next) ; Accept #\, + (loop)) ; Parse next "group"/"garbage" + ((peek? #\}) + ; Add current group's nesting depth to total score + (set! part1-total (+ part1-total depth)) + (next))))) ; Accept #\} and return + + ; Parse "garbage": everything until next non-escaped #\>. + (define (parse-garbage) + (let loop () + (next) ; Accept char (#\< at first) + (cond + ((peek? #\>) + (next)) ; Accept #\> and return + ((peek? #\!) + (next) ; Accept #\! + (loop)) ; Continue to escaped char + (else + ; Add this character to the total count + (set! part2-total (+ part2-total 1)) + (loop))))) + + ; Reset global parser state and parse the input string + (define (solve-puzzle str) + (set! chars (string->list str)) + (set! part1-total 0) + (set! part2-total 0) + (parse-group 1)) + + (define (solve-part1 str) + (solve-puzzle str) + part1-total) + + (define (solve-part2 str) + (solve-puzzle str) + part2-total) + +) diff --git a/09/main.scm b/09/main.scm new file mode 100644 index 0000000..b4b540a --- /dev/null +++ b/09/main.scm @@ -0,0 +1,14 @@ +(import (chezscheme)) + +; Where the magic happens +(import (lib)) + +; Read my personal puzzle input +(define input + (call-with-input-file "input.txt" get-line)) + +; Part 1 gives 21037 for me +(printf "Part 1 solution: ~a\n" (solve-part1 input)) + +; Part 2 gives 9495 for me +(printf "Part 2 solution: ~a\n" (solve-part2 input)) diff --git a/09/test.scm b/09/test.scm new file mode 100644 index 0000000..6d232da --- /dev/null +++ b/09/test.scm @@ -0,0 +1,68 @@ +(import (chezscheme)) + +; Where the magic happens +(import (lib)) + +; My quick-and-dirty unit testing framework (copied for each day) +(define (run-test name proc input expected) + (let ((result (proc input))) + (if (equal? result expected) + (printf "\x1b;[32;1mPASS\x1b;[0m: ~a\n" + name) + (printf "\x1b;[31;1mFAIL\x1b;[0m: ~a: got ~a, expected ~a\n" + name result expected)))) + +(printf "Part 1 tests:\n") + +(define (test-part1 name input expected) + (run-test name solve-part1 input expected)) + +(test-part1 "part 1 example 1" + "{}" 1) + +(test-part1 "part 1 example 2" + "{{{}}}" 6) + +(test-part1 "part 1 example 3" + "{{},{}}" 5) + +(test-part1 "part 1 example 4" + "{{{},{},{{}}}}" 16) + +(test-part1 "part 1 example 5" + "{,,,}" 1) + +(test-part1 "part 1 example 6" + "{{},{},{},{}}" 9) + +(test-part1 "part 1 example 7" + "{{},{},{},{}}" 9) + +(test-part1 "part 1 example 8" + "{{},{},{},{}}" 3) + +(printf "Part 2 tests:\n") + +(define (test-part2 name input expected) + (run-test name solve-part2 input expected)) + +(test-part2 "part 2 example 1" + "{<>}" 0) + +(test-part2 "part 2 example 2" + "{}" 17) + +(test-part2 "part 2 example 3" + "{<<<<>}" 3) + +(test-part2 "part 2 example 4" + "{<{!>}>}" 2) + +(test-part2 "part 2 example 5" + "{}" 0) + +(test-part2 "part 2 example 6" + "{>}" 0) + +(test-part2 "part 2 example 7" + "{<{o\"i!a,<{i}" 10) diff --git a/10/input.txt b/10/input.txt new file mode 100644 index 0000000..59db45c --- /dev/null +++ b/10/input.txt @@ -0,0 +1 @@ +31,2,85,1,80,109,35,63,98,255,0,13,105,254,128,33 diff --git a/10/lib.scm b/10/lib.scm new file mode 100644 index 0000000..11ad449 --- /dev/null +++ b/10/lib.scm @@ -0,0 +1,123 @@ +(library (lib) + (export solve-part1 solve-part2) + (import (chezscheme)) + + ; Split list at first delimiter into `prefix' and `suffix' + ; Return value is a pair like `((p r e f i x) s u f f i x)' + (define (list-split-left delimiter? xs) + (let loop ((prefix '()) + (suffix xs)) + (if (null? suffix) + (cons prefix suffix) + (let ((x (car suffix))) + (if (delimiter? x) + ; Found first delimiter, so return immediately + (cons prefix (cdr suffix)) + ; `x' isn't a delimiter, so append it to `prefix' + (loop (append prefix (list x)) (cdr suffix))))))) + + ; Split list at given delimiter into list of sublists + (define (list-split delimiter? xs) + (let loop ((pieces '()) + (rest xs)) + (if (null? rest) + ; Fix order and remove all empty sublists from output + ; (which are caused by consecutive delimiters in `xs') + (reverse (remp null? pieces)) + ; Extract next piece from `rest' and prepend it to `pieces' + (let ((next (list-split-left delimiter? rest))) + (loop (cons (car next) pieces) (cdr next)))))) + + ; Split string at commas into list of substrings + (define (string-split str) + (define (char-comma? c) (char=? c #\,)) + (map list->string (list-split char-comma? (string->list str)))) + + ; Reverse order of numbers in index range `[pos, pos+len)' in state + (define (reverse-range state-old pos len) + (define state-length (vector-length state-old)) + ; Initialize `state-new' as a copy of `state-old' + (define state-new (apply vector (vector->list state-old))) + (let loop ((i 0)) ; `i' is the offset from `pos' + (if (>= i len) + state-new + (begin + ; Copy `state-old[pos+i]' to `state-new[pos+len-i-1]' + (vector-set! + state-new + (mod (+ pos i) state-length) + (vector-ref + state-old + (mod (- (+ pos len) i 1) state-length))) + (loop (+ i 1)))))) + + ; Apply a single round of the (main phase of the) hash function + (define (single-round lengths0 state0 pos0 skip0) + (let loop ((lengths lengths0) + (state state0) + (pos pos0) + (skip skip0)) + (if (null? lengths) + ; Once we've exhausted `lengths', return the full internal state + (values state pos skip) + ; Call `reverse-range' for `(car lengths)', and update state + (loop + (cdr lengths) + (reverse-range state pos (car lengths)) + ; (We just let `pos' grow, ignoring circularity) + (+ pos (car lengths) skip) + (+ skip 1))))) + + ; Apply `single-round' `n' times, reusing the full internal state each time + (define (multi-round n lengths state-old pos-old skip-old) + (if (<= n 0) + state-old + (let-values + (((state-new pos-new skip-new) + (single-round lengths state-old pos-old skip-old))) + (multi-round (- n 1) lengths state-new pos-new skip-new)))) + + ; Initialize state and apply `n' rounds of knot-tying algorithm + (define (solve-puzzle n lengths) + (define state0 (list->vector (iota 256))) + (multi-round n lengths state0 0 0)) + + ; Convert "sparse hash" to "dense hash" as per part 2's description + (define (sparse->dense sparse) + ; At first, storing `state' as a vector was more convenient + ; because of all the indexing, but now a list seems better. + (let loop ((state (vector->list sparse)) + (dense '())) + (if (null? state) + (reverse dense) + (loop + ; Remove the first 16 elements from `sparse' + (cddddr (cddddr (cddddr (cddddr state)))) + (cons + ; XOR together the first 16 elements of `sparse' + (apply bitwise-xor + (list-tail (reverse state) (- (length state) 16))) + dense))))) + + (define (solve-part1 str) + (define lengths (map string->number (string-split str))) + (define state (solve-puzzle 1 lengths)) + (* (vector-ref state 0) (vector-ref state 1))) + + (define (solve-part2 str) + ; For part 2, `lengths' must be initialized differently + (define lengths + (append (map char->integer (string->list str)) + '(17 31 73 47 23))) + (define sparse-hash (solve-puzzle 64 lengths)) + (define dense-hash (sparse->dense sparse-hash)) + ; Convert `dense-hash' into lower-case hexadecimal representation + (let loop ((bytes dense-hash) + (final "")) + (if (null? bytes) + final + (loop + (cdr bytes) + (string-append final (format #f "~(~2,'0x~)" (car bytes))))))) + +) diff --git a/10/main.scm b/10/main.scm new file mode 100644 index 0000000..554b259 --- /dev/null +++ b/10/main.scm @@ -0,0 +1,14 @@ +(import (chezscheme)) + +; Where the magic happens +(import (lib)) + +; Read my personal puzzle input +(define input + (call-with-input-file "input.txt" get-line)) + +; Part 1 gives 6952 for me +(printf "Part 1 solution: ~a\n" (solve-part1 input)) + +; Part 2 gives "28e7c4360520718a5dc811d3942cf1fd" for me +(printf "Part 2 solution: ~a\n" (solve-part2 input)) diff --git a/10/test.scm b/10/test.scm new file mode 100644 index 0000000..50a425d --- /dev/null +++ b/10/test.scm @@ -0,0 +1,42 @@ +(import (chezscheme)) + +; Where the magic happens +(import (lib)) + +; My quick-and-dirty unit testing framework (copied for each day) +(define (run-test name proc input expected) + (let ((result (proc input))) + (if (equal? result expected) + (printf "\x1b;[32;1mPASS\x1b;[0m: ~a\n" + name) + (printf "\x1b;[31;1mFAIL\x1b;[0m: ~a: got ~a, expected ~a\n" + name result expected)))) + +; I've disabled part 1's test because it uses a 5-element list +; instead of 256 elements like the main problem and part 2, and +; I'm too lazy to structure my code properly to deal with that. + +;(printf "Part 1 tests:\n") + +;(define (test-part1 name input expected) +; (run-test name solve-part1 input expected)) + +;(test-part1 "part 1 example 1" +; "3,4,1,5" 12) + +(printf "Part 2 tests:\n") + +(define (test-part2 name input expected) + (run-test name solve-part2 input expected)) + +(test-part2 "part 2 example 1" + "" "a2582a3a0e66e6e86e3812dcb672a272") + +(test-part2 "part 2 example 2" + "AoC 2017" "33efeb34ea91902bb2f59c9920caa6cd") + +(test-part2 "part 2 example 3" + "1,2,3" "3efbe78a8d82f29979031a4aa0b16a9d") + +(test-part2 "part 2 example 4" + "1,2,4" "63960835bcdc130f0b66d7ff4f6a5a8e") -- cgit v1.3