Sunday Times Teaser 3282 – Not Necessarily in the Right Order


from itertools import permutations

# the given chords
chords = list("QPWR WVQO RXQS VYRO STUP UVYW".split())

# check a sequence of notes
def check_notes(ns):
  ns = sorted(ns)
  # calculate the note intervals
  ivs = tuple((y - x) % 12 for (x, y) in zip(ns, ns[1:] + [ns[0]]))
  # there are no unit intervals
  if not 1 in ivs:
    # the intervals must form a non-increasing sequence
    for rs in (ivs[i:] + ivs[:i] for i in range(4)):
      if rs[0] >= rs[1] >= rs[2] >= rs[3]:
        return [rs]
  return []

# consider the possible sequences of 10 notes fron eleven
for p10 in permutations(range(1, 12), 10):
  # map letters to the notes
  l2n = dict(zip('OPQRSTUVWXY', (0,) + p10))
  # and check that the given chords meet the teaser constraints
  for c in chords:
    ns = (l2n[l] for l in c)
    if not check_notes(ns):
      break
  else:
    # now check that all chords have the same note intervals
    ds = list(set(check_notes(l2n[x] for x in chd)) for chd in chords)
    ids = ds[0]
    for d in ds[1:]:
      ids &= d
    if ids:
      # find the value for Z
      l2n['Z'] = set(range(12)).difference(l2n.values()).pop()
      notes = ''.join(l for l, v in sorted(l2n.items(), key=lambda x: x[1]))
      print(f"Notes (1..12): {notes} -> {ids.pop()}")
      break

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

from itertools import permutations

# the given chords

chords = list("QPWR WVQO RXQS VYRO STUP UVYW".split())

# check a sequence of notes

def check_notes(ns):

ns = sorted(ns)

# calculate the note intervals

ivs = tuple((y - x) % 12 for (x, y) in zip(ns, ns[1:] + [ns[0]]))

# there are no unit intervals

if not 1 in ivs:

# the intervals must form a non-increasing sequence

for rs in (ivs[i:] + ivs[:i] for i in range(4)):

if rs[0] >= rs[1] >= rs[2] >= rs[3]:

return [rs]

return []

# consider the possible sequences of 10 notes fron eleven

for p10 in permutations(range(1, 12), 10):

# map letters to the notes

l2n = dict(zip('OPQRSTUVWXY', (0,) + p10))

# and check that the given chords meet the teaser constraints

for c in chords:

ns = (l2n[l] for l in c)

if not check_notes(ns):

break

else:

# now check that all chords have the same note intervals

ds = list(set(check_notes(l2n[x] for x in chd)) for chd in chords)

ids = ds[0]

for d in ds[1:]:

ids &= d

if ids:

# find the value for Z

l2n['Z'] = set(range(12)).difference(l2n.values()).pop()

notes = ''.join(l for l, v in sorted(l2n.items(), key=lambda x: x[1]))

print(f"Notes (1..12): {notes} -> {ids.pop()}")

break

Reply

Frits permalink

A difficult teaser for me (to get a fast version that covers the full solution space).


from itertools import combinations, permutations
 
# chords to check
chords = ["QPWR", "WVQO", "RXQS", "VYRO", "STUP", "UVYW"]
rng = set(range(12))
 
# check a sequence of values
def check(s):
  diffs = list((y - x) % 12 for (x, y) in zip(s, s[1:] + [s[0]]))
  if 1 in diffs: return
  # get highest up front (credit B. Gladman)
  ix = diffs.index(max(diffs))
  ss = tuple(diffs[ix:] + diffs[:ix])
  return [ss] if ss[0] >= ss[1] >= ss[2] >= ss[3] else []  
  
# assign new values to unknown notes
def assign(cord, d=dict):
  # count unknown variables 
  if (ln := sum(c not in d for c in cord)):
    # generate new values (order doesn't matter)
    for cmb in combinations(rng.difference(d.values()), ln):
      it = iter(cmb)
      yield [d[c] if c in d else next(it) for c in cord]  
  else:
    # all notes are known
    yield [d[c] for c in cord]
 
