[2024] Added Day 03: Mull It Over

Author: ACSimon33

2024/03/mull_it_over/benchmarks/puzzle_benchmarks.zig

@@ -0,0 +1,27 @@
+const std = @import("std");
+const zbench = @import("zbench");
+const mull_it_over = @import("mull_it_over");
+
+const puzzle_input = @embedFile("puzzle_input");
+
+// Benchmark of part 1
+fn task_1(_: std.mem.Allocator) void {
+    _ = mull_it_over.sum_of_multiplication_instructions(puzzle_input) catch {};
+}
+
+// Benchmark of part 2
+fn task_2(_: std.mem.Allocator) void {
+    _ = mull_it_over.conditional_sum_of_multiplication_instructions(puzzle_input) catch {};
+}
+
+pub fn main() !void {
+    const stdout = std.io.getStdOut().writer();
+    var bench = zbench.Benchmark.init(std.heap.page_allocator, .{});
+    defer bench.deinit();
+
+    try bench.add("Day 03 - Task 1", task_1, .{});
+    try bench.add("Day 03 - Task 2", task_2, .{});
+
+    try stdout.writeAll("\n");
+    try bench.run(stdout);
+}

2024/03/mull_it_over/build.zig

@@ -0,0 +1,75 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    // -------------------------- Solution module --------------------------- \\
+    const mull_it_over = b.addModule("mull_it_over", .{
+        .root_source_file = b.path("src/mull_it_over.zig"),
+    });
+
+    // -------------------------- Main executable --------------------------- \\
+    const mull_it_over_exe = b.addExecutable(.{
+        .name = "mull_it_over",
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const yazap = b.dependency("yazap", .{});
+    mull_it_over_exe.root_module.addImport("yazap", yazap.module("yazap"));
+    mull_it_over_exe.root_module.addImport("mull_it_over", mull_it_over);
+    b.installArtifact(mull_it_over_exe);
+
+    const run_cmd = b.addRunArtifact(mull_it_over_exe);
+    run_cmd.step.dependOn(b.getInstallStep());
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    const run_step = b.step("run", "Run the mull_it_over (day 03) app");
+    run_step.dependOn(&run_cmd.step);
+
+    // --------------------------- Example tests ---------------------------- \\
+    const mull_it_over_tests = b.addTest(.{
+        .name = "mull_it_over_tests",
+        .root_source_file = b.path("tests/example_tests.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    mull_it_over_tests.root_module.addImport("mull_it_over", mull_it_over);
+    mull_it_over_tests.root_module.addAnonymousImport("example_input_1", .{
+        .root_source_file = b.path("input/example_input_1.txt"),
+    });
+    mull_it_over_tests.root_module.addAnonymousImport("example_input_2", .{
+        .root_source_file = b.path("input/example_input_2.txt"),
+    });
+    b.installArtifact(mull_it_over_tests);
+
+    const test_step = b.step("test", "Run mull_it_over (day 03) tests");
+    test_step.dependOn(&b.addRunArtifact(mull_it_over_tests).step);
+
+    // ------------------------- Puzzle benchmarks -------------------------- \\
+    const mull_it_over_benchmarks = b.addExecutable(.{
+        .name = "mull_it_over_benchmarks",
+        .root_source_file = b.path("benchmarks/puzzle_benchmarks.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const zbench = b.dependency("zbench", .{
+        .target = target,
+        .optimize = optimize,
+    });
+    mull_it_over_benchmarks.root_module.addImport("zbench", zbench.module("zbench"));
+    mull_it_over_benchmarks.root_module.addImport("mull_it_over", mull_it_over);
+    mull_it_over_benchmarks.root_module.addAnonymousImport("puzzle_input", .{
+        .root_source_file = b.path("input/puzzle_input.txt"),
+    });
+    b.installArtifact(mull_it_over_benchmarks);
+
+    const benchmark_step = b.step("benchmark", "Run mull_it_over (day 03) benchmarks");
+    benchmark_step.dependOn(&b.addRunArtifact(mull_it_over_benchmarks).step);
+}

2024/03/mull_it_over/build.zig.zon

@@ -0,0 +1,23 @@
+.{
+    .name = "mull_it_over",
+    .version = "0.1.0",
+    .minimum_zig_version = "0.13.0",
+    .dependencies = .{
+        .yazap = .{
+            .url = "git+https://github.com/prajwalch/yazap#c2e3122d5dd6192513ba590f229dbc535110efb8",
+            .hash = "122054439ec36ac10987c87ae69f3b041b40b2e451af3fe3ef1fc578b3bad756a800",
+        },
+        .zbench = .{
+            .url = "git+https://github.com/hendriknielaender/zBench#fb3ecae5d035091fd2392a2ec21970c06fc375fa",
+            .hash = "122095b73930ff5d627429295c669905d85bb9b54394ddc185ad2d61295cc65819e5",
+        },
+    },
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        "input",
+        "tests",
+        "benchmarks",
+    },
+}

2024/03/mull_it_over/input/example_input_1.txt

@@ -0,0 +1 @@
+xmul(2,4)%&mul[3,7]!@^do_not_mul(5,5)+mul(32,64]then(mul(11,8)mul(8,5))

2024/03/mull_it_over/input/example_input_2.txt

@@ -0,0 +1 @@
+xmul(2,4)&mul[3,7]!^don't()_mul(5,5)+mul(32,64](mul(11,8)undo()?mul(8,5))

2024/03/mull_it_over/input/puzzle_input.txt

@@ -0,0 +1,56 @@
+const std = @import("std");
+const yazap = @import("yazap");
+const mull_it_over = @import("mull_it_over");
+
+const allocator = std.heap.page_allocator;
+const log = std.log;
+const App = yazap.App;
+const Arg = yazap.Arg;
+const string = []const u8;
+
+pub fn main() !void {
+    var app = App.init(allocator, "Day 03", "Day 03: Mull It Over");
+    defer app.deinit();
+
+    var cmd = app.rootCommand();
+    cmd.setProperty(.help_on_empty_args);
+    try cmd.addArg(Arg.singleValueOption(
+        "filename",
+        'f',
+        "Input file (e.g. input/puzzle_input.txt)",
+    ));
+
+    const matches = try app.parseProcess();
+
+    const stdout_file = std.io.getStdOut().writer();
+    var bw = std.io.bufferedWriter(stdout_file);
+    const stdout = bw.writer();
+
+    var file_content: string = undefined;
+    if (matches.getSingleValue("filename")) |filename| {
+        const file = try std.fs.cwd().openFile(filename, .{});
+        defer file.close();
+
+        const file_size = try file.getEndPos();
+        const buffer: []u8 = try allocator.alloc(u8, file_size);
+        defer allocator.free(buffer);
+
+        _ = try file.readAll(buffer);
+        file_content = std.mem.Allocator.dupe(
+            allocator,
+            u8,
+            std.mem.trim(u8, buffer, "\n"),
+        ) catch unreachable;
+    } else {
+        try app.displayHelp();
+        return;
+    }
+
+    const result_1 = mull_it_over.sum_of_multiplication_instructions(file_content);
+    try stdout.print("Sum of all multiplication instructions: {!}\n", .{result_1});
+    try bw.flush();
+
+    const result_2 = mull_it_over.conditional_sum_of_multiplication_instructions(file_content);
+    try stdout.print("Conditional sum of multiplication instructions: {!}\n", .{result_2});
+    try bw.flush();
+}

2024/03/mull_it_over/src/main.zig

@@ -0,0 +1,137 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const string = []const u8;
+
+/// Task 1 - Calculate the sum over all multiplication instructions.
+///
+/// Arguments:
+///   - `contents`: Input file contents.
+///
+/// Returns:
+///   - Sum of all multiplications.
+pub fn sum_of_multiplication_instructions(contents: string) !u32 {
+    const min_instruction_len: usize = 8;
+
+    var product_sum: u32 = 0;
+    var i: usize = 0;
+    while (i <= contents.len - min_instruction_len) {
+        product_sum += parse_mul_instruction(contents, &i) catch {
+            continue;
+        };
+    }
+
+    return product_sum;
+}
+
+/// Task 2 - Calculate the sum over the multiplication instructions which are
+///          activated via the do() instructions.
+///
+/// Arguments:
+///   - `contents`: Input file contents.
+///
+/// Returns:
+///   - Sum of all active multiplications.
+pub fn conditional_sum_of_multiplication_instructions(contents: string) !u32 {
+    const min_instruction_len: usize = 8;
+
+    var product_sum: u32 = 0;
+    var do: bool = true;
+    var i: usize = 0;
+    while (i <= contents.len - min_instruction_len) {
+        do = parse_conditional_instructions(contents, &i) catch do;
+        if (do) {
+            product_sum += parse_mul_instruction(contents, &i) catch {
+                continue;
+            };
+        } else {
+            i += 1;
+        }
+    }
+
+    return product_sum;
+}
+
+// -------------------------------------------------------------------------- \\
+
+/// Parse a single multiplication instruction.
+///
+/// Arguments:
+///   - `contents`: The instruction string.
+///   - `i`: Pointer to the current position in the instruction string.
+///
+/// Returns:
+///   - The result of the multiplication instruction if one was found.
+fn parse_mul_instruction(contents: string, i: *usize) !u32 {
+    if (!std.mem.eql(u8, contents[(i.*)..(i.* + 4)], "mul(")) {
+        i.* += 1;
+        return error.InvalidInstruction;
+    }
+    i.* += 4;
+
+    const multiplier = try parse_three_digit_number(contents[(i.*)..(i.* + 3)], i);
+    if (contents[i.*] != ',') {
+        return error.InvalidInstruction;
+    }
+    i.* += 1;
+
+    const multiplicand = try parse_three_digit_number(contents[(i.*)..(i.* + 3)], i);
+    if (contents[i.*] != ')') {
+        return error.InvalidInstruction;
+    }
+    i.* += 1;
+
+    return multiplier * multiplicand;
+}
+
+/// Parse a single integer up to three digits.
+///
+/// Arguments:
+///   - `contents`: The instruction string.
+///   - `i`: Pointer to the current position in the instruction string.
+///
+/// Returns:
+///   - The integer if one was found.
+fn parse_three_digit_number(str: string, i: *usize) !u32 {
+    var num = try std.fmt.parseInt(u32, str[0..1], 10);
+    i.* += 1;
+
+    if (str[1] != ',' and str[1] != ')') {
+        num *= 10;
+        num += try std.fmt.parseInt(u32, str[1..2], 10);
+    } else {
+        return num;
+    }
+    i.* += 1;
+
+    if (str[2] != ',' and str[2] != ')') {
+        num *= 10;
+        num += try std.fmt.parseInt(u32, str[2..3], 10);
+    } else {
+        return num;
+    }
+    i.* += 1;
+
+    return num;
+}
+
+/// Parse a single conditional instruction: do() or don't().
+///
+/// Arguments:
+///   - `contents`: The instruction string.
+///   - `i`: Pointer to the current position in the instruction string.
+///
+/// Returns:
+///   - The true if do() was found and false if don't() was found.
+fn parse_conditional_instructions(contents: string, i: *usize) !bool {
+    if (std.mem.eql(u8, contents[(i.*)..(i.* + 4)], "do()")) {
+        i.* += 4;
+        return true;
+    }
+
+    if (std.mem.eql(u8, contents[(i.*)..(i.* + 7)], "don't()")) {
+        i.* += 7;
+        return false;
+    }
+
+    return error.InvalidInstruction;
+}

2024/03/mull_it_over/src/mull_it_over.zig

@@ -0,0 +1,29 @@
+const std = @import("std");
+const mull_it_over = @import("mull_it_over");
+const testing = std.testing;
+
+// Test of part 1
+test "task_1_input_1" {
+    const example_input = @embedFile("example_input_1");
+    try testing.expectEqual(
+        161,
+        mull_it_over.sum_of_multiplication_instructions(example_input),
+    );
+}
+
+// Test of part 2
+test "task_2_input_1" {
+    const example_input = @embedFile("example_input_1");
+    try testing.expectEqual(
+        161,
+        mull_it_over.conditional_sum_of_multiplication_instructions(example_input),
+    );
+}
+
+test "task_2_input_2" {
+    const example_input = @embedFile("example_input_2");
+    try testing.expectEqual(
+        48,
+        mull_it_over.conditional_sum_of_multiplication_instructions(example_input),
+    );
+}

2024/03/mull_it_over/tests/example_tests.zig

@@ -34,5 +34,6 @@ pub fn build(b: *std.Build) void {
     add_subproject(b, target, optimize, test_step, benchmark_step, "00", "zig_template");
     add_subproject(b, target, optimize, test_step, benchmark_step, "01", "historian_hysteria");
     add_subproject(b, target, optimize, test_step, benchmark_step, "02", "red_nosed_reports");
+    add_subproject(b, target, optimize, test_step, benchmark_step, "03", "mull_it_over");
     add_subproject(b, target, optimize, test_step, benchmark_step, "06", "guard_gallivant");
 }