From d3d97e1db3b2819193128ccf7b59e58f3391b6b1 Mon Sep 17 00:00:00 2001 From: alexchao26 Date: Sat, 5 Dec 2020 17:48:04 -0500 Subject: [PATCH] too slow for day20 --- 2018/day20/input.txt | 1 + 2018/day20/main.go | 256 ++++++++++++++++++++++++++++++++++++++++ 2018/day20/main_test.go | 116 ++++++++++++++++++ 3 files changed, 373 insertions(+) create mode 100755 2018/day20/input.txt create mode 100644 2018/day20/main.go create mode 100644 2018/day20/main_test.go diff --git a/2018/day20/input.txt b/2018/day20/input.txt new file mode 100755 index 0000000..8057ab5 --- /dev/null +++ b/2018/day20/input.txt @@ -0,0 +1 @@ +^WSWSWSWNWSSWWWWWNENESENNWWNENENESENEEES(SWNWSS(WW(SS|N(W|E))|E)|EEENNEENESSWSSSSEENNESSENESSWWWWSWWWSWWSSSEEENEENWW(WWSEWNEE|)NEEESSENEENN(WSWNWESENE|)ESENENEEENEESWSESWWNWWSESWW(N|WSEESSSWWWNN(ESENSWNW|)N(WSW(SESSWSSSESSSSWWWSWWNNNENESS(WSNE|)EENWN(E|NWNENWNEN(NWWS(WN(NEEEWWWS|)WWWSEESSESWWNNWWSWNWSWNWNWWSSWWWSESENESENN(ESSSSSSENNNESENNN(WWSEWNEE|)ESE(ESWSW(N|SESSWWW(NE(NWES|)E|SESWWWWWSESWWWWWNWWSWWWSSSWWNWSWWNENWNENENNESSE(EEENWNNWSSWNNNNWWSWNWNENNWNNENEESENESEENNW(WWWWNWSWSWSSSWNNWSSWWNENWWNNNNWNWSWSSSSSWNNNWWSWSWSESEE(NWNENSWSES|)SENEENNE(SSE(N|SEESENESSSE(NNNEWSSS|)ESSE(NEENSWWS|)SWWS(WNWSWWWWSWWWNWNEEE(SWEN|)EEENWWWWNENESENEEE(NWWNWWS(WWWS(WNN(WSWNN(WSWWWNWWWWWWNWNEESENENESS(EEEE(SWEN|)(NWNWSWNNEENEE(SWSNEN|)NE(S|NWNENNENESESWWSEE(SSWNWS|ENENWNWNWWWWWWSEE(SWS(E|SSWS(E|WWNNNWSSWWNWWSSE(N|EEES(WWS(WWN(E|WWNNWNENE(SSS|EEEE(S|NENEE(NNNWNWNWNWNNEENEEESSWW(NEWS|)S(WNWESE|)ES(W|SESEES(WW|ENNWWNEENWW(WSNE|)NNNNNESEEESSSW(WWNNEESW(ENWWSSNNEESW|)|SSEESWSEENNNNNNEEENNEENESSESSWNWNWSSWSWW(NEWS|)SSEEN(W|EEEEN(ESESSWSSSWWWSESWWSS(WNWNNWNWN(WWWNNSSEEE|)EEENES(EEENNN(E|WWWS(ESEN|WWWSE))|SSW(NWES|)S)|SSEEEE(SWSWWWNEE(WWSEEEWWWNEE|)|NNES(S|EENNW(S|NWN(WSS(W(WSW(SEENSWWN|)N|NN)|E)|ENNEENWW(WSSNNE|)NENWNEESSENEENWNNWNWNEEEESSS(WNNWESSE|)EENNNW(SS|NENNENWNNEENNEENWNWSWNWSSWNNNNNWSWSESSWNWSWWSSSWWNWSWWNENWWSWSSE(ESENESESWWSS(SSSENNNEN(EEEENNNNESESSS(ENNNNWN(EEENSWWW|)NWWS(E|W(N|SSSSWNNW(SS|W)))|SW(WWWWSSSS(W(W|NNN)|E(ESNW|)N)|NNN))|W)|WNNWNWWWWSES(ENEWSW|)WWWSES(ENSW|)WW(SSSSWENNNN|)NWNWW(SEWN|)WWWNNWNWSWWWWNNNWNWWNWNWWWSESWSSESWSSSEENN(WSNE|)EENWNEE(NWWW(W|SS|N(E|N))|SSE(NN|SEESENEESSW(N|S(WSWWSWWWWWWSSW(NNNNNEESWSEENNNEE(NWWEES|)SWSSENE(EEN(WNWSNESE|)E|S)|SSESWSSSSENNESENESENESEE(ENNN(ESSENSWNNW|)WSW(SEWN|)WNNE(S|N(ESEWNW|)WNN(ESNW|)WWSSWW(NNESNWSS|)(SESWS(EEENN(WSNE|)NN|W)|W))|SWWWWWWS(SSSESSES(E(EEE|N)|WSSSSWSWW(SEESSEENNN(WSSNNE|)EN(EESSEEESWSWWSESWSEENEENN(WSWENE|)EEESESSWWW(SESSSWSESSENNENWNNEN(EESWS(EENN(NWNNW(NNW(WNN(WSWS(WNN(E|NWSWNWS(NESENEWSWNWS|))|E)|ESEESSEENW(ESWWNNSSEENW|))|S)|SS)|EEESSWNWSSWSWW(NEWS|)SEESESSWWWSESEESESWWNWWSWNWSWWSEESWWSSEEN(ENNEE(N|EESSWWSW(NNEEWWSS|)WSWWWWWWNENWWSSSSSSWNNNWSSWNWWNENWNNEES(W|S(S|EENNNENNENEE(EENNNN(WWSSWS(EENNSSWW|)WWSWSWWNENNNEEE(SWWSNEEN|)ENWNWNEEE(ESWWEENW|)NNNN(ESNW|)WWWSEESSWWN(WWWSESSWNWWSWWNNE(ENWNWSW(SSSSSSSESESSENNE(NENNWN(EEE(NNN|E)|WSS(SWNWNENW(ESWSESNWNENW|)|E)|N)|SSS(WWSWNNW(SSSSEE(NWES|)SWSW(SSSSEENWNEEE(SSESSESENNWNN(NWSNES|)EEENENNW(NEEEEESENESSSSEESSESSWNWWNN(ESNW|)WWWNWSWW(WSW(NWES|)SESWSS(ENENNNEEEEESWSSWS(WW(NNNEESWS(NENWWSNEESWS|)|W)|EENESEN(NWWEES|)EES(ENNEENWNW(NWNEENWNENWWWNEENESENESEENNNENWNWNENENESENNNWWNNNNNESSESWSEEESEENWNNWNW(SSEWNN|)WN(NWWNEENWN(E|WSWWSESSWSSE(SWSESS(EE|WWN(E|NWNNE(S|NWWN(WSWSESSE(SSW(SESESSW(SSS(ENNE(NNNEN(WWNNSSEE|)E|SE(S(W|S)|N))|W(NNN|WWS(W(SSSSEENW(ESWWNNSSEENW|)|W)|E)))|N)|N|WW)|NN)|ENE(NN(WS|NEE)|S|E)))))|N))|EEEES(W|SEENEENW(WWSNEE|)NENEN(WWSNEE|)E(N|SESSWW(NEWS|)SEEENENWNEN(WW|ESSESESSSWSSWSWNWNENE(S|NENW(N|WSWSWSSWSEESWWWSSWSWWNENWNWN(NNN(W|EESWSES(E(S(S|W)|ENWNNEE(SWEN|)N(E|WWW))|W))|WSWWSW(NN(N|EE)|SWWS(WNSE|)SESSESESESEESSSWSEESWWSESWSEEEES(EENESEEEEENWNEENNNWWNENESESSENEESSSSWWNW(NEE(S|N)|SS(WNSE|)EEEENEES(W|EEENWWNNNEESWSEEESS(WNSE|)ENENWNWNNNEEESSW(NWSNES|)SEEENWNENNW(NEEENENWNENNENENNWSWSWNWNNNEENWNENNENNWNNEENENNNWWWNNESENNNNWWSESWWNNWWSSSE(ESSSEEESWSWNWWNWSWWWSESENEEESWSESS(E|WSWNWNE(E|N(N|WWSWWSESE(ESWSSWNNWNWWNNNWWWNWNEESENEENNNEES(ENE(N(EESWENWW|)WNWSWNWW(S(WWWN(EE|WNW(SSESSES(ENN(W|EESWSE)|WWNWSSSSE(ESWWWNWSWSESEESSSWWSESWWSEEESSSENNESSESSWNWSWNWSSEEESSEEEEEENNESE(NNNNNNWSSWSWS(EENSWW|)WNWSSW(S(WN|EENES)|NNNENWNEESE(SWEN|)ENWNENEEN(EE(NENN(EN|WSWS)|SWS(WW|SSSESWSSEE(SWWEEN|)N(W|NENWNWNN(SSESESNWNWNN|))))|WWNNWWWWWWSEESESS(ENENNW(S|W)|WW(SS|N(E|NWSSWNN(WSNE|)NNNNEN(WWW|ESS(EE(NWNN(ESNW|)W|EE)|W)))))))|SSW(WWWWWSS(WWWW(SSSEENWNE(WSESWWEENWNE|)|NNWWNEEN(WWNWWSESS(SEEWWN|)WNWNWWNWSWNWWSWSSWNWWNNEE(SWEN|)ENNNNENNN(EENESSWSW(N|SSWSEENNESSS(EENES(SWEN|)EENWNWWNENE(EESE(SW(WNWESE|)SS|N)|NWNENENWNWW(NENE(ES(ES(ENSW|)W|W)|NWNENENWNWN(WS(SES|WN)|EESENE(SSWENN|)NN(E(NNWSNESS|)E|WWS(WNWSNESE|)E)))|SS(ENSW|)SSSW(W|NNNN|SSS)))|WWW))|WSSWSSSWWWNWSSS(E(NEEEWWWS|)SSSEESEESESSS(WW(S|NENWNWW(NWES|)SSS(ENN|WN))|ENNNNNEE(SSSW(NN|SSS(ENNENES(NWSWSSNNENES|)|W))|N(WW(WSSNNE|)N|E(S|E))))|WNWNWNWNEENENE(SS(EESENSWNWW|)WS(S|W)|NWWSWSWW(EENENEWSWSWW|))))|ESSSENES(NWSWNNSSENES|)))|EE(NWES|)SS)|N))|NN))|NENN(WSNE|)NNE(ENNNWESSSW|)S))|E)|NEEEENE(SS|NNWW(NENWNEEEESESS(WWN(WNEWSE|)E|ENNNESSEEENWWNNEEENWWWNENENWWNEENENNWSWW(S(WSWW(NEWS|)WSSSEENE(NWWSNEES|)(SSWS(W(S|WWN(EE|WWS(E|W(WSNE|)N)))|E)|E)|E)|NENNNW(WWWNWSWWNWW(WWNWW(WSSNNE|)NENNNW(NWNNENWWNNWNWWSESWSSWSSWSWSWS(WWNWSWWS(E|SWSSSWSSWNNWWSSSWWSWSSS(WNNNNWNNEEENE(SSWW(W|S)|NN(WSWSNENE|)ESENNESE(SWEN|)NN(WWWSNEEE|)NNE(SS|NWNNNEENNENENENW(WSW(SW(SS|W)|N)|NNENWNW(WWWNW(NEENESES(WW|ENESEESESSWSEEEES(ENNNWNWNENNWWS(E|W(NNNEEES(WW|ENEEESSSWWN(NESNWS|)WSSSESESESSEENNNESSSESEESEENESEENNNESENENEEENNENWNNENWWSSWWNENWWSWWSESSES(ENEN(ESSW|WWN)|SWNWNNWWWWWNWWWWNW(SSEEEESSW(NWWWS(WNWN(W|E)|SS)|SSENEENN(WSNE|)EEESWSW(SEE(NEWS|)S(WWW(S|W(NEWS|)W)|S)|N))|NNNENNWWWNNWNENESSSEENNW(NNEEENWWNWSWSWNWWNEEENWWNEEENWWNNWNENWNEEESSW(SSEEENNNNNNNWNWNNEES(W|SEESWSEESSEEEESESSENEEENENNNESEENNNWNWNEEEESENN(WWWWWWSWWWWSSESESE(NNN(W(S|W)|ESSE(ESNW|)N)|SSWSWWNEN(NWNWNNNWSWNN(WSSWW(SES(SSEEEE(NWWNENWWSS(NNEESWENWWSS|)|S|E)|W)|WNN(ESENSWNW|)W(WWWWWWSSEE(NWES|)SSESES(SSSSWENNNN|)WWNWSWWNENWN(EESNWW|)WWWSESE(N|SWSSENESSSSESWWWSWWWWWNNESENNWWNNESEESSE(SWEN|)ENN(ESSNNW|)W(S|NNNWSSWNWWWSWWSSSSENE(NWNEWSES|)SSWSSSENEN(EEESENESE(NENWESWS|)SSEESWSWNWSWWSWSSWWNNWSWSESSWNWNNWWSESWWNWWWWWWWNWNENEENWWWSWWWWSEESE(SESWSESWWNWNN(ESNW|)WSSSWNNNWSSWSESEESWWWSSSSSENES(SWSWNWWNENWNNWNWSSWSWNNWWNEEE(NENWWWWNENESEENWNWNWWNWNWSWWWNWSSSEEN(ESEE(NWES|)S(ENEWSW|)SWNWWWWSESSENNESEES(EEE|SWSESWWSWNNWN(WSSESWSWS(SENEEEEEESSWNWWS(WW(NE|WWSEE)|ESEEEEEEESS(ENNEEN(ESNW|)WWN(WSWNNENN(WSWWSSE(N|SWWNNNNNWSWWS(EE|WWW))|N)|E)|W(S|NWWS(WNWSWN|E))))|WNWWNEENNE(SS|NNN(ESNW|)NNWSSWWSSSE(NENWESWS|)SWW(S|NWNNNE(SS|NWNWWSW(NNEENNENWWW(SESWENWN|)NEEENNNESESWSESSW(N|SWSEENES(SW(SEWN|)W|ENNWNENWNENESS(SSSS|ENNENWNEESSSWSEE(SWEN|)NNNESEEENENNWWWS(SENEWSWN|)WWNWNWSWWNNNNESS(EENENWNENWWNWSWWWWNWWNWSSSWW(NNE(S|NWNEENNNESSEESEENWNNNN(EESSS(WNNSSE|)SESS(W(SWNW(WWNWESEE|)S|N)|ENNENESSEENNNESSESWSEESSESSENENWNWNNNNNWNEN(ESEEN(W|ESSWWSSSW(SEES(SEENESEEESWWWSSSWSWNWSSWWSESWW(SEESENNNESEESWSW(N|SEESE(S(WWWWWNN(ESEEWWNW|)WNWW(SWW(SEEE(ESW(SEES(W|EE(N(ESNW|)W|SWSSW(NN|SEE(N(N|E)|S(SS|W)))))|WW)|N)|WWNEEE)|N)|EE)|NN(ENNW(NWN(W(S|W)|EN(NENWNEEENNEEENENWNWNENEENNWWWN(EEEEEEEESWWSSWSW(NNNESNWSSS|)SSENEEN(ESESSE(NENWNNW(S|N(WSWNSENE|)NEN(W|ESS(SSENESESS(ENE(NNE(SSEWNN|)NNEES(W|EENWN(E|WWWWWWWSS(WNNSSE|)EE(ENWWEESW|)S(W|S)))|S)|WW(SW|NE))|W)))|SSSSWSESESSSSESENESS(E(NE(S|NWN(W|NESEES(SWN|EN)))|SS)|WWSWNNWNWNWNEE(NWWWWNNNWWNWSSESWWSWNNENNN(WWWSES(ENSW|)SWWSW(NNEEWWSS|)WSEEESSEEN(WNNWESSE|)EEEN(W|E(SEESWWWWS(ESSSWS(WNSE|)EENNNESEEE(S(ENSW|)WSWNWS|NWNW(S|WW))|W(WWWSWWNENNW(S|W)|N))|NN))|NEN(NNWNEWSESS|)ESENEESWSS(WNWWEESE|)EE(SWSES(W|E)|N(W|E(S|NWNNWW))))|S)))|W)|WSWNWWSWSESWSESEESS(EN(ESNW|)NNWNN(ESENEE|W(SS|N))|WWWN(NWWW(WNEN(ENNE(SSSWENNN|)N(E|W)|W)|S(EE|S))|EE)))|W))|S)|W)))|NNNNWN(EEE(SWSEWNEN|)NESENN(ESSNNW|)W|NNWWWW(NNE(EESWWEENWW|)NWWSWNN(SSENEEWWSWNN|)|SEESWWSWSE(EEE(N(WW|NN)|E)|S))))|W)|NNN))|WWWS(ESSESS|WWWS(ESSNNW|)WWW(SEWN|)NEEN(EEE|WW))))|WWS(ESSWNSENNW|)WWN(E|WSSW(SSENSWNN|)NN)))|SEESENEEN(WWNEWSEE|)EE(EEESSNNWWW|)SSW(N|WWSWSEEESSE(NNNWWEESSS|)ESWW(WNNWSWNWWNW(NNESES|SSSSSENE(NWNEWSES|)S)|S)))|S))))|SESWSEE(SWS(WNSE|)EE|NNN))))))|EE(NEWS|)S))|W)|S)|EEENWWNENN(ESSENNEESSW(N|SE(EENWNEE(S|NWWNNEES(E(NNWWWNN(WSSSSWWN(E|WW(SEWN|)N)|ESENEEESSESE(NESEN(NWWWEEES|)ESSENESEE(SWEN|)NWNNE(S|EEEEEEEEN(E|WWWNN(ESNW|)WSWS(WNN(WSSWWWSSW(ENNEEEWWWSSW|)|NE(S|EE))|E)))|SWWWN(NNWESS|)E))|S)|W))|SWS(ES|WNN)))|WSWW(NE|SE)))|N)|W)))|SS))|EEEEEE)|E))|ESESENN(ESSSWWSSSWSSWSWWNWSSESSSWWWSSENEEESWWSWWWWWSEEESWSSWWNWSWNWSSWNNNEENNE(SSEESNWWNN|)NENESENNWWWSWWWWNWWNNESENE(SENEES(WSWWEENE|)ENN(W|EENEE(NWNEEEE(S|ENWNW(S|NEN(WNWESE|)ESSENNN(SSSWNNSSENNN|)))|SSW(WS(EEEN|WN)|N)))|NNWNWSS(WWWSESSWSESW(SESWSESWWNW(SSSESWSEEEENWWNN(EENNNENN(EESS(ENNEWSSW|)W(N|SSW(N|SESW(SSSWWWSWNWSWSESENESENNESESWSEEENNEENENESENNWWWSWNN(ENEEEEENEN(NNESESWSSWSEEENN(WSNE|)NENNW(N(WSNE|)EENNW(NWNENN(WSNE|)ESSES(EENNEEEESENEESWSESENENWNNWNNNENENEESEEENWNEESESWSWSSEESSSENEE(NWNNE(S|NNNWSW(NNEENNNNWSWWWWWWWSWSWWNNN(WWSESWWWWWSSENESSWWWN(WWSESEESWWSEEESS(EENE(S|NWNW(SS|WNEEE(S|NE(S|EN(EEENE(SS|EEN(ESE(S|EN(ESNW|)W)|WW))|WWW(NEEWWS|)S)))))|WWN(E|WSWNNW(NENSWS|)S(SSESNWNN|)W))|NNNNESEEENWW(EESWWWEEENWW|))|EE(SWSNEN|)EEEEEEE)|S(E|S(W(N|W)|SS))))|SSSSWSWWWSSWNWSSSSWSWNNENWNWWWSWNWWSSWNWNWNEE(S|EENEN(ESS(W|EENNENW(WSSNNE|)NEEESWSEE(SWWWSES(NWNEEEWWWSES|)|ENESENEN(WWWW(S|NENWWSWNNWWW(SEESWENWWN|)NN(WSNE|)ESENEN(WW(W|N)|ESS(SEEWWN|)W))|N)))|WNWWN(E|WNWWSESESS(ENESNWSW|)WNWNWSSSWW(WSSESWWSSESEENWN(ENENE(SSSSW(SESSSEESSSWNWSSSWNNWSSWWNENWWWNNNENNESESWSES(WWNSEE|)EEN(EE|WNNN(ESSNNW|)WN(WWWN(E|WSSESWW(SS(E(N|SWSSE(SSENNESSESWSWWSWWWSESWWNNNNESEEN(NW(N(N|E)|WWWSSSSWWW(NEN(W|E(S|N))|WSESENESE(SWWWSSSSSESS(WNW(WNENNNWSSWWWNWSWSS(EEE(S|N(ESNW|)WW)|WNNNW(SS|NEE(S|NWNWNW(S(SEWN|)W|NNWNEE(EESSENEEEESWSEESSWNWWWSW(SEESENNW(ESSWNWESENNW|)|NN(EENWESWW|)W(WNWNEWSESE|)S)|NWWW(SS|WNWN(E|N)))))))|S)|EENEENNNNESSENNNEEESWSESENEENNWW(SEWN|)NWWWNNW(NEESSENNESES(ENNEEESSSESWWSW(NN(NE(NWES|)S|WW)|SSSSWSWWNN(E(ENWESW|)S|WWSESWSSSSENENESSSSSSSWSESWSSWSWSWNNENNNE(SS|NNNWNN(ESE(SS|NN)|WNWWW(NNNW(SSWNNSSENN|)NEENNEE(N(NN|E)|SWSESSWNWSSEE(WWNNESNWSSEE|))|SEESWSW(SW(SES(WW|SENENN(WSNE|)NE(N|SS(ENSW|)SSWS(E|SWW(NEWS|)SSSSWSEENNE(NWNEWSES|)SENEEESWSSSSESEENWNNN(WSSNNE|)EESEEENNWW(SEWN|)NENNENWWWWW(SWS(EEE(SSWNWS|N(ESNW|)W)|W)|NEENNENNEESWSEENESSSW(NWWS(WNSE|)E|SEESESEESENNNWNNESENENENWWNNWNWNNNNESENNEEENWNNWWSWS(EENSWW|)WNNNE(NWWSWSSE(N|SS(SWSESWWWNWNNWWNNESEESSE(S|NN(ESNW|)NWNNWNWN(ENEESS(WNSE|)(ENENNESSENNENWNWWS(WS(S|WWWNEENNWWW(NWNENNW(SWWN(E|WSW(SWS(E(EEN(ESNW|)W|S)|WW)|N))|NEN(W|ESEENWNNEEEESEEESESESWWWSEEEENNEENNNNWSSSWWNWNNNNNWSWSSW(SEENNSSWWN|)NNWWWSEESWWWNNWNWNNENN(WWW(N(N|E)|SE(E|SWSESS(WNSE|)ESS(ENSW|)SS))|EN(N|ESEEE(NNWSWENESS|)SWWSSS(ENNEEEEEN(W|NNEN(W|ENESSWSESENE(SSWSSWWNW(NE(ES|NWN)|W(SESWSSE(S(W|S)|NENESEE(N(NN|W)|SSW(N|SSE(N|SWSWWSSESWSESSENE(SSWSSWNWN(WWSESSSEESWWS(WNNWWWNENE(ESWENW|)NNW(SWSNEN|)NEEEN(ESNW|)NWNENWWSSS(E|WNW(WWNWSW(S|NNNWSWS(WNNEN(EENNE(NWWEES|)ESE(NESEWNWS|)SWSES(SENES|WWNNN)|W)|E))|S))|SSSEENESE(NNNNW(SWS(E|W(S|N))|NEN(WWWNSEEE|)NN)|SSWNWSWNWSSWSSS(WWNNNN(WWSESNWNEE|)NNESE(SWSSSNNNEN|)N|ENESESWSSEEN(W|E(SSWSESWSSWWSWNNWNEENWN(WW(WSSW(SSSWWSEEEENWNNE(NNEWSS|)SESSSWSESSWSWNN(E|NWSWNWWN(EEEE|NNNWSSSSSWNNNNNWSSSW(SSE(N|SESENESSSSWNNWSWWSESSESEENEN(WW(WNSE|)S|ENESESWSSWSWSWNWSSWSWSESESEEESESWWSSWNWSWWNENN(ESENEWSWNW|)WWS(WNNWNEE(NWWNWWWWNNESENNEEENWWNWSWWS(E|WSSSWSSWSSWNWWWNENWNWNWWNNW(NNESEESS(WNSE|)ESENEEES(SWS(E|W(SEWN|)N(NEWS|)W)|ENNNENWWWWSEESWWWWNNWWNENESE(NESENENNNNN(NNNN(WWSESSSWWNN(ESNW|)NWSSWW(SESSW(SS(WS(SWNWESEN|)E|EEENESENNNWSWW(SWEN|)N(N|E))|N)|WNNNE(SESWENWN|)NWN(EENNNWW(EESSSWENNNWW|)|WW))|N)|ESSESENESSEEENWWNN(WWW|NNEEE(NWWWWN|SSWS(WNNEWSSE|)E(EN(ESNW|)N|SSSESWW(NWSWNWWS(SENSWN|)WW(NEN(WNSE|)E|W)|SEESE(N|E(SWS(E|SWSWNWN(EEN|WS))|EEENEN)))))))|SS))|WSESWSES(WWSWNSENEE|)ESSSENE(NWN(NWES|)E|SSSEESWSESENNNESESENNWN(ENESEENEE(NWNN(ESNW|)WWWSEESW(S|WW)|ESWSSWSWWW(SWWSSWSESEENESSESSESES(WWNWNNWSSWWS(EEE|WWWWWWNNWWSESWWWNENWWNENNWSW(SSWSS(ENESNWSW|)WW(NENWESWS|)W|NNEN(W|EEN(W|ENWNENESSSSWSSSS(WNNNWESSSE|)EEEESES(WWNSEE|)EENWNWNWNNWSSWWNEN(W|NEEN(ESE(NENNSSWS|)SS(WNSE|)SE(N|SESENN(E|W))|WWNNE(SEWN|)NWNWN(WSWSNENE|)E))))))|ENNWNENNNENNWSWNWN(ENENNESE(SEESWSEESEENNEN(WWWSES|ESESWSESWW(SWWN(E|WWSESSWSESEES(WWWNWNWNW(NEN(E(NWN(EE|NNW(N|W))|S(S|E))|W)|SSES(E|W))|EEENNEEESS(WNWSNESE|)ENEENE(SSWWEENN|)NNWWWWS(ESENEWSWNW|)WNWN(WWSS(WWS(EESW|WNNEE)|E(E|N))|NEEENESENNNWSWNWNWW(WNENNW(SWWSEWNEEN|)NNNESES(SSES(EEES(E(SSSSSWWWWW(EEEEENSWWWWW|)|NNNNNWWSWS(SENE(N|S)|WNNENEENWWNWSW(SEWN|)WNNE(S|NNNEENNWSWNW(NNNESES(EEENNE(NNNWNNE(S|NNWSWWSW(NNEENEENN(SSWWSWENEENN|)|SESSW(S(EE(SSWNWESENN|)N(ESNW|)NNN|W(WWS(WWW(S|NEENNWSWNNW(ESSENEWSWNNW|))|S)|N))|N)))|SSSWWSSSWWSSENESSEE(SS|NWNENNNWSS(NNESSSNNNWSS|)))|W)|SSW(N|SWSWSWWSEEENE(NENSWS|)SSWS(S|WNWSWNWN(SESENEWSWNWN|)))))))|WW)|W)|W)|SSSEN(ESNW|)N))))|NN))|N)|WSW(S(WNWSSNNESE|)ESSEN(ESSWSNENNW|)N|N)))|NEN(E(ENSW|)S|W)))|WWWWNEE(WWSEEEWWWNEE|)))))|SE(N|E))|E)))|NNNWNEE(NWES|)E)))|N)|NENE(NWES|)S)|EESSSW)|NNNNWS(SS|WNN(WSWENE|)EE))))))|E)|NWNENWN(ENSW|)W)))))|WWWWSE))|NWNENN(N|W(S|WW)))))|WNNNWSS(W|S))))))|S(EE|S)))|E)|SS)|WSWSES(E(ESNW|)N|WSSWSSW(NWWWSNEEES|)SESENN(N|EESSW(N|SWWSS(ENEENE(SEESENN(WW|ESSESSS(WWSS(WNNNN(ESENSWNW|)WNW(WW|S)|SE(SEWN|)NN)|E(E|NN)))|N)|W(NNN|SESWSS)))))))|EE))|S))))))|N)|N))))))|W)|SSWNWWSES(E|WSWSESSWW(N(NNW(NEEWWS|)SS|E)|S))))|N))|S)|EE)|N))|W)|NNNWWSESWWNNN(E|WWW)))|E))|NN)|N(WW(W|S)|NN))|W)|NNNESS)))))|W)|S)|S)|W)|WWSESS(W(SS|W|N)|E))|WW)))|W(NEWS|)S)|W)|W)|WNNN(NNNEN(EESWENWW|)NW(NEWS|)S|WSW(S(ESNW|)W|N)|E))|E))|W)))|N)|S))))|SESSES(E|W)))|WSSSWNNWN(WSW(NN(W|NN(NWES|)E)|SWSSSSWW(NEN(W|N)|SS(SWNNWNE(WSESSEWNNWNE|)|ENESE(ENENNWNW(SS(S|E)|NENESSE(E|SS))|S))))|E)))|S)|S))))|EENWNEEESEENESSWSS(ENESENNWNNNN(WWS(E|W(NW(SWWEEN|)NN|S))|ESSEEEESWS(EES(W|EENWNWNENNN(EN(E(S|EE(E|NNW(NENNSSWS|)SW(N|W)))|W)|WWSESWWNWSWN(SENESEWNWSWN|)))|WNW(S|W)))|SWNW(SSSWSESWSS(WNW(S|NNWWW(SEEWWN|)NN(W|EEES(E(NEWS|)SS|WW)|N))|SEESS(WNWESE|)EESENE(NEEN(EESWENWW|)WNNWNEN(ESSSNNNW|)WWWSSE(N|SWSW(NWN(WSNE|)ENWNNNES(E|S)|SEENEN))|S))|NENWWN))))|EEEE(SWEN|)NN(WSWENE|)NNEESS(SWNNSSEN|)E(NNNWN(WSNE|)N|E))|SS)|SSE(SWEN|)(N|EEE))|SS)))|S(E|S))))|S)|WSSSESWW(NWES|)SS)|N))))|NN)|S)))|WWWWWNNWWNWSWWSWNWW(NENWNENNWSW(NNEN(EEESW(SSEEESS(WSWWNNE(E|S)|EEE(SWEN|)NWNENN(ESNW|)WNWSWW(NEN(E|NWW(NEN|SE))|S(EE(E|SS)|W)))|W)|W)|S(W|S))|SS(WNWSNESE|)E(N|EEEEN(EESWENWW|)W)))))))))))|S)|W))|WWWWWWWWNNNEN(EE(NN|SWSS(WNSE|)EEE(NW(W|NN)|EE))|W))|NENNNEESS(WNSE|)ENESSW)|S)|NWW(N|W))|N)|N(N|E))|ENE(E|SSS)))|NNNEEEESW(WW|SE(EEENWN(EEEEENW(ESWWWWEEEENW|)|NNNNW(SWSWWS(WWNNE(NWNEWSES|)(EE|S)|EEE(SS|N))|NNE(SEEWWN|)N))|SS)))|S)|E)|EE(EE(NWWNSEES|)E|SWSSE(E|N)))|SWSES(WWNSEE|)SS))))|W))|W)|W)|NE(NWES|)E)|NW(NN|S))|NNE(NE(NWNNW(NNE(SESSNNWN|)NNNWSS|SSS)|S)|S)))|E)))|EEENWNN(SSESWWEENWNN|))))))|N)))))))|WW(W|N))))))|S(W|SE(SWSNEN|)N)))))|EE)|EE))))|E)))|E)|W)|E)|EEEN(W|E))|E)|E)|SW(S(EEENWESWWW|)S|W))|E))|NWNNES)|S)|SWS(ES|WN))))|NN)|N)|E)|E))|N)|N)))$ diff --git a/2018/day20/main.go b/2018/day20/main.go new file mode 100644 index 0000000..c3d3fe5 --- /dev/null +++ b/2018/day20/main.go @@ -0,0 +1,256 @@ +package main + +import ( + "flag" + "fmt" + "regexp" + "strings" + + "github.com/alexchao26/advent-of-code-go/util" +) + +func main() { + var part int + flag.IntVar(&part, "part", 1, "part 1 or 2") + flag.Parse() + fmt.Println("Running part", part) + + if part == 1 { + ans := part1(util.ReadFile("./input.txt")) + util.CopyToClipboard(fmt.Sprintf("%v", ans)) + fmt.Println("Output:", ans) + } else { + ans := part2(util.ReadFile("./input.txt")) + util.CopyToClipboard(fmt.Sprintf("%v", ans)) + fmt.Println("Output:", ans) + } +} + +func part1(input string) int { + var furthest int + + coordsToRooms := parseInput(input) + + roomsVisited := make(map[[2]int]bool) + queue := [][3]int{{0, 0, 0}} // coord, coord, distance + // dijkstra traverse + for len(queue) != 0 { + front := queue[0] + currentCoords := [2]int{front[0], front[1]} + currentDistance := front[2] + currentRoom := coordsToRooms[[2]int{front[0], front[1]}] + + // do not visit the same room twice + if roomsVisited[currentCoords] { + queue = queue[1:] + continue + } + + if furthest < currentDistance { + furthest = currentDistance + } + roomsVisited[currentCoords] = true + + if currentRoom.northDoor { + queue = append(queue, [3]int{currentCoords[0] - 1, currentCoords[1], currentDistance + 1}) + } + if currentRoom.southDoor { + queue = append(queue, [3]int{currentCoords[0] + 1, currentCoords[1], currentDistance + 1}) + } + if currentRoom.eastDoor { + queue = append(queue, [3]int{currentCoords[0], currentCoords[1] + 1, currentDistance + 1}) + } + if currentRoom.westDoor { + queue = append(queue, [3]int{currentCoords[0], currentCoords[1] - 1, currentDistance + 1}) + } + + queue = queue[1:] + } + + return furthest +} + +func part2(input string) int { + parsed := parseInput(input) + _ = parsed + + return 0 +} + +type room struct { + coords [2]int + northDoor, eastDoor, southDoor, westDoor bool +} + +type roomMap map[[2]int]*room + +// String method for Stringer interface for easier debugging of a pointer-ed +// struct so it won't print as just an address +func (rm roomMap) String() string { + ans := "{\n" + for _, room := range rm { + ans += fmt.Sprintf("coords: %v, NSEW doors: %v %v %v %v\n", + room.coords, room.northDoor, room.eastDoor, room.southDoor, room.westDoor) + } + return ans + "}" +} + +var dirToDiff = map[string][2]int{ + "N": [2]int{-1, 0}, + "S": [2]int{1, 0}, + "E": [2]int{0, 1}, + "W": [2]int{0, -1}, +} + +func parseInput(input string) map[[2]int]*room { + coordsToRooms := roomMap{ + {0, 0}: {coords: [2]int{0, 0}}, + } + + paths := flattenRegexpPaths(input[1 : len(input)-1]) + + // inputRegexp to validate all generated paths - beauty of input being regexp + inputRegexp := regexp.MustCompile(input) + + for _, p := range paths { + if !inputRegexp.MatchString(p) { + panic("BAD PATH: " + p) + } + + // step through path and update te coordsToRooms map + currentCoords := [2]int{0, 0} + for _, dirRune := range p { + dir := string(dirRune) + + // if next room is not in map, add it + nextRoomCoords := [2]int{ + currentCoords[0] + dirToDiff[dir][0], + currentCoords[1] + dirToDiff[dir][1], + } + if _, ok := coordsToRooms[nextRoomCoords]; !ok { + coordsToRooms[nextRoomCoords] = &room{ + coords: nextRoomCoords, + } + } + + switch dir { + case "N": + coordsToRooms[currentCoords].northDoor = true + coordsToRooms[nextRoomCoords].southDoor = true + case "S": + coordsToRooms[currentCoords].southDoor = true + coordsToRooms[nextRoomCoords].northDoor = true + case "E": + coordsToRooms[currentCoords].eastDoor = true + coordsToRooms[nextRoomCoords].westDoor = true + case "W": + coordsToRooms[currentCoords].westDoor = true + coordsToRooms[nextRoomCoords].eastDoor = true + default: + panic("INVALID DIRECTION" + string(dir)) + } + currentCoords = nextRoomCoords + } + } + + return coordsToRooms +} + +var noNestedStepsRegexp = regexp.MustCompile("^[NS|EW]*$") + +// generates a string of all possible paths, inefficient but easier to parse through +func flattenRegexpPaths(input string) []string { + if noNestedStepsRegexp.MatchString(input) { + return strings.Split(input, "|") + } + + var paths []string + topLevelOptions := breakIntoTopLevelOptions(input) + + for _, step := range topLevelOptions { + rootStr, branchStr := ingestNextBalancedParen(step) + if rootStr[0] == '(' { + rootStr = rootStr[1 : len(rootStr)-1] + } + rootPaths := flattenRegexpPaths(rootStr) + branchPaths := flattenRegexpPaths(branchStr) + + for _, r := range rootPaths { + for _, b := range branchPaths { + paths = append(paths, r+b) + } + } + } + + return paths +} + +var parensMap = map[string]int{ + "(": 1, + ")": -1, +} + +// break into all balanced parens separated by a pipe +func breakIntoTopLevelOptions(input string) []string { + var topLevel []string + + var left, right, parenBalance int + for right < len(input) { + char := string(input[right]) + if char == "|" && parenBalance == 0 { + topLevel = append(topLevel, input[left:right]) + right++ + left = right + } else { + right++ + parenBalance += parensMap[char] + } + + parenBalance += parensMap[char] + } + + if parenBalance != 0 { + fmt.Println("top level", topLevel) + panic(fmt.Sprintf("paren balance off for %q, %d", input, parenBalance)) + } + + // append on last option + topLevel = append(topLevel, input[left:]) + + return topLevel +} + +// splits the string into the first section that's a balanced paren & the rest +// both sections will be balanced parens +// +// if the first character is a paren, it will parse until the string is balanced +// else it splits at the first paren +func ingestNextBalancedParen(input string) (balanced string, remainder string) { + if len(input) == 0 { + return "", "" + } + + // if not opening paren, parse up to first open paren + if input[0] != '(' { + firstParenIndex := strings.Index(input, "(") + if firstParenIndex == -1 { + return input, "" + } + return input[:firstParenIndex], input[firstParenIndex:] + } + + // otherwise first character is an opening paren + index := 1 + parenBalance := 1 + + // assume all in puts are valid - i.e. a panic for out of range input[index] + // is a good warning + for parenBalance != 0 { + char := string(input[index]) + parenBalance += parensMap[char] + + index++ + } + + return input[:index], input[index:] +} diff --git a/2018/day20/main_test.go b/2018/day20/main_test.go new file mode 100644 index 0000000..fb175fa --- /dev/null +++ b/2018/day20/main_test.go @@ -0,0 +1,116 @@ +package main + +import ( + "reflect" + "testing" +) + +var tests1 = []struct { + name string + want int + input string + // add extra args if needed +}{ + {"example", 3, "^WNE$"}, + {"example", 10, "^ENWWW(NEEE|SSE(EE|N))$"}, + {"example", 18, "^ENNWSWW(NEWS|)SSSEEN(WNSE|)EE(SWEN|)NNN$"}, + {"example", 23, "^ESSWWN(E|NNENN(EESS(WNSE|)SSS|WWWSSSSE(SW|NNNE)))$"}, + {"example", 31, "^WSSEESWWWNW(S|NENNEEEENN(ESSSSW(NWSW|SSEN)|WSWWN(E|WWS(E|SS))))$"}, + // {"actual", ACTUAL_ANSWER, util.ReadFile("input.txt")}, +} + +func TestPart1(t *testing.T) { + for _, tt := range tests1 { + t.Run(tt.name, func(t *testing.T) { + if got := part1(tt.input); got != tt.want { + t.Errorf("part1() = %v, want %v", got, tt.want) + } + }) + } +} + +var tests2 = []struct { + name string + want int + input string + // add extra args if needed +}{ + // {"actual", ACTUAL_ANSWER, util.ReadFile("input.txt")}, +} + +func TestPart2(t *testing.T) { + for _, tt := range tests2 { + t.Run(tt.name, func(t *testing.T) { + if got := part2(tt.input); got != tt.want { + t.Errorf("part2() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_flattenRegexpPaths(t *testing.T) { + tests := []struct { + name string + args string + want []string + }{ + {"no children", "NSEW", []string{"NSEW"}}, + {"no children", "NSEW|SS|EWN", []string{"NSEW", "SS", "EWN"}}, + {"one child", "NSEW(EE|WW|SS)", []string{"NSEWEE", "NSEWWW", "NSEWSS"}}, + {"nested", "NS(EE(WW|SS))WW", []string{"NSEEWWWW", "NSEESSWW"}}, + {"optional path", "NS(EE(WW|SS|))WW", []string{"NSEEWWWW", "NSEESSWW", "NSEEWW"}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := flattenRegexpPaths(tt.args); !reflect.DeepEqual(got, tt.want) { + t.Errorf("flattenRegexpPaths() = %v, want %v", got, tt.want) + } + }) + } +} + +func Test_ingestNextBalancedParen(t *testing.T) { + tests := []struct { + name string + args string + wantBalanced string + wantRemainder string + }{ + {"nonparen start", "NEWS(NEWS)", "NEWS", "(NEWS)"}, + {"paren start", "(NEWS|NEWS)NEWS(NEWS|)", "(NEWS|NEWS)", "NEWS(NEWS|)"}, + {"nested", "(NEWS(NEW|NEW))NEWS(NEWS|)", "(NEWS(NEW|NEW))", "NEWS(NEWS|)"}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + gotBalanced, gotRemainder := ingestNextBalancedParen(tt.args) + if gotBalanced != tt.wantBalanced { + t.Errorf("ingestNextBalancedParen() gotBalanced = %v, want %v", gotBalanced, tt.wantBalanced) + } + if gotRemainder != tt.wantRemainder { + t.Errorf("ingestNextBalancedParen() gotRemainder = %v, want %v", gotRemainder, tt.wantRemainder) + } + }) + } +} + +func Test_breakIntoTopLevelOptions(t *testing.T) { + tests := []struct { + name string + args string + want []string + }{ + {"flat w/o or", "NEWS", []string{"NEWS"}}, + {"flat w/ or", "NEWS|NWW", []string{"NEWS", "NWW"}}, + {"parens w/ or", "NEWS(NE|NW)|NWW", []string{"NEWS(NE|NW)", "NWW"}}, + {"from example", "ESSSSW(NWSW|SSEN)|WSWWN(E|WWS(E|SS))", []string{ + "ESSSSW(NWSW|SSEN)", "WSWWN(E|WWS(E|SS))", + }}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := breakIntoTopLevelOptions(tt.args); !reflect.DeepEqual(got, tt.want) { + t.Errorf("breakIntoTopLevelOptions() = %v, want %v", got, tt.want) + } + }) + } +}