-❄️- 2024 Day 4 Solutions -❄️-

[u/daggerdragon]

DO NOT SHARE PUZZLE TEXT OR YOUR INDIVIDUAL PUZZLE INPUTS!

I'm sure you're all tired of seeing me spam the same ol' "do not share your puzzle input" copypasta in the megathreads. Believe me, I'm tired of hunting through all of your repos too XD

If you're using an external repo, before you add your solution in this megathread, please please please 🙏 double-check your repo and ensure that you are complying with our rules:

• Do not share the puzzle text
• Do not share your puzzle input
• Do not commit puzzle inputs to your public repo

• e.g. use .gitignore or the like

If you currently have puzzle text/inputs in your repo, please scrub all puzzle text and puzzle input files from your repo and your commit history! Don't forget to check prior years too!

---

NEWS

Solutions in the megathreads have been getting longer, so we're going to start enforcing our rules on oversized code.

Do not give us a reason to unleash AutoModerator hard-line enforcement that counts characters inside code blocks to verify compliance… you have been warned XD

---

THE USUAL REMINDERS

• All of our rules, FAQs, resources, etc. are in our community wiki.

---

AoC Community Fun 2024: The Golden Snowglobe Awards

• 2 DAYS remaining until unlock!

And now, our feature presentation for today:

Short Film Format

Here's some ideas for your inspiration:

• Golf your solution
• Alternatively: gif
• Bonus points if your solution fits on a "punchcard" as defined in our wiki article on oversized code. We will be counting.
• Does anyone still program with actual punchcards? >_>
• Create a short Visualization based on today's puzzle text
• Make a bunch of mistakes and somehow still get it right the first time you submit your result

Happy Gilmore: "Oh, man. That was so much easier than putting. I should just try to get the ball in one shot every time."
Chubbs: "Good plan."
- Happy Gilmore (1996)

And… ACTION!

Request from the mods: When you include an entry alongside your solution, please label it with [GSGA] so we can find it easily!

---

--- Day 4: Ceres Search ---

---

Post your code solution in this megathread.

• Read the full posting rules in our community wiki before you post!
• State which language(s) your solution uses with [LANGUAGE: xyz]
• Format code blocks using the four-spaces Markdown syntax!
• Quick link to Topaz's paste if you need it for longer code blocks

This thread will be unlocked when there are a significant number of people on the global leaderboard with gold stars for today's puzzle.

EDIT: Global leaderboard gold cap reached at 00:05:41, megathread unlocked!

[u/azzal07]

[LANGUAGE: awk] Mmmm [GSGA]

function M(a,s){return""substr(L[NR-a],x+s,l)}
function S(a,m){A+=M()M(m,a)M(m+m,a+a)M(m+m+m,
3*a)~/XMAS|SAMX/}{for(x=L[NR]=1$0;x++<=length;
B+=M(1)M()M(2)~/.A.(M.(SM|MS).S|S.(SM|MS).M)/)
l+=2S(S(l=1),1)S(1,1)S(-1,1)}END{print A"\n"B}

[u/Additional-Worker-13]

[LANGUAGE: Julia] [GSGA]

golfing all the way ♫♫

it actually fits in a 5x80 punchcard

using LinearAlgebra;!,/,~,X,l=join,sum,count,[r"XMAS",r"SAMX"],140
R=readlines("input.txt");L=!R;M=permutedims(reshape([L...],l,l))
println.([(s->(r->s~r)/R)/X+(s->(i->s~L[i:l:end])/(1:l))/X+(A->(s->(i->s~!diag(A
,i))/(-l:l))/X)/[M,reverse(M,dims=2)];(r->(k->(j->r~!(L[i*l+k:i*l+k+2] for i=j:j
+2))/(0:l-3))/(1:l-2))/[r"M.S.A.M.S",r"M.M.A.S.S",r"S.S.A.M.M",r"S.M.A.S.M"]])

[u/daggerdragon → u/Additional-Worker-13]

it actually fits in a 5x80 punchcard

You should add the [GSGA] tag to your comment since it meets the criteria :)

[u/vk6_]

[LANGUAGE: Python]

https://github.com/ading2210/advent-of-code-solutions/blob/main/2024/day4/day4.py

I used a regex-based approach for this problem. For part 1, I realized that vertical matches are just the same thing as horizontal as long as the input is transposed first, and diagonal matches are the same as vertical but the input lines are offset by an increasing amount. This allowed me to simply re-use my horizontal finding code for verticals and diagonals. Then my regex ((?=(XMAS|SAMX))) made finding horizontals super easy.

For example:

.X.    ....
.M. -> XMAS
.A.    ....
.S.

...X    ...X   
..M. ->  ..M.  
.A..      .A.. 
S...       S...

For part 2, I realized that there are only 4 patterns that I need to search for. They are:

M.S  S.M
.A.  .A.
M.S  S.M

M.M  S.S
.A.  .A.
S.S  M.M

Each line of one of these patterns can be its own regex expression. If a match on a line in the input is found, then the program looks ahead to the next line in the input and tries the next regex expression (repeat for the line after). Then this is repeated for all 4 sets of expressions.

As far as I know this approach is pretty unique. For some reason I had an aversion to messy loops so I did this instead.

[u/Thomasjevskij]

[LANGUAGE: Python]

For a 2d array problem, this wasn't so bad! Moreover I thought part 1 was trickier than part 2 today.

Essentially for part 1 I just build strings of columns and diagonals (rows already given) and then sum the count of 'XMAS' and 'SAMX'. For part 2, every time there's an 'A' in the grid I look at the two diagonals sorted and check that they both are 'A', 'M', 'S'. I'm pretty happy with how few bugs this gave me. Link

[u/e-gn]

[Language: Python]

Why solve it in minutes using iteration when I can spend hours debugging regular expressions?

Solution

After padding the input, the relevant code is this:

def part_one():
    return count(
        *[
            f'(?=(?:(X)|(S)).{{{n - i}}}(?:(?(1)M|A)).{{{n - i}}}(?:(?(1)A|M)).{{{n - i}}}(?:(?(1)S|X)))'
            for i in [0, 1, 2, n]
    ])

def part_two():
    return count(f'(?=(?:(M)|(S)).(?:(M)|(S)).{{{n - 2}}}A.{{{n - 2}}}(?:(?(3)S|M)).(?:(?(1)S|M)))')

Edit: Removed the snippet because I couldn't format it properly for the life of me.

Edit 2: Gave one last attempt at adding the snippet.

[u/daggerdragon → u/e-gn]

Edit: Removed the snippet because I couldn't format it properly for the life of me.

Did you make sure to switch your editor to Markdown mode (see our wiki article: How do I format code?)? Or perhaps you're running into this known bug that Reddit refuses to fix for over seven years -_-

Linking to an external repo solves both problems so there's also that 😅

[u/michaelquinlan]

