teaser | S2T2 | Page 60

Updates from August, 2019 Toggle Comment Threads | Keyboard Shortcuts

Jim Randell 8:13 pm on 9 August 2019 Permalink | Reply
Tags: by: Danny Roth ( 88 )
Teaser 2968: Gardening division
From The Sunday Times, 11th August 2019 [link] [link]

George and Martha’s garden is a perfect square of length (whole number of metres) a two-digit number AB. The area is a three-digit number CDE. In the middle, they have planted a square flowerbed of a length which is a single-digit number F and area a two-digit number GH.

They have called in a gardener, who works for a single-digit I hours. He works for a whole number of minutes on the flowerbed and the remainder on the surrounding lawn. Each square metre of the flowerbed requires N (a single digit) times the time spent on each square metre of the surrounding lawn. I have mentioned nine letters, A-I inclusive, and each stands for a different positive digit.

How many minutes does the gardener work on the lawn?

[teaser2968]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 8:29 pm on 9 August 2019 Permalink | Reply
  We can express the puzzle as a set of alphametic constraints and then use the general alphametic solver [[ SubstitutedExpression() ]] from the enigma.py library to find the solution.
  
  The following run file executes in 140ms.
```
#! python -m enigma -rr

SubstitutedExpression

--distinct="ABCDEFGHI"
--digits="1-9"

"AB**2 = CDE"
"F**2 = GH"

"div(CDE - GH + N * GH, I * 60)"

--answer="div((CDE - GH) * I * 60, CDE - GH + N * GH)"
```
  Solution: The gardener worked on the lawn for 99 minutes.
  
  The garden is a square of side 24m, giving a total area of 576m².
  
  The flowerbed has sides of 9m, so has an area of 81m², leaving an area of 495m² of lawn.
  
  The gardener works on the flowerbed for 81 minutes, at a rate of 1 minute per square metre of flowerbed. He then works on the lawn 5 times faster, at a rate of 1 minute per 5 square metres of lawn, so the 495m² of lawn takes 99 minutes. The total time is therefore 180 minutes, or 3 hours.
  
  LikeLike
Reply Cancel reply
Required fields are marked *

Name *

Email *

Website

Notify me of new comments via email.
Notify me of new posts via email.
Δ

Jim Randell 10:09 am on 9 August 2019 Permalink | Reply
Tags: by: Graham Smithers ( 84 )

Teaser 2888: Two sums

From The Sunday Times, 28th January 2018 [link] [link]

Digits have been systematically replaced by letters to give:

ONE + ONE = TWO
ONE + FOUR = FIVE

No number consists of a consecutive set of digits.

What number is represented by FIFTEEN?

[teaser2888]

Jim Randell 10:10 am on 9 August 2019 Permalink | Reply
We can easily use the [[ SubstitutedExpression() ]] solver from the enigma.py library to solve the alphametic sums, and we can use [[ --code ]] parameters to provide the additional check that none of the numbers consist of a set of consecutive digits. The numbers are all composed of different digits, so that makes things a bit simpler.

This run file executes in 139ms.

Run: [ @repl.it ]
```
#! python -m enigma -rr

SubstitutedExpression

--answer="FIFTEEN"

"ONE + ONE = TWO"
"ONE + FOUR = FIVE"

# check the words in each sum do not consist of consecutive digits
"check(ONE) and check(TWO)"
"check(FOUR) and check(FIVE)"

# function to check a sorted sequence of distinct numbers is increasing consecutive 
--code="is_consecutive = lambda s: s[-1] - s[0] == len(s) - 1"

# function to check a word does not consist of consecutive digits
--code="check = lambda w: not is_consecutive(sorted(nsplit(w)))"
```
Solution: FIFTEEN = 9594663.

We have:

ONE = 236, TWO = 472, FOUR = 9280, FIVE = 9516

There is one other solution to the alphametic sums that is eliminated because FOUR is composed from a set of (numerically) consecutive digits:

ONE = 286, TWO = 572, FOUR = 3210, FIVE = 3496

So we could just generate both solutions to the alphametic sums, and remove the non-viable solution by inspection.

LikeLike

GeoffR 3:05 pm on 11 August 2019 Permalink | Reply

% A Solution in MiniZinc
include "globals.mzn";
 
var 1..9: O; var 0..9: N; var 1..9: F; var 0..9: R;
var 0..9: E; var 1..9: T; var 0..9: W; var 0..9: I; 
var 0..9: V; var 0..9: U;   

constraint all_different([U, O, N, E, F, R, T, W, I, V]); 

% check ONE for non-consecutive digits
var set of int : s1 = {O,N,E};
constraint max ([O,N,E]) - min([O,N,E]) != card(s1) - 1;
var 100..999: ONE = 100*O + 10*N + E; 

% check TWO for non-consecutive digits
var set of int : s2 = {T,W,O};
constraint max ([T,W,O]) - min([T,W,O]) != card(s2) - 1;
var 100..999: TWO = 100*T + 10*W + O;

% check FOUR for non-consecutive digits
var set of int : s3 = {F,O,U,R};
constraint max ([F,O,U,R]) - min([F,O,U,R]) != card(s3) - 1;
var 1000..9999: FOUR = 1000*F + 100*O + 10*U + R;

% check FIVE for non-consecutive digits
var set of int : s4 = {F,I,V,E};
constraint max ([F,I,V,E]) - min([F,I,V,E]) != card(s4) - 1;
var 1000..9999: FIVE = 1000*F + 100*I + 10*V + E;

constraint ONE + ONE == TWO;
constraint ONE + FOUR == FIVE;

solve  satisfy;

output [ "ONE = " ++  show(ONE) ] ++ [ ", TWO = " ++  show(TWO) ]  
++ [ ", FOUR = " ++  show(FOUR) ] ++ [ ", FIVE = " ++  show(FIVE) ]
++ [ "\nFIFTEEEN = " ++ show(F),show(I),show(F),show(T),show(E),show(E),show(N)];   

% ONE = 236, TWO = 472, FOUR = 9280, FIVE = 9516
% FIFTEEEN = 9594663
% time elapsed: 0.02 s
% ----------
% ==========
% Finished in 231msec

LikeLike

Jim Randell 2:25 pm on 8 August 2019 Permalink | Reply
Tags: by: E R Emmet ( 3 )
Brain-Teaser 492: Light on the matches
From The Sunday Times, 1st November 1970 [link]

Six football sides, A, B, C, D, E and F are all to play each other once, with 2 points for a win, 1 point for a draw.

After some of the matches have been played a battered piece of paper is discovered on which has obviously been written particulars of the results so far.

All that can be read is shown below:

What were the details (opponents and scores) of E’s matches? (Example: EvP = 4-3, EvQ = 0-2, etc. E’s score first).

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

[teaser492]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
John Crabtree and Jim Randell are discussing. Toggle Comments
- Jim Randell 2:26 pm on 8 August 2019 Permalink | Reply
  F has 7 points and has played 5 games, but they only have 2 goals for, so cannot have won more than 2 games. Their 7 points must be made by 2w + 3d, which must be 1-0, 1-0, 0-0, 0-0, 0-0, so their goals against is 0. Hence the total number of goals scored is 25, and between them C and E have scored 17 goals.
  
  This Python program chooses values for C and E’s “goals for” values and then uses the [[ Football() ]] helper class from the enigma.py library to determine the outcomes and scorelines of each match.
  
  It runs in 550ms.
  
  Run: [ @repl.it ]
```
from enigma import Football, digit_map, irange, int2base, sprintf

# scoring system
football = Football(points=dict(w=2, d=1))

# labels for the teams
(A, B, C, D, E, F) = (0, 1, 2, 3, 4, 5)

# digits stand for themselves, and could go up to 17
M = 17
d = digit_map(0, M)

# columns of the table (without goals against)
(table, gf, ga) = (dict(played="24?3?5", w="1????2", l="??1??0", d='?????3', points="?373?7"), "41{C}1{E}2", "247570")

# find possible match outcomes from the table
for (ms, _) in football.substituted_table(table, teams=[F, A, B, C, D, E], d=d):

  # consider possible goals for C and E
  for (fC, fE) in zip(irange(0, M), irange(M, 0, step=-1)):
    gf1 = sprintf(gf, C=int2base(fC, M + 1), E=int2base(fE, M + 1))

    # find possible scorelines
    for ss in football.substituted_table_goals(gf1, ga, ms, d=d):

      # output solution
      football.output_matches(ms, ss, teams="ABCDEF")
```
  Solution: The outcomes of E’s matches are: E vs A = not yet played; E vs B = 0-1; E vs C = 3-5; E vs D = not yet played; E vs F = 0-1.
  
  There is only one scenario that works, which is when C has 14 goals for, and E has 3.
  
  The full scores are:
  
  A vs B = —
  A vs C = 4-1
  A vs D = —
  A vs E = —
  A vs F = 0-1
  B vs C = 0-3
  B vs D = 0-1
  B vs E = 1-0
  B vs F = 0-0
  C vs D = 5-0
  C vs E = 5-3
  C vs F = 0-0
  D vs E = —
  D vs F = 0-0
  E vs F = 0-1
  
  LikeLike
  - John Crabtree 6:24 pm on 8 August 2019 Permalink | Reply
    
    This teaser has a logical solution which leads directly to the answer, with no other paths.
    
    LikeLike
    - John Crabtree 2:36 pm on 13 August 2019 Permalink | Reply
      
      F has 7 points, but only scores 2 goals, and so F’s line reads 5 2 0 3 2 0 7
      C has 7 points, but loses a game, and so C’s line reads 5 3 1 1 ? 7 7
      As A plays 2 games, E must play 3 games, not 5.
      The total of the Played column = 22 = the total of the Points column.
      A has a minimum of 2 points and so the minimum Points total = 22
      And so A has 2 points and so A’s line reads 2 1 1 0 4 2 2
      And so E has 0 points and so B’s line reads 3 0 3 0 ? 7 0
      B can only draw one game not three, and so B’s line reads 4 1 2 1 1 4 3
      D can only draw one game,not three, and so D’s line reads 3 1 1 1 1 5 3
      
      By inspection A v F 0-1, B v F 0-0, C v F 0-0, D v F 0-0, E v F 0-1.
      Then A beats C. C beats B, D and E. B loses to D and beats E.
      From A’s GF and GA, A v C 4-1.
      From D”s GF = 1, , B v D 0-1
      From D’s GF and GA, C v D 5-0
      From B’s GF = 1, B v E 1-0
      From B’s GF and GA, C v B 3-0
      From C’s GA and E’s GA, C v E 5 -3
      
      And so E played 3 matches: E v B 0-1, E v C 3-5 and E v F 0-1
      
      LikeLike
Jim Randell 9:14 am on 7 August 2019 Permalink | Reply
Tags: by: Peter Good ( 29 ), flawed ( 55 )
Teaser 2894: Time duality
From The Sunday Times, 11th March 2018 [link] [link]

After a good breakfast, Seb decided on 40 winks. He noted the time on his digital clock as he dozed off. When he woke up a little later that day, not fully alert, he saw the display reflected in a mirror and was amazed by how long he seemed to have slept. This was in fact 10 times the length of his nap. Next day, a similar thing happened: he fell asleep at the same time and slept a little less, but when he woke, the mirror led him to believe he had slept for 20 times as long as he had. (All times were whole numbers of minutes after midnight).

At what time did he fall asleep?

[teaser2894]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 9:16 am on 7 August 2019 Permalink | Reply
  We can find multiple solutions to this puzzle, depending on how the clock works.
  
  The program examines the following three scenarios for a digital clock consisting of standard 7-segment digits, where the digits 0, 1 and 8 appear the same when mirrored, and the digits 2 and 5 appear as each other when mirrored.
  
  Scenario 1: 24 hour clock, always displays 4 digits, reads from 00:00 – 23:59.
  
  Scenario 2: 24 hour clock, leading zeros are suppressed on the hours, and no clear hour/minute separator, reads from 0:00 – 23:59.
  
  Scenario 3: 12 hour clock, leading zeros are suppressed on the hours, and no clear hour/minute separator, reads from 12:00 – 11:59.
  
  It runs in 125ms.
  
  Run: [ @replit ]
```
from enigma import (defaultdict, cproduct, arg, irange, nsplit, div, sprintf, printf)

# digit reflections
X = None
#           0  1  2  3  4  5  6  7  8  9
reflect = [ 0, 1, 5, X, X, 2, X, X, 8, X ] 

# format time t as hh:mm
def fmt(t, hours=24):
  k = 0
  while t < 0:
    k -= 1
    t += hours * 60
  while t > hours * 60:
    k += 1
    t -= hours * 60
  (h, m) = divmod(t, 60)
  return sprintf("{h:02d}:{m:02d} [{k:+d}]")

# solve using digits function <digits>
def solve(digits, hours=24):
  # record results by start time (in minutes), 10x or 20x
  rs = defaultdict(lambda: defaultdict(list))

  # map display digits to possible times
  m = defaultdict(list)
  for t in irange(0, 24 * 60 - 1):
    m[digits(t)].append(t)

  # find sequences that have a reverse sequence
  for (s, t1s) in m.items():
    r = tuple(reflect[d] for d in s[::-1])    
    if None in r or r == s: continue
    if r in m:
      t2s = m[r]

      for (t1, t2) in cproduct([t1s, t2s]):
        if t1 == t2: continue
        while t2 < t1: t2 += 24 * 60
        d = t2 - t1

        # find differences that give 9x or 19y
        x = div(d, 9)
        if x:
          t0 = t1 - x
          printf("[{t1} | {t2} = {d} min (9x {x}m), t0={t0}]", t1=fmt(t1, hours), t2=fmt(t2, hours), t0=fmt(t0, hours))
          rs[t0][10].append((t1, t2))
        y = div(d, 19)
        if y:
          t0 = t1 - y
          printf("[{t1} | {t2} = {d} min (19x {y}m), t0={t0}]", t1=fmt(t1, hours), t2=fmt(t2, hours), t0=fmt(t0, hours))
          rs[t0][20].append((t1, t2))

  # output solutions
  for (t0, d) in rs.items():
    for ((t1a, t2a), (t1b, t2b)) in cproduct([d[10], d[20]]):
      if t1b < t1a:
        (ft0, ft1a, ft2a, ft1b, ft2b) = (fmt(x, hours) for x in (t0, t1a, t2a, t1b, t2b))
        printf("10x = {ft0} - {ft1a} | {ft2a} / 20x = {ft0} - {ft1b} | {ft2b}")

# digits displayed for time t in the different scenarios:

# [1] four digits, 24 hours: 00:00 - 23:59
def digits1(t):
  (h, m) = divmod(t, 60)
  return nsplit(h % 24, 2) + nsplit(m, 2)

# [2] three or four digits, 24 hours: 0:00 - 23:59, no clear separator
def digits2(t):
  (h, m) = divmod(t, 60)
  return nsplit(h % 24) + nsplit(m, 2)

# [3] three or four digits, 12 hours: 0:00 - 11:59, no clear separator
def digits3(t):
  (h, m) = divmod(t, 60)
  return nsplit(h % 12 or 12) + nsplit(m, 2)


types = {
  '1': [ digits1, "[type 1] 00:00 - 23:59", 24 ],
  '2': [ digits2, "[type 2] 0:00 - 23:59", 24 ],
  '3': [ digits3, "[type 3] 12:00 - 11:59", 12 ],
}

cmd = arg("123", 0)

for k in sorted(types.keys()):
  if k not in cmd: continue
  (fn, t, h) = types[k]
  printf("{t}")
  solve(fn, hours=h)
  printf()
```
  We find the following solutions:
  
  Scenario 1: 24 hour clock, always displays 4 digits, reads from 00:00 – 23:59.
  
  This is probably the most reasonable expectation of the clock’s behaviour without further explanation.
  
  Day 1: The nap starts at 09:41 and finishes after 74m at 10:55. The mirrored display reads 22:01 corresponding to a nap of 740m (= 10×74m).
  Day 2: The nap starts at 09:41 and finishes after 34m at 10:15. The mirrored display reads 21:01 corresponding to a nap of 680m (= 20×34m).
  
  Day 1: The nap starts at 09:21 and finishes after 119m at 11:20. The mirrored display reads 05:11 corresponding to a nap of 1190m (= 10×119m).
  Day 2: The nap starts at 09:21 and finishes after 59m at 10:20. The mirrored display reads 05:01 corresponding to a nap of 1180m (= 20×59m).
  
  But in both these solutions the second nap is less than half the length of the first nap, so it is a bit odd to say he slept “a little less” than the previous day.
  
  Scenario 2: 24 hour clock, leading zeros are suppressed on the hours, and no clear hour/minute separator, reads from 0:00 – 23:59.
  
  The 09:41 nap works the same, but the 09:21 nap does not as 10:20 when mirrored does not correspond to a displayable time.
  
  Day 1: The nap starts at 09:41 and finishes after 74m at 10:55. The mirrored display reads 22:01 corresponding to a nap of 740m (= 10×74m).
  Day 2: The nap starts at 09:41 and finishes after 34m at 10:15. The mirrored display reads 21:01 corresponding to a nap of 680m (= 20×34m).
  
  This scenario has a unique solution, but the problem remains that the second nap is less than half the length of the first nap.
  
  Scenario 3: 12 hour clock, leading zeros are suppressed on the hours, and no clear hour/minute separator, reads from 12:00 – 11:59.
  
  Day 1: The nap starts at 07:18 and finishes after 64m at 08:22. The mirrored display reads “558” corresponding to 17:58 and a nap of 640m (= 10×64m).
  Day 2: The nap starts at 07:18 and finished after 57m at 08:15. The mirrored display reads “218” corresponding to 02:18 and a nap of 1140m (= 20×57m).
  
  And as it is a 12 hour clock this all works shifted on 12 hours, although perhaps 7:18pm is a little late to be having breakfast.
  
  The problem here is that on day two when seeing the clock reading 2:18 Seb would probably think he had slept for 7 hours, not for 19 hours. However this is the best solution for sleeping “a little less” on the second day, and the puzzle text does say Seb was not fully alert when he read the clock.
  
  Out of all these scenarios the one that best fits the puzzle text is Scenario 3:
  
  On the first day, Seb has an early breakfast, and starts his snooze at 7:18am, and wakes up at 8:22am, having slept for 64m, but reads the time as 5:58, and believes he has slept until 5:58pm, which is 640m.
  
  On the second day, Seb again starts his snooze at 7:18am, and wakes at 8:15am, having slept for 57m (which is only 7m shorter than the previous day). He reads the time as 2:18, and believes he has slept until 2:18am the following day, which is 1140m.
  
  This gives us a solution to the puzzle that Seb fell asleep on both days at 7:18am.
  
  It is possible that the phrase “all times were whole numbers of minutes after midnight”, is meant to indicate that all the times mentioned (including the false mirrored times) are all supposed to fall within the same 24 hour day, in which case the 9:41am solution in Scenario 1 or Scenario 2 remain, and give a unique solution of 9:41am. This may be the setters intended solution.
  
  But as there are multiple possible answers I have marked this puzzle as “flawed“.
  
  The published solution is: “09:41am”.
  
  LikeLiked by 1 person

Jim Randell 8:36 am on 6 August 2019 Permalink | Reply
Tags: by: Rex Gooch ( 3 )

Brainteaser 1635: Double anagram

From The Sunday Times, 9th January 1994 [link]

In the woodwork class the ABLEST students made STABLE TABLES.

In the arithmetic class the cleverest students took those three six-letter words which were anagrams of each other, and they then assigned a different digit to each of the six letters involved. Substituting letters for digits then gave them three six-figure numbers.

They found that one of the numbers was the sum of the other two. Furthermore, no matter what alternative substitution of digits they had used, they could never have achieved this coincidence with a lower sum.

(a) Which word was the sum?
(b) What was its numerical value?

This puzzle is included in the book Brainteasers (2002). The text was changed slightly, but the puzzle remains the same.

[teaser1635]

Jim Randell 8:37 am on 6 August 2019 Permalink | Reply

This program uses the [[ SubstitutedExpression() ]] solver from the enigma.py library to solve the alphametic problem, and an [[ Accumulator() ]] object to find the smallest solution. It runs in 299ms.

Run: [ @replit ]

from enigma import (SubstitutedExpression, Accumulator, sprintf as f, join, printf)

# the three words
words = ("ABLEST", "STABLE", "TABLES")

# the alphametic puzzle
ws = join(words, sep=",", enc="()")
p = SubstitutedExpression(f("sum({ws}) == 2 * max({ws})"), answer=ws)

# look for a minimal solution
r = Accumulator(fn=min)

# solve the alphametic
for ans in p.answers(verbose=0):
  # find the result of the sum
  s = max(ans)
  # and which word is the result
  i = ans.index(s)
  r.accumulate_data(s, i)

# output the minimal solution
printf("{word} = {r.value} [of {r.count} possible sums]", word=words[r.data])

Solution: TABLES = 417582.

The corresponding alphametic sum is: ABLEST + STABLE = TABLES.

There are 18 possible solutions to this alphametic.

LikeLike

GeoffR 1:29 pm on 6 August 2019 Permalink | Reply

I tried the three possible addition sums, looking for the smallest total. Two of these sums proved unsatisfiable. The third addition sum gave two possible values for TABLES, the smallest of which agreed with Jim’s solution.

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

var 1..9: A; var 0..9: B; var 0..9: L;
var 0..9: E; var 1..9: S; var 1..9: T;

constraint all_different([A, B, L, E, S, T]);

var 100000..999999: ABLEST = 100000*A + 10000*B + 1000*L + 100*E + 10*S + T;
var 100000..999999: STABLE = 100000*S + 10000*T + 1000*A + 100*B + 10*L + E;
var 100000..999999: TABLES = 100000*T + 10000*A + 1000*B + 100*L + 10*E + S;

%constraint ABLEST == STABLE + TABLES;
%solve minimize(ABLEST);
%output ["ABLEST = " ++ show(ABLEST) ];  % =====UNSATISFIABLE=====

%constraint STABLE == ABLEST + TABLES;
%solve minimize(STABLE);
%output ["STABLE = " ++ show(STABLE) ];  % =====UNSATISFIABLE=====

constraint TABLES == ABLEST + STABLE;
solve minimize(TABLES);
output ["TABLES = " ++ show(TABLES)  ++ " = " ++ show(ABLEST) ++ " + " ++ show(STABLE)];

