Advent of Code 2019 - Day 5

bjorng · December 5, 2019, 6:12am

Note: This topic is to talk about Day 5 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 5, 2019, 6:14am

Here is my solution.

Aetherus · December 5, 2019, 6:15am

I cheated again

Very ugly code:

github.com

Aetherus/advent_of_code/blob/master/2019/day05.rb

#!/usr/bin/env ruby

ary = File.read(ARGV[0]).strip.split(',').map(&:to_i)

i = -1

loop do
  modes_and_op = ary[i += 1]
  op = modes_and_op % 100
  modes = modes_and_op / 100
  case op
  when 99
    break
  when 1
    v1 = ary[i += 1]
    v1 = ary[v1] if modes % 10 == 0
    modes /= 10
    v2 = ary[i += 1]
    v2 = ary[v2] if modes % 10 == 0
    pos = ary[i += 1]

This file has been truncated. show original

sb8244 · December 5, 2019, 6:20am

This one tripped me up quite a bit! I originally separated the “registers” from the program itself, on day 2, but code is data and I had to make them the same map.

github.com

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

defmodule Five do
  require Logger

  def solve(list) do
    nums = String.split(list, ",") |> Enum.map(&String.to_integer/1)

    positions = nums |> Enum.with_index() |> Enum.reduce(%{}, fn {num, p}, acc ->
      Map.put(acc, p, num)
    end)

    processor(positions, 0)
  end

  def processor(p, i) do
    {instr, modes} = case instruction(Map.get(p, i), p, i) do
      ret = {_, _} -> ret
      instr -> {instr, {:p, :p, :p}}
    end

    debug({instr, modes})

This file has been truncated. show original

aaronnamba · December 5, 2019, 6:37am

Here is my day 5, it’s not pretty.

I got stuck debugging “assembly” for quite some time because the last test case was returning nil instead of 999 for < 8.

Eventually, I gave up debugging and submitted anyway and it worked.

sasajuric · December 5, 2019, 7:54am

Here’s my solution.

Aetherus · December 5, 2019, 8:29am

No cheat this time:

github.com

Aetherus/advent_of_code/blob/master/2019/day05.exs

#!/usr/bin/env elixir