# add chords 
def solve(k, chords, d=dict(), same_iv=set(), ss=[]):
  if k == 0:
    yield d
  else:
    # check if we have already processed these 11 values (except Z)
    if len(d) == 11:
      if (tp := tuple(d.values())) in seen: return
      seen.add(tp)
    chord = chords[0]
    # assign new values to unknown notes for this chord
    for a in assign(chord, d):
      # check for valid values and for same interval
      if (ch := check(sorted(a))) and (not same_iv or ch == same_iv):
        # build new dictionary d_
        d_ = dict(d)
        ks = [x for x in chord if x not in d]
        vs = list(set(a) - set(d.values()))
        # permute the new notes
        for p in permutations(ks):
          for x, y in zip(p, vs):
            d_[x] = y
          yield from solve(k - 1, chords[1:], d_, ch, ss + [a])
 
seen = set()
# solve the teaser
for d in solve(len(chords), chords, {"O": 0}):
  d["Z"] = rng.difference(d.values()).pop()
  print("answer:", 
        ''.join(k for k, _ in sorted(d.items(), key=lambda x: x[1])))

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

from itertools import combinations, permutations

# chords to check

chords = ["QPWR", "WVQO", "RXQS", "VYRO", "STUP", "UVYW"]

rng = set(range(12))

# check a sequence of values

def check(s):

diffs = list((y - x) % 12 for (x, y) in zip(s, s[1:] + [s[0]]))

if 1 in diffs: return

# get highest up front (credit B. Gladman)

ix = diffs.index(max(diffs))

ss = tuple(diffs[ix:] + diffs[:ix])

return [ss] if ss[0] >= ss[1] >= ss[2] >= ss[3] else []

# assign new values to unknown notes

def assign(cord, d=dict):

# count unknown variables

if (ln := sum(c not in d for c in cord)):

# generate new values (order doesn't matter)

for cmb in combinations(rng.difference(d.values()), ln):

it = iter(cmb)

yield [d[c] if c in d else next(it) for c in cord]

else:

# all notes are known

yield [d[c] for c in cord]

# add chords

def solve(k, chords, d=dict(), same_iv=set(), ss=[]):

if k == 0:

yield d

else:

# check if we have already processed these 11 values (except Z)

if len(d) == 11:

if (tp := tuple(d.values())) in seen: return

seen.add(tp)

chord = chords[0]

# assign new values to unknown notes for this chord

for a in assign(chord, d):

# check for valid values and for same interval

if (ch := check(sorted(a))) and (not same_iv or ch == same_iv):

# build new dictionary d_

d_ = dict(d)

ks = [x for x in chord if x not in d]

vs = list(set(a) - set(d.values()))

# permute the new notes

for p in permutations(ks):

for x, y in zip(p, vs):

d_[x] = y

yield from solve(k - 1, chords[1:], d_, ch, ss + [a])

seen = set()

# solve the teaser

for d in solve(len(chords), chords, {"O": 0}):

d["Z"] = rng.difference(d.values()).pop()

print("answer:",

''.join(k for k, _ in sorted(d.items(), key=lambda x: x[1])))

Reply

BRG permalink

Great Work Frits! I also thought it would be quite hard work so I decided to get the solution by brute force in order to understand what was going on before thinking about possible ways of speeding it up.

I am still not sure I really understand it yet as I don’t really like these music based teasers since I am not familiar with musical notation.

Reply

Frits permalink


from itertools import combinations, permutations
from functools import cache 

# chords to check
chords = ["QPWR", "WVQO", "RXQS", "VYRO", "STUP", "UVYW"]
rng = set(range(12))

# check a sequence of values
@cache
def check(s):
  s = sorted(s)
  diffs = list((y - x) % 12 for (x, y) in zip(s, s[1:] + [s[0]]))
  if 1 in diffs: return
  # get highest up front (credit B. Gladman)
  ix = diffs.index(max(diffs))
  ss = tuple(diffs[ix:] + diffs[:ix])
  return [ss] if ss[0] >= ss[1] >= ss[2] >= ss[3] else []  
  
# determine new values for unknown notes
def get_new_values(cord, d=dict):
  known = tuple(d[c] for c in cord if c in d)
  # generate new values (order doesn't matter)
  for cmb in combinations(rng.difference(d.values()), 4 - len(known)):
    yield known, cmb

# add chords 
def solve(k, chords, d=dict(), same_iv=set()):
  if k == 0:
    yield d
  else:
    # check if we have already processed these 11 values (except Z)
    if len(d) == 11:
      if (tp := tuple(d.values())) in seen: return
      seen.add(tp)
    chord = chords[0]
    # determine new values for unknown notes for this chord
    for old, new in get_new_values(chord, d):
      # check for valid values and for same interval
      if ((ch := check(tuple(sorted(old + new)))) and 
          (not same_iv or ch == same_iv)):
        # build new dictionary d_
        d_ = dict(d)
        ks = [x for x in chord if x not in d]
        # permute the new notes
        for p in permutations(ks):
          for x, y in zip(p, new):
            d_[x] = y
          yield from solve(k - 1, chords[1:], d_, ch)

