Advent of Code 2021 Day 14

rugyoga · December 14, 2021, 6:55am

part 1:

rugyoga/aoc2021/blob/main/day14.exs

defmodule Day14 do
  def cycle(chars, transforms) do
    chars
    |> Enum.chunk_every(2, 1)
    |> Enum.map(fn [a, _] = ab -> [a, transforms[Enum.join(ab, "")]]
                    [b] -> [b] end)
    |> List.flatten()
  end
end

[sequence, transforms] = "day14.txt" |> File.read! |> String.split("\n\n", trim: true)

transforms =
  transforms
  |> String.split("\n", trim: true)
  |> Enum.map(fn line -> line |> String.split(" -> ", trim: true) |> List.to_tuple end)
  |> Map.new

sequence = sequence |> String.codepoints|> Stream.iterate(&Day14.cycle(&1, transforms))
sorted = Enum.at(sequence, 10) |> Enum.frequencies() |> Enum.sort_by(fn {_,y} -> y end)

This file has been truncated. show original

part 2:

github.com

rugyoga/aoc2021/blob/main/day14b.exs

defmodule Day14 do
  def cycle(freqs, transforms) do
    freqs
    |> Enum.map(fn {[a, b] = ab, count} -> tx_ab = transforms[ab]; [{[a, tx_ab], count}, {[tx_ab, b], count}]; x -> x end)
    |> List.flatten
    |> Enum.reduce(%{}, fn {l, count}, counts -> Map.update(counts, l, count, &(&1 + count)) end)
  end
end

[sequence, transforms] = "day14.txt" |> File.read! |> String.split("\n\n", trim: true)

transforms =
  transforms
  |> String.split("\n", trim: true)
  |> Enum.map(fn line -> line |> String.split(" -> ", trim: true) |> List.to_tuple |> then(fn {lhs, rhs} -> {String.split(lhs, "", trim: true), rhs} end) end)
  |> Map.new

sequence = sequence |> String.codepoints|> Enum.chunk_every(2, 1) |> Enum.frequencies |> Stream.iterate(&Day14.cycle(&1, transforms))
{min, max} =
  Enum.at(sequence, 40)

This file has been truncated. show original

wasi0013 · December 14, 2021, 7:24am

Just like day 7 spent some time on optimizing part 1 and it paid off
y2021/day_14.ex

bjorng · December 14, 2021, 7:49am

github.com

bjorng/advent-of-code-2021/blob/79f8a97fcca890a8b611f45199027e3f358dabeb/day14/lib/day14.ex

defmodule Day14 do
  def part1(input) do
    {template, rules} = parse(input)
    rules = Map.new(rules)

    Stream.iterate(template, &(next_part1(&1, rules)))
    |> Stream.drop(10)
    |> Enum.take(1)
    |> hd
    |> Enum.frequencies
    |> Enum.min_max_by(fn {_, freq} -> freq end)
    |> result
  end

  def part2(input) do
    {template, rules} = parse(input)

    pairs = Enum.zip(template, tl(template))
    |> Enum.frequencies

This file has been truncated. show original

princemaple · December 14, 2021, 9:25am

github.com

princemaple/aoc/blob/main/2021/day14.exs

# Title: Day14

# ── Untitled ──

[data, map] =
  "input"
  |> IO.getn(1_000_000)
  |> String.trim()
  |> String.split(["\n\n", "\r\n\r\n"], trim: true)

data = String.split(data, "", trim: true)

map =
  map
  |> String.split(["\n", "\r\n"], trim: true)
  |> Enum.map(&String.split(&1, " -> "))
  |> Enum.map(fn [template, insert] -> {template, insert} end)
  |> Map.new()

defmodule P1 do

This file has been truncated. show original

stefanluptak · December 14, 2021, 12:27pm

Oh, those small everyday learnings. Today it was Enum.min_max_by/4.

tommyokeefe · December 14, 2021, 4:22pm

Got a bit stuck on part2 today but reading some solutions here helped me sort it out. I’m learning a ton from you all!

code-shoily · December 14, 2021, 9:42pm

F# won the toss so solved it with F# and got back here to see how Elixir solutions were like. Surprisingly, my F# solution looked very much like yours here, so I tried running yours with my input (test case ran fine). But it didn’t work out. Looks like due to the line |> Enum.map(&{&1, 1}) where you’re collecting the pair count got me because I had a pair repeat (i.e. two “PK”-s). I guess a frequency there could fix it?

stefanluptak · December 14, 2021, 9:53pm

No idea. I will check that tomorrow. Could you please send me your input? Here or via a DM.

code-shoily · December 14, 2021, 10:28pm

Sure. Here’s the link: AoC 14 2021 INPUT - Pastebin.com

The answers are: 3118 and 4332887448171

APB9785 · December 15, 2021, 12:40am

I probably spent too much time on approaches that didn’t work. The “eureka!” moment for me was realizing that I had to track both the pairs AND individual letters. From there, it was simple to implement.

Solution here.

stevensonmt · December 15, 2021, 4:57am

Got it done just under the wire. Code is ugly but not going to pretty it up until tomorrow. Had the same “aha!” of tracking both pairs and individual counts as @APB9785 did. I just need to organize my initialization steps better.

github.com

stevensonmt/advent_of_code/blob/e05058fd7a330f430e8fa70d79604447de455846/2021/day14/lib/day14.ex

defmodule Day14 do
  @moduledoc """
  My solution to AoC day 14 2021
  """
  def parse(input) do
    input
    |> File.read!()
    |> String.split("\n\n", trim: true, parts: 2)
    |> parse_rules()
  end

  defp parse_rules([start, rules]) do
    {start,
     start
     |> String.to_charlist()
     |> Enum.chunk_every(2, 1, :discard),
     rules
     |> String.split("\n", trim: true)
     |> Enum.map(fn <<a, b>> <> " -> " <> <<c>> -> {[a, b], [c], [a, c], [c, b]} end)}
  end

This file has been truncated. show original

stefanluptak · December 15, 2021, 10:22am

You were right. Thanks a lot for finding that bug. With my input, it didn’t have an effect. With yours it did.
My answers were 2408 and 2651311098752 so probably just some lucky coincidence.
BTW: where can I take a look at your F# solution? I am quite curious.

code-shoily · December 15, 2021, 1:35pm

Here it is. AoCFs/Day14.fs at main · code-shoily/AoCFs (github.com) … once you get past the syntax you’ll see it is very similar to your solution

qhwa · December 17, 2021, 2:34am

I was stuck on it for a while but finally got it. The main module:

defmodule Recursion do
  def run(freq, _, 0) do
    freq
  end

  def run(freq, formulas, count) do
    freq =
      Enum.reduce(freq, freq, fn
        {{p1, p2} = pair, count}, acc ->
          case formulas do
            %{^pair => insertion} ->
              acc
              |> Map.update(pair, -count, &(&1 - count))
              |> Map.update({p1, insertion}, count, &(&1 + count))
              |> Map.update({insertion, p2}, count, &(&1 + count))
              |> Map.update(insertion, count, &(&1 + count))
          end

        {n, _}, acc when is_integer(n) ->
          acc
      end)

    run(freq, formulas, count - 1)
  end
end

full solution here.