Advent of Code 2025 Day 4 (BaseA Style)

Discussion thread for day 4 of the Advent of Code - https://adventofcode.com/2025/day/4

Accepted answers

All comments

Got my hopes up when I saw the input to this problem, thinking it would be some sort of maze solve... alas, it was much simpler than that. Can't believe we are already 1/3 of the way through AoC 😭.

Spoiler

Spoiler

The macro was almost an exact copy of what I did for part 1....
Macro

Macro

AoC 2025 Day 4 - Printing Department.yxzp

Tokimatsu

Very simple.

Spoiler

I used X and Y coordinates, but it wasn't necessary to divide it into individual cells.
I'm gathering the surrounding cells using string-related functions.
スクリーンショット 2025-12-04 150211.png

AoC2025Day04_toki.yxzp

Gawa

Every time when I see map style puzzle in AoC, I'm always overwhelmed at first according to past experience(unlike @Hub119 😁)

However, today's puzzle was very straightforward without having to come up with something clever.

Ah, 1/3 is already over this year...

Spoiler

Part1

The context of puzzle was simple, and everything was smooth but my answer was wrong at the end. Thing is that, I didn't realize the presence of rolls that have no

neighborhood in any of 8 surrounding position. Count of those presence were missing, that takes extra time to reach to the goal.

Part2

Nothing special. The solution for part1 is applicable to part2. Just iterating process where I felt it's too straightforward....

In my twisted assumption, usual part2 would ask...

"when roll paper is removed, new roll papers will be generated at surrounding 8 position." or input data is so designed that only one roll paper is removed in one iteration that require huge iterations.

Anyway, just for fun, I created visual map how rolls have been removed.

Yellow: Remained rolls after all iteration

Blue: Removed during iteration (concentration depends on iteration number in which roll was removed)

2025D4_gawa.yxzp

Stosh

Another day, another AoC BaseA challenge! Today's puzzle was certainly not the most challenging one I have faced thus far, however it does feel good to be able to finish with a good time and with no assistance whatsoever (no blogs, solution peeking, or asking neighbors at work😂). That being said, I now have nearly the full 24 hours to wait until the next one😢

My solutions:

Spoiler

Part 1 and 2 of my solutions

The macro used in Part 2

My reflection:

Spoiler

As mentioned above, this problem was not very challenging for me, as evidenced by the fact that it took me <1 hour whereas the first 3 each took multiple hours and some hint searching. It could be argued that my solutions are big and ugly, and I might have to agree with you based on looks alone, but the strategy is not very complex.

For part 1, I use multi-row tools to look up, down, left, and right and store that for each square in the grid. For corners, I created join keys in a duplicate table and join based on row +/- 1, column +/- 1, with the unions used to catch edge and corner squares on the grid that won't have certain diagonal neighbors. From there, I simply count the number of '@'s and return the candidates who had less than 4.

For part 2, I literally copied the second half of my part 2 solution into a separate canvas and converted it into an iterative macro that runs until there are no more removable candidates on the grid. The only addition includes an additional join between the removable candidates and initial input to convert the '@'s to '.'s for the subsequent iteration.

All in all, I am excited to see how much more efficient some of the more seasoned participant's solutions are, but I am super proud of my speed today, and I think I would have an easy time explaining this to someone else, which is a benchmark I always set for myself when building flows for clients.

AOC2025.4.yxmd

AOC2025.4.yxmc

Raj

Almost repeating the first part's logic and iterating it for second part
Overall, a good challenge.

2025 D4.yxmd

CoG

Another simple problem! Made a macro this time. Macro-less is potentially possible, but I do not want to deal with that headache.

Spoiler

For the main workflow, we begin by tokenizing the input so that every row has a single value, then we use the Generate Rows Tool to get a 1 row & column buffer around each cell, and count the paper roll neighbors.

Screenshot - Macro.png

For the macro (for part 2), we start with the exact same procedure, but this time, we prune/remove those rolls that satisfy the sparse-neighbors criteria and check to see if we removed any rolls. If not, then we stop iterating. The bottom Macro Output Tool is our primary output, and tracks how many rolls there are currently. As I write this, I just realized that I could have put a count records after the "Prune Rolls" Formula Tool (or Join Tool) to count only removed rolls.

Happy Solving, y'all!

Edit: I made the edit that I referred to above to optimize the macro portion of my solution. Looks much cleaner now:

Spoiler

Workflow.yxzp

Workflow_v02.yxzp

JeffF

Spoiler

The macro has the same logic as Part One.

Day04_JeffF.yxzp

danboll_life

I solved it using the Spatial tools.

Spoiler

AoC2025_04_DL.yxzp

AkimasaKajitani

My solution!

I almost lost my way. Except for it, it is not difficult. And I use some macros which I created last year for mapping problem. It works well.

Spoiler

Macro:

Day04.yxzp

AncientPandaman

Start to use back macros created in previous years.

