FA-83921 / Sports scoring and tiebreakers / Open access
Next set opened by the wrong server · case 01
After a set the team that won the last rally keeps serving instead of the alternating first server.
ROOT CAUSE
The server is not reassigned at the start of each set.
VERIFIED REPAIR
Alternate the first server by set number.
Unsuccessful approach: Giving the serve to the set winner still ignores the alternation rule.
Case contract
Best-of-five volleyball with rally scoring. rallies is a string of rally winners (A/B). Sets 1-4 are played to 25 and set 5 to 15, always win by two with no cap. The rally winner serves next; when the receiving team wins a rally (side-out) that team rotates once (rotation counter modulo 6). At the start of each set both rotation counters reset to 0 and the first server is first_serve in odd-numbered sets and the other team in even-numbered sets. Return [completed and current set scores as [a, b], match winner or None, rotation counters].
Why this case matters
Scoresheet apps track rotations to flag out-of-rotation faults and must reset them each set.
1 / The failure
Exit 1"""Failure Map reference implementation. Python standard library only."""
import json
N = 1
observations = []
def solve(rallies, first_serve):
won = {'A': 0, 'B': 0}
sets = []
a = b = 0
set_index = 0
server = first_serve
rot = {'A': 0, 'B': 0}
for r in rallies:
if r == 'A':
a += 1
else:
b += 1
if r != server:
rot[r] = (rot[r] + 1) % 6
server = r
target = 15 if set_index == 4 else 25
if max(a, b) >= target and abs(a - b) >= 2:
w = 'A' if a > b else 'B'
won[w] += 1
sets.append([a, b])
if won[w] == 3:
return [sets, w, rot]
a = b = 0
set_index += 1
rot = {'A': 0, 'B': 0}
return [sets + ([[a, b]] if a or b else []), None, rot]
def check(label, actual, expected):
observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
def run(args):
try:
return solve(*args)
except Exception as exc:
return 'raised ' + type(exc).__name__
cases = [[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
('boundary second set served by other team',
('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
('boundary deuce in set',
('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
[[[26, 24]], None, {'A': 0, 'B': 0}]),
('control straight-sets match',
('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
('regression: set first server',
('AAABAAABABABAAABABABABAAABBBBABAABBBABAABBBAABBAAAABAABAABBA', 'A'),
[[[25, 20], [9, 6]], None, {'A': 4, 'B': 3}]),
('variant scenario 1',
('BABBBAABBABABBBABAABAAAAABAABBABABABAABBABBABBAABBAB', 'A'),
[[[24, 26], [1, 1]], None, {'A': 1, 'B': 1}]),
('variant scenario 2',
('ABAABAAAAABAABBBBAABBAABBAABABAAAAAABAABBAA', 'B'),
[[[25, 14], [2, 2]], None, {'A': 1, 'B': 1}])],
[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
('boundary second set served by other team',
('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
('boundary deuce in set',
('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
[[[26, 24]], None, {'A': 0, 'B': 0}]),
('control straight-sets match',
('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
('regression: set first server',
('ABAABAAAAAAABABABAABBBAABBAAABBABAAAAABBAAAAAABABABABABBBBAAAABAABBBAAABAAAAAABABAAAA', 'B'),
[[[25, 13], [25, 15], [5, 2]], None, {'A': 2, 'B': 1}]),
('variant scenario 1',
('BAAAAABABBAABBABBAAAAABBBBBAABA', 'A'),
[[[17, 14]], None, {'A': 1, 'B': 1}]),
('variant scenario 2',
('AAABBAAAABAAAAABBAAAABBBAAAABBAAABBAAAAAABBAABAAAAABBAAABBABBABABABBAAABAAAABAABAABBBBABBAABAAAAABBA',
'A'),
[[[25, 12], [25, 14], [13, 11]], None, {'A': 0, 'B': 0}])],
[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
('boundary second set served by other team',
('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
('boundary deuce in set',
('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
[[[26, 24]], None, {'A': 0, 'B': 0}]),
('control straight-sets match',
('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
('regression: set first server',
('AAAAAAAAAAAABBAABAAAAABBAABAAAABBAABBAAAAAABAABABBBBABAAABBAABAAAAABAAABABBAAABABBAAAAAABABABAAAABBABAB',
'B'),
[[[25, 6], [25, 15], [19, 13]], None, {'A': 3, 'B': 3}]),
('variant scenario 1',
('ABAABAAAAABAABBABBBAAAAAAABAABBBAAABBABABBBAAABAAAAAABAABBABBAABBAABAAABAABABABAAAAABAAAABAAABABBBBAAABAA',
'A'),
[[[25, 15], [25, 16], [16, 8]], None, {'A': 5, 'B': 5}]),
('variant scenario 2',
('ABABABAAAABAAAAABAAABAABBAAAAABAAABBBBABBAABAAABAABBAAAAABAAABAA', 'A'),
[[[25, 9], [18, 12]], None, {'A': 1, 'B': 0}])],
[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
('boundary second set served by other team',
('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
('boundary deuce in set',
('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
[[[26, 24]], None, {'A': 0, 'B': 0}]),
('control straight-sets match',
('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
('regression: set first server',
('AAABBAAAAAAAABABAAABABAAABABBAABAABBABBBBBABA', 'A'),
[[[25, 12], [2, 6]], None, {'A': 2, 'B': 1}]),
('variant scenario 1',
('BAAABAAAAAAABAABBAAAABAAAAAABAAAAAAAAAAABAAABABAAABABABBAAABAAAAABAABBAAABABABBBBAAABAAAABBABAABBABABBBBABAAAAAABBAAAAAAABBABABBAB',
'A'),
[[[25, 7], [25, 8], [25, 21]], 'A', {'A': 0, 'B': 0}]),
('variant scenario 2',
('ABAAAAAAAABBBABAAAAAAABBBBBAAABAAAABBABABAABAABBABBAAAAAABAABAABAA', 'B'),
[[[25, 13], [18, 10]], None, {'A': 2, 'B': 2}])],
[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
('boundary second set served by other team',
('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
('boundary deuce in set',
('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
[[[26, 24]], None, {'A': 0, 'B': 0}]),
('control straight-sets match',
('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
('regression: set first server',
('AAAAAABAABABABAAABBABBAAAAAABAABAAAAABAAAABAAAABABBAABAABBABABAABAABBBABAABABBAABAAAAAAABAA',
'B'),
[[[25, 10], [25, 16], [11, 4]], None, {'A': 3, 'B': 2}]),
('variant scenario 1',
('ABAABAABAAAABAAABBBBAAAAABBABABABAAABBBAAAAABAABBABABABAAABAAAAAAAABAAAAAAAABAAAAAAAABBAAAABABABAABABAABAABAAABBBAAABAAAABAAAAAAABAAAABAABBBBAABBAABAABBAAAABBAABBAAA',
'A'),
[[[25, 16], [25, 8], [25, 10]], 'A', {'A': 3, 'B': 3}]),
('variant scenario 2',
('AAABBAABBBBBAAAAABBAAABBAABAAABAAABAABBAAABAABBBBBBBAABBAAAAABAAAABBAABBAABABBBAAAAAABAABAAAAABBBBBBABAABABAAAAABB',
'A'),
[[[25, 16], [25, 19], [16, 13]], None, {'A': 0, 'B': 1}])]]
for label, args, expected in cases[N - 1]:
check(label, run(args), 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 |
|---|---|---|---|
| control first rally held by server | [[[1, 0]], None, {'A': 0, 'B': 0}] | [[[1, 0]], None, {'A': 0, 'B': 0}] | Passed |
| boundary side-out rotates receiver | [[[0, 1]], None, {'A': 0, 'B': 1}] | [[[0, 1]], None, {'A': 0, 'B': 1}] | Passed |
| control clean set | [[[25, 0]], None, {'A': 0, 'B': 0}] | [[[25, 0]], None, {'A': 0, 'B': 0}] | Passed |
| boundary second set served by other team | [[[25, 0], [1, 0]], None, {'A': 0, 'B': 0}] | [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}] | Failed |
| boundary deuce in set | [[[26, 24]], None, {'A': 0, 'B': 0}] | [[[26, 24]], None, {'A': 0, 'B': 0}] | Passed |
| control straight-sets match | [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 0, 'B': 0}] | [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}] | Failed |
| regression: set first server | [[[25, 20], [9, 6]], None, {'A': 4, 'B': 4}] | [[[25, 20], [9, 6]], None, {'A': 4, 'B': 3}] | Failed |
| variant scenario 1 | [[[24, 26], [1, 1]], None, {'A': 1, 'B': 1}] | [[[24, 26], [1, 1]], None, {'A': 1, 'B': 1}] | Passed |
| variant scenario 2 | [[[25, 14], [2, 2]], None, {'A': 1, 'B': 1}] | [[[25, 14], [2, 2]], None, {'A': 1, 'B': 1}] | Passed |
SHA-256 / cbb5411c7b867b9a6c0d4e61eddc8f6c356cff45b19ba00febae72f3a88e6847
2 / The unsuccessful fix
Exit 1"""Failure Map reference implementation. Python standard library only."""
import json
N = 1
observations = []
def solve(rallies, first_serve):
won = {'A': 0, 'B': 0}
sets = []
a = b = 0
set_index = 0
server = first_serve
rot = {'A': 0, 'B': 0}
for r in rallies:
if r == 'A':
a += 1
else:
b += 1
if r != server:
rot[r] = (rot[r] + 1) % 6
server = r
target = 15 if set_index == 4 else 25
if max(a, b) >= target and abs(a - b) >= 2:
w = 'A' if a > b else 'B'
won[w] += 1
sets.append([a, b])
if won[w] == 3:
return [sets, w, rot]
a = b = 0
set_index += 1
rot = {'A': 0, 'B': 0}
server = w
return [sets + ([[a, b]] if a or b else []), None, rot]
def check(label, actual, expected):
observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
def run(args):
try:
return solve(*args)
except Exception as exc:
return 'raised ' + type(exc).__name__
cases = [[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
('boundary second set served by other team',
('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
('boundary deuce in set',
('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
[[[26, 24]], None, {'A': 0, 'B': 0}]),
('control straight-sets match',
('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
('regression: set first server',
('AAABAAABABABAAABABABABAAABBBBABAABBBABAABBBAABBAAAABAABAABBA', 'A'),
[[[25, 20], [9, 6]], None, {'A': 4, 'B': 3}]),
('variant scenario 1',
('BABBBAABBABABBBABAABAAAAABAABBABABABAABBABBABBAABBAB', 'A'),
[[[24, 26], [1, 1]], None, {'A': 1, 'B': 1}]),
('variant scenario 2',
('ABAABAAAAABAABBBBAABBAABBAABABAAAAAABAABBAA', 'B'),
[[[25, 14], [2, 2]], None, {'A': 1, 'B': 1}])],
[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
('boundary second set served by other team',
('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
('boundary deuce in set',
('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
[[[26, 24]], None, {'A': 0, 'B': 0}]),
('control straight-sets match',
('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
('regression: set first server',
('ABAABAAAAAAABABABAABBBAABBAAABBABAAAAABBAAAAAABABABABABBBBAAAABAABBBAAABAAAAAABABAAAA', 'B'),
[[[25, 13], [25, 15], [5, 2]], None, {'A': 2, 'B': 1}]),
('variant scenario 1',
('BAAAAABABBAABBABBAAAAABBBBBAABA', 'A'),
[[[17, 14]], None, {'A': 1, 'B': 1}]),
('variant scenario 2',
('AAABBAAAABAAAAABBAAAABBBAAAABBAAABBAAAAAABBAABAAAAABBAAABBABBABABABBAAABAAAABAABAABBBBABBAABAAAAABBA',
'A'),
[[[25, 12], [25, 14], [13, 11]], None, {'A': 0, 'B': 0}])],
[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
('boundary second set served by other team',
('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
('boundary deuce in set',
('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
[[[26, 24]], None, {'A': 0, 'B': 0}]),
('control straight-sets match',
('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
('regression: set first server',
('AAAAAAAAAAAABBAABAAAAABBAABAAAABBAABBAAAAAABAABABBBBABAAABBAABAAAAABAAABABBAAABABBAAAAAABABABAAAABBABAB',
'B'),
[[[25, 6], [25, 15], [19, 13]], None, {'A': 3, 'B': 3}]),
('variant scenario 1',
('ABAABAAAAABAABBABBBAAAAAAABAABBBAAABBABABBBAAABAAAAAABAABBABBAABBAABAAABAABABABAAAAABAAAABAAABABBBBAAABAA',
'A'),
[[[25, 15], [25, 16], [16, 8]], None, {'A': 5, 'B': 5}]),
('variant scenario 2',
('ABABABAAAABAAAAABAAABAABBAAAAABAAABBBBABBAABAAABAABBAAAAABAAABAA', 'A'),
[[[25, 9], [18, 12]], None, {'A': 1, 'B': 0}])],
[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
('boundary second set served by other team',
('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
('boundary deuce in set',
('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
[[[26, 24]], None, {'A': 0, 'B': 0}]),
('control straight-sets match',
('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
('regression: set first server',
('AAABBAAAAAAAABABAAABABAAABABBAABAABBABBBBBABA', 'A'),
[[[25, 12], [2, 6]], None, {'A': 2, 'B': 1}]),
('variant scenario 1',
('BAAABAAAAAAABAABBAAAABAAAAAABAAAAAAAAAAABAAABABAAABABABBAAABAAAAABAABBAAABABABBBBAAABAAAABBABAABBABABBBBABAAAAAABBAAAAAAABBABABBAB',
'A'),
[[[25, 7], [25, 8], [25, 21]], 'A', {'A': 0, 'B': 0}]),
('variant scenario 2',
('ABAAAAAAAABBBABAAAAAAABBBBBAAABAAAABBABABAABAABBABBAAAAAABAABAABAA', 'B'),
[[[25, 13], [18, 10]], None, {'A': 2, 'B': 2}])],
[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
('boundary second set served by other team',
('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
('boundary deuce in set',
('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
[[[26, 24]], None, {'A': 0, 'B': 0}]),
('control straight-sets match',
('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
('regression: set first server',
('AAAAAABAABABABAAABBABBAAAAAABAABAAAAABAAAABAAAABABBAABAABBABABAABAABBBABAABABBAABAAAAAAABAA',
'B'),
[[[25, 10], [25, 16], [11, 4]], None, {'A': 3, 'B': 2}]),
('variant scenario 1',
('ABAABAABAAAABAAABBBBAAAAABBABABABAAABBBAAAAABAABBABABABAAABAAAAAAAABAAAAAAAABAAAAAAAABBAAAABABABAABABAABAABAAABBBAAABAAAABAAAAAAABAAAABAABBBBAABBAABAABBAAAABBAABBAAA',
'A'),
[[[25, 16], [25, 8], [25, 10]], 'A', {'A': 3, 'B': 3}]),
('variant scenario 2',
('AAABBAABBBBBAAAAABBAAABBAABAAABAAABAABBAAABAABBBBBBBAABBAAAAABAAAABBAABBAABABBBAAAAAABAABAAAAABBBBBBABAABABAAAAABB',
'A'),
[[[25, 16], [25, 19], [16, 13]], None, {'A': 0, 'B': 1}])]]
for label, args, expected in cases[N - 1]:
check(label, run(args), 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 |
|---|---|---|---|
| control first rally held by server | [[[1, 0]], None, {'A': 0, 'B': 0}] | [[[1, 0]], None, {'A': 0, 'B': 0}] | Passed |
| boundary side-out rotates receiver | [[[0, 1]], None, {'A': 0, 'B': 1}] | [[[0, 1]], None, {'A': 0, 'B': 1}] | Passed |
| control clean set | [[[25, 0]], None, {'A': 0, 'B': 0}] | [[[25, 0]], None, {'A': 0, 'B': 0}] | Passed |
| boundary second set served by other team | [[[25, 0], [1, 0]], None, {'A': 0, 'B': 0}] | [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}] | Failed |
| boundary deuce in set | [[[26, 24]], None, {'A': 0, 'B': 0}] | [[[26, 24]], None, {'A': 0, 'B': 0}] | Passed |
| control straight-sets match | [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 0, 'B': 0}] | [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}] | Failed |
| regression: set first server | [[[25, 20], [9, 6]], None, {'A': 4, 'B': 4}] | [[[25, 20], [9, 6]], None, {'A': 4, 'B': 3}] | Failed |
| variant scenario 1 | [[[24, 26], [1, 1]], None, {'A': 1, 'B': 1}] | [[[24, 26], [1, 1]], None, {'A': 1, 'B': 1}] | Passed |
| variant scenario 2 | [[[25, 14], [2, 2]], None, {'A': 1, 'B': 1}] | [[[25, 14], [2, 2]], None, {'A': 1, 'B': 1}] | Passed |
SHA-256 / 3f2eb078edc64bd4e271c1a046d5c10b1f517a5ca71426431755fa22a2a1f9bd
3 / The verified repair
Exit 0"""Failure Map reference implementation. Python standard library only."""
import json
N = 1
observations = []
def solve(rallies, first_serve):
won = {'A': 0, 'B': 0}
sets = []
a = b = 0
set_index = 0
server = first_serve
rot = {'A': 0, 'B': 0}
for r in rallies:
if r == 'A':
a += 1
else:
b += 1
if r != server:
rot[r] = (rot[r] + 1) % 6
server = r
target = 15 if set_index == 4 else 25
if max(a, b) >= target and abs(a - b) >= 2:
w = 'A' if a > b else 'B'
won[w] += 1
sets.append([a, b])
if won[w] == 3:
return [sets, w, rot]
a = b = 0
set_index += 1
rot = {'A': 0, 'B': 0}
server = first_serve if set_index % 2 == 0 else ('B' if first_serve == 'A' else 'A')
return [sets + ([[a, b]] if a or b else []), None, rot]
def check(label, actual, expected):
observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
def run(args):
try:
return solve(*args)
except Exception as exc:
return 'raised ' + type(exc).__name__
cases = [[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
('boundary second set served by other team',
('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
('boundary deuce in set',
('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
[[[26, 24]], None, {'A': 0, 'B': 0}]),
('control straight-sets match',
('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
('regression: set first server',
('AAABAAABABABAAABABABABAAABBBBABAABBBABAABBBAABBAAAABAABAABBA', 'A'),
[[[25, 20], [9, 6]], None, {'A': 4, 'B': 3}]),
('variant scenario 1',
('BABBBAABBABABBBABAABAAAAABAABBABABABAABBABBABBAABBAB', 'A'),
[[[24, 26], [1, 1]], None, {'A': 1, 'B': 1}]),
('variant scenario 2',
('ABAABAAAAABAABBBBAABBAABBAABABAAAAAABAABBAA', 'B'),
[[[25, 14], [2, 2]], None, {'A': 1, 'B': 1}])],
[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
('boundary second set served by other team',
('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
('boundary deuce in set',
('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
[[[26, 24]], None, {'A': 0, 'B': 0}]),
('control straight-sets match',
('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
('regression: set first server',
('ABAABAAAAAAABABABAABBBAABBAAABBABAAAAABBAAAAAABABABABABBBBAAAABAABBBAAABAAAAAABABAAAA', 'B'),
[[[25, 13], [25, 15], [5, 2]], None, {'A': 2, 'B': 1}]),
('variant scenario 1',
('BAAAAABABBAABBABBAAAAABBBBBAABA', 'A'),
[[[17, 14]], None, {'A': 1, 'B': 1}]),
('variant scenario 2',
('AAABBAAAABAAAAABBAAAABBBAAAABBAAABBAAAAAABBAABAAAAABBAAABBABBABABABBAAABAAAABAABAABBBBABBAABAAAAABBA',
'A'),
[[[25, 12], [25, 14], [13, 11]], None, {'A': 0, 'B': 0}])],
[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
('boundary second set served by other team',
('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
('boundary deuce in set',
('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
[[[26, 24]], None, {'A': 0, 'B': 0}]),
('control straight-sets match',
('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
('regression: set first server',
('AAAAAAAAAAAABBAABAAAAABBAABAAAABBAABBAAAAAABAABABBBBABAAABBAABAAAAABAAABABBAAABABBAAAAAABABABAAAABBABAB',
'B'),
[[[25, 6], [25, 15], [19, 13]], None, {'A': 3, 'B': 3}]),
('variant scenario 1',
('ABAABAAAAABAABBABBBAAAAAAABAABBBAAABBABABBBAAABAAAAAABAABBABBAABBAABAAABAABABABAAAAABAAAABAAABABBBBAAABAA',
'A'),
[[[25, 15], [25, 16], [16, 8]], None, {'A': 5, 'B': 5}]),
('variant scenario 2',
('ABABABAAAABAAAAABAAABAABBAAAAABAAABBBBABBAABAAABAABBAAAAABAAABAA', 'A'),
[[[25, 9], [18, 12]], None, {'A': 1, 'B': 0}])],
[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
('boundary second set served by other team',
('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
('boundary deuce in set',
('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
[[[26, 24]], None, {'A': 0, 'B': 0}]),
('control straight-sets match',
('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
('regression: set first server',
('AAABBAAAAAAAABABAAABABAAABABBAABAABBABBBBBABA', 'A'),
[[[25, 12], [2, 6]], None, {'A': 2, 'B': 1}]),
('variant scenario 1',
('BAAABAAAAAAABAABBAAAABAAAAAABAAAAAAAAAAABAAABABAAABABABBAAABAAAAABAABBAAABABABBBBAAABAAAABBABAABBABABBBBABAAAAAABBAAAAAAABBABABBAB',
'A'),
[[[25, 7], [25, 8], [25, 21]], 'A', {'A': 0, 'B': 0}]),
('variant scenario 2',
('ABAAAAAAAABBBABAAAAAAABBBBBAAABAAAABBABABAABAABBABBAAAAAABAABAABAA', 'B'),
[[[25, 13], [18, 10]], None, {'A': 2, 'B': 2}])],
[('control first rally held by server', ('A', 'A'), [[[1, 0]], None, {'A': 0, 'B': 0}]),
('boundary side-out rotates receiver', ('B', 'A'), [[[0, 1]], None, {'A': 0, 'B': 1}]),
('control clean set', ('AAAAAAAAAAAAAAAAAAAAAAAAA', 'A'), [[[25, 0]], None, {'A': 0, 'B': 0}]),
('boundary second set served by other team',
('AAAAAAAAAAAAAAAAAAAAAAAAAA', 'A'),
[[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}]),
('boundary deuce in set',
('ABABABABABABABABABABABABABABABABABABABABABABABABAA', 'A'),
[[[26, 24]], None, {'A': 0, 'B': 0}]),
('control straight-sets match',
('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', 'B'),
[[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}]),
('regression: set first server',
('AAAAAABAABABABAAABBABBAAAAAABAABAAAAABAAAABAAAABABBAABAABBABABAABAABBBABAABABBAABAAAAAAABAA',
'B'),
[[[25, 10], [25, 16], [11, 4]], None, {'A': 3, 'B': 2}]),
('variant scenario 1',
('ABAABAABAAAABAAABBBBAAAAABBABABABAAABBBAAAAABAABBABABABAAABAAAAAAAABAAAAAAAABAAAAAAAABBAAAABABABAABABAABAABAAABBBAAABAAAABAAAAAAABAAAABAABBBBAABBAABAABBAAAABBAABBAAA',
'A'),
[[[25, 16], [25, 8], [25, 10]], 'A', {'A': 3, 'B': 3}]),
('variant scenario 2',
('AAABBAABBBBBAAAAABBAAABBAABAAABAAABAABBAAABAABBBBBBBAABBAAAAABAAAABBAABBAABABBBAAAAAABAABAAAAABBBBBBABAABABAAAAABB',
'A'),
[[[25, 16], [25, 19], [16, 13]], None, {'A': 0, 'B': 1}])]]
for label, args, expected in cases[N - 1]:
check(label, run(args), 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 |
|---|---|---|---|
| control first rally held by server | [[[1, 0]], None, {'A': 0, 'B': 0}] | [[[1, 0]], None, {'A': 0, 'B': 0}] | Passed |
| boundary side-out rotates receiver | [[[0, 1]], None, {'A': 0, 'B': 1}] | [[[0, 1]], None, {'A': 0, 'B': 1}] | Passed |
| control clean set | [[[25, 0]], None, {'A': 0, 'B': 0}] | [[[25, 0]], None, {'A': 0, 'B': 0}] | Passed |
| boundary second set served by other team | [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}] | [[[25, 0], [1, 0]], None, {'A': 1, 'B': 0}] | Passed |
| boundary deuce in set | [[[26, 24]], None, {'A': 0, 'B': 0}] | [[[26, 24]], None, {'A': 0, 'B': 0}] | Passed |
| control straight-sets match | [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}] | [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}] | Passed |
| regression: set first server | [[[25, 20], [9, 6]], None, {'A': 4, 'B': 3}] | [[[25, 20], [9, 6]], None, {'A': 4, 'B': 3}] | Passed |
| variant scenario 1 | [[[24, 26], [1, 1]], None, {'A': 1, 'B': 1}] | [[[24, 26], [1, 1]], None, {'A': 1, 'B': 1}] | Passed |
| variant scenario 2 | [[[25, 14], [2, 2]], None, {'A': 1, 'B': 1}] | [[[25, 14], [2, 2]], None, {'A': 1, 'B': 1}] | Passed |
SHA-256 / 1e17ec6f1418b445182521c43a40721e050d5d97a13fc2e523e9880893116978
Verification & scope
Stipulated, bounded toy contract stated in the contract field; not a claim of conformance with any governing body rulebook or operator house rules. 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:25.949045+00:00.
Case digest / c5de58d9b3981d0903874b6f8ea6fb3cc830a3039bf0ef0cd64422ee7c3b3e01