This is not syntactic sugar, this just avoids unnecessary atom generation in compile-time. And I’d suggest using quote instead of building AST from structures. quote preserves metadata and context for operators
hst337
0
mudasobwa
Creator of Cure
Excuse me? elixir/lib/elixir/lib/macro.ex at v1.14.2 · elixir-lang/elixir · GitHub
I know. Why would I ever need metadata here?
0
hst337
Debugging
Hahaha, I thought since they had counter in metadata, they wouldn’t generate atoms in this function. My bad, I didn’t even think that this function was so broken
0
mudasobwa
Creator of Cure
One obviously cannot generate AST for def foo(arg) without having arg atom, because its AST would contain {:arg, [], nil} I am not sure what do you mean under “broken.”
I prefer to write the code that works from scratch.
0
hst337
Did the second part with some metaprogramming
n = 14
defmodule Helper do
def pairs([head | tail]) do
pairs_with_head = Enum.map(tail, fn tail_item -> {head, tail_item} end)
pairs_with_head ++ pairs(tail)
end
def pairs([]), do: []
end
defmodule AOC do
vars = Macro.generate_unique_arguments(n, __MODULE__)
guard =
vars
|> Helper.pairs()
|> Enum.map(fn {left, right} -> quote do: unquote(left) != unquote(right) end)
|> Enum.reduce(fn neq, expr -> quote do: unquote(neq) and unquote(expr) end)
def traverse(string, acc \\ 0) do
case string do
<<unquote_splicing(vars), _tail :: binary>> when unquote guard ->
acc + unquote(n)
<<_, tail :: binary>> ->
traverse(tail, acc + 1)
end
end
end
IO.inspect AOC.traverse IO.read :eof
0
hst337
Pow-pow, 1000x-developer rockstar ninja in this thread
Nah, I meant that {name, [counter: 1], context} and {name, [counter: 2], context} are different variables and are treated as different variables.
So, instead of generating 1000 atoms for Macro.generate_unique_arguments(1000, __MODULE__), it could just use this :arg as a name atom for each variable and just have different [counter: counter] in metadata
The only problem with this solution is that code inspection will suck, since all variables are named exactly the same. But this is a known issue, since contexts are simply ignored in all AST-to-String functions
0
jfburdet
Here is my solution of this easy day. As usual I prefer expressive readable code.
defmodule AOCHelpers do
def find_marker(str, chunk_length) do
chunks =
str
|> String.to_charlist()
|> Enum.chunk_every(chunk_length, 1, :discard)
|> Enum.with_index()
{marker, idx} =
chunks
|> Enum.map(fn {chunk, idx} -> {Enum.uniq(chunk), idx} end)
|> Enum.filter(fn {chunk, _idx} -> length(chunk) == chunk_length end)
|> Enum.at(0)
{marker, idx + chunk_length}
end
end
1
Pistrie
This one was very easy, but I would love to hear what I can improve on
# window_size 4
# window_overlap 1
# index + window_size = answer
input
|> String.to_charlist()
|> Enum.chunk_every(4, 1, :discard)
|> Enum.with_index()
|> Enum.reduce_while(0, fn {window, index}, marker_index ->
if Enum.uniq(window) |> length() == 4 do
{:halt, marker_index + index + 4}
else
{:cont, marker_index}
end
end)
0
adamu
Part 1 completes in 61 microseconds using a guard. Not so good for part 2, where my feeble brain wasn’t capable of writing a guard for 14 characters and I went with Enum.uniq.
https://git.adamu.jp/adam/AdventOfCode/src/branch/main/2022/day6.exs
0