Advent of Code 2025 Day 5 (BaseA Style)

AlteryxCommunityTeam

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

Advent of Code

Accepted answers

All comments

iracine

Ok part 1 was easy... now part 2 I'll have to figure out after I get some sleep.

Spoiler

Capture d’écran 2025-12-05 à 12.25.22 AM.png

OI-DM-AOC_CHALLENGE_5.yxzp

ScottLewis

Appreciate the consistent quality of this year's puzzles. Wonder if cutting down also means focusing more on each one.

Also appreciate that work from home tomorrow means I get to do this one on time rather than the next day. Have missed the race.

Part 1 of today was straightforward.

Spoiler

Once I went from trying to generate all of the rows and just generated all the range/ingredient combinations. Once again we are reminded to consider the size of the problem and maybe solve the small one rather than the big one.

Part 2 caught me for a minute.

Spoiler

I had the basic idea that you sort the ranges and then prune each one to begin at max(Current Begin, Previous End +1).
Once I looked at the sorted ones I saw the second bit, which is that sometimes Previous End +1 >End, in which case you throw the whole range out.
What caught me was the last thing, which is that the above logic only works if there are duplicates. If there are triplicates or more you need to apply the logic an additional time. Fortunately, Triplicates was as high as it went, so no Iteration required.

Final

Spoiler

AOCDay5ScottLewis.yxmd

jrlindem

Okay this one was kind of cool. In some ways easier than previous days, but it was different in the way you needed to solve it and I like that.

Here's my solution:

Spoiler

Here's the narrative:

Spoiler

Part 1 was pretty straight forward... I might have taken an inappropriate shortcut and just brought the data in as two inputs. But i'm confident I could have split them up anyway, so whatever, I moved on.

Appending the data allowed me to just compare the ingredients list as "between" the low and high values of the range. Filter to yes, distinct, and count.

Part 2 was a little more dubious, simply because of the volume of values. But the key is in the overlaps. By creating groups of distinct ranges, you can reduce the overall number of ranges considerably. Then just count the number of values in the range (high minus low plus 1 to include) and you have the number of unique values. Sum those up and there you go!

jrlindem_AoC_day5.yxmd

Raj

Solved !!

2025 D5.yxmd

Tokimatsu

Solved.

Spoiler

In Part 2, I merged each range. First, I sort by the smaller values. If a larger value is smaller than the next smaller value, these two ranges cannot be merged.

スクリーンショット 2025-12-05 150120.png

AoC2025Day05_toki.yxzp

CoG

A lot of easy problems this year. I enjoyed the algorithmic approach that could be optimized in Part 2!

Spoiler

Part 1 was a straight-forward brute force approach. There are absolutely ways to optimize, but there is not enough data for that to really matter here. Append, Compare, and count the unique Ingredients!

Part 2 is where the fun is had! We have a list of potentially overlapping ranges and we need to count how many unique ID's are contained in at least one range. If the numbers were smaller, we could easily Generate Rows for each range and then Count Distinct as in part 1, but the numbers are too large for this to be practical. Unfortunately for us, if the ranges were all disjointed (no overlap), then this would still be trivial because we can "count" the ID's in each range with the formula [Max ID] - [Min ID] + 1, and then get the answer by summing over all of those counts.

For example: [1,3] & [6,7] has 1,2,3 & 6,7 - 5 ID's total
which can be calculated as
(3) - (1) + 1 = 3
(7) - (6) + 1 = 2
-> 3+ 2 = 5

The key insight is that we need a way to identify which ranges overlap and then merge them, which will allow us to solve the much simpler problem described above. This can be solved in several ways. My first solution involved building a macro to repeatedly check for merges and perform them, but I optimized that and wanted to showcase a dynamic, non-macro-based solution to this problem, which involves String Coding, a way of problem solving I have tried to popularize and discourage.

If you sort the ranges on their minimum values, you can step through the data with the Multi-Row Formula Tool to check if the maximum ID of the previous merged range is greater than the minimum ID of the current range, then there is overlap and the two ranges should be merged. In order to do this without a macro, you must track both the current group in addition to the maximum ID you've seen up to that point. This is because a large range, may contain several smaller ranges, and if you don't track the max, you'll lose sight of the bounds truly being considered:

[1, 1000] track: "0;1000"
[3,5] track: "0;1000"
[999, 1005] track: "0;1005"
[1006, 1010] track: "1;1010"

It's obvious above that 1000 >> 3, so ranges 1 and 2 should be merged, but if the next Multi-Row Formula Tool step only considers ranges 2 and 3 they look disjoint, because the interval component that connects the two ranges is the 1000 from range 1, which is why we need to track both pieces of information. Finally for each group of ranges we can merge by finding the minimum minimum ID and the maximum maximum ID of the group at which point the ranges are guaranteed to be disjoint and ready for the simple counting process!

Happy Solving!

Workflow.yxmd

Hub119

