jack's advent of code 2022 ramblings

given the sample input:

30373
25512
65332
33549
35390

assuming input is the above as one big string,

trees =
  input
  |> String.split("\n")
  |> Enum.map(fn row -> row |> String.graphemes() |> Enum.map(&String.to_integer/1) end)

split on newline, then take each row, convert it to characters, and then map those to integers

[
  [3, 0, 3, 7, 3],
  [2, 5, 5, 1, 2],
  [6, 5, 3, 3, 2],
  [3, 3, 5, 4, 9],
  [3, 5, 3, 9, 0]
]

basic 2d grid of trees

drawing

not required for problem solving, but just to make the output pretty :)

defmodule Draw do
  def grid(grid) do
    for row <- grid do
      for x <- row do
        if x, do: "X", else: "_"
      end
      |> Enum.join("")
    end
    |> Enum.join("\n")
  end
end

go over each row / item, depending on if that value is true or false, either print X or _, then join back together into one big string

utils

defmodule Quadcopter do
  def navigate(trees) do
    x = trees
    x_rev = x |> Enum.map(&Enum.reverse/1)

    y = trees |> Enum.zip() |> Enum.map(&Tuple.to_list/1)
    y_rev = y |> Enum.map(&Enum.reverse/1)

    [x, x_rev, y, y_rev]
  end

  def analyze_visibility(line) do
    Enum.map_reduce(line, -1, fn x, acc ->
      if x > acc do
        {false, x}
      else
        {true, acc}
      end
    end)
    |> elem(0)
  end

  def analyze_scenic_score(value, line, score \\ 0)

  def analyze_scenic_score(value, [compare | remainder], score) do
    if value > compare do
      analyze_scenic_score(value, remainder, score + 1)
    else
      score + 1
    end
  end

  def analyze_scenic_score(_value, [], score), do: score

  def analyze_scenic_score(line) do
    for {x, index} <- Enum.with_index(line) do
      seen = Enum.drop(line, index + 1)
      analyze_scenic_score(x, seen)
    end
  end

  def realign([x, x_rev, y, y_rev]) do
    x_rev = x_rev |> Enum.map(&Enum.reverse/1)
    y = y |> Enum.zip() |> Enum.map(&Tuple.to_list/1)
    y_rev = y_rev |> Enum.map(&Enum.reverse/1) |> Enum.zip() |> Enum.map(&Tuple.to_list/1)
    [x, x_rev, y, y_rev]
  end

  def combine_results(directions, combiner) do
    Enum.reduce(directions, fn direction, acc ->
      Enum.zip(direction, acc)
      |> Enum.map(&Tuple.to_list/1)
      |> Enum.map(&Enum.zip/1)
      |> Enum.map(fn line ->
        Enum.map(line, fn {a, b} -> combiner.(a, b) end)
      end)
    end)
  end
end

chonky module

first thing of note (and the entry point that takes in our tree structure) is navigate/1

def navigate(trees) do
  x = trees
  x_rev = x |> Enum.map(&Enum.reverse/1)

  y = trees |> Enum.zip() |> Enum.map(&Tuple.to_list/1)
  y_rev = y |> Enum.map(&Enum.reverse/1)

  [x, x_rev, y, y_rev]
end

this function returns a list of 4 different ‘views’ of the trees

- x is just the trees as-is

- x_rev is the columns in order, but with the rows reversed

- y is the trees zipped and put back together, which basically functions as rotating the grid such that each nested list represents not the x axis but a y axis

- y_rev the above y variable but flipped, so the y in the other direction as well

the code that actually figured out the visibility / scenic score acts on these lists

visibility

def analyze_visibility(line) do
  Enum.map_reduce(line, -1, fn x, acc ->
    if x > acc do
      {false, x}
    else
      {true, acc}
    end
  end)
  |> elem(0)
end

analyze_visibility/1 takes in a line (any one of the inner lists within the 4 lists we created with navigate/1)

it then does a map reduce to figure out if a tree is hidden or not

the accumulator defaults to -1 initially, therefore the first tree that is seen regardless of value will be considered higher than -1, therefore visible, and that value will be set as the current accumulator

the next tree that is seen will have the accumulator of the currently highest seen tree compared to itself, and if it is greater than, will be set to visible with the accumulator updated, or set as not visible, with the accumulator staying the same value (the highest tree seen so far does not update)

we discard the accumulator with |> elem(0), which returns a list of booleans for the given line on if something is visible or not

scenic score

def analyze_scenic_score(value, line, score \\ 0)

