AoC 2022 D11: improve naming

The OOM issues from comptime seems to be caused just by looping 10k times.
This seems to be a known issue: ziglang/zig#12493.

Author: seandewar

advent-of-code/2022/day11/src/main.zig

@@ -3,67 +3,66 @@ const std = @import("std");
 const parsed_input = blk: {
     @setEvalBranchQuota(10_000);
     const input = @embedFile("input");
-    const Items = std.BoundedArray(u64, 64);
+    const ItemWorries = std.BoundedArray(u64, 64);
     var monkeys = std.BoundedArray(struct {
-        items: Items,
+        item_worries: ItemWorries,
         op: u8,
         operand: ?u8, // null == "old".
         div: u8, // assumed to always be a prime number.
         true_i: u8,
         false_i: u8,
     }, 16).init(0) catch unreachable;
-    var max_worry: u64 = 1;
+    var max_div: u64 = 1; // divisors are prime, so we only need to consider worry values less than this.
     var line_it = std.mem.tokenize(u8, input, std.cstr.line_sep);
     while (line_it.next()) |_| {
-        var items = Items.init(0) catch unreachable;
-        var items_it = std.mem.split(u8, line_it.next().?["  Starting items: ".len..], ", ");
-        while (items_it.next()) |item_str| items.append(std.fmt.parseInt(u64, item_str, 10) catch unreachable) catch unreachable;
+        var item_worries = ItemWorries.init(0) catch unreachable;
+        var item_it = std.mem.split(u8, line_it.next().?["  Starting items: ".len..], ", ");
+        while (item_it.next()) |str| item_worries.append(std.fmt.parseInt(u64, str, 10) catch unreachable) catch unreachable;
         const op_str = line_it.next().?["  Operation: new = old ".len..];
         const div = std.fmt.parseInt(u8, line_it.next().?["  Test: divisible by ".len..], 10) catch unreachable;
+        max_div *= div;
         monkeys.append(.{
-            .items = items,
+            .item_worries = item_worries,
             .op = op_str[0],
             .operand = std.fmt.parseInt(u8, op_str[2..], 10) catch null,
             .div = div,
             .true_i = std.fmt.parseInt(u8, line_it.next().?["    If true: throw to monkey ".len..], 10) catch unreachable,
             .false_i = std.fmt.parseInt(u8, line_it.next().?["    If false: throw to monkey ".len..], 10) catch unreachable,
         }) catch unreachable;
-        max_worry *= div;
     }
-    break :blk .{ .monkeys = monkeys, .max_worry = max_worry };
+    break :blk .{ .monkeys = monkeys, .max_div = max_div };
 };
 
-fn computeAnswer(comptime p1: bool) usize {
+fn computeAnswer(comptime is_p1: bool) usize {
     var monkeys = parsed_input.monkeys;
-    var inspect_counts = [_]usize{0} ** parsed_input.monkeys.len;
-    var round: u64 = 0;
-    while (round < if (p1) 20 else 10_000) : (round += 1) {
+    var inspects = [_]usize{0} ** parsed_input.monkeys.len;
+    var round: u32 = 0;
+    while (round < if (is_p1) 20 else 10_000) : (round += 1) {
         for (monkeys.slice()) |*monkey, i| {
-            for (monkey.items.slice()) |item| {
-                const operand = monkey.operand orelse item;
-                const pre_worry = if (monkey.op == '*') item * operand else item + operand;
-                const worry = if (p1) pre_worry / 3 else pre_worry % parsed_input.max_worry;
+            for (monkey.item_worries.slice()) |item_worry| {
+                const operand = monkey.operand orelse item_worry;
+                const op_worry = if (monkey.op == '*') item_worry * operand else item_worry + operand;
+                const worry = if (is_p1) op_worry / 3 else op_worry % parsed_input.max_div;
                 const throw_i = if (worry % monkey.div == 0) monkey.true_i else monkey.false_i;
-                monkeys.slice()[throw_i].items.append(worry) catch unreachable;
+                monkeys.slice()[throw_i].item_worries.append(worry) catch unreachable;
             }
-            inspect_counts[i] += monkey.items.len;
-            monkey.items.len = 0;
+            inspects[i] += monkey.item_worries.len;
+            monkey.item_worries.len = 0;
         }
     }
     var top2 = [_]usize{0} ** 2;
-    for (inspect_counts) |count| {
+    for (inspects) |count| {
         const min_i = std.mem.indexOfMin(usize, &top2);
         top2[min_i] = @max(top2[min_i], count);
     }
     return top2[0] * top2[1];
 }
+const p1 = blk: {
+    @setEvalBranchQuota(100_000);
+    break :blk computeAnswer(true);
+};
 
 pub fn main() !void {
     const stdout = std.io.getStdOut().writer();
-    const p1 = comptime blk: {
-        @setEvalBranchQuota(100_000);
-        break :blk computeAnswer(true);
-    };
-    const p2 = computeAnswer(false);
-    try stdout.print("Day11 (P1 at comptime): P1: {}, P2: {}\n", .{ p1, p2 });
+    try stdout.print("Day11 (P1 at comptime): P1: {}, P2: {}\n", .{ p1, computeAnswer(false) });
 }