Advent Of Code 2022 - Day 4

I am grateful for MapSet module. Not every language is blessed with a set API that has common set operations.

https://github.com/code-shoily/advent_of_code/blob/master/lib/2022/day_04.ex

Second half was actually a little simpler.

# Part 1
day_4_data
|> String.split("\n")
|> Enum.map(fn ranges -> 
   ranges
   |> String.split(",")
   |> Enum.map(fn range -> 
        [start, finish] = String.split(range, "-")
        (String.to_integer(start)..String.to_integer(finish)) |> MapSet.new()
      end)
   end)
|> Enum.count(fn [first, second] -> 
     MapSet.subset?(first, second) || MapSet.subset?(second, first)
   end)

# Part 2
day_4_data
|> String.split("\n")
|> Enum.map(fn ranges -> 
     ranges
     |> String.split(",")
     |> Enum.map(fn range -> 
          [start, finish] = String.split(range, "-")          
          (String.to_integer(start)..String.to_integer(finish))
        end)
   end)
|> Enum.count(fn [first, second] -> not Range.disjoint?(first, second) end)

Basically did the same. I wasn’t as clever with your use of the && and || operators to convert to numbers. I just filtered and counted.

Like others, using Range

https://github.com/ed-flanagan/advent-of-code-solutions-elixir/blob/main/lib/advent/y2022/d04.ex

Ooh, TIL, I started with Ranges, but then converted them to MapSets - I didn’t consider that we can do it, especially part 2, directly with the range. This is why AoC is great

  def part1(input) do
    Enum.count(input, fn [a, b] -> MapSet.subset?(a, b) or MapSet.subset?(b, a) end)
  end

  def part2(input) do
    Enum.count(input, fn [a, b] -> not MapSet.disjoint?(a, b) end)
  end

  def input do
    with [input_filename] <- System.argv(),
         {:ok, input} <- File.read(input_filename) do
      input
      |> String.split(["-", ",", "\n"], trim: true)
      |> Enum.map(&String.to_integer/1)
      |> Enum.chunk_every(2)
      |> Enum.map(fn [a, b] -> MapSet.new(a..b) end)
      |> Enum.chunk_every(2)
    else
      _ -> :error
    end
  end

https://git.adamu.jp/adam/AdventOfCode/src/branch/main/2022/day4.exs

part 1

start = System.monotonic_time(:microsecond)

File.stream!("input.txt")
|> Stream.map(fn line ->
   Regex.run(~r/^(\d+)-(\d+),(\d+)-(\d+)$/, line, capture: :all_but_first)
   |> Enum.map(&String.to_integer/1)
end)
|> Enum.reduce(0, fn [lo1, hi1, lo2, hi2], count ->
  cond do
    lo1 >= lo2 && hi1 <= hi2 -> count + 1
    lo2 >= lo1 && hi2 <= hi1 -> count + 1
    true -> count
  end
end)
|> tap(fn count -> IO.puts "Number of contained assignment pairs: #{count}" end)

elapsed = System.monotonic_time(:microsecond) - start
IO.puts "Job done in #{elapsed} µs"

part 2 is very similar to part 1.

start = System.monotonic_time(:microsecond)

File.stream!("input.txt")
|> Stream.map(fn line ->
   Regex.run(~r/^(\d+)-(\d+),(\d+)-(\d+)$/, line, capture: :all_but_first)
   |> Enum.map(&String.to_integer/1)
end)
|> Enum.reduce(0, fn [lo1, hi1, lo2, hi2], count ->
  cond do
    lo1 >= lo2 && lo1 <= hi2 -> count + 1
    lo2 >= lo1 && lo2 <= hi1 -> count + 1
    hi1 >= lo2 && hi1 <= hi2 -> count + 1
    hi2 >= lo1 && hi2 <= hi1 -> count + 1
    true -> count
  end
end)
|> tap(fn count -> IO.puts "Number of overlapping assignment pairs: #{count}" end)

elapsed = System.monotonic_time(:microsecond) - start
IO.puts "Job done in #{elapsed} µs"

...
|> Enum.map(& &1 |> String.replace("-", "..") |> Code.eval_string() |> elem(0))

and then

|> Enum.map(fn [r1, r2] -> not Range.disjoint?(r1, r2) end)

clever parsing

I’ve been working through AOC using Gleam this year! This is probably pretty terrible Gleam code, but it’s Elixir-adjacent so I thought I’d share

https://github.com/markholmes/aoc/blob/main/src/y_22/d_04.gleam

I also went with parsing into Ranges, and was also surprised to learn about Range.disjoint?/2 solving part two that literally did all the work compared to part one.

What I really found impressive is that disjoint? handles steps with ranges, as well! That’s a cool technique.