Solve day 6

2024/day01/part1.ts

@@ -6,7 +6,7 @@ import {
 	words,
 	mapToInt,
 	sort,
-    self,
+	self,
 } from '@helper';
 
 const input = await loadData();

2024/day06/lib.ts

@@ -0,0 +1,51 @@
+import { applyOffset, Coordinate } from '@helper';
+import { ORTHONAL_OFFSETS } from '@constants';
+
+export type Direction = 'up' | 'down' | 'right' | 'left';
+
+export const nextDirection = (direction: Direction): Direction => {
+	const mappings: Record<Direction, Direction> = {
+		up: 'right',
+		right: 'down',
+		down: 'left',
+		left: 'up',
+	};
+	return mappings[direction];
+};
+
+export const offsetForDirection = (direction: Direction) =>
+	({
+		up: ORTHONAL_OFFSETS.bottom,
+		down: ORTHONAL_OFFSETS.top,
+		left: ORTHONAL_OFFSETS.left,
+		right: ORTHONAL_OFFSETS.right,
+	})[direction];
+
+export const walk = (
+	matrix: string[][],
+	current: Coordinate,
+	currentDirection: Direction,
+): [Coordinate, Direction][] => {
+	const potentialStep = applyOffset(
+		current,
+		offsetForDirection(currentDirection),
+	);
+	const valueAtNextStep = (matrix[potentialStep.row] ?? [])[potentialStep.col];
+
+	if (!valueAtNextStep) {
+		return [[current, currentDirection]];
+	}
+
+	const direction =
+		valueAtNextStep === '#'
+			? nextDirection(currentDirection)
+			: currentDirection;
+
+	const walked = walk(
+		matrix,
+		valueAtNextStep === '#' ? current : potentialStep,
+		direction,
+	);
+
+	return [[current, direction], ...walked];
+};

2024/day06/part1.ts

@@ -0,0 +1,31 @@
+import {
+	loadData,
+	findItemCoordinates,
+	lines,
+	uniqueBy,
+	setValueAtCord,
+} from '@helper';
+import { walk } from './lib';
+
+const input = await loadData();
+const matrix = lines(input, (l) => l.split('') as ('#' | '.' | '^')[]);
+
+const uniqueCoords = uniqueBy(
+	walk(matrix, findItemCoordinates(matrix, '^')!, 'up'),
+	([a], [b]) => a.col === b.col && a.row === b.row,
+);
+
+if (Bun.env.DATA === 'debug') {
+	const stringMatrix = uniqueCoords.reduce<string[][]>(
+		(acc, [coord, dir]) =>
+			setValueAtCord(
+				acc,
+				coord,
+				{ up: '↑', down: '↓', left: '←', right: '→' }[dir],
+			),
+		matrix,
+	);
+	console.log(stringMatrix.map((line) => line.join('')).join('\n'));
+}
+
+console.log(uniqueCoords.length);

2024/day06/part2.ts

@@ -0,0 +1,76 @@
+import {
+	loadData,
+	applyOffset,
+	Coordinate,
+	findItemCoordinates,
+	lines,
+	setValueAtCord,
+	uniqueBy,
+} from '@helper';
+import { nextDirection, offsetForDirection, walk } from './lib';
+
+type Direction = 'up' | 'down' | 'right' | 'left';
+
+const input = await loadData();
+const matrix = lines(input, (l) => l.split('') as ('#' | '.' | '^')[]);
+
+const hasLoop = (
+	matrix: string[][],
+	current: Coordinate,
+	currentDirection: Direction,
+	visited = new Set<string>(),
+): boolean => {
+	const state = `${current.row},${current.col},${currentDirection}`;
+	if (visited.has(state)) {
+		return true;
+	}
+	visited.add(state);
+
+	const potentialStep = applyOffset(
+		current,
+		offsetForDirection(currentDirection),
+	);
+	const valueAtNextStep = (matrix[potentialStep.row] ?? [])[potentialStep.col];
+
+	if (!valueAtNextStep) {
+		return false;
+	}
+
+	const direction =
+		valueAtNextStep === '#'
+			? nextDirection(currentDirection)
+			: currentDirection;
+
+	return hasLoop(
+		matrix,
+		valueAtNextStep === '#' ? current : potentialStep,
+		direction,
+		visited,
+	);
+};
+
+const obstacleCoordinates = uniqueBy(
+	walk(matrix, findItemCoordinates(matrix, '^')!, 'up').map(
+		([coord, direction]) => {
+			return applyOffset(coord, offsetForDirection(direction));
+		},
+	),
+	(a, b) => a.col === b.col && a.row === b.row,
+);
+
+const loopingMatrixes = obstacleCoordinates.filter((obstacleCord) => {
+	try {
+		const newMatrix = setValueAtCord(matrix, obstacleCord, '#');
+
+		const loopFound = hasLoop(
+			newMatrix,
+			findItemCoordinates(newMatrix, '^')!,
+			'up',
+		);
+		return loopFound;
+	} catch {
+		return false;
+	}
+});
+
+console.log(loopingMatrixes.length);

