I thought the same.. with me it turned out they were the same length, but when I printed them (as charlists) the backslashes got quoted - ie. printed as \\ rather than \ - and so visually they looked as if they’d have different length.
exists
0
igorb
For this problem I made an exception to how I usually provide input and instead read the input from a file, because I suspected the backsplashes would mess up the input within IEx.
0
seoulection
This was it. I usually write tests asserting on the example outputs by throwing the sample inputs in a multi-line string. I’m just having this day’s tests read from a text file instead, and now I’m seeing the correct row lengths. Cheers!
0
stevensonmt
Okay, sorted it out. I was making it more complex by considering the “next” space rather than the current space and I was not using the correct origin point for rays emanating from a reflection object. Changed the origin to {0,0} and
?/ ->
trace(
new(
Nx.add(ray.origin, Nx.multiply(ray.dir, ray.len)),
update_dir(ray.dir, :reflect270)
),
scene
)
?\\ ->
trace(
new(
Nx.add(ray.origin, Nx.multiply(ray.dir, ray.len)),
update_dir(ray.dir, :reflect90)
),
scene
)
needed to be
?/ ->
dir = update_dir(ray.dir, :reflect270)
origin = Nx.add(ray.origin, Nx.multiply(ray.dir, ray.len)) |> Nx.add(dir)
trace(new(origin, dir), scene)
?\\ ->
dir = update_dir(ray.dir, :reflect90)
origin = Nx.add(ray.origin, Nx.multiply(ray.dir, ray.len)) |> Nx.add(dir)
trace(new(origin, dir), scene)
It’s still a lot slower than I’d like, probably b/c of all the calls to :ets.lookup_element and :ets.insert.
============================================================================
I’m driving myself crazy on this one. I’m blind to the error I’m making at this point though. I’m getting the right output for the test input. The real input must have some edge cases that cause an inappropriate early return because I’m getting an answer that’s too low.
@origin Nx.tensor([-1, 0])
@initial_dir Nx.tensor([1, 0])
@north Nx.tensor([0, -1])
@south Nx.tensor([0, 1])
@west Nx.tensor([-1, 0])
@east Nx.tensor([1, 0])
@horizontal [@east, @west]
@vertical [@north, @south]
defstruct origin: @origin, dir: @initial_dir, len: 0
@type t() :: %__MODULE__{dir: dir(), origin: coord(), len: integer}
@doc "Create new ray at origin {0,0} traveling east, initiate ray path at origin as initial node in path"
@spec new :: t()
def new() do
maybe_start_cache()
%__MODULE__{}
end
@doc "Create new ray at specified oring, with specified direction."
@spec new(coord(), dir()) :: t()
def new(origin, dir) do
maybe_start_cache()
%__MODULE__{origin: origin, dir: dir}
end
@spec maybe_start_cache() :: :ets.table() | atom
defp maybe_start_cache() do
if :ets.whereis(:ray_cache) == :undefined do
:ets.new(:ray_cache, [:named_table])
:ets.insert(:ray_cache, {:seen, MapSet.new()})
else
:cache_already_started
end
end
@doc "At end of ray (OOB, or reflecting/refracting), therefore update the cache with all points travelled by the ray."
@spec update_cache(t()) :: boolean
def update_cache(%__MODULE__{dir: dir, origin: origin, len: len} = _ray) do
seen = :ets.lookup_element(:ray_cache, :seen, 2)
0..len
|> Enum.reduce(seen, fn i, acc ->
MapSet.put(acc, {Nx.add(origin, Nx.multiply(dir, i)), dir})
end)
|> do_update_cache()
end
@spec do_update_cache(MapSet.t(path_el())) :: boolean
defp do_update_cache(seen) do
:ets.insert(:ray_cache, {:seen, seen})
end
@doc "Change direction the ray is traveling but not the location of end of ray."
@spec update_dir(dir(), interaction()) :: t()
def update_dir(dir, :reflect270),
do: Nx.multiply(Nx.reverse(dir), -1)
def update_dir(dir, :reflect90),
do: Nx.reverse(dir)
def update_dir(dir, _), do: dir
@doc """
Track the ray through the scene. A ray ends when it runs off the edge of the scene, refracts, or is reflected. In the
first case the cache is updated but no new ray created. In the second case the cache is updated and two rays are created,
each orthogonal to the direction of the original ray and opposite and colinear to each other. In the case of reflection,
a single new ray is created at 90° or 270° to the original ray. Note that future work could potentiall make it possible
to have objects with defined interactions that reflect or refract with customized angles but this is not currently available.
"""
@spec trace(t(), scene()) :: status()
def trace(ray, scene) do
next = Nx.add(ray.origin, Nx.multiply(ray.dir, ray.len + 1))
next_obj = Map.get(scene, List.to_tuple(Nx.to_list(next)))
cond do
next_obj == nil ->
update_cache(ray)
{:complete, :oob}
found?({next, ray.dir}) ->
ray = %__MODULE__{ray | len: ray.len + 1}
update_cache(ray)
{:complete, :loop}
true ->
ray = %__MODULE__{ray | len: ray.len + 1}
update_cache(ray)
do_trace(ray, next_obj, scene)
end
end
@spec found?(path_el()) :: boolean
defp found?({coord, dir}) do
seen = :ets.lookup_element(:ray_cache, :seen, 2)
MapSet.member?(seen, {coord, dir})
end
@spec do_trace(t(), obj(), scene()) :: status()
def do_trace(ray, obj, scene) do
case obj do
nil ->
{:complete, :oob}
?. ->
trace(ray, scene)
?- when ray.dir in @horizontal ->
trace(ray, scene)
?| when ray.dir in @vertical ->
trace(ray, scene)
?/ ->
trace(
new(
Nx.add(ray.origin, Nx.multiply(ray.dir, ray.len)),
update_dir(ray.dir, :reflect270)
),
scene
)
?\\ ->
trace(
new(
Nx.add(ray.origin, Nx.multiply(ray.dir, ray.len)),
update_dir(ray.dir, :reflect90)
),
scene
)
?- ->
refract_h(ray, scene)
?| ->
refract_v(ray, scene)
end
end
@spec refract_h(t(), scene()) :: status()
def refract_h(ray, scene) do
origin = Nx.add(ray.origin, Nx.multiply(ray.dir, ray.len))
trace(new(origin, @east), scene)
trace(new(origin, @west), scene)
end
@spec refract_v(t(), scene()) :: status()
def refract_v(ray, scene) do
origin = Nx.add(ray.origin, Nx.multiply(ray.dir, ray.len))
trace(new(origin, @north), scene)
trace(new(origin, @south), scene)
end
I’m parsing the input into a map of %{{col, row} => char} and getting the count from
:ets.lookup_element(:ray_cache, :seen, 2)
|> Enum.map(&elem(&1, 0))
|> Enum.map(&Nx.to_list/1)
|> Enum.reject(fn n -> n == {-1, 0} end)
|> Enum.uniq()
|> Enum.count()
0
trnasistor
My beginner’s solution, Day 16 part 1.
I decided this was a good opportunity to learn elixir processes.
For each tile, a process is spawned that “knows” it’s type and pids of it’s neighbors.
When a process receives a message, it sends a message(s), depending on tile type and source location. First time it happens, it also sends a message to :energized which counts towards the result.
It was tricky to get my head around it and get it right, but I’m pretty proud I succeeded.
I can still see many ways to improve, but I will take those lessons with me for Advent of Code 2024.
Cheers 
defmodule Day16 do
def part1(input) do
{border_pid,
top_left_tile_pid} = initialize(input)
Process.register spawn(fn -> energized() end), :energized
send(top_left_tile_pid, border_pid) # the beam enters
end
def energized(count \\ 0) do
receive do
_ -> energized(count+1)
after # 1000ms without a message
1000 -> IO.puts "No. energized tiles: #{count} "
end
end
def init(tile), do: (receive do {l, u, r, d} -> tile_cold(l, u, r, d, tile) end)
def tile_cold(left, up, right, down, tile) do
reflect(left, up, right, down, tile)
send(:energized, self())
tile_hot(left, up, right, down, tile)
end
def tile_hot(left, up, right, down, tile) do
reflect(left, up, right, down, tile)
tile_hot(left, up, right, down, tile)
end
def reflect(left, up, right, down, tile) do
case tile do
#dot
:. -> receive do
^left -> right
^up -> down
^right -> left
^down -> up
end |> send(self())
#slash
:/ -> receive do
^left -> up
^up -> left
^right -> down
^down -> right
end |> send(self())
#backslash
:"\\" -> receive do
^left -> down
^up -> right
^right -> up
^down -> left
end |> send(self())
#pipe
:| -> receive do
^left -> [up, down]
^up -> [down]
^right -> [up, down]
^down -> [up]
end |> Enum.map(&send(&1, self()))
#dash
:- -> receive do
^left -> [right]
^up -> [left, right]
^right -> [left]
^down -> [left, right]
end |> Enum.map(&send(&1, self()))
end
end
def loop(), do: loop()
def initialize(raw_layout) do
border = spawn(fn -> loop() end)
border_row = raw_layout
|> String.split("\n")
|> List.first
|> String.length
|> then(&List.duplicate(border, (&1)+2))
grid = raw_layout
|> String.split("\n")
|> Enum.map(fn raw_line -> raw_line
|> String.graphemes
|> Enum.map(&String.to_atom/1)
|> Enum.map(&spawn(__MODULE__, :init, [&1]))
|> then(&([border] ++ &1 ++ [border]))
end)
|> then(&([border_row] ++ &1 ++ [border_row]))
for {row, r} <- Enum.with_index(grid) |> Enum.slice(1..-2) do
for {pid, c} <- Enum.with_index(row) |> Enum.slice(1..-2) do
left = grid |> Enum.at(r) |> Enum.at(c-1)
up = grid |> Enum.at(r-1) |> Enum.at(c)
right = grid |> Enum.at(r) |> Enum.at(c+1)
down = grid |> Enum.at(r+1) |> Enum.at(c)
send(pid, {left, up, right, down})
end
end
{
border,
grid |> Enum.at(1) |> Enum.at(1)
}
end
end
PS. Check this out (not me):
https://nitter.net/miladamilli/status/1736095441798795746#m
0