defmodule IntcodeComputer do

  @spec run(list(integer)) :: %{non_neg_integer => integer}
  def run(program) do
    program = program
              |> Stream.with_index()
              |> Stream.map(fn {n, i} -> {i, n} end)
              |> Enum.into(%{})
    run(program, 0)
  end

  @instructions %{
    1 => {:add, 2, true},
    2 => {:multiply, 2, true},
    3 => {:read, 0, true},
    4 => {:print, 1, false},
    5 => {:jump_if_true, 2, false},
    6 => {:jump_if_false, 2, false},

This file has been truncated. show original

I wonder is there a way to call private functions dynamically.

xfix · December 5, 2019, 8:43am

Making heavy use of higher-order functions. I even have functions to modify higher order functions. Worked the first time, somehow.

gitlab.com

KonradBorowski/advent_of_code_2019/blob/master/lib/day5.ex

defmodule AdventOfCode2019.Day5 do
  @moduledoc """
  Day 5 solutions
  """

  @doc """
  Solves the first riddle of day 5.

  ## Examples

      iex> AdventOfCode2019.Day5.part1("3,0,4,0,99")
      1
      iex> File.read!("inputs/day5.txt") |> AdventOfCode2019.Day5.part1
      9775037

  """
  def part1(program), do: run_with_input(program, 1)

  @doc """
  Solves the second riddle of day 5.

This file has been truncated. show original

xfix · December 5, 2019, 8:50am

(post withdrawn by author, will be automatically deleted in 24 hours unless flagged)

Aetherus · December 5, 2019, 8:52am

But what if I wanna call private functions with different arities? I guess I need to unify them.

Aetherus · December 5, 2019, 8:56am

Very intriguing. I’m gonna try that too.

xfix · December 5, 2019, 9:07am

Use Kernel.apply/2.

NobbZ · December 5, 2019, 11:25am

Okay, I got the first part up and running successfully.

After factoring the VM from day 2 into its own module, refactoring it a bit, doing bugfixing and then enhencing it, the solution itself for day 5a was pretty straight forward.

I do not have the time anymore to continue on part 2 (haven’t even read it so far) as I have to do some office work. It might become evening until I have the possibility to do side coding again. Therefore I link to the current solution in the work in progress branch:

gitlab.com

NobbZ/aoc_ex/blob/19-5/lib/y2019/d5.ex

defmodule AocEx.Y2019.D5 do
  use AocEx.Boilerplate,
    transform: fn raw ->
      raw
      |> String.split(",")
      |> Enum.map(&String.to_integer/1)
      |> AocEx.Y2019.IntcodeVM.from_list()
    end

  alias AocEx.Y2019.IntcodeVM

  def part1(input \\ processed()) do
    input
    |> IntcodeVM.set_input([1])
    |> IntcodeVM.exec()
    |> IntcodeVM.get_output()
    |> hd()
  end

  def part2(input \\ processed()) do

This file has been truncated. show original

Also the VM might be interesting;

gitlab.com

NobbZ/aoc_ex/blob/19-5/lib/y2019/intcode_vm.ex

defmodule AocEx.Y2019.IntcodeVM do
  defstruct mem: nil, input: [], output: [], ic: 0

  def from_list(list) when is_list(list) do
    mem =
      list
      |> Stream.with_index()
      |> Map.new(fn {v, k} -> {k, v} end)

    %__MODULE__{mem: mem}
  end

  def exec(%__MODULE__{mem: mem, ic: ic} = state) do
    %{^ic => intcode} = mem

    access_modes = to_access_modes(intcode)

    intcode
    |> to_opcode
    |> case do

This file has been truncated. show original

PS: The VM is totally unoptimized! The day2 runtimes suffer significantly, though optimizing the VM is not something I could find the time for in the couple of days/weeks…

cblavier · December 5, 2019, 12:13pm

Pfeww, I had a hard time to find out bugs in my code, but I finally did it …

Here is my solution https://github.com/cblavier/advent/blob/0fe0010188de83aef15a007801fa51246861901a/lib/2019/day5/day5.ex

NobbZ · December 5, 2019, 1:12pm

I finished part 2 now. Links on master are as follows (purposefully not as a onebox)

I really have to rework how I handle arities and pass the access-modes around, that feels bottlenecky (though measuring might proof me wrong, as always)

Still optimising it, is not yet scheduled.

edit:

Today I considered extracting and enhencing the VM from day 2 the real challenge, not the solving of the actual problem, and I’m really looking forward to follow ups that extend the VM even further!

This is also the reason why I will probably do them on a separate branch, as then the refactoring/enhencing process is easier to follow comapred to have some huge commit on master.

jenarvaezg · December 5, 2019, 1:50pm

Fifth day in a row writing elixir, definitely having a good time.

My solution

ColaCheng · December 5, 2019, 3:22pm

My solution

alvises · December 5, 2019, 3:26pm

Here’s my Day5 solution
and some tests to capture the output with capture_io/1

I wanted to read the user input from :stdin with IO.gets/1 but the result is a bit messy because to test the most of the functions I had to pass a function that mocks IO.gets/1, returning a value…

@sasajuric nice the queues as user input, really neat! I think I’m going to refactor mine

ferd · December 5, 2019, 3:32pm

Fighting day 5: https://www.youtube.com/watch?v=QaAmHcqwCKc

Source at: https://gist.github.com/ferd/a5c88c589df81d9e8754bac7e8457eba

keathley · December 5, 2019, 3:44pm

Here’s mine: https://github.com/keathley/advent_of_code_2019/blob/master/lib/aoc/vm.ex. My original design was pretty easy to change to support the parameter modes and whatnot so that felt good.