AoC 2023 Day 13

13.zig

const std = @import("std");
const print = std.debug.print;

const input_file_name = "inputs/13_test.txt";
// const input_file_name = "inputs/13.txt";
const input_data = blk: {
    @setEvalBranchQuota(300_000);
    var result: []const []const u8 = &.{};
    const input_file = @embedFile(input_file_name);
    var token = std.mem.splitSequence(u8, input_file, "\r\n");
    while (token.next()) |val| {
        result = result ++ [1][]const u8{val};
    }
    break :blk result;
};

fn findReflection_worked(mirror: [][]const u8) usize {
    // Part of code I took from python guy for check
    var result: usize = 0;

    const rows = mirror.len;
    const cols = mirror[0].len;

    for (0..cols - 1) |c| {
        var cnt: usize = 0;
        for (0..cols) |cc| {
            if (c < cc) continue;
            if (c + cc + 1 <= c - cc) continue;
            if (cols - 1 <= c + cc) continue;

            for (0..rows) |r| {
                if (mirror[r][c - cc] != mirror[r][c + cc + 1]) {
                    cnt += 1;
                }
            }
        }
        print("cnt {d}\n", .{cnt});
        if (cnt == 0) result += c + 1;
    }

    for (0..rows - 1) |r| {
        var cnt: usize = 0;
        for (0..rows) |rr| {
            if (r < rr) continue;
            if (r + rr + 1 <= r - rr) continue;
            if (rows - 1 <= r + rr) continue;

            for (0..cols) |c| {
                if (mirror[r - rr][c] != mirror[r + rr + 1][c]) {
                    cnt += 1;
                }
            }
        }
        print("cnt2 {d}\n", .{cnt});
        if (cnt == 0) result += (r + 1) * 100;
    }

    return result;
}

fn findReflection(mirror: [][]const u8) usize {
    var result: usize = 0;

    const rows = mirror.len;
    const cols = mirror[0].len;

    // Vertical divider of reflection
    for (0..cols - 1) |c| {
        var is_mirror: bool = true;
        const window = @min(c + 1, cols - (c + 1));
        for (0..window) |w| {
            if (!is_mirror) break;
            const c_from = c - w;
            const c_to = c + w + 1;
            for (0..rows) |r| {
                if (mirror[r][c_from] != mirror[r][c_to]) {
                    is_mirror = false;
                    break;
                }
            }
        }
        if (is_mirror) result += c + 1;
    }

    // Horisontal divider of reflection
    for (0..rows - 1) |r| {
        var is_mirror: bool = true;
        const window = @min(r + 1, rows - (r + 1));
        for (0..window) |w| {
            if (!is_mirror) break;
            const r_from = r - w;
            const r_to = r + w + 1;
            for (0..cols) |c| {
                if (mirror[r_from][c] != mirror[r_to][c]) {
                    is_mirror = false;
                    break;
                }
            }
        }
        if (is_mirror) result += (r + 1) * 100;
    }

    return result;
}

fn findSmudge(mirror: [][]const u8) usize {
    var result: usize = 0;

    const rows = mirror.len;
    const cols = mirror[0].len;

    // Vertical divider of reflection
    for (0..cols - 1) |c| {
        var diffs: usize = 0;
        const window = @min(c + 1, cols - (c + 1));
        for (0..window) |w| {
            const c_from = c - w;
            const c_to = c + w + 1;
            for (0..rows) |r| {
                if (mirror[r][c_from] != mirror[r][c_to]) {
                    diffs += 1;
                }
            }
        }
        if (diffs == 1) result += c + 1;
    }

    // Horisontal divider of reflection
    for (0..rows - 1) |r| {
        var diffs: usize = 0;
        const window = @min(r + 1, rows - (r + 1));
        for (0..window) |w| {
            const r_from = r - w;
            const r_to = r + w + 1;
            for (0..cols) |c| {
                if (mirror[r_from][c] != mirror[r_to][c]) {
                    diffs += 1;
                }
            }
        }
        if (diffs == 1) result += (r + 1) * 100;
    }

    return result;
}

fn part1() !usize {
    var result: usize = 0;
    result = 0;

    var j: usize = 0;
    for (input_data, 0..) |line, i| {
        if (line.len == 0 or i == input_data.len - 1) {
            const slide = if (i == input_data.len - 1) i + 1 else i;
            const mirror: [][]const u8 = @constCast(input_data[j..slide]);

            result += findReflection(mirror);

            j = i + 1;
        }
    }

    return result;
}

fn part2() !usize {
    var result: usize = 0;
    result = 0;

    var j: usize = 0;
    for (input_data, 0..) |line, i| {
        if (line.len == 0 or i == input_data.len - 1) {
            const slide = if (i == input_data.len - 1) i + 1 else i;
            const mirror: [][]const u8 = @constCast(input_data[j..slide]);

            result += findSmudge(mirror);

            j = i + 1;
        }
    }

    return result;
}

pub fn main() !void {
    var timer = try std.time.Timer.start();
    const part1_result = try part1();
    print("part 1 {d}    {d}ms\n", .{ part1_result, timer.lap() / std.time.ns_per_ms });

    const part2_result = try part2();
    print("part 2 {d}    {d}ms\n", .{ part2_result, timer.lap() / std.time.ns_per_ms });
}