teaser | S2T2 | Page 32

Updates from July, 2022 Toggle Comment Threads | Keyboard Shortcuts

Jim Randell 9:10 am on 28 July 2022 Permalink | Reply
Tags: by: Michael Fletcher ( 18 )
Teaser 2726: Christmas star
From The Sunday Times, 21st December 2014 [link] [link]

I asked Peter to place the numbers 1 to 10 at the ten intersection points of the Christmas star so that in each of the five lines the four numbers added to the same total. He found that this was impossible so instead he did it with the numbers 1 to 9 together with just one of those digits repeated. In his answer there was just one line in which that digit did not appear.

[In ascending order] what were the four numbers in that line?

[teaser2726]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 9:12 am on 28 July 2022 Permalink | Reply
  (See also: Enigma 1063).
  
  I assume were are talking about a layout like this:
  
  There are 5 lines, and each of the numbers appears on two of the lines.
  
  If we add the lines we will be counting each number twice, and the total will be 5 times the common sum, T.
  
  So, if X is the repeated digit we have:
  
  2 × (1 + 2 + … + 9 + X) = 5 × T
  T = 18 + (2/5)X
  
  Hence: X = 5, and T = 20.
  
  To remove duplicate solutions we can suppose the line that doesn’t include X is (B, C, D, E) and that B < E.
  
  The following run file executes in 98ms.
  
  Run: [ @replit ]
```
#! python3 -m enigma -rr

# suppose the line with no repeated digit is BCDE

SubstitutedExpression

--digits="1-9"
--distinct="BCDE"

# the 5 lines have the same sum (= 20)
"A + C + F + I = 20"
"A + D + G + J = 20"
"B + C + D + E = 20"
"B + F + H + J = 20"
"E + G + H + I = 20"

# all 9 digits are used
"len({A, B, C, D, E, F, G, H, I, J}) = 9"

# 5 is in all the lines except BCDE
"5 not in {B, C, D, E}"
"5 in {A, C, F, I}"
"5 in {A, D, G, J}"
"5 in {B, F, H, J}"
"5 in {E, G, H, I}"

# remove duplicate solutions
"B < E"

--answer="ordered(B, C, D, E)"
--template=""
```
  Solution: The four numbers on the line without the repeated digit are: 1, 3, 7, 9.
  
  There are 12 essentially different layouts, here is one:
  
  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 9:17 am on 26 July 2022 Permalink | Reply
Tags: by: Dr V W Bryant ( 5 )
Brain-Teaser 727: Right hand
From The Sunday Times, 22nd June 1975 [link]

When South, who was bored with being dummy, had left the card room of the Logic Club for good, West extracted four kings, three queens and two jacks from the pack, showed them round, shuffled them, and dealt three cards to each of the three.

“Forget the suits”, he said. “Let each of us look at his own three cards and see if he can make a sure statement about any kings, queens or jacks in the next man’s hand; we will use as evidence what we see in our own hands and what we hear each other say.

They played with the full rigours of logic. West began by announcing that he could say nothing about North’s hand; North then said that he could say nothing about East’s hand; thereupon East said that he could deduce the value of one card — and one only — in West’s hand.

What can you say about the cards that were dealt to East?

This puzzle is included in the book The Sunday Times Book of Brain-Teasers: Book 2 (1981).

[teaser727]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell and John Crabtree are discussing. Toggle Comments
- Jim Randell 9:18 am on 26 July 2022 Permalink | Reply
  There are 9 possible hands that could be dealt to W, and in each case W would be able to say something about the cards that are dealt to N:
  
  KKK → N holds at most 1K
  KKQ → N holds at most 2K, at most 2Q
  KKJ → N holds at most 2K, at most 1J
  KQQ → N holds at most 1Q
  KQJ → N holds at most 2Q, at most 1J
  KJJ → N holds no J
  QQQ → N holds at least 1K, no Q
  QQJ → N holds at least 1K, at most 1Q, at most 1J
  QJJ → N holds at least 1K, at most 2Q, no J
  
  So let’s use a tighter definition that each must declare if they know for certain cards that are held by the next player.
  
  This reduces the list to:
  
  QQQ → N holds at least 1K
  QQJ → N holds at least 1K
  QJJ → N holds at least 1K
  
  And this allows us to find an answer to the puzzle.
  
  This Python program runs in 58ms. (Internal runtime is 1.2ms).
  
  Run: [ @replit ]
```
from collections import defaultdict
from enigma import (multiset, join, printf)

# format a hand
fmt = lambda x: join(x).upper()

# deal groups of <k> cards from <cards>
def deal(cards, k, ss=[]):
  if not cards:
    yield ss
  else:
    # choose the first hand
    for hand in cards.subsets(size=3):
      yield from deal(cards.difference(hand), k, ss + [tuple(hand.sorted())])

# initial cards
cards = multiset(K=4, Q=3, j=2)
values = sorted(cards.keys())

# possible deals
hands = list(deal(cards, 3))

# look at W's hand, record the number of Ks, Qs, Js in N's
w = defaultdict(lambda: defaultdict(set))
for (W, N, E) in hands:
  for k in values:
    w[W][k].add(N.count(k))

# W can't be sure of any cards held by N
Ws = set(W for (W, d) in w.items() if all(0 in d[k] for k in values))
printf("[W = {Ws}]", Ws=join(map(fmt, Ws), sep=", ", enc="{}"))

# look at N's hand, record the number of Ks, Qs, Js in E's
n = defaultdict(lambda: defaultdict(set))
for (W, N, E) in hands:
  if W not in Ws: continue
  for k in values:
    n[N][k].add(E.count(k))

# N can't be sure of any cards held by E
Ns = set(N for (N, d) in n.items() if all(0 in d[k] for k in values))
printf("[N = {Ns}]", Ns=join(map(fmt, Ws), sep=", ", enc="{}"))

# look at E's hand, record the number of Ks, Qs, Js in W's
e = defaultdict(lambda: defaultdict(set))
for (W, N, E) in hands:
  if W not in Ws or N not in Ns: continue
  for k in values:
    e[E][k].add(W.count(k))

# E can be sure of exactly 1 card held by W
for (E, d) in e.items():
  if sorted(min(v) for v in d.values()) == [0, 0, 1]:
    printf("E = {E}", E=fmt(E))
```
  Solution: East held a King, a Queen, and a Jack.
  
  LikeLike
  - John Crabtree 6:50 pm on 26 July 2022 Permalink | Reply
    
    In manually reaching the same solution, I concluded that West must hold at least one King, and that North must hold at least one King and one Queen. That gives three possible sets of hands.
    Do you agree? Thanks.
    
    LikeLike
    - Jim Randell 8:20 am on 27 July 2022 Permalink | Reply
      
      @John: Yes, I found three possible sets of hands:
      
      W = KQJ; N = KKQ; E = KQJ
      W = KKJ; N = KQQ; E = KQJ
      W = KKQ; N = KQJ; E = KQJ
      
      LikeLike
Jim Randell 2:04 pm on 24 July 2022 Permalink | Reply
Tags: by: C Skeffington Quin ( 11 ), flawed ( 55 )
Brain-Teaser 159: Fallen leaves
From The Sunday Times, 26th April 1964 [link]

Three leaves fall from a book. The total of the page numbers remaining in the second half of the book is now three times the total of the page numbers remaining in the first half.

The total of the page numbers on the fallen leaves lies between 1050 and 1070, and is the highest which could have produced this effect.

How many numbered pages did the book contain originally?

I found many solutions, which improve on the published answer. So I have marked the puzzle as flawed.

This puzzle is included in the book Sunday Times Brain Teasers (1974).

[teaser159]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 2:06 pm on 24 July 2022 Permalink | Reply
  I think this puzzle is flawed, as I found many solutions that seem to satisfy the puzzle text, and are different from the published solution.
  
  If we suppose the book consists of n leaves (= 2n pages), and that the leaves are 1|2, 3|4, …, (2n − 1)|(2n).
  
  And the two halves of the book are pages 1 – n and (n + 1) – (2n).
  
  Then the initial sum of page numbers in each half of the book are:
  
  first half = sum(1 .. n) = n(n + 1)/2
  second half = sum(n+1 .. 2n) = n(3n + 1)/2
  
  Now, if the three leaves removed are (2a − 1)|(2a), (2b − 1)|(2b), (2c − 1)|(2c).
  
  Then the total of the page numbers removed is t = 4(a + b + c) − 3, and this is in the range 1050 – 1070.
  
  So (a + b + c) is in the range 264 – 268, and we want this to take on the highest possible value (i.e. 268 if possible, which corresponds to t = 1069).
  
  If the sum of the removed pages in the first and second halves is t1, t2 (t1 + t2 = t), then we have:
  
  n(3n + 1)/2 − t2 = 3(n(n + 1)/2 − t1)
  n = 3.t1 − t2
  
  This Python program starts looking for values of t from 268 down to 264, and stops when it finds a value that gives viable books. It runs in 74ms. And it finds many possible solutions.
```
from enigma import (irange, decompose, printf)

# solve with leaves removed (even page numbers given)
def solve(*vs):
  # calculate the removed page numbers
  (x, y, z) = (2 * v for v in vs)
  ps = (x - 1, x, y - 1, y, z - 1, z)
  # split the pages at index i
  for i in irange(2, 4):
    t1 = sum(ps[:i])
    t2 = sum(ps[i:])
    # calculate the number of leaves (so there are 2n pages)
    n = 3 * t1 - t2
    if n < 3 or ps[-1] > 2 * n: continue
    # and check the split occurs between the halves
    if i > 0:
      if ps[i - 1] > n: continue
    if i < 6:
      if not (ps[i] > n): continue
    yield (n, ps, t1, t2)

# record solutions (number of pages = twice the number of leaves)
ss = set()

# t = a + b + c
for t in irange(268, 264, step=-1):
  # calculate possible a, b, c values
  for (a, b, c) in decompose(t, 3):
    for (n, ps, t1, t2) in solve(a, b, c):
      printf("[t={t}: a={a} b={b} c={c} -> {ps}; t1={t1} t2={t2}; n={n}]")
      ss.add(2 * n)
  # are we done?
  if ss:
    printf("pages = {ss}", ss=sorted(ss))
    break
```
  Solution: The book could have: 310, 318, 342, 350, 374, 406, 438, 470, 502, 534, 566, 598, 630, 662, 694, 6414 pages.
  
  Here is one of the solutions found:
  
  If the book has 203 leaves = 406 pages, numbered 1|2, 3|4, …, 203|204, …, 405|406.
  
  Then the sum of the page numbers in the first half of the book is: sum(1..203) = 20706.
  
  And the sum of the page numbers in the second half of the book is: sum(204..406) = 61915.
  
  (Note that if leaf 203|204 is removed, that is one page from each half of the book).
  
  Now, if pages 1|2, 157|158, 375|376 are removed (total = 1069, the largest possible value).
  
  Then the pages removed from the first half are: 1, 2, 157, 158; sum = 318, so the sum of the remaining pages in the first half is 20706 − 318 = 20388.
  
  And the pages removed from the second half are: 375, 376; sum = 751, so the sum of the remaining pages in the second half is 61915 − 751 = 61164.
  
  And: 61164 = 3 × 20388, as required.
  
  The published solution (and that given in the 1974 book) is that the book initially had 302 pages (i.e. 151 leaves), and the removed pages are 75|76, 151|152, 301|302. Which gives a total of 1057.
  
  But I have shown above that this is not the largest total possible.
  
  It was also noted: “Only 4 correct answers in a very small entry”. So it seems I wasn’t the only one that had issues with this puzzle.
  
  The solution in the book only considers 3 ways that leaves can be removed: 1 from the first half + 2 from the second half; 2 from the first half + 1 from the second half; 1.5 from each half. In terms of pages these are 2+4, 3+3, 4+2, but my program also considers 0+6, 1+5, 5+1, 6+0. However the example I give is a 4+2 combination, which should be accounted for by the published solution. But it has arrived at the conclusion that the maximum viable total of the numbers on the removed pages for a book with x leaves is 7x, so 1057 is the maximum possible (with 151 leaves), but I think this is faulty reasoning.
  
  (The only thing I can think of is that the two halves of the book are considered after the leaves have been removed. (Although the solution given in the book doesn’t seem to support this). But even with this interpretation there are multiple solutions with a total of 1069 – any that removes 3 pages from the first half and three from the second half will leave the boundary unchanged).
  
  LikeLike

Jim Randell 4:03 pm on 22 July 2022 Permalink | Reply
Tags: by: Angela Newing ( 39 )

Teaser 3122: Bank robbery

From The Sunday Times, 24th July 2022 [link] [link]

Five witnesses were interviewed following a robbery at the bank in the High Street. Each was asked to give a description of the robber and his actions.

The details given were: height; hair colour; eye colour; weapon carried; escape method.

Witness 1: short; fair; brown; cricket bat; motorbike.

Witness 2: tall; fair; grey; gun; car.

Witness 3: tall; dark; brown; crowbar; motorbike.

Witness 4: short; ginger; blue; knife; car.

Witness 5: tall; dark; blue; stick; pushbike.

When the police caught up with the perpetrator, they found that each of the five witnesses had been correct in exactly two of these characteristics.

What was the robber carrying, and how did he get away?

[teaser3122]

Jim Randell 4:15 pm on 22 July 2022 Permalink | Reply

It is straightforward to try all possible combinations. (Assuming the robber has a unique single value for each characteristic).

I include an “other” value for each characteristic to account for possibilities where none of the witnesses have correctly described it.

This Python program runs in 58ms. (Internal runtime is 1.9ms).

Run: [ @replit ]

from enigma import (cproduct, join, printf)

# descriptions
descs = [
  dict(S='short', T='tall', X='other'),
  dict(F='fair', D='dark', G='ginger', X='other'),
  dict(R='brown', G='grey', L='blue', X='other'),
  dict(B='cricket bat', G='gun', C='crowbar', K='knife', S='stick', X='other'),
  dict(M='motorbike', C='car', P='pushbike', X='other'),
]

# statements
statements = [ 'SFRBM', 'TFGGC', 'TDRCM', 'SGLKC', 'TDLSP' ]

# how many characteristics are correct?
correct = lambda xs, ys: sum(x == y for (x, y) in zip(xs, ys))

# consider characteristics of the perp
for cs in cproduct(d.keys() for d in descs):
  # each witness gave 2 correct statements
  if all(correct(xs, cs) == 2 for xs in statements):
    # output solution
    printf("{cs}", cs=join((d[k] for (d, k) in zip(descs, cs)), sep=", "))

Solution: The robber was carrying a knife. He made his escape by motorbike.

In fact we can determine a complete description:

height = tall
hair = fair
eyes = blue
weapon = knife
vehicle = motorbike

LikeLike

Jim Randell 8:48 am on 26 July 2022 Permalink | Reply
And here is a solution using the [[ SubstitutedExpression ]] solver from the enigma.py library.

The following run file executes in 72ms.

Run: [ @replit ]
```
#! python3 -m enigma -rr

# statements:
#
#  A = height is short; B = height is tall
#  C = hair is fair; D = hair is dark; E = hair is ginger
#  F = eyes are brown; G = eyes are grey; H = eyes are blue
#  I = weapon is cricket bat; J = weapon is gun; K = weapon is crowbar; L = weapon is knife; M = weapon is stick
#  N = vehicle is motorbike; P = vehicle is car; Q = vehicle is pushbike

SubstitutedExpression

# binary statements
--base=2
--distinct=""

# at most one of the statements in each category is true
"not (A + B > 1)"
"not (C + D + E > 1)"
"not (F + G + H > 1)"
"not (I + J + K + L + M > 1)"
"not (N + P + Q > 1)"

# witnesses each make exactly 2 true statements
"A + C + F + I + N == 2"
"B + C + G + J + P == 2"
"B + D + F + K + N == 2"
"A + E + H + L + P == 2"
"B + D + H + M + Q == 2"

--template=""
```
This construction also leads to a simple manual solution:

In the matrix of statements (lines 25 – 29), each row sums to 2. So the total sum of all matrix elements is 10.

Looking at the columns of the matrix we get the following potential column totals:

height: 0 (X), 2 (A), 3 (B)
hair: 0 (X), 1 (E), 2 (C, D)
eyes: 0 (X), 1 (G), 2 (F, H)
weapon: 0 (X), 1 (I, J, K, L, M)
vehicle: 0 (X), 1 (Q), 2 (N, P)

A grand total of 10 can only be achieved by taking the maximum value for each column.

So we can eliminate all the X’s and A, E, G, Q (all of which must = 0). Hence B = 1.

One of C, D = 1 (and the other = 0). If D = 1, then witnesses 3 and 5 have achieved their 2 correct statements so: F, H, K, M, N = 0, but one of F, H = 1. So D = 0 and C = 1.

