Diophantine equation

A Diophantine equation is a polynomial equation in which only integer solutions are admitted. That one word — integer — changes everything. Over the reals, x² - 2y² = 1 is an unremarkable curve; over the integers it is Pell's equation, with infinitely many solutions that march off to infinity in a rigid, predictable pattern. This is the largest single domain in the archive precisely because "which integers satisfy this?" is the question a huge fraction of number-theory problems are really asking, once you strip away the story about triangles, discs, or reciprocals.

The shape of the difficulty

The defining trap of a Diophantine problem is that the solutions are sparse but can be enormous. You cannot search for them by their magnitude. Problem 66 asks for the fundamental solution of x² - Dy²= 1 over D ≤ 1000; for D = 661 the smallest x already exceeds 10¹⁷, so any loop bounded by the size of the answer would never finish. Most of the craft of solving these is to stop searching over values and start exploiting structure — to find the algebraic identity or the recurrence that hands you the solutions directly.

Across the problems below, the same handful of structural moves recur.

Eliminate a variable with a linear constraint

The gentlest case. When a Diophantine system pairs a hard equation with a linear one, the linear equation lets you delete a variable and collapse the search a dimension. In Problem 9 — a Pythagorean triple a² + b² = c² with the side constraint a + b + c = 1000 — you never search for c at all:

for a in range(1, s // 4 + 1):
    for b in range(a, s // 2):
        c = s - a - b            # the linear constraint fixes c; no third loop
        if a * a + b * b == c * c:
            return a * b * c

Two nested loops instead of three, exact integer arithmetic instead of a floating-point square root. The lesson generalises: a linear side-condition is a free dimension of pruning.

A linear equation is not always the easy part, though. Once the unknowns must be non-negative, ax + by + cz = n becomes the coin problem. Problem 718 asks for the sum of every n that 17ᵖa + 19ᵖb + 23ᵖc cannot reach. The reachable values form a numerical semigroup with finitely many gaps, but at p = 6 the gaps run into the quadrillions. The way through is the Apéry set: for each residue r modulo the smallest generator x, find the least reachable value w_r in that class. Everything above w_r in the class is reachable and everything below it is a gap. So the gaps in each class form one arithmetic progression, and its count and sum have closed forms. The cost is linear in x and does not depend on how far the gaps extend. With three generators, walking the residues in steps of z reduces the Apéry set to a running minimum of one array.

With two generators the gaps have more structure: they have coordinates. Problem 988 places frogs on gaps of ⟨a, b⟩ so that no frog can reach another, and asks for a weighted count of the valid placements. Every gap is uniquely ab − ia − jb with i, j ≥ 1. The difference of two gaps is (i' − i)a + (j' − j)b. The solutions of a linear equation in two unknowns are spaced by (b, −a), and the coordinates are too small for that shift to help, so the difference is reachable exactly when i' ≥ i and j' ≥ j. Reachability is therefore componentwise dominance on a staircase of lattice points. A non-attacking placement is an antichain in that order, and antichains of a staircase are counted by a row-by-row DP with suffix sums in O(ab). About 10¹⁵ subsets are counted without listing any of them. Once the solution set of the linear equation is understood exactly, a question about a semigroup becomes a question about a partial order.

Reduce to Pell's equation, then iterate a recurrence

The workhorse pattern. Many geometric or probabilistic constraints, after completing the square and clearing denominators, become a Pell or Pell-like equation x² - Dy² = N for small constants D and N. Problem 100 turns "two blue discs with probability exactly ½" into x² - 2y² = -1; Problem 94 turns "almost-equilateral triangle with integer area" into a family built on x² - 3y² = 1. The decisive fact about Pell equations is that their infinitely many solutions are not scattered — they satisfy a fixed linear recurrence relation. Once you know the fundamental solution, every later one is a constant-time arithmetic update:

x' = 3x + 4y
y' = 2x + 3y      # Problem 100: each step is the next valid arrangement

Because the solutions grow geometrically (here by 3 + 2√2 ≈ 5.83 per step), you cross a threshold of 10¹² in about forty iterations — O(log N) in the bound rather than O(N). Finding the fundamental solution when it is not obvious is itself a classical algorithm: the continued fraction expansion of √D is eventually periodic, and one specific convergent (chosen by the parity of the period length) is guaranteed to be it — the method Problem 66 uses. When D is large the numerators outrun 64 bits, so you reach for arbitrary-precision arithmetic.

When the right-hand side is not ±1, one fundamental solution is no longer enough. A generalised Pell equation x² − Dy² = N usually has several orbits, and you need one seed from each. Problem 582 counts 120° triangles with b − a ≤ 100 up to 10¹⁰⁰. The law of cosines gives the Eisenstein triple equation c² = a² + ab + b². Fixing the difference d = b − a and completing the square gives X² − 3Y² = d². The unit 2 + √3 maps solutions to solutions, and along the branch it moves Y forward by at least d each step. So the range 0 ≤ Y < d is one full period, and every orbit has exactly one seed there. A hundred perfect-square tests per difference find all the seeds. Each orbit is then walked to the bound in O(log n) steps. Points whose parity does not give integer sides, or which give the degenerate a = 0, are filtered on the way. A useful rule is to filter each point as it is produced instead of working out which orbits qualify, because the per-point check is cheap and leaves no parity case to get wrong.

Pell equations can also prove that a search is finite. Problem 581 needs every n for which n and n + 1 are both 47-smooth. With x = 2n + 1 and q the squarefree part of n(n+1), the condition becomes x² − 2q·y² = 1. Here q is a product of some subset of the fifteen primes up to 47, so there are only 2¹⁵ equations to check. That is Størmer's theorem. Lehmer's refinement adds two cheap filters. If the fundamental y₁ is not smooth, no later solution is, because y₁ divides every yₖ. If some yₖ is smooth, then k ≤ max(3, (p+1)/2). An unbounded problem about consecutive smooth numbers therefore becomes a fixed list of Pell equations, each with a short run of powers. The equation tells you where the search can stop as well as how to generate solutions.

Factor the equation into a divisor count

The algebraic sleight-of-hand. An equation in two variables can sometimes be factored into a product of shifted variables, at which point counting solutions becomes counting divisors. The reciprocal equation 1/x + 1/y = 1/n behind Problem 108 and Problem 110 is the canonical example. Multiply through and rearrange, then add n² to both sides so the left factors:

$$ (x - n)(y - n) = n^2 $$

This is Simon's Favorite Factoring Trick. Now every solution (x, y) is an ordered factorisation of n², so the number of solutions is governed by the divisor-counting function τ(n²) — a multiplicative function you compute from the prime exponents of n without ever forming n². Asking for the least n with more than a thousand solutions then reduces to a search over highly composite numbers, which is a tiny structured tree rather than a linear scan.

A factorisation can also give you the least solution directly. In Problem 955, a sequence jumps from one triangular number t(x) to the next. The size of each jump is the least j ≥ 1 with t(x) + t(j) = t(y). Multiplying by 8 and taking a difference of squares turns this into x(x+1) = p·q, where q − p = 2j + 1. The trivial pair (x, x+1) gives j = 0. The smallest real jump therefore comes from the factor pair closest to the trivial one, which is the largest suitable divisor of x(x+1) below x. Each step costs a factorisation of x and x + 1 separately (they are coprime) by Pollard's rho, so the method never scans gaps that reach into the trillions.

Factoring can also be what makes a condition such as "is prime" tractable. Problem 291 asks for primes p = (x⁴ − y⁴)/(x³ + y³). Cancel x + y, put x = ga and y = gb with a and b coprime, and coprimality forces the leftover denominator to divide g. The prime is then a product of three positive integers, so two of them must equal 1, and the two-variable equation collapses to the one-variable form p = n² + (n+1)². What remains is to count the primes among the values of a quadratic. A polynomial sieve handles this: an odd prime q divides some value only when −1 is a square mod q, which means q ≡ 1 (mod 4). Each such q then strikes exactly two residue classes of n. This is Eratosthenes run over the values of f(n) instead of over the integers.

Sometimes the number of solutions is already a known arithmetic function of the right-hand side. Then you never need to find the solutions themselves. The standard case is x² + y² = f. By Jacobi's two-square theorem, for odd f the count r₂(f)/4 is ∏(e + 1) over the primes p ≡ 1 (mod 4) in f. It is zero if any prime ≡ 3 (mod 4) appears to an odd power. The count is multiplicative, so it comes straight from the factorisation.

Problem 621 counts the ways to write n ≈ 1.75 × 10¹³ as a sum of three triangular numbers. A loop over pairs would take more than 10¹³ steps. Instead, fix the first term and multiply the other two by 8. The equation T_b + T_c = m becomes (2b+1)² + (2c+1)² = 8m + 2, so the remaining pairs are counted by r₂(4m + 1)/4. This leaves one search dimension and a function to evaluate at each point, and the problem becomes factoring about √(2n) values of one quadratic in the first index. That is Problem 291's polynomial sieve again. A prime p divides a value only in the residue classes given by the square roots of 8n + 3 mod p, which Tonelli–Shanks finds. The same identity also gives a free cross-check. It is Gauss's theorem that every number is a sum of three triangular numbers, and the full count is a class number that the analytic formula estimates to within parts per million.

Parametrise, then count whole families by division

When the question is how many solutions lie under a bound, generating them one by one is the slow way even after the algebra is done. The faster way is to parametrise the solution set so that each parameter choice stands for a whole family, and then count each family with a single division.

Problem 257 shows the cleanest form. Its area ratio becomes (a+b)(a+c) / bc. Before any search, notice that with a ≤ b ≤ c each of the two factors (a+b)/b and (a+c)/c lies in (1, 2]. An integer ratio can therefore only be 2, 3 or 4, so one open-ended equation becomes three fixed ones. Writing the first factor as a reduced fraction p/q turns each primitive triangle into a coprime pair (p, q). Every triangle is then that primitive shape scaled by some s, so a pair whose smallest member has perimeter L contributes ⌊N / L⌋ triangles in one step. The scaled copies are never visited.

The parametrisation usually comes from one lemma: if coprime factors multiply to a square, each factor is a square (up to a unit, or a factor of 2 you track separately). In Problem 518, three numbers are in geometric progression when y² = xz. Writing the ratio in lowest terms as q/p forces p² to divide x. That gives the complete and unique family (kp², kpq, kq²) with p and q coprime, so a pairwise divisibility search becomes a walk over three small parameters. Problem 764 uses the lemma twice. It reads 16x² + y⁴ = z² as a Pythagorean triple (4x, y², z) and takes the triple from Euclid's formula. Requiring the leg y² to be a square forces m ± n (when y is odd) or m and 2n (when y is even) to be squares themselves. The result is two quartic families in a coprime pair (a, b). Because z grows like the fourth power of the parameters, the enumeration costs O(N^{1/2}).

The same lemma works when the problem asks for a sum over solutions rather than a count. In Problem 510, three circles tangent to each other and to a line satisfy 1/√r_C = 1/√r_A + 1/√r_B, which is the line case of Descartes' theorem. Rationality forces r_A/r_B = (u/v)² with u and v coprime. Coprimality then forces (u + v)² to divide the scale, which gives the complete family t·(u²(u+v)², v²(u+v)², u²v²). The quantity asked for is linear in t, so the m multiples of a primitive solution contribute its total times m(m+1)/2. Looping over t would bring back the linear cost, because u = v = 1 alone has n/4 multiples.

A quadratic with one known rational point gives a family by a different route. Problem 962 reduces a bisector-and-tangent condition to g² − w² = D·m². The conic has the obvious point (1 : 1 : 0), and every line through it with rational slope β/α meets the conic in exactly one other rational point. That is the chord method, the same idea that produces Euclid's formula from the point (1, 0) on the unit circle. It yields (Dβ² + α², Dβ² − α², 2αβ)/δ, and each primitive solution is counted with ⌊N/L⌋ as before. The inner loop over α can also be removed. The divisor δ depends only on gcd(α, D) and the parity of the cofactor, so the admissible α in each class are counted by Möbius inclusion–exclusion over the primes of (D/γ)β. They are never enumerated one at a time.

A parametrised family can also be joined against itself. In Problem 309, crossed ladders reduce to two Pythagorean triples that share a leg w, together with the condition (a + b) | ab on the other legs. You first show that a and b must be integers: an irrational pair would make 1/h irrational. Then you generate every triple once with Euclid's formula, group the triples by their shared leg, and test pairs only within each group. Each leg belongs to only a handful of triples, so the quadratic pair test inside a group costs almost nothing.

Problem 998 uses the same join and adds a lesson about where the integers come from. The minimum bounding square of a triangle has its side at the lowest point of an envelope of sinusoids. A single arc bottoms out at L/√2, which is never an integer, so an integer side can only appear where two arcs cross. That leaves two configurations, and each is a set of Pythagorean triples sharing their longer leg. The minimality condition is a condition on angles, arctan(x/s) + arctan(y/s) ≥ 45°. The tangent addition formula turns it into the integer inequality s² − (x + y)s − xy ≤ 0. That rewrite is necessary, not just neat. A floating-point minimiser with a 10⁻¹¹ tolerance still accepts a family of triangles whose true side misses an integer by 3.6 × 10⁻¹³.

Problem 251 goes one step further. A condition on nested cube roots reduces, through the cubic that u + v satisfies, to the integer equation 27(a² − b²c) = (1 − 2a)³. Divisibility by 27 forces a ≡ 2 (mod 3). Splitting b against n by their gcd then leaves a family in which the remaining variable d is bounded above by a linear inequality and confined by a congruence to a single residue class. Counting the members of an arithmetic progression below a ceiling takes one line:

d_min = 3 * pow(8 * n1, -1, m) % m     # the one residue class the congruence allows
count += (D - d_min) // m + 1          # members of that class up to the ceiling D

The modular inverse exists only because the parametrisation made the pair coprime. That is the general pattern: a gcd split creates the coprimality, and the coprimality makes the congruence solvable. Problem 251 also has to choose its loop order. For small moduli the residue class is dense, so the loop walks one parameter. For large moduli the class is almost empty, so it walks the cofactor instead. Balancing the two costs puts the switch near L^{1/4}.

When the unknown is its own exponent, iterate to a fixed point

Some Diophantine conditions are congruences rather than equalities, and the unknown sits in the exponent. Problem 455 asks, for each base n, for the x < 10⁹ whose last nine digits of nˣ spell x itself, that is nˣ ≡ x (mod 10⁹). Nothing factors and no recurrence applies, and a scan over 10⁹ exponents for each of a million bases is out of the question. The useful structure is that x is a fixed point of the map T(x) = nˣ mod 10⁹.

Iterating that map from x = 1 builds the power tower n, nⁿ, n^(nⁿ), … modulo 10⁹. Such towers become constant after a few levels. Once the exponent is large, nᵃ mod m depends only on a modulo the Carmichael function λ(m). The level below therefore only matters modulo λ(m), the one below that modulo λ(λ(m)), and the chain of moduli shrinks to 1 within a handful of steps. The settled value satisfies T(x) = x by construction, so a dozen rounds of fixed-point iteration replace the search. Each round is one modular exponentiation per base, and every base can be run in lockstep as a vectorised array. Two pieces of ordinary Diophantine reasoning finish the job. A divisibility argument rules out the multiples of ten before any iteration. If 10 | n, then nˣ ends in 0, so x must too. That makes x ≥ 10, so 10⁹ divides nˣ and forces x ≡ 0, which is excluded. Then the claim that the tower's limit is the largest solution, which the problem asks for, is not something the iteration proves. The solution checks it by exhaustive search on the scaled-down moduli 10³, 10⁴ and 10⁵ before relying on it.

Vieta jumping: the solutions form a tree

Some equations are quadratic in each variable taken separately. Then every solution has a neighbour. In the Markov-type equation x₁² + … + x_k² = k·x₁⋯x_k of Problem 844, fix all the variables but one. That one is a root of a quadratic, and by Vieta's formulas the other root kP − x is also a positive integer. Swapping one root for the other is Vieta jumping. If you always swap out the largest entry, the tuple shrinks down to a fundamental solution, which here is all ones. Run in the other direction, the same move makes every solution a node of a single tree, and the values only grow along each branch. A depth-first search pruned at the bound therefore lists every solution, and the tree has only O(log² N) nodes because the values grow doubly exponentially. The problem has one more layer, a sum over k up to 10¹⁸. The tree has the same shape for every large k, so each node is a fixed polynomial in k. The sum over k then becomes a few dozen power sums instead of 10¹⁸ trees.

When the function is injective, solve by structure

In some problems the arithmetic turns out to carry no information at all. Problem 674 asks when two nested expressions in I(x, y) = (1+x+y)² + y − x are equal. For a fixed s = x + y, the values of I fill a window around (s+1)², and the windows for different s never overlap. So I is injective on non-negative pairs, much like a pairing function, and two expressions are equal exactly when their trees match after the variables are substituted. Solving the equation is then first-order unification: union-find over a hash-consed term DAG, with an occurs check to reject equations like x = I(x, z). I increases in each argument, so the least solution is the most general unifier with every free variable set to 0. The lesson is to ask, before computing anything, whether the equation holds only for identical inputs.

When no structure appears, choose the side you search from

Not every Diophantine question gives way to algebra. Problem 348 asks for palindromes that can be written as a² + b³ in exactly four ways. Being a palindrome is a property of base-10 digits, and the number of representations has no closed form, so nothing reduces. What remains is a choice of direction. You can test each target (palindromes, then every cube, then a perfect-square check on the remainder), or you can generate every pair (a, b) and filter the sums. Both cost O(N^{5/6}), but pair generation needs no square roots. For a fixed b the sums also form a contiguous run that NumPy can produce and filter as one array. The unknown bound is handled by scanning one decimal-length band [10^{d−1}, 10^d) at a time, since each finished band gives its palindromes completely and in order. Even here the integer view matters: a 64-bit a² + b³ limits the method to 18 digits, and the solution enforces that with an explicit guard.

How to reason about one

When a problem admits only integer answers — and most Project Euler problems do — treat it as a Diophantine equation and work through these questions before writing any loop:

  • Normalise first. Clear denominators, complete the square, substitute. The messy statement almost always hides one of a few canonical forms: linear, Pell/Pell-like, or something that factors.
  • Is there a linear constraint to spend? Each one eliminates a variable and a loop level. If the unknowns must be non-negative, it is a Frobenius problem: count the gaps per residue class with the Apéry set, never one by one. With two generators, give each gap coordinates (i, j). Reachability between gaps is then dominance, a partial order you can run a DP over.
  • Does it become x² - Dy² = N? Then the solutions form a recurrence-generated family; find the fundamental solution (by inspection, or via continued fractions) and iterate. Never bound the loop by the size of the answer. If N ≠ ±1, there are several orbits: find one seed per orbit within a single period of the unit's action. A family of Pell equations with Lehmer's bounds can also show that a smoothness search is finite.
  • Does it factor? If you can force a product (…)(…) = k, counting solutions becomes counting divisors of k, and the problem turns into a factorisation question. The divisor nearest the trivial one gives the least solution. A prime equal to a product forces every factor but one to be 1.
  • Is the count a known arithmetic function? Representations as a sum of two squares are counted by a multiplicative formula. Factor the right-hand side, or sieve it across a polynomial, and never list the representations.
  • Do coprime factors multiply to a square? Then each factor is a square, and the solutions are parametrised by a coprime pair. For a conic with one rational point, draw lines through that point. Their rational slopes parametrise the other points.
  • Is it quadratic in each variable? Vieta jumping links the solutions into a tree rooted at a fundamental solution, and a pruned DFS walks all of it.
  • Is the operation injective? Then equality means the expression trees match: unify them instead of doing arithmetic.
  • Can an inequality bound the unknown value? If the sides are ordered, a ratio or quotient often fits in a small interval (Problem 257's (1, 4]). One open equation then becomes a few fixed ones.
  • Counting, not listing? Parametrise by primitive solutions, usually coprime pairs, and count each family's members with ⌊N / L⌋ or a residue-class count. Do not enumerate them. If you are summing a quantity linear in the scale, the multiples add up to a triangular number.
  • Is the unknown in the exponent of a congruence? Look for a fixed point. Iterating x ← nˣ mod m settles quickly because the Carmichael chain m, λ(m), λ(λ(m)), … is short. Verify on small moduli that the limit is the solution the problem wants.
  • Nothing reduces? Pick the search direction by its constant factors as well as its exponent. Generating the solutions and filtering them can beat testing the targets when it avoids roots and vectorises.
  • Mind the integers themselves. Solutions grow geometrically; a 64-bit type overflows fast. Know whether your language gives you big integers for free (Python) or whether you must carry them yourself (C), and prefer exact integer tests over floating-point ones — a Diophantine equality checked with a tolerance is a bug waiting to happen. Problem 998 shows that this is a real risk: near-miss triangles miss an integer by less than 10⁻¹², so turn angle and root conditions into integer polynomial inequalities. Watch the intermediates too. The C port of Problem 251 silently wrapped a product n₁²·e used only in a bound test, and the count came out too high. The fix was to compare n₁ with a precomputed integer-square-root cap so the product is never formed.

When the algebra works, the payoff is the same trade every time: a moment of algebra up front buys an algorithm whose cost depends on the structure of the solution set, not on how large the numbers get. When it does not work, as in Problem 348, the same integer discipline still shapes the search.

Problems44 / 86

  • ● 0009 — Special Pythagorean Triplet
  • ● 0066 — Diophantine Equation
  • ● 0094 — Almost Equilateral Triangles
  • ● 0100 — Arranged Probability
  • ● 0108 — Diophantine Reciprocals I
  • ● 0110 — Diophantine Reciprocals II
  • ● 0131 — Prime Cube Partnership
  • ● 0135 — Same Differences
  • ● 0136 — Singleton Difference
  • ● 0137 — Fibonacci Golden Nuggets
  • ● 0138 — Special Isosceles Triangles
  • ● 0140 — Modified Fibonacci Golden Nuggets
  • ● 0142 — Perfect Square Collection
  • ● 0157 — Base-10 Diophantine Reciprocal
  • ● 0168 — Number Rotations
  • ● 0180 — Golden Triplets
  • ● 0221 — Alexandrian Integers
  • ● 0223 — Almost Right-angled Triangles I
  • ● 0236 — Luxury Hampers
  • ● 0251 — Cardano Triplets
  • ● 0257 — Angular Bisectors
  • ○ 0261 — Pivotal Square Sums
  • ○ 0278 — Linear Combinations of Semiprimes
  • ○ 0279 — Triangles with Integral Sides and an Integral Angle
  • ○ 0283 — Integer Sided Triangles with Integral Area/perimeter Ratio
  • ● 0291 — Panaitopol Primes
  • ○ 0296 — Angular Bisector and Tangent
  • ○ 0299 — Three Similar Triangles
  • ● 0309 — Integer Ladders
  • ○ 0311 — Biclinic Integral Quadrilaterals
  • ● 0313 — Sliding Game
  • ● 0348 — Sum of a Square and a Cube
  • ○ 0360 — Scary Sphere
  • ○ 0390 — Triangles with Non Rational Sides and Integral Area
  • ○ 0397 — Triangle on Parabola
  • ○ 0404 — Crisscross Ellipses
  • ○ 0410 — Circle and Tangent Line
  • ○ 0418 — Factorisation Triples
  • ○ 0428 — Necklace of Circles
  • ○ 0438 — Integer Part of Polynomial Equation's Solutions
  • ○ 0454 — Diophantine Reciprocals III
  • ● 0455 — Powers with Trailing Digits
  • ○ 0482 — The Incenter of a Triangle
  • ○ 0496 — Incenter and Circumcenter of Triangle
  • ● 0510 — Tangent Circles
  • ○ 0513 — Integral Median
  • ● 0518 — Prime Triples and Geometric Sequences
  • ○ 0528 — Constrained Sums
  • ○ 0557 — Cutting Triangles
  • ● 0581 — $47$-smooth Triangular Numbers
  • ● 0582 — Nearly Isosceles $120$ Degree Triangles
  • ○ 0583 — Heron Envelopes
  • ○ 0585 — Nested Square Roots
  • ○ 0620 — Planetary Gears
  • ● 0621 — Expressing an Integer as the Sum of Triangular Numbers
  • ○ 0647 — Linear Transformations of Polygonal Numbers
  • ○ 0660 — Pandigital Triangles
  • ● 0674 — Solving $\mathcal{I}$-equations
  • ● 0678 — Fermat-like Equations
  • ○ 0681 — Maximal Area
  • ● 0718 — Unreachable Numbers
  • ○ 0730 — Shifted Pythagorean Triples
  • ○ 0748 — Upside Down Diophantine Equation
  • ○ 0753 — Fermat Equation
  • ● 0757 — Stealthy Numbers
  • ● 0764 — Asymmetric Diophantine Equation
  • ○ 0769 — Binary Quadratic Form II
  • ○ 0784 — Reciprocal Pairs
  • ○ 0785 — Symmetric Diophantine Equation
  • ○ 0791 — Average and Variance
  • ○ 0799 — Pentagonal Puzzle
  • ● 0833 — Square Triangle Products
  • ○ 0835 — Supernatural Triangles
  • ● 0844 — $k$-Markov Numbers
  • ○ 0876 — Triplet Tricks
  • ○ 0877 — XOR-Equation A
  • ○ 0880 — Nested Radicals
  • ● 0883 — Remarkable Triangles
  • ○ 0919 — Fortunate Triangles
  • ● 0932 — $2025$
  • ○ 0945 — XOR-Equation C
  • ● 0955 — Finding Triangles
  • ● 0962 — Angular Bisector and Tangent 2
  • ● 0988 — Non-attacking Frogs
  • ○ 0991 — Fruit Salad
  • ● 0998 — Squaring the Triangle