% TABLES = 428571 = 285714 + 142857
% ----------
% TABLES = 417582 = 175824 + 241758  << smallest answer for value of TABLES
% ----------
% ==========

LikeLike

John Crabtree 6:21 pm on 8 August 2019 Permalink | Reply

With TABLES as the sum, ABLE = 999(T-S) – 100S – 10T. This enables the desired solution, as well as all of the possible 18 found by Jim, to be easily found.

LikeLike

Frits 2:36 pm on 27 July 2020 Permalink | Reply

Substituted expression which returns only one solution (minimized on first part of answer):

# The following function has been manually added to enigma.py
#
# def substituted_expression_minimum(*args, **kw):
#   if 'verbose' not in kw: kw['verbose'] = 0
#   answs = []
#   for r in SubstitutedExpression(*args, **kw).solve():
#     answs.append(r)
#   answs.sort(key=lambda x: x[1])  
#   if len(answs) > 0:
#       yield answs[0]


from enigma import substituted_expression_minimum, printf, irange

# the alphametic puzzle
p = substituted_expression_minimum(\
    [\
    # if one element in (X,Y,Z) is sum of 2 others then sum(X,Y,Z) = 2*max(X,Y,Z)
    # in this way we don't have to specify it is Z=X+Y, Y=X+Z or X=Y+Z 
    "TABLES + ABLEST + STABLE == 2 * max(TABLES, ABLEST, STABLE)",\
    "max(TABLES, ABLEST, STABLE) = HIGNUM",\
    "not(is_duplicate(TABLES))",\
    "not(is_duplicate(ABLEST))",\
    "not(is_duplicate(STABLE))"],\
    distinct="",   # needed for HIGNUM \   
    answer="HIGNUM, ABLEST, STABLE, TABLES",\
    verbose=0)      
                          
for (_, ans) in p: 
  if ans[1] == ans[0]: printf("ABLEST is the sum with value {ans[1]}")
  if ans[2] == ans[0]: printf("STABLE is the sum with value {ans[2]}")
  if ans[3] == ans[0]: printf("TABLES is the sum with value {ans[3]}")

LikeLike

Frits 3:12 pm on 27 July 2020 Permalink | Reply
@Jim:

Any idea why I needed the HIGNUM field?
```
p = substituted_expression_minimum(\
    [\
    "TABLES + ABLEST + STABLE == 2 * max(TABLES, ABLEST, STABLE)"],\
    answer="TABLES + ABLEST + STABLE, ABLEST, STABLE, TABLES",\
    verbose=0)   
```
Using this setup I got no results (even with distinct=””).

LikeLike
- Jim Randell 3:33 pm on 27 July 2020 Permalink | Reply
  @Frits: I think you get no answers because you are checking to see when one of the summands is equal to the sum total (which is never).
  
  Try using:
```
answer="(max(TABLES, ABLEST, STABLE), ABLEST, STABLE, TABLES)"
```
  BTW: You don’t need to modify the enigma.py library, you can just define the [[ substituted_expression_minimum ]] function in your own program.
  
  LikeLike

Frits 2:41 pm on 29 July 2020 Permalink | Reply

@Jim: Thanks for the internal accumulate function

from enigma import SubstitutedExpression, printf

# the alphametic puzzle
p = SubstitutedExpression(
  [
    # if one element in (X,Y,Z) is sum of 2 others then sum(X,Y,Z) = 2*max(X,Y,Z)
    # in this way we don't have to specify it is Z=X+Y, Y=X+Z or X=Y+Z 
    "TABLES + ABLEST + STABLE == 2 * max(TABLES, ABLEST, STABLE)",
    "not(is_duplicate(TABLES))",
    "not(is_duplicate(ABLEST))",
    "not(is_duplicate(STABLE))"
  ],
  answer="(TABLES + ABLEST + STABLE)/2, ABLEST, STABLE, TABLES",
  accumulate=min,
  verbose=0)      
    
# solve the puzzle
r = p.run()

# Print answer
lst = ["ABLEST", "STABLE", "TABLES"]
cnt = 0
for ans in r.accumulate:
    if cnt == 0: hghnum = ans
    else:  
      if ans == hghnum: printf("{lst[cnt-1]} is the sum with value {ans}")
    cnt += 1

LikeLike

Jim Randell 8:42 am on 5 August 2019 Permalink | Reply
Tags: by: Victor Bryant ( 144 )
Teaser 2893: Win some, lose some
From The Sunday Times, 4th March 2018 [link] [link]

The six teams in our local league play each other once in the season. Last season no two teams tied on points.

Above is part of the table from the end of that season, with the teams in alphabetical order.

However, digits have been consistently replaced by letters.

Find the value of the number of LEMONS.

[teaser2893]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 8:43 am on 5 August 2019 Permalink | Reply
  When I first looked at this puzzle I assumed the scoring regime was “2 points for a win, 1 point to each side for a draw” (which is a common scenario in Enigma puzzles [ link ]), but that gave me two possible solutions (the values for L and N are interchangeable). But using “3 points for a win, 1 point to each side for a draw” give a unique solution, and is probably what the setter had in mind. (This was later confirmed).
  
  I derived a set of constraints from the table and then used the general alphametic solver [[ SubstitutedExpression() ]] from the enigma.py library to solve the puzzle.
  
  The following run file executes in 73ms. (Internal runtime of the generated program is 94µs).
  
  Run: [ @replit ]
```
#! python3 -m enigma -rr

SubstitutedExpression

--answer="LEMONS"

# each team has played 5 matches
"W = 5"

# won + lost + drawn = 5
"O + N <= 5"
"S + O + M = 5"
"L + O <= 5"
"S <= 5"

# goals for >= won, goals against >= lost
"E >= S"
"S >= 5 - L - O"
"T >= L"
"O >= (E - S) // 3" "(E - S) % 3 = 0"

# points (= 3 * won + drawn) are all different
--code="pts = lambda w, d: 3 * w + d"
"all_different(pts(O, 5 - O - N), pts(S, M), pts(5 - L - O, O), E)"
```
  Solution: LEMONS = 370124.
  
  We could provide additional constraints in the run file (e.g. assign W=5; and L, M, N, O, S are 0, 1, 2, 3, 4 (in some order)) but it doesn’t make much difference to the run time if we do:
```
# [optional] w, l, d can only contain digits 0-5 (and W is 5)
--assign="W,5"
--invalid="6|7|8|9,LMNOS"
```
  If we change the definition of [[ pts() ]] to use the “2 points for a win …” scenario, and we find there is an additional solution of:
  
  LEMONS = 270134
  
  LikeLike

Jim Randell 9:10 am on 4 August 2019 Permalink | Reply
Tags: by: Angela Humphreys, corrected ( 10 )

Brain-Teaser 491: [Family names]

From The Sunday Times, 25th October 1970 [link]

Each of the five families in Admirals Walk comprised three boys; one of the boys in each family had the same christian name as the surname of one of his neighbours, and no boy had the same christian and surname.

The three christian names of Mr. Arnold’s three sons all had the same initial as the surname of Lawrence, who lived opposite to Benjamin Thomas.

Mr. Gordon’s oldest son had a christian name with the same initial as Clement’s surname. Clement’s father played chess with Jasper Lawrence’s father.

Mr. Oliver was Arnold’s father’s business partner. Godfrey had measles. Mr. Oliver’s oldest son had the same christian name as Crispin’s surname, and also the same initial to his christian name as Arnold’s surname. Arnold lived next door to the man whose son Oswald played truant from school with his cousin Hector Lawrence, until Oswald’s brother Walter, a school prefect, caught them.

Gilbert and Oscar had red hair.

Oliver was in Borstal. What was his surname?

When originally published the condition relating to Mr. Oliver’s sons was given as:

Mr. Oliver’s oldest son had the same christian name as Crispin’s surname, and Mr. Oliver’s youngest son had the same initial to his christian name as Arnold’s surname.

However a correction was published with Brain-Teaser 493 stating:

It is regretted that in para. 3, line 7, “youngest” should have read “eldest”. However, as the correct initials of these boys can be proved independently and most solvers gave the correct answer, this answer will stand.”

I have made the correction in the puzzle text above, although instead of just changing “youngest” to “eldest”, as we are already talking about Mr. Oliver’s oldest son, I used “and also”.

This puzzle was originally published with no title.

[teaser491]

Jim Randell 9:11 am on 4 August 2019 Permalink | Reply

There are 15 first names mentioned, so each boy must have a different first name.

This Python 3 program starts by filling out the full names we are given. Then it looks for three first names with the same initial for the Arnold family (which also gives us Lawrence’s surname). It then allocates the remaining names, and checks the remaining conditions.

It runs in 271ms.

Run: [ @repl.it ]

from collections import defaultdict
from enigma import subsets, update, diff, multiset, Accumulator, join, printf

# names we know (map: firstname -> lastname)
names = { "Benjamin": "Thomas", "Hector": "Lawrence", "Jasper": "Lawrence" }

# the surnames are all distinct by initial
lastnames = dict((x[0], x) for x in ("Arnold", "Gordon", "Lawrence", "Oliver", "Thomas"))

# the remaining first names
firstnames = ["Clement", "Crispin", "Gilbert", "Godfrey", "Oscar", "Oswald", "Walter" ]
firstnames.extend(lastnames.values())

# group firstnames by initial
initial = defaultdict(list)
for f in firstnames:
  initial[f[0]].append(f)

# complete the families, ensuring no-one has the same first/last name
def complete(ns, fs):
  # are we done?
  if not fs:
    yield ns
  else:
    # find an incomplete family to fill out
    s = multiset(ns.values())
    r = Accumulator(fn=min)
    for v in lastnames.values():
      n = 3 - s.get(v, 0)
      if n > 0: r.accumulate_data(n, v)
    (n, v) = (r.value, r.data)
    # choose names
    for ts in subsets(diff(fs, [v]), size=n):
      yield from complete(update(ns, ts, [v] * n), diff(fs, ts))

# collect results
r = multiset()

# the Arnold children share the same first initial
for (k, vs) in initial.items():
  if k == 'L': continue
  for fs in subsets(vs, size=3):
    if "Arnold" in fs: continue
    ns1 = update(names, fs, ["Arnold"] * 3)

    # Lawrence has one of these names as a surname
    ns1["Lawrence"] = lastnames[k]

    # complete the allocations
    for ns in complete(ns1, diff(firstnames, ns1.keys())):

      # "Clement's father played chess with Jasper Lawrence's father"
      # so Clement's surname is not Lawrence
      if ns["Clement"] == "Lawrence": continue

      # "Mr. Oliver was Arnold's father's business partner"
      # so Arnold's surname is not Oliver
      if ns["Arnold"] == "Oliver": continue

      # "Oswald played truant from school with his cousin Hector Lawrence"
      # so Oswald's surname is not Lawrence
      if ns["Oswald"] == "Lawrence": continue

      # "Arnold lived next door to ... Oswald"
      # so Arnold and Oswald have different surnames
      if ns["Arnold"] == ns["Oswald"]: continue

      # "... Oswald's brother Walter ..."
      # so Oswald and Walter have the same surname
      if ns["Oswald"] != ns["Walter"]: continue

      # "Mr. Oliver's oldest son had the same christian name as Crispin's surname ..."
      oliver_maj = ns["Crispin"]
      if ns[oliver_maj] != "Oliver": continue

      # "...and the same initial to his christian name as Arnold's surname"
      if oliver_maj[0] != ns["Arnold"][0]: continue

      # "Mr. Gordon's oldest son had a christian name with the same initial as Clement's surname"
      gordon_maj = list(k for (k, v) in ns.items() if v == "Gordon" and k[0] == ns["Clement"][0])
      if not gordon_maj: continue

      # each family has a child whose name is the surname of one of the other families
      ss = sorted(lastnames.values())
      fss = list()
      for v in ss:
        fss.append(set(x for (x, s) in ns.items() if s == v))
      if not all(fs.intersection(ss) for fs in fss): continue

      # output families
      fmt = lambda s: join(sorted(s), sep=", ")
      for (s, fs) in zip(ss, fss):
        printf("{s}: {fs}", fs=fmt(fs))
      printf("Oliver maj = {oliver_maj}; Gordon maj = {gordon_maj}", gordon_maj=fmt(gordon_maj))
      printf()

      # record the answer (Oliver's surname)
      r.add(ns["Oliver"])


# output the answer
for (s, n) in r.most_common():
  printf("Oliver {s} [{n} solutions]")

Solution: Oliver’s surname is Lawrence.

The families are:

Arnold: Gilbert, Godfrey, Gordon
Gordon: Lawrence, Oswald, Walter
Lawrence: Hector, Jasper, Oliver
Oliver: Clement, Oscar, Thomas
Thomas: Arnold, Benjamin, Crispin

Oswald Gordon and Oliver Thomas are the eldest sons in their respective families.

The originally published puzzle said that “Mr. Oliver’s youngest son had the same initial to his christian name as Arnold’s surname”, which cannot be satisfied with the rest of the conditions. The youngest of the Oliver children must be Clement or Oscar, and Arnold’s surname is Lawrence or Thomas.

With the change of the puzzle text to refer to the oldest son (who is Thomas Oliver), he shares the same initial (and indeed the same name) as Arnold, as Arnold and Crispin are brothers (both Thomases).

LikeLike

Jim Randell 5:47 pm on 2 August 2019 Permalink | Reply
Tags: by: Angela Newing ( 39 )

Teaser 2967: Odds and evens

From The Sunday Times, 4th August 2019 [link] [link]

I have done a “long multiplication”, which is reproduced above. [If the multiplication was ABC × DE, then the third line shows the result of ABC × E and the fourth line shows the result of ABC × D]. However instead of writing the actual digits involved, I have written “O” where there is an odd digit and “E” where there is an even digit.

What is the result of the multiplication?

[teaser2967]

Jim Randell 5:59 pm on 2 August 2019 Permalink | Reply

(See also: Enigma 1242, Enigma 1721, Enigma 109, Enigma 1503).

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

The following run file executes in 140ms.

#! python -m enigma -rr

#     A B C
#  *    D E
#   -------
#   J K L M (= ABC * E)
#   N P Q   (= ABC * D)
#   -------
#   F G H I
#   =======

SubstitutedExpression

--distinct=""
--invalid="1|3|5|7|9,BCDEHIJLMNQ" # even digits
--invalid="2|4|6|8,AFGKP" # odd digits
--invalid="0,ADFGJKNP" # odd digits + leading even digits

"ABC * DE = FGHI"

"ABC * E = JKLM"
"ABC * D = NPQ"

# prettify the output (disable with -O -A)
--answer="(ABC, DE)"
--output="SubstitutedExpression.output_mul"

Solution: The result of the multiplication sum is 9744.

The full sum is:

348 × 28 = 2784 + 696×10 = 9744

LikeLike

GeoffR 8:45 am on 5 August 2019 Permalink | Reply

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

var 0..9:A; var 0..9:B; var 1..9:C; 
var 0..9:D; var 0..9:E; 
var 0..9:F; var 0..9:G; var 0..9:H; var 0..9:I; 
var 0..9:J; var 0..9:K; var 0..9:L; var 0..9:M; 
var 0..9:N; var 0..9:P; var 0..9:Q;

constraint A > 0 /\ D > 0 /\ J > 0 /\ N > 0 
/\ K > 0/\ F > 0 /\ G > 0 /\ P > 0;

% Allocate parity to the digits
constraint A mod 2 == 1 /\ B mod 2 == 0 /\ C mod 2 == 0;
constraint D mod 2 == 0 /\ E mod 2 == 0;
constraint F mod 2 == 1 /\ G mod 2 == 1 /\ H mod 2 == 0
 /\ I mod 2 == 0;

constraint J mod 2 == 0 /\ K mod 2 == 1 /\ L mod 2 == 0
 /\ M mod 2 == 0;
constraint N mod 2 == 0 /\ P mod 2 == 1 /\ Q mod 2 == 0;

% Components of multiplication sum
var 100..999: ABC = 100*A + 10*B + C;
var 10..99: DE = 10*D + E;
var 1000..9999: JKLM = 1000*J + 100*K +10*L + M;
var 1000..9999: NPQ = 1000*N + 100*P + 10*Q;
var 1000..9999: FGHI = 1000*F + 100*G + 10*H + I;

constraint ABC * DE == FGHI;
constraint ABC * D * 10 == NPQ;
constraint ABC * E == JKLM;

solve satisfy;

output ["Multiplication sum is " ++ show(ABC) ++ " * " 
++ show(DE) ++ " = " ++ show(JKLM) ++ " + " ++ show(NPQ)
 ++ " = " ++ show(FGHI) ];

LikeLike

Jim Randell 10:28 am on 2 August 2019 Permalink | Reply
Tags: by: Graham Smithers ( 84 )
Teaser 2892: Political pairings
From The Sunday Times, 25th February 2018 [link] [link]

A debating society arranged for a series of eight political debates between different Labour and Conservative politicians, each time with a different presenter.

The presenters were:

MARR, NEIL, NEWMAN, PARKINSON, PAXMAN, POPPLEWELL, ROBINSON and SNOW.

The Labour politicians were:

ABBOTT, ABRAHAMS, CHAKRABARTI, CORBYN, EAGLE, LEWIS, STARMER and WATSON.

The Conservative politicians were:

BRADLEY, GRAYLING, GREEN, HAMMOND, LEADSOM, LIDINGTON, MCLOUGHLIN and MUNDELL.

For each debate there were 2 letters in common for any pairing from presenter, Labour politician and Conservative politician. The Labour politicians are listed alphabetically.

What is the corresponding order for the Conservative politicians?

[teaser2892]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 10:29 am on 2 August 2019 Permalink | Reply
  This puzzle can be solved using the [[ grouping ]] functionality in the enigma.py library (originally written to solve Teaser 2816, and a number of previous Teasers).
  
  This Python program runs in 87ms.
  
  Run: [ @repl.it ]
```
from enigma import grouping

# categories for this puzzle
presenters = ( 'MARR', 'NEIL', 'NEWMAN', 'PARKINSON', 'PAXMAN', 'POPPLEWELL', 'ROBINSON', 'SNOW' )
labs = ( 'ABBOTT', 'ABRAHAMS', 'CHAKRABARTI', 'CORBYN', 'EAGLE', 'LEWIS', 'STARMER', 'WATSON' )
cons = ( 'BRADLEY', 'GRAYLING', 'GREEN', 'HAMMOND', 'LEADSOM', 'LIDINGTON', 'MCLOUGHLIN', 'MUNDELL' )

# match the categories into groups such that each pair in each group shares exactly 2 letters
grouping.solve([presenters, labs, cons], grouping.share_letters(2))
```
  Solution: LEADSOM, GRAYLING, HAMMOND, LIDINGTON, GREEN, BRADLEY, MUNDELL, MCLOUGHLIN.
  
  The groupings are:
  
  MARR, CHAKRABARTI, HAMMOND
  NEIL, EAGLE, GREEN
  NEWMAN, ABRAHAMS, GRAYLING
  PARKINSON, LEWIS, BRADLEY
  PAXMAN, STARMER, MUNDELL
  POPPLEWELL, WATSON, MCLOUGHLIN
  ROBINSON, ABBOTT, LEADSOM
  SNOW, CORBYN, LIDINGTON
  
  LikeLike
Jim Randell 8:36 am on 31 July 2019 Permalink | Reply
Tags: by: Graham Smithers ( 84 )
Teaser 2895: Spanish and Latin
From The Sunday Times, 18th March 2018 [link] [link]

I have ten cards. For each card there is a number in Spanish on one side and a number in Latin on the other.

The Spanish numbers are CINCO, CUATRO, DIEZ, DOS, NUEVE, OCHO, SEIS, SIETE, TRES and UNO. The Latin numbers are DECEM, DUO, NOVEM, OCTO, QUATTUOR, QUINQUE, SEPTEM, SEX, TRES and UNUS. For each of the ten pairs of numbers, there are two letters in common. If I told you on how many cards the two numbers were consecutive, you should be able to work out all ten pairings. The Spanish numbers are written alphabetically.

What is the corresponding order for the Latin numbers?

[teaser2895]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 8:37 am on 31 July 2019 Permalink | Reply
  This Python program make use of a couple of the routines from the enigma.py library to solve this puzzle in a few lines of code. It runs in 80ms.
  
  Run: [ @repl.it ]
```
from enigma import (grouping, filter_unique, unpack)

# the words and corresponding numbers
spanish = dict(CINCO=5, CUATRO=4, DIEZ=10, DOS=2, NUEVE=9, OCHO=8, SEIS=6, SIETE=7, TRES=3, UNO=1)
latin = dict(DECEM=10, DUO=2, NOVEM=9, OCTO=8, QUATTUOR=4, QUINQUE=5, SEPTEM=7, SEX=6, TRES=3, UNUS=1)

# find solutions unique by the number of pairs with consecutive values
(ss, _) = filter_unique(
  # find all solution groups
  grouping.groups([list(spanish.keys()), list(latin.keys())], grouping.share_letters(2)),
  # count pairs with numerically consecutive values
  lambda s: sum(abs(spanish[es] - latin[la]) == 1 for (es, la) in s),
  tuple
)

# output solutions
for s in ss:
  # sort the solution by the spanish numbers alphabetically
  grouping.output_groups(sorted(s, key=unpack(lambda es, la: es)))
```
  Solution: The corresponding Latin numbers are: NOVEM, TRES, DECEM, DUO, UNUS, OCTO, SEPTEM, QUINQUE, SEX, QUATTUOR.
  
  So the pairs are:
  
  CINCO, NOVEM (NO)
  CUATRO, TRES (RT) [consecutive]
  DIEZ, DECEM (DE)
  DOS, DUO (DO)
  NUEVE, UNUS (NU)
  OCHO, OCTO (CO)
  SEIS, SEPTEM (ES) [consecutive]
  SIETE, QUINQUE (EI)
  TRES, SEX (ES)
  UNO, QUATTUOR (OU)
  
  There are also two sets of cards that have 4 cards with consecutive numbers:
  
  CINCO, NOVEM (NO)
  CUATRO, TRES (RT) [consecutive]
  DIEZ, DECEM (DE)
  DOS, DUO (DO)
  NUEVE, UNUS (NU)
  OCHO, OCTO (CO)
  SEIS, SEPTEM (ES) [consecutive]
  SIETE, SEX (ES) [consecutive]
  TRES, QUATTUOR (RT) [consecutive]
  UNO, QUINQUE (NU)
  
  CINCO, QUINQUE (IN)
  CUATRO, TRES (RT) [consecutive]
  DIEZ, DECEM (DE)
  DOS, DUO (DO)
  NUEVE, UNUS (NU)
  OCHO, OCTO (CO)
  SEIS, SEPTEM (ES) [consecutive]
  SIETE, SEX (ES) [consecutive]
  TRES, QUATTUOR (RT) [consecutive]
  UNO, NOVEM (NO)
  
  And these are the only sets of cards that can be made.
  
  LikeLike
Jim Randell 11:58 am on 30 July 2019 Permalink | Reply
Tags: by: G H Dickson ( 13 )
Brain-Teaser 490: Equal marks
From The Sunday Times, 18th October 1970 [link]

Tom, Dick and Harry took a test in each of five subjects. Each test was marked out of a total of 40. In grand total each boy obtained half-marks, and no boy scored the same mark in two or more tests.

Each boy’s best and third-best marking totalled one-fifth more than the total of his best and fourth-best, and each boy’s worst mark exceeded 10.

The aggregate of the three boys’ marks in each of four subjects was the same, the highest single mark going to Tom. The second-highest was scored by Dick in the remaining subject.

How many marks did Harry get in that subject?

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

[teaser490]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 11:58 am on 30 July 2019 Permalink | Reply
  This Python program runs in 410ms.
  
  Run: [ @repl.it ]
```
from enigma import (irange, subsets, multiset, cproduct, printf)

# find sets of 5 scores that sum to 100
ss = list()
for s in subsets(irange(11, 40), size=5, select='C'):
  # total score is 100
  if not (sum(s) == 100): continue
  # (best + 3rd best) = (6/5)(best + 4th best)
  if not (5 * (s[-1] + s[-3]) == 6 * (s[-1] + s[-4])): continue
  ss.append(s)

# choose scores for the 3 students
for (s1, x2, x3) in subsets(ss, size=3, select='C'):
  # choose orders for s2 and s3
  permute = lambda x: subsets(x, size=len, select='P')
  for (s2, s3) in cproduct([permute(x2), permute(x3)]):
    scores = (s1, s2, s3)
    # accumulate the total scores in each test
    ts = list(sum(s) for s in zip(*scores))
    m = multiset(ts)
    if not (sorted(m.values()) == [1, 4]): continue
    # find the highest and second highest marks
    ms = sorted(s1 + s2 + s3)
    (m1, m2, m3) = (ms[-1], ms[-2], ms[-3])
    if not (m1 > m2 > m3): continue

    # determine which is Tom, Dick
    T = D = H = -1
    for (i, s) in enumerate(scores):
      if m1 in s: T = i
      if m2 in s: D = i
    # Harry is the other one
    H = 3 - (T + D)
    if not (sorted([T, D, H]) == [0, 1, 2]): continue
    # check the 2nd highest score is in the test with the unique total
    d = scores[D].index(m2)
    if not (m[ts[d]] == 1): continue

    # output solution
    printf("T = {T}", T=scores[T])
    printf("D = {D}", D=scores[D])
    printf("H = {H}", H=scores[H])
    printf("+ = {ts}")
    printf("answer = {x}", x=scores[H][d])
    printf()
```
  Solution: 15 marks.
  
  The scores in each test are shown below:
  
  The highest single mark is highlighted red. The second highest mark is orange. And the answer (Harry’s mark in the same subject as the second highest mark) is yellow.
  
  There is a “near miss” scenario, where the scores are as follows:
  
  T = (11, 12, 21, 23, 33)
  D = (25, 26, 22, 14, 13)
  H = (25, 23, 13, 24, 15)
  
  The sum of the scores for each test are 61, apart from the third one where they are 56.
  
  Tom has the highest score (33) and Dick has the second highest (26), but the score of 26 is not in the subject with a sum of 56.
  
  The scores are a rearrangement of the scores in the actual solution because there are only three possible sequences of 5 scores between 11 and 40 that sum to 100 and have best and third best scores summing to one fifth more than the sum of the best and fourth best scores.
  
  LikeLike
Jim Randell 12:40 pm on 28 July 2019 Permalink | Reply
Tags: by: Pete Bradley ( 7 )
Brainteaser 1633: New Year’s resolution
From The Sunday Times, 26th December 1993 [link]

My New Year’s resolution is that this year I will remember my father’s birthday. To remind me I devised this formula: if I take the factorial of the number on the calendar representing the month in which he was born (1 for January to 12 for December) and multiply this by the square of the day of the month of his birth (1 to 31), the four digit result is the year when he was born.

[Note, for example, that “6 factorial” is 6×5×4×3×2×1 = 720.]

I then realised that this is no use for determining his birthday as even my own date of birth fits the formula.

Can you tell me what is my father’s date of birth?

This puzzle is included in the book Brainteasers (2002) under the title of “Birthday resolution”. The text was changed slightly, but the puzzle remains the same.

[teaser1633]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 12:41 pm on 28 July 2019 Permalink | Reply
  This Python program finds day/month/year combinations that satisfy the formula, where the year is in the range [1850, 1993].
  
  It runs in 84ms.
  
  Run: [ @repl.it ]
```
from enigma import irange, factorial, printf

# number of possible days in each month
days = (31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)

# consider day, month, formula values
for (m, dm) in enumerate(days, start=1):
  f = factorial(m)
  for d in irange(1, dm):
    y = f * d * d
    if y < 1850: continue
    if y > 1993: break
    printf("d={d} m={m} -> y={y}")
```
  Solution: The father’s birthdate is 4th May 1920.
  
  There are 3 day/month combinations that give a reasonable value for the year.
  
  These are:
  
  day=18, month=3 → year=1944
  day=9, month=4 → year=1944
  day=4, month=5 → year=1920
  
  So the setters birthdate must be one of the 1944 dates (18th March 1944, 9th April 1944) and his fathers birthdate must be 4th May 1920.
  
  But it seems to me that the setter would probably be able to remember that his father was not born in 1944, so he can use the formula to determine his fathers birthday.
  
  The setter is obviously not a fan of Star Wars, otherwise he would find it easy to remember his father’s birthday.
  
  LikeLike
Jim Randell 6:52 pm on 26 July 2019 Permalink | Reply
Tags: by: Howard Williams ( 44 )
Teaser 2966: On track
From The Sunday Times, 28th July 2019 [link] [link]

Sarah and Jenny are runners who train together on a circular track, and Sarah can run up to 20 per cent faster than Jenny. They both run at a constant speed, with Sarah running an exact percentage faster than Jenny. To reduce competition they start at the same point, but run round the track in different directions, with Sarah running clockwise.

On one day they passed each other for the seventh time at a point which is an exact number of degrees clockwise from the start. Sarah immediately changed her pace, again an exact percentage faster then Jenny. After a few [additional] passes both runners reached the exit, at a point on the track an exact number of degrees clockwise from the start, at the same time.

How fast, relative to Jenny, did Sarah run the final section?

[teaser2966]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell, Robert Brown, and John Crabtree are discussing. Toggle Comments
- Jim Randell 8:20 pm on 26 July 2019 Permalink | Reply
  If S is going p percent faster than J, she is going at rate of (1 + p/100) times as fast as J.
  
  If they meet after J has travelled through d degrees of the circle, then S has travelled through d(1 + p/100) degrees of the circle, and together these must make up the full circle. So:
  
  d + d(1 + p/100) = 360
  d = 36000 / (200 + p)
  
  And if they meet at an exact number of degrees after k passings:
  
  kd = 36000k / (200 + p)
  
  must be an integer.
  
  This Python program finds possible percentage increases for S where she meets J at an exact number of degrees for up to 7 passings. It runs in 81ms.
  
  Run: [ @repl.it ]
```
from enigma import (irange, cproduct, printf)

# suppose they meet after k passings and S runs p percent faster than J
for (k, p) in cproduct([irange(1, 7), irange(1, 20)]):
  # do they meet at an exact number of degrees?
  if (36000 * k) % (200 + p) == 0:
    printf("k={k} p=+{p}% [{s}]", s=('initial' if k == 7 else 'final'))
```
  Solution: Sarah ran the final section 16% faster than Jenny.
  
  For the first section Sarah was running 10% faster than Jenny.
  
  And the final section lasted for some multiple of 3 crossings. Probably 3 or 6, as there are only “a few” additional passes, but we don’t need to know that to get the answer to the puzzle.
  
  Further solutions appear if we allow higher values of k. For example, at k = 11 we get a solution where S is 20% faster than J, but from the wording of the puzzle it seems likely that the number of passings in the final section is fewer than 7, so we get a unique answer.
  
  LikeLike
- John Crabtree 2:19 am on 27 July 2019 Permalink | Reply
  
  You could calculate the minimum k for any p. In Excel format:
  k = +(200 + p) / GCD(36000, 200 + p)
  Then if k < 8, print k and p
  
  I am not a Python programmer, but understand that Python does have a gcd function.
  
  LikeLike
  - Jim Randell 8:07 am on 27 July 2019 Permalink | Reply
    @John: Python does indeed have [[ gcd() ]].
    
    We can generate the list of first k for each p, and then output them in k order:
```
from enigma import (irange, gcd, div, printf)

# find first k for each p
kps = ((div(200 + p, gcd(36000, 200 + p)), p) for p in irange(1, 20))

# output (k, p) pairs, ordered by k
for (k, p) in sorted(kps):
  printf("k={k} p=+{p}%")
```
    LikeLike
  - Jim Randell 2:19 pm on 1 August 2019 Permalink | Reply
    Here’s a program that uses a similar approach to generate the solutions in a given range (in this case p = 1..20, k = 1..7, like my first program):
```
from enigma import (irange, fraction, printf)

# consider values for p
for p in irange(1, 20):
  (a, b) = fraction(36000, 200 + p)
  # consider values for k
  for k in irange(b, 7, step=b):
    printf("k={k} p=+{p}% [{s}]", s=('initial' if k == 7 else 'final'))
```
    LikeLike
- Robert Brown 11:35 am on 1 August 2019 Permalink | Reply
  
  For each p value, you found equivalent k value. I reversed this, leading to an easy manual solution.
  At k passings, J has travelled 180k+x and S has travelled 180k–x giving J/S = (180k+x)/(180k–x).
  (x = integer, k is prime to avoid duplication). This gives the following rapid 3 line solution:
  
  k = 7 J/S = 1260+x / 1260-x By inspection, x = 60 giving J/S = 1.10
  k = 2 J/S = 360+x / 360-x By inspection, x = 60 giving J/S = 1.40 (too large)
  k = 3 J/S = 540+x / 540-x By inspection, x = 40 giving J/S = 1.16 (the answer)
  
  LikeLike
Jim Randell 11:30 am on 26 July 2019 Permalink | Reply
Tags: by: Graham Smithers ( 84 )
Teaser 2816: Chat shows
From The Sunday Times, 11th September 2016 [link] [link]

Each day next week there will be a chat show on television and in each show the host will appear with an actress and an actor.

The hosts will be (in order) Dimbleby, Evans, Mack, Marr, Norton, Peschardt and Ross. In no particular order, the actresses will be Arterton, Blunt, Carter, Jones, Knightley, Margolyes and Watson. Again in no particular order, the actors will be Bean, Caine, Cleese, Craig, De Niro, Neeson and Oldman.

For any two people in the same show there are just two different letters of the alphabet that occur (perhaps more than once) in both their surnames.

List the actresses in the order in which they appear.

[teaser2816]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 11:30 am on 26 July 2019 Permalink | Reply
  This kind of grouping problem is a favourite of Graham Smithers. By the time this puzzle was published in September 2016 I had already solved several of this type of problem, writing a custom Python program for each one.
  
  So for this puzzle I wrote some generic code that could be used to solve this puzzle and the other similar puzzles I had encountered.
  
  The code is available in the enigma.py library by importing the [[ grouping ]] namespace.
  
  This Python program runs in 42ms.
```
from enigma import grouping

# categories for this puzzle
hosts = ["Dimbleby", "Evans", "Mack", "Marr", "Norton", "Peschardt", "Ross"]
actresses = ["Arterton", "Blunt", "Carter", "Jones", "Knightley", "Margolyes", "Watson"]
actors = ["Bean", "Caine", "Cleese", "Craig", "De Niro", "Neeson", "Oldman"]

# match the categories into groups such that each pair in each group shares exactly two letters
grouping.solve([hosts, actresses, actors], grouping.share_letters(2))
```
  Solution: The order of the actresses is: Blunt, Carter, Margolyes, Arterton, Knightley, Jones, Watson.
  
  The full solution is:
  
  Dimbleby, Blunt, Bean
  Evans, Carter, Cleese
  Mack, Margolyes, Caine
  Marr, Arterton, Craig
  Norton, Knightley, Neeson
  Peschardt, Jones, Oldman
  Ross, Watson, De Niro
  
  LikeLike
Jim Randell 12:15 pm on 25 July 2019 Permalink | Reply
Tags: by: W A Thatcher ( 13 )
Brain-Teaser 489: [Railway journeys]
From The Sunday Times, 11th October 1970 [link]

The All-Go railway runs from Alby to Goby over 20 miles away. Let us say it goes from A to G, and on the way you stop at B, C, D, E and F in that order.

All the distances between stops are different from one another and all are less than 8 miles, yet it is possible to make journeys of 1 mile, 2 miles, 3 miles and so on up to 18 miles by picking the right stations.

The distance from A to B is less than the distance from F to G.

How many miles from A are B, C, D, E, F and G?

This puzzle was originally published with no title.

[teaser489]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 12:15 pm on 25 July 2019 Permalink | Reply
  (See also: Teaser 1986).
  
  This Python program runs in 220ms.
  
  Run: [ @replit ]
```
from enigma import (subsets, irange, tuples, csum, join, sprintf as f, printf)

# required distances
rs = set(irange(1, 18))

# choose the lengths of the 6 segments, AB BC CD DE EF FG
for ss in subsets(irange(1, 7), size=6, select='P'):
  (AB, BC, CD, DE, EF, FG) = ss
  if not (AB < FG): continue

  # collect together adjacent segments from 1 to 6
  ds = set(sum(t) for k in irange(1, 6) for t in tuples(ss, k))
  if not rs.issubset(ds): continue

  printf("{cs} [ss={ss}]", cs=join((f("A{x}={d}") for (x, d) in zip("BCDEFG", csum(ss))), sep=" "))
```
  Solution: The distances (in miles) are: A→B=2, A→C=7, A→D=14, A→E=15, A→F=18, A→G=24.
  
  The distances between stations are:
  
  [A] 2 [B] 5 [C] 7 [D] 1 [E] 3 [F] 6 [G]
  
  So as well as being able to make all the distances from 1 to 18, we can also make distances of 22 (B to G) and 24 (A to G).
  
  LikeLike
Jim Randell 5:20 pm on 24 July 2019 Permalink | Reply
Tags: by: Stephen Hogg ( 64 )
Teaser 2896: Light angles
From The Sunday Times, 25th March 2018 [link] [link]

The hotel’s night clerk was always glancing at the novelty 12-hour clock facing her. Its hands’ rotation axis was exactly midway across and between three-quarters and four-fifths of the way up the four-metre high rectangular wall. Light rays directed out along the continuous-motion minute and hour hands made pencil beams across the wall. Twice during her 12-hour shift she saw the beams hit the top corners of the wall simultaneously, and twice she saw the beams hit the bottom corners simultaneously.

How wide was the wall to the nearest metre?

[teaser2896]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 5:21 pm on 24 July 2019 Permalink | Reply
  I thought this was a neat puzzle, but there are only a few values to consider.
  
  For any given hour, there will be a (fractional) minute when the hour “hand” and the minute “hand” are the at the same angle from vertical, but on opposite sides, and so mirror each other about the vertical axis.
  
  If we consider the times between 12 o’clock and 6 o’clock, at some time before 3 o’clock the two “hands” will illuminate the top corners of the wall, and as sometime after 3 o’clock the two “hands” will illuminate the bottom corners of the wall. By choosing values for the “top” hours and “bottom” hours, we can determine the corresponding minutes, angles of the “hands” and hence the height of the origin of the hands up the wall. If it’s between 3.0m and 3.2m we have a solution.
  
  This Python program runs in 68ms.
  
  Run: [ @repl.it ]
```
from math import tan
from itertools import product
from enigma import (irange, fdiv, two_pi, printf)

# given an hour, compute the corresponding minute and tangent
def hmt(h):
  m = fdiv((12 - h) * 60, 13) # minute
  a = fdiv(h, 12) + fdiv(m, 720) # angle (fraction of a circle)
  t = tan(two_pi * a) # tangent of a
  return (h, m, t)

# consider the times when the hour and minute beams mirror each other
# about the vertical axis

# calculate (h, m, t) for hours from 0 to 5
hmts = list(hmt(h) for h in irange(0, 5))

# the hour for the top right corner is before 3
# the hour for the bottom right corner is after 3
for ((h1, m1, t1), (h2, m2, t2)) in product(hmts[:3], hmts[3:]):
  # calculate the height of the hands above the floor
  y = fdiv(4 * t1, t1 - t2)
  # check it is in range
  if 3.0 <= y <= 3.2:
    # calculate the width of the wall
    x = y * -t2
    w = 2 * x
    # output solution
    printf("width={w:.03f}, x={x:.03f} y={y:.03f} [TR @ {h1}:{m1:05.2f}, BR @ {h2}:{m2:05.2f}]")
```
  Solution: The wall is approximately 16 metres wide.
  
  The actual width of the wall (to the nearest millimetre) is 15.979m.
  
  The height of the origin of the hands is 3.030m.
  
  Here is a diagram that shows the wall, ruled with lines at heights of 1m, 2m, 3m and 3.2m.
  
  The upper lines would be illuminated at 2:46 and 9:14.
  
  The lower lines would be illuminated at 3:42 and 8:18.
  
  So it is possible to observe the situation between 2:46 and 9:14, which is only 6 hours 28 minutes.
  
  LikeLike
  - Jim Randell 9:29 am on 25 July 2019 Permalink | Reply
    
    Here’s a chart with the choices for the times (upward times across the top, downward times along the side), and the calculated width of the wall and height of the hands.
    
    We find the solution (highlighted) when h is between 3.0m and 3.2m.
    
    LikeLike
Jim Randell 9:18 am on 23 July 2019 Permalink | Reply
Tags: by: Oliver D Anderson ( 2 )
Brainteaser 1631: Ali Baba’s boxes
From The Sunday Times, 12th December 1993 [link]

The royal jewellers Fabulé make standard-sized golden cubic boxes which are diamond-encrusted on the outside. They make these from large sheets of gold which have been encrusted with diamonds on one side and they then cut out the required shapes to make the boxes.

For example, the 3-by-4 cruciform shown on the left below provides a shape which folds up into a cubic box, but the strip on the right does not.

Recently thieves broke into the Fabulé workshops and stole various cut-out pieces of the diamond-encrusted sheeting. They did not realise that in fact they had taken the mis-cuts: all the pieces that consisted of six squares but none would actually fold into a box. And their haul consisted of one piece of each possible faulty shape.

How many pieces did they steal?

This puzzle is included in the book Brainteasers (2002). The text was changed slightly, but the substance of the puzzle remains the same.

[teaser1631]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 9:20 am on 23 July 2019 Permalink | Reply
  It seems like a bit of a wasteful manufacturing process, but it does mean that the shapes cannot be turned over. (Although card with different coloured sides would have sufficed).
  
  I enjoyed programming a constructive solution for this puzzle.
  
  This Python program generates possible shapes that consist of 6 connected squares, and determines how many different shapes there are when translation and rotation are allowed (but not reflection). It then takes those shapes and attempts to wrap each one around a cube to find out which of them represent the net of a cube.
  
  It runs in 982ms
  
  Run: [ @repl.it ]
```
from enigma import Accumulator, ordered, uniq, update, first, join, printf

# slide shape against x=0, y=0 axes
def slide(shape):
  min_x = min(x for (x, y) in shape)
  min_y = min(y for (x, y) in shape)
  return tuple((x - min_x, y - min_y) for (x, y) in shape)

# rotate shape through 90 degrees
def rotate(shape):
  return tuple((y, -(x + 1)) for (x, y) in shape)

# find a canonical representation of a shape
def canonical(shape):
  r = Accumulator(fn=min)
  for i in (0, 1, 2, 3):
    # slide shape against the axes
    shape = slide(shape)
    r.accumulate(ordered(*shape))
    # rotate shape
    if i < 3: shape = rotate(shape)
  # return the minimim value
  return r.value

# find squares adjacent to p
def adj(p):
  (x, y) = p
  return ((x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1))

# generate shapes with k additional squares
def generate(k, shape):
  if k == 0:
    yield shape
  else:
    # choose a square to extend
    for p in shape:
      for q in adj(p):
        if q not in shape:
          yield from generate(k - 1, shape + [q])

# roll a cube to the ajacent squares
def roll(p, fs):
  ((x, y), (U, D, F, B, L, R)) = (p, fs)
  return (
     ((x - 1, y), (R, L, F, B, U, D)), # L
     ((x + 1, y), (L, R, F, B, D, U)), # R
     ((x, y - 1), (B, F, U, D, L, R)), # F
     ((x, y + 1), (F, B, D, U, L, R)), # B
  )

# wrap a cube with shape
# shape = the shape we are trying to wrap
# ss = remaining unwrapped squares
# m = map from square -> face
# cube = current cube orientation (U, D, F, B, L, R)
def wrap(shape, m):
  # are we done?
  n = len(shape)
  if len(m.keys()) == n:
    d = dict((k, v[1]) for (k, v) in m.items())
    if len(set(d.values())) == n:
      yield d
  else:
    # roll the cube
    for (p, fs) in m.items():
      for (q, gs) in roll(p, fs):
        if q in shape and q not in m:
          yield from wrap(shape, update(m, [(q, gs)]))

# find the number of shapes made from 6 squares
(t, n) = (0, 0)
for s in uniq(canonical(s) for s in generate(5, [(0, 0)])):
  t += 1
  # can we form the shape into a cube?
  r = first(wrap(s, { s[0]: "UDFBLR" }))
  if r:
    n += 1
    printf("[{t}: {s} -> {r}]", r=join(r[0][p] for p in s))
  else:
    printf("[{t}: {s}]")

printf("{n} of {t} shapes form cubes")
```
  Solution: There are 40 shapes that cannot be folded into a cube.
  
  We can make 60 different shapes out of 6 joined squares (where reflection is not allowed). (See OEIS A000988 [ @oeis ]).
  
  And there are 11 shapes that can be folded to make a cube (if reflection is allowed):
  
  The two of these on the left are achiral (i.e. their mirror image can be formed by rotating the piece), leaving 9 that are chiral (i.e. the mirror image cannot be formed by rotation of the piece). So we need to make mirror images of the 9 chiral shapes to give 20 shapes altogether that can be folded into a cube (where reflection is not allowed).
  
  The remaining 40 shapes cannot be folded into a cube.
  
  See: [ @wikipedia ], which tells us there are 60 one-sided hexonimoes and gives the 11 nets of the cube. Which is enough information to determine the answer.
  
  The program is constructive so can easily be augmented to plot the 60 shapes, and colour in those which can be folded into cubes. I used my simple plotting library [ @github ].
  
  Run: [ @repl.it ]
  
  The output looks like this:
  
  The colours show how the shape can be folded to give the colouring of a standard Rubik’s Cube.
  
  LikeLike
Jim Randell 8:51 am on 22 July 2019 Permalink | Reply
Tags: by: Andrew Skidmore ( 87 )
Teaser 2897: Easter egg
From The Sunday Times, 1st April 2018 [link] [link]

“Granddad, I’ve got a great big Easter egg in a square box!” My grandson Liam inspired this Teaser in which I have used non-zero digits then consistently replaced them with letters, using different letters for different digits.

In this way, I have:

EASTER
(EGG)²
BOX

Two of the numbers add to make the third, and if I told you which number was largest you should be able to solve this Teaser.

Find the value of BOX.

[teaser2897]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
GeoffR and Jim Randell are discussing. Toggle Comments
- Jim Randell 8:52 am on 22 July 2019 Permalink | Reply
  EASTER has 6 digits, (EGG)² has 5 or 6 digits, but whichever is larger BOX is the difference between them.
  
  The alphametic expression:
  
  abs(EASTER − (EGG)²) = BOX
  
  only has one solution (when we don’t use the digit 0):
```
% python -m enigma SubstitutedExpression --digits="1-9" "abs(EASTER - sq(EGG)) = BOX"
(abs(EASTER - sq(EGG)) = BOX)
(abs(954891 - sq(977)) = 362) / A=5 B=3 E=9 G=7 O=6 R=1 S=4 T=8 X=2
[1 solution]
```
  So this gives us our solution (BOX=362), even without needing to know which of EASTER or (EGG)² is larger. (In fact EASTER > (EGG)²).
  
  But here is a full solution, that solves the two possible sums as alphametic problems, and looks for situations where there is a single solution for BOX. It runs in 122ms.
```
from enigma import (SubstitutedExpression, irange, printf)

# look for solutions to the alphametic sum that give a unique value for ans
def check(expr, answer):
  p = SubstitutedExpression(expr, digits=irange(1, 9), answer=answer, verbose=0)
  r = set(x for (_, x) in p.solve())
  if len(r) == 1:
    x = r.pop()
    printf("{answer}={x} [{expr}]")

# there are two possible largest values
check("sq(EGG) + BOX = EASTER", "BOX") # if EASTER is largest
check("sq(EGG) - BOX = EASTER", "BOX") # if EGG^2 is largest
```
  Solution: BOX = 362.
  
  In fact this program runs faster than the single alphametic expression above, as each alphametic expression only requires considering the possibilities for 5 digits, rather than 6 with the single sum.
  
  If (non-leading) 0 digits are allowed, then there are three further solutions to the (EGG)² + BOX = EASTER sum (but still none for (EGG)² − BOX = EASTER).
  
  LikeLike
- GeoffR 8:52 am on 30 July 2019 Permalink | Reply
```
% A Solution in MiniZinc
include "globals.mzn";

var 1..9:E;   var 1..9:A;   var 1..9:S;   var 1..9:T;
var 1..9:R;   var 1..9:G;   var 1..9:B;   var 1..9:O;
var 1..9:X;

constraint all_different ([E, A, S, T, R, G, B, O, X]);

var 100..999:EGG = 100*E + 11*G;
var 100..999:BOX = 100*B + 10*O + X;
var 100000..999999: EASTER = 100000*E + 10000*A + 1000*S + 100*T + 10*E + R;

% Two of the numbers add to make the third
constraint (EASTER - EGG*EGG == BOX) \/ (EGG*EGG - EASTER == BOX);

solve satisfy;

output [ "EASTER = " ++ show(EASTER) 
++ ", EGG = " ++ show(EGG)  ++ ", BOX = " ++ show(BOX) ];

% EASTER = 954891, EGG = 977, BOX = 362
% ----------
% Finished in 232msec
```
  LikeLike
Jim Randell 8:38 am on 21 July 2019 Permalink | Reply
Tags: by: R Postill ( 20 )
Brain-Teaser 488: [Truth and lies]
From The Sunday Times, 4th October 1970 [link]

The villagers of Titterton always tell the truth; those from Lilling always lie; those from Trulham alternate between truth and lie, starting with a truth; those from Litford also alternate, but start with a lie.

I recently met four men, one from each village:

Alf: “I’m from Trulham.”
Bert: “Alf’s from Lilling.”
Charlie: “Bert’s from Lilling.”
Dan: “Charlie’s from Lilling.”
Alf: “Dan’s from Titterton.”

As I was sorting this out, in came three more men, each from one of other of the villages:

Edgar: “I’m from Dan’s village.”
Frank: “There are more chaps here from my village than from any other.”
George: “Frank’s lying. I’m from Bert’s village.”

Name the men from Titterton, Trulham and Litford. (I should perhaps add that I live in Totworth and tell the truth invariably).

This puzzle was originally published with no title.

[teaser488]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Jim Randell is discussing. Toggle Comments
- Jim Randell 8:40 am on 21 July 2019 Permalink | Reply
  I assumed the puzzle text itself was a completely true account, and that the “alternators” were at the beginning of their cycle with their first quoted statements.
  
  This Python program runs in 85ms.
  
  Run: [ @repl.it ]
```
from enigma import (subsets, printf)

# bT = always true (= Titterton)
def bT(ss):
  return all(ss)

# bF = always false (= Lilling)
def bF(ss):
  return not any(ss)

# bTF = alternate, T then F (= Trulham)
def bTF(ss):
  return all(ss[0::2]) and not any(ss[1::2])

# bFT = alternate, F then T (= Litford)
def bFT(ss):
  return all(ss[1::2]) and not any(ss[0::2])

# possible behaviours
fns = (bT, bF, bTF, bFT)

# solve the puzzle
def solve():
  # choose behaviours for A, B, C, D
  for (A, B, C, D) in subsets(fns, size=len, select='P'):

    # A: "I am from Trulham", "D is from Titterton"
    if not A([A is bTF, D is bT]): continue

    # B: "A is from Lilling"
    if not B([A is bF]): continue

    # C: "B is from Lilling"
    if not C([B is bF]): continue

    # D: "C is from Lilling"
    if not D([C is bF]): continue

    # choose behaviours for E, F, G
    for (E, F, G) in subsets(fns, size=3, select='M'):

      # E: "I am from D's village"
      if not E([E == D]): continue

      # F: "There are more from my village than any other"
      s = (A, B, C, D, E, F, G)
      n = dict((k, s.count(k)) for k in s)
      f = all(n[F] > n[x] for x in s if x != F)
      if not F([f]): continue

      # G: "F is lying" "I am from B's village"
      if not G([(not f), G == B]): continue

      yield s

for s in solve():
  (A, B, C, D, E, F, G) = (b.__name__ for b in s)
  printf("A={A} B={B} C={C} D={D} E={E} F={F} G={G}")
```
  Solution: The affiliations are:
  
  Titterton: Charlie
  Lilling: Bert, Edgar
  Trulham: Alf, George
  Litford: Dan, Frank
  
  LikeLike
Jim Randell 6:21 pm on 19 July 2019 Permalink | Reply
Tags: by: Victor Bryant ( 144 )
Teaser 2965: Knock, knock!
From The Sunday Times, 21st July 2019 [link] [link]

Last year a two-figure number of teams entered our football competition. With that number, it was impossible to have a straightforward knockout competition (where half the teams are knocked out in each round), so we divided the teams into equal-sized groups, each pair of teams within a group played each other once, and the overall winner from each group went forward to the second stage consisting of a knockout competition. Unfortunately our local team was knocked out in the quarter-finals of that stage.

This year a higher number of teams entered (but not twice as many). Again a straightforward knockout competition was impossible so we copied last year’s model but with smaller groups and more of them. By coincidence the total number of games played this year equalled the number played last year.

How many teams entered last year and how many this year?

[teaser2965]
Rate this:
Share:
X
Facebook
WhatsApp
Email
Like Loading...
Frits, Lise Andreasen, and Jim Randell are discussing. Toggle Comments
- Jim Randell 7:01 pm on 19 July 2019 Permalink | Reply
  In order to have a knockout tournament (without using byes) the number of teams needs to be a power of 2 (half the teams are knocked out at each stage).
  
  So the numbers of teams we are dealing with cannot be powers of two. But we can divide the numbers into groups where the winners of the groups can have a knockout tournament, so the number of groups must be a power of 2. Hence the total number of teams has to have a divisor that is a power of 2.
  
  Within a group of size m, the number of matches where each team plays each other team is T(m − 1).
  
  This Python program looks for 2-digit values for the number of teams last year, works out the total number of matches played in the tournament, and then finds a scenario for this year which has the same total number of matches. It runs in 91ms.
  
  Run: [ @replit ]
```
from enigma import (irange, div, tri, bit_permutations as powers2, printf)

# check a positive integer is a power of 2
is_power2 = lambda n: not (n & (n - 1))

# number of teams last year (a 2-digit number)
for n in irange(24, 99, step=8):
  # skip numbers that are powers of 2
  if is_power2(n): continue

  # divide n into k groups of m (k is a power of 2)
  # a team was knocked out in the quarter finals, so k > 7
  for k in powers2(8):
    m = div(n, k)
    if m is None: break
    # calculate the total number of games played
    t = k * tri(m - 1) + (k - 1)

    # now look for possible values with the same total, but with smaller groups
    for m2 in irange(3, m - 1):
      # and m2 must not be a power of 2
      if is_power2(m2): continue
      # calculate the number of groups
      k2 = div(t + 1, tri(m2 - 1) + 1)
      if k2 is None: continue
      # there must be more groups
      if not (k2 > k): continue
      # k2 must be a power of 2
      if not is_power2(k2): continue
      # the total number of teams this year
      n2 = k2 * m2
      # and n2 greater than n, but not twice n
      if not (n2 > n and n2 != n * 2): continue

      printf("t={t}: last year = {n} teams ({k} groups of {m}), this year = {n2} teams ({k2} groups of {m2})")
```
  Solution: 56 teams entered last year. 80 teams entered this year.
  
  Last year the 56 teams were formed into 8 groups of 7. Each group would play 21 matches, and then the 8 winners of the groups would play 4 quarter-finals, 2 semi-finals and 1 final to give 175 matches in total.
  
  This year the 80 teams were formed into 16 groups of 5. Each group would play 10 matches, and then the 16 winners of the groups would play 8 eighth-finals, 4 quarter-finals, 2 semi-finals and 1 final to also give 175 matches in total.
  
  As a team was knocked out in the quarter-finals last year, the number of groups must have been at least 8, and we can consider multiples of 8 (that are not exact powers of 2). So there are only 8 candidate numbers for the number of teams last year: 24, 40, 48, 56, 72, 80, 88, 96.
  
  There are two “near miss” scenarios:
  
  48 teams last year (8 groups of 6), and 96 teams this year (32 groups of 3). Both have 127 matches.
  96 teams last year (16 groups of 6), and 192 teams this year (64 groups of 3). Both have 255 matches.
  
  But both are eliminated by the requirement that the number of teams this year is not twice the number of teams last year.
  
  When I initially read the puzzle I took “not twice as many” to mean “fewer than twice as many”, but in my program I relaxed this condition to “not exactly twice as many”, and the single solution remains.
  
  There is also the question of whether, in the knockout tournament, there is a match to decide 3rd and 4th places. It doesn’t matter if there is or not, as long as both tournaments use the same format. If there is a match for the semi-final losers then the total numbers of matches will be increased by 1.
  
  LikeLike
- Jim Randell 12:52 pm on 22 July 2019 Permalink | Reply
  Here is a MiniZinc model for the puzzle. It executes in 66ms.
```
%#! minizinc -a

% powers of 2
set of int: pow2 = { pow(2, i) | i in 1..9 };


% last year: n teams, k groups of m
var 10..99: n; % n is a 2 digit number
var 3..33: k;
var 5..99: m;

% n can be divided into k groups of m;
% n is not a power of 2
% k is a power of 2
% m is not a power of 2
constraint k * m = n;
constraint not(n in pow2);
constraint k in pow2;
constraint not(m in pow2);

% k is at least 8
constraint not(k < 8);


% this year: n1 teams, k1 groups of m1
var 11..1000: n1;
var 4..334: k1;
var 3..98: m1;

constraint n1 = k1 * m1;
constraint not(n1 in pow2);
constraint k1 in pow2;
constraint not(m1 in pow2);

% more teams, but not twice as many
constraint n1 > n;
constraint n1 != 2 * n;

% smaller groups, but more of them
constraint m1 < m;
constraint k1 > k;

% total number of matches is the same
constraint k * (m * (m - 1) + 2) = k1 * (m1 * (m1 - 1) + 2);

solve satisfy;
```
  I wasn’t sure how use the neat trick to test for powers of 2 in MiniZinc, so I assumed an upper bound of 1,000 teams, and just made a set of powers of 2 less than this.
  
  LikeLike
- Lise Andreasen 2:50 pm on 6 June 2024 Permalink | Reply
  
  I think it’s possible to figure this out on paper, but there are a lot of restrictions to deal with.
  9 < x < 100
  x < y < 2x
  x = m * 2^k
  y = n * 2^l
  (that’s an L)
  l > k
  2 < n < m
  2^k or 2^l groups
  m or n members of each group
  Neither m nor n can be a power of 2
  There are this number of matches the first year:
  2^k * m(m-1)/2 + 2^k – 1
  And the second year:
  2^l * n(n-1)/2 + 2^l – 1
  These 2 numbers are the same
  A little calculation gives:
  m(m-1) + 2 = 2^(l-k) * [n(n-1) + 2]
  (I hope I got that one right!)
  Now it's possible to systematically go through all the possibilities.
  Like, k = 3, l = 4, n = 3, is m integer? And so on.
  Neat puzzle!
  
  LikeLike
- Frits 7:38 pm on 6 June 2024 Permalink | Reply
  Comparing triangular numbers.
```
tri = lambda n: (n * (n + 1)) // 2

# powers of 2 (upper bound is not important as breaks are used)
ps2 = [1 << i for i in range(1, 10)]

# maximum number of teams last year is 96 (a multiple of 8)
# t = number of teams per group
# ngroups * t < 192 with ngroups >= 8 (quarter finals) so nteams < 24

# nmatches = ngroups * (tri(t - 1) + 1) - 1  
d = {tri(t - 1) + 1: t for t in range(2, 24) if t & (t - 1)} 
mx = max(d)

# last: matches = g * d[k2] - 1
# this: matches = q * g * d[k1] - 1  where q = k2 / k1 and q is a power of 2
for k1 in d.keys():
  for q in ps2:
    # k2 must be a multiple of k1
    if (k2 := q * k1) > mx: break
    if k2 not in d: continue
  
    # try different number of groups
    for g in ps2:
      if g < 8: continue
      if (nlast := g * d[k2]) > 99: break
      if (nthis := q * g * d[k1]) >= 2 * nlast: break
     
      print("answer:", nlast, "and", nthis)     
```
  LikeLike

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

Search

Recent Posts

Recent Comments

Archives

Categories

Subscribe

RSS Links

Site Stats

Meta

Updates from August, 2019 Toggle Comment Threads | Keyboard Shortcuts

Jim Randell 8:13 pm on 9 August 2019 Permalink | Reply Tags: by: Danny Roth ( 88 )

Rate this:

Share:

Jim Randell 8:29 pm on 9 August 2019 Permalink | Reply

Reply Cancel reply

Jim Randell 10:09 am on 9 August 2019 Permalink | Reply Tags: by: Graham Smithers ( 84 )

Rate this:

Share:

Jim Randell 10:10 am on 9 August 2019 Permalink | Reply

GeoffR 3:05 pm on 11 August 2019 Permalink | Reply

Jim Randell 2:25 pm on 8 August 2019 Permalink | Reply Tags: by: E R Emmet ( 3 )

Rate this:

Share:

Jim Randell 2:26 pm on 8 August 2019 Permalink | Reply

John Crabtree 6:24 pm on 8 August 2019 Permalink | Reply

John Crabtree 2:36 pm on 13 August 2019 Permalink | Reply

Jim Randell 9:14 am on 7 August 2019 Permalink | Reply Tags: by: Peter Good ( 29 ), flawed ( 55 )

Rate this:

Share:

Jim Randell 9:16 am on 7 August 2019 Permalink | Reply

Jim Randell 8:36 am on 6 August 2019 Permalink | Reply Tags: by: Rex Gooch ( 3 )

Rate this:

Share:

Jim Randell 8:37 am on 6 August 2019 Permalink | Reply

GeoffR 1:29 pm on 6 August 2019 Permalink | Reply

John Crabtree 6:21 pm on 8 August 2019 Permalink | Reply

Frits 2:36 pm on 27 July 2020 Permalink | Reply

Frits 3:12 pm on 27 July 2020 Permalink | Reply

Jim Randell 3:33 pm on 27 July 2020 Permalink | Reply

Frits 2:41 pm on 29 July 2020 Permalink | Reply

Jim Randell 8:42 am on 5 August 2019 Permalink | Reply Tags: by: Victor Bryant ( 144 )

Rate this:

Share:

Jim Randell 8:43 am on 5 August 2019 Permalink | Reply

Jim Randell 9:10 am on 4 August 2019 Permalink | Reply Tags: by: Angela Humphreys, corrected ( 10 )

Rate this:

Share:

Jim Randell 9:11 am on 4 August 2019 Permalink | Reply

Jim Randell 5:47 pm on 2 August 2019 Permalink | Reply Tags: by: Angela Newing ( 39 )

Rate this:

Share:

Jim Randell 5:59 pm on 2 August 2019 Permalink | Reply

GeoffR 8:45 am on 5 August 2019 Permalink | Reply

Jim Randell 10:28 am on 2 August 2019 Permalink | Reply Tags: by: Graham Smithers ( 84 )

Rate this:

Share:

Jim Randell 10:29 am on 2 August 2019 Permalink | Reply

Jim Randell 8:36 am on 31 July 2019 Permalink | Reply Tags: by: Graham Smithers ( 84 )

Rate this:

Share:

Jim Randell 8:37 am on 31 July 2019 Permalink | Reply

Jim Randell 11:58 am on 30 July 2019 Permalink | Reply Tags: by: G H Dickson ( 13 )

Rate this:

Share:

Jim Randell 11:58 am on 30 July 2019 Permalink | Reply

Jim Randell 12:40 pm on 28 July 2019 Permalink | Reply Tags: by: Pete Bradley ( 7 )

Rate this:

Share:

Jim Randell 12:41 pm on 28 July 2019 Permalink | Reply

Jim Randell 6:52 pm on 26 July 2019 Permalink | Reply Tags: by: Howard Williams ( 44 )

Rate this:

Share:

Jim Randell 8:20 pm on 26 July 2019 Permalink | Reply

John Crabtree 2:19 am on 27 July 2019 Permalink | Reply

Jim Randell 8:07 am on 27 July 2019 Permalink | Reply

Jim Randell 2:19 pm on 1 August 2019 Permalink | Reply

Robert Brown 11:35 am on 1 August 2019 Permalink | Reply

Jim Randell 11:30 am on 26 July 2019 Permalink | Reply Tags: by: Graham Smithers ( 84 )

Rate this:

Share:

Jim Randell 8:13 pm on 9 August 2019 Permalink | Reply
Tags: by: Danny Roth ( 88 )

Jim Randell 10:09 am on 9 August 2019 Permalink | Reply
Tags: by: Graham Smithers ( 84 )

Jim Randell 2:25 pm on 8 August 2019 Permalink | Reply
Tags: by: E R Emmet ( 3 )

Jim Randell 9:14 am on 7 August 2019 Permalink | Reply
Tags: by: Peter Good ( 29 ), flawed ( 55 )

Jim Randell 8:36 am on 6 August 2019 Permalink | Reply
Tags: by: Rex Gooch ( 3 )

Jim Randell 8:42 am on 5 August 2019 Permalink | Reply
Tags: by: Victor Bryant ( 144 )

Jim Randell 9:10 am on 4 August 2019 Permalink | Reply
Tags: by: Angela Humphreys, corrected ( 10 )

Jim Randell 5:47 pm on 2 August 2019 Permalink | Reply
Tags: by: Angela Newing ( 39 )

Jim Randell 10:28 am on 2 August 2019 Permalink | Reply
Tags: by: Graham Smithers ( 84 )

Jim Randell 8:36 am on 31 July 2019 Permalink | Reply
Tags: by: Graham Smithers ( 84 )

Jim Randell 11:58 am on 30 July 2019 Permalink | Reply
Tags: by: G H Dickson ( 13 )

Jim Randell 12:40 pm on 28 July 2019 Permalink | Reply
Tags: by: Pete Bradley ( 7 )

Jim Randell 6:52 pm on 26 July 2019 Permalink | Reply
Tags: by: Howard Williams ( 44 )

Jim Randell 11:30 am on 26 July 2019 Permalink | Reply
Tags: by: Graham Smithers ( 84 )

Jim Randell 12:15 pm on 25 July 2019 Permalink | Reply
Tags: by: W A Thatcher ( 13 )

Jim Randell 5:20 pm on 24 July 2019 Permalink | Reply
Tags: by: Stephen Hogg ( 64 )

Jim Randell 9:18 am on 23 July 2019 Permalink | Reply
Tags: by: Oliver D Anderson ( 2 )

Jim Randell 8:51 am on 22 July 2019 Permalink | Reply
Tags: by: Andrew Skidmore ( 87 )

Jim Randell 8:38 am on 21 July 2019 Permalink | Reply
Tags: by: R Postill ( 20 )

Jim Randell 6:21 pm on 19 July 2019 Permalink | Reply
Tags: by: Victor Bryant ( 144 )