We can then complete the assignment of values, and determine the true statements are: B, C, H, L, N.

LikeLike

GeoffR 5:51 pm on 23 July 2022 Permalink | Reply


# List of possible witness statements
statements = []

# Witness statements
W1 = ['short', 'fair', 'brown', 'cricket bat', 'motorbike']
W2 = ['tall', 'fair', 'grey', 'gun', 'car' ]
W3 = ['tall', 'dark', 'brown', 'crowbar', 'motorbike' ]
W4 = ['short', 'ginger', 'blue', 'knife', 'car' ] 
W5 = ['tall', 'dark', 'blue', 'stick', 'pushbike' ]

# Form lists of all possible witness statements
for a in ('short', 'tall'): 
  for b in ('fair', 'dark', 'ginger'):
    for c in ('brown', 'grey', 'blue'):
      for d in ('cricket bat', 'gun', 'crowbar', 'knife', 'stick'):
        for e in ('motorbike', 'car', 'pushbike'):
          statements.append([a, b, c, d, e])

for st in statements:
    a, b, c, d, e = st
    # Two statements from five are true for each witness
    # test Witness No.1 statements
    if sum([a == 'short', b == 'fair', c == 'brown', \
            d == 'cricket bat', e == 'motorbike']) == 2:
      
      #test Witness No.2 statements
      if sum([a == 'tall', b == 'fair', c == 'grey', \
              d == 'gun', e == 'car']) == 2:
        
        # test Witness No.3 statements
        if sum([ a == 'tall', b == 'dark', c == 'brown', \
                 d == 'crowbar', e == 'motorbike']) == 2:
        
          # test Witness No.4 statements
          if sum([a == 'short', b == 'ginger', c == 'blue', \
                  d == 'knife', e == 'car']) == 2:
            
            # test Witness No.5 statements
            if sum([ a == 'tall', b == 'dark', c == 'blue', \
                     d == 'stick', e == 'pushbike']) == 2:
              print(f"The robber was {a}.")
              print(f"He had {b} coloured hair and {c} colour eyes.")
              print(f"He carried a {d} as a weapon, escaping on a {e}.")

LikeLike

GeoffR 9:41 pm on 23 July 2022 Permalink | Reply

Indexing the witness statement lists is neater:


# List of possible witness statements
statements = []

# Witness statements
W1 = ['short', 'fair', 'brown', 'cricket bat', 'motorbike']
W2 = ['tall', 'fair', 'grey', 'gun', 'car' ]
W3 = ['tall', 'dark', 'brown', 'crowbar', 'motorbike' ]
W4 = ['short', 'ginger', 'blue', 'knife', 'car' ] 
W5 = ['tall', 'dark', 'blue', 'stick', 'pushbike' ]

# Form lists of all possible witness statements
for a in ('short', 'tall'): 
  for b in ('fair', 'dark', 'ginger'):
    for c in ('brown', 'grey', 'blue'):
      for d in ('cricket bat', 'gun', 'crowbar', 'knife', 'stick'):
        for e in ('motorbike', 'car', 'pushbike'):
          statements.append([a, b, c, d, e])

for st in statements:
    a, b, c, d, e = st
    # Two statements from five are true for each witness
    # test Witness No.1 statements
    if sum([a == W1[0], b == W1[1], c == W1[2], \
            d == W1[3], e == W1[4]]) == 2:
      
      # test Witness No.2 statements
      if sum([a == W2[0], b == W2[1], c == W2[2], \
              d == W2[3], e == W2[4]]) == 2:
        
        # test Witness No.3 statements
        if sum([ a == W3[0], b == W3[1], c == W3[2], \
                 d == W3[3], e == W3[4]]) == 2:
        
          # test Witness No.4 statements
          if sum([a == W4[0], b == W4[1], c == W4[2], \
                  d == W4[3], e == W4[4]]) == 2:
            
            # test Witness No.5 statements
            if sum([ a == W5[0], b == W5[1], c == W5[2], \
                     d == W5[3], e == W5[4]]) == 2:
              print(f"The robber was {a}.")
              print(f"He had {b} coloured hair and {c} colour eyes.")
              print(f"He carried a {d} as a weapon, escaping on a {e}.")

LikeLike

GeoffR 12:07 pm on 1 August 2022 Permalink | Reply

% A Solution in MiniZinc
include "globals.mzn";

set of int: TF = {1,0};

var TF:short; var TF:tall;
var TF:h_fair; var TF:h_dark; var TF:h_ginger;
var TF:e_brown; var TF:e_grey; var TF:e_blue;
var TF:c_bat; var TF:gun; var TF:c_bar; var TF:knife; var TF:stick;
var TF:mbike; var TF:car; var TF:pbike;

% Values are 0 or 1 for main variables 
% ..i.e. for height, hair colour, eye colour, weapon, vehicle
constraint sum([short, tall]) < 2;
constraint sum([h_fair, h_dark, h_ginger]) < 2;
constraint sum([e_brown, e_grey, e_blue]) < 2;
constraint sum([c_bat, gun, c_bar, knife, stick]) < 2;
constraint sum([mbike, car, pbike]) < 2;

% 5 witness statements - 2 are true for each witness
constraint sum([short, h_fair, e_brown,c_bat, mbike]) == 2;
constraint sum([tall, h_fair, e_grey, gun, car]) == 2;
constraint sum([tall, h_dark, e_brown, c_bar, mbike]) == 2;
constraint sum([short, h_ginger, e_blue, knife, car]) == 2;
constraint sum([tall, h_dark, e_blue, stick, pbike]) ==  2;

solve satisfy;

output [" [short, tall ] = " ++ show([ short, tall ]) ++ "\n"
++ " [h_fair, h_dark, h_ginger] = " ++ show([ h_fair, h_dark, h_ginger])  
++ "\n" ++ " [e_brown, e_grey, e_blue] = " ++ show([e_brown, e_grey, e_blue] )
++ "\n" ++ " [c_bat, gun, c_bar, knife, stick] = " 
++ show([c_bat, gun, c_bar, knife, stick]) 
++ "\n" ++ " [mbike, car, pbike] = "  ++ show([mbike, car, pbike]) ];

%  [short, tall ] = [0, 1]
%  [h_fair, h_dark, h_ginger] = [1, 0, 0]
%  [e_brown, e_grey, e_blue] = [0, 0, 1]
%  [c_bat, gun, c_bar, knife, stick] = [0, 0, 0, 1, 0]
%  [mbike, car, pbike] = [1, 0, 0]
% ----------
% ==========
% i.e. Robber was tall, had fair hair, blue eyes, with a knife, escaping on a motorbike.

LikeLike

Jim Randell 9:07 am on 21 July 2022 Permalink | Reply
Tags: by: Victor Bryant ( 147 )
Teaser 2533: A lopsided number
From The Sunday Times, 10th April 2011 [link] [link]

In this letters-for-digits substitution puzzle, each letter consistently represents a different digit. In the display, each letter in the top row is the sum of the two letters directly below it:

What number is LOPSIDED?

[teaser2533]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
GeoffR and Jim Randell are discussing. Toggle Comments
- Jim Randell 9:08 am on 21 July 2022 Permalink | Reply
  We can use the [[ SubstitutedExpression ]] solver from the enigma.py library to solve this puzzle.
  
  The following run file executes in 64ms. The internal runtime of the generated program is 55µs).
  
  Run: [ @replit ]
```
#! python3 -m enigma -rr

SubstitutedExpression

"F + I = P"
"I + D = O"
"D + D = S"
"D + L = E"
"L + E = R"

--answer="LOPSIDED"
```
  Solution: LOPSIDED = 24961353.
  
  And: POSER = 94657; FIDDLE = 813325.
  
  LikeLike
- GeoffR 11:38 am on 21 July 2022 Permalink | Reply
```
% A Solution in MiniZinc
include "globals.mzn";
 
var 1..9:P; var 1..9:O; var 1..9:S; var 1..9:E; var 1..9:R;
var 1..9:F; var 1..9:I; var 1..9:D; var 1..9:L; 

constraint all_different([P, O, S, E, R, F, I, D, L]);

constraint F + I == P /\ I + D == O /\ D + D == S
/\ D + L == E /\ L + E == R;

solve satisfy;

output ["LOPSIDED = \(L)\(O)\(P)\(S)\(I)\(D)\(E)\(D)"];

% LOPSIDED = 24961353
% ----------
% ==========
```
  LikeLike
Jim Randell 6:31 am on 19 July 2022 Permalink | Reply
Tags: by: Nick MacKinnon ( 57 )
Teaser 2721: Milliner’s hat-trick
From The Sunday Times, 16th November 2014 [link] [link]

A football tournament has four groups each of four teams, with the teams in the same group playing each other once. So far the teams have each played two games and in each group the distribution of points is different. Also, in each group just one pair of teams are level on points and their positions have been determined by their “goals scored”. Milliner has scored four (including a hat-trick), Orlando two, and nine other players have scored one goal each. Despite his success, Orlando’s team is not the top of their group.

What are the results of the two games that Milliner’s team have played? And the two games that Orlando’s team have played?

[teaser2721]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 6:33 am on 19 July 2022 Permalink | Reply
  The puzzle is not explicit on the scoring system used (i.e. 2 points for a win, or 3 points for a win), although it turns out it doesn’t matter which is used, the answer to the puzzle is the same in both cases.
  
  In each group each team has played 2 of their 3 matches. So there have been 4 matches played (and there are 2 matches left to play). So among the 4 groups there have been 16 matches played in total.
  
  The minimum possible number of goals scored among the 4 matches in a group is 2. So the maximum possible number of goals scored is 15 − 3×2 = 9. (Although it may be possible to reduce this theoretical maximum value, which would speed up the program).
  
  For each group, this Python program considers the scores for teams A (1st), B (2nd), C (3rd), D (4th), such that each team has played 2 matches, and two of the teams are tied on points, but have different “goals for” values.
  
  It then chooses 4 different points distributions (one for each of the groups), and from the previously examined scores it chooses 4 sets of scores that have 15 goals scored in total, and ensures there are possible teams for both Milliner and Orlando.
  
  The program runs in 361ms.
  
  Run: [ @replit ]
```
from collections import defaultdict
from enigma import (
  Football, irange, subsets, tuples, cproduct, peek, delete,
  update, find, unzip, reverse, map2str, join, printf
)

# scoring regime (2 or 3 points for a win)
football = Football(games='wdlx', points=dict(w=2, d=1))

# labels for the teams
teams = (A, B, C, D) = tuple("ABCD")

# keys for the matches
ks = list(x + y for (x, y) in subsets(teams, size=2))

# allocate <t> goals among the matches <ms>, return scores <ss>
def allocate(t, ms, ss=dict()):
  # are we done?
  if not ms:
    if t == 0:
      yield ss
  else:
    # calculate the number of surplus goals
    n = t - sum(v == 'w' for v in ms.values())
    if n < 0: return
    # choose the next match to allocate goals to
    (k, v) = peek(ms.items())
    if v == 'x':
      # not played
      yield from allocate(t, delete(ms, [k]), update(ss, [(k, None)]))
    elif v == 'w' or v == 'l':
      # a win (or loss), calculate scores (x, y)
      for x in irange(1, n + 1):
        for y in irange(0, min(x - 1, n - x + 1)):
          s = ((x, y) if v == 'w' else (y, x))
          yield from allocate(t - x - y, delete(ms, [k]), update(ss, [(k, s)]))
    elif v == 'd':
      # a draw, calculate scores (x, x)
      for x in irange(0, n // 2):
        yield from allocate(t - x - x, delete(ms, [k]), update(ss, [(k, (x, x))]))

# check goals scored by team <t> in a match from scores <ss> is <n> or more
def scored(t, ss, n):
  for (k, v) in ss.items():
    if v is not None:
      i = find(k, t)
      if i != -1 and v[i] >= n:
        return True

# map: <pts> -> <total goals> -> (<match scores>, <milliner>, <orlando>) values
d = defaultdict(lambda: defaultdict(list))

# consider possible match outcomes
for ms in football.games(repeat=len(ks)):
  ms = dict(zip(ks, ms))
  # compute the table for each team
  table = dict((t, football.extract_table(ms, t)) for t in teams)
  # each team has played twice
  if not all(table[t].played == 2 for t in teams): continue
  # points are increasing, with exactly 2 teams having the same points
  pts = tuple(table[t].points for t in teams)
  if len(set(pts)) != 3: continue
  if not all(x >= y for (x, y) in tuples(pts, 2)): continue
  # allocate goals to the matches
  for t in irange(2, 9):
    for ss in allocate(t, ms):
      # extract the goals (for, against) for each team
      goals = dict((t, football.extract_goals(ss, t)) for t in teams)
      # check teams with same points have different "goals for" values
      if any(p1 == p2 and not (goals[t1][0] > goals[t2][0])
        for ((t1, p1), (t2, p2)) in tuples(zip(teams, pts), 2)
      ): continue
      # find teams for Milliner: team must have a match with >= 3 goals scored
      # and have >= 4 goals scored in total
      tM = list(t for (t, (f, _)) in goals.items() if f > 3 and scored(t, ss, 3))
      # find teams for Orlando: must have >= 2 goals, and not be top
      tO = list(t for (t, (f, _)) in goals.items() if t != 'A' and f > 1)
      # record this set of scores
      d[pts][t].append((ss, tM, tO))

# collect scores from <ss> for teams in <ts> (from the team's perspective)
def collect(ss, ts):
  for t in ts:
    rs = list()
    for (s, f) in unzip(football.extract(ss, t)):
      if s is None: continue
      rs.append(reverse(s) if f else s)
    yield tuple(sorted(rs, reverse=1))

# choose 4 different points distributions
for ps in subsets(d.keys(), size=4):
  # choose the number of goals scored in each group
  for ts in cproduct(d[p].keys() for p in ps):
    # there should be 15 goals in total
    if sum(ts) != 15: continue
    # choose the actual scores in each match
    for ss in cproduct(d[p][t] for (p, t) in zip(ps, ts)):
      # check for possibilities for Milliner and Orlando
      if not any(tM for (_, tM, _) in ss): continue
      if not any(tO for (_, _, tO) in ss): continue
      # output a solution (groups = scores, pts, M, O; M's team; O's team)
      (Ms, Os) = (set(), set())
      for (i, ((s, tM, tO), p)) in enumerate(zip(ss, ps), start=1):
        printf("Group {i}: {s} {p} {tM} {tO}", s=map2str(s, enc=""), tM=join(tM, enc="[]"), tO=join(tO, enc="[]"))
        Ms.update(collect(s, tM))
        Os.update(collect(s, tO))
      for M in sorted(Ms): printf("M's team: {M}", M=join(M, sep=", "))
      for O in sorted(Os): printf("O's team: {O}", O=join(O, sep=", "))
      printf()
```
  Solution: The results for Milliner’s team are: a 3-1 win, a 1-0 win. The results for Orlando’s team are: a 2-0 win, a 0-1 loss.
  
  M’s team is a group leader. O’s team is second in their group.
  
  With “2 points for a win” (and 1 for a draw) there are three possible sets of scores:
  
  Group 1: A v B = 1-0; A v C = 1-0; B v D = 2-0; C v D = 1-0; points = [4, 2, 2, 0], Orlando is team B
  Group 2: A v C = 3-1; A v D = 1-0; B v C = 0-0; B v D = 0-0; points = [4, 2, 1, 1], Milliner is team A
  Group 3: A v B = 1-0; A v C = 0-0; B v D = 1-0; C v D = 0-0; points = [3, 2, 2, 1]
  Group 4: A v C = 0-0; A v D = 2-0; B v C = 0-0; B v D = 1-0; points = [3, 3, 2, 0]
  
  Group 1: A v B = 1-0; A v D = 1-0; B v C = 2-0; C v D = 1-0; points = [4, 2, 2, 0], Orlando is team B
  Group 2: A v C = 3-1; A v D = 1-0; B v C = 0-0; B v D = 0-0; points = [4, 2, 1, 1], Milliner is team A
  Group 3: A v B = 1-0; A v C = 0-0; B v D = 1-0; C v D = 0-0; points = [3, 2, 2, 1]
  Group 4: A v C = 0-0; A v D = 2-0; B v C = 0-0; B v D = 1-0; points = [3, 3, 2, 0]
  
  Group 1: A v C = 1-0; A v D = 1-0; B v C = 0-1; B v D = 2-0; points = [4, 2, 2, 0], Orlando is team B
  Group 2: A v C = 3-1; A v D = 1-0; B v C = 0-0; B v D = 0-0; points = [4, 2, 1, 1], Milliner is team A
  Group 3: A v B = 1-0; A v C = 0-0; B v D = 1-0; C v D = 0-0; points = [3, 2, 2, 1]
  Group 4: A v C = 0-0; A v D = 2-0; B v C = 0-0; B v D = 1-0; points = [3, 3, 2, 0]
  
  We can examine what happens with “3 points for a win” by changing the initialisation at line 8. And we find in this case there are four possible sets of scores:
  
  Group 1: A v B = 1-0; A v D = 0-0; B v C = 2-0; C v D = 1-0; points = [4, 3, 3, 1], Orlando is team B
  Group 2: A v B = 1-1; A v D = 1-0; B v C = 0-0; C v D = 0-0; points = [4, 2, 2, 1]
  Group 3: A v C = 3-1; A v D = 1-0; B v C = 0-0; B v D = 0-0; points = [6, 2, 1, 1], Milliner is team A
  Group 4: A v C = 0-0; A v D = 2-0; B v C = 0-0; B v D = 1-0; points = [4, 4, 2, 0]
  
  Group 1: A v B = 1-0; A v D = 0-0; B v C = 2-0; C v D = 1-0; points = [4, 3, 3, 1], Orlando is team B
  Group 2: A v C = 0-0; A v D = 1-0; B v C = 0-0; B v D = 1-1; points = [4, 2, 2, 1]
  Group 3: A v C = 3-1; A v D = 1-0; B v C = 0-0; B v D = 0-0; points = [6, 2, 1, 1], Milliner is team A
  Group 4: A v C = 0-0; A v D = 2-0; B v C = 0-0; B v D = 1-0; points = [4, 4, 2, 0]
  
  Group 1: A v C = 1-0; A v D = 0-0; B v C = 0-1; B v D = 2-0; points = [4, 3, 3, 1], Orlando is team B
  Group 2: A v B = 1-1; A v D = 1-0; B v C = 0-0; C v D = 0-0; points = [4, 2, 2, 1]
  Group 3: A v C = 3-1; A v D = 1-0; B v C = 0-0; B v D = 0-0; points = [6, 2, 1, 1], Milliner is team A
  Group 4: A v C = 0-0; A v D = 2-0; B v C = 0-0; B v D = 1-0; points = [4, 4, 2, 0]
  
  Group 1: A v C = 1-0; A v D = 0-0; B v C = 0-1; B v D = 2-0; points = [4, 3, 3, 1], Orlando is team B
  Group 2: A v C = 0-0; A v D = 1-0; B v C = 0-0; B v D = 1-1; points = [4, 2, 2, 1]
  Group 3: A v C = 3-1; A v D = 1-0; B v C = 0-0; B v D = 0-0; points = [6, 2, 1, 1], Milliner is team A
  Group 4: A v C = 0-0; A v D = 2-0; B v C = 0-0; B v D = 1-0; points = [4, 4, 2, 0]
  
  LikeLike

Jim Randell 12:33 pm on 17 July 2022 Permalink | Reply
Tags: by: Graham Smithers ( 84 )

Teaser 2531: [Harshad numbers]

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

A Harshad number (or H-number) is any number that is divisible by the sum of its digits. Using each non-zero digit just the once, I have written down a 9-figure H-number. Reading from left to right, it also consists of three 2-figure H-numbers followed by a 3-figure H-number. Again working from left to right through the 9-figure number, the last five digits form a 5-figure H-number. Reversing the order of the first five digits of the 9-figure number also gives a 5-figure H-number.

What is the 9-figure number?

This puzzle was originally published with no title.

[teaser2531]

Jim Randell 12:34 pm on 17 July 2022 Permalink | Reply

See: [@wikipedia].

We can use the [[ SubstitutedExpression ]] solver from the enigma.py library to solve this puzzle.

The following run file executes in 72ms. The internal runtime of the generated program is 3.1ms).

Run: [ @replit ]

#! python3 -m enigma -rr

SubstitutedExpression

--digits="1-9"

# is <n> an H-number?
--code="H = lambda n: n % dsum(n) == 0"

# the 9-digit number is: abcdefghi
"H({abcdefghi})"

# three 2-digit H-numbers and a 3-digit H-number
"H({ab})"
"H({cd})"
"H({ef})"
"H({ghi})"

# 5-digit H-numbers
"H({efghi})"
"H({edcba})"

--answer="{abcdefghi}"

Solution: The 9-digit number is: 273684915.

LikeLike

GeoffR 2:16 pm on 17 July 2022 Permalink | Reply


% A Solution in MiniZinc 
include "globals.mzn";

var 1..9: a; var 1..9: b; var 1..9: c;
var 1..9: d; var 1..9: e; var 1..9: f;
var 1..9: g; var 1..9: h; var 1..9: i;

constraint all_different([a,b,c,d,e,f,g,h,i]);

% 2-digit Harshad numbers
constraint (10*a + b) mod (a + b) == 0
/\ (10*c + d) mod (c + d) == 0
/\ (10*e + f) mod (e + f) == 0;

% 3-digit Harshad number
constraint (100*g + 10*h + i) mod (g + h + i) == 0;

% 5-digit Harshad numbers
constraint (10000*e + 1000*f + 100*g + 10*h + i) mod(e + f + g + h + i) == 0;
constraint (10000*e + 1000*d + 100*c + 10*b + a) mod(e + d + c + b + a) == 0;

% 9-digit Harshad number
constraint (a * pow(10,8) + b * pow(10,7) + c * pow(10,6)
+ d * pow(10,5) + e * pow(10,4) + f * pow(10,3)
+ g * pow(10,2) + h * 10 + i) mod (a+b+c+d+e+f+g+h+i) == 0;

solve satisfy;

output ["9-figure number = " ++ " \(a)\(b)\(c)\(d)\(e)\(f)\(g)\(h)\(i)" ];

% 9-figure number = 273684915
% ----------
% ==========

LikeLike

Frits 3:40 pm on 17 July 2022 Permalink | Reply

   
from itertools import permutations
from functools import reduce

# convert digits sequence to number
d2n = lambda s: reduce(lambda x, y: 10 * x + y, s)

# calculate H-number
H = lambda s: d2n(s) % sum(s) == 0

i = 5  # as abcdefghi is divisible by 45

# ghi:   sum(g,h) must be even as sum(g,h,i) must be odd
# efghi: sum(e,f) must be even as sum(e,f,g,h,i) must be odd
# ef:    e and f not both odd otherwise 10*d + e is not divisible by e + f
#        so e and f are both even
# ab:    a and b not both odd
# cd:    c and d not both odd
# g an h must be both odd otherwise a, b, c and d must all be odd

# ....eeoo5
# edcba : a must be even as sum(e,d,c,b,a) is even
# e...eeoo5
# as c and d are not both odd b must be odd
# eo..eeoo5

for (b, g, h) in permutations([1, 3, 7, 9], 3):
  if not H((g, h, i)): continue
  for (a, e, f) in permutations([2, 4, 6, 8], 3):
    if not H((a, b)): continue
    if not H((e, f)): continue
    if not H((e, f, g, h, i)): continue
    rest = set(range(1, 10)).difference({a, b, e, f, g, h, i})
    for (c, d) in permutations(rest):
      if not H((c, d)): continue
      if not H((e, d, c, b, a)): continue
      if not H((a, b, c, d, e, f, g, h, i)): continue
      print("the 9-figure number:", d2n((a, b, c, d, e, f, g, h, i)))

LikeLike

GeoffR 6:43 pm on 17 July 2022 Permalink | Reply
I carried out some further analysis to see how the number of Harshad numbers reduced with different arrangements of numbers.

1) For numbers ab, cd, ef, ghi and abcdefghi, this gave 96 possible 9-digit Harshad numbers.

2) Adding abcde to (1) above, I found 16 possible Harshad numbers for abcdefghi:
```
 a b c d e f g h i    a b c d e f g h i    a b c d e f g h i
------------------------------------------------------------
 2 7 3 6 4 8 1 9 5,   2 7 3 6 8 4 9 1 5,   2 7 6 3 4 8 1 9 5,   
 2 7 6 3 8 4 9 1 5,   3 6 2 7 4 8 1 9 5,   3 6 2 7 8 4 9 1 5,   
 3 6 7 2 4 8 1 9 5,   3 6 7 2 8 4 9 1 5,   6 3 2 7 4 8 1 9 5,   
 6 3 2 7 8 4 9 1 5,   6 3 7 2 4 8 1 9 5,   6 3 7 2 8 4 9 1 5,   
 7 2 3 6 4 8 1 9 5,   7 2 3 6 8 4 9 1 5,   7 2 6 3 4 8 1 9 5,   
 7 2 6 3 8 4 9 1 5.
```
3) Finally, adding number edcba to (2) above, this gave the single 9-digit answer of 273684915.
(top row, middle value)

Interesting to note how the 16 solutions illustrate aspects of analysis in Frits code.

LikeLike

Jim Randell 4:03 pm on 15 July 2022 Permalink | Reply
Tags: by: Howard Williams ( 45 )
Teaser 3121: Top marks
From The Sunday Times, 17th July 2022 [link] [link]

A teacher is preparing her end of term class test. After the test she will arrive at each pupil’s score by giving a fixed number of marks for each correct answer, no marks for a question that is not attempted, and deducting a mark for each incorrect answer. The computer program she uses to prepare parents’ reports can only accept tests with the number of possible test scores (including negative scores) equal to 100.

She has worked out all possible combinations of the number of questions asked and marks awarded for a correct answer that satisfy this requirement, and has chosen the one that allows the highest possible score for a pupil.

What is that highest possible score?

[teaser3121]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell and Frits are discussing. Toggle Comments
- Jim Randell 4:25 pm on 15 July 2022 Permalink | Reply
  If there are n questions asked, and there are a marks for a correct answer, then the possible scores are:
  
  score = ax − z; where x + z ≤ n
  
  And we need there to be exactly 100 possible scores.
  
  There are tri(n + 1) different (correct, unanswered, incorrect) ways the n questions can be answered.
  
  So we need n ≥ 13 in order for there to be 100 or more different combinations (some may have the same score).
  
  Here’s a quick program to solve the puzzle.
  
  It runs in 66ms.
  
  Run: [ @replit ]
```
from enigma import (irange, inf, Accumulator, printf)

# find the highest possible score (all answers correct)
r = Accumulator(fn=max, collect=1)

# consider possible marks for a correct answer
for a in irange(1, 10):
  # consider possible numbers of questions
  for n in irange(13, inf):
    # calculate possible scores
    ss = set(a * x - z for x in irange(0, n) for z in irange(0, n - x))
    k = len(ss)
    if k > 100: break
    if k == 100:
      m = max(ss) # = a * n
      r.accumulate_data(m, (a, n))
      printf("[a={a} n={n} m={m}]")

# output solutions
printf("max score = {m}")
for (a, n) in r.data:
  printf("-> {n} questions; {a} marks for a correct answer")
```
  Solution: The maximum possible score is 105.
  
  There are 15 questions, and 7 marks for each correct answer. The maximum is therefore 15×7 = 105.
  
  It is also possible to have 100 potential scores with 21 questions, and 4 marks for each correct answer. In this case the maximum is 21×4 = 84.
  
  LikeLike
- Frits 7:28 pm on 15 July 2022 Permalink | Reply
```
   
m = 0 
# consider possible marks for a correct answer
for a in range(1, 11):
  # range [-n, -n+1, ..., -1, 0, 1, ..., a*n]
  # max scores            = (a + 1) * n + 1    
  # nr impossible to make = a * (a - 1) / 2

  # n.a + n + 1 - 1/2 a.a + 1/2 a = 100
  # (2a + 2)n = a.a - a + 198
  n, r = divmod(a * a - a + 198, 2 * a + 2)
  if r: continue
  
  m = max(m, a * n)

print("answer:", m)  
```
  LikeLike
  - Jim Randell 8:59 am on 16 July 2022 Permalink | Reply
    I wondered how you arrived at your formula for the unreachable marks.
    
    I came up with this:
    
    If we get all the questions right the (maximum possible) score is: a.n
    
    If we get all but one of the questions right (and don’t attempt the remaining question) the next lowest score is: a(n − 1).
    
    So there are (a − 1) unreachable scores between these.
    
    If, however, we get the remaining question wrong, we get a score of: a(n − 1) − 1.
    
    The there are only (a − 2) unreachable scores in the next gap.
    
    If we get all but two of the questions right the possible scores are: a(n − 2), a(n − 2) − 1, a(n − 2) − 2.
    
    And there are (a − 3) unreachable scores in the following gap.
    
    So, in each gap the number of unreachable scores decreases by 1.
    
    Hence the total number of unreachable scores is: tri(a − 1), providing n ≥ a. (All possible negative scores are reachable).
    
    And using this we can determine the number of possible scores without having to construct them.
    
    And we can proceed manually (there are only 10 values to check), or programatically:
    
    Run: [ @replit ]
```
from enigma import (irange, inf, tri, Accumulator, printf)

# find the highest possible score (all answers correct)
r = Accumulator(fn=max, collect=1)

# consider possible marks for a correct answer
for a in irange(1, inf):
  # "unreachable" scores
  u = tri(a - 1)
  # find number of questions (100 = m + n + 1 - u)
  (n, q) = divmod(99 + u, a + 1)
  if n < 13: break
  if q != 0: continue
  assert n >= a
  # max possible score
  m = a * n
  r.accumulate_data(m, (a, n))
  printf("[a={a} n={n} m={m}]")

# output solutions
printf("max score = {m}")
for (a, n) in r.data:
  printf("-> {n} questions; {a} marks for a correct answer")
```
    Manually, we can consider increasing a values, calculate u values (by just adding the preceding a value), and compute n = (99 + u) / (a + 1). We need n to be an integer ≥ 13. The calculations proceed as follows:
    
    a = 1; u = 0; n = 99/2 = 49r1
    a = 2; u = 1; n = 100/3 = 33r1
    a = 3; u = 3; n = 102/4 = 25r2
    a = 4; u = 6; n = 105/5 = 21 [candidate solution]
    a = 5; u = 10; n = 109/6 = 18r1
    a = 6; u = 16; n = 115/7 = 16r2
    a = 7; u = 21; n = 120/8 = 15 [candidate solution]
    a = 8; u = 28; n = 127/9 = 14r1
    a = 9; u = 36; n = 135/10 = 13r5
    a = 10; u = 45; n = 144/11 = 13r1
    a = 11; u = 55; n = 154/12 = 12r10 [n < 13]
    
    There are two candidate solutions a=4, n=21 ⇒ max=84 and a=7, n=15 ⇒ max=105, so we want the second one.
    
    LikeLiked by 1 person
    - Frits 12:48 pm on 16 July 2022 Permalink | Reply
      
      I printed and analyzed the sorted ss lists of your program and noticed that
      the first unreachable number always is F = (n – (a – 2)) * a – (a – 1).
      This happens if the number of correct answers is equal to n – (a – 2).
      
      the next two unreachable numbers always are:
      (F + a, F + a + 1)
      the next three unreachable numbers always are:
      (F + 2*a, F + 2*a + 1, F + 2*a + 2)
      etc…
      
      LikeLike
  - Frits 12:27 am on 17 July 2022 Permalink | Reply
    
    If a >= n then the number of possible test scores is independent of a.
    The number of unreachable scores is then tri(a – 1) – tri(a – n – 1).
    
    The number of possible test scores is equal to (n + 1) * (n + 2) / 2.
    The number of possible test scores equal to 100 leads to the formula
    (n + 1) * (n + 2) = 200
    
    A positive solution for n is (3 * sqrt(89) – 3) / 2 = 12.65 so
    not an integer solution.
    
    LikeLike
- Frits 6:09 pm on 21 July 2022 Permalink | Reply
  Formula (2a + 2).n = a.a – a + 198 is valid if marks for a correct answer (a) is not higher than the number of questions (n). If a is higher or equal to n then n must be a non-integer solution (approx 12.65).
  
  Another option would have been to use divisor_pairs().
```
   
#! python3 -m enigma -r

# rearrangement idea from John Crabtree:

# formula (2a + 2).n = a.a - a + 198
# can be rearranged to 2.n + 3 = 200 / (a + 1) + (a + 1) 
# so both terms of RHS are divisors of 200
 
SubstitutedExpression

# find divisors of 200
"div(200, AB) = DEF"
"1 < AB <= DEF"

# make sure exactly one of them is odd
"(AB + DEF) % 2"

# marks for a correct answer: AB - 1
# number of question: (AB + DEF - 3) / 2
--answer="(AB - 1) * (AB + DEF - 3) // 2"
--distinct=""
--accumulate=max
--invalid="2-9,A"
--verbose=16
```
  LikeLike
  - Jim Randell 3:04 pm on 22 July 2022 Permalink | Reply
    I also did a solution based on John Crabtree’s analysis:
    
    Run: [ @replit ]
