Advent Of Code 2025 Day 7

const std = @import("std");

pub fn computePartTwo(space: [][]u8, allocator: std.mem.Allocator) !u64 {
    const rows = space.len;
    const cols = space[0].len;

    const cell_count = rows * cols;

    var dp = try allocator.alloc(u64, cell_count);
    @memset(dp, 0);

    var start_r: usize = 0;
    var start_c: usize = 0;
    var found = false;
    for (0..rows) |r| {
        for (0..cols) |c| {
            if (space[r][c] == 'S') {
                start_r = r;
                start_c = c;
                found = true;
                break;
            }
        }
        if (found) break;
    }
    if (!found) {
        allocator.free(dp);
        return 0;
    }

    dp[start_r * cols + start_c] = 1;

    var r: usize = start_r;
    while (r + 1 < rows) : (r += 1) {
        const next_row = r + 1;
        for (0..cols) |c| {
            const idx = r * cols + c;
            const count = dp[idx];
            if (count == 0) continue;

            const ch = space[r][c];

            if (ch == '^') {
                if (c > 0) dp[next_row * cols + (c - 1)] += count;
                if (c + 1 < cols) dp[next_row * cols + (c + 1)] += count;
            } else {
                dp[next_row * cols + c] += count;
            }
        }
    }

    var total: u64 = 0;
    const bottom_row = rows - 1;
    for (0..cols) |c| {
        total += dp[bottom_row * cols + c];
    }

    allocator.free(dp);
    return total;
}

fn advanceBeam(space: [][]u8, line_number: usize, splitters: *u16) void {
    const length = space[line_number].len;
    var idx: usize = 0;
    while (idx < length) : (idx += 1) {
        if (space[line_number][idx] == 'S' or space[line_number][idx] == '|') {
            if (space[line_number + 1][idx] == '^') {
                splitters.* += 1;
                space[line_number + 1][idx - 1] = '|';
                space[line_number + 1][idx + 1] = '|';
            } else {
                space[line_number + 1][idx] = '|';
            }
        }
    }
}

fn daySevenBothParts(stdout: *std.Io.Writer, allocator: std.mem.Allocator) !void {
    const file = try std.fs.cwd().openFile("data.txt", .{ .mode = .read_only });
    defer file.close();

    var file_buffer: [4096]u8 = undefined;
    var file_reader = file.reader(&file_buffer);
    const reader = &file_reader.interface;

    var splitters: u16 = 0;
    var list: std.ArrayList([]u8) = .empty;
    defer list.deinit(allocator);

    while (reader.takeDelimiterExclusive('\n')) |line| {
        reader.toss(1);

        const dupl = try allocator.dupe(u8, line);
        try list.append(allocator, dupl);
    } else |err| switch (err) {
        error.EndOfStream => {},
        else => return err,
    }

    const space = try list.toOwnedSlice(allocator);

    // We calculate timelines on clean space, because its faster
    const timelines = try computePartTwo(space, allocator);

    const steps = space.len - 1;
    for (0..steps) |step| {
        advanceBeam(space, step, &splitters);
    }

    try stdout.print("A tachyon beam is split a total of {d} times.\n", .{splitters});
    try stdout.flush();

    const day: u8 = 7;
    try stdout.print("--" ** 20 ++ "\n", .{});
    try stdout.print("Start of Day {d} Part 2\n", .{day});
    try stdout.print("--" ** 20 ++ "\n", .{});

    try stdout.print("Those {d} splits create {d} timelines.\n", .{ splitters, timelines });
    try stdout.flush();
}

pub fn main() !void {
    var stdout_buffer: [1024]u8 = undefined;
    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
    const stdout = &stdout_writer.interface;
    const day: u8 = 7;
    try stdout.print("Start of Day {d} Part 1\n", .{day});
    try stdout.print("--" ** 20 ++ "\n", .{});
    try stdout.flush();
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    const allocator = arena.allocator();
    try daySevenBothParts(stdout, allocator);
}