From: Alan R Evans Date: Fri, 1 Dec 2023 01:40:09 +0000 (+0000) Subject: 20223 day1 X-Git-Url: https://fbox.kageds.com/gitweb/adventofcode.git/commitdiff_plain/87786ac5b1569a9cc60680549ed9539d809d4864?ds=inline 20223 day1 --- diff --git a/2023/go/day01/day01.go b/2023/go/day01/day01.go new file mode 100644 index 0000000..a9a351e --- /dev/null +++ b/2023/go/day01/day01.go @@ -0,0 +1,116 @@ +package day01 + +import ( + "adventofcode2023/utils" + "fmt" + "strings" +) +func Part1(input string) int { + num := 0 + lines := strings.Split(input, "\n") + for _, line := range lines { + for i:=0;i= '0' && line[i] <= '9' { + num += utils.MustAtoi(string(line[i])) * 10 + break; + } + } + for i:=len(line) - 1;i>=0;i-- { + if line[i] >= '0' && line[i] <= '9' { + num += utils.MustAtoi(string(line[i])) + break; + } + } + } + return num + +} + + +func Part2(input string) int { + digits := make(map[string]string) + digits["one"] = "1" + digits["two"] = "2" + digits["three"] = "3" + digits["four"] = "4" + digits["five"] = "5" + digits["six"] = "6" + digits["seven"] = "7" + digits["eight"] = "8" + digits["nine"] = "9" + + digits_backwards := make(map[string]string) + digits_backwards["eno"] = "1" + digits_backwards["owt"] = "2" + digits_backwards["eerht"] = "3" + digits_backwards["ruof"] = "4" + digits_backwards["evif"] = "5" + digits_backwards["xis"] = "6" + digits_backwards["neves"] = "7" + digits_backwards["thgie"] = "8" + digits_backwards["enin"] = "9" + + num := 0 + found := false + lines := strings.Split(input, "\n") + for _, line := range lines { + for i:=0;i= '0' && line[i] <= '9' { + fmt.Println("first digit:", string(line[i])) + num += utils.MustAtoi(string(line[i])) * 10 + found = true + } + if found { break;} + for key := range digits { + if strings.HasPrefix(line[i:], key) { + fmt.Println("first digit:", digits[key]) + num += utils.MustAtoi(digits[key]) * 10 + found = true + } + if found { break;} + } + } + + found = false + + reverse := reverseString(line) + + for i:=0;i= '0' && reverse[i] <= '9' { + fmt.Println("last digit:", string(reverse[i])) + num += utils.MustAtoi(string(reverse[i])) + found = true + } + if found { break;} + for key := range digits_backwards { + if strings.HasPrefix(reverse[i:], key) { + fmt.Println("last digit:", digits_backwards[key]) + num += utils.MustAtoi(digits_backwards[key]) + found = true + } + if found { break;} + } + } + found = false + + } + return num +} + +func reverseString(input string) string { + // Convert the string to a rune slice + runes := []rune(input) + + // Get the length of the rune slice + length := len(runes) + + // Reverse the order of runes + for i, j := 0, length-1; i < j; i, j = i+1, j-1 { + runes[i], runes[j] = runes[j], runes[i] + } + + // Convert the reversed rune slice back to a string + reversedString := string(runes) + + return reversedString +} \ No newline at end of file diff --git a/2023/go/day01/day01_test.go b/2023/go/day01/day01_test.go new file mode 100644 index 0000000..d9cc7bf --- /dev/null +++ b/2023/go/day01/day01_test.go @@ -0,0 +1,28 @@ +package day01 + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestPart1(t *testing.T) { + r := Part1( +`1abc2 +pqr3stu8vwx +a1b2c3d4e5f +treb7uchet`) + require.Equal(t, 142, r) +} + +func TestPart2(t *testing.T) { + r := Part2( +`two1nine +eightwothree +abcone2threexyz +xtwone3four +4nineeightseven2 +zoneight234 +7pqrstsixteen`) + require.Equal(t, 281, r) +} diff --git a/2023/go/day01/input.txt b/2023/go/day01/input.txt new file mode 100644 index 0000000..318b300 --- /dev/null +++ b/2023/go/day01/input.txt @@ -0,0 +1,1000 @@ +tsgbzmgbonethreedrqzbhxjkvcnm3 +7qlpsnhbmnconeeight78 +prbqsfzqn57 +ctrv3hmvjphrffktwothree +9six9qbgcvljfvccdjslspprgonenine +eighteight9dnvcqznjvfpreight +one5sevenfour3 +gjgfiveonekzssz9c +one54 +rtsevenfourfive1rqhslone +xkxfdhk25fourtwot8 +kjgcsncmeightdxdgkxfzqmmkg1351 +7qpnldcvgs +reightwotz5 +nineqrtrsfsreightthreetworvrphxptlrbczxsix1 +1svfvgsfcssjpvhzr +1seven174ndseight2 +56lrkxdfive +2jvrgmmlninejf583 +fvsspqpt31 +3threemhjhvrvgkseven +eightoneoneeightttlpjqgnkndbnmppjsdhzdbhkhl12 +vxjgghc18dzbsssnssh +one2cgxdfbfhl3 +8ssfour997six6 +8onesrtcvqmxpzeighttwo6 +3twoptpvz5cbgpdrggdtwoseven +35smnsnzxmdjtsns6sevenonethree +fivetwoeightfdjpscncb41 +flkdknzdxtgdxcfqkn4mbh4tqvgdq +one3threethree +sevenfourgdnxhsqq5one1 +kkrjgpm2sixeight24 +krrhdhjqgmc5dv4 +cvlh16nineeight +495five2nine1 +tzmcxvdtvxpmrcsevenfour15one +2qvbrsxqsix45threeeight +pfmktwo29onensbfgdddfm2 +7xqjzxstvsthree +37ninetwo3 +5vhtctxvjrvftwoone2six +hbhxhjjl5twoqxmlprccr5 +ninefour2foureight69 +1sevenmggmcxfcfdxptktsgcgsc +fnkzsdjh3kqxpdvmkmvqqjcjn +twotcspvbvppqqntwo1hlcvppcpnv5 +xbfhpnkqbnxdfgbgtm5 +84tpzgonelnine6bzkx +bgslbmdkfpbx6 +lqpfphxdtfourxbqdhrbcz2cmhtddsnkpgln +7fourfzthreezhrjdjlvsix4lrrfv +2seven3 +fourtdggtgsdm5 +1pbphhpsxbnqmfbxzone +tskfvdph7mftvqpnvcj2oneninenine2 +3fiveeighttwothreeninenine +seven687two1pdjbbprztwo +eightrslvddpmonejfive4hhqbdq +xbhcqzx52eight52seventwo +fbgpj8fourthreecqngmbbvkktlbss +plckgsixeight6eight95bnrfonetwonej +1nine97rtrtxhqnone2 +cntfouronerdsnn4lfcmhvlrq1five +hrh34sixfourqqng7eightwot +sixlfldl7qjsclxqfive15 +khdfour17 +frmcpx65 +five6bjlbxkp7qthreethreecc3 +5four6qlmpsrdeightfour +9lxdxgfrnlk4lsgbjnz9two +one7five2fvdqfqqn92xsxnblxvhdfcrz +hmhmxvqljdgvvvdfour5one68zgm +718 +3onefive43 +xgpqs5four267six +pqseven17nineninephpszgqzsixldhxmhzgf +ncxxlsqdkvc8fiverslzqtzhzltcmbkthreelkjjckxsvljvs +nine6sixkrs +5kcqpgfms +1znbcrpxmjcsixeight +sixtwo28eight59fql +8nfcseven +8five864sixfive +8fzsvsrjmjxmc +kftvseven6dcsfqtmtjvmgbrninefvv6 +twoseven65 +nine58sjshtgtqlz +lhjfzvlbtrfffour9eighteight73 +9crhmmqkrrfour +threeklhhtlmczn6thfkvdd +dvjxkdgsnlds44kxs +9gtvhrcphvnzbmckkeightfour +fouronejtvrscxj9onethreelgslth +86four +4hvnqzfthree +8qone9 +lnkngkxsflqsvm3threenine2seven3 +65five +8529xdd5threeonexq +sevenlthree1 +5sevennineflfivevgp +6pmzqczjtlnfvgg1sevensix +sixtwoone2 +kqrxsgtrrjsix9 +2twonebs +fs9hmjmdmbhkskqvdb +293 +9sevenbprbbnzqjbhfpcgnxjmflxgkvqgvc +rkd58six +5mbgfldv7rskkllhm +fcjdzfjpvptdcxfltdddm7twornkskrnqnqv +bkqzf51two8twoeight8 +2fivefour4777six8 +mzq67threetwonrqpcrptwo +7bmkeightm8 +z6twoeight5threerfckddtc +threeninesixmtdc7xtjhvksjjc +5fxffvhqzgtdlfdxdhsixnmjtvlq2five +nqpsvzgql1 +six3qljkjbfeight +sgddglfjrtwoseven3 +rxzhvffr1rfxqpr +7zjv5 +3tcsxlpxhsmnmg27 +lbqkvfxp8sevendcjlrfour7 +cxlvqldcjhhlzcvsix6crleight6 +jhchtninehrvlsfvkr7two +48ninetwo +45fivefiveone2 +hthchfc1 +oneninetwobfk7two +ninesevenkfnlhrznqseventhree9 +2fzbgjdvbnktwoonefivefiveqhz +seven28mxjxnzb +gqrznvtjeight9six277five +four3three +1kpqmrjctwolngk8 +49zks +threesevensix9fivergmlzrblg +eight9sixeightlfvrbvfhd5one +4sevensevenonegm6 +six11one3lrztzsjczlnhddxbn +eightsevenpqdsxzmblmvdmjpeight9 +71seven +cjqcqjlkgffoursvfcqxfkkszjhjl73 +dgndjkhcplztmkjrdn53 +1eight91vqjhmxrq9nine6 +bthlrtwo54hxppxfourdsnxnlnpvhmrpqtqzlr +1bhdmvdrjvzthreenine6four6 +threerknmhjtfourtwoeight65eight7 +1hbgvsdxtrsixmsfzxrlzskkkgh +4hsjt +twothreefxhlr1bfngthreemthqqvgfpxeight +nineeight4hp5nhksqdvrhcn22 +hdcfdknjkhsxnk9 +pshjqxmqcbkhqkc5onekzfgkbeight +five3ninektmsrxhsdrseveneight1onenine +p5five +2sixrgznrrvmxbbvnxhqtpeightthree77 +threehmpjclsbhjlbxj1 +982 +vcjxvjvbmmzmrvv97one6rdxrdk +four8one9xpgfjgvjmdsevennineeight5 +five7jmcrkbnine2 +kmbhc8threessdnfmsix +214sixfkxkllldfive6 +dbhbfprsqkpmnfxgkgcone4qfgrgghqtqhxqn +1plplklqjqjdsix +ztzgqsixqsevenseven4 +3threedjnbdbvxseven3qpsjone +dnccnninetwomkzk52sixcgq +94rdhfgjjr1gzl +8three2ljbjjfvx +8sdklzklt +onexvrsttmhfninetftbrhtwo1gkpbninekh +vsbfour5six +2phhz85 +two73fourfive +2twonineninesjkljpdgx +2h +tghzldzcj38foursix +9srzlsv9seven +twojzssixfive53 +85eight35foursix +rzx2lb +ghfnqk396nxqgvvgsmnine9hhc +6sixnine746zlrksxcglg58 +1nbfivelvpcjnsddt3eight4fourblrzckjvf +sixninethreednqkk9zzspxbcfjmfive +16tsvqdplfnbnh +l13tkbfldqcdfzjsdvtfttphmcmsix7 +rcgmlmnine94foureightnine +lpvmrmtkthdqll5 +gjjprdvggvtjvqsnbg7xjvnp3eightninebhrdrq +lzzmsmbpqnineninemnine6two4 +52qldxmrfive36ninetwo +four6fourhrsgf29 +9zb97kffl +eighttwonine5fourkqtjsjthree +two21 +two6fourtjjn147 +lxnzlpcvzkbd9pxtr6qhbfmcmblbhmncljqd +zccjlmzhm9 +11zdnjgj +one5fourone4onerttltxrzgf3 +eight2nine83onepxjhx +38fourllqpbclqnlmfourthree +treight9threesevenqgj +jb7threezfvnine28seven +kmnkbmmnine53lddseven3 +3jxgfdzkgznine +72lzbqmclqtwo94nkt5 +threejdqnineeight4seven9two9 +sevenqnpjbznp6sevenfrnghcmvlfbns +oneone23oneeightone +52qngdcmftmchfzt +two8hnine1qsseven1three +seventjlsdnmx25pnxvtxtsix4 +3veightjkgnbmcssevenpjrszdxqthree +kkhxtnqzvz4jdqmtwoeight +4eight15niner +kreightpprcklznlcstjvqhn36ggfkphxdhm +four53ngjzlmhg +ztwoneoneshxnb2sevenxcrgjbckmfiveeight +3five5221ddgprnvgpnj +2hdkdzcvcmmtcrbsvfsevenone +dtkjdncq73threechgcccdgqqsixthreehlfroneightn +vtfvj4nine23seven2two +phcvhvlq4kjnjcdkjrgninefourthreethree57 +twopxngznkbrmrmrz7135one +one3bqdzone9sevenc2 +69threesix +6jcmfivenine6fivefivethreetr +six1jpxjrqkpgllkqldf +rjz4two59gjjgs2five +joneight9gvqknfour7sevenfhzjsrldj +9one4onesixhvvkqtpleightwovmh +seven4threekpstdppxhvtwo7 +flxzfrxp1 +seven57eightthreeeightseveneight1 +6sevengmkvrvone +five1eightfour19 +nqxnqn7five3txrngheightnine +rdfkkkthree7lnpmdgdb9 +jhhvznhlsevenninefourcmkrbtfive3thtfbjvgvdnv +2seven7eight8jrjkf4fourhv +oneone7hmdfjpzr57vfz +7vqsllrhznvrdccrdrnjvmzmmknp4 +412sevenflfcvksjzk +7eight43mq354oneightv +sevenseven7eightoneightvvj +twotwosix2ninefour9three +threefourtwotwothree1lj +jpqccxztdninepncqqmnlxninexjfgvgccrm1 +5cr +jlhrrqmtlgtqfqpmkrhqjmpmxjshshblthreefournine2 +four93kssrxr +bztqzsjkeight6two18four +sevenoneone587ghfbdmjpqxnpbh +823onesevenseven1 +tt3qmcsbcm1eight +prkptfivefourtwo8 +4six8836gmmgvlrz +qklnpxjqhpczsc775 +phblxtj9 +jgz8lrghthree813eightone +vppt4eightthreezpgqt6dmxdtllksgrtmcbpfjh +nine9lgsgzkjvbcmtfourr +7three61ninefqgsfbpvjrx +98ninenfzfh +two2one8seventwo3hpdbstnhvkthree +fourstrljqf8nine +5kzgf5rspljfnsljrfrhg2mdsh +jkbjkbjhvfoureightgfnnxxnqh826z +3ksgl +3vfivehntm +threeeightone64krfskdqlxsfive +oneseventwo8vqzvnine9ninenq +7fivesrkfkfthree8qmxmdrvhl +447lhctbzpphthreebkmrthreetwo +two92seven +95sevenonecgj +kcgsqqdpfhrpxzceight88 +9c4six +rdkqfzkdlggfq661tfmqlgkcfmfcvpqsmr82 +1zzhzhz +six2ndsdxkfxsfthreeonesevenzlp +eight5threeoneightmxp +sixfour4hdktht3two3seven +9zdphltlnrfg9225 +6eightfourplxbgjfnnzfk2sevendcpbl +threenineeightsltsrkvpl28six8nine +lmbqmrmjldlgb7 +2sixninedxnhmdfxh4five66 +5mllgtrxzkgxskkqxvpjttninefour3 +2hjl6two +h5 +eightthreethree3hcsrt +htjlplnfxgfqkm77seven +lpmggpmcq943lcsvrhdljsqqdlgrphlnnine +7twoonecgtdnfvlrsixrhnineseven +lxszmkhj983five +four9fourninefourtwol +eight58sixsix94 +2sixthreefkbvtdgjq +1rnc +86seven13 +one6f3jkrlrtf +two4nine72twojtfive +fourtdtwo27 +two6eight +nxhzvln3five5 +six7lbgqhnzkntwo +hsfjgnjxjvzskjninezfndhtwofghpstbqzcseven1four +6q +ffszknxdbqzgvmg2p +cvl52 +nmfmp8six5threenhnxs4 +9fdknpvztworqfdpjrk36eight9 +brmqzbhx84 +two72nvrlnhkjnineseven +1spsmjscthone8 +sevenphkpdzvgzcjvlskdzbhqgpknrzdpsn39 +gfmxvrrvk8 +8zkpvrq7ggjskkr +7ninemvm41sbftf6 +nine2sevenfiveonetlnhbbxv +rtwone881998 +eight5threegthree +fhlnkzgqh191 +48fourcmfivecz +5mdvbgmdhqbctxclonedhx1sevenqczd +12one +sixsixeightjmnbqzfive49bk +nine2seventhreehvrfvm11 +gnsixb3three2 +one3hrqzfsc3one8threehhjbzkmln +vvxcbrrone95 +nine7twosnpv2threeeighttgg +8onetwobqnxkkvhk5 +qrphvhfqninemcnzfrhfbvdtsnhst3 +2eightj +eightmdjmnqd1seven +seven5sixtwoeightcglpqvlzxdfive32 +nine3scvsffour6 +3onefourseven +cfqfkxv4five +2dbq8fnzpzp +fivekbblqgnjt12pxnvjxrssm +sixfive16r8dqkgspmlb +ninexjhfsgn9ninezv +lcfourtwofiveffrl6gfhxsrzmdl +8oneshvxjn +8threeeight8sixqbfnpxhr +smdjbhvsxlnhcqnxxgqcxfive5 +threeonesevenglblr56lsntrdsjhp +seven1ninevqpssj +58seven +lghxjdhpdbqs19 +lkcttrkrcpfourjtkfxmxcfive4kxnchspbqvqrfv +7mpgnvdrmsqbcnfzrhtpjhz +threezkjqk5fourthree8four3 +7398 +xpmrcfffmhqpnmxtqxsblcd2fourq6eightdqvj +6onedvdxtv9 +sevenzzvgmlqk5phcldhgghvshclp8 +xpddfttzsix63one3 +threem5eightwomp +2crrxnvrcjklzvdxk1slmrkq2 +5fivesix8mstzprjlvqhcrn +rzkhdgfvkqonexhblnnine32 +5rseight377fivepnlsngxvmthree +onesixseven9 +9dgr98 +6jjcb1hlmlchvtqhpp36nine +lrxhvzs538seven76mkt +six48fivexqxqxdzzhggvcb1 +94seven7two7 +five2bqxzjllksix4 +21three2eight +9rbsrdjbgmgln2fivesixninejfvk1 +9foursixsevennine1 +9zjxdzqbxjlbbsnine +8zfslsdlhdqmptwozzndjcskhptwo68 +9fiveone3fourpncrvfive9 +tbslbmgkqv936sixgsqzkfcjpl +fournxfsgdthq4bsmp38sevenfivegclrlpgxt +1kzql +7onehfzqjdnlzcxflzrlxdh8four9mzf +1sevensfivevgxeight9frcbzhpn +four1seven8njj8 +74dtgcn +sevennine8twothreeztstwoklxhgfbgnnb +7seven3bdrbpnzcr +2twooneggtzrfqcsqqq +rfxnrxkk5twocjddcmqbrqjvprtbdjtpngl99 +pspkmpxzmn9cndplpjskthree7klc +eighthcnhhvvjxc295rxgfour +74nine +jk17mxgfhjveight8twonine +2six8seven2nine4sevenkrgmk +6k96 +5jseveneight6eightnpfqt +ntwone1dkfrhmfourzngslfournine +nine64 +njeightwo52 +15mhnqxqcdgcqbqtdp +hlpgsrxf429four +tncmkps6bninergvfkrv649 +bqqlgvbdp3 +7sixpzpbrxbhqjgvgns +849zhtmsevenfour77 +three15seven9fourthreejfmxhllseven +ksixeight4three4fqkjthreemjqhxqgk +four4seven4eightkgsg +sxgrghvnfknfrsixnkflvngkmsznhc8 +6dzxmxkvvpnkp6fnzdfkjsevendlqrsgdztone +eighttwo81cbrtrrfour9fourqkkbk +hvnjpcxhlb9skfjsixseven9two9 +pmt113onertkj4 +seveneightdftwotttone6 +fnsmzpthreexcssct42 +5eight4threefgllrpsgqhdtsqbqvzxtpgpdgnvctt +rfddtbdpftrvf641five2x +1three8clseventjtwodlhggr +fivelxhrninej8fjngzdskseveneight +ninexxlhmhzdj7tfzds3khvctlrxmhsxdnbm +bggglk31threefivenineonepqcdzczjm +223seveneightfp +mkvsblkv76 +7three86 +xkmxnbmtzrpdp2threesixfjkpbhpzb +9four2 +7tqqg +three4five +zndhqdmkntwo6 +rgblqcvrxzv5clzjdmfkph5 +skcvbd2seven5 +eight8xnlmzm +9twovfnvrmcfhn2gm187 +seven8sevenjshjndsdgrnczlsevensix7djrk +bt2one4jgztwo +one126eightnzpxkgfj +blrlnfnnvbhkltmgqqsixsix2bdnprfp2rpqtnvbtwonenpx +prffzmfndlqfqjncvskgdtwovmbqnxm8twojttxpv2 +6qhjdzs5bm +76lcmfntskmxddthreesixone23 +bstcghjbhkrlpxf1six +7ptpcjchcfffivenineoneone +7ninethreezstzpdr1two +szxlzxpn2fiverhjrp +5625 +two6ghnhfvrzlqdtqflvfgldfjj37gcxnxf +one3scnfcdpsn2five3ninejbv +eight569nffztptqgd1mqbkssdcppjg +fbsvjlln4cdshlvmxpmmc4threemfqnseven +nljzcfzfive5ninen +gmhlb2sixfive55cvnkgknrpbdtnrd +47six +skkhbxfour6trmh7nineseven +three9five +12ninexcc +eight6kdtbvfourb +425threetwo4hxnxseven +five4jbbftjkcmjqxrdls3nlhvcgeightrjn3 +knnjdj5tgtsrgnmjqmjjrnht1 +nine3mhxxsix39 +fivefourseven2drz3eight +215xnm +6seven3 +77kqzfcbklvznhgvnpfivefivejx5 +8seven6sevengjssbvngxzbgcmm1 +mqqxqgmzdvzdgjrlkntdjhgfouronegrkddl14 +5threetxbscpfxdgfive +two3bdhxhkqnd87cmrkzxf5 +two7twobgnxklp +9sdnnzrkms8rbbzfqms8one +2hxdxxstwo +foursrb7smqxmkt +14xfhdkfmh +84trqvtltpqvdtzdlch +19hjjhfljxnine +1lbkvjcjbbeightngnqdvz8nddkmqmvvb8seven +mlnpptcflthdprj4fiveseven92sdhxchdcj +cdmbfivepgdbgdfvbklz8six7 +cbqvbtpljv8skzgmbzbfgrbffmmb +one9ninev4 +nzvjsqx7fivebgptkrxsx65sixfivesczbl +42bhjthree1 +twoqnsxllxrsfive64vgtpcmxc9 +sixbzflbdv7 +54threehf9vhctwofour +4pmkmlpnnine3 +3sk88qglhbsjxdsdcnqrnpdz +79szleighttwofivef +vbctcrttwo43oneone +qjhdlqzqftfgxgnbbscsbznfgslbltd6szdppxfpm +fivenbbsgfthree9 +hjqmr9rqsrhspcfjmfj379 +lxjeightwo6four8 +45twonkxhqq +ggcvxfz6lfpbcspvzsqztjllrrpd +qmlvh9bmlkfive83fivepbtnine +1qqqbrct45sevenx +ttgtbnzrn1dprs6four +nine1rcstjdlhb6hsrnvsjxeight1 +gtlhk3gjhqvtwotv +six278kd +vlgzjxlmfs6 +8d51 +seven6lzjgcc +sz7sixctstdkhlb89 +27three +6two3msmszdzcrfgxj5 +8dbvzcrqv +tftbmjrjd831gbzrhscthree6jvvfour +254sevensixzzkjsq1jmmbvdbhtmfjsp +ghqgzfkqhnqntwo4nfj1 +sixfourninetwoxjtsxcr3 +five2niner2 +22blmbkts7 +one2cbkvqstone5threekzvskbzdt5 +48lgvmpjvhlfsixone6seventwo9 +1five5pzglqpqltn +8dc6blpnqcjndthree5 +lncn3sevenptdrlpqsbseven +9mdzt +flnr3sevensevenpjgrgdbrvdgkhtlzzljdnppp +lpljgkpqdgqsevenseven8foureight5 +xzrkml7 +127 +hgxdcdprhg4qkxtwo1rlc +nine9five5g +three1lgdctzmqpgc4zbmc6ttsls +onethree495three +eightfblxhxptkdnhk6npbbsxgxlhoneights +fourm6sixeightmrztnbjptqfv +twoone76 +6dsbcqrjj +pfkoneightmv8bdrmhlnhmninektnbdtvtwo6twod +qttsnrppd6s +76three5 +thrxlfmbmtsxjzsx5fivelvknrgctp5vlmpf +nine7ninethreeztmlsfch +18eightthreetwo978seven +bseightwovtlxsb5sevensrqnrklqvzstncmr6zg +3zthdrzlqcjbdsfgqphkzqeight +mvfnine6sevenrkbxbhlld35five +cddpxjhdgt9fsfmkxmvtm3dnqndzsnm +vrhjfsfkt3sevenqcsxvkdrfndtfljvkxzckctwoonednpklkm +hqjfnbh9threexqfive +mrpdsqbhzjzplrlqf4fjstqq +6htcxzghbx +nine6dflrcbjl65 +bpclpbkbbmq9threeonetwonejn +eight5fivedcsqtsnfkthreefour9six +4lvl +fourq2 +four388rrkjtfjzrceight8 +7lznsixfh41pdlvhbh9tr +9nineseven438 +tgcqntlpqonevmcqninezcxfxbbone6 +seven2gg +two1one65threexsix +1one6lrgflmsixfivefour +sevenone46 +61crvnncdxmkseventzqvdsmfkx +khztxzpnl6nine +threeonehjxpgj3nine6threehcsix +twotwo5mpbgbtfjpcxbksix49two +62 +kssevengjcdtrcmklxdgftslsz7kfclxsdtc +9mgpqjhlfivesix34sevenone +89711 +3tgkpfrvvcpxfs8jhmdcxz392 +6ghbglhfive469x +9ctfqkhbgprf38 +cshsctcqr6tcxzjgrzsx +chn5onethreevqdhhdv74 +one9fmlbplqeightfthchbzjhzgkbv +fourtwopkllbslsix94bcshtp2 +rvmpsxkmcqninetwovhjzvhm3 +4eightbcdvjjr5ninethree6fiveone +6three6eightdqkcg +rsix7seven6fdpzpgvmkp +eightrvlmbdq91six +x978bsdxxnknine +81five3 +6bmmvdflqfxcmhtsixjprt +five6two4five37seven7 +nine6hldzbzxhzdvnptjeight4ninejxlhvtkpzd +eightfone9 +4vknnxxj6192q6nnfbcm +twolzt6two23two1 +84lltlrz4vsl3two +rnfour39cpcggzone +hgfx464 +6tdldmclkhqkkdzxmhvtthree8 +9sevensix +pfgb55 +mqnqnineplccphpctvxs3sldkl +cblchzhrsone4fcbvfxkjjbcptp8oneightv +5mndn +pptwone8 +fivejvzddb3bcvvskzxstfive5 +k7sevenninefivefiveqzbxlsgcmoneone +gxqthreejzntslggzhxnsevensix1onecphllcxc +6slttzsdvnkfgbqldqvlqrszlpsixtwo3 +7lqlkstbxpt87xcbssmn +fourtwoeightjnflkkbksn566 +dkjpckbtnninejcxg3 +6713ninetwo +9six3rskfprrbqhbstmp9 +4onepfqshseven4seven +1d +zdht4sksmztjpcrjthreenine +four29one2csmk +93lmdlxrrj4threeeight +zkbckninedlzxpmdneight4 +gjdshxctnszcrlxj8 +4nqfvtshhk +hvjvrh37threehznzlrprtptwo4one +eightghbtgpbjfdprqnpvhhcbdtrzsjgsix2 +sixmgpzcmxq3sixsixxpdrfpzdsmqsr +onefivegphhdggf6kdrmnvgfqj +mvtj2six +6jhtqngl7jtphdsvtkbvscm1fivehv +632onefiveeight2 +9ninezfbzdplrfourthree3eight8 +164three7fbznchn8 +fsklrdzbzv8threefour8sevensix +twosixtwo4sixsevenfivethree +foursevensix4fourxhfjzjbkhsix +eight26foursixseven +8frxqhzqstxzmlsqpqtcsevenfive9 +mgck4815plnnmrvhfvhbsln +3fxpccfplrfivetwobbngonephjs9four +4gbbgpbqnpbqjzgvjrgpprtwoqvjrrn +four17two93eightthree +twoseven3 +one5vqpmvkpgtwo88seven +sssmblvsixseven2 +6fsdxfxgdhnqkcpzmbljlfkfsjztdp94h +kx99pbk6 +nineone7knpqj +2fourzgseightseven5 +sixninekdbvrrllrl8sevencvrdhnine +8jtqlpz2 +hgblktnine92htpggp22 +8l3 +xfxb82srqlldfonelqjhssmsrfkbmldjqt2klnq +321one42seventhreenlrtm +jponefoureight6nine +3lsljdntnsjrseven +two1rvc9fiveonerkdnrnfd1 +1twoclddjfsixtwovhhczl +4two48krlhhbvzhq +78fourncglqhghzxhbrb98threeglzklqgkg +threetmzvnrfnqq23 +9five5four5ones8 +six4onefive6 +45lfmdrgsrvkkkzglnqmrlt +64onevthree +onefour9zvkgndsv2 +dmrk46vlrztxbjfsbll +2four8oneeighteight +pqtvvlbrgninethreeone1 +6four733d +seven1qhxhgxsx8fzlbkm9hpmnqkknjpseven +6cspj21fivetwo +seven3fllzkctljxlcqljbxfrcleightwov +73bkkkdnptddqqxhjteight +jjdmnfourp1threextxpmdnnnine +five2lvhh4kfg3 +rbconeightthree8 +59lqvpccqlbmqqtzfourseven547 +vdvsbhcptvxbgd46three6 +xtrbzgtwofour9kq9 +2nineeight +29nlcdzgrkh7 +onehglhgkcksm2onemzpnqmbxccvpxxssg1gcpvhl +sevenhhhgntcldxlfbrpks27threeeightwoh +2kccbsjdblthree +nine6threenine +nkbcdbseven8cqfour +bfour3 +nineeighttneight833 +3glgsvfhkz7fivefivefive +zzlxqlfour3mcjjp +93eight28 +1threeffive4c5oneightgdg +five4six +gpzjjxthree4fmvbzmzbjf31six +bcbdtbjrtn3five11 +kbtnkjvkmdh6 +fpjsqbxv5 +3twofive +9vplnvkkmhpdfxckm2js64 +4eightsixxgmbxzkkcsevennvdgprqcgvsqct +eightsix1five8one5sevenvqjmrkdjq +9seven7 +ngmnllfj49dlqdmnthree +sixthreeqbkmzvmt7sbgsscqsg +5sjbrdqvbksss7gnfcp6vjpbfcgps +nhssblqsixtwo57 +fourbthree7four +6foursix +pfcbeightfvtnlrmld273 +fivefhthree8189mvhf +nine5qzvxjvj1nkljhvdpnf9 +tgrllhmcmpmpeightzjd7 +vnblzqbhx4four6 +5qb6six2one9 +sevenprjnnznl9nvbfour28sixnpxttwonemcn +4sixsix +7two9 +7pzzdv2fourgxxczzqtdxfjgtxjztbvjt +218jxfvzrfournine +4sevennine +662onecvzlsixzj7six +bpnmf95seven2 +clfcfivetwo9mkxqnthnnhkpxcm +klgfmtjlctstwo9 +1zlqhkkhmdvszg2three4nljlbrzz +five6threesevensnprfgsggs1nqqjtsqxpdtjlfr +nhkvqk89four +rtgzhbhjcjcznp5cxbprzxfoureighteight4lng +xdvgfzxbvzfdkff5dthree +1two465sixnine +2six327mflsr +qpeightwo4sixfivetwokvzhkg +4seven9jmbnjrhrtthree +4flchcfh1four +94fourldjgvg7drlcxqtnv2 +99sevenfourmfhnjg9 +32fivesix275ninelpmkponeightnp +9xzgfxcmplrzjsbnlkgcbnpchth +htoneighttntmj6ninethreen7 +64one9sevenghcqjjrseven +8nvkfqkbbpzseven63zpnbbnine62 +fivefoursmdnvczb6 +mmrqfrtwo2hhpk7eightthree +dnrrfklrpxstln57vqzkrxlqnmsvmgdbthreeoneightc +19rqmvljqfrmfoureightseven +twofive9vm1csqlrvngtfiveeight +zeightwofivefour6gcmh97 +7pzts +42ninecnbthreedlgglgp +3kqthqfprdntgbfqqc +sixdrrqxxdgl8dhf4 +51three +39qpctcjfnh7 +9bfour4 +onefourseventwohbqpxn73 +jzbqdcsevenseven8seven8mmbktn +xlzeightwo3648threegrfourrjzvz +eighttmmtcrqhlpnrjjlchrvvthree6 +5five3one69eightthf +bctwonelppl122bkfivetwo +foursix2ddxqqz +hbmcnbvdhpkhp3sv88 +csdp3onebjxxlckthreetwoplskdphhmp +rvkdmmgfvsfive8ggvcvxgjgrsix +7zjsdzbeightfour7 +four3qfsvmbhhfv276 +krdnine4bnneightbpxfdvl9pcf +scdklgdh46fivefiveseven24seven +9rmmsthreethrlxjtjkb +7fivesevenstfourfivecddbzmxrrqeight +fivethreeninexgkpmpbvsix7 +sixvqpdpfk43rhmd9 +2zvkhxtfourpdfnsbsnbvone +four7lrcvtsczdp2sixvvlkzrzzk9gcxtmx7 +61pzlq74cmlkjvseven +qcjzncctvv237dsjvqm2three +89threezgd2eight8 +nxll6fivev6kt4rmtfkrnkfive +lvxxvnpzlrk8sbmbnhtmlds +sevensevenjhcxcninesevendlghdvfj5mkmdb +vfq4 +gxkcbkknqg8187eight +six79tcdlv +bsntwone3six8 +8nd +qdlhkvvpxrtgbrzpmcfourfivegpjqjfbfmngnnbpshfkdpsdgj2 +threetjbcjmzlcvnchp34nineseven +zjpxzkdlmhcbzkrflvfour5mdqldvgrnx5sixlmgjpqx +cjnvmsdrpmq8 +threeqr8xrxgv87 +rcfsntqrlonezlgl7dhlflqckc9vhd21 +9three7three +ptkqnrtmrnsixfiveseven67 +44fourfive9 +4fstrhjjctsvrz7cpbr6gjpkkxglx +6rjqcmpfbp +731 +fivexdfkzmjs3146five6kvdsnvsxsj +dhhz6 +sltpllcs4seven8771 +1fourkjfhfcfxbeightseven8three +sevengrzlghdkg8three +sixsixnkgfcfivekqfzsj59 +4qbqggqlmjkrgnrxthree9dxgssjkrseven +xhlmbone3one8 +3t +8six37 +fivethree3onegthree9thhfzp +9xdmvkx7fourfxpgsvnine77 +coneightfivedfkqrfjcckghzsrtrc9sevenone1 +five4ninevxldttfxxdfxfhttbxkvjkfour23 +cpfklzcpp2eightfjqcrsmhlnxckxmtdchbzqblqsqqp +34six1 +5fivex4 +fivefivepjfrpzdvcq2 +onelnppnxczthreelldqndvt3 +nine699ninexjnine +16one74 +8jdkblqbq59zlkhj97one +ckrft6sixeight +fourldmq24 +87zvt +threefiveone75hxnqqsjroneeight +lsxlzvssshlvbr5vtvgsznrxhkp73 +threeknpqxxgg84 +oneone3mvtlxjhfiveksgpnms9kzkf +thxrqsrninefourfive31kbcp57 +fivesixnine6oneqgxckbjqfszpsvhjgms +eightsix83 +ttwone9qqhg7 +7fhvffiveftkbfgxsdfourthree1 +hbkst6foursixdndhmtwosix +mhgxpvgmndjgsftqjkkxkfzxmhgtdpxxmbztwo6six +two6ljpjc8ffgmblpxrcsevenvbsm +xqbmzh85mqchftctnfourfkeight7 +xlbltdqcsx2sixmqdzvxhqj +eight468 +nine2rcrgfpx5 +eight5tjoneseven +hncnnjvbdfdfcthree1 +sixzfllx24threesevensix +7eighteight +8652sslmpr1 +m88ktthbnh5 +six1ninethree +sevengtb6 +9eightzpdkqzp3 +tplshfhqsshs4 +4twothreefpj +48threetwockbzxdhqp4eight +eightmkeightjdgmvxdqfx7 +six99 +69one +twodmnzphhsb2 +three3zhqckdqeight1 +2x9xjzgtdgk5ninefourseven +4vrpseven7tq +86cjqrqp +one8four67 +three7two7six2kxl +bhnbkthreetwofqchzvbxjqqm4seven4five +onehncctk2qnphtkjns +6stmbmtj1ms +mdhmknhftkdtnrgkbmh7six1six +six4three5 +fnccxltjdn4gteightfourone3 +twofoureight5seven4 +four7twosix8three +pgvjtszlkx4 +threeseven438two5 +six78qhspmhqtkc +56sevenjdfvfbzvsgthreemrbmcqctgonesixppg +fivesevenlsixvgxfkxtbclkbsqt35 +sixeightfiveseven7three +frmgthreefour3szxtf1 +5eightrvflvtqzq8sevenj +five5dbtfxqxzfour52mxfzmkfks +2ggjtsdmdr6 +cpszsjthree4 +rrd8rrfcvzhcdr651rfc6h +sfnfsc89eighttmsc888t +46eight +992sevenzsxkzxxppnkxlxkpbz +seven93tzgthree +952sszqqqrc1seven +fivetwo3sevenfive4 +pfgdhlvv23onesixtwoznfrlcndlvr8 +mhcvnl1three5 +3twofour3pgjtjp2five1 +nfcvxxcltwo49khnmggcdlr5 +8frh21n +6p477xtfrhvclvnxpbdmftrgd2 +sevenbqsdxlceight3 +seven2nine86jx +44cqv +7bfgmrc +88twoonethree4m5oneightn +94eightthreefourdqdrnx8threetwonepbt +onegvkdxllnd76 +onechljqc4mvhljvcgbthree +2ninenine1two +threenineone8ggnbmnfcnfteightsix1 +eight6fivermqnm94onessnplzpkzjm +7fivezcnlhtfournine +pfourvpqfqz7foursix +sevenonedcs9 +threebfspz4b6sevennzkznbd7 +tbg56jzgmkgmxnbncvtgrpk4 +337sdxdlbqd2 +4tcvrpvqkkhhthmcjzggqgmpdonektzmrrszs +twocfgqtp7 +sevenfcmgkblzh4mvgjmktn4 +ptnqxxf1two +fqftxjznine186three +6foursevenonenjkbdjfbhhtvdthreethreeeight +4two3 +zhronethree2six3five7 +3fxbqvvkh6twoneftm +zf2two4xndhkmb93 +fivefivefour9rhcjxxtbtd63nxtk +five3qpvgdcqcvcvbn6 +1qjckjqkbqvbtqkrbvkxp +2gnglzbllksix6fgfjrrltrhrspl5seven +four6five8gpktxzxcdtvqsevenqlbsnine +seven6lgkknlfouronegxnine2 +9ninefour8fourpd2threetwo +358lmjlsevensjrlhkbspkqxcfourmktxqrhjz +mbqnmgjcbninenine82djlmzk38 +four6lgd66eighteight8 +three566 +czeightwoninefive7one +threecmkmzszq337rsctbvvpgvlfvreight +btwone91blrcbjvpfl +cgfddzmnmz3 +seven3sixsixnqt9 +xsthfourtwo1nine5dpvjpnine +97fpjzktsixtzpdseven5 +seven6fivefive +two16 +nddxvnqnggdzcnhthree2 +1sixseven +three1nvpdzhrndgbvfiveeight1 +134 +threeeightlvbp6 +qmrmqcjkdfoursixfive8915six +2jrsix78twoninefour +5vgtsevenfoureighttmntdgptbvxonez +2npzxnpmdtxctgeightrbvrgdkqthree5fg +hxtvnvqffivekgzcl6dtmplhqprfdbzdoneninesix +two384zlqs8351 +2sevensgnxgzkqsixtwo +nkone877fivegtr +ldr43 +six3nrstcpvfive6 +one799onenineseven +4onetwofourfourghpzmgjthree +one53two8tnmlpcxvvqvrtjthreefour +49nine +sgnxr3two +threeblnc1six3hvdlj1 +8sskxtzkl35hknine8one +keightcqbkbz9gsbxdqshzngxcbjqtqn +7foursixnine +sbhv3lvkgsgk +dmvthree152cjh +two6nzdd7rrltcngdbshfzlhsix +1nxthreetchfsleightq6v +5threevrc9four6st +b2threeeightonesix44hnxzcm +2threefourfournine +1fxbbfszjhseven +lrxhhqdzx2sixsixtwo7eight6nine +2eightmzzcgszpxr +7nine7sevenzndthknx1 +kkstmkvmfeight92ninelpxhsssk9 +1zjpvbmzdxxc +ninevtqgtzxtprbst1bxxsrrrztnhbjrdqvlheightvbhncs +7seven8threeeight +mfzkktfoneseven8pvqpszgqjszx +lr9kddzcxmmxc253lxfournine +three29gpbvjthree6hcnxzqcdcj +sixljtcnxbq8vnbrjgd9qsqonethreenzdnvjjg +vpeightwo15 +lctthree6four14nine +eightfiveone47sevenhdxtlninegffpzhjmh +foursixhtx9nineseven8 +seven94four +9h6nine +fivemxkfxvbpneight8hqlmmrmeight6 +five5bhrghlfiveseventhreeoneseven +eight79nbmspstpkxhttvrq +xqcmqxnine6 +prcnjkshkvlcgsixfiveone6 +btbcs2rsrcrshzp8six89 +5tg578fldlcxponefourtwonet +v4 +gqrnpz5sth +xcsmcfour3eightts +eight691seven8cxdbveightzv +onenjhcd9 \ No newline at end of file diff --git a/2023/go/go.mod b/2023/go/go.mod new file mode 100644 index 0000000..b9a24ad --- /dev/null +++ b/2023/go/go.mod @@ -0,0 +1,14 @@ +module adventofcode2023 + +go 1.19 + +require ( + github.com/stretchr/testify v1.8.2 + golang.org/x/exp v0.0.0-20221208152030-732eee02a75a +) + +require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect +) diff --git a/2023/go/go.sum b/2023/go/go.sum new file mode 100644 index 0000000..80664fa --- /dev/null +++ b/2023/go/go.sum @@ -0,0 +1,19 @@ +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8= +github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +golang.org/x/exp v0.0.0-20221208152030-732eee02a75a h1:4iLhBPcpqFmylhnkbY3W0ONLUYYkDAW9xMFLfxgsvCw= +golang.org/x/exp v0.0.0-20221208152030-732eee02a75a/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/2023/go/main.go b/2023/go/main.go new file mode 100644 index 0000000..ab4582a --- /dev/null +++ b/2023/go/main.go @@ -0,0 +1,83 @@ +package main + +import ( + "fmt" +// "math/rand" + "os" +// "strings" +// "time" + "adventofcode2023/utils" + "adventofcode2023/day01" +) +// Usage: go run main.go +// assumes input is in day/input.txt +func main() { + d := day() + fmt.Printf("Running day %02d\n", d) + + switch d { + case 1: + fmt.Printf("part 1: %d\n", day01.Part1(utils.Readfile(d))) + fmt.Printf("part 2: %d\n", day01.Part2(utils.Readfile(d))) + default: + panic(fmt.Errorf("no such day: %d", d)) + } +} + +// Reads day from os.Args. +func day() int { + latest := 0 + if len(os.Args) == 1 { + return latest + } + + if os.Args[1] == "next" { + genNext(latest + 1) + os.Exit(0) + } + day := utils.MustAtoi(os.Args[1]) + return day +} + + +func genNext(n int) { + os.Mkdir(fmt.Sprintf("day%02d", n), 0755) + f, err := os.Create(fmt.Sprintf("day%02d/day%02d.go", n, n)) + utils.PanicOnErr(err) + defer f.Close() + f.WriteString(fmt.Sprintf(`package day%02d + +func Part1(input string) int { + return 0 +} + +func Part2(input string) int { + return 0 +} +`, n)) + fmt.Printf("wrote day%02d/day%02d.go\n", n, n) + + f, err = os.Create(fmt.Sprintf("day%02d/day%02d_test.go", n, n)) + utils.PanicOnErr(err) + defer f.Close() + f.WriteString(fmt.Sprintf(`package day%02d + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestPart1(t *testing.T) { + r := Part1("") + require.Equal(t, 0, r) +} + +func TestPart2(t *testing.T) { + r := Part2("") + require.Equal(t, 0, r) +} +`, n)) + fmt.Printf("wrote day%02d/day%02d_test.go\n", n, n) + +} \ No newline at end of file diff --git a/2023/go/utils/grid2d/grid2d.go b/2023/go/utils/grid2d/grid2d.go new file mode 100644 index 0000000..e92b74f --- /dev/null +++ b/2023/go/utils/grid2d/grid2d.go @@ -0,0 +1,74 @@ +package grid2d + +import ( + "strings" + + "adventofcode2023/utils" +) + +type Grid[T any] struct { + sizeX, sizeY int + matrix [][]T + empty T +} + +func NewGrid[T any](sizeX, sizeY int, empty T) *Grid[T] { + matrix := make([][]T, sizeY) + rows := make([]T, sizeX*sizeY) + for i := 0; i < sizeX*sizeY; i++ { + rows[i] = empty + } + + j := 0 + for i := 0; i < sizeY; i++ { + matrix[i] = rows[j : j+sizeX : j+sizeX] + j += sizeX + } + return &Grid[T]{ + sizeX: sizeX, + sizeY: sizeY, + matrix: matrix, + empty: empty, + } +} + +func (g *Grid[T]) SizeX() int { + return g.sizeX +} + +func (g *Grid[T]) SizeY() int { + return g.sizeY +} + +func (g *Grid[T]) Get(x, y int) T { + if x < 0 || x >= g.sizeX { + return g.empty + } + if y < 0 || y >= g.sizeY { + return g.empty + } + return g.matrix[y][x] +} + +func (g *Grid[T]) Set(x, y int, v T) { + if x < 0 || x >= g.sizeX { + panic("invalid x") + } + if y < 0 || y >= g.sizeY { + panic("invalid y") + } + g.matrix[y][x] = v +} + +func (g *Grid[T]) StringWithFormatter(formatter func(T, int, int) string) string { + var r strings.Builder + for j := 0; j < g.sizeY; j++ { + for i := 0; i < g.sizeX; i++ { + _, err := r.WriteString(formatter(g.matrix[j][i], i, j)) + utils.PanicOnErr(err) + } + _, err := r.WriteRune('\n') + utils.PanicOnErr(err) + } + return r.String() +} diff --git a/2023/go/utils/inputFile.go b/2023/go/utils/inputFile.go new file mode 100644 index 0000000..893b134 --- /dev/null +++ b/2023/go/utils/inputFile.go @@ -0,0 +1,56 @@ +package utils + +import ( + "fmt" + "io" + "net/http" + "os" +) + +func GenInputFile(day int) string { + var d string + if day < 10 { + d = fmt.Sprintf("0%d", day) + } else { + d = fmt.Sprintf("%d", day) + } + + pwd, _ := os.Getwd() + path := fmt.Sprintf("%s\\day%s\\input.txt", pwd, d) + fi, _ := os.Stat(path) + if fi != nil { + return path + } + + fmt.Println("Creating new input file...") + f, _ := os.OpenFile(path, os.O_CREATE, 0700) + f.WriteString(readHttp(2022, day)) + return path +} + +func readHttp(year, day int) string { + fmt.Println("Fetching data into file...") + + url := fmt.Sprintf("https://adventofcode.com/%d/day/%d/input", year, day) + session := os.Getenv("sessionAoC") + + req, err := http.NewRequest("GET", url, nil) + if err != nil { + panic(err) + } + + req.AddCookie(&http.Cookie{Name: "session", Value: session}) + client := &http.Client{} + resp, err := client.Do(req) + if err != nil { + panic(err) + } + + body, err := io.ReadAll(resp.Body) + if err != nil { + panic(err) + } + + return string(body) +} + diff --git a/2023/go/utils/inputs/inputs.go b/2023/go/utils/inputs/inputs.go new file mode 100644 index 0000000..8ffb5ac --- /dev/null +++ b/2023/go/utils/inputs/inputs.go @@ -0,0 +1,45 @@ +package inputs + +import ( + "strings" + + "adventofcode2023/utils" + "adventofcode2023/utils/grid2d" + sparsegrid "adventofcode2023/utils/sparseGrid" +) + +func ToInts(input string, sep string) []int { + var r []int + for _, line := range strings.Split(input, sep) { + if line != "" { + r = append(r, utils.MustAtoi(line)) + } + } + return r +} + +func ToGrid2D[T any](input, rowSep, colSep string, empty T, conv func(string) T) *grid2d.Grid[T] { + lines := strings.Split(input, rowSep) + + grid := grid2d.NewGrid(len(lines[0]), len(lines), empty) + for y, line := range lines { + for x, v := range strings.Split(line, colSep) { + grid.Set(x, y, conv(v)) + } + } + + return grid +} + +func ToSparseGrid[T comparable](input, rowSep, colSep string, empty T, conv func(string) T) *sparsegrid.SparseGrid[T] { + lines := strings.Split(input, rowSep) + + grid := sparsegrid.NewGrid(empty) + for y, line := range lines { + for x, v := range strings.Split(line, colSep) { + grid.Set(x, y, conv(v)) + } + } + + return grid +} diff --git a/2023/go/utils/sparseGrid/sparseGrid.go b/2023/go/utils/sparseGrid/sparseGrid.go new file mode 100644 index 0000000..0d17ab2 --- /dev/null +++ b/2023/go/utils/sparseGrid/sparseGrid.go @@ -0,0 +1,81 @@ +package sparsegrid + +import ( + "fmt" + "strings" + + "adventofcode2023/utils" +) + +type SparseGrid[T comparable] struct { + minX, maxX, minY, maxY int + data map[string]T + empty T +} + +func NewGrid[T comparable](empty T) *SparseGrid[T] { + return &SparseGrid[T]{ + minX: utils.MaxInt, + maxX: utils.MinInt, + minY: utils.MaxInt, + maxY: utils.MinInt, + data: map[string]T{}, + empty: empty, + } +} + +func (g *SparseGrid[T]) SizeX() (int, int) { + return g.minX, g.maxX +} + +func (g *SparseGrid[T]) SizeY() (int, int) { + return g.minY, g.maxY +} + +func (g *SparseGrid[T]) Visited() int { + return len(g.data) +} + +func (g *SparseGrid[T]) Get(x, y int) T { + k := key(x, y) + v, ok := g.data[k] + if !ok { + return g.empty + } + return v +} + +func (g *SparseGrid[T]) Set(x, y int, v T) { + k := key(x, y) + current, ok := g.data[k] + if ok && v == current { + return + } else if !ok && v == g.empty { + return + } else if v == g.empty { + delete(g.data, k) + } else { + g.data[k] = v + g.minX = utils.Min(g.minX, x) + g.maxX = utils.Max(g.maxX, x) + g.minY = utils.Min(g.minY, y) + g.maxY = utils.Max(g.maxY, y) + } +} + +func (g *SparseGrid[T]) StringWithFormatter(formatter func(T, int, int) string) string { + var r strings.Builder + for j := g.minY; j <= g.maxY; j++ { + for i := g.minX; i <= g.maxX; i++ { + _, err := r.WriteString(formatter(g.Get(i, j), i, j)) + utils.PanicOnErr(err) + } + _, err := r.WriteRune('\n') + utils.PanicOnErr(err) + } + return r.String() +} + +func key(x, y int) string { + return fmt.Sprintf("%d:%d", x, y) +} diff --git a/2023/go/utils/utils.go b/2023/go/utils/utils.go new file mode 100644 index 0000000..14d1797 --- /dev/null +++ b/2023/go/utils/utils.go @@ -0,0 +1,222 @@ +package utils + +import ( + "bufio" + "fmt" + "io" + "os" + "reflect" + "regexp" + "strconv" + "strings" + + "golang.org/x/exp/constraints" +) + +func PanicOnErr(err error) { + if err != nil { + panic(err) + } +} + +const MaxInt = int(^uint(0) >> 1) +const MinInt = ^MaxInt + +func Max[T constraints.Ordered](a, b T) T { + if a > b { + return a + } + return b +} + +func Min[T constraints.Ordered](a, b T) T { + if a < b { + return a + } + return b +} + +func SliceMinMax[T constraints.Ordered](slice []T) (*T, *T) { + if len(slice) == 0 { + return nil, nil + } + min := &slice[0] + max := &slice[0] + for i, v := range slice { + if v < *min { + min = &slice[i] + } + if v > *max { + max = &slice[i] + } + } + return min, max +} + +func MustAtoi(s string) int { + v, err := strconv.Atoi(s) + PanicOnErr(err) + return v +} + +// Returns key from map[T]int which has the max value +func MapFindMax(m interface{}) interface{} { + var maxK interface{} = nil + var maxV = MinInt + iter := reflect.ValueOf(m).MapRange() + for iter.Next() { + k := iter.Key() + v := int(iter.Value().Int()) + if v > maxV { + maxV = v + maxK = k.Interface() + } + } + return maxK +} + +// Returns key from map[T]int which has the min value +func MapFindMin(m interface{}) interface{} { + var minK interface{} = nil + var minV = MaxInt + iter := reflect.ValueOf(m).MapRange() + for iter.Next() { + k := iter.Key() + v := int(iter.Value().Int()) + if v < minV { + minV = v + minK = k.Interface() + } + } + return minK +} + +func Readfile(day int) string { + filename := fmt.Sprintf("day%02d/input.txt", day) + file, err := os.Open(filename) + PanicOnErr(err) + defer file.Close() + + reader := bufio.NewReader(file) + contents, err := io.ReadAll(reader) + PanicOnErr(err) + + return strings.TrimSuffix(string(contents), "\n") +} + +func ReadfileAsSlice(day int) []string { + filename := fmt.Sprintf("day%02d/input.txt", day) + file, err := os.Open(filename) + PanicOnErr(err) + defer file.Close() + + arr := make([]string, 0) + sc := bufio.NewScanner(file) + for sc.Scan() { + arr = append(arr, sc.Text()) + } + + return arr +} + +func ParseToStruct(re *regexp.Regexp, input string, target interface{}) bool { + m := re.FindStringSubmatch(input) + if m == nil { + return false + } + + var useOffset bool + + for i, name := range re.SubexpNames() { + if i == 0 { + continue + } + var field reflect.Value + if name == "" { + // use offset + if i == 1 { + useOffset = true + } else if !useOffset { + panic("can't mix named and unnamed subexpressions") + } + field = reflect.ValueOf(target).Elem().Field(i - 1) + } else { + // use name + if i == 1 { + useOffset = false + } else if useOffset { + panic("can't mix named and unnamed subexpressions") + } + field = reflect.ValueOf(target).Elem().FieldByName(name) + } + if field.Kind() == reflect.String { + field.SetString(m[i]) + } else if field.Kind() == reflect.Int { + v, err := strconv.Atoi(m[i]) + PanicOnErr(err) + field.SetInt(int64(v)) + } else if field.Kind() == reflect.Uint8 { + if len(m[i]) != 1 { + panic(fmt.Sprintf("expecting 1 char, got: %s", m[i])) + } + field.SetUint(uint64(m[i][0])) + } else { + panic(fmt.Sprintf("unknown kind: %s", field.Kind())) + } + } + return true +} + +func MustParseToStruct(re *regexp.Regexp, input string, target interface{}) { + if !ParseToStruct(re, input, target) { + panic(fmt.Errorf("failed to parse: %s", input)) + } +} + +func CharToLower(c byte) byte { + return strings.ToLower(string(c))[0] +} + +func CharToUpper(c byte) byte { + return strings.ToUpper(string(c))[0] +} + +func Contains(haystack []string, needle string) bool { + for _, s := range haystack { + if s == needle { + return true + } + } + return false +} + +func Abs[T constraints.Signed](x T) T { + if x < 0 { + return -x + } + return x +} + +func Gcd(x, y int) int { + if x <= 0 || y <= 0 { + panic(fmt.Errorf("invalid input: %d, %d", x, y)) + } + if x == y { + return x + } + if x > y { + return Gcd(x-y, y) + } else { + return Gcd(x, y-x) + } +} + +func Sign[T constraints.Signed](x T) int { + if x < 0 { + return -1 + } else if x > 0 { + return 1 + } else { + return 0 + } +}