by: Nick MacKinnon

Tagged: by: Nick MacKinnon Toggle Comment Threads | Keyboard Shortcuts

Jim Randell 8:13 am on 22 April 2026 Permalink | Reply
Tags: by: Lachlan MacKinnon, by: Nick MacKinnon
Teaser 2447: [Number grid]
From The Sunday Times, 16th August 2009 [link]

In this variation on a sudoku theme, your task is to find a particular 5-by-5 array of digits in which each row and each column use the same five consecutive digits. When completed, you can read five 5-digit numbers across the rows and a further five down the columns. These 10 numbers should all be different, and their product should be divisible by the fourth powers of 11, 10 and 9. The product should also be divisible by the fourth (but not the fifth) power of 8.

What are the lowest and highest of your 10 numbers?

This puzzle was originally published with no title.

[teaser2447]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 8:14 am on 22 April 2026 Permalink | Reply
  The overall product is divisible by 9^4 (= 3^8), so at least one of the numbers is divisible by 3, and as the numbers are rearrangements of each other, they must all be divisible by 3. (And so the final product will have a divisor of at least 3^10).
  
  We can fill out a grid using the digits 0-4 (allowing leading zeros), and than add the same value (between 0 and 5) to each digit to form a candidate grid.
  
  The sum of the digits 0-4 is 10, and if this combines with 5 copies of the additional digit to give a multiple of 3 then the additional digit can only be 1 or 4.
  
  This is the approach taken with the following run file, using the [[ SubstitutedExpression ]] solver from the enigma.py library.
  
  It executes in 661ms. (Internal runtime of the generated code is 448ms (using PyPy 7.3.21)).
```
#! python3 -m enigma -rr

SubstitutedExpression

#  A B C D E
#  F G H I J
#  K L M N O
#  P Q R S T
#  U V W X Y
#
# and each number is increased by: ZZZZZ

--macro="@rows = ABCDE, FGHIJ, KLMNO, PQRST, UVWXY"
--macro="@cols = AFKPU, BGLQV, CHMRW, DINSX, EJOTY"
--macro="@nums = [@rows, @cols]"

# rows and cols are rearrangements of the same 5 digits
--distinct="ABCDE,FGHIJ,KLMNO,PQRST,UVWXY,AFKPU,BGLQV,CHMRW,DINSX,EJOTY"

# numbers are formed from 5 consecutive digits
# so the numbers in the grid are formed from 0-4
# and the base (Z) is 1 or 4
--digits="0-4"
--invalid="0|2|3,Z"

# the numbers are all different
"seq_all_different(@nums)"

# check divisibility
--code="""
D = mlcm(8**4, 9**4, 10**4, 11**4)  # product is divisible by D
X = 8**5  # but not X
def check(ns, b=0):
  p = multiply(n + b for n in ns)
  return (p % D == 0) and (p % X != 0)
"""
"check(@nums, ZZZZZ)"

# remove duplication
"ABCDE < AFKPU"

--template=""
--denest=-30  # CPython workaround
```
  Solution: The lowest of the numbers is: 45768. And the highest is: 86547.
  
  The prime factors are:
  
  74856 = (2^3)(3)(3119)
  68475 = (3)(5^2)(11)(83)
  86547 = (3)(17)(1697)
  57684 = (2^2)(3)(11)(19)(23)
  45768 = (2^3)(3)(1907)
  
  76854 = (2)(3)(12809)
  48675 = (3)(5^2)(11)(59)
  84567 = (3)(7)(4027)
  57486 = (2)(3)(11)(13)(67)
  65748 = (2^2)(3)(5479)
  
  These combine to give an overall product with the following repeated prime factors:
  
  (2^12)(3^10)(5^4)(11^4)
  
  In the published solution the lowest number was given as 45678, but this is likely to have been a typo.
  
  LikeLike
Reply Cancel reply
Required fields are marked *

Name *

Email *

Website

Notify me of new comments via email.
Notify me of new posts via email.
Δ
Jim Randell 10:41 am on 8 April 2026 Permalink | Reply
Tags: by: Nick MacKinnon, flawed ( 55 )
Teaser 2438: [Nested quadrilaterals]
From The Sunday Times, 14th June 2009 [link]

Quadrilateral A has its vertices on a circle, and no two angles are the same. Another circle is drawn inside A that touches its sides at four points, and these points form the corners of Quadrilateral B. Then Quadrilateral C is formed inside B in the same way, and so on.

Quadrilateral K’s angles are whole numbers of degrees.

What (in increasing order) are Quadrilateral A’s angles?

This puzzle was originally published with no title.

[teaser2438]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 10:42 am on 8 April 2026 Permalink | Reply
  
  A quadrilateral that has a circumcircle (i.e. a circle that passes through each of the vertices) is called a cyclic quadrilateral.
  
  A quadrilateral is cyclic if (and only if) opposite internal angles are supplementary (i.e. if the angles at the vertices are (𝛂, 𝛃, 𝛄, 𝛅) we have: 𝛂 + 𝛄 = 𝛃 + 𝛅 = 180°).
  
  A quadrilateral that has a incircle (i.e. a circle inscribed inside the quadrilateral that touches all four sides) is called a tangential quadrilateral.
  
  A quadrilateral is tangential if (and only if) opposite sides sum to the same total length (i.e. if the length of the sides are (a, b, c, d) we have: a + c = b + d).
  
  Note that the condition for a tangential quadrilateral is more restrictive than the condition for a cyclic quadrilateral. For example, all rectangles (all internal angles = 90°) are cyclic, but only squares are tangential.
  
  A quadrilateral that is both cyclic and tangential is called bicentric.
  
  This puzzle concerns a series of nested bicentric quadrilaterals.
  
  Consider a bicentric quadrilateral ABCD. The tangential points on the incircle form the contact quadrilateral WXYZ. (Such that W is on AB, X on BC, Y on CD, Z on DA).
  
  Considering the internal angles of the ABCD quadrilateral (as a, b, c, d), the tangent lengths from a vertex to the vertices of the the contact quadrilateral are equal (see: Pitot Theorem), and so the angle subtended at the incentre of the contact quadrilateral (I) is supplementary to the internal angle of the original quadrilateral. (And so it is the same as the opposite internal angle of the original quadrilateral):
  
  ∠ZIW = 180° − a = c
  ∠WIX = 180° − b = d
  ∠XIY = 180° − c = a
  ∠YIZ = 180° − d = b
  
  (Note that knowing the angles subtended at the centre of the incircle means we can fully determine the shape of the contact quadrilateral, and we can then draw the tangents to the vertices of the contact quadrilateral to find the original quadrilateral (which has opposite angles supplementary, and so is necessarily cyclic). [*]
  
  And so, each internal angle of the contact quadrilateral is the mean of the internal angles at the vertices on the original quadrilateral at either end of the tangent side:
  
  w = (a + b) / 2
  x = (b + c) / 2
  y = (c + d) / 2
  z = (d + a) / 2
  
  So, if the original angles are (a, b, c, d), then the final angles (a′, b′, c′, d′) after 10 applications of this transformation are:
  
  a′ = (16a + 17b + 16c + 15d) / 64
  b′ = (15a + 16b + 17c + 16d) / 64
  c′ = (16a + 15b + 16c + 17d) / 64
  d′ = (17a + 16b + 15c + 16d) / 64
  
  And remembering a + c = 180°, and b + d = 180°, we get:
  
  a′ = 87 + (6 + b)/32
  b′ = 92 + (26 − a)/32
  c′ = 92 + (26 − b)/32
  d′ = 87 + (6 + a)/32
  
  And these are integers.
  
  So, if we assume a and b are angles where 0° < a < b < 90°, we get:
  
  a = 26°, b = 58°, c = 154°, d = 122°
  ⇒
  a′ = 89°, b′ = 92°, c′ = 91°, d′ = 88°
  
  Solution: The angles in the original quadrilateral were: 26°, 58°, 122°, 154°.
  
  Calculating successive internal angles we get:
  
  A: 26°, 58°, 154°, 122°.
  B: 42°, 106°, 138°, 74°.
  C: 74°, 122°, 106°, 58°.
  D: 98°, 114°, 82°, 66°.
  E: 106°, 98°, 74°, 82°.
  F: 102°, 86°, 78°, 94°.
  G: 94°, 82°, 86°, 98°.
  H: 88°, 84°, 92°, 96°.
  I: 86°, 88°, 94°, 92°.
  J: 87°, 91°, 93°, 89°.
  K: 89°, 92°, 91°, 88°.
  
  Note that the angles are approaching 90°, and a square forms a stable scenario, which can be extended in either direction indefinitely.
  
  The sequence would continue:
  
  L: 90.5°, 91.5°, 89.5°, 88.5°.
  M: 91°, 90.5°, 89°, 89.5°.
  N: 90.75°, 89.75°, 89.25°, 90.25°.
  O: 90.25°, 89.5°, 89.75°, 90.5°.
  P: 89.875°, 89.625°, 90.125°, 90.375°.
  Q: 89.75°, 89.875°, 90.25°, 90.125°.
  R: 89.8125°, 90.0625°, 90.1875°, 89.9375°.
  …
  
  by which time the angles are all within 0.2° of 90°.
  
  However if we attempt to actually construct the series of nested quadrilaterals we run into a problem.
  
  From [*] we know that if the internal angles of quadrilateral A are: (26°, 58°, 154°, 122°), then the angles subtended at the centre of the contact quadrilateral (= quadrilateral B) are: (122°, 26°, 58°, 154°), and this is enough information to draw quadrilateral B inside a circle, and then construct quadrilateral A outside the circle.
  
  If we do so we get this:
  
  (quadrilateral A is red; quadrilateral B is black).
  
  Similarly, knowing the internal angles of quadrilateral B are: (42°, 106°, 138°, 74°), then the angles subtended at the centre of quadrilateral C are: (74°, 42°, 106°, 138°), and drawing quadrilaterals C and B we get this:
  
  (quadrilateral B is red; quadrilateral C is black).
  
  And, although the two quadrilaterals B in the diagrams look superficially similar (as they have the same angles), they are not mathematically similar, so the second cannot be uniformly scaled to fit onto the first. (The easy way to see this is that the distance between the 106° and 138° angles in the second diagram is longer than if the first diagram was scaled so as to fit the opposite side over the corresponding side in the first diagram. It is as if a strip parallel to that side has been removed (keeping the angles the same)).
  
  Here are the two quadrilaterals B superimposed:
  
  (Note the extra red line where one side of the red (smaller) quad B does not overlap the black quad B, and the inscribed circle does not touch all four sides of the black quad B).
  
  So, practically it is not possible to construct such a sequence of quadrilaterals.
  
  Hence the puzzle itself is flawed.
  
  LikeLike
  - Jim Randell 2:44 pm on 8 April 2026 Permalink | Reply
    
    Although I have not found a correction printed in The Sunday Times, this puzzle did prompt an article by Victor Bryant (editor of Teaser puzzles at the time) and John Duncan, showing that if a nest of 3 bicentric quadrilaterals can be made, then they are necessarily all squares.
    
    “Wheels within wheels”, Victor Bryant, John Duncan
    The Mathematical Gazette, Volume 94, Issue 531, November 2010, pp. 502 – 505
    https://www.jstor.org/stable/25759740
    
    LikeLike
Jim Randell 8:39 am on 3 April 2026 Permalink | Reply
Tags: by: Nick MacKinnon
Teaser 2443: [Phone masts]
From The Sunday Times, 19th July 2009 [link]

Six phone masts, A to F, are each 24 miles from the base station, and clockwise they form a hexagon, ABCDEF. In degrees, the angles in the hexagon are such that A is not more than B, which is not more than C; and so on. The angle at A is a prime; the angle at C is the average of those at A and E; the angle at D is the average of those at B and F; and the angle at E is a perfect square.

What are the six angles, and how far is the base station from the line BD?

This puzzle was originally published with no title.

[teaser2443]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 8:40 am on 3 April 2026 Permalink | Reply
  
  In a hexagon the internal angles sum to 720°.
  
  In a cyclic hexagon the total sum of alternate internal angles is equal:
  
  A + B + C + D + E + F = 720°
  A + C + E = B + D + F = 360°
  
  Also C is the mean of A and E, and D is the mean of B and F, so:
  
  A + E = B + F = 240°
  C = D = 120°
  
  We are looking for a square E ≥ 120 such that (240 − E) is a prime number, and there are only a few candidates to check:
  
  E = 11² = 121; A = 119 = 7×17 (not prime)
  E = 12² = 144; A = 96 = (2^5)×3 (not prime)
  E = 13² = 169; A = 71 (prime)
  E = 14² = 196; A = 44 = (2^2)×11 (not prime)
  E = 15² = 225; A = 15 = 3×5 (not prime)
  
  There is only one viable (A, E) pair, so:
  
  A = 71°
  B = B
  C = 120°
  D = 120°
  E = 169°
  F = 240° − B
  
  Now B must lie between 71° and 120°, so:
  
  71° ≤ B ≤ 120° ⇒ 120° ≤ F ≤ 169°
  
  But F ≥ 169°, so we must have F = 169°, and so B = 71°.
  
  Hence the angles are fully determined:
  
  A = 71°
  B = 71°
  C = 120°
  D = 120°
  E = 169°
  F = 169°
  
  If the centre of the circle is X, and we say the angles subtended at X by the chords AB, BC, CD, DE, EF, FA are a, b, c, d, e, f, then we can show:
  
  a = 218° − u
  b = u
  c = 120° − u
  d = u
  e = 22° − u
  f = u
  
  To make the smallest angle as large as possible we can set u = 11°, to get the angles subtended at the centre to be (207°, 11°, 109°, 11°, 11°, 11°). Which gives a layout like this:
  
  (But we could make a valid hexagon for any real value 0° < u < 22°).
  
  In particular the angle subtended at the centre of the circle by the chord BD is b + c = (u + (120° − u)) = 120°.
  
  And so, considering the isosceles triangle BXD, the distance from the line BD to the centre of the circle is:
  
  d = 24 cos(120°/2)
  d = 24 cos(60°)
  d = 12
  
  Solution: The angles are: 71°, 71°, 120°, 120°, 169°, 169°. The minimum distance from the base station to the line BD is 12 miles.
  
  LikeLike
Jim Randell 7:29 am on 13 March 2026 Permalink | Reply
Tags: by: Nick MacKinnon
Teaser 2452: [Cubic time]
From The Sunday Times, 20th September 2009 [link]

The time and date 19:36, 24/08/57, uses all 10 digits. Furthermore, the product of the five constituent numbers is a perfect square (namely the square of 2736).

19 × 36 × 24 × 08 × 57 = 7485696 = 2736²

There are many times and dates that have this property. However, there is only one time and date that uses all 10 digits, and where the product of the five constituent numbers is a perfect cube.

What is that time and date?

This puzzle was originally published with no title.

[teaser2452]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
ruudvanderham and Jim Randell are discussing. Toggle Comments
- Jim Randell 7:30 am on 13 March 2026 Permalink | Reply
  The following run file executes in 105ms. (Internal runtime of the generated code is 22ms).
```
#! python3 -m enigma -rr

SubstitutedExpression

--invalid=""

"is_cube(AB * CD * EF * GH * IJ)"

# limits on the ranges
"AB < 24"  # hour
"CD < 60"  # minute
"0 < EF < 32"  # day
"0 < GH < 13"  # month

--answer="(AB, CD, EF, GH, IJ)"
```
  Solution: The time/date is: 13:54, 26/09/78.
  
  i.e. 1:54pm on 26th September 1978.
  
  And:
  
  13 × 54 × 26 × 09 × 78 = 12812904 = 234³
  or:
  (13) × (2×3×3×3) × (2×13) × (3×3) × (2×3×13) = (2×3×3×13)³
  
  The code doesn’t check that a valid date is produced, but it easy to see that the only candidate solution corresponds to a valid date, so such a check is not necessary.
  
  LikeLike
- ruudvanderham 2:22 pm on 13 March 2026 Permalink | Reply
  This code checks only valid dates:
```
import peek
import istr

number_of_days_in_month = [None, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
istr.int_format("02")

for hour in istr.range(24):
    if hour.all_distinct():
        for minute in istr.range(60):
            if (hour | minute).all_distinct():
                for year in istr.range(100):
                    if (hour | minute | year).all_distinct():
                        for month in istr.range(1, 13):
                            if (hour | minute | year | month).all_distinct():
                                for day in istr.range(number_of_days_in_month[int(month)] + 1):
                                    if (hour | minute | year | month | day).all_distinct():
                                        if (hour * minute * year * month * day).is_cube():
                                            peek(hour, minute, year, month, day)
```
  LikeLike
- ruudvanderham 4:46 pm on 13 March 2026 Permalink | Reply
  Here is a recursive version (that doesn’t check for valid dates):
```
import istr

istr.int_format("02")

def solve(sofar, ranges):
    if ranges:
        for i in ranges[0]:
            if (sofar | i).all_distinct():
                solve(sofar | i, ranges[1:])
    else:
        if (sofar[0:2] * sofar[2:4] * sofar[4:6] * sofar[6:8] * sofar[8:10]).is_cube():
            print(f"{sofar[0:2]}:{sofar[2:4]} {sofar[4:6]}/{sofar[6:8]}/{sofar[8:10]}")


solve(istr(""), [istr.range(24), istr.range(60), istr.range(1, 32), istr.range(1, 13), istr.range(100)])
```
  LikeLike
Jim Randell 9:34 am on 3 February 2026 Permalink | Reply
Tags: by: Nick MacKinnon, flawed ( 55 )
Teaser 2461: [Football league]
From The Sunday Times, 22nd November 2009 [link]

The saying “Most teams lose most of the time” was true of our league last season. Five teams, Albion, Broncos, City, Devils and Eagles, play each other once, earning three points for a win, one for a draw. Albion won and the teams ended in alphabetical order, the positions of teams tying on points determined by goal difference. Albion’s goal difference was four times the Broncos’. No match scores were the same; 32 goals were scored; City scored none against Albion; and Devils scored four different consecutive numbers of goals.

What were the scores in the four Devils’ games (DvA, DvB, DvC, DvE)?

Although this puzzle can be solved there are two possible answers (although only one of them was given when the solution was published in The Sunday Times).

This puzzle was originally published with no title.

[teaser2461]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 9:35 am on 3 February 2026 Permalink | Reply
  There are 5 teams in the league, so each team plays 4 matches. For a team to “lose most of the time”, they would have to lose at least 3 of their 4 matches. And for “most teams to lose most of the time”, there have to be at least 3 teams that lost at least 3 of their matches.
  
  So, of the 10 matches in the tournament, at least 9 of them must be lost/won, i.e. there can be at most 1 drawn match.
  
  All the scores in the matches must be different, so in increasing numbers of total goals scored in lost/won match we have the possible following scorelines:
  
  1: 1-0
  2: 2-0
  3: 3-0, 2-1
  4: 4-0, 3-1
  5: 5-0, 4-1, 3-2
  
  At this point, we have identified 9 matches, and the total number of goals scored in them is 32. So all these must take place, and the remaining match must be a 0-0 draw. And we have identified the scores in all of the 10 matches.
  
  This Python program allocates the scores to the matches. It runs in 20s (using PyPy).
```
from enigma import (Football, subsets, diff, cproduct, ordered, is_consecutive, printf)

# scoring system
football = Football(games="wdl", points=dict(w=3, d=1))

# scores in the 10 matches; all different, and 32 goals scored in total
scores = [(1, 0), (2, 0), (3, 0), (2, 1), (4, 0), (3, 1), (5, 0), (4, 1), (3, 2), (0, 0)]
assert sum(x + y for (x, y) in scores) == 32

# allocate <k> scores from <scs>
def allocate(k, scs):
  for ss in subsets(scs, size=k, select='P'):
    rs = diff(scs, ss)
    for xys in cproduct({(x, y), (y, x)} for (x, y) in ss):
      yield (xys, rs)

# calculate the table and goal difference from a sequence of scores
def table(ss, ts):
  T = football.table(football.outcomes(ss), ts)
  (f, a) = football.goals(ss, ts)
  return (T, f - a)

# X did better than Y
def better(ptsX, ptsY, gdX, gdY):
  return ptsX > ptsY or (ptsX == ptsY and gdX > gdY)

# choose the scores in D's matches
for ((AD, BD, CD, DE), scs1) in allocate(4, scores):
  # D's goals in each match must be consecutive (in some order)
  if not is_consecutive(ordered(AD[1], BD[1], CD[1], DE[0])): continue
  # calculate the table for D
  (D, gdD) = table([AD, BD, CD, DE], [1, 1, 1, 0])

  # choose the scores in C's matches
  for ((AC, BC, CE), scs2) in allocate(3, scs1):
    # C scored 0 goals in the A v C match
    if not (AC[1] == 0): continue
    # calculate the table for C
    (C, gdC) = table([AC, BC, CD, CE], [1, 1, 0, 0])
    # C did better than D
    if not better(C.points, D.points, gdC, gdD): continue

    # choose the scores in B's matches
    for ((AB, BE), scs3) in allocate(2, scs2):
      # calculate the table for B
      (B, gdB) = table([AB, BC, BD, BE], [1, 0, 0, 0])
      # B did better than C
      if not better(B.points, C.points, gdB, gdC): continue

      # allocate the remaining match
      for ([AE], _) in allocate(1, scs3):
        # calculate the table for A
        (A, gdA) = table([AB, AC, AD, AE], [0, 0, 0, 0])
        # A did better than B
        if not better(A.points, B.points, gdA, gdB): continue
        # A's goal difference is 4 times B's
        if not (gdA == 4 * gdB): continue

        # calculate the table for E
        (E, gdE) = table([AE, BE, CE, DE], [1, 1, 1, 1])
        # D is higher than E
        if not better(D.points, E.points, gdD, gdE): continue

        # at least 3 teams lost at least 3 matches
        if not sum(X.l >= 3 for X in [A, B, C, D, E]) >= 3: continue

        # output scenario
        printf("AB={AB} AC={AC} AD={AD} AE={AE} BC={BC} BD={BD} BE={BE} CD={CD} CE={CE} DE={DE}")
        printf("A={A} gd={gdA}")
        printf("B={B} gd={gdB}")
        printf("C={C} gd={gdC}")
        printf("D={D} gd={gdD}")
        printf("E={E} gd={gdE}")
        printf()
```
  Solution: There are two possible answers:
  
  DvA = 0-3; DvB = 2-3; DvC = 1-4; DvE = 3-1
  DvA = 1-4; DvB = 2-3; DvC = 0-3; DvE = 3-1
  
  Only the first of these was given in the published solution.
  
  These correspond to the following 4 scenarios:
  
  AvB = 0-0; AvC = 4-0; AvD = 3-0; AvE = 5-0; BvC = 2-1; BvD = 3-2; BvE = 1-0; CvD = 4-1; CvE = 0-2; DvE = 3-1
  AvB = 0-0; AvC = 4-0; AvD = 3-0; AvE = 5-0; BvC = 1-0; BvD = 3-2; BvE = 2-1; CvD = 4-1; CvE = 0-2; DvE = 3-1
  AvB = 0-0; AvC = 4-0; AvD = 4-1; AvE = 5-0; BvC = 2-1; BvD = 3-2; BvE = 1-0; CvD = 3-0; CvE = 0-2; DvE = 3-1
  AvB = 0-0; AvC = 4-0; AvD = 4-1; AvE = 5-0; BvC = 1-0; BvD = 3-2; BvE = 2-1; CvD = 3-0; CvE = 0-2; DvE = 3-1
  
  i.e. the order of {AvD, CvD} = {3-0, 4-1} and {BvC, BvE} = {2-1, 1-0} is not determined.
  
  But in each case the final table is:
  
  1st: A → 3w1d = 10 points; goal diff = 12
  2nd: B → 3w1d = 10 points; goal diff = 3
  3rd: C → 1w3l = 3 points; goal diff = −4
  4th: D → 1w3l = 3 points; goal diff = −5
  5th: E → 1w3l = 3 points; goal diff = −6
  
  With teams C, D, E (i.e. “most teams”) having lost 3 of their matches (i.e. “lost most of the time”).
  
  LikeLike
Jim Randell 9:16 am on 20 January 2026 Permalink | Reply
Tags: by: Nick MacKinnon
Teaser 2363: [A round number]
From The Sunday Times, 6th January 2008 [link]

We are used to thinking of 1,000 as a “round number”, but this is very much based on 10. One definition of a round number is that it should have lots of small factors, and certainly that it should be divisible by every number up to and including sixteen. There is one such round number that, when written in a certain base (of less than 10,000), looks like 1111. What is more, its base can be found very neatly.

What is that base?

This puzzle was originally published with no title.

[teaser2363]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Frits, Jim Randell, and Ruud are discussing. Toggle Comments
- Jim Randell 9:17 am on 20 January 2026 Permalink | Reply
  Programatically, it is straightforward to just try all possible bases.
  
  This Python program runs in 75ms. (Internal runtime is 4.2ms).
```
from enigma import (irange, mlcm, call, nconcat, printf)

# M = LCM(2..16)
M = call(mlcm, irange(2, 16))

# consider possible bases
for b in irange(2, 9999):
  # n = 1111 [base b]
  n = nconcat([1, 1, 1, 1], base=b)
  # check for divisibility by 2..16
  if n % M == 0:
    # output solution
    printf("base={b} n={n}")
```
  But here is a more sophisticated approach:
  
  Another way to write 1111 [base b] is: b³ + b² + b + 1, which is an integer valued polynomial function.
  
  And this means we can use the [[ poly_roots_mod() ]] solver from the enigma.py library (described here: [ link ]) to solve the puzzle.
  
  The following Python program has an internal runtime of 572µs.
```
from enigma import (Polynomial, rev, irange, mlcm, call, poly_roots_mod, printf)

# calculate 1111 [base b]
p = Polynomial(rev([1, 1, 1, 1]))

# M = LCM(2..16)
M = call(mlcm, irange(2, 16))

# find roots of p(b) = 0 [mod M] that give a valid base
roots = poly_roots_mod(p, 0)
for b in roots(M):
  if 1 < b < 10000:
    # calculate the corresponding n value
    n = p(b)
    # output solution
    printf("base={b} n={n}")
```
  Solution: The base is 5543.
  
  And the round number is: 1111 [base 5543] = 170338568400 [decimal] = 720720 × 236345.
  
  LikeLike
- Ruud 10:52 am on 20 January 2026 Permalink | Reply
```
import istr

print(*(base for base in istr.range(2, 10000) if all(sum(base**i for i in range(4)).is_divisible_by(i) for i in range(2, 17))))
```
  LikeLike
- Frits 8:33 am on 21 January 2026 Permalink | Reply
```
# 1111 [base b] is: b^3 + b^2 + b + 1 or (b + 1)(b^2 + 1)
# I am not good at modular arithmetic but b^2 + 1 is never a multiple of
# numbers 4.k + 3. So b + 1 must be divisible by 3, 7 and 11 and thus by 231.

for b1 in range(231, 10001, 231):
  # calculate n = 1111 [base b]
  b = b1 - 1
  n = b1 * (b**2 + 1)
  # n must be divisible by numbers 2-16
  if any(n % i for i in [9, 11, 13, 14, 15, 16]): continue
  print("answer:", b)
```
  LikeLike
  - Jim Randell 9:11 am on 21 January 2026 Permalink | Reply
    @Frits: A neat bit of analysis. That is probably the kind of approach the setter had in mind.
    
    In fact as (b² + 1) is not divisible by 3, then it is also not divisible by 9, so we can proceed in steps of: 9 × 7 × 11 = 693, which only needs 14 iterations.
    
    This Python program has an internal runtime of 34µs:
```
from enigma import (irange, printf)

S = 9 * 7 * 11
R = 720720 // S
for i in irange(S, 10000, step=S):
  b = i - 1
  n = i * (b*b + 1)
  if n % R == 0:
    printf("base={b} n={n}")
```
    LikeLike
    - Jim Randell 9:40 am on 21 January 2026 Permalink | Reply
      
      In fact although (b² + 1) may be divisible by 2, it cannot be divisible by 4, so we can move in steps of:
      
      S = 8 × 9 × 7 × 11 = 5544
      
      And, as the base is limited to be less than 10000, there is only one value to check (or if we accept that there is a solution to the puzzle, then there are no values to check).
      
      LikeLike
      - Frits 1:10 pm on 21 January 2026 Permalink | Reply
        
        @Jim, good work.
        
        if b is even then b=2k and b^2 + 1 = 4k^2 + 1
        if b is odd then b = 2k+1 and b^2 + 1 = 4k^2 + 4k + 2
        
        so indeed b^2 + 1 cannot be divisible by 4.
        
        LikeLike

Jim Randell 8:55 am on 2 December 2025 Permalink | Reply
Tags: by: Nick MacKinnon

Teaser 2469: [Football league]

From The Sunday Times, 17th January 2010 [link]

Our football league has six teams, A, B, C, D, E and F, who play each other once, earning 3 points for a win, 1 for a draw. Of last season’s 20 goals, the best were in Primadona’s hat-trick in C’s derby against D. At one stage, when C and D had played all their games, but A and B each still had two in hand, the league order was A, B, C, D, E, F (goal differences separate teams tying on points). But A’s morale was shattered because, in the end, C won the league (the number of goals scored also being needed for the final decision).

What were the scores in C’s matches? (C v A, C v B, C v D, C v E, C v F)?

This puzzle was originally published with no title.

[teaser2469]

Jim Randell 8:55 am on 2 December 2025 Permalink | Reply

The wording of the puzzle suggests that in the final order C had the same points and goal difference as (at least) one of the other teams, and was declared winner based on goals scored.

I think this puzzle (and probably Teaser 2516) are more easily dealt with manually. But there is a certain challenge in constructing a programmatic solution.

My program adopts the following strategy:

[1] Allocate match outcomes for the “one stage”, when C & D have played all their matches, A & B have 2 to play, the league order is A, B, C, D, E, F.

[2] Allocate the remaining match outcomes such that C is at the top of the table.

[3] Allocate goals to the outcomes such that 3 goals are scored by (at least) one side in the CvD match.

[4] Allocate any remaining goals, so that 20 goals are allocated in total.

[5] Check C wins the league (but has the same points and goal difference as another team) and that the ordering of “one stage” is valid.

It runs in 5.3s (using PyPy).

from enigma import (Football, subsets, update, cproduct, peek, is_decreasing, zip_eq, join, printf)

# scoring system
football = Football(games="wdlx", points=dict(w=3, d=1))

teams = "ABCDEF"
keys = sorted(x + y for (x, y) in subsets(teams, size=2))

# find keys for each of the teams
dks = dict((t, list(k for k in keys if t in k)) for t in teams)

# allocate match outcomes for the "one stage"
def stage1():
  # C and D have played all their games
  for (AD, BD, CD, DE, DF) in football.games("wdl", repeat=5):
    D = football.table([AD, BD, CD, DE, DF], [1, 1, 1, 0, 0])
    for (AC, BC, CE, CF) in football.games("wdl", repeat=4):
      C = football.table([AC, BC, CD, CE, CF], [1, 1, 0, 0, 0])
      if not (C.points >= D.points): continue

      # A and B each have two games unplayed (x)
      for (AB, BE, BF) in football.games("wdlx", repeat=3):
        B = football.table([AB, BC, BD, BE, BF], [1, 0, 0, 0, 0])
        if not (B.x == 2 and B.points >= C.points): continue
        for (AE, AF) in football.games("wdlx", repeat=2):
          A = football.table([AB, AC, AD, AE, AF], [0, 0, 0, 0, 0])
          if not (A.x == 2 and A.points >= B.points): continue

          # the remaining game (may be unplayed)
          for EF in football.games("wdlx"):
            E = football.table([AE, BE, CE, DE, EF], [1, 1, 1, 1, 0])
            if not (D.points >= E.points): continue
            F = football.table([AF, BF, CF, DF, EF], [1, 1, 1, 1, 1])
            if not (E.points >= F.points): continue

            # return match outcomes (at "one stage")
            yield dict(zip(keys, [AB, AC, AD, AE, AF, BC, BD, BE, BF, CD, CE, CF, DE, DF, EF]))

# allocate remaining matches
def stage2(ms):
  # find unplayed matches
  xs = list(k for (k, v) in ms.items() if v == 'x')
  # allocate match outcomes
  for vs in football.games("wdl", repeat=len(xs)):
    ms1 = update(ms, xs, vs)
    # calculate the new table
    (A, B, C, D, E, F) = (football.extract_table(ms1, t) for t in teams)
    # C is now at the top of the table
    if not (C.points >= max(A.points, B.points, D.points, E.points, F.points)): continue

    # return match outcomes (final) and unplayed games (at "one stage")
    yield (ms1, xs)

# allocate goals to the matches; return scorelines
def stage3(ms):
  # minimum goals
  gs = dict(w=(1, 0), d=(0, 0), l=(0, 1))
  # allocate minimum goals
  ss = dict((k, gs[v]) for (k, v) in ms.items())
  # one side scores 3 goals in the CvD match
  gs = dict(w=[(3, 0), (4, 3)], d=[(3, 3)], l=[(3, 4), (0, 3)])
  k = 'CD'
  for v in gs[ms[k]]:
    yield update(ss, [(k, v)])

# allocate remaining goals (to make 20 in total); return scorelines
def stage4(ms, ss):
  # calculate number of goals remaining
  r = 20 - sum(sum(x) for x in ss.values())
  if r == 0:
    yield ss
  elif r > 0:
    # chose matches and teams for the remaining goals
    for kts in subsets(cproduct([keys, (0, 1)]), size=r, select='R'):
      # make an updated set of scores
      (ks, ss_) = (set(), ss)
      for (k, t) in kts:
        ks.add(k)
        v = ss_[k]
        ss_ = update(ss_, [(k, update(v, [(t, v[t] + 1)]))])
      # check we haven't changed any outcomes
      if all(peek(football.outcomes([ss_[k]], [0])) == ms[k] for k in ks):
        yield ss_

# calculate (<points>, <goal-difference>, <goals-for>) score for team <t>
def score(t, ms, ss):
  T = football.extract_table(ms, t)
  (gf, ga) = football.extract_goals(ss, t)
  return (T.points, gf - ga, gf)

# check a scenario
def check(ms, ss, xs):
  # check C wins the league
  (A, B, C, D, E, F) = (score(t, ms, ss) for t in teams)
  # C is at the top of the table
  others = (A, B, D, E, F)
  if not C > max(others): return
  # but has the same number of points _and_ goal difference as another team
  if not any(zip_eq(C, X, first=2) for X in others): return

  # check the positions with the matches in <xs> unplayed
  ms = update(ms, xs, ['x'] * len(xs))
  ss = update(ss, xs, [None] * len(xs))
  scores = tuple(score(t, ms, ss) for t in teams)
  # check the order is A, B, C, D, E, F
  if not is_decreasing(scores, strict=1): return

  # this is a valid scenario
  return scores

# put it all together ...
for ms1 in stage1():
  for (ms, xs) in stage2(ms1):
    for ss3 in stage3(ms):
      for ss in stage4(ms, ss3):
        # extract (<pts>, <diff>, <for>) scores for a valid scenario
        scores = check(ms, ss, xs)
        if scores:
          printf("unplayed = {xs}", xs=join(xs, sep=", ", sort=1))
          printf("scores = {scores}")  # scores at "one stage"
          football.output_matches(ms, ss)  # final results

Solution: The scores in C’s matches are: C v A = 0-1; C v B = 0-1; C v D = 3-3; C v E = 1-0; C v F = 2-0.

The full set of results is:

A vs B = (d) 0-0
A vs C = (w) 1-0
A vs D = (w) 2-0
A vs E = (l) 0-1
A vs F = (l) 0-1
B vs C = (w) 1-0
B vs D = (w) 1-0
B vs E = (l) 0-1
B vs F = (l) 0-1
C vs D = (d) 3-3
C vs E = (w) 1-0
C vs F = (w) 2-0
D vs E = (w) 1-0
D vs F = (w) 1-0
E vs F = (d) 0-0

The final order was:

C: 2w1d = 7 points; for = 6; against = 5; difference = +1
A: 2w1d = 7 points; for = 3; against = 2; difference = +1
B: 2w1d = 7 points; for = 2; against = 2; difference = 0
E: 2w1d = 7 points; for = 2; against = 2; difference = 0
D: 2w1d = 7 points; for = 5; against = 6; difference = −1
F: 2w1d = 7 points; for = 2; against = 3; difference = −1

i.e. C > A > B = E > D > F.

Note that B and E cannot be separated in the final order by points, goal difference, or goals scored.

At the intermediate stage the following games were unplayed:

A v E; A v F; B v E; B v F; and maybe E v F

Giving the following orders:

A: 3 played; 2w1d = 7 points; for = 3; against = 0; difference = +3
B: 3 played; 2w1d = 7 points; for = 2; against = 0; difference = +2
C: 5 played; 2w1d = 7 points; for = 6; against = 5; difference = +1
D: 5 played; 2w1d = 7 points; for = 5; against = 6; difference = −1

E: 3 played; 1d = 1 point; for = 0; against = 2; difference = −2
F: 3 played; 1d = 1 point; for = 0; against = 3; difference = −3

or (if E v F is unplayed):

E: 2 played; 0 points; for = 0; against = 2; difference = −2
F: 2 played; 0 points; for = 0; against = 3; difference = −3

In either case the order is: A > B > C > D > E > F.

LikeLike

Jim Randell 7:42 am on 25 November 2025 Permalink | Reply
Tags: by: Nick MacKinnon

Teaser 2516: [Football league]

From The Sunday Times, 12th December 2010 [link] [link]

Six teams — Ayes, Bees, Cees, Dees, Ease and Fees — played each other once in a football league, with three points for a win and one for a draw. Ayes finished top, with the order of the teams being alphabetical. The difference in points between each pair of adjacent teams was the same. The 13 goals scored included hat-tricks from the Dees striker in two matches. In one game, the Cees goalkeeper let in two before being substituted.

What were Cees’ five results (in the order CvA, CvB, CvD, CvE, CvF)?

This puzzle was originally published with no title.

[teaser2516]

Jim Randell 7:43 am on 25 November 2025 Permalink | Reply

The points form an arithmetic sequence, from low (F) to high (A) = (f, f + x, f + 2x, f + 3x, f + 4x, f + 5x).

So the total number of points is: 6f + 15x.

There are 6 teams, and 15 matches in all. And there are 13 goals scored in total.

We know 6 of the goals are involved in two of D’s matches, which leaves just 7 goals remaining to be allocated. So the maximum number of games that are won/lost is 9, meaning there must be at least 6 matches that are drawn. And in order for the 5 teams to have different points totals there can be no more than 11 drawn matches.

The following Python program considers the possible numbers for matches that are drawn (and the rest must be won/lost), calculates the total number of points allocated, and constructs possible arithmetic sequences corresponding to this total. It then uses the [[ Football() ]] helper class from the enigma.py library to allocate match outcomes that give the required points totals, and then allocates the 13 goals accordingly.

It runs in 239ms. (Internal runtime is 173ms).

from enigma import (Football, irange, div, rev, seq_get, subsets, ordered, diff, update, fail, sprintf, printf)

# scoring system
football = Football(games="wdl", points=dict(w=3, d=1))

# allocate match outcomes for teams <ts>, points <pts>,
# with <w> total wins and <d> total draws
def matches(ts, pts, w, d, i=0, ms=dict()):
  # look for the next team
  t = seq_get(ts, i)
  # are we done?
  if t is None:
    if w == 0 and d == 0:
      yield ms
  else:
    # find unallocated keys involving this team
    ks = list(ordered(t, x) for x in ts if x != t)
    ks = diff(ks, ms)
    # consider match outcomes for the unallocated games
    for vs in football.games(repeat=len(ks)):
      ms_ = update(ms, ks, vs)
      # extract the table and check we have achieved the required points
      T = football.extract_table(ms_, t)
      if T.points != pts[i]: continue
      # and have not exceeded the number of wins/draws
      (w_, d_) = (w - T.w, d - T.d)
      if (w_ < 0 or d_ < 0): continue
      # solve for the remaining teams
      yield from matches(ts, pts, w_, d_, i + 1, ms_)

# solve for points <pts> with <w> matches won/lost and <d> matches drawn
def solve(pts, w, d):
  # fill out matches (note: each draw is counted by both sides)
  for ms in matches("ABCDEF", pts, w, 2 * d):
    # extract keys for C and D
    (Cs, cs) = football.extract_keys(ms, 'C')
    (Ds, ds) = football.extract_keys(ms, 'D')

    # allocate minimum possible goals for the matches
    gs = dict(w=(1, 0), d=(0, 0), l=(0, 1))
    ss0 = dict((k, gs[v]) for (k, v) in ms.items())

    # choose 2 matches for D to have hat-tricks
    gs = [dict(w=(3, 0), d=(3, 3), l=(3, 4)), dict(w=(4, 3), d=(3, 3), l=(0, 3))]
    for kts in subsets(zip(Ds, ds), size=2):
      ss = update(ss0, ((k, gs[t][ms[k]]) for (k, t) in kts))
      # find the number of remaining goals to allocate
      r = 13 - sum(sum(v) for v in ss.values())
      if r < 0: continue
      if r > 0: fail(msg=sprintf("distribute {r} remaining goals"))

      # C concedes (at least) 2 goals in (at least) one match
      if not any(ss[k][1 - t] >= 2 for (k, t) in zip(Cs, cs)): continue

      # output scenario
      football.output_matches(ms, ss)

# consider number of drawn matches (between 6 and 11)
for d in irange(6, 11):
  # the remaining matches are won/lost
  w = 15 - d
  # total points allocated
  t = 2*d + 3*w
  # consider points difference between teams
  for x in [1, 2, 3]:
    f = div(t - 15*x, 6)
    if f is None or f < 0: continue
    pts = rev(f + i*x for i in irange(6))
    # attempt to solve for this sequence of points
    printf("[d={d}: w={w} -> t={t}; x={x} f={f} -> pts = {pts}]")
    solve(pts, w, d)

Fortunately it turns out that after the minimum possible goals have been allocated to the matches, there are no “discretionary” goals remaining to allocate, so I didn’t bother to write that section of code.

Solution: The scores in Cee’s matches were: CvA = 0-1; CvB = 1-0; CvD = 0-3; CvE = 1-0; CvF = 0-0.

The full list of match outcomes and scores is:

A vs B = (d) 0-0
A vs C = (w) 1-0
A vs D = (w) 1-0
A vs E = (d) 0-0
A vs F = (d) 0-0
B vs C = (l) 0-1
B vs D = (w) 1-0
B vs E = (w) 1-0
B vs F = (d) 0-0
C vs D = (l) 0-3
C vs E = (w) 1-0
C vs F = (d) 0-0
D vs E = (l) 0-1
D vs F = (w) 3-0
E vs F = (d) 0-0

And the points are: A = 9, B = 8, C = 7, D = 6, E = 5, F = 4.

The program actually runs fine considering the full range of possible draws (d = 0..15), so we don’t need to do any pre-analysis.

LikeLike

Frits 4:58 am on 30 November 2025 Permalink | Reply

rev = lambda s: s[::-1]
opp = lambda n: 1 if n == 1 else 3 - n
# return sorted tuple
stup = lambda x, y: (x, y) if x < y else (y, x)
tri = lambda n: n * (n + 1) // 2

# remove elements from <s2> from <s1>
# eg diff_lists([1,3,1,2], [2,0,1]) results in [1,3]
def diff_lists(s1, s2):
  s = s1.copy()
  for x in s2:
    if x in s1:
      s.remove(x)
  return s 

# return a permutation of sequence <s> where s may have duplicate elements   
def permutations_non_unique(s, k, ss=()):
  if k == 0:
    yield ss
  else:
    for v in set(s):
      i = s.index(v)
      # list without first occurrence of <v> 
      s_ = s[:i] + s[i + 1:]
      yield from permutations_non_unique(s_, k - 1, ss + (v, ))

# generate a list of 15 wins/losses/draws
def gen_games(k, s, ps, ss=[]):
  if k == -1:
    yield ss
  else:
    # reverse the games that are already known
    r = tuple(opp(x[4 - k]) for x in ss)
    sumr = sum(r)
    # get <k> more games
    for p in permutations_non_unique(s, k):
      # check total points per team
      if sumr + sum(p) == ps[5 - k]:
        yield from gen_games(k - 1, diff_lists(s, p), ps, ss + [r + p])

# generate the scores of a team
def solve_team(gs, r, k, mxNotD, mxD, ngs, sss, ss=[]):
  if k == 0:
    yield ss, ngs
  else:
    g, i = gs[0], 5 - k
    mn = 1 if g == 3 else 0
    mx = mxD if r == 3 or i == 3 else mxNotD
    if i < r: # we know the opponents score
      o = sss[i][r - 1]
      if g == 3:
        mn = o + 1
      elif g == 0:
        mx = min(mx, o - 1)
      else:
        mn, mx = o, o 
    
    for sc in range(mn, mx + 1):
      if sc > ngs: break
      yield from solve_team(gs[1:], r, k - 1, mxNotD, mxD, 
                            ngs - sc, sss, ss + [sc])   
  
# generate the scores of all teams    
def solve(gss, k, mxNotD, mxD, ngs=0, ss=[]):
  if k == 6:
    if ngs == 0:
      yield ss
  else:
    gs = gss[0] 
    for sc, ngs_ in solve_team(gs, k, 5, mxNotD, mxD, ngs, ss):
      if k == 3:
        # The Dees had 2 hat-trick games
        if sum(x > 2 for x in sc) < 2: continue 
      yield from solve(gss[1:], k + 1, mxNotD, mxD, ngs_, ss + [sc])

sols = set()        
# two matches have at least 3 goals so we can have 9 wins at most
for w in range(1, 10):
  d = 15 - w
  tp = w + 30   # total points: 3 * w + 2 * d
  # possible increments of the arithmetic sequence (ap, bp ... fp)
  for inc in range(1, 4):
    fp, r = divmod(tp - 15 * inc, 6)
    # we have 13 - 6 = 7 goals to divide
    # for games without the Dees determine the maximum goals per win
    maxNonD = 7 - (w - 3) 
    if r or fp < 0 or maxNonD < 1: continue
    # the Dees can have 5 wins at most, leaving (w - 5) wins for other teams
    # so for D we have 13 - 3 (other hat-trick) - 3 (non-hat-trick) - (w - 5) 
    # or 12 - w maximum goals per win
    maxD = 12 - w
    # check if both hat-trick games must be both wins
    if (ht_wins := 13 - 3 * 3 < w - 2):
      if fp + 2 * inc < 6: continue
    # points for the six teams
    ps = [fp + x * inc for x in range(5, -1, -1)]
    ws, ds = [0, 3] * w, [1] * d
    
    # generate a list of 15 wins/losses/draws
    for gs in gen_games(5, ws + ds, ps):
      # check hat-trick games
      if ht_wins and sum(x == 3 for x in gs[3]) < 2: continue
      # assign scores to games
      for goals in solve(gs, 0, maxNonD, maxD, 13, []):
        vsC = [gs[2] for i, gs in enumerate(goals) if i != 2]
        # in one game the Cees goalkeeper let in two before being substituted
        if max(vsC) < 2: continue
        sols.add(tuple(zip(goals[2], vsC)))
        
print("answer:", ' or '.join(str(s)[1:-1] for s in sols))

LikeLike

Jim Randell 8:17 am on 30 November 2025 Permalink | Reply

@Frits: Your code gives a result of 1-1 in the CvB match. But the correct result is 1-0. (See my comment above for the complete set of results).

LikeLike
- Frits 3:51 am on 1 December 2025 Permalink | Reply
  @Jim,
  
  I found that out myself today (when comparing it to Brian’s output).
  
  Please use:
```
vsC = [gs[2 if i > 2 else 1] for i, gs in enumerate(goals) if i != 2]
```
  LikeLike

Jim Randell 7:32 am on 22 August 2025 Permalink | Reply
Tags: by: Nick MacKinnon
Teaser 2485: [Circular field]
From The Sunday Times, 9th May 2010 [link] [link]

Jack and Katy have inherited a circular field, with North Gate (N) at the northernmost point and East Gate (E), South Gate (S) and West Gate (W) at the appropriate points.

Jack’s share of the field is one hectare in area. For each point P in his share, [exactly] three of the angles NPE, EPS, SPW and WPN are acute. For each point in Katy’s share, however, fewer than three of those angles are acute.

How far is it between North Gate and East Gate?

This puzzle was originally published with no title.

[teaser2485]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 7:32 am on 22 August 2025 Permalink | Reply
  
  If we draw a circle and consider the angle subtended by the diameter with any point P, then:
  
  If P is on the circumference of the circle, then the angle is 90°.
  
  If P is inside the circle, then the angle is >90°.
  
  If P is outside the circle, then the angle is <90° (i.e. actute).
  
  So we can draw circles with diameters of NE, ES, SW, WN, and then Jack’s region is any point that is outside exactly 3 of the circles, and Katy’s region is any point that is outside fewer than 3 of the circles.
  
  The situation is this:
  
  Jack’s area (blue) consists of points that are outside exactly 3 of the circles, and Katy’s area (green) consists of points that are outside exactly 2 of the circles.
  
  If we suppose the distance we are interested in is 2d:
  
  Then the area of the semi-circle with diameter NE, radius = d is: (1/2) 𝛑 d^2.
  
  And this area is the same as that of the triangle NOE and two half-petals (= 1 petal):
  
  (1/2) 𝛑 d^2 = d^2 + P
  ⇒
  2P = (𝛑 − 2) d^2
  
  And Katy’s area (K) consists of 4 petals:
  
  K = 4P = 2 (𝛑 − 2) d^2
  
  The radius of the entire circular field is: OE = d √2.
  
  And so the total area of the field is then: 2 𝛑 d^2.
  
  And so Jack’s area (J) is:
  
  J = 2 𝛑 d^2 − 2 (𝛑 − 2) d^2
  ⇒
  J = 4 d^2
  
  And this is equal to 1 hectare = 10_000 sq m.
  
  4 d^2 = 10_000 sq m
  d^2 = 2500 sq m
  d = 50 m
  
  And the distance we are interested in is NE = 2d, hence:
  
  Solution: The distance between the N gate and E gate is 100 m.
  
  And Katy’s area is:
  
  K = 2 (𝛑 − 2) d^2
  K ≈ 5708 sq m
  
  So, only 57% the size of Jack’s area.
  
  LikeLike

Jim Randell 8:59 am on 2 April 2025 Permalink | Reply
Tags: by: Nick MacKinnon

Teaser 2561: Winning the double

From The Sunday Times, 23rd October 2011 [link] [link]

Four teams, A, B, C and D, played each other once in a league, then played a knockout competition. They scored a total of 54 goals in the nine games, with a different score in each game; no team scored more than five goals in any game. For each team the average number of goals per game was a different whole number. Team B beat D by a margin of more than one goal in the knockout competition, but team A took the double, winning all their games.

What was the score in the match CvD?

[teaser2561]

Jim Randell 9:00 am on 2 April 2025 Permalink | Reply
In the tournament the 6 matches are:

AvB, AvC, AvD, BvC, BvD, CvD

In the knockout there is a BvD match (which B won), but A won the knockout. So the matches in the knockout must be:

1st round: AvC (A wins); BvD (B wins)
Final: AvB (A wins)

So A and B have played 5 matches, and C and D have played 4.

A won all their matches, so their goal average must be at least 3.

B won at least one match, so their goal average must be at least 1.

The following run file finds possible scorelines in each match. It isn’t very fast though, but it does run in 10.3s under PyPy.
```
#! python3 -m enigma -rr

SubstitutedExpression

# tournament:
#
#     A B C D
#  A: - H I J  (A wins all matches)
#  B: K - L M
#  C: N P - Q
#  D: R S T -
#
# knockout:
#
#  round 1: A v C = U - V (A wins); B v D = W - X (B wins)
#  final: A v B = Y - Z (A wins)
#
# no team scored more than 5 goals, so goals (and goal averages = A, B, C, D) are all 0-5
--base=6  # allows digits 0-5
--distinct="ABCD"  # goal averages are all different

# total goals scored by each team
--macro="@goalsA = (H + I + J + U + Y)"
--macro="@goalsB = (K + L + M + W + Z)"
--macro="@goalsC = (N + P + Q + V)"
--macro="@goalsD = (R + S + T + X)"

# total of all the goals scored is 54
"@goalsA + @goalsB + @goalsC + @goalsD == 54"

# each game has a different score line
"seq_all_different(ordered(x, y) for (x, y) in zip([H, I, J, L, M, Q, U, W, Y], [K, N, R, P, S, T, V, X, Z]))"

# goal averages (are all different by --distinct)
"A * 5 == @goalsA"
"B * 5 == @goalsB"
"C * 4 == @goalsC"
"D * 4 == @goalsD"
"A > 2"  # A won all their matches
"B > 0"  # B won at least one match
# and the total of all goals scored is 54
"5 * (A + B) + 4 * (C + D) == 54"

# B beat D by more than 1 goal in the knockout
"W > X + 1"

# A won all their games
"H > K" "I > N" "J > R" "U > V" "Y > Z"

--template="(H-K I-N J-R L-P M-S Q-T) (U-V W-X; Y-Z) (A B C D)"
--header="(AvB AvC AvD BvC BvD CvD) (AvC BvD; AvB) (A B C D)"
--solution=""
--answer="(Q, T)"  # answer is the score in C vs D match
--denest=-1  # CPython workaround
```
Solution: The score in the C vs D match was 5 – 5.

The program finds 48 ways to assign the scores in each match.

For example, one of the assignments is:

Tournament:
A vs B = 5-1
A vs C = 5-3
A vs D = 5-0
B vs C = 0-4
B vs D = 0-3
C vs D = 5-5

Knockout:
A vs C = 5-4
B vs D = 2-0
A vs B = 5-2

A wins all their matches by scoring 5 goals, so their goal average is 5. And the goal averages for B, C, D are B = 1 (from 5 goals), C = 4 (from 16 goals), D = 2 (from 8 goals).

LikeLike
- Frits 1:20 pm on 2 April 2025 Permalink | Reply
  
  @Jim, typo in line 48: “J > R”.
  It makes the program slower (and 48 ways to assign the scores in each match)
  
  LikeLike
  - Jim Randell 1:35 pm on 2 April 2025 Permalink | Reply
    
    @Frits: Thanks. Fixed now.
    
    LikeLike
- Frits 2:17 pm on 2 April 2025 Permalink | Reply
  Easy performance enhancement (from Brian’s analysis):
```
--invalid="5,BCD"  # teams other than A cannot score 5 goals in all their games
```
  LikeLike
  - Jim Randell 2:27 pm on 2 April 2025 Permalink | Reply
    Yes. With a little analysis there are some easy additional restrictions we can deduce.
    
    These bring the run time down to a much more reasonable 196ms.
```
# more restrictions we can deduce
--invalid="0,ABHIJUWY"
--invalid="1,AW"
--invalid="2,A"
--invalid="4,X"
--invalid="5,BCDKNRVXZ"
```
    And with more analysis we can go further. But I prefer to let the computer do the majority of the work.
    
    LikeLike

Frits 1:15 pm on 3 April 2025 Permalink | Reply

The program loops over the requested score so we can early return as soon as a solution is found (and not report 47 similar solutions).

The runtime approaches the 10 ms with CPython (as is feasible for most teasers).

from itertools import product

# Analysis: (credit B. Gladman)

# If the average goals per game for A, B, C, D are a, b, c and d we then have
#
#     54 == 5.(a + b) + 4.(c + d) 
#
# (since A and B play five games whereas C and D play four). Here the possible
# solutions (a + b, c + d) = (10, 1), (6, 6) or (2, 11).
 
# Since the maximum goals a team can score in any game is 5, all the averages
# are five or less. And, since the averages are all different, a + b and c + d
# are both less than 10 which means that a + b == c + d == 6. Moreover, since
# A wins all their games, other teams cannot score 5 goals in all their games
# and must have goals per match averages of less than five.
#
# Hence the possibilities are:
#
#      (a, b) = (5, 1), (4, 2), (2, 4)
#      (c, d) = (4, 2), (2, 4)
#
# And since the values are all different 
#
#      (a, b, c, d) =  (5, 1, 4, 2) or (5, 1, 2, 4)
#
#
# Hence in goal totals (A, B, C, D) = (25, 5, 16, 8) or (25, 5, 8, 16)

(H, I, J, U, Y, A, B) = (5, 5, 5, 5, 5, 5, 1)

# tournament:
#
#     A B C D
#  A: - H I J  (A wins all matches)
#  B: K - L M
#  C: N P - Q
#  D: R S T -
#
# knockout:
#
#  round 1: A v C = U - V (A wins); B v D = W - X (B wins)
#  final: A v B = Y - Z (A wins)
#

def inner(Q, T):
  for C in [2, 4]:
    D = 6 - C
    # A wins all their games with 5 goals  
    if 5 in {Q, T} and (Q, T) != (5, 5): continue
    for X in range(3):                        # X != 3 as W < 5
      for W in range(X + 2, 5):               # B beat D by more than one goal
        for R in range(5):
          S = D * 4 - (R + T + X)             # team D
          if not (0 <= S <= 4): continue      # S != 5 as M <= 3
          for V in range(5):                  # as W >= 2 then K,L,M,Z <= 3
            if V == R: continue
            for N in range(5):
              if N in {V, R}: continue
              P = C * 4 - (N + Q + V)         # team C
              if not (0 <= P <= 4): continue  # P != 5 als L <= 3
              # as W >= 2 then K,L,M,Z <= 3
              for L, M in product(range(4), repeat=2): 
                # different games
                if (len(set(s := list(zip([L, M, Q, W], [P, S, T, X])))) !=
                    len(s)): continue
                for Z in range(4):            # as W >= 2 then K,L,M,Z <= 3
                  if Z in {V, R, N}: continue
                  K = B * 5 - (L + M + W + Z) # team B
                  if not (0 <= K <= 3) or K in {V, R, N, Z}: continue
                  if H+I+J+K+L+M+N+P+Q+R+S+T+U+V+W+X+Y+Z != 54: continue
                  return str((Q, T))

sols = []
# Process scores CvD  (Q, T)
for C, D in product(range(6), repeat=2):
  if (s := inner(C, D)):
    sols.append(s)

print("answer(s):", ' or '.join(sols))

LikeLike

Frits 6:20 pm on 3 April 2025 Permalink | Reply

Another one using more analysis. Internal runtime 22 microseconds (under PyPy).

from itertools import product, permutations

stup = lambda x, y: (x, y) if x < y else (y, x)
  
def diffgames(a, b):
  return len(set(s := list(stup(x, y) for x, y in zip(a, b)))) == len(s)
  
# Analysis: (credit B. Gladman)

# If the average goals per game for A, B, C, D are a, b, c and d we then have
#
#     54 == 5.(a + b) + 4.(c + d) 
#
# (since A and B play five games whereas C and D play four). Here the possible
# solutions (a + b, c + d) = (10, 1), (6, 6) or (2, 11).
 
# Since the maximum goals a team can score in any game is 5, all the averages
# are five or less. And, since the averages are all different, a + b and c + d
# are both less than 10 which means that a + b == c + d == 6. Moreover, since
# A wins all their games, other teams cannot score 5 goals in all their games
# and must have goals per match averages of less thsn five.
#
# Hence the possibilities are:
#
#      (a, b) = (5, 1), (4, 2), (2, 4)
#      (c, d) = (4, 2), (2, 4)
#
# And since the values are all different 
#
#      (a, b, c, d) =  (5, 1, 4, 2) or (5, 1, 2, 4)
#
#
# Hence in goal totals (A, B, C, D) = (25, 5, 16, 8) or (25, 5, 8, 16)
#
#
# In the knockout 1st round game BvD team B can score a maximum of 4 goals
# and we have B - D >= 2. Team D can only score a maximum of 2 goals in this 
# knockout round.
# This means the average of team D cannot be 4 (as it would require at least 
# 2 wins with 5 goals). So the averages of team C and D are 2 resp. 4.
# In all games of team C they score at least 3 goals.

(H, I, J, U, Y, A, B, C, D) = (5, 5, 5, 5, 5, 5, 1, 4, 2)
(B5, C4, D4) = (5 * B, 4 * C, 4 * D)

# tournament:
#
#     A B C D
#  A: - H I J  (A wins all matches)
#  B: K - L M
#  C: N P - Q
#  D: R S T -
#
# knockout:
#
#  round 1: A v C = U - V (A wins); B v D = W - X (B wins)
#  final: A v B = Y - Z (A wins)
#

# inner loops
def inner(Q, T):
  # team A wins all their games scoring 5 goals in each game
  if 5 in {Q, T} and (Q, T) != (5, 5): return
  for X in range(3):                      # X != 3 as W < 5
    for R in range(3):                    # as N and V (team C) use 3 and 4
      S = D4 - (R + T + X)             # team D
      if not (0 <= S <= 4): continue      # S != 5 as M <= 3
      for N, V in permutations(range(3, 5), 2): # team C goals
        P = C4 - (N + Q + V)           # team C
        if not (3 <= P <= 4): continue    # P != 5 als L <= 3
        for W in range(X + 2, 5):         # B beat D by more than one goal
          # K + N + R + V + Z = 10  and  K + L + M + W + Z = 5
          for L in range((LM := (V + N + R) - W - 5) + 1):       
            M = LM - L
            
            # different games
            if not diffgames([L, M, Q, W], [P, S, T, X]): continue

            for Z in range(6 - W - L - M):  # K,L,M,Z <= 3 as W >= 2
              if Z in {V, R, N}: continue
              K = B5 - (L + M + W + Z) # team B
              if not (0 <= K <= 3) or K in {V, R, N, Z}: continue

              if H+I+J+K+L+M+N+P+Q+R+S+T+U+V+W+X+Y+Z != 54: continue
              return str((Q, T))

sols = []
# process scores CvD, team C scores at least 3 goals in each game
for Q, T in product(range(3, 6), range(6)):
  if (s := inner(Q, T)):
    sols.append(s)

print("answer(s):", ' or '.join(sols))

LikeLike

Jim Randell 7:57 am on 18 March 2025 Permalink | Reply
Tags: by: Nick MacKinnon

Teaser 2528: [Football league]

From The Sunday Times, 6th March 2011 [link] [link]

Some teams, A, B, C and so on, play each other once in a football league, earning three points for a win and one for a draw. So far, each team has played two games and scored the same total number of goals. At the moment, they stand in alphabetical order, with each team having a different number of points. The result of the game B v E was 3-2, and indeed all the wins so far have been by a one-goal margin.

If you knew how many teams there were in the league, then it would be possible to work out all the results so far.

What are those results?

This puzzle was originally published with no title.

[teaser2528]

Jim Randell 7:57 am on 18 March 2025 Permalink | Reply

Each team has played 2 matches, so the possible outcomes are:

w+w = 6 points
w+d = 4 points
w+l = 3 points
d+d = 2 points
d+l = 1 point
l+l = 0 points

So, if each of the teams has a different number of points, there can be no more than 6 teams in the league. And we are told there are at least 5 teams.

There were quite a lot of conditions to keep track of, so I opted to use a MiniZinc model, and then look for a unique solution given the number of teams in the league (using the minizinc.py wrapper).

The following Python/MiniZinc program runs in 649ms.

from enigma import (irange, subsets, str_upper, sprintf, printf)
from minizinc import MiniZinc

# find solutions for <n> teams
def solve(n):
  model = sprintf(r"""

  include "globals.mzn";

  set of int: Teams = 1..{n};

  % record goals scored in the matches
  % 0 = unplayed
  % >0 = goals scored + 1
  array [Teams, Teams] of var 0..10: x;

  % no team plays itself
  constraint forall (i in Teams) (x[i, i] = 0);

  % unplayed games are unplayed by both sides
  constraint forall (i, j in Teams where i < j) (x[i, j] = 0 <-> x[j, i] = 0);

  % each team has played exactly 2 games (= positive values)
  constraint forall (i in Teams) (sum (j in Teams) (x[i, j] > 0) = 2);

  % each team has scored the same number of goals (over both games)
  function var int: goal(var int: X) = if X > 0 then X - 1 else 0 endif;
  function var int: goals(var Teams: i) = sum (j in Teams) (goal(x[i, j]));
  constraint all_equal([goals(i) | i in Teams]);

  % points are in alphabetical order
  function var int: pt(var int: X, var int: Y) = if X > 0 /\ Y > 0 then 3 * (X > Y) + (X = Y) else 0 endif;
  function var int: pts(var Teams: i) = sum (j in Teams where j != i) (pt(x[i, j], x[j, i]));
  constraint forall (i in Teams where i > 1) (pts(i) < pts(i - 1));

  % score in B vs E match was 3-2 (so values are 4, 3)
  constraint x[2, 5] = 4 /\ x[5, 2] = 3;

  % all winning goal margins are 1
  constraint forall (i, j in Teams where i != j) (x[i, j] > x[j, i] -> x[i, j] = x[j, i] + 1);

  solve satisfy;
  """)

  m = MiniZinc(model, solver="minizinc -a --solver chuffed")
  for s in m.solve():
    yield s['x']

# output matches for <n> teams, solution <x>
def output(n, x):
  for i in irange(0, n - 1):
    for j in irange(i + 1, n - 1):
      (a, b) = (x[i][j] - 1, x[j][i] - 1)
      if a == b == -1: continue
      printf("{i} vs {j} = {a} - {b}", i=str_upper[i], j=str_upper[j])
  printf()

# find possible points totals for 2 matches scoring 0, 1, 3.
tots = set(x + y for (x, y) in subsets([0, 1, 3], size=2, select='R'))
printf("tots = {tots}")

# consider leagues with at least 5 teams
for n in irange(5, len(tots)):
  ss = list(solve(n))
  k = len(ss)
  printf("[{n} teams -> {k} solutions]")
  if k == 1:
    for x in ss:
      output(n, x)

Solution: The results are: A vs C = 2-1; A vs F = 3-2; B vs D = 2-2; B vs E = 3-2; C vs F = 4-3; D vs E = 3-3.

The points are:

A = 6 points (2 wins)
B = 4 points (1 win + 1 draw)
C = 3 points (1 win)
D = 2 points (2 draws)
E = 1 point (1 draw)
F = 0 points

With 5 teams there are 3 possible sets of matches, so this does not provide a solution:

A vs C = 1-0; A vs E = 3-2; B vs D = 1-1; B vs E = 3-2; C vs D = 4-3;
A vs C = 2-1; A vs D = 4-3; B vs D = 3-3; B vs E = 3-2; C vs E = 5-4
A vs D = 1-0; A vs E = 2-1; B vs C = 0-0; B vs E = 3-2; C vs D = 3-3

LikeLike

Jim Randell 4:43 pm on 31 December 2024 Permalink | Reply
Tags: by: Nick MacKinnon

Teaser 2596: Unusual factors

From The Sunday Times, 24th June 2012 [link] [link]

There are no neat tests for divisibility by 7 or 13, so it’s unusual for these factors to feature in Teasers. Today we put that right.

If you start with any three different non-zero digits, then you can make six different three-digit numbers using precisely those digits. For example, with 2, 5 and 7 you get 257, 275, 527, 572, 725 and 752. Here, one of their differences (572 − 257) is divisible by 7, and another (725
− 257) is divisible by 13.

Your task today is to find three different digits so that none of the six possible three-digit numbers and none of the differences between any pair of them is a multiple of either 7 or 13.

What are the three digits?

My review of puzzles posted in 2024 is at Enigmatic Code: 2024 in review.

[teaser2596]

Jim Randell 4:44 pm on 31 December 2024 Permalink | Reply

This Python program looks at possible sets of three digits, and then uses the [[ generate() ]] function to generate possible arrangements and differences. This means as soon as we find a number that fails the divisibility tests we can move on to the next set of digits.

It runs in 65ms. (Internal runtime is 491µs).

from enigma import (irange, subsets, nconcat, printf)

# generate numbers to test from digits <ds>
def generate(ds):
  seen = list()
  # consider all arrangements of the digits
  for n in subsets(ds, size=len, select='P', fn=nconcat):
    # return the arrangement
    yield n
    # return the differences
    for x in seen:
      yield abs(n - x)
    seen.append(n)

# choose 3 digits
for ds in subsets(irange(1, 9), size=3):
  # check numbers are not divisible by 7 or 13
  if any(n % 7 == 0 or n % 13 == 0 for n in generate(ds)): continue
  # output solution
  printf("digits = {ds}")

Solution: The three digits are: 1, 4, 9.

See also: A video by Matt Parker on divisibility tests [@youtube].

LikeLike

GeoffR 7:34 pm on 1 January 2025 Permalink | Reply

from itertools import permutations
from enigma import nsplit

N = []

for a, b, c in permutations(range(1, 10), 3): 
    n1, n2 = 100*a + 10*b + c, 100*a + 10*c + b
    n3, n4 = 100*b + 10*a + c, 100*b + 10*c + a
    n5, n6 = 100*c + 10*a + b, 100*c + 10*b + a
    # Check three-digit numbers are not divisible by 7 or 13
    if any(x % 7 == 0 for x in (n1 ,n2, n3, n4, n5, n6)):
        continue
    if any(x % 13 == 0 for x in (n1, n2, n3, n4, n5, n6)):
        continue
    N.append(n1)

# check differences for each number in the list
# of potential candidates
for m in N:
    x, y, z = nsplit(m)
    m1, m2 = m, 100*x + 10*z + y
    m3, m4 = 100*y + 10*x + z, 100*y + 10*z + x
    m5, m6 = 100*z + 10*x + y, 100*z + 10*y + x
    # a manual check of the 15 differences of each 6-digit number
    if abs(m1-m2) % 7 == 0 or abs(m1-m2) % 13 == 0: continue
    if abs(m1-m3) % 7 == 0 or abs(m1-m3) % 13 == 0: continue
    if abs(m1-m4) % 7 == 0 or abs(m1-m4) % 13 == 0: continue
    if abs(m1-m6) % 7 == 0 or abs(m1-m5) % 13 == 0: continue
    if abs(m1-m6) % 7 == 0 or abs(m1-m6) % 13 == 0: continue
    #
    if abs(m2-m3) % 7 == 0 or abs(m2-m3) % 13 == 0: continue
    if abs(m2-m4) % 7 == 0 or abs(m2-m4) % 13 == 0: continue
    if abs(m2-m5) % 7 == 0 or abs(m2-m5) % 13 == 0: continue
    if abs(m2-m6) % 7 == 0 or abs(m2-m6) % 13 == 0: continue
    #
    if abs(m3-m4) % 7 == 0 or abs(m3-m4) % 13 == 0: continue
    if abs(m3-m5) % 7 == 0 or abs(m3-m5) % 13 == 0: continue
    if abs(m3-m6) % 7 == 0 or abs(m3-m6) % 13 == 0: continue
    #
    if abs(m4-m5) % 7 == 0 or abs(m4-m5) % 13 == 0: continue
    if abs(m4-m6) % 7 == 0 or abs(m4-m6) % 13 == 0: continue
    if abs(m5-m6) % 7 == 0 or abs(m5-m6) % 13 == 0: continue
    if x < y < z:
        print(f"The three digit numbers are {x}, {y} and {z}.")

# The three digit numbers are 1, 4 and 9.

I resorted to a manual check of the differences of the 6 numbers arising from each 3 digit candidate, as it was not coming out easily in code.

LikeLike

Jim Randell 11:16 am on 19 November 2024 Permalink | Reply
Tags: by: Nick MacKinnon

Teaser 2613: Anagrammatical

From The Sunday Times, 21st October 2012 [link] [link]

The number 258 is special in the following way. If you write down its six different anagrams (258, 285, 528, etc.), then calculate the fifteen differences between any two of those six (27, 270, 243, etc.) and then add up those fifteen differences, you get 4644, which is a multiple of the number 258 that you started with!

Which higher three-figure number has the same property?

[teaser2613]

Jim Randell 11:17 am on 19 November 2024 Permalink | Reply
Here is a constructive solution.

It runs in 57ms. (Internal runtime is 3.1ms).
```
from enigma import (irange, nsplit, subsets, nconcat, printf)

# check a 3 digit number
def check(n):
  # find different rearrangements of the digits
  rs = sorted(subsets(nsplit(n), size=len, select='mP', fn=nconcat))
  if len(rs) < 2: return False
  # calculate the total sum of the pairwise differences
  t = sum(y - x for (x, y) in subsets(rs, size=2))
  if t % n != 0: return False
  printf("{n} -> {t}")
  return True

# check the given value
assert check(258)

# find the next 3-digit number after 258 that works
for n in irange(259, 999):
  if check(n): break
```
Solution: The next 3-digit number with the same property is 387.

And there are no higher 3-digit numbers with the property, but there are lower ones.

The complete list of 3-digit numbers (and the sum of the differences) with this property is:

129 → 6192
172 → 4644
258 → 4644
387 → 3870

LikeLike
- Frits 5:03 pm on 21 November 2024 Permalink | Reply
  
  The differences between any two of these four 3-digit numbers are multiples of 43.
  
  See [https://brg.me.uk/?page_id=300].
  
  LikeLike

Ruud 7:18 pm on 19 November 2024 Permalink | Reply

This code finds all three digit numbers that meet the conditions given:

import istr

for i in istr.range(100, 1000):
    if i.all_distinct() and sum(abs(x - y) for x, y in istr.combinations(istr.concat(istr.permutations(i)), 2)).is_divisible_by(i):
        print(i)

LikeLike

GeoffR 2:56 pm on 21 November 2024 Permalink | Reply

from enigma import nsplit

for n in range(258, 999):
    diff = 0
    a, b, c = nsplit(n)
    if 0 in (a, b, c):
        continue
    # Form the six numbers
    n1, n2 = 100*a + 10*b + c, 100*a + 10*c + b
    n3, n4 = 100*b + 10*a + c, 100*b + 10*c + a
    n5, n6 = 100*c + 10*a + b, 100*c + 10*b + a
    if not len(set((n1, n2, n3, n4, n5, n6))) == 6:
        continue
    # Find sum of fifteen differences
    diff = abs(n1-n2) + abs(n1-n3) + abs(n1-n4) + abs(n1-n5) + abs(n1-n6)\
            + abs(n2-n3) + abs(n2-n4) + abs(n2-n5) + abs(n2-n6)\
            + abs(n3-n4) + abs(n3-n5) + abs(n3-n6)\
            + abs(n4-n5) + abs(n4-n6)\
            + abs(n5-n6)
    #  Sum of fifteen differences is a multiple of the number 
    if diff % n == 0:
        print(f"Number = {n}, Differences sum = {diff}")

# Number = 258, Differences sum = 4644
# Number = 387, Differences sum = 3870

Interesting that the differences sum is ten times the number.

LikeLike

Jim Randell 10:43 am on 17 September 2024 Permalink | Reply
Tags: by: Nick MacKinnon

Teaser 2604: Foreign friends

From The Sunday Times, 19th August 2012 [link] [link]

The telephone number of my Japanese friend is a ten-digit number written as a group of five two-digit numbers. The phone number does not start with a 0, and no digit is used more than once. The numbers in the group are in increasing order, no two of them have a common factor greater than 1, and one of them is a fourth power. Also, the product of the numbers in the group is divisible by four of the first five primes.

The telephone number of my Russian friend is also a ten-digit number but it is written as a group of two five-digit numbers. The number and group have the same properties as those stated above. The second digit of the Russian number is double the second digit of the Japanese number.

What are the two telephone numbers?

[teaser2604]

Jim Randell 10:44 am on 17 September 2024 Permalink | Reply

Here is a solution using the [[ SubstitutedExpression ]] solver from the enigma.py library.

It runs in 772ms. (Internal runtime is 582ms, although this can be reduced to 377ms by splitting out the [[ is_coprime(@jps) ]] check into 10 separate coprime tests (one for each pair)).

Note: An up-to-date version of enigma.py is required for the multiple argument version of is_coprime().

#! python3 -m enigma -rr

SubstitutedExpression

# Japanese phone number = AB CD EF GH IJ
# Russian phone number = KLMNP QRSTU
--distinct="ABCDEFGHIJ,KLMNPQRSTU"
--macro="@jps = AB, CD, EF, GH, IJ"
--macro="@rus = KLMNP, QRSTU"

# neither phone number starts with 0
--invalid="0,AK"

# in the groups ...
# the numbers are in increasing order
"A < C" "C < E" "E < G" "G < I"
"K < Q"

# the numbers are pairwise co-prime
"is_coprime(@jps)"
"is_coprime(@rus)"

# use "at least" or "exactly" for counting?
--code="count = icount_at_least"  # or: icount_exactly

# one of them is a fourth power
--code="pow4s = set(i**4 for i in irange(0, 17))"
--code="pow4 = lambda ns: count(ns, is_in(pow4s), 1)"
"pow4([@jps])"
"pow4([@rus])"

# the product is divisible by four of {2, 3, 5, 7, 11}
--code="_divs = (lambda n, ds, k: count(ds, (lambda d: n % d == 0), k))"
--code="divs = (lambda ns: _divs(multiply(ns), [2, 3, 5, 7, 11], 4))"
"divs([@jps])"
"divs([@rus])"

# 2nd digit of the Russian number is double the 2nd digit of the Japanese number
"2 * B = L"
--invalid="5|6|7|8|9,B"  # so, B < 5

--template="(AB CD EF GH IJ) (KLMNP QRSTU)"
--solution=""
--denest=-1

Solution: The numbers are: (23 49 50 67 81) and (46970 83521).

The individual parts factorise as:

(23 49 50 67 81) = ([23] [7×7] [2×5×5] [67] [3×3×3×3])
(46970 83521) = ([2×5×7×11×61] [17×17×17×17])

From which we see in each number there are no prime factors common to any two of the parts, so each is pairwise coprime.

And the final part in each is the fourth power (of a prime).

The top number has divisors of: 2, 3, 5, 7 (but not 11).

The bottom number has divisors of: 2, 5, 7, 11 (but not 3).

LikeLike

Ruud 12:22 pm on 19 September 2024 Permalink | Reply

Brute force:

from istr import istr
import math
import functools
import operator

istr.repr_mode("str")
solutions = {2: set(), 5: set()}

for s in istr.permutations(istr.range(10)):
    if s[0] != 0:
        for k in (2, 5):
            numbers = tuple(istr("".join(s[i : i + k])) for i in range(0, len(s), k))
            if all(number0 < number1 for number0, number1 in zip(numbers, numbers[1:])):
                if sum((float(number) ** (1 / 4)).is_integer() for number in numbers) == 1:
                    if sum(functools.reduce(operator.mul, numbers) % prime == 0 for prime in (2, 3, 5, 7, 11)) == 4:
                        if all(math.gcd(int(number0), int(number1)) == 1 for number0, number1 in istr.combinations(numbers, 2)):
                            solutions[k].add(istr(" ").join(numbers))
for japanese in solutions[2]:
    for russian in solutions[5]:
        if japanese[1] * 2 == russian[1]:
            print(f"{japanese=} {russian=}")

LikeLike

GeoffR 4:41 pm on 19 September 2024 Permalink | Reply

# Japanese telephone number is AB CD EF GH IJ
# Russian telephone number is KLMNP QRSTU

from itertools import permutations
from enigma import is_coprime

# max 5 digits for the 4th power
pow4 = [n * n * n * n for n in range(2, 18)]

dgts = set(range(10))

# Japanese Telephone Number
for p1 in permutations(dgts, 4):
  jp_found = 0
  A, B, C, D = p1
  if 0 in (A, C): continue
  # Constraint on 2nd digit of 1st Tel No. i.e. L = 2 *  B
  if B == 0 or B > 4: continue
  if not A < C: continue
  AB, CD = 10*A + B, 10*C + D
  if not is_coprime(AB, CD): continue

  # Find remaining digits in Japanese Telephone Number
  q1 = dgts.difference({A, B, C, D})
  for p2 in permutations(q1):
    E, F, G, H, I, J = p2
    if 0 in (E, G, I): continue
    if not A < C < E < G < I: continue
    EF, GH, IJ = 10*E + F, 10*G + H, 10*I + J
    
    # check ten co-prime conditions 
    if is_coprime(CD, EF) and is_coprime(EF, GH) and is_coprime(GH, IJ) \
      and is_coprime(AB, EF) and is_coprime(AB, GH) and is_coprime(AB, IJ) \
      and is_coprime(CD, GH ) and is_coprime(CD, IJ) and is_coprime(EF, IJ):
        
      # Check for a fourth power
      if any (x in pow4 for x in (AB, CD, EF, GH, IJ)):
        # Find number of divisors of Japanese Tel. No.
        cnt = 0
        for num in (AB, CD, EF, GH, IJ):
          for p3 in (2, 3, 5, 7, 11):
            if num % p3 == 0:
              cnt += 1
          if cnt == 4:
            print(f"Japanese No. is {AB} {CD} {EF} {GH} {IJ}.")
            jp_found = 1

          # Russian Telephone Number - find first half of Tel. No.
          for p5 in permutations(dgts,5):
            K, L, M, N, P = p5
            if K == 0: continue
            if L != 2 * B: continue
            KLMNP = 10000*K + 1000*L + 100*M + 10*N + P
            # Assume 4th power is QRSTU  
            if KLMNP not in pow4:
              cnt2 = 0
              for p5 in (2, 3, 5, 7, 11):
                if KLMNP % p5 == 0:
                  cnt2 += 1
            if cnt2 == 4:
                
              # Find second half of Russian Tel. No.
              q6 = dgts.difference({K, L, M, N, P})
              for p7 in permutations(q6):
                Q, R, S, T, U = p7
                QRSTU = 10000*Q + 1000*R + 100*S + 10*T + U
                if Q == 0: continue
                if not KLMNP < QRSTU: continue
                if not is_coprime(KLMNP, QRSTU): continue
                if QRSTU in pow4 and jp_found == 1:
                  print(f"Russian No. is {KLMNP} {QRSTU}.")

#Japanese No. 23 49 50 67 81
# Russian No. is 46970 83521

LikeLike

Jim Randell 8:54 am on 19 March 2024 Permalink | Reply
Tags: by: Nick MacKinnon
Teaser 2673: Footprints
From The Sunday Times, 15th December 2013 [link] [link]

A cubical dice, with faces labelled as usual, is placed in one of the nine squares of a three-by-three grid, where it fits exactly. It is then rotated about one of its edges into an adjacent square and this is done a total of eight times so that the dice visits each square once. The “footprint” of the route is the total of the nine faces that are in contact with the grid.

(a) What is the lowest footprint possible?
(b) What is the highest footprint possible?
(c) Which whole numbers between those two values cannot be footprints?

[teaser2673]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 8:55 am on 19 March 2024 Permalink | Reply
  I used the [[ Cube() ]] class to deal with rotations of the standard die (see: Teaser 2835).
  
  This Python program considers possible representative starting squares on the grid (a corner, an edge, the centre square) using a standard right-handed die, and then positioning it in all possible orientations it looks for possible footprint values as it moves around the grid. (We get the same results with the remaining squares on the grid, and also if we were to use a left-handed die).
  
  It runs in 82ms. (Internal runtime is 17ms).
```
from enigma import (irange, append, diff, printf)
from cube import (Cube, U, D, L, R, F, B)

# possible moves:
#
#  1 2 3
#  4 5 6
#  7 8 9
#
move = {
  1: { F: 2, L: 4 },
  2: { B: 1, F: 3, L: 5 },
  3: { B: 2, L: 6 },
  4: { R: 1, F: 5, L: 7 },
  5: { R: 2, B: 4, F: 6, L: 8 },
  6: { R: 3, B: 5, L: 9 },
  7: { R: 4, F: 8 },
  8: { R: 5, B: 7, F: 9 },
  9: { R: 6, B: 8 },
}

# calculate footprint totals
# d = current die orientation
# i = current die position
# t = accumulated footprint total
# vs = visited positions
def footprints(d, i, t=0, vs=set()):
  # add in the value on the D face
  t += d.faces[D]
  vs = append(vs, i)
  # have we visited each square in the grid?
  if len(vs) == 9:
    yield t
  else:
    # make a move
    for (r, j) in move[i].items():
      if j not in vs:
        yield from footprints(d.rotate([r]), j, t, vs)

# a standard die (U, D, L, R, F, B)
die = (1, 6, 2, 5, 3, 4)

# accumulate footprint totals
ts = set()
# consider possible starting squares: corner = 1, edge = 2, centre = 5
for i in [1, 2, 5]:
  # consider possible initial orientations for the die
  for d in Cube(faces=die).rotations():
    # calculate footprint totals
    ts.update(footprints(d, i))

# calculate min/max footprints
(a, b) = (min(ts), max(ts))
# output solution
printf("min = {a}; max = {b}; missing = {ms}", ms=diff(irange(a, b), ts))
```
  Solution: (a) The minimum possible footprint is 21; (b) The maximum possible footprint is 42; (c) 29 and 34 cannot be footprints.
  
  The following paths starting in the centre square (5) and visiting (5, 6, 3, 2, 1, 4, 7, 8, 9) (i.e. spiralling out from the centre) give the minimum and maximum:
  
  (1); F → (2); R → (4); B → (1); B → (3); L → (2); L → (4); F → (1); F → (3) = footprint 21
  (6); F → (5); R → (4); B → (6); B → (3); L → (5); L → (4); F → (6); F → (3) = footprint 42
  
  With a bit of analysis we can get a faster program:
  
  There are only 3 essentially different paths (every other path is a reflection/rotation/reversal of one of these):
  
  If we start at the beginning of one of these paths with a die showing (x, y, z) around one corner, and opposite faces (X, Y, Z) (so x + X = y + Y = z + Z = 7), then we get the following footprints:
  
  X + z + x + y + z + Y + X + z + x = 21 + 3z
  X + z + x + y + X + z + x + y + z = 14 + 2y + 3z
  X + z + y + X + Z + y + z + X + Z = 14 + 2y + 3X
  
  (y, z) = (2, 1) gives a minimum of 21 in second equation, and (y, z) = (5, 6) gives a maximum of 42.
  
  We can examine the full range of footprints by considering the value of 1 face in the first equation, and 2 adjacent faces in the second (or third) equation.
  
  This Python program examines all possible footprints, and has an internal runtime of 63µs.
```
from enigma import (irange, diff, printf)

# calculate footprint totals
scores = [1, 2, 3, 4, 5, 6]
ts = set()
for x in scores:
  ts.add(21 + 3*x)
  for y in scores:
    if x == y or x + y == 7: continue
    ts.add(14 + 2*x + 3*y)

# calculate min/max footprints
(a, b) = (min(ts), max(ts))
# output solution
printf("min = {a}; max = {b}; missing = {ms}", ms=diff(irange(a, b), ts))
```
  LikeLike
Jim Randell 8:46 am on 22 August 2023 Permalink | Reply
Tags: by: Nick MacKinnon
Teaser 2635: Three sisters
From The Sunday Times, 24th March 2013 [link] [link]

In Shakespeare’s less well-known prequel, King Lear shared all of his estate amongst his three daughters, each daughter getting a fraction of the estate. The three fractions, each in their simplest form, had numerators less than 100 and had the same denominators. Cordelia got the least, with Regan getting more, and Goneril the most (but her share was less than three times Cordelia’s). Each of the three fractions gave a decimal which recurred after three places (as in 0.abcabc…) and each digit from 1 to 9 occurred in one of the three decimals.

What were the three fractions?

[teaser2635]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 8:46 am on 22 August 2023 Permalink | Reply
  The recurring decimal 0.(abc)… is a representation of the fraction abc/999.
  
  But the three fractions we are dealing with can all be reduced to fractions with a 2-digit numerator, and a common denominator.
  
  So the common denominator must be a divisor of 999.
  
  This Python program runs in 54ms. (Internal runtime is 2ms)
  
  Run: [ @replit ]
```
from enigma import (divisors, decompose, gcd, recurring, join, printf)

# return viable repetends
def repetend(n, d):
  r = recurring(n, d)
  return (None if r.nr else r.rr)

# consider possible denominator values 3 < d < 100
for d in divisors(999):
  if d < 4: continue
  if d > 297: break

  # calculate ascending splits of the denominator
  for (C, R, G) in decompose(d, 3, increasing=1, sep=1, min_v=1, max_v=99):
    # G's share is less than 3 times C's
    if not (G < 3 * C): continue
    # check fractions are in lowest terms
    if any(gcd(n, d) != 1 for n in (C, R, G)): continue

    # find the repetends
    reps = list(repetend(n, d) for n in (C, R, G))
    if None in reps: continue
    # check the digits used
    ds = join(reps)
    if '0' in ds or len(set(ds)) < 9: continue

    # output solution
    (rC, rR, rG) = reps
    printf("C = {C}/{d} = 0.({rC})...; R = {R}/{d} = 0.({rR})...; G = {G}/{d} = 0.({rG})...")
```
  Solution: The fractions are: Cordelia = 6/37, Reagan = 14/37, Goneril = 17/37.
  
  As decimals:
  
  C = 0.(162)…
  R = 0.(378)…
  G = 0.(459)…
  
  LikeLike
Jim Randell 10:43 am on 4 July 2023 Permalink | Reply
Tags: by: Nick MacKinnon
Teaser 2625: Mind the gap
From The Sunday Times, 13th January 2013 [link] [link]

If you list in increasing order all ten-figure numbers with no repeat digit, then the first is 1023456789 and the last is 9876543210. The differences between consecutive numbers in the list vary wildly but no difference is ever equal to the average of all the differences between the consecutive numbers.

What difference between consecutive numbers comes closest to the average?

[teaser2625]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell and Frits are discussing. Toggle Comments
- Jim Randell 10:44 am on 4 July 2023 Permalink | Reply
  The way [[ subsets(..., select='P') ]] works the numbers will be produced in numerical order, so we don’t need to order them.
  
  The distances between consecutive numbers are recorded in a [[ multiset() ]], so we don’t have to bother processing duplicate values.
  
  But there are a lot of numbers to process, so the program is quite slow.
  
  This Python program runs in 871ms.
  
  Run: [ @replit ]
```
from enigma import (irange, subsets, nconcat, multiset, tuples, rdiv, Accumulator, printf)

# construct pandigitals in numerical order
def generate():
  for ds in subsets(irange(0, 9), size=10, select='P'):
    if ds[0] != 0:
      yield nconcat(ds)

# record the collection of differences between consecutive pandigitals
ds = multiset.from_seq(b - a for (a, b) in tuples(generate(), 2))
# calculate the mean difference
m = ds.avg(div=rdiv)
printf("mean difference = {m}", m=float(m))

# find the closest difference
r = Accumulator(fn=min, collect=1)
for d in ds.keys():
  r.accumulate_data(abs(m - d), d)
# output solution(s)
for d in r.data:
  printf("closest difference = {d} [{n} times]", n=ds[d])
```
  Solution: The difference that comes closest to the mean is 2727.
  
  Which occurs 1872 times, for example in the following pairs:
  
  (1034679852, 1034682579)
  …
  (9865317420, 9865320147)
  
  There are 500 different difference values.
  
  The smallest difference is 9 (which happens 322560 times):
  
  (1023456789, 1023456798)
  …
  (9876543201, 9876543210)
  
  And the largest difference is 104691357 (which happens 2 times):
  
  (1098765432, 1203456789)
  (8796543210, 8901234567)
  
  With some analysis we can get a faster program.
  
  We can calculate the mean difference fairly easily:
  
  In an ordered sequence (a, b, c, …, x, y, z) the sequence of consecutive distances is:
  
  (b − a, c − b, …, y − x, z − y)
  
  and this has one fewer element than the original sequence.
  
  And the sum of this sequence is simply:
  
  sum = z − a
  
  i.e. the difference between the largest pandigital and the smallest pandigital.
  
  So, if we knew the number of pandigitals in the original sequence we can calculate the mean.
  
  There are factorial(10) possible digit sequences, but factorial(9) of them will have a leading zero, so are rejected.
  
  Hence, there are 3265920 pandigitals (and the number of distances is 1 less than this).
  
  And so the mean distance is:
  
  mean distance = (9876543210 − 1023456789) / 3265919 = 2710.7489…
  
  So we see that no individual difference is equal to the mean because the mean is not an integer and all individual differences are. (And in fact they all must be multiples of 9).
  
  Now, if we consider two consecutive pandigitals that are at a distance apart that is close to the mean, then they are going to look something like:
  
  abcde|vwxyz
  abcde|xzyvw
  
  Where there is some shared prefix, and then the remaining digits appear in a different arrangement for the two numbers. And when calculating the difference between them the common prefix disappears.
  
  So the difference for the numbers in the example is then:
  
  xzyvw − vwxyz
  
  And we can calculate the differences by just looking at sets of numbers that are not part of the common prefix, and calculating the closest difference using those set.
  
  We are looking for a difference close to 2711, so we can examine sets of digits that have 5 elements.
  
  This Python program runs in 123ms.
  
  Run: [ @replit ]
```
from enigma import (
  factorial, rdiv, ndigits, Accumulator,
  irange, subsets, nconcat, tuples, printf
)

# calculate the mean distance
m = rdiv(9876543210 - 1023456789, 9 * factorial(9) - 1)
printf("mean difference = {m}", m=float(m))

# record the closest difference to the mean
r = Accumulator(fn=min)

# consider possible sets of digits
k = ndigits(int(m)) + 1
for ds in subsets(irange(0, 9), size=k):
  # find consecutive numbers using this set of digits
  ns = subsets(ds, size=len, select='P', fn=nconcat)
  # find differences between consecutive numbers closest to the mean
  for (a, b) in tuples(ns, 2):
    d = b - a
    r.accumulate_data(abs(m - d), d)

# output solution
printf("closest difference = {r.data}")
```
  LikeLike
- Frits 5:22 pm on 4 July 2023 Permalink | Reply
```
  
from enigma import factorial
from itertools import permutations, combinations

# calculate the mean distance
m = (9876543210 - 1023456789) / (factorial(10) - factorial(9) - 1)
print(f"mean difference = {m}")

mn, md = 9999999, 9999999

# abcde with c > d > e 
# choose last three descending digits
for c in combinations('9876543210', 3):
  # choose first 2 digits
  for p in permutations(set('0123456789').difference(c), 2):
    s = ''.join(p + c)

    # jump within same 10000:  like 32510 to 35012
    if s[1] < '7':
      # jump 3 higher for a difference of 2xxx
      s2 = str(int(s[1]) + 3)
      if s2 not in s[1:]: continue
      new = int(s[0] + s2 + ''.join(sorted(set(s[1:]).difference(s2))))
    else:  
      ints = [int(x) for x in s]
      # we must be able to jump to a higher 10000
      a1 = str(ints[0] + 1)
      if s[0] == '9' or a1 not in s: continue
      # digit 3 higher then 2nd digit must be present
      if str(ints[1] - 7) not in s: continue
      # digits higher than 2nd digit may not occur in last three positions
      if any(str(j) in s[2:] for j in range(ints[1] + 1, 10)): continue
      
      # jump to higher 10000:   like 17420 to 20147
      new = int(a1 + ''.join(sorted(set(s).difference(a1))))
  
    i = int(s)
    # check for closeness to target
    if abs(m - new + i) <= mn:
      mn, md = abs(m - new + i), new - i

print("answer:", md)
```
  LikeLike
  - Frits 1:27 pm on 5 July 2023 Permalink | Reply
    
    With the abcde|vwxyz method we might miss other combinations that can come relatively close to 2710.
    
    like 2345698710, 2345701689 with difference 2979
    
    LikeLike
    - Jim Randell 1:37 pm on 5 July 2023 Permalink | Reply
      We can reduce the size of the prefix considered at line 14:
      
      k = ndigits(int(m)) + 2
      
      Although it turns out the common prefix is size 5 in all 1872 cases, so we are OK.
      
      Originally I allowed 1 digit more than the length of the mean for the suffix, but this does assume that the closest value is going to be reasonably close to the mean value.
      
      LikeLike
Jim Randell 10:33 am on 25 May 2023 Permalink | Reply
Tags: by: Nick MacKinnon
Teaser 2183: The punishment fits the crime
From The Sunday Times, 18th July 2004 [link]

Recently I was teaching the class about Pascal’s triangle, which starts:

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1

Subsequent rows have a 1 at each end of each row, with any other number in the row obtained by adding the two numbers diagonally above it. Then a row gives, for example:

(1 + x)⁴ = 1 + 4x + 6x² + 4x³ + x⁴

Six pupils disrupted the lesson, and so I kept them in after school. I gave each of them a different prime number and told them to work out its 10th power without a calculator.

“That’s too easy”, said Blaise, whose prime was 3. “I’ll work out the product of everyone else’s answers instead”. Then she read out the 41-digit answer and left!

What was her 41-digit answer?

[teaser2183]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
GeoffR and Jim Randell are discussing. Toggle Comments
- Jim Randell 10:34 am on 25 May 2023 Permalink | Reply
  In order for the 10th power to be a 41 digit number the product of the 5 primes must be in the range:
  
  min = ceil(10^(40/10)) = ceil(10^4) = 10000
  max = floor(10^(41/10)) = floor(10^4.1) = 12589
  
  Excluding 3, the five smallest primes are (2, 5, 7, 11, 13) which have a product of 10010, which is in the range we require.
  
  And:
  
  10010^10 = 10100451202102522101200450100010000000000
  
  We can calculate this number using Pascal’s Triangle as follows:
  
  10010^10 = (10(1000 + 1))^10
  = (10^10)(1000 + 1)^10
  
  And row 10 (numbering from 0) of Pascal’s triangle is:
  
  10: (1 10 45 120 210 252 210 120 45 10 1)
  
  So we can calculate (1000 + 1)^10, using the polynomial derived from this row with x = 1000).
  
  The terms are separated by 1000, and each value in the row is 3 digits or less, so we can just write the result out by padding the values in the row to 3 digits:
  
  001 010 045 120 210 252 210 120 045 010 001
  
  Multiplying this by 10^10 just involves adding 10 zeros to the end, to give the 41 digit number:
  
  10100451202102522101200450100010000000000
  
  Or using Python.
  
  The following Python program runs in 57ms. (Internal runtime is 228µs).
  
  Run: [ @replit ]
```
from enigma import (intc, intf, fdiv, primes, inf, subsets, diff, multiply, ndigits, printf)

def solve(n, k):
  # min and max products for an n digit number
  m = intc(pow(10, fdiv(n - 1, k)))
  M = intf(pow(10, fdiv(n, k)))
  printf("[n={n} -> [{m}, {M}]]")

  # consider the largest prime
  for p in primes.irange(2, inf):
    if p == 3: continue
    # choose 4 smaller primes (excluding 3)
    f = 0
    for ps in subsets(diff(primes.between(2, p - 1), [3]), size=4, fn=list):
      ps.append(p)
      x = multiply(ps)
      if x > M:
        if f == 0: return
        break
      if not (x < m or x > M):
        x10 = pow(x, 10)
        printf("{ps} -> {x} -> {x10} [{d} digits]", d=ndigits(x10))
      f = 1

# solve for 41 digit numbers
solve(41, 10)
```
  LikeLike
- GeoffR 4:45 pm on 26 May 2023 Permalink | Reply
```
primes = (2, 5, 7, 11, 13, 17, 19)  # prime 3 excluded from description

# The highest product of primes to power of 10 in the tuple below
# .. i.e. (7,11,13,17,19) gives a 56 digit number
# .. so a more than an adequate range to find a 41 digit product.

from itertools import combinations

for P1 in combinations(primes, 5):
    # choose 5 primes from a tuple of 7 primes
    p1, p2, p3, p4, p5 = P1

    num = p1**10 * p2**10 * p3**10 * p4**10 * p5**10
    if len(str(num)) == 41:
       print(f"41 digit number is {num}")
       exit()  # only one answer needed

# 41 digit number is 10100451202102522101200450100010000000000
```
  LikeLike

Jim Randell 10:17 am on 7 March 2023 Permalink | Reply
Tags: by: Nick MacKinnon

Teaser 2714: Group of death

From The Sunday Times, 28th September 2014 [link] [link]

In a Champions League group four teams play each other twice with the top two qualifying for the next stage. If two teams are level on points then their head-to-head results determine their position. In one group, after five games each, the teams in order were A, B, C, D, each with a different number of points. At that stage team A was bound to qualify and teams B and C could still top the group. But the final two games were draws. All games had different results, no game had more than five goals, and team D had the same number of “goals for” as “goals against”. Team A scored fewer goals than any other team whilst D scored more than any other.

What were the results of the two games B v C?

[teaser2714]

Jim Randell 10:18 am on 7 March 2023 Permalink | Reply

I am assuming the point are allocated as: “3 points for a win, 1 point for a draw”. (Although the puzzle also seems to work if “2 points for a win” is used instead).

Each team plays their three opponents twice, so there are 12 matches in total.

There are not more than 5 goals scored in any match, so possible scores are:

drawn = (0, 0) (1, 1) (2, 2)
won/list = (1, 0) (2, 0) (3, 0) (4, 0) (5, 0) (2, 1) (3, 1) (4, 1) (3, 2)

This accounts for all 12 matches, so each score must be used.

And the final 2 matches are drawn, so there is exactly 1 draw in the first 10 matches.

Programming a constructive solution for this puzzle is quite involved. I hope that a manual solution is more fun. I used the [[ Football() ]] helper class from the enigma.py library to save on some of the coding, but things are complicated a bit by the fact each pair of teams meet twice, and there is nothing to distinguish the two games, so to avoid duplicated solutions I store the results for the two games in order with the “best” game (from the first team’s point of view) given first.

This Python program runs in 253ms.

from enigma import (Football, subsets, partitions, update, compare, ordered, rev, join, map2str, printf)

football = Football(points=dict(w=3, d=1))

# possible scores, no game had more than 5 goals
scores = dict()
scores['d'] = [(0, 0), (1, 1), (2, 2)]
scores['w'] = [(1, 0), (2, 0), (2, 1), (3, 0), (3, 1), (3, 2), (4, 0), (4, 1), (5, 0)]
scores['l'] = list(map(rev, scores['w']))

# label the matches (each label corresponds to 2 matches)
teams = "ABCD"
matches = list(x + y for (x, y) in subsets(teams, size=2))

# complete possible match pairs (additional win/lose outcomes)
pairs = {
  '-': ['ww', 'wl', 'll'],
  'x': ['wx', 'lx'],
  'd': ['wd', 'dl'],
}

# swap pairs into canonical order
_pair = { 'dw': 'wd', 'lw': 'wl', 'ld': 'dl' }
pair = lambda x: _pair.get(x, x)

# allocate win/lose outcomes to matches
def allocate_matches(ks, ms):
  # are we done?
  if not ks:
    yield ms
  else:
    k = ks[0]
    v = ms.get(k, '-')
    if len(v) > 1:
      # skip this key
      yield from allocate_matches(ks[1:], ms)
    else:
      # allocate both outcomes
      for x in pairs[v]:
        yield from allocate_matches(ks[1:], update(ms, [(k, x)]))

# allocate scores to matches
def allocate_scores(ks, ms, used=set(), ss=dict()):
  # are we done?
  if not ks:
    yield (ss, used)
  else:
    k = ks[0]
    if k in ss:
      # skip this key
      yield from allocate_scores(ks[1:], ms, used, ss)
    else:
      # allocate both scores
      (a, b) = ms[k]
      for x in scores[a]:
        x_ = ordered(*x)
        if x_ in used: continue
        for y in scores[b]:
          y_ = ordered(*y)
          # remove duplicate solutions
          if (a == b and not x_ > y_) or y_ in used: continue
          yield from allocate_scores(ks[1:], ms, used.union({x_, y_}), update(ss, [(k, (x, y))]))

# extract match/teams values from dict d
def extract(d, t, fn):
  (gs, ts) = (list(), list())
  for (k, v) in d.items():
    if t in k:
      gs.extend(v)
      ts.extend([(0 if k[0] == t else 1)] * len(v))
  return fn(gs, ts)

# construct the table for team t, using matches in ms
table = lambda ms, t: extract(ms, t, football.table)

# goals for/against team t, using scores in ss
goals = lambda ss, t: extract(ss, t, football.goals)

# output the matches and scores
def output_matches(ms, ss, **kw):
  def _process(d, fn):
    d_ = dict()
    for (k, (a, b)) in d.items():
      d_[k] = a
      d_[rev(k)] = fn(b)
    return d_
  football.output_matches(_process(ms, football.swap), _process(ss, rev), **kw)

# does team <x> beat team <y> in the table <tbl> and match outcomes <ms>?
def beats(x, y, tbl, ms):
  # a team does not beat itself
  if x == y: return 0
  # can it be decided on points?
  r = compare(tbl[x].points, tbl[y].points)
  if r == 1: return 1
  if r == -1: return 0
  # can it be decided on the outcome of head-to-head games?
  (k, a, b) = ((x + y, 0, 1) if x < y else (y + x, 1, 0))
  gs = ms[k]
  (X, Y) = (football.table(gs, [a, a]), football.table(gs, [b, b]))
  r = compare(X.points, Y.points)
  if r == 1: return 1
  if r == -1: return 0
  # there may be other ways to order the teams (e.g. goal difference
  # or goals scored), but these are not mentioned
  return 0

# check all possible final 2 games for required scenario
def check(ms, f1, f2):
  # check conditions for teams A, B, C
  fB = fC = 0
  for (g1, g2) in football.games('wdl', repeat=2):
    ms_ = update(ms, [(f1, pair(ms[f1][0] + g1)), (f2, pair(ms[f2][0] + g2))])
    # calculate the final table
    tbl = dict((t, table(ms_, t)) for t in teams)
    # can A fail to qualify? (i.e. fail to beat at least 2 of the other teams)
    if not (sum(beats('A', t, tbl, ms_) for t in teams) >= 2): return False
    # can B come top? (i.e. beat the other 3 teams)
    if fB == 0 and sum(beats('B', t, tbl, ms_) for t in teams) == 3: fB = 1
    # can C come top? (i.e. beat the other 3 teams)
    if fC == 0 and sum(beats('C', t, tbl, ms_) for t in teams) == 3: fC = 1
  return (fB and fC)

# find viable scenarios
def generate():
  # choose the final 2 matches (which are draws)
  for ((t1, t2), (t3, t4)) in partitions(teams, 2):
    (f1, f2) = (t1 + t2, t3 + t4)
    ms0 = { f1: 'x', f2: 'x' }
    # of the remaining matches exactly 1 of them is a draw
    for d in matches:
      ms1 = update(ms0, [(d, ('dx' if d in ms0 else 'd'))])
      # choose win/lose outcomes for the remaining matches
      for ms2 in allocate_matches(matches, ms1):
        # calculate the table before the final 2 matches are played
        (A, B, C, D) = (table(ms2, t) for t in teams)
        if not (A.points > B.points > C.points > D.points): continue
        # in the final 2 games B or C _could_ gain the top spot
        # so A cannot be more than 3 points ahead of C
        if A.points > C.points + 3: continue
        # check all possible final 2 games
        if not check(ms2, f1, f2): continue

        # now include the final games (both are, in fact, drawn)
        ms3 = update(ms2, list((k, pair(ms2[k][0] + 'd')) for k in (f1, f2)))
        (A, B, C, D) = (table(ms3, t) for t in teams)

        # allocate scores for D
        (Ds, As) = (list(k for k in matches if t in k) for t in "DA")
        for (ss1, us1) in allocate_scores(Ds, ms3):
          # D has equal for and against (and scored more goals than any other team)
          (fD, aD) = goals(ss1, 'D')
          if fD != aD: continue
          # allocate remaining scores for A
          for (ss2, us2) in allocate_scores(As, ms3, us1, ss1):
            # A scored fewer goals than any other team
            (fA, aA) = goals(ss2, 'A')
            if not (fA < fD): continue
            # allocate remaining scores (B and C)
            for (ss3, us3) in allocate_scores(matches, ms3, us2, ss2):
              ((fB, aB), (fC, aC)) = (goals(ss3, t) for t in "BC")
              if not (fA < fB < fD and fA < fC < fD): continue

              # yield scenario (matches, scores, final2, goals for/against)
              yield (ms3, ss3, (f1, f2), ((fA, aA), (fB, aB), (fC, aC), (fD, aD)))


# look for viable scenarios
for (ms, ss, fs, gfa) in generate():
  # output scenarios as we find them
  output_matches(ms, ss, end=None)
  printf("final games = {fs}", fs=join(fs, sep=", "))
  printf("goals for/against = {gfa}", gfa=map2str(zip(teams, gfa), arr=": ", enc=""))
  BCs = ss['BC']
  # answer is the scores in the B vs C matches
  printf("-> B vs C = {BCs}", BCs=join(BCs, sep=" "))
  printf()

Solution: The scores in the B vs. C games were: 4-1 and 1-1.

And the B vs C 1-1 draw was one of the two final games.

There are two possible scenarios. Here is one of them:

A vs B: 3-0, 2-0
A vs C: 0-0, 0-4
A vs D: 1-0, (2-2)
B vs C: 4-1, (1-1)
B vs D: 3-1, 2-1
C vs D: 3-2, 0-5

(with the two final draws indicated in brackets).

Before the final 2 games (A vs D, B vs C) are the points are:

A: 10 points
B: 9 points
C: 7 points
D: 3 points

If B wins their final game then they will have 12 points, and top the table (providing A does not win their final game).

If C wins their final game then they will have 10 points, and if A loses their final game they will also have 10 points, so the top position comes down to the result of the A vs C games. And these are a draw and a win for C, so C comes out on top.

A is guaranteed to finish higher than D, and unless C wins (and A loses) their final game also higher than C. But if C does win, then B must lose, and A will finish higher than B. So A is guaranteed to finish in the top 2 teams (and qualify for the next round).

When the final 2 games are played they are both drawn, and the results are:

A: 11 points; goals = 8 for, 6 against
B: 10 points; goals = 10 for, 9 against
C: 8 points; goals = 9 for, 12 against
D: 4 points; goals = 11 for, 11 against

So A and B go through to the next round.

The other scenario plays out similarly, but the games won 3-1 and 3-2 are swapped with each other. Although this second scenario could be eliminated if the puzzle text stated that D were the only team with the same number of goals for as goals against. (As B ends up with 10 goals for and 10 goals against).

We can use these 2 scenarios to construct further solutions where the order of the two matches played by pairs of teams are swapped over.

LikeLike

Jim Randell 9:01 am on 8 November 2022 Permalink | Reply
Tags: by: Nick MacKinnon
Teaser 2695: Powers behind the thrones
From The Sunday Times, 18th May 2014 [link] [link]

Gold sovereigns were minted in London for most years from the great recoinage in 1817 until Britain left the gold standard in 1917. I have a collection of eight sovereigns from different years during that period, the most recent being an Edward VII sovereign (he reigned from 1902 until 1910). I noticed that the year on one of the coins is a perfect square and this set me thinking about other powers. Surprisingly, it turns out that the product of the eight years on my coins is a perfect cube.

What (in increasing order) are those eight years?

[teaser2695]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell and Hugh Casement are discussing. Toggle Comments
- Jim Randell 9:02 am on 8 November 2022 Permalink | Reply
  The values were are interested in lie in the interval [1817, 1910].
  
  And the only square in that range is 1849 (= 43²), so that must be one of the 8 values.
  
  And the largest value is in the interval [1902, 1910].
  
  This Python program finds the prime factors for numbers in the required range, and then constructs sets of 8 values whose prime factors, when combined, all appear a multiple of 3 times, and so the product of the values is a cube.
  
  It runs in 164ms.
  
  Run: [ @replit ]
```
from enigma import (irange, prime_factor, multiset, delete, append, printf)

# find values whose product is a cube
# k = remaining values for find (int)
# vs = values so far (list)
# fs = prime factors so far (multiset)
# d = map of value -> prime factors (multiset)
# ks = candidate keys in d (list)
def solve(n, vs, fs, d, ks):
  if n == 0:
    # check all prime exponents are multiples of 3
    if all(x % 3 == 0 for x in fs.values()):
      yield vs
  elif not len(ks) < n:
    # add in a new candidate
    for (i, k) in enumerate(ks):
      # and solve for the remaining candidates
      yield from solve(n - 1, append(vs, k), fs.combine(d[k]), d, ks[i + 1:])

# collect candidate numbers and their prime factors (as a multiset)
d = dict((n, multiset.from_pairs(prime_factor(n))) for n in irange(1817, 1910))

# find factors that appear fewer than 3 times in total
while True:
  # count the factors (by combining values from each of the numbers)
  m = multiset.from_dict(*d.values())
  fs = set(k for (k, v) in m.items() if v < 3)
  if not fs: break
  # and remove any numbers which involve any of these factors
  d = delete(d, (k for (k, v) in d.items() if any(p in fs for p in v)))

# 1849 is one of the values in the set
(vs1, fs1) = ([1849], d[1849])

# and the max value is between 1902 and 1910
for v in irange(1902, 1910):
  if v not in d: continue
  vs2 = append(vs1, v)
  fs2 = fs1.union(d[v])

  # solve for the remaining 6 values
  ks = sorted(k for k in d.keys() if k < v and k not in vs2)
  for vs in solve(6, vs2, fs2, d, ks):
    # output solution
    printf("years = {vs}", vs=sorted(vs))
```
  Solution: The eight years are: 1820, 1836, 1849, 1859, 1870, 1890, 1892, 1904.
  
  So we have:
  
  numbers = (1820, 1836, 1849, 1859, 1870, 1890, 1892, 1904)
  factors = (2^12, 3^6, 5^3, 7^3, 11^3, 13^3, 17^3, 43^3)
  factors = (2^4, 3^2, 5, 7, 11, 13, 17, 43)^3
  
  And the product of the numbers is: (2^4, 3^2, 5, 7, 11, 13, 17, 43)^3 = 526846320^3.
  
  LikeLike
- Hugh Casement 8:31 am on 10 November 2022 Permalink | Reply
  
  We can get part of the way by analysis. We need another factor 43, so 1892 must be one of the years.
  The only integer in the range 1902 to 1910 with a small enough largest prime factor to allow us to find two more is 1904 = 2^4 × 7 × 17.
  After that I think trial and error (i.e. by computer) is needed.
  
  LikeLike
  - Jim Randell 11:03 am on 10 November 2022 Permalink | Reply
    
    @Hugh: My manual solution proceeded as follows:
    
    Armed with the prime factorisations of the numbers between 1817 and 1910 (which I did not compute manually), we quickly find 1849, 1892, 1904 are on the list.
    
    Then we need more factors of 17, and there are only 2 candidates: 1836 and 1870. Both of which must be included. So we now have 5 of the 8 numbers on the list.
    
    We can eliminate numbers with a factor of 29 (1827, 1856, 1885).
    
    Considering numbers with factors of 13 (1820, 1859, 1872), if any of these are included it must be 1859 and just one of the others.
    
    Adding 1859 and 1820 to the list leaves factors of (2, 5, 7) to find, and the only candidate is 1890, and this does indeed give a viable list.
    
    And I didn’t look for further solutions.
    
    LikeLike

	Jim Randell on Teaser 2444: [Pat’s…
	Jim Randell on Teaser 2447: [Number grid…
	Ellen Napier on Teaser 3317: Hitting all the…
	Jim Randell on Teaser 3317: Hitting all the…
	Ellen Napier on Teaser 3317: Hitting all the…
	Ruud on Teaser 3317: Hitting all the…
	Frits on Teaser 3317: Hitting all the…
	Jim Randell on Teaser 3317: Hitting all the…

Search

Recent Posts

Recent Comments

Archives

Categories

Subscribe

RSS Links

Site Stats

Meta

Tagged: by: Nick MacKinnon Toggle Comment Threads | Keyboard Shortcuts

Jim Randell 8:13 am on 22 April 2026 Permalink | Reply Tags: by: Lachlan MacKinnon, by: Nick MacKinnon

Rate this:

Share:

Jim Randell 8:14 am on 22 April 2026 Permalink | Reply

Reply Cancel reply

Jim Randell 10:41 am on 8 April 2026 Permalink | Reply Tags: by: Nick MacKinnon, flawed ( 55 )

Rate this:

Share:

Jim Randell 10:42 am on 8 April 2026 Permalink | Reply

Jim Randell 2:44 pm on 8 April 2026 Permalink | Reply

Jim Randell 8:39 am on 3 April 2026 Permalink | Reply Tags: by: Nick MacKinnon

Rate this:

Share:

Jim Randell 8:40 am on 3 April 2026 Permalink | Reply

Jim Randell 7:29 am on 13 March 2026 Permalink | Reply Tags: by: Nick MacKinnon

Rate this:

Share:

Jim Randell 7:30 am on 13 March 2026 Permalink | Reply

ruudvanderham 2:22 pm on 13 March 2026 Permalink | Reply

ruudvanderham 4:46 pm on 13 March 2026 Permalink | Reply

Jim Randell 9:34 am on 3 February 2026 Permalink | Reply Tags: by: Nick MacKinnon, flawed ( 55 )

Rate this:

Share:

Jim Randell 9:35 am on 3 February 2026 Permalink | Reply

Jim Randell 9:16 am on 20 January 2026 Permalink | Reply Tags: by: Nick MacKinnon

Rate this:

Share:

Jim Randell 9:17 am on 20 January 2026 Permalink | Reply

Ruud 10:52 am on 20 January 2026 Permalink | Reply

Frits 8:33 am on 21 January 2026 Permalink | Reply

Jim Randell 9:11 am on 21 January 2026 Permalink | Reply

Jim Randell 9:40 am on 21 January 2026 Permalink | Reply

Frits 1:10 pm on 21 January 2026 Permalink | Reply

Jim Randell 8:55 am on 2 December 2025 Permalink | Reply Tags: by: Nick MacKinnon

Rate this:

Share:

Jim Randell 8:55 am on 2 December 2025 Permalink | Reply

Jim Randell 7:42 am on 25 November 2025 Permalink | Reply Tags: by: Nick MacKinnon

Rate this:

Share:

Jim Randell 7:43 am on 25 November 2025 Permalink | Reply

Frits 4:58 am on 30 November 2025 Permalink | Reply

Jim Randell 8:17 am on 30 November 2025 Permalink | Reply

Frits 3:51 am on 1 December 2025 Permalink | Reply

Jim Randell 7:32 am on 22 August 2025 Permalink | Reply Tags: by: Nick MacKinnon

Rate this:

Share:

Jim Randell 7:32 am on 22 August 2025 Permalink | Reply

Jim Randell 8:59 am on 2 April 2025 Permalink | Reply Tags: by: Nick MacKinnon

Rate this:

Share:

Jim Randell 9:00 am on 2 April 2025 Permalink | Reply

Frits 1:20 pm on 2 April 2025 Permalink | Reply

Jim Randell 1:35 pm on 2 April 2025 Permalink | Reply

Frits 2:17 pm on 2 April 2025 Permalink | Reply

Jim Randell 2:27 pm on 2 April 2025 Permalink | Reply

Frits 1:15 pm on 3 April 2025 Permalink | Reply

Frits 6:20 pm on 3 April 2025 Permalink | Reply

Jim Randell 7:57 am on 18 March 2025 Permalink | Reply Tags: by: Nick MacKinnon

Rate this:

Share:

Jim Randell 7:57 am on 18 March 2025 Permalink | Reply

Jim Randell 4:43 pm on 31 December 2024 Permalink | Reply Tags: by: Nick MacKinnon

Rate this:

Share:

Jim Randell 4:44 pm on 31 December 2024 Permalink | Reply

GeoffR 7:34 pm on 1 January 2025 Permalink | Reply

Jim Randell 11:16 am on 19 November 2024 Permalink | Reply Tags: by: Nick MacKinnon

Rate this:

Share:

Jim Randell 8:13 am on 22 April 2026 Permalink | Reply
Tags: by: Lachlan MacKinnon, by: Nick MacKinnon

Jim Randell 10:41 am on 8 April 2026 Permalink | Reply
Tags: by: Nick MacKinnon, flawed ( 55 )

Jim Randell 8:39 am on 3 April 2026 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 7:29 am on 13 March 2026 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 9:34 am on 3 February 2026 Permalink | Reply
Tags: by: Nick MacKinnon, flawed ( 55 )

Jim Randell 9:16 am on 20 January 2026 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 8:55 am on 2 December 2025 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 7:42 am on 25 November 2025 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 7:32 am on 22 August 2025 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 8:59 am on 2 April 2025 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 7:57 am on 18 March 2025 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 4:43 pm on 31 December 2024 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 11:16 am on 19 November 2024 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 10:43 am on 17 September 2024 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 8:54 am on 19 March 2024 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 8:46 am on 22 August 2023 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 10:43 am on 4 July 2023 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 10:33 am on 25 May 2023 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 10:17 am on 7 March 2023 Permalink | Reply
Tags: by: Nick MacKinnon

Jim Randell 9:01 am on 8 November 2022 Permalink | Reply
Tags: by: Nick MacKinnon