seen = set()
# solve the teaser
for d in solve(len(chords), chords, {"O": 0}):
  d["Z"] = rng.difference(d.values()).pop()
  print("answer:", 
        ''.join(k for k, _ in sorted(d.items(), key=lambda x: x[1])))

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

from itertools import combinations, permutations

from functools import cache

# chords to check

chords = ["QPWR", "WVQO", "RXQS", "VYRO", "STUP", "UVYW"]

rng = set(range(12))

# check a sequence of values

@cache

def check(s):

s = sorted(s)

diffs = list((y - x) % 12 for (x, y) in zip(s, s[1:] + [s[0]]))

if 1 in diffs: return

# get highest up front (credit B. Gladman)

ix = diffs.index(max(diffs))

ss = tuple(diffs[ix:] + diffs[:ix])

return [ss] if ss[0] >= ss[1] >= ss[2] >= ss[3] else []

# determine new values for unknown notes

def get_new_values(cord, d=dict):

known = tuple(d[c] for c in cord if c in d)

# generate new values (order doesn't matter)

for cmb in combinations(rng.difference(d.values()), 4 - len(known)):

yield known, cmb

# add chords

def solve(k, chords, d=dict(), same_iv=set()):

if k == 0:

yield d

else:

# check if we have already processed these 11 values (except Z)

if len(d) == 11:

if (tp := tuple(d.values())) in seen: return

seen.add(tp)

chord = chords[0]

# determine new values for unknown notes for this chord

for old, new in get_new_values(chord, d):

# check for valid values and for same interval

if ((ch := check(tuple(sorted(old + new)))) and

(not same_iv or ch == same_iv)):

# build new dictionary d_

d_ = dict(d)

ks = [x for x in chord if x not in d]

# permute the new notes

for p in permutations(ks):

for x, y in zip(p, new):

d_[x] = y

yield from solve(k - 1, chords[1:], d_, ch)

seen = set()

# solve the teaser

for d in solve(len(chords), chords, {"O": 0}):

d["Z"] = rng.difference(d.values()).pop()

print("answer:",

''.join(k for k, _ in sorted(d.items(), key=lambda x: x[1])))

Reply

BRG permalink

A faster version than my original using a simplified version of Frits’ approach


from itertools import combinations, permutations

# the given chords (chords with O first and Z not used)
chords = list("WVQO VYRO QPWR RXQS STUP UVYW".split())

# check a sequence of notes
def check_notes(ns):
  ns = sorted(ns)
  # calculate the note intervals
  ivs = tuple((y - x) % 12 for (x, y) in zip(ns, ns[1:] + [ns[0]]))
  # there are no unit intervals
  if not 1 in ivs:
    # the intervals must form a non-increasing sequence
    for rs in (ivs[i:] + ivs[:i] for i in range(4)):
      if rs[0] >= rs[1] >= rs[2] >= rs[3]:
        return rs

# solve for the letters to notes map in <l2n> (credit: Frits)
def solve(chords, notes, l2n=dict(), same_iv=()):
  if not chords:
    # add unused note
    l2n['Z'] = notes.pop()
    yield l2n, same_iv
  else:
    chord = set(chords[0])
    # find the known notes for this chord
    known = tuple(l2n[c] for c in chord.intersection(l2n))
    # and find possible values for the remaining letters
    for new in combinations(notes.difference(l2n.values()), 4 - len(known)):
      # check for valid notes and for the same interval pattern
      if ((ch := check_notes(known + new)) and (not same_iv or ch == same_iv)):
        # consider all mappings for the new notes
        for p in permutations(chord.difference(l2n)):
          l2n_ = l2n | dict(zip(p, new))
          yield from solve(chords[1:], notes.difference(new), l2n_, ch)

# solve the teaser
for l2n, pat in solve(chords, set(range(1, 12)), {"O": 0}):
  notes = ''.join(l for l, v in sorted(l2n.items(), key=lambda x: x[1]))
  print(f"Notes (1..12): {notes} -> {pat}")

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

from itertools import combinations, permutations

# the given chords (chords with O first and Z not used)

chords = list("WVQO VYRO QPWR RXQS STUP UVYW".split())

# check a sequence of notes

def check_notes(ns):

ns = sorted(ns)

# calculate the note intervals