```
from enigma import (Accumulator, divisors_pairs, div, printf)

# based on John Crabtree's derivation: 2n + 3 = 200/(a + 1) + (a + 1)

# find the highest possible score (all answers correct)
r = Accumulator(fn=max, collect=1)

# look for divisors of 200
for (p, q) in divisors_pairs(200, every=1):
  a = p - 1
  if a < 1: continue
  # calculate n
  n = div(p + q - 3, 2)
  if n is None or n < a: continue
  m = a * n
  r.accumulate_data(m, (a, n))
  printf("[a={a}: n={n} m={m}]")

# output solutions
printf("max score = {m}")
for (a, n) in r.data:
  printf("-> {n} questions; {a} marks for a correct answer")
```
    It is neat because we sum the divisor pairs.
    
    But it is more straightforward (and slightly faster) just to consider increasing a values (as in my second program).
    
    LikeLike
Jim Randell 9:01 am on 14 July 2022 Permalink | Reply
Tags: by: Victor Bryant ( 147 )
Teaser 2532: In hot pursuit
From The Sunday Times, 3rd April 2011 [link] [link]

George and Martha are jogging around a circular track. Martha starts at the most westerly point, George starts at the most southerly point, and they both jog clockwise at their own steady speeds. After a short while Martha is due north of George for the first time. Five minutes later she is due south of him for the first time. Then George catches up with her during their second laps at the most northeasterly point of the track.

What is Martha’s speed (in degrees turned per minute)?

[teaser2532]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 9:02 am on 14 July 2022 Permalink | Reply
  
  If George starts at 0° and goes at g degrees per minute, and Martha starts at 90° and goes at m degrees per minute.
  
  Then at time x (shortly after they set off) M is due north of G. So the angle G has gone is the same angular distance that M has to go to reach the north (180°) marker.
  
  So we have:
  
  xg = 90° − xm
  x(g + m) = 90°
  
  And 5 minutes later M is due south of G for the first time. The distance G has gone beyond the north (180°) marker is the same as the distance that M has to go to reach the south (360°/0°) marker.
  
  (x + 5)g − 180° = 270° − (x + 5)m
  (x + 5)(g + m) = 450°
  ⇒
  5x = x + 5
  4x = 5
  x = 5/4
  g + m = 72°/min
  
  Later, at some time t during lap 2, G catches up with M at the north-east (225°) marker. So G has gone 585° and M has gone 495°.
  
  Hence:
  
  585 = tg
  495 = tm
  ⇒
  t(g + m) = 1080
  t = 1080 / 72 = 15 min
  g = 39°/min
  m = 33°/min
  
  Solution: Martha’s speed is 33°/min.
  
  LikeLike
Jim Randell 7:29 am on 12 July 2022 Permalink | Reply
Tags: by: Victor Bryant ( 147 )
Teaser 2724: Headcount
From The Sunday Times, 7th December 2014 [link] [link]

My grandson and I play a coin game. First we toss seven coins and I have to predict in advance the number of heads whilst he has to predict the number of tails. I then get a number of points equal to the number of heads, he gets a number of points equal to the number of tails, and anyone whose prediction was correct gets a fixed bonus number of points (less than 40). We repeat this with six coins in the second round, then five, and so on down to two. In a recent game we noticed that, after each round, the total of all the points so far awarded was equal to a prime number.

What is the “fixed bonus” number of points? And what was the total of all the points at the end of the game?

[teaser2724]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 7:30 am on 12 July 2022 Permalink | Reply
  (See also: Teaser 3009).
  
  In a round with n coins the points awarded are, the number of heads (+ bonus if guessed correctly) and the number of tails (+ bonus if guessed correctly). So n points are always awarded, along with 0, 1, or 2 bonuses.
  
  We don’t need to worry about the points won by each player, just the total number of points gained in each round.
  
  This Python program keeps a set of (total, bonus) pairs, and then progresses through the rounds keeping viable values.
  
  It runs in 57ms. (Internal runtime is 664µs).
  
  Run: [ @replit ]
```
from enigma import (irange, is_prime, printf)

# start with a total of 0, and all possible bonus values
ss = set((0, x) for x in irange(0, 40))

# start with <k> coins
k = 7

# consider subsequent rounds
while k > 1:
  ss_ = set()
  # consider (total, bonus) in the previous round
  for (t, b) in ss:
    # consider number of bonuses awarded in this round
    for n in (0, 1, 2):
      t_ = t + k + n * b
      if is_prime(t_):
        ss_.add((t_, b))
  # move on to the next round
  (ss, k) = (ss_, k - 1)

# output solutions
for (t, b) in ss:
  printf("total = {t}, bonus={b}")
```
  Solution: The number of bonus points is 19. The total number of points at the end of the game is 103.
  
  The progression of the game is:
  
  7 coins: total = 7 (0 bonus points)
  6 coins: total = 13 (0 bonus points)
  5 coins: total = 37 (19 bonus points)
  4 coins: total = 79 (38 bonus points)
  3 coins: total = 101 (19 bonus points)
  2 coins: total = 103 (0 bonus points)
  
  LikeLike

Jim Randell 8:02 am on 10 July 2022 Permalink | Reply
Tags: by: J S Rowley ( 9 )

Brain-Teaser 150: Paving the way

From The Sunday Times, 23rd February 1964 [link]

I have eight paving stones whose dimensions are an exact number of inches. Their areas are 504, 420, 324, 306, 270, 130, 117 and 112 square inches. Four of these are red and four green. There should be a ninth stone coloured yellow and square so that all nine stones can be fitted together to form a square in such a way that the red stones completely enclose the other five and the green stones completely enclose the yellow one.

What are the dimensions of the red stones?

[teaser150]

Jim Randell 8:03 am on 10 July 2022 Permalink | Reply

The tiles that are mentioned have a total area of 2183.

If the missing central tile has an area of x², and the entire collection has an area of y² then we have:

y² = x² + 2183
y² − x² = 2183
(y − x)(y + x) = 2183

So we can calculate possible values for x and y by examining the divisors of 2183.

The Python program find values for x and y, and then chooses 4 green tiles, along with the x by x yellow square, which can fit together to form a square. And then checks that this square, along with the the remaining (green) tiles can fit together to form a y by y square.

We use the rectpack.py module to fit the tiles into squares.

The program runs in 169ms.

Run: [ @replit ]

from enigma import (divisors_pairs, div, subsets, is_square, cproduct, printf)
import rectpack

# areas of tiles we are given
areas = {504, 420, 324, 306, 270, 130, 117, 112}

# record possible tiles
dps = dict((x, list(divisors_pairs(x))) for x in areas)

# select tiles by area <x>, with max dimension not exceeding <m>
tiles = lambda x, m: ((a, b) for (a, b) in dps[x] if not (b > m))

# pack rectangles <rs> and an <s> by <s> square into a <t> by <t> square
def pack(rs, s, t):
  # make the list of rectangles
  rs_ = [(s, s)]
  rs_.extend(rs)
  # pack them into a t by t square
  for ps in rectpack.pack(t, t, rs_):
    # check the square is not on the edge
    if not any(
      w == h == s and x > 0 and y > 0 and x + w < t and y + h < t
      for (x, y, w, h) in ps
    ): continue
    return ps  # we only need one packing

# consider divisors of the total area
for (a, b) in divisors_pairs(sum(areas)):
  # calculate x and y
  (x, y) = (div(b - a, 2), div(a + b, 2))
  if x is None or y is None or y < x + 4: continue
  # choose 4 green tiles to go around a central x by x square
  for green in subsets(areas, size=4):
    z = is_square(x * x + sum(green))
    if z is None: continue
    # consider dimensions of green tiles
    for gs in cproduct(tiles(x, z) for x in green):
      # pack them into a z by z square
      ps1 = pack(gs, x, z)
      if ps1 is None: continue
      # consider dimensions of red tiles
      red = areas.difference(green)
      for rs in cproduct(tiles(x, y) for x in red):
        # pack them into a y by y square
        ps2 = pack(rs, z, y)
        if ps2 is None: continue
        # output packings
        printf("red {red} around {z} x {z} green in {y} x {y}\n-> {ps2}")
        printf("green {green} around {x} x {x} yellow in {z} x {z}\n-> {ps1}")
        printf()

Solution: The dimensions of the red stones (in inches) are: 3×39, 6×45, 9×36, 12×42.

Here is a diagram of one possible layout:

LikeLike

Frits 1:01 pm on 10 July 2022 Permalink | Reply

@Jim, it is not stated that the yellow and green tiles form a square.

LikeLike

Jim Randell 1:11 pm on 10 July 2022 Permalink | Reply

@Frits: Is there a way the red stones can enclose the green ones without forming a square?

LikeLike

Jim Randell 1:14 pm on 10 July 2022 Permalink | Reply

I suppose it could be a non-square rectangle. But luckily it is possible to do it with a square.

LikeLike

Frits 1:18 pm on 10 July 2022 Permalink | Reply

So there might be another solution…

LikeLike
Jim Randell 1:26 pm on 10 July 2022 Permalink | Reply

I made some tweaks to my program, and it didn’t find any solutions with a non-square rectangle. But I’ll have a closer look.

LikeLike

Jim Randell 2:53 pm on 10 July 2022 Permalink | Reply

This is my program adapted to consider packing the green and yellow tiles into a (possibly non-square) rectangle.

It doesn’t find any additional solutions.

Run: [ @replit ]

from enigma import (divisors_pairs, div, subsets, cproduct, printf)
import rectpack

# areas of tiles we are given
areas = {504, 420, 324, 306, 270, 130, 117, 112}

# record possible tiles
dps = dict((x, list(divisors_pairs(x))) for x in areas)

# select tiles by area <x>, with max dimension not exceeding <m>
tiles = lambda x, m: ((a, b) for (a, b) in dps[x] if not(b > m))

# pack rectangles <rs> and rectangle <s> into a bounding rectangle <t>
def pack(rs, s, t):
  (a, b) = t
  # make the list of rectangles
  rs_ = [s]
  rs_.extend(rs)
  # pack them into a the rectangle
  for ps in rectpack.pack(t[0], t[1], rs_):
    # check that s is not on the edge
    if not any(
      x > 0 and y > 0 and x + w < a and y + h < b and {w, h} == set(s)
      for (x, y, w, h) in ps
    ): continue
    return ps  # we only need one packing

# consider divisors of the total area
for (a, b) in divisors_pairs(sum(areas)):
  # calculate x and y
  (x, y) = (div(b - a, 2), div(a + b, 2))
  if x is None or y is None or y < x + 4: continue
  # choose 4 green tiles to go around the central x by x square
  for green in subsets(areas, size=4):
    for (a, b) in divisors_pairs(x * x + sum(green)):
      if a < x + 2 or y < b + 2: continue
      # consider dimensions of green tiles
      for gs in cproduct(tiles(x, b) for x in green):
        # pack them into an a by b rectangle
        ps1 = pack(gs, (x, x), (a, b))
        if ps1 is None: continue
        # consider dimensions of red tiles
        red = areas.difference(green)
        for rs in cproduct(tiles(x, y) for x in red):
          # pack them into a y by y square
          ps2 = pack(rs, (a, b), (y, y))
          if ps2:
            # output packings
            printf("red {red} around {a} x {b} green in {y} x {y}\n-> {ps2}")
            printf("green {green} around {x} x {x} yellow in {a} x {b}\n-> {ps1}")
            printf()

LikeLike

Frits 5:02 pm on 10 July 2022 Permalink | Reply

One piece of logic is not coded, it turns out it is not needed.

   
from enigma import divisors_pairs
from itertools import product
 
# find three other red pieces which can form the outer ring
def check(a, b, d):
  # combinations of length and width of fourth red piece
  lst = [[[big_square_side - x, (big_square_side - y) * x] 
          for x in d[big_square_side - y] if (big_square_side - x) in d] 
         for y in [a, b]]
  
  # check every combination of possible length and width
  for c, d in product(lst[0], lst[1]):
    # has the fourth piece a known area
    if c[0] * d[0] not in d_red: continue

    # do all four pieces have a different area
    if len(set([c[0] * d[0], a * b, c[1], d[1]])) != 4: continue
    # return all four pieces
    return tuple(sorted([tuple(sorted([a, b])), 
           tuple(sorted([big_square_side - a, big_square_side - c[0]])), 
           tuple(sorted([big_square_side - b, big_square_side - d[0]])), 
           tuple(sorted([c[0], d[0]]))]))
   
  return tuple()          
      
# areas of tiles we are given
areas = sorted([504, 420, 324, 306, 270, 130, 117, 112])
 
# record possible tiles
d_tiles = dict((x, list(divisors_pairs(x))) for x in areas)

# possible areas for the big square
sqs = {n * n for n in range(1, areas[-4] + 1)}

area_greenred = sum(areas)

# candidates for yellow area
area_yellow_cands = [sq for sq in sqs if (sq + area_greenred) in sqs]

# check all candidates for yellow areas 
for area in area_yellow_cands:
  big_square_side = int((area + area_greenred)**.5)
  yellow = int(area**.5)
  area_yellow = area
  
  # adjust possible red tiles to drop tiles with a big length
  d_red = {k: [x for x in vs if x[0] <= big_square_side and 
                                x[1] <= big_square_side] 
              for k, vs in d_tiles.items()}
  
  d_side = dict()     # dictionary per side
  for k, vs in d_red.items():
    for x in vs:
      d_side[x[0]] = d_side.get(x[0], set()) | {x[1]}
      d_side[x[1]] = d_side.get(x[1], set()) | {x[0]}

  if big_square_side in d_side:
    # valid situation but not coded!
    continue
  
  # as each piece now is shorter than the side of the big square
  # we need to have a form so that 2 sides of different pieces are equal to
  # the side of the big square, forms should be similar to this one:
  #
  #   +----------+--+
  #   |          |  |
  #   +----+-----+  |
  #   |    |     |  |
  #   |    +-----+--+
  #   |    |        |
  #   +----+--------+
  
  # adjust dictionary to keep only sides <x> for which complementary side 
  # <big_square_side> - <k> also exists
  d_side = {k: vs for k, vs in d_side.items() 
                  if big_square_side - k in d_side}
  # also adjust possible red tiles 
  d_red = {k: [x for x in vs if big_square_side - x[0] in d_side and 
                                big_square_side - x[1] in d_side] 
              for k, vs in d_red.items()}
 
  sol = set()
  for k, vs in d_red.items():
    # pick a first red piece
    for (le, wi) in vs:
      # find three other red pieces which can form the outer ring
      chk = check(le, wi, d_side)
      if chk:
        if chk not in sol:
          print("answer:", *chk)
        sol.add(chk)

LikeLike

Jim Randell 4:50 pm on 8 July 2022 Permalink | Reply
Tags: by: Susan Bricket ( 17 )

Teaser 3120: Bus stop blues

From The Sunday Times, 10th July 2022 [link] [link]

While waiting for buses, I often look out for interesting number plates on passing cars. From 2001 the UK registration plate format has been 2 letters + a 2-digit number + 3 more letters, the digits being last two of the year of registration with 50 added after six months (for example in 2011, the possible numbers were 11 and 61). I spotted one recently with its five letters in alphabetical order, all different and with no vowels. Looking more closely, I saw that if their numerical positions in the alphabet (A = 1, B = 2 etc.) were substituted for the 5 letters, their sum plus 1 was the 2-digit number and the sum of their reciprocals was equal to 1.

Find the 7-character registration.

[teaser3120]

Jim Randell 4:59 pm on 8 July 2022 Permalink | Reply

I used the [[ reciprocals() ]] function from the enigma.py library (originally written for Enigma 348).

This Python program runs in 63ms. (Internal run time is 174µs).

Run: [ @replit ]

from enigma import (reciprocals, printf)

# letters (1-indexed)
letters = "?ABCDEFGHIJKLMNOPQRSTUVWXYZ"

# vowels: A=1, E=5, I=9, O=15, U=21
vowels = set(letters.index(x) for x in "AEIOU")

# find 5 reciprocals that sum to 1
for ns in reciprocals(5, M=26, g=1):
  # no vowels allowed
  if vowels.intersection(ns): continue
  # calculate the year
  y = sum(ns) + 1
  if not (1 < y < 23 or 50 < y < 72): continue
  # output the registration
  (A, B, X, Y, Z) = (letters[n] for n in ns)
  printf("reg = [{A}{B} {y:02d} {X}{Y}{Z}]")

Solution: The registration is: BD 51 HLX.

Note that the “vowels” restriction is not necessary if the restriction on the year number being within [02, 22] or [51, 71] is observed.

LikeLike

Frits 6:39 pm on 8 July 2022 Permalink | Reply

   
from enigma import SubstitutedExpression

# the alphametic puzzle
p = SubstitutedExpression(
  [
    # its five letters converted to numerical positions
    # AB, CD, EF, GH, IJ
    "1 < AB < 23",
    "AB < CD < 24",
    "CD < EF < 25",
    "EF < GH < 26",
    "GH < IJ < 27",
    
    # no vowels allowed, A=1, E=5, I=9, O=15, U=21
    "all(x not in {1, 5, 9, 15, 21} for x in [AB, CD, EF, GH, IJ])",
    # ranges for the sum
    "(AB + CD + EF + GH + IJ) < 22 or \
     49 < (AB + CD + EF + GH + IJ) < 72",
    # the sum of their reciprocals was equal to 1
    "1 / AB + 1 / CD + 1 / EF + 1 / GH + 1 / IJ == 1",
  ],
  answer="AB, CD, EF, GH, IJ",
  d2i="",
  distinct="",
  verbose=0,    # use 256 to see the generated code
)

# print answers
for (_, ans) in p.solve():
  reg = chr(ord('A') + ans[0] - 1) + \
        chr(ord('A') + ans[1] - 1) + " "
  reg += str(sum(ans) + 1) + " "
  reg += chr(ord('A') + ans[2] - 1) + \
         chr(ord('A') + ans[3] - 1) + \
         chr(ord('A') + ans[4] - 1)
  print("registration =", reg)

LikeLike

Jim Randell 9:38 pm on 8 July 2022 Permalink | Reply

Or we can use base 27 to make things a bit neater:

Run: [ @replit ]

#! python3 -m enigma -rr

SubstitutedExpression

# allow digits 1-26
--base=27
# but exclude vowels (1, 5, 9, 15, 21)
--digits="1-26,!1,!5,!9,!15,!21"

# numbers are in increasing order
"A < B" "B < X" "X < Y" "Y < Z"

# reciprocals sum to 1
"fraction(1, A,  1, B,  1, X,  1, Y,  1, Z) == (1, 1)"

# check year
--code="year = lambda n: (2 <= n <= 22) or (51 <= n <= 71)"
"year(A + B + X + Y + Z + 1)"

# output the registration
--code="l = lambda x: int2base(x, base=27, digits='?ABCDEFGHIJKLMNOPQRSTUVWXYZ')"
--code="n = lambda x: int2base(x, width=2)"
--code="reg = lambda A, B, X, Y, Z: sprintf('{A}{B} {y} {X}{Y}{Z}', A=l(A), B=l(B), X=l(X), Y=l(Y), Z=l(Z), y=n(A + B + X + Y + Z + 1))"
--answer="reg(A, B, X, Y, Z)"
--template=""

LikeLike

GeoffR 8:27 pm on 8 July 2022 Permalink | Reply

% A Solution in MiniZinc
include "globals.mzn";

% Omitting vowel values for A,E,I,O,U
% Used to translate numerical letters in output(v,w,x,y,z) to letters
int:B == 2; int:C == 3; int:D == 4; int:F == 6; int:G == 7;
int:H == 8; int:J == 10; int:K == 11; int:L == 12; int:M == 13;
int:N == 14; int:P == 16; int:Q == 17; int:R == 18; int:S == 19;
int:T == 20; int:V == 22; int:W == 23; int:X == 24; int:Y == 25;
int:Z == 26;

% number plate format is v w num x y z  (num is 2 digits)
var 2..26:v; var 2..26:w; var 2..26:x;
var 2..26:y; var 2..26:z;

% last 2 digits in number plate - range = 2001 to 2022 + 50
var 01..72: num;

set of int: letters = {B,C,D,F,G,H,J,K,L,M,N,P,Q,R,S,T,V,W,X,Y,Z};

% Five number plate letters
constraint v in letters /\ w in letters /\ x in letters
/\ y in letters /\ z in letters;

% five letters in number plate are in alphabetical order
constraint w > v /\ x > w /\ y > x /\ z > y;

% Reciprocals of letter values sum to 1
constraint z * 1/v + z * 1/w + z * 1/x + z * 1/y + z/z == z;

% Two middle digits are the sum of letter values plus 1
constraint v + w + x + y + z + 1 == num;

solve satisfy;

output [ "Number plate = " ++ show( [v, w, num, x, y, z ] ) ];
% uses translation table to convert numbers to letters

LikeLike

GeoffR 3:39 pm on 10 July 2022 Permalink | Reply


from itertools import combinations
import string

# Dictionary mapping numbers to upper case letters
DN = dict(zip(range(1, 27), string.ascii_uppercase))

# omit values for vowels A, E, I, O, U
vowels = {1, 5, 9, 15, 21}

for C1 in combinations(set(range(1, 27)).difference(vowels), 5):
  a, b, c, d, e = C1
  #  five letters are in alphabetical order
  if a < b < c < d < e:
    # the sum of their reciprocals was equal to 1
    # i.e. 1/a + 1/b + 1/c + 1/d + 1/e == 1:
    if b*c*d*e + a*c*d*e + a*b*d*e + a*b*c*e + a*b*c*d == a*b*c*d*e:
      
      # last two digits of the year
      year2d = a + b + c + d + e + 1
      if year2d <= 22 or (51 <= year2d <= 72):
        print('Reg. No. = ', DN[a], DN[b], year2d, DN[c], DN[d], DN[e])

LikeLike

Jim Randell 9:53 am on 7 July 2022 Permalink | Reply
Tags: by: Andrew Skidmore ( 88 )

Teaser 2723: St Andrew’s day

From The Sunday Times, 30th November 2014 [link] [link]

Bearing in mind today’s date, I have written down two numbers in code, with different letters being used consistently to replace different digits. The addition of the two numbers is shown below, appropriately leading to today’s date as a six- figure number.

What is the value of SEND?

[teaser2723]

Jim Randell 9:55 am on 7 July 2022 Permalink | Reply
We can use the general alphabetic solver [[ SubstitutedExpression ]] from the enigma.py library to solve this puzzle.

The following run file is straightforward, but not especially quick. It runs in 710ms.

Run: [ @replit ]
```
#! python3 -m enigma -rr

SubstitutedExpression

"{SAINT} + {ANDREW} = 301114"

--answer="{SEND}"
```
One way we can improve the execution time is to split the sum into multiple partial sums consisting of columns from the original sum.

This process is automated by the [[ SubstitutedExpression.split_sum ]] helper method, which can now be called from a run file.

The following run file executes in 65ms. (The internal runtime of the generated program is 277µs).

Run: [ @replit ]
```
#! python3 -m enigma -rr

SubstitutedExpression.split_sum

"{SAINT} + {ANDREW} = {301114}"

--literal="0134"
--distinct="ADEINRSTW"
--answer="{SEND}"
```
Solution: SEND = 3568.

The solver finds 4 solutions to the sum as (I, R) = (1, 9) and (T, W) = (0, 4), in some order.

LikeLike

GeoffR 11:18 am on 7 July 2022 Permalink | Reply


% A Solution in MiniZinc
include "globals.mzn";

var 1..9:S; var 1..9:A; var 0..9:I;
var 0..9:N; var 0..9:T; var 0..9:D;
var 0..9:R; var 0..9:E; var 0..9:W;

constraint all_different([S,A,I,N,T,D,R,E,W]);

var 10000..99999: SAINT = 10000*S + 1000*A + 100*I + 10*N + T;
var 100000..999999: ANDREW = 100000*A + 10000*N + 1000*D+ 100*R + 10*E + W;

var 1000..9999:SEND = 1000*S + 100*E + 10*N + D;

constraint SAINT + ANDREW == 301114;

solve satisfy;
output["SEND = " ++ show(SEND) ];

% SEND = 3568
% ----------
% ==========

LikeLike

GeoffR 2:37 pm on 7 July 2022 Permalink | Reply

A solution simulating the normal column addition process, with carry digits.


% A Solution in MiniZinc
include "globals.mzn";

%    S A I N T
%  A N D R E W
%-------------
%  3 0 1 1 1 4
%-------------

var 1..9:S; var 1..9:A; var 0..9:I;
var 0..9:N; var 0..9:T; var 0..9:D;
var 0..9:R; var 0..9:E; var 0..9:W;

constraint all_different([S,A,I,N,T,D,R,E,W]);

% column carry digits for adding columns
var 0..1: c1; var 0..1: c2; var 0..1: c3; var 0..1: c4; var 0..1: c5; 

% carry digits start from RH end of sum
constraint (T + W) mod 10 == 4 /\ (T + W) div 10 == c1;

constraint (N + E + c1) mod 10 == 1 /\ (N + E + c1) div 10 == c2;

constraint (I + R + c2) mod 10 == 1 /\ (I + R + c2) div 10 == c3;

constraint (A + D + c3) mod 10 == 1 /\ (A + D + c3) div 10 == c4;

constraint (S + N + c4) mod 10 == 0 /\ (S + N + c4) div 10 == c5;

 constraint A + c5 == 3;
 
solve satisfy;

output ["SEND = \(S)\(E)\(N)\(D)" 
++  ", SAINT = \(S)\(A)\(I)\(N)\(T)"
++  ", ANDREW = \(A)\(N)\(D)\(R)\(E)\(W)" ];

% SEND = 3568, SAINT = 32964, ANDREW = 268150
% ----------
% SEND = 3568, SAINT = 32960, ANDREW = 268154
% ----------
% SEND = 3568, SAINT = 32164, ANDREW = 268950
% ----------
% SEND = 3568, SAINT = 32160, ANDREW = 268954
% ----------
% ==========

LikeLike

Jim Randell 10:32 am on 5 July 2022 Permalink | Reply
Tags: by: Dr V W Bryant ( 5 )
Brain-Teaser 731: A little list
From The Sunday Times, 20th July 1975 [link]

(1) In this list there is a true statement and a false statement whose numbers add up to give the number of a false statement.

(2) Either statement 4 is false or there are three consecutive true statements.

(3) The number of the last false statement subtracted from the product of the numbers of the first and last true statements gives the number of a statement which is false.

(4) The number of even-numbered true statements equals the number of false statements.

(5) One of the first and last statements is true and the other is false.

(6) When I first sent this problem to the editor, thanks to a typing error no sixth statement was included. However the answer to the following question was the same then as it is now:

Which statements are false?

This puzzle is included in the book The Sunday Times Book of Brain-Teasers: Book 2 (1981). The puzzle text above is taken from the book.

[teaser724]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 10:33 am on 5 July 2022 Permalink | Reply
  This Python program runs in 62ms. (Internal runtime is 680µs).
  
  Run: [ @replit ]
```
from enigma import (subsets, filter2, irange, first, product, tuples, icount, printf)

# solve the puzzle with k (= 5 or 6) statements, considering only the first 5 statements
def solve(k):

  # consider the puzzle with k statements
  for ss in subsets((True, False), size=k, select="M"):
    # check the first 5 statements
    (s1, s2, s3, s4, s5) = first(ss, 5)
    (ts, fs) = filter2((lambda n: ss[n - 1]), irange(1, k))

    # 1: "in this list there is a true statement and a false statement
    # whose numbers add up to give the number of a false statement"
    if not (s1 == any(x + y in fs for (x, y) in product(ts, fs))): continue

    # 2: "either statement 4 is false, or there are three consecutive
    # true statements"
    if not (s2 == ((s4 is False) != (any(all(xs) for xs in tuples(ss, 3))))): continue

    # 3: "the number of the last false statement subtracted from the
    # product of the numbers of the first and last true statements gives
    # the number of a statement which is false"
    if not (s3 == (ts and fs and ts[0] * ts[-1] - fs[-1] in fs)): continue

    # 4: "the number of even numbered true statements equals the number
    # of false statements"
    if not (s4 == (icount(n for n in ts if n % 2 == 0) == len(fs))): continue

    # 5: "one of the first and last statements is true and the other is false"
    if not (s5 == (s1 != ss[-1])): continue

    # return the numbers of the false statements
    yield fs

# look for solutions for the first 5 statements of the 6 statement
# version of the puzzle, grouped by the value of statement 6
(fs6t, fs6f) = filter2((lambda fs: 6 not in fs), solve(6))

# if statement 6 is false, we don't have to worry about the 5 statement version
printf("false statements = {fs6f}")

# if statement 6 is true, the solution(s) must be the same as the 5 statement version
fs5 = list(solve(5))
if fs5 == fs6t:
  printf("false statements = {fs6t}")
```
  Solution: Statements 3, 4, 6 are false.
  
  So statements 1, 2, 5 are true.
  
  1. (true) “in this list there is a true statement and a false statement whose numbers add up to give the number of a false statement”.
  There are two: 1 + 3 = 4, 2 + 4 = 6.
  
  2. (true) “either statement 4 is false, or there are three consecutive true statements”.
  4 is false; there are not three consecutive true statements.
  
  3. (false) “the number of the last false statement subtracted from the product of the numbers of the first and last true statements gives the number of a statement which is false”.
  1×5 − 6 = −1, is not the number of a statement.
  
  4. (false) “the number of even numbered true statements equals the number of false statements”.
  There is 1 even numbered true statement, and there are 3 false statements.
  
  5. (true) “one of the first and last statements is true and the other is false”.
  1 is true; 6 is false.
  
  6. (false) “When I first sent this problem to the editor, thanks to a typing error no sixth statement was included. However the answer to the following question was the same then as it is now: Which statements are false”.
  The first part could be false (there was no error). But if it was true there are no solutions given only the first 5 statements, so the answer to the puzzle could not be the same if the 6th statement was included.
  
  LikeLike
Jim Randell 12:49 pm on 3 July 2022 Permalink | Reply
Tags: by: W. M. Greenway ( 5 )
Brain-Teaser 120: Rugby results
From The Sunday Times, 14th July 1963 [link]

At a certain stage in our all-against-all Rugby football competition the table of results read as follows. There had been no matches in which neither side had scored at all:

What was the result of the match between A and B?

Note: This problem was set when a try was worth 3 points, a penalty goal 3 points and a converted try 5 points. Match points are on the usual basis of 2 for a win and 1 for a draw.

This puzzle is included in the book Sunday Times Brain Teasers (1974).

[teaser120]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 12:50 pm on 3 July 2022 Permalink | Reply
  There are certain scores which are not possible to make from combinations of 3 and 5 points.
  
  This Python program uses the [[ express() ]] function from the enigma.py library to determine what they are. We then use the [[ Football() ]] helper class to determine possible match outcomes and scorelines.
  
  It runs in 89ms.
  
  Run: [ @replit ]
```
from enigma import (express, irange, peek, Football, digit_map, cache)

# find scores that cannot be made from multiples of 3 and 5
invalid = set(n for n in irange(0, 18) if not peek(express(n, [3, 5]), default=None))

# scoring system (2 points for a win, 1 for a draw)
football = Football(points=dict(w=2, d=1))

# digits used in the table (10=A, 13=D, 15=F, 16=G, 18=I)
d = digit_map(0, 18)

# the table, goals for/against
(table, gf, ga) = (dict(played="34432", points="55420"), "DGF53", "8AI88")

# check for a valid score (and cache as we go along)
@cache
def valid(s):
  # unplayed?
  if s is None: return True
  # otherwise:
  # (0, 0) is not allowed
  if s == (0, 0): return False
  # reject invalid scores
  if invalid.intersection(s): return False
  # looks OK
  return True

# find possible match outcomes
for (ms, _) in football.substituted_table(table, d=d):
  # find possible scorelines
  for ss in football.substituted_table_goals(gf, ga, ms, d=d, valid=valid):
    # output solution
    football.output_matches(ms, ss, teams="ABCDE")
```
  Solution: The result of the A vs B match was a 5-3 win for A.
  
  The full results are:
  
  A vs B = 5-3
  A vs C = 5-5
  A vs D = 3-0
  A vs E = (unplayed)
  B vs C = 5-5
  B vs D = 5-0
  B vs E = 3-0
  C vs D = 0-5
  C vs E = 5-3
  D vs E = (unplayed)
  
  LikeLike

Jim Randell 4:40 pm on 1 July 2022 Permalink | Reply
Tags: by: Victor Bryant ( 147 )

Teaser 3119: Hidden powers

From The Sunday Times, 3rd July 2022 [link] [link]

My grandson is studying “History since the Battle of Hastings”. I made him a game, which consisted of a row of nine cards, each with a different non-zero digit on it. Throw a standard die, note the number of spots displayed, count that number of places along the row and pause there. Throw the die again, move the corresponding number of places further along and pause again. Repeat this until you come off the end of the row, noting the digit or digits you paused on and put these together in the same order, to produce a number.

Keeping the cards in the same order I asked my grandson to try to produce a square or cube or higher power. He eventually discovered that the lowest possible such number was equal to the number of one of the years that he had been studying.

What is the order of the nine digits along the row?

[teaser3119]

Jim Randell 5:54 pm on 1 July 2022 Permalink | Reply

It took me a little while to understand how this puzzle is supposed to work.

