diff --git a/day18/build.zig b/day18/build.zig new file mode 100644 index 0000000..b4d3d4f --- /dev/null +++ b/day18/build.zig @@ -0,0 +1,27 @@ +const Builder = @import("std").build.Builder; + +pub fn build(b: *Builder) void { + // Standard target options allows the person running `zig build` to choose + // what target to build for. Here we do not override the defaults, which + // means any target is allowed, and the default is native. Other options + // for restricting supported target set are available. + const target = b.standardTargetOptions(.{}); + + // Standard release options allow the person running `zig build` to select + // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. + const mode = b.standardReleaseOptions(); + + const exe = b.addExecutable("day18", "src/main.zig"); + exe.setTarget(target); + exe.setBuildMode(mode); + exe.install(); + + const run_cmd = exe.run(); + run_cmd.step.dependOn(b.getInstallStep()); + if (b.args) |args| { + run_cmd.addArgs(args); + } + + const run_step = b.step("run", "Run the app"); + run_step.dependOn(&run_cmd.step); +} diff --git a/day18/input b/day18/input new file mode 100644 index 0000000..da39d13 --- /dev/null +++ b/day18/input @@ -0,0 +1,381 @@ +(7 * (7 * 6 * 4 + 3)) * 3 + ((8 + 5 * 3 + 7 + 8) + 3 * (2 + 9 * 5 + 7 * 5 * 6) * 2 + 3 * 9) + (4 + 5 + 5 * 2 + 2) + ((5 + 6 + 9 + 6) + 3 + 4 * 6 * 5) +7 * 5 +(9 * (9 + 7) * 7 + (4 + 5 * 5 + 2 + 3) + 3) * 7 * 5 + 8 + (4 + (7 + 9 + 6 * 9) * 2) +((6 + 4) * 6 * (5 + 3) * 9 * (3 * 5 * 5 * 9 * 4 + 9) * 4) * 2 * 8 + 9 +7 * 7 + (9 + 2 * 9 + 9) +9 + (7 * 7 * 5 * 9 * 7) * 2 + 3 * 3 +5 * (5 * (8 * 4) * 7 + 8 + 7) * (5 * (4 * 3 * 5 + 2 * 5) + (6 * 6 * 7 * 2 + 2) + 4) + (5 + 4 * 7 + 5 * 9 + 9) * 2 +((7 + 3 + 8) + (2 + 6 * 4 * 5)) + 8 +8 * (6 * 7 + 3 * (8 * 5 * 2 * 4)) * (3 + (5 + 5 + 6) * (4 * 3 + 7 * 5 + 7) + (3 * 5 * 9 * 3)) + 8 +6 + 4 + 8 + 4 * ((3 + 5 * 8) + 7 * 7 * 8 * 7 * 2) +3 * (9 + 4) * (9 + 2 + 6 + 5) + 4 * (7 * 2) + 6 +4 * 6 + (8 + 3) + 7 +2 + (8 * (5 + 6 * 5) + 9 * 7 + (7 * 7)) + 5 + 5 +(8 + (5 * 7 * 3 + 6) + 8) * 8 + 6 +8 * 6 * 6 +8 * 6 + (9 + 4 * 5 * 3) * 9 * (4 * 2 + 6 + 7 + 4 * 8) +(5 * 9 * 8 * 9 * 6) * 8 +7 * 5 + ((2 * 7 * 5 + 2 + 6 + 3) * 9) * 5 + ((2 * 2 * 4 + 3) * 5) +(2 + 3 * 4 * (2 + 4 * 9 + 8) * 8) + 6 + 8 + 7 * 2 +3 + 7 + (3 * 4 * (8 * 6 + 8 * 8 * 2 + 9)) * 4 +9 * 9 + 9 + (3 * 7 * 9 * 4) +(7 * 7 + (2 * 5 * 8) * 4) * 9 + (9 + 4 * 8 * (9 + 3 * 5 * 4 * 7 * 4)) + 3 * 3 +7 + 6 + 3 * 8 * 4 * (9 * 4 * (5 + 7 * 2 * 8 + 7 * 8)) +(7 + 2) * 5 * 8 + 6 * 2 +9 + 4 + (5 + (7 * 7 * 9 + 5) + 6 * 5 + 2 * (4 * 7 * 7 + 8 * 5 * 5)) * 2 + 2 +8 + 2 * 2 * (2 + (2 + 7 + 7 * 7 * 3) + 7) +3 + 4 * (3 + 3 * 3 + 4) * 9 * 6 + 8 +((4 + 4 + 6) + (5 * 5 + 4 * 9 * 5) + 5) + 2 * 2 +9 * 5 * 6 * 2 + 6 + (2 * 9 + (2 * 3 + 4)) +(3 * 9) + 2 * (2 * 5 + 7 + 9 * 7 * 6) + 5 * 5 * 2 +7 + 3 + 5 * 6 +7 + 5 + (2 * 8 + (6 * 6) + 6) + (4 + 7) +2 * (9 + 5 * 3 + 5 + 5 + 4) * (3 + 4 + 3 + 5 + 2 + 7) + 2 * 2 +(4 * 5 + 6 * 3 + (5 * 3)) * 5 + 5 +9 + 8 + 7 * (7 + 9 + 2 * 2 + 7) * 7 +3 * 3 * ((4 + 3 * 4 * 2 * 2 * 6) * (9 + 6) * 3) * 5 +9 + 6 + 7 + 6 +8 * (4 * 8 * 8 * 7 + 4 + 9) +2 + (7 * 9 * 2) + 6 * 6 * 4 * 6 +((4 * 6 + 7 + 9 * 4) + 9) * 4 * ((6 * 3 + 3 + 9 * 7) * 8 * 4 * 5 * (2 * 6 * 8 * 5 + 5 * 3)) * 7 +(4 * 7) + 5 +6 + 9 * 6 + 9 + ((5 + 7 * 5 * 8) + 7 + 7 + 8 * (2 + 8 * 2 * 4 * 7 + 9) * 7) +6 + 3 + (9 + 6 * (4 + 7 + 4 * 6 * 7)) + 6 +5 * 7 * (4 * 6 * (3 + 8 + 6 * 8)) + 8 +(5 * 6) * 8 + 2 * 3 + (7 + 4 + 3) +3 + 4 * 9 * 2 + (7 + (5 * 9 * 7 + 7 * 4) * 4) + 3 +2 * 9 + ((3 + 5 + 2 + 9 * 9 + 6) + 4 + (6 * 4) + 2) + 3 +3 + 6 + (3 + 6 + 8 + 2 + 2) +8 * ((8 * 6) + (7 + 2 * 2 * 2 + 4 * 3) * (9 + 8 + 4 * 8) + 8 * 4) + 2 +9 + 4 * (7 * (2 * 4 + 9 * 3 + 7) * 8 + (4 * 3 * 9 + 9 * 5 + 7) + 9 * (6 * 4 * 2)) + ((5 + 6 + 7 * 9 * 6 + 6) + (6 * 2 + 8 + 9 + 4 + 4) + (8 * 5 * 2 + 6 + 7) * 5 + 3) * 9 * 8 +9 + 2 + (5 + 3 * 2 * (7 + 4 * 5 * 5 + 3 * 7) * 8 * (5 * 6)) +7 * (3 + 3 + 7 * 7 * 9) + (2 + 5 * 6 * 4) +9 + 8 + 9 +8 * (7 + (5 * 7) + (7 + 3) * 2 + 7) + 4 * 3 +2 * (2 * 6 + 5 * 7) * 2 + (3 + 3) * ((2 * 3 + 2) + (5 * 3 * 4 + 8 * 2)) +4 * (3 + 7 + 6 + 8 + 3 + 6) + 8 + (2 * 3 * (5 * 2 + 6 + 5 * 8)) +2 + 5 + 3 + 2 + 4 + (2 + (6 + 4) + 5) +2 * (4 * 4) + (5 + 2 * (4 + 2 * 2 + 4) * 4 + (5 * 9 * 9) + 2) +(6 + 9 + (3 + 5 * 3) + 4 * 2 * 2) + 7 + ((6 * 6 + 4 * 5 * 5 + 4) + 5) + ((8 + 4 + 9 * 8 * 9 + 2) + (7 + 2 + 9) + 4) + 5 +7 * 3 + (6 + (8 * 5) * 6 * 8) * 2 * 9 * 4 +9 + 9 + 9 + 2 +(7 * 9 * 2 + 8 * 7 * 4) + 9 + (9 * 6 * 9 + 7) * 3 * (9 * 5 * 5) +4 * 7 * ((7 + 9 * 5 * 4 + 7 * 4) + (2 + 3 + 5 * 4 + 2) + (2 + 5 * 8 * 5 * 5 + 6)) * 6 +5 + 8 * (9 + (9 + 3 + 9 + 5 + 5)) +(3 * 7 * 2 * 3 + (8 + 8 + 3 * 9)) + 8 + 8 * 6 + 8 + 6 +9 + 4 + 8 * (7 * 8 + 8 + 4 * 8) +2 * 9 + 2 * (5 + 3) * 2 * (5 * 5 * 8 + (3 + 4 + 4 + 5) + 4 * 4) +5 * 7 + 2 * ((2 * 8 * 8 + 8 * 2 * 7) * 6 * 7 + 7 + 2) * 2 + 9 +4 * (6 * (6 * 3 * 3)) * (7 * 5 * 4 * 2 * (5 + 5 + 8 * 3)) + 7 + 7 * 8 +3 * 2 + 4 +9 + 6 * 2 * 4 + 2 +((5 * 5 + 3 + 7 * 2) * 2 * 5 + (9 + 9)) + 3 + 6 * (9 + 8) * 8 * 9 +4 * (8 + 2 + 3 * 9 * 6) * 6 * 3 +2 * (9 * 6 + (8 + 6 * 4) * (5 * 5) + 9 * 2) +6 + (3 * (6 * 6 + 4 + 5) + 3 * 5 * 4 + (6 + 9 + 4 * 5 * 3)) + 6 * (3 + (6 + 5 + 5 + 6) * 8 + 8 * 4) * 4 + 6 +9 * 9 * 2 + (6 * 4 * 2 + 4 * 7 * 9) * 7 + ((5 + 6 + 7 + 7) * (7 * 3 + 9) + 9) +(2 + (6 + 8 + 6 * 5 + 5) + 8 * 5) * 9 + 3 +2 * 9 + 2 + (9 * (4 + 6 + 4 + 2) * 9 * 5 + 7 + 2) +8 + 6 + 4 + 6 +3 + ((6 * 4 + 2 + 4 + 3 + 8) * (4 * 3) * (9 + 4 * 6 + 2 * 7 * 6)) + 5 + 7 +3 * (8 * 4 + 9 + 4) * 7 * 2 + ((5 + 9 * 6 * 4 * 4) * 8 * 4 * (6 + 2)) +((8 * 7 + 6) * 3 + 2 + 5) + 8 * 5 * 8 +(3 * 2 * 6 * 3 * 2) * 6 * 2 * 9 +(4 * 8 * 3 + 5) + (8 + 9) + 7 * 7 + 3 * 3 +(2 + 7 * (7 * 8)) + 8 + (6 * (4 * 8) * 4 * 2 * 8) * 4 * ((7 + 8 + 4 + 3 + 6) * 4 + 9 + 4) + 3 +((7 + 2 + 3 * 3) * 5 * 5 + 4) + 9 * 2 + 7 + 9 + 2 +(6 + (2 + 7)) * 4 + 7 + 8 * 5 +(9 * 8) + (8 + (2 + 4 + 5 + 6 * 9) + 2 * (8 + 9)) +2 * (9 + 8) * 8 * ((7 * 6 + 7 * 3) + 2 + 5 * (7 * 2 + 7 + 8) + 3 * 3) + 8 +4 * 6 + 6 + 4 * 9 +(2 + 4 + 5 + 3 + 6) + 3 * 3 * 3 + (5 * 2 * 9 + 6 * 6 + 5) +7 * 5 + (6 + 2 * 2 * 8 + 5) * 6 + 6 +(5 + 8 + 2) + 3 +3 + 3 * 5 * ((3 + 8 + 5 + 9) * 4 + 4 * 4 + 4) + 8 * 3 +2 + (5 + 5 + (6 * 5 * 2 * 8) * 4 + 8) +8 + (5 * 7 * 2 * 2) * (7 + 9 * 5) * 2 + 9 + 4 +((9 * 9) + 6 + 4 + 9) * 5 +5 + 3 * ((4 + 8) + 9 * 2 * 6 + 7) +6 + 7 + 5 * (2 + 9 * 4 * 5 * 7 + 5) + 9 * 4 +(7 * 2 + 4 + (8 * 8 + 2 * 5 * 3 * 6)) + (4 + 4 * 3 + 7) + 4 * 6 +2 * (5 * 9 * (5 + 3 * 5) * 5 + 6) + 4 + 5 +5 * (4 + 7 + 4) +9 * 7 + 8 + 4 + (6 * (6 * 2 * 4 + 9)) + 5 +6 * 3 +(5 * 6 + 2 * (2 + 5 * 6 * 4 + 9 + 2)) + (4 + 3 * (9 * 9 + 4 * 8 * 8 * 9) * 4) * (8 + 7 + (4 + 8 * 2 + 4) * 9) +8 * 5 + 9 +7 + 4 * 9 * 6 + 6 +9 + 6 * (8 * (7 * 6 + 2 + 4 + 6 + 9) * 2 + 2 + 2 + (7 + 7 + 9)) +6 * (7 * 6 * 6) * 9 * 6 + 7 +(5 * 7 + 9) * 7 + ((4 * 5 + 3) * 5 * (3 + 8 * 7) + 2 + 3 * (7 + 6 + 2)) + (3 * 5 * 5) + 2 +4 * 2 * 2 * 2 * (6 + 4 + 9 + 4 * 5) +((9 * 7 + 7) + 8 * 7) * 4 + (7 + 9 * 9) * 6 +8 * (6 * (8 + 4) + (5 + 6) * 6) * 7 + 4 * 7 * 2 +(7 + 7 * (8 * 5 + 4)) * 5 * (3 * 6 * 2 * 3 * 9) * 3 +4 + (7 * 5 * 3 * 5 + 3 * 5) * 7 +(6 + 5 + 6 * 3 * (6 * 4 + 6)) + 2 * 5 * 9 + 3 * 5 +3 * (6 + 3 + 5 * 3) + 6 * 3 + (7 + 8) * 9 +(3 + 8 + (5 * 4 + 4 + 7) + 5 * 2) + 2 + 5 + 6 * 9 + (4 + 2 + 6) +9 * 8 + (3 + (4 + 2 * 8 + 7 * 5 + 3) + (3 * 3) * 3 + (2 * 8)) +7 * 4 + (3 + 7 + 6 + 4 * (3 * 6) * 2) + ((5 + 5 * 5) + 6 + 2 * (2 * 3 * 3 + 3)) +9 * 5 * (6 + (2 * 3)) + (3 * 4 + 3 + 9 + 6) + (9 + 5 + 2 + (3 * 4 * 9 * 9 * 5) + 2 * 7) * 5 +(6 + 9 * 4 + 5 * 4 * (8 + 2 * 4 * 2 * 3)) + 4 * 9 + 6 * (4 * 5 * 9) +9 * 7 + (2 + (6 + 3) + (4 * 3 + 9) + 9) + 8 + 9 * 3 +3 * (8 + 7 + 7 + 8) * (5 + 5 + 2 + 6 + 9 + 7) +7 + (7 * 5 + 3 * 4 * 9 + 2) * (8 * 6 + (5 + 2) + 6) * 4 + (6 * 3) + 2 +(4 * 5 + 7 + 3 * (7 * 8) + 8) + 6 * 2 + 9 + 3 +7 * 4 * 8 * (7 + 5 + 2) + (8 * 8 * 2) + 3 +7 + 7 * (6 + (4 * 7 + 3 + 2 + 7) + 3) +2 + (8 + (5 + 9 + 2 * 6 * 6 + 8) * 8 + 2 * (5 * 2 + 8) * 4) + 2 * 6 +(4 * 9 * (7 * 6 * 9 + 8 * 6) * 9) * 2 * 2 +3 + (8 + 2 + (2 + 3 * 2) * 6 + (5 * 8 * 8 * 8 + 2 + 3)) * 4 * (9 + 3) * 6 +8 + 3 * (3 + 5) + 3 + 5 +4 + ((9 * 5 * 2 + 7 + 5) + 6 + 3 + 6 * (7 * 6) + 6) * 2 * 3 * (3 * 9 + 9) +((4 * 9) * 8 * 6) + 8 * 8 + 6 + ((6 + 4 + 7) * (2 + 2 * 4 * 9) + 3 + (5 * 9 + 9 * 9 + 5) + 2) +(8 * 4) + (8 + 8) +((4 + 5 + 2 * 4 * 7 + 3) * 6 * (4 * 6 + 8) * 9 * (9 + 7 + 5 + 3)) * 5 +8 * 2 + 8 + (7 * (8 + 2 + 6 * 7 + 9) + (5 + 9 + 3) + 6 * 6) * (8 + (4 * 2 + 4 + 7 * 5) + 2 * 6) * 5 +(2 * 5 + (8 * 7 + 9 + 2 + 2)) * 2 + (8 * (2 + 4) + 4 * 5 + 7) + 4 +4 + (2 + (4 * 3 * 9) * 5 * 4) +((3 + 4) * 7 + 6 + (5 * 3 * 8 + 8 * 9) * 3 + 6) + 8 * 4 * ((7 + 4 * 3) * (6 + 9 + 9 * 4 * 7) + 9 + 5 + 2 + (5 + 8 * 4 * 6 + 4 * 8)) +4 * (9 * 5 * (5 * 7 * 7 + 4)) * 5 * (5 * 7 + (4 * 5) * 4 + 9) +5 + (8 * 6 + 8) + 8 +7 + (8 + 6) * 4 + 2 +(3 * (9 + 6 * 8)) * 8 +3 + 6 + 4 + ((5 + 4 * 2) + 7) +7 * 3 + 5 * (2 * 5 + 4) * 8 +5 * 5 + (6 * (8 + 5) * 7) * 7 + 4 +7 + 9 + (2 + (3 + 8 + 4) + 9 * 2 + 6) * (7 + (3 + 6 * 8 + 8 * 7) + 9 * 3 * 8 + (9 * 6 + 2 + 8 + 4 * 4)) +6 * (2 * 8 + 3 + 5 + 5) + (3 + (8 * 2 * 3) * (2 + 9 * 8 * 5 + 3) + 4 + 7) * 7 + (5 * 5 + 7) +(2 * 2 * 6 * 4 * 9 + (9 * 5 + 7 * 4 + 6 * 2)) * 4 + (4 + (8 * 2 + 3 + 6)) +2 + (8 + 4 * 8 + 3) * 6 + 7 + 4 +(6 + 6 * (2 * 5 * 5 * 4 * 5 * 4) + 8 * 7 * 3) + 5 + (3 * 6 + 3 * 7) + 5 + 5 * 3 +2 * (8 + 2 + 6 * (9 * 9 * 9 + 4 * 2 * 7) * 3 * (4 + 6 * 3 + 8 + 4)) + 8 +(6 * 7 + 8 * 6 * 7 + (5 + 9 * 3 + 6 + 9 * 5)) + 2 * 6 +(7 + 2 * 4 + 3) + 4 * 5 + 3 +((7 * 7 + 2 + 7) + (3 + 3 + 5 + 9 * 3 + 2) * (2 * 4 * 7 + 6 * 3)) * (2 + (7 + 4 + 3 * 9 + 4 * 5) * 4 + 3 * (5 + 8 * 3)) + 5 + (2 + 8 * 2 * 8 * (6 * 7 + 4 + 5)) * (3 * (7 * 6 * 3 * 8)) + 7 +3 * 4 * ((8 + 8 + 9) * 6 + 6 + 7 + 6) + 8 + 3 +(6 + (7 * 4) + (9 + 6 + 3 * 9)) + 2 * (4 + 6 * 5 + (2 + 8) * 5 + 9) + 3 * (6 + 8 + 8 * (7 * 8 * 3 * 2 + 2 + 8)) +(9 + 8 * 4 + (5 * 8 + 7 * 2 * 8 * 9) * 8 + 9) * 3 +9 + ((5 * 3 + 6) + (8 + 6 * 6 + 7 + 2 + 8) * 8 + 5 + (9 + 8 + 2 * 9 + 2)) * 7 +((8 + 2 + 6 + 3) * 8 + 5 + 8 + 2) * 9 +(6 + (4 * 4 * 7 * 2 + 6) * 4 + 2 * 8 * (6 + 2 * 8)) * 2 * 8 +3 * (4 + 3 + 3 + (3 * 7 * 7)) + 6 + 7 + 4 + 8 +(6 * 8 + 7) * 8 * 9 + 8 + 4 +(7 * 7) * 2 + (8 * 7) + 4 * (5 * 2 * (3 + 4 + 7 * 8 * 3) * 9) + 6 +7 + (9 * (6 + 8 * 7 + 6 * 3) + 4) * 4 + 3 +6 + 3 * ((2 + 2 + 3 + 9 + 9 + 8) * 6 + 2) + 5 +3 * 6 * 6 + 2 + 2 + (2 * 2) +6 + (4 + 9 * (5 + 9 * 4 * 6 + 6) + 4 * 6 * (2 * 7 * 7 * 4 + 8)) + 5 +((2 + 6) + 2 + 5) + 7 + 3 + 5 * 3 + 5 +(6 * (2 + 8 + 7) + 4 * (2 + 8) * 9) + 9 * 6 +(2 * (9 * 4 * 3 * 2) + (4 + 4 * 3 + 2)) + 4 +(6 + 4 * (5 + 9)) + 7 * 7 * 8 * 5 * 3 +(3 + (5 + 4 * 3 + 9)) * 2 * (9 + 6 * 6 * (7 + 8 + 2 * 5) * 8 * 6) +8 + 6 * 6 +8 + (8 * 9) + 5 +8 + (7 * (6 + 8) * 7 * (5 * 7 * 8 * 7) + (8 + 4 + 6 * 9 + 8) + 4) + (6 * 4) * 3 * 7 +9 + 4 + 3 * 7 * 5 +(8 + 9) + 6 + 4 * 7 +5 * (4 * 6 + 4 + 2 * (5 * 2 * 2 * 8)) * 3 +3 * 3 + 2 + ((8 + 5 + 4 + 8 + 8) * 7 * 6 + 9 * 8) +9 + (8 + (8 + 9) + 7 + 8) +(8 + 2) + (2 + 5 + 7) + 6 * 6 * 6 * 6 +5 + 7 + (5 + 4 * (5 * 6 + 3 + 3) + (7 * 9 * 5 * 6 * 6 + 3) * 8) * 7 +6 + ((7 * 3) * 6 * 5 + 5 + (3 + 3 + 9)) + (6 * 2 + 6 + 9 + (2 + 4 * 3 * 4) + 7) +8 * 5 + (9 * 2 * 7 * 2 * 6 + 8) * 2 + 2 + 6 +6 * 8 +(2 * 3 + 5 + (8 + 6 * 8 * 7 * 2)) * 3 + 2 + 6 + 2 * 5 +(7 + 6 * (2 + 2 * 4 * 9 + 7 * 5) * 4 + 2) + 4 * (9 + 6) + (9 + 5) + 7 +5 * (3 + 7 + 7 * 4) +2 * ((2 * 7 * 8 * 4 * 3 + 7) + 6 + 3) * 5 * 7 +8 * 4 + 7 + (6 * 4 + 3 + 2) + 7 * 8 +7 * 9 + (2 * 9 * 2) * 6 +8 + (6 * (2 + 8) + 9) + (7 + 6 + 6 * (8 * 3 * 5 * 5 * 9) + 3 + 7) + 8 +2 + 5 * 4 + (4 * (3 + 7 * 5 + 8) * 8 + 2) + 3 * 7 +(8 * (9 * 7 + 9 + 9 + 4) * 3 + 2) * 8 +4 + (6 + (2 + 4 * 6) + 4) +(8 * (4 + 6 + 2 * 6 + 7)) * 9 + 8 + 3 * 5 +((2 * 7 + 3 * 5) * (5 + 7 + 7 + 3 * 7 * 3) * 8) * 2 * ((2 * 9 * 4 * 6 + 4) + 6 + (8 * 5 * 4 * 5 * 6 * 8) + 7 * (9 * 6 + 7 * 3 + 4 + 7)) + 9 +6 + 8 + (3 * 3 + 2) + 5 + 4 +5 * 6 + 6 * 5 * ((3 + 5 * 8 + 4 * 8) * 9 * 9 + 6 * 4 + 6) + (4 * 7 * 5 + 9 + 7) +2 * 7 * (4 * 7 + (4 + 7 + 4 + 3 * 2 + 7) + 7) +((8 + 3 * 6 * 6 + 4) + (9 + 5 + 3 * 3) + 7 * (3 * 4 + 4 + 9 * 4 + 6) + (8 + 5 + 2 * 2 * 5)) * 8 * 6 * 7 + ((5 + 6 + 2 * 4 + 2) * (9 + 8 + 9) + 6 + (6 * 5 * 9 + 7) * 4 * 6) * 7 +4 * 5 * (9 * 3) + (9 + 6 + 5 * 8) +3 * 8 +9 + 2 * (7 + (2 + 9) * 9) + 4 * 4 * 8 +(8 + 4 + 7 * 2 + 8 * (8 + 7 * 4 + 4)) + 4 +4 + 8 + ((7 * 9 + 9) + 3 + 2 + 3) * 8 +(6 + (4 + 3 + 8 + 6 * 8)) * (5 + 9 * (5 + 2 * 7 + 8) + (6 * 7 * 4 + 2 * 5) + 4 * 9) * 8 * 5 +8 + 3 + 4 * 9 * ((4 * 9 + 3 + 6) + 3 * 3 + 9) * 2 +6 + ((3 * 2) * (4 + 9 + 9 * 5 * 2) * (2 * 8 + 4 * 7 + 4 + 8)) * 5 + (9 * 4 * 6 + 6 * 4 + 8) +2 + (5 + 4 * 8) + (9 * 9) +8 * 3 + 7 * 3 + ((2 * 2 + 6 * 3) * 3 * 7 * 8 + 5) + 9 +4 * 7 + ((6 + 7 * 3 * 4 + 8) * 2 + 6 + (4 * 6 + 9 + 6 * 8 * 3) + 3 * 3) + 3 +5 * (9 * 9 + (7 + 6 + 2 + 9 + 9 + 9)) * 8 +5 + 4 * 2 + 7 * (5 * 5 + 2 + 3) +2 * 2 + 6 + ((2 + 2 + 5) * 6 * (2 + 7 + 3 * 9) * 5 + 9 * 8) +((2 * 4 + 7) + 9 * 8) + 5 * 6 * 2 + 9 +6 + ((7 * 9 * 9 + 2) * 2) +6 * (7 + (4 + 7 * 2) * 5 + 2 + 7) + 6 * 7 + 5 +8 * (6 * 8 + (7 + 2 + 7) + 3) + 7 + 6 +(7 * 2 * 3 * 7) + 4 * 3 + 6 * 9 + 7 +8 * 7 * (8 * 9 * 3) +9 + (9 * 4 * (9 + 3 * 5 + 9 + 9) * 8 + 5 + 9) +6 * (9 * 2 * 9 + 6 + 9 + 8) + (6 * 9 * 5) + 2 * 4 +2 * 5 * (7 + 8 + 3 + 8 + 6 * 4) * 4 + 5 +2 * 2 * (4 + 3) + 2 + 4 * 4 +(6 * (9 * 6 + 2 * 2) * 4 * 3 * 4 * 7) + 2 +(2 * 5) * 3 + 3 * 3 * 7 * 8 +3 + 6 + ((6 * 6) * (9 + 8 * 2) * 7 + 5 + 9 * 2) +9 + 7 + (2 * 8) +(8 * 7) + (8 + 6 * 7 + (3 * 9 + 6) * 6 + 8) + (4 * 2 * 9) +2 + 2 + 2 + 9 * ((4 + 5 * 7 * 5 * 4 * 7) * (9 + 9) + 4 * 4 + 9) * 8 +4 + 2 + ((6 + 8 * 4 + 7) * 7 + 3 * 9 + (9 + 5)) +7 + 8 * (3 * (3 + 9 + 6 * 5) + 6 * 8) * 7 + 4 +8 + 7 * (2 * (5 * 7)) + (4 * 3 + 7) +(2 + 8 * 7) + ((8 * 9 * 3 + 3 + 5 * 7) * 2 * (9 + 6 * 3 * 5) * 4 * (4 + 6 * 6 + 4 * 9) * 3) * 6 + 4 * 4 + 2 +3 * (9 + 4 + (9 + 5 + 8 + 6 * 3 * 4) * 8 + (9 * 3 + 8 + 4 + 7)) * 8 +(4 + 4 * (4 * 7)) * 2 + 7 * 3 +((4 * 9) * (9 + 6 + 9 * 8 + 7)) + 6 + 7 + 7 +6 + ((9 * 5 + 9 + 6 * 6 + 4) * 7 + (9 + 5 + 5) * 9 + 3) * (5 * 9) + 8 + 9 +(3 + 8 * (7 * 3 * 4)) * (6 * (6 + 4) + (9 + 8) * (2 * 5 + 4) + (8 + 5 * 6 + 5 * 2 + 2)) * 6 + 9 + (7 + 6 * 5) + (5 + 4 + (6 + 8 * 2) * 2) +4 * ((6 * 8 + 7 * 6 + 4) + 4) +((5 * 6) + 4) + (9 + 4 + 9) + 2 +5 * 9 * 7 * 6 + (9 * 7) +5 + (2 + 7) * 5 + 9 + 7 +6 * 2 * 8 + 4 +(3 + 2 * 4 + 8) + ((7 * 5 + 7 * 2 * 8) + 7 + 2) * 6 * 2 + 5 +(2 * 5) * (3 * 9 * 4 * 8 + 5 * 3) * ((9 + 5 * 6 * 3) + 3 * 7 + 4) * 5 +((3 + 6 * 3) * (4 + 9 * 5 * 6 + 4 * 7)) + ((8 * 7 * 2 + 7) + 5 * 6) * 6 + 7 +(8 + 4 * 8 * 8) * 9 * 9 + 7 + 4 +(7 * 9 + 5) * 5 + (9 + 4 + 4 + (7 * 9 * 2 * 8 * 2 + 9)) * ((7 * 5 * 7 * 3 * 7) * 5 * 2) + 8 +5 + (6 * (8 + 9) * 7 + 9) + 3 + 3 +8 + 8 * (6 * 5 * (3 + 5 + 9 * 2 * 9 * 7)) +5 * (4 + 7) * 5 + 7 + 8 + 6 +3 * ((5 + 6 + 2 + 7) * 4 * 6) * 5 * 5 +(6 + 3 * (9 * 9 * 7 * 8 * 9 + 9) + 5) * 8 * 6 + 7 + 2 +8 * (4 + 3 * 5 + (5 + 2 * 3 + 8) * 2 + (8 + 7 * 7 + 4 * 7 + 7)) + 8 * 6 + 4 * 5 +4 + 7 * 8 * (2 + 6 + 5) * (4 + 8 + 4) +9 + 8 * ((2 * 3 * 6 + 4 * 2) + (6 * 5 * 9 + 7) * 5 * 2 * 9 * 7) + (9 + 4 * (2 * 8 * 7) * 3 + (9 + 8)) + 3 + 6 +7 * 3 * 8 + ((6 + 7) * 9) * 2 +5 + 3 +4 + 9 * 7 * ((7 * 8 + 7 * 2 + 5 * 7) + 5 * 4) + (5 * 5 + (7 * 6) * 6) +((2 + 4) * 5) * 3 + 5 +5 + (2 + 8 * 9 * 6 * 2 * (2 + 8 + 3 + 5)) * 9 * 8 + 3 * (9 + (4 + 2 + 4 + 7 * 4) * 9 * 9 + 7) +2 + 6 * 9 + 3 + (7 + 8 + 2) * 4 +5 * 4 * (2 * 4 + 3 + 3 * (9 + 6 + 6) + (3 * 8 * 4)) * 4 * 3 + (9 * 7) +7 * (5 * 5 + 4 + 8 + (3 * 4 + 6 + 9)) * 2 * 9 * (6 + 7) +2 + (5 + 3 * 5 * 8) + 3 * 8 + (9 + 9 * 8 * 2 * 2) +((7 + 9 * 9) * 7 * 2) + 6 * 6 * 9 +(6 * (9 + 9 + 4 + 5 + 6 + 2) + 6 + 8 + (7 * 3 * 8)) + 2 + 6 + 2 +(3 + (6 * 2 + 2 + 6 * 7 + 8) * 9 * 2) * ((2 + 9) + 8 * 9 + 2) + 3 * (3 + 4 * 7 * (3 + 2 * 8 * 6 + 7) * (5 + 3)) * 5 +(9 * (9 * 9 + 7 * 4) + (7 * 4 * 7 * 5) * (9 * 2 + 8 + 5 * 6)) * (6 * (7 + 9 + 6 * 7 + 9) + 4 * 4 * 2 + 6) * 9 +4 + (3 + (4 + 5)) + 7 * (6 + 4 * (5 + 3 + 9 + 5 + 2) * 4 + 4) + 8 + 8 +((5 + 8) + 5) * 9 + 6 + 8 * 7 +8 * (5 + (3 * 3 + 6 * 3)) * 5 + 2 + 8 * 8 +6 * 2 * 9 * (8 * 7 * (2 * 4 + 6 + 7 + 4 * 5)) + 9 + 7 +(5 * 3 * (8 * 2 * 8 + 2 + 8) * (8 + 8 + 9 * 7 * 6 * 3) + (4 * 2 * 7) * 4) + (4 * 3 + 9 * 5) + 5 + (5 + 9) +(6 + 3) * 5 + (6 + 7 + 5 + 7) +(9 * (6 + 6 * 8 + 4) * (3 * 6 + 6 + 7 + 7 + 5) + (5 * 7 + 4) * 9) * (7 + 3 + 7 * 2 + (5 + 7 * 6 + 8) * 4) * 7 +6 + 8 * (5 * 5 + (3 * 2 * 2 * 7 + 4 * 9) * 7 + 4) + 8 + 4 +9 + (5 * 7) * (5 * 6 * 8 * (5 * 2) + 9) * (6 + 3 + 6 + 9 + 2) * 6 +8 * (8 + 8 + 9 + 9 * 6 * 3) + 8 * (3 * 3) + 3 * 3 +7 * 7 * (5 + 5 * 9) + (6 * 6 * 3 * 4 * 8 + 8) + 3 +(3 * 2) + 5 * (6 * (9 + 2 + 3 + 2 * 9 + 5) + 6) + 2 + 7 * 9 +9 * 2 + 3 + (3 * 7) + 4 +7 * 5 * 7 * (4 + 3 * 7 + 3 + (4 * 5 + 5) + (5 * 8)) * (8 * 3 * (8 + 9)) +((3 * 8 * 8 + 6 + 5 * 5) + 3 + (3 * 8 * 7)) * 2 * (9 + (9 * 8) * 5) * 5 * 4 + 7 +4 * 9 * (4 + (3 * 7) + (6 * 4 * 9)) + 2 + 8 +5 * ((7 + 2 + 6 + 6) * 2 + 4 * 8) +5 + 9 * ((7 + 2) * 5 * 4 * (5 + 7) + (8 + 4 * 8 * 7 * 9)) +((4 + 3) + 6 * 3) * (4 * (4 * 6) * 3 * 2 + 8 * 4) + 8 +5 + (6 + 3 + 6 * 8 * 7 * 2) + 3 * 9 + (8 + 2 + 6 * (4 + 6 * 6 * 8 * 3 * 3)) + 7 +7 + (8 + 8 * (8 + 3 * 3 * 5 + 2)) + 4 + (2 + 3 * 7 * 7 + 6 + 2) * 9 +7 * 3 * 2 + 6 + 7 * 4 +(3 + 4 * 7 + (8 * 3 * 5 * 8 + 5 * 3) * (7 + 4 * 8 + 9)) + 8 + (4 * 3 * 4) * (6 + 4 + 8) + 5 + (9 + 6 + 2 + 4) +((3 + 9 + 5) * 7 * 2 * (3 + 7)) + 5 + 3 +(4 * 9 + 3 + 9) * 8 * 8 + ((7 * 2 + 6 * 2 * 2) + 8 * 3 * 2 + 2 + 6) * 3 + 7 +(5 * 6 * (8 + 8) + 2) + 6 + 2 * (5 + 4) + 2 +(3 * 8 + 2 + 5 + 6 + 6) + (8 + 7 + 9 * 4 * 4 + (4 * 4 + 4 * 7 + 7)) * 4 +(7 * 7 * 4) * 7 * 3 + 6 +(9 * 3 + 7) * 7 + 4 + 2 * 7 * 3 +6 * 9 + (6 * 6 + 6 * (3 * 9 + 7)) +5 + 6 * 7 + 8 + (3 * 3 + 5 + 3 + 6) + 8 +(6 + 4 + 6 * 9) + (3 * (6 * 3 * 2 + 2 + 9)) + (2 + 9 + 8 * 3 * 8 + 9) + 4 + (4 + 4 + 7) +4 + 3 * ((6 * 3 * 2) + 3 * 3 + (6 * 4 + 5 * 5 * 7) * 6 + 3) +2 + (7 * 5 * 6 + 8 + 4 * 8) * 3 * 6 * 3 +9 * (8 * (6 * 7 + 7) * 3 + 9) + 7 * 5 + 6 +((3 * 5) + 2 * 4 * 2) * 7 + (4 + (4 * 2 * 6) + 2) + (3 + 5 * 8 + 6) + (5 + 2 * 6) * 2 +8 + 9 * (4 + 6 + 9 + 2 + 4 + 6) * (9 + 4 * 5) * 2 +(6 + 9 + 4 + 7 * 7 + (6 + 5 + 4 * 6 + 4 * 5)) * 3 + 7 + (2 + 9 + 7 + 8 + 4 * 5) +(6 * 7 * (7 * 7 + 3 * 9 + 4 * 2) + 8 * 7) * 3 * 2 +(7 * (5 * 2 + 2 + 8 * 4 + 6)) + 7 + 7 * 8 * 7 + 2 +(8 * 6 * (4 + 6 * 8 * 8)) * 8 + 4 +(4 + 7) * (7 * 4 + 4 + 5 + (9 * 9 * 4 * 5) + 8) + 4 + (8 * 9 + 2 + 4 * (2 * 2 + 8) * (5 * 7 * 4 * 6 + 2)) + 6 +4 * (8 * (2 * 5) + 4 * (7 * 2 + 7 + 8) * 7) * 4 * 9 * 7 + ((5 * 4 * 5 + 7 + 9) + 7 * 7 + (6 * 3 + 8 + 7 * 4) + (6 + 4 * 3)) +((3 + 4 + 7 * 8 * 5) * 9 * 6) + 6 + 3 +((7 + 3 * 8) * (3 * 7 + 4 * 3) + 5 + 2 * 9) * 8 + 4 + 2 +((3 + 8 * 8 + 9) * 5 * (5 * 6 + 5 + 7)) + 2 * (6 * 5 + 4 * 6 * 4 * 8) * 9 * 7 +4 + 9 * 8 * ((8 * 6) + 7 * 2 + 2 * 6) +(2 * 3 * 3) + 4 * 8 * (3 * 5) +(8 * (5 + 9) + (5 * 6 * 7 * 2) + 4 + 4 + (6 * 9 + 8 + 7 + 2)) * 7 * 2 * 6 + 2 * 2 +(8 * 9 * 7 + 3 * 6) + 5 + 4 * ((9 + 8) + (3 + 7 + 6 * 2) + (7 * 5 * 9 + 5) * 8 * 3) + (6 + 9 * (6 * 8) + 2 + 4 * 4) +6 + 8 * 9 + (4 * (9 + 2 + 3 + 5 + 3 + 8) + (3 + 7 * 4) + 4 * 7 * (6 + 2)) +2 + 4 * 7 * 5 + (8 * 3) + 6 +9 + 9 + 4 + (4 * 3 + 3 * 2 + (7 + 2 + 9 + 8) + 4) +3 * 7 * 7 * 9 + 7 +(3 * 2 * 3 * 5 + 6) + 4 * 5 + 8 + 5 +7 * 6 + 7 * 8 + 8 * 3 +(6 + 2 + (6 * 8 * 5) * 6 + 3 * (8 * 5 * 9 * 2 * 7 + 4)) * 3 +(8 + (4 + 2 * 3 + 7 * 5) * 9) * 3 + 9 + 4 + 6 +(9 + 6 + (6 + 3 * 2 + 8 * 5 + 7) + (8 + 8 * 3 + 9 * 4 * 8) + 6 * 2) * (7 + 9 + 5 + 8) * 7 + 4 * ((6 * 5 * 7 + 7 * 9 * 3) + (2 * 4 + 4 * 2)) +(5 * (3 + 5 + 5 * 6) * 7) + 8 + 3 * 4 + 7 +3 * 7 * (9 * 5 + 9 + 7) + 9 * (3 * 4 * 4 * (8 * 4 + 2 + 5)) + (9 * (5 * 3 * 4 * 9) + 5 * 8 + 9 * 5) +6 + 7 + ((2 * 4 * 5 + 7) * 2 * (8 + 8 * 4 * 3) * 3) * 5 * 6 * 4 +7 * (9 * 6 * 4) + 7 + (8 * 2 * 7 * 4 + 8) +4 + 7 * (8 * 4 * 2 * (2 + 5 + 9 + 5 * 2 + 5) * (5 * 6 + 2 * 5 + 9) + 3) * 9 * (3 * 6 + 3 * (4 * 4 * 6 + 6 * 2 * 9)) + 8 +2 + 6 * (8 + 9 + 6 + 2 * (9 + 4 * 7 * 5 + 5)) * (7 * 7 * 2 * 9) +4 * 3 + (8 * (6 * 8 + 8 + 6) + 3) + 5 +(5 + 6) + (2 + 6 + 4 + 8) +(9 * 5 * 3 + 6 * 6) + (5 * 4) +3 * 2 + (7 + 7 * 2 + (6 + 6 + 2 * 8 * 4) * 3) * 8 +(4 * 6 + 6) + 4 * 9 +6 + (9 * 3 * 3 * 3) + 8 +(5 + (9 + 6 + 3 + 7 * 3 + 5)) + 5 + (4 * 3 + 4) * 9 * 3 +(6 + 8 * (8 + 3 * 2 + 4 + 5 + 9)) * 7 +6 + 3 * 3 * 5 + ((7 + 4 * 8) + 2 * 7 + 4 * (5 + 8) * 8) + ((5 * 4 * 2) * 4 * 5 + (3 + 4 + 4 * 7 + 7)) +2 * 3 * 3 * 4 * 7 + 2 +6 * (7 + 9 * 9 + (9 * 6) + 5) + 4 +8 * (2 * 7 + 5 * 5 + 8) + 5 +(4 * 5) + (3 + 3 * (5 * 9 + 8 * 2) + 6 * 4 + 4) * 5 + 6 +4 * 9 + (3 + 3 * 2 + (2 + 4 * 4 * 7 * 7 + 5) * 9) * 5 * 3 +(5 * 3 * 6 + 8 + 2 + 4) * 6 * 8 * ((6 * 2 + 2 * 4 + 6 * 2) * 6) +4 * (5 * 4 * 6 + (7 + 3 * 9 + 3)) + (3 * 4 + 4 + (5 + 7 * 6 * 2 + 7) + 3) +3 * (5 + 2 * 6 + 8 + 5) + ((8 + 3 * 6 + 8 * 3) * (7 * 7)) + 8 * 4 * 5 +4 + (8 + 6 * (4 + 3)) * 4 + 4 +4 * 3 * (3 + (8 * 9) * (9 * 7 * 4 * 9 * 4 * 8) * (5 + 2 + 2 + 2)) +8 + (2 + 2 * 5 * 3 * (4 * 3 + 7 + 6 + 3)) + 7 * 2 * 5 * 5 +4 * (7 * 9 * (2 * 2 * 5) + 2 + 8 * (6 + 2)) * 4 * 7 * 8 +(2 * 3 * 3 * 2 + (9 * 8 + 5 + 4)) + 7 * 2 * 6 +((6 * 7 + 3 + 3 * 4) * (5 + 9 + 5) + 7 * 6) + 9 +6 * 9 + 8 + 3 + 6 * (6 * 9 + 9 + 3 * 2 * 2) +(3 * 5 + 2 + 9) * (6 + 9 + (6 * 8 + 2 + 8 * 3 + 8) + (2 + 6 + 6 + 6 * 3)) * ((7 * 5 * 9) * 3 + 9 + 3 + 8 * 2) * 8 * 6 + 8 +3 * (4 + 4 + 6 * (5 + 7) * 8) * (3 * (6 * 7 + 3 + 7 + 7) + 7) +6 * 8 + 8 * (6 + 9 + 5) * 7 + 7 +3 * (8 + 5 + 8 * 7 * 7 * 8) + 7 + 9 * 4 + 9 +(4 + 5 + 7 + 6) * (9 * (6 * 3 + 9 + 3 + 3) + 6 * 8 + (2 * 8 * 4 + 7 + 5 * 4)) +7 * 2 + 3 * (5 + 9) + 7 * 3 +7 * 8 + 5 + 7 * 4 * ((7 * 4 + 8 * 8) * (6 + 5 * 8 + 7 + 5 * 3)) +(7 * 4 + 3) + (7 + 9 * 7 * 9 * (3 + 2 * 2 * 8 * 2 * 6)) + 5 * 3 + 3 + 3 +5 + 6 * (3 + 6) * (6 + (7 + 2) * 3 + (8 * 6 + 3 + 8 + 5 * 9)) * 7 +(9 + 6 + 8) + 3 + 5 + 2 + (3 * 9 + (8 + 3) + 7 * 3) +6 + (9 + 7 * 2 * (8 * 9 * 2 + 7 + 6 * 7) * 6) +2 + 4 * ((7 * 2 + 4) * 8) + 9 * 3 * 3 +3 + ((5 + 4) * 4 * 7 * (3 + 5 * 4 + 3) + 3) +(7 + 4 * 3 * 6 * 7 * 5) * 2 * 7 + 4 +(7 * (7 * 9) + 8 + 2 * (6 + 9 + 9 * 2 * 5) + 7) * 7 * 7 + 9 +(2 * 5 + 9 * 5) * 3 +3 * 9 + 5 + 7 * 9 + 6 +9 * 3 * ((3 * 6 + 4 + 8) + 9 + 2) * 3 +8 * 3 + 6 * 8 * 2 + 4 diff --git a/day18/src/main.zig b/day18/src/main.zig new file mode 100644 index 0000000..fda184f --- /dev/null +++ b/day18/src/main.zig @@ -0,0 +1,401 @@ +const std = @import("std"); + +pub fn main() anyerror!void { + var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); + defer arena.deinit(); + var gpa = &arena.allocator; + + var sum : i64 = 0; + var f = try std.fs.cwd().openFile("input", .{}); + var contents = try f.readToEndAlloc(gpa, std.math.maxInt(u32)); + defer gpa.free(contents); + var it = std.mem.tokenize(contents, "\n"); + while (it.next()) |line| { + var tree = try Tree.init(gpa); + defer tree.deinit(); + try tree.parse_line(line); + sum += tree.resolve(); + } + + std.log.info("Sum of all operations from input: {}", .{sum}); +} + +const Operation = enum { + addition, + multiplication, + unknown, +}; + +const TreeValueTag = enum { + value, + operation, +}; + +const TreeValue = union(TreeValueTag) { + value: i64, + operation: Operation, +}; + +/// Binary tree node +const TreeElement = struct { + parent: ?*TreeElement = null, + children: [2]?*TreeElement = [_]?*TreeElement {null, null}, + value: TreeValue, + + pub fn add_child(self: *TreeElement, c: *TreeElement) void { + for (self.children) |ch, k| { + if (ch == null) { + self.children[k] = c; + return; + } + } + // We're not meant to call add_child 3+ times on a TreeElement + unreachable; + } + + pub fn get_root_node(self: *TreeElement) *TreeElement { + var r = self; + while(r.parent) |p| { + r = p; + } + return r; + } + + pub fn print(self: *TreeElement, depth: u64) anyerror!void { + var _type = switch(@as(TreeValueTag, self.*.value)) { + .value => "value", + .operation => "operation" + }; + var i : u64 = 0; + var stdout = std.io.getStdOut().writer(); + while (i < depth) : (i += 1) { + try stdout.print(" ", .{}); + } + try stdout.print("{*} ({}) - {}\n", .{self, _type, self.value}); + for (self.children) |c, k| { + if (c != null) { + try TreeElement.print(self.children[k].?, depth + 2); + //try self.children[k].?.print(depth + 2); + } + } + } + + pub fn resolve(self: *TreeElement) i64 { + if (@as(TreeValueTag, self.value) == TreeValueTag.value) { + return self.value.value; + } + else { + std.debug.assert(self.value.operation != .unknown); + var v : i64 = undefined; + var l = self.children[0].?.resolve(); + var r = self.children[1].?.resolve(); + if (self.value.operation == .addition) { + v = l + r; + } + else { + v = l * r; + } + return v; + } + } + + pub fn nearest_unknown_parent(self: *TreeElement) ?*TreeElement { + var t : *TreeElement = self; + var r : ?*TreeElement = null; + while(t.parent) |p| { + if (@as(TreeValueTag, p.*.value) == TreeValueTag.value) { + t = p; + continue; + } + else { + r = p; + break; + } + } + return r; + } +}; + +const Tree = struct { + allocator: *std.mem.Allocator, + // we want constant pointers for the TreeElements, but + // maybe we can use this object to simplify keeping track + // of them + children: std.ArrayList(*TreeElement), + + pub fn init(a: *std.mem.Allocator) !*Tree { + var self = try a.create(Tree); + errdefer a.destroy(self); + self.* = Tree { + .allocator = a, + .children = std.ArrayList(*TreeElement).init(a), + }; + return self; + } + + pub fn deinit(self: *Tree) void { + for (self.children.items) |c| { + self.allocator.destroy(c); + } + self.children.deinit(); + self.allocator.destroy(self); + } + + pub fn resolve(self: *Tree) i64 { + std.debug.assert(self.children.items.len > 0); + var root = self.children.items[0].get_root_node(); + return root.resolve(); + } + + pub fn create_number_node(self: *Tree, buf: []const u8, previous: ?*TreeElement) !*TreeElement { + var t = try self.create_node(); + var last : *TreeElement = undefined; + t.* = .{ + .value = TreeValue { .value = try std.fmt.parseInt(i64, buf, 10) }, + }; + if (previous) |l| { + l.add_child(t); + t.parent = l; + last = l; + } + else { + last = t; + } + return last; + } + + pub fn parse_line(self: *Tree, line: []const u8) !void { + var last_node : ?*TreeElement = null; + var disjointed_nodes = std.ArrayList(*TreeElement).init(self.allocator); + defer disjointed_nodes.deinit(); + + var buf = std.mem.zeroes([16]u8); + var buf_pos : usize = 0; + for (line) |c, k| { + if (c == ' ') { + // Check buffer length, if not zero add the necessary tree node + if (buf_pos == 0) { + continue; + } + last_node = try self.create_number_node(buf[0..buf_pos], last_node); + // Reset buffer + std.mem.set(u8, buf[0..], 0); + buf_pos = 0; + continue; + } + if (std.ascii.isDigit(c)) { + buf[buf_pos] = c; + buf_pos += 1; + + // If we're at the end of the string, we need to run the stuff + // for adding a number node + if (k == line.len-1) { + last_node = try self.create_number_node(buf[0..buf_pos], last_node); + // Buffer reset unneccesary here + } + continue; + } + switch (c) { + '+' => { + std.debug.assert(last_node != null); + // If we have a last node, we should check up for + // an unknown parent. If an unknown parent exists, + // we should set the operation on that node, and + // set that node to the last_node. + // If we ourselves are unknown + if (@as(TreeValueTag, last_node.?.value) == .operation) { + if (last_node.?.value.operation == .unknown) { + last_node.?.value = TreeValue { .operation = .addition }; + continue; + } + } + else if (last_node.?.nearest_unknown_parent()) |unknown_parent| { + unknown_parent.value = TreeValue { .operation = .addition }; + last_node = unknown_parent; + continue; + } + // If there is no unknown parent, our last node could + // be an operation node or value node. + // When it's an operation node, this is probably an error? + var root = last_node.?.get_root_node(); + var t = try self.create_node(); + t.* = .{ + .value = TreeValue{ .operation = .addition}, + }; + root.parent = t; + t.add_child(root); + last_node = t; + continue; + }, + '*' => { + std.debug.assert(last_node != null); + // Same as '+' + if (@as(TreeValueTag, last_node.?.value) == .operation) { + if (last_node.?.value.operation == .unknown) { + last_node.?.value = TreeValue { .operation = .multiplication }; + continue; + } + } + else if (last_node.?.nearest_unknown_parent()) |unknown_parent| { + unknown_parent.value = TreeValue { .operation = .multiplication }; + last_node = unknown_parent; + continue; + } + var root = last_node.?.get_root_node(); + var t = try self.create_node(); + t.* = .{ + .value = TreeValue{ .operation = .multiplication}, + }; + root.parent = t; + t.add_child(root); + last_node = t; + continue; + }, + '(' => { + // We need to start a new disjointed tree. + // Create an operation node of an unknown type, + // and set that as the parent of the current last node, if + // there is one. + if (last_node) |l| { + try disjointed_nodes.append(l); + } + else { + var t = try self.create_node(); + t.* = .{ + .value = TreeValue { .operation = .unknown }, + }; + if (last_node) |l| { + l.parent = t; + t.add_child(l); + } + try disjointed_nodes.append(t); + } + last_node = null; + }, + ')' => { + std.debug.assert(last_node != null); + // Close out any number that's in progress + if (buf_pos != 0) { + last_node = try self.create_number_node(buf[0..buf_pos], last_node); + // Reset buffer + std.mem.set(u8, buf[0..], 0); + buf_pos = 0; + } + var dj = disjointed_nodes.pop(); + if (last_node) |l| { + l.parent = dj; + dj.add_child(l); + last_node = dj; + } + }, + else => unreachable, + } + } + } + + fn create_node(self: *Tree) !*TreeElement { + var t = try self.allocator.create(TreeElement); + try self.children.append(t); + return t; + } + + fn print_tree(self: *Tree) !void { + var stdout = std.io.getStdOut().writer(); + if (self.children.items.len == 0) { + try stdout.print("Tree {} has no children", .{self}); + return; + } + var root = self.children.items[0].get_root_node(); + try root.print(0); + } +}; + +test "no_parentheses" { + var line = "1 + 2 * 3 + 4 * 5 + 6"; + var tree = try Tree.init(std.testing.allocator); + defer tree.deinit(); + + try tree.parse_line(line); + std.debug.warn("\n", .{}); + try tree.print_tree(); + + var v = tree.resolve(); + std.testing.expectEqual(@as(i64, 71), v); +} + +test "ex2" { + var line = "1 + (2 * 3) + (4 * (5 + 6))"; + var tree = try Tree.init(std.testing.allocator); + defer tree.deinit(); + + try tree.parse_line(line); + std.debug.warn("\n", .{}); + try tree.print_tree(); + + var v = tree.resolve(); + std.testing.expectEqual(@as(i64, 51), v); +} + +test "ex3" { + var line = "2 * 3 + (4 * 5)"; + var tree = try Tree.init(std.testing.allocator); + defer tree.deinit(); + + try tree.parse_line(line); + std.debug.warn("\n", .{}); + try tree.print_tree(); + + var v = tree.resolve(); + std.testing.expectEqual(@as(i64, 26), v); +} + +test "ex4" { + var line = "5 + (8 * 3 + 9 + 3 * 4 * 3)"; + var tree = try Tree.init(std.testing.allocator); + defer tree.deinit(); + + try tree.parse_line(line); + std.debug.warn("\n", .{}); + try tree.print_tree(); + + var v = tree.resolve(); + std.testing.expectEqual(@as(i64, 437), v); +} +test "ex5" { + var line = "5 * 9 * (7 * 3 * 3 + 9 * 3 + (8 + 6 * 4))"; + var tree = try Tree.init(std.testing.allocator); + defer tree.deinit(); + + try tree.parse_line(line); + std.debug.warn("\n", .{}); + try tree.print_tree(); + + var v = tree.resolve(); + std.testing.expectEqual(@as(i64, 12240), v); +} + +test "double_open_brackets" { + var line = "((2 * 3) + 4) * 2"; + var tree = try Tree.init(std.testing.allocator); + defer tree.deinit(); + + try tree.parse_line(line); + std.debug.warn("\n", .{}); + try tree.print_tree(); + + var v = tree.resolve(); + std.testing.expectEqual(@as(i64, 20), v); +} + +test "ex6" { + var line = "((2 + 4 * 9) * (6 + 9 * 8 + 6) + 6) + 2 + 4 * 2"; + var tree = try Tree.init(std.testing.allocator); + defer tree.deinit(); + + try tree.parse_line(line); + std.debug.warn("\n", .{}); + try tree.print_tree(); + + var v = tree.resolve(); + std.testing.expectEqual(@as(i64, 13632), v); +}