Sunday Times Teaser 3167 – Binary Primes


from number_theory import is_prime

# play the game: A to move with <az> zeros, B with <bz> zeros, <n>
# cards played, <seq> and <cv> are the current table card sequence
# and value; return (points, seq) (with points +/- for a win/loss)
def play(n, az, bz, cv, seq):
  # record B's results (value, seq) for A playing 1 or 0 (if available) 
  vs = list()
  
  # find B's outcome for A playing a one
  if not cv or is_prime((cv_ := (1 << n) + cv)):
    vs.append(play(n + 1, bz, az, cv_, (1,) + seq))
    
    # find B's outcome for A playing a zero (if available)
  if n and az:
    vs.append(play(n + 1, bz, az - 1, cv, (0,) + seq))
  
  # if A has no moves (i.e. loses) return the current points to B
  if not vs:
    return -cv, seq
  # otherwise choose A's play that minimises B's result
  v, s = min(vs, key=lambda x: x[0])
  # a loss for B is a win for A and vice versa
  return -v, s
 
# play starting with 2 zero cards each and a one card on the table
pts, seq = play(1, 2, 2, 1, (1,))
wnr = 'Grace Helen'.split()[len(seq) & 1]
seq = ' '.join(str(d) for d in seq)
print(f"Cards played ({seq}) -> {wnr} wins with {abs(pts)} points.")

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

from number_theory import is_prime

# play the game: A to move with <az> zeros, B with <bz> zeros, <n>

# cards played, <seq> and <cv> are the current table card sequence

# and value; return (points, seq) (with points +/- for a win/loss)

def play(n, az, bz, cv, seq):

# record B's results (value, seq) for A playing 1 or 0 (if available)

vs = list()

# find B's outcome for A playing a one

if not cv or is_prime((cv_ := (1 << n) + cv)):

vs.append(play(n + 1, bz, az, cv_, (1,) + seq))

# find B's outcome for A playing a zero (if available)

if n and az:

vs.append(play(n + 1, bz, az - 1, cv, (0,) + seq))

# if A has no moves (i.e. loses) return the current points to B

if not vs:

return -cv, seq

# otherwise choose A's play that minimises B's result

v, s = min(vs, key=lambda x: x[0])

# a loss for B is a win for A and vice versa

return -v, s

# play starting with 2 zero cards each and a one card on the table

pts, seq = play(1, 2, 2, 1, (1,))

wnr = 'Grace Helen'.split()[len(seq) & 1]

seq = ' '.join(str(d) for d in seq)

print(f"Cards played ({seq}) -> {wnr} wins with {abs(pts)} points.")

Reply

John Z permalink

Brilliant!

in line 12

Python

not cv or

1
2
3

not cv or

is redundant because cv can never be 0.
in line 23

Python

key=lambda x: x[0]

1
2
3

key=lambda x: x[0]

is also redundant.

Reply
- John Z permalink
  
  and line 16
  
  Python
  
  n and
  
  1
  2
  3
  
  n and
  
  Reply
- BRG permalink
  
  Hi John,
  
  These (and other) conditions are there to ensure that the subroutine will work
  with other inputs, For example, calling it with no cards on the table at the start.
  
  Reply

Frits permalink

I found this version of returning positive/negative points a bit more intuitive.


from number_theory import is_prime

def play(p=1, r=1, zG=2, zH=2, s=[]):
  points = []           # store points for player in round <r>
  # try to put a zero card
  if (zG if r % 2 else zH):
    points.append(play(p, r + 1, zG - (r % 2), zH - ((r + 1) % 2), ["0"] + s))

  # try to put a one card
  p_ = p + 2**r
  if is_prime(p_):
    points.append(play(p_, r + 1, zG, zH, ["1"] + s))

  # in round <r> this player loses, return points to opponent
  if not points:
    return (p, s)

  # maximize our points in round <r>, return negative points to opponent
  m_p, m_s = max(points, key=lambda x: x[0])
  return(-m_p, m_s)

# play() returns the minimized points for Helen
(p_H, s) = play()

print(f"{'Grace' if p_H < 0 else 'Helen'} wins, "
      f"cards on the table from left to right: {','.join(s) + ',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

from number_theory import is_prime

def play(p=1, r=1, zG=2, zH=2, s=[]):

points = [] # store points for player in round <r>

# try to put a zero card

if (zG if r % 2 else zH):

points.append(play(p, r + 1, zG - (r % 2), zH - ((r + 1) % 2), ["0"] + s))

# try to put a one card

p_ = p + 2**r

if is_prime(p_):

points.append(play(p_, r + 1, zG, zH, ["1"] + s))

# in round <r> this player loses, return points to opponent

if not points:

return (p, s)

# maximize our points in round <r>, return negative points to opponent

m_p, m_s = max(points, key=lambda x: x[0])

return(-m_p, m_s)

# play() returns the minimized points for Helen

(p_H, s) = play()

print(f"{'Grace' if p_H < 0 else 'Helen'} wins, "

f"cards on the table from left to right: {','.join(s) + ',1'}")

Reply

BRG permalink

I have noticed that I can simplify mine a bit by altering what I store (which I will do shortly).

Reply

Frits permalink

Without recursion.

First all possible games are determined and then the whole list of games is collapsed to only one entry (working our way back from games with the most moves to games with the fewest moves)


from number_theory import is_prime

# return next move
def next(r, p, zG, zH, s):
  ret = []
  # try to put a zero card
  if (zG if r % 2 else zH):
    ret.append([r + 1, p, zG - (r % 2), zH - ((r + 1) % 2), "0" + s])

  # try to put a one card
  if is_prime(p_ := p + (1 << r)):
    ret.append([r + 1, p_, zG, zH, "1" + s])

  return ret

# return all possible games
def get_games(moves):
  games = []
  # find all possible games for every move
  while True:
    candidates = []
    # process previously determined moves
    for (r_, p_, zG_, zH_, s_) in moves:
      moves_ = next(r_, p_, zG_, zH_, s_)
      # are we finished for this game?
      if moves_:
        candidates.append(moves_)
      else:
        games.append([s_[::-1], r_, p_, ])

    if candidates:
      # list comprehension for moves = [] for x in candidates: moves.extend(x)
      moves = [y if len(x) > 1 else x[0] for x in candidates for y in x]
    else:
      break
  return games

# determine all possible games
games = get_games([[1, 1, 2, 2, ""]])  # parameters r, p, zG, zH, s

# sort games on round / length
games.sort(key=lambda x: x[1], reverse=True)

d = dict()
# game determine who wins, start with games with the most moves
for ln in range(games[0][1] - 1, -1, -1):
  # Helen uses max and Grace uses min
  fn = max if ln % 2 else min

  # process games with length greater equal to <ln>
  for s, r, p in games:
    if r <= ln: break
    # store new entries
    d[s[:ln]] = d.get(s[:ln], []) + [[s, r, p]]

  d_ = dict()                          # new dictionary for winning games
  for k, v in d.items():
    if len(v) < 2:
      d_[k] = v
      continue

    # we have to decide a winner for remaining games
    m = fn(v, key=lambda x: x[2])      # minimised/maximised points
    d_[k] = [m]                        # only store winning game
    # remove losing games
    for g in v:
      if g == m: continue
      if g[0] in d_:
        del d_[g[0]]
      games.remove(g)
  d = d_.copy()

assert len(games) == 1

print(f"{'Grace' if games[0][2] < 0 else 'Helen'} wins, "
      f"cards on the table from left to right: {games[0][0][::-1] + '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

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

from number_theory import is_prime

# return next move

def next(r, p, zG, zH, s):

ret = []

# try to put a zero card

if (zG if r % 2 else zH):

ret.append([r + 1, p, zG - (r % 2), zH - ((r + 1) % 2), "0" + s])

# try to put a one card

if is_prime(p_ := p + (1 << r)):

ret.append([r + 1, p_, zG, zH, "1" + s])

return ret

# return all possible games

def get_games(moves):

games = []

# find all possible games for every move

while True:

candidates = []

# process previously determined moves

for (r_, p_, zG_, zH_, s_) in moves:

moves_ = next(r_, p_, zG_, zH_, s_)

# are we finished for this game?

if moves_:

candidates.append(moves_)

else:

games.append([s_[::-1], r_, p_, ])

if candidates:

# list comprehension for moves = [] for x in candidates: moves.extend(x)

moves = [y if len(x) > 1 else x[0] for x in candidates for y in x]

else:

break

return games

# determine all possible games

games = get_games([[1, 1, 2, 2, ""]]) # parameters r, p, zG, zH, s

# sort games on round / length

games.sort(key=lambda x: x[1], reverse=True)

d = dict()

# game determine who wins, start with games with the most moves

for ln in range(games[0][1] - 1, -1, -1):

# Helen uses max and Grace uses min

fn = max if ln % 2 else min

# process games with length greater equal to <ln>

for s, r, p in games:

if r <= ln: break

# store new entries

d[s[:ln]] = d.get(s[:ln], []) + [[s, r, p]]

d_ = dict() # new dictionary for winning games

for k, v in d.items():

if len(v) < 2:

d_[k] = v

continue

# we have to decide a winner for remaining games

m = fn(v, key=lambda x: x[2]) # minimised/maximised points

d_[k] = [m] # only store winning game

# remove losing games

for g in v:

if g == m: continue

if g[0] in d_:

del d_[g[0]]

games.remove(g)

d = d_.copy()

assert len(games) == 1

print(f"{'Grace' if games[0][2] < 0 else 'Helen'} wins, "

f"cards on the table from left to right: {games[0][0][::-1] + '1'}")

Reply

Frits permalink

Line 30 must be:

Python

games.append([s_[::-1], r_, (1 if r_ % 2 else -1) * p_, ])

1
2
3

games.append([s_[::-1], r_, (1 if r_ % 2 else -1) * p_, ])

Reply

John Z permalink

This code prints out all possible outcomes without indicating which is the solution to the teaser. The ‘0’ card count switch is inspired by Brian’s code.


from number_theory import is_prime

names = ('Grace', 'Helen')

def zerone(r = '1', g0 = 2, h0 = 2):
  
  # are any moves possible for the current player
  if g0 == 0 and not is_prime(int('1' + r, base = 2)):
    yield r # result if not possible to play another card
    
  else:
    # consider card to play: '0' or '1'
    for nc in '01': 
      
      if ((nc == '0' and g0) or # possible to play a '0'?
          (nc == '1' and is_prime(int('1' + r, base = 2)))): # or a one

        # next card to play, switching '0' count between players
        yield from zerone(nc + r, h0, g0 - (nc == '0'))

# get all possible outcomes and sort by length-normalised binary inverse
games = sorted((y for y in zerone()), key = lambda z: int(z[::-1], base = 2)
               << (12 - len(z)))

for x in games:
  print('  ' * (11 - len(x)), ' '.join(x), names[len(x) & 1], int(x, base = 2))

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

from number_theory import is_prime

names = ('Grace', 'Helen')

def zerone(r = '1', g0 = 2, h0 = 2):

# are any moves possible for the current player

if g0 == 0 and not is_prime(int('1' + r, base = 2)):

yield r # result if not possible to play another card

else:

# consider card to play: '0' or '1'

for nc in '01':

if ((nc == '0' and g0) or # possible to play a '0'?

(nc == '1' and is_prime(int('1' + r, base = 2)))): # or a one

# next card to play, switching '0' count between players

yield from zerone(nc + r, h0, g0 - (nc == '0'))

# get all possible outcomes and sort by length-normalised binary inverse

games = sorted((y for y in zerone()), key = lambda z: int(z[::-1], base = 2)

<< (12 - len(z)))

for x in games:

print(' ' * (11 - len(x)), ' '.join(x), names[len(x) & 1], int(x, base = 2))

Reply

Frits permalink

Hi John, why is sorting necessary? I find it difficult to see order in the output.

The contents of games and list(zerone()) are the same.

Reply

John Z permalink

Hi frits, The purpose of sorting is to place games with the same initial plays next to each other so that the tree of plays is easier to visualise or draw manually.

Reply

John Z permalink

Frits, you are absolutely right, there is no need to sort because the result of zerone() is already in the desired order. Thanks. Here is the slimmed down version…


from number_theory import is_prime

names = ('Grace', 'Helen')

def zerone(r = '1', g0 = 2, h0 = 2):
  
  # are any moves possible for the current player
  if not (is_pr := is_prime(int('1' + r, base = 2))) and g0 == 0:
    yield r # result if not possible to play another card
    
  else:
    # consider next card to play: '0' or '1'
    for nc in '01': 
      
      if (nc == '0' and g0) or (nc == '1' and is_pr): # zero or a one possible?

        # next card to play, swapping '0' count between players
        yield from zerone(nc + r, h0, g0 - (nc == '0'))

# get all possible outcomes and print
for x in zerone():
  print('  ' * (11 - len(x)), ' '.join(x), names[len(x) & 1], int(x, base = 2))

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

from number_theory import is_prime

names = ('Grace', 'Helen')

def zerone(r = '1', g0 = 2, h0 = 2):

# are any moves possible for the current player

if not (is_pr := is_prime(int('1' + r, base = 2))) and g0 == 0:

yield r # result if not possible to play another card

else:

# consider next card to play: '0' or '1'

for nc in '01':

if (nc == '0' and g0) or (nc == '1' and is_pr): # zero or a one possible?

# next card to play, swapping '0' count between players

yield from zerone(nc + r, h0, g0 - (nc == '0'))

# get all possible outcomes and print

for x in zerone():

print(' ' * (11 - len(x)), ' '.join(x), names[len(x) & 1], int(x, base = 2))

Reply

Frits permalink

Starting from a list of prime numbers. I can’t deduce an upper limit for the highest prime number.

(in my previous program I conclude who wins based on the printed entries).


from itertools import compress

# return
def primesbelow(n):
  # rwh_primes1v2(n):
  """ Returns a list of primes < n for n > 2 """
  sieve = bytearray([True]) * (n // 2 + 1)
  for i in range(1, int(n ** 0.5) // 2 + 1):
    if sieve[i]:
      sieve[2 * i * (i + 1)::2 * i + 1] = \
      bytearray((n // 2 - 2 * i * (i + 1)) // (2 * i + 1) + 1)
  return [2, *compress(range(3, n, 2), sieve[1:])]

# add leading zeroes to string <s> if allowed
def add_zeroes(s):
  while True:
    if s[::2].count('0') > 2 or s[1::2].count('0') > 2:
      break
    s = '0' + s
  return s[1:]

# up to 7-digit primes
P = primesbelow(10**7)

# don't allow more than 2 zeroes on odd/even places
P = [b for p in P[1:] if (b := bin(p)[2:])[::2].count('0') <= 2 and
                                        b[1::2].count('0') <= 2]

# all intermediate results must be prime as well
P = [p for p in P if all(p[-j] == '0' or
                         p[-j:] in P for j in range(2, len(p)))]

# remove entries where we can still put a one card on the table
P = ['1'] + [p for p in P if '1' + add_zeroes(p) not in P]

for p in P:
  zp = ' '.join(add_zeroes(p))
  print(f"{zp:>22} "
        f"{'Helen' if ((len(zp) + 1) // 2) % 2 else 'Grace'} {int(p, 2)}")

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 compress

# return

def primesbelow(n):

# rwh_primes1v2(n):

""" Returns a list of primes < n for n > 2 """

sieve = bytearray([True]) * (n // 2 + 1)

for i in range(1, int(n ** 0.5) // 2 + 1):

if sieve[i]:

sieve[2 * i * (i + 1)::2 * i + 1] = \

bytearray((n // 2 - 2 * i * (i + 1)) // (2 * i + 1) + 1)

return [2, *compress(range(3, n, 2), sieve[1:])]

# add leading zeroes to string <s> if allowed

def add_zeroes(s):

while True:

if s[::2].count('0') > 2 or s[1::2].count('0') > 2:

break

s = '0' + s

return s[1:]

# up to 7-digit primes

P = primesbelow(10**7)

# don't allow more than 2 zeroes on odd/even places

P = [b for p in P[1:] if (b := bin(p)[2:])[::2].count('0') <= 2 and

b[1::2].count('0') <= 2]

# all intermediate results must be prime as well

P = [p for p in P if all(p[-j] == '0' or

p[-j:] in P for j in range(2, len(p)))]

# remove entries where we can still put a one card on the table

P = ['1'] + [p for p in P if '1' + add_zeroes(p) not in P]

for p in P:

zp = ' '.join(add_zeroes(p))

print(f"{zp:>22} "

f"{'Helen' if ((len(zp) + 1) // 2) % 2 else 'Grace'} {int(p, 2)}")

Reply

BRG permalink

For interest here is a version based on the bottom up pruning of a binary tree. To show the pruning process, set ‘print_tree’ to True.


import binarytree as tree
from number_theory import is_prime

print_tree = False
print_prms = True

child_count = lambda n: bool(n.left) + bool(n.right)
get_child = lambda n: [n.left, n.right][bool(n.right)]
get_children = lambda n: [x for x in [n.left, n.right] if x]
get_value = lambda n: int(n.value, 2)

def shorten_chains(root):           #     GP
  changed =  False                  #    /
  for gp in root:                   #   P
    if child_count(gp) == 1:        #  /
      p = get_child(gp)             # C
      if child_count(p) == 1:
        c = get_child(p)
        if not child_count(c):
          ix = tree.get_index(root, gp)
          del root[ix]
          root[ix] = c
          changed = True
  return changed

def promote_grandchild(root):       #     GP
  changed =  False                  #    /
  for gp in root:                   #   P
    if child_count(gp) == 1:        #  / \
      p = get_child(gp)             # C   C
      if child_count(p) == 2:
        c1, c2 = get_children(p)
        if not (child_count(c1) or child_count(c2)):
          c = max(c1, c2, key=get_value)
          ix = tree.get_index(root, p)
          del root[ix]
          ix = tree.get_index(root, gp)
          root[ix] = tree.Node(c.value)
          changed = True
  return changed

def remove_bad_children(root):      #     GP
  changed =  True                   #    /  \
  for gp in root:                   #   P    U
    if child_count(gp) != 2:        #  / \
      continue                      # C   C (1 or 2)
    u, p = sorted(get_children(gp),
                            key=child_count)
    if not child_count(p) or child_count(u):
      continue
    cc = get_children(p)
    if any(child_count(c) for c in cc):
      continue      
    ix = tree.get_index(root, p)
    del root[ix]      
    ix = tree.get_index(root, gp)
    t = tree.Node(gp.value)
    t.left = tree.Node(u.value)
    root[ix] = t
    changed = True
  return changed

def remove_two_layers(root):        #     _GP_
  for gp in root:                   #    /    \
    if child_count(gp) != 2:        #   P      P
      continue                      #  / \    / \
    p1, p2 = get_children(gp)       # C   C  C   C (each 1 or 2)
    cc1, cc2 = (get_children(p1),
                get_children(p2))
    if not (cc1 and cc2):
      continue
    if any(child_count(c) for c in cc1 + cc2):
      continue
    c1 = max(*cc1, key=get_value)
    c2 = max(*cc2, key=get_value)
    c = min(c1, c2, key=get_value)
    ix = tree.get_index(root, p1)
    del root[ix]
    ix = tree.get_index(root, p2)
    del root[ix]    
    ix = tree.get_index(root, gp)
    # have we reached the root of the tree
    if not ix:
      return c.value
    else:
      root[ix] = tree.Node(c.value)

# create the tree of values
root = tree.Node('1')
sv = '1'
parents = [root]
while True:
  leafs = []
  for p in parents:
    sv = p.value
    if sv[::2].count('0') <= 2 and sv[1::2].count('0') < 2:
      p.left = tree.Node('0' + sv)
      leafs.append(p.left)
    sv = '1'+ sv
    if is_prime(int(sv, 2)):
      p.right = tree.Node(sv)
      leafs.append(p.right)
  if not leafs:
    break
  parents = leafs

def output_tree(root):
  if print_prms:
    t = root.clone()
    for n in t:
      n.value = int(n.value, 2)
    t.pprint()
  else:
    root.pprint()

while True:
  if print_tree:
    output_tree(root)  
  if shorten_chains(root) and print_tree:
    output_tree(root)
  if promote_grandchild(root) and print_tree:
    output_tree(root)
  if remove_bad_children(root) and print_tree:
    output_tree(root)
  if (v := remove_two_layers(root)):
    break
  
wnr = 'Grace Helen'.split()[len(v) & 1]
seq = ' '.join(str(d) for d in v)
print(f"Cards played ({seq}) -> {wnr} wins with {int(v, 2)} points.")

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

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

import binarytree as tree

from number_theory import is_prime

print_tree = False

print_prms = True

child_count = lambda n: bool(n.left) + bool(n.right)

get_child = lambda n: [n.left, n.right][bool(n.right)]

get_children = lambda n: [x for x in [n.left, n.right] if x]

get_value = lambda n: int(n.value, 2)

def shorten_chains(root): # GP

changed = False # /

for gp in root: # P

if child_count(gp) == 1: # /

p = get_child(gp) # C

if child_count(p) == 1:

c = get_child(p)

if not child_count(c):

ix = tree.get_index(root, gp)

del root[ix]

root[ix] = c

changed = True

return changed

def promote_grandchild(root): # GP

changed = False # /

for gp in root: # P

if child_count(gp) == 1: # / \

p = get_child(gp) # C C

if child_count(p) == 2:

c1, c2 = get_children(p)

if not (child_count(c1) or child_count(c2)):

c = max(c1, c2, key=get_value)

ix = tree.get_index(root, p)

del root[ix]

ix = tree.get_index(root, gp)

root[ix] = tree.Node(c.value)

changed = True

return changed

def remove_bad_children(root): # GP

changed = True # / \

for gp in root: # P U

if child_count(gp) != 2: # / \

continue # C C (1 or 2)

u, p = sorted(get_children(gp),

key=child_count)

if not child_count(p) or child_count(u):

continue

cc = get_children(p)

if any(child_count(c) for c in cc):

continue

ix = tree.get_index(root, p)

del root[ix]

ix = tree.get_index(root, gp)

t = tree.Node(gp.value)

t.left = tree.Node(u.value)

root[ix] = t

changed = True

return changed

def remove_two_layers(root): # _GP_

for gp in root: # / \

if child_count(gp) != 2: # P P

continue # / \ / \

p1, p2 = get_children(gp) # C C C C (each 1 or 2)

cc1, cc2 = (get_children(p1),

get_children(p2))

if not (cc1 and cc2):

continue

if any(child_count(c) for c in cc1 + cc2):

continue

c1 = max(*cc1, key=get_value)

c2 = max(*cc2, key=get_value)

c = min(c1, c2, key=get_value)

ix = tree.get_index(root, p1)

del root[ix]

ix = tree.get_index(root, p2)

del root[ix]

ix = tree.get_index(root, gp)

# have we reached the root of the tree

if not ix:

return c.value

else:

root[ix] = tree.Node(c.value)

# create the tree of values

root = tree.Node('1')

sv = '1'

parents = [root]

while True:

leafs = []

for p in parents:

sv = p.value

if sv[::2].count('0') <= 2 and sv[1::2].count('0') < 2:

p.left = tree.Node('0' + sv)

leafs.append(p.left)

sv = '1'+ sv

if is_prime(int(sv, 2)):

p.right = tree.Node(sv)

leafs.append(p.right)

if not leafs:

break

parents = leafs

def output_tree(root):

if print_prms:

t = root.clone()

for n in t:

n.value = int(n.value, 2)

t.pprint()

else:

root.pprint()

while True:

if print_tree:

output_tree(root)

if shorten_chains(root) and print_tree:

output_tree(root)

if promote_grandchild(root) and print_tree:

output_tree(root)

if remove_bad_children(root) and print_tree:

output_tree(root)

if (v := remove_two_layers(root)):

break

wnr = 'Grace Helen'.split()[len(v) & 1]

seq = ' '.join(str(d) for d in v)

print(f"Cards played ({seq}) -> {wnr} wins with {int(v, 2)} points.")

Reply

Sunday Times Teaser 3167 – Binary Primes

by Mark Valentine

Published Sunday June 04 2023 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta