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 |
|---|---|---|---|---|---|---|---|---|---|
edit-distance-b0-s12 | edit-distance | baseline | 20,356,036 | 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": ["猫aca猫bcba", "猫aca猫bcba"], "expected": 0}, {"args": ["猫caabbb猫b猫猫", "猫caabbb猫b猫猫"], "expected": 0}, {"args": ["b", "猫a猫cb"], "expected... | def solve(a,b):
return abs(len(a)-len(b))
| train | true | 140 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["dcdbdaba","cccdd猫"],"expected":6},{"args":["cb猫猫cab","猫a"],"expected":5},{"args":["cad猫猫a","cb猫"],"expected":4},{"args":["bcdacaadc","cbabbdb"],"expected":6},{"args":["bda","d猫"],"expected":2},{"args":["b... |
edit-distance-b1-s12 | edit-distance | row-boundary | 20,356,036 | 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": ["kitten", "sitting"], "expected": 3}, {"args": ["d猫d猫猫cacda猫", "b猫aaaa猫"], "expected": 7}, {"args": ["cadcb猫babdb", ""], "expected": 1... | 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 | 140 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["dcdbdaba","cccdd猫"],"expected":6},{"args":["cb猫猫cab","猫a"],"expected":5},{"args":["cad猫猫a","cb猫"],"expected":4},{"args":["bcdacaadc","cbabbdb"],"expected":6},{"args":["bda","d猫"],"expected":2},{"args":["b... |
edit-distance-b2-s12 | edit-distance | inverted-substitution | 20,356,036 | 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": ["猫b猫c猫", ""], "expected": 5}, {"args": ["dc猫cdcaaa猫b", "dddca猫"], "expected": 6}, {"args": ["猫", "cac"], "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-1]+(x == y)))
row = nxt
return row[-1]
| train | false | 140 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["dcdbdaba","cccdd猫"],"expected":6},{"args":["cb猫猫cab","猫a"],"expected":5},{"args":["cad猫猫a","cb猫"],"expected":4},{"args":["bcdacaadc","cbabbdb"],"expected":6},{"args":["bda","d猫"],"expected":2},{"args":["b... |
edit-distance-b3-s12 | edit-distance | diagonal-index | 20,356,036 | 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": ["猫caabbb猫b猫猫", ""], "expected": 11}, {"args": ["猫cd猫dd猫猫", "b猫d猫d猫c"], "expected": 4}, {"args": ["猫cccbbc猫猫cb猫", ""], "expected": 12}] | 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 | 140 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["dcdbdaba","cccdd猫"],"expected":6},{"args":["cb猫猫cab","猫a"],"expected":5},{"args":["cad猫猫a","cb猫"],"expected":4},{"args":["bcdacaadc","cbabbdb"],"expected":6},{"args":["bda","d猫"],"expected":2},{"args":["b... |
meeting-rooms-b0-s12 | meeting-rooms | baseline | 20,356,036 | 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, 6], [12, 20], [1, 4], [2, 6], [1, 5], [4, 8], [5, 9], [15, 19], [10, 18],... | def solve(intervals):
return len(intervals)
| train | false | 109 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[3,11],[8,11],[3,11],[6,11],[17,18],[4,8],[14,15],[13,16],[19,21],[9,16],[18,21]]],"expected":5},{"args":[[[18,19],[4,11],[4,10]]],"expected":2},{"args":[[[10,12],[4,6],[17,22],[14,17],[11,14],[6,12],... |
meeting-rooms-b1-s12 | meeting-rooms | tie-order | 20,356,036 | 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": [[[-11, -3], [-10, -8], [-9, -4]]], "expected": 3}, {"args": [[]], "expected": ... | 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 | 109 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[3,11],[8,11],[3,11],[6,11],[17,18],[4,8],[14,15],[13,16],[19,21],[9,16],[18,21]]],"expected":5},{"args":[[[18,19],[4,11],[4,10]]],"expected":2},{"args":[[[10,12],[4,6],[17,22],[14,17],[11,14],[6,12],... |
meeting-rooms-b2-s12 | meeting-rooms | peak-tracking | 20,356,036 | 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, 4], [7, 13], [13, 20], [7, 15], [3, 11], [17, 22], [10, 13], [10, 15], [8... | 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 | 109 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[3,11],[8,11],[3,11],[6,11],[17,18],[4,8],[14,15],[13,16],[19,21],[9,16],[18,21]]],"expected":5},{"args":[[[18,19],[4,11],[4,10]]],"expected":2},{"args":[[[10,12],[4,6],[17,22],[14,17],[11,14],[6,12],... |
meeting-rooms-b3-s12 | meeting-rooms | end-event-sign | 20,356,036 | 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": [[[6, 9], [11, 15], [14, 20], [13, 16], [7, 15], [9, 17], [0, 2], [5, 10], [9, ... | 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 | 109 | [{"args":[[]],"expected":0},{"args":[[[0,1],[1,2]]],"expected":1},{"args":[[[0,5],[1,3],[2,4]]],"expected":3},{"args":[[[3,11],[8,11],[3,11],[6,11],[17,18],[4,8],[14,15],[13,16],[19,21],[9,16],[18,21]]],"expected":5},{"args":[[[18,19],[4,11],[4,10]]],"expected":2},{"args":[[[10,12],[4,6],[17,22],[14,17],[11,14],[6,12],... |
nearest-percentile-b0-s12 | nearest-percentile | baseline | 20,356,036 | 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": [[-35, -25, -26, -19, -27, -34, -22, -20, -30, -36, -21, -31, -29, -23, -24, -33, -32, -28, -37], 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":[[-20,-61,78,13,-36,-82,-88,38,-86,76,-63,-90,-66,1],50],"expected":-61},{"args":[[5,-79,90,-32,20,88,92,91],100],"expected":92},{"args":[[68,-10,62,60,16,-6,74,-78,46,66,89... |
nearest-percentile-b1-s12 | nearest-percentile | floor-not-ceiling | 20,356,036 | 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": [[1, 2, 3, 4], 100], "expected": 4}, {"args": [[-46, -15, -79, 76, -76, -34, 30, -93, -71, 68], 100], "... | 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":[[-20,-61,78,13,-36,-82,-88,38,-86,76,-63,-90,-66,1],50],"expected":-61},{"args":[[5,-79,90,-32,20,88,92,91],100],"expected":92},{"args":[[68,-10,62,60,16,-6,74,-78,46,66,89... |
nearest-percentile-b2-s12 | nearest-percentile | rank-index | 20,356,036 | 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": [[-25, -27, -22, -29, -17, -21, -19, -28, -34, -35, -32, -33, -23, -20, -31, -26, -18, -24, -30], 33], ... | 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":[[-20,-61,78,13,-36,-82,-88,38,-86,76,-63,-90,-66,1],50],"expected":-61},{"args":[[5,-79,90,-32,20,88,92,91],100],"expected":92},{"args":[[68,-10,62,60,16,-6,74,-78,46,66,89... |
nearest-percentile-b3-s12 | nearest-percentile | descending-order | 20,356,036 | 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": [[32, -67], 0], "expected": -67}, {"args": [[74, -88, -99, 69, -37, 88, 51, -99, 99, -54, 55, 49, -5, -... | 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":[[-20,-61,78,13,-36,-82,-88,38,-86,76,-63,-90,-66,1],50],"expected":-61},{"args":[[5,-79,90,-32,20,88,92,91],100],"expected":92},{"args":[[68,-10,62,60,16,-6,74,-78,46,66,89... |
fifo-inventory-b0-s12 | fifo-inventory | baseline | 20,356,036 | 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 | 120 | [{"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":[[[0,228],[7,278],[3,775],[1,239],[4,865],[5,903],[4,667],[7,671],[3,652]],31],"expected":[19850,[[3,652]]]},{"args":[[[7,78],[5,556],... |
fifo-inventory-b1-s12 | fifo-inventory | zero-lot-retention | 20,356,036 | 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 | 120 | [{"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":[[[0,228],[7,278],[3,775],[1,239],[4,865],[5,903],[4,667],[7,671],[3,652]],31],"expected":[19850,[[3,652]]]},{"args":[[[7,78],[5,556],... |
fifo-inventory-b2-s12 | fifo-inventory | over-consumption | 20,356,036 | 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 | 120 | [{"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":[[[0,228],[7,278],[3,775],[1,239],[4,865],[5,903],[4,667],[7,671],[3,652]],31],"expected":[19850,[[3,652]]]},{"args":[[[7,78],[5,556],... |
fifo-inventory-b3-s12 | fifo-inventory | unit-cost-not-quantity | 20,356,036 | 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 | 120 | [{"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":[[[0,228],[7,278],[3,775],[1,239],[4,865],[5,903],[4,667],[7,671],[3,652]],31],"expected":[19850,[[3,652]]]},{"args":[[[7,78],[5,556],... |
csv-row-b0-s12 | csv-row | baseline | 20,356,036 | 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": ["\"x8\"\"y\",z"], "expected": ["x8\"y", "z"]},... | 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":["\"b猫猫 \"\"b\"\"\"\" \",,\"猫,\"\"\",猫b 猫猫b,,bbb"],"expected":["b猫猫 \"b\... |
csv-row-b1-s12 | csv-row | quoted-comma | 20,356,036 | 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"], "expected": ["a", "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 | 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":["\"b猫猫 \"\"b\"\"\"\" \",,\"猫,\"\"\",猫b 猫猫b,,bbb"],"expected":["b猫猫 \"b\... |
csv-row-b2-s12 | csv-row | escaped-quote | 20,356,036 | 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": ["\"x0,y\",z"], "expected": ["x0,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 | 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":["\"b猫猫 \"\"b\"\"\"\" \",,\"猫,\"\"\",猫b 猫猫b,,bbb"],"expected":["b猫猫 \"b\... |
csv-row-b3-s12 | csv-row | lost-final-field | 20,356,036 | 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\"\"a,\",\" \"\"aa,b\"\"猫\""], "expe... | 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":["\"b猫猫 \"\"b\"\"\"\" \",,\"猫,\"\"\",猫b 猫猫b,,bbb"],"expected":["b猫猫 \"b\... |
shortest-path-b0-s12 | shortest-path | baseline | 20,356,036 | 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", 5]], "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":[["4",1]],"2":[["1",8],["3",0]],"3":[["2",3]],"4":[["3",8]]},"0","4"],"expected":null},{"args":[{"0":[["2",0],["4",8]],"1":[["4",7]],"2":[["1",4]],"3":[["2... |
shortest-path-b1-s12 | shortest-path | farthest-first | 20,356,036 | 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", 177], ["... | 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":[["4",1]],"2":[["1",8],["3",0]],"3":[["2",3]],"4":[["3",8]]},"0","4"],"expected":null},{"args":[{"0":[["2",0],["4",8]],"1":[["4",7]],"2":[["1",4]],"3":[["2... |
shortest-path-b2-s12 | shortest-path | lost-path-prefix | 20,356,036 | 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", 0]], "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":[["4",1]],"2":[["1",8],["3",0]],"3":[["2",3]],"4":[["3",8]]},"0","4"],"expected":null},{"args":[{"0":[["2",0],["4",8]],"1":[["4",7]],"2":[["1",4]],"3":[["2... |
shortest-path-b3-s12 | shortest-path | missing-relaxation | 20,356,036 | 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", 0]], "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 | true | 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":[["4",1]],"2":[["1",8],["3",0]],"3":[["2",3]],"4":[["3",8]]},"0","4"],"expected":null},{"args":[{"0":[["2",0],["4",8]],"1":[["4",7]],"2":[["1",4]],"3":[["2... |
merge-intervals-b0-s13 | merge-intervals | baseline | 20,363,955 | 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, -17], [22, 26], [8, 11], [-17, -13], [7, 7], [1, 5], [7, 9], [19, 19], [6... | def solve(intervals):
return sorted(intervals)
| train | false | 106 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[26,31],[-7,-7],[-7,-1],[18,20],[16,16],[7,7],[-19,-19],[14,15],[16,19]]],"expected":[[-19,-19],[-7,-1],[7,7],[14,15],[16,20],[26,31]]},{"args":[[[9,12],[7,10],[25,32],[-2,5],[-14,-11],[-5,-5],[9,10],[-15,-9],[0,0],[-19,-12],[1,8],... |
merge-intervals-b1-s13 | merge-intervals | touching-boundary | 20,363,955 | 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, -2], [0, 7], [-10, -9], [-12, -8], [-17, -14], [-14, -12]]], "expected": [... | 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":[[[26,31],[-7,-7],[-7,-1],[18,20],[16,16],[7,7],[-19,-19],[14,15],[16,19]]],"expected":[[-19,-19],[-7,-1],[7,7],[14,15],[16,20],[26,31]]},{"args":[[[9,12],[7,10],[25,32],[-2,5],[-14,-11],[-5,-5],[9,10],[-15,-9],[0,0],[-19,-12],[1,8],... |
merge-intervals-b2-s13 | merge-intervals | nested-endpoint | 20,363,955 | 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": [[[-2, 3], [-5, -2]]], "expected": [[-5, 3]]}, {"args": [[[-15, -12], [13, 14], [... | 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,31],[-7,-7],[-7,-1],[18,20],[16,16],[7,7],[-19,-19],[14,15],[16,19]]],"expected":[[-19,-19],[-7,-1],[7,7],[14,15],[16,20],[26,31]]},{"args":[[[9,12],[7,10],[25,32],[-2,5],[-14,-11],[-5,-5],[9,10],[-15,-9],[0,0],[-19,-12],[1,8],... |
merge-intervals-b3-s13 | merge-intervals | unsorted-input | 20,363,955 | 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": [[]], "expected": []}, {"args": [[[39, 44], [36, 39]]], "expected": [[36, 44]]}, ... | 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,31],[-7,-7],[-7,-1],[18,20],[16,16],[7,7],[-19,-19],[14,15],[16,19]]],"expected":[[-19,-19],[-7,-1],[7,7],[14,15],[16,20],[26,31]]},{"args":[[[9,12],[7,10],[25,32],[-2,5],[-14,-11],[-5,-5],[9,10],[-15,-9],[0,0],[-19,-12],[1,8],... |
moving-sums-b0-s13 | moving-sums | baseline | 20,363,955 | 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": [[33, 39, -74, -72, -94, 49, -5, 13, -32, -77, 71, -100, 30, -17, -71, 17, -43], 5], "expected": [-168, -152, -196, -109, -69, -52, -30, -125, -108, -93, -... | def solve(values,k):
return [sum(values[i:i+k]) for i in range(len(values)-k)]
| train | false | 141 | [{"args":[[],1],"expected":[]},{"args":[[1,2,3],2],"expected":[3,5]},{"args":[[5],1],"expected":[5]},{"args":[[1],0],"expected":[]},{"args":[[-12,14,-1,40,-95,-20],0],"expected":[]},{"args":[[28,2,-5,-26,43,-90,75,77,-18,67,-69,-61,-93,-87,-75,86,-98,-80,10],11],"expected":[84,-5,-100,-182,-231,-188,-196,-351,-418]},{"... |
moving-sums-b1-s13 | moving-sums | zero-window | 20,363,955 | 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": [[57], 21], "expected": []}, {"args": [[-26, -5, -8], 2], "expected": [-31, -13]}, {"args": [[36, 26, -33, -5, -51, 49, 85, 55, -41], 16], "expected": []}] | 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 | 141 | [{"args":[[],1],"expected":[]},{"args":[[1,2,3],2],"expected":[3,5]},{"args":[[5],1],"expected":[5]},{"args":[[1],0],"expected":[]},{"args":[[-12,14,-1,40,-95,-20],0],"expected":[]},{"args":[[28,2,-5,-26,43,-90,75,77,-18,67,-69,-61,-93,-87,-75,86,-98,-80,10],11],"expected":[84,-5,-100,-182,-231,-188,-196,-351,-418]},{"... |
moving-sums-b2-s13 | moving-sums | window-width | 20,363,955 | 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, -18, -8, -5, 1, 4, 28, -17, -20], 2], "expected": [-36, -26, -13, -4, 5, 32, 11, -37]}, {"args": [[67, 55, 56, -61, 20, -49, -63, -94, 45, 53, 77], ... | 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 | 141 | [{"args":[[],1],"expected":[]},{"args":[[1,2,3],2],"expected":[3,5]},{"args":[[5],1],"expected":[5]},{"args":[[1],0],"expected":[]},{"args":[[-12,14,-1,40,-95,-20],0],"expected":[]},{"args":[[28,2,-5,-26,43,-90,75,77,-18,67,-69,-61,-93,-87,-75,86,-98,-80,10],11],"expected":[84,-5,-100,-182,-231,-188,-196,-351,-418]},{"... |
moving-sums-b3-s13 | moving-sums | missing-first-window | 20,363,955 | 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": [[], 1], "expected": []}, {"args": [[9, -20, -5, 13, -4, 10, 13], 0], "expected": []}, {"args": [[-26, 98, -66, 40, -41], 6], "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 | 141 | [{"args":[[],1],"expected":[]},{"args":[[1,2,3],2],"expected":[3,5]},{"args":[[5],1],"expected":[5]},{"args":[[1],0],"expected":[]},{"args":[[-12,14,-1,40,-95,-20],0],"expected":[]},{"args":[[28,2,-5,-26,43,-90,75,77,-18,67,-69,-61,-93,-87,-75,86,-98,-80,10],11],"expected":[84,-5,-100,-182,-231,-188,-196,-351,-418]},{"... |
weighted-mean-b0-s13 | weighted-mean | baseline | 20,363,955 | 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": [[44, -15, 24, -47, 33, -32, 2, -35, -10], [1, 4, 5, 0, 1, 0, 1, 1, 2]], "expected": 5.6},... | def solve(values,weights):
return sum(values)/len(values) if values else None
| train | false | 113 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[-34,-50,25,-18,-34,5,-37,-32,18,18,16,10,-31,-17,36,46,10,46],[0,5,0,2,2,0,1,4,5,2,5,0,2,0,1,3,5,2]],"expected":-1.5128205128205128},{"args":[[-49,38,-25,-35,-2,22,5,26,-28,-47,-14,39],[0,2,2,1,5,3,0,3... |
weighted-mean-b1-s13 | weighted-mean | unweighted-numerator | 20,363,955 | 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": [[-49, 38, -25, -35, -2, 22, 5, 26, -28, -47, -14, 39], [0, 2, 2, 1, 5, 3, 0, 3, 4, 5, 0, ... | def solve(values,weights):
total = sum(weights)
return sum(x for x,w in zip(values,weights))/total if total else None
| train | false | 113 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[-34,-50,25,-18,-34,5,-37,-32,18,18,16,10,-31,-17,36,46,10,46],[0,5,0,2,2,0,1,4,5,2,5,0,2,0,1,3,5,2]],"expected":-1.5128205128205128},{"args":[[-49,38,-25,-35,-2,22,5,26,-28,-47,-14,39],[0,2,2,1,5,3,0,3... |
weighted-mean-b2-s13 | weighted-mean | wrong-denominator | 20,363,955 | 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, -19], [1, 5]], "expected": -20.166666666666668}, {"args": [[5, -6, 24, -34, 23, -20... | 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 | 113 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[-34,-50,25,-18,-34,5,-37,-32,18,18,16,10,-31,-17,36,46,10,46],[0,5,0,2,2,0,1,4,5,2,5,0,2,0,1,3,5,2]],"expected":-1.5128205128205128},{"args":[[-49,38,-25,-35,-2,22,5,26,-28,-47,-14,39],[0,2,2,1,5,3,0,3... |
weighted-mean-b3-s13 | weighted-mean | zero-weight-result | 20,363,955 | 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": [[], []], "expected": null}, {"args": [[36, 43], [1, 5]], "expected": 41.833333333333336},... | 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 | 113 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[-34,-50,25,-18,-34,5,-37,-32,18,18,16,10,-31,-17,36,46,10,46],[0,5,0,2,2,0,1,4,5,2,5,0,2,0,1,3,5,2]],"expected":-1.5128205128205128},{"args":[[-49,38,-25,-35,-2,22,5,26,-28,-47,-14,39],[0,2,2,1,5,3,0,3... |
stable-unique-b0-s13 | stable-unique | baseline | 20,363,955 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[9, 4, -3, -6, 6, 5, -7, -2, -6, -6, -3, -1, 6, -8, 5, 0, 7, 6, 4, -2, -2, -8]], "expected": [9, 4, -3, -6, 6, 5, -7, -2, -1, -8, 0, 7]}, {"args": [[-... | def solve(values):
return sorted(set(values))
| train | false | 95 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[3,10,5,-9,0,6,-8,-3,8,6,-8,2,-1,-4,-5,-8,9]],"expected":[3,10,5,-9,0,6,-8,-3,8,2,-1,-4,-5,9]},{"args":[[4,5,10,-3,4,4,-10,9,-6,-10,-4,8,-9,-7,8,5,-3,-8,-6,7,7,1,-10,1]],"expected":[4,5,10,-3,-10,9,-6,-4,8,-9,-7,-8,7,1]},{"args":[[-5,-7,-9,... |
stable-unique-b1-s13 | stable-unique | reverse-traversal | 20,363,955 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[-5, -7, -9, -9, -3, 7, 2, -10, -2, -8, -10, -7, 8, 5, 8, 9, -7]], "expected": [-5, -7, -9, -3, 7, 2, -10, -2, -8, 8, 5, 9]}, {"args": [[-10]], "expec... | 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 | 95 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[3,10,5,-9,0,6,-8,-3,8,6,-8,2,-1,-4,-5,-8,9]],"expected":[3,10,5,-9,0,6,-8,-3,8,2,-1,-4,-5,9]},{"args":[[4,5,10,-3,4,4,-10,9,-6,-10,-4,8,-9,-7,8,5,-3,-8,-6,7,7,1,-10,1]],"expected":[4,5,10,-3,-10,9,-6,-4,8,-9,-7,-8,7,1]},{"args":[[-5,-7,-9,... |
stable-unique-b2-s13 | stable-unique | reverse-output | 20,363,955 | 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, 0, -1]], "expected": [1, -1, 0]}, {"args": [[8, 2, -2, 1, -7, -4, -9, -1, -4]], "expected": [8, 2, -2, 1, -7, -4, -9, -1]}, {"args": [[4, 8... | 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 | 95 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[3,10,5,-9,0,6,-8,-3,8,6,-8,2,-1,-4,-5,-8,9]],"expected":[3,10,5,-9,0,6,-8,-3,8,2,-1,-4,-5,9]},{"args":[[4,5,10,-3,4,4,-10,9,-6,-10,-4,8,-9,-7,8,5,-3,-8,-6,7,7,1,-10,1]],"expected":[4,5,10,-3,-10,9,-6,-4,8,-9,-7,-8,7,1]},{"args":[[-5,-7,-9,... |
stable-unique-b3-s13 | stable-unique | wrong-seen-value | 20,363,955 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[]], "expected": []}, {"args": [[-14, -16, -14, -15, -16]], "expected": [-14, -16, -15]}, {"args": [[5, 3, -9, 10, -1, 5, 10, -9, -7, -9, -10, 2, 9, 0... | 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 | 95 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[3,10,5,-9,0,6,-8,-3,8,6,-8,2,-1,-4,-5,-8,9]],"expected":[3,10,5,-9,0,6,-8,-3,8,2,-1,-4,-5,9]},{"args":[[4,5,10,-3,4,4,-10,9,-6,-10,-4,8,-9,-7,8,5,-3,-8,-6,7,7,1,-10,1]],"expected":[4,5,10,-3,-10,9,-6,-4,8,-9,-7,-8,7,1]},{"args":[[-5,-7,-9,... |
run-length-b0-s13 | run-length | baseline | 20,363,955 | 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 b🙂abb🙂b"], "expected": [[" ", 1], ["a", 1], ["c", 1], [" ", 1], ["b", 1], ["🙂", 1], [... | def solve(text):
return [[c,text.count(c)] for c in sorted(set(text))]
| train | false | 103 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["bbb猫猫猫a🙂a🙂b bbbc🙂 猫猫🙂猫"],"expected":[["b",3],["猫",3],["a",1],["🙂",1],["a",1],["🙂",1],["b",1],[" ",1],["b",3],["c",1],["🙂",1],[" ",1],["猫",2],["🙂",1],["猫",1]]... |
run-length-b1-s13 | run-length | inverted-grouping | 20,363,955 | 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": ["bc猫🙂 猫猫b 猫bbb a 猫ab猫🙂b猫b "], "expected": [["b", 1], ["c", 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,1])
return out
| train | true | 103 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["bbb猫猫猫a🙂a🙂b bbbc🙂 猫猫🙂猫"],"expected":[["b",3],["猫",3],["a",1],["🙂",1],["a",1],["🙂",1],["b",1],[" ",1],["b",3],["c",1],["🙂",1],[" ",1],["猫",2],["🙂",1],["猫",1]]... |
run-length-b2-s13 | run-length | double-increment | 20,363,955 | 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": ["猫猫猫猫猫猫猫猫猫dddddddd"], "expected": [["猫", 9], ["d", 8]]}, {"args": ["🙂a猫a 猫c猫 c 🙂c 🙂猫c🙂 猫... | 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 | 103 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["bbb猫猫猫a🙂a🙂b bbbc🙂 猫猫🙂猫"],"expected":[["b",3],["猫",3],["a",1],["🙂",1],["a",1],["🙂",1],["b",1],[" ",1],["b",3],["c",1],["🙂",1],[" ",1],["猫",2],["🙂",1],["猫",1]]... |
run-length-b3-s13 | run-length | zero-initial-count | 20,363,955 | 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": []}, {"args": ["猫猫猫猫猫猫猫猫猫猫猫猫猫猫猫猫猫dddddddddddddddd"], "expected": [["猫", 17],... | 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 | 103 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["bbb猫猫猫a🙂a🙂b bbbc🙂 猫猫🙂猫"],"expected":[["b",3],["猫",3],["a",1],["🙂",1],["a",1],["🙂",1],["b",1],[" ",1],["b",3],["c",1],["🙂",1],[" ",1],["猫",2],["🙂",1],["猫",1]]... |
luhn-b0-s13 | luhn | baseline | 20,363,955 | 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": ["326498119166083911"], "expected"... | def solve(text):
return bool(text) and text.isdigit() and sum(int(c) for c in text)%10 == 0
| train | false | 183 | [{"args":[""],"expected":false},{"args":["0"],"expected":true},{"args":["79927398713"],"expected":true},{"args":["79927398714"],"expected":false},{"args":["12x"],"expected":false},{"args":[" 0"],"expected":false},{"args":["12"],"expected":false},{"args":["0000"],"expected":true},{"args":["160359"],"expected":false},{"a... |
luhn-b1-s13 | luhn | wrong-parity | 20,363,955 | 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": ["242955776915550717"], "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 not i%2:
v *= 2
if v > 9: v -= 9
total += v
return total%10 == 0
| train | false | 183 | [{"args":[""],"expected":false},{"args":["0"],"expected":true},{"args":["79927398713"],"expected":true},{"args":["79927398714"],"expected":false},{"args":["12x"],"expected":false},{"args":[" 0"],"expected":false},{"args":["12"],"expected":false},{"args":["0000"],"expected":true},{"args":["160359"],"expected":false},{"a... |
luhn-b2-s13 | luhn | wrong-reduction | 20,363,955 | 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": ["280039009"], "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 -= 8
total += v
return total%10 == 0
| train | false | 183 | [{"args":[""],"expected":false},{"args":["0"],"expected":true},{"args":["79927398713"],"expected":true},{"args":["79927398714"],"expected":false},{"args":["12x"],"expected":false},{"args":[" 0"],"expected":false},{"args":["12"],"expected":false},{"args":["0000"],"expected":true},{"args":["160359"],"expected":false},{"a... |
luhn-b3-s13 | luhn | wrong-modulus | 20,363,955 | 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": [""], "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 | 183 | [{"args":[""],"expected":false},{"args":["0"],"expected":true},{"args":["79927398713"],"expected":true},{"args":["79927398714"],"expected":false},{"args":["12x"],"expected":false},{"args":[" 0"],"expected":false},{"args":["12"],"expected":false},{"args":["0000"],"expected":true},{"args":["160359"],"expected":false},{"a... |
edit-distance-b0-s13 | edit-distance | baseline | 20,363,955 | 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": ["猫ca猫", "猫ac猫猫猫cdab"], "expected": 7}, {"args": ["cacc猫aabcccc", ""], "expected": 12}, {"args": ["b猫猫dacab", "bdd猫猫acd"], "expected": ... | 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":["dbcdaba猫","caaa猫bbabd"],"expected":8},{"args":["d","da"],"expected":1},{"args":["a","acdb"],"expected":3},{"args":["b猫猫dacab","bdd猫猫acd"],"expected":5},{"args":["b猫b猫ddc猫","ba猫c"],"expected":5},{"args":["... |
edit-distance-b1-s13 | edit-distance | row-boundary | 20,363,955 | 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": ["猫b猫猫", "ba"], "expected": 3}, {"args": ["bca猫c猫", "bca猫c猫"], "expected": 0}, {"args": ["dcaaccc猫", "bbd猫d"], "expected": 8}] | 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":["dbcdaba猫","caaa猫bbabd"],"expected":8},{"args":["d","da"],"expected":1},{"args":["a","acdb"],"expected":3},{"args":["b猫猫dacab","bdd猫猫acd"],"expected":5},{"args":["b猫b猫ddc猫","ba猫c"],"expected":5},{"args":["... |
edit-distance-b2-s13 | edit-distance | inverted-substitution | 20,363,955 | 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猫a", "ac猫a"], "expected": 0}, {"args": ["猫b", "aaca猫"], "expected": 5}, {"args": ["猫ad猫", ""], "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 | 142 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["dbcdaba猫","caaa猫bbabd"],"expected":8},{"args":["d","da"],"expected":1},{"args":["a","acdb"],"expected":3},{"args":["b猫猫dacab","bdd猫猫acd"],"expected":5},{"args":["b猫b猫ddc猫","ba猫c"],"expected":5},{"args":["... |
edit-distance-b3-s13 | edit-distance | diagonal-index | 20,363,955 | 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": ["", ""], "expected": 0}, {"args": ["cbccbb猫ba", "ab猫bbccbc"], "expected": 6}, {"args": ["adbc猫dca猫b猫", "猫猫dcbc"], "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 | 142 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["dbcdaba猫","caaa猫bbabd"],"expected":8},{"args":["d","da"],"expected":1},{"args":["a","acdb"],"expected":3},{"args":["b猫猫dacab","bdd猫猫acd"],"expected":5},{"args":["b猫b猫ddc猫","ba猫c"],"expected":5},{"args":["... |
meeting-rooms-b0-s13 | meeting-rooms | baseline | 20,363,955 | 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": [[[19, 26], [11, 18], [1, 2], [18, 25], [6, 12], [7, 10], [7, 8], [5, 9], [10, ... | 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":[[[6,10],[5,12],[4,11],[5,9],[14,16],[4,12],[16,23],[18,25],[17,18]]],"expected":5},{"args":[[[2,6],[9,14],[12,20],[19,21],[17,25],[7,15],[17,24],[7,15],[0,1],[2,9]]],"expected":4},{"args":[[[13,20],[6,... |
meeting-rooms-b1-s13 | meeting-rooms | tie-order | 20,363,955 | 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], [9, 14], [12, 20], [19, 21], [17, 25], [7, 15], [17, 24], [7, 15], [0... | 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":[[[6,10],[5,12],[4,11],[5,9],[14,16],[4,12],[16,23],[18,25],[17,18]]],"expected":5},{"args":[[[2,6],[9,14],[12,20],[19,21],[17,25],[7,15],[17,24],[7,15],[0,1],[2,9]]],"expected":4},{"args":[[[13,20],[6,... |
meeting-rooms-b2-s13 | meeting-rooms | peak-tracking | 20,363,955 | 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": [[[-33, -25], [-32, -30], [-31, -26]]], "expected": 3}, {"args": [[[3, 10], [14... | 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":[[[6,10],[5,12],[4,11],[5,9],[14,16],[4,12],[16,23],[18,25],[17,18]]],"expected":5},{"args":[[[2,6],[9,14],[12,20],[19,21],[17,25],[7,15],[17,24],[7,15],[0,1],[2,9]]],"expected":4},{"args":[[[13,20],[6,... |
meeting-rooms-b3-s13 | meeting-rooms | end-event-sign | 20,363,955 | 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": [[]], "expected": 0}, {"args": [[[0, 8], [1, 3], [2, 7]]], "expected": 3}, {"ar... | 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":[[[6,10],[5,12],[4,11],[5,9],[14,16],[4,12],[16,23],[18,25],[17,18]]],"expected":5},{"args":[[[2,6],[9,14],[12,20],[19,21],[17,25],[7,15],[17,24],[7,15],[0,1],[2,9]]],"expected":4},{"args":[[[13,20],[6,... |
nearest-percentile-b0-s13 | nearest-percentile | baseline | 20,363,955 | 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": [[0, 15, 13, 12, 1, 7, 11, 2, 19, 9, 16, 3, 4, 18, 6, -1, 5, 14, 8, 17, 10], 50], "expected": 9}, {"arg... | 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":[[6,11,-12,-29,56,0,-53,-13,-34,-12,-100,19,-20,97,96,92,-51,-74,91,-22,13,-10,87,3,-88,-17,84,65],50],"expected":-10},{"args":[[27,86,-68,-4,-52,-2,-65,-9,0,89,-57,81,-45,-... |
nearest-percentile-b1-s13 | nearest-percentile | floor-not-ceiling | 20,363,955 | 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": [[39, -72, 27, 33, 22, -67, 12, 17, -70, -35], 0], "expected": -72}, {"args": [[-19, -24, -27, -17, -15... | 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":[[6,11,-12,-29,56,0,-53,-13,-34,-12,-100,19,-20,97,96,92,-51,-74,91,-22,13,-10,87,3,-88,-17,84,65],50],"expected":-10},{"args":[[27,86,-68,-4,-52,-2,-65,-9,0,89,-57,81,-45,-... |
nearest-percentile-b2-s13 | nearest-percentile | rank-index | 20,363,955 | 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": [[38, 42, 40, 45, 43, 44, 39, 41, 37], 99], "expected": 45}, {"args": [[-54, 29, -65, -4], 100], "expec... | 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":[[6,11,-12,-29,56,0,-53,-13,-34,-12,-100,19,-20,97,96,92,-51,-74,91,-22,13,-10,87,3,-88,-17,84,65],50],"expected":-10},{"args":[[27,86,-68,-4,-52,-2,-65,-9,0,89,-57,81,-45,-... |
nearest-percentile-b3-s13 | nearest-percentile | descending-order | 20,363,955 | 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": [[], 50], "expected": null}, {"args": [[-29, -27, -39, -32, -33, -31, -28, -25, -37, -36, -26, -35, -34... | 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":[[6,11,-12,-29,56,0,-53,-13,-34,-12,-100,19,-20,97,96,92,-51,-74,91,-22,13,-10,87,3,-88,-17,84,65],50],"expected":-10},{"args":[[27,86,-68,-4,-52,-2,-65,-9,0,89,-57,81,-45,-... |
fifo-inventory-b0-s13 | fifo-inventory | baseline | 20,363,955 | 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":[[],12],"expected":null},{"args":[[[1,160]],21],"expected":null},{"args":[[[2,458],[1,997],[3,765]],19],"expected":null},{"args":[[[6,... |
fifo-inventory-b1-s13 | fifo-inventory | zero-lot-retention | 20,363,955 | 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":[[],12],"expected":null},{"args":[[[1,160]],21],"expected":null},{"args":[[[2,458],[1,997],[3,765]],19],"expected":null},{"args":[[[6,... |
fifo-inventory-b2-s13 | fifo-inventory | over-consumption | 20,363,955 | 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":[[],12],"expected":null},{"args":[[[1,160]],21],"expected":null},{"args":[[[2,458],[1,997],[3,765]],19],"expected":null},{"args":[[[6,... |
fifo-inventory-b3-s13 | fifo-inventory | unit-cost-not-quantity | 20,363,955 | 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":[[],12],"expected":null},{"args":[[[1,160]],21],"expected":null},{"args":[[[2,458],[1,997],[3,765]],19],"expected":null},{"args":[[[6,... |
csv-row-b0-s13 | csv-row | baseline | 20,363,955 | 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": ["x19,"], "expected": ["x19", ""]}, {"args": ["... | 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":["\"a\"\"a bb \",\"ba,b\",\",\"\"猫aba,\""],"expected":["a\"a bb ","ba,b",... |
csv-row-b1-s13 | csv-row | quoted-comma | 20,363,955 | 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猫,,b\"\"\",\", 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 | 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":["\"a\"\"a bb \",\"ba,b\",\",\"\"猫aba,\""],"expected":["a\"a bb ","ba,b",... |
csv-row-b2-s13 | csv-row | escaped-quote | 20,363,955 | 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": ["\"x6,y\",z"], "expected": ["x6,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":["\"a\"\"a bb \",\"ba,b\",\",\"\"猫aba,\""],"expected":["a\"a bb ","ba,b",... |
csv-row-b3-s13 | csv-row | lost-final-field | 20,363,955 | 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": ["\"x16\"\"y\",... | 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":["\"a\"\"a bb \",\"ba,b\",\",\"\"猫aba,\""],"expected":["a\"a bb ","ba,b",... |
shortest-path-b0-s13 | shortest-path | baseline | 20,363,955 | 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):
return 0 if start == target else None
| train | false | 99 | [{"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",3],["2",9],["5",2]],"1":[["5",7]],"2":[["3",7]],"3":[["1",4],["4",0],["5",0]],"4":[["5",1]],"5":[["2",5]]},"0","5"],"expected":2},{"args":[{"0":[["1",8],["6... |
shortest-path-b1-s13 | shortest-path | farthest-first | 20,363,955 | 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", 8], ["6"... | 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 | 99 | [{"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",3],["2",9],["5",2]],"1":[["5",7]],"2":[["3",7]],"3":[["1",4],["4",0],["5",0]],"4":[["5",1]],"5":[["2",5]]},"0","5"],"expected":2},{"args":[{"0":[["1",8],["6... |
shortest-path-b2-s13 | shortest-path | lost-path-prefix | 20,363,955 | 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", 494], ["... | 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 | 99 | [{"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",3],["2",9],["5",2]],"1":[["5",7]],"2":[["3",7]],"3":[["1",4],["4",0],["5",0]],"4":[["5",1]],"5":[["2",5]]},"0","5"],"expected":2},{"args":[{"0":[["1",8],["6... |
shortest-path-b3-s13 | shortest-path | missing-relaxation | 20,363,955 | 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", "a"], "expec... | 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 | 99 | [{"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",3],["2",9],["5",2]],"1":[["5",7]],"2":[["3",7]],"3":[["1",4],["4",0],["5",0]],"4":[["5",1]],"5":[["2",5]]},"0","5"],"expected":2},{"args":[{"0":[["1",8],["6... |
merge-intervals-b0-s14 | merge-intervals | baseline | 20,371,874 | 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": [[[24, 27], [-17, -17], [-2, 2], [10, 10], [14, 19], [-8, -7], [1, 3], [8, 9], [4... | def solve(intervals):
return sorted(intervals)
| train | false | 106 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[4,6],[-1,3],[-5,1],[1,3]]],"expected":[[-5,3],[4,6]]},{"args":[[[-16,-14],[14,14]]],"expected":[[-16,-14],[14,14]]},{"args":[[[-15,-14],[-4,1],[27,27],[27,34],[3,4],[18,18],[22,28],[26,27],[5,8],[29,36],[4,6],[20,25],[-19,-15],[3,... |
merge-intervals-b1-s14 | merge-intervals | touching-boundary | 20,371,874 | 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": [[[12, 17], [11, 12], [-3, -3], [27, 32]]], "expected": [[-3, -3], [11, 17], [27,... | 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,6],[-1,3],[-5,1],[1,3]]],"expected":[[-5,3],[4,6]]},{"args":[[[-16,-14],[14,14]]],"expected":[[-16,-14],[14,14]]},{"args":[[[-15,-14],[-4,1],[27,27],[27,34],[3,4],[18,18],[22,28],[26,27],[5,8],[29,36],[4,6],[20,25],[-19,-15],[3,... |
merge-intervals-b2-s14 | merge-intervals | nested-endpoint | 20,371,874 | 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": [[[-33, -28], [-36, -33]]], "expected": [[-36, -28]]}, {"args": [[[-12, -10], [-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 | 106 | [{"args":[[]],"expected":[]},{"args":[[[1,4],[2,3],[4,8]]],"expected":[[1,8]]},{"args":[[[4,6],[-1,3],[-5,1],[1,3]]],"expected":[[-5,3],[4,6]]},{"args":[[[-16,-14],[14,14]]],"expected":[[-16,-14],[14,14]]},{"args":[[[-15,-14],[-4,1],[27,27],[27,34],[3,4],[18,18],[22,28],[26,27],[5,8],[29,36],[4,6],[20,25],[-19,-15],[3,... |
merge-intervals-b3-s14 | merge-intervals | unsorted-input | 20,371,874 | 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, 17], [0, 2], [-19, -16], [12, 16]]], "expected": [[-19, -16], [0, 2], [12,... | 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,6],[-1,3],[-5,1],[1,3]]],"expected":[[-5,3],[4,6]]},{"args":[[[-16,-14],[14,14]]],"expected":[[-16,-14],[14,14]]},{"args":[[[-15,-14],[-4,1],[27,27],[27,34],[3,4],[18,18],[22,28],[26,27],[5,8],[29,36],[4,6],[20,25],[-19,-15],[3,... |
moving-sums-b0-s14 | moving-sums | baseline | 20,371,874 | 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": [[47, -41, 71, 32, 56, 75], 4], "expected": [109, 118, 234]}, {"args": [[21, 6, -19, -12, -26, 28], 0], "expected": []}, {"args": [[-86, 39, -86, -1, 89, -... | 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":[[63,-50,33],8],"expected":[]},{"args":[[-47,-63,34,-78,1,-89,13,-27,-27],5],"expected":[-153,-195,-119,-180,-129]},{"args":[[63,8,-46,-15,-10,-73,18,59,-27,-86,56,37,-48,2,72,81,-... |
moving-sums-b1-s14 | moving-sums | zero-window | 20,371,874 | 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, 13, -11, 84, 16, -1, 72, -27, -3, -33, -97, 64, -15, 25, -27, 70, -21, -2], -2], "expected": []}, {"args": [[47, -41, 71, 32, 56, 75], 4], "expected... | 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":[[63,-50,33],8],"expected":[]},{"args":[[-47,-63,34,-78,1,-89,13,-27,-27],5],"expected":[-153,-195,-119,-180,-129]},{"args":[[63,8,-46,-15,-10,-73,18,59,-27,-86,56,37,-48,2,72,81,-... |
moving-sums-b2-s14 | moving-sums | window-width | 20,371,874 | 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": [[-2, -12, -27, -29], 0], "expected": []}, {"args": [[-6, -69, -59, 70, 3, -26], 22], "expected": []}, {"args": [[88, 6, -19, 19, 62], -1], "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 | 144 | [{"args":[[],1],"expected":[]},{"args":[[1,2,3],2],"expected":[3,5]},{"args":[[5],1],"expected":[5]},{"args":[[1],0],"expected":[]},{"args":[[63,-50,33],8],"expected":[]},{"args":[[-47,-63,34,-78,1,-89,13,-27,-27],5],"expected":[-153,-195,-119,-180,-129]},{"args":[[63,8,-46,-15,-10,-73,18,59,-27,-86,56,37,-48,2,72,81,-... |
moving-sums-b3-s14 | moving-sums | missing-first-window | 20,371,874 | 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": [[-9, -16, -22, 12], 1], "expected": [-9, -16, -22, 12]}, {"args": [[48, 69, 60, -78, -73, -63, 77, 52, 23, -49], 18], "expected": []}, {"args": [[-86, 44,... | 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":[[63,-50,33],8],"expected":[]},{"args":[[-47,-63,34,-78,1,-89,13,-27,-27],5],"expected":[-153,-195,-119,-180,-129]},{"args":[[63,8,-46,-15,-10,-73,18,59,-27,-86,56,37,-48,2,72,81,-... |
weighted-mean-b0-s14 | weighted-mean | baseline | 20,371,874 | 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": [[-29, -18, 6, -12, -15, 36, -4, 29, 29, 12, -34, 11, 38, 24, -42], [3, 0, 5, 0, 0, 4, 4, ... | def solve(values,weights):
return sum(values)/len(values) if values else None
| train | false | 117 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[40,-50],[0,1]],"expected":-50.0},{"args":[[49,29,-26,45,-35,38,-21,-43,42,-1,-21,46],[2,3,2,0,3,4,2,1,5,0,1,0]],"expected":12.347826086956522},{"args":[[2,-48,-7,-40,24,6,-38,39,-25],[2,2,3,3,0,2,5,5,1... |
weighted-mean-b1-s14 | weighted-mean | unweighted-numerator | 20,371,874 | 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": [[-28, -47, -47, 28, -15, 2, -33, 25], [1, 0, 3, 0, 4, 5, 3, 4]], "expected": -10.9}, {"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 | 117 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[40,-50],[0,1]],"expected":-50.0},{"args":[[49,29,-26,45,-35,38,-21,-43,42,-1,-21,46],[2,3,2,0,3,4,2,1,5,0,1,0]],"expected":12.347826086956522},{"args":[[2,-48,-7,-40,24,6,-38,39,-25],[2,2,3,3,0,2,5,5,1... |
weighted-mean-b2-s14 | weighted-mean | wrong-denominator | 20,371,874 | 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": [[24, 31], [1, 5]], "expected": 29.833333333333332}, {"args": [[-20, -13], [1, 5]], "expec... | def solve(values,weights):
total = len(weights)
return sum(x*w for x,w in zip(values,weights))/total if total else None
| train | true | 117 | [{"args":[[],[]],"expected":null},{"args":[[2,10],[0,1]],"expected":10.0},{"args":[[2],[0]],"expected":null},{"args":[[40,-50],[0,1]],"expected":-50.0},{"args":[[49,29,-26,45,-35,38,-21,-43,42,-1,-21,46],[2,3,2,0,3,4,2,1,5,0,1,0]],"expected":12.347826086956522},{"args":[[2,-48,-7,-40,24,6,-38,39,-25],[2,2,3,3,0,2,5,5,1... |
weighted-mean-b3-s14 | weighted-mean | zero-weight-result | 20,371,874 | 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, 8, 44, 29], [5, 1, 5, 3]], "expected": 37.5}, {"args": [[21, 34, 26, -1, 36, 42, 11,... | 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":[[40,-50],[0,1]],"expected":-50.0},{"args":[[49,29,-26,45,-35,38,-21,-43,42,-1,-21,46],[2,3,2,0,3,4,2,1,5,0,1,0]],"expected":12.347826086956522},{"args":[[2,-48,-7,-40,24,6,-38,39,-25],[2,2,3,3,0,2,5,5,1... |
stable-unique-b0-s14 | stable-unique | baseline | 20,371,874 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[9]], "expected": [9]}, {"args": [[-7, 6, -6, 5, 8]], "expected": [-7, 6, -6, 5, 8]}, {"args": [[1, -7, 2, -1, 0, -10, 5, 8, 1, 7, 8, 2]], "expected":... | def solve(values):
return sorted(set(values))
| train | false | 93 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[-1,9,-5,-9,4,0,2,-2,-10,-5,-2,-2,7,-5,5,-10,-2,9]],"expected":[-1,9,-5,-9,4,0,2,-2,-10,7,5]},{"args":[[-5,2]],"expected":[-5,2]},{"args":[[9,-3,4,-1,4,-5,1,0]],"expected":[9,-3,4,-1,-5,1,0]},{"args":[[-10]],"expected":[-10]},{"args":[[-2,2... |
stable-unique-b1-s14 | stable-unique | reverse-traversal | 20,371,874 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[2, 4, 9, 5, 10, 1, 10, 9, 1, -3, -3, -7, 10, -8, 8, -8, -8, -9, 1, -2, 7, -7, 0, 4, 8, -7]], "expected": [2, 4, 9, 5, 10, 1, -3, -7, -8, 8, -9, -2, 7... | 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 | 93 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[-1,9,-5,-9,4,0,2,-2,-10,-5,-2,-2,7,-5,5,-10,-2,9]],"expected":[-1,9,-5,-9,4,0,2,-2,-10,7,5]},{"args":[[-5,2]],"expected":[-5,2]},{"args":[[9,-3,4,-1,4,-5,1,0]],"expected":[9,-3,4,-1,-5,1,0]},{"args":[[-10]],"expected":[-10]},{"args":[[-2,2... |
stable-unique-b2-s14 | stable-unique | reverse-output | 20,371,874 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[-9, 5, 4, 1, -1, -3, 7, -7, -6, 2, 1, -6, -7, 0, 3, 9, 1]], "expected": [-9, 5, 4, 1, -1, -3, 7, -7, -6, 2, 0, 3, 9]}, {"args": [[-10]], "expected": ... | 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 | 93 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[-1,9,-5,-9,4,0,2,-2,-10,-5,-2,-2,7,-5,5,-10,-2,9]],"expected":[-1,9,-5,-9,4,0,2,-2,-10,7,5]},{"args":[[-5,2]],"expected":[-5,2]},{"args":[[9,-3,4,-1,4,-5,1,0]],"expected":[9,-3,4,-1,-5,1,0]},{"args":[[-10]],"expected":[-10]},{"args":[[-2,2... |
stable-unique-b3-s14 | stable-unique | wrong-seen-value | 20,371,874 | Implement solve(values). Deduplicate integer values while preserving first occurrence order. Empty list stays empty.
Examples (JSON args and expected result): [{"args": [[-8, -4, 5, 3, 1, -6, 9, 8, 3, -1, 9, 6, 2]], "expected": [-8, -4, 5, 3, 1, -6, 9, 8, -1, 6, 2]}, {"args": [[-14, -16, -14, -15, -16]], "expected": [-... | 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 | 93 | [{"args":[[]],"expected":[]},{"args":[[3,1,3,2,1]],"expected":[3,1,2]},{"args":[[-1,9,-5,-9,4,0,2,-2,-10,-5,-2,-2,7,-5,5,-10,-2,9]],"expected":[-1,9,-5,-9,4,0,2,-2,-10,7,5]},{"args":[[-5,2]],"expected":[-5,2]},{"args":[[9,-3,4,-1,4,-5,1,0]],"expected":[9,-3,4,-1,-5,1,0]},{"args":[[-10]],"expected":[-10]},{"args":[[-2,2... |
run-length-b0-s14 | run-length | baseline | 20,371,874 | 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": ["babbccc猫b🙂 ba猫c猫 "], "expected": [["b", 1], ["a", 1], ["b", 2], ["c", 3], ["猫", 1], ["b", 1... | 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":["cc 🙂猫b cc猫bba猫 猫🙂 b🙂c猫b"],"expected":[["c",2],[" ",1],["🙂",1],["猫",1],["b",1],[" ",1],["c",2],["猫",1],["b",2],["a",1],["猫",1],[" ",1],["猫",1],["🙂",1],[" ",1],["... |
run-length-b1-s14 | run-length | inverted-grouping | 20,371,874 | 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 cc猫babb🙂bca猫🙂猫a猫c🙂bc🙂c cacbb猫ab"], "expected": [[" ", 1], ["b", 1], [" ", 1], ["c", 2... | 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":["cc 🙂猫b cc猫bba猫 猫🙂 b🙂c猫b"],"expected":[["c",2],[" ",1],["🙂",1],["猫",1],["b",1],[" ",1],["c",2],["猫",1],["b",2],["a",1],["猫",1],[" ",1],["猫",1],["🙂",1],[" ",1],["... |
run-length-b2-s14 | run-length | double-increment | 20,371,874 | 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": ["猫猫猫猫猫猫猫猫猫猫猫猫猫猫ccccccccccccc"], "expected": [["猫", 14], ["c", 13]]}, {"args": ["b猫 ca 🙂猫🙂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 | 102 | [{"args":[""],"expected":[]},{"args":["aabbaa"],"expected":[["a",2],["b",2],["a",2]]},{"args":["猫猫🙂🙂猫"],"expected":[["猫",2],["🙂",2],["猫",1]]},{"args":["cc 🙂猫b cc猫bba猫 猫🙂 b🙂c猫b"],"expected":[["c",2],[" ",1],["🙂",1],["猫",1],["b",1],[" ",1],["c",2],["猫",1],["b",2],["a",1],["猫",1],[" ",1],["猫",1],["🙂",1],[" ",1],["... |
run-length-b3-s14 | run-length | zero-initial-count | 20,371,874 | 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": ["caba 猫bcabb c猫🙂🙂ac ba猫猫猫c a"], "expected": [["c", 1], ["a", 1], ["b", 1], ["a", 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":["cc 🙂猫b cc猫bba猫 猫🙂 b🙂c猫b"],"expected":[["c",2],[" ",1],["🙂",1],["猫",1],["b",1],[" ",1],["c",2],["猫",1],["b",2],["a",1],["猫",1],[" ",1],["猫",1],["🙂",1],[" ",1],["... |
luhn-b0-s14 | luhn | baseline | 20,371,874 | 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": ["59844366786912478"], "expected":... | 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":["12"],"expected":false},{"args":["0000"],"expected":true},{"args":["49536860907827065"],"expected"... |
luhn-b1-s14 | luhn | wrong-parity | 20,371,874 | 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": ["46476930047989"], "expected": fa... | 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":["12"],"expected":false},{"args":["0000"],"expected":true},{"args":["49536860907827065"],"expected"... |
luhn-b2-s14 | luhn | wrong-reduction | 20,371,874 | 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": ["4656"], "expected": false}, {"ar... | 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":["12"],"expected":false},{"args":["0000"],"expected":true},{"args":["49536860907827065"],"expected"... |
luhn-b3-s14 | luhn | wrong-modulus | 20,371,874 | 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": ["066542137734"], "expected": fals... | 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":["12"],"expected":false},{"args":["0000"],"expected":true},{"args":["49536860907827065"],"expected"... |
edit-distance-b0-s14 | edit-distance | baseline | 20,371,874 | 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": ["a猫da猫dc", ""], "expected": 7}, {"args": ["bc猫猫cba", "abc猫猫cb"], "expected": 2}, {"args": ["cdcbcd猫d猫d", "aaccbc猫"], "expected": 7}] | 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":["a猫dbaba",""],"expected":7},{"args":["","acd猫aabd"],"expected":8},{"args":["bcd猫","abcc猫adc猫"],"expected":5},{"args":["","acd猫bbbd"],"expected":8},{"args":["cd",""],"expected":2},{"args":["猫c猫aa猫dbd","bb猫b... |
edit-distance-b1-s14 | edit-distance | row-boundary | 20,371,874 | 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": ["cbc猫da", "b"], "expected": 5}, {"args": ["a猫da猫dc", ""], "expected": 7}, {"args": ["猫猫ddbbaa猫", ""], "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 | 139 | [{"args":["",""],"expected":0},{"args":["kitten","sitting"],"expected":3},{"args":["猫","狗"],"expected":1},{"args":["a猫dbaba",""],"expected":7},{"args":["","acd猫aabd"],"expected":8},{"args":["bcd猫","abcc猫adc猫"],"expected":5},{"args":["","acd猫bbbd"],"expected":8},{"args":["cd",""],"expected":2},{"args":["猫c猫aa猫dbd","bb猫b... |
edit-distance-b2-s14 | edit-distance | inverted-substitution | 20,371,874 | 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": ["c猫c", "c猫c"], "expected": 0}, {"args": ["ca", "aad猫bddabcd"], "expected": 10}, {"args": ["ccd", "caccb猫"], "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":["a猫dbaba",""],"expected":7},{"args":["","acd猫aabd"],"expected":8},{"args":["bcd猫","abcc猫adc猫"],"expected":5},{"args":["","acd猫bbbd"],"expected":8},{"args":["cd",""],"expected":2},{"args":["猫c猫aa猫dbd","bb猫b... |
edit-distance-b3-s14 | edit-distance | diagonal-index | 20,371,874 | 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": ["abbab猫bac", ""], "expected": 9}, {"args": ["caadab猫db", "b猫"], "expected": 7}, {"args": ["bd猫dd猫ab", "c"], "expected": 8}] | 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":["a猫dbaba",""],"expected":7},{"args":["","acd猫aabd"],"expected":8},{"args":["bcd猫","abcc猫adc猫"],"expected":5},{"args":["","acd猫bbbd"],"expected":8},{"args":["cd",""],"expected":2},{"args":["猫c猫aa猫dbd","bb猫b... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.