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 |
|---|---|---|---|---|---|---|---|---|---|
weighted-mean-b0-s04 | weighted-mean | baseline | 20,292,684 | 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": [[-3, 31, -15, -38, -16, 14, 26, -17, 46, -29, 30], [4, 0, 1, 4, 2, 2, 4, 3, 4, 1, 2]], "e... | def solve(values,weights):
return sum(values)/len(values) if values else None
| train | true | 117 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[-8,-34,-44,3,4,-15,47,-4,-30,-49,-24,6,-49],[4,1,3,5,0,4,5,0,5,0,5,5,0]],"expected":-6.702702702702703},{"args":[[40,-50,-50,21,-48,-5,-29],[3,1,3,2,5,4,2]],"expected":-17.8},{"args":[[-21,-13,-19,34,2... |
weighted-mean-b1-s04 | weighted-mean | unweighted-numerator | 20,292,684 | 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": [[19, 26], [0, 0]], "expected": null}, {"args": [[50, -37, -10, -7, 23, -40, -34, -3, 33, ... | def solve(values,weights):
total = sum(weights)
return sum(x for x,w in zip(values,weights))/total if total else None
| train | false | 117 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[-8,-34,-44,3,4,-15,47,-4,-30,-49,-24,6,-49],[4,1,3,5,0,4,5,0,5,0,5,5,0]],"expected":-6.702702702702703},{"args":[[40,-50,-50,21,-48,-5,-29],[3,1,3,2,5,4,2]],"expected":-17.8},{"args":[[-21,-13,-19,34,2... |
weighted-mean-b2-s04 | weighted-mean | wrong-denominator | 20,292,684 | 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, -13, -30, -27, -11, -39, -50, 2, 18, 10, 2, -31, 14, 42, 21, 18, 36, 42], [3, 2, 5, 0... | 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 | 117 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[-8,-34,-44,3,4,-15,47,-4,-30,-49,-24,6,-49],[4,1,3,5,0,4,5,0,5,0,5,5,0]],"expected":-6.702702702702703},{"args":[[40,-50,-50,21,-48,-5,-29],[3,1,3,2,5,4,2]],"expected":-17.8},{"args":[[-21,-13,-19,34,2... |
weighted-mean-b3-s04 | weighted-mean | zero-weight-result | 20,292,684 | 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": [[-23, 16, 10, 29, 4, 6, -5, -12, 16, 19, -45, -41, 4, -42, 23, -48, -26, -28, -41], [4, 5... | 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 | 117 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[-8,-34,-44,3,4,-15,47,-4,-30,-49,-24,6,-49],[4,1,3,5,0,4,5,0,5,0,5,5,0]],"expected":-6.702702702702703},{"args":[[40,-50,-50,21,-48,-5,-29],[3,1,3,2,5,4,2]],"expected":-17.8},{"args":[[-21,-13,-19,34,2... |
stable-unique-b0-s04 | stable-unique | baseline | 20,292,684 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[-4, -6, -4, -5, -6]], "expected": [-4, -6, -5]}, {"args": [[-8, -8, 2, -9, 8, -1, 2, 4, -6, 6, -1, -6, 6, 6, -2]], "expected": [-8, 2, -9, 8, -1, 4, ... | def solve(values):
return sorted(set(values))
| train | false | 98 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[-9,-10,7,8,10,8,-4,10,-1,3]],"expected":[-9,-10,7,8,10,-4,-1,3]},{"args":[[3,-7,-8,-4,2,-1,-10,-9]],"expected":[3,-7,-8,-4,2,-1,-10,-9]},{"args":[[4,2,1,10,7,7,4,5,10]],"expected":[4,2,1,10,7,5]},{"args":[[4,1,6]],"expected":[4,1,6]},{"arg... |
stable-unique-b1-s04 | stable-unique | reverse-traversal | 20,292,684 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[-8, 2, 6, -9, 2, -9, 10, -9, 7, -7, 3, 2, -8, -8, 4, -3, 5, 8, 8, 5, -10, 2, -2, 9]], "expected": [-8, 2, 6, -9, 10, 7, -7, 3, 4, -3, 5, 8, -10, -2, ... | 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":[[-9,-10,7,8,10,8,-4,10,-1,3]],"expected":[-9,-10,7,8,10,-4,-1,3]},{"args":[[3,-7,-8,-4,2,-1,-10,-9]],"expected":[3,-7,-8,-4,2,-1,-10,-9]},{"args":[[4,2,1,10,7,7,4,5,10]],"expected":[4,2,1,10,7,5]},{"args":[[4,1,6]],"expected":[4,1,6]},{"arg... |
stable-unique-b2-s04 | stable-unique | reverse-output | 20,292,684 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[9, -9, 10, 10, 8, 3, -6, 6, 1, -2, -2]], "expected": [9, -9, 10, 8, 3, -6, 6, 1, -2]}, {"args": [[10, 2, 6, 3, -1, 8, 8, -7, 3, -4, -7, -4, 3, 8, 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":[[-9,-10,7,8,10,8,-4,10,-1,3]],"expected":[-9,-10,7,8,10,-4,-1,3]},{"args":[[3,-7,-8,-4,2,-1,-10,-9]],"expected":[3,-7,-8,-4,2,-1,-10,-9]},{"args":[[4,2,1,10,7,7,4,5,10]],"expected":[4,2,1,10,7,5]},{"args":[[4,1,6]],"expected":[4,1,6]},{"arg... |
stable-unique-b3-s04 | stable-unique | wrong-seen-value | 20,292,684 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[-4, 5, 4, 0, -8, -3, -6, -5]], "expected": [-4, 5, 4, 0, -8, -3, -6, -5]}, {"args": [[-3, -9, 2, -3, 1, -8, -3, 3, 9, 4, -1, -4, 3, 5, 3, -4, -2, 1, ... | 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":[[-9,-10,7,8,10,8,-4,10,-1,3]],"expected":[-9,-10,7,8,10,-4,-1,3]},{"args":[[3,-7,-8,-4,2,-1,-10,-9]],"expected":[3,-7,-8,-4,2,-1,-10,-9]},{"args":[[4,2,1,10,7,7,4,5,10]],"expected":[4,2,1,10,7,5]},{"args":[[4,1,6]],"expected":[4,1,6]},{"arg... |
run-length-b0-s04 | run-length | baseline | 20,292,684 | 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": ["bbc"], "expected": [["b", 2], ["c", 1]]}, {"args": ["猫猫猫🙂猫a猫猫🙂 c🙂c猫🙂a猫 c猫c a c baab"], "... | def solve(text):
return [[c,text.count(c)] for c in sorted(set(text))]
| train | false | 102 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["猫a a猫c猫aca猫c 猫ac🙂ccb🙂b"],"expected":[["猫",1],["a",1],[" ",1],["a",1],["猫",1],["c",1],["猫",1],["a",1],["c",1],["a",1],["猫",1],["c",1],[" ",1],["猫",1],["a",1],["c",1... |
run-length-b1-s04 | run-length | inverted-grouping | 20,292,684 | 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🙂baba猫"], "expected": [["a", 1], ["b", 1], ["🙂", 1], ["b", 1], ["a", 1], ["b", 1], ["a",... | 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 | 102 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["猫a a猫c猫aca猫c 猫ac🙂ccb🙂b"],"expected":[["猫",1],["a",1],[" ",1],["a",1],["猫",1],["c",1],["猫",1],["a",1],["c",1],["a",1],["猫",1],["c",1],[" ",1],["猫",1],["a",1],["c",1... |
run-length-b2-s04 | run-length | double-increment | 20,292,684 | 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猫猫ca猫a🙂🙂a"], "expected": [["猫", 1], ["b", 1], ["猫", 2], ["c", 1], ["a", 1], ["猫", 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 | 102 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["猫a a猫c猫aca猫c 猫ac🙂ccb🙂b"],"expected":[["猫",1],["a",1],[" ",1],["a",1],["猫",1],["c",1],["猫",1],["a",1],["c",1],["a",1],["猫",1],["c",1],[" ",1],["猫",1],["a",1],["c",1... |
run-length-b3-s04 | run-length | zero-initial-count | 20,292,684 | 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": ["acb 🙂b 猫🙂🙂 猫猫aca "], "expected": [["a", 1], ["c", 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 | 102 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["猫a a猫c猫aca猫c 猫ac🙂ccb🙂b"],"expected":[["猫",1],["a",1],[" ",1],["a",1],["猫",1],["c",1],["猫",1],["a",1],["c",1],["a",1],["猫",1],["c",1],[" ",1],["猫",1],["a",1],["c",1... |
luhn-b0-s04 | luhn | baseline | 20,292,684 | 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": ["337211510"], "expected": true}, ... | 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":["423"],"expected":false},{"args... |
luhn-b1-s04 | luhn | wrong-parity | 20,292,684 | 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": ["096602"], "expected": true}, {"a... | 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":["423"],"expected":false},{"args... |
luhn-b2-s04 | luhn | wrong-reduction | 20,292,684 | 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": ["8351888934551"], "expected": fal... | 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":["423"],"expected":false},{"args... |
luhn-b3-s04 | luhn | wrong-modulus | 20,292,684 | 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": ["19"], "expected": false}, {"args... | 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":["423"],"expected":false},{"args... |
edit-distance-b0-s04 | edit-distance | baseline | 20,292,684 | 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": ["cacb猫c猫猫猫b", "a猫猫ad"], "expected": 7}, {"args": ["猫ca", "猫bdddba猫d猫a"], "expected": 9}, {"args": ["猫猫", "abc"], "expected": 3}] | def solve(a,b):
return abs(len(a)-len(b))
| train | false | 141 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["a","adbaa"],"expected":4},{"args":["d猫c猫dd","猫d"],"expected":4},{"args":["","babdcbcc猫c"],"expected":10},{"args":["a猫bdcc","d"],"expected":5},{"args":["cc猫猫bcd猫b","c猫"],"expected":7},{"args":["猫猫b猫caac","... |
edit-distance-b1-s04 | edit-distance | row-boundary | 20,292,684 | 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": ["bcaaab猫", ""], "expected": 7}, {"args": ["a", "ca猫ab猫"], "expected": 5}, {"args": ["", "abacbc猫猫aa"], "expected": 10}] | 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 | 141 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["a","adbaa"],"expected":4},{"args":["d猫c猫dd","猫d"],"expected":4},{"args":["","babdcbcc猫c"],"expected":10},{"args":["a猫bdcc","d"],"expected":5},{"args":["cc猫猫bcd猫b","c猫"],"expected":7},{"args":["猫猫b猫caac","... |
edit-distance-b2-s04 | edit-distance | inverted-substitution | 20,292,684 | 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猫ad猫cdd", "cacca"], "expected": 6}, {"args": ["c猫aa猫aba", ""], "expected": 8}, {"args": ["accc猫a猫aaa", "accc猫a猫aaa"], "expected": 0}... | 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 | 141 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["a","adbaa"],"expected":4},{"args":["d猫c猫dd","猫d"],"expected":4},{"args":["","babdcbcc猫c"],"expected":10},{"args":["a猫bdcc","d"],"expected":5},{"args":["cc猫猫bcd猫b","c猫"],"expected":7},{"args":["猫猫b猫caac","... |
edit-distance-b3-s04 | edit-distance | diagonal-index | 20,292,684 | 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": ["dc猫ac猫", "cca猫"], "expected": 3}, {"args": ["猫acc猫c猫猫aba", "aba猫猫c猫cca猫"], "expected": 8}, {"args": ["ca猫猫b猫a", ""], "expected": 7}] | 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 | 141 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["a","adbaa"],"expected":4},{"args":["d猫c猫dd","猫d"],"expected":4},{"args":["","babdcbcc猫c"],"expected":10},{"args":["a猫bdcc","d"],"expected":5},{"args":["cc猫猫bcd猫b","c猫"],"expected":7},{"args":["猫猫b猫caac","... |
meeting-rooms-b0-s04 | meeting-rooms | baseline | 20,292,684 | 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, -7], [-14, -12], [-13, -8]]], "expected": 3}, {"args": [[[15, 20], [18,... | def solve(intervals):
return len(intervals)
| train | false | 113 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[18,26],[7,10],[7,11],[10,16],[5,7],[0,4]]],"expected":2},{"args":[[[2,4],[12,15],[8,15],[12,18],[8,10],[12,14],[10,16],[7,8],[10,17],[18,19],[13,14],[11,15],[6,11],[16,24],[2,8],[10,18],[7,13],[4,8]]... |
meeting-rooms-b1-s04 | meeting-rooms | tie-order | 20,292,684 | 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": [[[26, 28], [28, 30]]], "expected": 1}, {"args": [[[9, 13], [18, 19], [1, 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,key=lambda item:(item[0],-item[1])):
active += d
best = max(best,active)
return best
| train | false | 113 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[18,26],[7,10],[7,11],[10,16],[5,7],[0,4]]],"expected":2},{"args":[[[2,4],[12,15],[8,15],[12,18],[8,10],[12,14],[10,16],[7,8],[10,17],[18,19],[13,14],[11,15],[6,11],[16,24],[2,8],[10,18],[7,13],[4,8]]... |
meeting-rooms-b2-s04 | meeting-rooms | peak-tracking | 20,292,684 | 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": [[[1, 8], [1, 3], [0, 5], [6, 7], [6, 11], [5, 9], [8, 13], [0, 1], [15, 20], [... | 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 | 113 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[18,26],[7,10],[7,11],[10,16],[5,7],[0,4]]],"expected":2},{"args":[[[2,4],[12,15],[8,15],[12,18],[8,10],[12,14],[10,16],[7,8],[10,17],[18,19],[13,14],[11,15],[6,11],[16,24],[2,8],[10,18],[7,13],[4,8]]... |
meeting-rooms-b3-s04 | meeting-rooms | end-event-sign | 20,292,684 | 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, 10], [4, 11], [9, 15], [14, 21], [10, 11], [13, 16]]], "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 = max(best,active)
return best
| train | true | 113 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[18,26],[7,10],[7,11],[10,16],[5,7],[0,4]]],"expected":2},{"args":[[[2,4],[12,15],[8,15],[12,18],[8,10],[12,14],[10,16],[7,8],[10,17],[18,19],[13,14],[11,15],[6,11],[16,24],[2,8],[10,18],[7,13],[4,8]]... |
nearest-percentile-b0-s04 | nearest-percentile | baseline | 20,292,684 | 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": [[-95, -32], 0], "expected": -95}, {"args": [[63, 35, 16, -32, 67, 37, 83, -44, -1, 34, 93, 32, -75, -3... | 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":[[66,82,14,-98],50],"expected":14},{"args":[[-50,-68,43,-48,-57,99,-85,73,20,52,-89,31,-77,30,3,10,-20,8,41,67,20,36],100],"expected":99},{"args":[[69,-43,9,90,-26,-7,-52,-7... |
nearest-percentile-b1-s04 | nearest-percentile | floor-not-ceiling | 20,292,684 | 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": [[-24, -27, -34, -23, -30, -28, -33, -32, -25, -22, -29, -26, -31], 33], "expected": -30}, {"args": [[6... | 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":[[66,82,14,-98],50],"expected":14},{"args":[[-50,-68,43,-48,-57,99,-85,73,20,52,-89,31,-77,30,3,10,-20,8,41,67,20,36],100],"expected":99},{"args":[[69,-43,9,90,-26,-7,-52,-7... |
nearest-percentile-b2-s04 | nearest-percentile | rank-index | 20,292,684 | 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": [[-15, -61, 68, -37, -34, 38, -9, -41, -93, -45, 30, -87, -75, 49, -99, -29], 100], "expected": 68}, {"... | 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":[[66,82,14,-98],50],"expected":14},{"args":[[-50,-68,43,-48,-57,99,-85,73,20,52,-89,31,-77,30,3,10,-20,8,41,67,20,36],100],"expected":99},{"args":[[69,-43,9,90,-26,-7,-52,-7... |
nearest-percentile-b3-s04 | nearest-percentile | descending-order | 20,292,684 | 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": [[-87, 60, 83, 94, 19, 37, -86, 91, 12, 74, 54, 10], 50], "expected": 37}, {"args": [[35, 32, 37, 33, 3... | 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":[[66,82,14,-98],50],"expected":14},{"args":[[-50,-68,43,-48,-57,99,-85,73,20,52,-89,31,-77,30,3,10,-20,8,41,67,20,36],100],"expected":99},{"args":[[69,-43,9,90,-26,-7,-52,-7... |
fifo-inventory-b0-s04 | fifo-inventory | baseline | 20,292,684 | 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":[[[5,804],[3,352],[4,845],[0,772],[6,735],[2,835],[0,568],[3,897],[2,905]],17],"expected":[12131,[[1,735],[2,835],[3,897],[2,905]]]},{... |
fifo-inventory-b1-s04 | fifo-inventory | zero-lot-retention | 20,292,684 | 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":[[[5,804],[3,352],[4,845],[0,772],[6,735],[2,835],[0,568],[3,897],[2,905]],17],"expected":[12131,[[1,735],[2,835],[3,897],[2,905]]]},{... |
fifo-inventory-b2-s04 | fifo-inventory | over-consumption | 20,292,684 | 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":[[[5,804],[3,352],[4,845],[0,772],[6,735],[2,835],[0,568],[3,897],[2,905]],17],"expected":[12131,[[1,735],[2,835],[3,897],[2,905]]]},{... |
fifo-inventory-b3-s04 | fifo-inventory | unit-cost-not-quantity | 20,292,684 | 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":[[[5,804],[3,352],[4,845],[0,772],[6,735],[2,835],[0,568],[3,897],[2,905]],17],"expected":[12131,[[1,735],[2,835],[3,897],[2,905]]]},{... |
csv-row-b0-s04 | csv-row | baseline | 20,292,684 | 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": ["\"\"\"bbba,猫 猫\"\"\"\"\",\"猫a\"\"b\",\",a, ,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":[" "],"expected":[" "]},{"args":["\" , 猫a\",\"bb\"\"\"\"\""],"expected"... |
csv-row-b1-s04 | csv-row | quoted-comma | 20,292,684 | 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": ["\"x17\"\"y\",z"], "expected": ["x17\"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":[" "],"expected":[" "]},{"args":["\" , 猫a\",\"bb\"\"\"\"\""],"expected"... |
csv-row-b2-s04 | csv-row | escaped-quote | 20,292,684 | 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": [",\"\""]}, {"ar... | 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":[" "],"expected":[" "]},{"args":["\" , 猫a\",\"bb\"\"\"\"\""],"expected"... |
csv-row-b3-s04 | csv-row | lost-final-field | 20,292,684 | 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\"\"a猫\"\"\"\" \""], "expected": ["", "... | 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":[" "],"expected":[" "]},{"args":["\" , 猫a\",\"bb\"\"\"\"\""],"expected"... |
shortest-path-b0-s04 | shortest-path | baseline | 20,292,684 | 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", 326], ["... | 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",5]],"2":[["1",0]],"3":[]},"0","3"],"expected":null},{"args":[{"0":[["1",6]],"1":[["4",1],["5",2],["6",1]],"2":[["0",8],["6",2],["7",1]],"3":[["1",1],... |
shortest-path-b1-s04 | shortest-path | farthest-first | 20,292,684 | 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": [["2",... | 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",5]],"2":[["1",0]],"3":[]},"0","3"],"expected":null},{"args":[{"0":[["1",6]],"1":[["4",1],["5",2],["6",1]],"2":[["0",8],["6",2],["7",1]],"3":[["1",1],... |
shortest-path-b2-s04 | shortest-path | lost-path-prefix | 20,292,684 | 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": [], "2... | 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",5]],"2":[["1",0]],"3":[]},"0","3"],"expected":null},{"args":[{"0":[["1",6]],"1":[["4",1],["5",2],["6",1]],"2":[["0",8],["6",2],["7",1]],"3":[["1",1],... |
shortest-path-b3-s04 | shortest-path | missing-relaxation | 20,292,684 | 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", 1]], "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",5]],"2":[["1",0]],"3":[]},"0","3"],"expected":null},{"args":[{"0":[["1",6]],"1":[["4",1],["5",2],["6",1]],"2":[["0",8],["6",2],["7",1]],"3":[["1",1],... |
merge-intervals-b0-s05 | merge-intervals | baseline | 20,300,603 | 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": [[[-13, -8], [-16, -13]]], "expected": [[-16, -8]]}, {"args": [[[-23, -15], [-22,... | def solve(intervals):
return sorted(intervals)
| train | false | 106 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[26,30],[-11,-5],[-13,-13],[7,9],[3,5],[-16,-14],[10,12],[26,31],[29,30],[-15,-14],[10,10]]],"expected":[[-16,-14],[-13,-13],[-11,-5],[3,5],[7,9],[10,12],[26,31]]},{"args":[[[27,30],[16,16],[18,23]]],"expected":[[16,16],[18,23],[27... |
merge-intervals-b1-s05 | merge-intervals | touching-boundary | 20,300,603 | 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, -3], [-14, -10], [-8, -2]]], "expected": [[-14, -10], [-8, -2]]}, {"args":... | 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 | true | 106 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[26,30],[-11,-5],[-13,-13],[7,9],[3,5],[-16,-14],[10,12],[26,31],[29,30],[-15,-14],[10,10]]],"expected":[[-16,-14],[-13,-13],[-11,-5],[3,5],[7,9],[10,12],[26,31]]},{"args":[[[27,30],[16,16],[18,23]]],"expected":[[16,16],[18,23],[27... |
merge-intervals-b2-s05 | merge-intervals | nested-endpoint | 20,300,603 | 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": [[[-3, 2], [-6, -3]]], "expected": [[-6, 2]]}, {"args": [[[-10, -4], [22, 23], [2... | 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 | 106 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[26,30],[-11,-5],[-13,-13],[7,9],[3,5],[-16,-14],[10,12],[26,31],[29,30],[-15,-14],[10,10]]],"expected":[[-16,-14],[-13,-13],[-11,-5],[3,5],[7,9],[10,12],[26,31]]},{"args":[[[27,30],[16,16],[18,23]]],"expected":[[16,16],[18,23],[27... |
merge-intervals-b3-s05 | merge-intervals | unsorted-input | 20,300,603 | 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": [[[11, 12], [16, 17], [22, 25], [-3, 3], [-11, -9], [-5, -4], [-2, 3], [18, 18], ... | 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 | 106 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[26,30],[-11,-5],[-13,-13],[7,9],[3,5],[-16,-14],[10,12],[26,31],[29,30],[-15,-14],[10,10]]],"expected":[[-16,-14],[-13,-13],[-11,-5],[3,5],[7,9],[10,12],[26,31]]},{"args":[[[27,30],[16,16],[18,23]]],"expected":[[16,16],[18,23],[27... |
moving-sums-b0-s05 | moving-sums | baseline | 20,300,603 | 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": [[17, -97, 99, 59, -9, -61, 49], 12], "expected": []}, {"args": [[-6], 13], "expected": []}, {"args": [[-4, -13, -7, -3, -10, 28], 2], "expected": [-17, -2... | 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":[[-61],12],"expected":[]},{"args":[[13,68,46,-42,-17,21],12],"expected":[]},{"args":[[86,-13,-42,49,-70,61,-85],1],"expected":[86,-13,-42,49,-70,61,-85]},{"args":[[-85,-91,-5,-10,-... |
moving-sums-b1-s05 | moving-sums | zero-window | 20,300,603 | 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": [[-13, -20, -25, -23, 4, -13, -29, 15, 9, -15, -17], 1], "expected": [-13, -20, -25, -23, 4, -13, -29, 15, 9, -15, -17]}, {"args": [[-23, -45, -73, -92, 60... | 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":[[-61],12],"expected":[]},{"args":[[13,68,46,-42,-17,21],12],"expected":[]},{"args":[[86,-13,-42,49,-70,61,-85],1],"expected":[86,-13,-42,49,-70,61,-85]},{"args":[[-85,-91,-5,-10,-... |
moving-sums-b2-s05 | moving-sums | window-width | 20,300,603 | 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": [[-37, 27, -65, -78, 48], 18], "expected": []}, {"args": [[44, 57, -46, -7, 72, -64, 36, 12, 73, 21, -46], 6], "expected": [56, 48, 3, 122, 150, 32]}, {"ar... | 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":[[-61],12],"expected":[]},{"args":[[13,68,46,-42,-17,21],12],"expected":[]},{"args":[[86,-13,-42,49,-70,61,-85],1],"expected":[86,-13,-42,49,-70,61,-85]},{"args":[[-85,-91,-5,-10,-... |
moving-sums-b3-s05 | moving-sums | missing-first-window | 20,300,603 | 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": [[-6, 28, -36, -8, -6, 52, 60, 17, -68, -25, 10, 25, -76], 14], "expected": []}, {"args": [[-20, -2, 42, -56, 59, -64, -70, -54, 14], 21], "expected": []},... | 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":[[-61],12],"expected":[]},{"args":[[13,68,46,-42,-17,21],12],"expected":[]},{"args":[[86,-13,-42,49,-70,61,-85],1],"expected":[86,-13,-42,49,-70,61,-85]},{"args":[[-85,-91,-5,-10,-... |
weighted-mean-b0-s05 | weighted-mean | baseline | 20,300,603 | 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": [[26, -16, 16, 3], [1, 4, 2, 5]], "expected": 0.75}, {"args": [[24, 31], [0, 0]], "expecte... | def solve(values,weights):
return sum(values)/len(values) if values else None
| train | false | 123 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[48,-45,50,23,-7,18,49,-31,40,-25,1,32,29],[1,5,4,2,1,0,5,1,5,3,2,3,5]],"expected":17.405405405405407},{"args":[[-2,38,-50,25,-46,-45,48,-8,33,14,47,-18,29,48,-36,9,6,-16],[4,4,3,0,3,5,0,5,5,5,0,5,1,2,3... |
weighted-mean-b1-s05 | weighted-mean | unweighted-numerator | 20,300,603 | 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": [[27, 34], [1, 5]], "expected": 32.833333333333336}, {"args": [[-2, 13, -17, -9, -4], [1, ... | def solve(values,weights):
total = sum(weights)
return sum(x for x,w in zip(values,weights))/total if total else None
| train | false | 123 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[48,-45,50,23,-7,18,49,-31,40,-25,1,32,29],[1,5,4,2,1,0,5,1,5,3,2,3,5]],"expected":17.405405405405407},{"args":[[-2,38,-50,25,-46,-45,48,-8,33,14,47,-18,29,48,-36,9,6,-16],[4,4,3,0,3,5,0,5,5,5,0,5,1,2,3... |
weighted-mean-b2-s05 | weighted-mean | wrong-denominator | 20,300,603 | 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": [[-30, -23], [1, 5]], "expected": -24.166666666666668}, {"args": [[45, -13, -11, -20, -5, ... | 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 | 123 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[48,-45,50,23,-7,18,49,-31,40,-25,1,32,29],[1,5,4,2,1,0,5,1,5,3,2,3,5]],"expected":17.405405405405407},{"args":[[-2,38,-50,25,-46,-45,48,-8,33,14,47,-18,29,48,-36,9,6,-16],[4,4,3,0,3,5,0,5,5,5,0,5,1,2,3... |
weighted-mean-b3-s05 | weighted-mean | zero-weight-result | 20,300,603 | 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": [[-42, -7], [3, 2]], "expected": -28.0}, {"args": [[41, 7, -15, 47, -45, 46, -3, 37, -41, ... | 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 | 123 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[48,-45,50,23,-7,18,49,-31,40,-25,1,32,29],[1,5,4,2,1,0,5,1,5,3,2,3,5]],"expected":17.405405405405407},{"args":[[-2,38,-50,25,-46,-45,48,-8,33,14,47,-18,29,48,-36,9,6,-16],[4,4,3,0,3,5,0,5,5,5,0,5,1,2,3... |
stable-unique-b0-s05 | stable-unique | baseline | 20,300,603 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[-27, -29, -27, -28, -29]], "expected": [-27, -29, -28]}, {"args": [[-26, -28, -26, -27, -28]], "expected": [-26, -28, -27]}, {"args": [[4, -2, 6, 9, ... | def solve(values):
return sorted(set(values))
| train | false | 99 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[-6,-9,1]],"expected":[-6,-9,1]},{"args":[[0,-2,-8,1]],"expected":[0,-2,-8,1]},{"args":[[10,0,-7,1,-9,8,-10,-8,-10,-10,10,8,-5,5,1]],"expected":[10,0,-7,1,-9,8,-10,-8,-5,5]},{"args":[[0,-2,-4,2,-2,-9,9,6,0,-3]],"expected":[0,-2,-4,2,-9,9,6,... |
stable-unique-b1-s05 | stable-unique | reverse-traversal | 20,300,603 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[-1, 1, 1, -10, 10, 7, 5, 5, 10, 3, -2, 2, -6]], "expected": [-1, 1, -10, 10, 7, 5, 3, -2, 2, -6]}, {"args": [[-10, 5, -4, 2, -9, -6, -5, 3, -4, -4, 2... | 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 | 99 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[-6,-9,1]],"expected":[-6,-9,1]},{"args":[[0,-2,-8,1]],"expected":[0,-2,-8,1]},{"args":[[10,0,-7,1,-9,8,-10,-8,-10,-10,10,8,-5,5,1]],"expected":[10,0,-7,1,-9,8,-10,-8,-5,5]},{"args":[[0,-2,-4,2,-2,-9,9,6,0,-3]],"expected":[0,-2,-4,2,-9,9,6,... |
stable-unique-b2-s05 | stable-unique | reverse-output | 20,300,603 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[-25, -27, -25, -26, -27]], "expected": [-25, -27, -26]}, {"args": [[8, -3, 3, -7, 7, 6, -2, -5, -9, 8, -3, -3, 0]], "expected": [8, -3, 3, -7, 7, 6, ... | 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 | 99 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[-6,-9,1]],"expected":[-6,-9,1]},{"args":[[0,-2,-8,1]],"expected":[0,-2,-8,1]},{"args":[[10,0,-7,1,-9,8,-10,-8,-10,-10,10,8,-5,5,1]],"expected":[10,0,-7,1,-9,8,-10,-8,-5,5]},{"args":[[0,-2,-4,2,-2,-9,9,6,0,-3]],"expected":[0,-2,-4,2,-9,9,6,... |
stable-unique-b3-s05 | stable-unique | wrong-seen-value | 20,300,603 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[9, 5, 1, -2]], "expected": [9, 5, 1, -2]}, {"args": [[7, -7, -3, -3, 4, -3, 3, 6, 6, -9, -5, 3, -4, 5, 3, 0, 4]], "expected": [7, -7, -3, 4, 3, 6, -9... | 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 | 99 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[-6,-9,1]],"expected":[-6,-9,1]},{"args":[[0,-2,-8,1]],"expected":[0,-2,-8,1]},{"args":[[10,0,-7,1,-9,8,-10,-8,-10,-10,10,8,-5,5,1]],"expected":[10,0,-7,1,-9,8,-10,-8,-5,5]},{"args":[[0,-2,-4,2,-2,-9,9,6,0,-3]],"expected":[0,-2,-4,2,-9,9,6,... |
run-length-b0-s05 | run-length | baseline | 20,300,603 | 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": ["猫猫猫猫猫猫ddddd"], "expected": [["猫", 6], ["d", 5]]}, {"args": ["bbbbbbbbbbbbbbbbb狗狗狗狗狗狗狗狗狗狗狗狗狗狗... | def solve(text):
return [[c,text.count(c)] for c in sorted(set(text))]
| train | false | 98 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["🙂🙂 "],"expected":[["🙂",2],[" ",1]]},{"args":["bb🙂 abcca🙂cc🙂c c aa b🙂a🙂猫🙂ab🙂 猫c"],"expected":[["b",2],["🙂",1],[" ",1],["a",1],["b",1],["c",2],["a",1],["🙂"... |
run-length-b1-s05 | run-length | inverted-grouping | 20,300,603 | 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 bbcc🙂c"], "expected": [["🙂", 1], ["b", 1], [" ", 1], ["b", 2], ["c", 2], ["🙂", 1], ["... | 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 | 98 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["🙂🙂 "],"expected":[["🙂",2],[" ",1]]},{"args":["bb🙂 abcca🙂cc🙂c c aa b🙂a🙂猫🙂ab🙂 猫c"],"expected":[["b",2],["🙂",1],[" ",1],["a",1],["b",1],["c",2],["a",1],["🙂"... |
run-length-b2-s05 | run-length | double-increment | 20,300,603 | 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": ["猫猫猫猫猫猫猫猫猫猫ccccccccc"], "expected": [["猫", 10], ["c", 9]]}, {"args": ["b🙂cbcabaa猫cc猫a b🙂b�... | 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 | 98 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["🙂🙂 "],"expected":[["🙂",2],[" ",1]]},{"args":["bb🙂 abcca🙂cc🙂c c aa b🙂a🙂猫🙂ab🙂 猫c"],"expected":[["b",2],["🙂",1],[" ",1],["a",1],["b",1],["c",2],["a",1],["🙂"... |
run-length-b3-s05 | run-length | zero-initial-count | 20,300,603 | 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": ["🙂caacc c🙂 c 猫cc acba 🙂"], "expected": [["🙂", 1], ["c", 1], ["a", 2], ["c", 2], [" ", 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 | 98 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["🙂🙂 "],"expected":[["🙂",2],[" ",1]]},{"args":["bb🙂 abcca🙂cc🙂c c aa b🙂a🙂猫🙂ab🙂 猫c"],"expected":[["b",2],["🙂",1],[" ",1],["a",1],["b",1],["c",2],["a",1],["🙂"... |
luhn-b0-s05 | luhn | baseline | 20,300,603 | 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": ["439292823"], "expected": false},... | def solve(text):
return bool(text) and text.isdigit() and sum(int(c) for c in text)%10 == 0
| train | false | 188 | [{"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":["984378"],"expected":false},{"a... |
luhn-b1-s05 | luhn | wrong-parity | 20,300,603 | 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": ["951663558"], "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 | 188 | [{"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":["984378"],"expected":false},{"a... |
luhn-b2-s05 | luhn | wrong-reduction | 20,300,603 | 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": ["792494164"], "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 | 188 | [{"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":["984378"],"expected":false},{"a... |
luhn-b3-s05 | luhn | wrong-modulus | 20,300,603 | 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": ["791190994"], "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 | 188 | [{"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":["984378"],"expected":false},{"a... |
edit-distance-b0-s05 | edit-distance | baseline | 20,300,603 | 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": ["猫cd猫a", "d"], "expected": 4}, {"args": ["b", "baddbaddac"], "expected": 9}, {"args": ["ac猫猫aba", ""], "expected": 7}] | 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":["aacdbb","猫b"],"expected":5},{"args":["bdcbacccdda","abdc猫ab猫猫ab"],"expected":8},{"args":["","cdcba"],"expected":5},{"args":["cbb猫dcc猫c","猫c猫cd猫猫d"],"expected":7},{"args":["d","猫dbab猫bda"],"expected":8},{"... |
edit-distance-b1-s05 | edit-distance | row-boundary | 20,300,603 | 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": ["猫cbbbc", "cbbbc猫"], "expected": 2}, {"args": ["a猫b猫bcaab", "adb猫"], "expected": 6}, {"args": ["bcba猫cc猫b猫ba", "ab猫b猫cc猫abcb"], "expec... | 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":["aacdbb","猫b"],"expected":5},{"args":["bdcbacccdda","abdc猫ab猫猫ab"],"expected":8},{"args":["","cdcba"],"expected":5},{"args":["cbb猫dcc猫c","猫c猫cd猫猫d"],"expected":7},{"args":["d","猫dbab猫bda"],"expected":8},{"... |
edit-distance-b2-s05 | edit-distance | inverted-substitution | 20,300,603 | 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猫dcd", "c"], "expected": 4}, {"args": ["b猫", "bdc猫"], "expected": 2}, {"args": ["猫猫ccab猫bbbab", "猫猫ccab猫bbbab"], "expected": 0}] | 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":["aacdbb","猫b"],"expected":5},{"args":["bdcbacccdda","abdc猫ab猫猫ab"],"expected":8},{"args":["","cdcba"],"expected":5},{"args":["cbb猫dcc猫c","猫c猫cd猫猫d"],"expected":7},{"args":["d","猫dbab猫bda"],"expected":8},{"... |
edit-distance-b3-s05 | edit-distance | diagonal-index | 20,300,603 | 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": ["acddbabdd猫c", "ad猫bac"], "expected": 6}, {"args": ["d猫dc", "猫bbacb猫ba"], "expected": 8}, {"args": ["cbaca猫", "猫acabc"], "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 | 142 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["aacdbb","猫b"],"expected":5},{"args":["bdcbacccdda","abdc猫ab猫猫ab"],"expected":8},{"args":["","cdcba"],"expected":5},{"args":["cbb猫dcc猫c","猫c猫cd猫猫d"],"expected":7},{"args":["d","猫dbab猫bda"],"expected":8},{"... |
meeting-rooms-b0-s05 | meeting-rooms | baseline | 20,300,603 | 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, 8], [1, 3], [2, 7]]], "expected": 3}, {"args": [[[-5, -3], [-3, -1]]], "e... | def solve(intervals):
return len(intervals)
| train | false | 113 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[11,15],[17,20]]],"expected":1},{"args":[[[13,15],[2,9],[19,24],[7,14],[12,20]]],"expected":3},{"args":[[[5,7],[10,12],[10,15],[2,8],[4,8],[12,18],[17,19],[7,13],[6,14],[12,15]]],"expected":5},{"args"... |
meeting-rooms-b1-s05 | meeting-rooms | tie-order | 20,300,603 | 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": [[[-2, 6], [-1, 1], [0, 5]]], "expected": 3}, {"args": [[[12, 20], [1, 8], [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 | 113 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[11,15],[17,20]]],"expected":1},{"args":[[[13,15],[2,9],[19,24],[7,14],[12,20]]],"expected":3},{"args":[[[5,7],[10,12],[10,15],[2,8],[4,8],[12,18],[17,19],[7,13],[6,14],[12,15]]],"expected":5},{"args"... |
meeting-rooms-b2-s05 | meeting-rooms | peak-tracking | 20,300,603 | 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": [[[22, 30], [23, 25], [24, 29]]], "expected": 3}, {"args": [[[12, 13]]], "expec... | 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 | 113 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[11,15],[17,20]]],"expected":1},{"args":[[[13,15],[2,9],[19,24],[7,14],[12,20]]],"expected":3},{"args":[[[5,7],[10,12],[10,15],[2,8],[4,8],[12,18],[17,19],[7,13],[6,14],[12,15]]],"expected":5},{"args"... |
meeting-rooms-b3-s05 | meeting-rooms | end-event-sign | 20,300,603 | 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": [[[17, 18], [17, 23], [1, 4], [0, 2], [16, 23], [18, 23], [1, 6], [11, 17]]], "... | 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 | 113 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[11,15],[17,20]]],"expected":1},{"args":[[[13,15],[2,9],[19,24],[7,14],[12,20]]],"expected":3},{"args":[[[5,7],[10,12],[10,15],[2,8],[4,8],[12,18],[17,19],[7,13],[6,14],[12,15]]],"expected":5},{"args"... |
nearest-percentile-b0-s05 | nearest-percentile | baseline | 20,300,603 | 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": [[73, 26, 65, -98, 83, 45, 37, -83, 72, -3, -49, -60, -86, 21, 37, -86], 0], "expected": -98}, {"args":... | 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":[[19,-42,-67,42,-86,-40,-100,-37,-92,-81],50],"expected":-67},{"args":[[-69,-37,86,-44,19,-51,-85,-97,90,-3,74,88,-42,44,-60,25,-56,59,-92,-34,36,-50,-60,-60,-19,59,-80,12],... |
nearest-percentile-b1-s05 | nearest-percentile | floor-not-ceiling | 20,300,603 | 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": [[11, 14, 0, 2, 10, 4, 9, 6, 13, 12, 21, 19, 22, 5, 16, 17, 15, 18, 23, 3, 1, 8, 7, 24, 20], 50], "expe... | 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":[[19,-42,-67,42,-86,-40,-100,-37,-92,-81],50],"expected":-67},{"args":[[-69,-37,86,-44,19,-51,-85,-97,90,-3,74,88,-42,44,-60,25,-56,59,-92,-34,36,-50,-60,-60,-19,59,-80,12],... |
nearest-percentile-b2-s05 | nearest-percentile | rank-index | 20,300,603 | 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": [[-41, -14, 85, -20, 29, 5], 100], "expected": 85}, {"args": [[-27, 28, -64, -41, -53, 98, -92, -6, -82... | 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":[[19,-42,-67,42,-86,-40,-100,-37,-92,-81],50],"expected":-67},{"args":[[-69,-37,86,-44,19,-51,-85,-97,90,-3,74,88,-42,44,-60,25,-56,59,-92,-34,36,-50,-60,-60,-19,59,-80,12],... |
nearest-percentile-b3-s05 | nearest-percentile | descending-order | 20,300,603 | 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": [[71, 48, -45, 1, -4, -95, 4, -2, -91, -2, -56, 33, -93, 37, -26, 35, -29, -26, -53, 17, 82, -26, 2, -7... | 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":[[19,-42,-67,42,-86,-40,-100,-37,-92,-81],50],"expected":-67},{"args":[[-69,-37,86,-44,19,-51,-85,-97,90,-3,74,88,-42,44,-60,25,-56,59,-92,-34,36,-50,-60,-60,-19,59,-80,12],... |
fifo-inventory-b0-s05 | fifo-inventory | baseline | 20,300,603 | 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 | 123 | [{"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,446],[3,56]],3],"expected":[948,[[2,56]]]},{"args":[[[6,599],[0,614],[3,834],[6,773],[1,382],[5,479],[1,780],[7,551],[4,560]],12]... |
fifo-inventory-b1-s05 | fifo-inventory | zero-lot-retention | 20,300,603 | 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 | 123 | [{"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,446],[3,56]],3],"expected":[948,[[2,56]]]},{"args":[[[6,599],[0,614],[3,834],[6,773],[1,382],[5,479],[1,780],[7,551],[4,560]],12]... |
fifo-inventory-b2-s05 | fifo-inventory | over-consumption | 20,300,603 | 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 | 123 | [{"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,446],[3,56]],3],"expected":[948,[[2,56]]]},{"args":[[[6,599],[0,614],[3,834],[6,773],[1,382],[5,479],[1,780],[7,551],[4,560]],12]... |
fifo-inventory-b3-s05 | fifo-inventory | unit-cost-not-quantity | 20,300,603 | 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 | 123 | [{"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,446],[3,56]],3],"expected":[948,[[2,56]]]},{"args":[[[6,599],[0,614],[3,834],[6,773],[1,382],[5,479],[1,780],[7,551],[4,560]],12]... |
csv-row-b0-s05 | csv-row | baseline | 20,300,603 | 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": [" ,\"aa,ba\",\"猫baab,\",\"b猫猫猫 ba ,,\",\" 猫\"\... | def solve(row):
return row.split(',') if row else []
| train | false | 146 | [{"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":["\",a,a\"\"\",\",\"\"b\",\"b,,b猫,, ,,\",\"\"\",a猫,b猫,aaa\",\" \"\"\"\"... |
csv-row-b1-s05 | csv-row | quoted-comma | 20,300,603 | 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"]},... | 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 | 146 | [{"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":["\",a,a\"\"\",\",\"\"b\",\"b,,b猫,, ,,\",\"\"\",a猫,b猫,aaa\",\" \"\"\"\"... |
csv-row-b2-s05 | csv-row | escaped-quote | 20,300,603 | 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\"\",aa,,,,\"\"\",\"猫 猫aa猫, 猫a\",猫 ab... | 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 | 146 | [{"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":["\",a,a\"\"\",\",\"\"b\",\"b,,b猫,, ,,\",\"\"\",a猫,b猫,aaa\",\" \"\"\"\"... |
csv-row-b3-s05 | csv-row | lost-final-field | 20,300,603 | 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": ["\" ab猫\"\"aa,\",,"], "expected": [" ab猫\"aa,"... | 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 | 146 | [{"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":["\",a,a\"\"\",\",\"\"b\",\"b,,b猫,, ,,\",\"\"\",a猫,b猫,aaa\",\" \"\"\"\"... |
shortest-path-b0-s05 | shortest-path | baseline | 20,300,603 | 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", 514], ["... | def solve(graph,start,target):
return 0 if start == target else None
| train | false | 92 | [{"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":[["2",7],["3",8],["4",6],["5",0]],"1":[["5",4],["6",7]],"2":[["0",7],["1",3],["5",3]],"3":[],"4":[["2",1]],"5":[["0",8],["1",7]],"6":[["0",1],["2",7],["3",5],["5"... |
shortest-path-b1-s05 | shortest-path | farthest-first | 20,300,603 | 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", 1], ["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 = max(candidates,key=lambda x:dist[x])
if n == target: return dist[n]
visited.add(n)
for nxt,w in gr... | train | false | 92 | [{"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":[["2",7],["3",8],["4",6],["5",0]],"1":[["5",4],["6",7]],"2":[["0",7],["1",3],["5",3]],"3":[],"4":[["2",1]],"5":[["0",8],["1",7]],"6":[["0",1],["2",7],["3",5],["5"... |
shortest-path-b2-s05 | shortest-path | lost-path-prefix | 20,300,603 | 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", 462], ["... | 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 | 92 | [{"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":[["2",7],["3",8],["4",6],["5",0]],"1":[["5",4],["6",7]],"2":[["0",7],["1",3],["5",3]],"3":[],"4":[["2",1]],"5":[["0",8],["1",7]],"6":[["0",1],["2",7],["3",5],["5"... |
shortest-path-b3-s05 | shortest-path | missing-relaxation | 20,300,603 | 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", 3]], "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 | 92 | [{"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":[["2",7],["3",8],["4",6],["5",0]],"1":[["5",4],["6",7]],"2":[["0",7],["1",3],["5",3]],"3":[],"4":[["2",1]],"5":[["0",8],["1",7]],"6":[["0",1],["2",7],["3",5],["5"... |
merge-intervals-b0-s06 | merge-intervals | baseline | 20,308,522 | 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": [[[15, 20], [12, 15]]], "expected": [[12, 20]]}, {"args": [[[5, 9], [10, 17], [14... | def solve(intervals):
return sorted(intervals)
| train | false | 106 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[4,9],[-20,-13],[-18,-13],[11,18],[22,26],[8,10],[-13,-10],[26,31],[15,19],[28,32],[9,12],[9,16],[-9,-7],[5,8]]],"expected":[[-20,-10],[-9,-7],[4,19],[22,32]]},{"args":[[[-17,-14],[2,3],[10,16],[-18,-17],[-13,-13],[13,17],[-9,-5],[... |
merge-intervals-b1-s06 | merge-intervals | touching-boundary | 20,308,522 | 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": [[[37, 45], [38, 39]]], "expected": [[37, 45]]}, {"args": [[[8, 11], [-18, -12], ... | 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 | 106 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[4,9],[-20,-13],[-18,-13],[11,18],[22,26],[8,10],[-13,-10],[26,31],[15,19],[28,32],[9,12],[9,16],[-9,-7],[5,8]]],"expected":[[-20,-10],[-9,-7],[4,19],[22,32]]},{"args":[[[-17,-14],[2,3],[10,16],[-18,-17],[-13,-13],[13,17],[-9,-5],[... |
merge-intervals-b2-s06 | merge-intervals | nested-endpoint | 20,308,522 | 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, -3], [-10, -10], [12, 16], [10, 15], [11, 11], [-11, -7], [27, 30]]], "ex... | 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 | 106 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[4,9],[-20,-13],[-18,-13],[11,18],[22,26],[8,10],[-13,-10],[26,31],[15,19],[28,32],[9,12],[9,16],[-9,-7],[5,8]]],"expected":[[-20,-10],[-9,-7],[4,19],[22,32]]},{"args":[[[-17,-14],[2,3],[10,16],[-18,-17],[-13,-13],[13,17],[-9,-5],[... |
merge-intervals-b3-s06 | merge-intervals | unsorted-input | 20,308,522 | 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": [[[-9, -5], [22, 25], [13, 18], [-9, -3], [12, 12], [-2, 2], [12, 15], [-9, -9]]]... | 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 | 106 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[4,9],[-20,-13],[-18,-13],[11,18],[22,26],[8,10],[-13,-10],[26,31],[15,19],[28,32],[9,12],[9,16],[-9,-7],[5,8]]],"expected":[[-20,-10],[-9,-7],[4,19],[22,32]]},{"args":[[[-17,-14],[2,3],[10,16],[-18,-17],[-13,-13],[13,17],[-9,-5],[... |
moving-sums-b0-s06 | moving-sums | baseline | 20,308,522 | 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": [[-29, 7, 5, -17, -24, -28, -25, -26, -19, -7, -15, -10], 0], "expected": []}, {"args": [[5], 1], "expected": [5]}, {"args": [[-36, -55, -45, 9], 9], "expe... | 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":[[76,-65,100,-28,-9,86,-38,94,-73,25,-83,-89,63,61],16],"expected":[]},{"args":[[],18],"expected":[]},{"args":[[76,-87,-83,76,28,-51,-60,-13,-4,-61,61,85,-83,6,90,-98],19],"expecte... |
moving-sums-b1-s06 | moving-sums | zero-window | 20,308,522 | 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": [[-18, 22, -16, -13, -3, -5, 30, -8, -25, 29, 4], 2], "expected": [4, 6, -29, -16, -8, 25, 22, -33, 4, 33]}, {"args": [[-25, -16, 13, -20, 14, -26, 13], 0]... | 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":[[76,-65,100,-28,-9,86,-38,94,-73,25,-83,-89,63,61],16],"expected":[]},{"args":[[],18],"expected":[]},{"args":[[76,-87,-83,76,28,-51,-60,-13,-4,-61,61,85,-83,6,90,-98],19],"expecte... |
moving-sums-b2-s06 | moving-sums | window-width | 20,308,522 | 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, -22, 7, 3], 2], "expected": [-8, -15, 10]}, {"args": [[-79, -76, 85, 24, -13, -50, 85, 46, 22, -39, -28, 35, -78, -26, -88, -70, 42], 0], "expected":... | 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":[[76,-65,100,-28,-9,86,-38,94,-73,25,-83,-89,63,61],16],"expected":[]},{"args":[[],18],"expected":[]},{"args":[[76,-87,-83,76,28,-51,-60,-13,-4,-61,61,85,-83,6,90,-98],19],"expecte... |
moving-sums-b3-s06 | moving-sums | missing-first-window | 20,308,522 | 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": [[13, 35, -49, -55], 20], "expected": []}, {"args": [[18, -6, 21, 3, 27, -29], 0], "expected": []}, {"args": [[38, -19, 22, -74, -84, -77, -67, 64, 1, -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 | 143 | [{"args":[[],1],"expected":[]},{"args":[[1,2,3],2],"expected":[3,5]},{"args":[[5],1],"expected":[5]},{"args":[[1],0],"expected":[]},{"args":[[76,-65,100,-28,-9,86,-38,94,-73,25,-83,-89,63,61],16],"expected":[]},{"args":[[],18],"expected":[]},{"args":[[76,-87,-83,76,28,-51,-60,-13,-4,-61,61,85,-83,6,90,-98],19],"expecte... |
weighted-mean-b0-s06 | weighted-mean | baseline | 20,308,522 | 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": [[7, 14], [1, 5]], "expected": 12.833333333333334}, {"args": [[-1, -24, 25, -17, -18, 29, ... | 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":[[-38,-45,-24,20,-38,45],[3,5,2,2,0,0]],"expected":-28.916666666666668},{"args":[[-19,5,33],[5,4,0]],"expected":-8.333333333333334},{"args":[[11,-11,-22,22,28,-36,14],[0,0,0,5,2,0,1]],"expected":22.5},{"... |
weighted-mean-b1-s06 | weighted-mean | unweighted-numerator | 20,308,522 | 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": [[-11, -4], [0, 0]], "expected": null}, {"args": [[10, 27, -45, 15, -40, -39, 43, -17, 50,... | 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":[[-38,-45,-24,20,-38,45],[3,5,2,2,0,0]],"expected":-28.916666666666668},{"args":[[-19,5,33],[5,4,0]],"expected":-8.333333333333334},{"args":[[11,-11,-22,22,28,-36,14],[0,0,0,5,2,0,1]],"expected":22.5},{"... |
weighted-mean-b2-s06 | weighted-mean | wrong-denominator | 20,308,522 | 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": [[3, -31, -24, -13, 24, -32, 17, 16, -44, -19], [4, 0, 1, 1, 2, 4, 3, 0, 3, 0]], "expected... | 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":[[-38,-45,-24,20,-38,45],[3,5,2,2,0,0]],"expected":-28.916666666666668},{"args":[[-19,5,33],[5,4,0]],"expected":-8.333333333333334},{"args":[[11,-11,-22,22,28,-36,14],[0,0,0,5,2,0,1]],"expected":22.5},{"... |
weighted-mean-b3-s06 | weighted-mean | zero-weight-result | 20,308,522 | 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": [[-20, -5, 34, -43, 35, -26, 45, 45, 45, -3, 48, 5], [0, 5, 4, 0, 2, 2, 4, 1, 1, 0, 0, 1]]... | 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":[[-38,-45,-24,20,-38,45],[3,5,2,2,0,0]],"expected":-28.916666666666668},{"args":[[-19,5,33],[5,4,0]],"expected":-8.333333333333334},{"args":[[11,-11,-22,22,28,-36,14],[0,0,0,5,2,0,1]],"expected":22.5},{"... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.