How I made a puzzle solver
A couple of months ago I stumbled across the a-puzzle-a-day by dragonfjord got one from Amazon if I recall correctly and not long after I bought one for my friend.
Soon after that I upgraded to the “legendary version” and sent him one, after having sent him the acrylic version which he hated. 😆
A daily routine
We started sending photos of the puzzle each day, showing how we solved it that day. It was a fun little thing to do and it was a nice way to keep in touch.
Since both he and I are developers it did not take long before we started wondering about systems and how it worked, and if there was a way to solve it programmatically etc.
Stuff we developers do with pretty much everything.
There are other solvers for this
Now this is not ground breaking. There are plenty of other websites, python scripts and other solver tools for this puzzle and I was not really interested in solving the puzzle.
I wanted to understand the inner workings of it and I really wanted to get the data on why some days felt impossible to solve and others seemed to solve themselves.
The research
I came across this paper on Algoritm X and some reverse searching lead to a python script that credited this paper.
The algorithm itself is not that complicated - well it is but it is not - but the way it is implemented is quite clever.
def solve(X, Y, solution=None):
if not X:
yield list(solution)
else:
c = min(X, key=lambda c: len(X[c]))
for r in list(X[c]):
solution.append(r)
cols = select(X, Y, r)
for s in solve(X, Y, solution):
yield s
deselect(X, Y, r, cols)
solution.pop()
def select(X, Y, r):
cols = []
for j in Y[r]:
for i in X[j]:
for k in Y[i]:
if k != j:
X[k].remove(i)
cols.append(X.pop(j))
return cols
def deselect(X, Y, r, cols):
for j in reversed(Y[r]):
X[j] = cols.pop()
for i in X[j]:
for k in Y[i]:
if k != j:
X[k].add(i)
def exact_cover(X, Y):
X = {j: set() for j in X}
for i, row in Y.items():
for j in row:
X[j].add(i)
return X
if __name__ == '__main__':
X = {1, 2, 3, 4, 5, 6, 7}
Y = {'A':[1,4,7], 'B':[1,4], 'C':[4,5,7], 'D':[3,5,6], 'E':[2,3,6,7], 'F':[2,7]}
X = exact_cover(X, Y)
solutions = solve(X, Y, [])
print(list(solutions))
Explanation
Algoritm X is based on the Exact Cover Problem which is useful for solving sudokus, tetris-like puzzles and even scheduling problems.
Imagine you have a bunch of requirements (represented by X) and a set of choices (represented by Y). Each choice covers some of the requirements.
Your goal is to pick a set of choices such that:
Every requirement is covered exactly once. You use the fewest possible choices.
Pentomino
There is a similar puzzle to a-puzzle-a-day, called Pentomino. It is a 5x12 grid and you have to fit all 12 pentominoes into the grid.
The same author for the algox.py also conveniently had a pentomino solver and even a a-puzzle-a-day solver that utilizes the pentomino solver.
After reading through the code I realized that I could use the same solution but in svelte.
My solver
I created this a-puzzle-a-day solver, I basically just copied the code from the python script and translated it to svelte, wrote an UI from scratch and that was it.
What I noticed was that the script was very fast in calculating the maximum number of solutions which was the data I was interested in.
Back to my friend
In a chat with my mate I expressed how it would be cool to have like a heatmap for what days are hard and what days are easy.
Some back and forth later (like clarifying what hard/easy meant) I wrote a quick and dirty python script that ran the pentomino solver from before 366 times and gathered all the data in a json file.
#!/usr/bin/env python3
"""
Author: Pierre Hagelberg <hello@hglbrg.dev>
License: MIT
References:
https://www.cs.mcgill.ca/~aassaf9/python/algorithm_x.html
https://en.wikipedia.org/wiki/Exact_cover
Dependencies:
pentomino by Michael Shepanski <michael.shepanski@gmail.com>
"""
import datetime
import json
import multiprocessing
import configparser
import pentomino
import time
import calendar
import os
def find_solutions_for_date(board, pieces, date, allow_reflections=True, allow_duplicates=False):
"""Find the solutions for the specified date."""
board = pentomino.Shape.fromstr(board, 'board') if isinstance(board, str) else board
board = set_date(board, date)
solver = pentomino.Puzzle(board, pieces,
allow_reflections=allow_reflections,
allow_duplicates=allow_duplicates)
solutions = list(solver.find_solutions())
return solutions, len(solutions)
def set_date(board, date):
"""Place the occupied markers on the specified month and day."""
weekday = ((date.weekday() + 1) % 7) + 1
count = 0
for r, c in board.coords():
count += 1
if date.month == count: board.shape[r][c] = pentomino.Shape.EMPTY
if date.day == count-12: board.shape[r][c] = pentomino.Shape.EMPTY
return board
def calculate_solutions_for_year(year=2025, num_procs=4):
"""Calculate solutions for all days in a year."""
print(f"Calculating solutions for {year}...")
# Load puzzle configuration
puzzles = configparser.ConfigParser()
puzzles.read('puzzle-a-day.ini', encoding='utf-8')
# Use dragonfjord board and set1 pieces
board = puzzles['dragonfjord']['board']
pieces = puzzles['dragonfjord']['set1']
# Create result structure
results = {
"solutions": {},
"minSolutions": float('inf'),
"maxSolutions": 0
}
# Initialize month dictionaries
for month in range(1, 13):
results["solutions"][str(month)] = {}
# Use multiprocessing to speed up calculations
with multiprocessing.Pool(processes=num_procs) as pool:
tasks = []
for month in range(1, 13):
days_in_month = calendar.monthrange(year, month)[1]
for day in range(1, days_in_month + 1):
date = datetime.date(year, month, day)
tasks.append((date, pool.apply_async(
find_solutions_for_date,
(board, pieces, date)
)))
# Process results as they complete
total_days = len(tasks)
for i, (date, task) in enumerate(tasks):
try:
_, solution_count = task.get(timeout=300)
# Update results
month_str = str(date.month)
day_str = str(date.day)
results["solutions"][month_str][day_str] = solution_count
# Update min and max
results["minSolutions"] = min(results["minSolutions"], solution_count)
results["maxSolutions"] = max(results["maxSolutions"], solution_count)
# Print progress
print(f"Progress: {i+1}/{total_days} - {date.isoformat()}: {solution_count} solutions")
except Exception as e:
print(f"Error processing {date.isoformat()}: {e}")
return results
def main():
start_time = time.time()
# Calculate solutions for a single year (results should be the same for any year)
results = calculate_solutions_for_year()
# Save results to JSON file
output_file = "puzzle_solutions.json"
with open(output_file, "w") as f:
json.dump(results, f, indent=2)
elapsed_time = time.time() - start_time
print(f"Calculations complete. Results saved to {output_file}")
print(f"Total time: {elapsed_time:.2f} seconds")
print(f"Min solutions: {results['minSolutions']}")
print(f"Max solutions: {results['maxSolutions']}")
if __name__ == "__main__":
main()
The heatmap
What I wanted was basically a way to show what day had the fewest solutions and what day had the most solutions with colors somehow. I decided on my currently most used gradient in watercolor which is a transparent orange with indigo. Beautiful colors. Sidenote. Not sorry.
And here it is. I should add them both to the top too.
Usage
By clicking a month you show the solutions for that month. By clicking a day you show the solutions for that day.
There are some statistics at the bottom of the page and I might keep developing this further so there may be more things I don’t write about here.