broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s)-1 <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) < pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

prompt:
Attribute run includes the preceding codepoint.

Input [length,default_attributes,spans] where spans are [start,end,attributes,priority]. Clamp endpoints to [0,length], discard empty/reversed spans. At each character position merge active spans over defaults by increasing priority, preserving input tie order; None attribute removes that attribute. Build maximal equal adjacent runs [start,end,attributes]. Zero length returns empty. Offsets are codepoints. Dictionary values are strings or None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos <= min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

meaning: Fixture-count band, not measured model difficulty

deps: stdlib

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)-1]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

prompt:
Attribute run includes its exclusive end character.

Input [length,default_attributes,spans] where spans are [start,end,attributes,priority]. Clamp endpoints to [0,length], discard empty/reversed spans. At each character position merge active spans over defaults by increasing priority, preserving input tie order; None attribute removes that attribute. Build maximal equal adjacent runs [start,end,attributes]. Zero length returns empty. Offsets are codepoints. Dictionary values are strings or None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(-x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:x[1]):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

prompt:
Lower priority style overwrites higher priority semantics.

Input [length,default_attributes,spans] where spans are [start,end,attributes,priority]. Clamp endpoints to [0,length], discard empty/reversed spans. At each character position merge active spans over defaults by increasing priority, preserving input tie order; None attribute removes that attribute. Build maximal equal adjacent runs [start,end,attributes]. Zero length returns empty. Offsets are codepoints. Dictionary values are strings or None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],-x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],-x[1] if x[0]>0 else x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

prompt:
Equal-priority semantic styles reverse source precedence.

Input [length,default_attributes,spans] where spans are [start,end,attributes,priority]. Clamp endpoints to [0,length], discard empty/reversed spans. At each character position merge active spans over defaults by increasing priority, preserving input tie order; None attribute removes that attribute. Build maximal equal adjacent runs [start,end,attributes]. Zero length returns empty. Offsets are codepoints. Dictionary values are strings or None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs[key] = None
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs[key] = ''
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

prompt:
Cleared text attributes are serialized as null values.

Input [length,default_attributes,spans] where spans are [start,end,attributes,priority]. Clamp endpoints to [0,length], discard empty/reversed spans. At each character position merge active spans over defaults by increasing priority, preserving input tie order; None attribute removes that attribute. Build maximal equal adjacent runs [start,end,attributes]. Zero length returns empty. Offsets are codepoints. Dictionary values are strings or None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = defaults
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = defaults if pos else dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

prompt:
An attribute patch contaminates subsequent text positions.

Input [length,default_attributes,spans] where spans are [start,end,attributes,priority]. Clamp endpoints to [0,length], discard empty/reversed spans. At each character position merge active spans over defaults by increasing priority, preserving input tie order; None attribute removes that attribute. Build maximal equal adjacent runs [start,end,attributes]. Zero length returns empty. Offsets are codepoints. Dictionary values are strings or None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs.setdefault(key,value)
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value if key not in defaults else defaults[key]
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

prompt:
Text run updates omit preexisting attribute replacements.

Input [length,default_attributes,spans] where spans are [start,end,attributes,priority]. Clamp endpoints to [0,length], discard empty/reversed spans. At each character position merge active spans over defaults by increasing priority, preserving input tie order; None attribute removes that attribute. Build maximal equal adjacent runs [start,end,attributes]. Zero length returns empty. Offsets are codepoints. Dictionary values are strings or None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if False: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs and not attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

prompt:
Adjacent equal attribute runs remain fragmented.

Input [length,default_attributes,spans] where spans are [start,end,attributes,priority]. Clamp endpoints to [0,length], discard empty/reversed spans. At each character position merge active spans over defaults by increasing priority, preserving input tie order; None attribute removes that attribute. Build maximal equal adjacent runs [start,end,attributes]. Zero length returns empty. Offsets are codepoints. Dictionary values are strings or None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] += 0
        else: result.append([pos,pos+1,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

prompt:
Coalesced attribute runs lose their final character.

Input [length,default_attributes,spans] where spans are [start,end,attributes,priority]. Clamp endpoints to [0,length], discard empty/reversed spans. At each character position merge active spans over defaults by increasing priority, preserving input tie order; None attribute removes that attribute. Build maximal equal adjacent runs [start,end,attributes]. Zero length returns empty. Offsets are codepoints. Dictionary values are strings or None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,defaults,spans = data
    points = []
    for pos in range(length):
        attrs = dict(defaults)
        active = [(p,i,a) for i,(s,e,a,p) in enumerate(spans) if max(0,s) <= pos < min(length,e)]
        for priority,idx,updates in sorted(active,key=lambda x:(x[0],x[1])):
            for key,value in updates.items():
                if value is None: attrs.pop(key,None)
                else: attrs[key] = value
        points.append(attrs)
    result = []
    for pos,attrs in enumerate(points):
        if result and result[-1][2] == attrs: result[-1][1] = pos+1
        else: result.append([pos,pos+2,attrs])
    return result
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+2,{'lang':'en'},[[0,N,{'weight':'bold'},1],[1,N+1,{'lang':'fr'},2]]],), [[0,1,{'lang':'en','weight':'bold'}]]+([[1,N,{'lang':'fr','weight':'bold'}]] if N>1 else [])+[[N,N+1,{'lang':'fr'}],[N+1,N+2,{'lang':'en'}]])
check('contract fixture 2', solve([3,{'lang':'en','color':'red'},[[0,3,{'lang':None},1],[1,2,{'color':'blue'},2]]],), [[0,1,{'color':'red'}],[1,2,{'color':'blue'}],[2,3,{'color':'red'}]])
check('contract fixture 3', solve([3,{},[[0,3,{'x':'high'},5],[0,3,{'x':'low'},1]]],), [[0,3,{'x':'high'}]])
check('contract fixture 4', solve([3,{},[[0,3,{'x':'first'},1],[0,3,{'x':'last'},1]]],), [[0,3,{'x':'last'}]])
check('contract fixture 5', solve([3,{},[[-3,2,{'x':'a'},0],[2,8,{'x':'a'},0],[2,1,{'x':'bad'},9]]],), [[0,3,{'x':'a'}]])
check('contract fixture 6', solve([0,{'lang':'en'},[]],), [])
check('contract fixture 7', solve([2,{'lang':'en'},[[0,1,{},0]]],), [[0,2,{'lang':'en'}]])
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)

prompt:
New attribute runs start with an empty interval.

Input [length,default_attributes,spans] where spans are [start,end,attributes,priority]. Clamp endpoints to [0,length], discard empty/reversed spans. At each character position merge active spans over defaults by increasing priority, preserving input tie order; None attribute removes that attribute. Build maximal equal adjacent runs [start,end,attributes]. Zero length returns empty. Offsets are codepoints. Dictionary values are strings or None.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([index,start,len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed and kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([index,start,len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

prompt:
Unexposed inline objects enter accessible text.

Input [tokens,alt_mode] where tokens are [kind,text,exposed], kinds text, object, break, decoration. Ignore unexposed or decoration tokens. Text is copied exactly; break becomes LF; object becomes U+FFFC unless alt_mode, when nonempty alternative text is used and empty alternative falls back to U+FFFC. Return [flattened,objects] with objects [token_index,start,end,alternative]. All offsets are codepoints in output; ordinary text does not add object mappings. Adjacent objects remain separate; zero-length text has no effect.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed: continue
        if kind == 'decoration': kind = 'text'
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([index,start,len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed: continue
        if kind == 'decoration' and value: kind = 'text'
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([index,start,len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

prompt:
Decorative text tokens consume accessibility offsets.

Input [tokens,alt_mode] where tokens are [kind,text,exposed], kinds text, object, break, decoration. Ignore unexposed or decoration tokens. Text is copied exactly; break becomes LF; object becomes U+FFFC unless alt_mode, when nonempty alternative text is used and empty alternative falls back to U+FFFC. Return [flattened,objects] with objects [token_index,start,end,alternative]. All offsets are codepoints in output; ordinary text does not add object mappings. Adjacent objects remain separate; zero-length text has no effect.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value.strip()
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([index,start,len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value+' '
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([index,start,len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

prompt:
Literal text is trimmed while constructing object offsets.

Input [tokens,alt_mode] where tokens are [kind,text,exposed], kinds text, object, break, decoration. Ignore unexposed or decoration tokens. Text is copied exactly; break becomes LF; object becomes U+FFFC unless alt_mode, when nonempty alternative text is used and empty alternative falls back to U+FFFC. Return [flattened,objects] with objects [token_index,start,end,alternative]. All offsets are codepoints in output; ordinary text does not add object mappings. Adjacent objects remain separate; zero-length text has no effect.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += ''
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([index,start,len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += value
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([index,start,len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

prompt:
Accessible line break tokens disappear from text.

Input [tokens,alt_mode] where tokens are [kind,text,exposed], kinds text, object, break, decoration. Ignore unexposed or decoration tokens. Text is copied exactly; break becomes LF; object becomes U+FFFC unless alt_mode, when nonempty alternative text is used and empty alternative falls back to U+FFFC. Return [flattened,objects] with objects [token_index,start,end,alternative]. All offsets are codepoints in output; ordinary text does not add object mappings. Adjacent objects remain separate; zero-length text has no effect.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if value else '\ufffc'
            objects.append([index,start,len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode or value else '\ufffc'
            objects.append([index,start,len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

prompt:
Object alternatives replace markers even when disabled.

Input [tokens,alt_mode] where tokens are [kind,text,exposed], kinds text, object, break, decoration. Ignore unexposed or decoration tokens. Text is copied exactly; break becomes LF; object becomes U+FFFC unless alt_mode, when nonempty alternative text is used and empty alternative falls back to U+FFFC. Return [flattened,objects] with objects [token_index,start,end,alternative]. All offsets are codepoints in output; ordinary text does not add object mappings. Adjacent objects remain separate; zero-length text has no effect.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode else '\ufffc'
            objects.append([index,start,len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode else ''
            objects.append([index,start,len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

prompt:
Empty alternative erases an embedded object position.

Input [tokens,alt_mode] where tokens are [kind,text,exposed], kinds text, object, break, decoration. Ignore unexposed or decoration tokens. Text is copied exactly; break becomes LF; object becomes U+FFFC unless alt_mode, when nonempty alternative text is used and empty alternative falls back to U+FFFC. Return [flattened,objects] with objects [token_index,start,end,alternative]. All offsets are codepoints in output; ordinary text does not add object mappings. Adjacent objects remain separate; zero-length text has no effect.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([index,len(text),len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([index,start+1,len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

prompt:
Object starts are measured after the replacement is appended.

Input [tokens,alt_mode] where tokens are [kind,text,exposed], kinds text, object, break, decoration. Ignore unexposed or decoration tokens. Text is copied exactly; break becomes LF; object becomes U+FFFC unless alt_mode, when nonempty alternative text is used and empty alternative falls back to U+FFFC. Return [flattened,objects] with objects [token_index,start,end,alternative]. All offsets are codepoints in output; ordinary text does not add object mappings. Adjacent objects remain separate; zero-length text has no effect.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([index,start,start+1,value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([index,start,start+len(value),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

prompt:
Alternative text spans retain a one-character object extent.

Input [tokens,alt_mode] where tokens are [kind,text,exposed], kinds text, object, break, decoration. Ignore unexposed or decoration tokens. Text is copied exactly; break becomes LF; object becomes U+FFFC unless alt_mode, when nonempty alternative text is used and empty alternative falls back to U+FFFC. Return [flattened,objects] with objects [token_index,start,end,alternative]. All offsets are codepoints in output; ordinary text does not add object mappings. Adjacent objects remain separate; zero-length text has no effect.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([len(objects),start,len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([index+1,start,len(text),value])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

prompt:
Inline object IDs use filtered output ordinals.

Input [tokens,alt_mode] where tokens are [kind,text,exposed], kinds text, object, break, decoration. Ignore unexposed or decoration tokens. Text is copied exactly; break becomes LF; object becomes U+FFFC unless alt_mode, when nonempty alternative text is used and empty alternative falls back to U+FFFC. Return [flattened,objects] with objects [token_index,start,end,alternative]. All offsets are codepoints in output; ordinary text does not add object mappings. Adjacent objects remain separate; zero-length text has no effect.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([index,start,len(text),''])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    tokens,alt_mode = data
    text = ''
    objects = []
    for index,(kind,value,exposed) in enumerate(tokens):
        if not exposed or kind == 'decoration': continue
        start = len(text)
        if kind == 'text': text += value
        elif kind == 'break': text += '\n'
        elif kind == 'object':
            text += value if alt_mode and value else '\ufffc'
            objects.append([index,start,len(text),text[start:]])
    return [text,objects]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([[['text','A'*N,True],['object','Cat',True],['text','Z',True]],False],), ['A'*N+'￼Z',[[1,N,N+1,'Cat']]])
check('contract fixture 2', solve([[['text','A'*N,True],['object','Cat',True],['object','',True]],True],), ['A'*N+'Cat￼',[[1,N,N+3,'Cat'],[2,N+3,N+4,'']]])
check('contract fixture 3', solve([[['decoration','*',True],['object','Hidden',False],['text','X',True]],False],), ['X',[]])
check('contract fixture 4', solve([[['text','A',True],['break','ignored',True],['text','B',True]],False],), ['A\nB',[]])
check('contract fixture 5', solve([[['object','A',True],['object','B',True]],False],), ['￼￼',[[0,0,1,'A'],[1,1,2,'B']]])
check('contract fixture 6', solve([[['text','',True]],True],), ['',[]])
check('contract fixture 7', solve([[['text',' A ',True]],False],), [' A ',[]])
check('contract fixture 8', solve([[],False],), ['',[]])
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)

prompt:
Object mappings lose authored alternative text.

Input [tokens,alt_mode] where tokens are [kind,text,exposed], kinds text, object, break, decoration. Ignore unexposed or decoration tokens. Text is copied exactly; break becomes LF; object becomes U+FFFC unless alt_mode, when nonempty alternative text is used and empty alternative falls back to U+FFFC. Return [flattened,objects] with objects [token_index,start,end,alternative]. All offsets are codepoints in output; ordinary text does not add object mappings. Adjacent objects remain separate; zero-length text has no effect.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,links,offset = data
    valid = []
    for i,(ident,start,end,url,enabled) in enumerate(links):
        if not url: continue
        start,end = max(0,start),min(length,end)
        if start >= end: continue
        valid.append((start,end-start,i,ident,end,url))
    valid.sort(key=lambda x:(x[0],x[1],x[2]))
    seen = set()
    rows = []
    for start,width,i,ident,end,url in valid:
        if ident in seen: continue
        seen.add(ident)
        rows.append([ident,start,end,url])
    hit = next((ident for ident,start,end,url in rows if start <= offset < end),None)
    return [rows,hit]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+5,[['wide',N,N+4,'/a#x',True],['small',N,N+2,'/a#y',True]],N+1],), [[['small',N,N+2,'/a#y'],['wide',N,N+4,'/a#x']],'small'])
check('contract fixture 2', solve([5,[['a',-3,2,'/a',True],['b',2,8,'/b',True]],2],), [[['a',0,2,'/a'],['b',2,5,'/b']],'b'])
check('contract fixture 3', solve([5,[['a',1,1,'/a',True],['b',4,2,'/b',True],['c',0,3,'',True],['d',0,3,'/d',False]],0],), [[],None])
check('contract fixture 4', solve([6,[['a',3,6,'later',True],['a',0,2,'early',True]],1],), [[['a',0,2,'early']],'a'])
check('contract fixture 5', solve([3,[['a',0,3,'/same',True],['b',0,3,'/same',True]],3],), [[['a',0,3,'/same'],['b',0,3,'/same']],None])
check('contract fixture 6', solve([0,[],0],), [[],None])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,links,offset = data
    valid = []
    for i,(ident,start,end,url,enabled) in enumerate(links):
        if not enabled and not url: continue
        start,end = max(0,start),min(length,end)
        if start >= end: continue
        valid.append((start,end-start,i,ident,end,url))
    valid.sort(key=lambda x:(x[0],x[1],x[2]))
    seen = set()
    rows = []
    for start,width,i,ident,end,url in valid:
        if ident in seen: continue
        seen.add(ident)
        rows.append([ident,start,end,url])
    hit = next((ident for ident,start,end,url in rows if start <= offset < end),None)
    return [rows,hit]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+5,[['wide',N,N+4,'/a#x',True],['small',N,N+2,'/a#y',True]],N+1],), [[['small',N,N+2,'/a#y'],['wide',N,N+4,'/a#x']],'small'])
check('contract fixture 2', solve([5,[['a',-3,2,'/a',True],['b',2,8,'/b',True]],2],), [[['a',0,2,'/a'],['b',2,5,'/b']],'b'])
check('contract fixture 3', solve([5,[['a',1,1,'/a',True],['b',4,2,'/b',True],['c',0,3,'',True],['d',0,3,'/d',False]],0],), [[],None])
check('contract fixture 4', solve([6,[['a',3,6,'later',True],['a',0,2,'early',True]],1],), [[['a',0,2,'early']],'a'])
check('contract fixture 5', solve([3,[['a',0,3,'/same',True],['b',0,3,'/same',True]],3],), [[['a',0,3,'/same'],['b',0,3,'/same']],None])
check('contract fixture 6', solve([0,[],0],), [[],None])
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)

prompt:
Disabled hyperlinks remain reachable through text interfaces.

Input [text_length,links,offset] where links [id,start,end,url,enabled]. Admit only nonempty URL, enabled and nonempty interval after clamping. Sort by start then shorter interval then input order; dedupe IDs after sorting. Query offset resolves the first matching half-open span, or None. Return [ordered descriptors,hit_id]. URLs remain exact including fragments; IDs are retained even when URL is shared.

split: open-access


broken_source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,links,offset = data
    valid = []
    for i,(ident,start,end,url,enabled) in enumerate(links):
        if not enabled: continue
        start,end = max(0,start),min(length,end)
        if start >= end: continue
        valid.append((start,end-start,i,ident,end,url))
    valid.sort(key=lambda x:(x[0],x[1],x[2]))
    seen = set()
    rows = []
    for start,width,i,ident,end,url in valid:
        if ident in seen: continue
        seen.add(ident)
        rows.append([ident,start,end,url])
    hit = next((ident for ident,start,end,url in rows if start <= offset < end),None)
    return [rows,hit]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+5,[['wide',N,N+4,'/a#x',True],['small',N,N+2,'/a#y',True]],N+1],), [[['small',N,N+2,'/a#y'],['wide',N,N+4,'/a#x']],'small'])
check('contract fixture 2', solve([5,[['a',-3,2,'/a',True],['b',2,8,'/b',True]],2],), [[['a',0,2,'/a'],['b',2,5,'/b']],'b'])
check('contract fixture 3', solve([5,[['a',1,1,'/a',True],['b',4,2,'/b',True],['c',0,3,'',True],['d',0,3,'/d',False]],0],), [[],None])
check('contract fixture 4', solve([6,[['a',3,6,'later',True],['a',0,2,'early',True]],1],), [[['a',0,2,'early']],'a'])
check('contract fixture 5', solve([3,[['a',0,3,'/same',True],['b',0,3,'/same',True]],3],), [[['a',0,3,'/same'],['b',0,3,'/same']],None])
check('contract fixture 6', solve([0,[],0],), [[],None])
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)

source:
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(data):
    length,links,offset = data
    valid = []
    for i,(ident,start,end,url,enabled) in enumerate(links):
        if not enabled or url is None: continue
        start,end = max(0,start),min(length,end)
        if start >= end: continue
        valid.append((start,end-start,i,ident,end,url))
    valid.sort(key=lambda x:(x[0],x[1],x[2]))
    seen = set()
    rows = []
    for start,width,i,ident,end,url in valid:
        if ident in seen: continue
        seen.add(ident)
        rows.append([ident,start,end,url])
    hit = next((ident for ident,start,end,url in rows if start <= offset < end),None)
    return [rows,hit]
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
check('contract fixture 1', solve([N+5,[['wide',N,N+4,'/a#x',True],['small',N,N+2,'/a#y',True]],N+1],), [[['small',N,N+2,'/a#y'],['wide',N,N+4,'/a#x']],'small'])
check('contract fixture 2', solve([5,[['a',-3,2,'/a',True],['b',2,8,'/b',True]],2],), [[['a',0,2,'/a'],['b',2,5,'/b']],'b'])
check('contract fixture 3', solve([5,[['a',1,1,'/a',True],['b',4,2,'/b',True],['c',0,3,'',True],['d',0,3,'/d',False]],0],), [[],None])
check('contract fixture 4', solve([6,[['a',3,6,'later',True],['a',0,2,'early',True]],1],), [[['a',0,2,'early']],'a'])
check('contract fixture 5', solve([3,[['a',0,3,'/same',True],['b',0,3,'/same',True]],3],), [[['a',0,3,'/same'],['b',0,3,'/same']],None])
check('contract fixture 6', solve([0,[],0],), [[],None])
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)

prompt:
Empty hyperlink targets are represented as valid links.

Input [text_length,links,offset] where links [id,start,end,url,enabled]. Admit only nonempty URL, enabled and nonempty interval after clamping. Sort by start then shorter interval then input order; dedupe IDs after sorting. Query offset resolves the first matching half-open span, or None. Return [ordered descriptors,hit_id]. URLs remain exact including fragments; IDs are retained even when URL is shared.

split: open-access