Advent Of Code 2022 - Day 4

bismark · December 4, 2022, 5:48am

Took me a minute to remember my binary math …

import Bitwise

__DIR__
|> Path.join("puzzle.txt")
|> File.stream!()
|> Stream.filter(fn line ->
  line
  |> String.trim()
  |> String.split(",")
  |> Enum.map(fn range ->
    [s,e] = range |> String.split("-") |> Enum.map(& String.to_integer(&1))
    Integer.pow(2, e - s + 1) - 1 <<< (s - 1)
  end)
  |> Enum.reduce(fn int1, int2 ->
    intersection = int1 ||| int2
    intersection == int1 or intersection == int2
  end)
end)
|> Enum.count()
|> IO.puts()

import Bitwise

__DIR__
|> Path.join("puzzle.txt")
|> File.stream!()
|> Stream.filter(fn line ->
  line
  |> String.trim()
  |> String.split(",")
  |> Enum.map(fn range ->
    [s,e] = range |> String.split("-") |> Enum.map(& String.to_integer(&1))
    Integer.pow(2, e - s + 1) - 1 <<< (s - 1)
  end)
  |> Enum.reduce(fn int1, int2 ->
    (int1 &&& int2) != 0
  end)
end)
|> Enum.count()
|> IO.puts()

Edit: oops, I’m supposed to import not use Bitwise now…

code-shoily · December 4, 2022, 6:05am

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

github.com

code-shoily/advent_of_code/blob/master/lib/2022/day_04.ex

defmodule AdventOfCode.Y2022.Day04 do
  @moduledoc """
  --- Day 4: Camp Cleanup ---
  Problem Link: https://adventofcode.com/2022/day/4
  """
  alias AdventOfCode.Helpers.{InputReader, Transformers}

  def input, do: InputReader.read_from_file(2022, 4)

  def run(input \\ input()) do
    with input <- parse(input), do: {run_1(input), run_2(input)}
  end

  defp run_1(data),
    do: Enum.reduce(data, 0, fn [a, b], acc -> acc + ((subset?(a, b) && 1) || 0) end)

  defp run_2(data),
    do: Enum.reduce(data, 0, fn [a, b], acc -> acc + ((MapSet.disjoint?(a, b) && 0) || 1) end)

  defp subset?(a, b), do: MapSet.subset?(a, b) || MapSet.subset?(b, a)

This file has been truncated. show original

srowley · December 4, 2022, 6:09am

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)

stevensonmt · December 4, 2022, 6:10am

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.

deadbeef · December 4, 2022, 6:54am

Like others, using Range

github.com

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

defmodule Advent.Y2022.D04 do
  @moduledoc """
  https://adventofcode.com/2022/day/4
  """

  @doc """
  In how many assignment pairs does one range fully contain the other?
  """
  @spec part_one(Enumerable.t()) :: integer()
  def part_one(input) do
    input
    |> parse_input()
    |> Enum.count(fn {r1 = r1s..r1e, r2 = r2s..r2e} ->
      (r1s in r2 && r1e in r2) || (r2s in r1 && r2e in r1)
    end)
  end

  @doc """
  In how many assignment pairs do the ranges overlap?
  """

This file has been truncated. show original

adamu · December 4, 2022, 7:04am

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

lkuty · December 4, 2022, 7:06am

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"

mudasobwa · December 4, 2022, 7:25am

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

and then

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

kwando · December 4, 2022, 8:09am

clever parsing

markholmes · December 4, 2022, 8:32am

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

github.com

markholmes/aoc/blob/main/src/y_22/d_04.gleam

import gleam/erlang/file
import gleam/int
import gleam/io
import gleam/list
import gleam/option.{Some}
import gleam/regex.{Match}
import gleam/set
import gleam/string

