Advent of Code #16 (in Crystal)

Today's puzzle didn't seem particularly challenging. I figured that I would have to keep track of cycles and that it was possible to visit a mirror or splitter from multiple sides. But I ran into a snag during part 1 that slowed me down for over an hour. My code worked perfectly fine on the examples and on any scenario that I could think of, but it failed on my input.

Turns out that I was just branching on the splitters before counting them in the path, so my answer was lower than it should have been for the input. Conveniently, the "dumb thing" for part 2 worked fine and gave an answer in just a few minutes.

In my solution, I used enums for the first time. I love that case does exhaustive checking for enums, and I think it made for pretty readable code. Here it is:

input = File.read("input").strip

grid = input.split("\n").map(&.chars)

enum Direction
  Up
  Down
  Left
  Right
end

def move(position, direction)
  row, col = position
  case direction
    in .up? then {row - 1, col}
    in .down? then {row + 1, col}
    in .left? then {row, col - 1}
    in .right? then {row, col + 1}
  end
end

def back_slash(direction)
  case direction
    in .up? then Direction::Left
    in .down? then Direction::Right
    in .left? then Direction::Up
    in .right? then Direction::Down
  end
end

def forward_slash(direction)
  case direction
    in .up? then Direction::Right
    in .down? then Direction::Left
    in .left? then Direction::Down
    in .right? then Direction::Up
  end
end

def in_grid(position, grid)
  row, col = position
  row >= 0 && row < grid.size && col >= 0 && col < grid[row].size
end

def shine(grid, path, start, start_direction)
  edge = false
  position = start
  row, col = position
  direction = start_direction
  while in_grid(position, grid) && !path.includes?({position, direction})
    row, col = position
    path << {position, direction}
    case grid[row][col]
    when '\\'
      direction = back_slash(direction)
    when '/'
      direction = forward_slash(direction)
    when '-'
      if direction.up? || direction.down?
        shine(grid, path, position, Direction::Left)
        shine(grid, path, position, Direction::Right)
        break
      end
    when '|'
      if direction.left? || direction.right?
        shine(grid, path, position, Direction::Up)
        shine(grid, path, position, Direction::Down)
        break
      end
    else
    end
    position = move(position, direction)
  end
end

part1 = begin
  path = [] of Tuple(Tuple(Int32, Int32), Direction)
  shine(grid, path, {0, 0}, Direction::Right)
  path.map(&.[0]).uniq.size  
end

puts part1

part2 = begin
  max = 0
  (0...110).each do |i|
    path = [] of Tuple(Tuple(Int32, Int32), Direction)
    shine(grid, path, {0, i}, Direction::Down)
    max = Math.max(max, path.map(&.[0]).uniq.size)
  end
  (0...110).each do |i|
    path = [] of Tuple(Tuple(Int32, Int32), Direction)
    shine(grid, path, {109, i}, Direction::Up)
    max = Math.max(max, path.map(&.[0]).uniq.size)
  end
  (0...110).each do |i|
    path = [] of Tuple(Tuple(Int32, Int32), Direction)
    shine(grid, path, {i, 0}, Direction::Right)
    max = Math.max(max, path.map(&.[0]).uniq.size)
  end
  (0...110).each do |i|
    path = [] of Tuple(Tuple(Int32, Int32), Direction)
    shine(grid, path, {i, 109}, Direction::Left)
    max = Math.max(max, path.map(&.[0]).uniq.size)
  end
  max  
end

puts part2