Sunday Times Teaser 3332 – As Easy As One, Two, Three

by BRG on 2 August 2026

by Colin Vout

Published Sunday August 02 2026 (link)

telladom shoodlat quoz veedku quoz means 87.
rimjy veedku rimjy ump telladom means 50.

Counting is quite easy in this traditional dialect. Words mean different positive whole numbers called “minor” or “major”. All minors have lower values than all majors. In the counting name for a number, two minors never occur in succession, and the majors occur in order of strictly decreasing value (so majors cannot be repeated). A minor followed by a major means the product of those two values (although 1 is never used as a minor here). The value of the whole expression is the sum of all products and all the other individual values. So an English-ish example, with all “majors” underlined, would be “thousand six ten six” for 1066.

What are the values of quoz, rimjy, shoodlat, telladom, ump, veedku (in that order)?

From → Uncategorized

4 Comments Leave one →

BRG permalink


# translate the two sums (where minor/major = lower/upper case)
# tSqVq = 87 ==> T.S + Q.(V + 1) == 87 ) and majors U < V < S 
# rVrUt = 50 ==>    R.(V + U) + T = 50 )     minors Q   R   T

# 2.(3 + 4) (min) + T (max) = 50 ==> T < 36
for T in range(2, 36):
  # S (max) <= (87 - 2.4) (max) / T (min) ==> S < 40
  for S in range(T + 1, 40):
    # r1 = Q.(V + 1) = 87 - T.S
    if (r1 := 87 - T * S) <= 0: 
      continue
    for V in range(3, S):
      # Q = (87 - T.S) / (V + 1)
      Q, r = divmod(r1, V + 1)
      if r or  Q < 2 or S <= V:
        continue
      # R = (50 - T) / (V + U)
      for U in range(2, V):
        R, r = divmod(50 - T, V + U)
        if r or R < 2:
          continue
        # check started symbol order and for six different values
        if max(Q, R, T) < U < V < S and len({Q, R, T, U, V, S}) == 6:
          print(f"{Q = }, {R = }, {S = }, {T = }, {U = }, {V = }.")

# translate the two sums (where minor/major = lower/upper case)

# tSqVq = 87 ==> T.S + Q.(V + 1) == 87 ) and majors U < V < S

# rVrUt = 50 ==> R.(V + U) + T = 50 ) minors Q R T

# 2.(3 + 4) (min) + T (max) = 50 ==> T < 36

for T in range(2, 36):

# S (max) <= (87 - 2.4) (max) / T (min) ==> S < 40

for S in range(T + 1, 40):

# r1 = Q.(V + 1) = 87 - T.S

if (r1 := 87 - T * S) <= 0:

continue

for V in range(3, S):

# Q = (87 - T.S) / (V + 1)

Q, r = divmod(r1, V + 1)

if r or Q < 2 or S <= V:

continue

# R = (50 - T) / (V + U)

for U in range(2, V):

R, r = divmod(50 - T, V + U)

if r or R < 2:

continue

# check started symbol order and for six different values

if max(Q, R, T) < U < V < S and len({Q, R, T, U, V, S}) == 6:

print(f"{Q = }, {R = }, {S = }, {T = }, {U = }, {V = }.")

Frits permalink

Now with a different understanding of “majors cannot be repeated”, assuming an upper limit of 20.


from itertools import product, permutations
# words and sums
ws = ["abcdc", "edefa"]
ss = [87, 50]

trans0 = lambda e, d, f, a, b, c: (a, b, c, d, c)
trans1 = lambda e, d, f, a: (e, d, e, f, a)

# evaluate the expression
def evaluate(ws, ts):
  t, p = 0, ws[0]
  for i, b in enumerate(ws[1:]):
    if ts[i:i + 2] == (0, 1):
      if ws[i] == 1: return 0
      p *= b
    else: 
      t += p
      p = b
  return t + p
 
# solve an equation
def solve(fn, tot, pa, pd, new, old="", mx_minor=0, mn_major=99, 
          t0=tuple(), w0=tuple()):
  # repeated characters in <new>        
  rep = {x for x in set(new) if new.count(x) > 1}        
  # number of unknown words
  ln = len(set(new + old)) - len(set(old))
  # for each type of the unknown word (minor/major = 0/1)
  for ts in product((0, 1), repeat=ln):
    ts5 = fn(*(t0 + ts))
    # majors cannot be repeated  
    if any(x and y in rep for x, y in zip(ts5, new)): continue
    
    # <a> and <d> can't be both majors as they occur in both equations in 
    # different order
    if ts5[pa] == ts5[pd] == 1: continue
    # two minors never occur in succession
    if (0, 0) in zip(ts5, ts5[1:]): continue
    
    # for all unknown different positive whole numbers
    for ws in permutations(set(range(1, 21)) - set(w0), ln):
      ws5 = fn(*(w0 + ws))
      majors = [a for a, b in zip(ws5, ts5) if b]
      #  majors occur in order of strictly decreasing value 
      if any(a <= b for a, b in zip(majors, majors[1:])): continue
      
      if majors[-1] <= mx_minor: continue
      
      minors = [w for w in ws5 if w not in majors]
      # all minors have lower values than all majors
      if max(minors) >= min(mn_major, majors[-1]): continue
      
      # evaluate the expression
      if evaluate(ws5, ts5) == tot:
        yield ts, ws, max(minors), min(majors)
  
# start with the lowest total, edefa
for ts1, ws1, mx_min1, mn_maj1 in solve(trans1, ss[1], -1, 1, ws[1]):
  # get values for abcdc
  for _, ws2, _, _ in solve(trans0, ss[0], 0, 3, ws[0], ws[1], 
                            mx_min1, mn_maj1, ts1, ws1):
    (e, d, f, a), (b, c) = ws1, ws2
    print("answer:", (c, e, b, a, f, d))

from itertools import product, permutations

# words and sums

ws = ["abcdc", "edefa"]

ss = [87, 50]

trans0 = lambda e, d, f, a, b, c: (a, b, c, d, c)

trans1 = lambda e, d, f, a: (e, d, e, f, a)

# evaluate the expression

def evaluate(ws, ts):

t, p = 0, ws[0]

for i, b in enumerate(ws[1:]):

if ts[i:i + 2] == (0, 1):

if ws[i] == 1: return 0

p *= b

else:

t += p

p = b

return t + p

# solve an equation

def solve(fn, tot, pa, pd, new, old="", mx_minor=0, mn_major=99,

t0=tuple(), w0=tuple()):

# repeated characters in <new>

rep = {x for x in set(new) if new.count(x) > 1}

# number of unknown words

ln = len(set(new + old)) - len(set(old))

# for each type of the unknown word (minor/major = 0/1)

for ts in product((0, 1), repeat=ln):

ts5 = fn(*(t0 + ts))

# majors cannot be repeated

if any(x and y in rep for x, y in zip(ts5, new)): continue

# <a> and <d> can't be both majors as they occur in both equations in

# different order

if ts5[pa] == ts5[pd] == 1: continue

# two minors never occur in succession

if (0, 0) in zip(ts5, ts5[1:]): continue

# for all unknown different positive whole numbers

for ws in permutations(set(range(1, 21)) - set(w0), ln):

ws5 = fn(*(w0 + ws))

majors = [a for a, b in zip(ws5, ts5) if b]

# majors occur in order of strictly decreasing value

if any(a <= b for a, b in zip(majors, majors[1:])): continue

if majors[-1] <= mx_minor: continue

minors = [w for w in ws5 if w not in majors]

# all minors have lower values than all majors

if max(minors) >= min(mn_major, majors[-1]): continue

# evaluate the expression

if evaluate(ws5, ts5) == tot:

yield ts, ws, max(minors), min(majors)

# start with the lowest total, edefa

for ts1, ws1, mx_min1, mn_maj1 in solve(trans1, ss[1], -1, 1, ws[1]):

# get values for abcdc

for _, ws2, _, _ in solve(trans0, ss[0], 0, 3, ws[0], ws[1],

mx_min1, mn_maj1, ts1, ws1):

(e, d, f, a), (b, c) = ws1, ws2

print("answer:", (c, e, b, a, f, d))

Frits permalink

Without assumptions on upper limits.


from itertools import combinations

# edefa -> mMmMa, (d + f).e + a = 50, e > 1 and a < f
# abcdc -> aMmMm, a * b + (d + 1).c = 87 (as a < f so also a < b), c > 1

# b = (87 - (d + 1).c) / a,  b <= (87 - (6 + 1).3) / 2 <= 33 

# M = {b, d, f}, m = {a, c, e} 

# select the two smallest majors (d + f <= 25 - a / 2)
for f, d in combinations(range(5, 19), 2):
  # edefa = mMmMm
  for e in range(2, f):
    a = 50 - (d + f) * e
    if a < 2: break
    if a in {d, f, e} or a >= f: continue
    # select highest major
    for b in range(d + 1, 34): 
      c, r = divmod(87 - a * b, d + 1) 
      if c < 2: break
      if r or c >= f: continue

      if c in {a, b, d, f, e}: continue
      print("answer:", (c, e, b, a, f, d))

from itertools import combinations

# edefa -> mMmMa, (d + f).e + a = 50, e > 1 and a < f

# abcdc -> aMmMm, a * b + (d + 1).c = 87 (as a < f so also a < b), c > 1

# b = (87 - (d + 1).c) / a, b <= (87 - (6 + 1).3) / 2 <= 33

# M = {b, d, f}, m = {a, c, e}

# select the two smallest majors (d + f <= 25 - a / 2)

for f, d in combinations(range(5, 19), 2):

# edefa = mMmMm

for e in range(2, f):

a = 50 - (d + f) * e

if a < 2: break

if a in {d, f, e} or a >= f: continue

# select highest major

for b in range(d + 1, 34):

c, r = divmod(87 - a * b, d + 1)

if c < 2: break

if r or c >= f: continue

if c in {a, b, d, f, e}: continue

print("answer:", (c, e, b, a, f, d))

BRG permalink

Or even 🙂


from itertools import combinations

# RVRUT -> mMmMm, (V + U).R + T   = 50
# TSQVQ -> mMmMm, T.S + (V + 1).Q = 87

for U, V in combinations(range(5, 19), 2):
  for R in range(2, U):
    T = 50 - (V + U) * R
    if T < 2:
      break
    if T in {V, U, R} or T >= U:
      continue
    for S in range(V + 1, 34): 
      Q, r = divmod(87 - T * S, V + 1) 
      if Q < 2:
        break
      if r or Q >= U:
        continue
      if Q in {T, S, V, U, R}:
        continue
      print(f"{Q = }, {R = }, {S = }, {T = }, {U = }, {V = }.")

from itertools import combinations

# RVRUT -> mMmMm, (V + U).R + T = 50

# TSQVQ -> mMmMm, T.S + (V + 1).Q = 87

for U, V in combinations(range(5, 19), 2):

for R in range(2, U):

T = 50 - (V + U) * R

if T < 2:

break

if T in {V, U, R} or T >= U:

continue

for S in range(V + 1, 34):

Q, r = divmod(87 - T * S, V + 1)

if Q < 2:

break

if r or Q >= U:

continue

if Q in {T, S, V, U, R}:

continue

print(f"{Q = }, {R = }, {S = }, {T = }, {U = }, {V = }.")

Mine is a variation of this.

Sunday Times Teaser 3332 – As Easy As One, Two, Three

by Colin Vout

Published Sunday August 02 2026 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta