83 lines
2 KiB
Markdown
83 lines
2 KiB
Markdown
# AOC 2024 Day 4
|
|
|
|
## Section
|
|
|
|
```elixir
|
|
input = """
|
|
MMMSXXMASM
|
|
MSAMXMSMSA
|
|
AMXSXMAAMM
|
|
MSAMASMSMX
|
|
XMASAMXAMM
|
|
XXAMMXXAMA
|
|
SMSMSASXSS
|
|
SAXAMASAAA
|
|
MAMMMXMMMM
|
|
MXMXAXMASX
|
|
"""
|
|
```
|
|
|
|
```elixir
|
|
lines = input |> String.trim() |> String.split("\n")
|
|
```
|
|
|
|
```elixir
|
|
g = Grid2D.new(
|
|
lines |> Enum.at(0) |> String.trim() |> String.graphemes() |> Enum.count(),
|
|
lines |> Enum.count
|
|
)
|
|
```
|
|
|
|
```elixir
|
|
input = input |> String.replace("\n", "")
|
|
```
|
|
|
|
```elixir
|
|
find_word = fn
|
|
_, w, pl, w, _, _ -> pl
|
|
input, word, [pos | _] = poslist, curr, dir, f ->
|
|
|
|
["", <<next_letter::binary-size(1)>> <> _] = String.split(word, curr)
|
|
coord = Grid2D.index_to_coord(g, pos)
|
|
next = Grid2D.add(coord, dir)
|
|
|
|
if Grid2D.in_grid?(next, g) and (next_letter == String.at(input, index)) do
|
|
index = Grid2D.coord_to_index(g, next)
|
|
f.(input, word, index, [index | poslist], curr <> next_letter, dir, f)
|
|
else
|
|
nil
|
|
end
|
|
end
|
|
```
|
|
|
|
```elixir
|
|
for [{idx, _}] <- Regex.scan(~r/X/, input, return: :index),
|
|
i <- -1..1//1,
|
|
j <- -1..1//1,
|
|
j != 0 or i != 0 do
|
|
find_word.(input, "XMAS", [idx], "X", {i, j}, find_word)
|
|
end |> Enum.reject(&(&1 == nil)) |> Enum.count()
|
|
```
|
|
|
|
```elixir
|
|
is_xmas? =
|
|
fn grid, coord->
|
|
corners = [{1,1}, {1,-1}, {-1, -1}, {-1, 1}] |> Enum.map(&Grid2D.add(coord, &1))
|
|
has_corners? = Enum.all?(
|
|
corners,
|
|
fn p -> Grid2D.in_grid?(p, g) end
|
|
)
|
|
corner_letters = (corners |> Enum.map(fn c -> String.at(grid, Grid2D.coord_to_index(g, c)) end))
|
|
is_mas? = fn -> corner_letters |> Enum.chunk_every(2, 1, :discard) |> Enum.any?(fn i -> i == ["S", "S"] or i == ["M", "M"] end) end
|
|
has_m? = fn -> (corner_letters |> Enum.count(&(&1 == "M"))) == 2 end
|
|
has_s? = fn -> (corner_letters |> Enum.count(&(&1 == "S"))) == 2 end
|
|
has_corners? and has_m?.() and has_s?.() and is_mas?.()
|
|
end
|
|
```
|
|
|
|
```elixir
|
|
for [{i, _}] <- Regex.scan(~r/A/, input, return: :index),
|
|
coord = Grid2D.index_to_coord(g, i) do
|
|
{ coord, is_xmas?.(input, coord)}
|
|
end |> Enum.count(fn {_, t} -> t end)
|
|
```
|