From a4b455f831a4b3ba7951d6857c76d581f8f0191e Mon Sep 17 00:00:00 2001 From: Inga Date: Mon, 4 Dec 2023 20:08:57 +0000 Subject: [PATCH] day 4, part 2 --- day04-hard/build.zig | 70 ++++++++++++++++++++++++++++++++++ day04-hard/sample.in | 6 +++ day04-hard/src/main.zig | 83 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 159 insertions(+) create mode 100644 day04-hard/build.zig create mode 100644 day04-hard/sample.in create mode 100644 day04-hard/src/main.zig diff --git a/day04-hard/build.zig b/day04-hard/build.zig new file mode 100644 index 0000000..2649974 --- /dev/null +++ b/day04-hard/build.zig @@ -0,0 +1,70 @@ +const std = @import("std"); + +// Although this function looks imperative, note that its job is to +// declaratively construct a build graph that will be executed by an external +// runner. +pub fn build(b: *std.Build) 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 optimization options allow the person running `zig build` to select + // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not + // set a preferred release mode, allowing the user to decide how to optimize. + const optimize = b.standardOptimizeOption(.{}); + + const exe = b.addExecutable(.{ + .name = "day04-hard", + // In this case the main source file is merely a path, however, in more + // complicated build scripts, this could be a generated file. + .root_source_file = .{ .path = "src/main.zig" }, + .target = target, + .optimize = optimize, + }); + + // This declares intent for the executable to be installed into the + // standard location when the user invokes the "install" step (the default + // step when running `zig build`). + b.installArtifact(exe); + + // This *creates* a Run step in the build graph, to be executed when another + // step is evaluated that depends on it. The next line below will establish + // such a dependency. + const run_cmd = b.addRunArtifact(exe); + + // By making the run step depend on the install step, it will be run from the + // installation directory rather than directly from within the cache directory. + // This is not necessary, however, if the application depends on other installed + // files, this ensures they will be present and in the expected location. + run_cmd.step.dependOn(b.getInstallStep()); + + // This allows the user to pass arguments to the application in the build + // command itself, like this: `zig build run -- arg1 arg2 etc` + if (b.args) |args| { + run_cmd.addArgs(args); + } + + // This creates a build step. It will be visible in the `zig build --help` menu, + // and can be selected like this: `zig build run` + // This will evaluate the `run` step rather than the default, which is "install". + const run_step = b.step("run", "Run the app"); + run_step.dependOn(&run_cmd.step); + + // Creates a step for unit testing. This only builds the test executable + // but does not run it. + const unit_tests = b.addTest(.{ + .root_source_file = .{ .path = "src/main.zig" }, + .target = target, + .optimize = optimize, + }); + + const run_unit_tests = b.addRunArtifact(unit_tests); + + // Similar to creating the run step earlier, this exposes a `test` step to + // the `zig build --help` menu, providing a way for the user to request + // running the unit tests. + const test_step = b.step("test", "Run unit tests"); + test_step.dependOn(&run_unit_tests.step); +} diff --git a/day04-hard/sample.in b/day04-hard/sample.in new file mode 100644 index 0000000..71f208a --- /dev/null +++ b/day04-hard/sample.in @@ -0,0 +1,6 @@ +Card 1: 41 48 83 86 17 | 83 86 6 31 17 9 48 53 +Card 2: 13 32 20 16 61 | 61 30 68 82 17 32 24 19 +Card 3: 1 21 53 59 44 | 69 82 63 72 16 21 14 1 +Card 4: 41 92 73 84 69 | 59 84 76 51 58 5 54 83 +Card 5: 87 83 26 28 32 | 88 30 70 12 93 22 82 36 +Card 6: 31 18 13 56 72 | 74 77 10 23 35 67 36 11 \ No newline at end of file diff --git a/day04-hard/src/main.zig b/day04-hard/src/main.zig new file mode 100644 index 0000000..0daa1c9 --- /dev/null +++ b/day04-hard/src/main.zig @@ -0,0 +1,83 @@ +const std = @import("std"); + +fn StackList(comptime T: type, comptime capacity_type: type, comptime capacity: capacity_type) type { + return struct { + const Self = @This(); + mem: [capacity]T, + length: capacity_type, + + fn add(self: *Self, value: T) void { + self.mem[self.length] = value; + self.length += 1; + } + + fn has(self: *Self, needle: T) bool { + for (0..self.length) |i| { + if (self.mem[i] == needle) { + return true; + } + } + + return false; + } + + fn init() Self { + return Self{ + .mem = undefined, + .length = 0, + }; + } + }; +} + +fn getWinningNumbersCount(line: []const u8) u32 { + var result: u32 = 0; + var winning_numbers = StackList(u16, u8, 20).init(); + + var index: usize = 0; + while (index < line.len and line[index] != ':') : (index += 1) {} + + index += 2; + while (index < line.len and line[index] != '|') : (index += 3) { + winning_numbers.add((@as(u16, line[index]) << 8) | @as(u16, line[index + 1])); + } + + index += 2; + while (index < line.len) : (index += 3) { + const current_card = (@as(u16, line[index]) << 8) | @as(u16, line[index + 1]); + if (winning_numbers.has(current_card)) { + result += 1; + } + } + + return result; +} + +fn solve(line: []const u8, state: *[]u32) u32 { + const winning_numbers_count = getWinningNumbersCount(line); + state.*[0] += 1; + //std.debug.print("state: {d} long, starts with {d}; winning numbers: {d}\n", .{ state.len, state.*[0], winning_numbers_count }); + for (0..winning_numbers_count) |i| { + state.*[i + 1] += state.*[0]; + } + + return state.*[0]; +} + +pub fn main() !void { + const stdout = std.io.getStdOut().writer(); + + const raw_in = std.io.getStdIn(); + var buffered_reader = std.io.bufferedReader(raw_in.reader()); + var reader = buffered_reader.reader(); + + var result: u32 = 0; + var line_buffer: [1000]u8 = undefined; + var state = std.mem.zeroes([1000]u32); + var slice: []u32 = state[0..]; + while (try reader.readUntilDelimiterOrEof(&line_buffer, '\n')) |line| { + result += solve(line, &slice); + slice = slice[1..]; + } + try stdout.print("{d}\n", .{result}); +}