Sunday Times Teaser 3043 – An Odd Selection

Brian Gladman permalink


from itertools import combinations, permutations
from functools import reduce

# only odd digits are used
digits = {1, 3, 5, 7, 9}

# convert numbers to digit sequences and vice versa
d2n = lambda s: reduce(lambda x,  y: 10 * x + y, s) 
n2d = lambda n: {n} if n < 10 else n2d(n // 10) | {n % 10}

# generate grids of four rows of four digits in which
# all rows and all columns have four different digits
# and <md> lists the missing digits in the four rows
def build_rows(md, r=0, rws=()):
  if r == 4:
    yield rws
  else:
    for row in permutations(digits - {md[0]}, 4):
      if not any(row[i] in col for i, col in enumerate(zip(*rws))):
        yield from build_rows(md[1:], r + 1, rws + (row,))

# if we add a fifth row in which each digit is not equal to
# those above it, we can add the numbers in the five rows
# as 1111 x (1 + 3 + 5 + 7 + 9) = 27,775; hence the sum of
# the numbers in the first four rows is 27,775 minus the
# number in the fifth row; the same applies to the columns
def gen_avgs():
  # form the possible numbers in the fifth row/column
  for p4 in permutations(digits, 4):
    # find the possible averages of four rows/columns
    av, r = divmod(27775 - d2n(p4), 4)
    dgts = n2d(av)
    # it has only odd digits and an odd number of different digits
    if not r and all(d & 1 for d in dgts) and len(set(dgts)) & 1: 
      yield (av, p4)

sol_cnt = 0
# look for a pair of solutions for the rows and columns 
for (havg, vm),  (vavg, hm) in combinations(sorted(gen_avgs()), 2):
  for r4 in build_rows(hm):
    # form the columns and check for correct missing column digits
    if not any(vm[i] in col for i, col in enumerate(zip(*r4))):
      sol_cnt += 1
      print(f"{sol_cnt:02} {r4} ==> {havg}, {vavg}")

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

from itertools import combinations, permutations

from functools import reduce

# only odd digits are used

digits = {1, 3, 5, 7, 9}

# convert numbers to digit sequences and vice versa

d2n = lambda s: reduce(lambda x, y: 10 * x + y, s)

n2d = lambda n: {n} if n < 10 else n2d(n // 10) | {n % 10}

# generate grids of four rows of four digits in which

# all rows and all columns have four different digits

# and <md> lists the missing digits in the four rows

def build_rows(md, r=0, rws=()):

if r == 4:

yield rws

else:

for row in permutations(digits - {md[0]}, 4):

if not any(row[i] in col for i, col in enumerate(zip(*rws))):

yield from build_rows(md[1:], r + 1, rws + (row,))

# if we add a fifth row in which each digit is not equal to

# those above it, we can add the numbers in the five rows

# as 1111 x (1 + 3 + 5 + 7 + 9) = 27,775; hence the sum of

# the numbers in the first four rows is 27,775 minus the

# number in the fifth row; the same applies to the columns

def gen_avgs():

# form the possible numbers in the fifth row/column

for p4 in permutations(digits, 4):

# find the possible averages of four rows/columns

av, r = divmod(27775 - d2n(p4), 4)

dgts = n2d(av)

# it has only odd digits and an odd number of different digits

if not r and all(d & 1 for d in dgts) and len(set(dgts)) & 1:

yield (av, p4)

sol_cnt = 0

# look for a pair of solutions for the rows and columns

for (havg, vm), (vavg, hm) in combinations(sorted(gen_avgs()), 2):

for r4 in build_rows(hm):

# form the columns and check for correct missing column digits

if not any(vm[i] in col for i, col in enumerate(zip(*r4))):

sol_cnt += 1

print(f"{sol_cnt:02} {r4} ==> {havg}, {vavg}")

This used to find 56 solutions in under 100 milliseconds. But with the improvement found by John (see below) it now runs in 60 milliseconds. Well done John!

Reply

Frits permalink

@Brian Last digit of p4 has to be 1, 5 or 9. Then the average will always be a whole number.

In the past I have tried to write clever permutation routines that used such analysis but it was always slower than itertools permutation.

Reply
- Brian Gladman permalink
  
  @Frits I really doubt that the extra coding needed to add this constraint would
  produce a significantly faster result.
  
  Reply

Frits permalink

A bit faster. I have chosen for an indent level of 1 due the many loops.


from collections import defaultdict

# return True if all digits in number are odd
def oddDigits(n):
  if n < 10: return n % 2;
  return oddDigits(n % 10) and oddDigits(int(n / 10))
  
# make sure loop variable value is not equal to previous ones
def domain(v):
  # find already used loop values  ...
  vals = set()
  #print(globals())
  # ... by accessing previously set loop variable names
  for s in lvd[v]:
    x = globals()[s] if s in globals() else -99
    if x != -99: vals.add(x)
  
  return [x for x in odds if x not in vals]


lvd = defaultdict(list)
rowscols = ["JKLM", "NPQR", "LQCG", "MRDH", "CDAB", "GHEF", "JNAE", "KPBF"]

# build dictionary of loop variables
for lv in rowscols:
  for i, v in enumerate(lv):
    lvd[v] += lv[:i]
 
odds = [1, 3, 5, 7, 9]


# suppose the layout is:
#
#  A B C D
#  E F G H
#  J K L M
#  N P Q R

for J in odds:
 for K in domain('K'):
  for L in domain('L'):
   for M in domain('M'):
    tensJKLM = 10 * (J + K + L + M)
    for N in domain('N'):
     for P in domain('P'):
      for Q in domain('Q'):
       for R in domain('R'):
         # sum column totals is a multiple of 4
         if (tensJKLM + N + P + Q + R) % 4 != 0:
          continue
         for C in domain('C'):
          for G in domain('G'):
           tensCGLQ = 10 * (C + G + L + Q)
           for D in domain('D'):
            for H in domain('H'):
             # sum row totals is a multiple of 4
             if (tensCGLQ + D + H + M + R) % 4 != 0:
              continue
             for A in domain('A'):
              for B in domain('B'):
               for E in domain('E'):
                for F in domain('F'):
                 avgr = (D+H+M+R + 10 * (C+G+L+Q) + 100 * (B+F+K+P) + 
                         1000 * (A+E+J+N)) // 4
                 # each average uses an odd number of different odd digits
                 if not(oddDigits(avgr) and len(set(str(avgr))) % 2):
                  continue
                 
                 avgc = (N+P+Q+R + 10 * (J+K+L+M) + 100 * (E+F+G+H) + 
                         1000 * (A+B+C+D)) // 4
                 # each average uses an odd number of different odd digits
                 if not(oddDigits(avgc) and len(set(str(avgc))) % 2):
                  continue
                 # col average is greater than row average
                 if not (avgr < avgc): 
                  continue
                 # each digit appears at least 3 times 
                 if any([A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R].count(d) < 3 
                         for d in odds):
                  continue
                 
                 print(f"{A}{B}{C}{D} {E}{F}{G}{H} {J}{K}{L}{M} "
                       f"{N}{P}{Q}{R} row avg {avgr}, col avg {avgc}")

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

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

from collections import defaultdict

# return True if all digits in number are odd

def oddDigits(n):

if n < 10: return n % 2;

return oddDigits(n % 10) and oddDigits(int(n / 10))

# make sure loop variable value is not equal to previous ones

def domain(v):

# find already used loop values ...

vals = set()

#print(globals())

# ... by accessing previously set loop variable names

for s in lvd[v]:

x = globals()[s] if s in globals() else -99

if x != -99: vals.add(x)

return [x for x in odds if x not in vals]

lvd = defaultdict(list)

rowscols = ["JKLM", "NPQR", "LQCG", "MRDH", "CDAB", "GHEF", "JNAE", "KPBF"]

# build dictionary of loop variables

for lv in rowscols:

for i, v in enumerate(lv):

lvd[v] += lv[:i]

odds = [1, 3, 5, 7, 9]

# suppose the layout is:

#

# A B C D

# E F G H

# J K L M

# N P Q R

for J in odds:

for K in domain('K'):

for L in domain('L'):

for M in domain('M'):

tensJKLM = 10 * (J + K + L + M)

for N in domain('N'):

for P in domain('P'):

for Q in domain('Q'):

for R in domain('R'):

# sum column totals is a multiple of 4

if (tensJKLM + N + P + Q + R) % 4 != 0:

continue

for C in domain('C'):

for G in domain('G'):

tensCGLQ = 10 * (C + G + L + Q)

for D in domain('D'):

for H in domain('H'):

# sum row totals is a multiple of 4

if (tensCGLQ + D + H + M + R) % 4 != 0:

continue

for A in domain('A'):

for B in domain('B'):

for E in domain('E'):

for F in domain('F'):

avgr = (D+H+M+R + 10 * (C+G+L+Q) + 100 * (B+F+K+P) +

1000 * (A+E+J+N)) // 4

# each average uses an odd number of different odd digits

if not(oddDigits(avgr) and len(set(str(avgr))) % 2):

continue

avgc = (N+P+Q+R + 10 * (J+K+L+M) + 100 * (E+F+G+H) +

1000 * (A+B+C+D)) // 4

# each average uses an odd number of different odd digits

if not(oddDigits(avgc) and len(set(str(avgc))) % 2):

continue

# col average is greater than row average

if not (avgr < avgc):

continue

# each digit appears at least 3 times

if any([A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R].count(d) < 3

for d in odds):

continue

print(f"{A}{B}{C}{D} {E}{F}{G}{H} {J}{K}{L}{M} "

f"{N}{P}{Q}{R} row avg {avgr}, col avg {avgc}")

Reply

Brian Gladman permalink

@Frits Thanks for posting (I agree that indents of one are better than overflowing the right margin!).

This is faster than my old version but I have now updated mine using an analysis from a contributor on the Sunday Times Teasers Discussion Group (Jim Randell uses the same analysis in his second version).

Reply

John Z permalink

Here is a somewhat clunky solution. I reused the structure of a bit of software that I used to solve a row / column problem many moons ago. This stops after finding one grid that gives the correct averages.


def verifyGrid():

  # count odd digits
  oddcount = [0] * 10
  for m in range(4):
    for n in range(4):
      oddcount[grid[m][n]] += 1

  # each odd digit appearing three or more times overall
  for m in range(1, 10, 2):
    if oddcount[m] < 3:
      return False

  # calculate averages
  avg = [0, 0]
  for m in range(4):
    for n in range(4):
      avg[0] += grid[m][n] * 10 ** (3 - n) # across average
      avg[1] += grid[m][n] * 10 ** (3 - m) # down average

  # down average greater than across average
  if avg[1] <= avg[0]:
    return False

  for m in range(2):
    # average must be whole number
    avg[m], r = divmod(avg[m], 4)
    if r != 0:
      return False

    # average must be odd
    if (avg[m] & 1) != 1:
      return False

    # averages must have only odd digits 
    avgd = str(avg[m])
    if (set(avgd) & set("02468")):
      return False

    # odd number of different odd digits
    if len(set(avgd)) & 1 != 1:
      return False

  print("across avg", avg[0], "down avg", avg[1])
  return True

def solveGrid(i=-1, j=-1):

  # fill cells in grid one by one
  # initialise
  if i == -1:
    i = j = 0
  # next cell 
  elif (j := j + 1) == 4:
    j = 0
    if (i := i + 1) == 4:
      return -1, -1

  # fill cells with odd numbers only
  for e in (1, 3, 5, 7, 9):

    # check e not in row:
    if e in grid[i]: 
      continue
    # check e not in column
    if e in [grid[x][j] for x in range(4)]: 
      continue
    grid[i][j] = e

    # check if last square in grid
    if i == j == 3:
      if verifyGrid():
        return True
      else:
        grid[i][j] = 0 # backtrack
        continue

    else:

      if solveGrid(i, j):
        return True
      # Undo the current cell for backtracking
      grid[i][j] = 0
  return False

# Initialize grid
grid = [[0 for i in range(4)] for j in range(4)]

if solveGrid():  # True if solution found
  print("grid")
  for a in grid:
    print(*a)
else:
  print("error")
  print(grid)

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

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

def verifyGrid():

# count odd digits

oddcount = [0] * 10

for m in range(4):

for n in range(4):

oddcount[grid[m][n]] += 1

# each odd digit appearing three or more times overall

for m in range(1, 10, 2):

if oddcount[m] < 3:

return False

# calculate averages

avg = [0, 0]

for m in range(4):

for n in range(4):

avg[0] += grid[m][n] * 10 ** (3 - n) # across average

avg[1] += grid[m][n] * 10 ** (3 - m) # down average

# down average greater than across average

if avg[1] <= avg[0]:

return False

for m in range(2):

# average must be whole number

avg[m], r = divmod(avg[m], 4)

if r != 0:

return False

# average must be odd

if (avg[m] & 1) != 1:

return False

# averages must have only odd digits

avgd = str(avg[m])

if (set(avgd) & set("02468")):

return False

# odd number of different odd digits

if len(set(avgd)) & 1 != 1:

return False

print("across avg", avg[0], "down avg", avg[1])

return True

def solveGrid(i=-1, j=-1):

# fill cells in grid one by one

# initialise

if i == -1:

i = j = 0

# next cell

elif (j := j + 1) == 4:

j = 0

if (i := i + 1) == 4:

return -1, -1

# fill cells with odd numbers only

for e in (1, 3, 5, 7, 9):

# check e not in row:

if e in grid[i]:

continue

# check e not in column

if e in [grid[x][j] for x in range(4)]:

continue

grid[i][j] = e

# check if last square in grid

if i == j == 3:

if verifyGrid():

return True

else:

grid[i][j] = 0 # backtrack

continue

else:

if solveGrid(i, j):

return True

# Undo the current cell for backtracking

grid[i][j] = 0

return False

# Initialize grid

grid = [[0 for i in range(4)] for j in range(4)]

if solveGrid(): # True if solution found

print("grid")

for a in grid:

print(*a)

else:

print("error")

print(grid)

Reply

GeoffR permalink

This program finds just two averages, the greater value being the column average and the lesser the row average. It also prints the 5th row – a feature of this method of solution


# Based on an idea by Peter Noll in the Discussion Group
# i.e. adding an extra 5th row to the grid to show all five odd digits

from itertools import permutations

digits = {1, 3, 5, 7, 9}

# total of 5 row, 4 col grid
R5_total = 1111 * (1 + 3 + 5 + 7 + 9)

for abcd in permutations(digits, 4):
  a, b, c, d = abcd
  num = 1000 * a + 100 * b + 10 * c + d
  R4_total = R5_total - num
  # 4 row by 4 col grid - sum divides exactly by 4
  # for a whole number average
  if R4_total % 4 == 0:
    avg = R4_total // 4
    if 1000 < avg <= 9999:
      # find digits in average
      d1, d2 = avg // 1000, avg // 100 % 10
      d3, d4 = avg // 10 % 10, avg % 10
      ds = set((d1, d2, d3, d4))
      if set((d1, d2, d3, d4)).issubset(digits):
        # average consists entirely of odd digits
        if len(ds) % 2 == 1:
          print(f"5th row = {num}, average = {avg}")

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

# Based on an idea by Peter Noll in the Discussion Group

# i.e. adding an extra 5th row to the grid to show all five odd digits

from itertools import permutations

digits = {1, 3, 5, 7, 9}

# total of 5 row, 4 col grid

R5_total = 1111 * (1 + 3 + 5 + 7 + 9)

for abcd in permutations(digits, 4):

a, b, c, d = abcd

num = 1000 * a + 100 * b + 10 * c + d

R4_total = R5_total - num

# 4 row by 4 col grid - sum divides exactly by 4

# for a whole number average

if R4_total % 4 == 0:

avg = R4_total // 4

if 1000 < avg <= 9999:

# find digits in average

d1, d2 = avg // 1000, avg // 100 % 10

d3, d4 = avg // 10 % 10, avg % 10

ds = set((d1, d2, d3, d4))

if set((d1, d2, d3, d4)).issubset(digits):

# average consists entirely of odd digits

if len(ds) % 2 == 1:

print(f"5th row = {num}, average = {avg}")

Reply

Brian Gladman permalink

Here is another version that uses the MiniZinc constraint solver via Jim Randell’s minizinc.py wrapper:


from minizinc import MiniZinc

model_str = """
include "globals.mzn";

% all digits are odd
set of int: odd_dgts = {1, 3, 5, 7, 9};

% define the 4 x 4 grid of digits
set of int: row = 1..4;
set of int: col = 1..4;
array[row, col] of var odd_dgts: g;

% the digits in each row are diffent
constraint forall (r in row) (alldifferent (c in col) (g[r, c]));

% the digits in each column are diffent
constraint forall (c in col) (alldifferent (r in row) (g[r, c]));

% each digit appears three or four times in the grid
constraint forall (i in odd_dgts) (    
                   count_eq ([g[r, c] | r in row, c in col], i, 3) 
                \/ count_eq ([g[r, c] | r in row, c in col], i, 4) );

% the row and column numbers
array [row] of var 1000..9999: row_nbrs;
array [col] of var 1000..9999: col_nbrs;
constraint forall (r in row) 
                    (row_nbrs[r] = sum (c in col) (pow(10, 4 - c) * g[r, c]));
constraint forall (c in col) 
                    (col_nbrs[c] = sum (r in row) (pow(10, 4 - r) * g[r, c]));

% the row and column averages
var 4000..49999: row_sum = sum (c in col) (row_nbrs[c]);
var 4000..49999: col_sum = sum (r in row) (col_nbrs[r]);
var 1000..9999: row_avg;
var 1000..9999: col_avg;
constraint row_sum mod 4 == 0 /\ row_avg == row_sum div 4;
constraint col_sum mod 4 == 0 /\ col_avg == col_sum div 4;

% the row average is less than the column average
constraint row_avg < col_avg;

% row and columns averages have only odd digits
array[1..4] of var odd_dgts: r_avd;
array[1..4] of var odd_dgts: c_avd;
constraint row_avg == sum (i in 1..4) (pow(10, 4 - i) * r_avd[i]);
constraint col_avg == sum (i in 1..4) (pow(10, 4 - i) * c_avd[i]);

% the two averages each have an odd number of different digits
constraint card ({r_avd[i] | i in 1..4}) mod 2 == 1
        /\ card ({c_avd[i] | i in 1..4}) mod 2 == 1;

solve satisfy;
"""

p = MiniZinc(model_str)
cnt  = 0
for d in p.solve():
  cnt += 1
  r = tuple(tuple(d['g'][r][c] for c in range(1, 5)) for r in range(1, 5))  
  print(f"{cnt:02}: {d['row_avg']}, {d['col_avg']}")
  print(f"  {r[0]}\n  {r[1]}\n  {r[2]}\n  {r[3]}")

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

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

from minizinc import MiniZinc

model_str = """

include "globals.mzn";

% all digits are odd

set of int: odd_dgts = {1, 3, 5, 7, 9};

% define the 4 x 4 grid of digits

set of int: row = 1..4;

set of int: col = 1..4;

array[row, col] of var odd_dgts: g;

% the digits in each row are diffent

constraint forall (r in row) (alldifferent (c in col) (g[r, c]));

% the digits in each column are diffent

constraint forall (c in col) (alldifferent (r in row) (g[r, c]));

% each digit appears three or four times in the grid

constraint forall (i in odd_dgts) (

count_eq ([g[r, c] | r in row, c in col], i, 3)

\/ count_eq ([g[r, c] | r in row, c in col], i, 4) );

% the row and column numbers

array [row] of var 1000..9999: row_nbrs;

array [col] of var 1000..9999: col_nbrs;

constraint forall (r in row)

(row_nbrs[r] = sum (c in col) (pow(10, 4 - c) * g[r, c]));

constraint forall (c in col)

(col_nbrs[c] = sum (r in row) (pow(10, 4 - r) * g[r, c]));

% the row and column averages

var 4000..49999: row_sum = sum (c in col) (row_nbrs[c]);

var 4000..49999: col_sum = sum (r in row) (col_nbrs[r]);

var 1000..9999: row_avg;

var 1000..9999: col_avg;

constraint row_sum mod 4 == 0 /\ row_avg == row_sum div 4;

constraint col_sum mod 4 == 0 /\ col_avg == col_sum div 4;

% the row average is less than the column average

constraint row_avg < col_avg;

% row and columns averages have only odd digits

array[1..4] of var odd_dgts: r_avd;

array[1..4] of var odd_dgts: c_avd;

constraint row_avg == sum (i in 1..4) (pow(10, 4 - i) * r_avd[i]);

constraint col_avg == sum (i in 1..4) (pow(10, 4 - i) * c_avd[i]);

% the two averages each have an odd number of different digits

constraint card ({r_avd[i] | i in 1..4}) mod 2 == 1

/\ card ({c_avd[i] | i in 1..4}) mod 2 == 1;

solve satisfy;

"""

p = MiniZinc(model_str)

cnt = 0

for d in p.solve():

cnt += 1

r = tuple(tuple(d['g'][r][c] for c in range(1, 5)) for r in range(1, 5))

print(f"{cnt:02}: {d['row_avg']}, {d['col_avg']}")

print(f" {r[0]}\n {r[1]}\n {r[2]}\n {r[3]}")

Reply

Frits permalink

Nice,

It runs really fast with Cpython (faster than PyPy).

I had to upgrade MiniZinc from 2.43 to 2.53 to get it working (as you used “var set comprehensions”).

The upper limits of row_sum and col_sum seem to have been designed for 5 rows/cols.

Maybe using a name like “odigits” iso “digits” would make lines 46-49 more clear (averages all have odd digits). I first thought you had forgotten to code a constraint.

Reply
- Brian Gladman permalink
  
  @Frits Yes, you are right that it is long enough to forget that the digits
  are all odd so I have changed this. I used 1..4 because this is the human
  way that the rows and columns would be numbered and it hence makes the
  model more appropriate for anyone reading it It would, of course, be
  likely to be faster if I generated the averages before the grid as I did
  in my first version.
  
  Reply

John Z permalink

Hi Brian,
Taking line 20 of the code from your first solution:


      if all(all(x != y for x, y in zip(row, rws[i])) for i in range(r)):

1

2

3

if all(all(x != y for x, y in zip(row, rws[i])) for i in range(r)):

I wrote three alternative if statements (commented out below) which may or may not be more efficient than yours – is it even worth worrying about? They do have the advantage of eliminating the need for the ‘r’ variable. Here they are:


      #if all(all(x != y for x, y in zip(row, rwsi)) for rwsi in rws):
      #if all(all(x != rwsi[i] for i, x in enumerate(row)) for rwsi in rws):
      #if not any(row[i] in col for i, col in enumerate(zip(* rws))):

1

2

3

4

5

#if all(all(x != y for x, y in zip(row, rwsi)) for rwsi in rws):

#if all(all(x != rwsi[i] for i, x in enumerate(row)) for rwsi in rws):

#if not any(row[i] in col for i, col in enumerate(zip(* rws))):

You thoughts?

Reply

Brian Gladman permalink

Hi John

A very nice investigation! Your first alternative runs in about the same time as my construction but is certainly nicer. I would be inclined to adopt it. Your second alternative runs a bit slower than your first and my own. But your third is very good and is a clear winner on speed with a significant improvement from about 58 milliseconds to 40 milliseconds, a major improvement. So your number three is the one I shall now adopt!

Well done for finding such a large speed improvement!

Reply

John Z permalink

Brian:
Thanks for you feedback.

here are two further touch-ups to the paintwork that might squeeze a further few milliseconds
from the run time:

removing line 43 and replacing line 44 with:


if not any(vm[i] in col for i, col in enumerate(zip(* r4))):

1

2

3

if not any(vm[i] in col for i, col in enumerate(zip(* r4))):

Replacing line 16 with:


  if not md:

1

2

3

if not md:

allows the variable ‘ r ‘ to be removed from the parameter list of ‘ build_rows ‘

Looking forward to 3044.

Reply

Brian Gladman permalink

@John Z

Thanks for your further suggestions, neither of which make any measurable difference to the speed. Nevertheless, your test is nicer than mine so I shall adopt it!

Reply

Sunday Times Teaser 3043 – An Odd Selection

by Victor Bryant

Published Sunday January 17 2021 (link)

Leave a comment to John Z Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta