Advent of Code 2019 - Day 3

bjorng · December 3, 2019, 7:10am

Note: This topic is to talk about Day 3 of the Advent of Code 2019 .

There is a private leaderboard for elixirforum members. You can join it by following this link and entering the following code:

39276-eeb74f9a

bjorng · December 3, 2019, 7:12am

Here is my solution.

sasajuric · December 3, 2019, 8:08am

Today was a bit finicky. Here’s my take.

xfix · December 3, 2019, 9:32am

That was weird to do functionally. https://gitlab.com/KonradBorowski/advent_of_code_2019/blob/master/lib/day3.ex

NobbZ · December 3, 2019, 10:19am

Todays solution is a bit earlier as usual for me, as I currently can’t do office work as we have an internet outage. Doing this per mobile connection sharing right now.

Solution is at github, as usual.

gitlab.com

NobbZ/aoc_ex/blob/master/lib/y2019/d3.ex

defmodule AocEx.Y2019.D3 do
  use AocEx.Boilerplate,
    transform: fn raw ->
      raw
      |> String.split()
      |> Enum.map(fn line ->
        line
        |> String.split(",")
        |> Enum.map(fn
          "U" <> num -> {:up, String.to_integer(num)}
          "R" <> num -> {:right, String.to_integer(num)}
          "D" <> num -> {:down, String.to_integer(num)}
          "L" <> num -> {:left, String.to_integer(num)}
        end)
      end)
    end

  def part1(input \\ processed()) do
    [wire1, wire2] =
      input

This file has been truncated. show original

Implementation is pretty straight forward after one has realised that we are basically just dealing with 2 sets and we want to know where they intersect

Though code clean up has to wait, as I have to attend to a meeting in a couple of minutes, which we will hold as scheduled despite the internet problem.

cblavier · December 3, 2019, 10:21am

I have a bug I can’t figure out, please help ^^

It works fine on simple tests, but when running on full puzzle input, it gives me a wrong shortest distance (=1). It also gives me the good answer but only in second rank

gist.github.com

https://gist.github.com/cblavier/b31561ff1bdad793fbc7b1ef4b326a10

day3_part1.ex

defmodule Advent2019.Day3.Part1 do
  def run(file_path) do
    [path1, path2] =
      file_path
      |> File.read!()
      |> String.split("\n")

    distance_to_closest_intersection(path1, path2)
  end

This file has been truncated. show original

cblavier · December 3, 2019, 10:59am

Ok finally found it : I had a bug in inc_pos_x / inc_pos_y when dealing with negative distances

Here is my final solution by the way

egze · December 3, 2019, 11:59am

Very elegant!

Schumi2k10 · December 3, 2019, 12:24pm

Hi,
at the moment so try to learn Elixir. So I will solve the advent of code for better understanding of Elixir.
Currently I only solved Day 1 and 2. I hope I find some time this week to solve the next days
Here is a link to the repo: repo.

I’d appreciate your feedback.

NobbZ · December 3, 2019, 12:45pm

Could you walk us through your implementations in the appropriate days thread?

I only glanced, and they look as if they only provide a single solution each, rather than tackling both problems of the given day.

Schumi2k10 · December 3, 2019, 12:54pm

Sure, I overlooked that this thread is only for the third day.
And then I’ll adjust the solutions again so that both solutions are there and not just the second solution.

ferd · December 3, 2019, 1:50pm

Here’s my erlang take on day 3:

sb8244 · December 3, 2019, 1:58pm

Mine was a bit messier today, but I’ll leave it as it is.

I spent a bit of time wondering how I was going to approach this (DFS?). Then I realized I can simply expand the coords to find overlaps. That’s a bit brute Force, but it still cleared it in under 100ms

github.com

sb8244/advent-of-code-2019/blob/master/lib/3.ex

defmodule Three do
  def solution(one, two) do
    one_coords = expand_coords([{0, 0}], String.split(one, ","))
    two_coords = expand_coords([{0 ,0}], String.split(two, ","))

    combined = Enum.reduce(one_coords, %{}, fn {x, y}, acc -> Map.put(acc, {x, y}, true) end)
    overlap = Enum.filter(two_coords, & Map.get(combined, &1, false) and &1 != {0, 0})

    {x, y} =
      Enum.sort_by(overlap, fn {x, y} ->
        abs(x) + abs(y)
      end)
      |> List.first()

    abs(x) + abs(y)
  end

  def solution_2(one, two) do
    one_coords = expand_coords([{0, 0}], String.split(one, ","))
    one_length = length(one_coords)