Spoiler

Day 04.yxzp

Qiu

Everyone is so fast.

Spoiler

AoC 2025 Day 04.yxzp

DataNath

The grids are back! For those of us who've participated in previous years, this is pretty much our bread and butter now, though today was definitely a very kind challenge compared to others! Workflow/macro aren't as clean as they could be but I was more than pleased with everything working first time.

Spoiler

Day 4 - Cleansed.yxzp

OllieClarke

I went route 1 today

Spoiler

Day 4.yxmd

DylanBell

By far my favourite challenge so far!

D4.yxzp

Kenda

Spoiler

part 1 so far! definitely could've had a faster run time if I narrowed down the joins instead of appending everything, but it worked😂

Aoc 2025 Day 4.yxmd

Goddenra

Some very elegant solutions out there. Had to go down the macro route for Part 2 for reasons of sanity.

Spoiler

Got a bit stuck on Part 1, as missed a corner case with the boundaries which was careless. Annoyingly it said I had the same answer as someone else, so knew I was really close. Should tidy it up a bit really.

Haven't created an iterative macro in a little while, so AoC is always a good refresher ...

Screenshot 2025-12-04 143922.png

Day4.yxzp

mmontgomery

Day 4

Spoiler

Had a dumb bug on P1 where I was filtering on adjoining points = '@' and counting vs just counting if they existed. Once I got that, P1 and P2 were a breeze.

P2 had the I macro using the same logic as P1 just adjusting for grid points with updated values

Day4.yxzp

Erin

Shout out to @Carolyn - I have my first "Nope didn't work" container. We're supposed to be keeping those? Kinda glad I did because I went back later to figure out why it didn't work and of course it was a rookie mistake. Learning so much!

My overall strategy for Pt 1:

Spoiler

Split the data up and assign each single character coordinates.
Calculate what all the neighbor coordinates are.
Look up the neighbor character using the neighbor coordinates.
Count the number of neighbor rolls.
Filter for the answer.

Well, I did do that more or less but my initial answer was too low. I kept getting the same answer too, so I decided to scrap it (but keep it?) and try a different way to lookup the values. This worked, and it turns out my first route didn't work because....

Spoiler

My filter excluded neighbors with a zero roll count. One little tweak there and the first route would've been fine.

Ah win some, learn some. 😁

Then for Pt 2

Spoiler

I put Pt 1 in an iterative macro and updated the char to be a ".", then sent it back through for another go. Easy peasy.
Day4 Iterative Macro.png

2025-Day04.yxzp

DavidP

Thanks for the tip on the zero counts @Hub119 !

Spoiler

2025_AoC_DavidP_Day_04.yxzp

ScottLewis

That was a good one.

Nice to see the return of grids, always appreciate doing part 1 while fretting about what part 2 could be.

This time, it was relatively kind.

Pleasantly surprised to find the multi-row formula tool goes all the way up.

Expected an error message along the lines of "138 is to many what the ^&## are you doing?"

Observations and tips

Spoiler

Whenever we're going to count something (In this case, adjacencies) I like to convert that thing from text representation into 1/0 so that we can do math to it later. In this case, it let me use a single multi-row to do the check by adding all 8 adjacent values together rather than making them 8 tests for "@".

Keeping your data orderly, which may involve turning off the AMP engine, often lets you shortcut. In this case, by keeping Row/Column sort we can know the index of any given adjacency.

Most of the complexity in this one is dealing with the (literal) edge cases. Wrote conditionals for Column and Row at Max and Min values. The other way to do this is to pad the grid with a row and a column of 0 values. In this case the conditionals were fairly clean so I didn't pad but there is value in taking complexity out of your formulas and putting it on the canvas.

It helps to think about the boundaries of a problem. We have in the past, and likely will again this year, seen problems that are either unbounded or at the minimum geometric. Those are the ones that will burn your computer down and require extreme macro optimization. pruning or formula trickery. This is not that. You're removing at least 1 crate every iteration, which means the problem is in N time with respect to the number of locations (actually the number of crates, which you can count or just estimate density and round up.)

With upper bound of <20k and with a high density estimate of 10k your macro should run in reasonable time (Minute and a half for mine, as an example.) If it doesn't, try to figure out why, because you will need the space(time) for future problems.

As a bonus, a bounded problem means you don't have to do an end state for the macro, which I find to be the most awkward part of iterative design. You can just run 10k times knowing that the last few thousand will likely be adding 0.

Final, with the Macro pasted in.

Working with numbers means I get to skip a few steps relative to some of the other Macro versions.

Day4 2025 Scott Lewis.png

AOCDay4ScottLewis.yxzp

kelsey_kincaid

I almost severely overcomplicated this one! Reminder to read the prompt before assuming what they are going to ask

Spoiler

Part 1 was pretty straightforward and just required finding adjacent values - something that's pretty standard in AOC puzzles. At first I thought we were only able to remove one roll at a time, which would require pretty extensive iterative optimization. When I reread the prompt I realized it was luckily much simpler than that.