constants/offset.ts

@@ -1,6 +1,6 @@
 type Offset = [number, number]
 
-export const ORTHONAL_OFFSETS: Record<string, Offset> = {
+export const ORTHONAL_OFFSETS: Record<"top" | "bottom" | "left" | "right", Offset> = {
 	top: [0, 1],
 	bottom: [0, -1],
 	left: [-1, 0],

helpers/index.ts

@@ -13,13 +13,13 @@ import { loadData } from './loadData';
 import { replaceMultiple } from './replaceAll';
 import { mapValues } from './objectMap';
 import { getKeyByValue } from './getKeyByValue';
-import { unique } from './unique';
 import { isNum, isDigit } from './isNum';
 import { removeConsecutiveNumbers } from './removeConsecutiveNumbers';
 import { findAllIndexes } from './findAllIndexes';
 import { findDuplicates } from './findDuplicates';
 import { lines } from './lines';
 import { words } from './words';
+export * from './unique';
 export * from './sum';
 export * from './isSorted';
 export * from './quickSelect';
@@ -54,7 +54,6 @@ export {
 	replaceMultiple,
 	mapValues,
 	getKeyByValue,
-	unique,
 	isNum,
 	isDigit,
 	removeConsecutiveNumbers,

helpers/unique.ts

@@ -11,3 +11,13 @@
  */
 export const unique = <T extends unknown>(array: T[]): T[] =>
 	array.filter((value, index, self) => self.indexOf(value) === index);
+
+export const uniqueBy = <T>(arr: T[], isEqual: (val1: T, val2: T) => boolean): T[] => {
+	return arr.reduce((unique: T[], current: T) => {
+		const isDuplicate = unique.some((existing) => isEqual(existing, current));
+		if (!isDuplicate) {
+			unique.push(current);
+		}
+		return unique;
+	}, []);
+};

input/2024/day06.debug

@@ -0,0 +1,10 @@
+....#.....
+.........#
+..........
+..#.......
+.......#..
+..........
+.#..^.....
+........#.
+#.........
+......#...

package.json

@@ -1,7 +1,6 @@
 {
 	"name": "adventofcode",
 	"module": "index.ts",
-	"type": "module",
 	"devDependencies": {
 		"bun-types": "latest",
 		"prettier": "^3.1.0"
@@ -12,5 +11,6 @@
 	"scripts": {
 		"solve": "./runNewest",
 		"format": "prettier --write ."
-	}
+	},
+	"type": "module"
 }

tests/helpers/unique.test.ts

@@ -1,7 +1,13 @@
 import { expect, test } from 'bun:test';
-import { unique } from '@helper';
+import { unique, uniqueBy } from '@helper';
 
-test('sum', () => {
+test('unique', () => {
 	expect(unique([1, 1, 1, 1, 1, 1, 2])).toEqual([1, 2]);
 	expect(unique([])).toEqual([]);
 });
+
+test('uniqueBy', () => {
+	expect(
+		uniqueBy([{ a: 1 }, { a: 2 }, { a: 3 }, { a: 1 }], (a, b) => a.a === b.a),
+	).toEqual([{ a: 1 }, { a: 2 }, { a: 3 }]);
+});