ivs = tuple((y - x) % 12 for (x, y) in zip(ns, ns[1:] + [ns[0]]))

# there are no unit intervals

if not 1 in ivs:

# the intervals must form a non-increasing sequence

for rs in (ivs[i:] + ivs[:i] for i in range(4)):

if rs[0] >= rs[1] >= rs[2] >= rs[3]:

return rs

# solve for the letters to notes map in <l2n> (credit: Frits)

def solve(chords, notes, l2n=dict(), same_iv=()):

if not chords:

# add unused note

l2n['Z'] = notes.pop()

yield l2n, same_iv

else:

chord = set(chords[0])

# find the known notes for this chord

known = tuple(l2n[c] for c in chord.intersection(l2n))

# and find possible values for the remaining letters

for new in combinations(notes.difference(l2n.values()), 4 - len(known)):

# check for valid notes and for the same interval pattern

if ((ch := check_notes(known + new)) and (not same_iv or ch == same_iv)):

# consider all mappings for the new notes

for p in permutations(chord.difference(l2n)):

l2n_ = l2n | dict(zip(p, new))

yield from solve(chords[1:], notes.difference(new), l2n_, ch)

# solve the teaser

for l2n, pat in solve(chords, set(range(1, 12)), {"O": 0}):

notes = ''.join(l for l, v in sorted(l2n.items(), key=lambda x: x[1]))

print(f"Notes (1..12): {notes} -> {pat}")

Reply

Frits permalink

No recursion.


from itertools import combinations, permutations

# chords to check (start with the ones with "O")
chords = ["WVQO", "VYRO", "QPWR", "UVYW", "RXQS", "STUP"]
rng = set(range(12))

# check a sequence of values
def check(s):
  s = sorted(s)
  diffs = list((y - x) % 12 for (x, y) in zip(s, s[1:] + [s[0]]))
  if 1 in diffs: return
  # get highest up front (credit B. Gladman)
  ix = diffs.index(max(diffs))
  ss = tuple(diffs[ix:] + diffs[:ix])
  return [ss] if ss[1] >= ss[2] >= ss[3] else []   
  
# determine new values for unknown notes
def get_new_values(chord, d=dict, iv=0):
  known = tuple(d[c] for c in chord if c in d)
  # generate new values (order doesn't matter)
  for cmb in combinations(rng.difference(d.values()), 4 - len(known)):
    if (new_iv := check(known + cmb)) and (not iv or new_iv == iv):
      # permute the new notes
      for p in permutations(cmb):
        it = iter(p)
        yield ([d[c] if c in d else next(it) for c in chord], new_iv)

d0 = {"O": 0}
for vals, iv in get_new_values(chords[0], d0):
  d1 = d0 | dict(zip(chords[0], vals))
  for vals, _ in get_new_values(chords[1], d1, iv):
    d2 = d1 | dict(zip(chords[1], vals))
    for vals, _ in get_new_values(chords[2], d2, iv):
      d3 = d2 | dict(zip(chords[2], vals))
      for vals, _ in get_new_values(chords[3], d3, iv):
        d4 = d3 | dict(zip(chords[3], vals))
        for vals, _ in get_new_values(chords[4], d4, iv):
          d5 = d4 | dict(zip(chords[4], vals))
          for vals, _ in get_new_values(chords[5], d5, iv):
            d6 = d5 | dict(zip(chords[5], vals))
            d6["Z"] = rng.difference(d6.values()).pop()
            #print(d1)
            #print(" ", d2)
            #print("   ", d3)
            #print("     ", d4)
            #print("       ", d5)
            #print("         ", d6)
            print("answer:", 
             ''.join(k for k, _ in sorted(d6.items(), key=lambda x: x[1])))

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

from itertools import combinations, permutations

# chords to check (start with the ones with "O")

chords = ["WVQO", "VYRO", "QPWR", "UVYW", "RXQS", "STUP"]

rng = set(range(12))

# check a sequence of values

def check(s):

s = sorted(s)

diffs = list((y - x) % 12 for (x, y) in zip(s, s[1:] + [s[0]]))

if 1 in diffs: return

# get highest up front (credit B. Gladman)

ix = diffs.index(max(diffs))

ss = tuple(diffs[ix:] + diffs[:ix])

return [ss] if ss[1] >= ss[2] >= ss[3] else []

# determine new values for unknown notes

def get_new_values(chord, d=dict, iv=0):

known = tuple(d[c] for c in chord if c in d)

# generate new values (order doesn't matter)

for cmb in combinations(rng.difference(d.values()), 4 - len(known)):

if (new_iv := check(known + cmb)) and (not iv or new_iv == iv):

# permute the new notes

for p in permutations(cmb):

it = iter(p)

yield ([d[c] if c in d else next(it) for c in chord], new_iv)

d0 = {"O": 0}

for vals, iv in get_new_values(chords[0], d0):

d1 = d0 | dict(zip(chords[0], vals))

for vals, _ in get_new_values(chords[1], d1, iv):

d2 = d1 | dict(zip(chords[1], vals))

for vals, _ in get_new_values(chords[2], d2, iv):

d3 = d2 | dict(zip(chords[2], vals))

for vals, _ in get_new_values(chords[3], d3, iv):

d4 = d3 | dict(zip(chords[3], vals))

for vals, _ in get_new_values(chords[4], d4, iv):

d5 = d4 | dict(zip(chords[4], vals))

for vals, _ in get_new_values(chords[5], d5, iv):

d6 = d5 | dict(zip(chords[5], vals))

d6["Z"] = rng.difference(d6.values()).pop()

#print(d1)

#print(" ", d2)

#print(" ", d3)

#print(" ", d4)

#print(" ", d5)

#print(" ", d6)

print("answer:",

''.join(k for k, _ in sorted(d6.items(), key=lambda x: x[1])))

Reply

Frits permalink

Most efficient so far.


from itertools import combinations, permutations
from collections import defaultdict

# chords to check (start with the ones with "O")
chords = ["WVQO", "VYRO", "QPWR", "UVYW", "RXQS", "STUP"]
rng = set(range(12))
 
# check a sequence of values
def check(s):
  diffs = list((y - x) % 12 for (x, y) in zip(s, s[1:] + (s[0], )))
  if 1 in diffs: return
  # get highest up front (credit B. Gladman)
  ix = diffs.index(max(diffs))
  ss = tuple(diffs[ix:] + diffs[:ix])
  return ss if ss[1] >= ss[2] >= ss[3] else tuple()
 
# determine new values for unknown notes
def get_new_values(chord, d, d_iv, iv=[]):
  known = {d[c] for c in chord if c in d}
  # generate new values (order doesn't matter)
  if iv:
    sel = [(new, iv) for s in d_iv[iv] if all(k in s for k in known) and
           (new := s - known).isdisjoint(d.values())]
  else:     
    sel = [(new, ival) for s, ival in ok if all(k in s for k in known) and
          (new := s - known).isdisjoint(d.values())]
  
  for s, iv in sel:
    # permute the new notes
    for p in permutations(s):
      it = iter(p)
      yield ([d[c] if c in d else next(it) for c in chord], iv)
 
# build a list of valid chord notes and a dictionary of chord notes
# per interval
ok, d_iv = list(), defaultdict(list)
for p in combinations(rng, 4):
  if (iv := check(p)):
    ok.append((set(p), iv))
    d_iv[iv] += [set(p)]
 
d0 = {"O": 0}
for vals, iv in get_new_values(chords[0], d0, d_iv):
  d1 = d0 | dict(zip(chords[0], vals))
  for vals, _ in get_new_values(chords[1], d1, d_iv, iv):
    d2 = d1 | dict(zip(chords[1], vals))
    for vals, _ in get_new_values(chords[2], d2, d_iv, iv):
      d3 = d2 | dict(zip(chords[2], vals))
      for vals, _ in get_new_values(chords[3], d3, d_iv, iv):
        d4 = d3 | dict(zip(chords[3], vals))
        for vals, _ in get_new_values(chords[4], d4, d_iv, iv):
          d5 = d4 | dict(zip(chords[4], vals))
          for vals, _ in get_new_values(chords[5], d5, d_iv, iv):
            d6 = d5 | dict(zip(chords[5], vals))
            d6["Z"] = rng.difference(d6.values()).pop()
            print("answer:", 
             ''.join(k for k, _ in sorted(d6.items(), key=lambda x: x[1])))

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

from itertools import combinations, permutations

from collections import defaultdict

# chords to check (start with the ones with "O")

chords = ["WVQO", "VYRO", "QPWR", "UVYW", "RXQS", "STUP"]

rng = set(range(12))

# check a sequence of values

def check(s):

diffs = list((y - x) % 12 for (x, y) in zip(s, s[1:] + (s[0], )))

if 1 in diffs: return

# get highest up front (credit B. Gladman)

ix = diffs.index(max(diffs))

ss = tuple(diffs[ix:] + diffs[:ix])

return ss if ss[1] >= ss[2] >= ss[3] else tuple()

# determine new values for unknown notes

def get_new_values(chord, d, d_iv, iv=[]):

known = {d[c] for c in chord if c in d}

# generate new values (order doesn't matter)

if iv:

sel = [(new, iv) for s in d_iv[iv] if all(k in s for k in known) and

(new := s - known).isdisjoint(d.values())]

else:

sel = [(new, ival) for s, ival in ok if all(k in s for k in known) and

(new := s - known).isdisjoint(d.values())]

for s, iv in sel:

# permute the new notes

for p in permutations(s):

it = iter(p)

yield ([d[c] if c in d else next(it) for c in chord], iv)

# build a list of valid chord notes and a dictionary of chord notes

# per interval

ok, d_iv = list(), defaultdict(list)

for p in combinations(rng, 4):

if (iv := check(p)):

ok.append((set(p), iv))

d_iv[iv] += [set(p)]

d0 = {"O": 0}

for vals, iv in get_new_values(chords[0], d0, d_iv):

d1 = d0 | dict(zip(chords[0], vals))

for vals, _ in get_new_values(chords[1], d1, d_iv, iv):

d2 = d1 | dict(zip(chords[1], vals))

for vals, _ in get_new_values(chords[2], d2, d_iv, iv):

d3 = d2 | dict(zip(chords[2], vals))

for vals, _ in get_new_values(chords[3], d3, d_iv, iv):

d4 = d3 | dict(zip(chords[3], vals))

for vals, _ in get_new_values(chords[4], d4, d_iv, iv):

d5 = d4 | dict(zip(chords[4], vals))

for vals, _ in get_new_values(chords[5], d5, d_iv, iv):

d6 = d5 | dict(zip(chords[5], vals))

d6["Z"] = rng.difference(d6.values()).pop()

print("answer:",

''.join(k for k, _ in sorted(d6.items(), key=lambda x: x[1])))

Reply

Frits permalink

The previous functions “check” were incorrect (fi invalidating (0, 4, 6, 8)).
This fix solves that:


rotations = lambda ivs: tuple((ivs * 2)[i:i + 4] for i in range(4))

# check a sequence of notes
def check(s):
  ivs = tuple((y - x) % 12 for (x, y) in zip(s, s[1:] + (s[0], )))
  # the intervals all exceeded 1 ...
  if 1 in ivs: return
  # ... and never increased
  for r in rotations(ivs):
    if all(r[i] >= r[i + 1] for i in range(3)):
      return r
  return

1

2

3

4

5

6

7

8

9

10

11

12

13

14

rotations = lambda ivs: tuple((ivs * 2)[i:i + 4] for i in range(4))

# check a sequence of notes

def check(s):

ivs = tuple((y - x) % 12 for (x, y) in zip(s, s[1:] + (s[0], )))

# the intervals all exceeded 1 ...

if 1 in ivs: return

# ... and never increased

for r in rotations(ivs):

if all(r[i] >= r[i + 1] for i in range(3)):

return r

return

Here is a faster version without check().


from itertools import  permutations
 
rng = set(range(12))
 