Day4_KKincaid.yxzp

DanFlint

This was a fun one!

Spoiler

Had to build a multi-field-multi-row formula to get my method to work out dynamically:

And as much as I wanted to do something different, for part 2 I just wrapped it all in an iterative macro where I rebuilt the grid without the removed rolls each time:

Day4_DF.yxzp

Samantha_Jayne

Spoiler

I had to use spatial on this one, wasn't sure if I would be able to again.

AOC - Day 4.png

Day4_Solution_Samantha_Clifton.yxzp

Samantha_Jayne

How are you going to cope when its over in a few days? Finish the whiskey advent calendar? Maybe we should design our own crazy puzzles for next year.

jrlindem

Made it with 30min to spare for the day. Yes, yes, I know it doesn't actually have to be done on the same day, but the likelihood of me staying on task is heavily reliant on me not falling behind 😂

Anyway, here it is, in all it's glory:

Spoiler

jrlindem_AoC_day4.yxzp

iracine

This one was much easier than yesterday's and a lot of fun.

Love any excuse to use iterative macros (which part 2 provided)

Spoiler

Capture d’écran 2025-12-04 à 11.37.21 PM.png

OI-DM-AOC_CHALLENGE_4.yxzp

DaisukeTsuchiya

It was a straightforward problem.

Spoiler

Part 1 was just checking how many paper rolls were around each one, and Part 2 was simply repeating that process.

スクリーンショット 2025-12-05 171433.jpg

DT2025_Day4_Rev0.yxzp

Malvim

That one was finding itself easy until.... I was certain I was right, but of course I was forgetting the zeros.

Spoiler

Day4 - Paper forklifts.yxzp

Pilsner

Part one took a little tweaking, but once I had that one solved, I basically had the exact steps needed for the part two macro!

Spoiler

I ended up tweaking my macro so that it worked for both parts one and two by adding a numeric up-down interface element, which allowed me to control the maximum number of iterations. Here is my full workflow:

Part 1 & 2
As hinted at above, my solution to both parts is almost identical, with the only difference being the configuration of my macro.

1) As usual, step one was to parse the data out to one record per row, and create a corresponding x & y coordinate, however, this time, I made a slightly adjustment. Spoiler alert, my plan was to use spatial tools to plot the points as if they were on a graph. However, if I used integer values, the coordinates would be plotted over the entire earth. As the earth is rounded, I would have to take this into account in my calculations. The way to get around this was to map the points over a very small area of the earth. By zooming in like this, the grid becomes almost flat, making future calculations easier. In order to do this, I used a multirow, instead of the usual record ID, to assign coordinates in the (50,50) to (50.002, 50.002) range.

2) The next step, is to actually create the points of interest. The first thing to note, is that only the "@ symbols need to be taken into account, so we can easily filter anything else out. Then its a simple case of feeding the data into the Create Points" tool.

Now, here comes the macro:

3) Inside the macro, the first step is to feed all the data, into both anchors of the find nearest tool. In the configuration of the tool I have specified that there should be at most 9 nearest records (the 8 surrounding squares + itself) and all points must be within 0.00085 miles. This effectively creates a radius around each point to determine, how many "rolls" are within that radius. You may be wondering how I knew they should be within 0.00085 miles. There is a way to calculate this using a mathematical formula, however, as I had some example data with a known answer (thank you AoC), I opted for the trial and error approach 😁

4) The next step is to count the number of matches per coordinate pair. As long as the count is less than or equal to 4, we can remove the roll (it can be equal to 4 because we know each roll will match with itself, adding one to the allowable total).

5) All of these records can be passed out of the macro, as they are the rolls which can be accessed by the forklift. Now we need to isolate the rolls which were not yet accessible. To do this, we can join the accessible rolls back to the input data, and records left on the right anchor are therefore the Inaccessible rolls.

6) It would be easy enough to end the macro here and just loop the remaining records round until the maximum number of iterations is reached, however in the interest of optimisation, I have added one more section. This section does two things. Firstly, if the count of "removed rolls" = 0, the loop will end, as we know if nothing was removed this time, the next time wont be any different. Secondly, records can only continue looping, if the iteration number is below the maximum user specified iterations. This value can be changed via a numeric up down, and is the key to making this macro work for both part one and two.

7) The final step is to make two copies of the macro on the parent worklfow. For part one, set the maximum iteration number equal to 1, and for part two set it to a significantly large value, (100 should do). To get the final answer, simply count the number of records output by the macro.

2 Stars again!

This one was fun!

Spoiler

Outer workflow:

Iterative macro:
Iterates until there are no more moveable rolls.

AoC2025-04.yxzp

Quick Links

This months top contributors

atcodedog05 19458

Qiu 15866

binu_acs 15708

MarqueeCrew 13708

apathetichell 13703