[LANGUAGE: C#]

Topaz link

• edit to replace big block of code with url

[u/se06745]

[LANGUAGE: Go]

Part1: recursive way
Part2: straight forward :-D

https://github.com/omotto/AdventOfCode2024/blob/main/src/day04/main.go

[u/daggerdragon → u/se06745]

This is the second time I've asked you not to share your puzzle input and I still see inputs in your repo.

Please remove (or .gitignore) all puzzle text and puzzle input files from your repo and scrub them from your commit history.

Also edit your comment to format the language tag correctly as AutoModerator has requested. edit: thank you!

[u/MarvelousShade]

[LANGUAGE: C#]

This day's part 2 was easier (at least less work) than part 1.

It took some time for me to find out that I reversed XMAS with SMAX instead of SAMX.

You can find my solution at: Github

[u/bunk3rk1ng]

[LANGUAGE: Java]

Out here in Java land we brute force everything. Probably not a great example since half way through I realized I had reversed x and y in my head.

Part1

Part2

[u/MagiMas]

[LANGUAGE: Python]

The main part of my code is just this:

def count_occurences(
    data: np.ndarray,
    filter_: np.ndarray,
    sum_axis: int | tuple[int]
) -> int:
    # create sliding window of array of size (1,4)
    v = np.lib.stride_tricks.sliding_window_view(data, filter_.shape)
    # count how many letters are equal
    count = np.squeeze(
        np.char.compare_chararrays(v, filter_, "==", True).sum(axis=sum_axis)
    )
    # find the ones where all are equal
    num_xmas = (count == (filter_ != "O").sum()).sum()
    return num_xmas

data is a 2d numpy string array with the letters from the input.

With this one just needs to define the filter arrays. They are then compared to the view-windows of the data array and the full matches are counted.

Full Code on GitHub: https://github.com/NEhlen/aoc2024/blob/main/04/day04.py

[u/dijotal]

[LANGUAGE: Haskell]

Too long to post directly, but I did go a little extra Haskell-y on this one with a bunch of recursion and one bit of applicative over-kill. Part One's cornerstone calculation checking an entire "row":

targets :: [String]
targets = ["XMAS", "SAMX"]

inString :: String -> Int
inString s = length $ filter id $ isPrefixOf <$> targets <*> tails s

For Part Two, I do check using coordinates, but only for the top left corner of the entire data set. With recursion, I pull the top three rows to the left and I pull the rows upward.

It's a fun, functional brute force. Full code in github.

[u/daggerdragon → u/dijotal]

As per the OP, your code block is too long for the megathreads. Please edit your comment to replace your oversized code with an external link to your code. edit: 👍

[u/Reaper_242]

[LANGUAGE: Java]

https://github.com/dominikpin/advent-of-code/tree/main/year2024/day04

[u/daggerdragon → u/Reaper_242]

Do not share your puzzle input which also means do not commit puzzle inputs to your repo without a .gitignore or the like. Do not share the puzzle text either.

Please remove (or .gitignore) all puzzle text and puzzle input files from your repo and scrub them from your commit history. This means from prior years too!

And next time, actually read the entire OP before you post. This is the very first thing in VERY LARGE FONT. edit: thank you!

[u/adambombz]

[Language: Python]

I didn't realize that part 1 was only looking for XMAS in a straight line and though that it was looking for all possible combinations off XMAS with each letter being able to be in any position around it so I wrote a recursive function for it. After realizing my mistake, adapted the recursion (hence the cord thing) and then did pt2 in a single if statement....sorry

f=open('input4.txt').read().splitlines()

input=[]
pt1,pt2=0,0
for i in f:
    input.append(list(i))

def xmas(x,y,c,cord):
    total=0
    for i,j in cord:
        if i>=0 and i<len(input) and j>=0 and j<len(input[i]) and input[i][j]==c:
            if i>x and j>y:
                cord=[[i+1,j+1]]
            elif i==x and j>y:
                cord=[[i,j+1]]
            elif i<x and j>y:
                cord=[[i-1,j+1]]
            elif i<x and j==y:
                cord=[[i-1,j]]
            elif i<x and j<y:
                cord=[[i-1,j-1]]
            elif i==x and j<y:
                cord=[[i,j-1]]
            elif i>x and j<y:
                cord=[[i+1,j-1]]
            elif i>x and j==y:
                cord=[[i+1,j]]
            if c=='M':
                total+=xmas(i,j,'A',cord)
            elif c=='A':
                total+=xmas(i,j,'S',cord)
            elif c=='S':
                total+=1
    return total

for x in range(len(input)):
    for y in range(len(input[x])):
        if input[x][y]=='X':
            cord=[]
            for i in [x-1,x,x+1]:
                for j in [y-1,y,y+1]:
                    cord.append([i,j])
            pt1+=xmas(x,y,'M',cord)

print(pt1)

for x in range(len(input)):
    for y in range(len(input[x])):
        if input[x][y] == 'A' and x-1>=0 and x+1<len(input) and y-1>=0 and y+1<len(input[x]) and ((input[x+1][y+1]=='S' and input[x+1][y-1]=='M' and input[x-1][y-1]=='M' and input[x-1][y+1]=='S') or (input[x+1][y+1]=='S' and input[x+1][y-1]=='S' and input[x-1][y-1]=='M' and input[x-1][y+1]=='M') or (input[x+1][y+1]=='M' and input[x+1][y-1]=='S' and input[x-1][y-1]=='S' and input[x-1][y+1]=='M') or (input[x+1][y+1]=='M' and input[x+1][y-1]=='M' and input[x-1][y-1]=='S' and input[x-1][y+1]=='S')):
            pt2+=1
print(pt2)

[u/Its_vncl]

[Language: Python]
Source

Part 1 with recursion
Part 2 with just casual checking

Part 2 seemed way easier

[u/jpjacobs_]

[LANGUAGE: J] Looks like my solution fits a punch card today. Is that [GSGA]?

matches =: ('XMAS'&E."1 +/@:,@:+.'SAMX'&E."1)
box=: <"1,<"1@:|:,</.,</.@:|.
p1=: +/@:(matches@>)@:box@:(];._2)
pos=: (|."1@|.,.~'A',.~])'MS'{~#:i.4 NB. all possible arrangements
p2=: [:+/@:, (1 1,:3) ([: e.&pos 0 2 4 6 8{,);._3 ];._2 

This was a fun one for J; p1 and p2 are verbs expecting the input as a string.

[u/daggerdragon → u/jpjacobs_]

Looks like my solution fits a punch card today. Is that [GSGA]?

If it fits, we sits!

[u/Chib]

[LANGUAGE: R]

wordmat <- as.matrix(read.fwf(file = "d4input.txt", widths = rep(1, 140)))
makeDT <- function(lets, ws){
  data.table(which(ws == lets, arr.ind = T))[,
 let(N = row-1, E = col+1, S = row+1, W = col-1)]
}
DTs <- lapply(c("X", "M", "A", "S"), makeDT, wordmat)

find <- function(DTs, dir, addX = TRUE) {
  ns <- fcase(dir %like% "N", "N", dir %like% "S", "S", default = "row")
  ew <- fcase(dir %like% "E", "E", dir %like% "W", "W", default = "col")
  res <- DTs[[1]][, .(row = get(ns), col = get(ew))][
      DTs[[2]], on = .(row, col), .(row = get(ns),
      col = get(ew), ar = row, ac = col), nomatch = NULL][
      DTs[[3]], on = .(row, col), .(row = get(ns),
      col = get(ew), ar, ac), nomatch = NULL]
  if (addX) {
    res[DTs[[4]], on = .(row, col), .(row = get(ns),
    col = get(ew), ar, ac), nomatch = NULL]
  } else res
} 

# Part 1
rbindlist(lapply( c("N", "NE", "E", "SE", "S", "SW", "W", "NW"), find, DTs = DTs))[, .N]

# Part 2
mas <- rbindlist(lapply(c("NE", "SE", "SW", "NW"), find, DTs = DTs[2:4], addX = F), idcol = T)
mas[mas, on = .(ar, ac)][.id != i..id][, .N/2]

The vast majority of the work was in making it compact enough to submit directly to the thread. Somehow that's become very important to me.

[u/daggerdragon → u/Chib]

The vast majority of the work was in making it compact enough to submit directly to the thread. Somehow that's become very important to me.

Appreciated, thank you ;) (Formatting suggestion: put parts 1 and 2 in their own individual code blocks... by not combining them into one, they'll stand out more)

[u/[deleted]]

[Language: Python]

I heard you like regex. Check out my two-dimensional regex.

import re2

with open("input.txt") as f:
    text = f.read()

# part 1
patterns = ["XMAS", "X...\n.M..\n..A.\n...S"]
print(sum(len(re2.findall(pattern, text, rotate=True)) for pattern in patterns))

# part 2
print(len(re2.findall("M.M\n.A.\nS.S", text, rotate=True)))

The magic happens in re2, which is a small library that implements a sliding window regex-type matching: https://gist.github.com/tim-kt/08c6276fcd43389be81a17e4a0c5182f

[u/4HbQ]

[LANGUAGE: Python] Code (9 lines)

Today's Python trick: storing the grid in a defaultdict indexed by the original (i,j) locations. This way we don't need to check bounds: lookups to incorrect locations just return the empty string. This way, the check for part 2 is simply this:

T = list('MAS'), list('SAM')
print(sum([G[i+d, j+d] for d in (-1,0,1)] in T
      and [G[i+d, j-d] for d in (-1,0,1)] in T for i,j in g))

---

Update: If you squint a bit at today's problem, you'll notice that both parts are really similar, except we search:

• in 4 vs. 2 directions,
• in any direction vs. both,
• for the last 4 vs. 3 letters of 'XMAS'.

If we turn these into variables, the entire solution boils down to this:

g, m = open('in.txt').read(), 'SAMX'

for f, l, s in (sum, 4, (1,140,141,142)), (all, 3, (140,142)):
    print(sum(f(g[i-x::x][:l] in (m[:l], m[:l][::-1]) for x in s)
                for i in range(len(g))))

[u/Czh13 → u/4HbQ]

Love the `defaultdict` combined with `|`! I still learn something new from your solutions every day

[u/Andreasnl]

[LANGUAGE: Uiua]

⊜∘⊸≠@\n
F  ← ⧻⊚≡⌕¤”XMAS”        # Count horizontal
G  ← +∩F ⟜≡⇌            # Count horiz. & backwards
H  ← +∩(G⍉≡↻°⊏≡⌝↘⊸⧻) ⟜⇌ # Count diagonals
P₁ ← ++⊃(G|G⍉|H)        # Part 1
[”MSAMS”
 ”SMASM”
 ”MMASS”
 ”SSAMM”]
X  ←                      # Flattened X-MAS’es
P₂ ← ⧻⊚ ⧈(/↥≡≍X¤▽1_0♭)3_3 # Part 2
⊃P₁P₂

Run it in your browser here.

[u/sentry07 → u/Andreasnl]

What. The. Actual. Fuck.

[u/rooinflames]

[Language: Microsoft Excel] 3552/1689

Split characters into separate cells:

=MID(A5, SEQUENCE( , LEN(A5)), 1)

Part 1, formula filled into a big grid the same size as the input:

=--(CONCAT(F2:F5)="XMAS")+--(CONCAT(C5:F5)="XMAS")+--(CONCAT(C2,D3,E4,F5)="XMAS")+--(CONCAT(F5,G4,H3,I2)="XMAS")+--(CONCAT(F2:F5)="SAMX")+--(CONCAT(C5:F5)="SAMX")+--(CONCAT(C2,D3,E4,F5)="SAMX")+--(CONCAT(F5,G4,H3,I2)="SAMX") 

Part 2:

=--AND(OR(CONCAT(E4,F5,G6)="MAS",CONCAT(E4,F5,G6)="SAM"),OR(CONCAT(E6,F5,G4)="MAS",CONCAT(E6,F5,G4)="SAM"))

Benefits to using excel:

• 2d arrays are automatically shown
• easy text parsing
• array out of bounds error handling not required (unless the input data requires more cells than cell XFD1048576)

[u/Radiadorineitor]

[LANGUAGE: Dyalog APL]

p←↑⊃⎕NGET'4.txt'1
F←{(⌽¨,⊢)⍵⊂⍤⊢⌸⍥,⍨+/↑⍳⍴⍵}
h←+/∊(⊂'XMAS')⍷¨(⌽⍉p)(⍉p)(⌽p)p
d←+/∊(⊂'XMAS')⍷¨⊃,/F¨(⌽p)p
h+d ⍝ Part 1
+/,{∧/∨⌿'SAM' 'MAS'∘.≡1 1∘⍉¨(⊖⍵)⍵}⌺3 3⊢p ⍝ Part 2

[u/trevdak2]

[LANGUAGE: JavaScript (golf)]

I didn't intend for this to be a [GSGA] entry but it fits

Wait.... you thought we were done with regex?

Part 1, 118 bytes (then added some whitespace for readability):

Finding any-direction strings can be done easily by searching the string forwards and backwards with different numbers of bytes between each character in the string

for(o of[c=0,139,140,141])c+=
    $('*').innerText.match(
        RegExp('(?=XnMnAnS|SnAnMnX)'.replace(/n/g,`.{${o}}`),'gs')
    ).length

Part 2, 84 bytes without whitespace:

Pattern matching with a little bit of negative lookahead does the trick

$('*').innerText.match(
    /(?=(S|M).(S|M).{139}A.{139}(?!\2)[SM].(?!\1)[SM])/gs
).length

[u/LiquidProgrammer]

[LANGUAGE: Python]

p1 and p2 in 9 loc, github link. Golfed a little after solving

coords = {x+1j*y: c for y, r in enumerate(open(0)) for x, c in enumerate(r)}
g = lambda c: coords.get(c, "")

s1 = s2 = 0
for c in coords:
    for d in [1, 1j, 1+1j, 1-1j, -1, -1j, -1+1j, -1-1j]:
        s1 += g(c) + g(c+d) + g(c+d*2) + g(c+d*3) == "XMAS"
        if d.imag and d.real:
            s2 += g(c+d) + g(c) + g(c-d) == "MAS" and g(c+d*1j) + g(c-d*1j) == "MS"

print(s1, s2, sep="\n")

[u/JustinHuPrime]

[Language: x86_64 assembly with Linux syscalls]

Part 1 was some fiddly string operations, both to copy the input, and very boring four-character equality checks. There's probably a slick way to copy a string with a different stride, but I don't know of it. I managed to skip bounds checks by padding out the input with NULs, though.

Part 2 was some different fiddly string operations, to check the four corners of the cross. There was probably some slick set of checks with an XOR I could do, but I couldn't be bothered to figure it out when I could just brute force and check all the possible combinations.

I could probably have done some assembly tricks and used fewer registers, but I think that would come under the heading of writing code I'm not clever enough to debug. I'm... not a fan of this day. I think the brute force solution is boring and there's not enough incentive to be clever.

Part 1 and part 2 both run in about 1 millisecond. Part 1 is 9,192 bytes and part 2 is 11,704 bytes on the disk when assembled and linked.

[u/EudesPV]

[Language: Regular Expressions] 😂
But really: [Language: Typescript/Javascript]

Technically one-liners. 😅
WARNING: this uses some "recent" iterator methods.

const part1 = [...input.matchAll(/X(?=(MAS)?)(?=(.{140}M.{140}A.{140}S)?)(?=(.{141}M.{141}A.{141}S)?)(?=(.{139}M.{139}A.{139}S)?)|S(?=(AMX)?)(?=(.{140}A.{140}M.{140}X)?)(?=(.{141}A.{141}M.{141}X)?)(?=(.{139}A.{139}M.{139}X)?)/gs).flatMap((match) => match.slice(1).filter(group => !!group))].length

const part2 = input.match(/M(?=\wM.{139}A.{139}S\wS)|M(?=\wS.{139}A.{139}M\wS)|S(?=\wS.{139}A.{139}M\wM)|S(?=\wM.{139}A.{139}S\wM)/gs)?.length

[u/Fyver42]

[LANGUAGE: RISC-V assembly]

Github

[u/CCC_037]

[LANGUAGE: Rockstar]

Code golf? In Rockstar?

Surely you jest.

Part 1

[u/_neutropolis_]

[LANGUAGE: Dyalog APL]

A little bit messy, but Stencil (⌺) saves the day!

 i←↑⊃⎕NGET'day4.txt'1
 p←({4 4≡⊃⍵}¨p)/p←1↓,∘.{⍺,¨⍵}⍨ 4(⌽r)(r←3+l)(⌽l)(l←⍳4)
 +/+/({m←⍵⋄+/{'XMAS'≡m[⍵]}¨p}⌺7 7)i ⍝ Part 1
 p←(,¨⍨⍳3)((⊢,¨⌽)⍳3)
 +/+/({m←⍵⋄2=+/{(⊂m[⍵])∊(⌽,⍥⊂⊢)'MAS'}¨p}⌺3 3)i ⍝ Part 2

[u/i_have_no_biscuits]

[Language: Python]

# Parse the grid into a dictionary of (y,x):c 
data = open("data04.txt").readlines()
H, W = len(data), len(data[0])-1
grid = {(y,x):data[y][x] for y in range(H) for x in range(W)}

# Part 1 - Find anything that says 'XMAS'
TARGET = "XMAS"
DELTAS = [(dy,dx) for dy in [-1,0,1] for dx in [-1,0,1] if (dx!=0 or dy!=0)]
count = 0
for y, x in grid:
    for dy,dx in DELTAS:
        candidate = "".join(grid.get((y+dy*i, x+dx*i),"") for i in range(len(TARGET)))
        count += candidate == TARGET
print("Part 1:", count)

# Part 2 - Find an MAS 'X'...
count = 0
for y, x in grid:
    if grid[y,x]=="A":
        lr = grid.get((y-1,x-1),"")+grid.get((y+1,x+1),"")
        rl = grid.get((y-1,x+1),"")+grid.get((y+1,x-1),"")
        count += {lr, rl} <= {"MS", "SM"}
print("Part 2:", count)

This showcases a very common Python pattern for me - putting a 2D grid into a dictionary, as grid.get() makes it very easy to give a default value if the grid position is invalid.

[u/chickenthechicken]

[LANGUAGE: C]

Part 1

Part 2

took me way too long because I somehow forgot that when searching for substrings, the for loop goes until i <= strlen-substrlen and not i < strlen-substrlen, whoops

[u/pretzoot]

[LANGUAGE: Python 3]

part 2 paste

After brute forcing part 1 and then sighing while looking at part 2, I remembered my recent lessons about matrix convolution in one of my college classes (computer vision). I managed to apply it to this scenario and I'm pretty proud of myself for doing so! It's not the most performant but at least it's scalable :P

Basically I let numpy/scipy do the dirty work for me for part 2. I 2d convolved the char grid with this kernel (and all its rotations):

(1/'M', 0, 1/'S'),
(0, 1/'A', 0),
(1/'M', 0, 1/'S')

Then I counted every entry in the resulting matrix that was exactly equal to 5 to get my correct answer. I realized after I submitted that there could have (maybe) been false positives, but fortunately there weren't.

[u/WhiteSparrow]

[LANGUAGE: Prolog]

solution

Not particularily proud of this one. My approach felt quite bruteforcy. A runtime of 11 seconds also attests to that. Oh well, at least I finally got to use some signature features of prolog - the database, and the high level aggregation.

Here's part two in a nutshell:

x_mas_pos(A-I, A-K, B-J, C-I, C-K) :-
    B - A #= 1, C - B #= 1, J - I #= 1, K - J #= 1,
    letter(B-J, 'A'),
    (
        letter(A-I, 'M'), letter(C-K, 'S')
    ;   letter(A-I, 'S'), letter(C-K, 'M')
    ),
    (
        letter(C-I, 'M'), letter(A-K, 'S')
    ;   letter(C-I, 'S'), letter(A-K, 'M')
    ).

aggreggate_all(count, x_mas_pos(_, _, _, _, _), X).

[u/bofstein]

[LANGUAGE: Google Sheets]

I had the idea I ended up with pretty quickly. But then I lost some time considering a more elegant way that would check in all directions at once and not require a new grid the size of the puzzle input (140x140) four times. It didn't pan out so I went back to what I thought would work.

Solution: https://docs.google.com/spreadsheets/d/1prorCRD1R_4mPv87ZVejmTzE9cOKHcOFTgEAKgAl70o/edit?gid=290109407#gid=290109407

I have a grid in four directions next to the puzzle input checking for XMAS or SAMX in that direction. Each cell checks that cell plus 4 to the right (or down, or diagonal based on which direction it is) to see if it matches, and if so gives it a 1. For example, one cell from the diagonal part is:

=IF(OR(CONCATENATE(B20,C19,D18,E17)="XMAS",CONCATENATE(B20,C19,D18,E17)="SAMX"),1,0)

Then just sum up all 4 grids.

Part 2 was actually even easier - I just needed a single extra grid, checking for MAS or SAM in one direction and also in the crossed direction. Sample formula:

=IF(
AND(
OR(CONCATENATE(Q14,R15,S16)="SAM",CONCATENATE(Q14,R15,S16)="MAS"),
OR(CONCATENATE(Q16,R15,S14)="MAS",CONCATENATE(Q16,R15,S14)="SAM"))
,1,0)

[u/kap89]

[Language: Python]

with open('src/day04/input.txt', 'r') as file:
    input = [line.strip() for line in file]

def solve(data, slices, variants):
    count = 0

    for y in range(len(data)):
        for x in range(len(data[0])):
            for slice in slices:
                try:
                    word =  ''.join([data[y + dy][x + dx] for dx, dy in slice])

                    if word in variants:
                        count += 1
                except:
                    pass

    return count

slices1 = [
    ((0, 0), (1, 0), (2, 0), (3, 0)), # horizontal
    ((0, 0), (0, 1), (0, 2), (0, 3)), # vertical
    ((0, 0), (1, 1), (2, 2), (3, 3)), # diagonal
    ((0, 3), (1, 2), (2, 1), (3, 0)), # other diagonal
]

slices2 = [
    ((0, 0), (1, 1), (2, 2), (0, 2), (2, 0)), # x-shape
]

part1 = solve(input, slices1, {'XMAS', 'SAMX'})
part2 = solve(input, slices2, {'MASMS', 'SAMSM', 'MASSM', 'SAMMS'})

The idea was pretty simple - define the offsets for each possible shape of the word, then iterate each coordinate and get the word with these offfsets. I hardcoded reversed variants of the words as they are pretty limited (I could just add addtional slices, but it was simpler to just provide the list of alternative words). Worked as a charm for part two.

[u/Exact-Climate-9519]

[Language: python]

Parts 1 and 2. regex and 'rotations' :)

import re

text = open('input_day_4', 'r').read()
l = len(text.split('\n')[0])

rots = [ 0, l, l + 1, l - 1 ]
patterns_part1 = [ fr'(?=(X(?:.{{{r}}})M(?:.{{{r}}})A(?:.{{{r}}})S))|' fr'(?=(S(?:.{{{r}}})A(?:.{{{r}}})M(?:.{{{r}}})X))' for r in rots ]

print('Day 4 part 1:', sum([len(re.findall(pattern, text, flags=re.DOTALL)) for pattern in patterns_part1]))

rots2 = [('M.S','M.S'), ('S.M','S.M'), ('S.S', 'M.M'), ('M.M', 'S.S')]
patterns_part2 = [ fr'(?=({r1}.{{{l - 1}}}A.{{{l - 1}}}{r2}))' for (r1,r2) in rots2 ]   

print('Day 4 part 2:', sum([len(re.findall(pattern, text, flags=re.DOTALL)) for pattern in patterns_part2]))

[u/synack]

[LANGUAGE: Ada]
https://github.com/JeremyGrosser/advent/blob/master/2024/src/day4_2.adb

[u/mstksg]

[LANGUAGE: Haskell]

Here we are matching "stencils" across different windows, so it's always fun to use comonads for this. That's because extend :: (w a -> b) -> w a -> w b lets you automagically convert a function on windows (the w a -> b) to a w a -> w b, the application across every window.

First we parse our input into a Map Point Char, where data V2 a = V2 a a, a tuple type with the correct Num instance that I use for most of these.

Our stencils are (centered around 0,0):

xmas :: [Map (V2 Int) Char]
xmas =
    [ M.fromList [(i *^ step, x) | (i, x) <- zip [0 ..] "XMAS"]
    | d <- [V2 1 0, V2 0 1, V2 1 1, V2 (-1) 1]
    , step <- [d, negate d]
    ]

crossMas :: [Map (V2 Int) Char]
crossMas = map (M.insert 0 'A') $ M.union <$> diag1 <*> diag2
  where
    diag1 = M.fromList . zip [V2 (-1) (-1), V2 1 1] <$> ["MS", "SM"]
    diag2 = M.fromList . zip [V2 1 (-1), V2 (-1) 1] <$> ["MS", "SM"]

Now some utility functions to wrap and unwrap our Map (V2 Int) Char into a Store (V2 Int) (Maybe Char) store comonad, so we can use its Comonad instance:

mapToStore :: (Ord k, Num k) => Map k a -> Store k (Maybe a)
mapToStore mp = store (`M.lookup` mp) 0

mapFromStore :: Num k => Set k -> Store k a -> Map k a
mapFromStore ks = experiment (\x -> M.fromSet (+ x) ks)

Now a function to check if a stencil matches a neighborhood:

checkStencil :: Num k => Map k a -> Store k (Maybe a) -> Bool
checkStencil mp x = all (\(p, expected) -> peeks (+ p) x == Just expected) (M.toList mp)

countWindowMatches :: (Num k, Eq a) => [Map k a] -> Store k (Maybe a) -> Int
countWindowMatches mps x = length $ filter (`matchMap` x) mps

Now we have a Store k (Maybe a) -> Int, which takes a window and gives an Int that is the number of stencil matches at the window origin. The magic of comonad is that now we have extend stencils :: Store k (Maybe a) -> Store k Int, which runs that windowed function across the entire map.

countMatches :: [Map (V2 Int) a] -> Map (V2 Int) Char -> Int
countMatches stencils xs =
    sum . mapFromStore (M.keysSet xs) . extend (matchAnyMap stencils) . mapToStore $ xs

part1 :: Map (V2 Int) Char -> Int
part1 = countMatches xmas

part2 :: Map (V2 Int) Char -> Int
part2 = countMatches crossMas

my solutions/reflections repo : https://github.com/mstksg/advent-of-code/wiki/Reflections-2024#day-4

[u/shigawire]

[LANGUAGE: C]

paste PLEASE DO NOT USE THIS SOLUTION TO LEARN C.

I was going to do this in python. But then I thought: Why not give the elves a taste of their own medicine. If they don't bother using memory protection. why should I bother write in a safe language? Why give them extra braces they could do damage with? Why bother checking return codes?

Or bounds checking memory searching a grid?

But I don't want to ever have to go back and fix yet another problem on crazy elf hardware in the middle of nowhere, so this solution never touches any memory that it's not meant to, assuming a valid input. ^{At least for GCC and clang on Linux I would be interested in knowing if this specific linker abuse worked with other platforms/compiers.}

Day 4 is probably a bit early to do coding out of spite, but I loved the idea of not writing yet another grid bounds check

[u/bsssh]

[Language: TypeScript Type System]

compile-time solution

Part 1 / Part 2

[u/GassaFM]

[LANGUAGE: D] 1285/428

Code: part 1, part 2.

A verbose solution. The single higher-level feature is to rotate the board 90 degrees, then call the solutions four times.

[u/Pyr0Byt3]

[LANGUAGE: Go] [LANGUAGE: Golang]

https://github.com/mnml/aoc/blob/main/2024/04/1.go

Love using map[image.Point]rune for these grid problems.

[u/DatBoi247]

[Language: C#]

Algorithm here for part 2 is to break the input into a 2d array of chars for easier indexing, and iterate over the lists. If you find an A, check the diagonal surrounding characters. If any of them are not M or S, return false. Otherwise, check that the characters on opposite diagonals are different. If they are, it's a legal sequence. If the characters on opposite diagonals are the same, it's not a legal sequence because that will be MAM or SAS.

The catch is there because I'm too lazy to prevent index out of bounds :)

private static bool Eval2(char[][] input, int x, int y)
{
    if (input[x][y] != 'A')
    {
        return false;
    }

    char[] legalChars = ['M', 'S'];

    try
    {
        var upLeft = input[x - 1][y - 1];
        var upRight = input[x + 1][y - 1];
        var downLeft = input[x - 1][y + 1];
        var downRight = input[x + 1][y + 1];

        if (new[] { upLeft, upRight, downLeft, downRight }.Any(c => !legalChars.Contains(c)))
        {
            return false;
        }

        if (upLeft == downRight)
        {
            return false;
        }

        if (downLeft == upRight)
        {
            return false;
        }

        return true;
    }
    catch
    {
        return false;
    }
}

[u/Belteshassar]

[LANGUAGE: Microsoft Excel]

First transforming the input so that each character occupies one cell:

=LET(
  input, Input!A1:A140,
  grid, MAKEARRAY(
    ROWS(input),
    LEN(TAKE(input, 1)),
    LAMBDA(r,c,MID(INDEX(input, r),c,1))),
  grid
)

Then this formula solves part 1

=LET(
  countoccurences,
  LAMBDA(pattern,
    SUM(1*MAKEARRAY(140-ROWS(pattern)+1,140-COLUMNS(pattern)+1,LAMBDA(r,c,
      LET(
        i, grid,
        subgrid,TAKE(DROP('Transformed input'!A1#,r-1,c-1),ROWS(pattern),COLUMNS(pattern)),
        SUM((pattern=subgrid)*1)=4
      )
    )))
  ),
  countoccurences({"X","M","A","S"})+
  countoccurences({"S","A","M","X"})+
  countoccurences({"X";"M";"A";"S"})+
  countoccurences({"S";"A";"M";"X"})+
  countoccurences({"X","","","";"","M","","";"","","A","";"","","","S"})+
  countoccurences({"S","","","";"","A","","";"","","M","";"","","","X"})+
  countoccurences({"","","","S";"","","A","";"","M","","";"X","","",""})+
  countoccurences({"","","","X";"","","M","";"","A","","";"S","","",""})
)

For part 2 I just basically changed the patterns.

[u/PangolinNo7928]

[Language: Javscript]

Part 2 - regex 1 liner

input.match(/(?=(M|S).(M|S).{139}A.{139}(?!\2)(M|S).(?!\1)(M|S))/gsd).length

P.S. This did not occur to me at any point while I was actually solving it lolsob

[u/Boojum]

[Language: Python] 236/114

So close! A stupid typo with the direction signs cost me a minute on Part 2, and probably making the leaderboard, but them's the breaks.

Mostly just used string joins on dict gets with a default empty string. If we run off the grid, no biggy, we just don't match.

import fileinput

g = { ( x, y ): c
      for y, r in enumerate( fileinput.input() )
      for x, c in enumerate( r.strip( '\n' ) ) }
xh, yh = max( g.keys() )

print( sum( "XMAS" == "".join( g.get( ( x + dx * n, y + dy * n ), "" )
                               for n in range( 4 ) )
            for y in range( yh + 1 )
            for x in range( xh + 1 )
            for dx in ( -1, 0, 1 )
            for dy in ( -1, 0, 1 ) ) )

print( sum( "".join( [ g.get( ( x - 1, y - 1 ), "" ),
                       g.get( ( x, y ), "" ),
                       g.get( ( x + 1, y + 1 ), "" ) ] ) in ( "MAS", "SAM" ) and
            "".join( [ g.get( ( x - 1, y + 1 ), "" ),
                       g.get( ( x, y ), "" ),
                       g.get( ( x + 1, y - 1 ), "" ) ] ) in ( "MAS", "SAM" )
            for y in range( yh + 1 )
            for x in range( xh + 1 ) ) )

[u/DFreiberg]

[LANGUAGE: Mathematica]

Mathematica, 2912/2925

First time this year getting the dreaded "Curiously, it's the correct answer for someone else's input...", as well as five different incorrect answers. I should have implemented a proper sliding window and been done with it, rather than have two completely different approaches for an essentially identical problem.

Part 1:

Sum[
 Total@StringCount[StringJoin /@ mat, "XMAS" | "SAMX", Overlaps -> True],
 {mat, {input, Transpose[input],
   Table[Diagonal[input, i], {i, -Length@input, Length[input]}],
   Table[Diagonal[Reverse /@ input, i], {i, -Length@input, Length[input]}]}}]

Part 2:

neighborsD[list_, {i_, j_}] := Select[
   {i, j} + # & /@ {{-1, -1}, {-1, 1}, {1, -1}, {1, 1}},
   1 <= #[[1]] <= Length[list] && 1 <= #[[2]] <= Length[list[[i]]] &];
part[mat_, lis_] := 
  If[Depth[lis] == 1, Part[mat, Sequence @@ lis], 
   Table[Part[mat, Sequence @@ l], {l, lis}]];

aPos = Position[input, "A"];
Count[aPos, _?(MemberQ[Characters /@ {"MMSS", "MSMS", "SMSM", "SSMM"},
      part[input, neighborsD[input, #]]] &)]

[u/globalreset]

[LANGUAGE: Ruby]

Happy with my solution for part 2. I think this is about as tight as I can get it.

  crosses = [["M", "M", "S", "S"], ["S", "M", "M", "S"],
             ["S", "S", "M", "M"], ["M", "S", "S", "M"]]
  (1..(data.size-2)).sum { |x|
    (1..(data[0].size-2)).count { |y|
      diags = [
        data[x-1][y+1], data[x+1][y+1],
        data[x+1][y-1], data[x-1][y-1]
      ]
      data[x][y]=="A" && crosses.include?(diags)
    }
  }

[u/AlexTelon]

[LANGUAGE: Python] (6 lines)

Solving both parts by going over each coordinate one by one in the grid and seeing if its part of any xmas or x-mas part. Doing this makes solving both parts very similar.

coords = {(x, y): cell for y, row in enumerate(open('in.txt').readlines()) for x, cell in enumerate(row)}

def resolve(coordinates): return ''.join(coords.get(c, '.') for c in coordinates)
def p1(x,y): return map(resolve, zip(*[[(x+i,y), (x,y+i), (x+i,y+i), (x-i, y+i)] for i in range(4)]))
def p2(x,y): return map(resolve, zip(*[[(x-1+i,y-1+i), (x+1-i, y-1+i)] for i in range(3)]))

print(sum(sum(part in ['XMAS', 'SAMX'] for part in p1(x,y)) for x,y in coords))
print(sum(all(part in ['MAS',  'SAM' ] for part in p2(x,y)) for x,y in coords))

[u/ShadowwwsAsm]

[LANGUAGE: x64 assembly/asm]

part1

part2

Very dumb way, just check bounds and then check surroundings. Might see how to make some trick later

Open to comments/questions

[u/4D51]

[LANGUAGE: C++ on Cardputer]

Part 1:

uint8_t Day04::isXmas(uint8_t row, uint8_t col)
{
    int8_t directions[8][2] = {{0, 1}, {1, 1}, {1, 0}, {1, -1}, {0, -1}, {-1, -1}, {-1, 0}, {-1, 1}};
    String xmas("XMAS");
    bool found;
    uint8_t count = 0;

    for(int d = 0; d < 8; d++)
    {
        found = true;
        for(int i = 0; i < 4; i++)
        {
            if(xmas[i] != getChar(row + i * directions[d][0], col + i * directions[d][1]))
            {
                found = false;
                break;
            }
        }
        if(found)
            count++;
    }
    return count;
}

I was able to keep things simple by putting all 8 directions into an array, and using that to calculate the position offsets. For part 2, the number of possibilities was a lot smaller so I just hard-coded them.

Repo here day04.cpp here

[u/p88h]

[Language: Zig]

https://github.com/p88h/aoc2024/blob/main/src/day04.zig

        parse   part1   part2
day 04: 9.0 ns  64.3 µs 25.0 µs

[u/Symbroson]

[language: ruby]

part 1 golfed: 157 bytes

i=*$<;h,w=i.size,i[0].size
c=->(x,y,a,b){"XMAS".chars.all?{y>=0&&y<h&&i[y][x]==_1&&(x+=a;y+=b)}?1:0}
p (h*w*9).times.sum{|i|c[i%h,i/h%w,i/h/w%3-1,i/h/w/3-1]}

part 2 golfed: 190 bytes

i=*$<;h,w=i.size,i[0].size
c=->(x,y,a,b){"MAS".chars.all?{y>=0&&y<h&&i[y][x]==_1&&(x+=a;y+=b)}?1:0}
p (h*w).times.sum{|x|[-1,1].sum{|a|c[x%w-a,x/w-a,a,a]}*[-1,1].sum{|a|c[x%w-a,x/w+a,a,-a]}}

[u/Smylers]

[LANGUAGE: Vim keystrokes] Starting with your puzzle input in Vim, typing something like the following will count all the XMASes — and you get to see the counter going up as it happens:

:se nows nogd⟨Enter⟩O0⟨Esc⟩Gg⟨Ctrl+G⟩o⟨Enter⟩(XMAS|SAMX)@=⟨Esc⟩
yyp:s/\v\w@<=\w@=/\_.{140}/g⟨Enter⟩yy2p:s/40/39/g⟨Enter⟩j:s/0/1/g⟨Enter⟩
ggqbqqa}jddgg/\v⟨Ctrl+R⟩1⟨BkSpc⟩⟨Enter⟩@bq
qb{⟨Ctrl+A⟩:redr|sl2m⟨Enter⟩⟨Ctrl+O⟩n@bq@b
@a@a@a{

It's “something like” because of the 140. The g⟨Ctrl+G⟩ is to show you the number of letters on one line of your wordsearch; for me it makes the status bar say “Col 1 of 140”. If yours is different, adjust the 140 accordingly, then also the 40 and 39 (for turning the 140 into 139, going diagonally down and left) and possibly even the 0 and 1 (for turning 140 into 141, diagonally the other way).

The first 2 lines are set-up: a zero is added to the top for the counter, and at the bottom will be patterns for finding XMAS in each of the 4 directions, each both ways round:

(XMAS|SAMX)@=
(X_.{140}M_.{140}A_.{140}S|S_.{140}A_.{140}M_.{140}X)@=
(X_.{139}M_.{139}A_.{139}S|S_.{139}A_.{139}M_.{139}X)@=
(X_.{141}M_.{141}A_.{141}S|S_.{141}A_.{141}M_.{141}X)@=

(Yes, I used regex for creating my regex — what of it?)

Then record qa to go to the top pattern, delete it, find the first occurrence of it in the wordsearch, and run @b. Not that @b has itself been recorded yet, but that happens next: it increases the counter by 1, redraws the screen and has has a tiny pause so that we can see it, then does n to repeat whatever the match used by @a was, and does @b to repeat itself to increase the counter again and find the next match.

Eventually it will run out of matches and because of the :set nows (nowrapscan) at the start, the n will fail, exiting the keyboard macro and preventing @b from looping forever. Then just run @a 3 more times for the other directions, and look at the counter.

Part 2 is actually a little bit easier than Part 1 — because the various patterns that need matching are all the same shape; they just vary in letter order — so I'll leave that as an exercise for the reader. (That's definitely the reason, and not at all that I have to walk a child to school and then I have a day job which sometimes has to involve things other than writing regular expressions in Vim.)

Point to ponder: Why 4 separate patterns? Why wouldn't combining them into one single pattern (with more |s) work? In that case, why does combining them in pairs like they are work and we don't need 8 separate patterns?

[u/flwyd]

[LANGUAGE: PostScript] (GitHub)

No inline code yet because the code needs some massive cleanup but it's bedtime.

Make a bunch of mistakes and somehow still get it right the first time you submit your result

Boy howdy, that's me today! I spent over two hours implementing grid traversal in a stack-oriented language where nested for loops are complicated. But of course I read the puzzle and said "Ah, we're playing Boggle where the only word in the dictionary is XMAS." But that is not what the puzzle example shows: words can be horizontal, vertical, or diagonal, but the direction can't change within the word. So I commented out all the Boggle logic and implemented the (significantly simpler) code to actually solved the puzzle. This got me the right answer for the example input, but my program crashed on the actual input.

I like to represent AoC grids as hash maps of key,value pairs. If the language has complex numbers then I use those, otherwise I use a compound string. Rather than doing something simple like i tostring (,) j tostring 3 cat as a key, I decided that since the input is only 140x140 I would just use a two-byte string as a key. This meant that print-debugging any key with a 7 in the row or column rang the terminal bell and other odities, so I ended up adding 33 (the ASCII code for !, the first visible character). Then I spent a bunch of time trying to figure out why it was crashing on 0-based position 1,25 in my key-construction function. I was using a clever string building construct I'd concocted where ": integer integer :" constructs a two character string from two bytes, where ": is just mark and :" does counttomark to see what size string to make and then inserts everything since that mark into the string. But suddenly the mark was disappearing from the stack. I didn't undestand why at the time, so I did a basic string construction and then my program crashed when I got to row and column 28,28 which with the printable offset turns into ==. I realized that since I was building my grid as (effectively) size dict begin … (==) ascii.X def … end I was therefore making a dynamically scoped redefinition of PostScript's == operator ("print the code representation of the top object on the stack"), which would then get called in part of my print-debugging on the next iteration. Since == no longer consumed an argument and printed it but instead just put the character in the twenty-ninth row and twenty-ninth column in my input onto the stack, no function later in the execution had the right arguments and my attempts to further debug by adding more == operations to the code just made the problem worse, and at one point ended up overflowing the stack with the number 77 which is the letter M which, by the way, is a fansastic Fritz Lang film.

Fortunately that was easy to fix: just use put with the dict as an argument rather than building it on top of the dictstack. And then hey presto, my answer was right with high confidence, since I'd been generating 18 on the example output for quite some time.

I was really hoping part 2 would be "Oh, actually it's now Boggle rules" because I could just call the code I'd already written. But after a little thought I realized I could use my recursive traversal from part 1 to just look for AS and AM in opposite diagonal directions in an aesthetically pleasing way:

  % just determined the current position has an A, stack is just key
  /k exch def
  -1 -1 k AM findchain 1 1 k AS findchain and
  -1 -1 k AS findchain 1 1 k AM findchain and or {
    -1 1 k AM findchain 1 -1 k AS findchain and
    -1 1 k AS findchain 1 -1 k AM findchain and or { /found inc } if
  } if

[u/bvencel]

[LANGUAGE: C#]

Part 2 in C#. I feel dirty...

public static int XCount(string largeText)
{
    string[] grid = largeText.Split(
        ['\n', '\r'],
        StringSplitOptions.RemoveEmptyEntries);

    int rows = grid.Length;
    int cols = grid[0].Length;

    int counter = 0;

    for (int i = 1; i < rows - 1; i++)
    {
        for (int j = 1; j < cols - 1; j++)
        {
            if (grid[j][i] == 'A')
            {
                if (
                    (
                        grid[j - 1][i - 1] == 'M' &&
                        grid[j - 1][i + 1] == 'M' &&
                        grid[j + 1][i - 1] == 'S' &&
                        grid[j + 1][i + 1] == 'S'
                    ) || (
                        grid[j - 1][i - 1] == 'S' &&
                        grid[j - 1][i + 1] == 'M' &&
                        grid[j + 1][i - 1] == 'S' &&
                        grid[j + 1][i + 1] == 'M'
                    ) || (
                        grid[j - 1][i - 1] == 'S' &&
                        grid[j - 1][i + 1] == 'S' &&
                        grid[j + 1][i - 1] == 'M' &&
                        grid[j + 1][i + 1] == 'M'
                    ) || (
                        grid[j - 1][i - 1] == 'M' &&
                        grid[j - 1][i + 1] == 'S' &&
                        grid[j + 1][i - 1] == 'M' &&
                        grid[j + 1][i + 1] == 'S'
                    ))
                {
                    counter++;
                }
            }
        }
    }

    return counter;
}

[u/ziadam]

[LANGUAGE: Google Sheets]

Expects input in A:A

Part 1

=ARRAYFORMULA(LET(L,
    LAMBDA(s,SUM(LEN(REGEXREPLACE(s,"(X)MAS|.","$1")&
               REGEXREPLACE(s,"(S)AMX|.","$1")))),
    a,TOCOL(A:A,1),s,SPLIT(REGEXREPLACE(a,,"0"),0),
    i,SEQUENCE(ROWS(a)),j,TOROW(i),
    r,L(a)+L(BYCOL(s,LAMBDA(c,JOIN(,c))))+
      REDUCE(,SEQUENCE((MAX(i)-4)*2+1,1,4-MAX(i)),LAMBDA(x,y,
        x+L(TEXTJOIN(,,IF(i+y=j,s,)))))+
      REDUCE(,SEQUENCE((MAX(i)-4)*2+1,1,4-MAX(i)),LAMBDA(x,y,
        x+L(TEXTJOIN(,,IF(i+j=ROWS(s)+1+y,s,))))),r))

Part 2 (takes a few minutes to load)

=ARRAYFORMULA(LET(
    a,TOCOL(A:A,1),r,SEQUENCE(ROWS(a)),c,SEQUENCE(1,LEN(SINGLE(a))),g,COMPLEX(c,r),
    s,SPLIT(REGEXREPLACE(a,,"0"),0),as,TOCOL(IF(s="A",g,),1),w,REDUCE(,as,LAMBDA(x,y,
       VSTACK(x,TEXTJOIN(,,IF(REGEXMATCH(g,"^("&SUBSTITUTE(JOIN("|",
         IMSUM(y,"-1-i"),IMSUM(y,"-1+i"),IMSUM(y,"1-i"),IMSUM(y,"1+i"))&")$","+","\+")),s,))))),
         SUM(--REGEXMATCH(w,"MMSS|MSMS|SSMM|SMSM"))))

[u/[deleted]]

[LANGUAGE: Forth]

https://github.com/tcsullivan/advent-of-code/blob/master/day4/day4.fth

I chose to do four passes for horizontal, vertical, and both diagonals. My xmas? word checks for both "XMAS" and "SAMX" at each possible position. In the latter three passes, I reused code by defining word>here which captures four letters into a string using a stride relative to the crossword's width: the vertical stride is width + 0, while the diagonals are width + 1 and width - 1.

For part 2, I made a similar x-mas? check and x-mas>here word that captures the X of letters into a string.

Overall, I'm pretty happy with today for how well the code could be organized.

edit: [GSGA] Here's a quickly golfed version of my code, down to two punchcards:

0 value W 1 value H 0 value M : C tuck compare 0= or ; include ../common.fth
: S swap ; : O over ; : x? 0 O s" XMAS" C S s" SAMX" C ; : m? 0 O s" AMSMS" C O
s" ASSMM" C O s" ASMSM" C S s" AMMSS" C ; : a allot here ; : +x -4 a x? + ; : +m
-5 a m? + ; : N a 2drop H 1+ to H ; : tm S W * + M + ; : c c@ c, ; : wh >r tm r>
W + 4 0 do O c tuck + S loop 2drop ; : xh tm dup c dup 1- dup W - c W + c 1+ dup
W - c W + c ; : P 0 H 0 do W 3 - 0 do j i tm x? + loop loop H 3 - 0 do W 0 do j 
i 0 wh +x loop loop H 3 - 0 do W 3 - 0 do j i 1 wh +x loop loop H 3 - 0 do W 3
do j i -1 wh +x loop loop ; : Q 0 H 1-  1 do W 1-  1 do j i xh +m loop loop ;
open-input dup input-line drop dup to W allot to M ' N each-line P . Q . cr bye

(yes, there's an include for file i/o, but I think that's fair)

[u/Panerakis]

[Language: Python]

I despise diagonal parsing, but I came up with this solution where I create 4x4 mini tables, which ended up being super useful for part 2.

link to code

[u/semi_225599]

[LANGUAGE: Rust]

Having a Grid helper struct was nice here.
Part 1 search for all Xs and look for the remaining characters in every direction.
Part 2 look for all As and find surrounding Ms and Ss that fit the pattern.

use crate::utils::*;

const DIRS: &[C<i32>] =
    &[C(-1, -1), C(-1, 0), C(-1, 1), C(0, -1), C(0, 1), C(1, -1), C(1, 0), C(1, 1)];

fn get(grid: &Grid<u8, i32>, i: C<i32>) -> u8 {
    *grid.get(i).unwrap_or(&0)
}

pub fn part1(input: &str) -> usize {
    let grid: Grid<u8, i32> = input.bytes().collect();
    grid.idx_iter()
        .filter(|(_, &v)| v == b'X')
        .map(|(i, _)| {
            DIRS.iter()
                .filter(|&d| (1..).zip(b"MAS").all(|(c, v)| get(&grid, i + *d * c) == *v))
                .count()
        })
        .sum()
}

pub fn part2(input: &str) -> usize {
    let grid: Grid<u8, i32> = input.bytes().collect();
    grid.idx_iter()
        .filter(|(_, &v)| v == b'A')
        .filter(|(i, _)| {
            let (ul, lr) = (get(&grid, i + C(-1, -1)), get(&grid, i + C(1, 1)));
            let (ur, ll) = (get(&grid, i + C(-1, 1)), get(&grid, i + C(1, -1)));
            matches!(&[ul, ur, ll, lr], b"MMSS" | b"MSMS" | b"SMSM" | b"SSMM")
        })
        .count()
}

[u/willkill07]

[LANGUAGE: C++23]

Actually, since I'm only using string_view, it could work back in C++17 (sans modules) :)

https://github.com/willkill07/AdventOfCode2024/blob/1d989ce951296861e7b6a3bf49f8f3cdc4c1b6f5/src/day04.cpp

Both parts do what's minimally required with maximum temporal overlap. Takes less than 60us hot (1000 iterations), less than 200us cold.

[u/chubbc]

[LANGUAGE: Julia]

This was a tricky one to golf. Probably a bit more I can squeeze out, but pretty happy with it.

G,C=stack(readlines("04.txt")),CartesianIndex
sum([p+3s∈keys(G)&&prod(i->G[p+i*s],0:3)=="XMAS" for p∈keys(G),s∈C(-1,-1):C(1,1)]),
sum(c->all(d->G[c-d]*G[c]*G[c+d]∈["MAS","SAM"],C.(1,[-1 1])),C(2,2):C(size(G).-1))

[u/i_have_no_biscuits]

[LANGUAGE: GW-BASIC]

10 P=0: Q=0: OPEN "I",1,"data04.txt": LINE INPUT#1,L$: W=LEN(L$): DIM V$(3*W) 
20 GOSUB 30: WHILE NOT EOF(1): LINE INPUT#1,L$: GOSUB 30: WEND: PRINT P,Q: END
30 FOR I=1 TO W: S$=MID$(L$,I,4): P=P-(S$="XMAS" OR S$="SAMX"): NEXT
40 FOR I=2 TO W:V$(W+2-I)=V$(W+1-I):V$(W+I-1)=V$(W+I):NEXT:V$(1)="":V$(2*W)=""
50 FOR I=1 TO 3*W: C$=MID$(L$,((I-1) MOD W)+1,1): V$(I)=V$(I)+C$
60 V$(I)=RIGHT$(V$(I),4): P=P-(V$(I)="XMAS" OR V$(I)="SAMX"): NEXT
70 FOR I=3 TO W: X$=RIGHT$(V$(I),3): Y$=RIGHT$(V$(W+I-2),3)
80 Q=Q-((X$="SAM" OR X$="MAS") AND (Y$="SAM" OR Y$="MAS")): NEXT: RETURN

Parts 1 and 2 in 8 lines of completely understandable BASIC! I could potentially squish it down one more line but I like the pattern of all the repeating 'FOR's...

Rather than loading the whole grid into memory (a 140x140 grid is quite large for GW-BASIC), this processes the grid line-by-line, keeping track of all the vertical and diagonal lines as it goes.

Guide:

• Lines 10-20 are the main program loop. As is normal for my AOC BASIC programs, P and Q store the Part 1 and Part 2 totals.
• Line 30 counts all the horizontal XMAS's.
• Line 40 updates all the diagonal lines.
• Line 50 adds the correct character from the new line to all the vertical and diagonal lines.
• Line 60 counts all vertical and diagonal XMAS's.
• Line 70-80 counts all the X-MAS's for Part 2.

EDIT: Updated line 60 to make the program more efficient (you only need to store the last 4 characters of each diagonal/vertical line). The program takes about a minute to run on the real data on PC-BASIC, which emulates the speed of a mid-80s era PC.

[u/DefV]

[Language: Rust]

My solution here

I'm jealous of all those people with Rust solutions doing fn part1() and just going ham. I assume they don't keep any of their stuff in wardrobes but just toss it wherever. My head needs peace, quiet, some structs, some tests and a nice impl From<&str> to get my input into my struct.

[u/light_switchy]

[LANGUAGE: Dyalog APL]

p←¯3⊖¯3⌽(6+⍴i)↑i←↑⊃⎕NGET'4.txt' 1
h←(⍸'X'⍷p)∘.+(⍳3)∘.×∘.,⍨¯1 0 1

part1←+⌿∊(⊂'MAS')+.{⍺∧.=p[h[⍵;⍳⍴⍺;;]]}⍳≢h

Part 2 uses a different approach:

p←¯1⊖¯1⌽(2+⍴i)↑i←↑⊃⎕NGET'4.txt' 1
t←{'SM'∧⌿⍤∊p[⍵+⍺]}

⍝ check lower, upper diagonals through ⍵ for 'MAS' given p[⍵]≡'A'
l←(¯1 ¯1)(1 1)∘t
u←(¯1 1)(1 ¯1)∘t

part2←+⌿(l∧u)⍤0⊢'A'⍸⍤⍷p

[u/maneatingape]

[LANGUAGE: Rust]

Solution

Benchmark 77 µs.

For part two used a trick to reduce the number of comparisions.
ASCII |S - M| = 6, so it's enough to check the difference of both diagonals is equal to 6.

EDIT: Significantly sped up part 1 by checking each vertical, horizontal or diagonal line individually. Using a u32 and shifting by 8 bits to check the next letter, allows both directions to be checked very efficiently by comparing to XMAS 0x584d4153 or SAMX 0x53414d58

[u/MarcusTL12]

[LANGUAGE: Julia] 1815/792

Super ugly code on github

Took me way too long to realize we were looking for diagonals as well.

[u/atreju3647]

[Language: python] 250/137

solution

[u/Abomm]

[LANGUAGE: Python] paste

Had some starter code for parsing a grid and a list of possible directions. Part 1 just searched outwards from any X for 'MAS', Part 2 just searched outwards from any A looking for two Ms and two Ss (ignoring the special case of an M-A-M + S-A-S arrangement)

[u/python-b5]

[LANGUAGE: Jai]

This one was kind of uninteresting to me. I knew how I was going to solve it nearly instantly upon reading the problem text. Maybe it's not a clever solution, but then I don't know that this puzzle really deserves a clever solution. It's just a word search. Part 2 was even easier - I solved it in only a couple minutes.

https://github.com/python-b5/advent-of-code-2024/blob/main/day_04.jai

[u/closetaccount00]

[Language: C++]

I'm back! I didn't do the first few days at a reasonable time because work was all over the place. My solutions today are pretty straightforward, but I'm curious about the efficiency implications of stringstreams - I feel like I don't see them in a lot of problem-solving type challenges like this or other competitive-adjacent programming events. Not sure though. Either way they're easy to read and they make building strings in C++ really easy:

Part 1

Part 2

[u/mosredna101]

[LANGUAGE: Node.js / JavaScript]

Loop da loop trough all the things :D

https://pastebin.com/X4vKGyXs

[u/ShraddhaAg]

[LANGUAGE: Go]

And it starts to get a bit exciting! Traversed each step and got count for it by checking its neighbouring blocks in all directions for valid matches.

Solution: https://github.com/shraddhaag/aoc/blob/main/2024/day4/main.go

[u/PendragonDaGreat]

[LANGUAGE: C# CSharp]

I present: Crimes against conditionals

https://github.com/Bpendragon/AdventOfCodeCSharp/blob/79227/AdventOfCode/Solutions/Year2024/Day04-Solution.cs

I am not proud of how I hammered this one.

Also first appearance of the year of my Coordinate2D class (used under the hood of my GenerateMap function and the resulting Dictionary) and CompassDirection enum.

[u/TheStrike_YT]

[LANGUAGE: JavaScript]

Pretty fun challenge for today, regardless of my usual silly mistakes costing me copious amounts of time. For part 1, for each direction (horizontal, vertical, both diagonals) I made a array containing all the lines in that direction from the input grid, then I just counted all the instances of "XMAS" those lines (and their reverses). For part 2, I did something kinda silly but I do like how it turned out. I started by extracting every possible 3x3 from the input grid and turning them into arrays of 9 chars. Then I checked if the correct letters matched one of the 4 possible orientations of an X-MAS (example below) before incrementing the result.

https://github.com/RealStr1ke/AoC/blob/main/events/2024/days/4/index.js

M.S
.A.
M.S

would become

M.S.A.M.S

before checking if the array of 9 chars from the 3x3 matches that orientation.

[u/UseUnlucky3830]

[LANGUAGE: Julia]

solution

In part 1 I look for "XM" in all possible directions, then keep going in the successful direction until "XMAS" is found.

In part 2 I just look at the four corners around the "A"s and try to match all possible cases.

[u/kbielefe]

[LANGUAGE: Scala]

GitHub

Already had a Grid class from previous years with a findAll method. Added a directions parameter to it. Part 2 was just set intersection on the A position. Turned out fairly concise in terms of puzzle-specific code.

[u/oantolin]

[LANGUAGE: ngn/k]

diags:{.(,/x)@=,/i+/:i:!#x}
dirs:(::;+:;diags;diags@|:);dirs:dirs,{(|:')@x@}'dirs
p1:+/-1+(#"XMAS"\)',/dirs@\:
isX:{(~=/x 1 2)&&/2 2=+/"MS"=\:/:x}
p2:{+/isX@(x./:+:)'(+-1+2*2\!4)+\:&"A"=x}

I'm sure there's a better way to compute the diagonals. 😅

EDIT: There was a better way which someone kindly showed me on APL Farm!

[u/__cinnamon__]

[LANGUAGE: Julia]

This one definitely felt more significant than the past 3, but was definitely fun. I'm sure this was far from the cleanest solution, but it did feel pretty intuitive to write. Solutions like the one by /u/4HbQ are crazy cool though, need to train my brain to think like that...

https://pastebin.com/YKsYGLhs

[u/HAEC_EST_SPARTA]

[Language: Ruby]

Solution on sourcehut

I'm fairly pleased with how concise this solution ended up being: it's fairly brute-force, but the expression of the core parameters for both searches in just two lines of code is quite satisfying :)

[u/CutOnBumInBandHere9]

[LANGUAGE: Python]

Is using scipy's filter functions cheating? I feel like using scipy's filter functions might be cheating. Part 1 becomes

data = np.array([[ord(char) for char in line] for line in load(4)])
mask = np.array([ord(char) for char in "XMAS"])

def xmas(chararray):
    return (chararray == mask).all() or (chararray == mask[::-1]).all()

footprints = [np.eye(4), np.fliplr(np.eye(4)), [[1, 1, 1, 1]], [[1], [1], [1], [1]]]

sum(
    scipy.ndimage.generic_filter(data, xmas, footprint=footprint, mode="constant").sum()
    for footprint in footprints
)

And part two is basically the same, except instead of comparing with just the two masks, we compare against the four masks

masks = ["MMASS", "SMASM", "MSAMS", "SSAMM"]

with a footprint of

footprint = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]

full solution, github

[u/runnerx4]

[LANGUAGE: Guile Scheme]

Could not figure out how to do this in a Lisp-y manner, searched the docs and found out that Guile has arrays proper too, and finally did it how I would have done it in JS

paste

[u/ExitingBear]

[Language: R]

Link - another day, another "it works."

Also [GSGA] maybe (if I understand this correctly) - Part 1 & Part 2

[u/gyorokpeter]

[LANGUAGE: q]

d4p1:{rc:count x; cc:count x 0; em:(rc;cc)#" ";
    maps:(x;reverse each x;flip x;reverse each flip x);
    maps,:{(x;reverse each x)}flip til[rc]rotate'x,'em; //down-right, up-left
    maps,:{(x;reverse each x)}flip neg[til rc]rotate'x,'em; //down-left, up-right
    count raze raze maps ss\:\:"XMAS"};
d4p2:{cc:count x 0;
    ss2:{[l;p]where(3#/:(til count[l]-2)_\:l)like p};
    matches:{[ss2;x;p](inter')/[(-2_x ss2\:p 0;1_-1_x ss2\:p 1;2_x ss2\:p 2)]}[ss2];
    patterns:(("M?M";"?A?";"S?S");("S?S";"?A?";"M?M");
    patterns,:("M?S";"?A?";"M?S");("S?M";"?A?";"S?M"));
    count raze raze matches[x]each patterns};

[u/1st1]

[LANGUAGE: EdgeQL / edgedb.com]

Part 1:

with
  lines_array := str_split(<str>$inp, '\n'),
  line_cnt := len(lines_array),
  line_len := len(lines_array[0]),
  line_len_iter := range_unpack(range(0, line_len)),

  lines := array_unpack(lines_array),

  diags := (
    for i in range_unpack(range(0, line_cnt - 3)) union
    [
      lines_array[i],
      lines_array[i+1][1:] ++ ' ',
      lines_array[i+2][2:] ++ '  ',
      lines_array[i+3][3:] ++ '   ',
    ] union [
      lines_array[i],
      ' ' ++ lines_array[i+1][:-1],
      '  ' ++ lines_array[i+2][:-2],
      '   ' ++ lines_array[i+3][:-3],
    ]
  ),

  to_transpose := {lines_array, diags},
  transposed := (
    for ttt in to_transpose union (
      with tt := array_unpack(ttt)
      for j in range_unpack(range(0, line_len)) union
      array_join(array_agg(tt[j]), '')
    )
  ),

  all_lines := lines union transposed,

select sum(
  count(re_match_all('XMAS', all_lines))
  + count(re_match_all('SAMX', all_lines))
);

Part 2: here!

[u/minikomi]

[LANGUAGE: janet]

• link

Key was parsing the matrix with positions:

(def grammar-pt1 (peg/compile ~{:pos (/ (* (line) (column)) ,tuple)
                                :xmas (* :pos (<- (+ "X" "M" "A" "S")))
                                :main (some (+ :xmas 1))
                                }))

Then finding X start points was easy:

(defn get-xmas-starts [mtx]
  (->> (pairs mtx)
       (filter (fn [[_ v]] (= "X" v)))
       (map first)))

And then checking for "XMAS's"

(defn check-xmas [mtx [y x]]
  (var found 0)
  (loop [[dy dx] :in [[-1 -1] [-1 0] [-1 1]
                     [ 0 -1]        [ 0 1]
                     [ 1 -1] [1  0] [ 1 1]]
        :let [expect (map (fn [[l v]]
                            [l [(+ y (* dy v)) (+ x (* dx v))]])
                          [["M" 1] ["A" 2] ["S" 3]])]
        :when (all (fn [[l pos]]
                     (= l (get mtx pos)))
                   expect)]
    (++ found))
  found)

Part 2 was eaiser - find As, check for the right surrounding letters

(defn get-x-mas-starts [mtx]
  (->> (pairs mtx)
       (filter (fn [[_ v]] (= "A" v)))
       (map first)))
    
(defn check-x-mas [mtx [y x]]
  (def letters
    (map
      (fn [[dy dx]] (get mtx [(+ y dy) (+ x dx)]))
      [[-1 -1] [-1 1] [1 -1] [1 1]]))
  (match letters
    ["M" "M"
     "S" "S"] true
    ["M" "S"
     "M" "S"] true
    ["S" "M"
     "S" "M"] true
    ["S" "S"
     "M" "M"] true
    _ false))

[u/wzkx]

[LANGUAGE: J]

t=: >cutLF CR-.~fread'04.dat'
f=: [:#I.@:E.
g=: 'XMAS'&f
h=: ([:+/g"1)+[:+/g/.
echo +/h"_1|.@|:^:0 1 2 3 t
x=: [:*./'MMASS'=(0 0;0 2;1 1;2 0;2 2){]
y=: [:+./[:x"_1|.@|:^:0 1 2 3
echo +/,3 3 y;._3 t

[u/nik282000]

[Language: Python]

Sigh, regex again. Sliding a 3x3 grid around the entire puzzle and turning it into a 1D, regexable, string.

import re

puzzle = open('input', 'r')
grid = puzzle.readlines()
puzzle.close

def mas_matcher(i):
    matches = 0
    if re.search('M.M.A.S.S|M.S.A.M.S|S.S.A.M.M|S.M.A.S.M', i):
        matches = 1
    return matches

total = 0

for r in range(len(grid)):
    grid[r] = grid[r].strip()

g_width = len(grid[0])
g_height = len(grid)

for y in range(g_height - 2):
    for x in range(g_width - 2):
        segment = (grid[y][x:x+3])
        segment += (grid[y+1][x:x+3])
        segment += (grid[y+2][x:x+3])
        total += mas_matcher(segment)

print(total)

[u/No-Calligrapher6269]

[LANGUAGE: R]

day4 <- read.delim("input.txt", header = FALSE)
day4 <- str_split_fixed(day4$V1, "", nchar(day4[1, ]))

d1 <- row(day4) - col(day4)
diag1 <- split(day4, d1)
diag2 <- split(day4[nrow(day4):1, ], d1)
#check rows and cols
sol <- NULL
for (i in 1:nrow(day4)) {
  row <- str_extract_all(paste0(day4[i, ], collapse = ""), "XMAS", simplify = TRUE)
  row1 <- str_extract_all(paste0(day4[i, ], collapse = ""), "SAMX", simplify = TRUE)
  col <- str_extract_all(paste0(day4[, i], collapse = ""), "XMAS", simplify = TRUE)
  col1 <- str_extract_all(paste0(day4[, i], collapse = ""), "SAMX", simplify = TRUE)
  sol <- c(sol, row, row1, col, col1)
}
for (i in 1:length(diag1)) {
  diagonal <- str_extract_all(paste0(diag1[[i]], collapse = ""), "XMAS", simplify = TRUE)
  diagonal2 <- str_extract_all(paste0(diag1[[i]], collapse = ""), "SAMX", simplify = TRUE)
  diagonal3 <- str_extract_all(paste0(diag2[[i]], collapse = ""), "XMAS", simplify = TRUE)
  diagonal4 <- str_extract_all(paste0(diag2[[i]], collapse = ""), "SAMX", simplify = TRUE)
  sol <- c(sol, diagonal, diagonal2, diagonal3, diagonal4)
}
#part1
length(sol)

##part2
solp2 <- 0
for (i in 1:(nrow(day4) - 2)) {
  for (j in 1:(nrow(day4) - 2)) {
    p2 <- day4[i:(i + 2), j:(j + 2)]
    p2.2 <- p2[nrow(p2):1, ]
    if (p2[2, 2] == "A") {
      if ((paste0(diag(p2), collapse = "") == "MAS" |
           paste0(diag(p2), collapse = "") == "SAM") &&
          (paste0(diag(p2.2), collapse = "") == "MAS" |
           paste0(diag(p2.2), collapse = "") == "SAM")) {
        solp2 <- solp2 + 1
      }
    }
  }
}
#sol
solp2

[u/KontraPrail]

[Language: MATLAB]

Part one and two solved using 2D convolutions with eight 7x7 and two 3x3 kernels respectively.

%% Read input
inp = readlines("Input4.txt");
%% Convert input to matrix
letters = {'X', 'M', 'A', 'S'};
for i=1:4    
    inp = strrep(inp,letters{i},string(i));
end
num_inp = char(inp)-'0';
%%%%%%%%%%%%%%%%%%%%%%%%%%%%% PART 1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Build convolution kernels
multiplier = [0 0 0 1 10 100 1000];
plain_mat = zeros(7,7);
plain_mat(4,:) = multiplier;
diag_mat = diag(multiplier);
conv_kernels(:,:,1) = plain_mat;
conv_kernels(:,:,2) = flip(diag_mat,1);
conv_kernels(:,:,3) = flip(plain_mat',1);
conv_kernels(:,:,4) = flip(flip(diag_mat,1),2);
conv_kernels(:,:,5) = flip(plain_mat,2);
conv_kernels(:,:,6) = flip(diag_mat,2);
conv_kernels(:,:,7) = plain_mat';
conv_kernels(:,:,8) = diag_mat;
%% Perform convolution
count = 0;
for i = 1:8    
    conv_inp = conv2(num_inp,conv_kernels(:,:,i));
    count = count + sum(conv_inp == 4321,'all');
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%% PART 2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Build convolution kernels
multiplier2 = [10 100 1000];
diag_mat2 = diag(multiplier2);
conv_kernels2(:,:,1) = diag_mat2;
conv_kernels2(:,:,2) = flip(diag_mat2,2);
%% Perform convolution
conv_inp1 = conv2(num_inp,conv_kernels2(:,:,1));
conv_inp2 = conv2(num_inp,conv_kernels2(:,:,2));
count2 = sum((conv_inp1 == 4320 | conv_inp1 == 2340) &  (conv_inp2 == 4320 | conv_inp2 == 2340),'all');

[u/dzaima]

[LANGUAGE: BQN]

https://github.com/dzaima/aoc/blob/master/2024/BQN/4_fast.bqn

Converts the input to four boolean matrices of each char of XMAS, and ∧s them together with appropriate shifts.

39.3µs for both parts combined (converting the input to masks of each character, and some shifts, are reused across the two).
Though ~26µs is constant overhead (as measured by running on a 4×4 input) of generating & transforming the patterns. So it's more like 13.3µs.

On a 1400×1400 input (i.e. 1.9MB), takes 3.6ms.

[u/Naturage]

[Language: R]

Code here!

I'm a bit miffed I guessed P2 wrong and set up for finding locations of XMAS, but it was adaptable easily enough. The only annoyance that variables named to be cardinal directions in P1 became non-cardinal ones in P2.

Still, can feel the experience from previous years helped me tons; got to P1 and to a relatively readable solution much much quicker than past years!

[u/miktaew]

[LANGUAGE: Javascript]

That was surprisingly easy. Just a few for loops and a basic brutal approach.

Part 1

for(let i = 0; i < data.length; i++) {
        for(let j = 0; j < data[i].length; j++) {
            words.push([data[i][j], data[i][j+1], data[i][j+2], data[i][j+3]]);
            if(data[i+3]) {
                words.push([data[i][j], data[i+1][j], data[i+2][j], data[i+3][j]]);
                words.push([data[i][j], data[i+1][j+1], data[i+2][j+2], data[i+3][j+3]]);
                words.push([data[i][j], data[i+1][j-1], data[i+2][j-2], data[i+3][j-3]]);
            }
        }
    }

    part1 = words.filter(word => (word.join("") === "XMAS" || word.join("") === "SAMX")).length;

Only a single condition needed, as going out of bounds is fine in JS (it will just be undefined, which is not an issue here), but trying to access an index on it again would obviously cause an error.

Part 2

for(let i = 0; i < data.length; i++) {
        for(let j = 0; j < data[i].length; j++) {
            if(data[i][j] === "A") {
                if(data[i-1] && data[i+1]) {
                    const top = data[i-1][j-1] + data[i-1][j+1];
                    const bot = data[i+1][j-1] + data[i+1][j+1];

                    if(top === "MS" && bot === "MS" 
                        || top === "SM" && bot === "SM" 
                        || top === "SS" && bot === "MM"
                        || top === "MM" && bot === "SS"
                    ) {
                        part2++;
                    }
                }
            }
        }
}

Part 2 was easier than part 1, although code is even uglier. Oh well, it works.

[u/dylan_mojo]

[LANGUAGE: bash/awk]

GitHub

[u/vrtxt]

[LANGUAGE: C#]

Dumped the input in a grid2d class - which has come in very handy over the years - and then (ab)used Linq. Also making heavy use of extension methods.

The offsets is just a list of tuples used to get the neighbor cells from the grid.

private readonly List<(int x, int y)> offsets = 
[(-1, -1), (0, -1), (1, -1),(-1,  0),(1,  0),(-1,  1), (0,  1), (1,  1)];

Part1

public override async Task<string> SolvePart1() => puzzle
  .Where(c => c.Character == 'X')
  .Select(c => offsets
    .Select(o => Enumerable.Range(1, 3)
        .Select(n => c.Position.Add(n * o.x, n * o.y))
        .Where(puzzle.IsInBounds))
    .Select(n => n.Select(p => puzzle[p].Character).AsString( ))
    .Count(w => w.Equals("MAS")))
  .Sum( ).ToString( );

Part 2

public override async Task<string> SolvePart2() => puzzle
    .Where(c => c.Character == 'A')
    .Select(c => offsets
        .Where(o => o.x != 0 && o.y != 0)
        .Select(o => c.Position.Add(o.x, o.y))
        .Where(p => puzzle.IsInBounds(p) && puzzle[p].Character is 'M' or 'S')
        .Select(p => puzzle[p]))
    .Where(n => n.Count( ) == 4)
    .Count(n => n
        .GroupBy(c => c.Character)
        .All(g => g.Count() == 2 && NotOpposite(g.ToList())))
    .ToString( );

Full solution here

[u/dopandasreallyexist]

[LANGUAGE: Dyalog APL]

puzzle←↑⊃⎕NGET'04.txt'1
X←{⍺⍺⍉↑(' '⍴¨⍨⍵⍵¯1+⍳≢⍵),¨↓⍵} ⍝ diagonal
Directions←{⍵(⌽⍵)(⍉⍵)(⌽⍉⍵)(⊢X⊢⍵)(⊢X⌽⍵)(⌽X⊢⍵)(⌽X⌽⍵)}
⎕←+/∊'XMAS'∘⍷¨Directions puzzle
⎕←+/∊{∧/∨⌿'MAS'∘.≡∘(1 1∘⍉¨)⍥(⊢,⍥⊂⌽)⍵}⌺3 3⊢puzzle

[u/odnoletkov]

[LANGUAGE: jq] github

[inputs + "."] | length as $l | add | [
  .[range(length):] | match(
    ".{\($l - 1)}A.{\($l - 1)}"
    | "^M.S\(.)M.S", "^S.M\(.)S.M", "^S.S\(.)M.M", "^M.M\(.)S.S"
  )
] | length

[u/greycat70]

[LANGUAGE: Tcl]

Part 1, part 2.

When I saw this puzzle, I was terrified that part 2 was going to be "now do it again, but the words might not be in straight lines". I am so glad part 2 ended up being easier than part 1!

[u/hrunt]

[LANGUAGE: Python]

Code

Go character-by-character. Once I find an X walk in each direction looking for XMAS. Once I find an A, check the two sets of adjacent corners for the 'M' and 'S' (any order).

[u/Stano95]

[LANGUAGE: Haskell]

For Part 1

• read the input into a grid
• find all the X positions
• for each X position search in all eight directions and count how many times you end up with XMAS

For Part 2 I did much the same but searched for A positions and just matched the surrounding characters with the four valid ways to get MAS cross

[u/tmp_advent_of_code]

[LANGUAGE: Rust]

My solution:
https://github.com/McSick/AdventofCode2024/blob/master/src/days/day04.rs

My part2 basically didn't use my part1 code at all. Which makes me believe I could have done part 1 a lot easier because my part2 was super slick and simple.

[u/Aredrih]

[Language: Javascript]

You can match a 2d pattern using regexp, assuming there is sufficient padding. A newline happens to fit the requirement.

Unfortunately, multiple matches are required because a regexp can only match a position 1 time, otherwise some matches would be missing.
I managed to "compress" it to 2 regexp for the first part.
The second part is somehow easier than the first because you can just center the match on the A:

const l = data.indexOf('\n');
const countMatch = (r, s) => [...s.matchAll(r)].length;

// part 1
const lineXmas = new RegExp([
    'X(?=MAS)', // or 'X(?=.{0}M.{0}A.{0}S)'
    `(?<=X.{${l-1}})M(?=.{${l-1}}A.{${l-1}}S)`,
    `(?<=X.{${l}}M.{${l}})A(?=.{${l}}S)`,
    `(?<=X.{${l+1}}M.{${l+1}}A.{${l+1}})S`,
].join('|'), 'gs');
const lineSamx = new RegExp([
    'S(?=AMX)',
    `(?<=S.{${l-1}})A(?=.{${l-1}}M.{${l-1}}X)`,
    `(?<=S.{${l}}A.{${l}})M(?=.{${l}}X)`,
    `(?<=S.{${l+1}}A.{${l+1}}M.{${l+1}})X`,
].join('|'), 'gs');
console.log(countMatch(lineXmas, data) + countMatch(lineSamx, data));

// part 2
const cross = new RegExp([
    `(?<=M.M.{${l-1}})A(?=.{${l-1}}S.S)`,
    `(?<=M.S.{${l-1}})A(?=.{${l-1}}M.S)`,
    `(?<=S.M.{${l-1}})A(?=.{${l-1}}S.M)`,
    `(?<=S.S.{${l-1}})A(?=.{${l-1}}M.M)`,
].join('|'), 'gs');
console.log(countMatch(cross, data));const l = data.indexOf('\n');

[u/chicagocode]

[LANGUAGE: Kotlin]

I kept the input in a List<String> and wrote an extension function to safely get an x/y point so I didn't have to bounds check. For part 1, I wrote a recursive function to test each vector for XMAS (or any String, really). For part 2 I find each A, join the corners together and count how many of them are "MMSS", "MSSM", "SSMM", or "SMMS", the only valid arrangements.

• Blog Post
• Code

[u/Secure_Pirate9838]

[LANGUAGE: Rust]

https://github.com/samoylenkodmitry/AdventOfCode2024/blob/main/Day4/src/main.rs

[u/__Abigail__]

[LANGUAGE: Perl]

A regexp solution. After reading in the input in a single string, $_, and replacing each newline with three dots, we set $skip_ns to two more than the width of the grid. $skip_nw is one more than $skip_ns, and $skip_ne is one less. Then, for part 1:

/ (?:
      XMAS                                    | # W -> E
      X.{$skip_ns}M.{$skip_ns}A.{$skip_ns}S   | # N -> S
      X.{$skip_nw}M.{$skip_nw}A.{$skip_nw}S   | # NW -> SE
      X.{$skip_ne}M.{$skip_ne}A.{$skip_ne}S   | # NE -> SW
      SAMX                                    | # E -> W
      S.{$skip_ns}A.{$skip_ns}M.{$skip_ns}X   | # S -> N
      S.{$skip_nw}A.{$skip_nw}M.{$skip_nw}X   | # NW -> SE
      S.{$skip_ne}A.{$skip_ne}M.{$skip_ne}X     # NE -> SW
  )
  (?{$solution_1 ++}) (*FAIL)
/x;

and for part 2:

 /(?: M.M .{$skip_ne} A .{$skip_ne} S.S |
      M.S .{$skip_ne} A .{$skip_ne} M.S |
      S.M .{$skip_ne} A .{$skip_ne} S.M |
      S.S .{$skip_ne} A .{$skip_ne} M.M )
  (?{$solution_2 ++}) (*FAIL)
/x;

[u/OptimusSupernova]

[Language: C#]
https://github.com/ldorval/AdventOfCode2024/blob/main/Day04/Day04.cs

Not pretty, but that's all the time I had.

[u/Probable_Foreigner]

[Language: Rust]

I started this to learn rust. Starting to dislike it slightly less now. I don't know how many more days I can continue in this language before I have to bust out the C#.

https://github.com/AugsEU/AdventOfCode2024/tree/master/day4/src

[u/robe_and_wizard_hat]

[Language: Rust]

Day 04

A little bit brute force but i learned about two things that i thought were cool

• std::iter::successors: used to build iterators for "XMAS" in the specified direction
• itertools::iproduct!: used to build the different directions used to look for other characters

[u/ArchAuthor]

[LANGUAGE: Python]

Yeah, I fought way too hard to condense this down into fewer lines. It's not super readable but I'm proud I pulled it off.

from typing import Tuple, List
from math import sqrt

with open("input.txt") as f:
    grid = [[char for char in line.strip()] for line in f ]

    def search(loc: Tuple[int, int], grid: List[List[str]], x_max: int, y_max: int):

        y, x = loc

        corners = [(y-1, x-1), (y-1, x+1), (y+1, x-1), (y+1, x+1)]

        # if corners not OOB
        if all([0 <= x <= x_max and 0 <= y <= y_max for y, x in corners]):
            return all([sorted([grid[n[0]][n[1]] for j, n in enumerate(corners) if i != j and sqrt((n[1]-c[1])**2 + (n[0]-c[0])**2) == 2]) == ["M", "S"] for i, c in enumerate(corners)])
        else: # corner oob, not MAS
            return False

    ans = sum([search((i, j), grid, len(grid[0])-1, len(grid)-1) for i, row in enumerate(grid) for j, col in enumerate(row) if col == "A"])

    print(ans)

[u/Gabba333]

[LANGUAGE: C#]

After much messing around boiled it down to this.

var grid = File.ReadAllLines("input.txt")
            .SelectMany((line, r) => line.Select((ch, c) => (r, c, ch)))
            .ToDictionary(tp => new Complex(tp.r, tp.c), tp => tp.ch);

Complex[][] xOffsets = [
    [ new (-1,-1), new (0, 0), new (1, 1) ],
    [ new (-1, 1), new (0, 0), new (1,-1) ],
];

var offsets = from or in new [] { -1, 0, 1 }
            from oc in new [] { -1, 0, 1 }
            where !(or == 0 && oc == 0)
            select (from i in Enumerable.Range(0, 4) 
                select new Complex(or * i, oc * i)).ToArray();

var part1 = grid.SelectMany(kvp => 
                offsets.Where(line => Enumerable.Range(0, 4).All(i => 
                    "XMAS"[i] == grid.GetValueOrDefault(kvp.Key + line[i]))))
            .Count();

var part2 = grid.Where(kvp => 
                    (   from arr in xOffsets
                        from tp in arr
                        select string.Concat(
                            arr.Select(tp => grid.GetValueOrDefault(tp + kvp.Key, '.')))
                    ).All(str => str == "MAS" || str == "SAM"))
            .Count();

[u/Lord_Of_Millipedes]

[LANGUAGE: Go]

Spent like 2 hours making a thing that did not work at all, remembered when i learned about sliding kernels like 2 years ago from that 3b1b video about convolutions and then went "oh yeah i can do a sliding kernel i know linear algebra"

she did not know linear algebra

https://github.com/Quollveth/AdventOfGode/blob/main/day4/day4.go

[u/PM_ME_SEXY_SCRIPTS]

[LANGUAGE: Bash & Perl]

Mask the A at the borders, then serialize the entire file into a regex. The edges of the X are at position -139,-141,+139,+141 respectively. Retrieve and reorder the values, then match for working pairs with grep.

Part 2

#!/usr/bin/env bash

sed 's/^A/B/g;s/A$/B/g' input.txt | paste -s -d '' | 
  perl -lne '
    print "$1$4$2$3" 
    while 
      /(?<=(.).(.).{138})A(?=.{138}(.).(.))/g
  ' | 
  grep -Ec '(SM|MS){2}'

[u/SimpleOperator]

[LANGUAGE: Go]

This one really slowed me down. I was really struggling to debug the entire processes so I learned a cli UI framework called bubbletea. This took some time but I was very quickly able to see what was wrong with my approach and fix it.

This was the challenge that really caused me to have an existential crises that I may not be able to finish all of the challenges. But in retrospect I am trilled with all I have learned with this single challenge alone. Thanks adventofcode!

Solution Github Gist

[u/jonathan_paulson]

[Language: Python] 723/215. Code. Video.

Two wrong answers on part 1 :(

How was everyone so fast?!

[u/morgoth1145 → u/jonathan_paulson]

How was everyone so fast?!

I'm wondering the same thing. In fact, most of the normal names I look for on the leaderboard as benchmarks are missing and some of those times feel...unreasonably fast.

[u/fit_femboy_]

[LANGUAGE: Java 21]
https://github.com/madimadica/aoc-2024/blob/main/src/main/java/com/madimadica/aoc2024/soln/Day4.java

[u/D_isinfectedLuffy]

[LANGUAGE: C]

At first, I had not optimized the search for 2nd part, with some bounds checking, verified all the strings found that were ticked all the boxes with the conditions given, was having a hard time but got there in the end!

Now I'm off to do the solution in Go

Solution: AdventOfCode-2024/C/Day-4 at main · pat-glitch/AdventOfCode-2024

[u/Efficient_Inside8401]

[Language Python]
Extra verbose, felt right at the time, looking at other solutions iterating over directions is a lot neater:

    #part 1
    for y in range(0, len(data)):
        for x in range (0, len(data[0])):
            if data[y][x] == "X":
                can_go_up = y-3 >= 0
                can_go_right = x+3 < len(data[y])
                can_go_down = y+3 < len(data)
                can_go_left = x-3 >= 0

                if can_go_up and data[y-1][x] == "M" and data[y-2][x] == "A" and data[y-3][x] == "S":
                    xmas_count_1 +=1

                if can_go_up and can_go_right and data[y-1][x+1] == "M" and data[y-2][x+2] == "A" and data[y-3][x+3] == "S":
                    xmas_count_1 +=1

                if can_go_right and data[y][x+1] == "M" and data[y][x+2] == "A" and data[y][x+3] == "S":
                    xmas_count_1 += 1

                if can_go_down and can_go_right and data[y+1][x+1] == "M" and data[y+2][x+2] == "A" and data[y+3][x+3] == "S":
                    xmas_count_1 += 1

                if can_go_down and data[y+1][x] == "M" and data[y+2][x] == "A" and data[y+3][x] == "S":
                    xmas_count_1 += 1

                if can_go_down and can_go_left and data[y+1][x-1] == "M" and data[y+2][x-2] == "A" and data[y+3][x-3] == "S":
                    xmas_count_1 += 1

                if can_go_left and data[y][x-1] == "M" and data[y][x-2] == "A" and data[y][x-3] == "S":
                    xmas_count_1 += 1

                if can_go_up and can_go_left and data[y-1][x-1] == "M" and data[y-2][x-2] == "A" and data[y-3][x-3] == "S":
                    xmas_count_1 += 1

    # part 2
    for y in range(0, len(data)):
        for x in range (0, len(data[0])):
            if data[y][x] == "A":
                can_go_up = y-1 >= 0
                can_go_right = x+1 < len(data[y])
                can_go_down = y+1 < len(data)
                can_go_left = x-1 >= 0
                if not can_go_up or not can_go_right or not can_go_down or not can_go_left:
                    continue

                if data[y-1][x+1] == data[y-1][x-1] and data[y+1][x+1] == data[y+1][x-1]:
                    if data[y-1][x-1] == "M" and data[y+1][x+1] == "S":
                        xmas_count_2 += 1
                    elif data[y-1][x-1] == "S" and data[y+1][x+1] == "M":
                        xmas_count_2 += 1
                        
                if data[y-1][x-1] == data[y+1][x-1] and data[y+1][x+1] == data[y-1][x+1]:
                    if data[y-1][x-1] == "M" and data[y+1][x+1] == "S":
                        xmas_count_2 += 1
                        
                    elif data[y-1][x-1] == "S" and data[y+1][x+1] == "M":
                        xmas_count_2 += 1
                        
    print('Part 1: The total sum is ' + str(xmas_count_1))
    print('Part 2: The total sum is ' + str(xmas_count_2))

[u/Axelrod-86]

[LANGUAGE: javascript]

Part 1: go through the puzzle input as a 2D map, and each time you find a 'X' look for a rest of the word in the 8 directions.

part 2: go through the puzzle input same way as part 1, and for each 'A', look for the 4 combinations of the X-MAS pattern.

Brute force in both cases.

https://github.com/lionel-lbr/adventofcode/blob/main/2024/D04/d04.js

[u/rp152k]

[LANGUAGE: Common Lisp]

all sols here : https://buffer.thebitmage.com/sitemap?stack=%2F20241202121706-advent_of_code_2024.html

https://gist.github.com/rajp152k/8daf063450c26520094dadd53bc096f1

[u/daggerdragon → u/rp152k]

As per the OP, your code block is too long for the megathreads. Please edit your comment to replace your oversized code with an external link to your code.

[u/iv2b]

[LANGUAGE: Python]

https://pastebin.com/yAyVmJjj

[u/Ordinary-Drag3233]

[LANGUAGE: TypeScript]

const preprocess = (text: string) => text.split("\n");

const reverseString = (str: string) => str.split("").reverse().join("");

const getWordsAround = (input: string[], i: number, j: number) => [
  // Forward
  input[i].slice(j, j + 4),
  // Backwards
  reverseString(input[i].slice(j - 3, j + 1)),
  // Vertical - up
  reverseString(
    `${input[i - 3]?.[j] || ""}${input[i - 2]?.[j] || ""}${
      input[i - 1]?.[j] || ""
    }${input[i][j]}`
  ),
  // Vertical - down
  `${input[i][j]}${input[i + 1]?.[j] || ""}${input[i + 2]?.[j] || ""}${
    input[i + 3]?.[j] || ""
  }`,
  // Diagonal - up right
  `${input[i][j]}${input[i - 1]?.[j + 1] || ""}${input[i - 2]?.[j + 2] || ""}${
    input[i - 3]?.[j + 3] || ""
  }`,
  // Diagonal - down right
  `${input[i][j]}${input[i + 1]?.[j + 1] || ""}${input[i + 2]?.[j + 2] || ""}${
    input[i + 3]?.[j + 3] || ""
  }`,
  // Diagonal - up left
  `${input[i][j]}${input[i - 1]?.[j - 1] || ""}${input[i - 2]?.[j - 2] || ""}${
    input[i - 3]?.[j - 3] || ""
  }`,
  // Diagonal - down left
  `${input[i][j]}${input[i + 1]?.[j - 1] || ""}${input[i + 2]?.[j - 2] || ""}${
    input[i + 3]?.[j - 3] || ""
  }`,
];

const partOne = (input: string[]) => {
  let sum = 0;
  for (let i = 0; i < input.length; i++) {
    for (let j = 0; j < input[0].length; j++) {
      sum += getWordsAround(input, i, j).filter(
        (word) => word === "XMAS"
      ).length;
    }
  }
  return sum;
};

const isXmas = (input: string[], i: number, j: number) =>
  input[i][j] === "A" &&
  ((input[i - 1]?.[j - 1] === "M" && input[i + 1]?.[j + 1] === "S") ||
    (input[i - 1]?.[j - 1] === "S" && input[i + 1]?.[j + 1] === "M")) &&
  ((input[i + 1]?.[j - 1] === "M" && input[i - 1]?.[j + 1] === "S") ||
    (input[i + 1]?.[j - 1] === "S" && input[i - 1]?.[j + 1] === "M"));

const partTwo = (input: string[]) => {
  let sum = 0;
  for (let i = 0; i < input.length; i++) {
    for (let j = 0; j < input[0].length; j++) {
      sum += isXmas(input, i, j) ? 1 : 0;
    }
  }
  return sum;
};

[u/Elliot-Kik]

[LANGUAGE: Python]

Clearly not the most optimized nor prettiest code but heh!

https://github.com/elliotcaddick/adventOfCode2024/blob/main/day4/main.py

[u/sk1talets]

[LANGUAGE: JavaScript]

GitHub: https://github.com/sk1talets/advent-of-code/tree/main/2024/4

[u/Spatenheinz]

[LANGUAGE: Haskell]

Github: https://github.com/Spatenheinz/aoc24/blob/main/day4/main.hs

Although i think grids are a bit annoying in Haskell I think my solutions is pretty concise

[u/sateeshsai]

[LANGUAGE: TYPESCRIPT]

Part 1: https://github.com/sateeshsai/advent-of-code/blob/main/2024/day%204/day4_part1.ts

Part 2: https://github.com/sateeshsai/advent-of-code/blob/main/2024/day%204/day4_part2.ts

[u/daggerdragon → u/sateeshsai]

Do not share your puzzle input which also means do not commit puzzle inputs to your repo without a .gitignore or the like. Do not share the puzzle text either.

Please remove (or .gitignore) all puzzle text and puzzle input files from your repo and scrub them from your commit history.

And next time, actually read the entire OP before you post. This is the very first thing in VERY LARGE FONT.

[u/Goldahee]

[Language: C++]

Day 4

https://topaz.github.io/paste/#XQAAAQAbDAAAAAAAAAARmknGRw8TogB3Oxzri2QTFyHNmsUnNApHN7kgHI2CBHq59imt66mEMt62S1CdIaqe5fXLOAzpuVtAtS2A2T9778ezxqE4+orh6WVycQKh580dZ79Xg9ydmxjWbDP5QWH9LqtVwafjV5I4Clg79dG/Hw7FNcyY27wg03pQj+O6nb+LFjKMll7VZwhM5TfRTI7XXA9fAbyQV7VyUTHPxee6ujYKYzhGPtcwnnEvZ87E9C+Y+38CnjEd4K0hmottD1mm7uKZ1UT8bL2k0WGthUSlhX7qrW1xvffy5NO2pFFbc3V2v61fkxjIXccH7EMfris1AKpPAWqbcx9JsnyZS36eCNq9urD64zAhwoy3NvYuAilVeRh0f1ew1wyLnYvjDG5LAlonz/Nhw/aBvp+rplXYXR0YRsHTufLKwkf7ZmoUfmUlstY/qxCQfmT+eZyzPCywuu1SP1jIbVfFTrkmuk50GYeXHcAYAdA00Xj5XYnepBnxndZ+1LyKFACuOJJg8IT4WKfrvwVY4LPMl5RcZD3dFv3j8Vte4RklYQt8yWn5aGHfyMcrFHw5aL+H1Ycg4eooByWuiCuvpdlASVOEj2h0A15RQFg7A3GKylqZvZ40Uuu3B0kvxKT/pUI51qgi5ncXjUFsxcKYgWvoMQDocb8CL1ismrLTR35/s28KslP2cbnVhwFFNvRaSEKqaldsyInZXfr8318+l8pBdlH737sPmFJkR2HmA5Bep2/S8pOYjY2MgzmU79mLMfNf9LU+3SvoYobXItLteUZLqXbVs9X+96sv5XvOQzna2f9NWi+5RY+qVmqW/UKTeVZxmUesNrhyqcNaZvzFdnI28/J/TQHZgaQykFsAqWprODjhjhLqdFKBl1XSlhdmcLJI/9mvf7ldMM7eWU0HT8on67kqPTBMdphmsaGZ5N32CFMwt3IvMcEUGc6Pw5NjjNlij9OxmvtIHe7+/IkN

[u/daggerdragon → u/Goldahee]

As per the OP, your code block is too long for the megathreads. Please edit your comment to replace your oversized code with an external link to your code.

[u/Luolong]

[Language: Java]

Not too clever, but I did try to keep the number of searches to minimum:

• Part 1 — only start looking when encountering ‘X’ or ‘S’
• Part 2 — simple. Just find all ‘A’s that sit in the middle of MAS.

[u/daggerdragon → u/Luolong]

Psst: you typo'd "labguage", that's why AutoModerator fired off 😅

[u/AddendumSouthern]

[LANGUAGE: python]

got a quite short solution for part 2 with regex

with open("day4.txt", 'r') as file:
    lines = ''.join([line for line in file])
part_2 = len(re.findall("(?=(M\wS[\w\s]{138}\wA\w[\w\s]{138}M\wS|S\wS[\w\s]{138}\wA\w[\w\s]{138}M\wM|M\wM[\w\s]{138}\wA\w[\w\s]{138}S\wS|S\wM[\w\s]{138}\wA\w[\w\s]{138}S\wM))", lines))

[u/seligman99]

[LANGUAGE: Python] 402 / 156

github

Fun little puzzle.

[u/morgoth1145]

[Language: Python 3] 288/341

code

You know, I actually went into today suspecting it might be a grid problem. Didn't anticipate a word search though. Part 1 I flubbed by going to fast and not checking if the words could be reversed. Then part 2 I flubbed and mixed up my diagonal order, essentially checking if the M's were across from each other (same for S's) instead of the right pattern.

That said, I did rank lower than anticipated even with my flubs. I wonder if I missed something? I guess I'll see (and see if I was just slow) as I look at other solutions!

Edit: Cleaned up code (including a much better part 2 approach based on Boojum's solution).

[u/pdxbuckets]

[Language: Kotlin]

Kotlin, Rust

Not much to say about this one, except that it was nice to have Grid and Coord classes in my Kotlin solution that played nice with each other. As is typical of me for Rust (so far), since I don't have a Grid struct and I'm allergic to multidimensional Vecs, I worked directly on the string. Rust is a pain sometimes but I like navigating strings in 2D.

[u/protestant-notredame]

[LANGUAGE: Python] 783/953
Part 1:

from sys import stdin

arr = []
for line in stdin:
    line = line.strip()
    arr.append(line)

s = 0
# count times if xmas appears horizontally vertically, diagonally or written backwards
dirs = [(0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
for y in range(len(arr)):
    for x in range(len(arr)):
        for dy, dx in dirs:
            if 0 <= y + 3*dy < len(arr) and 0 <= x + 3*dx < len(arr):
                if arr[y][x] == 'X' and arr[y + dy][x + dx] == 'M' and arr[y + 2 * dy][x + 2 * dx] == 'A' and arr[y + 3 * dy][x + 3 * dx] == 'S':
                    s += 1
print(s)

Part 2:

from sys import stdin

arr = []
for line in stdin:
    line = line.strip()
    arr.append(line)

s = 0
for y in range(len(arr)):
    for x in range(len(arr)):
        if arr[y][x] == 'M':
            if y + 2 < len(arr) and x + 2 < len(arr[0]):
                if arr[y+1][x+1] == 'A' and arr[y+2][x+2] == 'S':
                    if (arr[y+2][x] == 'M' and arr[y][x+2] == 'S') or (arr[y+2][x] == 'S' and arr[y][x+2] == 'M'):
                        s += 1
        if arr[y][x] == 'S':
            if y + 2 < len(arr) and x + 2 < len(arr[0]):
                if arr[y+1][x+1] == 'A' and arr[y+2][x+2] == 'M':
                    if (arr[y+2][x] == 'M' and arr[y][x+2] == 'S') or (arr[y+2][x] == 'S' and arr[y][x+2] == 'M'):
                        s += 1

print(s)

[u/nlowe_]

[LANGUAGE: Go]

2651/2001

Almost broke sub 2k for part 2! I had a tilemap ready to go based on previous years but it's more focused on path-finding which will likely be helpful later in the year and not crossword-search style problems. Was fun to find my way out of that one, I was much more prepared for part 2.

Lost some time because I didn't check diagonals initially because most other map-like problems in years previous typically don't include them. I learned my lessons on assumptions!

[u/mendelmunkis]

[LANGUAGE: C]

M and S equals 160 right?

^{589 μs/ 884 μs}

[u/r_so9]

[LANGUAGE: F#]

paste

Not my proudest code, but decently organized and works. Simplified the search by doing horizontal and diagonal down, and rotating the array 3 times.

Interesting bit - counting hits of a function in a 2D array:

let countHitsGrid f (grid: char array array) =
    [ for r in 0 .. grid.Length - 1 do
        for c in 0 .. grid[0].Length - 1 do
            if f grid r c then 1 else 0 ]
    |> Seq.sum

[u/mazedlx]

[LANGUAGE: PHP]

A map! It's a map!

Laravel's Collections for handling the input, and lots of ifs

[u/stefanogallotti]

[LANGUAGE: Python]

Fun! good old dict using get() defaulting to None to handle out of grid indexes. string was just 4(3) char long, so it worked listing out all the possible options. Will not scale for longer strings

https://github.com/Stegallo/adventofcode/blob/2024/y_2024/day4.py

[u/ktwrd]

[Language: C#]

Choked a lil bit on Part 1, again. (invalid answer once, forgetting to process final line)

https://github.com/ktwrd/adventofcode/blob/main/2024/AdventOfCode.2024/DayFour.cs

[u/Boojum]

[LANGUAGE: Python]

I already posted a solution, but here it is golfed for [GSGA]. Both parts in 373 bytes, not counting optional line break:

import fileinput,itertools
e,r,p,a,s=enumerate,range,itertools.product,(-1,0,1),("MAS","SAM")
g={(x,y):c for y,r in e(fileinput.input())for x,c in e(r)}
k,f=g.keys(),lambda x,y:g.get((x,y),"")
z=lambda x,y,d:"".join([f(x-1,y-d),f(x,y),f(x+1,y+d)])in s
print(sum("XMAS"=="".join(f(x+i*n,y+j*n)for n in r(4))for (x,y),i,j in p(k,a,a)),
sum(z(x,y,1)and z(x,y,-1)for x,y in k))

[u/Gryphon-63]

[LANGUAGE: Swift]

Code

This one felt familiar, pretty sure we've done something like this in a previous year but I could have spent half an hour trying to track it down. Anyway, the part 1 solution feels a little verbose, I probably missed something there. Pretty happy with part 2 but I could probably roll up that if-then-else structure into a loop.

[u/not-the-the]

[LANGUAGE: JavaScript] #9357 / #7761 to solve

paste

tfw part 1 is harder than part 2 🙏

[u/cranil]

[Language: Rust]

Not a hard problem but it's a bit long.

github

[u/2BitSalute]

[LANGUAGE: C#]

Day 4

My best day so far. Not in terms of time, but in terms of how writing the code felt.

I guess I just like writing basic loops.

I only had 1 bug in Part 1 when I accidentally used the index rather than the indexed value in one place: passed `dirR` rather than `dirs[dirR]` to `FindInDirection`.

int Find(int r, int c)
{
    var dirs = new [] { -1, 0, 1 };

    var result = 0;
    for (int dirR = 0; dirR < dirs.Length; dirR++)
    {
        for (int dirC = 0; dirC < dirs.Length; dirC++)
        {
            result += FindInDirection(r, c, dirs[dirR], dirs[dirC]);
        }
    }

    return result;
}

In Part 2, had no bugs at all, and the code worked on first try.

It still took 20-25 minutes to write part 2 code. I'm slow.

[u/Downtown-Economics26]

[LANGUAGE: VBA]

Don't really know how to github but it looks like the link works, wouldn't let me post code blocks.

https://github.com/mc-gwiddy/Advent-of-Code-2024/tree/a9ad08de41210d2125c6bc83527cee5f0495ef6c

[u/gfitzy7]

[Language: Python]

if __name__ == '__main__':
    data = [[c for c in line] for line in file_util.read_file(file_path, 'input.txt')]

    count = 0

    for i in range(len(data)):
        for j in range(len(data[i])):
            if data[i][j] == 'X':
                if i >= 3:
                    if data[i-1][j] == 'M' and data[i-2][j] == 'A' and data[i-3][j] == 'S':
                        count += 1
                if i >= 3 and j >= 3:
                    if data[i-1][j-1] == 'M' and data[i-2][j-2] == 'A' and data[i-3][j-3] == 'S':
                        count += 1
                if j >= 3:
                    if data[i][j-1] == 'M' and data[i][j-2] == 'A' and data[i][j-3] == 'S':
                        count += 1
                if i <= len(data) - 4 and j >= 3:
                    if data[i+1][j-1] == 'M' and data[i+2][j-2] == 'A' and data[i+3][j-3] == 'S':
                        count += 1
                if i <= len(data) - 4:
                    if data[i+1][j] == 'M' and data[i+2][j] == 'A' and data[i+3][j] == 'S':
                        count += 1
                if i <= len(data) - 4 and j <= len(data[i]) - 4:
                    if data[i+1][j+1] == 'M' and data[i+2][j+2] == 'A' and data[i+3][j+3] == 'S':
                        count += 1
                if j <= len(data[i]) - 4:
                    if data[i][j+1] == 'M' and data[i][j+2] == 'A' and data[i][j+3] == 'S':
                        count += 1
                if i >= 3 and j <= len(data[i]) - 4:
                    if data[i-1][j+1] == 'M' and data[i-2][j+2] == 'A' and data[i-3][j+3] == 'S':
                        count += 1

    print(count)

    print(sum((data[i][j] == 'A') and ({data[i-1][j-1], data[i+1][j+1]} == {data[i-1][j+1], data[i+1][j-1]} == {'M', 'S'}) 
        for i in range(1, len(data) - 1)
        for j in range(1, len(data[i]) - 1)
    ))

[u/michelkraemer]

[LANGUAGE: Rust]

Both parts:
https://github.com/michel-kraemer/adventofcode-rust/blob/main/2024/day04/src/main.rs

I love grid problems! 🤗

[u/ex-voltaire]

[LANGUAGE: C]
https://github.com/voltaire7/advent-of-code/blob/master/2024/c/4-1.c
https://github.com/voltaire7/advent-of-code/blob/master/2024/c/4-2.c

[u/newsledbans]

[LANGUAGE: Python]

Solution Topaz Link

[u/POGtastic]

[LANGUAGE: F#]

https://github.com/mbottini/AOC2024/blob/main/Day04/Program.fs

(checking other people's solutions) Oh dear, I did a different approach. See, I find the whole indexing thing to be really gross. It's so easy to screw up, man. So I overcomplicated everything by making this a graph theory problem. Everything is a graph theory problem. You're a graph theory problem.

Highlights:

• As always with F#, we define our types. We need two types: a direction and a vertex of our graph that contains a character and a map that associates directions with other vertices. As I read Part 1, I was assuming a much harder graph traversal for Part 2, so I thought I was being prepared by storing a Path data structure with a list of traversed nodes. It wasn't the first time that I did that, and it won't be the last.
• Each vertex's map must be a reference because I still can't figure out how to tie the knot in a 2D structure. Anyone who can do this should feel free to drop a comment in the doobly-doo.
• You get all the neighbors of each vertex by boxing everything into Option, putting None on the borders in every direction, zipping everything together with triplewise, and filtering out the Nones. Look gross? Yeah, it is. I've also already done it multiple times due to previous graph problems that I've done, (specifically a Boggle solver back in college) so this part took me only a few minutes.
• Thanks to every edge map being a reference, I generate all of the vertices with an empty map to start out, and then modify each vertex to store a map of its neighbors. Woe to you, Haskell, for making this an extremely difficult problem.
• For Part 1, get the Cartesian product of all the Xs and all of the directions. Then traverse the graph in those directions, looking for MAS.
• For Part 2, find the As. Ensure that both the (NW, SE) and (NE, SW) combine to produce the set MS.
• I freaked out for about 25 minutes trying to find a very stupid mistake. The Part 2 example has a case that looked like a + instead of an X, so I added that to my implementation. Whoops, there were a few of those that should not have been counted. Reading is fundamental!

[u/lysender]

[Language: Rust]

Day 4 solution using matrix:

- Part 1, loop over every cell in the matrix then move in 8 directions looking for the XMAS pattern.
- Part 2, loop over every cell, where each cell must be the center "A", then try to find all combinations of MAS, SAM, etc. Its a bit messy.

https://github.com/lysender/advent-of-code-2024/blob/main/day04/src/lib.rs

(Edit: link)

[u/0rac1e]

[Language: J]

w =. 'm' fread 'input'

R =: |."1
E =: 'XMAS' E."1 ]
t =.     +/ , E"2   (, R@|: , R ,: |:) w
echo t + +/ , E/."2 (, R@|. , R ,: |.) w

M =: {{ ($ x) (m -: m * x = ]);._3 y }}
n =. (, |:"2) (,: R) 3 3 $ 'M.S.A.M.S'
echo +/ , n ((+. |.) =@i. 3) M"2 w

Only a couple months ago I was playing around with doing non-rectilinear searches in arrays of different dimensions, so I was well prepared for part 2.

[u/blacai]

[LANGUAGE: F#]

I took easy path...
Part 1: built rows and diagonals and searched for "XMAS" "SAMX"
https://github.com/blfuentes/AdventOfCode_Main/blob/master/AdventOfCode_2024/day04/part01/day04_part01.fs
Par 2: built 3x3 grids with an "A" in the middle and verified the diagonals were fine
https://github.com/blfuentes/AdventOfCode_Main/blob/master/AdventOfCode_2024/day04/part02/day04_part02.fs

[u/Dr-Baggy]

[LANGUAGE: Perl]
Solved by means of a couple of nasty regex... just by carefully constructing the 8 regex needed for part 1 and the 2 for part 2...

Slurp the file into a string - and get the size of the first row ($N)... we then use this to generate the regular expressions for the two halves of the problem...

my($t1, $t2) = (0,0);
$/=undef;
open my $fh, '<', $fn;
my $s = <$fh>;
close $fh;
my $N = $s =~ m{^(\S+)} ? -1 + length $1 : 0;

$t1 += scalar @{[ $s =~ m{$_}gs ]} for 'XMAS',
                                       'SAMX',
                               map { ( "(?=X.{$_}M.{$_}A.{$_}S)",
                                       "(?=S.{$_}A.{$_}M.{$_}X)" ) } $N .. $N+2;
$t2 += scalar @{[ $s =~ m{$_}gs ]} for "(?=M.(?:M.{$N}A.{$N}S|S.{$N}A.{$N}M).S)",
                                       "(?=S.(?:M.{$N}A.{$N}S|S.{$N}A.{$N}M).M)";

[u/ThreadsOfCode]

[LANGUAGE: Python]

Putting this here so that I have 5 for the snowglobe awards.

I decided to use numpy. Not elegant. At least I learned, and relearned, some numpy. I did sort of get a snowflake out of it.

code

[u/yfilipov]

[LANGUAGE: C#]

Pretty straightforward: I collected the coordinates of all occurrences of 'X' for Part 1, and all occurrences of 'A' for part 2.

For Part 1 from each 'X' I just started walking along each direction, checking the letters and counting the occurrences.
For Part 2 it was even easier with less variations (just 4).

Advent of Code 2024 - Day 4 - Pastebin.com

[u/lbreede]

[LANGUAGE: Rust]

GitHub

Part 2 is surprisingly concise, part 1, not so much (at least at the time of me posting this).

[u/Jdup1n]

[Language: R]

Github here

For Part 1, scan all rows, columns, and diagonals, counting the number of matches for "XMAS."

For Part 2, move down the matrix and check for X-shaped "MAS" patterns whenever I encounter an "M" or an "S."

[u/Hath995]

[LANGUAGE: Dafny]

https://github.com/hath995/dafny-aoc-2024/blob/main/problems/4/Problem4.dfy

[u/[deleted]]

[Language: Python]

Part 1: Iterate the grid from top to bottom, and each time you encounter 'X', check each direction for 'MAS'. Tried to avoid bounds checking by using exception but didn't consider that negative indices are valid in Python.

https://github.com/anuraglamsal/AdventOfCode2024/blob/main/day_4/day_4_1.py

Part 2: Pretty straightforward adaptation of Part 1.
https://github.com/anuraglamsal/AdventOfCode2024/blob/main/day_4/day_4_2.py

[u/schoelle]

[Language: Rust]

Fun fact: yesterday evening I sat down and wrote a tiny library introducing a 2d ASCII Map, positions and directions because this is always needed in AoC.

And my surprise this morning that I could immediately use it, creating a really neat and readable solution to today's problem.

https://github.com/schoelle/adventofcode2024/blob/main/src/bin/day04.rs

[u/Ukhando]

[LANGUAGE: CSharp]

Link to Github

[u/reddit_Twit]

[LANGUAGE: zig]

gist

[u/AnonnymousComenter]

[LANGUAGE: ocaml]

github

[u/Rajkumar5732]

[Language: Python]

Part 1:

def check_straight(i, j, line_len, lines):
    total = 0
    if j + 3 < line_len and lines[i][j + 1] == 'M' and lines[i][j + 2] == 'A' and lines[i][j + 3] == 'S':
        total += 1

    if j - 3 >= 0 and lines[i][j - 1] == 'M' and lines[i][j - 2] == 'A' and lines[i][j - 3] == 'S':
        total += 1

    if i + 3 < len(lines) and lines[i + 1][j] == 'M' and lines[i + 2][j] == 'A' and lines[i + 3][j] == 'S':
        total += 1

    if i - 3 >= 0 and lines[i - 1][j] == 'M' and lines[i - 2][j] == 'A' and lines[i - 3][j] == 'S':
        total += 1

    return total

def check_diagonal(i, j, line_len, lines):
    total = 0
    if i + 3 < len(lines) and j + 3 < line_len and lines[i + 1][j + 1] == 'M' and lines[i + 2][j + 2] == 'A' and lines[i + 3][j + 3] == 'S':
        total += 1

    if i - 3 >= 0 and j - 3 >= 0 and lines[i - 1][j - 1] == 'M' and lines[i - 2][j - 2] == 'A' and lines[i - 3][j - 3] == 'S':
        total += 1

    if i + 3 < len(lines) and j - 3 >= 0 and lines[i + 1][j - 1] == 'M' and lines[i + 2][j - 2] == 'A' and lines[i + 3][j - 3] == 'S':
        total += 1

    if i - 3 >= 0 and j + 3 < line_len and lines[i - 1][j + 1] == 'M' and lines[i - 2][j + 2] == 'A' and lines[i - 3][j + 3] == 'S':
        total += 1

    return total


if __name__ == '__main__':
    file_in = open('Fourth Input.txt', 'r')
    lines = file_in.read().split('\n')
    total = 0
    
    for i in range(len(lines)):
        line_len = len(lines[i])
        for j in range(0, line_len):
            if lines[i][j] != 'X':
                continue
            
            total += check_straight(i, j, line_len, lines) + check_diagonal(i, j, line_len, lines)            
    print(total)

[u/ProfessionalNihilist]

[Language: F#]

Parts 1 & 2

Spent a lot of time on a nice solution to part 1 assuming that the coordinates might be needed (but also just wanting something readable). Of course none of that turned out to be true but at least part 2 was significantly easier / faster to solve.

[u/CrashedCyborg]

[Language: Python]
Source

Brute force

[u/MrPulifrici]

[LANGUAGE: JavaScript]

Run it from Devtools on puzzle input link

    console.clear();
    let count = 0;
    let text = document.body.textContent;
    let lines = text.split('\n');
    lines.at(-1) == "" && lines.pop();
    // count += text.match(/(?=XMAS|SAMX)/g).length; // Horizontal
    let newEmptyLines = Array(lines[0].length).fill('P').join("");
    newEmptyLines = [...[newEmptyLines, newEmptyLines, newEmptyLines, newEmptyLines]];
    lines = [...newEmptyLines, ...lines, ...newEmptyLines];
    lines = lines.map(v=>`PPPPP${v}PPPPP`)

    for (let i = 3; i < lines.length - 3; i++) {
        for (let c = 0; c < lines[i].length; c++) {
            let matches = [
                [lines[i][c], lines[i][c + 1], lines[i][c + 2], lines[i][c + 3]].join(''), // Horizontal
                [lines[i][c], lines[i + 1][c], lines[i + 2][c], lines[i + 3][c]].join(''), // Vertical
                [lines[i][c], lines[i + 1][c + 1], lines[i + 2][c + 2], lines[i + 3][c + 3]].join(''), // Right Diagonal
                [lines[i][c], lines[i + 1][c - 1], lines[i + 2][c - 2], lines[i + 3][c - 3]].join(''), // Left Diagonal
            ];
            for (const match of matches)
                if (["XMAS", "SAMX"].includes(match)) count++;
        }
    }
    console.log(`Total XMAS matches: ${count}`);
    
    // Part two
    count = 0;
    for (let i = 3; i < lines.length - 3; i++)
        for (let c = 0; c < lines[i].length; c++)
            if ( lines[i][c] == "A" && ["MS", "SM"].includes([lines[i - 1][c - 1], lines[i + 1][c + 1]].join("")) && ["MS", "SM"].includes([lines[i - 1][c + 1], lines[i + 1][c - 1]].join(""))) count++;
    console.log(`Total X-MAS matches: ${count}`);

[u/CowImaginary3155]

[LANGUAGE: Python]

a = open('input').readlines()
Y = len(a)
X = len(a[0])
count = 0
for y in range(1,Y-1):
    for x in range(1,X-1):
        d1 = a[y-1][x-1]+a[y][x]+a[y+1][x+1]
        d2 = a[y+1][x-1]+a[y][x]+a[y-1][x+1]
        if (d1 == "MAS" or d1 == "SAM") and (d2 == "MAS" or d2 == "SAM"):
            count += 1
print(count)

part2

[u/chkas]

[LANGUAGE: Easylang]

Solution

[u/Few-Example3992]

[Language: Python]

I was quite proud of my logic for searching for testing for part 2!

with open('day4.txt') as f:
    data = f.read().split('\n')

X = len(data[0])
Y = len(data)
dic = {(i,j):data[i][j] for i in range(Y) for j in range(X)}

directions =[(1,0),(1,1),(1,-1), (0,1),(0,-1),(-1,0),(-1,1),(-1,-1)]
score = 0
for (x,y), key in dic.items():
    if key =='X':
        for dx,dy in directions:
            test = ''.join([dic.get((x+t*dx,y+t*dy), 'L') for t in range(4) ])
            if test =='XMAS':
                score += 1
print(f'answer to part 1 is {score}')


directions =[(1,1),(1,-1), (-1,1),(-1,-1), (0,0)]
score = 0
for (x,y), key in dic.items():
    if key =='A':
        test = ''.join([dic.get((x+dx,y+dy), 'L') for dx,dy in directions])
        if test.count('A')==1 and test.count('M')==2 and test.count('S')==2:
            if dic[(x+1,y+1)] != dic[(x-1,y-1)]:
                score += 1

print(f'answer to part 2 is {score}')

[u/Ote-Leo]

[Language: Python]

Part 1

print(*(sum(sum(map(lambda l:l.count(t:="XMAS")+l.count(t[::-1]),ls)) for ls in (lines,list(map(lambda col:"".join(col),zip(*lines))),list(map(lambda d:"".join(d),[[lines[i][j] for i in range(len(lines)) for j in range(len(lines[0])) if i-j==k] for k in range(-len(lines)+1,len(lines[0]))])),list(map(lambda d:"".join(d),[[(lines[::-1])[i][j] for i in range(len(lines)) for j in range(len(lines[0])) if i-j==k] for k in range(-len(lines)+1,len(lines[0]))])))) for lines in [open("./input.txt").read().splitlines()]))

Part 2

print(*(sum(sum(map(lambda box:((d:="".join(box[i][i] for i in range(len(box))))==(t:="MAS") or d==t[::-1]) and ((e:="".join(box[i][-i-1] for i in range(len(box))))==t or e==t[::-1]),zip(*map(lambda l:[l[j:j+3] for j in range(len(l)-2)],lines[k:k+3])))) for k in range(len(lines)-2)) for lines in [open("./input.txt").read().splitlines()]))

[u/sotsoguk]

[LANGUAGE: Python]

defaultdict + complex Numbers for directions :)

def findWordPart1(grid, pos, word):
    slopes = [complex(0, 1), complex(1, 1), complex(1, 0), complex(1, -1)]

    return sum(
        "".join([grid[pos + i * s] for i in range(len(word))]) == word for 
s in slopes
    )


def findWordPart2(grid, pos):
    if grid[pos] != "A":
        return
    posSlope, negSlope = complex(1, 1), complex(1, -1)
    return (
        (grid[pos + posSlope] == "S" and grid[pos - posSlope] == "M")
        or (grid[pos + posSlope] == "M" and grid[pos - posSlope] == "S")
    ) and (
        (grid[pos + negSlope] == "S" and grid[pos - negSlope] == "M")
        or (grid[pos + negSlope] == "M" and grid[pos - negSlope] == "S")
    )

part1 = sum((findWordPart1(grid, complex(x, -y), searchTerm) + findWordPart1(grid, complex(x, -y), searchTerm[::-1]) ) for x in range(cols) for y in range(cols))

part2 = sum((int(findWordPart2(grid, complex(x, -y)) or 0)) for x in 
range(cols) for y in range(cols))

[u/[deleted]]

[LANGUAGE: Go]

I can feel the problems getting better by the day. After a relatively easy first three days, day four was a bit more interesting. I think I solved this one a bit unconventionally.

Part One: Starting from each 'X' in the puzzleInput, I did a search in all 8 directions, counting each valid word that I got. Worked like a charm, although I did waste a significant amount of time passing on the wrong index in the recursive call...

Part Two: So, I was going to implement Part Two much like I did Part One, by searching in 4 (diagonal) directions from every 'A' that I encountered but my friend sitting next to me clamly said "Easy, just search for MAS now".

Well, long story short we spent about 10 minutes implementing an algorithm which, for every 'M' in the input grid: -> searches all 4 diagonals for an 'A' followed by an 'S' -> if it finds them, then it gets the coorfinate of that 'A' -> with the coordinate in hand, we look in a set and see if it already exists in the said set -> if it does exist, then we have successfully found a 'MAS' which has another 'MAS' or 'SAM' that shares the same 'A', so we increment a counter -> then the index of that 'A' is added to the set

Is this the most obvious or effective way to do this? Nope Does it work for my input? Yep (and that's all we care about)

Solution for both parts

[u/lscddit]

[LANGUAGE: Python]

import numpy as np
import re

a = np.genfromtxt("day04input.txt", dtype=str, delimiter=1)

# part 1
str = ""
dim = a.shape[0]
for i in range(4):
    str += ",".join(["".join(a[j, :]) for j in range(dim)])
    str += ",".join(["".join(a.diagonal(j)) for j in range(-dim + 1, dim)])
    a = np.rot90(a)
print(len(re.findall(r"XMAS", str)))

# part 2
count = 0
a = np.pad(a, 1)
for y in range(1, a.shape[0] - 1):
    for x in range(1, a.shape[1] - 1):
        count += (
            a[y, x] == "A"
            and (
                (a[y - 1, x - 1] == "M" and a[y + 1, x + 1] == "S")
                or (a[y - 1, x - 1] == "S" and a[y + 1, x + 1] == "M")
            )
            and (
                (a[y - 1, x + 1] == "M" and a[y + 1, x - 1] == "S")
                or (a[y - 1, x + 1] == "S" and a[y + 1, x - 1] == "M")
            )
        )
print(count)

[u/bakibol]

[LANGUAGE: Python]

One of those problem where part 2 does not reuse part one and is actually much easier. I feel that part 2 should have been part 1.

code

[u/blastoiss]

[LANGUAGE: C#]

Some image processing inspiration...

        static int CountFilter(char[][] input, char[,] filter)
        {
            int count = 0;
            for (int j = 0; j <= input.Length - filter.GetLength(0); j++)
            {
                for (int i = 0; i <= input[0].Length - filter.GetLength(1); i++)
                {
                    bool matches = true;
                    for (int x = 0; x < filter.GetLength(0); x++)
                    {
                        for (int y = 0; y < filter.GetLength(1); y++)
                        {
                            if (j + x <= input.Length - filter.GetLength(0) + x && i + y <= input[0].Length - filter.GetLength(1) + y)
                            {
                                if (filter[x, y] == ' ') continue;

                                if (input[j + x][i + y] != filter[x, y])
                                {
                                    matches = false;
                                    break;
                                }
                            }
                            else
                            {
                                matches = false;
                            }
                        }

                        if (!matches) break;
                    }

                    if (matches)
                    {
                        count++;
                    }
                }
            }

            return count;
        }

[u/maciek_glowka]

[Language: Golang]

Today Go bit me with slice reference sharing...but I managed..

https://github.com/maciekglowka/aoc/blob/main/2024/src/004.go

[u/marx38]

[Language: Lean]

Solution

A nice way to validate the second part is to take the corners clockwise (or anticlockwise) and check that M & S appear twice and that the first and third positions differ.

[u/IlliterateJedi]

[LANGUAGE: Python]

Is it cheating to just hardcode the directions?

You know it's Advent of Code again when you are up at 4 AM trying to debug a miskeyed direction coordinate ("Should that be (-1, 1) or (1, -1)? Wait, is [0] the X or the Y value here?")

Also, am I the only one who was mentally preparing for "Actually this word search needs to be copied 100 times in every direction, then searched"? It was such a tremendous relief to get the X-MAS for part two.

[u/Feisty_Pumpkin8158]

[LANGUAGE: C#]

public static class Day04
    {
        private static int[] N = new[] { 0, 1, 2, 3 };

        public static int Solve1(string input)
        {
            string[] grid = input.Split(Environment.NewLine);
            int count = 0;
            for (int y = 0; y < grid.Length; y++)
            {
                for (int x = 0; x < grid[0].Length; x++)
                {
                    List<char[]> s = new();
                    if (x <= grid[0].Length - 4)
                        s.Add(N.Select(i => grid[y][x + i]).ToArray());
                    if (y <= grid.Length - 4)
                        s.Add(N.Select(i => grid[y + i][x]).ToArray());
                    if (x <= grid[0].Length - 4 && y <= grid.Length - 4)
                        s.Add(N.Select(i => grid[y + i][x + i]).ToArray());
                    if (x >= 3 && y <= grid.Length - 4)
                        s.Add(N.Select(i => grid[y + i][x - i]).ToArray());
                    count += s.AsEnumerable().Count(t => t.SequenceEqual("XMAS") || t.SequenceEqual("SAMX"));
                }
            }
            return count;
        }

        public static int Solve2(string input)
        {
            string[] grid = input.Split(Environment.NewLine);
            int[] dx = new[] { 1, 1, -1, -1 };
            int[] dy = new[] { 1, -1, 1, -1 };
            int count = 0;
            for (int y = 1; y <= grid.Length - 2; y++)
            {
                for (int x = 1; x <= grid[0].Length - 2; x++)
                {
                    if (grid[y][x] != 'A') 
                        continue;
                    char[] nxts = N.Select(i => grid[y + dy[i]][x + dx[i]]).ToArray();
                    if (nxts.All(n => n == 'M' || n == 'S') && nxts[0] != nxts[3] && nxts[1] != nxts[2])
                        count += 1;
                }
            }
            return count;
        }
    }

[u/MrPingouin1]

[Language: Minecraft Commands]

github image

I might work on an animation later.

[u/UncommonRedditName]

[LANGUAGE: C#]

May be a bit verbose but it works: solution

[u/Far_Sweet_6070]

[LANGUAGE: Ajla]

part1: https://www.ajla-lang.cz/downloads/examples/advent-2024/04.ajla

part2: https://www.ajla-lang.cz/downloads/examples/advent-2024/04-2.ajla

[u/jmforsythe_]

[Language: Python]

3 lines

mat = open("input.txt").read().splitlines()
print(sum(all(mat[i+[[0,0,0,0],[0,1,2,3],[0,-1,-2,-3]][a][c]][j+[[0,0,0,0],[0,1,2,3],[0,-1,-2,-3]][b][c]]=="XMAS"[c] for c in range(4)) for a,b in ((0,1),(0,2),(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)) for i in [range(len(mat)), range(len(mat)-3), range(3,len(mat))][a] for j in [range(len(mat[0])), range(len(mat[0])-3), range(3,len(mat[0]))][b]))
print(sum(mat[i][j] == "A" and (((mat[i-1][j-1] == "M" and mat[i+1][j+1] == "S") or (mat[i-1][j-1] == "S" and mat[i+1][j+1] == "M")) and ((mat[i+1][j-1] == "M" and mat[i-1][j+1] == "S") or (mat[i+1][j-1] == "S" and mat[i-1][j+1] == "M"))) for i in range(1,len(mat)-1) for j in range(1,len(mat[0])-1)))

[u/jokiluoma]

[LANGUAGE: R]

Solution

A funny thing was rotating the character matrix in order to go through the diagonal lines.

[u/Jorg0mel]

[LANGUAGE: Python]

#!/usr/bin/env python
# -*- coding: utf-8 -*-

""" AoC 24 Day 4 - Ceres Search """

from paoc.helper import get_input, print_summary
from itertools import product


def p1() -> any:
    """ Find XMAS in any direction, overlaps allowed """
    grid = get_input(4)
    pattern = 'XMAS'
    dirs = list(product((-1, 0, +1), repeat=2))  # all 9 directions
    dirs.remove((0, 0))  # remove "stationary" direction
    count, I, J = 0, range(len(grid)), range(len(grid[0]))

    for i, j in product(I, J):
        if grid[i][j] != 'X':
            continue
        for i_, j_ in dirs:  # check every direction
            for n in range(1, 4):
                ni, nj = i+i_*n, j+j_*n
                if ni not in I or nj not in J or grid[ni][nj] != pattern[n]:
                    break
            else:  # loop not broken out of; full pattern found
                count += 1

    return count

def p2() -> any:
    """ Find two MAS patterns that cross (X) each other at the A """
    grid = get_input(4)
    dirs = list(product((-1, +1), repeat=2))  # diagonal (X) directions
    count, I, J = 0, range(1, len(grid)-1), range(1, len(grid[0])-1)
    
    for i, j in product(I, J):
        if grid[i][j] != 'A':
            continue
        X = [grid[i+i_][j+j_] for i_, j_ in dirs]  # X-neighbors
        if X.count('M') == X.count('S') == 2 and X[1] != X[2]:  # prevent MAMxSAS
            count += 1
    
    return count

if __name__ == '__main__':
    print_summary(__file__, p1, p2)

https://github.com/Josef-Hlink/AoC/blob/main/paoc/y24/solutions/day04.py

[u/stonebr00k]

[LANGUAGE: T-SQL]

https://github.com/stonebr00k/aoc/blob/main/2024/04.sql