[2024] Add Day 11: Plutonian Pebbles

Author: ACSimon33

2024/11/plutonian_pebbles/benchmarks/puzzle_benchmarks.zig

@@ -0,0 +1,27 @@
+const std = @import("std");
+const zbench = @import("zbench");
+const plutonian_pebbles = @import("plutonian_pebbles");
+
+const puzzle_input = @embedFile("puzzle_input");
+
+// Benchmark of part 1
+fn task_1(_: std.mem.Allocator) void {
+    _ = plutonian_pebbles.amount_of_stones(puzzle_input, 25) catch {};
+}
+
+// Benchmark of part 2
+fn task_2(_: std.mem.Allocator) void {
+    _ = plutonian_pebbles.amount_of_stones(puzzle_input, 75) 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 11 - Task 1", task_1, .{});
+    try bench.add("Day 11 - Task 2", task_2, .{});
+
+    try stdout.writeAll("\n");
+    try bench.run(stdout);
+}

2024/11/plutonian_pebbles/build.zig

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

2024/11/plutonian_pebbles/build.zig.zon

@@ -0,0 +1,23 @@
+.{
+    .name = "plutonian_pebbles",
+    .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/11/plutonian_pebbles/input/example_input.txt

@@ -0,0 +1 @@
+125 17

2024/11/plutonian_pebbles/input/puzzle_input.txt

@@ -0,0 +1 @@
+6571 0 5851763 526746 23 69822 9 989

2024/11/plutonian_pebbles/src/main.zig

@@ -0,0 +1,65 @@
+const std = @import("std");
+const yazap = @import("yazap");
+const plutonian_pebbles = @import("plutonian_pebbles");
+
+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 11", "Day 11: Plutonian Pebbles");
+    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)",
+    ));
+    try cmd.addArg(Arg.singleValueOption(
+        "blinks",
+        'b',
+        "Amount of blinks",
+    ));
+
+    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;
+    }
+
+    var blinks: usize = undefined;
+    if (matches.getSingleValue("blinks")) |blinks_str| {
+        blinks = try std.fmt.parseInt(usize, blinks_str, 10);
+    } else {
+        try app.displayHelp();
+        return;
+    }
+
+    const result = plutonian_pebbles.amount_of_stones(file_content, blinks);
+    try stdout.print("Amount of stones: {!}\n", .{result});
+    try bw.flush();
+}

2024/11/plutonian_pebbles/src/plutonian_pebbles.zig

@@ -0,0 +1,102 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const HashMap = std.AutoArrayHashMap;
+const string = []const u8;
+
+/// Task 1 & 2 - Simulate the given amount of blinks and return the amount of
+///              stones after all blinks. Use two sets of stones which are
+///              swapped after each blink to reduce the amount of reallocations
+///              of the used Hashmaps.
+///
+/// Arguments:
+///   - `contents`: Input file contents.
+///   - `blinks`: Amount of blinks.
+///
+/// Returns:
+///   - The amount of stones after all blinks.
+pub fn amount_of_stones(contents: string, blinks: usize) !u64 {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+
+    const allocator = arena.allocator();
+    var stones = try parse(contents, allocator);
+    var new_stones = HashMap(u64, u64).init(allocator);
+
+    for (0..blinks) |_| {
+        try blink(stones, &new_stones);
+        std.mem.swap(HashMap(u64, u64), &stones, &new_stones);
+    }
+
+    var stones_count: u64 = 0;
+    for (stones.values()) |amount| {
+        stones_count += amount;
+    }
+
+    return stones_count;
+}
+
+// -------------------------------------------------------------------------- \\
+
+/// Simulate 'one blink'. For each unique stone number apply the rules and
+/// increment the amounts of the new stones.
+///
+/// Arguments:
+///   - `stones`: Current set of stone numbers and amounts.
+///   - `new_stones`: The new stones after the blink.
+fn blink(stones: HashMap(u64, u64), new_stones: *HashMap(u64, u64)) !void {
+    new_stones.clearRetainingCapacity();
+    for (stones.keys()) |stone| {
+        const amount = stones.getPtr(stone).?.*;
+        if (stone == 0) {
+            try increment_amount(new_stones, 1, amount);
+            continue;
+        }
+        const digits = std.math.log10(stone) + 1;
+        if (digits % 2 == 0) {
+            const power_of_10 = try std.math.powi(u64, 10, digits / 2);
+            const right_stone = stone % power_of_10;
+            const left_stone = (stone - right_stone) / power_of_10;
+
+            try increment_amount(new_stones, right_stone, amount);
+            try increment_amount(new_stones, left_stone, amount);
+        } else {
+            try increment_amount(new_stones, stone * 2024, amount);
+        }
+    }
+}
+
+/// Parse the file contents into a initial map of stones with their number
+/// mapped to the amount of the same stone.
+///
+/// Arguments:
+///   - `contents`: Input file contents.
+///   - `allocator`: Allocator for the containers.
+///
+/// Returns:
+///   - Map of stone numbers to stone amounts.
+fn parse(contents: string, allocator: Allocator) !HashMap(u64, u64) {
+    var stones = HashMap(u64, u64).init(allocator);
+
+    var numbers = std.mem.tokenize(u8, contents, " ");
+    while (numbers.next()) |num| {
+        try increment_amount(&stones, try std.fmt.parseInt(u64, num, 10), 1);
+    }
+
+    return stones;
+}
+
+/// Increment the amount of a given stone in the map by the given amount. Create
+/// a new entry if the stone didn't exist before.
+///
+/// Arguments:
+///   - `contents`: Input file contents.
+///   - `allocator`: Allocator for the containers.
+///
+/// Returns:
+///   - Map of stone numbers to stone amounts.
+fn increment_amount(stones: *HashMap(u64, u64), stone: u64, increment: u64) !void {
+    const entry = try stones.*.getOrPutValue(stone, increment);
+    if (entry.found_existing) {
+        entry.value_ptr.* += increment;
+    }
+}

2024/11/plutonian_pebbles/tests/example_tests.zig

@@ -0,0 +1,12 @@
+const std = @import("std");
+const plutonian_pebbles = @import("plutonian_pebbles");
+const testing = std.testing;
+
+// Test of part 1
+test "task_1" {
+    const example_input = @embedFile("example_input");
+    try testing.expectEqual(
+        55312,
+        plutonian_pebbles.amount_of_stones(example_input, 25),
+    );
+}

2024/build.zig

@@ -38,4 +38,5 @@ pub fn build(b: *std.Build) void {
     add_subproject(b, target, optimize, test_step, benchmark_step, "06", "guard_gallivant");
     add_subproject(b, target, optimize, test_step, benchmark_step, "09", "disk_fragmenter");
     add_subproject(b, target, optimize, test_step, benchmark_step, "10", "hoof_it");
+    add_subproject(b, target, optimize, test_step, benchmark_step, "11", "plutonian_pebbles");
 }

2024/build.zig.zon

@@ -10,6 +10,7 @@
         .day_06_guard_gallivant = .{ .path = "06/guard_gallivant" },
         .day_09_disk_fragmenter = .{ .path = "09/disk_fragmenter" },
         .day_10_hoof_it = .{ .path = "10/hoof_it" },
+        .day_11_plutonian_pebbles = .{ .path = "11/plutonian_pebbles" },
     },
     .paths = .{
         "build.zig",
@@ -21,5 +22,6 @@
         "06",
         "09",
         "10",
+        "11",
     },
 }