FA-81981 / Poker hand evaluation / Open access

Folded hole cards still reach showdown · case 01

A player who folded a set is declared the winner.

Verified by executionVariant 1 · 8 checks per implementationDownload source bundle ↓JSON ↗

ROOT CAUSE

Players are skipped only when their hole cards are empty, but folded seats keep their cards in the record.

VERIFIED REPAIR

Skip every player named in the folded list.

Unsuccessful approach: Skipping only the most recent folder still lets earlier folders win.

Case contract

Input: {"board": five community cards, "players": {name: two hole cards}, "folded": [names]}. Each live player uses the best five of their seven cards (zero, one or two hole cards may play). Return the sorted list of live players holding the best hand; ties split.

Why this case matters

Poker engines settle real money pots from these comparisons; a single misranked hand pays the wrong seat.

1 / The failure

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json
import collections
import itertools
N = 1
observations = []
def solve(x):
    R='23456789TJQKA'
    def key5(h):
        vals=sorted((R.index(c[0])+2 for c in h), reverse=True)
        cnt=collections.Counter(vals)
        order=sorted(cnt, key=lambda v:(cnt[v],v), reverse=True)
        shape=sorted(cnt.values(), reverse=True)
        flush=len({c[1] for c in h})==1
        straight=len(cnt)==5 and (vals[0]-vals[4]==4 or vals==[14,5,4,3,2])
        top=5 if vals==[14,5,4,3,2] else vals[0]
        if straight and flush: return (8,[top])
        if shape==[4,1]: return (7,order)
        if shape==[3,2]: return (6,order)
        if flush: return (5,vals)
        if straight: return (4,[top])
        if shape==[3,1,1]: return (3,order)
        if shape==[2,2,1]: return (2,order)
        if shape==[2,1,1,1]: return (1,order)
        return (0,vals)
    
    board=x['board']; folded=x.get('folded',[])
    scores={}
    for name,hole in x['players'].items():
        if not hole: continue
        scores[name]=max(key5(c) for c in itertools.combinations(hole+board,5))
    best=max(scores.values())
    return sorted(n for n,k in scores.items() if k==best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('flush fourth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2c'], 'bob': ['8h', '2d']}},
   ['bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann'])],
 [('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('flush fourth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2c'], 'bob': ['8h', '2d']}},
   ['bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann']),
  ('flush kickers deep',
   {'board': ['Ah', 'Kh', '9h', '3d', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2h'], 'bob': ['8h', '2c']}},
   ['ann']),
  ('same category different kicker',
   {'board': ['Ah', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', 'Kd'], 'bob': ['8s', 'Qd']}},
   ['ann']),
  ('two pair split',
   {'board': ['Kh', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['As', '4d']}},
   ['ann', 'bob'])],
 [('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush kickers deep',
   {'board': ['Ah', 'Kh', '9h', '3d', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2h'], 'bob': ['8h', '2c']}},
   ['ann']),
  ('same category different kicker',
   {'board': ['Ah', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', 'Kd'], 'bob': ['8s', 'Qd']}},
   ['ann']),
  ('two pair split',
   {'board': ['Kh', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['As', '4d']}},
   ['ann', 'bob']),
  ('set beats two pair',
   {'board': ['Kh', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', '8s'], 'bob': ['Kc', '7d']}},
   ['ann']),
  ('three-way split',
   {'board': ['6h', '7d', '8c', '9s', 'Th'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['2h', '3c'], 'cat': ['2d', '4c']}},
   ['ann', 'bob', 'cat']),
  ('single hole flush',
   {'board': ['2s', '7s', '9s', 'Js', '4d'],
    'folded': [],
    'players': {'ann': ['As', 'Kd'], 'bob': ['Qc', 'Qd']}},
   ['ann'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('set beats two pair',
   {'board': ['Kh', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', '8s'], 'bob': ['Kc', '7d']}},
   ['ann']),
  ('three-way split',
   {'board': ['6h', '7d', '8c', '9s', 'Th'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['2h', '3c'], 'cat': ['2d', '4c']}},
   ['ann', 'bob', 'cat']),
  ('single hole flush',
   {'board': ['2s', '7s', '9s', 'Js', '4d'],
    'folded': [],
    'players': {'ann': ['As', 'Kd'], 'bob': ['Qc', 'Qd']}},
   ['ann'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('flush fourth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2c'], 'bob': ['8h', '2d']}},
   ['bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann'])]]
for label, args, expected in fixtures[N-1]:
    try:
        actual = solve(args)
    except Exception as exc:
        actual = 'error:' + type(exc).__name__
    check(label, actual, expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
board plays for both	`['ann', 'bob']`	`['ann', 'bob']`	Passed
one hole card plays	`['ann']`	`['ann']`	Passed
kicker on paired board	`['ann']`	`['ann']`	Passed
folded best hand ignored	`['ann']`	`['cat']`	Failed
folded first then other	`['ann']`	`['bob']`	Failed
flush second card decides	`['ann']`	`['ann']`	Passed
flush fourth card decides	`['bob']`	`['bob']`	Passed
flush fifth card decides	`['ann']`	`['ann']`	Passed

SHA-256 / dcbb04187669ade3553bac865fbde378c3ee9dc780a99fe0e168685ee38645fb

2 / The unsuccessful fix

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json
import collections
import itertools
N = 1
observations = []
def solve(x):
    R='23456789TJQKA'
    def key5(h):
        vals=sorted((R.index(c[0])+2 for c in h), reverse=True)
        cnt=collections.Counter(vals)
        order=sorted(cnt, key=lambda v:(cnt[v],v), reverse=True)
        shape=sorted(cnt.values(), reverse=True)
        flush=len({c[1] for c in h})==1
        straight=len(cnt)==5 and (vals[0]-vals[4]==4 or vals==[14,5,4,3,2])
        top=5 if vals==[14,5,4,3,2] else vals[0]
        if straight and flush: return (8,[top])
        if shape==[4,1]: return (7,order)
        if shape==[3,2]: return (6,order)
        if flush: return (5,vals)
        if straight: return (4,[top])
        if shape==[3,1,1]: return (3,order)
        if shape==[2,2,1]: return (2,order)
        if shape==[2,1,1,1]: return (1,order)
        return (0,vals)
    
    board=x['board']; folded=x.get('folded',[])
    scores={}
    for name,hole in x['players'].items():
        if folded and name==folded[-1]: continue
        scores[name]=max(key5(c) for c in itertools.combinations(hole+board,5))
    best=max(scores.values())
    return sorted(n for n,k in scores.items() if k==best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('flush fourth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2c'], 'bob': ['8h', '2d']}},
   ['bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann'])],
 [('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('flush fourth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2c'], 'bob': ['8h', '2d']}},
   ['bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann']),
  ('flush kickers deep',
   {'board': ['Ah', 'Kh', '9h', '3d', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2h'], 'bob': ['8h', '2c']}},
   ['ann']),
  ('same category different kicker',
   {'board': ['Ah', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', 'Kd'], 'bob': ['8s', 'Qd']}},
   ['ann']),
  ('two pair split',
   {'board': ['Kh', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['As', '4d']}},
   ['ann', 'bob'])],
 [('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush kickers deep',
   {'board': ['Ah', 'Kh', '9h', '3d', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2h'], 'bob': ['8h', '2c']}},
   ['ann']),
  ('same category different kicker',
   {'board': ['Ah', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', 'Kd'], 'bob': ['8s', 'Qd']}},
   ['ann']),
  ('two pair split',
   {'board': ['Kh', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['As', '4d']}},
   ['ann', 'bob']),
  ('set beats two pair',
   {'board': ['Kh', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', '8s'], 'bob': ['Kc', '7d']}},
   ['ann']),
  ('three-way split',
   {'board': ['6h', '7d', '8c', '9s', 'Th'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['2h', '3c'], 'cat': ['2d', '4c']}},
   ['ann', 'bob', 'cat']),
  ('single hole flush',
   {'board': ['2s', '7s', '9s', 'Js', '4d'],
    'folded': [],
    'players': {'ann': ['As', 'Kd'], 'bob': ['Qc', 'Qd']}},
   ['ann'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('set beats two pair',
   {'board': ['Kh', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', '8s'], 'bob': ['Kc', '7d']}},
   ['ann']),
  ('three-way split',
   {'board': ['6h', '7d', '8c', '9s', 'Th'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['2h', '3c'], 'cat': ['2d', '4c']}},
   ['ann', 'bob', 'cat']),
  ('single hole flush',
   {'board': ['2s', '7s', '9s', 'Js', '4d'],
    'folded': [],
    'players': {'ann': ['As', 'Kd'], 'bob': ['Qc', 'Qd']}},
   ['ann'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('flush fourth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2c'], 'bob': ['8h', '2d']}},
   ['bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann'])]]
for label, args, expected in fixtures[N-1]:
    try:
        actual = solve(args)
    except Exception as exc:
        actual = 'error:' + type(exc).__name__
    check(label, actual, expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
board plays for both	`['ann', 'bob']`	`['ann', 'bob']`	Passed
one hole card plays	`['ann']`	`['ann']`	Passed
kicker on paired board	`['ann']`	`['ann']`	Passed
folded best hand ignored	`['ann']`	`['cat']`	Failed
folded first then other	`['cat']`	`['bob']`	Failed
flush second card decides	`['ann']`	`['ann']`	Passed
flush fourth card decides	`['bob']`	`['bob']`	Passed
flush fifth card decides	`['ann']`	`['ann']`	Passed

SHA-256 / 1d4f9a50511cd8ffc3b4a5133b764e925fee7a26c8b646bd2eda6b3ef6dced35

3 / The verified repair

Exit 0

"""Failure Map reference implementation. Python standard library only."""
import json
import collections
import itertools
N = 1
observations = []
def solve(x):
    R='23456789TJQKA'
    def key5(h):
        vals=sorted((R.index(c[0])+2 for c in h), reverse=True)
        cnt=collections.Counter(vals)
        order=sorted(cnt, key=lambda v:(cnt[v],v), reverse=True)
        shape=sorted(cnt.values(), reverse=True)
        flush=len({c[1] for c in h})==1
        straight=len(cnt)==5 and (vals[0]-vals[4]==4 or vals==[14,5,4,3,2])
        top=5 if vals==[14,5,4,3,2] else vals[0]
        if straight and flush: return (8,[top])
        if shape==[4,1]: return (7,order)
        if shape==[3,2]: return (6,order)
        if flush: return (5,vals)
        if straight: return (4,[top])
        if shape==[3,1,1]: return (3,order)
        if shape==[2,2,1]: return (2,order)
        if shape==[2,1,1,1]: return (1,order)
        return (0,vals)
    
    board=x['board']; folded=x.get('folded',[])
    scores={}
    for name,hole in x['players'].items():
        if name in folded: continue
        scores[name]=max(key5(c) for c in itertools.combinations(hole+board,5))
    best=max(scores.values())
    return sorted(n for n,k in scores.items() if k==best)
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('flush fourth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2c'], 'bob': ['8h', '2d']}},
   ['bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann'])],
 [('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('flush fourth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2c'], 'bob': ['8h', '2d']}},
   ['bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann']),
  ('flush kickers deep',
   {'board': ['Ah', 'Kh', '9h', '3d', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2h'], 'bob': ['8h', '2c']}},
   ['ann']),
  ('same category different kicker',
   {'board': ['Ah', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', 'Kd'], 'bob': ['8s', 'Qd']}},
   ['ann']),
  ('two pair split',
   {'board': ['Kh', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['As', '4d']}},
   ['ann', 'bob'])],
 [('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush kickers deep',
   {'board': ['Ah', 'Kh', '9h', '3d', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2h'], 'bob': ['8h', '2c']}},
   ['ann']),
  ('same category different kicker',
   {'board': ['Ah', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', 'Kd'], 'bob': ['8s', 'Qd']}},
   ['ann']),
  ('two pair split',
   {'board': ['Kh', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['As', '4d']}},
   ['ann', 'bob']),
  ('set beats two pair',
   {'board': ['Kh', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', '8s'], 'bob': ['Kc', '7d']}},
   ['ann']),
  ('three-way split',
   {'board': ['6h', '7d', '8c', '9s', 'Th'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['2h', '3c'], 'cat': ['2d', '4c']}},
   ['ann', 'bob', 'cat']),
  ('single hole flush',
   {'board': ['2s', '7s', '9s', 'Js', '4d'],
    'folded': [],
    'players': {'ann': ['As', 'Kd'], 'bob': ['Qc', 'Qd']}},
   ['ann'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('set beats two pair',
   {'board': ['Kh', '8d', '7c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['8c', '8s'], 'bob': ['Kc', '7d']}},
   ['ann']),
  ('three-way split',
   {'board': ['6h', '7d', '8c', '9s', 'Th'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['2h', '3c'], 'cat': ['2d', '4c']}},
   ['ann', 'bob', 'cat']),
  ('single hole flush',
   {'board': ['2s', '7s', '9s', 'Js', '4d'],
    'folded': [],
    'players': {'ann': ['As', 'Kd'], 'bob': ['Qc', 'Qd']}},
   ['ann'])],
 [('board plays for both',
   {'board': ['Th', 'Jd', 'Qc', 'Ks', 'Ah'],
    'folded': [],
    'players': {'ann': ['2c', '3d'], 'bob': ['4h', '5s']}},
   ['ann', 'bob']),
  ('one hole card plays',
   {'board': ['Ah', 'Kd', '7c', '7s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', '3d'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('kicker on paired board',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': [],
    'players': {'ann': ['Ac', 'Jd'], 'bob': ['Kc', 'Qs']}},
   ['ann']),
  ('folded best hand ignored',
   {'board': ['9h', '9d', '5c', '4s', '2h'],
    'folded': ['ann', 'dee'],
    'players': {'ann': ['9c', '9s'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['cat']),
  ('folded first then other',
   {'board': ['2h', '7d', '9c', 'Js', '4h'],
    'folded': ['cat', 'ann'],
    'players': {'ann': ['Jc', 'Jh'], 'bob': ['Kc', 'Qs'], 'cat': ['Ac', '3s']}},
   ['bob']),
  ('flush second card decides',
   {'board': ['2h', '7h', '9h', 'Jd', '4s'],
    'folded': [],
    'players': {'ann': ['Ah', '3h'], 'bob': ['Kh', 'Qh']}},
   ['ann']),
  ('flush fourth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['7h', '2c'], 'bob': ['8h', '2d']}},
   ['bob']),
  ('flush fifth card decides',
   {'board': ['Ah', 'Th', '9h', '3h', '4s'],
    'folded': [],
    'players': {'ann': ['2h', 'Kc'], 'bob': ['Kd', '2d']}},
   ['ann'])]]
for label, args, expected in fixtures[N-1]:
    try:
        actual = solve(args)
    except Exception as exc:
        actual = 'error:' + type(exc).__name__
    check(label, actual, expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
board plays for both	`['ann', 'bob']`	`['ann', 'bob']`	Passed
one hole card plays	`['ann']`	`['ann']`	Passed
kicker on paired board	`['ann']`	`['ann']`	Passed
folded best hand ignored	`['cat']`	`['cat']`	Passed
folded first then other	`['bob']`	`['bob']`	Passed
flush second card decides	`['ann']`	`['ann']`	Passed
flush fourth card decides	`['bob']`	`['bob']`	Passed
flush fifth card decides	`['ann']`	`['ann']`	Passed

SHA-256 / 974bb996fa44b36588134d084c6cf8a551a907c6b57bb67c48f6d1a45181b0f0

Verification & scope

A deterministic toy model with an explicitly stated contract; card strings are rank+suit (for example "As", "Td"); no claim of conformance to any casino or tournament rulebook. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.

Observations recorded using Python 3.12.14 at 2026-09-29T14:50:07.925921+00:00.

Case digest / 05f9fce1268d1dceb48e60882ff9af31c75075d6a7006d116745df7e84e9677b