Started out by way overcomplicating this, thinking back to AoC 2021 where you need to account for overlapping cubes in 3 dimensional space and building in some set math (I blame the Whiskey Advent Calendar I am pairing with this event this year 🥃)... only to eventually realize I could simplify this big time by just sorting my ID ranges in part 2 and just build groups adjusting the range bounds as I go...

Spoiler

Spoiler

In retrospect, probably could have just done this with some multi-row formula tools instead of an iterative macro, but once I had started I couldn't bring myself to reverse course.
Macro

Macro

AoC 2025 Day 5 - Cafeteria.yxzp

Stosh

Another challenge I was able to complete in 1 sitting, taking just over 1 hour in total for both parts! I did not find this puzzle particularly challenging, but part 2 had it's *specialties*. Anyways, it's back to waiting for another puzzle!

My Solution:

Spoiler

My Reflection:

Spoiler

Part 1 was insanely easy. I literally just appended each candidate to each range, checked for each candidate if it was within any range, and counted up the yes's Boom, done!

Part 2 didn't SEEM hard, but it was in the test cases that it got tricky. For anyone who is wondering, yes I did try to use generate rows initially, and yes... my Alteryx crashed😂 Can you hate me for trying though? Anyways, I realized that if I sorted the ranges by their starting value then I could use a multi-row tool to go through the ranges one by one. I thought the process I created was airtight: Go through the list and assign them one of 3 'situations': Usurped by previous, overlapping previous, or independent of previous. Then, remove the usurped ranges and go through the list again, setting the overlapping range's start values to the previous range's end value + 1. Should be done, right? After adding erroneous +1s in random places and testing outputs over and over, I decided to dig deeper into the actual ranges in my input and that's where I found some wacky ranges that were causing problems for my algorithm. I thought I was banished to the iterative macro realm, but decided to do one more manual iteration of the process just to see if I could get only independent ranges and voila, the answer was found.

Overall, this was another really strong day for me, as I was able to get both parts done in a decent time window and once again with 0 assistance. I thought surely I wouldn't be able to keep that going but here we are!

AOC2025.5.yxmd

Gawa

Is it just me who first applied the Generate Rows tool for part2 and as soon as run WF, endless number of rows were being generated? Thanks to Algorithm.

Spoiler

For part2, the core concept is to merge overlapped ranges each other, and create distinct and independent ranges. Mine is more or less similar to others.

2025D5_gawa.yxzp

DaisukeTsuchiya

Today's AoC is fun.

Spoiler

At first, I tried using a "Generate Rows" tool, but realized it would run forever, so I rebuilt my workflow.
For Part 1, I created combinations of IDs and ranges by appending tool, and then checked if the ID was within the range.

For Part 2, I sorted the ranges by their start value and then merged any that overlapped.

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

DT2025_Day5_Rev0.yxmd

AkimasaKajitani

My solution.

I couldn't come up with a good solution, and it took longer than I thought it would. Everyone else has created simple solutions, so I'll take another look at them.

Spoiler

Day05.yxzp

danboll_life

It was a process of trial and error using Spatial tools and Batch Macros. I needed several breakthroughs to arrive at the correct answer.

Spoiler

AoC2025_05_DL.yxzp

Qiu

Getting difficult...

Spoiler

I simply the criteria as below to check two neighbour ranges are ovelapping or not.
If we can have a few rows that keeping overlapping then they will be in one greater range and the min and max will be the LB and UB.

Two ranges [start1, end1] and [start2, end2] overlap if and only if the following condition is true:

max(start1, start2) <= min(end1, end2)

AoC 2025 Day 05.png

AoC 2025 Day 05.yxzp

Goddenra

Sneaky example which pushed me down the Generate Rows route initially. Lesson learned to look at the data first!

Spoiler

Part 2 was tricky until I figured out sorting the rows would make life a lot easier. Also reading the question to understand we wanted a count of the values, not the sum!

Day5.yxmd

DavidP

I used a batch macro for part 1 - probably not necessary. Solved part 2 without macro.

Spoiler

2025_AoC_DavidP_Day_05.yxzp

Pilsner

Another 2 stars! Certainly getting tougher than day one, but managing to keep the pace up so far.

Spoiler

Here's my full workflow for day 5:

Part 1

1) Today's input data actually had two separate lists - the list of fresh ranges and the list of ingredients. To get started, I separated the two lists by filtering to records containing a "-", as these were the ranges. With the fresh ranges identified, I could then use the "-" delimiter to parse the upper and lower bounds into separate rows, before renaming and changing the new columns' data types to numeric.

2) Next I appended all the ingredients onto all the ranges. Yes this grew the data but we only had a few hundred rows of data each side, so light work for Alteryx. With the appended data I could then filter to the cases where the ingredient ID, fell within the upper and lower bounds.

3) The steps so far, will likely have resulted in some ingredients being approved twice if they appeared in more than one cell range. To get around this I did a count distinct on the ingredients, to get my final answer.

Part 2
For part two, we aren't interested in the ingredients list at all. All we need to examine is the fresh ranges. With this in mind, the first step for part two can be the same as step on from above.

