Add new scaffolding

src/day1.zig

···
 const std = @import("std");
+const Allocator = std.mem.Allocator;
 
-pub fn run(input: []u8) !void {
+pub fn run(_: Allocator, input: []u8) !struct { u64, u64 } {
     var lines = std.mem.tokenizeScalar(u8, input, '\n');
 
     var dial: u8 = 50;
-    var zeroes_p1: u64 = 0;
-    var zeroes_p2: u64 = 0;
+    var answer1: u64 = 0;
+    var answer2: u64 = 0;
     while (lines.next()) |line| {
         const direction: i2 = switch (line[0]) {
             'L' => -1,
···
         dial = @intCast(@mod(new_rotation, 100));
 
         if (dial == 0) {
-            zeroes_p1 += 1;
+            answer1 += 1;
         }
 
-        zeroes_p2 += zeroes_clicked;
+        answer2 += zeroes_clicked;
     }
 
-    std.debug.print("Answer P1: {d}\n", .{zeroes_p1});
-    std.debug.print("Answer P2: {d}\n", .{zeroes_p2});
+    return .{ answer1, answer2 };
 }

src/day2.zig

···
 const std = @import("std");
+const Allocator = std.mem.Allocator;
 
-pub fn run(input: []u8) !void {
+pub fn run(_: Allocator, input: []u8) !struct { u64, u64 } {
     var ranges = std.mem.tokenizeScalar(u8, std.mem.trimEnd(u8, input, "\n"), ',');
 
     var answer1: u64 = 0;
···
         }
     }
 
-    std.debug.print("Answer P1: {d}\n", .{answer1});
-    std.debug.print("Answer P2: {d}\n", .{answer2});
+    return .{ answer1, answer2 };
 }

src/day3.zig

···
 const std = @import("std");
+const Allocator = std.mem.Allocator;
 
-pub fn run(input: []u8) !void {
+pub fn run(_: Allocator, input: []u8) !struct { u64, u64 } {
     var lines = std.mem.tokenizeScalar(u8, input, '\n');
 
     var answer1: u64 = 0;
···
         answer2 += try calculateJoltage(line, 12);
     }
 
-    std.debug.print("Answer P1: {d}\n", .{answer1});
-    std.debug.print("Answer P2: {d}\n", .{answer2});
+    return .{ answer1, answer2 };
 }
 
 fn calculateJoltage(line: []const u8, num_digits: usize) !u64 {

src/day4.zig

···
 const std = @import("std");
+const Allocator = std.mem.Allocator;
 const StringTokenIterator = std.mem.TokenIterator(u8, .scalar);
 
 const MAX_WIDTH = 137;
···
     return .{ .data = grid, .maxX = line_len, .maxY = i };
 }
 
-pub fn run(input: []u8) !void {
+pub fn run(_: Allocator, input: []u8) !struct { u64, u64 } {
     var lines = std.mem.tokenizeScalar(u8, input, '\n');
 
     const grid = try newGrid(&lines);
···
         }
     }
 
-    std.debug.print("Answer P1: {d}\n", .{answer1});
-    std.debug.print("Answer P2: {d}\n", .{answer2});
+    return .{ answer1, answer2 };
 }

src/day5.zig

···
     }
 };
 
-pub fn run(allocator: Allocator, input: []u8) !void {
+pub fn run(allocator: Allocator, input: []u8) !struct { u64, u64 } {
     var sections = std.mem.tokenizeSequence(u8, input, "\n\n");
 
     var answer1: u64 = 0;
···
         answer2 += item.high - item.low + 1;
     }
 
-    std.debug.print("Answer P1: {d}\n", .{answer1});
-    std.debug.print("Answer P2: {d}\n", .{answer2});
+    return .{ answer1, answer2 };
 }

src/day6.zig

···
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+pub fn run(allocator: Allocator, input: []u8) !void {
+    return .{ 0, 0 };
+}

src/main.zig

···
 const std = @import("std");
-const day1 = @import("./day1.zig");
-const day2 = @import("./day2.zig");
-const day3 = @import("./day3.zig");
-const day4 = @import("./day4.zig");
-const day5 = @import("./day5.zig");
+const days = .{
+    @import("./day1.zig"),
+    @import("./day2.zig"),
+    @import("./day3.zig"),
+    @import("./day4.zig"),
+    @import("./day5.zig"),
+};
 
 pub fn main() !void {
     var args = std.process.args();
···
     var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
     const allocator = gpa.allocator();
 
-    const day = try std.fmt.parseInt(u4, day_str, 10);
+    const day_num = try std.fmt.parseInt(u4, day_str, 10);
 
-    const input_path = try std.fmt.allocPrint(allocator, "inputs/day{d}{s}.txt", .{ day, test_str });
+    const input_path = try std.fmt.allocPrint(allocator, "inputs/day{d}{s}.txt", .{ day_num, test_str });
     defer allocator.free(input_path);
 
     const input_file = try std.fs.cwd().openFile(input_path, .{});
···
     const input_content = try reader.interface.allocRemaining(allocator, .unlimited);
     defer allocator.free(input_content);
 
-    switch (day) {
-        1 => try day1.run(input_content),
-        2 => try day2.run(input_content),
-        3 => try day3.run(input_content),
-        4 => try day4.run(input_content),
-        5 => try day5.run(allocator, input_content),
-        else => {},
+    inline for (days, 1..) |day, i| {
+        if (i == day_num) {
+            std.debug.print("Day {d}\n\n", .{i});
+
+            const answer1, const answer2 = try day.run(allocator, input_content);
+
+            std.debug.print("Answer P1: {d}\n", .{answer1});
+            std.debug.print("Answer P2: {d}\n", .{answer2});
+            break;
+        }
     }
 }