Sunday Times Teaser 3270 – Tunnel Vision

by BRG on May 25, 2025

by Howard Williams

Published Sunday May 25 2025 (link)

Four ramblers came to a tunnel that they all had to travel through. The tunnel was too dangerous to travel through without a torch, and unfortunately they only had one torch. It was also too narrow to walk through more than two at a time. The maximum walking speed of each of the walkers was such that they could walk through the tunnel in an exact number of minutes, less than ten, which was different for each walker. When two walkers walked together, they would walk at the speed of the slower one.

They all managed to get through the tunnel and in the quickest possible time, this time being five sixths of the total of their individual crossing times.

In ascending order, what are their four individual crossing times?

From → Uncategorized

6 Comments Leave one →

Brian Gladman permalink


from itertools import combinations

# consider all combinations of tunnel transit times
for s4 in combinations(range(1, 10), 4):
  
  # the total must be a multiple of six to ensure that
  # (5 / 6) of the total is an integer
  if sum(s4) % 6:
    continue
  
  # for storing the minimum total time and related values 
  min_t, min_ord, min_seq = 40, None, None
  
  # choose the first pair to transit the tunnel
  for a, b in combinations(s4, 2):
    # the first tunnel transit time
    t1 = max(a, b)
    # choose which stays at the end (e) and 
    # which returns to the start (f)
    for e, f in ((a, b), (b, a)):
      # add the return time
      t2 = t1 + f
      # collect those now at the start
      s3 = (set(s4) - {a, b}) | {f}
      # choose the pair for the second tunnel transit
      for c, d in combinations(s3, 2):
        # find who returns to the start
        g = (s3 - {c, d}).pop()
        # add the second transit time and the return time
        t3 = t2 + max(c, d) + e
        # add the third transit time
        t4 = t3 + max(e, g)
        if t4 < min_t:
          min_t = t4
          min_ord = s4
          min_seq = [(a, b), [f, c, d], (c, d), (e, g)]
  if min_ord and 6 * min_t == 5 * sum(min_ord):
    print(f"{min_ord} -> {min_t} {min_seq}")

from itertools import combinations

# consider all combinations of tunnel transit times

for s4 in combinations(range(1, 10), 4):

# the total must be a multiple of six to ensure that

# (5 / 6) of the total is an integer

if sum(s4) % 6:

continue

# for storing the minimum total time and related values

min_t, min_ord, min_seq = 40, None, None

# choose the first pair to transit the tunnel

for a, b in combinations(s4, 2):

# the first tunnel transit time

t1 = max(a, b)

# choose which stays at the end (e) and

# which returns to the start (f)

for e, f in ((a, b), (b, a)):

# add the return time

t2 = t1 + f

# collect those now at the start

s3 = (set(s4) - {a, b}) | {f}

# choose the pair for the second tunnel transit

for c, d in combinations(s3, 2):

# find who returns to the start

g = (s3 - {c, d}).pop()

# add the second transit time and the return time

t3 = t2 + max(c, d) + e

# add the third transit time

t4 = t3 + max(e, g)

if t4 < min_t:

min_t = t4

min_ord = s4

min_seq = [(a, b), [f, c, d], (c, d), (e, g)]

if min_ord and 6 * min_t == 5 * sum(min_ord):

print(f"{min_ord} -> {min_t} {min_seq}")

John Z. permalink


from itertools import combinations

def tunnel(entrance, Exit, torch, movements = (), time =0):

  if len(entrance) == 0:
      yield time, movements

  else:
    if torch: # torch is at entrance to tunnel

      for ramb in combinations(entrance, 2): # pick 2 to advance

        yield from tunnel(entrance - set(ramb), Exit | set(ramb), not torch,
                          movements + (ramb,), time + max(ramb))
    else: #torch is at exit of tunnel

      for ret in Exit: # pick one to return

        yield from tunnel(entrance | {ret}, Exit - {ret}, not torch,
                          movements + ((ret),), time + ret)

# consider possible ramble transit times                          
for r in combinations(range(1, 10), 4):

  if sum(r) % 6: # must be divisible by 6
    continue

  s = min(tunnel(set(r), set(), True))

  if s[0] * 6 == sum(r) * 5:
    print(r, sum(r), s)

from itertools import combinations

def tunnel(entrance, Exit, torch, movements = (), time =0):

if len(entrance) == 0:

yield time, movements

else:

if torch: # torch is at entrance to tunnel

for ramb in combinations(entrance, 2): # pick 2 to advance

yield from tunnel(entrance - set(ramb), Exit | set(ramb), not torch,

movements + (ramb,), time + max(ramb))

else: #torch is at exit of tunnel

for ret in Exit: # pick one to return

yield from tunnel(entrance | {ret}, Exit - {ret}, not torch,

movements + ((ret),), time + ret)

# consider possible ramble transit times

for r in combinations(range(1, 10), 4):

if sum(r) % 6: # must be divisible by 6

continue

s = min(tunnel(set(r), set(), True))

if s[0] * 6 == sum(r) * 5:

print(r, sum(r), s)

Frits permalink

@ John, the code apprarently also works with varable name “exit” (lowercase).

The meaning of your print statement is not clear to me.
You print (with “s”) only one of the possible strategies to to get through the tunnel in the quickest possible time.

Reply

BRG permalink

Hi John, I like the code in your solution but I am not convinced about the layout as I much prefer the PEP8 approach which suggest that inline comments should be used sparingly. Also your code has far too much vertical space for my liking. I hope you don’t mind but I have taken the liberty of recasting your solution in my style (also with a couple of minor code changes)


from itertools import combinations

# find sequences of moves which tranfer all ramblers to the far end
# of the tunnel; return the total time taken and the moves involved
# start/end = tunnel transit times for ramblers at tunnel start/end
def find(start, end, moves=(), time=0):

  if len(start) == 0:
    yield time, moves
  else:
    if len(moves) % 2 == 0:
      # torch is at start of the tunnel, pick two to advance
      for p in combinations(start, 2):
        yield from find(start - set(p), end | set(p), moves + (p,), time + max(p))  
    else:
      # torch is at end of the tunnel, pick one to return 
      for p in end:
        yield from find(start | {p}, end - {p}, moves + (p,), time + p)

# consider rambler tunnal transit times                          
for tms in combinations(range(1, 10), 4):

  # the total must be divisible by 6 for 5/6 of this total to be integer 
  if sum(tms) % 6:
    continue
  
# consider possible rambler transfer times ...
  time, moves = min(find(set(tms), set()))
  # ... that meet the teaser constraint
  moves = [tuple(sorted(x)) if type(x) is tuple else x for x in moves]
  if 6 * time == 5 * sum(tms):
    print(f"{tms} -> {time}/{sum(tms)} {moves}))")

from itertools import combinations

# find sequences of moves which tranfer all ramblers to the far end

# of the tunnel; return the total time taken and the moves involved

# start/end = tunnel transit times for ramblers at tunnel start/end

def find(start, end, moves=(), time=0):

if len(start) == 0:

yield time, moves

else:

if len(moves) % 2 == 0:

# torch is at start of the tunnel, pick two to advance

for p in combinations(start, 2):

yield from find(start - set(p), end | set(p), moves + (p,), time + max(p))

else:

# torch is at end of the tunnel, pick one to return

for p in end:

yield from find(start | {p}, end - {p}, moves + (p,), time + p)

# consider rambler tunnal transit times

for tms in combinations(range(1, 10), 4):

# the total must be divisible by 6 for 5/6 of this total to be integer

if sum(tms) % 6:

continue

# consider possible rambler transfer times ...

time, moves = min(find(set(tms), set()))

# ... that meet the teaser constraint

moves = [tuple(sorted(x)) if type(x) is tuple else x for x in moves]

if 6 * time == 5 * sum(tms):

print(f"{tms} -> {time}/{sum(tms)} {moves}))")

Although it is slower than my version, another really big advantage of your solution is that it is not tied to a specific range of tunnel transit times or numbers of walkers which makes it very easy to try other scenarios.

John Z permalink

Thanks, Brian.
I will try to apply your recommendations in future.

Reply

John Z permalink

Post analysis shows that the phrase “in the quickest possible time” in the teaser statement is not a hard constraint: its non-observance does not prevent finding a unique solution as demonstrated by the slightly modified code below where there is no attempt to find the minimum time.


from itertools import combinations

# find sequences of moves which tranfer all ramblers to the far end
# of the tunnel; return the total time taken and the moves involved
# start/end = tunnel transit times for ramblers at tunnel start/end
def find(start, end, moves=(), time=0):

  if len(start) == 0:
    yield time, moves
  else:
    if len(moves) % 2 == 0:
      # torch is at start of the tunnel, pick two to advance
      for p in combinations(start, 2):
        yield from find(start - set(p), end | set(p), moves + (p,), time + max(p))  
    else:
      # torch is at end of the tunnel, pick one to return 
      for p in end:
        yield from find(start | {p}, end - {p}, moves + (p,), time + p)

# consider rambler tunnal transit times                          
for tms in combinations(range(1, 10), 4):

  # the total must be divisible by 6 for 5/6 of this total to be integer 
  if sum(tms) % 6:
    continue
  
# consider possible rambler transfer times ...
  for time, moves in find(set(tms), set()):
    # ... that meet the teaser constraint
    moves = [tuple(sorted(x)) if type(x) is tuple else x for x in moves]
    if 6 * time == 5 * sum(tms):
      print(f"{tms} -> {time}/{sum(tms)} {moves}))")

from itertools import combinations

# find sequences of moves which tranfer all ramblers to the far end

# of the tunnel; return the total time taken and the moves involved

# start/end = tunnel transit times for ramblers at tunnel start/end

def find(start, end, moves=(), time=0):

if len(start) == 0:

yield time, moves

else:

if len(moves) % 2 == 0:

# torch is at start of the tunnel, pick two to advance

for p in combinations(start, 2):

yield from find(start - set(p), end | set(p), moves + (p,), time + max(p))

else:

# torch is at end of the tunnel, pick one to return

for p in end:

yield from find(start | {p}, end - {p}, moves + (p,), time + p)

# consider rambler tunnal transit times

for tms in combinations(range(1, 10), 4):

# the total must be divisible by 6 for 5/6 of this total to be integer

if sum(tms) % 6:

continue

# consider possible rambler transfer times ...

for time, moves in find(set(tms), set()):

# ... that meet the teaser constraint

moves = [tuple(sorted(x)) if type(x) is tuple else x for x in moves]

if 6 * time == 5 * sum(tms):

print(f"{tms} -> {time}/{sum(tms)} {moves}))")

Sunday Times Teaser 3270 – Tunnel Vision

by Howard Williams

Published Sunday May 25 2025 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta