The examples from this article are taken from a couple of recent issues of my weekly newsletter<\/a>.<\/p>\n Structural pattern matching excels at... matching the structure of your objects!\nFor the two examples in this article, we'll be using a number of dataclasses that you can use to build abstract Boolean expressions:<\/p>\n For example, the code Suppose you have a Boolean expression built out of the components shared above.\nHow do you evaluate that formula if you are given the assignments that map the variables to their values?<\/p>\n For example, if you have the assignments This is where structural pattern matching can be applied recursively and it's where it really shines!<\/p>\n To solve this problem, you will write a function called Since you're accepting an expression, you're going to use the The structure of the code looks like this:<\/p>\n The trick here is realising that you're using However, to make sure you don't trip on a weird bug later on, and because this matching is supposed to be exhaustive – you're supposed to have one When I'm being lazy, I just raise a Now, it's just a matter of implementing the evaluation logic.\nIn the case of a variable, all you have to do is fetch the variable value from the corresponding dictionary.\nHowever, to make it more convenient to...<\/p>","summary":"Learn how to use structural pattern matching (the match statement) to work recursively through tree-like structures.","date_modified":"2026-01-08T19:23:42+01:00","tags":["python","programming","recursion"],"image":"\/user\/pages\/02.blog\/recursive-structural-pattern-matching\/thumbnail.webp"},{"title":"Beating LinkedIn \u201cQueens\u201d with Python","date_published":"2025-02-25T18:40:00+01:00","id":"https:\/\/mathspp.com\/blog\/beating-linkedin-queens-with-python","url":"https:\/\/mathspp.com\/blog\/beating-linkedin-queens-with-python","content_html":" This is a short account of how I wrote a program that solves all LQueens puzzles from LinkedIn automatically with Python.<\/p>\n\n About a year ago LinkedIn started publishing a daily logic puzzle called “Queens”.\nThis puzzle is a crossover between the queen-placing puzzle from chess<\/a> and Sudoku, and takes place in a square grid with a number of heterogeneous coloured regions, as the image below demonstrates:<\/p>\n The rules for the puzzle are quite simple.\nYou have to place one queen on each coloured region while also making sure that:<\/p>\n See if you can solve the puzzle above, for example by visiting this unofficial archive<\/a>.\n(Make sure to select the same puzzle as I'm showing above, number 179.)<\/p>\n I write algorithms for things like this all the time – which is a bit of a weird thing to be experienced on, but oh well... –, so solving the puzzle in Python was actually quite straightforward.<\/p>\n I decided to represent the board as a list of sets, where each set contains the coordinates of the cells of a coloured region.\nFor example, puzzle 179 shown above would be represented as the following list of sets:<\/p>\n The good stuff lies in the function How does the function know it's done?\nIf it receives an empty list of coloured groups, then that means all groups received a queen, and we can start producing the list of queen positions:<\/p>\n That's the best possible scenario, because that's when the function is already done.\nBut usually, the function has work to do.<\/p>\n If the list of coloured groups is not empty, then the function looks at the very first coloured group, which should be The This article walks through the code used to animate a tree fractal.<\/p>\n\n I really enjoy fractals and for the longest time I've been meaning to draw the classical tree fractal that starts with the main trunk which then successively splits into two branches, that themselves can be seen as the full tree.<\/p>\n Today I quickly put together the code to do this and then I animated the rotation of the tree to make sure it's easy to see the self-similarity of the tree.<\/p>\n This is the animated GIF that I produced:<\/p>\n To draw the tree I wrote a recursive function (obviously!) that draws a trunk and then recursively draws the remainder of the tree.\nTo “recursively draw the remainder of the tree” I needed to compute the two trunks that stem from the trunk I just drew, so to do that I:<\/p>\n The recursive function looks like this:<\/p>\n One important thing that I ended up doing, and that explains the weird calculations inside the call to The full script to draw the tree looks like this:<\/p>\n To make it easier to animate the tree I first started by splitting the function Reverse-engineering the program from “Chronospatial Computer”, day 17 of Advent of Code 2024.<\/p>\n\n The “Chronospatial Computer” is from Advent of Code 2024, day 17<\/a>, a problem that entertained me for a couple of hours.<\/p>\n My input file looked like this:<\/p>\n To read the input and parse it I used a context manager and a couple of calls to Part 1 required me to simulate a series of simple instructions that operate on three registers.\nWhen I read the problem statement, I decided I wanted to use some ideas from functional programming.\nSo, what I did was to separate each operator (there are 8) into three parts:<\/p>\n By using First, the computation part of each operation:<\/p>\n In the lambda functions above, when we use The operation Then, I wrote a list with all the functions that update the state of the program:<\/p>\n This uses the dunder method Finally, all operators move the program pointer by two positions except the operator Solving “Bridge Repair”, from day 7 of Advent of Code 2024, in 4ms with Python with a simple deductive algorithm.<\/p>\n\n Today I solved the problem from Advent of Code 2024, day 7<\/a> in 4ms using Python.\nMy first solution used brute-force and ran in 15 seconds.\nIt was very easy to implement and I got the job done quite quickly.\nBut then I thought about using a smarter algorithm, and I got a solution that's over 4,000 times faster and that runs in under 4ms.\nI will describe both solutions in this article.<\/p>\n (It should be obvious by now, but this article contains spoilers!)<\/p>\n In short, given a target integer and a list of integers, can we use addition, multiplication, and concatenation, to manipulate the list of integers to equal the target integer?\nThere is the added restriction that the operations are always evaluated from left to right and the integers cannot be reordered.<\/p>\n Here are some examples that are possible:<\/p>\n To make \\(5\\)<\/span> with \\(2\\)<\/span> and \\(3\\)<\/span> we can do \\(5 = 2 + 3\\)<\/span>.\nTo make \\(6\\)<\/span> with \\(2\\)<\/span> and \\(3\\)<\/span> we can multiply the two numbers and to make \\(23\\)<\/span> with \\(2\\)<\/span> and \\(3\\)<\/span> we can concatenate the two digits.\nFinally, to make \\(94\\)<\/span> with the integers \\(2\\)<\/span>, \\(4\\)<\/span>, \\(9\\)<\/span>, and \\(5\\)<\/span>, we start by multiplying, then we concatenate, and then we add.\nIf we use \\(||\\)<\/span> to represent concatenation, then \\(94 = ((2 \\times 4) || 9) + 5\\)<\/span>.<\/p>\n To determine if a certain list of numbers can be manipulated to match the target value, we can write a function that generates all distinct sequences of operators and then tries to use each sequence of operators in turn.<\/p>\n Using Advent of Code provides an input file with 850 tests<\/a> and this code takes slightly over 15 seconds to classify all 850 tests on my machine.\nNow, I will show you how you can speed this up by a factor of 2,000.<\/p>\n The faster algorithm is conceptually very simple.\nDisappointingly simple.\nInstead of working from the front to the back, trying random operations and seeing if they work out in the end, we work from the back to the front.<\/p>\n For example, consider the target The...<\/p>","summary":"Solving \u201cBridge Repair\u201d, from day 7 of Advent of Code 2024, in 4ms with Python with a simple deductive algorithm.","date_modified":"2025-07-23T16:49:02+02:00","tags":["algorithms","mathematics","programming","python","recursion"],"image":"\/user\/pages\/02.blog\/solving-bridge-repair-in-4ms-with-python\/thumbnail.webp"},{"title":"N queens problem","date_published":"2024-02-09T00:00:00+01:00","id":"https:\/\/mathspp.com\/blog\/n-queens-problem","url":"https:\/\/mathspp.com\/blog\/n-queens-problem","content_html":" This article shows how to solve the N queens problem in 20 lines of code.<\/p>\n\n (You can skip to the solution<\/a> or just see the code<\/a>.)<\/p>\n “Do you understand what you have to do?”, Queen #6 asks.<\/p>\n “Uh, I– I think so.”<\/p>\n The challenge sounded simple enough but I was a bit intimidated by the Ten Queens all looking at me.<\/p>\n They stood tall in front of me.\nAn impeccable pose, worthy of a Queen.\nTimes ten.<\/p>\n They looked rigid and cold, wearing their white and black dresses.\nBut if you looked carefully enough, they also looked...\nThey looked... hopeful!\nThey believed I would be able to help them.<\/p>\n I wasn’t feeling confident and Queen #8 picked up on that, so she decided to recap what they needed:\n“Like my sister #6 said, we need to distribute ourselves on this 10 × 10 board.\nThe goal is to count<\/em> in how many different ways this can be done.<\/p>\n We like to have room to pace a bit, so no two of us can be on the same row, column, or diagonal.\nThis restriction is essential.”<\/p>\n I nodded along while she recapped.\nThen, I asked “How on Earth am I supposed to compute this?\nI can’t do this with pen and paper!”.<\/p>\n All Queens started laughing uncontrollably.\nQueen #1 managed to control herself for long enough to reply.<\/p>\n ”You silly! You use Python, of course!”\nShe waved.<\/p>\n The two pawns at the entrance of the room we were in opened the massive doors.\nAs the huge doors creaked and opened slowly, four pawns came into the hall, carrying a computer.\nThe computer was already turned on.\nAs the computer moved closer, this is what I saw on the screen:<\/p>\n “You have one week.\nYou can start now.”<\/p>\n I walked up to the computer and started working on the problem.<\/p>\n I was thinking aloud while I was typing.<\/p>\n “We know that no two queens can be on the same row or column.\nAnd that's easy to enforce in my code.\nI'll traverse the columns and put one of you in each column while also not repeating rows.\nIt's the diagonals that I have to be careful about.”<\/p>\n I paused for a bit.\nThen I wrote this function:<\/p>\n I proceeded to explain:<\/p>\n “I'll store a tuple called The queens...<\/p>","summary":"This article shows how to solve the N queens problem in 20 lines of code.","date_modified":"2025-09-27T16:50:04+02:00","tags":["algorithms","combinatorics","logic","programming","python","recursion"],"image":"\/user\/pages\/02.blog\/n-queens-problem\/thumbnail.webp"},{"title":"(More) Animations from first principles","date_published":"2023-09-08T12:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/more-animations-from-first-principles-in-5-minutes","url":"https:\/\/mathspp.com\/blog\/more-animations-from-first-principles-in-5-minutes","content_html":" Create a zooming animation from first principles in Python. In 5 minutes. Kind of.<\/p>\n\nA recursive data structure<\/a><\/h2>\n
from dataclasses import dataclass\n\nclass Expr:\n pass\n\n@dataclass\nclass And(Expr):\n exprs: list[Expr]\n\n@dataclass\nclass Or(Expr):\n exprs: list[Expr]\n\n@dataclass\nclass Not(Expr):\n expr: Expr\n\n@dataclass\nclass Var(Expr):\n name: str<\/code><\/pre>\nNot(And([Var(\"A\"), Var(\"B\")]))<\/code> represents the Boolean expression not (A and B)<\/code>.<\/p>\nEvaluating a Boolean expression<\/a><\/h2>\n
{\"A\": True, \"B\": False}<\/code> (for example, a dictionary that maps variable names to values), how can you determine that the expression Not(And([Var(\"A\"), Var(\"B\")]))<\/code> is True<\/code>?<\/p>\nevaluate(expression: Expr, assignments: dict[str, bool]) -> bool<\/code>.\nYour function accepts an expression and the assignments in the form of a dictionary and it returns the final Boolean value the expression evaluates to.<\/p>\nmatch<\/code> statement on the full expression and then create a case<\/code> branch for each of the possible expressions you might have:<\/p>\nAnd<\/code> expression;<\/li>\nOr<\/code> expression; or<\/li>\nNot<\/code> expression.<\/li>\n<\/ol>def evaluate(expression: Expr, assignments: dict[str, bool]) -> bool:\n match expression:\n case Var(): pass\n case And(): pass\n case Or(): pass\n case Not(): pass<\/code><\/pre>\nExpr<\/code> as the type of the argument but really, you always expect the argument to be an instance of one of the subclasses of Expr<\/code>, and not a direct Expr<\/code> instance.<\/p>\ncase<\/code> for each subclass of Expr<\/code> – you can defend yourself by including a catch-all pattern that raises an error.<\/p>\nRuntimeError<\/code>:<\/p>\ndef evaluate(expression: Expr, assignments: dict[str, bool]) -> bool:\n match expression:\n case Var(): pass\n case And(): pass\n case Or(): pass\n case Not(): pass\n case _:\n raise RuntimeError(\n f\"Couldn't evaluate expression of type {type(expression)}.\"\n )<\/code><\/pre>\n![A screenshot showing the text \"Puzzle 179 Appeared on 26 October 2024\" and a coloured grid that is 8 by 8 with 8 coloured regions of heterogeneous shapes.](\"\/user\/pages\/02.blog\/beating-linkedin-queens-with-python\/_puzzle.webp\" "\\"Queens")
Puzzle rules<\/a><\/h2>\n
Solving the puzzle<\/a><\/h2>\n
[\n {(0, 1), (4, 0), (0, 0), (7, 0), (2, 0), (3, 0), ...}, # yellow\n {(7, 4), (7, 1), (2, 1), (7, 7), (3, 1), (6, 1), ...}, # orange\n {(2, 4), (0, 4), (0, 3), (1, 4), (0, 6), (0, 2), ...}, # blue\n {(2, 3), (3, 2), (1, 2), (2, 2)}, # green\n {(6, 2), (4, 3), (4, 2), (3, 3), (5, 2)}, # gray\n {(2, 5), (3, 4), (3, 5), (1, 5)}, # red\n {(4, 4), (5, 5), (6, 5), (5, 4), (4, 5)}, # purple\n {(0, 7), (2, 7), (3, 7), (4, 6), (5, 7), (1, 7), ...}, # brown\n]<\/code><\/pre>\nsolve<\/code>.\nThe function solve<\/code> is a recursive function that accepts the list with coloured groups that don't have a queen yet and returns the list of positions where queens must go.<\/p>\ndef solve(group_sets):\n if not group_sets:\n return []\n\n # ...<\/code><\/pre>\ngroup_sets[0]<\/code>, and traverses that set of positions, one position at a time:<\/p>\n for tx, ty in group_sets[0]:<\/code><\/pre>\ntx<\/code> and ty<\/code> and the x and y coordinates for the tentative<\/em> position of the queen of the current coloured group.\nBut let us assume, for a second,...<\/p>","summary":"This is a short account of how I wrote a program that solves all Queens puzzles from LinkedIn automatically with Python.","date_modified":"2025-07-23T16:49:02+02:00","tags":["algorithms","image processing","python","programming","recursion","slice of life"],"image":"\/user\/pages\/02.blog\/beating-linkedin-queens-with-python\/thumbnail.webp"},{"title":"Animating a tree fractal","date_published":"2025-01-12T19:10:00+01:00","id":"https:\/\/mathspp.com\/blog\/animating-a-tree-fractal","url":"https:\/\/mathspp.com\/blog\/animating-a-tree-fractal","content_html":"![\"Animated](\"\/user\/pages\/02.blog\/animating-a-tree-fractal\/_tree.gif?decoding=auto&fetchpriority=auto\")
<\/p>\nDrawing the tree<\/a><\/h2>\n
def tree(screen, start, to, depth=0):\n if depth >= 15:\n return\n sx, sy = start\n tx, ty = to\n pygame.draw.line(\n screen,\n BLACK,\n (WIDTH \/\/ 2 + sx, HEIGHT \/\/ 2 - sy),\n (WIDTH \/\/ 2 + tx, HEIGHT \/\/ 2 - ty),\n 1,\n )\n direction = np.array([[tx - sx], [ty - sy]])\n for angle in [pi \/ 3, -pi \/ 3]:\n rot = np.array(\n [\n [cos(angle), -sin(angle)],\n [sin(angle), cos(angle)],\n ]\n )\n new_direction = ((rot @ ((direction) \/ 1.7))).reshape((2,))\n tree(screen, to, to + new_direction, depth + 1)<\/code><\/pre>\npygame.draw.line<\/code>, is that I decided to do all calculations as if the coordinate system were the standard one from maths class: the origin is at the centre of the pygame window and the values of the coordinate y increase by going up, not by going down.\nThen, I need to convert from this sytem to the pygame system right before drawing, which is why I add (WIDTH \/\/ 2, HEIGHT \/\/ 2)<\/code> to the points we're drawing and then for the y coordinate I need to use the symmetric value (-y<\/code> instead of y<\/code>) to compensate for the fact that the y axis is flipped.<\/p>\nfrom math import sin, cos, pi\nimport sys\n\nimport numpy as np\nimport pygame\nimport pygame.locals\n\nWIDTH, HEIGHT = 600, 400\n\nWHITE = (255, 255, 255)\nBLACK = (0, 0, 0)\n\nscreen = pygame.display.set_mode((WIDTH, HEIGHT))\n\ndef tree(screen, start, to, depth=0):\n ...\n\ndef main() -> None:\n screen.fill(WHITE)\n tree(screen, np.array((0, -200)), np.array((0, 0)))\n pygame.display.flip()\n pygame.image.save(screen, \"tree.png\")\n\n while True:\n for event in pygame.event.get():\n if event.type == pygame.locals.QUIT:\n pygame.quit()\n sys.exit(0)\n\nif __name__ == \"__main__\":\n main()<\/code><\/pre>\nAnimating the tree<\/a><\/h2>\n
tree<\/code> in two:<\/p>\nParsing the input<\/a><\/h2>\n
Register A: 64012472\nRegister B: 0\nRegister C: 0\n\nProgram: 2,4,1,7,7,5,0,3,1,7,4,1,5,5,3,0<\/code><\/pre>\nreadline<\/code>:<\/p>\nwith open(\"input.txt\", \"r\") as f:\n register_a = int(f.readline().split()[-1])\n register_b = int(f.readline().split()[-1])\n register_c = int(f.readline().split()[-1])\n _ = f.readline()\n program = [int(num) for num in f.readline().split()[-1].split(\",\")]\n\nprint(program, register_a, register_b, register_c)<\/code><\/pre>\nSolving part 1 with functional programming<\/a><\/h2>\n
lambda<\/code> functions, dunder methods<\/a>, and currying with functools.partial<\/code><\/a>, each list below represents one of the three parts of each opcode.<\/p>\nregisters = [0, 1, 2, 3, register_A, register_B, register_C]\nA, B, C = 4, 5, 6 # Indices of the named registers in the list `registers`.\n\ncomputations = [\n lambda o: registers[A] \/\/ pow(2, registers[o]), # ADV\n lambda o: registers[B] ^ o, # BXL\n lambda o: registers[o] % 8, # BST\n lambda o: ..., # JNZ\n lambda o: registers[B] ^ registers[C], # BXC\n lambda o: registers[o] % 8, # OUT\n lambda o: registers[A] \/\/ pow(2, registers[o]), # BDV\n lambda o: registers[A] \/\/ pow(2, registers[o]), # CDV\n]<\/code><\/pre>\no<\/code> in isolation, we're using the operand as a literal operand, whereas the list registers<\/code> maps an operand into its combo operand.\nBy using this list, we can map the numbers 0 through 3 to themselves and the indices 4, 5, and 6, to the registers A, B, and C, respectively, without having to use a conditional statement.<\/p>\nJNZ<\/code> has a lambda function that does nothing because there is no proper computation for this operator.<\/p>\nfrom functools import partial\n\noutput = []\nstate_updates = [\n partial(registers.__setitem__, A),\n partial(registers.__setitem__, B),\n partial(registers.__setitem__, B),\n lambda v: ...,\n partial(registers.__setitem__, B),\n output.append,\n partial(registers.__setitem__, B),\n partial(registers.__setitem__, C),\n]<\/code><\/pre>\n__setitem__<\/code><\/a> and the function functools.partial<\/code><\/a> to create a function that accepts a single value and that writes that value to the correct register in the list registers<\/code>.<\/p>\nJNZ...<\/code><\/p>","summary":"Reverse-engineering the program from \u201cChronospatial Computer\u201d, day 17 of Advent of Code 2024.","date_modified":"2025-07-23T16:49:02+02:00","tags":["algorithms","mathematics","modular arithmetic","programming","python","recursion"],"image":"\/user\/pages\/02.blog\/reverse-engineering-the-chronospatial-computer\/thumbnail.webp"},{"title":"Solving \u201cBridge Repair\u201d in 4ms with Python","date_published":"2024-12-07T19:00:00+01:00","id":"https:\/\/mathspp.com\/blog\/solving-bridge-repair-in-4ms-with-python","url":"https:\/\/mathspp.com\/blog\/solving-bridge-repair-in-4ms-with-python","content_html":"Problem statement<\/a><\/h2>\n
5: 2 3\n6: 2 3\n23: 2 3\n94: 2 4 9 5<\/code><\/pre>\nBrute-force solution, 15 seconds<\/a><\/h2>\n
itertools.product<\/code>, we can generate all sequences of distinct operators quite easily:<\/p>\nfrom itertools import product\nfrom operator import add, mul\n\nvalid_operators = [\n add,\n mul,\n lambda x, y: int(f\"{x}{y}\")\n]\n\ndef is_valid(target, operands):\n operator_sequences = product(valid_operators, repeat=len(operands) - 1)\n start, *head = operands\n for operators in operator_sequences:\n total = start\n for operator, operand in zip(operators, head):\n total = operator(total, operand)\n if total == target:\n return True\n return False\n\nprint(is_valid(94, [2, 4, 9, 5]))<\/code><\/pre>\nDeducing valid operations, 4 milliseconds<\/a><\/h2>\n
94<\/code> and the list of integers [2, 4, 9, 5]<\/code>.\nIf this is a possible case, then the final operation must be an addition.\nWhy?<\/p>\nThe problem for N = 10<\/a><\/h2>\n
Python 3.12.0 (the Ten Queens build)\nType \"help\" for more information.\n>>><\/code><\/pre>\nThe solution<\/a><\/h2>\n
def diagonally_safe(row, col, placements):\n for qrow, qcol in enumerate(placements):\n if row - col == qrow - qcol or row + col == qrow + qcol:\n return False\n return True<\/code><\/pre>\nplacements<\/code> with the positions of some of you.\nThe index is the row you're in and the value itself represents the column.\nFor example, if placements<\/code> is (5, 0, 4)<\/code> that means that the row 0<\/code> has a queen in column 5<\/code>, the row 1<\/code> has a queen in column 0<\/code>, and the row 3<\/code> has a queen in column 4<\/code>.”<\/p>\n