Sunday Times Teaser 2561 – Winning the Double

by Nick MacKinnon

Published: 23 October 2011 (link)

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

What was the score in the match CvD?

2 Comments Leave one →

BRG permalink

This one is hopelessly slow without the initial analysis to show what the average goals per game must be.


from itertools import permutations, product
 
# If the average goals per game for A, B, C, D are a, b, c and d we then have
#
#     54 == 5.(a + b) + 4.(c + d) 
#
# (since A and B play five games whereas C and D play four). Here the possible
# solutions (a + b, c + d) = (10, 1), (6, 6) or (2, 11).
 
# Since the maximum goals a team can score in any game is 5, all the averages
# are five or less. And, since the averages are all different, a + b and c + d
# are both less than 10 which means that a + b == c + d == 6. Moreover, since
# A wins all their games, other teams cannot score 5 goals in all their games
# and must have goals per match averages of less than five.
#
# Hence the possibilities are:
#
#      (a, b) = (5, 1), (4, 2), (2, 4)
#      (c, d) = (4, 2), (2, 4)
#
# And since the values are all different 
#
#      (a, b, c, d) =  (5, 1, 4, 2) or (5, 1, 2, 4)
#
# Hence in goal totals (A, B, C, D) = (25, 5, 16, 8) or (25, 5, 8, 16)
 
# the possible match scores (irrespective of which team wins or losses)
matches = set((x, y) for x, y in product(range(6), repeat=2) if x <= y)
 
# return the result of reversing the order of two values in each
# of a set of tuples in the input
def rev(args):
  return tuple((y, x) for x, y in args)
 
# compile statistics from a team's games in g, return points, goal
# difference and goals for
def stats(g):
  w, d = sum((a > b for a, b in g)), sum((a == b for a, b in g))
  gf, ga = sum(x[0] for x in g), sum(x[1] for x in g)
  return 3 * w + d, gf, ga
 
# consider all of A's possible game outcomes (A's always wins
# and always scores 5 goals in its matches - see analysis)
ag_list = ([(y, x) for x, y in matches if y == 5 and x < 5])
for pa in permutations(ag_list, 5):
  # set match results for A and for their opponents
  ab, ac, ad, ack, abk = pa
  ba, ca, da, cak, bak = qa = rev(pa)
  # remove these scores (since all match scores are different
  # these scores cannot be the results for remaining matches)
  m1 = matches.difference(pa + qa)
  # check that we don't have the same match result
  # more than once (one the reverse of the other)
  if len(set(frozenset(x) for x in pa)) != len(pa):
    continue
 
  # compose A's games and their statistics
  a_games = set((ab, ac, ad, ack, abk))
  a_pts, a_for, a_agn = stats(a_games)
  # A wins all its games with 5 goals in each (see analysis)
  if a_pts != 15 or a_for != 25:
    continue
 
  # consider B's (remaining) games
  bg_list = m1.union([(y, x) for x, y in m1 if x != y])
  for pb in permutations(bg_list, 3):
    if len(set(frozenset(x) for x in pb)) != len(pb):
      continue
    # process these results (as for A above)
    bc, bd, bdk = pb
    cb, db, dbk = qb = rev(pb)
    m2 = m1.difference(pb + qb)
    # team B beat D by a margin of more than one goal
    if bdk[0] - bdk[1] < 2: continue
 
    # compose B's games and their statistics
    b_games = set((ba, bc, bd, bdk, bak))
    b_pts, b_for, b_agn = stats(b_games)
    # B's results match those of A except goals for is one less
    if b_for != 5:
      continue
 
    cg_list = m2.union([(y, x) for x, y in m2 if x != y])
    for cd in cg_list:
      dc = (cd[1], cd[0])
      m3 = m2.difference([cd, dc])
 
      # compose C's games and their statistics
      c_games = set((ca, cb, cd, cak))
      c_pts, c_for, c_agn = stats(c_games)
      # C's results match those of B except goals for is one less
      if c_for not in (8, 16):
        continue
 
      # compose D's games and their statistics
      d_games = set((da, db, dc, dbk))
      d_pts, d_for, d_agn = stats(d_games)
      # D's results match those of C except goals for is one less
      if c_for + d_for != 24:
        continue
 
      print('      ', ab, ac, ad, ack, abk, a_for)
      print(ba, '      ', bc, bd, bak, bdk, b_for)
      print(ca, cb, '      ', cd, cak, c_for)
      print(da, db, dc, '      ', dbk, d_for)
      print()

100

101

102

103

104

105

106

107

108

from itertools import permutations, product

# If the average goals per game for A, B, C, D are a, b, c and d we then have

# 54 == 5.(a + b) + 4.(c + d)

# (since A and B play five games whereas C and D play four). Here the possible

# solutions (a + b, c + d) = (10, 1), (6, 6) or (2, 11).

# Since the maximum goals a team can score in any game is 5, all the averages

# are five or less. And, since the averages are all different, a + b and c + d

# are both less than 10 which means that a + b == c + d == 6. Moreover, since

# A wins all their games, other teams cannot score 5 goals in all their games

# and must have goals per match averages of less than five.

# Hence the possibilities are:

# (a, b) = (5, 1), (4, 2), (2, 4)

# (c, d) = (4, 2), (2, 4)

# And since the values are all different

# (a, b, c, d) = (5, 1, 4, 2) or (5, 1, 2, 4)

# Hence in goal totals (A, B, C, D) = (25, 5, 16, 8) or (25, 5, 8, 16)

# the possible match scores (irrespective of which team wins or losses)

matches = set((x, y) for x, y in product(range(6), repeat=2) if x <= y)

# return the result of reversing the order of two values in each

# of a set of tuples in the input

def rev(args):

return tuple((y, x) for x, y in args)

# compile statistics from a team's games in g, return points, goal

# difference and goals for

def stats(g):

w, d = sum((a > b for a, b in g)), sum((a == b for a, b in g))

gf, ga = sum(x[0] for x in g), sum(x[1] for x in g)

return 3 * w + d, gf, ga

# consider all of A's possible game outcomes (A's always wins

# and always scores 5 goals in its matches - see analysis)

ag_list = ([(y, x) for x, y in matches if y == 5 and x < 5])

for pa in permutations(ag_list, 5):

# set match results for A and for their opponents

ab, ac, ad, ack, abk = pa

ba, ca, da, cak, bak = qa = rev(pa)

# remove these scores (since all match scores are different

# these scores cannot be the results for remaining matches)

m1 = matches.difference(pa + qa)

# check that we don't have the same match result

# more than once (one the reverse of the other)

if len(set(frozenset(x) for x in pa)) != len(pa):

continue

# compose A's games and their statistics

a_games = set((ab, ac, ad, ack, abk))

a_pts, a_for, a_agn = stats(a_games)

# A wins all its games with 5 goals in each (see analysis)

if a_pts != 15 or a_for != 25:

continue

# consider B's (remaining) games

bg_list = m1.union([(y, x) for x, y in m1 if x != y])

for pb in permutations(bg_list, 3):

if len(set(frozenset(x) for x in pb)) != len(pb):

continue

# process these results (as for A above)

bc, bd, bdk = pb

cb, db, dbk = qb = rev(pb)

m2 = m1.difference(pb + qb)

# team B beat D by a margin of more than one goal

if bdk[0] - bdk[1] < 2: continue

# compose B's games and their statistics

b_games = set((ba, bc, bd, bdk, bak))

b_pts, b_for, b_agn = stats(b_games)

# B's results match those of A except goals for is one less

if b_for != 5:

continue

cg_list = m2.union([(y, x) for x, y in m2 if x != y])

for cd in cg_list:

dc = (cd[1], cd[0])

m3 = m2.difference([cd, dc])

# compose C's games and their statistics

c_games = set((ca, cb, cd, cak))

c_pts, c_for, c_agn = stats(c_games)

# C's results match those of B except goals for is one less

if c_for not in (8, 16):

continue

# compose D's games and their statistics

d_games = set((da, db, dc, dbk))

d_pts, d_for, d_agn = stats(d_games)

# D's results match those of C except goals for is one less

if c_for + d_for != 24:

continue

print(' ', ab, ac, ad, ack, abk, a_for)

print(ba, ' ', bc, bd, bak, bdk, b_for)

print(ca, cb, ' ', cd, cak, c_for)

print(da, db, dc, ' ', dbk, d_for)

print()

This shows that the CvD result is 5:5. Jim Randell has a football solver class in his enigma.py collection of puzzle solving utilities. But I dislike football teasers (almost as much as I dislike football) so I am not inclined to spend time understanding and using it or building my own equivalent.

Frits permalink

I don’t see so much of a difference with other teasers. To me a football teaser is still a challenge.

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


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

# return the result of reversing the order of two values in each
# of a set of tuples in the input
def rev(args):
  return tuple((y, x) for x, y in args)
 
# compile statistics from a team's games in g, return goals for
def goals_for(*g):
  return sum(x[0] for x in g)

a_for = 25
# A wins all matches with 5 goals per game
ag_list = ([(x, y) for x, y in matches if x == 5 and y < 5])

# check all possible scores CvD
for cd in matches:
  # if cd contains a '5' then cd must be (5, 5) as A has all wins with 5
  if 5 in cd and cd != (5, 5): continue 
  
  # either team C or D has 16 points (scoring 3 points per game at minimum)
  if max(cd) < 3: continue
  dc = cd[::-1]
  # select all wins for A
  for pa in permutations(ag_list, 5):
    # set match results for A and for their opponents
    ab, ac, ad, ack, abk = pa
    ba, ca, da, cak, bak = qa = rev(pa)
    # either team C or D has 16 points 
    # (scoring 3 points per game at minimum, 3 only if (5, 5) can be involved)
    d55 = (dc == (5, 5))
    if dc[0] + da[0] < 7 or not {0, 1, 2}.isdisjoint({dc[0], da[0]}):
      # team C must score 3 or more goals per game
      if (cd[0] + ca[0] + cak[0] < 11 + d55 or 
          not {0, 1, 2}.isdisjoint({cd[0], ca[0], cak[0]})):
        continue
    
    # team B beat D by more than one goal and total goals made by B must be 5
    if ba[0] + bak[0] > 3: continue

    # remove new scores 
    m1 = matches.difference(pa + qa + (cd, dc))
    
    # total goals made by B must be 5
    bg_list = set((x, y) for x, y in m1 if x <= 5 - (ba[0] + bak[0]))
    
    # goals made by C must be either 8 or 16
    if (c_for3 := goals_for(ca, cd, cak)) in {0, 1, 2, 9, 10}: continue
    for bc in [x for x in bg_list if (x[1] + c_for3) in {8, 16}]:
      cb = bc[::-1]
      c_for = c_for3 + cb[0]
      bg_list2 = [(x, y) for x, y in bg_list - {bc, cb} 
                      if x <= 5 - (ba[0] + bak[0] + bc[0])]
      for pb in permutations(bg_list2, 2):
        bd, bdk = pb
        
        # team B beat D by a margin of more than one goal 
        if bdk[0] - bdk[1] < 2: continue 
        # reject opposite scores in pb
        if bd == bdk[::-1]: continue
 
        # total goals made by B must be 5
        if (b_for := goals_for(ba, bc, bd, bdk, bak)) != 5: continue
        
        db, dbk = rev(pb)
        d_for = goals_for(da, db, dc, dbk)
        # total goals made by C and D must be 24
        if not (c_for + d_for == 24): continue
        
        # integrity checks
        if len(gs := {ab, ac, ad, ack, abk, bc, bd, bdk, cd}) != 9: continue
        if any([r in gs for x in gs if x != (r := x[::-1])]): continue

        print("example:\n")        
        print('      ', ab, ac, ad, ack, abk,      a_for)
        print(ba, '      ', bc, bd, bak, bdk,      b_for)
        print(ca, cb, '      ', cd, cak, '      ', c_for)
        print(da, db, dc, '      ', dbk, '      ', d_for)
        print()
        print("answer:", cd)
       
        break # we have found a solution for CvD
      else: # no break
        continue
      break # propagate break in most inner loop
    else: # no break
      continue
    break # propagate break in most inner loop

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

from itertools import permutations

# If the average goals per game for A, B, C, D are a, b, c and d we then have

# 54 == 5.(a + b) + 4.(c + d)

# (since A and B play five games whereas C and D play four). Here the possible

# solutions (a + b, c + d) = (10, 1), (6, 6) or (2, 11).

