AOC 2022 13

1.exs

test_pair = fn 
  [nil, _], _ -> true
  [_, nil], _ -> false
  [left, right], _ when is_integer(left) and is_integer(right) -> 
    cond do
      left == right -> nil
      left < right -> true
      right < left -> false
    end
  pair = [left, right], self when is_list(left) and is_list(right) -> 
    pair
    |> Enum.map(fn list -> 
      missing = Enum.max([length(left), length(right)]) - length(list)
      
      list ++ List.duplicate(nil, missing)
    end)
    |> List.zip()
    |> Enum.reduce_while(nil, fn {left, right}, valid -> 
      case self.([left, right], self) do
        nil -> {:cont, valid}
        valid -> {:halt, valid}
      end
    end)
  pair, self -> pair |> Enum.map(&List.wrap/1) |> self.(self)
end

System.argv()
|> List.first()
|> File.read!()
|> String.split("\n\n", trim: true)
|> Enum.with_index()
|> Enum.reduce(0, fn {pair, idx}, total -> 
  valid = 
    pair 
    |> String.split("\n", trim: true)
    |> Enum.map(& &1 |> Code.eval_string() |> elem(0))
    |> test_pair.(test_pair)
    
  if valid, do: total + idx + 1, else: total
end)
|> IO.inspect

2.exs

test_pair = fn 
  [nil, _], _ -> true
  [_, nil], _ -> false
  [left, right], _ when is_integer(left) and is_integer(right) -> 
    cond do
      left == right -> nil
      left < right -> true
      right < left -> false
    end
  pair = [left, right], self when is_list(left) and is_list(right) -> 
    pair
    |> Enum.map(fn list -> 
      missing = Enum.max([length(left), length(right)]) - length(list)
      
      list ++ List.duplicate(nil, missing)
    end)
    |> List.zip()
    |> Enum.reduce_while(nil, fn {left, right}, valid -> 
      case self.([left, right], self) do
        nil -> {:cont, valid}
        valid -> {:halt, valid}
      end
    end)
  pair, self -> pair |> Enum.map(&List.wrap/1) |> self.(self)
end

System.argv()
|> List.first()
|> File.read!()
|> String.split("\n", trim: true)
|> Enum.map(& &1 |> Code.eval_string() |> elem(0))
|> Enum.concat([[[2]], [[6]]])
|> Enum.sort(fn a, b -> test_pair.([a, b], test_pair) == true end)
|> Enum.with_index()
|> Enum.flat_map(fn 
  {divider, idx} when divider in [[[2]], [[6]]] -> [idx + 1]
  _ -> []
end)
|> Enum.product()
|> IO.inspect