Advent of Code Day 13

rugyoga · December 13, 2021, 5:55am

part 1:

rugyoga/aoc2021/blob/main/day13.exs

defmodule Day13 do
  def folder(folds, points) do
    folds |> Enum.reduce(points, fn {dir, n}, points -> points |> Enum.map(&fold(dir, n, &1)) |> MapSet.new end)
  end

  def fold("x", n, {x, y} = p), do: if x > n, do: {n - (x-n), y}, else: p
  def fold("y", n, {x, y} = p), do: if y > n, do: {x, n - (y-n)}, else: p
end

[coords, folds] =
  "day13.txt"
  |> File.read!
  |> String.split("\n\n", trim: true)


 coords =
  coords
  |> String.split("\n", trim: true)
  |> Enum.filter(&String.match?(&1, ~r/\d+/))
  |> Enum.map(fn line -> line |> String.split(",", trim: true) |> Enum.map(&String.to_integer/1) |> then(fn [x, y] -> {x, y} end) end)

This file has been truncated. show original

part 2:

github.com

rugyoga/aoc2021/blob/main/day13b.exs

defmodule Day13 do
  def folder(folds, points) do
    folds |> Enum.reduce(points, fn {dir, n}, points -> points |> Enum.map(&fold(dir, n, &1)) |> MapSet.new end)
  end

  def fold("x", n, {x, y} = p), do: if x > n, do: {n - (x-n), y}, else: p
  def fold("y", n, {x, y} = p), do: if y > n, do: {x, n - (y-n)}, else: p
end

[coords, folds] =
  "day13.txt"
  |> File.read!
  |> String.split("\n\n", trim: true)


 coords =
  coords
  |> String.split("\n", trim: true)
  |> Enum.filter(&String.match?(&1, ~r/\d+/))
  |> Enum.map(fn line -> line |> String.split(",", trim: true) |> Enum.map(&String.to_integer/1) |> then(fn [x, y] -> {x, y} end) end)

This file has been truncated. show original

princemaple · December 13, 2021, 6:06am

github.com

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

# Title: Day13

# ── Untitled ──

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

dots =
  dots
  |> String.split(["\n", "\r\n"], trim: true)
  |> Enum.map(fn line ->
    line |> String.split(",") |> Enum.map(&String.to_integer/1) |> List.to_tuple()
  end)
  |> IO.inspect()

folds =
  folds

This file has been truncated. show original

bjorng · December 13, 2021, 6:08am

github.com

bjorng/advent-of-code-2021/blob/e1005ce1a75366073903b9f442d40a45f84e9bd6/day13/lib/day13.ex

defmodule Day13 do
  def part1(input) do
    {dots, folding} = parse(input)

    dots = MapSet.new(dots)

    {axis, value} = hd(folding)
    fold(dots, axis, value)
    |> MapSet.size
  end

  def part2(input) do
    {dots, folding} = parse(input)

    dots = MapSet.new(dots)

    Enum.reduce(folding, dots, fn {axis, value}, dots ->
      fold(dots, axis, value)
    end)
    |> print_grid

This file has been truncated. show original

ruslandoga · December 13, 2021, 7:24am

I wonder if anyone here could help me out to position doctest outputs better. Right now I have

@doc """

      iex> part2(example_input())
      "#####
      #...#
      #...#
      #...#
      #####"

      iex> part2(my_input())
      "###..###...##..#..#.####.###..#....###.
      #..#.#..#.#..#.#.#..#....#..#.#....#..#
      #..#.#..#.#....##...###..###..#....#..#
      ###..###..#....#.#..#....#..#.#....###.
      #.#..#....#..#.#.#..#....#..#.#....#.#.
      #..#.#.....##..#..#.#....###..####.#..#"

  """

And I don’t like that the first line is misplaced by one ". I’d like the output to be more like