def analyze_scenic_score(value, [compare | remainder], score) do
  if value > compare do
    analyze_scenic_score(value, remainder, score + 1)
  else
    score + 1
  end
end

def analyze_scenic_score(_value, [], score), do: score

def analyze_scenic_score(line) do
  for {x, index} <- Enum.with_index(line) do
    seen = Enum.drop(line, index + 1)
    analyze_scenic_score(x, seen)
  end
end

analyze_scenic_score, with 4 different clauses, is used to calculate the scenic score of a given line

my first approach to writing this function was done using Enum.map_reduce, but i wasn’t able to get that to work (and aren’t sure if its even possible), and went with this recursive approach instead

def analyze_scenic_score(line) do
  for {x, index} <- Enum.with_index(line) do
    seen = Enum.drop(line, index + 1)
    analyze_scenic_score(x, seen)
  end
end

analyze_scenic_score/1 takes in the line, and iterates over it, dropping the lines up until the index + 1, so we only compare values that are ahead of x, rather than starting at the beginning of the line each time

we then pass it off to analyze_scenic_score/3 (third value, score, defaults to 0) to actually calculate the scenic score for the given point in the line

def analyze_scenic_score(value, [compare | remainder], score) do
  if value > compare do
    analyze_scenic_score(value, remainder, score + 1)
  else
    score + 1
  end
end

our recursion function analyze_scenic_score/3 will keep plucking items from the remainder of the list, and comparing it to the value

if the value is greater than the thing we are comparing against, we keep going with the value compared to the tail (the rest of the line), and increase our score by one

if we have a tree we are comparing against that is equal to or greater than or current value we just return score + 1 (this is still a tree we can see, therefore it is used in the scenic score)

def analyze_scenic_score(_value, [], score), do: score

there is also a base case for when we run out of trees, here we just pass back the score since there are no more trees to get points for

realign

def realign([x, x_rev, y, y_rev]) do
  x_rev = x_rev |> Enum.map(&Enum.reverse/1)
  y = y |> Enum.zip() |> Enum.map(&Tuple.to_list/1)
  y_rev = y_rev |> Enum.map(&Enum.reverse/1) |> Enum.zip() |> Enum.map(&Tuple.to_list/1)
  [x, x_rev, y, y_rev]
end

so navigate/1 took our grid, and made it 4 different but technically the same grids, but now for us to figure out the results we need to realign them, here is where the realign function comes in!

it still returns a list of 4 values, however, these 4 values will all be back onto the same orientation, therefore our next function comes in handy!

combine results

def combine_results(directions, combiner) do
  Enum.reduce(directions, fn direction, acc ->
    Enum.zip(direction, acc)
    |> Enum.map(&Tuple.to_list/1)
    |> Enum.map(&Enum.zip/1)
    |> Enum.map(fn line ->
      Enum.map(line, fn {a, b} -> combiner.(a, b) end)
    end)
  end)
end

combine results will take any number of ‘directions’ (such as our 4 aligned grids), and combine them back together, not before using the paseed in combiner function to combine lines from one ‘direction’ with another

part 1

visibility =
  trees
  |> Quadcopter.navigate()
  |> Enum.map(fn direction -> Enum.map(direction, &Quadcopter.analyze_visibility/1) end)
  |> Quadcopter.realign()
  |> Quadcopter.combine_results(&(&1 and &2))

Draw.grid(visibility) |> IO.write()

now its time to use the functions!

- take in the trees, use our navigate/1 function to split into the 4 directions

- map each direction, and then each line in each direction, over the analyze_visibility function

- realign the directions back together again

- combine them, with our combiner function being something that does an ’and’ between the two values this means if something says something isn’t visible, and something says it is, it will be assumed to be visible, but if both things agree on it not being visible, it will stay not visible

then, draw the grid for fun

_____
___X_
__X__
_X_X_
_____

yay!

count_of_not_hidden =
  visibility
  |> List.flatten()
  |> Enum.count(&(!&1)) # -> 21

count the not hidden values, basically everything that is not a x in the above drawing

part 2

scenic_scores =
  trees
  |> Quadcopter.navigate()
  |> Enum.map(fn direction -> Enum.map(direction, &Quadcopter.analyze_scenic_score/1) end)
  |> Quadcopter.realign()
  |> Quadcopter.combine_results(&(&1 * &2))

scenic_scores
|> List.flatten()
|> Enum.max() # -> 8

do the same as above, except map over the analyze_scenic_score/1 function, and use a combiner that multiplies the values together instead of ’and’

then, flatten the list of values, and get the max

the full solution can be found [here]