Sunday Times Teaser 3155 – Increasing temperature

by BRG on March 11, 2023

by Victor Bryant

Published Sunday March 12 2023 (link)

I have written down an above-freezing temperature, a whole number of degrees Celsius, in which the digits are all different and are in decreasing order. I have then calculated the Fahrenheit equivalent. It is also a whole number whose digits are all different, but here the digits are in increasing order.

If I told you the first digit of the Celsius temperature, then you would not be able to calculate the temperature. However, bearing that in mind, if I now told you the final digit of the Celsius temperature, then it would be possible to calculate it.

You should now be able to work out the Celsius and Fahrenheit temperatures.

What are they?

From → Uncategorized

5 Comments Leave one →

Brian Gladman permalink

Here is a simple solution:


from collections import defaultdict

# check that the digits of a temperature <t> are all different
# and increasing if <b> == 1 or decreasing if <b> = -1
check = lambda t, b: len(set(t)) == len(t) and t == ''.join(sorted(t)[::b])

# map (C, F) pairs indexed on the first digit of the Celsius value
ci2cfp = defaultdict(list)
for n in range(1, 200):
  if check((c := str(5 * n)), -1):
    if check((f := str(9 * n + 32)), 1):
      ci2cfp[c[0]].append((c, f))

# map resulting non-unique (C, F) pairs on the last digit of their Celsius value
cl2cf = defaultdict(list)
for l_cf in ci2cfp.values():
  if len(l_cf) > 1:
    for c, f in l_cf:
      cl2cf[c[-1]].append((c, f))

# output (C, F) pairs that have unique last digits of their Celsius value
for l_cf in cl2cf.values():
  if len(l_cf) == 1:
    c, f = l_cf[0]
    print(f"{c}\u00b0C <==> {f}\u00b0F.")

from collections import defaultdict

# check that the digits of a temperature <t> are all different

# and increasing if <b> == 1 or decreasing if <b> = -1

check = lambda t, b: len(set(t)) == len(t) and t == ''.join(sorted(t)[::b])

# map (C, F) pairs indexed on the first digit of the Celsius value

ci2cfp = defaultdict(list)

for n in range(1, 200):

if check((c := str(5 * n)), -1):

if check((f := str(9 * n + 32)), 1):

ci2cfp[c[0]].append((c, f))

# map resulting non-unique (C, F) pairs on the last digit of their Celsius value

cl2cf = defaultdict(list)

for l_cf in ci2cfp.values():

if len(l_cf) > 1:

for c, f in l_cf:

cl2cf[c[-1]].append((c, f))

# output (C, F) pairs that have unique last digits of their Celsius value

for l_cf in cl2cf.values():

if len(l_cf) == 1:

c, f = l_cf[0]

print(f"{c}\u00b0C <==> {f}\u00b0F.")

and here is a slower version that checks all possible solutions:


from itertools import combinations
from partition_unique import partition_unique

# generate combinations of ten digits of all lengths
def powerset():
  for i in range(1, 11):
    for c in combinations(range(10), i):
      yield c

# generate temperatures that, when given in Celsius and
# Fahrenheit, have digit sequences in left to right 
# order that decrease and increase respectively
def gen(nc=0, dgts=set(range(10))):
  for c in powerset():
    if (c := int(''.join(str(s) for s in c[::-1]))):
      f, r = divmod(9 * c + 160, 5)
      if c and not r:
        sf = str(f)
        if len(sf) == len(set(sf)) and sf == ''.join(sorted(sf)):
          yield str(c), sf

# list all (C, F) pairs of the above form 
cf_pairs = list(gen())

# list all (C, F) pairs where their first Celsius digit is not unique  
cf_nu = partition_unique(cf_pairs, lambda c, f: c[0])[1]

# list all resulting (C, F) pairs where their last Celsius digit is unique
cf_un = partition_unique(cf_nu, lambda c, f: c[-1])[0]
for c, f in cf_un:
  print(f"{c}\u00b0C <==> {f}\u00b0F.")

from itertools import combinations

from partition_unique import partition_unique

# generate combinations of ten digits of all lengths

def powerset():

for i in range(1, 11):

for c in combinations(range(10), i):

yield c

# generate temperatures that, when given in Celsius and

# Fahrenheit, have digit sequences in left to right

# order that decrease and increase respectively

def gen(nc=0, dgts=set(range(10))):

for c in powerset():

if (c := int(''.join(str(s) for s in c[::-1]))):

f, r = divmod(9 * c + 160, 5)

if c and not r:

sf = str(f)

if len(sf) == len(set(sf)) and sf == ''.join(sorted(sf)):

yield str(c), sf

# list all (C, F) pairs of the above form

cf_pairs = list(gen())

# list all (C, F) pairs where their first Celsius digit is not unique

cf_nu = partition_unique(cf_pairs, lambda c, f: c[0])[1]

# list all resulting (C, F) pairs where their last Celsius digit is unique

cf_un = partition_unique(cf_nu, lambda c, f: c[-1])[0]

for c, f in cf_un:

print(f"{c}\u00b0C <==> {f}\u00b0F.")

John Z. permalink


cfdl = [0] * 10 # count of first digit occurrence in C° (list)
cfldm = [[0] * 10 for i in range(10)] # count of first, last digit in C° matrix
CF = [[0] * 10 for i in range(10)]  # C° and F° value matrix

# consider C° temperatures than convert to an integral F°
for c in range(10, 100000, 5):
  f = 32 + 9 * c // 5
  cs, fs = str(c), str(f)
  
  if (all(a > b for a, b in zip(cs, cs[1:]))and # descending digits for C°
      all(a < b for a, b in zip(fs, fs[1:]))): # ascending digits for F°
    
    cfd, cld = int(cs[0]), int(cs[-1]) # first and last digits of C°

    cfdl[cfd] += 1 # count of first digit of possible solution
    cfldm[cfd][cld] += 1 # count by first, last digit of possible solution
    CF[cfd][cld] = (c, f)  # save possible solution

fd = cfdl.index(max(cfdl)) # first digit of solution
ld = cfldm[fd].index(1) # last digit of solution

# retrieve solution from matrix and print
print(f'{CF[fd][ld][0]}°C, {CF[fd][ld][1]}°F')

cfdl = [0] * 10 # count of first digit occurrence in C° (list)

cfldm = [[0] * 10 for i in range(10)] # count of first, last digit in C° matrix

CF = [[0] * 10 for i in range(10)] # C° and F° value matrix

# consider C° temperatures than convert to an integral F°

for c in range(10, 100000, 5):

f = 32 + 9 * c // 5

cs, fs = str(c), str(f)

if (all(a > b for a, b in zip(cs, cs[1:]))and # descending digits for C°

all(a < b for a, b in zip(fs, fs[1:]))): # ascending digits for F°

cfd, cld = int(cs[0]), int(cs[-1]) # first and last digits of C°

cfdl[cfd] += 1 # count of first digit of possible solution

cfldm[cfd][cld] += 1 # count by first, last digit of possible solution

CF[cfd][cld] = (c, f) # save possible solution

fd = cfdl.index(max(cfdl)) # first digit of solution

ld = cfldm[fd].index(1) # last digit of solution

# retrieve solution from matrix and print

print(f'{CF[fd][ld][0]}°C, {CF[fd][ld][1]}°F')

John Z permalink

Using a dictionary instead of matrices gives even tighter code:


from collections import defaultdict

CF = defaultdict(lambda: defaultdict(list))

# consider C° temperatures that convert to an integral F°, at least 2 digits
for c in range(10, 100000, 5):
  f = 32 + 9 * c // 5
  cs, fs = str(c), str(f)
  
  if (all(a > b for a, b in zip(cs, cs[1:]))and # descending digits for C°
      all(a < b for a, b in zip(fs, fs[1:]))): # ascending digits for F° 

    CF[cs[0]][cs[-1]].append((c, f))  # save possible solutions

# there must be more than one possible solution for first digit
# but a single solution for only one first digit - last digit pair
sol = [y for x in CF.values() for y in x.values() if len(x) > 1 and len(y) == 1]

print (str(sol)[3:-3].replace(',', '°C,') + '°F')

from collections import defaultdict

CF = defaultdict(lambda: defaultdict(list))

# consider C° temperatures that convert to an integral F°, at least 2 digits

for c in range(10, 100000, 5):

f = 32 + 9 * c // 5

cs, fs = str(c), str(f)

if (all(a > b for a, b in zip(cs, cs[1:]))and # descending digits for C°

all(a < b for a, b in zip(fs, fs[1:]))): # ascending digits for F°

CF[cs[0]][cs[-1]].append((c, f)) # save possible solutions

# there must be more than one possible solution for first digit

# but a single solution for only one first digit - last digit pair

sol = [y for x in CF.values() for y in x.values() if len(x) > 1 and len(y) == 1]

print (str(sol)[3:-3].replace(',', '°C,') + '°F')

John Z permalink

Checking all possible solutions:


#generate all possible numbers ending in 0 or 5 with digits in descending order
def desc(i = 10, res = 0):
  if i == 0:
    yield res
  else:
    if i == 5:
      yield res
    for j in range(i - 1, -1, -1):
      yield from desc(j, res * 10 + j)

# C° and F° possible solution value matrix indexed by first, last digit in C°
CF = [[[] for i in range(10)] for j in range(10)]  

# consider C° temperatures that are in descending order and end in 0 or 5
for c in desc():
  f = 32 + 9 * c // 5
  cs, fs = str(c), str(f)
  
  if all(a < b for a, b in zip(fs, fs[1:])): # ascending digits for F°
    
    # save possible solution indexed by first, last digits of C°                    
    CF[int(cs[0])][c % 10].append((c, f))

# count the number of entries in a row of CF as 10 - count([])
# there must be more than one possible solution for first digit
# but a single solution for only one first digit - last digit pair
sol = [y for x in CF for y in x if x.count([]) < 9 and len(y) == 1]

print (str(sol)[3:-3].replace(',', '°C,') + '°F')

#generate all possible numbers ending in 0 or 5 with digits in descending order

def desc(i = 10, res = 0):

if i == 0:

yield res

else:

if i == 5:

yield res

for j in range(i - 1, -1, -1):

yield from desc(j, res * 10 + j)

# C° and F° possible solution value matrix indexed by first, last digit in C°

CF = [[[] for i in range(10)] for j in range(10)]

# consider C° temperatures that are in descending order and end in 0 or 5

for c in desc():

f = 32 + 9 * c // 5

cs, fs = str(c), str(f)

if all(a < b for a, b in zip(fs, fs[1:])): # ascending digits for F°

# save possible solution indexed by first, last digits of C°

CF[int(cs[0])][c % 10].append((c, f))

# count the number of entries in a row of CF as 10 - count([])

# there must be more than one possible solution for first digit

# but a single solution for only one first digit - last digit pair

sol = [y for x in CF for y in x if x.count([]) < 9 and len(y) == 1]

print (str(sol)[3:-3].replace(',', '°C,') + '°F')

John Z permalink

Using a dictionary without the benefit of ‘defaultdict()’ to store possible solutions. Inspired by Brian’s code for Teaser 3156. Can anyone see a way of compressing lines 18 & 22 into a single assignment statement?


# dictionary of possible solutions indexed by first and last digits of C°
CF = {}

# consider C° temperatures that convert to an integral F°, at least 2 digits
for c in range(10, 10000, 5):
  f = 32 + 9 * c // 5
  cs, fs = str(c), str(f)
  
##  if (all(a > b for a, b in zip(cs, cs[1:]))and # descending digits for C°
##      all(a < b for a, b in zip(fs, fs[1:]))): # ascending digits for F°
  
  # alternative formulation for descending / ascending digits check
  if (list(cs) == sorted(set(cs), reverse = 1) and
      list(fs) == sorted(set(fs))):
  
      # create dictionary entry indexed on first digit of C° if non existent
      # with nested dictionary indexed on last digit
      CF[cs[0]] = CF.get(cs[0], {cs[-1]: []})

      # add possible solution while adding dictionary entry indexed on last
      # digit of C° if that entry doesn't already exist
      CF[cs[0]][cs[-1]] = CF[cs[0]].get(cs[-1], []) + [(c, f)]

# there must be more than one possible solution for first digit
# but a single solution for only one first digit - last digit pair
sol = [y for x in CF.values() for y in x.values() if len(x) > 1 and len(y) == 1]

print (str(sol)[3:-3].replace(',', '°C,') + '°F')

# dictionary of possible solutions indexed by first and last digits of C°

CF = {}

# consider C° temperatures that convert to an integral F°, at least 2 digits

for c in range(10, 10000, 5):

f = 32 + 9 * c // 5

cs, fs = str(c), str(f)

## if (all(a > b for a, b in zip(cs, cs[1:]))and # descending digits for C°

## all(a < b for a, b in zip(fs, fs[1:]))): # ascending digits for F°

# alternative formulation for descending / ascending digits check

if (list(cs) == sorted(set(cs), reverse = 1) and

list(fs) == sorted(set(fs))):

# create dictionary entry indexed on first digit of C° if non existent

# with nested dictionary indexed on last digit

CF[cs[0]] = CF.get(cs[0], {cs[-1]: []})

# add possible solution while adding dictionary entry indexed on last

# digit of C° if that entry doesn't already exist

CF[cs[0]][cs[-1]] = CF[cs[0]].get(cs[-1], []) + [(c, f)]

# there must be more than one possible solution for first digit

# but a single solution for only one first digit - last digit pair

sol = [y for x in CF.values() for y in x.values() if len(x) > 1 and len(y) == 1]

print (str(sol)[3:-3].replace(',', '°C,') + '°F')

Sunday Times Teaser 3155 – Increasing temperature

by Victor Bryant

Published Sunday March 12 2023 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta