day_6

This is being solved by a recursive function:

If no “>” or similar character is found, return the 2D array. Otherwise, find that character, check the direction its pointing, and then update the grid:

If it is pointing “outside”, so “>” is at the right edge, etc., replace the character with “.”
If it is pointing at “.” or “X”, replace the arrow with “X” and the “.” with the arrow.
If it is pointing at “#”, rotate it by 90 degrees Then, call the function again with the updated grid.

This also could benefit from using the shared grid module - it also should transform the individual directions in their own types instead of always comparing strings. You can see these sort of ideas develop in the later solutions, for now, I’m a bit too lazy to refactor this. (Also it’s a nice snapshot in time of my gleam-learning journey)

Functions

check_grid_for_loop

</>

pub fn check_grid_for_loop(
  grid: Dict(#(Int, Int), String),
  guard: #(#(Int, Int), String),
) -> Bool

find_guard

</>

pub fn find_guard(
  grid: Dict(#(Int, Int), String),
) -> Result(#(#(Int, Int), String), Nil)

get_element_index

</>

pub fn get_element_index(
  row: List(a),
  element: a,
) -> Result(Int, Nil)

get_grid_permutations

</>

pub fn get_grid_permutations(
  grid: Dict(#(Int, Int), String),
  original_grid: Dict(#(Int, Int), String),
) -> List(Dict(#(Int, Int), String))

get_guard_column

</>

pub fn get_guard_column(
  grid: List(List(String)),
  guard_row: List(String),
) -> List(String)

get_guard_list

</>

pub fn get_guard_list(
  grid: List(List(String)),
  guard: String,
) -> List(String)

get_guard_trail

</>

pub fn get_guard_trail(guard_char: String) -> String

get_next_guard_pos

</>

pub fn get_next_guard_pos(
  guard: #(#(Int, Int), String),
) -> Result(#(Int, Int), Nil)

has_guard

</>

pub fn has_guard(grid: List(List(String))) -> Bool

is_forward_guard

</>

pub fn is_forward_guard(guard: String) -> Bool

is_vertical_guard

</>

pub fn is_vertical_guard(guard: String) -> Bool

main

</>

pub fn main() -> Nil

move_guard

</>

pub fn move_guard(
  grid: Dict(#(Int, Int), String),
  guard: #(#(Int, Int), String),
  target: #(Int, Int),
) -> Dict(#(Int, Int), String)

part_1

</>

pub fn part_1() -> Int

part_2

</>

pub fn part_2() -> Int

pretty_print

</>

pub fn pretty_print(
  grid: Dict(#(Int, Int), String),
) -> Dict(#(Int, Int), String)

rotate_guard

</>

pub fn rotate_guard(
  grid: Dict(#(Int, Int), String),
  guard: #(#(Int, Int), String),
) -> Dict(#(Int, Int), String)

rotate_guard_char

</>

pub fn rotate_guard_char(char: String) -> String

row_contains_guard

</>

pub fn row_contains_guard(row: List(String)) -> Bool

should_create_permutation

</>

pub fn should_create_permutation(
  grid: Dict(#(Int, Int), String),
  coords: #(Int, Int),
) -> Bool

solve_grid

</>

pub fn solve_grid(
  grid: Dict(#(Int, Int), String),
) -> Dict(#(Int, Int), String)

solve_grid_loops

</>

pub fn solve_grid_loops(
  grid: Dict(#(Int, Int), String),
  previously_seen_grids: List(Dict(#(Int, Int), String)),
) -> Result(Dict(#(Int, Int), String), Nil)

update_grid

</>

pub fn update_grid(
  grid: Dict(#(Int, Int), String),
  guard: #(#(Int, Int), String),
) -> Dict(#(Int, Int), String)

update_normalized_row

</>

pub fn update_normalized_row(row: List(String)) -> List(String)

will_loop

</>

pub fn will_loop(row: List(String)) -> Bool