pub fn solve_1() {
  assert Ok(input) = file.read("./input/d_04.txt")

  input
  |> string.trim()
  |> string.split("\n")
  |> list.filter(fn(x) {
    assert Ok(re) = regex.from_string("(\\d*)-(\\d*),(\\d*)-(\\d*)")
    let capture = case regex.scan(re, x) {
      [Match(_, [Some(a), Some(b), Some(c), Some(d)])] -> [a, b, c, d]
      _ -> []

This file has been truncated. show original

christhekeele · December 4, 2022, 9:20am

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.

LostKobrakai · December 4, 2022, 9:35am

I used ranges as well. Part 1 and 2 are basically contains? and overlaps? for ranges. Did the first on my own, for part 2 Range.disjoint? is the opposite to overlaps?, so it does the job. Contains can be checked just by looking at the edges of the ranges.

Solution

defmodule Day4 do
  def sum_number_of_contained_assignments(text) do
    text
    |> String.split("\n")
    |> Enum.reject(&(&1 == ""))
    |> Enum.filter(&contained_assignments?/1)
    |> length()
  end

  def sum_number_of_overlapping_assignments(text) do
    text
    |> String.split("\n")
    |> Enum.reject(&(&1 == ""))
    |> Enum.filter(&overlapping_assignments?/1)
    |> length()
  end

  defp contained_assignments?(assignments) do
    {elf_a_range, elf_b_range} = parse_pair_ranges(assignments)
    contains?(elf_a_range, elf_b_range) or contains?(elf_b_range, elf_a_range)
  end

  defp overlapping_assignments?(assignments) do
    {elf_a_range, elf_b_range} = parse_pair_ranges(assignments)
    !Range.disjoint?(elf_a_range, elf_b_range)
  end

  defp parse_pair_ranges(assignments) do
    [elf_a_assignment, elf_b_assignment] = String.split(assignments, ",", trim: true, parts: 2)
    elf_a_range = to_range(elf_a_assignment)
    elf_b_range = to_range(elf_b_assignment)
    {elf_a_range, elf_b_range}
  end

  defp to_range(assignment) do
    [from, to] = String.split(assignment, "-", trim: true, parts: 2)
    from_int = String.to_integer(from)
    to_int = String.to_integer(to)
    from_int..to_int//1
  end

  defp contains?(fa..ta//1, fb..tb//1) do
    fa <= fb and ta >= tb
  end
end

Aetherus · December 4, 2022, 10:01am

My simple solution:

defmodule Day04 do
  def part1(input_path) do
    input_path
    |> File.stream!()
    |> Stream.map(&String.trim/1)
    |> Stream.map(&String.split(&1, ~r/\D/, global: true))
    |> Stream.map(fn x -> Enum.map(x, &String.to_integer/1) end)
    |> Enum.count(fn [start1, end1, start2, end2] ->
      (start1 <= start2 and end1 >= end2) or
      (start1 >= start2 and end1 <= end2)
    end)
  end

  def part2(input_path) do
    input_path
    |> File.stream!()
    |> Stream.map(&String.trim/1)
    |> Stream.map(&String.split(&1, ~r/\D/, global: true))
    |> Stream.map(fn x -> Enum.map(x, &String.to_integer/1) end)
    |> Enum.count(fn [start1, end1, start2, end2] ->
      start1 <= end2 and start2 <= end1
    end)
  end
end

mruoss · December 4, 2022, 10:01am

Advent of code always reminds me what a great “stdlib” Elixir comes with!

  parsed = 
    input
    |> String.split("\n", trim: true)
    |> Enum.flat_map(&String.split(&1, ~r/[-,]/))
    |> Enum.map(&String.to_integer/1)
    |> Enum.chunk_every(4)

part1 = Enum.count(parsed, fn [ax, ay, bx, by] -> (ax <= bx and ay >= by) or (ax >= bx and ay <= by) end)
part2 = Enum.count(parsed, fn [ax, ay, bx, by] -> (bx <= ay and by >= ax) end)

Edit: @Aetherus you beat me by a few seconds

bmitc · December 4, 2022, 10:36am

I am getting the feeling that Advent of Code is written from the mindset of primarily imperative languages, because it feels they’re getting easier with Elixir. Today’s was just Range and MapSet doing everything. I think today’s is probably the closest to literally just restating the problem description in Elixir. Part two required no edits to the code to solve part one since it just required a different count function. Link to Livebook notebook.

defmodule Day4 do
  @moduledoc """
  Solutions for Day 4
  """

  @typedoc """
  Represents a pairing of two elf's section assignments. The section assignments
  are represented by Elixir `Range`s.
  """
  @type assignment_pair() :: {Range.t(), Range.t()}

  @doc """
  Parse an assignment pair string into a tuple of section assignment ranges

  ## Examples:
    iex> Day4.parse_assignment_pair("2-4,6-8")
    {2..4, 6..8}
  """
  @spec parse_assignment_pair(String.t()) :: assignment_pair()
  def parse_assignment_pair(string) do
    [[a_start, a_end], [b_start, b_end]] =
      for range <- String.split(string, ",", trim: true) do
        String.split(range, "-", trim: true)
        |> Enum.map(&String.to_integer/1)
      end

    {Range.new(a_start, a_end), Range.new(b_start, b_end)}
  end

  @doc """
  List of all the assignment pairs
  """
  @spec assignment_pairs() :: [assignment_pair()]
  def assignment_pairs() do
    Utilities.read_data(4)
    |> Enum.map(&parse_assignment_pair/1)
  end

  @doc """
  Determines if range 1 is a subset of range 2
  """
  @spec range_subset?(Range.t(), Range.t()) :: boolean()
  def range_subset?(range1, range2) do
    MapSet.subset?(MapSet.new(range1), MapSet.new(range2))
  end

  @doc """
  Determines if one of the ranges is fully contained in (i.e., a subset of) the other
  """
  @spec range_contained_in_the_other?(Range.t(), Range.t()) :: boolean()
  def range_contained_in_the_other?(range1, range2) do
    range_subset?(range1, range2) or range_subset?(range2, range1)
  end

  def part_one() do
    assignment_pairs()
    |> Enum.count(fn {range1, range2} -> range_contained_in_the_other?(range1, range2) end)
  end

  def part_two() do
    assignment_pairs()
    |> Enum.count(fn {range1, range2} -> !Range.disjoint?(range1, range2) end)
  end
end

newton-peixoto · December 4, 2022, 11:25am

Probably not the most performant code but it does the job. Suggestions are appreciated

github.com

newton-peixoto/advent-of-code/blob/main/2022/livebooks/day-04.livemd

# day 04

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

## Input

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

```elixir
input =
  input
  |> Kino.Input.read()
  |> String.split([",", "\n"])
```

This file has been truncated. show original

hst337 · December 4, 2022, 11:41am

One more day for scanning

defmodule AOC do
  def traverse(string, number \\ 0, line \\ [], acc \\ 0)
  def traverse("", 0, [], acc), do: acc
  def traverse(string, 0, [r2, l2, r1, l1], acc) do
    cond do
      r1 < l2 ->
        traverse(string, 0, [], acc)

      r2 < l1 ->
        traverse(string, 0, [], acc)

      true ->
        traverse(string, 0, [], acc + 1)
    end
  end
  def traverse(string, number, line, acc) do
    case string do
      <<splitter, tail :: binary>> when splitter in [?-, ?,, ?\n] ->
        traverse(tail, 0, [number | line], acc)

      <<int, tail :: binary>> ->
        traverse(tail, number * 10 + int - ?0, line, acc)

      "" ->
        traverse("", 0, [number | line], acc)

      "\n" ->
        traverse("", 0, [number | line], acc)
    end
  end
end

IO.inspect AOC.traverse IO.read :eof

bossek · December 4, 2022, 12:03pm

day04.exs:

solve = fn oper ->
  "data/04"
  |> File.read!()
  |> String.split(["\n", ",", "-"], trim: true)
  |> Enum.map(&String.to_integer/1)
  |> Enum.chunk_every(4)
  |> Enum.filter(fn [a, b, c, d] -> oper.(c in a..b, d in a..b) or oper.(a in c..d, b in c..d) end)
  |> Enum.count()
end

(&and/2)
|> then(solve)
|> tap(&IO.puts("Part 1: #{&1}"))

(&or/2)
|> then(solve)
|> tap(&IO.puts("Part 2: #{&1}"))

stefanluptak · December 4, 2022, 2:44pm

github.com

stefanluptak/advent-of-code/blob/main/2022/day_04.livemd

<!-- vim: syntax=markdown -->

# Day 4

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

## Common

<!-- livebook:{"reevaluate_automatically":true} -->

```elixir
defmodule Day4 do
  def parse_input(textarea) do
    textarea
    |> Kino.Input.read()
    |> String.split("\n", trim: true)

This file has been truncated. show original

egze · December 4, 2022, 2:47pm

Part 1

input
|> String.split("\n", trim: true)
|> Enum.map(fn line ->
  %{"a1" => a1, "a2" => a2, "b1" => b1, "b2" => b2} =
    Regex.named_captures(~r/(?<a1>\d+)-(?<a2>\d+),(?<b1>\d+)-(?<b2>\d+)/, line)
  {Range.new(String.to_integer(a1), String.to_integer(a2)), Range.new(String.to_integer(b1), String.to_integer(b2))}
end)
|> Enum.filter(fn {r1, r2} ->
  s1 = MapSet.new(r1)
  s2 = MapSet.new(r2)

  MapSet.subset?(s1, s2) || MapSet.subset?(s2, s1)
end)
|> length()

Part 2

input
|> String.split("\n", trim: true)
|> Enum.map(fn line ->
  %{"a1" => a1, "a2" => a2, "b1" => b1, "b2" => b2} =
    Regex.named_captures(~r/(?<a1>\d+)-(?<a2>\d+),(?<b1>\d+)-(?<b2>\d+)/, line)
  {Range.new(String.to_integer(a1), String.to_integer(a2)), Range.new(String.to_integer(b1), String.to_integer(b2))}
end)
|> Enum.reject(fn {r1, r2} ->
  s1 = MapSet.new(r1)
  s2 = MapSet.new(r2)

  MapSet.disjoint?(s1, s2)
end)
|> length()