Sunday Times Teaser 3190 – Mods-In-Suits

by BRG on November 10, 2023

by Stephen Hogg

Sunday November 12 2023 (link)

In single-pack card game Mods-In-Suits, players are dealt two cards. Each card’s face value (Ace=1 to K=13) is modified by its suit, thus: “Spade” squares it; “Heart” halves it; “Club” changes its sign; “Diamond” divides it by the other card’s face value. Players score their modified values’ sum (or zero if there is a matching pair of face values). Players may exchange their second dealt card for a fresh card from the pack.

Stuck in the jam in the Smoke at rush hour, John’s children were missing Andy’s party. Playing Mods-In-Suits for amusement led to one unusual game. Jo’s initial score was a positive whole number, Bo’s its negative. Four different suits and face values were dealt. Both exchanged their second card, but each score was unchanged. Four different suits were still showing.

Give Jo’s final hand.

From → Uncategorized

5 Comments Leave one →

BRG permalink


from itertools import permutations, product
from collections import defaultdict
from fractions import Fraction as RF

# the pack of cards
pack = list(product('SHDC', range(1, 14)))

# calculate the value of a card <a> when paired with <b>
def card_value(suit, a, b):
  match suit:
    case 'S':
      return a * a
    case 'H':
      return RF(a, 2)
    case 'C':
      return -a
    case 'D':
      return RF(a, b)
        
# calculate the value of a pair of cards <c1> and <c2>
def pair_value(c1, c2):
  (s1, v1), (s2, v2) = c1, c2
  if v1 != v2:
    r = card_value(s1, v1, v2) + card_value(s2, v2, v1)
    return r.numerator if r.denominator == 1 else None

# map values to sets of card pairs with the value
v2pp, v2pn = defaultdict(set), defaultdict(set)       
for a, b in permutations(pack, 2):
  if (v := pair_value(a, b)):
    (v2pp if v > 0 else v2pn)[abs(v)] |= {(a, b)}

# for four cards, check that there are no duplicate cards or suits
# and that the number of different values is not less than <vdiff>
def check(a, b, c, d, vdiff=4):
  if len({a, b, c, d}) == 4:
    if len({a[0], b[0], c[0], d[0]}) == 4:
      if len({a[1], b[1], c[1], d[1]}) >= vdiff:
        return True
  return False

# Jo's first, second and second replaced cards: (jf, js, jr)
# Bo's first, second and second replaced cards: (bf, bs, br)
# map (jf, bf) (+ve, -ve) to pairs for (js, bs) or (jr, br)
# (+ve, -ve) with the same absolute value
def f2s():
  # consider Jo's and Bo's cards with the same absolute scores
  for v in set(v2pp).intersection(v2pn):
    l_jprs, l_bprs = v2pp[v], v2pn[v]
    jf2ls, bf2ls = defaultdict(list), defaultdict(list)
        
    # map Jo's and Bo's first cards to their second cards 
    # that have the same combined scores with them 
    for jf, js in l_jprs:
      jf2ls[jf] += [js]
    for bf, bs in l_bprs:
      bf2ls[bf] += [bs]
    
    yield jf2ls, bf2ls
  
vs = ' 0 A 2 3 4 5 6 7 8 9 10 J Q K'.split()
f = lambda c: ''.join((vs[c[1]],  c[0]))
                    
for jf2ls, bf2ls in f2s():
  
  # consider Jo's first card
  for jf, l_js in jf2ls.items():
    # and Jo's second card and its replacement
    for js, jr in permutations(l_js, 2):
    
      # consider Bo's first card
      for bf, l_bs in bf2ls.items():
        # and Bo's second card and its replacement
        for bs, br in permutations(l_bs, 2):
          
          # all cards drawn from the pack must be different
          if len(set((jf, js, jr, bf, bs, br))) == 6:
            # check initial card pairs have all cards suits and values
            # different but replacements can have duplicate face values
            if check(jf, js, bf, bs) and check(jf, jr, bf, br, vdiff=0):
              fj = f"Jo: ({f(jf)}, {f(js)} -> {f(jr)}) "
              fb = f"Bo: ({f(bf)}, {f(bs)} -> {f(br)}) "
              print(fj, fb)

from itertools import permutations, product

from collections import defaultdict

from fractions import Fraction as RF

# the pack of cards

pack = list(product('SHDC', range(1, 14)))

# calculate the value of a card <a> when paired with <b>

def card_value(suit, a, b):

match suit:

case 'S':

return a * a

case 'H':

return RF(a, 2)

case 'C':

return -a

case 'D':

return RF(a, b)

# calculate the value of a pair of cards <c1> and <c2>

def pair_value(c1, c2):

(s1, v1), (s2, v2) = c1, c2

if v1 != v2:

r = card_value(s1, v1, v2) + card_value(s2, v2, v1)

return r.numerator if r.denominator == 1 else None

# map values to sets of card pairs with the value

v2pp, v2pn = defaultdict(set), defaultdict(set)

for a, b in permutations(pack, 2):

if (v := pair_value(a, b)):

(v2pp if v > 0 else v2pn)[abs(v)] |= {(a, b)}

# for four cards, check that there are no duplicate cards or suits

# and that the number of different values is not less than <vdiff>

def check(a, b, c, d, vdiff=4):

if len({a, b, c, d}) == 4:

if len({a[0], b[0], c[0], d[0]}) == 4:

if len({a[1], b[1], c[1], d[1]}) >= vdiff:

return True

return False

# Jo's first, second and second replaced cards: (jf, js, jr)

# Bo's first, second and second replaced cards: (bf, bs, br)

# map (jf, bf) (+ve, -ve) to pairs for (js, bs) or (jr, br)

# (+ve, -ve) with the same absolute value

def f2s():

# consider Jo's and Bo's cards with the same absolute scores

for v in set(v2pp).intersection(v2pn):

l_jprs, l_bprs = v2pp[v], v2pn[v]

jf2ls, bf2ls = defaultdict(list), defaultdict(list)

# map Jo's and Bo's first cards to their second cards

# that have the same combined scores with them

for jf, js in l_jprs:

jf2ls[jf] += [js]

for bf, bs in l_bprs:

bf2ls[bf] += [bs]

yield jf2ls, bf2ls

vs = ' 0 A 2 3 4 5 6 7 8 9 10 J Q K'.split()

f = lambda c: ''.join((vs[c[1]], c[0]))

for jf2ls, bf2ls in f2s():

# consider Jo's first card

for jf, l_js in jf2ls.items():

# and Jo's second card and its replacement

for js, jr in permutations(l_js, 2):

# consider Bo's first card

for bf, l_bs in bf2ls.items():

# and Bo's second card and its replacement

for bs, br in permutations(l_bs, 2):

# all cards drawn from the pack must be different

if len(set((jf, js, jr, bf, bs, br))) == 6:

# check initial card pairs have all cards suits and values

# different but replacements can have duplicate face values

if check(jf, js, bf, bs) and check(jf, jr, bf, br, vdiff=0):

fj = f"Jo: ({f(jf)}, {f(js)} -> {f(jr)}) "

fb = f"Bo: ({f(bf)}, {f(bs)} -> {f(br)}) "

print(fj, fb)

John Z permalink

Brian, your code is very fast – much faster than mine: it usually is. But I think it can be made even faster by adding a test to line 24 to verify that the suits of the two cards are different:

Python

if v1 != v2 and s1 != s2:

1
2
3

if v1 != v2 and s1 != s2:

Reply

BRG permalink

Here is another approach.


from itertools import permutations, product
from collections import defaultdict
from fractions import Fraction as RF

# the pack of cards
pack = list(product('SHDC', range(1, 14)))

# calculate the value of a card <a> when paired with <b>
def card_value(suit, a, b):
  match suit:
    case 'S':
      return a * a
    case 'H':
      return RF(a, 2)
    case 'C':
      return -a
    case 'D':
      return RF(a, b)
    
# calculate the value of a pair of cards <c1> and <c2>
def pair_value(c1, c2):
  (s1, v1), (s2, v2) = c1, c2
  if v1 != v2:
    r = card_value(s1, v1, v2) + card_value(s2, v2, v1)
    return r.numerator if r.denominator == 1 else None

# map values to sets of card pairs with the value
v2pp, v2pn = defaultdict(set), defaultdict(set)       
for a, b in permutations(pack, 2):
  if (v := pair_value(a, b)):
    (v2pp if v > 0 else v2pn)[abs(v)] |= {(a, b)}
    
# for four cards, check that there are no duplicate cards or suits
# and that the number of different values is not less than <vdiff>
def check(a, b, c, d, vdiff=4):
  if len({a, b, c, d}) == 4:
    if len({a[0], b[0], c[0], d[0]}) == 4:
      if len({a[1], b[1], c[1], d[1]}) >= vdiff:
        return True
  return False

# find two pairs with the same absolute score, one positive and
# one negative, that use, among them, four different cards and 
# have four different suits and four different values; index
# the two pairs on their absolute values
v2p4 = defaultdict(list)
for v in set(v2pp).intersection(v2pn):
  for ap, bp in v2pp[v]:
    for an, bn in v2pn[v]:
      if check(ap, bp, an, bn):
        v2p4[v] += [(ap, bp, an, bn)]

# now do the same but allow duplicate face values
v2p4r = defaultdict(list)
for v in set(v2pp).intersection(v2pn):
  for ap, bp in v2pp[v]:
    for an, bn in v2pn[v]:
      # no check on face values
      if check(ap, bp, an, bn, vdiff=0):
        v2p4r[v] += [(ap, bp, an, bn)]

vs = ' 0 A 2 3 4 5 6 7 8 9 10 J Q K'.split()
f = lambda c: ''.join((vs[c[1]],  c[0]))

# find two sets of four cards with the same first cards
for v in set(v2p4).intersection(v2p4r):
  for fp1, sp1, fn1, sn1 in v2p4[v]:
    for fp2, sp2, fn2, sn2 in v2p4r[v]:
      if {fp1, fn1} == {fp2, fn2}:
        if len({sp1, sn1, sp2, sn2}) == 4:
          # check that the unchecked pairs have the correct values
          if len({pair_value(fp1, sp2), pair_value(fp2, sp1)}) == 1:
            fj = f"Jo: ({f(fp1)}, {f(sp1)} -> {f(sp2)}) "
            fb = f"Bo: ({f(fn1)}, {f(sn1)} -> {f(sn2)}) "
            print(fj, fb)

from itertools import permutations, product

from collections import defaultdict

from fractions import Fraction as RF

# the pack of cards

pack = list(product('SHDC', range(1, 14)))

# calculate the value of a card <a> when paired with <b>

def card_value(suit, a, b):

match suit:

case 'S':

return a * a

case 'H':

return RF(a, 2)

case 'C':

return -a

case 'D':

return RF(a, b)

# calculate the value of a pair of cards <c1> and <c2>

def pair_value(c1, c2):

(s1, v1), (s2, v2) = c1, c2

if v1 != v2:

r = card_value(s1, v1, v2) + card_value(s2, v2, v1)

return r.numerator if r.denominator == 1 else None

# map values to sets of card pairs with the value

v2pp, v2pn = defaultdict(set), defaultdict(set)

for a, b in permutations(pack, 2):

if (v := pair_value(a, b)):

(v2pp if v > 0 else v2pn)[abs(v)] |= {(a, b)}

# for four cards, check that there are no duplicate cards or suits

# and that the number of different values is not less than <vdiff>

def check(a, b, c, d, vdiff=4):

if len({a, b, c, d}) == 4:

if len({a[0], b[0], c[0], d[0]}) == 4:

if len({a[1], b[1], c[1], d[1]}) >= vdiff:

return True

return False

# find two pairs with the same absolute score, one positive and

# one negative, that use, among them, four different cards and

# have four different suits and four different values; index

# the two pairs on their absolute values

v2p4 = defaultdict(list)

for v in set(v2pp).intersection(v2pn):

for ap, bp in v2pp[v]:

for an, bn in v2pn[v]:

if check(ap, bp, an, bn):

v2p4[v] += [(ap, bp, an, bn)]

# now do the same but allow duplicate face values

v2p4r = defaultdict(list)

for v in set(v2pp).intersection(v2pn):

for ap, bp in v2pp[v]:

for an, bn in v2pn[v]:

# no check on face values

if check(ap, bp, an, bn, vdiff=0):

v2p4r[v] += [(ap, bp, an, bn)]

vs = ' 0 A 2 3 4 5 6 7 8 9 10 J Q K'.split()

f = lambda c: ''.join((vs[c[1]], c[0]))

# find two sets of four cards with the same first cards

for v in set(v2p4).intersection(v2p4r):

for fp1, sp1, fn1, sn1 in v2p4[v]:

for fp2, sp2, fn2, sn2 in v2p4r[v]:

if {fp1, fn1} == {fp2, fn2}:

if len({sp1, sn1, sp2, sn2}) == 4:

# check that the unchecked pairs have the correct values

if len({pair_value(fp1, sp2), pair_value(fp2, sp1)}) == 1:

fj = f"Jo: ({f(fp1)}, {f(sp1)} -> {f(sp2)}) "

fb = f"Bo: ({f(fn1)}, {f(sn1)} -> {f(sn2)}) "

print(fj, fb)

John Z permalink


from itertools import permutations

AK = ' A23456789TJQK' # card values as a single character (T = 10)

# calculate hand value
def handvalue(cards):
  # zero if there is a matching pair of face values
  if cards[0][1] == cards[1][1]:
    return 0
  
  tot = 0
  for i, c in enumerate(cards):
    if c[0] == 'S': # “Spade” squares it
      tot += c[1] ** 2
    elif c[0] == 'H': # “Heart” halves it
      tot += c[1] / 2
    elif c[0] == 'D': # “Diamond” divides it by the other card’s face value
      tot += c[1] / cards[1 - i][1]
    else:  # “Club” changes its sign
      tot -= c[1]
  return tot 

def hf(cards): # format a hand for output
  return '(' + ', '.join(AK[c[1]] + c[0] for c in cards)
      
# four different suits
for s in permutations('CDHS'):

  # four different face values
  for v in permutations(range(1, 14), 4):
    # four cards suits and values
    sv = tuple(zip(s,v))

    # Jo & Bo's intial hand values
    Joi, Boi = handvalue(sv[:2]), handvalue(sv[2:])

    # is Jo's hand a whole number > 0 and the negative of Bo
    if Joi == abs(int(Joi)) and Boi == -Joi:
      # For their hand value to remain the same after the card exchange,
      # The card drawn must have a different suit from the original so
      # Bo and Jo's new second cards will have the same suits as Jo and Bo's
      # Old second cards respectively

      # consider value of Jo's new second card
      for jv2 in set(range(1, 14)) - {v[3]}:
        # hand value for old first card + new second card
        Jof = handvalue((sv[0], (s[3], jv2)))

        # Jo's final hand value == initial hand value?
        if Jof == Joi:
          # consider Bo's second card
          for bv2 in set(range(1, 14)) - {v[1]}:
            # Bo's final hand value == initial hand value?
            Bof = handvalue((sv[2], (s[1], bv2)))
            
            if Bof == Boi:
              print('Jo:', hf(sv[:2]), '->', AK[jv2] + s[3] + ')   '
                    'Bo:', hf(sv[2:]), '->', AK[bv2] + s[1] + ')')

from itertools import permutations

AK = ' A23456789TJQK' # card values as a single character (T = 10)

# calculate hand value

def handvalue(cards):

# zero if there is a matching pair of face values

if cards[0][1] == cards[1][1]:

return 0

tot = 0

for i, c in enumerate(cards):

if c[0] == 'S': # “Spade” squares it

tot += c[1] ** 2

elif c[0] == 'H': # “Heart” halves it

tot += c[1] / 2

elif c[0] == 'D': # “Diamond” divides it by the other card’s face value

tot += c[1] / cards[1 - i][1]

else: # “Club” changes its sign

tot -= c[1]

return tot

def hf(cards): # format a hand for output

return '(' + ', '.join(AK[c[1]] + c[0] for c in cards)

# four different suits

for s in permutations('CDHS'):

# four different face values

for v in permutations(range(1, 14), 4):

# four cards suits and values

sv = tuple(zip(s,v))

# Jo & Bo's intial hand values

Joi, Boi = handvalue(sv[:2]), handvalue(sv[2:])

# is Jo's hand a whole number > 0 and the negative of Bo

if Joi == abs(int(Joi)) and Boi == -Joi:

# For their hand value to remain the same after the card exchange,

# The card drawn must have a different suit from the original so

# Bo and Jo's new second cards will have the same suits as Jo and Bo's

# Old second cards respectively

# consider value of Jo's new second card

for jv2 in set(range(1, 14)) - {v[3]}:

# hand value for old first card + new second card

Jof = handvalue((sv[0], (s[3], jv2)))

# Jo's final hand value == initial hand value?

if Jof == Joi:

# consider Bo's second card

for bv2 in set(range(1, 14)) - {v[1]}:

# Bo's final hand value == initial hand value?

Bof = handvalue((sv[2], (s[1], bv2)))

if Bof == Boi:

print('Jo:', hf(sv[:2]), '->', AK[jv2] + s[3] + ') '

'Bo:', hf(sv[2:]), '->', AK[bv2] + s[1] + ')')

John Z permalink

A hybrid of Brian’s code and mine with an added twist: dictionary keys that are a tuple of hand score and the two suits of the hand. The values of the dictionaries are the 2 card values.


from itertools import permutations
from collections import defaultdict

AK = ' A23456789TJQK' # card values as a single character (T = 10)

# calculate hand value
def handscore(cards):
  # zero if there is a matching pair of face values
  if cards[0][1] == cards[1][1]:
    return 0
  
  tot = 0
  for i, c in enumerate(cards):
    if c[0] == 'S': # “Spade” squares it
      tot += c[1] ** 2
    elif c[0] == 'H': # “Heart” halves it
      tot += c[1] / 2
    elif c[0] == 'D': # “Diamond” divides it by the other card’s face value
      tot += c[1] / cards[1 - i][1]
    else:  # “Club” changes its sign
      tot -= c[1]
  toti = int(tot)
  return toti if toti == tot else 0

# make dictionaries of positive and negative hand scores; key: score, suits
vsp, vsn = defaultdict(list), defaultdict(list)

# Permutations of 52 cards by 2 such that no repeat of suits or values
# two different suits
for s in permutations('SHDC', 2):

  # two different face values
  for v in permutations(range(1, 14), 2):
    
    # intial hand value
    hv = handscore(tuple(zip(s,v))) # two cards suits and values zipped

    if hv: # ignore zero hand values
      # save hand card values in dictionaries; key = score and cards suits
      (vsp if hv > 0 else vsn)[(hv, s[0], s[1])] += [(v)] # cf Brian's line 32
    
# consider positive score (Jo's) hands
for Jo in vsp.items():

  # consider two different orders of suits for Bo (leftover from Jo's suits)
  for k in permutations(set('SHDC').difference(Jo[0][1:])):

    # consider Bo's card pair values, if any  
    for Bov in vsn[(-Jo[0][0],) + k]: # index by hand score, 2 suits
  
      # consider Jo's card pair values
      for Jov in Jo[1]:
        if len(set(Jov + Bov)) == 4: # must have 4 different values

          #Jo's final hand
          Jofs = (Jo[0][1], k[1]) # suits 1 and 2
          # consider value of second card (can't be value of Bo's second card)
          for m in set(range(1, 14)) - {Bov[1]}:
            Jofv = (Jov[0], m) # original first card + new second card values

            # is final score same as initial score?
            if handscore(list(zip(Jofs, Jofv))) == Jo[0][0]:

              #Bo's final hand
              Bofs = (k[0], Jo[0][2])
              for n in set(range(1, 14)) - {Jov[1]}: #not value of Jo's 2nd card
                Bofv = (Bov[0], n)
                
                if handscore(tuple(zip(Bofs, Bofv))) == -Jo[0][0]:
                  
                  print(f'Jo: ({AK[Jov[0]]}{Jo[0][1]}, {AK[Jov[1]]}{Jo[0][2]}'
                        f' -> {AK[Jofv[1]]}{Jofs[1]}  ',
                        f'Bo: ({Bov[0]}{k[0]}, {Bov[1]}{k[1]})',
                        f' -> {AK[Bofv[1]]}{Bofs[1]}) ')

from itertools import permutations

from collections import defaultdict

AK = ' A23456789TJQK' # card values as a single character (T = 10)

# calculate hand value

def handscore(cards):

# zero if there is a matching pair of face values

if cards[0][1] == cards[1][1]:

return 0

tot = 0

for i, c in enumerate(cards):

if c[0] == 'S': # “Spade” squares it

tot += c[1] ** 2

elif c[0] == 'H': # “Heart” halves it

tot += c[1] / 2

elif c[0] == 'D': # “Diamond” divides it by the other card’s face value

tot += c[1] / cards[1 - i][1]

else: # “Club” changes its sign

tot -= c[1]

toti = int(tot)

return toti if toti == tot else 0

# make dictionaries of positive and negative hand scores; key: score, suits

vsp, vsn = defaultdict(list), defaultdict(list)

# Permutations of 52 cards by 2 such that no repeat of suits or values

# two different suits

for s in permutations('SHDC', 2):

# two different face values

for v in permutations(range(1, 14), 2):

# intial hand value

hv = handscore(tuple(zip(s,v))) # two cards suits and values zipped

if hv: # ignore zero hand values

# save hand card values in dictionaries; key = score and cards suits

(vsp if hv > 0 else vsn)[(hv, s[0], s[1])] += [(v)] # cf Brian's line 32

# consider positive score (Jo's) hands

for Jo in vsp.items():

# consider two different orders of suits for Bo (leftover from Jo's suits)

for k in permutations(set('SHDC').difference(Jo[0][1:])):

# consider Bo's card pair values, if any

for Bov in vsn[(-Jo[0][0],) + k]: # index by hand score, 2 suits

# consider Jo's card pair values

for Jov in Jo[1]:

if len(set(Jov + Bov)) == 4: # must have 4 different values

#Jo's final hand

Jofs = (Jo[0][1], k[1]) # suits 1 and 2

# consider value of second card (can't be value of Bo's second card)

for m in set(range(1, 14)) - {Bov[1]}:

Jofv = (Jov[0], m) # original first card + new second card values

# is final score same as initial score?

if handscore(list(zip(Jofs, Jofv))) == Jo[0][0]:

#Bo's final hand

Bofs = (k[0], Jo[0][2])

for n in set(range(1, 14)) - {Jov[1]}: #not value of Jo's 2nd card

Bofv = (Bov[0], n)

if handscore(tuple(zip(Bofs, Bofv))) == -Jo[0][0]:

print(f'Jo: ({AK[Jov[0]]}{Jo[0][1]}, {AK[Jov[1]]}{Jo[0][2]}'

f' -> {AK[Jofv[1]]}{Jofs[1]} ',

f'Bo: ({Bov[0]}{k[0]}, {Bov[1]}{k[1]})',

f' -> {AK[Bofv[1]]}{Bofs[1]}) ')

Sunday Times Teaser 3190 – Mods-In-Suits

by Stephen Hogg

Sunday November 12 2023 (link)

Leave a Reply Cancel reply

Recent Posts

Recent Comments

Archives

Categories

Meta