From be110c4dea2ff014b541c8b78c14a42933aefffe Mon Sep 17 00:00:00 2001 From: xuu Date: Wed, 20 Dec 2023 11:27:20 -0700 Subject: [PATCH 1/4] chore: save day18 --- day18/example.txt | 14 + day18/input.txt | 766 +++++++++++++++++++++++++++++++++++++++++++++ day18/main.go | 215 +++++++++++++ day18/main_test.go | 42 +++ 4 files changed, 1037 insertions(+) create mode 100644 day18/example.txt create mode 100644 day18/input.txt create mode 100644 day18/main.go create mode 100644 day18/main_test.go diff --git a/day18/example.txt b/day18/example.txt new file mode 100644 index 0000000..0ad754b --- /dev/null +++ b/day18/example.txt @@ -0,0 +1,14 @@ +R 6 (#70c710) +D 5 (#0dc571) +L 2 (#5713f0) +D 2 (#d2c081) +R 2 (#59c680) +D 2 (#411b91) +L 5 (#8ceee2) +U 2 (#caa173) +L 1 (#1b58a2) +U 2 (#caa171) +R 2 (#7807d2) +U 3 (#a77fa3) +L 2 (#015232) +U 2 (#7a21e3) \ No newline at end of file diff --git a/day18/input.txt b/day18/input.txt new file mode 100644 index 0000000..79212d7 --- /dev/null +++ b/day18/input.txt @@ -0,0 +1,766 @@ +R 4 (#0a7a60) +U 8 (#4453b3) +R 6 (#8e4f70) +U 2 (#4453b1) +R 4 (#0feb00) +U 4 (#355591) +R 8 (#2a09c0) +U 4 (#544c71) +R 4 (#472930) +U 2 (#199e33) +R 3 (#3d8df0) +U 5 (#199e31) +R 7 (#45de50) +U 4 (#57a941) +L 7 (#671c70) +U 5 (#5e5e81) +R 4 (#2e9b60) +U 8 (#490881) +L 7 (#1846f0) +U 3 (#304101) +L 4 (#1846f2) +D 2 (#58f3f1) +L 9 (#2e9b62) +D 2 (#56dcd1) +L 2 (#671c72) +D 9 (#275fd1) +L 4 (#76b7b2) +U 9 (#5b9641) +L 4 (#1d3212) +U 10 (#3d1841) +L 3 (#5ad5e2) +D 6 (#010211) +L 5 (#13ec52) +D 8 (#166471) +L 3 (#53ebc0) +D 5 (#0fdba1) +L 4 (#54e450) +D 9 (#440a21) +L 3 (#49b242) +D 5 (#2f0171) +L 6 (#447332) +D 4 (#182561) +L 8 (#1aaaa2) +D 6 (#0996a1) +L 4 (#1c1212) +D 6 (#5780d1) +L 7 (#0fc1d2) +D 7 (#36cb41) +L 3 (#505552) +D 7 (#8d8b81) +R 4 (#2bf742) +D 7 (#152791) +R 5 (#760492) +D 3 (#11a991) +R 3 (#5debc0) +D 10 (#59f211) +L 4 (#66d342) +D 8 (#1fc6b1) +R 4 (#66d340) +D 6 (#72dff1) +L 2 (#3f1b10) +D 4 (#2fca13) +L 10 (#2d0162) +D 5 (#8b5e53) +L 6 (#2d0160) +U 2 (#317053) +L 2 (#650c20) +U 7 (#2bed01) +R 10 (#409ed0) +U 2 (#166713) +L 10 (#939350) +U 6 (#166711) +L 4 (#38a180) +D 3 (#1d95f1) +L 6 (#11ea60) +D 5 (#931dc1) +R 6 (#11bf70) +D 7 (#536051) +L 3 (#995b60) +D 2 (#254e91) +L 3 (#332fd2) +U 6 (#7669f1) +L 3 (#574642) +U 6 (#1778a1) +L 3 (#1a00c2) +U 5 (#2eaa81) +L 3 (#1cf8e2) +U 6 (#0c71a1) +L 6 (#868472) +U 3 (#0a9fd1) +R 9 (#104c02) +U 4 (#082451) +L 7 (#850d02) +U 6 (#082453) +L 7 (#322552) +U 3 (#1339d1) +L 6 (#8e11d2) +U 4 (#6c5691) +R 6 (#1dda10) +U 3 (#25e5c3) +R 7 (#370670) +U 4 (#9324f1) +L 3 (#451030) +U 7 (#1f1021) +L 7 (#0ba3c0) +U 5 (#8a10a3) +L 8 (#67db30) +U 5 (#282473) +L 4 (#0cd350) +U 4 (#25e5c1) +R 3 (#6b4ee0) +U 4 (#333cf1) +R 5 (#02b610) +D 4 (#4e7cc1) +R 3 (#92abb0) +U 5 (#2f6ff1) +R 5 (#483360) +U 5 (#7b1cd1) +L 8 (#3a5d50) +U 3 (#1d2461) +R 8 (#3b2fd0) +U 5 (#630763) +R 6 (#5033c0) +U 3 (#252523) +R 7 (#08eeb0) +U 8 (#516633) +L 7 (#156240) +U 4 (#2db063) +L 3 (#791070) +D 5 (#2920a3) +L 3 (#0dafe0) +U 5 (#4185b3) +L 5 (#7ac0e0) +U 2 (#5a6cd3) +L 2 (#3ca790) +U 7 (#755403) +L 4 (#3b0740) +U 5 (#2004a3) +L 3 (#2db4f0) +U 6 (#602a23) +R 5 (#32c1c0) +D 2 (#000f53) +R 5 (#388360) +D 7 (#24d9e3) +R 4 (#4703a0) +D 3 (#2f1133) +R 3 (#4703a2) +U 11 (#52e853) +R 5 (#278132) +D 11 (#0665e3) +R 3 (#239112) +U 6 (#8f0ad1) +R 5 (#447de2) +U 6 (#8f0ad3) +R 6 (#636122) +U 2 (#187283) +R 3 (#5aae62) +U 10 (#1d8833) +L 5 (#476db0) +U 5 (#136393) +L 7 (#29e6b0) +U 5 (#136391) +R 7 (#3ba060) +U 3 (#635e23) +L 5 (#2042f0) +U 3 (#181643) +L 6 (#5af952) +U 8 (#28d0b1) +L 2 (#4a98f2) +U 9 (#28d0b3) +L 6 (#27a572) +D 3 (#3d7213) +L 4 (#516842) +D 11 (#21ef63) +L 5 (#38e342) +D 2 (#1118b3) +L 3 (#560502) +D 9 (#1118b1) +R 2 (#1c39a2) +D 2 (#303ab3) +R 6 (#716ba0) +D 6 (#780a93) +L 8 (#77ec30) +U 2 (#780a91) +L 3 (#271100) +U 10 (#5882f3) +L 4 (#2050c2) +D 3 (#434843) +L 3 (#7d9572) +D 2 (#3129b3) +L 5 (#21fb12) +D 5 (#8c2c33) +L 4 (#57bf92) +D 6 (#2730b3) +L 4 (#6a3902) +D 8 (#4656a3) +L 5 (#60ac80) +D 4 (#43b863) +R 9 (#3d69a0) +D 8 (#3ca913) +L 2 (#411d80) +D 3 (#725383) +L 8 (#4a98d0) +D 9 (#274553) +L 5 (#580d60) +U 5 (#568223) +L 6 (#473af0) +U 5 (#827593) +L 7 (#251dc2) +U 5 (#0fcea3) +L 8 (#5ae3d2) +U 3 (#4efa11) +R 9 (#389852) +U 2 (#7f7f91) +R 6 (#618342) +U 3 (#441143) +L 7 (#886df2) +U 3 (#26a093) +L 8 (#886df0) +U 4 (#63c7d3) +L 3 (#04f842) +D 10 (#0fcea1) +L 6 (#388e62) +U 10 (#3ae7f3) +L 3 (#2a6880) +U 6 (#3bfd53) +L 6 (#73a0c0) +U 5 (#3bfd51) +L 4 (#0d18a0) +U 2 (#19da93) +L 6 (#120600) +U 8 (#233b53) +L 6 (#2e1050) +U 3 (#4b2aa3) +L 4 (#5f9930) +U 10 (#6e65f1) +R 6 (#1eefa0) +U 9 (#50b9d3) +R 2 (#548ed0) +U 9 (#50b9d1) +R 7 (#8bd9f0) +U 4 (#5ae473) +R 6 (#0b0490) +U 10 (#186891) +R 4 (#764830) +U 7 (#33b0e1) +R 5 (#363c90) +U 8 (#7bd631) +R 7 (#031e30) +U 7 (#095881) +R 3 (#640e50) +D 5 (#02e7f3) +R 7 (#0922f0) +D 7 (#6b7af3) +R 9 (#0922f2) +D 3 (#62e543) +R 3 (#21e320) +U 9 (#5ead81) +R 7 (#01fd70) +D 9 (#3b0cf1) +R 2 (#2758a0) +D 5 (#7279b1) +R 8 (#5c7dc0) +D 7 (#3c8db1) +R 4 (#3c3740) +U 2 (#26b151) +R 6 (#11eb12) +U 4 (#587921) +R 6 (#11eb10) +U 4 (#320051) +R 4 (#038630) +U 3 (#6a2e61) +R 2 (#4ff680) +U 5 (#3c57f1) +R 9 (#0b2440) +U 8 (#497533) +L 6 (#704680) +U 11 (#549113) +R 6 (#23b470) +U 4 (#9e0641) +R 7 (#1aeec0) +D 7 (#4a6331) +R 2 (#547d80) +D 5 (#457a71) +R 9 (#7daa90) +D 4 (#16d7b1) +L 6 (#266810) +D 3 (#363561) +L 5 (#5312b2) +D 4 (#42c301) +R 5 (#9a0952) +D 7 (#42c303) +R 7 (#7d1df2) +D 4 (#51e321) +R 5 (#609422) +D 4 (#3b8f01) +R 6 (#644792) +U 4 (#2d8b11) +R 7 (#22bbc2) +D 7 (#6b39b1) +R 5 (#680e72) +U 2 (#7f9f31) +R 3 (#0e9b52) +U 3 (#3086c1) +R 3 (#5a60c0) +U 6 (#53b6e3) +R 7 (#8117d0) +U 7 (#53b6e1) +R 3 (#2cb930) +U 3 (#1bffd1) +R 6 (#4539f0) +U 8 (#680411) +R 4 (#6032c0) +U 6 (#255061) +R 3 (#5562a0) +U 6 (#088071) +R 3 (#3bf2f0) +U 5 (#52bdb1) +L 6 (#070500) +U 5 (#69e001) +R 6 (#070502) +U 3 (#071051) +R 2 (#036000) +U 4 (#0ea8a1) +R 5 (#05e4d0) +U 3 (#674de1) +R 3 (#804250) +D 6 (#3ffca1) +R 4 (#23dcb2) +D 6 (#9f9841) +L 5 (#45f210) +D 9 (#15efc1) +R 5 (#45f212) +D 4 (#969551) +L 9 (#23dcb0) +D 2 (#41bea1) +L 4 (#2f2a32) +D 4 (#71ffd1) +R 3 (#5c0bb2) +D 7 (#6f3501) +R 4 (#2b0a72) +D 4 (#7b3571) +R 3 (#1c67d2) +U 11 (#42f011) +R 3 (#51ae62) +D 3 (#75fcf1) +R 3 (#1f4742) +D 4 (#2813f1) +R 4 (#3d1812) +D 2 (#2b1d01) +R 11 (#1eb302) +U 3 (#27b0a1) +R 4 (#227b20) +U 5 (#34b7e1) +R 10 (#201220) +U 7 (#0502f3) +R 4 (#5ab7f0) +U 4 (#0502f1) +R 4 (#5d09b0) +U 7 (#504a81) +R 7 (#1e8250) +U 3 (#715aa1) +R 6 (#26d290) +U 6 (#9a12f1) +L 3 (#18be90) +U 8 (#037d11) +L 5 (#647600) +U 3 (#40b983) +L 5 (#04e450) +U 3 (#9a9a43) +L 8 (#04e452) +U 6 (#8af153) +R 8 (#6cbc90) +U 4 (#04d121) +L 4 (#285292) +U 3 (#688d51) +L 6 (#176332) +U 4 (#400a91) +L 5 (#176330) +U 5 (#43def1) +R 2 (#285290) +U 2 (#3e0711) +R 3 (#7eb9c0) +U 7 (#36f611) +R 7 (#666af0) +D 7 (#381b31) +R 3 (#298922) +U 3 (#475671) +R 6 (#977c12) +D 4 (#602d01) +R 6 (#25b0c2) +D 6 (#7ede81) +R 3 (#1d58c2) +D 8 (#873523) +L 9 (#265ae2) +D 3 (#57d663) +R 7 (#1565c2) +D 8 (#06ed11) +R 4 (#a348c2) +D 2 (#06ed13) +R 8 (#12d052) +D 4 (#2d3741) +L 7 (#0ccfd2) +D 3 (#1fcd61) +R 4 (#39a4c2) +D 3 (#44f7f1) +R 6 (#5c3202) +D 8 (#2625c1) +L 8 (#2b08c2) +D 2 (#20d7e1) +L 2 (#67b892) +D 10 (#546471) +R 7 (#484ef2) +D 7 (#49bc91) +R 4 (#91aa72) +U 11 (#499591) +R 3 (#0048b2) +U 7 (#34a7a1) +R 7 (#514600) +U 8 (#1cdc43) +L 7 (#471470) +U 3 (#8c8393) +R 3 (#18a780) +U 5 (#8c8391) +R 3 (#4e6f80) +U 3 (#1cdc41) +R 8 (#428930) +U 5 (#5dcb51) +R 3 (#4b21e2) +U 4 (#0464b1) +R 9 (#850552) +D 8 (#464881) +R 7 (#543852) +D 3 (#2d3a11) +R 3 (#081b22) +D 5 (#0cc731) +R 7 (#6990e0) +D 3 (#79d7b1) +R 3 (#509520) +D 5 (#438571) +R 3 (#27d510) +D 3 (#30d2d3) +L 8 (#1b7a00) +D 5 (#8a0da3) +L 8 (#1b7a02) +U 5 (#027cb3) +L 7 (#350130) +D 8 (#2ff771) +R 7 (#16dc02) +D 2 (#68f1c1) +R 5 (#02f782) +D 6 (#4e2a41) +R 11 (#448e32) +D 5 (#2cfac1) +L 11 (#417502) +D 5 (#2cfac3) +L 4 (#22f022) +U 9 (#1e9f01) +L 5 (#543572) +U 3 (#076e31) +L 6 (#081b20) +U 5 (#1ae851) +L 3 (#823132) +U 9 (#2d7993) +L 4 (#5738f2) +D 8 (#79e273) +L 4 (#5c9ad2) +D 8 (#4ed1b3) +L 3 (#311722) +D 4 (#0d5493) +L 6 (#5d63e0) +D 6 (#178cf3) +L 5 (#75b1b0) +D 5 (#178cf1) +L 6 (#11d550) +D 6 (#44ed03) +L 3 (#76a842) +U 6 (#3b6993) +L 5 (#184892) +D 4 (#5c8163) +L 3 (#14d872) +U 2 (#261a01) +L 5 (#2d01e2) +U 9 (#326ca3) +L 4 (#59ad32) +U 8 (#326ca1) +R 4 (#389ab2) +U 9 (#261a03) +L 4 (#50cb42) +D 4 (#2f8263) +L 5 (#9f3752) +D 6 (#4bb383) +L 4 (#2693f2) +D 4 (#19dca3) +R 4 (#475bc2) +D 6 (#960e13) +L 7 (#0c90a2) +D 8 (#3463d3) +L 6 (#5a82e2) +D 3 (#5a5c43) +R 7 (#120bf2) +D 3 (#5069e3) +R 3 (#4b47a2) +D 6 (#635b63) +R 4 (#66ca10) +U 4 (#1418f1) +R 7 (#1d5470) +D 4 (#1418f3) +R 8 (#66d4f0) +D 5 (#3c5533) +R 4 (#2f6e02) +D 3 (#2cf5e3) +R 4 (#633ec2) +D 7 (#2cf5e1) +R 7 (#5846b2) +D 3 (#4f9d63) +R 4 (#533380) +D 11 (#13c7e3) +R 2 (#222b62) +D 3 (#928ab3) +R 5 (#222b60) +U 5 (#0a4793) +R 5 (#15d3b0) +U 8 (#363fe1) +R 4 (#2feb30) +U 5 (#05d8b1) +R 3 (#39e030) +U 3 (#05d8b3) +R 2 (#3cd780) +U 8 (#02c781) +R 5 (#186452) +D 3 (#37bba1) +R 5 (#9e1232) +D 5 (#58e6f1) +R 5 (#182c30) +D 5 (#072db1) +R 5 (#85e600) +D 4 (#607651) +R 5 (#186450) +D 3 (#0aca91) +L 5 (#0ceb10) +D 5 (#860001) +L 6 (#54c8b0) +U 5 (#393971) +L 4 (#37c390) +D 3 (#1f1433) +L 5 (#3d8790) +D 6 (#353623) +R 4 (#78c830) +D 4 (#6fafa3) +R 6 (#2b0612) +D 5 (#31fff3) +R 7 (#8b49b2) +D 9 (#6f0ee3) +R 5 (#4212e0) +D 6 (#5d11f3) +R 6 (#648340) +D 8 (#393743) +R 6 (#34ddd0) +U 8 (#346fb3) +R 5 (#34fc22) +D 4 (#71c453) +R 6 (#5048f2) +D 4 (#0bb993) +R 4 (#42b9f0) +D 9 (#5cdf83) +R 5 (#42b9f2) +D 3 (#6f3f93) +R 3 (#3dbae2) +D 8 (#495363) +R 9 (#328ba2) +D 3 (#77afa1) +R 5 (#575710) +D 2 (#10d861) +R 4 (#257822) +D 4 (#6efe61) +R 9 (#257820) +D 5 (#521d01) +R 5 (#575712) +D 6 (#494cf1) +L 5 (#683ab2) +D 4 (#5e79c3) +L 3 (#4242a2) +D 4 (#5e79c1) +L 7 (#2c3442) +D 8 (#2fbd23) +L 5 (#636fb2) +D 5 (#63bd53) +L 2 (#299960) +D 6 (#31ea33) +R 3 (#51dfb0) +D 7 (#4e4ec3) +R 4 (#7b7912) +D 5 (#4b4bf3) +R 4 (#54e882) +D 5 (#7d2193) +R 3 (#3b77d2) +D 3 (#826973) +R 8 (#646ec2) +D 4 (#076c63) +L 10 (#674052) +D 6 (#3676b1) +L 9 (#3bd890) +D 4 (#7feb71) +L 3 (#3bd892) +D 3 (#27fc21) +R 8 (#66bba2) +D 8 (#645c73) +R 5 (#43e132) +D 5 (#51d9e3) +R 8 (#43e130) +D 6 (#2827f3) +R 4 (#412c92) +D 5 (#7e7f63) +L 4 (#218122) +D 4 (#546e83) +L 9 (#82f672) +D 8 (#6ed383) +L 3 (#701412) +D 7 (#47de23) +L 5 (#46f912) +D 7 (#0d9ec3) +L 4 (#515142) +D 3 (#4699e3) +L 9 (#2ed562) +U 6 (#00a273) +L 9 (#8d7d12) +U 2 (#6c3a83) +L 7 (#318fa2) +U 7 (#0bd473) +L 2 (#6d5050) +U 10 (#415673) +R 3 (#9e8420) +U 6 (#1ff213) +R 5 (#0c8bf0) +U 2 (#479a11) +R 6 (#977360) +U 5 (#479a13) +L 8 (#250680) +U 2 (#1ff211) +L 3 (#216630) +U 3 (#22d143) +L 3 (#3b4342) +U 7 (#9d4ff3) +L 5 (#43aca2) +U 6 (#29efd3) +L 3 (#5c6a12) +D 11 (#134a73) +L 6 (#2a0982) +U 11 (#444723) +L 4 (#47e2e2) +U 4 (#6855c3) +L 4 (#06a382) +U 4 (#2222e3) +R 3 (#4edc62) +U 6 (#9a2683) +R 6 (#131872) +U 10 (#4f5a23) +R 4 (#858f70) +U 5 (#4d4823) +L 9 (#3f73f0) +U 3 (#46f5a3) +L 4 (#935370) +U 4 (#46f5a1) +L 5 (#3ca140) +U 6 (#07b1e3) +L 5 (#61ecd0) +U 5 (#654743) +L 5 (#3cec42) +U 6 (#30bb83) +R 3 (#920782) +U 6 (#1f9323) +R 8 (#3d8aa2) +U 8 (#7492c3) +R 3 (#301cd2) +U 3 (#32e2f1) +R 4 (#6936f2) +U 6 (#32e2f3) +R 6 (#5112c2) +U 7 (#535b53) +L 10 (#61f4d0) +U 3 (#915863) +L 2 (#51d540) +U 5 (#32dee1) +L 10 (#4ec320) +U 5 (#406bc1) +L 2 (#1b3890) +U 3 (#681181) +L 6 (#35ed60) +D 9 (#153fd3) +L 5 (#323e30) +U 5 (#381ad3) +L 3 (#69a550) +U 3 (#310f63) +L 4 (#2cbb80) +U 5 (#3448a3) +R 6 (#206282) +U 5 (#202ab1) +L 6 (#83af82) +U 4 (#202ab3) +L 4 (#248d02) +D 9 (#28a983) +L 4 (#32cf10) +D 7 (#249d73) +R 4 (#2f5c70) +D 6 (#021c93) +L 7 (#957782) +D 6 (#550e53) +R 5 (#957780) +D 6 (#50bb13) +R 9 (#49b7f2) +U 6 (#096e93) +R 4 (#769452) +D 3 (#6dc543) +R 5 (#2ad352) +D 7 (#167963) +L 10 (#673682) +D 5 (#152883) +L 10 (#13f332) +D 3 (#996721) +L 4 (#4be2a2) +D 4 (#9c2443) +L 4 (#2b83b0) +D 3 (#5d63b3) +L 9 (#9cfd40) +D 7 (#49e793) +L 7 (#0b5422) +D 8 (#5c51b3) +L 2 (#6db152) +D 4 (#215b53) +L 3 (#38dc12) +D 8 (#7dad01) +L 6 (#559e22) +D 3 (#929d23) +L 2 (#0f7560) +D 6 (#448d13) +L 7 (#73a972) +D 2 (#2221c3) +L 3 (#73a970) +D 5 (#53b553) +R 10 (#513590) +D 3 (#293c83) +L 10 (#58e2e0) +D 4 (#54dd21) +L 5 (#1bcdf2) +D 5 (#4b0b71) +L 5 (#1bcdf0) +U 6 (#43b811) +L 5 (#4df1d0) +U 6 (#36d6a3) +R 5 (#3bfb20) +U 5 (#75de61) +L 5 (#1e0ec2) +U 4 (#30b571) +L 7 (#2dfd20) +D 5 (#49ad61) +L 2 (#2dfd22) +D 11 (#715d41) +L 3 (#1e0ec0) +U 4 (#0f2091) +L 4 (#9d29c0) +U 9 (#475a73) +L 2 (#108610) +U 3 (#1e5423) +L 8 (#394192) +U 3 (#0274b3) diff --git a/day18/main.go b/day18/main.go new file mode 100644 index 0000000..063e3c5 --- /dev/null +++ b/day18/main.go @@ -0,0 +1,215 @@ +package main + +import ( + "bufio" + _ "embed" + "encoding/hex" + "fmt" + "strings" + + aoc "go.sour.is/advent-of-code" +) + +// var log = aoc.Log + +func main() { aoc.MustResult(aoc.Runner(run)) } + +type result struct { + valuePT1 int + valuePT2 int +} + +func (r result) String() string { return fmt.Sprintf("%#v", r) } + +func run(scan *bufio.Scanner) (*result, error) { + + var vecs []vec + + for scan.Scan() { + text := scan.Text() + + if len(text) == 0 { + continue + } + + var s string + v := vec{} + s, text, _ = strings.Cut(text, " ") + v.Direction = direction(s) + s, text, _ = strings.Cut(text, " ") + v.Steps = aoc.Atoi(s) + _, text, _ = strings.Cut(text, "#") + s, _, _ = strings.Cut(text, ")") + b, _ := hex.DecodeString(s) + copy(v.Color[:], b) + vecs = append(vecs, v) + } + + var points []point + + var x, y int + var minX, minY int + for i, v := range vecs { + fmt.Println("pt ", i, v) + + for i := 0; i < v.Steps; i++ { + switch v.Direction { + case "U": + y++ + case "D": + y-- + case "R": + x++ + case "L": + x-- + } + + minX = min(minX, x) + minY = min(minY, y) + points = append(points, point{d: v.Direction, x: x, y: y, color: v.Color}) + } + } + + adjX := aoc.ABS(min(0, minX)) + adjY := aoc.ABS(min(0, minY)) + fmt.Println("minX", minX, "minY", minY) + fmt.Println("adjX", adjX, "adjY", adjY) + + trace := make(map[int]map[int]point) + + minX, minY = 0, 0 + maxX, maxY := 0, 0 + + for i, p := range points { + // fmt.Println("raw", i, p) + p.x += adjX + p.y += adjY + + maxX = max(maxX, p.x) + maxY = max(maxY, p.y) + + points[i] = p + + if row, ok := trace[p.y]; true { + if !ok { + row = make(map[int]point) + } + row[p.x] = p + trace[p.y] = row + } + } + + area := 0 + + for y := 0; y <= maxY; y++ { + row, ok := trace[y] + if !ok { + continue + } + + var last direction + p, inLoop := row[0] + last = p.d + + for x := 0; x <= maxX; x++ { + if p, ok := row[x]; ok { + switch last+p.d { + case " U"," L", "UR": + inLoop = true + case "LD", " D", "RD": + inLoop = !inLoop + } + if last != p.d { + last = p.d + } + fmt.Print(p.d) + if inLoop { + area++ + } + continue + } + last = direction(" ") + + if inLoop { + area++ + fmt.Print(".") + } else { + fmt.Print(" ") + } + + } + fmt.Println("") + } + + // for y := 0; y < len(trace); y++ { + // rng := trace[y] + // sort.Ints(rng) + // for _, r := range ranges(rng) { + // area += r[1] - r[0] + 1 + // } + // } + + return &result{valuePT1: area}, nil +} + +type direction string + +const ( + U direction = "U" + D direction = "D" + L direction = "L" + R direction = "R" +) + +type vec struct { + Direction direction + Steps int + Color [3]byte +} + +type point struct { + w direction + d direction + x, y int + color [3]byte +} + +func ranges(rng []int) [][]int { + // inLoop := true + var mn int = rng[0] + var last int = rng[0] + var result [][]int + result = append(result, []int{mn, mn}) + + for _, i := range rng[1:] { + if i-last == 1 { + result[len(result)-1][1] = i + last = i + continue + } + + last = i + mn = i + result = append(result, []int{mn, last}) + } + + if len(result) == 1 { + return result + } + + if len(result) == 2 { + return [][]int{{result[0][0], result[1][1]}} + } + + if len(result)%2 == 0 { + var result2 [][]int + for i := 0; i < len(result); i += 2 { + result2 = append(result2, []int{result[i][0], result[i+1][1]}) + } + + return result2 + } + + fmt.Println("odd ranges", result) + return nil +} diff --git a/day18/main_test.go b/day18/main_test.go new file mode 100644 index 0000000..e709ab5 --- /dev/null +++ b/day18/main_test.go @@ -0,0 +1,42 @@ +package main + +import ( + "bufio" + "bytes" + "testing" + + _ "embed" + + "github.com/matryer/is" +) + +//go:embed example.txt +var example []byte + +//go:embed input.txt +var input []byte + +func TestExample(t *testing.T) { + is := is.New(t) + scan := bufio.NewScanner(bytes.NewReader(example)) + + result, err := run(scan) + is.NoErr(err) + + t.Log(result) + is.Equal(result.valuePT1, 62) + is.Equal(result.valuePT2, 0) +} + +func TestSolution(t *testing.T) { + is := is.New(t) + scan := bufio.NewScanner(bytes.NewReader(input)) + + result, err := run(scan) + is.NoErr(err) + + t.Log(result) + is.True(result.valuePT1 < 68834) // first attempt too high. + is.Equal(result.valuePT1, 0) + is.Equal(result.valuePT2, 0) +} -- 2.45.1 From b6501e80c94aaebc7e8ba0396cd7d6335c952e3a Mon Sep 17 00:00:00 2001 From: xuu Date: Wed, 27 Dec 2023 13:18:49 -0700 Subject: [PATCH 2/4] chore: add day 18 pt 2 --- day18/main.go | 169 +++++++++++++++++++++++++-------------------- day18/main_test.go | 7 +- 2 files changed, 99 insertions(+), 77 deletions(-) diff --git a/day18/main.go b/day18/main.go index 063e3c5..f736d8a 100644 --- a/day18/main.go +++ b/day18/main.go @@ -5,9 +5,12 @@ import ( _ "embed" "encoding/hex" "fmt" + "os" + "strconv" "strings" aoc "go.sour.is/advent-of-code" + "golang.org/x/exp/maps" ) // var log = aoc.Log @@ -24,6 +27,7 @@ func (r result) String() string { return fmt.Sprintf("%#v", r) } func run(scan *bufio.Scanner) (*result, error) { var vecs []vec + var vecs2 []vec for scan.Scan() { text := scan.Text() @@ -35,7 +39,7 @@ func run(scan *bufio.Scanner) (*result, error) { var s string v := vec{} s, text, _ = strings.Cut(text, " ") - v.Direction = direction(s) + v.Direction = direction(s[0]) s, text, _ = strings.Cut(text, " ") v.Steps = aoc.Atoi(s) _, text, _ = strings.Cut(text, "#") @@ -43,32 +47,47 @@ func run(scan *bufio.Scanner) (*result, error) { b, _ := hex.DecodeString(s) copy(v.Color[:], b) vecs = append(vecs, v) + vecs2 = append(vecs2, fromColor(s)) } + return &result{ + valuePT1: findArea(vecs), + valuePT2: skip("AOC_DAY18P2", func() int { return findArea(vecs2) }), + }, nil +} +func findArea(vecs []vec) int { var points []point var x, y int var minX, minY int - for i, v := range vecs { - fmt.Println("pt ", i, v) - + last := direction('S') + for _, v := range vecs { + // fmt.Println("pt ", i, v) for i := 0; i < v.Steps; i++ { switch v.Direction { - case "U": + case 'U': y++ - case "D": + case 'D': y-- - case "R": + case 'R': x++ - case "L": + case 'L': x-- } + // fmt.Println("pt ", i, y, x) minX = min(minX, x) minY = min(minY, y) - points = append(points, point{d: v.Direction, x: x, y: y, color: v.Color}) + if len(points) > 0 { + points[len(points)-1].d = v.Direction + } + points = append(points, point{d: v.Direction, w: opposite(v.Direction), x: x, y: y, color: v.Color}) + last = v.Direction } } + _ = last + // points[0].w = last + points[len(points)-1].d = points[0].w adjX := aoc.ABS(min(0, minX)) adjY := aoc.ABS(min(0, minY)) @@ -81,9 +100,10 @@ func run(scan *bufio.Scanner) (*result, error) { maxX, maxY := 0, 0 for i, p := range points { - // fmt.Println("raw", i, p) + p.x += adjX p.y += adjY + // fmt.Println("raw", i, p.x, p.y, string(p.w), string(p.d)) maxX = max(maxX, p.x) maxY = max(maxY, p.y) @@ -98,69 +118,78 @@ func run(scan *bufio.Scanner) (*result, error) { trace[p.y] = row } } + fmt.Println("maxX", maxX, "maxY", maxY) area := 0 - for y := 0; y <= maxY; y++ { + for y := maxY; y >= 0; y-- { row, ok := trace[y] if !ok { continue } var last direction - p, inLoop := row[0] + p := row[0] last = p.d + inLoop := false for x := 0; x <= maxX; x++ { if p, ok := row[x]; ok { - switch last+p.d { - case " U"," L", "UR": - inLoop = true - case "LD", " D", "RD": + // fmt.Println("vec", string(p.w), string(p.d)) + switch string([]rune{rune(p.w), rune(p.d)}) { + case "LD", "DL", "UD", "DU", "RD", "UU", "DR": inLoop = !inLoop } if last != p.d { last = p.d } - fmt.Print(p.d) - if inLoop { - area++ - } - continue + + // fmt.Print(string(p.w)+string(p.d)) + + // On loop + area++ + + continue // 203338 } - last = direction(" ") + last = direction('0') if inLoop { area++ - fmt.Print(".") - } else { - fmt.Print(" ") + // fmt.Print("XX") + // } else { + // fmt.Print("..") } } - fmt.Println("") + // fmt.Println("") + fmt.Println(y, area) } - - // for y := 0; y < len(trace); y++ { - // rng := trace[y] - // sort.Ints(rng) - // for _, r := range ranges(rng) { - // area += r[1] - r[0] + 1 - // } - // } - - return &result{valuePT1: area}, nil + return area } -type direction string +type direction rune const ( - U direction = "U" - D direction = "D" - L direction = "L" - R direction = "R" + U direction = 'U' + D direction = 'D' + L direction = 'L' + R direction = 'R' ) +func opposite(d direction) direction { + switch d { + case U: + return D + case D: + return U + case L: + return R + case R: + return L + } + return '0' +} + type vec struct { Direction direction Steps int @@ -174,42 +203,32 @@ type point struct { color [3]byte } -func ranges(rng []int) [][]int { - // inLoop := true - var mn int = rng[0] - var last int = rng[0] - var result [][]int - result = append(result, []int{mn, mn}) +func fromColor(c string) vec { + steps, _ := strconv.ParseInt(c[:5], 16, 64) - for _, i := range rng[1:] { - if i-last == 1 { - result[len(result)-1][1] = i - last = i - continue - } - - last = i - mn = i - result = append(result, []int{mn, last}) + d := '_' + switch c[5] { + case '0': + d = 'R' + case '1': + d = 'D' + case '2': + d = 'L' + case '3': + d = 'U' } - if len(result) == 1 { - return result + return vec{ + Direction: direction(d), + Steps: int(steps), } - - if len(result) == 2 { - return [][]int{{result[0][0], result[1][1]}} - } - - if len(result)%2 == 0 { - var result2 [][]int - for i := 0; i < len(result); i += 2 { - result2 = append(result2, []int{result[i][0], result[i+1][1]}) - } - - return result2 - } - - fmt.Println("odd ranges", result) - return nil +} + +func skip[T any](env string, fn func() T) T { + var zero T + if e, err := strconv.ParseBool(os.Getenv(env)); err == nil && e { + return zero + } + + return fn() } diff --git a/day18/main_test.go b/day18/main_test.go index e709ab5..15e4097 100644 --- a/day18/main_test.go +++ b/day18/main_test.go @@ -3,6 +3,7 @@ package main import ( "bufio" "bytes" + "os" "testing" _ "embed" @@ -25,18 +26,20 @@ func TestExample(t *testing.T) { t.Log(result) is.Equal(result.valuePT1, 62) - is.Equal(result.valuePT2, 0) + is.Equal(result.valuePT2, 952408144115) } func TestSolution(t *testing.T) { is := is.New(t) scan := bufio.NewScanner(bytes.NewReader(input)) + os.Setenv("AOC_DAY18P2", "1") + result, err := run(scan) is.NoErr(err) t.Log(result) is.True(result.valuePT1 < 68834) // first attempt too high. - is.Equal(result.valuePT1, 0) + is.Equal(result.valuePT1, 46334) is.Equal(result.valuePT2, 0) } -- 2.45.1 From bcd90a57f395f90a71b6ca469e528387cf85083d Mon Sep 17 00:00:00 2001 From: xuu Date: Wed, 27 Dec 2023 13:46:42 -0700 Subject: [PATCH 3/4] chore: use shoelace and picks theorem --- day18/main.go | 255 +++++++++++++-------------------------------- day18/main_test.go | 5 +- 2 files changed, 76 insertions(+), 184 deletions(-) diff --git a/day18/main.go b/day18/main.go index f736d8a..a3220e5 100644 --- a/day18/main.go +++ b/day18/main.go @@ -3,9 +3,7 @@ package main import ( "bufio" _ "embed" - "encoding/hex" "fmt" - "os" "strconv" "strings" @@ -26,8 +24,8 @@ func (r result) String() string { return fmt.Sprintf("%#v", r) } func run(scan *bufio.Scanner) (*result, error) { - var vecs []vec - var vecs2 []vec + var vecsPT1 []vector + var vecsPT2 []vector for scan.Scan() { text := scan.Text() @@ -36,199 +34,96 @@ func run(scan *bufio.Scanner) (*result, error) { continue } - var s string - v := vec{} - s, text, _ = strings.Cut(text, " ") - v.Direction = direction(s[0]) - s, text, _ = strings.Cut(text, " ") - v.Steps = aoc.Atoi(s) - _, text, _ = strings.Cut(text, "#") - s, _, _ = strings.Cut(text, ")") - b, _ := hex.DecodeString(s) - copy(v.Color[:], b) - vecs = append(vecs, v) - vecs2 = append(vecs2, fromColor(s)) + v, color := fromLine(text) + + vecsPT1 = append(vecsPT1, v) + vecsPT2 = append(vecsPT2, fromColor(color)) } return &result{ - valuePT1: findArea(vecs), - valuePT2: skip("AOC_DAY18P2", func() int { return findArea(vecs2) }), + valuePT1: findArea(vecsPT1), + valuePT2: findArea(vecsPT2), }, nil } -func findArea(vecs []vec) int { - var points []point - - var x, y int - var minX, minY int - last := direction('S') - for _, v := range vecs { - // fmt.Println("pt ", i, v) - for i := 0; i < v.Steps; i++ { - switch v.Direction { - case 'U': - y++ - case 'D': - y-- - case 'R': - x++ - case 'L': - x-- - } - // fmt.Println("pt ", i, y, x) - - minX = min(minX, x) - minY = min(minY, y) - if len(points) > 0 { - points[len(points)-1].d = v.Direction - } - points = append(points, point{d: v.Direction, w: opposite(v.Direction), x: x, y: y, color: v.Color}) - last = v.Direction - } - } - _ = last - // points[0].w = last - points[len(points)-1].d = points[0].w - - adjX := aoc.ABS(min(0, minX)) - adjY := aoc.ABS(min(0, minY)) - fmt.Println("minX", minX, "minY", minY) - fmt.Println("adjX", adjX, "adjY", adjY) - - trace := make(map[int]map[int]point) - - minX, minY = 0, 0 - maxX, maxY := 0, 0 - - for i, p := range points { - - p.x += adjX - p.y += adjY - // fmt.Println("raw", i, p.x, p.y, string(p.w), string(p.d)) - - maxX = max(maxX, p.x) - maxY = max(maxY, p.y) - - points[i] = p - - if row, ok := trace[p.y]; true { - if !ok { - row = make(map[int]point) - } - row[p.x] = p - trace[p.y] = row - } - } - fmt.Println("maxX", maxX, "maxY", maxY) - - area := 0 - - for y := maxY; y >= 0; y-- { - row, ok := trace[y] - if !ok { - continue - } - - var last direction - p := row[0] - last = p.d - inLoop := false - - for x := 0; x <= maxX; x++ { - if p, ok := row[x]; ok { - // fmt.Println("vec", string(p.w), string(p.d)) - switch string([]rune{rune(p.w), rune(p.d)}) { - case "LD", "DL", "UD", "DU", "RD", "UU", "DR": - inLoop = !inLoop - } - if last != p.d { - last = p.d - } - - // fmt.Print(string(p.w)+string(p.d)) - - // On loop - area++ - - continue // 203338 - } - last = direction('0') - - if inLoop { - area++ - // fmt.Print("XX") - // } else { - // fmt.Print("..") - } - - } - // fmt.Println("") - fmt.Println(y, area) - } - return area +type vector struct { + offset point + scale int } -type direction rune +type point [2]int -const ( - U direction = 'U' - D direction = 'D' - L direction = 'L' - R direction = 'R' -) +func (p point) add(a point) point { + return point{p[0] + a[0], p[1] + a[1]} +} +func (p point) scale(m int) point { + return point{p[0] * m, p[1] * m} +} -func opposite(d direction) direction { - switch d { - case U: - return D - case D: - return U - case L: - return R - case R: - return L +// numPoints the number of the points inside an outline plus the number of points in the outline +func numPoints(outline []point, borderLength int) int { + // shoelace - find the float area in a shape + sum := 0 + for _, p := range pairwise(outline) { + row1, col1 := p[0][0], p[0][1] + row2, col2 := p[1][0], p[1][1] + + sum += row1*col2 - row2*col1 } - return '0' + area := sum / 2 + + // pick's theorem - find the number of points in a shape given its area + return (aoc.ABS(area) - borderLength/2 + 1) + borderLength } -type vec struct { - Direction direction - Steps int - Color [3]byte -} - -type point struct { - w direction - d direction - x, y int - color [3]byte -} - -func fromColor(c string) vec { - steps, _ := strconv.ParseInt(c[:5], 16, 64) - - d := '_' - switch c[5] { - case '0': - d = 'R' - case '1': - d = 'D' - case '2': - d = 'L' - case '3': - d = 'U' +func pairwise[T any](arr []T) [][2]T { + var pairs [][2]T + for i := range arr[:len(arr)-1] { + pairs = append(pairs, [2]T{arr[i], arr[i+1]}) } + return pairs +} - return vec{ - Direction: direction(d), - Steps: int(steps), +var OFFSET = map[string]point{ + "R": {0, 1}, + "D": {1, 0}, + "L": {0, -1}, + "U": {-1, 0}, +} +var OFFSET_INDEXES = maps.Values(OFFSET) + +func fromLine(text string) (vector, string) { + v := vector{} + s, text, _ := strings.Cut(text, " ") + v.offset = OFFSET[s] + + s, text, _ = strings.Cut(text, " ") + v.scale = aoc.Atoi(s) + + _, text, _ = strings.Cut(text, "(#") + s, _, _ = strings.Cut(text, ")") + return v, s +} + +func fromColor(c string) vector { + scale, _ := strconv.ParseInt(c[:5], 16, 64) + offset := OFFSET_INDEXES[c[5]-'0'] + + return vector{ + offset: offset, + scale: int(scale), } } -func skip[T any](env string, fn func() T) T { - var zero T - if e, err := strconv.ParseBool(os.Getenv(env)); err == nil && e { - return zero +func findArea(vecs []vector) int { + shoelace := []point{{0,0}} + borderLength := 0 + + for _, vec := range vecs { + scaled_offset := vec.offset.scale(vec.scale) + shoelace = append(shoelace, shoelace[len(shoelace)-1].add(scaled_offset)) + borderLength += vec.scale } - return fn() + return numPoints(shoelace, borderLength) } + diff --git a/day18/main_test.go b/day18/main_test.go index 15e4097..a7c83af 100644 --- a/day18/main_test.go +++ b/day18/main_test.go @@ -3,7 +3,6 @@ package main import ( "bufio" "bytes" - "os" "testing" _ "embed" @@ -33,13 +32,11 @@ func TestSolution(t *testing.T) { is := is.New(t) scan := bufio.NewScanner(bytes.NewReader(input)) - os.Setenv("AOC_DAY18P2", "1") - result, err := run(scan) is.NoErr(err) t.Log(result) is.True(result.valuePT1 < 68834) // first attempt too high. is.Equal(result.valuePT1, 46334) - is.Equal(result.valuePT2, 0) + is.Equal(result.valuePT2, 102000662718092) } -- 2.45.1 From 2057a30420714172c7dafe7a4e23f0140c4f9502 Mon Sep 17 00:00:00 2001 From: xuu Date: Wed, 27 Dec 2023 14:01:04 -0700 Subject: [PATCH 4/4] chore: cleanup base tools --- tools_test.go => aoc_test.go | 0 day18/main.go | 71 ++------- grids.go | 51 ++++++ itertools.go | 57 +++++++ lists.go | 101 ++++++++++++ math.go | 90 +++++++++++ runner.go | 47 ++++++ tools.go | 290 ----------------------------------- 8 files changed, 362 insertions(+), 345 deletions(-) rename tools_test.go => aoc_test.go (100%) create mode 100644 grids.go create mode 100644 itertools.go create mode 100644 lists.go create mode 100644 math.go create mode 100644 runner.go delete mode 100644 tools.go diff --git a/tools_test.go b/aoc_test.go similarity index 100% rename from tools_test.go rename to aoc_test.go diff --git a/day18/main.go b/day18/main.go index a3220e5..91d1a05 100644 --- a/day18/main.go +++ b/day18/main.go @@ -24,8 +24,8 @@ func (r result) String() string { return fmt.Sprintf("%#v", r) } func run(scan *bufio.Scanner) (*result, error) { - var vecsPT1 []vector - var vecsPT2 []vector + var vecsPT1 []aoc.Vector + var vecsPT2 []aoc.Vector for scan.Scan() { text := scan.Text() @@ -45,45 +45,7 @@ func run(scan *bufio.Scanner) (*result, error) { }, nil } -type vector struct { - offset point - scale int -} - -type point [2]int - -func (p point) add(a point) point { - return point{p[0] + a[0], p[1] + a[1]} -} -func (p point) scale(m int) point { - return point{p[0] * m, p[1] * m} -} - -// numPoints the number of the points inside an outline plus the number of points in the outline -func numPoints(outline []point, borderLength int) int { - // shoelace - find the float area in a shape - sum := 0 - for _, p := range pairwise(outline) { - row1, col1 := p[0][0], p[0][1] - row2, col2 := p[1][0], p[1][1] - - sum += row1*col2 - row2*col1 - } - area := sum / 2 - - // pick's theorem - find the number of points in a shape given its area - return (aoc.ABS(area) - borderLength/2 + 1) + borderLength -} - -func pairwise[T any](arr []T) [][2]T { - var pairs [][2]T - for i := range arr[:len(arr)-1] { - pairs = append(pairs, [2]T{arr[i], arr[i+1]}) - } - return pairs -} - -var OFFSET = map[string]point{ +var OFFSET = map[string]aoc.Point{ "R": {0, 1}, "D": {1, 0}, "L": {0, -1}, @@ -91,39 +53,38 @@ var OFFSET = map[string]point{ } var OFFSET_INDEXES = maps.Values(OFFSET) -func fromLine(text string) (vector, string) { - v := vector{} +func fromLine(text string) (aoc.Vector, string) { + v := aoc.Vector{} s, text, _ := strings.Cut(text, " ") - v.offset = OFFSET[s] + v.Offset = OFFSET[s] s, text, _ = strings.Cut(text, " ") - v.scale = aoc.Atoi(s) + v.Scale = aoc.Atoi(s) _, text, _ = strings.Cut(text, "(#") s, _, _ = strings.Cut(text, ")") return v, s } -func fromColor(c string) vector { +func fromColor(c string) aoc.Vector { scale, _ := strconv.ParseInt(c[:5], 16, 64) offset := OFFSET_INDEXES[c[5]-'0'] - return vector{ - offset: offset, - scale: int(scale), + return aoc.Vector{ + Offset: offset, + Scale: int(scale), } } -func findArea(vecs []vector) int { - shoelace := []point{{0,0}} +func findArea(vecs []aoc.Vector) int { + shoelace := []aoc.Point{{0,0}} borderLength := 0 for _, vec := range vecs { - scaled_offset := vec.offset.scale(vec.scale) - shoelace = append(shoelace, shoelace[len(shoelace)-1].add(scaled_offset)) - borderLength += vec.scale + shoelace = append(shoelace, shoelace[len(shoelace)-1].Add(vec.Point())) + borderLength += vec.Scale } - return numPoints(shoelace, borderLength) + return aoc.NumPoints(shoelace, borderLength) } diff --git a/grids.go b/grids.go new file mode 100644 index 0000000..43810be --- /dev/null +++ b/grids.go @@ -0,0 +1,51 @@ +package aoc + +type Vector struct { + Offset Point + Scale int +} + +func (v Vector) Point() Point { + return v.Offset.Scale(v.Scale) +} + +type Point [2]int + +func (p Point) Add(a Point) Point { + return Point{p[0] + a[0], p[1] + a[1]} +} +func (p Point) Scale(m int) Point { + return Point{p[0] * m, p[1] * m} +} + +func Transpose[T any](matrix [][]T) [][]T { + rows, cols := len(matrix), len(matrix[0]) + + m := make([][]T, cols) + for i := range m { + m[i] = make([]T, rows) + } + + for i := 0; i < cols; i++ { + for j := 0; j < rows; j++ { + m[i][j] = matrix[j][i] + } + } + return m +} + +// NumPoints the number of the points inside an outline plus the number of points in the outline +func NumPoints(outline []Point, borderLength int) int { + // shoelace - find the float area in a shape + sum := 0 + for _, p := range Pairwise(outline) { + row1, col1 := p[0][0], p[0][1] + row2, col2 := p[1][0], p[1][1] + + sum += row1*col2 - row2*col1 + } + area := sum / 2 + + // pick's theorem - find the number of points in a shape given its area + return (ABS(area) - borderLength/2 + 1) + borderLength +} diff --git a/itertools.go b/itertools.go new file mode 100644 index 0000000..c6925d5 --- /dev/null +++ b/itertools.go @@ -0,0 +1,57 @@ +package aoc + +import ( + "strconv" +) + +func Atoi(s string) int { + i, _ := strconv.Atoi(s) + return i +} + +func Repeat[T any](s T, i int) []T { + lis := make([]T, i) + for i := range lis { + lis[i] = s + } + return lis +} + +func Reduce[T, U any](fn func(int, T, U) U, u U, list ...T) U { + for i, t := range list { + u = fn(i, t, u) + } + return u +} + +func Reverse[T any](arr []T) []T { + for i := 0; i < len(arr)/2; i++ { + arr[i], arr[len(arr)-i-1] = arr[len(arr)-i-1], arr[i] + } + return arr +} + + +func SliceMap[T, U any](fn func(T) U, in ...T) []U { + lis := make([]U, len(in)) + for i := range lis { + lis[i] = fn(in[i]) + } + return lis +} +func SliceIMap[T, U any](fn func(int, T) U, in ...T) []U { + lis := make([]U, len(in)) + for i := range lis { + lis[i] = fn(i, in[i]) + } + return lis +} + +// Pairwise iterates over a list pairing i, i+1 +func Pairwise[T any](arr []T) [][2]T { + var pairs [][2]T + for i := range arr[:len(arr)-1] { + pairs = append(pairs, [2]T{arr[i], arr[i+1]}) + } + return pairs +} \ No newline at end of file diff --git a/lists.go b/lists.go new file mode 100644 index 0000000..fc611ef --- /dev/null +++ b/lists.go @@ -0,0 +1,101 @@ +package aoc + +import "fmt" + + +type Node[T any] struct { + value T + pos int + left *Node[T] +} + +func (n *Node[T]) add(a *Node[T]) *Node[T] { + if a == nil { + return n + } + + if n == nil { + return a + } + + n.left = a + return a +} + +func (n *Node[T]) Value() (value T, ok bool) { + if n == nil { + return + } + return n.value, true +} + +func (n *Node[T]) Position() int { + if n == nil { + return -1 + } + return n.pos +} +func (n *Node[T]) SetPosition(i int) { + if n == nil { + return + } + n.pos = i +} +func (n *Node[T]) Next() *Node[T] { + if n == nil { + return nil + } + return n.left +} + +func (n *Node[T]) String() string { + if n == nil { + return "EOL" + } + return fmt.Sprintf("node %v", n.value) +} + +type List[T any] struct { + head *Node[T] + n *Node[T] + p map[int]*Node[T] +} + +func NewList[T any](a *Node[T]) *List[T] { + lis := &List[T]{ + head: a, + n: a, + p: make(map[int]*Node[T]), + } + lis.add(a) + + return lis +} +func (l *List[T]) Add(value T, pos int) { + a := &Node[T]{value: value, pos: pos} + l.add(a) +} +func (l *List[T]) add(a *Node[T]) { + if l.head == nil { + l.head = a + } + if a == nil { + return + } + + l.n = l.n.add(a) + l.p[a.pos] = a +} +func (l *List[T]) Get(pos int) *Node[T] { + return l.p[pos] +} +func (l *List[T]) GetN(pos ...int) []*Node[T] { + lis := make([]*Node[T], len(pos)) + for i, p := range pos { + lis[i] = l.p[p] + } + return lis +} +func (l *List[T]) Head() *Node[T] { + return l.head +} diff --git a/math.go b/math.go new file mode 100644 index 0000000..468b1d6 --- /dev/null +++ b/math.go @@ -0,0 +1,90 @@ +package aoc + +import "cmp" + +type integer interface { + int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64 +} + +// type float interface { +// complex64 | complex128 | float32 | float64 +// } +// type number interface{ integer | float } + +// greatest common divisor (GCD) via Euclidean algorithm +func GCD[T integer](a, b T) T { + for b != 0 { + t := b + b = a % b + a = t + } + return a +} + +// find Least Common Multiple (LCM) via GCD +func LCM[T integer](integers ...T) T { + if len(integers) == 0 { + return 0 + } + if len(integers) == 1 { + return integers[0] + } + + a, b := integers[0], integers[1] + result := a * b / GCD(a, b) + + for _, c := range integers[2:] { + result = LCM(result, c) + } + + return result +} + +func Sum[T integer](arr ...T) T { + var acc T + for _, a := range arr { + acc += a + } + return acc +} +func SumFunc[T any, U integer](fn func(T) U, input ...T) U { + return Sum(SliceMap(fn, input...)...) +} +func SumIFunc[T any, U integer](fn func(int, T) U, input ...T) U { + return Sum(SliceIMap(fn, input...)...) +} + +func Power2(n int) int { + if n == 0 { + return 1 + } + p := 2 + for ; n > 1; n-- { + p *= 2 + } + return p +} + +func ABS(i int) int { + if i < 0 { + return -i + } + return i +} + +func Max[T cmp.Ordered](a T, v ...T) T { + for _, b := range v { + if b > a { + a = b + } + } + return a +} +func Min[T cmp.Ordered](a T, v ...T) T { + for _, b := range v { + if b < a { + a = b + } + } + return a +} diff --git a/runner.go b/runner.go new file mode 100644 index 0000000..c69849b --- /dev/null +++ b/runner.go @@ -0,0 +1,47 @@ +package aoc + +import ( + "bufio" + "fmt" + "os" + "path/filepath" + "strings" +) + +func Runner[R any, F func(*bufio.Scanner) (R, error)](run F) (R, error) { + if len(os.Args) != 2 { + Log("Usage:", filepath.Base(os.Args[0]), "FILE") + os.Exit(22) + } + + input, err := os.Open(os.Args[1]) + if err != nil { + Log(err) + os.Exit(1) + } + + scan := bufio.NewScanner(input) + return run(scan) +} + +func MustResult[T any](result T, err error) { + if err != nil { + fmt.Println("ERR", err) + os.Exit(1) + } + + Log("result", result) +} + +func Log(v ...any) { fmt.Fprintln(os.Stderr, v...) } +func Logf(format string, v ...any) { + if !strings.HasSuffix(format, "\n") { + format += "\n" + } + fmt.Fprintf(os.Stderr, format, v...) +} + + +func ReadStringToInts(fields []string) []int { + return SliceMap(Atoi, fields...) +} diff --git a/tools.go b/tools.go deleted file mode 100644 index 969aafa..0000000 --- a/tools.go +++ /dev/null @@ -1,290 +0,0 @@ -package aoc - -import ( - "bufio" - "cmp" - "fmt" - "os" - "path/filepath" - "strconv" - "strings" -) - -func Runner[R any, F func(*bufio.Scanner) (R, error)](run F) (R, error) { - if len(os.Args) != 2 { - Log("Usage:", filepath.Base(os.Args[0]), "FILE") - os.Exit(22) - } - - input, err := os.Open(os.Args[1]) - if err != nil { - Log(err) - os.Exit(1) - } - - scan := bufio.NewScanner(input) - return run(scan) -} - -func MustResult[T any](result T, err error) { - if err != nil { - fmt.Println("ERR", err) - os.Exit(1) - } - - Log("result", result) -} - -func Log(v ...any) { fmt.Fprintln(os.Stderr, v...) } -func Logf(format string, v ...any) { - if !strings.HasSuffix(format, "\n") { - format += "\n" - } - fmt.Fprintf(os.Stderr, format, v...) -} - -func Reverse[T any](arr []T) []T { - for i := 0; i < len(arr)/2; i++ { - arr[i], arr[len(arr)-i-1] = arr[len(arr)-i-1], arr[i] - } - return arr -} - -type integer interface { - int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64 -} - -// type float interface { -// complex64 | complex128 | float32 | float64 -// } -// type number interface{ integer | float } - -// greatest common divisor (GCD) via Euclidean algorithm -func GCD[T integer](a, b T) T { - for b != 0 { - t := b - b = a % b - a = t - } - return a -} - -// find Least Common Multiple (LCM) via GCD -func LCM[T integer](integers ...T) T { - if len(integers) == 0 { - return 0 - } - if len(integers) == 1 { - return integers[0] - } - - a, b := integers[0], integers[1] - result := a * b / GCD(a, b) - - for _, c := range integers[2:] { - result = LCM(result, c) - } - - return result -} - -func ReadStringToInts(fields []string) []int { - return SliceMap(Atoi, fields...) -} - -type Node[T any] struct { - value T - pos int - left *Node[T] -} - -func (n *Node[T]) add(a *Node[T]) *Node[T] { - if a == nil { - return n - } - - if n == nil { - return a - } - - n.left = a - return a -} - -func (n *Node[T]) Value() (value T, ok bool) { - if n == nil { - return - } - return n.value, true -} - -func (n *Node[T]) Position() int { - if n == nil { - return -1 - } - return n.pos -} -func (n *Node[T]) SetPosition(i int) { - if n == nil { - return - } - n.pos = i -} -func (n *Node[T]) Next() *Node[T] { - if n == nil { - return nil - } - return n.left -} - -func (n *Node[T]) String() string { - if n == nil { - return "EOL" - } - return fmt.Sprintf("node %v", n.value) -} - -type List[T any] struct { - head *Node[T] - n *Node[T] - p map[int]*Node[T] -} - -func NewList[T any](a *Node[T]) *List[T] { - lis := &List[T]{ - head: a, - n: a, - p: make(map[int]*Node[T]), - } - lis.add(a) - - return lis -} -func (l *List[T]) Add(value T, pos int) { - a := &Node[T]{value: value, pos: pos} - l.add(a) -} -func (l *List[T]) add(a *Node[T]) { - if l.head == nil { - l.head = a - } - if a == nil { - return - } - - l.n = l.n.add(a) - l.p[a.pos] = a -} -func (l *List[T]) Get(pos int) *Node[T] { - return l.p[pos] -} -func (l *List[T]) GetN(pos ...int) []*Node[T] { - lis := make([]*Node[T], len(pos)) - for i, p := range pos { - lis[i] = l.p[p] - } - return lis -} -func (l *List[T]) Head() *Node[T] { - return l.head -} - -func SliceMap[T, U any](fn func(T) U, in ...T) []U { - lis := make([]U, len(in)) - for i := range lis { - lis[i] = fn(in[i]) - } - return lis -} -func SliceIMap[T, U any](fn func(int, T) U, in ...T) []U { - lis := make([]U, len(in)) - for i := range lis { - lis[i] = fn(i, in[i]) - } - return lis -} - -func Atoi(s string) int { - i, _ := strconv.Atoi(s) - return i -} - -func Repeat[T any](s T, i int) []T { - lis := make([]T, i) - for i := range lis { - lis[i] = s - } - return lis -} - -func Sum[T integer](arr ...T) T { - var acc T - for _, a := range arr { - acc += a - } - return acc -} -func SumFunc[T any, U integer](fn func(T) U, input ...T) U { - return Sum(SliceMap(fn, input...)...) -} -func SumIFunc[T any, U integer](fn func(int, T) U, input ...T) U { - return Sum(SliceIMap(fn, input...)...) -} - -func Power2(n int) int { - if n == 0 { - return 1 - } - p := 2 - for ; n > 1; n-- { - p *= 2 - } - return p -} - -func ABS(i int) int { - if i < 0 { - return -i - } - return i -} - -func Transpose[T any](matrix [][]T) [][]T { - rows, cols := len(matrix), len(matrix[0]) - - m := make([][]T, cols) - for i := range m { - m[i] = make([]T, rows) - } - - for i := 0; i < cols; i++ { - for j := 0; j < rows; j++ { - m[i][j] = matrix[j][i] - } - } - return m -} - -func Reduce[T, U any](fn func(int, T, U) U, u U, list ...T) U { - for i, t := range list { - u = fn(i, t, u) - } - return u -} - -func Max[T cmp.Ordered](a T, v ...T) T { - for _, b := range v { - if b > a { - a = b - } - } - return a -} -func Min[T cmp.Ordered](a T, v ...T) T { - for _, b := range v { - if b < a { - a = b - } - } - return a -} -- 2.45.1