Such a pragmatic solution 
, I was so tired when tackling this and spent more-time-than-I-want-to-admit solving for merging the numbers back after splitting with String.graphemes() due to those parenthesis without whitespace 
Hallski
3
camilleryr
I originally parsed each equation into an expression tree to evaluate them - which worked, but then I saw on reddit someone mention the shunting yard algorithm - did a bunch of reading on operator precedence parsing and stack based calculators and was able to refactor my code in a really satisfying way. The implementation of the algorithm and the evaluator could use some clean up, but it works, and it works about 10 times faster then the expression tree approach
https://github.com/camilleryr/advent20/blob/main/lib/day_18.ex
4
felix-alonso
Honestly, I’m a bit blown away by people cracking open the AST and evaluating the expressions in Elixir. Once advent of code is complete I feel like I need to go back through the days and really try to grock everyone’s code. Lot’s of good stuff that I haven’t had the chance to look at.
I had a much more mundane, tree based approach. My solution to part 2 was just to wrap addition in some parens.
defmodule Day18 do
def part_1, do: load() |> Enum.map(&interpret/1) |> Enum.sum()
def part_2, do: load() |> Enum.map(&interpret2/1) |> Enum.sum()
def interpret(text), do: text |> lex() |> parse() |> eval()
def interpret2(text), do: text |> lex() |> parse() |> wrap() |> eval()
def lex(""), do: []
def lex(" " <> rest), do: lex(rest)
def lex(<<n::bytes-size(1)>> <> rest) when n in ["(", ")", "+", "*"], do: [n|lex(rest)]
def lex(<<n::bytes-size(1)>> <> rest), do: [String.to_integer(n)|lex(rest)]
def parse(tokens=["("|_]), do: parse(match_parens(tokens, []))
def parse([n|rest]), do: [parse(n)|parse(rest)]
def parse(n), do: n
def match_parens(["("|t], stack), do: match_parens(t, [[]|stack])
def match_parens([")"|t], [c,p|rest]), do: match_parens(t, [[parse(Enum.reverse(c))|p]|rest])
def match_parens([")"|rest], [group]), do: [Enum.reverse(group)|rest]
def match_parens([n|t], [group|rest]), do: match_parens(t, [[n|group]|rest])
def wrap([]), do: []
def wrap([left, "+", right|rest]), do: wrap([[wrap(left), "+", wrap(right)]|rest])
def wrap([left, "*", right|rest]), do: [wrap(left), "*"| wrap([wrap(right)|rest])]
def wrap([n]), do: [n]
def wrap(n), do: n
def eval(prev, []), do: prev
def eval(prev, ["+", n|rest]), do: eval(prev + eval(n), rest)
def eval(prev, ["*", n|rest]), do: eval(prev * eval(n), rest)
def eval([n, "+", m|rest]), do: eval(eval(n) + eval(m), rest)
def eval([n, "*", m|rest]), do: eval(eval(n) * eval(m), rest)
def eval([l=[_|_]]), do: eval(l)
def eval(n), do: n
def load, do: File.read!("day-18.input") |> String.split("\n", trim: true)
end
0
Hallski
That’s what I also ended up doing but my code was a lot messier. Tried reimplementing it using the Shunting Yard algorithm suggested by @camilleryr which made it a lot nicer and easier to change as part 2 would have been a simple change of:
def precedence(operator) do
case operator do
"+" -> 3
"*" -> 2
end
end
Was a fun exercise!
The code if anyone is interested.
And the code from this morning
0
lud
I tried to do that in Elixir tonight, it works. Of course, it is absolutely terrible. But it works 
I still like my first solution better though.
defmodule NoPrecedence do
import Kernel, except: [-: 2]
def a - b, do: a * b
def eval(expression) do
env = Map.update!(__ENV__, :functions, &[{__MODULE__, -: 2} | &1])
expression
|> String.replace("*", "-")
|> Code.eval_string([], env)
|> elem(0)
end
end
defmodule AdditionPrecedence do
import Kernel, except: [-: 2, /: 2]
def a / b, do: a + b
def a - b, do: a * b
def eval(expression) do
env = Map.update!(__ENV__, :functions, &[{__MODULE__, -: 2}, {__MODULE__, "/": 2} | &1])
expression
|> String.replace("+", "/")
|> String.replace("*", "-")
|> Code.eval_string([], env)
|> elem(0)
end
end
for line <- File.stream!("../src/adventofcode/priv/input/2020/day-18.inp") do
NoPrecedence.eval(line)
end
|> Enum.sum()
|> IO.inspect(label: "part 1")
for line <- File.stream!("../src/adventofcode/priv/input/2020/day-18.inp"), reduce: 0 do
sum -> sum + AdditionPrecedence.eval(line)
end
|> IO.inspect(label: "part 2")
0
adamu
Slower pace now so I only just got around to finishing this.
I noticed Part 1 could be optimised to just walk the string, using recursion for the parentheses. Unfortunately, that meant I had to effectively start again for Part 2. Here’s an excerpt from Part 1:
def evaluate(command), do: evaluate(command, nil, 0)
def evaluate([], nil, acc), do: acc
def evaluate(["*" | rest], nil, acc), do: evaluate(rest, "*", acc)
def evaluate(["+" | rest], nil, acc), do: evaluate(rest, "+", acc)
def evaluate(["(" | rest], op, acc), do: evaluate(rest) |> evaluate(op, acc)
def evaluate([")" | rest], nil, acc), do: [acc | rest]
def evaluate([num | rest], "*", acc), do: evaluate(rest, nil, acc * num)
def evaluate([num | rest], "+", acc), do: evaluate(rest, nil, acc + num)
def evaluate([num | rest], nil, 0), do: evaluate(rest, nil, num)
I also went the AST route for Part 2, first building up a tree and then evaluating it. I spent more time that I care to admit on that fixing silly bugs and staring at logging output, and the end result is not exactly pretty either. I wasn’t sure how to parse the precedence correctly. I decided to do it in two passes: first construct the + operations, then go back and pick up any * operations left - although it felt pretty awkward.
I wanted to do the AST, so it was a good exercise, but I wish I’d come up with @princemaple’s elegant solution.
0
al2o3cr
This seemed like a good time to try out NimbleParsec, it worked out pretty well:
https://github.com/al2o3cr/advent-of-code-2020/blob/main/day18/part1.exs
I still don’t have a great mental model for what adding wrap() does, but some experimentation got me through.
I’m curious what somebody who knows the library better would do…
0