@doc """

      iex> part2(example_input())
      #####
      #...#
      #...#
      #...#
      #####

      iex> part2(my_input())
      ###..###...##..#..#.####.###..#....###.
      #..#.#..#.#..#.#.#..#....#..#.#....#..#
      #..#.#..#.#....##...###..###..#....#..#
      ###..###..#....#.#..#....#..#.#....###.
      #.#..#....#..#.#.#..#....#..#.#....#.#.
      #..#.#.....##..#..#.#....###..####.#..#

  """

I’d be very thankful

bjorng · December 13, 2021, 7:32am

The following should work:

iex> part2(my_input()) |> IO.puts

ruslandoga · December 13, 2021, 7:33am

mix test
Compiling 1 file (.ex)
.....................#####
#...#
#...#
#...#
#####


  1) doctest Day13.part2/1 (3) (Day13Test)
     test/days_test.exs:6
     Doctest failed
     doctest:
       iex> part2(example_input()) |> IO.puts
       "#####
       #...#
       #...#
       #...#
       #####"
     code:  part2(example_input()) |> IO.puts === "#####
            #...#
            #...#
            #...#
            #####"
     left:  :ok
     right: "#####\n#...#\n#...#\n#...#\n#####"
     stacktrace:
       lib/day13.ex:119: Day13 (module)

.................................

Finished in 0.5 seconds (0.5s async, 0.00s sync)
55 doctests, 1 failure

Randomized with seed 958985

Sorry, I should’ve been clearer that these are doctests, not commands in iex repl. Using IO.puts in doctests results in :ok being returned instead of the value that’s been printed.

dallagi · December 13, 2021, 7:35am

Here’s my solution.

This advent of code (not day13 specifically) is making me fall in love with comprehensions, I never realized they were so convenient and powerful.

github.com

dallagi/aoc2021/blob/main/lib/aoc2021/day13.ex

defmodule Aoc2021.Day13 do
  def part1(input) do
    {dots, [first_fold | _]} = parse(input)

    dots
    |> fold(first_fold)
    |> length()
  end

  def part2(input) do
    {dots, folds} = parse(input)

    folds
    |> Enum.reduce(dots, &fold(&2, &1))
    |> print()
  end

  def fold(dots, {axis, value} = _fold_line) do
    case axis do
      :x ->

This file has been truncated. show original

stevensonmt · December 13, 2021, 8:01am

Not spending a lot of time on this one.

github.com

stevensonmt/advent_of_code/blob/425c8822abfcf29989e3bdc0ac18aa6992626ee6/2021/day13/lib/day13.ex

