task_id stringlengths 4 25 | family stringclasses 12
values | bug_pattern stringclasses 37
values | case_seed int64 20.3M 20.5M | prompt stringlengths 299 1.09k | starter stringclasses 48
values | split stringclasses 1
value | arena_selected bool 2
classes | num_cases int64 92 188 | cases_json stringlengths 5.75k 15.3k |
|---|---|---|---|---|---|---|---|---|---|
merge-intervals | merge-intervals | baseline | 20,261,008 | Implement solve(intervals). Merge closed intervals that overlap or touch, sort by start, and return lists [start,end]. Inputs may be unsorted; do not mutate them. Empty input returns [].
Examples (JSON args and expected result): [{"args": [[[-6, -4], [8, 15]]], "expected": [[-6, -4], [8, 15]]}, {"args": [[[2, 3]]], "ex... | def solve(intervals):
return sorted(intervals)
| train | true | 110 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[-18,-17],[8,11],[-5,-1],[-11,-8],[-3,3]]],"expected":[[-18,-17],[-11,-8],[-5,3],[8,11]]},{"args":[[[16,23],[27,27]]],"expected":[[16,23],[27,27]]},{"args":[[[3,4],[-6,-2],[-5,1],[-2,5],[8,15],[-17,-10],[-8,-8]]],"expected":[[-17,-... |
merge-intervals-b1-s00 | merge-intervals | touching-boundary | 20,261,008 | Implement solve(intervals). Merge closed intervals that overlap or touch, sort by start, and return lists [start,end]. Inputs may be unsorted; do not mutate them. Empty input returns [].
Examples (JSON args and expected result): [{"args": [[[-1, 7], [0, 1]]], "expected": [[-1, 7]]}, {"args": [[[4, 9], [1, 4]]], "expect... | def solve(intervals):
out = []
for a,b in sorted(intervals):
if out and a < out[-1][1]:
out[-1][1] = max(b, out[-1][1])
else:
out.append([a,b])
return out
| train | false | 110 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[-18,-17],[8,11],[-5,-1],[-11,-8],[-3,3]]],"expected":[[-18,-17],[-11,-8],[-5,3],[8,11]]},{"args":[[[16,23],[27,27]]],"expected":[[16,23],[27,27]]},{"args":[[[3,4],[-6,-2],[-5,1],[-2,5],[8,15],[-17,-10],[-8,-8]]],"expected":[[-17,-... |
merge-intervals-b2-s00 | merge-intervals | nested-endpoint | 20,261,008 | Implement solve(intervals). Merge closed intervals that overlap or touch, sort by start, and return lists [start,end]. Inputs may be unsorted; do not mutate them. Empty input returns [].
Examples (JSON args and expected result): [{"args": [[[28, 30], [20, 26], [13, 13], [3, 10], [13, 19], [-4, 3], [25, 29], [3, 5], [5,... | def solve(intervals):
out = []
for a,b in sorted(intervals):
if out and a <= out[-1][1]:
out[-1][1] = min(b, out[-1][1])
else:
out.append([a,b])
return out
| train | false | 110 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[-18,-17],[8,11],[-5,-1],[-11,-8],[-3,3]]],"expected":[[-18,-17],[-11,-8],[-5,3],[8,11]]},{"args":[[[16,23],[27,27]]],"expected":[[16,23],[27,27]]},{"args":[[[3,4],[-6,-2],[-5,1],[-2,5],[8,15],[-17,-10],[-8,-8]]],"expected":[[-17,-... |
merge-intervals-b3-s00 | merge-intervals | unsorted-input | 20,261,008 | Implement solve(intervals). Merge closed intervals that overlap or touch, sort by start, and return lists [start,end]. Inputs may be unsorted; do not mutate them. Empty input returns [].
Examples (JSON args and expected result): [{"args": [[[-8, -7], [-4, -1]]], "expected": [[-8, -7], [-4, -1]]}, {"args": [[[28, 30], [... | def solve(intervals):
out = []
for a,b in intervals:
if out and a <= out[-1][1]:
out[-1][1] = max(b, out[-1][1])
else:
out.append([a,b])
return out
| train | false | 110 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[-18,-17],[8,11],[-5,-1],[-11,-8],[-3,3]]],"expected":[[-18,-17],[-11,-8],[-5,3],[8,11]]},{"args":[[[16,23],[27,27]]],"expected":[[16,23],[27,27]]},{"args":[[[3,4],[-6,-2],[-5,1],[-2,5],[8,15],[-17,-10],[-8,-8]]],"expected":[[-17,-... |
moving-sums | moving-sums | baseline | 20,261,008 | Implement solve(values,k). Return sums of every contiguous window of length k. k<=0 or k>len(values) returns [].
Examples (JSON args and expected result): [{"args": [[72, 93, -49, -91, -32, 74, 51, 77, -42, 48], 3], "expected": [116, -47, -172, -49, 93, 202, 86, 83]}, {"args": [[86, 4, -24, -70, 6, -73, -92, -96, 29], ... | def solve(values,k):
return [sum(values[i:i+k]) for i in range(len(values)-k)]
| train | false | 143 | [{"args":[[],1],"expected":[]},{"args":[[1,2,3],2],"expected":[3,5]},{"args":[[5],1],"expected":[5]},{"args":[[1],0],"expected":[]},{"args":[[],16],"expected":[]},{"args":[[-52,-24,43,-70,-9,43,-79,68,41,-29,18,-97,73,95,-17,62,64,-47],0],"expected":[]},{"args":[[-47,-58,-70,-32,54,86,-77],15],"expected":[]},{"args":[[... |
moving-sums-b1-s00 | moving-sums | zero-window | 20,261,008 | Implement solve(values,k). Return sums of every contiguous window of length k. k<=0 or k>len(values) returns [].
Examples (JSON args and expected result): [{"args": [[14, -93, -68, -83, -74, 69, 35, -67, 98, 18, -48, -46, -40, -24, 49, -93, -62, -82], 9], "expected": [-169, -165, -120, -98, -55, -5, -25, -153, -148, -3... | def solve(values,k):
if k < 0 or k > len(values): return []
return [sum(values[i:i+k]) for i in range(len(values)-k+1)]
| train | false | 143 | [{"args":[[],1],"expected":[]},{"args":[[1,2,3],2],"expected":[3,5]},{"args":[[5],1],"expected":[5]},{"args":[[1],0],"expected":[]},{"args":[[],16],"expected":[]},{"args":[[-52,-24,43,-70,-9,43,-79,68,41,-29,18,-97,73,95,-17,62,64,-47],0],"expected":[]},{"args":[[-47,-58,-70,-32,54,86,-77],15],"expected":[]},{"args":[[... |
moving-sums-b2-s00 | moving-sums | window-width | 20,261,008 | Implement solve(values,k). Return sums of every contiguous window of length k. k<=0 or k>len(values) returns [].
Examples (JSON args and expected result): [{"args": [[27, -8, -15, 13, -14, -30, 27, 25, -17, -17], 0], "expected": []}, {"args": [[-3, 23, 40, -54, 55, 45, 63, 36, 68, 12, -5, -84, -47, -20, -85, 91, 89, -9... | def solve(values,k):
if k <= 0 or k > len(values): return []
return [sum(values[i:i+k-1]) for i in range(len(values)-k+1)]
| train | false | 143 | [{"args":[[],1],"expected":[]},{"args":[[1,2,3],2],"expected":[3,5]},{"args":[[5],1],"expected":[5]},{"args":[[1],0],"expected":[]},{"args":[[],16],"expected":[]},{"args":[[-52,-24,43,-70,-9,43,-79,68,41,-29,18,-97,73,95,-17,62,64,-47],0],"expected":[]},{"args":[[-47,-58,-70,-32,54,86,-77],15],"expected":[]},{"args":[[... |
moving-sums-b3-s00 | moving-sums | missing-first-window | 20,261,008 | Implement solve(values,k). Return sums of every contiguous window of length k. k<=0 or k>len(values) returns [].
Examples (JSON args and expected result): [{"args": [[19, 17, -13, 8, 3, 1, 7, 20, -30, 10, -18, -20], 0], "expected": []}, {"args": [[3, -14, 29, 10, -17, 29, -28, 13], 2], "expected": [-11, 15, 39, -7, 12,... | def solve(values,k):
if k <= 0 or k > len(values): return []
return [sum(values[i:i+k]) for i in range(1,len(values)-k+1)]
| train | false | 143 | [{"args":[[],1],"expected":[]},{"args":[[1,2,3],2],"expected":[3,5]},{"args":[[5],1],"expected":[5]},{"args":[[1],0],"expected":[]},{"args":[[],16],"expected":[]},{"args":[[-52,-24,43,-70,-9,43,-79,68,41,-29,18,-97,73,95,-17,62,64,-47],0],"expected":[]},{"args":[[-47,-58,-70,-32,54,86,-77],15],"expected":[]},{"args":[[... |
weighted-mean | weighted-mean | baseline | 20,261,008 | Implement solve(values,weights). Inputs have equal length and nonnegative weights. Return weighted arithmetic mean; return None if total weight is zero (including empty inputs).
Examples (JSON args and expected result): [{"args": [[41, -14, 21, -47, -38, 22, 12, 15, 23, -21], [3, 3, 4, 3, 0, 4, 1, 4, 3, 3]], "expected"... | def solve(values,weights):
return sum(values)/len(values) if values else None
| train | false | 121 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[8,-20,40],[3,4,0]],"expected":-8.0},{"args":[[-22,46,2,47,-41,-50,-10,-47,1,-48,2,-24,4,-31,-20,26,-14,44,-26],[4,3,5,4,0,4,3,5,5,1,5,5,3,4,2,1,0,2,3]],"expected":-8.23728813559322},{"args":[[13,19,-19... |
weighted-mean-b1-s00 | weighted-mean | unweighted-numerator | 20,261,008 | Implement solve(values,weights). Inputs have equal length and nonnegative weights. Return weighted arithmetic mean; return None if total weight is zero (including empty inputs).
Examples (JSON args and expected result): [{"args": [[-9, -2], [0, 0]], "expected": null}, {"args": [[-5, 2], [0, 0]], "expected": null}, {"ar... | def solve(values,weights):
total = sum(weights)
return sum(x for x,w in zip(values,weights))/total if total else None
| train | false | 121 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[8,-20,40],[3,4,0]],"expected":-8.0},{"args":[[-22,46,2,47,-41,-50,-10,-47,1,-48,2,-24,4,-31,-20,26,-14,44,-26],[4,3,5,4,0,4,3,5,5,1,5,5,3,4,2,1,0,2,3]],"expected":-8.23728813559322},{"args":[[13,19,-19... |
weighted-mean-b2-s00 | weighted-mean | wrong-denominator | 20,261,008 | Implement solve(values,weights). Inputs have equal length and nonnegative weights. Return weighted arithmetic mean; return None if total weight is zero (including empty inputs).
Examples (JSON args and expected result): [{"args": [[-2], [3]], "expected": -2.0}, {"args": [[38, -45, -38, -46, -11, -15, 38, -43, 35, 34, -... | def solve(values,weights):
total = len(weights)
return sum(x*w for x,w in zip(values,weights))/total if total else None
| train | false | 121 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[8,-20,40],[3,4,0]],"expected":-8.0},{"args":[[-22,46,2,47,-41,-50,-10,-47,1,-48,2,-24,4,-31,-20,26,-14,44,-26],[4,3,5,4,0,4,3,5,5,1,5,5,3,4,2,1,0,2,3]],"expected":-8.23728813559322},{"args":[[13,19,-19... |
weighted-mean-b3-s00 | weighted-mean | zero-weight-result | 20,261,008 | Implement solve(values,weights). Inputs have equal length and nonnegative weights. Return weighted arithmetic mean; return None if total weight is zero (including empty inputs).
Examples (JSON args and expected result): [{"args": [[21, 30, -22, -7, -48, 43, 13], [0, 0, 5, 4, 1, 4, 2]], "expected": 0.75}, {"args": [[-2]... | def solve(values,weights):
total = sum(weights)
return sum(x*w for x,w in zip(values,weights))/total if total else 0
| train | false | 121 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[8,-20,40],[3,4,0]],"expected":-8.0},{"args":[[-22,46,2,47,-41,-50,-10,-47,1,-48,2,-24,4,-31,-20,26,-14,44,-26],[4,3,5,4,0,4,3,5,5,1,5,5,3,4,2,1,0,2,3]],"expected":-8.23728813559322},{"args":[[13,19,-19... |
stable-unique | stable-unique | baseline | 20,261,008 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[-4, -2, -5, -9, -10, -3, 1, -4, -2, -6, 7, -1, 1, -6, 5, 9, 6, 4, 8, -3, -10, 8, -5, -9]], "expected": [-4, -2, -5, -9, -10, -3, 1, -6, 7, -1, 5, 9, ... | def solve(values):
return sorted(set(values))
| train | false | 97 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[1,4,5,-8,-7,-6]],"expected":[1,4,5,-8,-7,-6]},{"args":[[-3,-1,6,7,-5,8,2,-2,6,-9,7,1,2,-2,9]],"expected":[-3,-1,6,7,-5,8,2,-2,-9,1,9]},{"args":[[1,10,8,-2,-10,-9,4,8,9,3,6,-3,-4,3,3,10,-6,-5,-9,-1,-8,10,2]],"expected":[1,10,8,-2,-10,-9,4,9... |
stable-unique-b1-s00 | stable-unique | reverse-traversal | 20,261,008 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[20, 18, 20, 19, 18]], "expected": [20, 18, 19]}, {"args": [[-3, -5, 4, 6, 4, 8, 7, 2, 7, 9, -4, -7, -9, 10, -10, -4]], "expected": [-3, -5, 4, 6, 8, ... | def solve(values):
seen = set()
out = []
for x in reversed(values):
if x not in seen:
seen.add(x)
out.append(x)
return out
| train | false | 97 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[1,4,5,-8,-7,-6]],"expected":[1,4,5,-8,-7,-6]},{"args":[[-3,-1,6,7,-5,8,2,-2,6,-9,7,1,2,-2,9]],"expected":[-3,-1,6,7,-5,8,2,-2,-9,1,9]},{"args":[[1,10,8,-2,-10,-9,4,8,9,3,6,-3,-4,3,3,10,-6,-5,-9,-1,-8,10,2]],"expected":[1,10,8,-2,-10,-9,4,9... |
stable-unique-b2-s00 | stable-unique | reverse-output | 20,261,008 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[8, -6, 1, -4, 4, -9, 7, 2, -4, -1, -10, 2, 9, 2, 6, -5, -5, 9, 9, -4, -3, 9, 1, 5, 6]], "expected": [8, -6, 1, -4, 4, -9, 7, 2, -1, -10, 9, 6, -5, -3... | def solve(values):
seen = set()
out = []
for x in values:
if x not in seen:
seen.add(x)
out.insert(0,x)
return out
| train | false | 97 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[1,4,5,-8,-7,-6]],"expected":[1,4,5,-8,-7,-6]},{"args":[[-3,-1,6,7,-5,8,2,-2,6,-9,7,1,2,-2,9]],"expected":[-3,-1,6,7,-5,8,2,-2,-9,1,9]},{"args":[[1,10,8,-2,-10,-9,4,8,9,3,6,-3,-4,3,3,10,-6,-5,-9,-1,-8,10,2]],"expected":[1,10,8,-2,-10,-9,4,9... |
stable-unique-b3-s00 | stable-unique | wrong-seen-value | 20,261,008 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[-5, 10, 1, -2, -1, -9, -1, -8, 10, 6, -5, 3, -1, -7, 0, 7, -2, -3, -9, 1, -6, 10, 2, -7, -2, -7]], "expected": [-5, 10, 1, -2, -1, -9, -8, 6, 3, -7, ... | def solve(values):
seen = set()
out = []
for x in values:
if x not in seen:
seen.add(-x)
out.append(x)
return out
| train | false | 97 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[1,4,5,-8,-7,-6]],"expected":[1,4,5,-8,-7,-6]},{"args":[[-3,-1,6,7,-5,8,2,-2,6,-9,7,1,2,-2,9]],"expected":[-3,-1,6,7,-5,8,2,-2,-9,1,9]},{"args":[[1,10,8,-2,-10,-9,4,8,9,3,6,-3,-4,3,3,10,-6,-5,-9,-1,-8,10,2]],"expected":[1,10,8,-2,-10,-9,4,9... |
run-length | run-length | baseline | 20,261,008 | Implement solve(text). Run-length encode consecutive Unicode characters as a list of [character,count] pairs. Empty text returns []. Nonadjacent occurrences remain separate.
Examples (JSON args and expected result): [{"args": ["ac🙂🙂猫c"], "expected": [["a", 1], ["c", 1], ["🙂", 2], ["猫", 1], ["c", 1]]}, {"args": ["🙂c... | def solve(text):
return [[c,text.count(c)] for c in sorted(set(text))]
| train | false | 100 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["bac"],"expected":[["b",1],["a",1],["c",1]]},{"args":["猫 cab猫b 猫🙂a aab猫🙂 🙂b "],"expected":[["猫",1],[" ",1],["c",1],["a",1],["b",1],["猫",1],["b",1],[" ",1],["猫",1],... |
run-length-b1-s00 | run-length | inverted-grouping | 20,261,008 | Implement solve(text). Run-length encode consecutive Unicode characters as a list of [character,count] pairs. Empty text returns []. Nonadjacent occurrences remain separate.
Examples (JSON args and expected result): [{"args": ["aaaaaaa狗狗狗狗狗狗"], "expected": [["a", 7], ["狗", 6]]}, {"args": [" b "], "expected": [[" ", 3... | def solve(text):
out = []
for c in text:
if out and out[-1][0] != c: out[-1][1] += 1
else: out.append([c,1])
return out
| train | false | 100 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["bac"],"expected":[["b",1],["a",1],["c",1]]},{"args":["猫 cab猫b 猫🙂a aab猫🙂 🙂b "],"expected":[["猫",1],[" ",1],["c",1],["a",1],["b",1],["猫",1],["b",1],[" ",1],["猫",1],... |
run-length-b2-s00 | run-length | double-increment | 20,261,008 | Implement solve(text). Run-length encode consecutive Unicode characters as a list of [character,count] pairs. Empty text returns []. Nonadjacent occurrences remain separate.
Examples (JSON args and expected result): [{"args": ["ab b🙂aab猫cc b猫 ba猫b🙂猫🙂🙂acba"], "expected": [["a", 1], ["b", 1], [" ", 1], ["b", 1], ["�... | def solve(text):
out = []
for c in text:
if out and out[-1][0] == c: out[-1][1] += 2
else: out.append([c,1])
return out
| train | false | 100 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["bac"],"expected":[["b",1],["a",1],["c",1]]},{"args":["猫 cab猫b 猫🙂a aab猫🙂 🙂b "],"expected":[["猫",1],[" ",1],["c",1],["a",1],["b",1],["猫",1],["b",1],[" ",1],["猫",1],... |
run-length-b3-s00 | run-length | zero-initial-count | 20,261,008 | Implement solve(text). Run-length encode consecutive Unicode characters as a list of [character,count] pairs. Empty text returns []. Nonadjacent occurrences remain separate.
Examples (JSON args and expected result): [{"args": ["cc猫b猫🙂猫caa🙂b 🙂🙂a "], "expected": [["c", 2], ["猫", 1], ["b", 1], ["猫", 1], ["🙂", 1], ["猫... | def solve(text):
out = []
for c in text:
if out and out[-1][0] == c: out[-1][1] += 1
else: out.append([c,0])
return out
| train | false | 100 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["bac"],"expected":[["b",1],["a",1],["c",1]]},{"args":["猫 cab猫b 猫🙂a aab猫🙂 🙂b "],"expected":[["猫",1],[" ",1],["c",1],["a",1],["b",1],["猫",1],["b",1],[" ",1],["猫",1],... |
luhn | luhn | baseline | 20,261,008 | Implement solve(text). Return whether a nonempty ASCII digit string satisfies the Luhn checksum: starting from right, double every second digit, subtract 9 if >9, and require total divisible by 10. Nondigits/empty input return False.
Examples (JSON args and expected result): [{"args": ["04584223"], "expected": true}, {... | def solve(text):
return bool(text) and text.isdigit() and sum(int(c) for c in text)%10 == 0
| train | false | 186 | [{"args":[""],"expected":false},{"args":["0"],"expected":true},{"args":["79927398713"],"expected":true},{"args":["79927398714"],"expected":false},{"args":["12x"],"expected":false},{"args":[" 0"],"expected":false},{"args":["１２"],"expected":false},{"args":["0000"],"expected":true},{"args":["8139710499"],"expected":false}... |
luhn-b1-s00 | luhn | wrong-parity | 20,261,008 | Implement solve(text). Return whether a nonempty ASCII digit string satisfies the Luhn checksum: starting from right, double every second digit, subtract 9 if >9, and require total divisible by 10. Nondigits/empty input return False.
Examples (JSON args and expected result): [{"args": ["181336272"], "expected": true}, ... | def solve(text):
if not text or any(c not in '0123456789' for c in text): return False
total = 0
for i,c in enumerate(reversed(text)):
v = int(c)
if not i%2:
v *= 2
if v > 9: v -= 9
total += v
return total%10 == 0
| train | false | 186 | [{"args":[""],"expected":false},{"args":["0"],"expected":true},{"args":["79927398713"],"expected":true},{"args":["79927398714"],"expected":false},{"args":["12x"],"expected":false},{"args":[" 0"],"expected":false},{"args":["１２"],"expected":false},{"args":["0000"],"expected":true},{"args":["8139710499"],"expected":false}... |
luhn-b2-s00 | luhn | wrong-reduction | 20,261,008 | Implement solve(text). Return whether a nonempty ASCII digit string satisfies the Luhn checksum: starting from right, double every second digit, subtract 9 if >9, and require total divisible by 10. Nondigits/empty input return False.
Examples (JSON args and expected result): [{"args": ["7756647869"], "expected": false}... | def solve(text):
if not text or any(c not in '0123456789' for c in text): return False
total = 0
for i,c in enumerate(reversed(text)):
v = int(c)
if i%2:
v *= 2
if v > 9: v -= 8
total += v
return total%10 == 0
| train | false | 186 | [{"args":[""],"expected":false},{"args":["0"],"expected":true},{"args":["79927398713"],"expected":true},{"args":["79927398714"],"expected":false},{"args":["12x"],"expected":false},{"args":[" 0"],"expected":false},{"args":["１２"],"expected":false},{"args":["0000"],"expected":true},{"args":["8139710499"],"expected":false}... |
luhn-b3-s00 | luhn | wrong-modulus | 20,261,008 | Implement solve(text). Return whether a nonempty ASCII digit string satisfies the Luhn checksum: starting from right, double every second digit, subtract 9 if >9, and require total divisible by 10. Nondigits/empty input return False.
Examples (JSON args and expected result): [{"args": ["5157646536724958"], "expected": ... | def solve(text):
if not text or any(c not in '0123456789' for c in text): return False
total = 0
for i,c in enumerate(reversed(text)):
v = int(c)
if i%2:
v *= 2
if v > 9: v -= 9
total += v
return total%9 == 0
| train | true | 186 | [{"args":[""],"expected":false},{"args":["0"],"expected":true},{"args":["79927398713"],"expected":true},{"args":["79927398714"],"expected":false},{"args":["12x"],"expected":false},{"args":[" 0"],"expected":false},{"args":["１２"],"expected":false},{"args":["0000"],"expected":true},{"args":["8139710499"],"expected":false}... |
edit-distance | edit-distance | baseline | 20,261,008 | Implement solve(a,b). Return Levenshtein edit distance with unit-cost insertion, deletion, and substitution over Unicode characters.
Examples (JSON args and expected result): [{"args": ["dbcdbcbd猫d", "dcbdcb猫"], "expected": 5}, {"args": ["猫猫d猫bbcc", "猫a猫aa猫猫"], "expected": 6}, {"args": ["猫bbaa", ""], "expected": 5}] | def solve(a,b):
return abs(len(a)-len(b))
| train | false | 139 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["猫d","bcdcd猫aacab"],"expected":10},{"args":["猫aacca猫bd","cccad"],"expected":5},{"args":["ddba猫d","ab"],"expected":5},{"args":["c","c猫猫"],"expected":2},{"args":["bacbadb猫","b猫bdd"],"expected":5},{"args":["d... |
edit-distance-b1-s00 | edit-distance | row-boundary | 20,261,008 | Implement solve(a,b). Return Levenshtein edit distance with unit-cost insertion, deletion, and substitution over Unicode characters.
Examples (JSON args and expected result): [{"args": ["d猫bdcadaaa", "dab猫dddbc猫猫"], "expected": 8}, {"args": ["猫bb", ""], "expected": 3}, {"args": ["dc猫猫bc", "aaa猫db"], "expected": 5}] | def solve(a,b):
row = list(range(len(b)+1))
for i,x in enumerate(a,1):
nxt = [0]
for j,y in enumerate(b,1):
nxt.append(min(nxt[-1]+1,row[j]+1,row[j-1]+(x != y)))
row = nxt
return row[-1]
| train | false | 139 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["猫d","bcdcd猫aacab"],"expected":10},{"args":["猫aacca猫bd","cccad"],"expected":5},{"args":["ddba猫d","ab"],"expected":5},{"args":["c","c猫猫"],"expected":2},{"args":["bacbadb猫","b猫bdd"],"expected":5},{"args":["d... |
edit-distance-b2-s00 | edit-distance | inverted-substitution | 20,261,008 | Implement solve(a,b). Return Levenshtein edit distance with unit-cost insertion, deletion, and substitution over Unicode characters.
Examples (JSON args and expected result): [{"args": ["猫ba", ""], "expected": 3}, {"args": ["adb猫", "acbcc猫a猫"], "expected": 5}, {"args": ["bbddcc", "dbc"], "expected": 4}] | def solve(a,b):
row = list(range(len(b)+1))
for i,x in enumerate(a,1):
nxt = [i]
for j,y in enumerate(b,1):
nxt.append(min(nxt[-1]+1,row[j]+1,row[j-1]+(x == y)))
row = nxt
return row[-1]
| train | false | 139 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["猫d","bcdcd猫aacab"],"expected":10},{"args":["猫aacca猫bd","cccad"],"expected":5},{"args":["ddba猫d","ab"],"expected":5},{"args":["c","c猫猫"],"expected":2},{"args":["bacbadb猫","b猫bdd"],"expected":5},{"args":["d... |
edit-distance-b3-s00 | edit-distance | diagonal-index | 20,261,008 | Implement solve(a,b). Return Levenshtein edit distance with unit-cost insertion, deletion, and substitution over Unicode characters.
Examples (JSON args and expected result): [{"args": ["ccab", "ccab"], "expected": 0}, {"args": ["a猫accb猫b", "b猫bcca猫a"], "expected": 4}, {"args": ["ccab", "bacc"], "expected": 4}] | def solve(a,b):
row = list(range(len(b)+1))
for i,x in enumerate(a,1):
nxt = [i]
for j,y in enumerate(b,1):
nxt.append(min(nxt[-1]+1,row[j]+1,row[j]+(x != y)))
row = nxt
return row[-1]
| train | false | 139 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["猫d","bcdcd猫aacab"],"expected":10},{"args":["猫aacca猫bd","cccad"],"expected":5},{"args":["ddba猫d","ab"],"expected":5},{"args":["c","c猫猫"],"expected":2},{"args":["bacbadb猫","b猫bdd"],"expected":5},{"args":["d... |
meeting-rooms | meeting-rooms | baseline | 20,261,008 | Implement solve(intervals). Return minimum rooms for positive-length half-open meetings [start,end). A meeting ending at time t frees its room for one starting at t. Empty input returns 0.
Examples (JSON args and expected result): [{"args": [[[3, 8], [15, 22]]], "expected": 1}, {"args": [[[6, 11], [15, 19], [7, 10], [1... | def solve(intervals):
return len(intervals)
| train | false | 117 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[2,3],[18,19],[17,25],[13,16],[17,24],[9,16],[8,13],[15,20],[0,3],[19,25],[0,2],[15,20],[18,24],[15,19],[16,23],[7,14],[17,19]]],"expected":9},{"args":[[[13,21],[0,1],[16,23]]],"expected":2},{"args":[... |
meeting-rooms-b1-s00 | meeting-rooms | tie-order | 20,261,008 | Implement solve(intervals). Return minimum rooms for positive-length half-open meetings [start,end). A meeting ending at time t frees its room for one starting at t. Empty input returns 0.
Examples (JSON args and expected result): [{"args": [[[28, 30], [30, 32]]], "expected": 1}, {"args": [[[-12, -4], [-11, -9], [-10, ... | def solve(intervals):
events = []
for a,b in intervals:
events.append([a,1])
events.append([b,-1])
active = best = 0
for t,d in sorted(events,key=lambda item:(item[0],-item[1])):
active += d
best = max(best,active)
return best
| train | false | 117 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[2,3],[18,19],[17,25],[13,16],[17,24],[9,16],[8,13],[15,20],[0,3],[19,25],[0,2],[15,20],[18,24],[15,19],[16,23],[7,14],[17,19]]],"expected":9},{"args":[[[13,21],[0,1],[16,23]]],"expected":2},{"args":[... |
meeting-rooms-b2-s00 | meeting-rooms | peak-tracking | 20,261,008 | Implement solve(intervals). Return minimum rooms for positive-length half-open meetings [start,end). A meeting ending at time t frees its room for one starting at t. Empty input returns 0.
Examples (JSON args and expected result): [{"args": [[[4, 12], [18, 19], [4, 10], [5, 10], [15, 16], [16, 21]]], "expected": 3}, {"... | def solve(intervals):
events = []
for a,b in intervals:
events.append([a,1])
events.append([b,-1])
active = best = 0
for t,d in sorted(events):
active += d
best = min(best,active)
return best
| train | false | 117 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[2,3],[18,19],[17,25],[13,16],[17,24],[9,16],[8,13],[15,20],[0,3],[19,25],[0,2],[15,20],[18,24],[15,19],[16,23],[7,14],[17,19]]],"expected":9},{"args":[[[13,21],[0,1],[16,23]]],"expected":2},{"args":[... |
meeting-rooms-b3-s00 | meeting-rooms | end-event-sign | 20,261,008 | Implement solve(intervals). Return minimum rooms for positive-length half-open meetings [start,end). A meeting ending at time t frees its room for one starting at t. Empty input returns 0.
Examples (JSON args and expected result): [{"args": [[[10, 13], [7, 14], [13, 16], [11, 16], [19, 22], [16, 17], [5, 11], [3, 4], [... | def solve(intervals):
events = []
for a,b in intervals:
events.append([a,1])
events.append([b,1])
active = best = 0
for t,d in sorted(events):
active += d
best = max(best,active)
return best
| train | false | 117 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[2,3],[18,19],[17,25],[13,16],[17,24],[9,16],[8,13],[15,20],[0,3],[19,25],[0,2],[15,20],[18,24],[15,19],[16,23],[7,14],[17,19]]],"expected":9},{"args":[[[13,21],[0,1],[16,23]]],"expected":2},{"args":[... |
nearest-percentile | nearest-percentile | baseline | 20,261,008 | Implement solve(values,p). Return nearest-rank percentile: sort ascending and take 1-based rank max(1,ceil(p/100*n)). p is integer 0..100. Empty input returns None.
Examples (JSON args and expected result): [{"args": [[18, 50, -63, 65, 81, 15], 100], "expected": 81}, {"args": [[-61, -74, 67, -57, -17, -95, 49, -2, 58, ... | def solve(values,p):
return sorted(values)[int(p/100*len(values))] if values else None
| train | false | 144 | [{"args":[[],50],"expected":null},{"args":[[1,2,3,4],100],"expected":4},{"args":[[1,2,3,4],50],"expected":2},{"args":[[4],0],"expected":4},{"args":[[95,9,76,-6,42,-81,46,0,-74,-96,-43,35,-12,72],50],"expected":0},{"args":[[38,-9,-82,-14,-81,4,-53,5,83,97,67,-99,58,83,7,42,17,-43],100],"expected":97},{"args":[[-49,-47],... |
nearest-percentile-b1-s00 | nearest-percentile | floor-not-ceiling | 20,261,008 | Implement solve(values,p). Return nearest-rank percentile: sort ascending and take 1-based rank max(1,ceil(p/100*n)). p is integer 0..100. Empty input returns None.
Examples (JSON args and expected result): [{"args": [[63, 1, -4, -41], 0], "expected": -41}, {"args": [[-4, -10, -11, -7, -2, 0, -6, -5, -1, 1, -9, -8, -3]... | def solve(values,p):
if not values: return None
rank = max(1,(p*len(values)+0)//100)
return sorted(values)[rank-1]
| train | false | 144 | [{"args":[[],50],"expected":null},{"args":[[1,2,3,4],100],"expected":4},{"args":[[1,2,3,4],50],"expected":2},{"args":[[4],0],"expected":4},{"args":[[95,9,76,-6,42,-81,46,0,-74,-96,-43,35,-12,72],50],"expected":0},{"args":[[38,-9,-82,-14,-81,4,-53,5,83,97,67,-99,58,83,7,42,17,-43],100],"expected":97},{"args":[[-49,-47],... |
nearest-percentile-b2-s00 | nearest-percentile | rank-index | 20,261,008 | Implement solve(values,p). Return nearest-rank percentile: sort ascending and take 1-based rank max(1,ceil(p/100*n)). p is integer 0..100. Empty input returns None.
Examples (JSON args and expected result): [{"args": [[-9, -11, -13, -7, -12, -10, -14, -8, -15], 99], "expected": -7}, {"args": [[-9, 42, -79, -56, 53, 96,... | def solve(values,p):
if not values: return None
rank = max(1,(p*len(values)+99)//100)
return sorted(values)[rank-2]
| train | false | 144 | [{"args":[[],50],"expected":null},{"args":[[1,2,3,4],100],"expected":4},{"args":[[1,2,3,4],50],"expected":2},{"args":[[4],0],"expected":4},{"args":[[95,9,76,-6,42,-81,46,0,-74,-96,-43,35,-12,72],50],"expected":0},{"args":[[38,-9,-82,-14,-81,4,-53,5,83,97,67,-99,58,83,7,42,17,-43],100],"expected":97},{"args":[[-49,-47],... |
nearest-percentile-b3-s00 | nearest-percentile | descending-order | 20,261,008 | Implement solve(values,p). Return nearest-rank percentile: sort ascending and take 1-based rank max(1,ceil(p/100*n)). p is integer 0..100. Empty input returns None.
Examples (JSON args and expected result): [{"args": [[46, 47, 39, 48, 49, 43, 42, 44, 40, 45, 41], 99], "expected": 49}, {"args": [[-9, -11, -13, -7, -12, ... | def solve(values,p):
if not values: return None
rank = max(1,(p*len(values)+99)//100)
return sorted(values,reverse=True)[rank-1]
| train | false | 144 | [{"args":[[],50],"expected":null},{"args":[[1,2,3,4],100],"expected":4},{"args":[[1,2,3,4],50],"expected":2},{"args":[[4],0],"expected":4},{"args":[[95,9,76,-6,42,-81,46,0,-74,-96,-43,35,-12,72],50],"expected":0},{"args":[[38,-9,-82,-14,-81,4,-53,5,83,97,67,-99,58,83,7,42,17,-43],100],"expected":97},{"args":[[-49,-47],... |
fifo-inventory | fifo-inventory | baseline | 20,261,008 | Implement solve(lots,demand). lots are [quantity,unit_price_cents] in purchase order with nonnegative integers. Return [cost_cents,remaining_lots] after fulfilling demand FIFO, dropping zero-quantity lots. If inventory cannot cover demand, return None. Do not mutate input; demand>=0.
Examples (JSON args and expected re... | def solve(lots,demand):
return [0,lots]
| train | false | 122 | [{"args":[[],0],"expected":[0,[]]},{"args":[[],1],"expected":null},{"args":[[[2,100],[3,200]],3],"expected":[400,[[2,200]]]},{"args":[[[0,50],[2,80]],0],"expected":[0,[[2,80]]]},{"args":[[[2,327]],16],"expected":null},{"args":[[[5,606],[1,437],[3,528],[6,894],[1,882],[2,473],[6,406],[1,220],[2,537]],1],"expected":[606,... |
fifo-inventory-b1-s00 | fifo-inventory | zero-lot-retention | 20,261,008 | Implement solve(lots,demand). lots are [quantity,unit_price_cents] in purchase order with nonnegative integers. Return [cost_cents,remaining_lots] after fulfilling demand FIFO, dropping zero-quantity lots. If inventory cannot cover demand, return None. Do not mutate input; demand>=0.
Examples (JSON args and expected re... | def solve(lots,demand):
if sum(q for q,p in lots) < demand: return None
remaining = []
cost = 0
for q,p in lots:
used = min(q,demand)
demand -= used
cost += used*p
if q >= used: remaining.append([q-used,p])
return [cost,remaining]
| train | false | 122 | [{"args":[[],0],"expected":[0,[]]},{"args":[[],1],"expected":null},{"args":[[[2,100],[3,200]],3],"expected":[400,[[2,200]]]},{"args":[[[0,50],[2,80]],0],"expected":[0,[[2,80]]]},{"args":[[[2,327]],16],"expected":null},{"args":[[[5,606],[1,437],[3,528],[6,894],[1,882],[2,473],[6,406],[1,220],[2,537]],1],"expected":[606,... |
fifo-inventory-b2-s00 | fifo-inventory | over-consumption | 20,261,008 | Implement solve(lots,demand). lots are [quantity,unit_price_cents] in purchase order with nonnegative integers. Return [cost_cents,remaining_lots] after fulfilling demand FIFO, dropping zero-quantity lots. If inventory cannot cover demand, return None. Do not mutate input; demand>=0.
Examples (JSON args and expected re... | def solve(lots,demand):
if sum(q for q,p in lots) < demand: return None
remaining = []
cost = 0
for q,p in lots:
used = max(q,demand)
demand -= used
cost += used*p
if q-used: remaining.append([q-used,p])
return [cost,remaining]
| train | false | 122 | [{"args":[[],0],"expected":[0,[]]},{"args":[[],1],"expected":null},{"args":[[[2,100],[3,200]],3],"expected":[400,[[2,200]]]},{"args":[[[0,50],[2,80]],0],"expected":[0,[[2,80]]]},{"args":[[[2,327]],16],"expected":null},{"args":[[[5,606],[1,437],[3,528],[6,894],[1,882],[2,473],[6,406],[1,220],[2,537]],1],"expected":[606,... |
fifo-inventory-b3-s00 | fifo-inventory | unit-cost-not-quantity | 20,261,008 | Implement solve(lots,demand). lots are [quantity,unit_price_cents] in purchase order with nonnegative integers. Return [cost_cents,remaining_lots] after fulfilling demand FIFO, dropping zero-quantity lots. If inventory cannot cover demand, return None. Do not mutate input; demand>=0.
Examples (JSON args and expected re... | def solve(lots,demand):
if sum(q for q,p in lots) < demand: return None
remaining = []
cost = 0
for q,p in lots:
used = min(q,demand)
demand -= used
cost += p
if q-used: remaining.append([q-used,p])
return [cost,remaining]
| train | false | 122 | [{"args":[[],0],"expected":[0,[]]},{"args":[[],1],"expected":null},{"args":[[[2,100],[3,200]],3],"expected":[400,[[2,200]]]},{"args":[[[0,50],[2,80]],0],"expected":[0,[[2,80]]]},{"args":[[[2,327]],16],"expected":null},{"args":[[[5,606],[1,437],[3,528],[6,894],[1,882],[2,473],[6,406],[1,220],[2,537]],1],"expected":[606,... |
csv-row | csv-row | baseline | 20,261,008 | Implement solve(row). Parse one valid CSV record into strings, comma delimiter, double-quote quoting, and doubled quotes inside quoted fields. No embedded newlines. Empty row means []. Do not trim spaces. Use no imports.
Examples (JSON args and expected result): [{"args": ["\" ,,,,b\",\"ba\"\",,\",\",,\",\", ,猫b,b\",\... | def solve(row):
return row.split(',') if row else []
| train | false | 145 | [{"args":[""],"expected":[]},{"args":["a,b"],"expected":["a","b"]},{"args":["\"a,b\",c"],"expected":["a,b","c"]},{"args":["\"a\"\"b\",,c"],"expected":["a\"b","","c"]},{"args":[",,"],"expected":["","",""]},{"args":["\"\""],"expected":[""]},{"args":[",aab ,\"\"\" 猫\"\"\"\",b , \",\",\"\"猫 a \",\",ab\"\"\",a,\",\""],"exp... |
csv-row-b1-s00 | csv-row | quoted-comma | 20,261,008 | Implement solve(row). Parse one valid CSV record into strings, comma delimiter, double-quote quoting, and doubled quotes inside quoted fields. No embedded newlines. Empty row means []. Do not trim spaces. Use no imports.
Examples (JSON args and expected result): [{"args": ["\" a猫猫bba猫,\""], "expected": [" a猫猫bba猫,"]}, ... | def solve(row):
if not row: return []
out = []
field = ''
quoted = False
i = 0
while i < len(row):
c = row[i]
if c == '"':
if quoted and i+1 < len(row) and row[i+1] == '"':
field += '"'
i += 1
else: quoted = not quoted
... | train | true | 145 | [{"args":[""],"expected":[]},{"args":["a,b"],"expected":["a","b"]},{"args":["\"a,b\",c"],"expected":["a,b","c"]},{"args":["\"a\"\"b\",,c"],"expected":["a\"b","","c"]},{"args":[",,"],"expected":["","",""]},{"args":["\"\""],"expected":[""]},{"args":[",aab ,\"\"\" 猫\"\"\"\",b , \",\",\"\"猫 a \",\",ab\"\"\",a,\",\""],"exp... |
csv-row-b2-s00 | csv-row | escaped-quote | 20,261,008 | Implement solve(row). Parse one valid CSV record into strings, comma delimiter, double-quote quoting, and doubled quotes inside quoted fields. No embedded newlines. Empty row means []. Do not trim spaces. Use no imports.
Examples (JSON args and expected result): [{"args": ["\"x1,y\",z"], "expected": ["x1,y", "z"]}, {"a... | def solve(row):
if not row: return []
out = []
field = ''
quoted = False
i = 0
while i < len(row):
c = row[i]
if c == '"':
if quoted and i+1 < len(row) and row[i+1] == '"':
field += '""'
i += 1
else: quoted = not quoted
... | train | false | 145 | [{"args":[""],"expected":[]},{"args":["a,b"],"expected":["a","b"]},{"args":["\"a,b\",c"],"expected":["a,b","c"]},{"args":["\"a\"\"b\",,c"],"expected":["a\"b","","c"]},{"args":[",,"],"expected":["","",""]},{"args":["\"\""],"expected":[""]},{"args":[",aab ,\"\"\" 猫\"\"\"\",b , \",\",\"\"猫 a \",\",ab\"\"\",a,\",\""],"exp... |
csv-row-b3-s00 | csv-row | lost-final-field | 20,261,008 | Implement solve(row). Parse one valid CSV record into strings, comma delimiter, double-quote quoting, and doubled quotes inside quoted fields. No embedded newlines. Empty row means []. Do not trim spaces. Use no imports.
Examples (JSON args and expected result): [{"args": ["\"x13,y\",z"], "expected": ["x13,y", "z"]}, {... | def solve(row):
if not row: return []
out = []
field = ''
quoted = False
i = 0
while i < len(row):
c = row[i]
if c == '"':
if quoted and i+1 < len(row) and row[i+1] == '"':
field += '"'
i += 1
else: quoted = not quoted
... | train | false | 145 | [{"args":[""],"expected":[]},{"args":["a,b"],"expected":["a","b"]},{"args":["\"a,b\",c"],"expected":["a,b","c"]},{"args":["\"a\"\"b\",,c"],"expected":["a\"b","","c"]},{"args":[",,"],"expected":["","",""]},{"args":["\"\""],"expected":[""]},{"args":[",aab ,\"\"\" 猫\"\"\"\",b , \",\",\"\"猫 a \",\",ab\"\"\",a,\",\""],"exp... |
shortest-path | shortest-path | baseline | 20,261,008 | Implement solve(graph,start,target). graph maps string nodes to lists of [neighbor,nonnegative_integer_weight] directed edges. Return shortest distance, or None if unreachable. start==target returns 0. Nodes without a key have no outgoing edges.
Examples (JSON args and expected result): [{"args": [{"0": [["2", 0]], "1"... | def solve(graph,start,target):
return 0 if start == target else None
| train | false | 93 | [{"args":[{},"a","a"],"expected":0},{"args":[{},"a","b"],"expected":null},{"args":[{"a":[["b",5],["c",1]],"c":[["b",1]]},"a","b"],"expected":2},{"args":[{"0":[["3",4]],"1":[["0",1]],"2":[["5",7]],"3":[],"4":[["0",1],["6",2]],"5":[["0",6],["1",4],["2",1]],"6":[["0",7]]},"0","6"],"expected":null},{"args":[{"0":[],"1":[["... |
shortest-path-b1-s00 | shortest-path | farthest-first | 20,261,008 | Implement solve(graph,start,target). graph maps string nodes to lists of [neighbor,nonnegative_integer_weight] directed edges. Return shortest distance, or None if unreachable. start==target returns 0. Nodes without a key have no outgoing edges.
Examples (JSON args and expected result): [{"args": [{"a": [["b", 168], ["... | def solve(graph,start,target):
dist = {start:0}
visited = set()
while True:
candidates = [n for n in dist if n not in visited]
if not candidates: return None
n = max(candidates,key=lambda x:dist[x])
if n == target: return dist[n]
visited.add(n)
for nxt,w in gr... | train | false | 93 | [{"args":[{},"a","a"],"expected":0},{"args":[{},"a","b"],"expected":null},{"args":[{"a":[["b",5],["c",1]],"c":[["b",1]]},"a","b"],"expected":2},{"args":[{"0":[["3",4]],"1":[["0",1]],"2":[["5",7]],"3":[],"4":[["0",1],["6",2]],"5":[["0",6],["1",4],["2",1]],"6":[["0",7]]},"0","6"],"expected":null},{"args":[{"0":[],"1":[["... |
shortest-path-b2-s00 | shortest-path | lost-path-prefix | 20,261,008 | Implement solve(graph,start,target). graph maps string nodes to lists of [neighbor,nonnegative_integer_weight] directed edges. Return shortest distance, or None if unreachable. start==target returns 0. Nodes without a key have no outgoing edges.
Examples (JSON args and expected result): [{"args": [{"0": [["4", 9], ["5"... | def solve(graph,start,target):
dist = {start:0}
visited = set()
while True:
candidates = [n for n in dist if n not in visited]
if not candidates: return None
n = min(candidates,key=lambda x:dist[x])
if n == target: return dist[n]
visited.add(n)
for nxt,w in gr... | train | false | 93 | [{"args":[{},"a","a"],"expected":0},{"args":[{},"a","b"],"expected":null},{"args":[{"a":[["b",5],["c",1]],"c":[["b",1]]},"a","b"],"expected":2},{"args":[{"0":[["3",4]],"1":[["0",1]],"2":[["5",7]],"3":[],"4":[["0",1],["6",2]],"5":[["0",6],["1",4],["2",1]],"6":[["0",7]]},"0","6"],"expected":null},{"args":[{"0":[],"1":[["... |
shortest-path-b3-s00 | shortest-path | missing-relaxation | 20,261,008 | Implement solve(graph,start,target). graph maps string nodes to lists of [neighbor,nonnegative_integer_weight] directed edges. Return shortest distance, or None if unreachable. start==target returns 0. Nodes without a key have no outgoing edges.
Examples (JSON args and expected result): [{"args": [{"0": [["3", 2]], "1"... | def solve(graph,start,target):
dist = {start:0}
visited = set()
while True:
candidates = [n for n in dist if n not in visited]
if not candidates: return None
n = min(candidates,key=lambda x:dist[x])
if n == target: return dist[n]
visited.add(n)
for nxt,w in gr... | train | false | 93 | [{"args":[{},"a","a"],"expected":0},{"args":[{},"a","b"],"expected":null},{"args":[{"a":[["b",5],["c",1]],"c":[["b",1]]},"a","b"],"expected":2},{"args":[{"0":[["3",4]],"1":[["0",1]],"2":[["5",7]],"3":[],"4":[["0",1],["6",2]],"5":[["0",6],["1",4],["2",1]],"6":[["0",7]]},"0","6"],"expected":null},{"args":[{"0":[],"1":[["... |
merge-intervals-b0-s01 | merge-intervals | baseline | 20,268,927 | Implement solve(intervals). Merge closed intervals that overlap or touch, sort by start, and return lists [start,end]. Inputs may be unsorted; do not mutate them. Empty input returns [].
Examples (JSON args and expected result): [{"args": [[[17, 24], [12, 13], [28, 30]]], "expected": [[12, 13], [17, 24], [28, 30]]}, {"... | def solve(intervals):
return sorted(intervals)
| train | false | 110 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[-9,-8]]],"expected":[[-9,-8]]},{"args":[[[6,8],[10,10],[-1,5],[28,28],[-2,4],[11,11],[13,16],[-16,-14],[17,21],[29,31]]],"expected":[[-16,-14],[-2,5],[6,8],[10,10],[11,11],[13,16],[17,21],[28,28],[29,31]]},{"args":[[[6,11],[-14,-1... |
merge-intervals-b1-s01 | merge-intervals | touching-boundary | 20,268,927 | Implement solve(intervals). Merge closed intervals that overlap or touch, sort by start, and return lists [start,end]. Inputs may be unsorted; do not mutate them. Empty input returns [].
Examples (JSON args and expected result): [{"args": [[[-19, -19], [27, 34], [-17, -14], [8, 11], [28, 33], [-10, -4], [-17, -15], [22... | def solve(intervals):
out = []
for a,b in sorted(intervals):
if out and a < out[-1][1]:
out[-1][1] = max(b, out[-1][1])
else:
out.append([a,b])
return out
| train | false | 110 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[-9,-8]]],"expected":[[-9,-8]]},{"args":[[[6,8],[10,10],[-1,5],[28,28],[-2,4],[11,11],[13,16],[-16,-14],[17,21],[29,31]]],"expected":[[-16,-14],[-2,5],[6,8],[10,10],[11,11],[13,16],[17,21],[28,28],[29,31]]},{"args":[[[6,11],[-14,-1... |
merge-intervals-b2-s01 | merge-intervals | nested-endpoint | 20,268,927 | Implement solve(intervals). Merge closed intervals that overlap or touch, sort by start, and return lists [start,end]. Inputs may be unsorted; do not mutate them. Empty input returns [].
Examples (JSON args and expected result): [{"args": [[[-14, -7], [17, 18], [28, 31], [-17, -14], [-3, 1], [24, 25], [22, 24], [21, 26... | def solve(intervals):
out = []
for a,b in sorted(intervals):
if out and a <= out[-1][1]:
out[-1][1] = min(b, out[-1][1])
else:
out.append([a,b])
return out
| train | false | 110 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[-9,-8]]],"expected":[[-9,-8]]},{"args":[[[6,8],[10,10],[-1,5],[28,28],[-2,4],[11,11],[13,16],[-16,-14],[17,21],[29,31]]],"expected":[[-16,-14],[-2,5],[6,8],[10,10],[11,11],[13,16],[17,21],[28,28],[29,31]]},{"args":[[[6,11],[-14,-1... |
merge-intervals-b3-s01 | merge-intervals | unsorted-input | 20,268,927 | Implement solve(intervals). Merge closed intervals that overlap or touch, sort by start, and return lists [start,end]. Inputs may be unsorted; do not mutate them. Empty input returns [].
Examples (JSON args and expected result): [{"args": [[[29, 30], [8, 9], [-2, 3], [1, 2], [-10, -6], [27, 28], [8, 15], [-8, -6], [-19... | def solve(intervals):
out = []
for a,b in intervals:
if out and a <= out[-1][1]:
out[-1][1] = max(b, out[-1][1])
else:
out.append([a,b])
return out
| train | false | 110 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[-9,-8]]],"expected":[[-9,-8]]},{"args":[[[6,8],[10,10],[-1,5],[28,28],[-2,4],[11,11],[13,16],[-16,-14],[17,21],[29,31]]],"expected":[[-16,-14],[-2,5],[6,8],[10,10],[11,11],[13,16],[17,21],[28,28],[29,31]]},{"args":[[[6,11],[-14,-1... |
moving-sums-b0-s01 | moving-sums | baseline | 20,268,927 | Implement solve(values,k). Return sums of every contiguous window of length k. k<=0 or k>len(values) returns [].
Examples (JSON args and expected result): [{"args": [[35, -10, -15, -30, -82, 85, 41], 17], "expected": []}, {"args": [[8, 50, 4], 1], "expected": [8, 50, 4]}, {"args": [[], 9], "expected": []}] | def solve(values,k):
return [sum(values[i:i+k]) for i in range(len(values)-k)]
| train | false | 144 | [{"args":[[],1],"expected":[]},{"args":[[1,2,3],2],"expected":[3,5]},{"args":[[5],1],"expected":[5]},{"args":[[1],0],"expected":[]},{"args":[[-96,-18],20],"expected":[]},{"args":[[13,-10,48,12,-18,-8,-96,-68,-37,78,26,-48,5],3],"expected":[51,50,42,-14,-122,-172,-201,-27,67,56,-17]},{"args":[[-22,-27,98,65,-12],14],"ex... |
moving-sums-b1-s01 | moving-sums | zero-window | 20,268,927 | Implement solve(values,k). Return sums of every contiguous window of length k. k<=0 or k>len(values) returns [].
Examples (JSON args and expected result): [{"args": [[8, -20, -25], 0], "expected": []}, {"args": [[], 17], "expected": []}, {"args": [[3, 19, -24, 13, 55, 67, 86, 68, -100, -30, -7, 38, -100, -45, 78, -28, ... | def solve(values,k):
if k < 0 or k > len(values): return []
return [sum(values[i:i+k]) for i in range(len(values)-k+1)]
| train | false | 144 | [{"args":[[],1],"expected":[]},{"args":[[1,2,3],2],"expected":[3,5]},{"args":[[5],1],"expected":[5]},{"args":[[1],0],"expected":[]},{"args":[[-96,-18],20],"expected":[]},{"args":[[13,-10,48,12,-18,-8,-96,-68,-37,78,26,-48,5],3],"expected":[51,50,42,-14,-122,-172,-201,-27,67,56,-17]},{"args":[[-22,-27,98,65,-12],14],"ex... |
moving-sums-b2-s01 | moving-sums | window-width | 20,268,927 | Implement solve(values,k). Return sums of every contiguous window of length k. k<=0 or k>len(values) returns [].
Examples (JSON args and expected result): [{"args": [[-11, -63, 77, 3, 85, 44, -100, -56, -11, 31, 3, -18, 62, -39], 13], "expected": [46, 18]}, {"args": [[89, -50, -34, -90, -59, -29, 84, 3, -13, 28, 64, -1... | def solve(values,k):
if k <= 0 or k > len(values): return []
return [sum(values[i:i+k-1]) for i in range(len(values)-k+1)]
| train | false | 144 | [{"args":[[],1],"expected":[]},{"args":[[1,2,3],2],"expected":[3,5]},{"args":[[5],1],"expected":[5]},{"args":[[1],0],"expected":[]},{"args":[[-96,-18],20],"expected":[]},{"args":[[13,-10,48,12,-18,-8,-96,-68,-37,78,26,-48,5],3],"expected":[51,50,42,-14,-122,-172,-201,-27,67,56,-17]},{"args":[[-22,-27,98,65,-12],14],"ex... |
moving-sums-b3-s01 | moving-sums | missing-first-window | 20,268,927 | Implement solve(values,k). Return sums of every contiguous window of length k. k<=0 or k>len(values) returns [].
Examples (JSON args and expected result): [{"args": [[-43, -29, 5, -69, 33, 91, 7], 12], "expected": []}, {"args": [[11, -29, 27], 2], "expected": [-18, -2]}, {"args": [[-12, 2, -10, 10, -13, -16, 7, 4, 15, ... | def solve(values,k):
if k <= 0 or k > len(values): return []
return [sum(values[i:i+k]) for i in range(1,len(values)-k+1)]
| train | false | 144 | [{"args":[[],1],"expected":[]},{"args":[[1,2,3],2],"expected":[3,5]},{"args":[[5],1],"expected":[5]},{"args":[[1],0],"expected":[]},{"args":[[-96,-18],20],"expected":[]},{"args":[[13,-10,48,12,-18,-8,-96,-68,-37,78,26,-48,5],3],"expected":[51,50,42,-14,-122,-172,-201,-27,67,56,-17]},{"args":[[-22,-27,98,65,-12],14],"ex... |
weighted-mean-b0-s01 | weighted-mean | baseline | 20,268,927 | Implement solve(values,weights). Inputs have equal length and nonnegative weights. Return weighted arithmetic mean; return None if total weight is zero (including empty inputs).
Examples (JSON args and expected result): [{"args": [[22], [4]], "expected": 22.0}, {"args": [[21, -14, 31, 49, 43, -21, 47, 3, -34, 19, -35],... | def solve(values,weights):
return sum(values)/len(values) if values else None
| train | false | 119 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[-26,13,45,-47,-46,-15,-33,-9],[1,4,2,5,1,4,2,1]],"expected":-15.0},{"args":[[-15,-43,3,46,-26,-25,27,7,-17,10,43,-16],[2,0,4,4,4,2,3,3,5,3,4,1]],"expected":6.142857142857143},{"args":[[-26,-32,-32,-49,... |
weighted-mean-b1-s01 | weighted-mean | unweighted-numerator | 20,268,927 | Implement solve(values,weights). Inputs have equal length and nonnegative weights. Return weighted arithmetic mean; return None if total weight is zero (including empty inputs).
Examples (JSON args and expected result): [{"args": [[-50, -30, 11, 1, 10, 44, -36, 13, 38, 22, 22], [2, 4, 5, 0, 5, 3, 3, 2, 3, 5, 4]], "expe... | def solve(values,weights):
total = sum(weights)
return sum(x for x,w in zip(values,weights))/total if total else None
| train | false | 119 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[-26,13,45,-47,-46,-15,-33,-9],[1,4,2,5,1,4,2,1]],"expected":-15.0},{"args":[[-15,-43,3,46,-26,-25,27,7,-17,10,43,-16],[2,0,4,4,4,2,3,3,5,3,4,1]],"expected":6.142857142857143},{"args":[[-26,-32,-32,-49,... |
weighted-mean-b2-s01 | weighted-mean | wrong-denominator | 20,268,927 | Implement solve(values,weights). Inputs have equal length and nonnegative weights. Return weighted arithmetic mean; return None if total weight is zero (including empty inputs).
Examples (JSON args and expected result): [{"args": [[-1, 6], [1, 5]], "expected": 4.833333333333333}, {"args": [[38, 6, -50], [4, 1, 3]], "ex... | def solve(values,weights):
total = len(weights)
return sum(x*w for x,w in zip(values,weights))/total if total else None
| train | false | 119 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[-26,13,45,-47,-46,-15,-33,-9],[1,4,2,5,1,4,2,1]],"expected":-15.0},{"args":[[-15,-43,3,46,-26,-25,27,7,-17,10,43,-16],[2,0,4,4,4,2,3,3,5,3,4,1]],"expected":6.142857142857143},{"args":[[-26,-32,-32,-49,... |
weighted-mean-b3-s01 | weighted-mean | zero-weight-result | 20,268,927 | Implement solve(values,weights). Inputs have equal length and nonnegative weights. Return weighted arithmetic mean; return None if total weight is zero (including empty inputs).
Examples (JSON args and expected result): [{"args": [[-9, -2], [1, 5]], "expected": -3.1666666666666665}, {"args": [[36], [4]], "expected": 36... | def solve(values,weights):
total = sum(weights)
return sum(x*w for x,w in zip(values,weights))/total if total else 0
| train | false | 119 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[-26,13,45,-47,-46,-15,-33,-9],[1,4,2,5,1,4,2,1]],"expected":-15.0},{"args":[[-15,-43,3,46,-26,-25,27,7,-17,10,43,-16],[2,0,4,4,4,2,3,3,5,3,4,1]],"expected":6.142857142857143},{"args":[[-26,-32,-32,-49,... |
stable-unique-b0-s01 | stable-unique | baseline | 20,268,927 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[-6, 10, -1, -9]], "expected": [-6, 10, -1, -9]}, {"args": [[-10, -6, -2, -7, -4]], "expected": [-10, -6, -2, -7, -4]}, {"args": [[7, -5, -10, 9, 8, 5... | def solve(values):
return sorted(set(values))
| train | false | 98 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[3,5,1,7,6,10,-8,-5,3,-1,3,9,-6,-10,-9,5,-10,-10,7,-10,2,2,-5,-1,-4,7]],"expected":[3,5,1,7,6,10,-8,-5,-1,9,-6,-10,-9,2,-4]},{"args":[[5,0,-3,-5,-3,3,-3,9,3,-1,8,5,-6,0,3,7,6,8,0,4,-3,-8,3,-4,-1,-1,-10,8]],"expected":[5,0,-3,-5,3,9,-1,8,-6,... |
stable-unique-b1-s01 | stable-unique | reverse-traversal | 20,268,927 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[7, 8, -3, 9, 1, 7, 0, 3, -7, -4, 1, 10, -5, 7]], "expected": [7, 8, -3, 9, 1, 0, 3, -7, -4, 10, -5]}, {"args": [[-24, -26, -24, -25, -26]], "expected... | def solve(values):
seen = set()
out = []
for x in reversed(values):
if x not in seen:
seen.add(x)
out.append(x)
return out
| train | false | 98 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[3,5,1,7,6,10,-8,-5,3,-1,3,9,-6,-10,-9,5,-10,-10,7,-10,2,2,-5,-1,-4,7]],"expected":[3,5,1,7,6,10,-8,-5,-1,9,-6,-10,-9,2,-4]},{"args":[[5,0,-3,-5,-3,3,-3,9,3,-1,8,5,-6,0,3,7,6,8,0,4,-3,-8,3,-4,-1,-1,-10,8]],"expected":[5,0,-3,-5,3,9,-1,8,-6,... |
stable-unique-b2-s01 | stable-unique | reverse-output | 20,268,927 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[6]], "expected": [6]}, {"args": [[1, -8, -8, 5, -3, -3, -3, 5, 2, -4, -8, -6, -4]], "expected": [1, -8, 5, -3, 2, -4, -6]}, {"args": [[-2, 10, -1, 1,... | def solve(values):
seen = set()
out = []
for x in values:
if x not in seen:
seen.add(x)
out.insert(0,x)
return out
| train | false | 98 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[3,5,1,7,6,10,-8,-5,3,-1,3,9,-6,-10,-9,5,-10,-10,7,-10,2,2,-5,-1,-4,7]],"expected":[3,5,1,7,6,10,-8,-5,-1,9,-6,-10,-9,2,-4]},{"args":[[5,0,-3,-5,-3,3,-3,9,3,-1,8,5,-6,0,3,7,6,8,0,4,-3,-8,3,-4,-1,-1,-10,8]],"expected":[5,0,-3,-5,3,9,-1,8,-6,... |
stable-unique-b3-s01 | stable-unique | wrong-seen-value | 20,268,927 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[-3, -10, 9, -3, 10, 5, -1, 7, -1, -9, -5, -9, -6, 3, -3, 8, -9]], "expected": [-3, -10, 9, 10, 5, -1, 7, -9, -5, -6, 3, 8]}, {"args": [[5, 3, 5, 4, 3... | def solve(values):
seen = set()
out = []
for x in values:
if x not in seen:
seen.add(-x)
out.append(x)
return out
| train | false | 98 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[3,5,1,7,6,10,-8,-5,3,-1,3,9,-6,-10,-9,5,-10,-10,7,-10,2,2,-5,-1,-4,7]],"expected":[3,5,1,7,6,10,-8,-5,-1,9,-6,-10,-9,2,-4]},{"args":[[5,0,-3,-5,-3,3,-3,9,3,-1,8,5,-6,0,3,7,6,8,0,4,-3,-8,3,-4,-1,-1,-10,8]],"expected":[5,0,-3,-5,3,9,-1,8,-6,... |
run-length-b0-s01 | run-length | baseline | 20,268,927 | Implement solve(text). Run-length encode consecutive Unicode characters as a list of [character,count] pairs. Empty text returns []. Nonadjacent occurrences remain separate.
Examples (JSON args and expected result): [{"args": ["cab🙂 ac"], "expected": [["c", 1], ["a", 1], ["b", 1], ["🙂", 1], [" ", 1], ["a", 1], ["c", ... | def solve(text):
return [[c,text.count(c)] for c in sorted(set(text))]
| train | false | 96 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["aa猫猫🙂a 猫🙂cccba猫a"],"expected":[["a",2],["猫",2],["🙂",1],["a",1],[" ",1],["猫",1],["🙂",1],["c",3],["b",1],["a",1],["猫",1],["a",1]]},{"args":["a 🙂🙂 猫猫c aaa🙂c猫 ... |
run-length-b1-s01 | run-length | inverted-grouping | 20,268,927 | Implement solve(text). Run-length encode consecutive Unicode characters as a list of [character,count] pairs. Empty text returns []. Nonadjacent occurrences remain separate.
Examples (JSON args and expected result): [{"args": ["🙂 🙂"], "expected": [["🙂", 1], [" ", 1], ["🙂", 1]]}, {"args": ["bbbbbbbbbdddddddd"], "exp... | def solve(text):
out = []
for c in text:
if out and out[-1][0] != c: out[-1][1] += 1
else: out.append([c,1])
return out
| train | false | 96 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["aa猫猫🙂a 猫🙂cccba猫a"],"expected":[["a",2],["猫",2],["🙂",1],["a",1],[" ",1],["猫",1],["🙂",1],["c",3],["b",1],["a",1],["猫",1],["a",1]]},{"args":["a 🙂🙂 猫猫c aaa🙂c猫 ... |
run-length-b2-s01 | run-length | double-increment | 20,268,927 | Implement solve(text). Run-length encode consecutive Unicode characters as a list of [character,count] pairs. Empty text returns []. Nonadjacent occurrences remain separate.
Examples (JSON args and expected result): [{"args": ["🙂🙂b b 猫猫b猫abac"], "expected": [["🙂", 2], ["b", 1], [" ", 1], ["b", 1], [" ", 1], ["猫", 2]... | def solve(text):
out = []
for c in text:
if out and out[-1][0] == c: out[-1][1] += 2
else: out.append([c,1])
return out
| train | false | 96 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["aa猫猫🙂a 猫🙂cccba猫a"],"expected":[["a",2],["猫",2],["🙂",1],["a",1],[" ",1],["猫",1],["🙂",1],["c",3],["b",1],["a",1],["猫",1],["a",1]]},{"args":["a 🙂🙂 猫猫c aaa🙂c猫 ... |
run-length-b3-s01 | run-length | zero-initial-count | 20,268,927 | Implement solve(text). Run-length encode consecutive Unicode characters as a list of [character,count] pairs. Empty text returns []. Nonadjacent occurrences remain separate.
Examples (JSON args and expected result): [{"args": ["a 🙂🙂🙂c猫 c猫ac猫🙂acca ca猫babb 🙂猫aab"], "expected": [["a", 1], [" ", 1], ["🙂", 3], ["c", 1... | def solve(text):
out = []
for c in text:
if out and out[-1][0] == c: out[-1][1] += 1
else: out.append([c,0])
return out
| train | false | 96 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["aa猫猫🙂a 猫🙂cccba猫a"],"expected":[["a",2],["猫",2],["🙂",1],["a",1],[" ",1],["猫",1],["🙂",1],["c",3],["b",1],["a",1],["猫",1],["a",1]]},{"args":["a 🙂🙂 猫猫c aaa🙂c猫 ... |
luhn-b0-s01 | luhn | baseline | 20,268,927 | Implement solve(text). Return whether a nonempty ASCII digit string satisfies the Luhn checksum: starting from right, double every second digit, subtract 9 if >9, and require total divisible by 10. Nondigits/empty input return False.
Examples (JSON args and expected result): [{"args": ["72778"], "expected": false}, {"a... | def solve(text):
return bool(text) and text.isdigit() and sum(int(c) for c in text)%10 == 0
| train | false | 187 | [{"args":[""],"expected":false},{"args":["0"],"expected":true},{"args":["79927398713"],"expected":true},{"args":["79927398714"],"expected":false},{"args":["12x"],"expected":false},{"args":[" 0"],"expected":false},{"args":["１２"],"expected":false},{"args":["0000"],"expected":true},{"args":["03629778143685391"],"expected"... |
luhn-b1-s01 | luhn | wrong-parity | 20,268,927 | Implement solve(text). Return whether a nonempty ASCII digit string satisfies the Luhn checksum: starting from right, double every second digit, subtract 9 if >9, and require total divisible by 10. Nondigits/empty input return False.
Examples (JSON args and expected result): [{"args": ["167310910044158"], "expected": f... | def solve(text):
if not text or any(c not in '0123456789' for c in text): return False
total = 0
for i,c in enumerate(reversed(text)):
v = int(c)
if not i%2:
v *= 2
if v > 9: v -= 9
total += v
return total%10 == 0
| train | false | 187 | [{"args":[""],"expected":false},{"args":["0"],"expected":true},{"args":["79927398713"],"expected":true},{"args":["79927398714"],"expected":false},{"args":["12x"],"expected":false},{"args":[" 0"],"expected":false},{"args":["１２"],"expected":false},{"args":["0000"],"expected":true},{"args":["03629778143685391"],"expected"... |
luhn-b2-s01 | luhn | wrong-reduction | 20,268,927 | Implement solve(text). Return whether a nonempty ASCII digit string satisfies the Luhn checksum: starting from right, double every second digit, subtract 9 if >9, and require total divisible by 10. Nondigits/empty input return False.
Examples (JSON args and expected result): [{"args": ["0437385926"], "expected": false}... | def solve(text):
if not text or any(c not in '0123456789' for c in text): return False
total = 0
for i,c in enumerate(reversed(text)):
v = int(c)
if i%2:
v *= 2
if v > 9: v -= 8
total += v
return total%10 == 0
| train | false | 187 | [{"args":[""],"expected":false},{"args":["0"],"expected":true},{"args":["79927398713"],"expected":true},{"args":["79927398714"],"expected":false},{"args":["12x"],"expected":false},{"args":[" 0"],"expected":false},{"args":["１２"],"expected":false},{"args":["0000"],"expected":true},{"args":["03629778143685391"],"expected"... |
luhn-b3-s01 | luhn | wrong-modulus | 20,268,927 | Implement solve(text). Return whether a nonempty ASCII digit string satisfies the Luhn checksum: starting from right, double every second digit, subtract 9 if >9, and require total divisible by 10. Nondigits/empty input return False.
Examples (JSON args and expected result): [{"args": ["019887976595"], "expected": true... | def solve(text):
if not text or any(c not in '0123456789' for c in text): return False
total = 0
for i,c in enumerate(reversed(text)):
v = int(c)
if i%2:
v *= 2
if v > 9: v -= 9
total += v
return total%9 == 0
| train | false | 187 | [{"args":[""],"expected":false},{"args":["0"],"expected":true},{"args":["79927398713"],"expected":true},{"args":["79927398714"],"expected":false},{"args":["12x"],"expected":false},{"args":[" 0"],"expected":false},{"args":["１２"],"expected":false},{"args":["0000"],"expected":true},{"args":["03629778143685391"],"expected"... |
edit-distance-b0-s01 | edit-distance | baseline | 20,268,927 | Implement solve(a,b). Return Levenshtein edit distance with unit-cost insertion, deletion, and substitution over Unicode characters.
Examples (JSON args and expected result): [{"args": ["猫cda", "acac"], "expected": 3}, {"args": ["dbab", "ccabadc"], "expected": 5}, {"args": ["猫a猫bbabdc猫d", "abc猫dcdd猫bc"], "expected": 9}... | def solve(a,b):
return abs(len(a)-len(b))
| train | false | 142 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["d猫cdd猫","猫bacdbc猫"],"expected":5},{"args":["b猫","d猫猫bca"],"expected":5},{"args":["bdc猫ba猫","cbbc猫猫d"],"expected":5},{"args":["cbbd","d"],"expected":3},{"args":["猫bcacadddda","猫bba"],"expected":8},{"args":... |
edit-distance-b1-s01 | edit-distance | row-boundary | 20,268,927 | Implement solve(a,b). Return Levenshtein edit distance with unit-cost insertion, deletion, and substitution over Unicode characters.
Examples (JSON args and expected result): [{"args": ["acabbcb", "acabbcb"], "expected": 0}, {"args": ["ca", "d"], "expected": 2}, {"args": ["aa猫acadbca", "c"], "expected": 9}] | def solve(a,b):
row = list(range(len(b)+1))
for i,x in enumerate(a,1):
nxt = [0]
for j,y in enumerate(b,1):
nxt.append(min(nxt[-1]+1,row[j]+1,row[j-1]+(x != y)))
row = nxt
return row[-1]
| train | false | 142 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["d猫cdd猫","猫bacdbc猫"],"expected":5},{"args":["b猫","d猫猫bca"],"expected":5},{"args":["bdc猫ba猫","cbbc猫猫d"],"expected":5},{"args":["cbbd","d"],"expected":3},{"args":["猫bcacadddda","猫bba"],"expected":8},{"args":... |
edit-distance-b2-s01 | edit-distance | inverted-substitution | 20,268,927 | Implement solve(a,b). Return Levenshtein edit distance with unit-cost insertion, deletion, and substitution over Unicode characters.
Examples (JSON args and expected result): [{"args": ["ac猫dabd", "ac猫猫bbd猫"], "expected": 3}, {"args": ["cccaadcb猫猫猫", "bdcacdd"], "expected": 8}, {"args": ["dba", "ddbc"], "expected": 2}] | def solve(a,b):
row = list(range(len(b)+1))
for i,x in enumerate(a,1):
nxt = [i]
for j,y in enumerate(b,1):
nxt.append(min(nxt[-1]+1,row[j]+1,row[j-1]+(x == y)))
row = nxt
return row[-1]
| train | false | 142 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["d猫cdd猫","猫bacdbc猫"],"expected":5},{"args":["b猫","d猫猫bca"],"expected":5},{"args":["bdc猫ba猫","cbbc猫猫d"],"expected":5},{"args":["cbbd","d"],"expected":3},{"args":["猫bcacadddda","猫bba"],"expected":8},{"args":... |
edit-distance-b3-s01 | edit-distance | diagonal-index | 20,268,927 | Implement solve(a,b). Return Levenshtein edit distance with unit-cost insertion, deletion, and substitution over Unicode characters.
Examples (JSON args and expected result): [{"args": ["cbcb", "猫ccccda"], "expected": 5}, {"args": ["ac猫bba", "ac猫bba"], "expected": 0}, {"args": ["猫bb", ""], "expected": 3}] | def solve(a,b):
row = list(range(len(b)+1))
for i,x in enumerate(a,1):
nxt = [i]
for j,y in enumerate(b,1):
nxt.append(min(nxt[-1]+1,row[j]+1,row[j]+(x != y)))
row = nxt
return row[-1]
| train | false | 142 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["d猫cdd猫","猫bacdbc猫"],"expected":5},{"args":["b猫","d猫猫bca"],"expected":5},{"args":["bdc猫ba猫","cbbc猫猫d"],"expected":5},{"args":["cbbd","d"],"expected":3},{"args":["猫bcacadddda","猫bba"],"expected":8},{"args":... |
meeting-rooms-b0-s01 | meeting-rooms | baseline | 20,268,927 | Implement solve(intervals). Return minimum rooms for positive-length half-open meetings [start,end). A meeting ending at time t frees its room for one starting at t. Empty input returns 0.
Examples (JSON args and expected result): [{"args": [[[0, 3], [9, 15], [16, 24], [13, 15], [2, 7], [12, 13], [10, 17], [1, 7], [13,... | def solve(intervals):
return len(intervals)
| train | false | 118 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[4,10],[17,22],[2,9],[3,5],[2,10],[18,19],[19,25],[15,20],[17,20],[15,17],[1,5]]],"expected":5},{"args":[[[5,11],[12,18],[18,19],[13,19],[13,17],[3,10],[2,7],[7,10],[19,25],[9,15],[18,22],[14,20]]],"e... |
meeting-rooms-b1-s01 | meeting-rooms | tie-order | 20,268,927 | Implement solve(intervals). Return minimum rooms for positive-length half-open meetings [start,end). A meeting ending at time t frees its room for one starting at t. Empty input returns 0.
Examples (JSON args and expected result): [{"args": [[[15, 22], [0, 4], [15, 18], [9, 14], [15, 23], [16, 18], [6, 11], [19, 24], [... | def solve(intervals):
events = []
for a,b in intervals:
events.append([a,1])
events.append([b,-1])
active = best = 0
for t,d in sorted(events,key=lambda item:(item[0],-item[1])):
active += d
best = max(best,active)
return best
| train | false | 118 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[4,10],[17,22],[2,9],[3,5],[2,10],[18,19],[19,25],[15,20],[17,20],[15,17],[1,5]]],"expected":5},{"args":[[[5,11],[12,18],[18,19],[13,19],[13,17],[3,10],[2,7],[7,10],[19,25],[9,15],[18,22],[14,20]]],"e... |
meeting-rooms-b2-s01 | meeting-rooms | peak-tracking | 20,268,927 | Implement solve(intervals). Return minimum rooms for positive-length half-open meetings [start,end). A meeting ending at time t frees its room for one starting at t. Empty input returns 0.
Examples (JSON args and expected result): [{"args": [[[8, 10], [10, 12]]], "expected": 1}, {"args": [[[1, 2], [7, 8], [9, 13], [11,... | def solve(intervals):
events = []
for a,b in intervals:
events.append([a,1])
events.append([b,-1])
active = best = 0
for t,d in sorted(events):
active += d
best = min(best,active)
return best
| train | false | 118 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[4,10],[17,22],[2,9],[3,5],[2,10],[18,19],[19,25],[15,20],[17,20],[15,17],[1,5]]],"expected":5},{"args":[[[5,11],[12,18],[18,19],[13,19],[13,17],[3,10],[2,7],[7,10],[19,25],[9,15],[18,22],[14,20]]],"e... |
meeting-rooms-b3-s01 | meeting-rooms | end-event-sign | 20,268,927 | Implement solve(intervals). Return minimum rooms for positive-length half-open meetings [start,end). A meeting ending at time t frees its room for one starting at t. Empty input returns 0.
Examples (JSON args and expected result): [{"args": [[[34, 36], [36, 38]]], "expected": 1}, {"args": [[[9, 11], [2, 3], [7, 8], [18... | def solve(intervals):
events = []
for a,b in intervals:
events.append([a,1])
events.append([b,1])
active = best = 0
for t,d in sorted(events):
active += d
best = max(best,active)
return best
| train | false | 118 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[4,10],[17,22],[2,9],[3,5],[2,10],[18,19],[19,25],[15,20],[17,20],[15,17],[1,5]]],"expected":5},{"args":[[[5,11],[12,18],[18,19],[13,19],[13,17],[3,10],[2,7],[7,10],[19,25],[9,15],[18,22],[14,20]]],"e... |
nearest-percentile-b0-s01 | nearest-percentile | baseline | 20,268,927 | Implement solve(values,p). Return nearest-rank percentile: sort ascending and take 1-based rank max(1,ceil(p/100*n)). p is integer 0..100. Empty input returns None.
Examples (JSON args and expected result): [{"args": [[-60, -17, 37, -93, 45, 45, -46, 35, 39, 21], 0], "expected": -93}, {"args": [[-34, 73, 38, -45], 50],... | def solve(values,p):
return sorted(values)[int(p/100*len(values))] if values else None
| train | false | 144 | [{"args":[[],50],"expected":null},{"args":[[1,2,3,4],100],"expected":4},{"args":[[1,2,3,4],50],"expected":2},{"args":[[4],0],"expected":4},{"args":[[-56,4,-22,66,93,37,16,97,19,77,-15,71,-64,53],50],"expected":19},{"args":[[-5,19,83,-33,-21,2,-52,-55,-40,69,-27,-4,-83,67,-1,97],100],"expected":97},{"args":[[39,19,44,68... |
nearest-percentile-b1-s01 | nearest-percentile | floor-not-ceiling | 20,268,927 | Implement solve(values,p). Return nearest-rank percentile: sort ascending and take 1-based rank max(1,ceil(p/100*n)). p is integer 0..100. Empty input returns None.
Examples (JSON args and expected result): [{"args": [[7, 16, 8, 14, 11, 6, 15, 4, 12, 17, 5, 21, 19, 9, 13, 18, 10, 22, 20], 33], "expected": 10}, {"args":... | def solve(values,p):
if not values: return None
rank = max(1,(p*len(values)+0)//100)
return sorted(values)[rank-1]
| train | false | 144 | [{"args":[[],50],"expected":null},{"args":[[1,2,3,4],100],"expected":4},{"args":[[1,2,3,4],50],"expected":2},{"args":[[4],0],"expected":4},{"args":[[-56,4,-22,66,93,37,16,97,19,77,-15,71,-64,53],50],"expected":19},{"args":[[-5,19,83,-33,-21,2,-52,-55,-40,69,-27,-4,-83,67,-1,97],100],"expected":97},{"args":[[39,19,44,68... |
nearest-percentile-b2-s01 | nearest-percentile | rank-index | 20,268,927 | Implement solve(values,p). Return nearest-rank percentile: sort ascending and take 1-based rank max(1,ceil(p/100*n)). p is integer 0..100. Empty input returns None.
Examples (JSON args and expected result): [{"args": [[40, 3, 54, -20, 37, -17, -40, 45, -28, 34, -97, 61, 93, 8, -82, 31, 9, 46, -11, -26, 11, -64], 50], "... | def solve(values,p):
if not values: return None
rank = max(1,(p*len(values)+99)//100)
return sorted(values)[rank-2]
| train | true | 144 | [{"args":[[],50],"expected":null},{"args":[[1,2,3,4],100],"expected":4},{"args":[[1,2,3,4],50],"expected":2},{"args":[[4],0],"expected":4},{"args":[[-56,4,-22,66,93,37,16,97,19,77,-15,71,-64,53],50],"expected":19},{"args":[[-5,19,83,-33,-21,2,-52,-55,-40,69,-27,-4,-83,67,-1,97],100],"expected":97},{"args":[[39,19,44,68... |
nearest-percentile-b3-s01 | nearest-percentile | descending-order | 20,268,927 | Implement solve(values,p). Return nearest-rank percentile: sort ascending and take 1-based rank max(1,ceil(p/100*n)). p is integer 0..100. Empty input returns None.
Examples (JSON args and expected result): [{"args": [[-28, -53, 1, -30, -68, -16, -19, 79, -18, 70, -99, 83, -36, 30, 93, 5, -64, 96], 50], "expected": -18... | def solve(values,p):
if not values: return None
rank = max(1,(p*len(values)+99)//100)
return sorted(values,reverse=True)[rank-1]
| train | false | 144 | [{"args":[[],50],"expected":null},{"args":[[1,2,3,4],100],"expected":4},{"args":[[1,2,3,4],50],"expected":2},{"args":[[4],0],"expected":4},{"args":[[-56,4,-22,66,93,37,16,97,19,77,-15,71,-64,53],50],"expected":19},{"args":[[-5,19,83,-33,-21,2,-52,-55,-40,69,-27,-4,-83,67,-1,97],100],"expected":97},{"args":[[39,19,44,68... |
fifo-inventory-b0-s01 | fifo-inventory | baseline | 20,268,927 | Implement solve(lots,demand). lots are [quantity,unit_price_cents] in purchase order with nonnegative integers. Return [cost_cents,remaining_lots] after fulfilling demand FIFO, dropping zero-quantity lots. If inventory cannot cover demand, return None. Do not mutate input; demand>=0.
Examples (JSON args and expected re... | def solve(lots,demand):
return [0,lots]
| train | false | 124 | [{"args":[[],0],"expected":[0,[]]},{"args":[[],1],"expected":null},{"args":[[[2,100],[3,200]],3],"expected":[400,[[2,200]]]},{"args":[[[0,50],[2,80]],0],"expected":[0,[[2,80]]]},{"args":[[[7,775],[3,885],[0,101],[2,527],[5,914],[0,742],[2,82],[4,599]],27],"expected":null},{"args":[[[2,411],[3,690],[4,263]],15],"expecte... |
fifo-inventory-b1-s01 | fifo-inventory | zero-lot-retention | 20,268,927 | Implement solve(lots,demand). lots are [quantity,unit_price_cents] in purchase order with nonnegative integers. Return [cost_cents,remaining_lots] after fulfilling demand FIFO, dropping zero-quantity lots. If inventory cannot cover demand, return None. Do not mutate input; demand>=0.
Examples (JSON args and expected re... | def solve(lots,demand):
if sum(q for q,p in lots) < demand: return None
remaining = []
cost = 0
for q,p in lots:
used = min(q,demand)
demand -= used
cost += used*p
if q >= used: remaining.append([q-used,p])
return [cost,remaining]
| train | false | 124 | [{"args":[[],0],"expected":[0,[]]},{"args":[[],1],"expected":null},{"args":[[[2,100],[3,200]],3],"expected":[400,[[2,200]]]},{"args":[[[0,50],[2,80]],0],"expected":[0,[[2,80]]]},{"args":[[[7,775],[3,885],[0,101],[2,527],[5,914],[0,742],[2,82],[4,599]],27],"expected":null},{"args":[[[2,411],[3,690],[4,263]],15],"expecte... |
fifo-inventory-b2-s01 | fifo-inventory | over-consumption | 20,268,927 | Implement solve(lots,demand). lots are [quantity,unit_price_cents] in purchase order with nonnegative integers. Return [cost_cents,remaining_lots] after fulfilling demand FIFO, dropping zero-quantity lots. If inventory cannot cover demand, return None. Do not mutate input; demand>=0.
Examples (JSON args and expected re... | def solve(lots,demand):
if sum(q for q,p in lots) < demand: return None
remaining = []
cost = 0
for q,p in lots:
used = max(q,demand)
demand -= used
cost += used*p
if q-used: remaining.append([q-used,p])
return [cost,remaining]
| train | false | 124 | [{"args":[[],0],"expected":[0,[]]},{"args":[[],1],"expected":null},{"args":[[[2,100],[3,200]],3],"expected":[400,[[2,200]]]},{"args":[[[0,50],[2,80]],0],"expected":[0,[[2,80]]]},{"args":[[[7,775],[3,885],[0,101],[2,527],[5,914],[0,742],[2,82],[4,599]],27],"expected":null},{"args":[[[2,411],[3,690],[4,263]],15],"expecte... |
fifo-inventory-b3-s01 | fifo-inventory | unit-cost-not-quantity | 20,268,927 | Implement solve(lots,demand). lots are [quantity,unit_price_cents] in purchase order with nonnegative integers. Return [cost_cents,remaining_lots] after fulfilling demand FIFO, dropping zero-quantity lots. If inventory cannot cover demand, return None. Do not mutate input; demand>=0.
Examples (JSON args and expected re... | def solve(lots,demand):
if sum(q for q,p in lots) < demand: return None
remaining = []
cost = 0
for q,p in lots:
used = min(q,demand)
demand -= used
cost += p
if q-used: remaining.append([q-used,p])
return [cost,remaining]
| train | false | 124 | [{"args":[[],0],"expected":[0,[]]},{"args":[[],1],"expected":null},{"args":[[[2,100],[3,200]],3],"expected":[400,[[2,200]]]},{"args":[[[0,50],[2,80]],0],"expected":[0,[[2,80]]]},{"args":[[[7,775],[3,885],[0,101],[2,527],[5,914],[0,742],[2,82],[4,599]],27],"expected":null},{"args":[[[2,411],[3,690],[4,263]],15],"expecte... |
csv-row-b0-s01 | csv-row | baseline | 20,268,927 | Implement solve(row). Parse one valid CSV record into strings, comma delimiter, double-quote quoting, and doubled quotes inside quoted fields. No embedded newlines. Empty row means []. Do not trim spaces. Use no imports.
Examples (JSON args and expected result): [{"args": ["\" ,a\",\"b bba猫\"\" \", a bba a,\"\"\"\"\"... | def solve(row):
return row.split(',') if row else []
| train | false | 145 | [{"args":[""],"expected":[]},{"args":["a,b"],"expected":["a","b"]},{"args":["\"a,b\",c"],"expected":["a,b","c"]},{"args":["\"a\"\"b\",,c"],"expected":["a\"b","","c"]},{"args":[",,"],"expected":["","",""]},{"args":["\"\""],"expected":[""]},{"args":["aa a猫猫猫 ba,\"a猫\"\"a\"\",\",\"\"\"b猫,\"\", \",\"\"\",\"\"b,b \"\"a\",... |
csv-row-b1-s01 | csv-row | quoted-comma | 20,268,927 | Implement solve(row). Parse one valid CSV record into strings, comma delimiter, double-quote quoting, and doubled quotes inside quoted fields. No embedded newlines. Empty row means []. Do not trim spaces. Use no imports.
Examples (JSON args and expected result): [{"args": ["\"x3\"\"y\",z"], "expected": ["x3\"y", "z"]},... | def solve(row):
if not row: return []
out = []
field = ''
quoted = False
i = 0
while i < len(row):
c = row[i]
if c == '"':
if quoted and i+1 < len(row) and row[i+1] == '"':
field += '"'
i += 1
else: quoted = not quoted
... | train | false | 145 | [{"args":[""],"expected":[]},{"args":["a,b"],"expected":["a","b"]},{"args":["\"a,b\",c"],"expected":["a,b","c"]},{"args":["\"a\"\"b\",,c"],"expected":["a\"b","","c"]},{"args":[",,"],"expected":["","",""]},{"args":["\"\""],"expected":[""]},{"args":["aa a猫猫猫 ba,\"a猫\"\"a\"\",\",\"\"\"b猫,\"\", \",\"\"\",\"\"b,b \"\"a\",... |
csv-row-b2-s01 | csv-row | escaped-quote | 20,268,927 | Implement solve(row). Parse one valid CSV record into strings, comma delimiter, double-quote quoting, and doubled quotes inside quoted fields. No embedded newlines. Empty row means []. Do not trim spaces. Use no imports.
Examples (JSON args and expected result): [{"args": ["\"b\"\"猫猫\""], "expected": ["b\"猫猫"]}, {"args... | def solve(row):
if not row: return []
out = []
field = ''
quoted = False
i = 0
while i < len(row):
c = row[i]
if c == '"':
if quoted and i+1 < len(row) and row[i+1] == '"':
field += '""'
i += 1
else: quoted = not quoted
... | train | false | 145 | [{"args":[""],"expected":[]},{"args":["a,b"],"expected":["a","b"]},{"args":["\"a,b\",c"],"expected":["a,b","c"]},{"args":["\"a\"\"b\",,c"],"expected":["a\"b","","c"]},{"args":[",,"],"expected":["","",""]},{"args":["\"\""],"expected":[""]},{"args":["aa a猫猫猫 ba,\"a猫\"\"a\"\",\",\"\"\"b猫,\"\", \",\"\"\",\"\"b,b \"\"a\",... |
csv-row-b3-s01 | csv-row | lost-final-field | 20,268,927 | Implement solve(row). Parse one valid CSV record into strings, comma delimiter, double-quote quoting, and doubled quotes inside quoted fields. No embedded newlines. Empty row means []. Do not trim spaces. Use no imports.
Examples (JSON args and expected result): [{"args": ["猫猫 "], "expected": ["猫猫 "]}, {"args": ["\"x... | def solve(row):
if not row: return []
out = []
field = ''
quoted = False
i = 0
while i < len(row):
c = row[i]
if c == '"':
if quoted and i+1 < len(row) and row[i+1] == '"':
field += '"'
i += 1
else: quoted = not quoted
... | train | false | 145 | [{"args":[""],"expected":[]},{"args":["a,b"],"expected":["a","b"]},{"args":["\"a,b\",c"],"expected":["a,b","c"]},{"args":["\"a\"\"b\",,c"],"expected":["a\"b","","c"]},{"args":[",,"],"expected":["","",""]},{"args":["\"\""],"expected":[""]},{"args":["aa a猫猫猫 ba,\"a猫\"\"a\"\",\",\"\"\"b猫,\"\", \",\"\"\",\"\"b,b \"\"a\",... |
shortest-path-b0-s01 | shortest-path | baseline | 20,268,927 | Implement solve(graph,start,target). graph maps string nodes to lists of [neighbor,nonnegative_integer_weight] directed edges. Return shortest distance, or None if unreachable. start==target returns 0. Nodes without a key have no outgoing edges.
Examples (JSON args and expected result): [{"args": [{"0": [], "1": []}, "... | def solve(graph,start,target):
return 0 if start == target else None
| train | false | 93 | [{"args":[{},"a","a"],"expected":0},{"args":[{},"a","b"],"expected":null},{"args":[{"a":[["b",5],["c",1]],"c":[["b",1]]},"a","b"],"expected":2},{"args":[{"0":[],"1":[["0",2]],"2":[["0",7]],"3":[["1",5]]},"0","3"],"expected":null},{"args":[{"0":[["1",5],["4",7]],"1":[["0",0]],"2":[["5",8]],"3":[["5",4],["7",7]],"4":[],"... |
shortest-path-b1-s01 | shortest-path | farthest-first | 20,268,927 | Implement solve(graph,start,target). graph maps string nodes to lists of [neighbor,nonnegative_integer_weight] directed edges. Return shortest distance, or None if unreachable. start==target returns 0. Nodes without a key have no outgoing edges.
Examples (JSON args and expected result): [{"args": [{"0": [["2", 5]], "1"... | def solve(graph,start,target):
dist = {start:0}
visited = set()
while True:
candidates = [n for n in dist if n not in visited]
if not candidates: return None
n = max(candidates,key=lambda x:dist[x])
if n == target: return dist[n]
visited.add(n)
for nxt,w in gr... | train | false | 93 | [{"args":[{},"a","a"],"expected":0},{"args":[{},"a","b"],"expected":null},{"args":[{"a":[["b",5],["c",1]],"c":[["b",1]]},"a","b"],"expected":2},{"args":[{"0":[],"1":[["0",2]],"2":[["0",7]],"3":[["1",5]]},"0","3"],"expected":null},{"args":[{"0":[["1",5],["4",7]],"1":[["0",0]],"2":[["5",8]],"3":[["5",4],["7",7]],"4":[],"... |
shortest-path-b2-s01 | shortest-path | lost-path-prefix | 20,268,927 | Implement solve(graph,start,target). graph maps string nodes to lists of [neighbor,nonnegative_integer_weight] directed edges. Return shortest distance, or None if unreachable. start==target returns 0. Nodes without a key have no outgoing edges.
Examples (JSON args and expected result): [{"args": [{"0": [["2", 2], ["3"... | def solve(graph,start,target):
dist = {start:0}
visited = set()
while True:
candidates = [n for n in dist if n not in visited]
if not candidates: return None
n = min(candidates,key=lambda x:dist[x])
if n == target: return dist[n]
visited.add(n)
for nxt,w in gr... | train | false | 93 | [{"args":[{},"a","a"],"expected":0},{"args":[{},"a","b"],"expected":null},{"args":[{"a":[["b",5],["c",1]],"c":[["b",1]]},"a","b"],"expected":2},{"args":[{"0":[],"1":[["0",2]],"2":[["0",7]],"3":[["1",5]]},"0","3"],"expected":null},{"args":[{"0":[["1",5],["4",7]],"1":[["0",0]],"2":[["5",8]],"3":[["5",4],["7",7]],"4":[],"... |
shortest-path-b3-s01 | shortest-path | missing-relaxation | 20,268,927 | Implement solve(graph,start,target). graph maps string nodes to lists of [neighbor,nonnegative_integer_weight] directed edges. Return shortest distance, or None if unreachable. start==target returns 0. Nodes without a key have no outgoing edges.
Examples (JSON args and expected result): [{"args": [{"0": [["1", 6]], "1"... | def solve(graph,start,target):
dist = {start:0}
visited = set()
while True:
candidates = [n for n in dist if n not in visited]
if not candidates: return None
n = min(candidates,key=lambda x:dist[x])
if n == target: return dist[n]
visited.add(n)
for nxt,w in gr... | train | false | 93 | [{"args":[{},"a","a"],"expected":0},{"args":[{},"a","b"],"expected":null},{"args":[{"a":[["b",5],["c",1]],"c":[["b",1]]},"a","b"],"expected":2},{"args":[{"0":[],"1":[["0",2]],"2":[["0",7]],"3":[["1",5]]},"0","3"],"expected":null},{"args":[{"0":[["1",5],["4",7]],"1":[["0",0]],"2":[["5",8]],"3":[["5",4],["7",7]],"4":[],"... |
merge-intervals-b0-s02 | merge-intervals | baseline | 20,276,846 | Implement solve(intervals). Merge closed intervals that overlap or touch, sort by start, and return lists [start,end]. Inputs may be unsorted; do not mutate them. Empty input returns [].
Examples (JSON args and expected result): [{"args": [[[10, 14], [-20, -20], [11, 14], [-1, -1], [10, 17], [-9, -4], [-12, -5], [-18, ... | def solve(intervals):
return sorted(intervals)
| train | false | 104 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[-1,2],[20,21],[29,33],[23,30]]],"expected":[[-1,2],[20,21],[23,33]]},{"args":[[[-19,-19],[24,28],[24,25],[-12,-9],[14,17]]],"expected":[[-19,-19],[-12,-9],[14,17],[24,28]]},{"args":[[[1,6],[0,4],[-18,-11],[27,34],[-17,-15],[16,19]... |
merge-intervals-b1-s02 | merge-intervals | touching-boundary | 20,276,846 | Implement solve(intervals). Merge closed intervals that overlap or touch, sort by start, and return lists [start,end]. Inputs may be unsorted; do not mutate them. Empty input returns [].
Examples (JSON args and expected result): [{"args": [[[-6, 0], [15, 20], [9, 10], [-13, -8], [-16, -16], [-6, 1], [24, 25], [-20, -15... | def solve(intervals):
out = []
for a,b in sorted(intervals):
if out and a < out[-1][1]:
out[-1][1] = max(b, out[-1][1])
else:
out.append([a,b])
return out
| train | false | 104 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[-1,2],[20,21],[29,33],[23,30]]],"expected":[[-1,2],[20,21],[23,33]]},{"args":[[[-19,-19],[24,28],[24,25],[-12,-9],[14,17]]],"expected":[[-19,-19],[-12,-9],[14,17],[24,28]]},{"args":[[[1,6],[0,4],[-18,-11],[27,34],[-17,-15],[16,19]... |
merge-intervals-b2-s02 | merge-intervals | nested-endpoint | 20,276,846 | Implement solve(intervals). Merge closed intervals that overlap or touch, sort by start, and return lists [start,end]. Inputs may be unsorted; do not mutate them. Empty input returns [].
Examples (JSON args and expected result): [{"args": [[[-6, -1], [-9, -6]]], "expected": [[-9, -1]]}, {"args": [[[0, 1], [20, 27], [-1... | def solve(intervals):
out = []
for a,b in sorted(intervals):
if out and a <= out[-1][1]:
out[-1][1] = min(b, out[-1][1])
else:
out.append([a,b])
return out
| train | false | 104 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[-1,2],[20,21],[29,33],[23,30]]],"expected":[[-1,2],[20,21],[23,33]]},{"args":[[[-19,-19],[24,28],[24,25],[-12,-9],[14,17]]],"expected":[[-19,-19],[-12,-9],[14,17],[24,28]]},{"args":[[[1,6],[0,4],[-18,-11],[27,34],[-17,-15],[16,19]... |
merge-intervals-b3-s02 | merge-intervals | unsorted-input | 20,276,846 | Implement solve(intervals). Merge closed intervals that overlap or touch, sort by start, and return lists [start,end]. Inputs may be unsorted; do not mutate them. Empty input returns [].
Examples (JSON args and expected result): [{"args": [[[-29, -21], [-28, -27]]], "expected": [[-29, -21]]}, {"args": [[[-6, 1], [21, 2... | def solve(intervals):
out = []
for a,b in intervals:
if out and a <= out[-1][1]:
out[-1][1] = max(b, out[-1][1])
else:
out.append([a,b])
return out
| train | false | 104 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[-1,2],[20,21],[29,33],[23,30]]],"expected":[[-1,2],[20,21],[23,33]]},{"args":[[[-19,-19],[24,28],[24,25],[-12,-9],[14,17]]],"expected":[[-19,-19],[-12,-9],[14,17],[24,28]]},{"args":[[[1,6],[0,4],[-18,-11],[27,34],[-17,-15],[16,19]... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.