Advent of Code 2025 Day 10 (BaseA Style)

After not sleeping at all while working on an alternate Part 2 solve, posting this here in the meantime... will continue to delve into an alternate solve once I'm ever able to get some sleep...

Spoiler

Spoiler

P1 Macro

Spoiler

@AkimasaKajitani says this is allowed at least...

P2 Optimization Macro

AoC 2025 Day 10 - Factory.yxzp

ScottLewis

Interested to see the first non-optimization solve what is really a classic linear programming problem.

I did something even worse than that because work reasons prohibit me from having predictive tools, so I built something to set up the optimization problem in Alteryx and then dumped to another LP tool.

For those of you joining for the first time this year, we usually get about one of these a year where the problem is not well suited for Base A and we learn by trying to hack rather than by doing things the "right" way. Be not discouraged and note that the posts before this one are some of the folks who are best at this hitting that same wall.

DaisukeTsuchiya

Day 10 presented quite a challenging problem.

Spoiler

For Part 1, I struggled considerably with how to structure the data, but ultimately, I converted it to a vertical format for processing. I suspect it might be possible to solve it more elegantly using tools like Regex.

Part 2 was tackled using an Optimization Tool, which took about 10 minutes to run. I couldn't come up with a solution without relying on the Optimization Tool, so I'm keen to learn from others' workflows to discover alternative approaches.

スクリーンショット 2025-12-10 235551.jpg
<P1 Macro>
スクリーンショット 2025-12-10 235613.jpg
<P2 Macro>
スクリーンショット 2025-12-10 235647.jpg

DT2025_Day10_Rev1.yxzp

Goddenra

Same issue as everyone else with Part 2. Works fine for the test data, tried optimising a few ways but grinding slowly. Looking at the numbers I think there's a chance it'd run overnight.

Edit: Reader, it did not 😂

Spoiler

Part 1 Macro:
A bit of a blunt force approach. Set the light to on or off for all button combinations and repeat until one matches for that puzzle. Main issue here was figuring out what data I needed for the iteration.

Part 2 macro:
Initial build stopped after about 4 iterations due to liberal use of generating rows and summarising. Good lesson learned there. Solution works fine for the test data, does progress at a snails pace through the real data so am tempted to leave it running overnight, although I'll be interested to see if someone comes up with any clever solutions which don't use the magic optimisation box 😁

I need to upgrade my Alteryx to 2024 or later as FindNth formula would have made my formulas a whole lot easier and I could just check the strings against each other rather than having to split into multiple columns. Still quicker than splitting into rows and summarising though.

Day10.yxzp

ScottLewis

Spent a while working with @Goddenra 's Part 2 macro from the post below.

I believe it is a valid solution, if we ignore execution time.

I was able to get the macro about 50% faster (attached.) Which sounds like a lot but wow is that not anywhere close to enough. It can solve easy to medium individual machines but trying to do big ones, much less all of them at once, is a path to out of memory.

Reasonably confident that if there is an answer down this path it comes from some novel way to prune branches rather than just testing each one faster.

For Random extra fun I can't package (zip) the workflow. Throws an error about the Macro being created in a newer version and unlike when I'm opening it to work I can't just click through.

Day10.yxmd

Day10MacroPt2.yxmc

Qiu

Since @AkimasaKajitani @DaisukeTsuchiya and @Hub119 said it is acceptable to use Optimizaton tool, I will listen.

Spoiler

AoC 2025 Day 10-QIu.yxzp

Stosh

Day 10 'complete'. Wow, just... wow. This was an insane problem! My Alteryx skills were stretched to the absolute maximum on this one.

Part 1 and 2 Flows

Spoiler

Part 1 Macro

Spoiler

Surprise! There are 2! Went for a nested macro.
Outer:

Inner:

Part 2 Macro:

Spoiler

My Reflection:

Spoiler

This problem kicked my butt. Both parts were the hardest of their respective difficulty thus far, and it certainly showed in my solve time😂

I knew all along that this problem required some nested for-loop logic: One to handle the iterations of button presses for each machine and another to have it go one machine at a time. The outer macro simply sends one row of the machines into the inner macro per iteration. The inner macro begins with fully closed indicator cells and handles the on/off logic for each button press. Then, if no resulting indicator matches the final state, the current states are summarized to remove duplicates and appends to the buttons, and this handles every possibility. This wouldn't work if we needed to track the order of button presses, but all we care about is how many buttons are pressed, so we can gain some key efficiency that leads to a massive reduction in total records in the cases with more iterations than average. Once a current indicator state matches the final indicator, the macro completes. This runs pretty quickly (about 15 secs), which I am pleased with.

