I have never written a macro before, but part one inspired me to give it a go. In hindsight, it was a bad idea, but it worked for part one.
defmodule LinenLayout do
defmacro __using__(_opts) do
quote do
import LinenLayout
# safeq (resp. safer) is needed, because I wanted a clause like:
# def q(_), do: 0
# but Idk how to make sure that clause comes _after_ all the def's
# that would be expanded from macros, so instead I use try/rescue to
# catch invocations that don't have matching defs (e.g., patterns s.t. no
# towel exists for.
def safeq(x) do
try do
q(x)
rescue _ -> nil
end
end
def safer(x) do
try do
r(x)
rescue _ -> nil
end
end
# these two stop the recursive steps below
def qq(nil) do
0
end
# using `raise` for control flow. I don't like it, but I was desperate
# will be rescued in `count_makeable`
def qq(1) do
raise "yes"
end
def qq(x) do
(safeq(x) |> qq()) + (safer(x) |> qq())
end
# invoked when there is no pattern left - we had all the towels we needed
def q(""), do: 1
def r(""), do: 1
def count_makeable(towels) do
towels
|> String.split("\n", trim: true)
|> Stream.map(&
try do
qq(&1)
# qq throws when `safeq` (resp. `safer`) finished completing a patttern
rescue _ in RuntimeError -> 1
end)
|> Enum.sum()
end
end
end
# I didn't need `f` _and_ `h`, but I wanted
# the macro to expand out to functions with different names.
# there is a way to do this as an arg to the macro, but i was lazy.
# these are exactly the same, to understand why they exist, read `g/1`
#
# The basic idea of the approach is that we will use Elixir's binary
# pattern matching to do all of the work. Each towel in our
# inventory will get its own `def q(color <> rest)`. We will recursively call on `q(rest)`
# until either:
# (a) We exhaust the pattern (yay, we had all the towels we needed!)
# (b) we throw an error for no clause matching input params (the pattern began
# with color we don't have a towel for).
defmacro f(i) do
quote do
def q(unquote(i) <> rest), do: rest
end
end
defmacro h(i) do
quote do
def r(unquote(i) <> rest), do: rest
end
end
# takes a list of towels and expands out to two sets of functions:
# one set where the clauses are ordered longest towel first, e.g.,
# if `bgr` and `b` are both towels `q("bgr" <> rest)` will appear before
# `q("b" <> rest)`.
# the other set is reversed - these are the `r` functions, expanded from `h`, above.
#
# why did I do this? because just one of these directions will miss some patterns
# because they will be greedy in either using the towels with more stripes first or
# using the towels with the least stripes first. Doing both was my attempt to fix the
# issue where either of these under counted. This doesn't _really_ fix the real issue.
# There could be a towel `"bg"` that is "between" `"bgr"` and `"b"` that would never be
# accounted for if the pattern began with `"bgr"`. In fact, this exact issue is probably why
# this approach will not work for pt. 2.
defmacro g(u) do
# `u` is the list of towels we have
u = u
|> String.split(", ")
# expand out `f` for all the towels
(u
|> Enum.sort_by(fn l -> -String.length(l) end)
|> Enum.map(fn o ->
quote do
f(unquote(o))
end
end)
)
++
(
# then expand out `h`
u
|> Enum.sort_by(&(String.length(&1)))
|> Enum.map(&(quote do h(unquote(&1)) end))
)
end
end
Now actually solving part 1:
defmodule Foo do
use LinenLayout
g "r, wr, b, g, bwu, rb, gb, br"
end
"""
brwrr
bggr
gbbr
rrbgbr
ubwu
bwurrg
brgr
bbrgwb
"""
|> Foo.count_makeable()
