maybe you will like my way of parsing the input?

      File.read!("day_5.txt")
      |> String.split(["\n", ",", " -> "], trim: true)
      |> Enum.map(&String.to_integer/1)
      |> Enum.chunk_every(4)
      |> Enum.map(&List.to_tuple/1)

We can split the file in all the special content we have, and then just take numbers 4 at a time. No need to nest anything

My solution

Today was significatively simpler than yesterday, but I had to remember my vector algebra
To calculate the intermediate points, I used:

  def fill_points({x1,y1,x2,y2}) do
    {dx, dy} = {x2 - x1, y2 - y1}
    slope = {step(dx), step(dy)}
    do_fill({x1, y1}, {x2, y2}, slope, [])
  end

  defp step(0), do: 0
  defp step(x) when x > 0, do: 1
  defp step(x) when x < 0, do: -1

  defp do_fill(point, point, _slope, acc) do
    [point | acc]
  end

  defp do_fill({x1, y1} = point, end_point, {dx, dy} = slope, acc) do
    new_point = {x1 + dx, y1 + dy}
    do_fill(new_point, end_point, slope, [point | acc])
  end

IO.puts would work, I think:

iex(5)> input = "1.1...11.\n.111...2...\n...2.1.111.\n...1.2.2...\n.112313211\n...1.2...\n...1...1...\n.1...1...\n1...1.\n222111..."
iex(6)> IO.puts input
1.1...11.
.111...2...
...2.1.111.
...1.2.2...
.112313211
...1.2...
...1...1...
.1...1...
1...1.
222111...

Here’s my take:

defmodule Y2021.Day05 do
  def p1 do
    AOC.Input.stream("2021/day05.txt", &parse_seg/1)
    |> Stream.filter(fn [x1, y1, x2, y2] -> x1 == x2 || y1 == y2 end)
    |> count_overlap()
  end

  def p2 do
    AOC.Input.stream("2021/day05.txt", &parse_seg/1)
    |> count_overlap()
  end

  defp parse_seg(line) do
    Regex.run(~r/(\d+),(\d+) -> (\d+),(\d+)/, line, capture: :all_but_first)
    |> Enum.map(&String.to_integer/1)
  end

  defp count_overlap(segs) do
    segs
    |> Stream.flat_map(fn [x1, y1, x2, y2] ->
      max_step = max(abs(x2 - x1), abs(y2 - y1))
      dx = div(x2 - x1, max_step)
      dy = div(y2 - y1, max_step)

      Stream.iterate({x1, y1}, fn {x, y} -> {x + dx, y + dy} end)
      |> Stream.take(max_step + 1)
      |> Enum.to_list()
    end)
    |> Enum.frequencies()
    |> Enum.count(fn {_, count} -> count > 1 end)
  end
end

full file

Wow, today was an absolute breeze (looking at you Day 4…)

• Learned about pairing Stream.cycle with Enum.zip
• Had to switch from Livebook native input (looks like it’s deprecated at edge) to Kino input
• Pattern matching makes this easy
• Just expanded all coordinates and counted frequencies bigger than 1

# Day 4

## Deps & preparation

```elixir
Mix.install([
  {:kino, "~> 0.4.0"}
])

input = Kino.Input.textarea("Please paste your input file:")
```

## Input

```elixir
coordinates =
  Kino.Input.read(input)
  |> String.split(["\n", ",", " -> "], trim: true)
  |> Enum.map(&String.to_integer/1)
  |> Enum.chunk_every(4)
```

## Part 1

```elixir
coordinates
|> Enum.reduce(
  [],
  fn
    [x, y, x1, y1], map when y == y1 ->
      Enum.zip(x..x1, Stream.cycle([y])) ++ map

    [x, y, x1, y1], map when x == x1 ->
      Enum.zip(Stream.cycle([x]), y..y1) ++ map

    _, map ->
      map
  end
)
|> Enum.frequencies()
|> Enum.count(fn {_k, v} -> v > 1 end)
```

## Part 2

```elixir
coordinates
|> Enum.reduce(
  [],
  fn
    [x, y, x1, y1], map when y == y1 ->
      Enum.zip(x..x1, Stream.cycle([y])) ++ map

    [x, y, x1, y1], map when x == x1 ->
      Enum.zip(Stream.cycle([x]), y..y1) ++ map

    [x, y, x1, y1], map ->
      Enum.zip(x..x1, y..y1) ++ map
  end
)
|> Enum.frequencies()
|> Enum.count(fn {_k, v} -> v > 1 end)
```

EDIT: Updated with @epilgrim split approach, thanks!