This file has been truncated. show original

faried · December 3, 2019, 2:00pm

My solution today is very ugly. I wrote a lot more code than needed because I kept track of “steps” or length along with each point, which, upon reading other solutions, it’s obvious that I didn’t need. Everywhere I used Enum.map(&Enum ...) is where I couldn’t come up with something better.

One thing I felt I missed was Map.merge that takes a list of maps, instead of two maps. Having to write Enum.reduce(ls_of_maps, %{}, fn x, acc -> Map.merge(acc, x) end) seemed like extra work.

ferd · December 3, 2019, 3:58pm

I ended up doing the same and tracking all points as well. In retrospect (and once it’s no longer 15 minutes after I got up) it’s obvious you don’t need it that way, but it’s rather straightforward to count steps after the fact for part 2 anyway if you went with that approach for part 1.

evantravers · December 3, 2019, 4:17pm

I’m having a great time defining a sort of runner/pattern for my advent of code… I think this is my second or third year trying in elixir.

This year’s (current) model is using @callback to define a sort of API that all Advent problems have to solve:

defmodule Advent do
  @moduledoc """
  This is intended to be an importable module that defines some runners and
  conventions for advent of code problems.

  Each "day" should contain the following methods...

  - `setup/0` should setup a input object.
  - `p1/1` and `p2/2` should take the input and solve the puzzle, returning the
    answer.

  I want to define a test runner such that if you run mix <day number> it runs
  `setup/0` once and runs `p1/1` and/or `p2/1` when appropriate.
  """

  @callback setup() :: {:ok, term}
  @callback p1(Map.t) :: {:ok, term}
  @callback p2(Map.t) :: {:ok, term}
end

If you look at the whole file here, it also defines some timing functions as a mix task.

This pattern really became really fun for today’s puzzle. As I started into part 2, more of p1 moved up into setup/0 so that p1/1 and p2/1 are just the specific solutions to their part.

For instance:

  def p1(%{intersections: intersections}) do
    intersections
    |> Enum.min_by(fn({x, y}) -> abs(x) + abs(y) end)
    |> (fn({x, y}) -> abs(x) + abs(y) end).()
  end

and

  def p2(%{wires: {wire1, wire2}, intersections: intersections}) do
    intersections
    |> Enum.map(fn(coord) ->
      {
        Enum.find_index(Enum.reverse(wire1), & coord == &1) +
        Enum.find_index(Enum.reverse(wire2), & coord == &1),
        coord
      }
    end)
    |> Enum.map(fn({combined_distance, _}) -> combined_distance end)
    |> Enum.min
  end

full day 3 solution here

keathley · December 3, 2019, 4:43pm

Pretty hacky but it works and is reasonably speedy: https://github.com/keathley/advent_of_code_2019/blob/master/day3.exs

kbredemeier · December 3, 2019, 5:34pm

Here is my solution: https://github.com/kbredemeier/aoc2019/blob/master/lib/advent_of_code2019/day_3.ex

ColaCheng · December 3, 2019, 7:01pm

My solution:

github.com

ColaCheng/Adventofcode2019/blob/master/lib/day3/day3.ex

defmodule Day3 do
  @input_file "./lib/day3/input"

  def part1() do
    {coordinates1, coordinates2} = read_data()

    do_part1(coordinates1, coordinates2, [])
    |> Enum.map(&manhattan_distance/1)
    |> Enum.sort()
    |> List.first()
  end

  defp do_part1([], _, acc), do: acc
  defp do_part1([_], _, acc), do: acc
  defp do_part1(_, [], acc), do: acc
  defp do_part1(_, [_], acc), do: acc

  defp do_part1([a_p1, a_p2 | a_tail], [b_p1, b_p2 | b_tail], acc) do
    new_acc =
      case find_cross({a_p1, a_p2}, {b_p1, b_p2}) do

This file has been truncated. show original

lakret · December 3, 2019, 9:32pm

This time my stream was saved

Code is here.