# Since the maximum goals a team can score in any game is 5, all the averages

# are five or less. And, since the averages are all different, a + b and c + d

# are both less than 10 which means that a + b == c + d == 6. Moreover, since

# A wins all their games, other teams cannot score 5 goals in all their games

# and must have goals per match averages of less thsn five.

# Hence the possibilities are:

# (a, b) = (5, 1), (4, 2), (2, 4)

# (c, d) = (4, 2), (2, 4)

# And since the values are all different

# (a, b, c, d) = (5, 1, 4, 2) or (5, 1, 2, 4)

# Hence in goal totals (A, B, C, D) = (25, 5, 16, 8) or (25, 5, 8, 16)

# the possible match scores

matches = set((i, j) for i in range(6) for j in range(6))

# return the result of reversing the order of two values in each

# of a set of tuples in the input

def rev(args):

return tuple((y, x) for x, y in args)

# compile statistics from a team's games in g, return goals for

def goals_for(*g):

return sum(x[0] for x in g)

a_for = 25

# A wins all matches with 5 goals per game

ag_list = ([(x, y) for x, y in matches if x == 5 and y < 5])

# check all possible scores CvD

for cd in matches:

# if cd contains a '5' then cd must be (5, 5) as A has all wins with 5

if 5 in cd and cd != (5, 5): continue

# either team C or D has 16 points (scoring 3 points per game at minimum)

if max(cd) < 3: continue

dc = cd[::-1]

# select all wins for A

for pa in permutations(ag_list, 5):

# set match results for A and for their opponents

ab, ac, ad, ack, abk = pa

ba, ca, da, cak, bak = qa = rev(pa)

# either team C or D has 16 points

# (scoring 3 points per game at minimum, 3 only if (5, 5) can be involved)

d55 = (dc == (5, 5))

if dc[0] + da[0] < 7 or not {0, 1, 2}.isdisjoint({dc[0], da[0]}):

# team C must score 3 or more goals per game

if (cd[0] + ca[0] + cak[0] < 11 + d55 or

not {0, 1, 2}.isdisjoint({cd[0], ca[0], cak[0]})):

continue

# team B beat D by more than one goal and total goals made by B must be 5

if ba[0] + bak[0] > 3: continue

# remove new scores

m1 = matches.difference(pa + qa + (cd, dc))

# total goals made by B must be 5

bg_list = set((x, y) for x, y in m1 if x <= 5 - (ba[0] + bak[0]))

# goals made by C must be either 8 or 16

if (c_for3 := goals_for(ca, cd, cak)) in {0, 1, 2, 9, 10}: continue

for bc in [x for x in bg_list if (x[1] + c_for3) in {8, 16}]:

cb = bc[::-1]

c_for = c_for3 + cb[0]

bg_list2 = [(x, y) for x, y in bg_list - {bc, cb}

if x <= 5 - (ba[0] + bak[0] + bc[0])]

for pb in permutations(bg_list2, 2):

bd, bdk = pb

# team B beat D by a margin of more than one goal

if bdk[0] - bdk[1] < 2: continue

# reject opposite scores in pb

if bd == bdk[::-1]: continue

# total goals made by B must be 5

if (b_for := goals_for(ba, bc, bd, bdk, bak)) != 5: continue

db, dbk = rev(pb)

d_for = goals_for(da, db, dc, dbk)

# total goals made by C and D must be 24

if not (c_for + d_for == 24): continue

# integrity checks

if len(gs := {ab, ac, ad, ack, abk, bc, bd, bdk, cd}) != 9: continue

if any([r in gs for x in gs if x != (r := x[::-1])]): continue

print("example:\n")

print(' ', ab, ac, ad, ack, abk, a_for)

print(ba, ' ', bc, bd, bak, bdk, b_for)

print(ca, cb, ' ', cd, cak, ' ', c_for)

print(da, db, dc, ' ', dbk, ' ', d_for)

print()

print("answer:", cd)

break # we have found a solution for CvD

else: # no break

continue

break # propagate break in most inner loop

else: # no break

continue

break # propagate break in most inner loop

Sunday Times Teaser 2561 – Winning the Double

by Nick MacKinnon

Published: 23 October 2011 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta