super inefficient … but did you have fun writing it? 
cblavier
billylanchantin
Haha yes I did, thanks! I think it’s fun to see how short I can make the solutions rather than how fast, so that’s what I’m doing this year.
1
Awlexus
Before doing the challenge I decided to check which data structure would be ideal for fast random access and binaries won, so I based my code on that.
Benchmark of randomly accessing every letter of the first 5 paragraphs of lorem ipsum in a random order
Name ips average deviation median 99th %
binary 7.92 K 126.33 μs ±6.69% 124.37 μs 149.82 μs
tuple random access 6.12 K 163.31 μs ±6.54% 160.95 μs 193.62 μs
list 5.36 K 186.71 μs ±5.73% 184.37 μs 211.32 μs
Comparison:
binary 7.92 K
tuple random access 6.12 K - 1.29x slower +36.98 μs
list 5.36 K - 1.48x slower +60.38 μs
Time to solve on my machine:
Day 1: 7.348 ms
Day 2: 1.04 ms
2
BartOtten
So there’s another one. Didn’t bother to check performance while writing but did care about clarity of the code and flexibility. It’s not Xmas every day…
Would like to compare performance, but most post don’t have timing information.
Solution for 2024 day 4
part_one: 2536 in 22.95ms
part_two: 1875 in 15.2ms
Improvements possible:
- district horizontal and vertical movement
- proper names for directions instead of [-1,1,0]
- refactor some ugly property drilling
- refactor all function at the bottom…as they are…different.
Code!
defmodule Aoc2024.Solutions.Y24.Day04 do
alias AoC.Input
def part_one(problem) do
grid = to_grid(problem)
coordinates = find_coordinates(grid, "XMAS")
Enum.count(coordinates)
end
def part_two(problem) do
grid = to_grid(problem)
coordinates = find_coordinates(grid, "MAS", directions: [-1, 1])
cross_coordinates = find_crosses(coordinates, fn [_, pos_a, _] -> pos_a end)
Enum.count(cross_coordinates)
end
defp find_coordinates(grid, <<marker::utf8>> <> _ = word, opts \\ []) do
grid
|> list_marker_positions(<<marker>>)
|> Enum.map(&generate_candidates(&1, String.length(word), opts))
|> find_word_in_candidates(grid, word)
end
defp list_marker_positions(grid, marker) do
for {row, cols} <- grid, {col, ^marker} <- cols do
{row, col}
end
end
defp generate_candidates({row, col} = _pos, length, opts) do
directions = Keyword.get(opts, :directions, [-1, 1, 0])
for row_shift <- directions, col_shift <- directions do
for shift <- 0..(length - 1) do
{row + shift * row_shift, col + shift * col_shift}
end
end
end
defp find_crosses(coordinates, group_fun) do
coordinates
|> Enum.group_by(&group_fun.(&1))
|> Enum.filter(fn {_, candidates} -> candidates |> Enum.count() >= 2 end)
end
defp find_word_in_candidates(candidates, grid, word) do
wordlist = String.split(word, "", trim: true)
for candidate <- candidates, positions <- candidate, reduce: [] do
acc ->
result =
for {row, col} <- positions do
grid[row][col]
end
(result == wordlist && [positions | acc]) || acc
end
end
defp to_grid(input) do
for row <- input do
String.split(row, "", trim: true) |> to_index_map()
end
|> to_index_map()
end
defp to_index_map(input) do
input |> Enum.with_index(fn el, col_idx -> {col_idx, el} end) |> Map.new()
end
def parse(input, _part) do
input
|> Input.stream!(trim: true)
end
end
0
mwilsoncoding
Had to get some sleep and deal with work today. Catching up with this late, but still day of.
Part 1:
#!/usr/bin/env elixir
defmodule Day4.Part1 do
defp transpose(%{rows: rows} = haystack) do
%{haystack | rows: Enum.zip(rows) |> Enum.map(&Tuple.to_list/1)}
end
defp count_linear(row, needle, length) do
stride = needle |> Enum.count()
for x <- 0..(length - stride) do
slice = Enum.slice(row, x..(x + stride - 1))
equal? = slice == needle
if equal?, do: 1, else: 0
end
|> Enum.sum()
end
defp count_horizontal(%{rows: rows, length: length}, needle) do
rows
|> Enum.reduce(
0,
fn row, acc ->
acc + count_linear(row, needle, length) + count_linear(Enum.reverse(row), needle, length)
end
)
end
defp count_vertical(haystack, needle) do
count_horizontal(transpose(haystack), needle)
end
defp skew(%{rows: rows, length: length} = haystack) do
%{
haystack
| rows:
for(_ <- 1..(length - 1), do: for(_ <- 1..(length + length - 1), do: nil)) ++
(rows
|> Enum.reduce(
%{i: 0, j: length - 1, rows: []},
fn row, state ->
%{
i: state.i + 1,
j: state.j - 1,
rows: [
if(state.i == 0, do: [], else: for(_ <- 1..state.i, do: nil)) ++
row ++ if(state.j == 0, do: [], else: for(_ <- 1..state.j, do: nil))
| state.rows
]
}
end
)
|> Map.get(:rows)
|> Enum.reverse()),
length: length + length - 1
}
end
defp count_diagonal(%{rows: rows} = haystack, needle) do
backslash_count =
haystack
|> skew()
|> count_vertical(needle)
forward_slash_count =
%{haystack | rows: rows |> Enum.map(&Enum.reverse/1)}
|> skew()
|> count_vertical(needle)
backslash_count + forward_slash_count
end
defp count(haystack, needle) do
count_horizontal(haystack, needle) + count_vertical(haystack, needle) +
count_diagonal(haystack, needle)
end
defp parse(str) do
lines =
str
|> String.split("\n")
rowcount =
lines
|> Enum.count()
rows =
lines
|> Enum.map(&to_charlist/1)
length = rows |> List.first() |> Enum.count()
^length = rowcount
%{
length: length,
rows: rows
}
end
def solve() do
needle = ~c"XMAS"
haystack =
File.read!("04/input.txt")
|> parse()
count(haystack, needle)
|> IO.puts()
end
end
Day4.Part1.solve()
Part 2:
#!/usr/bin/env elixir
defmodule Day4.Part2 do
@mas ~c"MAS"
defp count_crosses([a | [_a_2 | [a_3 | _a_t]] = tail_a], [_b | [b_2 | [_b_3 | _b_t]] = tail_b], [
c | [_c_2 | [c_3 | _c_t]] = tail_c
]) do
top_down_backslash? = [a, b_2, c_3] == @mas
bottom_up_backslash? = [c_3, b_2, a] == @mas
top_down_forward_slash? = [a_3, b_2, c] == @mas
bottom_up_forward_slash? = [c, b_2, a_3] == @mas
if (top_down_backslash? and bottom_up_forward_slash?) or
(bottom_up_backslash? and bottom_up_forward_slash?) or
(top_down_backslash? and top_down_forward_slash?) or
(bottom_up_backslash? and top_down_forward_slash?) do
1
else
0
end
|> (fn x -> x + count_crosses(tail_a, tail_b, tail_c) end).()
end
defp count_crosses([_, _], [_, _], [_, _]), do: 0
defp count_mas([row_a | [row_b | [row_c | _t]] = tail]) do
count_crosses(row_a, row_b, row_c) + count_mas(tail)
end
defp count_mas([_row_a , _row_b]), do: 0
defp parse(str) do
str
|> String.split("\n")
|> Enum.map(&to_charlist/1)
end
def solve() do
haystack =
File.read!("04/input.txt")
|> parse()
count_mas(haystack)
|> IO.puts()
end
end
Day4.Part2.solve()
0
sevenseacat
Author of Ash Framework
I do benchmarking for all of my solutions - here’s my 2024 day 4 
Name ips average deviation median 99th %
day 04, part 1 0.109 K 9206.98 μs ±3.53% 9049.48 μs 10099.13 μs
day 04, part 2 0.120 K 8363.73 μs ±4.76% 8099.29 μs 9391.84 μs
That was on my M1 Max though…
0
al2o3cr
Saw a meme about day 4 on r/adventofcode, so my part 1 solution was somewhat overengineered - but it was an easy jump to part 2 as a result.
For fun, tried to write the whole thing in a local-variable-free style, which makes for very arrow-shaped functions.
Part 1:
defmodule PatternFinder do
defmodule Grid do
defstruct [:by_char, :by_pos]
def init do
%__MODULE__{
by_char: %{},
by_pos: %{}
}
end
def add(g, char, pos) do
%{g |
by_char: Map.update(g.by_char, char, MapSet.new([pos]), &MapSet.put(&1, pos)),
by_pos: Map.put(g.by_pos, pos, char)
}
end
def get(g, pos) do
Map.fetch(g.by_pos, pos)
end
def where(g, char) do
Map.fetch!(g.by_char, char)
end
end
def read(filename) do
File.stream!(filename)
|> Stream.map(&String.trim/1)
|> Stream.map(&String.graphemes/1)
|> Stream.with_index()
|> Stream.flat_map(fn {chars, row} ->
chars
|> Enum.with_index()
|> Enum.map(fn {c, col} ->
{{row, col}, c}
end)
end)
|> Enum.reduce(Grid.init(), fn {pos, char}, grid ->
Grid.add(grid, char, pos)
end)
end
@patterns [
%{
start_at: "X",
neighbors: %{
"M" => {0,1},
"A" => {0,2},
"S" => {0,3}
}
},
%{
start_at: "X",
neighbors: %{
"M" => {0,-1},
"A" => {0,-2},
"S" => {0,-3}
}
},
%{
start_at: "X",
neighbors: %{
"M" => {1,0},
"A" => {2,0},
"S" => {3,0}
}
},
%{
start_at: "X",
neighbors: %{
"M" => {-1,0},
"A" => {-2,0},
"S" => {-3,0}
}
},
%{
start_at: "X",
neighbors: %{
"M" => {1,1},
"A" => {2,2},
"S" => {3,3}
}
},
%{
start_at: "X",
neighbors: %{
"M" => {-1,1},
"A" => {-2,2},
"S" => {-3,3}
}
},
%{
start_at: "X",
neighbors: %{
"M" => {1,-1},
"A" => {2,-2},
"S" => {3,-3}
}
},
%{
start_at: "X",
neighbors: %{
"M" => {-1,-1},
"A" => {-2,-2},
"S" => {-3,-3}
}
},
]
def matches(grid) do
@patterns
|> Enum.flat_map(fn pattern ->
grid
|> Grid.where(pattern.start_at)
|> Enum.filter(fn {row, col} ->
pattern.neighbors
|> Enum.all?(fn {expected_char, {row_off, col_off}} ->
case Grid.get(grid, {row + row_off, col + col_off}) do
:error -> false
{:ok, char} -> char == expected_char
end
end)
end)
end)
end
end
PatternFinder.read("input.txt")
|> PatternFinder.matches()
|> IO.inspect()
|> length()
|> IO.inspect()
Part 2:
defmodule PatternFinder do
defmodule Grid do
defstruct [:by_char, :by_pos]
def init do
%__MODULE__{
by_char: %{},
by_pos: %{}
}
end
def add(g, char, pos) do
%{g |
by_char: Map.update(g.by_char, char, MapSet.new([pos]), &MapSet.put(&1, pos)),
by_pos: Map.put(g.by_pos, pos, char)
}
end
def get(g, pos) do
Map.fetch(g.by_pos, pos)
end
def where(g, char) do
Map.fetch!(g.by_char, char)
end
end
def read(filename) do
File.stream!(filename)
|> Stream.map(&String.trim/1)
|> Stream.map(&String.graphemes/1)
|> Stream.with_index()
|> Stream.flat_map(fn {chars, row} ->
chars
|> Enum.with_index()
|> Enum.map(fn {c, col} ->
{{row, col}, c}
end)
end)
|> Enum.reduce(Grid.init(), fn {pos, char}, grid ->
Grid.add(grid, char, pos)
end)
end
@patterns [
%{
start_at: "A",
neighbors: %{
{-1,-1} => "M",
{1,-1} => "M",
{-1,1} => "S",
{1,1} => "S"
}
},
%{
start_at: "A",
neighbors: %{
{-1,-1} => "S",
{1,-1} => "M",
{-1,1} => "S",
{1,1} => "M"
}
},
%{
start_at: "A",
neighbors: %{
{-1,-1} => "S",
{1,-1} => "S",
{-1,1} => "M",
{1,1} => "M"
}
},
%{
start_at: "A",
neighbors: %{
{-1,-1} => "M",
{1,-1} => "S",
{-1,1} => "M",
{1,1} => "S"
}
},
]
def matches(grid) do
@patterns
|> Enum.flat_map(fn pattern ->
grid
|> Grid.where(pattern.start_at)
|> Enum.filter(fn {row, col} ->
pattern.neighbors
|> Enum.all?(fn {{row_off, col_off}, expected_char} ->
case Grid.get(grid, {row + row_off, col + col_off}) do
:error -> false
{:ok, char} -> char == expected_char
end
end)
end)
end)
end
end
PatternFinder.read("input.txt")
|> PatternFinder.matches()
|> IO.inspect()
|> length()
|> IO.inspect()
0
jarlah
Part1 was so hard! I think i must have digged my self into a rabbit hole or something, because the natural “human approach” is often translatable into a program.
First i started to look for horizontals and verticals, and made a count function for both. Easy. Then i made a new function for counting diagonals. Thats where the hell began. But i still dont know why.
Anyway. Due to me wanting total control and be able to cross reference, my program outputs this
[
{0, 4, 3, 7, "XMAS"},
{0, 5, 0, 8, "XMAS"},
{1, 1, 1, 4, "SAMX"},
{1, 6, 4, 6, "SAMX"},
{2, 3, 5, 6, "SAMX"},
{2, 3, 5, 0, "SAMX"},
{3, 9, 6, 9, "XMAS"},
{3, 9, 6, 6, "XMAS"},
{4, 0, 4, 3, "XMAS"},
{4, 3, 4, 6, "SAMX"},
{6, 0, 9, 3, "SAMX"},
{6, 2, 9, 5, "SAMX"},
{6, 4, 9, 1, "SAMX"},
{6, 6, 9, 9, "SAMX"},
{6, 6, 9, 3, "SAMX"},
{6, 8, 9, 5, "SAMX"},
{6, 9, 9, 9, "SAMX"},
{9, 5, 9, 8, "XMAS"}
]
which is start row id, start col id, end row id, end col id and the word it found
https://github.com/jarlah/advent_of_code/blob/master/lib/2024/day_4/Part1.ex
i almost never publishes unpolished code like this, but i cant stand working on it more 
1
jarlah
at least part2 didnt kill my soul
https://github.com/jarlah/advent_of_code/blob/master/lib/2024/day_4/Part2.ex
1
BartOtten
Looking at your code I see which rabbit hole you experienced. I experienced the same and just dropped all code and started from scratch.
You made it, which is the most important
3