scubbo/advent-of-code-2024
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Solutions to part 04

Browse Source
This commit is contained in:
Jack Jackson 2024-12-23 19:41:44 -08:00
parent f8d9fcdb06
commit 098bebd25e
5 changed files with 451 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
NOTES.md
View File

@ -14,6 +14,7 @@ Hmmmm, right now it seems even worse than GoLang. Though the Error handling is _
* [String concatenation](https://old.reddit.com/r/Zig/comments/bfcsul/concatenating_zig_strings/) * [String concatenation](https://old.reddit.com/r/Zig/comments/bfcsul/concatenating_zig_strings/)
* [String equality](https://nofmal.github.io/zig-with-example/string-handling/#string-equal) * [String equality](https://nofmal.github.io/zig-with-example/string-handling/#string-equal)
* Switching on strings * Switching on strings
* [Iterating over values of an enum](https://zig.guide/language-basics/enums) - [this](https://ziggit.dev/t/iterating-over-a-packed-enum/6530) suggests that it's possible, but testing indicates that that only works at comptime.
## Not "missing", but... ## Not "missing", but...

140
inputs/04/real.txt Normal file
View File

@ -0,0 +1,140 @@
SAXMASMMMASAMMMMXXMMXMMMSSMMMXSAAXMSSMSSSSSSSSXSASXMSMMMSASXSXMASXMSSSMXSSMXSMSSXMXXSXMXAMXMASXASXMSAMSSSMMAAXAMMXXSAMMSXSSSSMSMMSMSAXSAMXMX
MXXAAMAAMAMASXSSSMMSAMMSAMASMMSXSAMXAAMAAAAAAXSXAMMMAMAAXAMMAXXAXAAAXMAMMAMAMMAMXMAXSASXSAMXAXMSMAMMAAXSAMXSSXMMMAMMASAMXAAAXAAAXAAMAMXAMXAM
XSXMASXMMXSAMXAAXMASASMMXXAMAXXAMXXSMMMMMMMMMMXMXMAMASASMMMAMMMMXMMMMSAMSAMAXMAMAMMXSAMXMMXMASXAMXMSMMMSMXMXAXSAMSXSAMASMMMMMSMSMMSMAMSXMASA
SMAMASMAMAMASMMMMMASMMXAAMMSSMMMMMXAXXXAMAMASXAASXXSASAXAAASAAAMASAXMSXXSMMMMSASXSMAMXMAMXAMXMXMMAMXAAAMXSMMMXMAMMAMSSXMMMSMAMXXXAAMAAXASAMS
XMAMAXXAMSSXSMSAXMXSXSMSMMXAXAXMASAMXMMMSMSASXMXSAMMMMXSMMMMSSXSXSASAMXMMMSMMMAMAAMXMMSXSAXXAMAXASASXMSSXXAAXMXMMMMMASXAXAAMSSXXMXSSXSMMMAXX
SSXSXMMXSMMMSASAMSMSAXAAAXMXMSMSASAMAMAAAAMASXMASAMXASXAXAXMXMASAMXMASMSAAAAMMSMSMMAXAAAMMSSXMAMMMAXXAXAXMSMSSMXAMXMAMSAMSXSMMMXXAMXXMASXMMS
XAAAAMSMMMAAMMMSMAAMMMSMSMMMMMAMXSMXAXMSSSMAMXMASAMXMAASXSSMAMXMASASXMASMSSSMAMMXXSSSSMSMXXASASXMMXMMXMMMXMAAASXMMSMAXMXXMMSASMXSAMXSAAXAAAX
SMMMMMAAASMSMSAMMMSMXAXXXAAAAAXMMXMSAXMAMXMAXXMAXAMSXMXMAMXXAXSXMSMMSMMMMAAMMMSXMAXMAMAMXMMAXMXAMXAMXSXXMAMMMSMSMAXMSXMXSAMXMMAMXASAMMSXXMSM
MAAXMSXXMSAAAMMXAXAMMMSMSSMSMSMSAXMASAMAMXSXMMMMXSAMXXXMAMASXXSAMXMXAMAAMMMMAAXASXSMSMMAAMMAASXMMSSSMMMSSMSSMAAAMXMMXAMXSMMSSMXMSAMXXAMMSXMM
SAMMXAMSAMMMSMSSSXXXAXAMMXAXMAMXAXXAMXSXSAMXMSAXAXMMSSMSAMXMMMSAMAMSMMSMSXSSMSMMMAAXXAMSXXXMXSAAMXAAAAAXSXAMSMSMXAMXSAMASXAAAAXMMXAAMSSXMASX
MSSXAAMMASXSAXXAAMSSSSSSMMSMMXMMMMSXSAMAMAXAAAXMMXAAAMXSXMAMXAMAMXMAXMAXXAMXAMASMSMMSXMXMSAMASXMMMXMSMSSXMSXSXMASXSMSXMASMSMMMMXAMMXMAMAMAMS
MAXXMAMXAXXXXMMXMAMAAMXAMXXXMMAAAXXAMXSASMSMSMMXXSMMMMAXMMSSMMSAMXASMMSMSAXMASAMAAXMAMMMASAMXSAMSAMXAAXMXMMAMSSXAAAAXMMASAMSMAMXXSMAMASAMASX
MSSMXMSMMSSMMSMAMASMSMSMMSXAAXSMMSMAMASXSAAAMXAXMASXMMSSXAMAMXXASAMXXSAAXXMAXMAMSMXSAXMAXXAMASAMXMASMSMMAMMXMAXSMSMMMAMAMXMAMMXSXAMSSMSMSMAX
XAMAAAAAAAAAAAXXSASXMAXXAMMSMXXAMAXMMXSSMMMXSASMAMSMSAAAMXSAMXXAMAMAXSMSMAXMMXAMAMAXMSXSSSMMXSMMSAXSAMAMASMMMSXSXAASMXMASMSMXSAMSMSMMMMMSMAA
AMSSMSSSMMSMSSSXMMSMMSMMXSAMXMMAMMSMSMMAXXAMAXMMMMMAMMSSXMMMMSAMXSMXXMAMXMMSMSMSAMXXSMAAAAXSAMXAXMXSAXSSMSAAMXASMSSMASMMMXAAAMAXXXAAAXAAXMXS
SXAXMMXMAMXXMXMMAMXMAAXMAMXSXAXXMXAXAASXMSAMMMAXSXMMMMXMMXAAAXAMSAMXMMAMAMXAAAASXMMXMAXMMMMSXMAMMMASAMXAAXASAMAMAXXMAMAAXSMMMMSMMSSMMSMSSMAX
AMASXXAAXAMXAMXSAMMSMMMMASMXMSAMXSMSSMMAXMAMXMXXXAMSSMAMSSSMMMXMXAMXASASASMMSMMMXASXMASMXSAMASAXAMAMMSSMMMXMMMMMMMXMSSSMMXMAMMAAXXMAXXMMXMAM
MMMMMSMMSMSAXAMSASAAXXASXSAAAXAXMMMAMAMSASXMASMMSAMAAMASAXXMSSSXSXSXMXASMXXAAXAMSXAAXMAMXMASASAMSMSSMAAASXXMXAMAXAXMAXAXMXMASXSSMMMMAAAAMMSS
XXAAAAAXAAXXXMASAMMSSSMSAMMSSMXSAXMASAMAAAAMXSAASAMSSMSMMXXAAAXAAAXAXMMMMSMSMSAXXXSXMXSSMSMMASMMXAMAMSSMAMXXSASMSSMSMSMMASXAAXAAAXASMSMXSAAM
SSSSSSSMMSMXMAXMMMMMXMXMAMAXAAAMMMSXSAMMMSXMXMXMSAMAXXAASMSMMSMXMAXAMXSAAXAAAXXASXMXSAAAAXMMMMXSXASXMAXMAXAAMAMAAAXAAAMMAMMXXASMMMMSAAASMMSS
AAMAAAMXMAXAMXXAXAMXMMXSMMXXMMMXSAMXSAMXAAAMMMMXSAMMXXXXXAAAAMASMMASMMSMMSMMXSAMXAMAMMSMMMMAAMASXMMMMMXXMMAMXAMMSMMMSMXMASXMXMASXAAMMMMXASAM
MSMSMSMSSSSMXAMSMMXXASXSXSAMXAAMMASASAMMMSSMAMXMSAMXMSSXMSMMMSXMAXAAAAXMMAXXXSMXSXMAXAXXAASXSMAMXXAAMXMASMSXSXSXMXSAAMXSXMASMXMSSMSSXXASMMAS
XXAXAXAAAAAXMXSAASASMMAMAMXMSMSSSMMASXMXMAMMXSAMXAXXSAAMAMXMAXMSMMXSMMSXMAXSAMXAMMSXSXSSSXSMXMMSMSSMSASMXAXAXAMXXAMSMSXMXMAMSAMXXMAXMXXMXSMM
AMMMSMMMSMMAMSAXXMAMAMAMAMAXAMAXAMMMMMSXMASXASASXSMMAMMMSXAMSSMMXSAAAMAXXAMMXMAXMAMMAXXAMASAMMMAAMXAMXSAMSMSMSMSMMMXXMAMXMXSSMMMMMMSMSSMASXA
AAXAAXXXXASMMAAMSSMSAXAMASMSSXMSSMXAAAXAMSAMXXXMAXXXMXXXMAMSXAXXAMXSMMASXMMXMMMSMMSSXXMAMSMXMASXSSSSMAMAMMAXAMASXSASASMMAXMAMXAAAAMAAASMAMMS
SSMSSSXMAMMXXMSMXAASASXSMAMSASXAAMMSMMSAMXMASMMMMMMXXXSAMXXSMMMMMMAMXMXSAMAXXAAMAMAAAAMMMMAASAMAMMAMMASXMXSMXMAMAMASAMXMXMXAMSSMSSSMMMMMXMAM
XAAXXXMAXMAXXAAMMMMMMMMAMMSMMAMSSMAXAMXMAMMASAMMAAXMXMXMAMMMAXAMAMSSXMSMASASXSXSAMXSMMSAAMAMMASMMMAMXMMAAXMMXMMSAMXMAMSSSMAXMAMXAAXAMXSSSMSS
SMMMMMSMMSXSSSMSXMASXSSMMXXMXMMMAMASAMXMAMMASXMMMSSMMSSMMSASMMXMASMAMSMMASMSAMXSASAMAXSMSSMXSAMAASXSAMMXMMMASXAXAMXSAMXAAAAASAMMMMMSAMXAAAAX
SAMXXAAAMMAMAAAMXMXAAAAMAXMASXSSMMXSAMMSASMASMMSMAXXAXAAMXMAXSASMXMAMAAMASAMAMASMMXSAMXXAXMXMASMMMASAXSSMXXASMMSAMASMSMSMMMMMASAAAAXASMSMSMS
SAMXASMSMMAMSMMMAMMMMSMMXAXMMAMAXSAMXXAXASMMXXAAMMMMSMMMMSAMXMASAXSASMSMMMXMAMMMASAMAMXMMSAXMASAMMMMSMAASMMMSAXSAMXSASXAMXXXSMMMSMSSXMMMXXAA
MSAMXAAAXSSMXXASASAXAMXMXMXMMAMAXMXSAMMSXMASMMSMSASMXXSAASAMXMSMMMMASXXXMASXMXXXAMASXMXAXAMXAAMAMXXAMMSMMXXXSXMSMSMMAMSMSMSAMAAXMAXMASXSAMXM
XMMMMMSMMAXMASXMMSXMXSASASAMSMSMSMMSASAAAAAXAMXAMAXAXASMXSAMXXXAXAMSMMSMSXMASMMMASXMAAMMXSXSSSSSMMMAMAMASXAMMSMXAAMMAMAXXMAASXMMMMMSMXAMXSAS
MXAAAXAMMMXMASMSXMXMMSASAXAXAAAAAMASXMASMMXSAMMMMSMMMMMMMXXMSMSMMXMAAMAAAMMAMAMMAXAMMMSMAMAMAMAASAMSMXSAMXSAAAMMSMMXASMXXAMXMMAMXAAXXMXMXMAS
AXMSXMXXAXAMASAAMXASAMMMMSSMMMMSXMXSXMXXAMXAAXXXAXAMSXSMSSSXXAXMASMMMSMSMSSSSSSMMSMMXAAMAMAMAMXAXXXAAMMMSSMMSMXAAXSSMSASXSAXASMMMMXSAMASMMMM
SXMMMMMMMSSSMMXMAMXMMSXAAAXASMMMASAMXSAMAMXSXMXMMMAXMASAAASAMSMMMSAXMAAAXMAAAAXAAAMSMSSSXSXSXSMASXSXSMASMXXAXAMSMMMAXMXMAXXMXMASAAASXMAXAAXS
XSAAAXAMMAMAXAMXSAAMXMMMSSSMMAAMXMAXXXASXMAXAMXAMSSMMMMMMXMXMAXAXSASMMXMXMMMMMMMMMXAAMXMXMAMAXXMAMXAXXXMASMSSXMXASXMMXSMMMXAAMMMMMXSAMSSXMSM
SAMSMSSXMASAMMSMMSAMASAMXAAXSXMMSMSMMMMMMMASXMAXXAMASXXXSXSMSXSSXXAMAMASAMXXAASMMSSMSMAMMMAMAMSAMXMXMAXMSMAAMMSXMMAMSMSAAAMMSSXXMSASMMAAASAM
AMXAAMXAMXMAXAAAMMMXAXAMMSMMSMSMSAAXAXSAXMAXAXAMMASASMMMSAAAMMMMMMSMXSAMASXXXASAAXAXAXMXAMMXAXMMASXXAASXMMXMXAXAXSXMAAMXMMSAAXMSXMAXXMMSMSAS
MXSMSMSMMMSAMSSSMAAMXSXSXMAAXMAAMSMMSMSASMSSMMSXSAMMSASAMSMMMAMMMAAXMMMXAMASMASMMSMSSXMMSSSMMXAAMAAASXMMAMMMMSXMMMXSMSMASAMXSMMXXMMMMSXXAMAM
XASMAXAMXXMAXAAAXMSSMAASASMMSSMSMAXXMAXAMAAXMAMXMASXSAMSAXMAXMSSMSSMSASMASAXMAMAXXXMMAAXXAXAXSMMMMMMMAMSAMXSAMSSMSMSAAXXMAMMAMXXMASMAMXMAMXM
MXSAMSSXMXSMMMMMMXAXMMXSAMXMMAAAMXMSMSMXMXMXMAXAMAMXMXMMMMAXXXAMMXAXMAMSAMXSMMMMMMMASXMMMSMSMXMAXXXAMAMSASAAASAMASAMSMSXMAXXAMXMSASMSMMXAMAM
XMXAMXMASAMXSXSXXMMSXXAMMMSSSMMMMMMAAAAAMMSMSASMSSMXMAXAMMAMXMMSSMXMMMMMSMSMXSAMAASMMAXMAMAMAMSMMMSXMAMSMMMMMMMMAMAMMMMASASMMSSXMASAMXSSSSSS
MSMAXXSAMASAAMAMMAASAMXMAAAAXAXXMASMSMSXSAAMAAMXAMXASXSSMMASAAXAMAMXAXAXASXAASMSMXMASXMXXMAMAMAAAXXXSMMXAASXMXXMASXMMASAMAXXMAMXMXMMMXMAMAAM
AMXMMXMXMXMXMAAAXMMSXMAMMSSMSMMXSAMMAAXMMMSSMMMXMXSMSAMAXSASMSMXSXMXXSASMMMMMSXSXSSXMMMXMSAMXXMSMSAMMSSSSMSAMXSAAXMXSMMXSMSSMSSXMXMAAXMAMMMM
SMSMMAMMSXSAMSSSMSXMASXSAMAXSAAXMAMSMSMSAMXAAMMAMMMMMMMAMSAMXMXXMASMXSAMAAXMXSAXAXMMMAXMASXSXSAAXMAXAAMAAASXMAMMMXMASAMXSAAMAMXAMASAMXMAMAAX
ASAAMXSAAAMAXAAAAMXSAMMMASMMSMMSSSXAAAMAMMSSMMSAMAAAAXMAMMMMMMSASAMMAMASXMSXAMAMSMMASMSAMXXAAMSMMSMMMSXSSMMMMASAAASASAMAMMMMMMSXMASASASXSSSS
SSSSMXAXMSSSMMSMMMMXMASMXMAXXAAAAAMMMMSAMXMASXSXSSSSMSMXMASXXASMAMSMXMAMAMMMMSAAMAMASMAMXMXMXMAMAAAMAMMMAXAXMXSMMXMASXMXSAMMMMXAMXXMMXAAXAAX
AMAMXMMSXMAXAAMAAXSAMXMXXSMMSMMMMMXXAXSMSMSAAMMMMMAXASMMMAMXMASMAMXMAMMXSXAAMMMXSAMXSXMMXSMSASMSXSXMAXASAMXMMAXXXAMAMAMASAMAAXSSMMMXMSMXMMMM
MMAMXSAAAMAMMMSSMXSAMSAMXSXMXAXASXSSMXMASAMMMMAXXMAMMMASAXSAMXXMAXAMAMSAMSSSSXMASASASAMXXXAXASAAMMXMSSMMXMASMSASXXMASXMASAMSMXAAAXSAMAAASASM
XSMSAMSSSMASXAAAXAXMASXMXMAMSSMMSAAAXAMAMAMMXSASXMMSXMAMMXXXMAMXSSMSASMAMAMAXXMASXMASXMAXMSMAMMMXXAMXAXSAMXXAAAAMSSXXAMASAMAMMMMSMSASMSMMASA
MMAMAMAMXMASMMSSMMMSASASASAMXMASMMMMSMSASAMXAMAXXAAMMSMMXSMMXASAAAXMXSMSMAMSSMMMSAMXMMMXMAAMXMXMSAMXMMMXAMSMSSMMAXMMMMAMSXMASAXMAASXMAMAMSMM
AMAMXMMSMSAXAMAAASAMXMAXMXASXSXMAXSXSAXAXAXMSSMMSMMSAAAXAXAAXAXMSMMMASXMSXXMAASAMMXSAAASMSMXSASAXAAMAXMMSSXAAMAXSXSAAXAMMMSXSXSSMMMMMSMSMAAA
MMXSXSXMAMAMSMMXMMSSSMSMMSAMASXSAMMAMXMMSSMAAAAAMASMMXSMMSXMXSMMAAMMMSAMXSMSSMMASXXSMMMSAMAMMASMSMSSMXMAMAMXMSAMXXSSSSXSAAXMMAAMMMAMMMAMMSXM
XSXMMSAMMMSAMXSAXXAMAAXAMMMMMXASXSMAMMMMAAAMSSMMMXMASXXAAMAXAAASXMMAMMAMAMMAAASXMMMSASAMXMSMMAMXXAAAMSMMXSAMXXMXMMMMMAXXMMSAMXMMASAMXMAMAMMM
AXAMASAMXAMASAASAMXSSMMXMASMMMAMAAMMXSAASXMMAMASXMMAAXSMMXAMSXMMASXXSSMMSXMMSMMXMAAMXMXMXMMAMSSMMSMSMXAAAMMAMASAMAAAAMSXSXSASXMSMSASXMXSAMAM
SSMMXSAMXXSAMXMAXAAAAXSXSASMXMAMAMXXAMMXXAMMXSAXMAMAMMMSSMMMAASMMMMAMXAAMASAXXMASMSSXSSMXSSMMAAAAXXMAMMMMMSSMASASXSMSAMAMMMMMMMAXSAMXXXMASAM
XAMSXSASXAMXMSXMXMMMMXMXMAMAASXMXMAMMSMMSAMMMMMSSXMXXSAAXAXMXXMASAMSMSMMMAMASAXAXAAAMAMXAXAMSSSMXSXSASMSMMAAMASMMAXAAMMAMSSXXAXMMMAMSAMXXSAS
SMMXASAMMMMMAXAAXXAAXASMMSXSASXSAMAMMAXXSAMAAXXXAMXMMMMMSMMSMXSMMAAMASXSMSSMSXMSSSMMAMMMASMMMAXMAMAMASAAMMSXMMSAMSMXMXMASAAAMSSMMSMMASAXXSAM
XAAMXMSMAAAMMSAMXSSXSASAAXMMAMXSASASXMMMSASXSSMMSAAXXAMXXXAAXMXXMXMMAMMAAAAXXAXMAMXXMSSMASAAMMMMASAMMMXMMAMASMSXMXAXXAAXMMMMSAAMAAAMAMXMAMMM
SMMSAAAXSSSSMSAMXXAAXASMMMAXSMMSXMAMAXAASAMAMXMAXSSSSSSSSMMSAMMXMAMMMMAMMMXAMSMMAMMSMAAMASMMMAASXSASXAMXMASXMAMMMSMMSMSMXXXMAMMMSSXMMXAMSMAM
MAASMSMXMAAAMSAMXMMMMMMXMMXMAAXMMMMSMMMMSAMSMSMMXAMAXAAXXAAXMAAAMAMXMAMXMSMSMXASXMAAMSSMASXSSSXSXSMMMMSXMASMMAMXAMAMXMXMMXSAMXMXAMXMAXXXAAAS
SMMSAMMAMSSMMSXMAMAAAAAAMAAASAMXAAAAAAAMSXMAAAAXSAMXMMMMMMMSXMXXSASMXSXAAXAXXMXMMMSSXMXMASAMXXMXMMMSXSMMMXSXSASMASXMASAMMAMXXMASASMXMASXSSMS
XXSMAMSSMMAAXXAMXSSSSMSSSSXXMSXXMMSSSSSMXXMMSMSMXMASMSAXMAMSASAXMASMAMSSMMXMXSMXXAAMMMAMXMAMXMAAXAAMMSXAXASXSASMXMASMSMSAMXMASXMAMXAXASAMAAX
MMMMMMXMASXMMSXMXAMXAXXXAAXAAXMXSAMAAMMAMMSAMXAAXMXSASASMAXSAMMMSAMMSMAXMASMAAAXMMXSASXSXSAMAMMSSMXSAMSSMASMMMXXMSXMAXAMAMAMMXMMSMMXMXSAXMMM
SASAXMMSAMAAAAASMSSSMMXMMSAMXMAMMAMMMMSAMMAMASMSMMAMAMXMMMMMAMAAMAMSAMXSXAAMASMMXAAMXSAMASXSASAMXMXMMMAXMMMXSMMXXXAMXMXMASMSMXMAAXXAMXMAMSAM
SASAXSAMXXMMMSSMAAAMXASAAAMXSMSMSSMSXXXAMXASXSXAASASAMMSASASAMMSSMMMMMAXMXMSAMXAMMMSAMXMAMXAAMASASAMSMSXSASMSAASMSMAAAASXMMAASMMSAXAXAMAMXAX
MMMAMMASAMSAMXAMMMMMMSAAMSXMAAXXAAAXMSSSMSXSAMXMXSXSXSXSASMSASAAAMXSXMMSMSMSMSMXSAMXMSXMASAMAMXSASAAXAMXSASASMMMAAMSSSMMAASAMMASXMMXSASXSSSM
SSMMMSMMAMXAMXAMSAMMMMMAAXMSMSMMSAMXXAAAXSASMMAMMSMMASAMXMXXXMMSMMAAXMSXAAAMXXMAMXSMXXASAMASAMXMASXMMMMMMMMMMAXSSSMXAMXXSMXAAMXMASAMSAMXAAMX
XAAMXAMMSMSSMAXAXAXAAAXXXXAAAAXMMMXSMMXMXMAMSSXSASAMAMAMAMMSMSAXAMXSMMMXXMSMAMMXMAMAXSXMASAMASXSMMXMAAAASXSXSMMAMMMMAMMAMASMXMXSAMAMMXMMMMMS
SMMMSASAXMAMXAMMSMMSSSSMMSSMSMMMAMAXXMASMMAMXXAMASXMSSMSXSAAXMASMXAXAAMMMMMMSSMSMSXSAMASAMXSAMXMAAASXSSMXASMAMAMXAAXXMXXMAMXAAXMMSMMMAXAAXXA
MAAASMMMSMASXMAXAAAAAXAAMAAMMAXSAMMXMMXAAXASXSAMAMAXXAXAAMXSMMAMAMSSSXSAAXAAAAMMAAAXMSAMXSXMAMXSMMMAMMXXMAMXAMXXMSSSSMSXMMMMMMXAAXMASXSSMSSM
ASMXXASXXMASXAXSMSMSSSSMMXXMMMMSAXMASMSSSSXSASASXSMMSMMMMMMMAMXSMXXAMXMMSMMSSSMMMMSMXSAMXXMASXMMXMASMMAXMAMSSSSMAXMAAAMXSAAASXSMMMXMSXAAXAAX
XMMMMAMMAMXXXSXSAAAAXMAXXSXSASAMXXSASAAAAXAMASAMMMXMXSMXMAAMSSXMXSMAMXMAMXMAAAMXAAAXMMMSSMXAXMAMAMAXAMXMASAXAAAXMXMMMMMASMSSSMXMASAASMSMMSSM
MSASMSMXSMSXAXAMMMSMMSSMSAAXMXAXMAMXXMMSMMSMAMMMAXXXMASASMXSAMAXAMMMMXMASASMSMMSMSSSMAAAAAMXSXSSSSMMSMAXAMAAMSMMSMMXMAMAMAMAMAAMASMXSAAXAXAA
AMAMAMSMMASMMMMMAAXXAAAMXMMXSMMMSMMMMSAAXXXMSSXSSSMMXASMXAMMASMMMSAAXAMMSAMMAXAXMAXAMMMSSMXMMMAMXAAAMMSMXXMMXMMXAAXSSMMMSAMSXSMMAXXAMMMXMMMS
SMAMMMAMMAMAAAASMSSMMMMMXXXXXASASXSAAMMSMSXAXAMMXAMXSXMXSAXMXMXASMXSMMSAMXMXAMMXMSXSMXXXAMXMAXAMSMMMSAXXMMSAXASXMSMXAAAASAMXMXAMASMSSMMSAAMM
ASXSASXMMMMSMSMSAMMMSAMMXMXXSAMASXMMXSAXXMMXMAMXSMMAXAAAMMMMSMSSSMAMAAMMMXSMXXSAAAAXXSXSAMXSSSMMAMXXSAMASAMXMAMXXMXXMMMMSASXASXMMAXAAAASXMMM
MMMSMSASXMAXXXAMXMAAMASMAAAAMAMXMXMAMXAMAXSMSSSMAAMXSMMMMMAMAAMAMMAMMXMSMMMSAASMMMXMAAMSXSXMAAMSAMSAMASXMASAMSSSSXSMMAMXSAMXMAXMXXASMMMSMSAX
ASAMXSMMAMASAMXMMMMMSAMMSMMSSSMSXXMASMMMXMXAAAAXSMMMXMAAASMSMSMAXMXXXAAAAAAMMXMXAXAMMMAMMSAMSAMXMXMASXMASMMXSAAAMASMASXMMSXSMMXSAMMMXMMXAXXM
SSMSASXSMMAMAMAMASMAMXSAXAXMXMAXMAXAMAAAAMMMMSMXMXAXAMMXXSAAAMXMMMSMSSSSSMSSSSXSASMSAAXSASAMXMXASXSAMXMASXSXMMSMMAMXAXASAMXMAAAXAMMSXMSSMMSS
MMAMASAMXMXSMMXSAMMASMMMSMMSAMXMMSMASMMSXSAAMMXMASMSMXASXMMMAMAMAXAAAAAAMXMAXAMSAAASMSAMXSAMXAMSAMXAXAMAMAMSAMXXMASMSSMMASMSMMMSAMXMMMAAAAAA
SMAMMMMMAMXXMAMMASMXSAMXSAASAMAXAAAXXMAXAXMSMMAMMMMAXAAMXAXXXSAMXSMSMMMMMAMMMMAMMMXMXMASMSAMAXMAMASASMMMMAAAXMASXXXAXMAXAMMASMXXXAMXAMMMMMMM
MMMXSASXSSXMMMSMXMMASXMAMMXSAMAMMMMAMXMMMMAXXSAMAASAMXSXSAMSXMXSAAXXXAAMXMSMMXXXAXXMXSMSASAMMXMAXMAAAXAXXSSSXSAMXMMSMSMMSXXAMMXXMMMMMSASMSMS
MASMMASAMXXMAAAXMMMAMAMXMMXSMMAXMSSXAAXAXMXSASASMXMAMMXASXMXAAAMMMMSSSMSASAMXAMMXSXMAMXMAMMXXASMSSMMMSXMMAAXMAXSAAAMAXXSXAXSAMXMMASXMMAXAAAA
SASAMAMAMASMMSSXSAMSSMSXMSAMXSMSXAAAXMSXXSAMXMXAXXSXMAMXMASMMMMMAXMAXMASMSXSMASXAAAMASAMMMMMMXXMAMXAXAMSAMXMASMMAMSMAMXXMXMMAMXMSASASMSMSMMM
MASXMASAMXSXAMAASMMMAXAAXMASAAASMMSMAMAMXMMSAMASMMAAXSMMSAMAXXMSSSXMSMXMMXAXMAAMXMXMAXMMSAXAAMSMMMMASMAMSXMSXXXXAMXMAXSASXSSXMAXMMSAMXXAXXAS
MAMAMAXAAXSMSSMMMMSSMMMMMMASXMMMAXAXXMXSAAASASAAAMAXMAAAMASAMAAAAAMXAMASMMMXMMSMAMMMXMSASMSAXAAMXXMASXAXASAMXMMSMSXXAXSAMAMAMSSSMAMXMMMSMXMX
SMSSMMSXMASMMAXXAAMAAAXXSMMMASMSSSSSSMAMMMMSAMMXXMASMMMSMXMXASMMSMASASASXASAMXAMASAMAAMAXAXAXSASMMMASMMXMSMMMMAAAMAMSXMAMMMAMAAAMMXAXXAMMASM
AAAMAXAAXXSASXMSMMSMSXSAXAXSAMMXAAMAAMXSAMXMMXMSXMAAMSXXXXAMMMAMXXXSXMASMMMMSSMSXSASMSMSMMMMMMAAXAMMSASMXSASXMSSSMSMMASAMASXSMXAMXMSMMAXSAMA
MMMSMMSXMASAMXMASXMXMXMMSMMMXXAMMMMSMMMMAMXMSAASXMMMAMAMMMMMAXAMXXAMMMXMXSAAAAAAASAXAAAAXXXXXMXXMMSXSAMXAMAAXAAAAAXAMAMXSXSMXXMSXMAMMSMMMSSM
XMMSMAMMMXMXMMMSXXXAXMAAAAMMSAMXAAAMASXSAMXAMMXMAXMSMMAMAAXMASMMMSSMASXMASMMSSMMXMMMSMSMSXMMMSMMMASAMXMMXMAMMMMSMMMMMSMMSXMXSXMMASMMAXASAMXX
XSASMXSASMMMMSXMXSMMSAXSMSMAMAXXXMXSAMAMAXMAXMASXMMAXXSSSMSAMXXAAAASASXMASAMMAAXMXMAMAXXMMAXAAAMMXSAMSXMSXSXSAAAAXSXAMAMXAMAXSASMMMMSSMMSSMX
XMASXAMXMAAAASAMAXAAAXMXMMMMMSMMXXAMXMXMAXSSMSASAMSSSXXAAAXAAMSMMSMMXSXXASMMMXMMAAMXMXMXSASMSSSMXMSAMXAAAAAXSMSSMMSMXMAMSSMASMXXAAXSAAAMAMAM
MMMMMMSXMXMMXXAMASMMMSMMMMAAXMAMXSSSMMAMXXMAAMXMAMAAMMMMMMSXMAAXAAAAXMMMMMAAMASMSSSSMXSAMXXAXMAMMAMAMXMMMXMMSMMMMSXMMSXMXAMXMXMSSMMMXSMMASXX
AXSAXSAMMSSXMSAMXSASAMXAASMMMSAMXAMAMSASMMSMMMMSAMXSMAAXXAMMSSXMSXSAMMAAAXSMSASAAAAAAAMXXAMXMSAMASMMMXMMXAMAMAMXXSAMXAASMMMXMAAMASXAAMASASAM
SMSMXMASAAXAXMMSSXAMMSXSXXAXAMAMMMSAMSASAASAMAAMAMSMXSSMMMSAMAMMAXMASXSXSXMAMXMMMSMMMMSSMMXXAMAMXXAAMMMSMMMAMAMMMSAMMXMXAXAASXMSAMMMMXAMASXA
MAXMASAMMSMXMMAMAMMMMSAMMMMMMSMMAXMAMMXMMMMAMMXMASXMAMAXAXMXMASMMXSXMAMAXXMXMAXMAXAXSAAXAAAASMSSXSSMMAAXASXXMAMAASAMXMMSXMXMSAAMASMASMXMXMMS
SSMSMSASXXMAMMASAAAMASAMXASXMAMXMSSXMSMXXMSMMMSSMSAMSSSMXSAMSXMASAMAMAMMMSSMSMSXMSXMMMSSMMMSAAAAXXASMMSSXMASMSASMSMMXXMAXSXMMMMMAXMASMSXSAAA
SAAMXSASAASXSSMMXSASMSAMMXXAMXSAAMMMMAAAMMAAAAMAMMMMXAAAAMMMMXSAMXSXMASAAAAAMMMAMMXAMSMXXAMXMMMMMSAMXMMMMMMMAMMMAXAMMXAMMMASXMXMSXMMSAAASMMS
XMMMAMMMMXASAMSMXMMMXSXMMSSMMAXMXSAMSASMASXSMXSAMSXMASMMMMSAMMMMSXMASMSMSXMMMASMMSSMXAAMXMSMXXMXAMXMSXMAAAAMAMASXSAMSAMXXSAMAMSMMASXMMMXMMAX
XSAMAMAXXMMXXMAMAAAMXMMXXMASMMSXASAMXAXMXMAAAMSMXMAMMXXXXMSASAMXMMMAXXMAXXMXXXXAAAAXSMSMMMAAXAMMMSMAAASMSSSMXSXSXSAXMASAXMMMAMAAXAMAAXMASXAM
XSASMSMSXAXAMMASMXMXAASMXXAXXSAMXXMMMMXMAMMMMMMMXSAMXMAMMMSAXXXAXAMMSXMAMAMAMXSMMSXMXAAAASMSMXXAAAAMXMMAMAAXAAMMAMMMSAMXSMMSMSMSMSSSMMMSAMAS
XSXMAAASASMMSAMXMASMSSMAMSMMMXXAMXSXXMASXSAXASXAAMXSAMAMAMMMMMXMSXSASAMXSAMASMAXAXMSXSMSMSAAASMMMMXSXMMSMSMMMMAMAMAASAMXSAASXSAXXMAMXAXAAMXS
MMMMSMMSAMXAAXSSMXSAMXMXMAAAAXMSAMXAXSAMAMXMMSMMXSASXSASXXASXMAXMXMASMMASXSASXSMXSASAAXXAXMMSMASXSMMMAAMXMAMXASMMMMXSAMAMXMSAXMASXSMSSSSSMAX
XAAMAMMMMMMMMXMAMMMMMXSSSSSMXSAMXSAMXMMSSMAXSMMAXMAMXMASMSMSAMXSAAMAMAMAMAMXMXMAAMAMMMMMXMAXAMMMAAAASMSMSMMSSMMASXSASAMAXAMMMMSAMMXAXAXMAMMS
SSXMASAMXASMSMSAMMSMAMSAMAAAASAMMSAMXSMAAMXMXAMSXMAMAMAMXAASXMSXMXMAMXMASMSSSXSMMSXMXMXMSAMXMSMSSSMMXAAXXSAAAASXMASASXXXSMMAXAMAMAMAMMMMSMXM
XMMSMMMAXMXAAMMAMMAMASMAMSMMMSAMMSAMMAMXMMAMXXMAASAMSSMMAMXMMXMAMXSXSAMXAXAAXAMAMXXXXMXMXMMMXAAMAMXSMSMXMMMSSMMSMXMAMMXMAXXXMASMMSMMSASMMSAA
SMMAAXXSSMMSMXMAMSAXXXXMMXAAXSMMAMSAMXMAXXASMMSMMSASAMXSXXXXAAMAMAAXAMMMMMMMMXMASMSSMMSAMXAMXMSMSMAXXXXAXAMAAMSASXMSMAMMASMXMXMMAXAASASMASMS
XASXSMAXAAXXMXAMMSASMSAMXMAMXMAMMXMMSAMMMSASMAAXXMMAMXAAAXMASMSXSMSSSMAAXXAXXXSMSAXMAAAMASAXSAXAMMMSMMSXSAMSSMSASXMAMMSMAMAAXAAMAMMMMAMMASMA
SAMXAMXMXMMAMXSMAXXAASMMSSXMAMMAMAMXMAAAMAMXMMSSXSMMMXXMXMAMXXSASAAAASMSSSMXSAMXMMMSMMXXMSAXMAMMMAMAAXAMMXMAAAMAMXMASMXMASMXSXXMASMSMSMMAMMM
AAMSXMAMASMMMAMMXMMSAMXAASASXSAASXSXSSMSSXSXMMXMAAMASAMXMASMMAMAMMMSMMXXAXMASAMXAXAAXXXSMMMMMMMASASXMMASMMMSMXMSMAXASAAXASMXSMXXMAXAXAXMMSMX
SAMAMSASASAAMSSXMXXMSSMSSSXMASMMMXAXXXMXXXMASAMMMMSAMMAAXAAMMSMXMXAAAXMMAMMASAMSSSSMSSXSAMXAAASXSAMXASAMXAAAXAAXMMMXSMSMAMMASMXSMMSXMMXSAAXM
MMAMXMAMASXMMAMASXSMAMAMAMMMXMASXMMMMASAMXSAMMSAAXMASXSMSSXSAAMAMMSSMMMMSMMAXAMAAXXXAXXMAASXSMSAMXSAMMASXSSMSMSMAAAMMAXMAMMAXMAMAAAMSMAMMMSA
XASXSMSMMMMSMMSAMSMMASMMAMSAMXXMXMXAMAMMSAMXSXMXMXAXAMXAMXAMMSXXSAXAXAAAMXMSMMMMSMMMXSMSSMAMMMMXMAAAXSAMXAAXXXAMSXSAMAMMSSMMMMAMXMSAAMASXXXM
MXMASXXASAAXAAMAMAXMASAXXMXMASXXAASMXSSMMXMAXMMMSMMXSAMXSMXMXMMXMXSAMSMSSSXMAXAAAAAXXSAAAMXSAAXAMXXMMMAXMSMMASXXXMAXMASXAXAAAMMSXMXXXSASXMMM
AAMXMMSAMMXSSMSSMAMSASMMSSMSAMXSXMMMAXAMXSMASASAAAAMMAAMAMXMAXMXSXMAMXAAXMASMSMSSSMSASMSMMASMSMSMMMSXSMXMAMXXXMASMMXAAMMMMMSXSAAMSASXMASAXAA
SXMASXMMMXXMAAAAMAMMAMXMMAAMMSAMMAAMSSMMAXMXSAMSSMSMSASXMSXMAMSAMXSXMASMXMASAAMAAAAMAXXAXMXSAXAXMASAAASMXSAMSAMMMAXXMAMAAAAAAMMMSMASAMXMMXXM
MASASASXXXAMMMMMXAAMSMMSAMXMAMAXSMXMMAAMXSMAMAMAMAAASAXMXSXMMXMAXAMASAXAXMAMMSMMXMXMXMSASXAXAMXMSMSMSMSXAXAXSASMSMMMSXSSSMSSSMSXSMSMMMSSXSSS
SAMASXMMMSMMAAXXMMXXAAXMAXAMXSXMMXMMSSMMSAMASAXAMSMXMMXMAMAMXASMSMSMMSSMXMAMXAMMSSMSAAMASMMMXMAMAAXAAAXMASMMSAMXAMAXSMMMAAAMMMXAXXMAMAAXXAAS
MAMMMMSMAAXXSMSXAXMSSSMMMMXSAMXMMAMXAXAXXASAXXSXXXXMAXAMASAMXMMMAAXAAAXASXMSSMSASXASMSMAXAASMMXSMSMSMSMMAAAMMMMSXMSXMASXMMMMSXMXMXMAMMSSMMXM
SXMAAAAMXSSMXASMMAMXMMAAAASMMMAAMASMAMXXSXMXSAMXMASXXSMSASASMSSSMMMMMMSMXASAXAMXMMXMXXMXSAMXASAMXMAXXXXMASAMAXMAMXMXXAMASXSAMXSMMSSMMAAXASXS
MXSSMXXSXAXAMAXAMSASMSSMMMXAAXMMMMSMAMXAXAAASAMASMMSMAMMXSASAMMAAXXXAXMASMMMXMASMMAMXXSAMXSXMAMMMMXMASMSAXXSXSMMASMSMASXMAAXMXAAMAAAMMMXXMAA
SAMXSXASMMMXMAMSMAAMMAXAXMMSMSSXMSSXSXSASMXMXASMXMAAXAMXAMMMAMSSMMXMMSAMXXAXMSXMASASMXMASAMAMMSAXMAMMMAMASAMXMAMSAAXMAMMMSMMSMMAMSSMMASMSMXM
MASAMMMMAAAXXMAMXMXMMAMXMMMMAAAAXAXAMAAASXAMSMMMMMSSSSSMXSSSSMXAMXAAAMXXMSMMASASXSASAXSAMXSXMASMMSASASMMAMAMAXXMMMMMSASAAMXAAAXMMXMASASAMXAX
MMMAMAAMXMSSMSMXMMAMMMXAAXAMMMSMMMMSMSMMMXSMMAASAAXAAAMAMXAAXXXMASXSXSSMMASXMSAMAMAMXAMASXSXMXSXASASASXMXSXMMSSMXAMASASMASMSSSMXXAMXMMMAMSXS
SSSMSSSSXAXMMAMAASXSAAMSMMMSMXAAAXAAMASMXXMASMMSMMSAMSMSSMMMMMSMMAXMASAMSAMXXMAMAMXMSXMASMMMSAMMAMXMXMMAMXAMAAMASMMAMAMMXXAAXAMXSXMSXSXSMSMA
XMAAAAAMMMMMSASXXAMMMSMMAXXAXMSXMMSSSMAMXMMAMXXXXXMXXAAXAAXXAAAAMSAMXMAMMASMMSXSASAMMASAXAAAMSMMSXSAMXXMXSXMMSSMSAMXSMXMMMMMSSMXXMXSAMAMASAM
XSMMMSMAAMAASXSMSMMAXMAXSMSMSXXAMAAXAXMSMSMSSMMXSSSMSMXMMSMSMSSSMXXMMSXMSAMAXAASASMXSAMXSSMXSASXAAXXAMAMXMSXXAXXXMMXXAAMASXAAAMMMMAMAMSMAMSA
ASASXXMSSSMMSASAAXXAMSMMMXMXSAMAMMSXMMXAAAMMAMXXXAAMXSAAXAAAAAXAMXASAMXMMSSSMMMMXMXMMAMXXMAMSAMMMMMMAMASAAAMMMXSXMSSMSMSSSMMMMSAAMMSMMMMAMMM
XSAMXMAAAMXXMAMMMSASMXMASAAAXXMXMXXMAASMSMSSSMAAMSMMAMMXSMSMSMSMMXMMXSXMAMMAMXMMXSAMSSMMMMXMMAMXAXASXSASMSMSXMASMMAXAMAXAXMAMAMXXSMMAAMSSSMS
MMMMMMMMSMXMMXMASXAXAAMASXMAXSAMXAMXXMXAXMMAMXXSMXAMXMXAXXAXAXMASXSXMAXMAXSAMXSAXXAMAXAAAAAMSXSSMSMXXMXXAAXMAMXSAMASXMMMAMSAMXMAMSASMMMAAAAS
XMAMAAXMAMXXAAMXMMMMSXMASAXMASMSMXSSSSMXMXMAMXAXXSXMMXSAMMSXMSMASXAXAASXMMAASAMXSSSMSSSSSSMXAAAAMAXMSMSMSMSSXMASMMASXAXAXASMXSAMXSAMXMMMSMMM
MSSSSSSXSXSXSMSAMAXAMAMXSMMSMMXMMMAXAAASMSSSSMMMMXAXMAXAAMAASMMASXSXMASAAMSMMMMAXXXAAAXXAAXMASMMXMSXAAAAAAXMSMMSXMXMMAMSMMMSASXSAMXMAMXAMMMS
MMMAXAMAMAMXMAMXXAXSMSMAMXAXASMAAMXMMMMXAAAMXAAMMSAXMASMSMSSMAMAXMAASASMMMAAXSMSSMMMMSMXSMMMAMMSAMMMMSMMMXMAASAMXSMMMSAAXAAAMSAXXXASASMMMAAA
SAMXMMMAMAMMSAMSMSXMAAMMAMXSAMASMSAMSMSMMMSMXSMSAMXMSAXXAAMAMAMXXASAMAMMMXMSMXXMAXAAXMXMMXMMXMASMSAMXAAMSSMSMSMSAMAAAMSSSMSXAMMMSMASAMMASMSS
XSMXAXAAXXMAMAMXAMAMXMMXAAXMAMXMXSMSAAAXXMXXAAXMMSXMASXSMSMASMMMSMMMMSMSAASAMXSSMMSSSXMAXASXMMAMXMMMMMSMAAXXAMAMMSSMXXAXXXXMMXSAAMAMAXSMSMAA
SXXSAMMXXXMAMAMMAMXMSXMXAMXXAMMXASXSMSMXXSAMSSMMXMXMAMXMAMMMMXMAAXXAAXMMXMXAMAMAMAXAXMASMMMAASAMSMMSSMAMMSASAMXMAXMMSMMMSSXAXAMMMMXMMXMAXXMX
AXAAAMAASMSASXSMAMAMAASXSMMSASAMXSAXAMMSMMMMMAXMAMAMMMAMAMMMASMSMSSMSSMAMSSSMASXMSMSMMAXXMMMMMAXSAAAAXMSXXASXMAXMMMAASASAMXMMMSMSSMMSSMAMMXM
MMMMSMXXSAAAAAXXASASXXMAMAASXMASMMMMSMAAAASASMMSASASMSSMASXMAMAAXMASAXMAMXAASAMXAXAAAMSSSMAXXSXMSMMSSMXAAMAMXSXSXAMSSSSMASAXAMAXAAAAAAAMSAAA
XXXXMAMXMAMSMAMSXSMSXMMAMMMMXXMAMAXXXMSSSMSMSXMSASMSMXMAXSAMMSSMSSMMSSSMSMSMMSAMXMSMSMMAASXSAMXMXXMAXXSMSMSMMXXSMSXXAMXMASASMSSSSSMMSSMXAXSS

10
inputs/04/test.txt Normal file
View File

@ -0,0 +1,10 @@
MMMSXXMASM
MSAMXMSMSA
AMXSXMAAMM
MSAMASMSMX
XMASAMXAMM
XXAMMXXAMA
SMSMSASXSS
SAXAMASAAA
MAMMMXMMMM
MXMXAXMASX

37
solutions/03.zig
View File

@ -1,15 +1,3 @@
// It seems like the goal of the program is just to multiply some numbers. It does that with instructions like mul(X,Y), where X and Y are each 1-3 digit numbers. For instance, mul(44,46) multiplies 44 by 46 to get a result of 2024. Similarly, mul(123,4) would multiply 123 by 4.
// However, because the program's memory has been corrupted, there are also many invalid characters that should be ignored, even if they look like part of a mul instruction. Sequences like mul(4*, mul(6,9!, ?(12,34), or mul ( 2 , 4 ) do nothing.
// For example, consider the following section of corrupted memory:
// xmul(2,4)%&mul[3,7]!@^do_not_mul(5,5)+mul(32,64]then(mul(11,8)mul(8,5))
// Only the four highlighted sections are real mul instructions. Adding up the result of each instruction produces 161 (2*4 + 5*5 + 11*8 + 8*5).
// Scan the corrupted memory for uncorrupted mul instructions. What do you get if you add up all of the results of the multiplications?
const std = @import("std"); const std = @import("std");
const print = std.debug.print; const print = std.debug.print;
const util = @import("util.zig"); const util = @import("util.zig");
@ -38,7 +26,6 @@ pub fn part_one() !u32 {
idx += 1; idx += 1;
} }
return total; return total;
} }
pub fn part_two() !u32 { pub fn part_two() !u32 {
@ -50,12 +37,12 @@ pub fn part_two() !u32 {
while (idx < data.len) { while (idx < data.len) {
// As elsewhere - there are probably plenty of optimizations to be done here, such as only checking for `d` // As elsewhere - there are probably plenty of optimizations to be done here, such as only checking for `d`
// first to avoid checking the whole 4 bytes. Lol :P // first to avoid checking the whole 4 bytes. Lol :P
if (idx+4 < data.len and std.mem.eql(u8, data[idx..idx+4], "do()")) { if (idx + 4 < data.len and std.mem.eql(u8, data[idx .. idx + 4], "do()")) {
should_mul = true; should_mul = true;
idx += 1; idx += 1;
continue; continue;
} }
if (idx+7 < data.len and std.mem.eql(u8, data[idx..idx+7], "don't()")) { if (idx + 7 < data.len and std.mem.eql(u8, data[idx .. idx + 7], "don't()")) {
should_mul = false; should_mul = false;
idx += 1; idx += 1;
continue; continue;
@ -84,10 +71,10 @@ fn check_if_is_valid_multiplication(line: []const u8, start_index: u32) u32 {
return 0; return 0;
} }
if (!std.mem.eql(u8, line[start_index..start_index+4], "mul(")) { if (!std.mem.eql(u8, line[start_index .. start_index + 4], "mul(")) {
return 0; return 0;
} }
if (line[start_index+4] == ')') { if (line[start_index + 4] == ')') {
// I.e. if `mul()` // I.e. if `mul()`
// print("DEBUG - content is mul()", .{}); // print("DEBUG - content is mul()", .{});
return 0; return 0;
@ -97,11 +84,11 @@ fn check_if_is_valid_multiplication(line: []const u8, start_index: u32) u32 {
var length_of_parameters: u32 = 0; var length_of_parameters: u32 = 0;
var index_of_comma: u32 = 0; var index_of_comma: u32 = 0;
while (i < 12) { while (i < 12) {
if (line[start_index+i] == ')') { if (line[start_index + i] == ')') {
length_of_parameters = i; length_of_parameters = i;
break; break;
} }
if (line[start_index+i] == ',') { if (line[start_index + i] == ',') {
index_of_comma = i; index_of_comma = i;
} }
i += 1; i += 1;
@ -118,23 +105,23 @@ fn check_if_is_valid_multiplication(line: []const u8, start_index: u32) u32 {
} }
// This is _almost_ guaranteed to be a legal multiplication command - we know it has the form // This is _almost_ guaranteed to be a legal multiplication command - we know it has the form
// `mul(...,...)`. Try parsing the `...`s as ints - and if they don't parse, return 0 // `mul(...,...)`. Try parsing the `...`s as ints - and if they don't parse, return 0
const num_1 = std.fmt.parseInt(u32, line[start_index+4..start_index+index_of_comma], 10) catch { const num_1 = std.fmt.parseInt(u32, line[start_index + 4 .. start_index + index_of_comma], 10) catch {
print("DEBUG - failed to parse first value into an integer: ", .{}); print("DEBUG - failed to parse first value into an integer: ", .{});
for (line[start_index..start_index+index_of_comma]) |char| { for (line[start_index .. start_index + index_of_comma]) |char| {
print("{c}", .{char}); print("{c}", .{char});
} }
print("\n", .{}); print("\n", .{});
return 0; return 0;
}; };
const num_2 = std.fmt.parseInt(u32, line[start_index+index_of_comma+1..start_index+length_of_parameters], 10) catch { const num_2 = std.fmt.parseInt(u32, line[start_index + index_of_comma + 1 .. start_index + length_of_parameters], 10) catch {
print("DEBUG - failed to parse second value into an integer: ", .{}); print("DEBUG - failed to parse second value into an integer: ", .{});
for (line[start_index+index_of_comma+1..start_index+length_of_parameters]) |char| { for (line[start_index + index_of_comma + 1 .. start_index + length_of_parameters]) |char| {
print("{c}", .{char}); print("{c}", .{char});
} }
print("\n", .{}); print("\n", .{});
return 0; return 0;
}; };
print("DEBUG - found a real pair, {} and {}\n", .{num_1, num_2}); print("DEBUG - found a real pair, {} and {}\n", .{ num_1, num_2 });
return num_1 * num_2; return num_1 * num_2;
} }
@ -147,7 +134,7 @@ test "Testing multiplication" {
} }
// This is absolutely fucking ridiculous - but, simply doing `<variable>.*` doesn't work. // This is absolutely fucking ridiculous - but, simply doing `<variable>.*` doesn't work.
fn fromStringToU8Array(string: *const[57:0]u8) ![]u8 { fn fromStringToU8Array(string: *const [57:0]u8) ![]u8 {
var gpa = std.heap.GeneralPurposeAllocator(.{}){}; var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit(); defer _ = gpa.deinit();
const allocator = gpa.allocator(); const allocator = gpa.allocator();

286
solutions/04.zig Normal file
View File

@ -0,0 +1,286 @@
const std = @import("std");
const print = std.debug.print;
const util = @import("util.zig");
pub fn main() !void {
const output = try part_two();
print("{}\n", .{output});
}
const Location = struct { x: u32, y: u32 };
const NavigationError = error{OutOfBounds};
const Direction = enum {
north,
north_east,
east,
south_east,
south,
south_west,
west,
north_west,
// Errors if asked to go below zero
fn progress(self: Direction, from: Location) NavigationError!Location {
return switch (self) {
Direction.north => {
if (from.y > 0) {
return Location{ .x = from.x, .y = from.y - 1 };
} else {
return error.OutOfBounds;
}
},
Direction.north_east => {
if (from.y > 0) {
return Location{ .x = from.x + 1, .y = from.y - 1 };
} else {
return error.OutOfBounds;
}
},
Direction.east => Location{ .x = from.x + 1, .y = from.y },
Direction.south_east => Location{ .x = from.x + 1, .y = from.y + 1 },
Direction.south => Location{ .x = from.x, .y = from.y + 1 },
Direction.south_west => {
if (from.x > 0) {
return Location{ .x = from.x - 1, .y = from.y + 1 };
} else {
return error.OutOfBounds;
}
},
Direction.west => {
if (from.x > 0) {
return Location{ .x = from.x - 1, .y = from.y };
} else {
return error.OutOfBounds;
}
},
Direction.north_west => {
if (from.x > 0 and from.y > 0) {
return Location{ .x = from.x - 1, .y = from.y - 1 };
} else {
return error.OutOfBounds;
}
},
};
}
pub fn getIndicesFromStartingPoint(self: Direction, starting_point: Location) ![4]Location {
var response: [4]Location = undefined;
response[0] = starting_point;
var idx: u8 = 1;
while (idx < 4) {
response[idx] = try self.progress(response[idx - 1]);
idx += 1;
}
return response;
}
};
// !?
const ALL_DIRECTIONS: [8]Direction = .{ Direction.north, Direction.north_east, Direction.east, Direction.south_east, Direction.south, Direction.south_west, Direction.west, Direction.north_west };
pub fn part_one() !u32 {
// Logic:
// * Iterate over the letters
// * When X is found:
// * Iterate over all 8 directions
// * If an XMAS is found in that direction, increment counter
const is_test_case: bool = true;
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
const data = try util.readAllInput(try util.getInputFile("04", is_test_case));
// https://stackoverflow.com/a/79199470/1040915
var it = std.mem.splitScalar(u8, data, '\n');
var lines_list = std.ArrayList([]const u8).init(allocator);
defer lines_list.deinit();
while (it.next()) |line| {
if (line.len > 1) {
try lines_list.append(line);
}
}
const lines = lines_list.items;
// Makes the assumption that all lines are the same length.
// In real production code, we'd assert that.
const line_length = lines[0].len;
const number_of_lines = lines.len;
print("DEBUG - line_length is {} and number_of_lines is {}\n", .{ line_length, number_of_lines });
var x: u32 = 0;
var number_of_xmasses: u32 = 0;
while (x < line_length) : (x += 1) {
var y: u32 = 0;
while (y < number_of_lines) : (y += 1) {
const starting_point = Location{ .x = x, .y = y };
print("SUPER-DEBUG - checking in neighbourhood of {}\n", .{starting_point});
// Short-circuit - only do checking if the starting_point is `X`
if (lines[starting_point.y][starting_point.x] != 'X') {
continue;
}
print("DEBUG - found an X at {}\n", .{starting_point});
for (ALL_DIRECTIONS) |dir| {
if (is_valid_xmas(lines, starting_point, dir)) {
number_of_xmasses += 1;
}
}
}
}
return number_of_xmasses;
}
fn is_valid_xmas(data: [][]const u8, starting_point: Location, dir: Direction) bool {
const indices = dir.getIndicesFromStartingPoint(starting_point) catch {
// If we fail to get the indices (because they strayed out-of-bounds), then of _course_ that's not a valid XMAS.
return false;
};
// Check for validity to avoid bounds issues
for (indices) |index| {
if (index.x >= data[0].len or index.y >= data.len) {
return false;
}
}
print("DEBUG - checking indices {any}\n", .{indices});
const return_value = (data[indices[0].y][indices[0].x] == 'X' and
data[indices[1].y][indices[1].x] == 'M' and
data[indices[2].y][indices[2].x] == 'A' and
data[indices[3].y][indices[3].x] == 'S');
if (return_value) {
print("DEBUG - found an XMAS at {}, going {}\n", .{ starting_point, dir });
}
return return_value;
}
const expect = std.testing.expect;
// test "part_one" {
// try expect(try part_one() == 18);
// }
// ==========
pub fn part_two() !u32 {
// Logic:
// * Iterate over the letters
// * When M is found:
// * Look for a X going forwards-down and backwards-down
// (No need to look for Xs going upwards because all upward-crosses will have already been found as part of an
// earlier pass)
const is_test_case: bool = true;
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
const data = try util.readAllInput(try util.getInputFile("04", is_test_case));
// https://stackoverflow.com/a/79199470/1040915
var it = std.mem.splitScalar(u8, data, '\n');
var lines_list = std.ArrayList([]const u8).init(allocator);
defer lines_list.deinit();
while (it.next()) |line| {
if (line.len > 1) {
try lines_list.append(line);
}
}
const lines = lines_list.items;
// Makes the assumption that all lines are the same length.
// In real production code, we'd assert that.
const line_length = lines[0].len;
const number_of_lines = lines.len;
print("DEBUG - line_length is {} and number_of_lines is {}\n", .{ line_length, number_of_lines });
var x: u32 = 0;
var number_of_xmasses: u32 = 0;
while (x < line_length) : (x += 1) {
var y: u32 = 0;
while (y < number_of_lines) : (y += 1) {
const starting_point = Location{ .x = x, .y = y };
print("SUPER-DEBUG - checking in neighbourhood of {}\n", .{starting_point});
// Short-circuit - only do checking if the starting_point is `M`
if (lines[starting_point.y][starting_point.x] != 'M') {
continue;
}
print("DEBUG - found a M at {}\n", .{starting_point});
// I could probably have implemented `is_valid_cross` as a single function taking a 4-value enum, but, ehh.
for ([2]bool{ true, false }) |is_forwards| {
if (is_valid_horizontal_cross(lines, starting_point, is_forwards)) {
number_of_xmasses += 1;
}
}
for ([2]bool{ true, false }) |is_upward| {
if (is_valid_vertical_cross(lines, starting_point, is_upward)) {
number_of_xmasses += 1;
}
}
}
}
return number_of_xmasses;
}
fn is_valid_horizontal_cross(data: [][]const u8, starting_point: Location, is_forward: bool) bool {
if (is_forward) {
if (starting_point.x >= data[0].len - 2 or starting_point.y >= data.len - 2) {
return false;
}
const found_forward_cross = (data[starting_point.y + 2][starting_point.x] == 'M' and
data[starting_point.y + 1][starting_point.x + 1] == 'A' and
data[starting_point.y][starting_point.x + 2] == 'S' and
data[starting_point.y + 2][starting_point.x + 2] == 'S');
if (found_forward_cross) {
print("Found forward cross\n", .{});
}
return found_forward_cross;
} else {
if (starting_point.x < 2 or starting_point.y >= data.len - 2) {
return false;
}
const found_backward_cross = (data[starting_point.y + 2][starting_point.x] == 'M' and
data[starting_point.y + 1][starting_point.x - 1] == 'A' and
data[starting_point.y][starting_point.x - 2] == 'S' and
data[starting_point.y + 2][starting_point.x - 2] == 'S');
if (found_backward_cross) {
print("Found backward cross\n", .{});
}
return found_backward_cross;
}
}
fn is_valid_vertical_cross(data: [][]const u8, starting_point: Location, is_upward: bool) bool {
if (is_upward) {
if (starting_point.y < 2 or starting_point.x >= data[0].len - 2) {
return false;
}
const found_upward_cross = (data[starting_point.y][starting_point.x + 2] == 'M' and
data[starting_point.y - 1][starting_point.x + 1] == 'A' and
data[starting_point.y - 2][starting_point.x] == 'S' and
data[starting_point.y - 2][starting_point.x + 2] == 'S');
if (found_upward_cross) {
print("Found upward cross\n", .{});
}
return found_upward_cross;
} else {
if (starting_point.y >= data.len - 2 or starting_point.x >= data[0].len - 2) {
return false;
}
const found_downward_cross = (data[starting_point.y][starting_point.x + 2] == 'M' and
data[starting_point.y + 1][starting_point.x + 1] == 'A' and
data[starting_point.y + 2][starting_point.x] == 'S' and
data[starting_point.y + 2][starting_point.x + 2] == 'S');
if (found_downward_cross) {
print("Found downward cross\n", .{});
}
return found_downward_cross;
}
}
test "part_two" {
const answer_of_part_two = try part_two();
print("DEBUG - answer is {}\n", .{answer_of_part_two});
try expect(answer_of_part_two == 9);
}