And despite my initial misgivings there is only one possible arrangement of digits that can lead to the situation described.

The following Python program isn’t very quick (it tries all possible arrangements of digits), but it does find the required arrangement.

The code to generate powers is adapted from Teaser 683 and Enigma 1777.

It runs in 669ms.

Run: [ @replit ]

from enigma import (Primes, nsplit, subsets, irange, tuples, printf)

# generate powers (x^y) in numerical order, x >= 0, y >= 2,
def powers():
  # powers less than 2^2
  yield 0
  yield 1
  # powers from 2^2 upwards
  base = { 2: 2 }
  power = { 2: 4 }
  maxp = 2
  primes = Primes(35, expandable=1).generate(maxp + 1)
  while True:
    # find the next power
    n = min(power.values())
    yield n
    # what powers are involved
    ps = list(p for (p, v) in power.items() if v == n)
    # increase the powers
    for p in ps:
      base[p] += 1
      power[p] = pow(base[p], p)
    # do we need to add in a new power?
    if maxp in ps:
      maxp = next(primes)
      base[maxp] = 2
      power[maxp] = pow(2, maxp)

# collect candidate powers
pows = list()
for n in powers():
  if n > 2022: break
  # split the power into digits
  ds = nsplit(n)
  # no 0 digits, or repeated digits
  if 0 in ds or len(set(ds)) != len(ds): continue
  pows.append((n, ds))

# check powers that can be made with an arrangement of digits
def play(ss):
  # find powers that can be made
  ns = list()
  for (n, ds) in pows:
    # find indices of the digits
    js = list(ss.index(d) for d in ds)
    # check entry and exit
    if js[0] > 5 or js[-1] < 3: continue
    js.insert(0, -1)
    # and corresponding dice throws
    ts = list(y - x for (x, y) in tuples(js, 2))
    if min(ts) < 1 or max(ts) > 6: continue
    # check the power is permissible
    if n < 1066: return
    ns.append(n)
  # return the list of powers
  return ns

# consider possible arrangements of digits
for ss in subsets(irange(1, 9), size=len, select="P"):
  ns = play(ss)
  if ns:
    printf("{ss} -> {ns}")

Solution: The order of the digits is: 1, 9, 8, 7, 5, 2, 3, 4, 6.

And the smallest (and onliest) power which can be made by rolling the die is 1936, with rolls of (1, 1, 5, 2, *).

Although the puzzle talks about the lowest power that can be generated, it turns out it is the only (non-trivial) power that can be generated with the required arrangement of cards.

The puzzle will continue to work in the future, until the year 4913 (= 17³) is incorporated into the history book.

LikeLike

Jim Randell 10:13 am on 2 July 2022 Permalink | Reply

Here’s a faster (but slightly longer) program. Instead of just trying all possible arrangements of digits, it recursively constructs arrangements that cannot give powers less than 1066, and then finds which greater powers can be made.

It runs in 174ms.

Run: [ @replit ]

from enigma import (Primes, nsplit, subsets, tuples, diff, update, printf)

# generate powers (x^y) in numerical order, x >= 0, y >= 2,
def powers():
  # powers less than 2^2
  yield 0
  yield 1
  # powers from 2^2 upwards
  base = { 2: 2 }
  power = { 2: 4 }
  maxp = 2
  primes = Primes(35, expandable=1).generate(maxp + 1)
  while True:
    # find the next power
    n = min(power.values())
    yield n
    # what powers are involved
    ps = list(p for (p, v) in power.items() if v == n)
    # increase the powers
    for p in ps:
      base[p] += 1
      power[p] = pow(base[p], p)
    # do we need to add in a new power?
    if maxp in ps:
      maxp = next(primes)
      base[maxp] = 2
      power[maxp] = pow(2, maxp)

# collect candidate powers (disallowed and allowed)
(xpows, pows) = (list(), list())
for n in powers():
  if n > 2022: break
  # split the power into digits
  ds = nsplit(n)
  # no 0 digits, or repeated digits
  if 0 in ds or len(set(ds)) != len(ds): continue
  (xpows if n < 1066 else pows).append((n, ds))

# check if digit sequence <ds> can be made from arrangement <ns>
def play(ns, ds):
  # find indices of the digits
  js = list(ns.index(d) for d in ds)
  # check entry and exit
  if js[0] > 5 or js[-1] < 3: return False
  # check corresponding dice throws (1-6)
  js.insert(0, -1)
  return all(0 < y - x < 7 for (x, y) in tuples(js, 2))

# generate arrangements <ns> that don't allow sequences <xs> to be made
# ns = digit arrangement
# xs = disallowed sequences
# ss = allocated digits
# js = indices of empty slots
def solve(ns, xs, ss=set(), js=None):
  if not xs:
    yield ns
  else:
    # find the shortest sequences with the fewest missing digits
    fn = lambda ds: (len(set(ds).difference(ss)), len(ds))
    ds = min(xs, key=fn)
    # choose placements for the missing digits
    ms = diff(ds, ss)
    if not js: js = set(j for (j, n) in enumerate(ns) if n is None)
    for ks in subsets(js, size=len(ms), select="P"):
      ns_ = update(ns, ks, ms)
      if not play(ns_, ds):
        # solve the rest
        yield from solve(ns_, xs.difference([ds]), ss.union(ms), js.difference(ks))

# find layouts that do not permit sequences from xpows
for ns in solve([None] * 9, set(ds for (_, ds) in xpows)):
  # look for permissible powers
  ps = list(n for (n, ds) in pows if play(ns, ds))
  if ps:
    printf("{ns} -> {ps}")

LikeLiked by 1 person

Frits 11:28 pm on 1 July 2022 Permalink | Reply

Reusing my code of Teaser 683 and using Jim’s early performance enhancement (also considering number 1 as a power).

   
from itertools import permutations

def prime_factors(n):
  i = 2
  factors = []
  while i * i <= n:
    if n % i:
      i = 3 if i == 2 else i + 2
    else:
      n //= i
      factors.append(i)
  if n > 1:
    factors.append(n)
     
  return factors
    
def is_a_power(n):
  pf = prime_factors(n)
  if len(pf) < 2: 
    return False
     
  # occurences of digits  
  oc = {pf.count(x) for x in set(pf)}
  if mult_gcd(list(oc)) == 1:
    return False
  return True
 
# calculate greatest common divisor of multiple numbers  
def mult_gcd(li):
  if len(li) == 1:
    return li[0]
 
  for i in range(len(li) - 1):
    a = li[i]
    b = li[i+1]
    while b:
      (a, b) = (b, a % b)
     
    if a == 1: return a
     
    li[i+1] = a
  return a  
 
# generate powers, stop if you encounter one less than 1067    
def solve(k, s, pw=0, ns=[], rs=set()):
  if k > 0:
    # year must be before 2023
    if k == 1 and pw > 202:
      return []
    ls = len(s)
    for i in range(6):
      # check if you come off the end of the row
      if i > ls - 1: break
      p = 10 * pw + s[i]
      if p in pows and ls - i < 7:
        return [p]
      
      # recurse if worthwhile
      if p in powstart:  
        res = solve(k - 1, s[i + 1:], p, ns + [i + 1], rs)  
        if len(res) == 1:
          rs.add(res[0])
          if res[0] < 1067:
            return []  # no solution
    
    # if we didn't encounter a low power return list of powers
    return list(rs)    
    
# collect candidate powers
pows = {i for i in range(1, 2023) if is_a_power(i) and \
        len(s:= str(i)) == len(set(s)) and "0" not in s}  

powstart = {int(str(p)[:i]) for p in pows for i in range(1, 4)}

# consider possible arrangements of digits
for perm in permutations(range(1, 10)):
  # [performance] single digit powers cannot be in slots 3, 4, 5
  if {1, 4, 8, 9}.intersection(perm[3:6]): continue

  r = sorted(solve(4, perm, rs=set()))
  if r and r[0] > 1066:
    print(perm, "number", r[0])

LikeLike

Frits 9:29 am on 2 July 2022 Permalink | Reply

Python 3.9 introduced multiple arguments version of math.gcd so math.gcd() can be used instead of mult_gcd().

LikeLike
- Jim Randell 10:14 am on 2 July 2022 Permalink | Reply
  
  Or you can use enigma.mgcd() which will work in a wide variety of Python implementations.
  
  LikeLike

Frits 2:50 pm on 2 July 2022 Permalink | Reply

Just as with Jim ‘s third program only calling solve() for 49 permutations.

Doing the checks for 2-digit and 3-digit powers in a general way is a bit slower.
Also storing digit positions in a dictionary to minimize index() calls is a bit slower.

   
from itertools import permutations
from math import gcd

def prime_factors(n):
  i = 2
  factors = []
  while i * i <= n:
    if n % i:
      i = 3 if i == 2 else i + 2
    else:
      n //= i
      factors.append(i)
  if n > 1:
    factors.append(n)
     
  return factors
    
def is_a_power(n):
  pf = prime_factors(n)
  if len(pf) < 2: 
    return False
     
  # occurences of digits  
  oc = {pf.count(x) for x in set(pf)}
  if gcd(*oc) == 1:
    return False
  return True
 
# generate powers, stop if you encounter one less than 1067    
def solve(k, s, pw=0, ns=[], rs=set()):
  if k > 0:
    # year must be before 2023
    if k == 1 and pw > 202:
      return []
    ls = len(s)
    for i in range(6):
      # check if you come off the end of the row
      if i > ls - 1: break
      p = 10 * pw + s[i]
      if p in pows and ls - i < 7:
        return [p]
      
      # recurse if worthwhile
      if p in powstart:  
        res = solve(k - 1, s[i + 1:], p, ns + [i + 1], rs)  
        if len(res) == 1:
          rs.add(res[0])
          if res[0] < 1067:
            return []  # no solution
    
    # if we didn't encounter a low power return list of powers
    return list(rs)    
    
# collect candidate powers
pows = {i for i in range(1, 2023) if is_a_power(i) and \
        len(s:= str(i)) == len(set(s)) and "0" not in s}  

powstart = {int(str(p)[:i]) for p in pows for i in range(1, 4)}

# 2-digit powers
pows2 = [(x // 10, x % 10) for x in pows if 9 < x < 100]

# 3-digit powers
pows3 = [(x // 100, (x // 10) % 10, x % 10) for x in pows if 99 < x < 1000]

# consider possible arrangements of digits
for perm in permutations(range(1, 10)):
  # [performance] single digit powers cannot be in slots 3, 4, 5
  if {1, 4, 8, 9}.intersection(perm[3:6]): continue
  
  # check 2-digit powers
  for a, b in pows2:
    posa = perm.index(a)
    posb = perm.index(b)
    # can we make the power in 2 jumps and then come off the end of the row?
    if 0 < (posb - posa) < 7 and posa < 6 and posb > 2:
      break
  else:  # no break   
    # check 3-digit powers
    for a, b, c in pows3:
      posa = perm.index(a)
      posb = perm.index(b)
      posc = perm.index(c)
      # can we make the power in 3 jumps and 
      # then come off the end of the row?
      if not (0 < (posb - posa) < 7 and 0 < (posc - posb) < 7): continue
      if posa < 6 or posc > 2:
        break    
    else:  # no break   
      # no 2- or 3-digit power can be formed
      r = sorted(solve(4, perm, rs=set()))
      if r and r[0] > 1066:
        print(perm, "number", r[0])

LikeLike

Frits 4:04 pm on 2 July 2022 Permalink | Reply

Without recursion.

   
from itertools import permutations
from enigma import mgcd

def prime_factors(n):
  i = 2
  factors = []
  while i * i <= n:
    if n % i:
      i = 3 if i == 2 else i + 2
    else:
      n //= i
      factors.append(i)
  if n > 1:
    factors.append(n)
     
  return factors
    
def is_a_power(n):
  pf = prime_factors(n)
  if len(pf) < 2: 
    return False
     
  # occurences of digits  
  oc = {pf.count(x) for x in set(pf)}
  if mgcd(*oc) == 1:
    return False
  return True
 
# collect candidate powers
pows = {i for i in range(1, 2023) if is_a_power(i) and \
        len(s:= str(i)) == len(set(s)) and "0" not in s}  

# powers grouped by number of digits
pws = [[[int(x) for x in str(p)] for p in pows 
         if 10**i <= p < 10**(i + 1)] for i in range(1, 4)]

# do powers exists >= 2000 ?
exists2xxx = any(x for x in pws[2] if x[0] == 2)

# consider possible arrangements of digits
for perm in permutations(range(1, 10)):
  # [performance] single digit powers cannot be in slots 3, 4, 5
  if {1, 4, 8, 9}.intersection(perm[3:6]): continue
  
  for ps in pws[:-1]:
    for p in ps:
      pos = [perm.index(i) for i in p]
      # first digit reachable and then come off the end of the row?
      if not(pos[0] < 6 and pos[-1] > 2): continue
      # can we make the power in <len(pos)> jumps ...
      if any(y - x not in {1, 2, 3, 4, 5, 6} for x, y in zip(pos, pos[1:])):
        continue
        
      # we have found a valid 2- or 3-digit power
      break
    else: # no break  
      continue
      
    break   # break if break occurred    
  else:  # no break
    if not exists2xxx:
      # check position of 1
      if perm.index(1) > 5: continue
    
    # check 4-digit powers
    for p in sorted(pws[2]):
      pos = [perm.index(i) for i in p]
      # it is enough to only check for increasing numbers
      if pos != sorted(pos): continue
      
      print(perm, "number", "".join(str(x) for x in p))
      break

LikeLike

Frits 5:48 pm on 8 July 2022 Permalink | Reply

   
from itertools import permutations
from functools import reduce
from math import gcd

def prime_factors(n):
  i = 2
  factors = []
  while i * i <= n:
    if n % i:
      i = 3 if i == 2 else i + 2
    else:
      n //= i
      factors.append(i)
  if n > 1:
    factors.append(n)
     
  return factors
    
def is_a_power(n):
  if n == 1: return [1]
  pf = prime_factors(n)
  if len(pf) < 2: 
    return False
     
  # occurences of digits  
  oc = {pf.count(x) for x in set(pf)}
  if gcd(*oc) == 1:
    return False
  return True

# group type
gtype = lambda i: "first" if i == 0 else "middle" if i == 1 else "last"
        
# collect all candidate powers
pows = {i for i in range(1, 2023) if is_a_power(i) and 
        len(s:= str(i)) == len(set(s)) and "0" not in s} 

# powers grouped by number of digits
pws = [set(str(p) for p in pows 
         if 10**i <= p < 10**(i + 1)) for i in range(4)]
         
# return possible arrangements of digits in group <grp> for 2-digit powers
def arrangements(grp):
  return [p for p in permutations(grp) if all(fdgt + sdgt not in pws[1] 
          for fdgt, sdgt in [(p[0], p[1]), (p[0], p[2]), (p[1], p[2])])
         ]

# return all numbers per group that don't occur in other groups
def calc_known(grp):
  return [[x for x in grp[i] 
          if all(x not in t for t in 
                [y for j, y in enumerate(grp) if j != i])] 
          for i in range(3)]
 
# for all combinations in <lst> check if a 3-digit power can be made
# with a digit in the last group
def check_last_group(grp, lst):
  forbidden = [set() for _ in range(len(lst))]
  for i, n in enumerate(lst):
    # for all combinations in <lst> 
    for x in [(n[0] + n[1]), (n[0] + n[2]), (n[1] + n[2])]:
      for p in pws[2]:
        if x in {p[:-1]}:
          # x + p[-1] is 3-digit power so p[-1] is forbidden in last group
          forbidden[i].add(p[-1])
        
  # return numbers in the last group which are forbidden for all <lst> entries
  return reduce((lambda x, y: x & y), map(set, forbidden))

# maintain groups if all numbers in a group are known
def maintain_groups(grp, fixed):
  for i, fix in enumerate(fixed):
    # all numbers in a group are known?
    if len(fix) == 3:
      # remove other numbers from this group
      for n in [x for x in grp[i] if x not in fix]:
        print(f"{gtype(i)} group must be {','.join(fix)}:"
              f" remove {n} from {gtype(i)} group")
      grp[i] = set(fix)
            
def print_groups(g):
  print("----- groups:", ",".join(sorted(g[0])), "--", 
                         ",".join(sorted(g[1])), "--", 
                         ",".join(sorted(g[2])), "-----")

# maintain and print groups  
def update(g):
  known = calc_known(g)
  maintain_groups(g, known)
  print_groups(g)
  return known


print("-------- START -----------")

print("split the nine digits in three groups of three digits")
# list <g> contains candidate digits for each group
g = [set("123456789"), set("123456789"), set("123456789")]
print_groups(g)

print(f"removing 1 from last group"
      f" as we need a 4-digit power 1xxx as an answer")
g[2] -= {'1'}             # we need a 4-digit power

print("removing", ", ".join(sorted(pws[0])), 
      "from middle group to prevent single digit powers")
g[1] -= set(pws[0])       

for x in calc_known(g)[0]:
  # can we can make a 2-digit power with <x>?
  for p in [p2 for p2 in pws[1] if p2[0] == x]:
    print("removing", p[1], "from middle group to prevent power", p)
    g[1].remove(p[1])         

print_groups(g)

# check middle group
if len(g[1]) == 4:
  # see what happens if we remove <m> from middle group 
  for m in g[1]:
    middle = [x for x in g[1] if x != m]
    for m2 in middle:
      # if combination is a 2-digit power <m> must occur in middle group
      if m2 + m in pws[1]: 
        g[2] -= {m}
      if m + m2 in pws[1]: 
        g[0] -= {m}
   
    # get arrangements from <middle> without a 2-digit power
    lst = arrangements(middle)
    
    if len(lst) == 1:
      # we have only one arrangement for slots 3, 4 and 5 
      # can we can make a 3-digit power with this arrangement?
      arr = lst[0]
      for a in [(arr[0] + arr[1]), (arr[0] + arr[2]), (arr[1] + arr[2])]:
        # 3-digit powers that can be made from <a>
        tdp = [p3 for p3 in pws[2] if a in p3[:-1]]
        for p in tdp:
          # last digit of 3-digit power may not be used yet
          if p[-1] in (arr + ('1', )): continue
          # removing m has lead to a valid 3-digit power 
          print(f"removing {m} from the middle group can lead to"
                f" power {p}, remove {m} from first and last group")
          g[0] -= {m}
          g[2] -= {m}
         
  # maintain and print groups
  known = update(g)
  
  # for every 3-digit power check if two of it's digits have to occur in two 
  # groups, if so we can remove the other digit from the other group
  first = 1
  for p in pws[2]:
    unknown = [i for i in range(3) if p[i] not in known[i]]  
    if len(unknown) != 1: continue
    
    i = unknown[0]
    if first: 
      print("known digits per group:", known)
      first = 0
    
    print(f"digits {' and '.join(p[j] for j in range(3) if j != i)}"
          f" of power {p} each have to occur in a different specific group:"
          f" remove {p[i]} from {gtype(i)} group")
    g[i] -= {p[i]}
  
  update(g)
  
  # get numbers in the last group which make a 3-digit power for all
  # valid combinations in the middle group
  for s in check_last_group(g, arrangements(g[1])):
    print(f"all valid combinations of middle group combined with the number"
          f" {s} lead to 3-digit power: remove {s} from last group")
    g[2] -= {s}
         
  update(g)
  print()
  
  # consider possible arrangements of digits
  for p0 in permutations(g[0]):
    for p1 in arrangements(g[1]):
      for p2 in permutations(g[2]):
        perm = p0 + p1 + p2
        # check 2-digit and 3-digit powers
        for ps in pws[1:-1]:
          for p in ps:
            # the index positions of its digits in the row of cards
            pos = [perm.index(i) for i in p]
            # ensure that its first digit is reachable and that its
            # last digit can be the final digit (with a throw of six)
            if not(pos[0] < 6 and pos[-1] > 2): 
              continue
            # can we make the power in intervals of  1 - 6 jumps?
            if any(y - x not in set(range(1, 7))
                  for x, y in zip(pos, pos[1:])):
              continue

            # we have found a valid 2-digit or 3-digit power
            break
          else: 
            continue

          break   # break again if break occurred    
        else:  
          # check 4-digit powers
          for p in sorted(pws[3]):
            pos = [perm.index(i) for i in p]
            
            # checking for the correct digit order is sufficient because
            # the highest gap between digits is five empty slots
            if pos != sorted(pos): continue
            
            print(perm, "number", p)
            break  # only print the lowest 4-digit power

LikeLike

Jim Randell 9:59 am on 30 June 2022 Permalink | Reply
Tags: by: Michael Fletcher ( 18 )
Teaser 2720: Better tetra
From The Sunday Times, 9th November 2014 [link] [link]

I have four tetrahedral dice. Each has four identical triangular faces and on each face of each die is one of the numbers 1, 2, 3 or 4 (repeats being allowed on a die). No die uses the same four numbers and, for each die, the sum of its four numbers is ten.

I play a game with my friend. My friend chooses a die first and then I choose one of the remaining three dice. We each throw our chosen die and score the face-down number: sometimes it’s a draw, otherwise the higher number wins. I can choose my die so that I am always more likely to win.

So my friend changes the rules. We now throw our chosen die twice, add the two numbers, and the higher total wins.

Now he knows that there is one die he can choose that makes him more likely to win the game.

What are the four numbers on the winning dice?

The wording for this puzzle has been modified from the originally published version.

[teaser2720]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Frits and Jim Randell are discussing. Toggle Comments
- Jim Randell 10:00 am on 30 June 2022 Permalink | Reply
  (See: [@youtube]).
  
  We assume that the dice are chosen in such a way that each player is aware of which die has been chosen. (So, for example, they may be different colours and arranged on the table, but not be hidden a bag and chosen by putting your hand in and selecting one at random).
  
  When we compare 2 dice, we say that one is “better” than the other, if it is more like to win a game against the other die.
  
  There are 5 possible dice (i.e. 5 possible decompositions of 10 into the numbers 1, 2, 3, 4), but the set only contains 4 of these.
  
  It turns out there is only one possible set of 4, where whatever die A chooses B can always choose a better die.
  
  And from this set we can look to see if there is die which is better when played against each of the other dice.
  
  This Python program runs in 61ms. (Internal runtime is 593µs).
  
  Run: [ @replit ]
```
from enigma import (decompose, subsets, multiset, product, printf)

# return wins for X and Y in a game with k throws?
def play(X, Y, k):
  # generate scores for X and Y
  (sX, sY) = (multiset.from_seq(sum(ss) for ss in subsets(ns, size=k, select="M")) for ns in (X, Y))
  # count wins for X, wins for Y
  wX = wY = 0
  for ((x, nx), (y, ny)) in product(sX.items(), sY.items()):
    if x > y:
      wX += nx * ny
    elif y > x:
      wY += nx * ny
  return (wX, wY)

# is X better than Y in a game with k throws?
def better(X, Y, k):
  (wX, wY) = play(X, Y, k)
  return wX > wY

# generate possible dice
ns = list(decompose(10, 4, increasing=1, sep=0, min_v=1, max_v=4))

# choose a set of 4 dice, and solve the puzzle
for ds in subsets(ns, size=4):

  # with 1 throw, whatever die A chooses, B can always choose a better die
  if not all(any(better(B, A, 1) for B in ds if B != A) for A in ds): continue
  printf("dice = {ds}")

  # with 2 throws, A can choose a die that is better than the others
  for A in ds:
    if not all(better(A, B, 2) for B in ds if B != A): continue
    printf("-> A = {A}")
```
  Solution: The best die in the second game is: (1, 3, 3, 3).
  
  The four dice are:
  
  (1, 1, 4, 4)
  (1, 3, 3, 3)
  (2, 2, 2, 4)
  (2, 2, 3, 3)
  
  And we have:
  
  (1, 1, 4, 4) is beaten by (2, 2, 2, 4)
  (2, 2, 2, 4) is beaten by (2, 2, 3, 3) and (1, 3, 3, 3)
  (2, 2, 3, 3) is beaten by (1, 3, 3, 3)
  (1, 3, 3, 3) is beaten by (1, 4, 4, 4)
  
  So whichever die is chosen first, there is always a choice from the other three that is better.
  
  LikeLike
- Frits 5:54 pm on 30 June 2022 Permalink | Reply
  Apparently we can also compare lists with the less than operator in Python.
```
   
from itertools import product
from enigma import SubstitutedExpression

# number of times x wins from y if die is thrown once
play1 = lambda x, y: sum([p > q for p, q in product(x, y)])

# number of times x wins from y if die is thrown twice
def play2(x, y):
  # add the score of two throws
  x2 = [p + q for p, q in product(x, x)]
  y2 = [p + q for p, q in product(y, y)]
  
  return sum([p > q for p, q in product(x2, y2)])


# the alphametic puzzle
p = SubstitutedExpression(
  [
   "A <= B <= C",
   "10 - A - B - C = D",
   "C <= D",
   
   "E <= F <= G",
   "10 - E - F - G = H",
   "G <= H",
   "(A, B, C, D) < (E, F, G, H)",
   
   "I <= J <= K",
   "10 - I - J - K = L",
   "K <= L",
   "(E, F, G, H) < (I, J, K, L)",
   
   "M <= N <= O",
   "10 - M - N - O = P",
   "O <= P",
   "(I, J, K, L) < (M, N, O, P)",
   
   # with 1 throw, whatever die my friend chooses (x), 
   # I can always choose a better die (y), resulting in 4 wins
   "sum([any(play1(y, x) > play1(x, y) \
         for y in [(A,B,C,D), (E,F,G,H), (I,J,K,L), (M,N,O,P)] if y != x) \
         for x in [(A,B,C,D), (E,F,G,H), (I,J,K,L), (M,N,O,P)]]) == 4",
  ],
  answer="(A,B,C,D), (E,F,G,H), (I,J,K,L), (M,N,O,P)",
  env=dict(play1=play1),
  distinct="",
  digits=range(1, 5),
  reorder=0,
  verbose=0,    # use 256 to see the generated code
)

# check if my friend can win with the die thrown twice
for _, s in p.solve():
  for s1 in s:
    if all(play2(s1, s2) > play2(s2, s1) for s2 in s if s1 != s2):
      print("answer:", s1)
```
  LikeLike
Jim Randell 9:54 am on 28 June 2022 Permalink | Reply
Tags: by: M C Breach
Brain-Teaser 724: Counting sheep …
From The Sunday Times, 1st June 1975 [link]

In a primitive eastern country a shepherd was counting his
sheep into four separate pens. In the first were 75 sheep, so he wrote in his records:

In the second were 255 and he wrote:

In the third were 183 and he wrote:

After counting the sheep in the fourth pen he wrote:

How many sheep were in the fourth pen?

This puzzle is included in the book The Sunday Times Book of Brain-Teasers: Book 2 (1981). The puzzle text above is taken from the book.

[teaser724]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
GeoffR and Jim Randell are discussing. Toggle Comments
- Jim Randell 9:55 am on 28 June 2022 Permalink | Reply
  
  I think this puzzle is a bit open ended.
  
  I called the symbols A (for the triangle), D (for the box), and X (for the loop).
  
  For all we know DXA, ADX, XAD could be words that happen to mean 75, 255, 183.
  
  Or it could be some system with strange rules (like roman numerals, for instance).
  
  So, I made some assumptions:
  
  I assumed each symbol stands for a different non-negative integer value (but the same value whenever it appears). And as the same symbols appear in a different order for each of the given values I assumed position is important (as it is in our decimal system).
  
  My first thought was maybe it was just a substituted base system where each digit is represented by one of the symbols.
  
  For 255 to be represented by 3-digits the base must be 7 – 15.
  
  For 75 to be represented by 3-digits the base must be: 5 – 8.
  
  So we can look at values 75, 255, 183 in base 7 and 8:
  
  base 7: 75 → “135”; 255 → “513”; 183 → “351”
  base 8: 75 → “113”; 255 → “377”; 183 → “267”
  
  Only for the case of base 7 do the same 3 digits appear in different orders.
  
  And in this case the substitution: A=5, D=1, X=3, gives us:
  
  DAX = 153 [base 7] = 87 [base 10]
  
  So: 87 is certainly a possible answer (and it is the published answer).
  
  But there are other solutions where the positions represent different values, but not necessarily increasing powers of some base.
  
  For instance instead of the positions standing for (49, 7, 1) and the symbols being A=5, D=1, X=3, we swap them over to give:
  
  positions = (1, 5, 3); A=7, D=49, X=1
  DXA = 49×1 + 1×5 + 7×3 = 75
  ADX = 7×1 + 49×5 + 1×3 = 255
  XAD = 1×1 + 7×5 + 49×3 = 183
  DAX = 49×1 + 7×5 + 1×3 = 87
  
  But we can also use decreasing position values:
  
  positions = (39, 11, 7); A=6, D=0, X=3
  DXA = 0×39 + 3×11 + 6×7 = 75
  ADX = 6×39 + 0×11 + 3×7 = 255
  XAD = 3×39 + 6×11 + 0×7 = 183
  DAX = 0×39 + 6×11 + 3×7 = 87
  
  Note: this combination of positions is able to express all numbers greater than 59.
  
  positions = (117, 33, 21); A=2, D=0, X=1 (Note: symbols are 0, 1, 2):
  DXA = 0×117 + 1×33 + 2×21 = 75
  ADX = 2×117 + 0×33 + 1×21 = 255
  XAD = 1×117 + 2×33 + 0×21 = 183
  DAX = 0×117 + 2×33 + 1×21 = 87
  
  Note: this combination of positions can only be used to express multiples of 3.
  
  Or mixed positions:
  
  positions = (7, 31, 19); A=1, D=8, X=0
  DXA = 8×7 + 0×31 + 1×19 = 75
  ADX = 1×7 + 8×31 + 0×19 = 255
  XAD = 0×7 + 1×31 + 8×19 = 183
  DAX = 8×7 + 1×31 + 0×19 = 87
  
  Note: this combination of positions is able to express all numbers greater than 86.
  
  And we can also find viable answers of 159 or 267.
  
  positions = (31, 19, 7); A=8, D=0, X=1
  DXA = 0×31 + 1×19 + 8×7 = 75
  ADX = 8×31 + 0×19 + 1×7 = 255
  XAD = 1×31 + 8×19 + 0×7 = 183
  DAX = 0×31 + 8×19 + 1×7 = 159
  
  positions = (33, 21, 117); A=0, D=1, X=2 (Note: symbols are 0, 1, 2)
  DXA = 1×33 + 2×21 + 0×117 = 75
  ADX = 0×33 + 1×21 + 2×117 = 255
  XAD = 2×33 + 0×21 + 1×117 = 183
  DAX = 1×33 + 0×21 + 2×117 = 267
  
  These values can also be found by permuting the (49, 7, 1) positions of the base 7 representation.
  
  LikeLike
  - Jim Randell 11:13 pm on 28 June 2022 Permalink | Reply
    Here is a simple program using the [[ SubstitutedExpression ]] solver from the enigma.py library to solve the puzzle as a standard positional base system (which is how the puzzle is intended).
    
    It runs in 65ms.
```
from enigma import (SubstitutedExpression, map2str, printf)

# consider bases 7 and 8
for b in [7, 8]:
  # create the alphametic puzzle
  p = SubstitutedExpression(
    [ "DXA == 75", "ADX == 255", "XAD == 183" ],
    base=b,
    answer="DAX",
    verbose=0,
  )
  # solve it
  for (s, ans) in p.solve():
    # output solution
    printf("DAX={ans} [b={b}; {s}]", s=map2str(s, enc=""))
```
    LikeLike
- GeoffR 10:06 am on 29 June 2022 Permalink | Reply
```
% A Solution in MiniZinc
include "globals.mzn";
% test for numerical bases 7 and 8 only, as Jim's analysis
% i.e. symbols A (for the triangle), D (for the box), and X (for the loop)

var 1..7:D; var 1..7:A; var 1..7:X;

constraint  % base 7
(D < 7 /\ A < 7 /\ X < 7 
/\ (7 * 7 * D + 7 * X + A == 75) 
/\ (7 * 7 * A + 7 * D + X == 255) 
/\ (7 * 7 * X + 7 * A + D == 183))
\/  % base 8
(  (8 * 8 * D + 8 * X + A == 75) 
/\ (8 * 8 * A + 8 * D + X == 255)
/\ (8 * 8 * X + 8 * A + D == 183));

solve satisfy;

output ["[D, A, X ] = " ++ show([D, A, X ]) ];

% [D, A, X ] = [1, 5, 3]  
% ----------
% ==========
% DXA = 135, ADX = 513, XAD = 351, DAX = 153 (base 7)
% DAX (base 7) = 1*7*7 + 5*7 + 3 = 87 ( base 10)
```
  LikeLike

Jim Randell 11:55 am on 26 June 2022 Permalink | Reply
Tags: by: W. M. Greenway ( 5 )

Brain-Teaser 101: Midsummer birthday madness

From The Sunday Times, 3rd March 1963 [link]

Midsummer Day, 1962 (June 24) was my youngest grandson John’s first birthday, and I was then able to claim that my nine grandchildren were aged 0, 1, 2, 3, 4, 5, 6, 7, and 8 years old (neglecting, of course, the odd days). They were all born in June, and if they are arranged in birthday order through the month the following facts are true:

John is the middle grandchild;

The sum of the dates of the last four is an exact multiple of the sum of the dates of the first four;

The sum of the ages of the last four is two-thirds of the sum of the ages of the first four;

The sum of the years of birth of the first three is equal to the sum of the years of birth of the last three;

The intervals between birthdays are 0, 1, 2, 3, 4, 5, 6, and 7 days, but not in that order;

Also:

My eldest son’s two daughters are exactly two years apart;

The twins were born four hours apart;

Two children are as old as their dates of birth.

What was the date of birth of the grandchild born in 1954?

This puzzle is included in the book Sunday Times Brain Teasers (1974).

There are now 700 Teaser puzzles available on the site.

[teaser101]

Jim Randell 11:56 am on 26 June 2022 Permalink | Reply

The ages are all different, so the twins must be born either side of midnight on the 24th, so John is one of the twins, and the other must have a birthday of the 25th. John is the youngest grandson, so his (younger) twin must be a girl.

This Python program starts with the 24th in the middle of the order, and then chooses an ordering for the intervals to give the remaining dates. It then assigns the ages, and checks all the required conditions apply.

It runs in 161ms.

from enigma import (subsets, div, printf)

# the middle birthday is on the 24th, and the separation between
# birthdays is (0, 1, 2, 3, 4, 5, 6, 7), in some order
for ss in subsets((0, 1, 2, 3, 4, 5, 6, 7), size=len, select="P"):
  # construct the dates
  d5 = 24
  (d4, d6) = (d5 - ss[3], d5 + ss[4])
  (d3, d7) = (d4 - ss[2], d6 + ss[5])
  (d2, d8) = (d3 - ss[1], d7 + ss[6])
  (d1, d9) = (d2 - ss[0], d8 + ss[7])
  if d1 < 1 or d9 > 30: continue
  ds = [ d1, d2, d3, d4, d5, d6, d7, d8, d9]

  # John's twin must be born on the 25th
  if 25 not in ds: continue

  # sum of the dates of the last 4 is an exact multiple of the sum of
  # the dates of the first four
  x = div(sum(ds[-4:]), sum(ds[:4]))
  if x is None or x < 2: continue

  # choose values for the ages (John is 1)
  for ns in subsets((0, 2, 3, 4, 5, 6, 7, 8), size=len, select="P", fn=list):
    # insert 1
    ns.insert(4, 1)

    # John's twin (age 0) was born on the 25th
    if ds[ns.index(0)] != 25: continue

    # the sum of the ages of the last four is 2/3 the sum of the ages
    # of the first four
    if 3 * sum(ns[-4:]) != 2 * sum(ns[:4]): continue

    # [exactly] 2 ages are the same as the date
    if sum(x == y for (x, y) in zip(ds, ns)) != 2: continue

    # the sum of the years of birth of the first three is the same as
    # the sum of the years of birth of the last three
    ys = list(1962 - x for x in ns[:5]) + list(1961 - x for x in ns[5:])
    if sum(ys[:3]) != sum(ys[-3:]): continue

    # find the 2 grandchildren that share a birthday
    i = ss.index(0)
    # neither can be John
    if i == 3 or i == 4: continue
    # the ages must differ by 2
    if abs(ns[i] - ns[i + 1]) != 2: continue

    # output solution
    for (d, n, y) in zip(ds, ns, ys):
      printf("{d:02d} June {y} -> age = {n}{s}", s=(' [*** SOLUTION ***]' if y == 1954 else ''))
    printf()

Solution: The birthday of the grandchild born in 1954 is 11th June.

The dates of birth and ages are:

02 June 1960 → age = 2 (age 2 on the 2nd)
07 June 1955 → age = 7 (age 7 on the 7th)
11 June 1954 → age = 8 (answer)
17 June 1958 → age = 4
24 June 1961 → age = 1 (today, John’s birthday)
25 June 1961 → age = 0 (John’s twin sister)
28 June 1958 → ages = 3 & 5 (two granddaughters, exactly 2 years apart)
30 June 1955 → age = 6

The program prints two solutions because the granddaughters born on 28th June could appear in either order.

LikeLike

Frits 3:09 pm on 29 June 2022 Permalink | Reply

   
# dates: A,  B,  C,  D,  E,  F,  G,  H,  I  in order
# ages : R,  S,  T,  U,  V,  W,  X,  Y,  Z  not necessarily in order

'''
Notation: XYZ stands for X + Y + Z

The ages are all different, so the twins must be born either side of 
midnight on the 24th, so John is one of the twins, and the other must
have a birthday of the 25th. John is the youngest grandson, 
so his (younger) twin must be a girl.

E = 24, F = 25, V = 1, zero age is either W or X 

After F (25) we can only have intervals 0, 2 and 3 otherwise I exceeds 30
so I has to be 30 
A has to be equal to E (24) - intervals 4, 5, 6 and 7, so A = 2

Two children are as old as their dates of birth
so R = A and S = B

The sum of the ages of the last four is two-thirds of the sum of the
ages of the first four, sum of all ages is 36, John in the middle is 1
so we have to split the remaining 35 into a 21 and 14. 

The sum of the years of birth of the first three is equal to the sum of 
the years of birth of the last three, RST must be equal to XYZ + 3.

2 * RSTU = 3 * WXYZ ==> 2 * RST + 2 * U = 3 * W + 3 * RST - 9
==> ST = 2 * U - 3 * W + 7  (using R = 2)

RSTUVWXYZ = 36 

R    [     ST      ]       V       [    XYZ      ]   
2 +  2 * U - 3 * W + 7 + U + 1 + W + 2 * U - 3 * W + 6 = 36
5 * (U - W) = 20 ==> U = W + 4
(U, W) is (4, 0), (7, 3) or (8, 4)

If W is not zero:
  X must be zero leaving (U, W) to be (7, 3) or (8, 4).
  Two daughters with same birthday are exactly two years apart.
  These must be Y and Z (not W as V is male and Y can't be 2)
  W + Y + Z = 14. if W is odd than Y and Z can't be two years apart.
  This leaves W = 4 and Y + Z = 10, only two years apart option for Y and Z
  is 4 and 6. This is impossible as W already is 4. So W = 0 and U = 4.
'''

# dates: 2,  B,  C,  D, 24, 25,  G,  H, 30  in order
# ages : 2,  S,  T,  4,  1,  0,  X,  Y,  Z  not necessarily in order

'''
In order to have after F the intervals 2 and 3 either G or H must be 27 or 28
so 109 <= FGHI <= 115.
In order to have intervals 4, 5, 6, 7 we have 36 <= ABCD <= 46
(using 2, 6, 11, 17 resp. 2, 9, 15, 20 for A, B, C, D). 

So FGHI = 3 * ABCD (using multiplier three) leaving only values 37 and 38
for ABCD (with FGHI resp. 111 and 114) .
Using (2, 8, C, D) for (A, B, C, D) we get at least a sum of 39
then (A, B, C, D) is either (2, 6, C, D) or (2, 7, C, D).

As U = 4 RST must be 17, ST = 15 so R and S must use 7 and 8 
leaving 3, 5 and 6 for X, Y and Z.

As S is 7 or 8 and B is either 6 or 7 we can deduce R = 7, B = 7, S = 8.

Using (2, 7, 13, 17) for (A, B, C, D) we get at a sum of 39 so 
(A, B, C, D) is (2, 7, 11, 17). 
'''

# dates: 2,  7, 11, 17, 24, 25,  G,  H, 30  in order
# ages : 2,  7,  8,  4,  1,  0,  X,  Y,  Z  not necessarily in order

'''
As a grandchild born in 1954 can only occur with age 8 and date before 25
or age 7 and date after 24 we see the answer is 11th June 1954.
'''

LikeLike

Jim Randell 3:55 pm on 24 June 2022 Permalink | Reply
Tags: by: Edmund Marshall ( 10 )
Teaser 3118: Product dates
From The Sunday Times, 26th June 2022 [link] [link]

If a date during the current millennium is day D in month M during year (2000+N), it is said to be a product date if the product of D and M equals N (for example 11 February 2022).

My daughter and I have been investigating the numbers of days from one product date to the next product date. I was able to establish the longest such interval L, while my daughter worked out the shortest such interval S. We were surprised to find that L is a whole number multiple of S.

What is that multiple?

[teaser3118]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 4:07 pm on 24 June 2022 Permalink | Reply
  This Python program runs in 61ms. (Internal run time is 862µs).
  
  Run: [ @replit ]
```
from datetime import date
from enigma import (Accumulator, irange, product, tuples, catch, div, printf)

# generate "product dates" in the 21st century
def generate():
  # consider each possible D, M pairing
  for (D, M) in product(irange(1, 31), irange(1, 12)):
    N = D * M
    d = catch(date, 2000 + N, M, D)
    if d is not None:
      yield d

# find the maximum and minimum separations between consecutive dates
rs = Accumulator.multi(fns=[max, min], collect=1)
for (a, b) in tuples(sorted(generate()), 2):
  d = (b - a).days
  rs.accumulate_data(d, (a, b))

# output solution
(L, S) = (x.value for x in rs)
d = div(L, S)
printf("L/S = {d} [L={L} S={S}]")
```
  Solution: The multiple is 274.
  
  The longest interval is 4384 days (2236-12-28 → 2348-12-29 → 2360-12-30 → 2372-12-31).
  
  The shortest interval is 16 days (2030-01-30 → 2030-02-15).
  
  LikeLike

	Hugo on Teaser 3320: Penblwydd Ha…
	Frits on Teaser 3320: Penblwydd Ha…
	Ruud on Teaser 3320: Penblwydd Ha…
	Jim Randell on Teaser 3320: Penblwydd Ha…
	Jim Randell on Teaser 2441: [Letter grid…
	Jim Randell on Teaser 2433: [Date of bir…
	Jim Randell on Teaser 3318: Squaring the…
	Ruud on Teaser 3319: Watch out!

Search

Recent Posts

Recent Comments

Archives

Categories

Subscribe

RSS Links

Site Stats

Meta

Updates from July, 2022 Toggle Comment Threads | Keyboard Shortcuts

Jim Randell 9:10 am on 28 July 2022 Permalink | Reply Tags: by: Michael Fletcher ( 18 )

Rate this:

Share:

Jim Randell 9:12 am on 28 July 2022 Permalink | Reply

Reply Cancel reply

Jim Randell 9:17 am on 26 July 2022 Permalink | Reply Tags: by: Dr V W Bryant ( 5 )

Rate this:

Share:

Jim Randell 9:18 am on 26 July 2022 Permalink | Reply

John Crabtree 6:50 pm on 26 July 2022 Permalink | Reply

Jim Randell 8:20 am on 27 July 2022 Permalink | Reply

Jim Randell 2:04 pm on 24 July 2022 Permalink | Reply Tags: by: C Skeffington Quin ( 11 ), flawed ( 55 )

Rate this:

Share:

Jim Randell 2:06 pm on 24 July 2022 Permalink | Reply

Jim Randell 4:03 pm on 22 July 2022 Permalink | Reply Tags: by: Angela Newing ( 39 )

Rate this:

Share:

Jim Randell 4:15 pm on 22 July 2022 Permalink | Reply

Jim Randell 8:48 am on 26 July 2022 Permalink | Reply

GeoffR 5:51 pm on 23 July 2022 Permalink | Reply

GeoffR 9:41 pm on 23 July 2022 Permalink | Reply

GeoffR 12:07 pm on 1 August 2022 Permalink | Reply

Jim Randell 9:07 am on 21 July 2022 Permalink | Reply Tags: by: Victor Bryant ( 147 )

Rate this:

Share:

Jim Randell 9:08 am on 21 July 2022 Permalink | Reply

GeoffR 11:38 am on 21 July 2022 Permalink | Reply

Jim Randell 6:31 am on 19 July 2022 Permalink | Reply Tags: by: Nick MacKinnon ( 57 )

Rate this:

Share:

Jim Randell 6:33 am on 19 July 2022 Permalink | Reply

Jim Randell 12:33 pm on 17 July 2022 Permalink | Reply Tags: by: Graham Smithers ( 84 )

Rate this:

Share:

Jim Randell 12:34 pm on 17 July 2022 Permalink | Reply

GeoffR 2:16 pm on 17 July 2022 Permalink | Reply

Frits 3:40 pm on 17 July 2022 Permalink | Reply

GeoffR 6:43 pm on 17 July 2022 Permalink | Reply

Jim Randell 4:03 pm on 15 July 2022 Permalink | Reply Tags: by: Howard Williams ( 45 )

Rate this:

Share:

Jim Randell 4:25 pm on 15 July 2022 Permalink | Reply

Frits 7:28 pm on 15 July 2022 Permalink | Reply

Jim Randell 8:59 am on 16 July 2022 Permalink | Reply

Frits 12:48 pm on 16 July 2022 Permalink | Reply

Frits 12:27 am on 17 July 2022 Permalink | Reply

Frits 6:09 pm on 21 July 2022 Permalink | Reply

Jim Randell 3:04 pm on 22 July 2022 Permalink | Reply

Jim Randell 9:01 am on 14 July 2022 Permalink | Reply Tags: by: Victor Bryant ( 147 )

Rate this:

Share:

Jim Randell 9:02 am on 14 July 2022 Permalink | Reply

Jim Randell 7:29 am on 12 July 2022 Permalink | Reply Tags: by: Victor Bryant ( 147 )

Rate this:

Share:

Jim Randell 7:30 am on 12 July 2022 Permalink | Reply

Jim Randell 8:02 am on 10 July 2022 Permalink | Reply Tags: by: J S Rowley ( 9 )

Rate this:

Share:

Jim Randell 8:03 am on 10 July 2022 Permalink | Reply

Frits 1:01 pm on 10 July 2022 Permalink | Reply

Jim Randell 1:11 pm on 10 July 2022 Permalink | Reply

Jim Randell 1:14 pm on 10 July 2022 Permalink | Reply

Frits 1:18 pm on 10 July 2022 Permalink | Reply

Jim Randell 1:26 pm on 10 July 2022 Permalink | Reply

Jim Randell 2:53 pm on 10 July 2022 Permalink | Reply

Frits 5:02 pm on 10 July 2022 Permalink | Reply

Jim Randell 4:50 pm on 8 July 2022 Permalink | Reply Tags: by: Susan Bricket ( 17 )

Rate this:

Jim Randell 9:10 am on 28 July 2022 Permalink | Reply
Tags: by: Michael Fletcher ( 18 )

Jim Randell 9:17 am on 26 July 2022 Permalink | Reply
Tags: by: Dr V W Bryant ( 5 )

Jim Randell 2:04 pm on 24 July 2022 Permalink | Reply
Tags: by: C Skeffington Quin ( 11 ), flawed ( 55 )

Jim Randell 4:03 pm on 22 July 2022 Permalink | Reply
Tags: by: Angela Newing ( 39 )

Jim Randell 9:07 am on 21 July 2022 Permalink | Reply
Tags: by: Victor Bryant ( 147 )

Jim Randell 6:31 am on 19 July 2022 Permalink | Reply
Tags: by: Nick MacKinnon ( 57 )

Jim Randell 12:33 pm on 17 July 2022 Permalink | Reply
Tags: by: Graham Smithers ( 84 )

Jim Randell 4:03 pm on 15 July 2022 Permalink | Reply
Tags: by: Howard Williams ( 45 )

Jim Randell 9:01 am on 14 July 2022 Permalink | Reply
Tags: by: Victor Bryant ( 147 )

Jim Randell 7:29 am on 12 July 2022 Permalink | Reply
Tags: by: Victor Bryant ( 147 )

Jim Randell 8:02 am on 10 July 2022 Permalink | Reply
Tags: by: J S Rowley ( 9 )

Jim Randell 4:50 pm on 8 July 2022 Permalink | Reply
Tags: by: Susan Bricket ( 17 )

Jim Randell 9:53 am on 7 July 2022 Permalink | Reply
Tags: by: Andrew Skidmore ( 88 )

Jim Randell 10:32 am on 5 July 2022 Permalink | Reply
Tags: by: Dr V W Bryant ( 5 )

Jim Randell 12:49 pm on 3 July 2022 Permalink | Reply
Tags: by: W. M. Greenway ( 5 )

Jim Randell 4:40 pm on 1 July 2022 Permalink | Reply
Tags: by: Victor Bryant ( 147 )

Jim Randell 9:59 am on 30 June 2022 Permalink | Reply
Tags: by: Michael Fletcher ( 18 )

Jim Randell 9:54 am on 28 June 2022 Permalink | Reply
Tags: by: M C Breach

Jim Randell 11:55 am on 26 June 2022 Permalink | Reply
Tags: by: W. M. Greenway ( 5 )

Jim Randell 3:55 pm on 24 June 2022 Permalink | Reply
Tags: by: Edmund Marshall ( 10 )