advent-of-code-2023/day13/main.zig

const std = @import("std");

pub fn main() !void {
    const content = @embedFile("data.txt");

    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();

    // yo dog
    var grids = std.ArrayList(std.ArrayList(std.ArrayList(u8))).init(allocator);
    var sections = std.mem.split(u8, content, "\n\n");

    while (sections.next()) |section| {
        var lines = std.mem.split(u8, section, "\n");
        var gridArrayList = std.ArrayList(std.ArrayList(u8)).init(allocator);

        while (lines.next()) |line| {
            if (line.len < 1) {
                break;
            }

            var lineArrayList = std.ArrayList(u8).init(allocator);
            for (line) |char| {
                try lineArrayList.append(char);
            }
            try gridArrayList.append(lineArrayList);
        }

        try grids.append(gridArrayList);
    }

    var part1: usize = 0;
    var part2: usize = 0;

    for (grids.items) |grid| {
        const transposed = try transpose(grid, allocator);

        const rowReflection = findRowReflection(grid);
        const columnReflection = findRowReflection(transposed);

        part1 += 100 * (rowReflection orelse 0) + (columnReflection orelse 0);

        const rowSmudge = findSmudge(grid);
        const colSmudge = findSmudge(transposed);

        part2 += 100 * (rowSmudge orelse 0) + (colSmudge orelse 0);
    }

    std.debug.print("part1 {d}\n", .{part1});
    std.debug.print("part2 {d}\n", .{part2});
}

fn findSmudge(grid: std.ArrayList(std.ArrayList(u8))) ?usize {
    const height = grid.items.len;

    for (1..height) |row| {
        var numDiff: u8 = 0;

        for (1..row + 1) |d| {
            const row1 = grid.items[row - d];
            const row2 = grid.items[row + d - 1];

            for (0..row1.items.len) |i| {
                if (row1.items[i] != row2.items[i]) {
                    numDiff += 1;
                }
            }
            if (numDiff > 1) {
                break;
            }

            if (row - d == 0 or row + d == height) {
                break;
            }
        }

        if (numDiff == 1) {
            return row;
        }
    }
    return null;
}

fn findRowReflection(grid: std.ArrayList(std.ArrayList(u8))) ?usize {
    const height = grid.items.len;

    for (1..height) |row| {
        for (1..row + 1) |d| {
            const row1 = grid.items[row - d];
            const row2 = grid.items[row + d - 1];
            if (!std.mem.eql(u8, row1.items, row2.items)) {
                break;
            }

            if (row - d == 0 or row + d == height) {
                return row;
            }
        }
    }
    return null;
}

fn transpose(grid: std.ArrayList(std.ArrayList(u8)), allocator: std.mem.Allocator) !std.ArrayList(std.ArrayList(u8)) {
    const height = grid.items.len;
    const width = grid.items[0].items.len;

    var grid2 = std.ArrayList(std.ArrayList(u8)).init(allocator);
    for (0..width) |c| {
        var row = std.ArrayList(u8).init(allocator);

        for (0..height) |r| {
            try row.append(grid.items[r].items[c]);
        }

        try grid2.append(row);
    }

    return grid2;
}