AoC/2024/18/index2.ts

const fs = require('fs');

const input = fs.readFileSync(__dirname + '/input.txt', 'utf8').split("\n");

interface Coord {
    x: number,
    y: number,
};

enum Dir {
    Up,
    Right,
    Down,
    Left,
};

const map: Array<Array<string|number>> = [];

const width = 71;
const height = 71;

for (let y = 0; y < height; y++) {
    if (!map[y]) {
        map[y] = [];
    }
    for (let x = 0; x < width; x++) {
        map[y][x] = '.';
    }
}

for (let i = 0; i < 1024; i++) {
    const [x, y] = input[i].split(',').map((st: string) => parseInt(st));
    map[y][x] = '#'
}

function get(pos: Coord): string|number {
    if (map[pos.y] && map[pos.y][pos.x]) {
        return map[pos.y][pos.x];
    }
    return '#';
}

function set(pos: Coord, val: string|number): void {
    map[pos.y][pos.x] = val;
}

function nextDir(dir: Dir): Dir {
    const directions = [Dir.Up, Dir.Right, Dir.Down, Dir.Left];
    const i = (directions.indexOf(dir) + 1) % directions.length;
    return directions[i];
}
function prevDir(dir: Dir): Dir {
    const directions = [Dir.Up, Dir.Right, Dir.Down, Dir.Left];
    const i = directions.indexOf(dir) - 1;
    if (i < 0) {
        return directions[directions.length - 1];
    }
    return directions[i];
}

function printMap(path: Array<Coord> = []) {
    const mapClone = map.slice().map((row: Array<string|number>) => row.slice());
    path.forEach(({ x, y }) => {
        mapClone[y][x] = 'O';
    });
    console.log(mapClone.map((row: Array<string|number>) => row.map((c) => typeof c === 'number' ? '.' : c).join('')).join("\n"));
    console.log("\n");
}

function nextCoord(pos: Coord, direction: Dir): Coord {
    return direction === Dir.Up ? { x: pos.x, y: pos.y - 1 }
        : (direction === Dir.Right ? { x: pos.x + 1, y: pos.y }
            : (direction === Dir.Down ? { x: pos.x, y: pos.y + 1 } : { x: pos.x - 1, y: pos.y })
        );
}

function isDeadEnd(pos: Coord): boolean {
    if ((pos.x === 0 && pos.y === 0) || (pos.x === width - 1 && pos.y === width - 1)) {
        return false;
    }
    const adjs = [Dir.Up, Dir.Right, Dir.Down, Dir.Left].map((dir) => get(nextCoord(pos, dir))).join('');
    return adjs === '###.'
        || adjs === '##.#'
        || adjs === '#.##'
        || adjs === '.###';
}

function fillDeadEnd(pos: Coord): void {
    set(pos, '#')
    for (let dir of [Dir.Up, Dir.Right, Dir.Down, Dir.Left]) {
        const next = nextCoord(pos, dir);
        if (get(next) === '.') {
            if (isDeadEnd(next)) {
                fillDeadEnd(next);
            }
        }
    };
}
printMap();

for (let y = 0; y < height; y++) {
    for (let x = 0; x < width; x++) {
        const pos = { x, y };
        const char = get(pos);
        if (char !== '.') {
            continue;
        }
        if (isDeadEnd(pos)) {
            fillDeadEnd(pos);
        }
    }
}

printMap();

for (let i = 1025; i < input.length; i++) {
    const byte = input[i].split(',').map((c: string) => parseInt(c));
    set({ x: byte[0], y: byte[1] }, '#');

    for (let y = 0; y < height; y++) {
        for (let x = 0; x < width; x++) {
            const pos = { x, y };
            let char = get(pos);
            if (typeof char === 'number') {
                set(pos, '.');
            }
        }
    }

    let finished = false;

    function getScoresAfterPosition(pos: Coord, dir: Dir, path: Array<Coord> = []): void {
        if (finished) {
            return;
        }
        [dir, nextDir(dir), prevDir(dir)].forEach((newDir, i) => {
            if (finished) {
                return;
            }
            const next = nextCoord(pos, newDir);
            if (next.x === width - 1 && next.y === height - 1) {
                finished = true;
                return;
            }
            const nextCell = get(next);
            if (nextCell !== '#' && (typeof nextCell !== 'number' || nextCell > path.length) && !path.find(({ x, y }) => next.x === x && next.y === y)) {
                set(next, path.length);
                getScoresAfterPosition(next, newDir, [...path, next]);
            }
        });

        return;
    }

    getScoresAfterPosition({ x: 0, y: 0 }, Dir.Right, [{ x: 0, y: 0 }]);

    console.log(i, byte);
    printMap();
    if (!finished) {
        console.log('blocked');
        break;
    }
}