# build a dictionary of valid chord notes per interval
d_iv = dict()
for a in range(3, 7):
  # using: ceil(p, q) = (p+q-1) // q
  for b in range((14 - a) // 3, min(a, 8 - a) + 1):
    for c in range((13 - a - b) // 2, min(b, 10 - a - b) + 1):
      iv = (a, b, c, 12 - a - b - c) # sum(intervals) = 12 
      d_iv[iv] = set(tuple(sorted((i + sum(iv[:j])) % 12 for j in range(1, 5))) 
                     for i in range(12))
 
# uses sets for the intervals
d_iv = {k: [set(v) for v in vs] for k, vs in d_iv.items()}
 
# chords order: ["WVQO", "VYRO", "UVYW", "QPWR", "RXQS", "STUP"]
O = 0    # "starting from O"
for iv, vs in d_iv.items():
  # get first 2 chords 
  for WVQO, VYRO in permutations([x for x in vs if O in x], 2):
    if len(VO := WVQO & VYRO) != 2: continue
    V = (VO - {O}).pop()
    WQ = WVQO - VO
    # get third chord 
    for UVWY in [x for x in vs if O not in x and V in x]:
      if len(VW := WVQO & UVWY) != 2: continue
      if (W := (VW - {V}).pop()) not in WQ: continue
      Q = (WQ - {W}).pop()
      # get fourth chord 
      for QPWR in [x for x in vs if {O, V}.isdisjoint(x) and 
                   all(y in x for y in WQ)]:
        if len(R := VYRO & QPWR) != 1: continue
        R = R.pop()
        Y = (VYRO - {V, R, O}).pop()
        U = (UVWY - {Y, V, W}).pop()
        P = (QPWR - {Q, W, R}).pop()
        # get fifth chord 
        for RXQS in [x for x in vs if {O, V, W, Y, U, P}.isdisjoint(x) and
                    all(y in x for y in [R, Q])]:
          XS = RXQS - {R, Q}
          # get last chord 
          for STUP in [x for x in vs if {O, V, Q, W, R, Y}.isdisjoint(x) and 
                      all(y in x for y in [U, P])]:
            if len(S := RXQS & STUP) != 1: continue
            S = S.pop()
            X = (XS - {S}).pop()
            T = (STUP - {S, U, P}).pop()
            vs11 = [O, V, Q, W, R, Y, U, P, S, X, T]
            if len(set(vs11)) != 11: continue
            Z = (rng - set(vs11)).pop()
            print("answer:",
                ''.join(x[1] for x in sorted(zip(vs11 + [Z], "OVQWRYUPSXTZ"))))

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

from itertools import permutations

rng = set(range(12))

# build a dictionary of valid chord notes per interval

d_iv = dict()

for a in range(3, 7):

# using: ceil(p, q) = (p+q-1) // q

for b in range((14 - a) // 3, min(a, 8 - a) + 1):

for c in range((13 - a - b) // 2, min(b, 10 - a - b) + 1):

iv = (a, b, c, 12 - a - b - c) # sum(intervals) = 12

d_iv[iv] = set(tuple(sorted((i + sum(iv[:j])) % 12 for j in range(1, 5)))

for i in range(12))

# uses sets for the intervals

d_iv = {k: [set(v) for v in vs] for k, vs in d_iv.items()}

# chords order: ["WVQO", "VYRO", "UVYW", "QPWR", "RXQS", "STUP"]

O = 0 # "starting from O"

for iv, vs in d_iv.items():

# get first 2 chords

for WVQO, VYRO in permutations([x for x in vs if O in x], 2):

if len(VO := WVQO & VYRO) != 2: continue

V = (VO - {O}).pop()

WQ = WVQO - VO

# get third chord

for UVWY in [x for x in vs if O not in x and V in x]:

if len(VW := WVQO & UVWY) != 2: continue

if (W := (VW - {V}).pop()) not in WQ: continue

Q = (WQ - {W}).pop()

# get fourth chord

for QPWR in [x for x in vs if {O, V}.isdisjoint(x) and

all(y in x for y in WQ)]:

if len(R := VYRO & QPWR) != 1: continue

R = R.pop()

Y = (VYRO - {V, R, O}).pop()

U = (UVWY - {Y, V, W}).pop()

P = (QPWR - {Q, W, R}).pop()

# get fifth chord

for RXQS in [x for x in vs if {O, V, W, Y, U, P}.isdisjoint(x) and

all(y in x for y in [R, Q])]:

XS = RXQS - {R, Q}

# get last chord

for STUP in [x for x in vs if {O, V, Q, W, R, Y}.isdisjoint(x) and

all(y in x for y in [U, P])]:

if len(S := RXQS & STUP) != 1: continue

S = S.pop()

X = (XS - {S}).pop()

T = (STUP - {S, U, P}).pop()

vs11 = [O, V, Q, W, R, Y, U, P, S, X, T]

if len(set(vs11)) != 11: continue

Z = (rng - set(vs11)).pop()

print("answer:",

''.join(x[1] for x in sorted(zip(vs11 + [Z], "OVQWRYUPSXTZ"))))

Reply

John Z permalink


'''
This is the only way the notes of the chords can be played if the interval
between the first and second notes is 5. But only VYRO has exactly one note
in the second, higher octave and STUP has no notes in the second octave.
(The teaser states: "and finishing with the addition of a note an octave above
 the lowest.") All the others have two or three notes in the second octave.
 The intervals are (5, 3, 2) not (5, 3, 2, 2) unless one considers that the
 first note should appear twice. 

     -----------1-----------|-----------2-----------
     O P Y Q Z W S V X U R T O P Y Q Z W S V X U R T

WVQO               V         O     Q   W 
           
VYRO     Y         V     R   O
                      
QPWR           W         R     P   Q
  
RXQS                     R         Q     S   X
    
STUP   P         S     U   T

UVYW                   U         Y     W   V
'''

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

'''

This is the only way the notes of the chords can be played if the interval

between the first and second notes is 5. But only VYRO has exactly one note

in the second, higher octave and STUP has no notes in the second octave.

(The teaser states: "and finishing with the addition of a note an octave above

the lowest.") All the others have two or three notes in the second octave.

The intervals are (5, 3, 2) not (5, 3, 2, 2) unless one considers that the

first note should appear twice.

-----------1-----------|-----------2-----------

O P Y Q Z W S V X U R T O P Y Q Z W S V X U R T

WVQO V O Q W

VYRO Y V R O

QPWR W R P Q

RXQS R Q S X

STUP P S U T

UVYW U Y W V

'''

Reply

John Z permalink

Here is a simplification of Brian’s simplification of Frits’ excellent solution, also incorporating Brian’s new note check function


from itertools import combinations, permutations

# constant used later for the 11 unfilled scale positions
sr12 = set(range(1, 12))

# the given chords ( chords with O first)
chords = list("WVQO VYRO QPWR RXQS STUP UVYW".split())

# check a sequence of notes
def check_notes(ns):
  ns = sorted(ns)
  # calculate the note intervals
  ivs = tuple((y - x) % 12 for (x, y) in zip(ns, ns[1:] + [ns[0]]))
  # there are no unit intervals
  if not 1 in ivs:
    # the intervals must form a non-increasing sequence
    for rs in (ivs[i:] + ivs[:i] for i in range(4)):
      if rs[0] >= rs[1] >= rs[2] >= rs[3]:
        return [rs]
  return []

# solve for the letters to notes map (credit: Frits)
def solve(chords, l2n, same_iv = []):
  if not chords:
    yield l2n, same_iv
  else:
    chord = chords[0]
    # find positions of the known notes for this chord, if any
    known = tuple(l2n[c] for c in chord if c in l2n)
    
    # and find possible scale positions for the remaining letters
    for new in combinations(sr12 - set(l2n.values()), 4 - len(known)):
      # check for valid notes and for the same interval pattern
      if ((ch := check_notes(known + new)) and (not same_iv or ch == same_iv)):
        
        # consider all mappings for the new notes
        ks = [x for x in chord if x not in l2n]
        for p in permutations(ks):

          yield from solve(chords[1:], l2n | dict(zip(p, new)), ch)

# solve the teaser
for l2n, pat in solve(chords, {"O": 0}):
  l2n['Z'] = (sr12 - set(l2n.values())).pop()
  notes = ''.join(l for l, v in sorted(l2n.items(), key = lambda x : x[1]))
  print(f"Notes (1..12): {notes} -> {pat.pop()}")

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

from itertools import combinations, permutations

# constant used later for the 11 unfilled scale positions

sr12 = set(range(1, 12))

# the given chords ( chords with O first)

chords = list("WVQO VYRO QPWR RXQS STUP UVYW".split())

# check a sequence of notes

def check_notes(ns):

ns = sorted(ns)

# calculate the note intervals

ivs = tuple((y - x) % 12 for (x, y) in zip(ns, ns[1:] + [ns[0]]))

# there are no unit intervals

if not 1 in ivs:

# the intervals must form a non-increasing sequence

for rs in (ivs[i:] + ivs[:i] for i in range(4)):

if rs[0] >= rs[1] >= rs[2] >= rs[3]:

return [rs]

return []

# solve for the letters to notes map (credit: Frits)

def solve(chords, l2n, same_iv = []):

if not chords:

yield l2n, same_iv

else:

chord = chords[0]

# find positions of the known notes for this chord, if any

known = tuple(l2n[c] for c in chord if c in l2n)

# and find possible scale positions for the remaining letters

for new in combinations(sr12 - set(l2n.values()), 4 - len(known)):

# check for valid notes and for the same interval pattern

if ((ch := check_notes(known + new)) and (not same_iv or ch == same_iv)):

# consider all mappings for the new notes

ks = [x for x in chord if x not in l2n]

for p in permutations(ks):

yield from solve(chords[1:], l2n | dict(zip(p, new)), ch)

# solve the teaser

for l2n, pat in solve(chords, {"O": 0}):

l2n['Z'] = (sr12 - set(l2n.values())).pop()

notes = ''.join(l for l, v in sorted(l2n.items(), key = lambda x : x[1]))

print(f"Notes (1..12): {notes} -> {pat.pop()}")

Reply

Sunday Times Teaser 3282 – Not Necessarily in the Right Order

by Colin Vout

Published Sunday August 17 2025 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta