FA-83916 / Sports scoring and tiebreakers / Open access
Rotations carried over into the next set · case 01
The rotation counters at the start of set two still reflect set one.
ROOT CAUSE
The rotation state is not reset when a set completes.
VERIFIED REPAIR
Reset both rotation counters when a new set starts.
Unsuccessful approach: Resetting only the set winner leaves the loser in its old rotation.
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
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: rotation reset per set',
('AABAAABABABBBAABABBAAAABABBBBABABBAABABABAAAABABAB', 'A'),
[[[25, 20], [2, 3]], None, {'A': 2, 'B': 2}]),
('variant scenario 1',
('ABBAAAABABAAABBAAABBABABBAAABBAABBBA', 'A'),
[[[20, 16]], None, {'A': 3, 'B': 3}]),
('variant scenario 2',
('AAABAABAAAABAABAAABBABBAABBBBBAABAABBABBABB', 'B'),
[[[23, 20]], None, {'A': 5, 'B': 5}])],
[('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: rotation reset per set',
('ABAAABAAABABAABAAAAABBBAAAAAABABBAAAABABAABBBBBAABABABAAABAABAAAAABBBAABAAAABAAABBBAB', 'A'),
[[[25, 11], [25, 17], [3, 4]], None, {'A': 1, 'B': 2}]),
('variant scenario 1',
('ABAAAAABABBAABABBABAAABAABABABBBABAAAAAAAABAAAAAAABAAABBAABBAAAAA', 'A'),
[[[25, 15], [19, 6]], None, {'A': 5, 'B': 4}]),
('variant scenario 2',
('ABABAAAABAABBAABAAAABBABBAABBBABABAABABABABABAABABBAAABBBBBABAAABBBAAABAABBAAAAABAABAAABA',
'A'),
[[[25, 19], [25, 18], [1, 1]], 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: rotation reset per set',
('ABBABABBBAAAABABBAAAABAABAAAABAABBAAABABABAAAAABBBBBBBABBAAAABAAAABBBAAABBAAAAABBABAABBAABBBABBBBABABBAABAABBAAAABABBABAABAAAAABBBAAAAAABAAAABBBBAABABAAAABAAAAAAABAAABBAABBABA',
'B'),
[[[25, 16], [25, 19], [25, 23]], 'A', {'A': 0, 'B': 5}]),
('variant scenario 1',
('AAABABAABAAAABBAAAABBAAAAABBABBAABAAABBABABBAAABABBBAAABABABAABBABBABABAABBAAAAABBBBAAABBABABBAABBABABBABAAABAAAABBAABBBA',
'A'),
[[[25, 12], [26, 24], [17, 17]], None, {'A': 4, 'B': 4}]),
('variant scenario 2',
('AABAABBABBBBAAAAABABBABBBBABABABABABABBAAAAAABAAAABAAAAABBAABABAAAAAAAAABAAABBAAAAAAABABAABBABAABABBAABAAABAAAAAAAAAAABABAABBABBABAAB',
'A'),
[[[25, 22], [25, 8], [25, 10]], 'A', {'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: rotation reset per set',
('AABAABBAAABAAAAABBABAAAAAAABBABBBAAAAAAAAAABBAAABAABAAAABAABBAAAABAAAABBABAAAAAAAABABBABAAABAAAAAABAAAAAABBBABBAABAAAAAABAAABAAAAAABBAAABAAABBABABABAABBBAAAAAAABABAAAAAAABBAAAABBABAABBBBA',
'A'),
[[[25, 12], [25, 8], [25, 9]], 'A', {'A': 1, 'B': 1}]),
('variant scenario 1',
('AAABAAAAAAABAAABABBBAABAAABABABBAABAABAAAB', 'A'),
[[[25, 12], [3, 2]], None, {'A': 1, 'B': 1}]),
('variant scenario 2',
('ABABAAAABAAAAABAAAAABABABBAABAAABAABAABABAABAABBABABAABBAAABBBAAAAAAAAAB', 'A'),
[[[25, 10], [23, 14]], None, {'A': 3, 'B': 3}])],
[('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: rotation reset per set',
('ABAABBBBAAAAABABBBBAAABABBBAAAAAAAAAAAAAAAAAAAAAABBAABAAAAAAAAABAAABAAABAAABAABAAAABAAABABBAAAAABAAAAAABBAAAABAAAAAAABABAAAABBAAAABABAABABAAABAAABAAABBBAAAABAABAAAAAABAAAAAAABBAAAABAABAAAAAAAAA',
'B'),
[[[25, 14], [25, 5], [25, 8]], 'A', {'A': 2, 'B': 1}]),
('variant scenario 1',
('AAAAAAAAAABABABBBABABAABAAAAAABBABBAAAABAAABAABAABAAAABAABBAAAABAABAAAAABABAAAAAAABBABAABBABABAABBAAAABABAAAAAABAAAAAAAAABBABBBAAABABA',
'B'),
[[[25, 12], [25, 9], [25, 13]], 'A', {'A': 5, 'B': 4}]),
('variant scenario 2',
('BBAABAABBAAAAABBABAABAAAAABABABAAAABAAAABAAAAAABAAAAAABBBAABABAAAABAAABBAABAABAAABAAABAAABABAABBABAAABAABAAAAAABBABAABAB',
'B'),
[[[25, 13], [25, 10], [25, 11]], 'A', {'A': 5, 'B': 4}])]]
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': 2, 'B': 0}] | [[[25, 0], [25, 0], [25, 0]], 'A', {'A': 1, 'B': 0}] | Failed |
| regression: rotation reset per set | [[[25, 20], [2, 3]], None, {'A': 3, 'B': 3}] | [[[25, 20], [2, 3]], None, {'A': 2, 'B': 2}] | Failed |
| variant scenario 1 | [[[20, 16]], None, {'A': 3, 'B': 3}] | [[[20, 16]], None, {'A': 3, 'B': 3}] | Passed |
| variant scenario 2 | [[[23, 20]], None, {'A': 5, 'B': 5}] | [[[23, 20]], None, {'A': 5, 'B': 5}] | Passed |
SHA-256 / 4804b1f55ff8e84f3b1971e8a2e2219e523c7222a251da6063eb4d423ceeb4bc
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[w] = 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: rotation reset per set',
('AABAAABABABBBAABABBAAAABABBBBABABBAABABABAAAABABAB', 'A'),
[[[25, 20], [2, 3]], None, {'A': 2, 'B': 2}]),
('variant scenario 1',
('ABBAAAABABAAABBAAABBABABBAAABBAABBBA', 'A'),
[[[20, 16]], None, {'A': 3, 'B': 3}]),
('variant scenario 2',
('AAABAABAAAABAABAAABBABBAABBBBBAABAABBABBABB', 'B'),
[[[23, 20]], None, {'A': 5, 'B': 5}])],
[('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: rotation reset per set',
('ABAAABAAABABAABAAAAABBBAAAAAABABBAAAABABAABBBBBAABABABAAABAABAAAAABBBAABAAAABAAABBBAB', 'A'),
[[[25, 11], [25, 17], [3, 4]], None, {'A': 1, 'B': 2}]),
('variant scenario 1',
('ABAAAAABABBAABABBABAAABAABABABBBABAAAAAAAABAAAAAAABAAABBAABBAAAAA', 'A'),
[[[25, 15], [19, 6]], None, {'A': 5, 'B': 4}]),
('variant scenario 2',
('ABABAAAABAABBAABAAAABBABBAABBBABABAABABABABABAABABBAAABBBBBABAAABBBAAABAABBAAAAABAABAAABA',
'A'),
[[[25, 19], [25, 18], [1, 1]], 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: rotation reset per set',
('ABBABABBBAAAABABBAAAABAABAAAABAABBAAABABABAAAAABBBBBBBABBAAAABAAAABBBAAABBAAAAABBABAABBAABBBABBBBABABBAABAABBAAAABABBABAABAAAAABBBAAAAAABAAAABBBBAABABAAAABAAAAAAABAAABBAABBABA',
'B'),
[[[25, 16], [25, 19], [25, 23]], 'A', {'A': 0, 'B': 5}]),
('variant scenario 1',
('AAABABAABAAAABBAAAABBAAAAABBABBAABAAABBABABBAAABABBBAAABABABAABBABBABABAABBAAAAABBBBAAABBABABBAABBABABBABAAABAAAABBAABBBA',
'A'),
[[[25, 12], [26, 24], [17, 17]], None, {'A': 4, 'B': 4}]),
('variant scenario 2',
('AABAABBABBBBAAAAABABBABBBBABABABABABABBAAAAAABAAAABAAAAABBAABABAAAAAAAAABAAABBAAAAAAABABAABBABAABABBAABAAABAAAAAAAAAAABABAABBABBABAAB',
'A'),
[[[25, 22], [25, 8], [25, 10]], 'A', {'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: rotation reset per set',
('AABAABBAAABAAAAABBABAAAAAAABBABBBAAAAAAAAAABBAAABAABAAAABAABBAAAABAAAABBABAAAAAAAABABBABAAABAAAAAABAAAAAABBBABBAABAAAAAABAAABAAAAAABBAAABAAABBABABABAABBBAAAAAAABABAAAAAAABBAAAABBABAABBBBA',
'A'),
[[[25, 12], [25, 8], [25, 9]], 'A', {'A': 1, 'B': 1}]),
('variant scenario 1',
('AAABAAAAAAABAAABABBBAABAAABABABBAABAABAAAB', 'A'),
[[[25, 12], [3, 2]], None, {'A': 1, 'B': 1}]),
('variant scenario 2',
('ABABAAAABAAAAABAAAAABABABBAABAAABAABAABABAABAABBABABAABBAAABBBAAAAAAAAAB', 'A'),
[[[25, 10], [23, 14]], None, {'A': 3, 'B': 3}])],
[('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: rotation reset per set',
('ABAABBBBAAAAABABBBBAAABABBBAAAAAAAAAAAAAAAAAAAAAABBAABAAAAAAAAABAAABAAABAAABAABAAAABAAABABBAAAAABAAAAAABBAAAABAAAAAAABABAAAABBAAAABABAABABAAABAAABAAABBBAAAABAABAAAAAABAAAAAAABBAAAABAABAAAAAAAAA',
'B'),
[[[25, 14], [25, 5], [25, 8]], 'A', {'A': 2, 'B': 1}]),
('variant scenario 1',
('AAAAAAAAAABABABBBABABAABAAAAAABBABBAAAABAAABAABAABAAAABAABBAAAABAABAAAAABABAAAAAAABBABAABBABABAABBAAAABABAAAAAABAAAAAAAAABBABBBAAABABA',
'B'),
[[[25, 12], [25, 9], [25, 13]], 'A', {'A': 5, 'B': 4}]),
('variant scenario 2',
('BBAABAABBAAAAABBABAABAAAAABABABAAAABAAAABAAAAAABAAAAAABBBAABABAAAABAAABBAABAABAAABAAABAAABABAABBABAAABAABAAAAAABBABAABAB',
'B'),
[[[25, 13], [25, 10], [25, 11]], 'A', {'A': 5, 'B': 4}])]]
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: rotation reset per set | [[[25, 20], [2, 3]], None, {'A': 2, 'B': 3}] | [[[25, 20], [2, 3]], None, {'A': 2, 'B': 2}] | Failed |
| variant scenario 1 | [[[20, 16]], None, {'A': 3, 'B': 3}] | [[[20, 16]], None, {'A': 3, 'B': 3}] | Passed |
| variant scenario 2 | [[[23, 20]], None, {'A': 5, 'B': 5}] | [[[23, 20]], None, {'A': 5, 'B': 5}] | Passed |
SHA-256 / 8efabb6e630c46cce8c55c086c854dbe226553ac6c2454c3c4a9bd60c08b435a
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: rotation reset per set',
('AABAAABABABBBAABABBAAAABABBBBABABBAABABABAAAABABAB', 'A'),
[[[25, 20], [2, 3]], None, {'A': 2, 'B': 2}]),
('variant scenario 1',
('ABBAAAABABAAABBAAABBABABBAAABBAABBBA', 'A'),
[[[20, 16]], None, {'A': 3, 'B': 3}]),
('variant scenario 2',
('AAABAABAAAABAABAAABBABBAABBBBBAABAABBABBABB', 'B'),
[[[23, 20]], None, {'A': 5, 'B': 5}])],
[('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: rotation reset per set',
('ABAAABAAABABAABAAAAABBBAAAAAABABBAAAABABAABBBBBAABABABAAABAABAAAAABBBAABAAAABAAABBBAB', 'A'),
[[[25, 11], [25, 17], [3, 4]], None, {'A': 1, 'B': 2}]),
('variant scenario 1',
('ABAAAAABABBAABABBABAAABAABABABBBABAAAAAAAABAAAAAAABAAABBAABBAAAAA', 'A'),
[[[25, 15], [19, 6]], None, {'A': 5, 'B': 4}]),
('variant scenario 2',
('ABABAAAABAABBAABAAAABBABBAABBBABABAABABABABABAABABBAAABBBBBABAAABBBAAABAABBAAAAABAABAAABA',
'A'),
[[[25, 19], [25, 18], [1, 1]], 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: rotation reset per set',
('ABBABABBBAAAABABBAAAABAABAAAABAABBAAABABABAAAAABBBBBBBABBAAAABAAAABBBAAABBAAAAABBABAABBAABBBABBBBABABBAABAABBAAAABABBABAABAAAAABBBAAAAAABAAAABBBBAABABAAAABAAAAAAABAAABBAABBABA',
'B'),
[[[25, 16], [25, 19], [25, 23]], 'A', {'A': 0, 'B': 5}]),
('variant scenario 1',
('AAABABAABAAAABBAAAABBAAAAABBABBAABAAABBABABBAAABABBBAAABABABAABBABBABABAABBAAAAABBBBAAABBABABBAABBABABBABAAABAAAABBAABBBA',
'A'),
[[[25, 12], [26, 24], [17, 17]], None, {'A': 4, 'B': 4}]),
('variant scenario 2',
('AABAABBABBBBAAAAABABBABBBBABABABABABABBAAAAAABAAAABAAAAABBAABABAAAAAAAAABAAABBAAAAAAABABAABBABAABABBAABAAABAAAAAAAAAAABABAABBABBABAAB',
'A'),
[[[25, 22], [25, 8], [25, 10]], 'A', {'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: rotation reset per set',
('AABAABBAAABAAAAABBABAAAAAAABBABBBAAAAAAAAAABBAAABAABAAAABAABBAAAABAAAABBABAAAAAAAABABBABAAABAAAAAABAAAAAABBBABBAABAAAAAABAAABAAAAAABBAAABAAABBABABABAABBBAAAAAAABABAAAAAAABBAAAABBABAABBBBA',
'A'),
[[[25, 12], [25, 8], [25, 9]], 'A', {'A': 1, 'B': 1}]),
('variant scenario 1',
('AAABAAAAAAABAAABABBBAABAAABABABBAABAABAAAB', 'A'),
[[[25, 12], [3, 2]], None, {'A': 1, 'B': 1}]),
('variant scenario 2',
('ABABAAAABAAAAABAAAAABABABBAABAAABAABAABABAABAABBABABAABBAAABBBAAAAAAAAAB', 'A'),
[[[25, 10], [23, 14]], None, {'A': 3, 'B': 3}])],
[('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: rotation reset per set',
('ABAABBBBAAAAABABBBBAAABABBBAAAAAAAAAAAAAAAAAAAAAABBAABAAAAAAAAABAAABAAABAAABAABAAAABAAABABBAAAAABAAAAAABBAAAABAAAAAAABABAAAABBAAAABABAABABAAABAAABAAABBBAAAABAABAAAAAABAAAAAAABBAAAABAABAAAAAAAAA',
'B'),
[[[25, 14], [25, 5], [25, 8]], 'A', {'A': 2, 'B': 1}]),
('variant scenario 1',
('AAAAAAAAAABABABBBABABAABAAAAAABBABBAAAABAAABAABAABAAAABAABBAAAABAABAAAAABABAAAAAAABBABAABBABABAABBAAAABABAAAAAABAAAAAAAAABBABBBAAABABA',
'B'),
[[[25, 12], [25, 9], [25, 13]], 'A', {'A': 5, 'B': 4}]),
('variant scenario 2',
('BBAABAABBAAAAABBABAABAAAAABABABAAAABAAAABAAAAAABAAAAAABBBAABABAAAABAAABBAABAABAAABAAABAAABABAABBABAAABAABAAAAAABBABAABAB',
'B'),
[[[25, 13], [25, 10], [25, 11]], 'A', {'A': 5, 'B': 4}])]]
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: rotation reset per set | [[[25, 20], [2, 3]], None, {'A': 2, 'B': 2}] | [[[25, 20], [2, 3]], None, {'A': 2, 'B': 2}] | Passed |
| variant scenario 1 | [[[20, 16]], None, {'A': 3, 'B': 3}] | [[[20, 16]], None, {'A': 3, 'B': 3}] | Passed |
| variant scenario 2 | [[[23, 20]], None, {'A': 5, 'B': 5}] | [[[23, 20]], None, {'A': 5, 'B': 5}] | Passed |
SHA-256 / a42c1f8df1de00136c7978c7f2591d41ffabcc8edf2f92557bd037f7bae21729
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.949401+00:00.
Case digest / c3401965da9377f5bc7b71fcf7f8e83b44cb5c4ed1ddd83dcefb6ddfbbe2b2ca