Nothing too fancy. I did some basic optimizations like checking only from X (in p1) and A (in p2), plus reduce_while in p1 to stop early if there’s no matches.
https://github.com/mexicat/aoc-2024/blob/main/lib/aoc/day_04.ex
mexicat
0
ken-kost
Added some padding and made sub matrixes. Not optimal at all. 
defmodule Aoc2024.Solutions.Y24.Day04 do
alias AoC.Input
def parse(input, part) do
input =
input
|> Input.stream!(trim: true)
|> Enum.map(&String.codepoints(&1 <> "YYY"))
|> (fn input -> input ++ padding(length(hd(input))) end).()
n = if part == :part_one, do: 4, else: 3
for x <- 0..(length(input) - n), y <- 0..(length(hd(input)) - n) do
{_, rest_x} = Enum.split(input, x)
rest_rows = Enum.take(rest_x, n)
Enum.map(rest_rows, fn rest_row ->
{_, rest_y} = Enum.split(rest_row, y)
Enum.take(rest_y, n)
end)
end
end
def part_one(problem), do: Enum.reduce(problem, 0, &(&2 + count_xmas(&1)))
def part_two(problem), do: Enum.reduce(problem, 0, &(&2 + count_mas(&1)))
defp count_xmas([[a1, a2, a3, a4], [b1, b2, b3, _b4], [c1, c2, c3, _c4], [d1, _d2, _d3, d4]]) do
list = [
a1 <> a2 <> a3 <> a4,
a1 <> b1 <> c1 <> d1,
a1 <> b2 <> c3 <> d4,
a4 <> b3 <> c2 <> d1
]
Enum.reduce(list, 0, fn e, acc ->
case e do
"XMAS" -> acc + 1
"SAMX" -> acc + 1
_ -> acc
end
end)
end
defp count_mas([[a1, _a2, a3], [_b1, b2, _b3], [c1, _c3, c3]]) do
case b2 <> a1 <> a3 <> c1 <> c3 do
"AMMSS" -> 1
"ASSMM" -> 1
"ASMSM" -> 1
"AMSMS" -> 1
_ -> 0
end
end
defp padding(n) do
for _ <- 0..2 do
for _ <- 0..(n - 1) do
"Y"
end
end
end
end
Solution for 2024 day 4
part_one: 2427 in 82.75ms
part_two: 1900 in 49.76ms
I could try nx now that I thought about it… 
0
adamu
Ugh. Grids. Just grunt work.
I decided to use :array to represent the grid as I know the O(log n) lookup of maps are not ideal. Combined with for, it’s not very elixir-like. I agree with @lkuty that native code is probably the way to go for this kind of thing. I might come back to this when I have more free time next year to try it with Zigler.
Four of these for part 1:
for y <- 0..(n - 1), x <- 0..(n - 4), reduce: 0 do
count ->
for x_offset <- 0..(4 - 1), into: "" do
:array.get(x + x_offset, :array.get(y, grid))
end
|> consider(count)
end
and some similar stuff in part 2.
On my M1 the times were 15ms and 4ms. Not sure how that compares to the Map solutions.
https://git.adamu.jp/adam/AdventOfCode/src/branch/main/2024/day4.exs
0
Flo0807
It took me some time to get to the solution today. I solved part 2 by counting the diagonal occurrences of “MAS” in the 3x3 grid around the current position. If there are more than one then it is a valid X. I wondered if it was possible to have more than two “MAS” occurrences, but it is not because if two edges start with “M” then the other two edges must end with “S” obviously 
For both solutions, I construct the full word / sequence before comparing it with “MAS” or "XMAS. An optimization would be to stop earlier, e.g., if the word doesn’t start with X or M at all…
Source Code:
https://github.com/Flo0807/adventofcode/blob/main/2024/04.livemd
0
lkuty
It looks like Erlang arrays use a tree (trie maybe?) data structure and have O(log n) time complexity. See otp/lib/stdlib/src/array.erl at 44ffe8811dfcf3d2fe04d530c6e8fac5ca384e02 · erlang/otp · GitHub
I “cheated” a little bit because the C implementation is not just for 2D arrays of ints but it is specifically made for that problem. It allows to avoid many round-trips between Elixir and C as we check if we have an XMAS candidate. I could have gone all-in with C but then the Elixir code would have just been some sort of a driver for the C code. Would have been faster for sure.
0
adamu
Haha, oh well. I wonder why that info hidden in a comment instead of being in the moduledocs (which I read before starting, but didn’t find any information about performance…)
1
lkuty
netto
For part 1 I rotates the matrix instead of looking in differente directions.
And for part 2, I went with a sliding window using Enum,chunks =)
defmodule Smaoc.Solution.Day4 do
def solve(:part1, input) do
matrix = parse_input(input)
[
[],
[:reverse],
[:transpose],
[:transpose, :reverse],
[:rotate45],
[:rotate45, :reverse],
[:reverse, :rotate45],
[:reverse, :rotate45, :reverse]
]
|> Enum.map(
&(matrix
|> apply_operations(&1)
|> count_XMAS)
)
|> Enum.sum()
end
def solve(:part2, input) do
valid_patterns = [
~r/M.M.A.S.S/,
~r/M.S.A.M.S/,
~r/S.M.A.S.M/,
~r/S.S.A.M.M/
]
input
|> parse_input()
|> Enum.chunk_every(3, 1, :discard)
|> Enum.map(fn row ->
row
|> transpose()
|> Enum.chunk_every(3, 1, :discard)
|> Enum.count(fn chunk ->
Enum.any?(valid_patterns, &Regex.match?(&1, to_string(chunk)))
end)
end)
|> Enum.sum()
end
defp parse_input(input) do
input
|> String.split("\n", trim: true)
|> Enum.map(&String.split(&1, "", trim: true))
end
def reverse(matrix), do: Enum.map(matrix, &Enum.reverse/1)
def transpose(matrix) do
matrix
|> Enum.zip()
|> Enum.map(&Tuple.to_list/1)
end
def rotate45(matrix) do
for(
{row, i} <- Enum.with_index(matrix),
{v, j} <- Enum.with_index(row),
do: {i + j, v}
)
|> Enum.group_by(&elem(&1, 0), &elem(&1, 1))
|> Enum.sort()
|> Enum.map(&elem(&1, 1))
end
def count_XMAS(matrix) do
matrix
|> Enum.map(fn l ->
~r/XMAS/
|> Regex.scan(to_string(l))
|> Enum.count()
end)
|> Enum.sum()
end
defp apply_operations(matrix, ops) do
Enum.reduce(ops, matrix, fn op, m -> apply(__MODULE__, op, [m]) end)
end
end
0
gazzer82
Here’s mine for today, it’s a bit verbose, so could be tidied up significantly, agreed with others that Part 2 seemed easier than Part 1 in some ways, really waiting for the hammer to drop as the first 4 days have seemed worryingly easy compared to last year.
defmodule Aoc2024.Solutions.Y24.Day04 do
alias AoC.Input
def parse(input, _part) do
Input.read!(input) |> String.split("\n", trim: true) |> pad_grid()
end
def part_one(problem) do
matrix = problem |> build_matrix()
matrix |> Enum.to_list() |> Enum.filter(fn {_, v} -> v == "X" end) |> find_xmas(matrix)
end
def find_xmas(xs, matrix) do
Enum.reduce(xs, [], fn {x_coords, _}, acc ->
acc ++
[
find_next(x_coords, :up, ["M", "A", "S"], matrix),
find_next(x_coords, :down, ["M", "A", "S"], matrix),
find_next(x_coords, :left, ["M", "A", "S"], matrix),
find_next(x_coords, :right, ["M", "A", "S"], matrix),
find_next(x_coords, :diag_up_right, ["M", "A", "S"], matrix),
find_next(x_coords, :diag_down_right, ["M", "A", "S"], matrix),
find_next(x_coords, :diag_up_left, ["M", "A", "S"], matrix),
find_next(x_coords, :diag_down_left, ["M", "A", "S"], matrix)
]
end)
|> Enum.filter(&(&1 == 1))
|> Enum.count()
end
def find_next(_, _, [], _), do: 1
def find_next({current_x, current_y}, direction, [next_letter | tail], matrix) do
next_coords = get_next_coord({current_x, current_y}, direction)
next_match = Map.get(matrix, next_coords)
if next_letter == next_match do
find_next(next_coords, direction, tail, matrix)
else
0
end
end
def pad_grid(problem) do
[first | _] = problem
width = String.length(first)
pad_row = 1..width |> Enum.map(fn _ -> "." end) |> Enum.join()
[pad_row] ++ Enum.map(problem, &".#{&1}.") ++ [pad_row]
end
#
def build_matrix(grid) do
Enum.with_index(grid)
|> Enum.reduce(%{}, fn row, acc ->
build_matrix_row(row, acc)
end)
end
def build_matrix_row({row, row_index}, acc) do
row
|> String.graphemes()
|> Enum.with_index()
|> Enum.reduce(acc, fn {char, col_index}, acc ->
Map.put(acc, {col_index, row_index}, char)
end)
end
def get_next_coord({current_x, current_y}, direction) do
case direction do
:up -> {current_x, current_y - 1}
:down -> {current_x, current_y + 1}
:left -> {current_x - 1, current_y}
:right -> {current_x + 1, current_y}
:diag_up_right -> {current_x + 1, current_y - 1}
:diag_down_right -> {current_x + 1, current_y + 1}
:diag_up_left -> {current_x - 1, current_y - 1}
:diag_down_left -> {current_x - 1, current_y + 1}
end
end
def part_two(problem) do
matrix = problem |> build_matrix()
matrix |> Enum.to_list() |> Enum.filter(fn {_, v} -> v == "A" end) |> find_x_mases(matrix)
end
def find_x_mases(as, matrix) do
Enum.reduce(as, [], fn a, acc ->
acc ++ [find_x_mas(a, matrix)]
end)
|> Enum.filter(& &1)
|> Enum.count()
end
def find_x_mas({{coord_x, coord_y}, _}, matrix) do
cross_1 =
[
Map.get(matrix, {coord_x - 1, coord_y - 1}),
Map.get(matrix, {coord_x, coord_y}),
Map.get(matrix, {coord_x + 1, coord_y + 1})
]
|> List.to_string()
cross_2 =
[
Map.get(matrix, {coord_x + 1, coord_y - 1}),
Map.get(matrix, {coord_x, coord_y}),
Map.get(matrix, {coord_x - 1, coord_y + 1})
]
|> List.to_string()
cross_1 in ["MAS", "SAM"] && cross_2 in ["MAS", "SAM"]
end
end
Solution for 2024 day 4
part_one: 2370 in 143.32ms
part_two: 1908 in 26.88ms
0
billylanchantin
Approach: independent streams for each letter of the word and a bunch of zips.
Notes: super inefficient.
defmodule Aoc2024.Day04 do
def part1(f), do: count(f, "XMAS", [[0, 1], [1, 0], [1, 1], [1, -1]], &Enum.count/2)
def part2(f), do: count(f, "MAS", [[1, 1], [1, -1]], fn x, y -> (Enum.all?(x, y) && 1) || 0 end)
def count(file, word, jumps, fun) do
stream = File.stream!(file, 1)
{w, l} = {Enum.find_index(stream, &(&1 == "\n")), String.length(word)}
stream = Stream.concat(Stream.reject(stream, &(&1 == "\n")), Stream.duplicate("", w * l))
Enum.map(jumps, fn [dr, dc] ->
Enum.map(0..(String.length(word) - 1), fn j ->
Stream.drop(stream, max(0, -1 - l * dc) + w * (j * dr) + j * dc)
|> Stream.transform(max(0, -1 - l * dc), fn char, i ->
x = Enum.all?([div(i, w) + j * dr, rem(i, w) + j * dc], &(&1 in 0..(w - 1)))
{[if(x, do: char, else: "")], i + 1}
end)
end)
|> Stream.zip_with(&Enum.join/1)
end)
|> Enum.zip_reduce(0, fn x, s -> s + fun.(x, &(&1 in [word, String.reverse(word)])) end)
end
end
1