Part 2 was like Part 1 with rabies. I did try to retrofit my above logic to solve this new problem, but the reality is many machines required hundreds of iterations at minimum and in the end we were looking at a flow that would perhaps take days to run. I looked around and saw people using the Optimization tool, so I decided to check it out. Admittedly, I was disappointed that I myself didn't realize that we were looking at a linear programming problem, as I remember covering them in college not too long ago (although none of my problems back then had 10+ variables😂) but once I realized that, it made me feel a lot more calm about the problem overall. I tried to configure the Optimization tool on my own using the documentation, but by god if that isn't a finnicky tool! I ended up downloading @Hub119 's workflow to get the hang of the naming conventions and data structure required for each input. That being said, our solutions are slightly different, as he handles all the data prep in the outer flow, whereas I do it within the macro itself. Honestly don't know why I made this decision, but I think it came down to me wanting my Part 2 outer workflow to be the same length as Part 1's to make for a nice screenshot😂 This one runs like a bear (25 minutes) but it gets me the answer, and at this point that's all I can ask for.

All in all, this was a crazy problem, and all I can say is I am just happy to see the gold star next to my name for this day. The upside now is that I do not have to wait at all for day 11 and can begin solving right away!

AOC2025.10.yxzp

mmontgomery

Day 10

Spoiler

Only done P1 so far, and it took me a while. I ended up just randomly assigning 0 or 1 button presses to each wiring then simulating 30000 times then taking the min value

I'll work on P2 later

Spoiler

The key for this problem was leveraging the optimization tool! I used sample workflow=>predictive tool examples=> prescriptive analytics=>fantasy sports lineup as a guide. The biggest bug was making sure data types were correct! My subid defaulted to a number but needed to be a string. To make life easier (and take longer), I did it as a batch macro for each row

Day10.yxzp

AkimasaKajitani

Optimize tool!

Spoiler

Part1 macro

Part 2 macro

Later, I would like to solve on Pure Base A.

Day10.yxzp

AkimasaKajitani

I think the R tool, Python tool and Run command tool are obviously restricted in Base A.

It's true that the Optimization tool is an R-based tool. However, I think the imporant thing is that R, Python and Run Command tool allow free programming. The R-based tool merely provides a specific function for Alteryx Designer (how that tool is implemented is solely a matter of Alteryx).

However, it is free not to use R-based tool. I would like to call it as Pur Base A. That way makes AoC much more difficult to solve, but also much more rewarding🎉

Goddenra

Have rebuilt my Part 2 to use the Optimization tool. Good learning experience for me as not used it before. Very quick and dirty generation of the required format, but I was learning as I went.

Day10.yxzp

Pilsner

I was expecting it to keep getting tougher, but this was certainly a step up. Took a couple of long nights, but finally got a solution to part two without using the optimise tool! I will post more of a write-up & neater workflow at a later date, but here's my (relatively) raw solution. Total run time for parts one and two is just under 1 minute in the workflow's current state. A big shout out to @Hub119, I did download your optimise tool solution so that I had a target "button presses per machine", I don't think I would have arrived at my own solution without this.

Spoiler

The short explanation is that I implemented Gauss-Jordan elimination to create a "Row Reduced Epsilon Form" matrix (aka implement an algorithm to reduce the number of variables). From here, I only had to worry about a maximum of 3 variables, instead of 10+. With the reduced number of variables, I could then apply a brute force method to find the optimal solution.

Workflow:

Day 10.yxzp

CoG

And Now.... The moment that a couple people may have been waiting for.... a pure base-A solution to Day 10 Parts 1 & 2. This problem was brutal. I don't think I could have solved this without looking at other's code based solutions to learn that many struggled (outside of Alteryx users), and there were no sneaky insights that could solve this problem. There are certainly optimizations that I made use of to solve that several users mentioned on the Reddit AoC Solutions page.

Spoiler

Part 1 is solvable without a macro with pure brute force, Generate a super set {1, ... , 2^n} and convert to binary to determine which buttons get pressed, which will account for every possible combination. Key insight here is that pressing a single button more than once is entirely unnecessary. Isolate final state with modulus since multiple buttons can affect the same indicator light. Count it up and your done.

Part 2 is the real headache, with hundreds of millions to billions of permutations to run, this will eat up memory and run remarkably slowly even with hyper optimized brute force approaches. The key here was an approach from Linear Algebra called "Gaussian Elimination", which is basically a way to reframe/change perspective on the problem, so that you have less levers to control (and thus less permutations to deal with). In order for this approach to work I needed to build three different macros:
1. Gaussian Elimination Macro (Performs Gaussian Elimination; although my approach appears to be inefficient)
2. Permutation Generator (Leverages the results of Macro 1 to identify degrees of freedom and generate all possibilities for each)
3. Solver (Takes the permutations and runs through the new linear equation to generate possible solutions).

These macros are hard coded to 13 inputs (maximum for this problem), but they leverage some fascinating dynamic approaches like Dynamic Rename to cycle fields through each iteration, or Multi-Field Formula Tool with helper fields to guide which column needs to be edited dynamically.

Because my Gaussian Elimination solution is not entirely accurate, extra invalid "solutions" are generated. I added a verification section at the very end to ensure that only valid solutions were evaluated, then summed up the Fewest Total Buttons presses to get the answer!

Main:

Gaussian Elimination Macro:
Gaussian Elimination.png

Generate Permutations:

Solver:

This was remarkably difficult but so satisfying to finally solve. From a workflow that took over 4 hours to solve the smaller cases (up to 9 buttons) and would have destroyed my computer in attempting to solve the entire thing, to a workflow that gave me an answer in 1 minutes and 30 seconds, and I finished before Day 12 released to end this year's AoC!

Happy Solving, for the final time this AoC (This is my last AoC solution post for 2025)!

Workflow.yxzp

Gawa

Part2 is not yet done but for just getting Community Budge, I wanna upload mine for part1.

I still pursue how to crack it without the Optimization tool for my skill-up, it would be carry over to year 2026 though.

2025D10_gawa.yxzp

AncientPandaman

Part1 first.
a very good example to use/learn Binary formula (or so call bitmask (?)), where know as fastest operator.

Part2, No license for Optimization tool Orz.
Take forever with P1 methods. (even just 1st records)

Spoiler

Part1
benefit to use binary is to store in less data size and process faster. It take 1.7 seconds for Part1.

convert [###.] to 0111. remember to reverse the string because binary is from right to left

convert (3), (1,3) -> 1000 and 1010 where equal to 8 and 10
1. split to row
2. shift left 1 << [x]
3. sum

toggle -> by using Xor it will change the 1 to 0 and 0 to 1. it can done with 1 row,1 column and 1 formula tool.

the rest is similar to bfs method.
Workflow:

macro:

Day 10.yxzp

Gawa

At the end, I was able to solve part2 without the Optimization tool, but it took 2 hours running. 2 hours might sound too long, however, if you already tried part2 without the Optimization tool, you know "finishing calculation" itself is still worth enough, I believe.

Anyway, I did it, and completed AoC2025.

Spoiler

I borrowed idea from Part1 to prune the unnecessary records.
Convert joltage values and joltage increments by pushing buttons into light value as follows:
Even number = 0
Odd number = 1

For example, Joltage value '15_18_19_2' is equal to '1_0_1_0'.

If number of buttons is N, there is total 2^N - 1 patterns of combination of buttons, provided that the same button cannot be used twice or more.
First, find all patterns of button pushing combination and list up all light pattern. I used this list as a fixed reference dataset for further process.
At this point, we need to realize important observation. In the course of joltage value changes by pushing buttons, joltage value as light status is always any of the value in the list of all light status patterns derived by doing the above. In other words, in the course of tracing change in joltage values, if the joltage value which light status is not included in the above list is hit, you can ignore that record since its joltage value is theoretically unattainable.
For example, joltage increments by pushing buttons can be converted as follows, provided that initial status is all 0.
(0,1) => 1_1_0_0 (push count=1)
(2) => 0_0_1_0 (push count=1)
(3) => 0_0_0_1 (push count=1)
(0,1), (2) => 1_1_1_0 (push count=2)
(0,1), (3) => 1_1_0_1 (push count=2)
(2), (3) => 0_0_1_1 (push count=2)
(0,1),(2),(3) => 1_1_1_1 (push count=3)

In the above example, light status such as '1_0_0_0' are not in the list so if joltage value as light status becomes '1_0_0_0', drop it immediately during examination.
Thanks to how I pruned the record during Iteration Macro like this, the number of records were not infinitely inflating.
With this pruning logic, keep iteration until joltage value itself is all 0, then you get the path how joltage value is changed.

After this iteration macro, I configure another iteration macro that trace joltage value from 0_0_...0_0 to target value and sum up the count of pushing button as well. Find minimum value, and sum all...that's it.

D10P2_gawa.yxzp

AncientPandaman

Found a post in Reddit Post

I just converted it to alteryx. It take me 3 hours for finished it.

with runtime of 15 Seconds~ 🎉

Spoiler

Idea is similar to with gawa for treat the odd and even to 0_1_0_1

different in
1. combination: it just take combo between the Button, not more than 1 each
2. after calculation, Iteration is divide 2

a lot of difficult to convert the point.
1. add 0 combo for all 0_0_0_0
2. the press of this combo should be 0

for example:
1, 4_5_4_0 -> as 0_1_0_0 minus the found combination -> (4-0_5-1_4-0_0-0) -> 4_4_4_0 divide 2 for next loop
2. 2_2_2_0 -> as 0_0_0_0 <- where this should be +0 for [press]
3. 1_1_1_0 -> match the last combination. pow(2,2) *[number of press] + [press]

pow(2, iteration) is used because it divide 2 each iteration. so the number of press should be double for each iteration.

workflow:

macro:

Day 10.yxzp

estherb47

Relied on reading Reddit and other solutions to solve part 1. Loved the clean solution with binary provided by @AncientPandaman , and that's the approach I took as well.

Haven't started part 2 yet, so posting here for badge credit

Spoiler

2025_Day10_EHB.yxzp

Malvim

Pt1 already too traumatic! 10 minutes to get to the macro end =/

Spoiler

was

Day10 Malvim - Press the tempo.yxzp

Quick Links

This months top contributors

atcodedog05 19458

Qiu 15866

binu_acs 15708

MarqueeCrew 13708

apathetichell 13703