defmodule Day13 do
  @moduledoc """
  Day 13 of AoC 2021
  """

  def parse(input) do
    [coords, folds] = String.split(input, "\n\n")

    proccessed_coords =
      coords
      |> String.split()
      |> Enum.map(fn line ->
        String.split(line, ",") |> Enum.map(&String.to_integer(&1)) |> List.to_tuple()
      end)

    processed_folds =
      Regex.scan(~r/(x|y)=(\d+)/, folds, capture: :all_but_first)
      |> Enum.map(fn
        ["x", n] -> {String.to_integer(n), :nan}
        ["y", n] -> {:nan, String.to_integer(n)}

This file has been truncated. show original

stefanluptak · December 13, 2021, 9:18am

This one was surprisingly straightforward for a Day 13. I am really curious how the next ones will be. I have never got this far in the AoC before.

deadbeef · December 13, 2021, 12:07pm

Looks similar to others, and not particularly pretty. But had a little fun and added a function that would print the code in color. E.g.

aoc-2021-13-print-2

Sure you could make it fancier with some box-drawing chars.

github.com

ed-flanagan/advent-of-code-solutions-elixir/blob/main/lib/advent/y2021/d13.ex

defmodule Advent.Y2021.D13 do
  @moduledoc """
  https://adventofcode.com/2021/day/13
  """

  @typep fold :: {:x | :y, non_neg_integer()}

  @doc """
  How many dots are visible after completing just the first fold instruction on
  your transparent paper?
  """
  @spec part_one(Enumerable.t()) :: non_neg_integer()
  def part_one(input) do
    {paper, [instruction | _rest]} = parse_input(input)

    paper
    |> fold(instruction)
    |> MapSet.size()
  end

This file has been truncated. show original

hauleth · December 13, 2021, 1:16pm

LiveBook solution:

github.com

hauleth/advent-of-code/blob/master/2021/solutions.livemd#day-13

<!--
 vim:ft=markdown --!>
 livebook:{"persist_outputs":true} 
-->

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

# Advent of Code 2021

## Setup

```elixir
Mix.install([
  {:nx, github: "elixir-nx/nx", sparse: "nx"},
  {:kino, github: "livebook-dev/kino"}
])
```

```output
:ok

This file has been truncated. show original

egze · December 13, 2021, 3:31pm

y2021/day-13.livemd

Outputs something like this

⬛️⬛️⬛️⬜️⬜️⬜️⬛️⬛️⬜️⬜️⬛️⬜️⬜️⬛️⬜️⬛️⬛️⬛️⬜️⬜️⬛️⬜️⬜️⬛️⬜️⬛️⬜️⬜️⬜️⬜️⬛️⬜️⬜️⬛️⬜️⬛️⬜️⬜️⬜️
⬛️⬜️⬜️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬜️⬜️⬜️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬜️⬜️
⬛️⬜️⬜️⬛️⬜️⬛️⬜️⬜️⬜️⬜️⬛️⬛️⬛️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬛️⬛️⬜️⬜️⬜️⬛️⬜️⬜️⬜️⬜️⬛️⬛️⬜️⬜️⬜️⬛️⬜️⬜️⬜️
⬛️⬛️⬛️⬜️⬜️⬛️⬜️⬛️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬛️⬛️⬛️⬜️⬜️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬜️⬜️⬜️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬜️⬜️
⬛️⬜️⬜️⬜️⬜️⬛️⬜️⬜️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬜️⬜️⬜️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬜️⬜️
⬛️⬜️⬜️⬜️⬜️⬜️⬛️⬛️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬛️⬛️⬛️⬛️⬜️⬛️⬜️⬜️⬛️⬜️⬛️⬛️⬛️⬛️

Also used NimbleParsec just for fun.

milli · December 13, 2021, 7:24pm

Part 2 solved in Livebook with VegaLite

(Full solution)

ream88 · December 13, 2021, 7:29pm

Implemented part 2 before even realizing it is already the solution for part 1

github.com

ream88/advent-of-code-2021/blob/main/13/part2.exs

Code.require_file("../advent_of_code_2021.ex")

defmodule Paper do
  def new(points) do
    points
    |> Enum.reduce(%{}, fn point, acc ->
      [x, y] = Enum.map(point, &String.to_integer/1)
      Map.put(acc, {x, y}, "#")
    end)
    |> Map.new()
  end

  def fold(paper, {axis, line}) do
    index = if axis == :x, do: 0, else: 1

    paper
    |> Map.keys()
    |> Enum.filter(&(elem(&1, index) > line))
    |> Enum.reduce(paper, fn {x, y} = point, paper ->
      folded_point =

This file has been truncated. show original

APB9785 · December 14, 2021, 6:24am

I used this function to map over the coordinates:

def fold_coord({x, y}, {n, axis}) do
  case axis do
    :x -> if x < n, do: {x, y}, else: {2 * n - x, y}
    :y -> if y < n, do: {x, y}, else: {x, 2 * n - y}
  end
end

Full solution here

qhwa · December 17, 2021, 6:17am

I optimized my solution to use MapSet after watching @josevalim 's video

dots =
  commands
  |> Enum.take(1)
  |> Enum.reduce(dots, fn
    {"x", at}, dots ->
      for {x, y} <- dots, into: MapSet.new(), do: {at - abs(at - x), y}

    {"y", at}, dots ->
      for {x, y} <- dots, into: MapSet.new(), do: {x, at - abs(at - y)}
  end)

Enum.count(dots)

full solution