adventofcode2025/day7/zig/main.zig

const std = @import("std");

const Tile = enum {
    start,
    empty,
    splitter,
};

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();

    var stdin_buffer: [4096]u8 = undefined;
    var stdin_reader = std.fs.File.stdin().reader(&stdin_buffer);

    const stdin = &stdin_reader.interface;

    const allocator = gpa.allocator();
    var map = try std.ArrayList(std.ArrayList(Tile)).initCapacity(allocator, 1);
    defer map.deinit(allocator);

    while (try stdin.takeDelimiter('\n')) |line| {
        var row = try std.ArrayList(Tile).initCapacity(allocator, 1);

        for (line) |char| {
            switch (char) {
                'S' => {
                    try row.append(allocator, Tile.start);
                },
                '.' => {
                    try row.append(allocator, Tile.empty);
                },
                '^' => {
                    try row.append(allocator, Tile.splitter);
                },
                else => unreachable,
            }
        }

        try map.append(allocator, row);
    }

    var start_x: usize = 0;
    for (map.items[0].items, 0..) |tile, i| {
        if (tile == Tile.start) {
            start_x = i;
            break;
        }
    }

    var beammap = try std.ArrayList(std.ArrayList(u64)).initCapacity(allocator, 1);
    defer beammap.deinit(allocator);

    for (0..map.items.len) |_| {
        var row = try std.ArrayList(u64).initCapacity(allocator, 1);

        for (0..map.items[0].items.len) |_| {
            try row.append(allocator, 0);
        }

        try beammap.append(allocator, row);
    }

    beammap.items[0].items[start_x] = 1;

    var task1: u32 = 0;

    for (beammap.items, 0..) |beamrow, i| {
        for (beamrow.items, 0..) |has_beam, j| {
            if (has_beam > 0 and map.items[i].items[j] == Tile.splitter) {
                if (j != 0) {
                    beammap.items[i].items[j - 1] += beammap.items[i].items[j];
                }
                if (j < beamrow.items.len - 1) {
                    beammap.items[i].items[j + 1] += beammap.items[i].items[j];
                }
                beammap.items[i].items[j] = 0;
                task1 += 1;
            }
        }

        // Copy beams to next row
        if (i == beammap.items.len - 1) {
            continue;
        }

        for (0..beamrow.items.len) |j| {
            beammap.items[i + 1].items[j] = beammap.items[i].items[j];
        }
    }

    var task2: u64 = 0;
    for (beammap.items[beammap.items.len - 1].items) |n| {
        task2 += n;
    }

    std.debug.print("{d}\n", .{task1});
    std.debug.print("{d}\n", .{task2});

    for (map.items) |*row| {
        row.deinit(allocator);
    }

    for (beammap.items) |*row| {
        row.deinit(allocator);
    }
}