1) Once we have the list of ranges, the next step is to simplify them. To tackle this, I started by sorting the Lower and Upper Bounds in ascending order. This then allowed me to keep track of the "Rolling Maximum ID". What I mean by this, is that at any point, I would know what the previous, highest ID value had been. i.e:

Row ID	Lower Bound	Upper Bound	Rolling Maximum ID
1	0	10	-
2	6	15	10
3	16	30	15
4	21	25	30

As you will notice, we can now identify which lines have already been accounted for. The upper bound in Row 4, is lower than the Rolling maximum ID meaning that all the records represented by the range 21-25, have previously been seen. Therefore, we can remove this row from the process.

2) You will have likely noticed, that we still need to deal with the overlap, between record 1 & 2. The way I approached this, was to update the Lower Bound, so that the two groups, no longer overlapped.

Row ID	Lower Bound	Upper Bound	Rolling Maximum ID	Updated Lower Bound
1	0	10	-	0
2	6	15	10	11 (the Rolling maximum ID, 10, is greater than the Lower bound, 6. We know all numbers up to and including the Rolling Maximum ID have been delt with, so we only need to carry on counting IDs from that point forward).
3	16	30	15	16 (as the lower bound was greater than the Rolling maximum ID, we knew all numbers in this range were "new")

The formula to account for the above is actually quite simple. To update the lower bound we just need to take the maximum between the Lower Bound and the (Rolling Maximum ID + 1). Once the lower bound is updated, its easy enough to count the number of IDs within each range. The count is simply the Upper Bound - Updated Lower Bound + 1 (the plus one is to account for the fact that the ranges are inclusive).

Row ID	Updated Lower Bound	Upper Bound	Rolling Maximum ID	Count
1	0	10	0	11
2	11	15	10	5
3	16	30	15	15

3) The final step is to simply sum all of the counts to find out the total number of fresh IDs!

Day 5.yxmd

OllieClarke

Thank god for...

Spoiler

... the between function

Day 5.png

Day 5.yxmd

DanFlint

Spoiler

Looks lik I did the same/similar to others for part 1.

Part 2 just isn't working for me. I'll have to come back to it later.

Day5_DF.yxmd

Erin

Was tempted to be lazy and brute force the answer on Pt 2, but since the explanation "I burnt my work computer to a crisp looking for fresh ingredients for elves at the north pole" probably wouldn't fly at my company - I decided a more clever solution was needed.

Spoiler

Today's solution is brought to you by the Between(x, min, max) function.

Pt 1 check if in range:
pt1-in range.png

Pt 2 Update Start
update start.png

Pt 2 Update End
update end.png

2025-Day05.yxzp

Hub119

@gawa after blowing up my computer doing this very thing earlier in the year, I now know better... at least most of the time 🤣

mmontgomery

Day 5

Spoiler

This was fun!
P1 was rather easy. Just append all ranges then determine if values were inside it or not
P2 I was scared for a bit, but then remembered our often forgotten friend - make group! I made three categories of data: those fully inside another set, those partially inside another set, and those fully independent. Getting the tweaks of defining fully inside vs partially inside was most of my time and it needed <= or >= instead of just <or >

Day5.yxzp

Malvim

Easy enough to brake your computer into One Piece...

Spoiler

Main for Part2 is to remove overlapping ranges, like Duplicated ranges, Ranges within Ranges, and adapt ranges that overlap some inner parts of it.

And please, PLEASE, do not use generate rows for this challenge.

Day5 - Food Ranges.yxmd

DylanBell

Part 1 took me 10-15 minutes. Part 2 however... we won't talk about that.

D5.yxmd

JeffF

Spoiler

Day05_JeffF.yxmd

lwolfie

I was beating my head against a wall trying to figure out where my logic was wrong on the second star......it wasn't. I just didn't enter the number right.

Day5 law.yxmd

kelly_gilbert

Brute-forced part 1, but had to get more efficient for part 2! I have never used the Int64 data type so much in my entire life 😅

Spoiler

AoC2025-05.yxzp

AkimasaKajitani

I added a non macro solution( and Make Group solution).

Spoiler

Day05.yxzp

Yoshiro_Fujimori

My solution.

Spoiler

Workflow

AoC_2025_Day5.yxmd

AncientPandaman

love to see other new ideas to solve the question.

Spoiler

part2:

1st method, split the range.
1. update start=[row-1:end], if start is less then end.
2. update end=start, if end is less then start
3. reduce end-1, if end equal to [row+1:start] <-this take me an hours
4. removed triplicate where end is less than start) <- this take me another 2 hours.

PS: I sure it is not cover all situation. but it solved.

2nd method, count each row with pointer.
I saw these hint in prev post
1. identify the running max per row.
2. skip row the end is less than running max. calculate range count by [end]-max([row-1:running max],[start])+1
3. sum the count

Day 05.yxmd

DataNath

A very nice day 5! Took me a little to realise the quirks of part 2 and ended up creating a disgraceful Multi-Row Formula expression but hey, 2 stars = 2 stars.