Advent of Code 2025 - Day 12: Christmas Tree Farm (The Finale!)

Day 12 was the finale of Advent of Code 2025. The puzzle appeared to be about fitting oddly-shaped presents into regions under Christmas trees - a classic constraint satisfaction problem. But there was a twist.

Part 1: Can They Fit?

Given various present shapes and regions under trees, determine how many regions can fit all their listed presents.

Example shapes:

1
2
3
4

Shape 0:    Shape 4:    Shape 5:
###         ###         ###
##.         #..         .#.
##.         ###         ###

Example regions:

• 4x4: 0 0 0 0 2 0 - a 4×4 grid needing two shape-4 presents
• 12x5: 1 0 1 0 2 2 - a 12×5 grid needing various shapes

This looks like it’s asking for a full solution using something like Dancing Links (DLX) or Algorithm X - the kind of thing used for Sudoku solvers and exact cover problems.

The Suspicion

After reading the problem carefully, I had a suspicion: this might be simpler than it appears. Implementing DLX for the final day would be intense, especially with rotations and flips to consider.

The Simple Solution

I wrote a custom parser for the funky input format (hardcoded for 6 shapes at 3×3 size):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

def loadInput(input_f):
    lines = loadFile(input_f)
    firstPart = True
    shapes = []
    grids = []
    tmp = []
    size = 0
    
    for x in range(0, len(lines)):
        if x == 30: 
            firstPart = False
        if firstPart:
            if 0 < x%5 < 4:
                tmp.append(lines[x])
                size += lines[x].count('#')  # Count '#' in shape
            else:
                if x in [4, 9, 14, 19, 24, 29]:
                    shapes.append([tmp, size])
                    tmp = []
                    size = 0
        elif x >= 30:
            size, amount = lines[x].split(': ')
            size = size.split('x')
            amount = amount.split(' ')
            grids.append([list2int(size), list2int(amount)])
    
    return shapes, grids

Then I tested my hunch: maybe we just need to check if there’s enough space:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

def part1():
    score = 0
    shapes, grids = loadInput(input_f)
    
    for g in grids:
        grid_size = g[0][0] * g[0][1]  # Width × height
        
        needed_space = 0
        for sdx, s in enumerate(g[1]):
            needed_space += s * shapes[sdx][1]  # Count × shape size
        
        if grid_size > needed_space:
            score += 1
    
    return score

It worked! The puzzle was a red herring. You don’t actually need to solve the packing problem - you just need to check if there’s enough space. If the grid has more cells than the total cells needed by all presents, it’s solvable. Otherwise, it’s not.

This is brilliant problem design: it looks like you need a complex constraint solver, but the test cases are specifically crafted so simple space checking works.

Part 2: The Star on the Tree

Part 2 is where Advent of Code traditionally gets wild. But for the last day, Part 2 was just placing the star on top of the Christmas tree:

Before any of them can find a ladder, a particularly large Christmas tree suddenly flashes brightly when a large star magically appears above it!

No code needed. Just collect your final star. All 24 stars collected! 🎄⭐

But What If We Actually Solved It?

After finishing, I was curious: could we actually solve the packing problem? I had Claude help me implement two approaches:

Z3 SMT Solver

Using Microsoft’s Z3 theorem prover to encode the constraint satisfaction problem. Result: never finished. The search space was too large.

OR-Tools (Google’s Constraint Solver)

Using Google’s OR-Tools constraint programming library. Result: used too many resources, but gave some progress.

For the 46×46 grid with 44+43+34+34+28+41 = 224 pieces, OR-Tools estimated over 200,000 possible placements to explore. It’s technically solvable but computationally expensive.

Visualizing a Solution

I did manage to generate a valid packing for the first solvable grid (46×46 with 224 pieces). Here’s what it looks like:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

.AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVV.
AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWW
A.B.C.D.E.F.G.H.I.J.K.L.M.N.O.P.Q.R.S.T.U.VWWS
.XXYYZZAABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRWSS
XXYYZZAABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRTSSS
X.YUZ.AVB.CWD.EXF.GYH.IZJ.KAL.MBN.OCP.QDRTT.E.
..UU..VV..WW..XX..YY..ZZ..AA..BB..CC..DDTTTEE.
.UUUFVVVGWWWHXXXIYYYJZZZKAAALBBBMCCCNDDDO.EEEP
...FF..GG..HH..II..JJ..KK..LL..MM..NN..OO.Q.PP
..FFFRGGGSHHHTIIIUJJJVKKKWLLLXMMMYNNNZOOOQQPPP
..A.RR..SS..TT..UU..VV..WW..XX..YY..ZZ.BQQQC..
.AARRRDSSSETTTFUUUGVVVHWWWIXXX.YYY.ZZZBB..CC..
AAA..DD..EE..FF..GG..HH..IIJJJKKKLLL.BBB.CCC..
MMM.DDD.EEE.FFF.GGG.HHH.III..J..K..LNNNOOOPPP.
..MQQQRRRSSSTTTUUUVVVWWWXXXJJJKKKLLL..N..O..P.
MMM..Q..R..S..T..U..V..W..XYYYZZZAAANNNOOOPPP.
BBBQQQRRRSSSTTTUUUVVVWWWXXX..Y..Z..ACCCDDDEEE.
..BFFFGGGHHHIIIJJJKKKLLLMMMYYYZZZAAA..C..D..E.
BBB..F..G..H..I..J..K..L..MNNNOOOPPPCCCDDDEEE.
QQQFFFGGGHHHIIIJJJKKKLLLMMM..N..O..PR.RS.ST.T.
..QU.UV.VW.WX.XY.YZ.ZA.AB.BNNNOOOPPPRRRSSSTTT.
QQQUUUVVVWWWXXXYYYZZZAAABBBC.CD.DE.E.RR.SS.TT.
F.F.UU.VV.WW.XX.YY.ZZ.AA.BBCCCDDDEEEG.GH.HI.I.
FFFJ.JK.KL.LM.MN.NO.OP.PQ.Q.CC.DD.EEGGGHHHIII.
.FFJJJKKKLLLMMMNNNOOOPPPQQQR.RS.ST.T.GG.HH.II.
U.U.JJ.KK.LL.MM.NN.OO.PP.QQRRRSSSTTTV.VW.WX.X.
UUUY.YZ.ZA.AB.BC.CD.DE.EF.F.RR.SS.TTVVVWWWXXX.
.UUYYYZZZAAABBBCCCDDDEEEFFFG.GH.HI.I.VV.WW.XX.
J.J.YYZ.ZA.AB.BC.CD.DE.EF.FGGGHHHIIIK.KL.LM.M.
JJJN.NO.OP.PQ.QR.RS.ST.TU.UG.GH.HI.IKKKLLLMMM.
J.JNNNOOOPPPQQQRRRSSSTTTUUUV.VW.WX.XK.KL.LMYMY
Z.ZN.NO.OP.PQ.QR.RS.ST.TU.UVVVWWWXXXA.A.BB.YYY
ZZZCC.DD.EE.FF.GG.HH.II.JJ.V.VW.WX.XAAA.BB.Y.Y
Z.ZCC.DD.EE.FF.GG.HH.II.JJKK.LL.MM..A.ABBBNN..
..CCCDDDEEEFFFGGGHHHIIIJJJKK.LL.MMOO.PP...NNQQ
.RR.SS.TT.UU.VV.WW.XX.YY.KKKLLLMMMOO.PPZZNNNQQ
.RR.SS.TT.UU.VV.WW.XX.YYAA.BB.CC.OOOPPPZZDDQQQ
RRRSSSTTTUUUVVVWWWXXXYYYAA.BB.CCEE.FF.ZZZDDGG.
.HH.II.JJ.KK.LL.MM.NN..AAABBBCCCEE.FFOO.DDDGG.
.HH.II.JJ.KK.LL.MM.NNPP........EEEFFFOO...GGG.
HHHIIIJJJKKKLLLMMMNNNPP.............OOO.......
....................PPP.......................
..............................................
..............................................
..............................................
..............................................

Each letter represents a different instance of a present, and the shape template it uses. The . characters are empty spaces.

The Lesson

Day 12 was a perfect finale because it taught a meta-lesson: don’t overthink it.

Sometimes the hardest part of a problem is recognizing that you don’t need to solve it completely. The puzzle appears to require a complex constraint satisfaction solver, but the actual question is much simpler: “Can it fit?” not “Show me how it fits.”

This mirrors real-world engineering: sometimes a quick feasibility check is all you need before diving into implementation details.

Advent of Code 2025: Complete! 🎄⭐

24 stars collected. From Day 1’s circular dial to Day 12’s present packing, this year had great variety:

• Grid problems (Days 4, 6, 7, 12)
• Graph problems (Days 8, 11)
• Geometry (Day 9)
• Range merging (Day 5)
• Recursion (Day 7)
• Combinatorics (Day 11)
• Pattern matching (Day 2)

Some days rewarded careful implementation (Day 4’s queue optimization), others rewarded insight (Day 3’s skip budget, Day 5’s range merging, Day 11’s multiplication principle).

My helper library fred.py grew this year by adding dfs_all_paths(), improving loadFile() with CSV support, and proving its worth with grid utilities on nearly every other day.

Thanks for following along! Time for a well-deserved break before next year. 🎅