feat(day20): refactor to use levels

Author: coderbyheart

day20/transportingMazeSolver.ts

@@ -7,6 +7,7 @@ export type Location = {
 	pos: Position
 	path: Position[]
 	status: LocationStatus
+	level: number
 }
 
 export enum Tile {
@@ -25,10 +26,21 @@ export enum DIRECTION {
 const START = 'AA'
 const END = 'ZZ'
 
-const isSafe = (maze: MazeString, visited: boolean[], pos: Position) => {
+type Visited = {
+	[key: number]: {
+		[key: number]: boolean
+	}
+}
+
+const isSafe = (
+	maze: MazeString,
+	visited: Visited,
+	pos: Position,
+	level: number,
+) => {
 	const p = pos.y * maze.width + pos.x
 	if (maze.maze[p] === undefined) return false
-	if (visited[p]) return false
+	if (visited[level][p]) return false
 	if (maze.maze[p] !== Tile.PATH) return false
 	return true
 }
@@ -37,28 +49,32 @@ const equals = (a: Position, b: Position) => a.x === b.x && a.y === b.y
 
 const status = (
 	maze: MazeString,
-	visited: boolean[],
-	location: Position,
+	visited: Visited,
+	pos: Position,
+	level: number,
 ): LocationStatus => {
-	if (!isSafe(maze, visited, location)) return 'Blocked'
+	if (!isSafe(maze, visited, pos, level)) return 'Blocked'
 	return 'Valid'
 }
 
 const createLocation = (
 	maze: MazeString,
-	visited: boolean[],
+	visited: Visited,
 	location: Location,
 ) => (pos: Position): Location => ({
+	level: location.level,
 	pos: pos,
 	path: [...location.path, location.pos],
-	status: status(maze, visited, pos),
+	status: status(maze, visited, pos, location.level),
 })
 
 const exploreInDirection = (
 	maze: MazeString,
-	visited: boolean[],
+	visited: Visited,
 	portals: Portal[],
 	location: Location,
+	// whether to apply recursive rules
+	recursive = false,
 ) => (direction: DIRECTION): Location => {
 	let newLocation: Location
 	const cl = createLocation(maze, visited, location)
@@ -78,25 +94,100 @@ const exploreInDirection = (
 	}
 
 	if (newLocation.status === 'Valid') {
-		visited[newLocation.pos.y * maze.width + newLocation.pos.x] = true
+		visited[newLocation.level][
+			newLocation.pos.y * maze.width + newLocation.pos.x
+		] = true
 		// Is this a portal?
 		const portal = portals.find(({ pos }) => equals(pos, newLocation.pos))
 		if (portal) {
-			// Is this the last portal
-			if (portal.label === END) {
-				return {
-					...newLocation,
-					status: 'Target',
-				}
-			}
 			const pair = portals.find(
 				p => p !== portal && p.label === portal.label,
 			) as Portal
-			visited[pair.pos.y * maze.width + pair.pos.x] = true
-			return {
-				pos: pair.pos,
-				path: [...location.path, location.pos, portal.pos],
-				status: 'Valid',
+			if (recursive) {
+				// When you enter the maze, you are at the outermost level (0);
+				// when at the outermost level, only the outer labels AA and ZZ
+				// function (as the start and end, respectively); all other outer
+				// labeled tiles are effectively walls. At any other level,
+				// AA and ZZ count as walls, but the other outer labeled tiles
+				// bring you one level outward.
+				if (location.level === 0) {
+					// Outermost level
+					if (portal.label === END) {
+						// ZZ is accessible
+						return {
+							...newLocation,
+							status: 'Target',
+						}
+					}
+					// Outer portals are walls at outermost level
+					if (portal.isOuter) {
+						return {
+							...newLocation,
+							status: 'Blocked',
+						}
+					} else {
+						// Inner portal takes you one level deeper
+						if (visited[newLocation.level] === undefined) {
+							visited[newLocation.level] = []
+						}
+						visited[newLocation.level + 1][
+							pair.pos.y * maze.width + pair.pos.x
+						] = true
+						return {
+							pos: pair.pos,
+							path: [...location.path, location.pos, portal.pos],
+							status: 'Valid',
+							level: newLocation.level + 1,
+						}
+					}
+				} else {
+					// Other level
+					if (portal.label === END) {
+						// ZZ is not accessible
+						return {
+							...newLocation,
+							status: 'Blocked',
+						}
+					}
+					if (portal.isOuter) {
+						// Outer portal takes you one level up
+						visited[newLocation.level - 1][
+							pair.pos.y * maze.width + pair.pos.x
+						] = true
+						return {
+							pos: pair.pos,
+							path: [...location.path, location.pos, portal.pos],
+							status: 'Valid',
+							level: newLocation.level - 1,
+						}
+					} else {
+						// Inner portal takes you one level deeper
+						visited[newLocation.level + 1][
+							pair.pos.y * maze.width + pair.pos.x
+						] = true
+						return {
+							pos: pair.pos,
+							path: [...location.path, location.pos, portal.pos],
+							status: 'Valid',
+							level: newLocation.level + 1,
+						}
+					}
+				}
+			} else {
+				// Is this the last portal
+				if (portal.label === END) {
+					return {
+						...newLocation,
+						status: 'Target',
+					}
+				}
+				visited[newLocation.level][pair.pos.y * maze.width + pair.pos.x] = true
+				return {
+					pos: pair.pos,
+					path: [...location.path, location.pos, portal.pos],
+					status: 'Valid',
+					level: newLocation.level,
+				}
 			}
 		}
 	}
@@ -109,28 +200,39 @@ export type MazeString = {
 	width: number
 }
 
-export const transportingMazeSolver = (maze: string): Location | undefined => {
+export const transportingMazeSolver = (
+	maze: string,
+	recursive = false,
+): Location | undefined => {
 	const width = maze.indexOf('\n')
 	const mazeString: MazeString = {
 		width,
 		maze: maze.trimEnd().replace(/\n/g, ''),
 	}
 	const portals = findPortals(maze)
-	const visited = [] as boolean[]
+	const visited = [] as Visited
+	visited[0] = []
 
 	const startPos = portals.find(({ label }) => label === START) as Portal
 	const queue = [
 		{
 			path: [],
 			pos: startPos.pos,
 			status: 'Start',
+			level: 0,
 		},
 	] as Location[]
-	visited[startPos.pos.y * width + startPos.pos.x] = true
+	visited[0][startPos.pos.y * width + startPos.pos.x] = true
 
 	while (queue.length > 0) {
 		const location = queue.shift() as Location
-		const e = exploreInDirection(mazeString, visited, portals, location)
+		const e = exploreInDirection(
+			mazeString,
+			visited,
+			portals,
+			location,
+			recursive,
+		)
 
 		// Up
 		const up = e(DIRECTION.UP)