id stringlengths 25 25 | kind stringclasses 1
value | title stringlengths 17 17 | provisional bool 1
class | output_code stringlengths 60 4.12k | input_data_sample stringlengths 3 637 | output_data_sample unknown | transformation_instruction stringlengths 54 1.91k |
|---|---|---|---|---|---|---|---|
cmsrbolnn003ne0p2a9nwbpz2 | contributor_item | Submission NWBPZ2 | false | import json, csv, io
def transform(text):
data = json.loads(text)
out = io.StringIO()
writer = csv.writer(out)
writer.writerow(['name', 'salary', 'bonus', 'total'])
for row in data:
bonus = round(row['salary'] * row['bonus_pct'])
total = row['salary'] + bonus
writer.writerow... | [{"name": "Alice", "salary": 75000, "bonus_pct": 0.1}, {"name": "Bob", "salary": 90000, "bonus_pct": 0.15}, {"name": "Carol", "salary": 60000, "bonus_pct": 0.08}] | "name,salary,bonus,total\r\nAlice,75000,7500,82500\r\nBob,90000,13500,103500\r\nCarol,60000,4800,64800" | Read a JSON array of employee records and output a CSV with headers name, salary, bonus, total. Bonus is salary * bonus_pct (rounded to integer). Total is salary + bonus. |
cmsrbolnn003qe0p2xjgrak2q | contributor_item | Submission GRAK2Q | false | import json
def transform(text):
data = json.loads(text)
seen = set()
result = []
for item in data:
if item not in seen:
seen.add(item)
result.append(item)
return json.dumps(result) | [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] | [
3,
1,
4,
5,
9,
2,
6
] | Deduplicate a JSON array of integers, preserving the first occurrence of each value, and return the result as a JSON array. |
cmsrbolnn003ce0p2eou0bfqb | contributor_item | Submission U0BFQB | false | import re
def transform(text):
results = []
for line in text.strip().split('\n'):
digits = re.sub(r'\D', '', line)
if len(digits) == 11 and digits.startswith('1'):
results.append(f'+{digits}')
elif len(digits) == 10:
results.append(f'+1{digits}')
return '\n'.... | +1 (555) 123-4567
555.987.6543
(800) 555-0100
5550001234 | "+15551234567\n+15559876543\n+18005550100\n+15550001234" | Normalize US phone numbers to E.164 format (+1XXXXXXXXXX), stripping all non-digit characters and prepending +1 for 10-digit numbers. |
cmsrbolnn003le0p2p0tsknz7 | contributor_item | Submission TSKNZ7 | false | import json
def transform(text):
tasks = []
for line in text.strip().split('\n'):
line = line.strip()
if line.startswith('- ['):
done = line[3] == 'x'
title = line[6:].strip()
tasks.append({"title": title, "done": done})
return json.dumps(tasks) | - [x] Buy groceries
- [ ] Write documentation
- [x] Fix bug #123
- [ ] Deploy to production | [
{
"title": "Buy groceries",
"done": true
},
{
"title": "Write documentation",
"done": false
},
{
"title": "Fix bug #123",
"done": true
},
{
"title": "Deploy to production",
"done": false
}
] | Parse a Markdown-style task list and return a JSON array of objects with 'title' (string) and 'done' (boolean) fields. |
cmsrbolnn003ee0p2tvu538ul | contributor_item | Submission U538UL | false | def transform(text):
domains = sorted(set(
line.strip().split('@')[1]
for line in text.strip().split('\n')
if '@' in line.strip()
))
return '\n'.join(domains) | alice@example.com
bob@company.org
carol@example.com
dave@university.edu
eve@company.org | "company.org\nexample.com\nuniversity.edu" | Extract unique domain names from a list of email addresses and return them sorted alphabetically, one per line. |
cmsrbolnn003de0p292m4h2e7 | contributor_item | Submission M4H2E7 | false | import json
def transform(text):
result = {}
section = None
for line in text.strip().split('\n'):
line = line.strip()
if not line or line.startswith(';'):
continue
if line.startswith('[') and line.endswith(']'):
section = line[1:-1]
result[section... | [database]
host=localhost
port=5432
name=mydb
[cache]
host=redis
port=6379
ttl=3600 | {
"database": {
"host": "localhost",
"port": "5432",
"name": "mydb"
},
"cache": {
"host": "redis",
"port": "6379",
"ttl": "3600"
}
} | Parse an INI-style configuration file into a nested JSON object where each section becomes a key and its entries become key-value pairs. |
cmsrbolnn003fe0p2a0uj4yf4 | contributor_item | Submission UJ4YF4 | false | import json, re
from collections import Counter
def transform(text):
methods = Counter(
re.search(r'"(\w+) ', line).group(1)
for line in text.strip().split('\n')
if line.strip()
)
return json.dumps(dict(sorted(methods.items()))) | 192.168.1.1 - - [01/Aug/2026:10:00:01 +0000] "GET /api/users HTTP/1.1" 200 1234
192.168.1.2 - - [01/Aug/2026:10:00:02 +0000] "POST /api/users HTTP/1.1" 201 567
192.168.1.1 - - [01/Aug/2026:10:00:03 +0000] "GET /api/items HTTP/1.1" 200 890
192.168.1.3 - - [01/Aug/2026:10:00:04 +0000] "DELETE /api/users/5 HTTP/1.1" 204 0... | {
"DELETE": 1,
"GET": 3,
"POST": 1
} | Parse Apache-style access log lines and return a JSON object counting requests by HTTP method, sorted alphabetically by method name. |
cmsrbolnn003he0p2stll75ms | contributor_item | Submission LL75MS | false | import json
from collections import Counter
def transform(text):
words = text.strip().lower().split()
top3 = dict(Counter(words).most_common(3))
return json.dumps(top3) | apple banana apple cherry banana apple cherry cherry cherry banana | {
"cherry": 4,
"apple": 3,
"banana": 3
} | Count word frequency in the input text and return a JSON object with the top 3 most frequent words mapped to their counts. |
cmsrbolnn003je0p26doib6mg | contributor_item | Submission OIB6MG | false | import json
def transform(text):
result = {}
for line in text.strip().split('\n'):
if '=' in line:
k, _, v = line.partition('=')
k = k.strip()
if k.startswith('app_'):
result[k[4:]] = v.strip()
return json.dumps(result) | app_name=MyApp
app_version=1.2.3
db_host=localhost
db_port=5432
app_debug=true | {
"name": "MyApp",
"version": "1.2.3",
"debug": "true"
} | Extract only the key=value pairs whose keys start with 'app_', strip the prefix, and return the remaining pairs as a JSON object. |
cmsrbolnn003ie0p2iu25l5e8 | contributor_item | Submission 25L5E8 | false | def transform(text):
return '\n'.join(
'|'.join(line.split('\t'))
for line in text.strip().split('\n')
) | Name Age City
Alice 30 New York
Bob 25 San Francisco | "Name|Age|City\nAlice|30|New York\nBob|25|San Francisco" | Convert a tab-delimited string to a pipe-delimited string, preserving all rows and columns. |
cmsrbolnn003se0p2w6swflp8 | contributor_item | Submission SWFLP8 | false | import json
def transform(text):
data = json.loads(text)
lines = []
for k, v in data.items():
if isinstance(v, bool):
lines.append(f"{k}: {'true' if v else 'false'}")
else:
lines.append(f"{k}: {v}")
return '\n'.join(lines) | {"host": "localhost", "port": 5432, "database": "myapp", "ssl": true} | "host: localhost\nport: 5432\ndatabase: myapp\nssl: true" | Convert a flat JSON object to a YAML-style text representation with one key: value pair per line. Boolean values should appear as 'true' or 'false' (lowercase). |
cmsrbolnn003re0p2d6jjtxfy | contributor_item | Submission JJTXFY | false | import csv, io, json
from collections import defaultdict
def transform(text):
reader = csv.DictReader(io.StringIO(text.strip()), delimiter='\t')
totals = defaultdict(int)
for row in reader:
totals[row['Region']] += int(row['Sales'])
return json.dumps(dict(sorted(totals.items()))) | Region Product Sales
North Widget 500
South Gadget 300
North Gadget 700
South Widget 400
East Widget 200
North Widget 300 | {
"East": 200,
"North": 1500,
"South": 700
} | Parse a tab-separated sales report and return a JSON object mapping each region to its total sales, sorted alphabetically by region name. |
cmsrbolnn003pe0p2tvq6z9s9 | contributor_item | Submission Q6Z9S9 | false | import re
def transform(text):
def parse_duration(s):
total = 0
m = re.search(r'(\d+)h', s)
if m: total += int(m.group(1)) * 3600
m = re.search(r'(\d+)m', s)
if m: total += int(m.group(1)) * 60
m = re.search(r'(\d+)s', s)
if m: total += int(m.group(1))
... | 1h 30m 45s
2h 15m
45m 30s
1h | "5445\n8100\n2730\n3600" | Convert duration strings (e.g. '1h 30m 45s') to total seconds. Each line is one duration; output one integer per line. |
cmsrcbdop001oq2p2xec70g90 | contributor_item | Submission C70G90 | false | import json
def transform(text):
d=json.loads(text); out={}
for r in d['transactions']: out[r['account']]=out.get(r['account'],0)+r['amount']
return json.dumps(dict(sorted(out.items())),separators=(',',':'))
# scenario 0 | {"transactions":[{"account":"A","amount":5},{"account":"B","amount":3},{"account":"A","amount":-2}],"batch":0} | {
"A": 3,
"B": 3
} | Aggregate JSON transactions by account and return compact sorted JSON balances. Scenario family 1. |
cmsrcbdop0026q2p20le9l1n5 | contributor_item | Submission E9L1N5 | false | import json
def transform(text):
d={}
for line in text.strip().splitlines():
u,r=line.split('|'); d.setdefault(u,set()).add(r)
return json.dumps({u:sorted(d[u]) for u in sorted(d)},separators=(',',':'))
# scenario 3 | alice|admin
bob|viewer
alice|editor
bob|viewer | {
"alice": [
"admin",
"editor"
],
"bob": [
"viewer"
]
} | Parse pipe-delimited user,role rows, deduplicate roles, and return compact sorted JSON. Scenario family 4. |
cmsrcbdop001wq2p2cwvto3az | contributor_item | Submission VTO3AZ | false | import json
def transform(text):
d={}
for line in text.strip().splitlines():
u,r=line.split('|'); d.setdefault(u,set()).add(r)
return json.dumps({u:sorted(d[u]) for u in sorted(d)},separators=(',',':'))
# scenario 1 | alice|admin
bob|viewer
alice|editor
bob|viewer | {
"alice": [
"admin",
"editor"
],
"bob": [
"viewer"
]
} | Parse pipe-delimited user,role rows, deduplicate roles, and return compact sorted JSON. Scenario family 2. |
cmsrcbdop001xq2p2kijzijp2 | contributor_item | Submission JZIJP2 | false | import json
def transform(text):
a=json.loads(text)['values']; return json.dumps({'min':min(a),'max':max(a),'sum':sum(a),'mean':round(sum(a)/len(a),2)},separators=(',',':'))
# scenario 1 | {"values":[4,9,2,5],"batch":1} | {
"min": 2,
"max": 9,
"sum": 20,
"mean": 5
} | From JSON integer values, return compact JSON containing min, max, sum, and rounded mean. Scenario family 2. |
cmsrcbdop0027q2p2ikksv03o | contributor_item | Submission KSV03O | false | import json
def transform(text):
a=json.loads(text)['values']; return json.dumps({'min':min(a),'max':max(a),'sum':sum(a),'mean':round(sum(a)/len(a),2)},separators=(',',':'))
# scenario 3 | {"values":[4,9,2,5],"batch":3} | {
"min": 2,
"max": 9,
"sum": 20,
"mean": 5
} | From JSON integer values, return compact JSON containing min, max, sum, and rounded mean. Scenario family 4. |
cmsrcbdop001qq2p2vdj95w06 | contributor_item | Submission J95W06 | false | import json
def transform(text):
d=json.loads(text); rows=sorted((r for r in d['records'] if r['score']>=d['threshold']),key=lambda r:r['id'])
return json.dumps([{'id':r['id'],'name':r['name']} for r in rows],separators=(',',':'))
# scenario 0 | {"threshold":7,"records":[{"id":3,"name":"C","score":8},{"id":1,"name":"A","score":6},{"id":2,"name":"B","score":9}],"batch":0} | [
{
"id": 2,
"name": "B"
},
{
"id": 3,
"name": "C"
}
] | Filter JSON records whose score meets threshold, sort by id, and return id/name pairs as compact JSON. Scenario family 1. |
cmsrcbdop001pq2p2f759yejl | contributor_item | Submission 59YEJL | false | import csv,io,json
def transform(text):
out={}
for r in csv.DictReader(io.StringIO(text)): out[r['category']]=out.get(r['category'],0)+int(r['value'])
return json.dumps(dict(sorted(out.items())),separators=(',',':'))
# scenario 0 | category,value
x,5
y,2
x,4
z,1 | {
"x": 9,
"y": 2,
"z": 1
} | Parse CSV category,value rows and return compact JSON totals sorted by category. Scenario family 1. |
cmsrcbdop001rq2p2ncqk7xm7 | contributor_item | Submission QK7XM7 | false | import json
def transform(text):
d={}
for line in text.strip().splitlines():
u,r=line.split('|'); d.setdefault(u,set()).add(r)
return json.dumps({u:sorted(d[u]) for u in sorted(d)},separators=(',',':'))
# scenario 0 | alice|admin
bob|viewer
alice|editor
bob|viewer | {
"alice": [
"admin",
"editor"
],
"bob": [
"viewer"
]
} | Parse pipe-delimited user,role rows, deduplicate roles, and return compact sorted JSON. Scenario family 1. |
cmsrcbdop001uq2p2rwwzsvcc | contributor_item | Submission WZSVCC | false | import csv,io,json
def transform(text):
out={}
for r in csv.DictReader(io.StringIO(text)): out[r['category']]=out.get(r['category'],0)+int(r['value'])
return json.dumps(dict(sorted(out.items())),separators=(',',':'))
# scenario 1 | category,value
x,5
y,2
x,4
z,1
| {
"x": 9,
"y": 2,
"z": 1
} | Parse CSV category,value rows and return compact JSON totals sorted by category. Scenario family 2. |
cmsrcbdop001sq2p244kta64f | contributor_item | Submission KTA64F | false | import json
def transform(text):
a=json.loads(text)['values']; return json.dumps({'min':min(a),'max':max(a),'sum':sum(a),'mean':round(sum(a)/len(a),2)},separators=(',',':'))
# scenario 0 | {"values":[4,9,2,5],"batch":0} | {
"min": 2,
"max": 9,
"sum": 20,
"mean": 5
} | From JSON integer values, return compact JSON containing min, max, sum, and rounded mean. Scenario family 1. |
cmsrcbdop001vq2p2bn1yrznr | contributor_item | Submission 1YRZNR | false | import json
def transform(text):
d=json.loads(text); rows=sorted((r for r in d['records'] if r['score']>=d['threshold']),key=lambda r:r['id'])
return json.dumps([{'id':r['id'],'name':r['name']} for r in rows],separators=(',',':'))
# scenario 1 | {"threshold":7,"records":[{"id":3,"name":"C","score":8},{"id":1,"name":"A","score":6},{"id":2,"name":"B","score":9}],"batch":1} | [
{
"id": 2,
"name": "B"
},
{
"id": 3,
"name": "C"
}
] | Filter JSON records whose score meets threshold, sort by id, and return id/name pairs as compact JSON. Scenario family 2. |
cmsrcbdop001tq2p2gnxamvf1 | contributor_item | Submission XAMVF1 | false | import json
def transform(text):
d=json.loads(text); out={}
for r in d['transactions']: out[r['account']]=out.get(r['account'],0)+r['amount']
return json.dumps(dict(sorted(out.items())),separators=(',',':'))
# scenario 1 | {"transactions":[{"account":"A","amount":5},{"account":"B","amount":3},{"account":"A","amount":-2}],"batch":1} | {
"A": 3,
"B": 3
} | Aggregate JSON transactions by account and return compact sorted JSON balances. Scenario family 2. |
cmsrcbdop001yq2p2h35x64eo | contributor_item | Submission 5X64EO | false | import json
def transform(text):
d=json.loads(text); out={}
for r in d['transactions']: out[r['account']]=out.get(r['account'],0)+r['amount']
return json.dumps(dict(sorted(out.items())),separators=(',',':'))
# scenario 2 | {"transactions":[{"account":"A","amount":5},{"account":"B","amount":3},{"account":"A","amount":-2}],"batch":2} | {
"A": 3,
"B": 3
} | Aggregate JSON transactions by account and return compact sorted JSON balances. Scenario family 3. |
cmsrcbdop001zq2p2ndj1hup0 | contributor_item | Submission J1HUP0 | false | import csv,io,json
def transform(text):
out={}
for r in csv.DictReader(io.StringIO(text)): out[r['category']]=out.get(r['category'],0)+int(r['value'])
return json.dumps(dict(sorted(out.items())),separators=(',',':'))
# scenario 2 | category,value
x,5
y,2
x,4
z,1 | {
"x": 9,
"y": 2,
"z": 1
} | Parse CSV category,value rows and return compact JSON totals sorted by category. Scenario family 3. |
cmsrcbdop0022q2p2x6oxcbn0 | contributor_item | Submission OXCBN0 | false | import json
def transform(text):
a=json.loads(text)['values']; return json.dumps({'min':min(a),'max':max(a),'sum':sum(a),'mean':round(sum(a)/len(a),2)},separators=(',',':'))
# scenario 2 | {"values":[4,9,2,5],"batch":2} | {
"min": 2,
"max": 9,
"sum": 20,
"mean": 5
} | From JSON integer values, return compact JSON containing min, max, sum, and rounded mean. Scenario family 3. |
cmsrcbdop0023q2p2s43im90q | contributor_item | Submission 3IM90Q | false | import json
def transform(text):
d=json.loads(text); out={}
for r in d['transactions']: out[r['account']]=out.get(r['account'],0)+r['amount']
return json.dumps(dict(sorted(out.items())),separators=(',',':'))
# scenario 3 | {"transactions":[{"account":"A","amount":5},{"account":"B","amount":3},{"account":"A","amount":-2}],"batch":3} | {
"A": 3,
"B": 3
} | Aggregate JSON transactions by account and return compact sorted JSON balances. Scenario family 4. |
cmsrcbdop0020q2p21ornbw3p | contributor_item | Submission RNBW3P | false | import json
def transform(text):
d=json.loads(text); rows=sorted((r for r in d['records'] if r['score']>=d['threshold']),key=lambda r:r['id'])
return json.dumps([{'id':r['id'],'name':r['name']} for r in rows],separators=(',',':'))
# scenario 2 | {"threshold":7,"records":[{"id":3,"name":"C","score":8},{"id":1,"name":"A","score":6},{"id":2,"name":"B","score":9}],"batch":2} | [
{
"id": 2,
"name": "B"
},
{
"id": 3,
"name": "C"
}
] | Filter JSON records whose score meets threshold, sort by id, and return id/name pairs as compact JSON. Scenario family 3. |
cmsrcbdop0021q2p2tcrlc9kx | contributor_item | Submission RLC9KX | false | import json
def transform(text):
d={}
for line in text.strip().splitlines():
u,r=line.split('|'); d.setdefault(u,set()).add(r)
return json.dumps({u:sorted(d[u]) for u in sorted(d)},separators=(',',':'))
# scenario 2 | alice|admin
bob|viewer
alice|editor
bob|viewer | {
"alice": [
"admin",
"editor"
],
"bob": [
"viewer"
]
} | Parse pipe-delimited user,role rows, deduplicate roles, and return compact sorted JSON. Scenario family 3. |
cmsrcbdop0025q2p25exc66kk | contributor_item | Submission XC66KK | false | import json
def transform(text):
d=json.loads(text); rows=sorted((r for r in d['records'] if r['score']>=d['threshold']),key=lambda r:r['id'])
return json.dumps([{'id':r['id'],'name':r['name']} for r in rows],separators=(',',':'))
# scenario 3 | {"threshold":7,"records":[{"id":3,"name":"C","score":8},{"id":1,"name":"A","score":6},{"id":2,"name":"B","score":9}],"batch":3} | [
{
"id": 2,
"name": "B"
},
{
"id": 3,
"name": "C"
}
] | Filter JSON records whose score meets threshold, sort by id, and return id/name pairs as compact JSON. Scenario family 4. |
cmsrcbdop0024q2p2okbjg5ao | contributor_item | Submission BJG5AO | false | import csv,io,json
def transform(text):
out={}
for r in csv.DictReader(io.StringIO(text)): out[r['category']]=out.get(r['category'],0)+int(r['value'])
return json.dumps(dict(sorted(out.items())),separators=(',',':'))
# scenario 3 | category,value
x,5
y,2
x,4
z,1
| {
"x": 9,
"y": 2,
"z": 1
} | Parse CSV category,value rows and return compact JSON totals sorted by category. Scenario family 4. |
cmsrfjxi00028y8p25oonp7tg | contributor_item | Submission ONP7TG | false | import csv, io, json
from collections import defaultdict
def transform(text):
agg=defaultdict(lambda:{'count':0,'total':0})
for r in csv.DictReader(io.StringIO(text)):
d=agg[r['dept']]; d['count']+=1; d['total']+=int(r['amount'])
return json.dumps(dict(sorted(agg.items())), sort_keys=True) | dept,amount
eng,120
sales,80
eng,30
sales,20
ops,50 | {
"eng": {
"count": 2,
"total": 150
},
"ops": {
"count": 1,
"total": 50
},
"sales": {
"count": 2,
"total": 100
}
} | Parse the CSV and return a JSON object keyed by department with row count and total amount; keys must be sorted alphabetically. |
cmsrfjxi00029y8p2g5gpej2b | contributor_item | Submission GPEJ2B | false | import json
def transform(text):
rows=json.loads(text)
rows=[{'id':r['id'],'score':r['score']} for r in rows if r.get('active') and r['score']>=10]
rows.sort(key=lambda r:(-r['score'],r['id']))
return json.dumps(rows) | [{"id":"a","score":7,"active":true},{"id":"b","score":12,"active":false},{"id":"c","score":10,"active":true},{"id":"d","score":12,"active":true}] | [
{
"id": "d",
"score": 12
},
{
"id": "c",
"score": 10
}
] | From the JSON array, keep active records with score at least 10, sort by descending score then id, and return only id and score as JSON. |
cmsrfjxi0002ay8p21dhdbfy7 | contributor_item | Submission HDBFY7 | false | import urllib.parse, json
def transform(text):
pairs=urllib.parse.parse_qsl(text, keep_blank_values=True)
out={}
for k,v in pairs:
out.setdefault(k,[])
if v not in out[k]: out[k].append(v)
return json.dumps({k:out[k] for k in sorted(out)}) | tag=red&tag=blue&owner=ada&tag=red&priority=high | {
"owner": [
"ada"
],
"priority": [
"high"
],
"tag": [
"red",
"blue"
]
} | Parse the query string, preserve repeated values, deduplicate each key's values in first-seen order, and return a JSON object with alphabetically sorted keys. |
cmsrfjxi0002by8p2musib9ww | contributor_item | Submission SIB9WW | false | import json
def transform(text):
out={}
for line in text.strip().splitlines():
k,v=line.split('|'); v=int(v)
out[k]=max(out.get(k,v),v)
return json.dumps(dict(sorted(out.items()))) | alpha|7
beta|3
alpha|11
beta|9
gamma|4 | {
"alpha": 11,
"beta": 9,
"gamma": 4
} | Parse pipe-delimited name/value rows and return a JSON object containing the maximum value observed for each name, sorted by name. |
cmsrfjxi0002cy8p2aemunyr2 | contributor_item | Submission MUNYR2 | false | import json
from collections import defaultdict
def transform(text):
agg=defaultdict(lambda:defaultdict(int))
for line in text.strip().splitlines():
day,svc,count=line.split(','); agg[day][svc]+=int(count)
out={d:{s:agg[d][s] for s in sorted(agg[d])} for d in sorted(agg)}
return json.dumps(out) | 2026-08-13,api,4
2026-08-13,worker,2
2026-08-14,api,3
2026-08-14,worker,5
2026-08-14,api,1 | {
"2026-08-13": {
"api": 4,
"worker": 2
},
"2026-08-14": {
"api": 4,
"worker": 5
}
} | Parse date,service,count rows and return JSON totals per date, with nested service totals and dates/services sorted lexicographically. |
cmsrh2ffl008uy8p2o8shm13n | contributor_item | Submission SHM13N | false | import json
# scenario_19
def transform(text):
n=[int(x) for x in text.split(",")];k=2
return json.dumps([sum(n[i:i+k]) for i in range(len(n)-k+1)],separators=(",",":")) | 4,6,4,6,9 | [
10,
10,
10,
15
] | Parse CSV integers and compute width-2 consecutive sums (scenario_19). |
cmsrh2ffl008ey8p2bgf659cy | contributor_item | Submission F659CY | false | import json
# scenario_3
def transform(text):
rows=json.loads(text)
return json.dumps([{"id":r["id"],"score":r["score"]} for r in rows if r["active"] and r["score"]>=30],separators=(",",":")) | [{"id":"a2","score":26,"active":true},{"id":"b2","score":37,"active":true},{"id":"c2","score":35,"active":true}] | [
{
"id": "b2",
"score": 37
},
{
"id": "c2",
"score": 35
}
] | Filter active JSON rows at score >= 30, project id and score, preserve order (scenario_3). |
cmsrh2ffl008jy8p2nwilxu1i | contributor_item | Submission ILXU1I | false | import json
from collections import defaultdict
# scenario_8
def transform(text):
t=defaultdict(int)
for r in json.loads(text): t[r["region"]]+=r["units"]*r["price"]
return json.dumps(dict(sorted(t.items())),separators=(",",":")) | [{"region":"east","units":5,"price":10},{"region":"other","units":2,"price":9},{"region":"east","units":1,"price":14}] | {
"east": 64,
"other": 18
} | Aggregate sales by region as units*price and key-sort compact JSON (scenario_8). |
cmsrh2ffl008xy8p21w9jsv9z | contributor_item | Submission 9JSV9Z | false | import json
from collections import defaultdict
# scenario_22
def transform(text):
t=defaultdict(int)
for l in text.splitlines():
k,x=l.split("|",1);t[k]+=int(x)
return json.dumps(dict(sorted(t.items())),separators=(",",":")) | alpha|3
beta|4
alpha|3 | {
"alpha": 6,
"beta": 4
} | Parse key|integer lines, sum repeated keys, sort keys (scenario_22). |
cmsrh2ffm009ky8p27fs1w23e | contributor_item | Submission S1W23E | false | import json
# scenario_45
def transform(text):
d=json.loads(text);k="zone"
return json.dumps([{"id":u["id"],k:u["profile"][k]} for u in d["users"]],separators=(",",":")) | {"users":[{"id":1,"profile":{"zone":"v4a","extra":9}},{"id":2,"profile":{"zone":"v4b","extra":8}}]} | [
{
"id": 1,
"zone": "v4a"
},
{
"id": 2,
"zone": "v4b"
}
] | Extract id and nested profile.zone from users (scenario_45). |
cmsrh2ffl0093y8p2oygpdrwx | contributor_item | Submission GPDRWX | false | # scenario_28
def transform(text):
seen=set();out=[]
for w in text.splitlines():
k=w.casefold()
if k not in seen: seen.add(k);out.append(w)
return "\n".join(out) | Alpha2
BETA
alpha2
Gamma
beta
GAMMA
Delta2 | "Alpha2\nBETA\nGamma\nDelta2" | Deduplicate tokens case-insensitively, retaining first spelling/order (scenario_28). |
cmsrh2ffl008zy8p2o881hrod | contributor_item | Submission 81HROD | false | import json
from collections import defaultdict
# scenario_24
def transform(text):
t=defaultdict(int)
for l in text.splitlines():
k,x=l.split("~",1);t[k]+=int(x)
return json.dumps(dict(sorted(t.items())),separators=(",",":")) | alpha~5
beta~2
alpha~3 | {
"alpha": 8,
"beta": 2
} | Parse key~integer lines, sum repeated keys, sort keys (scenario_24). |
cmsrh2ffl0098y8p22ggli1aq | contributor_item | Submission GLI1AQ | false | import json,re
# scenario_33
def transform(text):
out=[]
for l in text.splitlines():
h,m,s=map(int,re.fullmatch(r"(\d+)h (\d+)m (\d+)s",l).groups());out.append(h*3600+m*60+s)
return json.dumps(out,separators=(",",":")) | 3h 22m 30s
0h 7m 45s
2h 0m 12s | [
12150,
465,
7212
] | Convert required h/m/s duration lines to JSON seconds (scenario_33). |
cmsrh2ffm009my8p25qbhf33n | contributor_item | Submission BHF33N | false | import json
# scenario_47
def transform(text):
r=json.loads(text);r.sort(key=lambda x:(-x["priority"],x["age"],x["name"]))
return json.dumps([{"name":x["name"],"priority":x["priority"]} for x in r[:3]],separators=(",",":")) | [{"name":"x1","priority":2,"age":5},{"name":"a1","priority":3,"age":2},{"name":"m1","priority":3,"age":7},{"name":"z1","priority":1,"age":1}] | [
{
"name": "a1",
"priority": 3
},
{
"name": "m1",
"priority": 3
},
{
"name": "x1",
"priority": 2
}
] | Select top 3 jobs by priority desc, age/name asc (scenario_47). |
cmsrh2ffl008fy8p2y2vk65bc | contributor_item | Submission VK65BC | false | import json
# scenario_4
def transform(text):
rows=json.loads(text)
return json.dumps([{"id":r["id"],"score":r["score"]} for r in rows if r["active"] and r["score"]>=35],separators=(",",":")) | [{"id":"a3","score":30,"active":true},{"id":"b3","score":40,"active":false},{"id":"c3","score":40,"active":true}] | [
{
"id": "c3",
"score": 40
}
] | Filter active JSON rows at score >= 35, project id and score, preserve order (scenario_4). |
cmsrh2ffl008cy8p2n47bomal | contributor_item | Submission 7BOMAL | false | import json
# scenario_1
def transform(text):
rows=json.loads(text)
return json.dumps([{"id":r["id"],"score":r["score"]} for r in rows if r["active"] and r["score"]>=20],separators=(",",":")) | [{"id":"a0","score":18,"active":true},{"id":"b0","score":31,"active":true},{"id":"c0","score":25,"active":true}] | [
{
"id": "b0",
"score": 31
},
{
"id": "c0",
"score": 25
}
] | Filter active JSON rows at score >= 20, project id and score, preserve order (scenario_1). |
cmsrh2ffl008dy8p2qbtwkq6a | contributor_item | Submission TWKQ6A | false | import json
# scenario_2
def transform(text):
rows=json.loads(text)
return json.dumps([{"id":r["id"],"score":r["score"]} for r in rows if r["active"] and r["score"]>=25],separators=(",",":")) | [{"id":"a1","score":22,"active":true},{"id":"b1","score":34,"active":false},{"id":"c1","score":30,"active":true}] | [
{
"id": "c1",
"score": 30
}
] | Filter active JSON rows at score >= 25, project id and score, preserve order (scenario_2). |
cmsrh2ffl008gy8p2wdottnh5 | contributor_item | Submission OTTNH5 | false | import json
# scenario_5
def transform(text):
rows=json.loads(text)
return json.dumps([{"id":r["id"],"score":r["score"]} for r in rows if r["active"] and r["score"]>=40],separators=(",",":")) | [{"id":"a4","score":34,"active":true},{"id":"b4","score":43,"active":true},{"id":"c4","score":45,"active":true}] | [
{
"id": "b4",
"score": 43
},
{
"id": "c4",
"score": 45
}
] | Filter active JSON rows at score >= 40, project id and score, preserve order (scenario_5). |
cmsrh2ffl008iy8p2g0l2osb9 | contributor_item | Submission L2OSB9 | false | import json
from collections import defaultdict
# scenario_7
def transform(text):
t=defaultdict(int)
for r in json.loads(text): t[r["region"]]+=r["units"]*r["price"]
return json.dumps(dict(sorted(t.items())),separators=(",",":")) | [{"region":"south","units":4,"price":10},{"region":"other","units":2,"price":8},{"region":"south","units":1,"price":13}] | {
"other": 16,
"south": 53
} | Aggregate sales by region as units*price and key-sort compact JSON (scenario_7). |
cmsrh2ffl008hy8p29hhgehlw | contributor_item | Submission HGEHLW | false | import json
from collections import defaultdict
# scenario_6
def transform(text):
t=defaultdict(int)
for r in json.loads(text): t[r["region"]]+=r["units"]*r["price"]
return json.dumps(dict(sorted(t.items())),separators=(",",":")) | [{"region":"north","units":3,"price":10},{"region":"other","units":2,"price":7},{"region":"north","units":1,"price":12}] | {
"north": 42,
"other": 14
} | Aggregate sales by region as units*price and key-sort compact JSON (scenario_6). |
cmsrh2ffl008my8p2jja9pq0t | contributor_item | Submission A9PQ0T | false | import json
# scenario_11
def transform(text):
d=json.loads(text);p="app_"
return json.dumps({k[len(p):]:v for k,v in d.items() if k.startswith(p)},separators=(",",":")) | {"app_name":"n0","app_limit":10,"ignore":0,"app_enabled":true} | {
"name": "n0",
"limit": 10,
"enabled": true
} | Select 'app_' JSON keys, strip the prefix, preserve values (scenario_11). |
cmsrh2ffl008ky8p22q85jzcy | contributor_item | Submission 85JZCY | false | import json
from collections import defaultdict
# scenario_9
def transform(text):
t=defaultdict(int)
for r in json.loads(text): t[r["region"]]+=r["units"]*r["price"]
return json.dumps(dict(sorted(t.items())),separators=(",",":")) | [{"region":"west","units":6,"price":10},{"region":"other","units":2,"price":10},{"region":"west","units":1,"price":15}] | {
"other": 20,
"west": 75
} | Aggregate sales by region as units*price and key-sort compact JSON (scenario_9). |
cmsrh2ffl008ny8p20e7dg4u8 | contributor_item | Submission 7DG4U8 | false | import json
# scenario_12
def transform(text):
d=json.loads(text);p="svc_"
return json.dumps({k[len(p):]:v for k,v in d.items() if k.startswith(p)},separators=(",",":")) | {"svc_name":"n1","svc_limit":11,"ignore":1,"svc_enabled":false} | {
"name": "n1",
"limit": 11,
"enabled": false
} | Select 'svc_' JSON keys, strip the prefix, preserve values (scenario_12). |
cmsrh2ffl008ly8p2zmgd84m3 | contributor_item | Submission GD84M3 | false | import json
from collections import defaultdict
# scenario_10
def transform(text):
t=defaultdict(int)
for r in json.loads(text): t[r["region"]]+=r["units"]*r["price"]
return json.dumps(dict(sorted(t.items())),separators=(",",":")) | [{"region":"central","units":7,"price":10},{"region":"other","units":2,"price":11},{"region":"central","units":1,"price":16}] | {
"central": 86,
"other": 22
} | Aggregate sales by region as units*price and key-sort compact JSON (scenario_10). |
cmsrh2ffl008ry8p2ewluehve | contributor_item | Submission LUEHVE | false | import json
# scenario_16
def transform(text):
n=[int(x) for x in text.split(",")];k=2
return json.dumps([sum(n[i:i+k]) for i in range(len(n)-k+1)],separators=(",",":")) | 1,3,7,0,9 | [
4,
10,
7,
9
] | Parse CSV integers and compute width-2 consecutive sums (scenario_16). |
cmsrh2ffl008qy8p2n7ns4tq3 | contributor_item | Submission NS4TQ3 | false | import json
# scenario_15
def transform(text):
d=json.loads(text);p="job_"
return json.dumps({k[len(p):]:v for k,v in d.items() if k.startswith(p)},separators=(",",":")) | {"job_name":"n4","job_limit":14,"ignore":4,"job_enabled":true} | {
"name": "n4",
"limit": 14,
"enabled": true
} | Select 'job_' JSON keys, strip the prefix, preserve values (scenario_15). |
cmsrh2ffl008py8p2vjpwsk7w | contributor_item | Submission PWSK7W | false | import json
# scenario_14
def transform(text):
d=json.loads(text);p="ui_"
return json.dumps({k[len(p):]:v for k,v in d.items() if k.startswith(p)},separators=(",",":")) | {"ui_name":"n3","ui_limit":13,"ignore":3,"ui_enabled":false} | {
"name": "n3",
"limit": 13,
"enabled": false
} | Select 'ui_' JSON keys, strip the prefix, preserve values (scenario_14). |
cmsrh2ffl008oy8p2h0c2r1sl | contributor_item | Submission C2R1SL | false | import json
# scenario_13
def transform(text):
d=json.loads(text);p="db_"
return json.dumps({k[len(p):]:v for k,v in d.items() if k.startswith(p)},separators=(",",":")) | {"db_name":"n2","db_limit":12,"ignore":2,"db_enabled":true} | {
"name": "n2",
"limit": 12,
"enabled": true
} | Select 'db_' JSON keys, strip the prefix, preserve values (scenario_13). |
cmsrh2ffl008sy8p2ury1v34n | contributor_item | Submission Y1V34N | false | import json
# scenario_17
def transform(text):
n=[int(x) for x in text.split(",")];k=3
return json.dumps([sum(n[i:i+k]) for i in range(len(n)-k+1)],separators=(",",":")) | 2,4,6,2,9 | [
12,
12,
17
] | Parse CSV integers and compute width-3 consecutive sums (scenario_17). |
cmsrh2ffl008ty8p2xar44vu9 | contributor_item | Submission R44VU9 | false | import json
# scenario_18
def transform(text):
n=[int(x) for x in text.split(",")];k=4
return json.dumps([sum(n[i:i+k]) for i in range(len(n)-k+1)],separators=(",",":")) | 3,5,5,4,9 | [
17,
23
] | Parse CSV integers and compute width-4 consecutive sums (scenario_18). |
cmsrh2ffl008vy8p2iylq1vuo | contributor_item | Submission LQ1VUO | false | import json
# scenario_20
def transform(text):
n=[int(x) for x in text.split(",")];k=3
return json.dumps([sum(n[i:i+k]) for i in range(len(n)-k+1)],separators=(",",":")) | 5,7,3,8,9 | [
15,
18,
20
] | Parse CSV integers and compute width-3 consecutive sums (scenario_20). |
cmsrh2ffl008yy8p28i2t95yy | contributor_item | Submission 2T95YY | false | import json
from collections import defaultdict
# scenario_23
def transform(text):
t=defaultdict(int)
for l in text.splitlines():
k,x=l.split(":",1);t[k]+=int(x)
return json.dumps(dict(sorted(t.items())),separators=(",",":")) | alpha:4
beta:3
alpha:3 | {
"alpha": 7,
"beta": 3
} | Parse key:integer lines, sum repeated keys, sort keys (scenario_23). |
cmsrh2ffl008wy8p2fyr9iyfr | contributor_item | Submission R9IYFR | false | import json
from collections import defaultdict
# scenario_21
def transform(text):
t=defaultdict(int)
for l in text.splitlines():
k,x=l.split("=",1);t[k]+=int(x)
return json.dumps(dict(sorted(t.items())),separators=(",",":")) | alpha=2
beta=5
alpha=3 | {
"alpha": 5,
"beta": 5
} | Parse key=integer lines, sum repeated keys, sort keys (scenario_21). |
cmsrh2ffl0091y8p2y3hqiu44 | contributor_item | Submission HQIU44 | false | # scenario_26
def transform(text):
seen=set();out=[]
for w in text.splitlines():
k=w.casefold()
if k not in seen: seen.add(k);out.append(w)
return "\n".join(out) | Alpha0
BETA
alpha0
Gamma
beta
GAMMA
Delta0 | "Alpha0\nBETA\nGamma\nDelta0" | Deduplicate tokens case-insensitively, retaining first spelling/order (scenario_26). |
cmsrh2ffl0090y8p20z0us7us | contributor_item | Submission 0US7US | false | import json
from collections import defaultdict
# scenario_25
def transform(text):
t=defaultdict(int)
for l in text.splitlines():
k,x=l.split(";",1);t[k]+=int(x)
return json.dumps(dict(sorted(t.items())),separators=(",",":")) | alpha;6
beta;1
alpha;3 | {
"alpha": 9,
"beta": 1
} | Parse key;integer lines, sum repeated keys, sort keys (scenario_25). |
cmsrh2ffl0092y8p234iw92m4 | contributor_item | Submission IW92M4 | false | # scenario_27
def transform(text):
seen=set();out=[]
for w in text.splitlines():
k=w.casefold()
if k not in seen: seen.add(k);out.append(w)
return "\n".join(out) | Alpha1
BETA
alpha1
Gamma
beta
GAMMA
Delta1 | "Alpha1\nBETA\nGamma\nDelta1" | Deduplicate tokens case-insensitively, retaining first spelling/order (scenario_27). |
cmsrh2ffl0096y8p20d453gnb | contributor_item | Submission 453GNB | false | import json,re
# scenario_31
def transform(text):
out=[]
for l in text.splitlines():
h,m,s=map(int,re.fullmatch(r"(\d+)h (\d+)m (\d+)s",l).groups());out.append(h*3600+m*60+s)
return json.dumps(out,separators=(",",":")) | 1h 20m 30s
0h 5m 45s
2h 0m 10s | [
4830,
345,
7210
] | Convert required h/m/s duration lines to JSON seconds (scenario_31). |
cmsrh2ffl0097y8p2nnt31vth | contributor_item | Submission T31VTH | false | import json,re
# scenario_32
def transform(text):
out=[]
for l in text.splitlines():
h,m,s=map(int,re.fullmatch(r"(\d+)h (\d+)m (\d+)s",l).groups());out.append(h*3600+m*60+s)
return json.dumps(out,separators=(",",":")) | 2h 21m 30s
0h 6m 45s
2h 0m 11s | [
8490,
405,
7211
] | Convert required h/m/s duration lines to JSON seconds (scenario_32). |
cmsrh2ffl0095y8p2auqwpn9a | contributor_item | Submission QWPN9A | false | # scenario_30
def transform(text):
seen=set();out=[]
for w in text.splitlines():
k=w.casefold()
if k not in seen: seen.add(k);out.append(w)
return "\n".join(out) | Alpha4
BETA
alpha4
Gamma
beta
GAMMA
Delta4 | "Alpha4\nBETA\nGamma\nDelta4" | Deduplicate tokens case-insensitively, retaining first spelling/order (scenario_30). |
cmsrh2ffl0094y8p23vncrtq7 | contributor_item | Submission NCRTQ7 | false | # scenario_29
def transform(text):
seen=set();out=[]
for w in text.splitlines():
k=w.casefold()
if k not in seen: seen.add(k);out.append(w)
return "\n".join(out) | Alpha3
BETA
alpha3
Gamma
beta
GAMMA
Delta3 | "Alpha3\nBETA\nGamma\nDelta3" | Deduplicate tokens case-insensitively, retaining first spelling/order (scenario_29). |
cmsrh2ffl009by8p2dpqcqv40 | contributor_item | Submission QCQV40 | false | import json
# scenario_36
def transform(text):
o={"low":0,"mid":0,"high":0}
for s in json.loads(text): o["low" if s<40 else "mid" if s<70 else "high"]+=1
return json.dumps(o,separators=(",",":")) | [22,45,68,75,99] | {
"low": 1,
"mid": 2,
"high": 2
} | Bucket scores below 40, 40-69, and >=70 (scenario_36). |
cmsrh2ffl0099y8p2h6huz69u | contributor_item | Submission HUZ69U | false | import json,re
# scenario_34
def transform(text):
out=[]
for l in text.splitlines():
h,m,s=map(int,re.fullmatch(r"(\d+)h (\d+)m (\d+)s",l).groups());out.append(h*3600+m*60+s)
return json.dumps(out,separators=(",",":")) | 4h 23m 30s
0h 8m 45s
2h 0m 13s | [
15810,
525,
7213
] | Convert required h/m/s duration lines to JSON seconds (scenario_34). |
cmsrh2ffl009ay8p269bhuwxd | contributor_item | Submission BHUWXD | false | import json,re
# scenario_35
def transform(text):
out=[]
for l in text.splitlines():
h,m,s=map(int,re.fullmatch(r"(\d+)h (\d+)m (\d+)s",l).groups());out.append(h*3600+m*60+s)
return json.dumps(out,separators=(",",":")) | 5h 24m 30s
0h 9m 45s
2h 0m 14s | [
19470,
585,
7214
] | Convert required h/m/s duration lines to JSON seconds (scenario_35). |
cmsrh2ffl009cy8p2xdiz7d9a | contributor_item | Submission IZ7D9A | false | import json
# scenario_37
def transform(text):
o={"low":0,"mid":0,"high":0}
for s in json.loads(text): o["low" if s<41 else "mid" if s<71 else "high"]+=1
return json.dumps(o,separators=(",",":")) | [23,46,69,76,99] | {
"low": 1,
"mid": 2,
"high": 2
} | Bucket scores below 41, 41-70, and >=71 (scenario_37). |
cmsrh2ffl009dy8p2wj4c3rcc | contributor_item | Submission 4C3RCC | false | import json
# scenario_38
def transform(text):
o={"low":0,"mid":0,"high":0}
for s in json.loads(text): o["low" if s<42 else "mid" if s<72 else "high"]+=1
return json.dumps(o,separators=(",",":")) | [24,47,70,77,99] | {
"low": 1,
"mid": 2,
"high": 2
} | Bucket scores below 42, 42-71, and >=72 (scenario_38). |
cmsrh2ffl009fy8p2x0h423uo | contributor_item | Submission H423UO | false | import json
# scenario_40
def transform(text):
o={"low":0,"mid":0,"high":0}
for s in json.loads(text): o["low" if s<44 else "mid" if s<74 else "high"]+=1
return json.dumps(o,separators=(",",":")) | [26,49,72,79,99] | {
"low": 1,
"mid": 2,
"high": 2
} | Bucket scores below 44, 44-73, and >=74 (scenario_40). |
cmsrh2ffl009ey8p2a8xw28c9 | contributor_item | Submission XW28C9 | false | import json
# scenario_39
def transform(text):
o={"low":0,"mid":0,"high":0}
for s in json.loads(text): o["low" if s<43 else "mid" if s<73 else "high"]+=1
return json.dumps(o,separators=(",",":")) | [25,48,71,78,99] | {
"low": 1,
"mid": 2,
"high": 2
} | Bucket scores below 43, 43-72, and >=73 (scenario_39). |
cmsrh2ffm009iy8p2c093m5z5 | contributor_item | Submission 93M5Z5 | false | import json
# scenario_43
def transform(text):
d=json.loads(text);k="role"
return json.dumps([{"id":u["id"],k:u["profile"][k]} for u in d["users"]],separators=(",",":")) | {"users":[{"id":1,"profile":{"role":"v2a","extra":9}},{"id":2,"profile":{"role":"v2b","extra":8}}]} | [
{
"id": 1,
"role": "v2a"
},
{
"id": 2,
"role": "v2b"
}
] | Extract id and nested profile.role from users (scenario_43). |
cmsrh2ffm009hy8p2l0p3hb92 | contributor_item | Submission P3HB92 | false | import json
# scenario_42
def transform(text):
d=json.loads(text);k="city"
return json.dumps([{"id":u["id"],k:u["profile"][k]} for u in d["users"]],separators=(",",":")) | {"users":[{"id":1,"profile":{"city":"v1a","extra":9}},{"id":2,"profile":{"city":"v1b","extra":8}}]} | [
{
"id": 1,
"city": "v1a"
},
{
"id": 2,
"city": "v1b"
}
] | Extract id and nested profile.city from users (scenario_42). |
cmsrh2ffl009gy8p2pz9k0smu | contributor_item | Submission 9K0SMU | false | import json
# scenario_41
def transform(text):
d=json.loads(text);k="email"
return json.dumps([{"id":u["id"],k:u["profile"][k]} for u in d["users"]],separators=(",",":")) | {"users":[{"id":1,"profile":{"email":"v0a","extra":9}},{"id":2,"profile":{"email":"v0b","extra":8}}]} | [
{
"id": 1,
"email": "v0a"
},
{
"id": 2,
"email": "v0b"
}
] | Extract id and nested profile.email from users (scenario_41). |
cmsrh2ffm009jy8p2v3uth0lr | contributor_item | Submission UTH0LR | false | import json
# scenario_44
def transform(text):
d=json.loads(text);k="team"
return json.dumps([{"id":u["id"],k:u["profile"][k]} for u in d["users"]],separators=(",",":")) | {"users":[{"id":1,"profile":{"team":"v3a","extra":9}},{"id":2,"profile":{"team":"v3b","extra":8}}]} | [
{
"id": 1,
"team": "v3a"
},
{
"id": 2,
"team": "v3b"
}
] | Extract id and nested profile.team from users (scenario_44). |
cmsrh2ffm009ly8p23nuhijps | contributor_item | Submission UHIJPS | false | import json
# scenario_46
def transform(text):
r=json.loads(text);r.sort(key=lambda x:(-x["priority"],x["age"],x["name"]))
return json.dumps([{"name":x["name"],"priority":x["priority"]} for x in r[:2]],separators=(",",":")) | [{"name":"x0","priority":2,"age":5},{"name":"a0","priority":3,"age":2},{"name":"m0","priority":3,"age":7},{"name":"z0","priority":1,"age":1}] | [
{
"name": "a0",
"priority": 3
},
{
"name": "m0",
"priority": 3
}
] | Select top 2 jobs by priority desc, age/name asc (scenario_46). |
cmsrh2ffm009ny8p215wc0pto | contributor_item | Submission WC0PTO | false | import json
# scenario_48
def transform(text):
r=json.loads(text);r.sort(key=lambda x:(-x["priority"],x["age"],x["name"]))
return json.dumps([{"name":x["name"],"priority":x["priority"]} for x in r[:4]],separators=(",",":")) | [{"name":"x2","priority":2,"age":5},{"name":"a2","priority":3,"age":2},{"name":"m2","priority":3,"age":7},{"name":"z2","priority":1,"age":1}] | [
{
"name": "a2",
"priority": 3
},
{
"name": "m2",
"priority": 3
},
{
"name": "x2",
"priority": 2
},
{
"name": "z2",
"priority": 1
}
] | Select top 4 jobs by priority desc, age/name asc (scenario_48). |
cmsrh2ffm009oy8p2tsqq2a77 | contributor_item | Submission QQ2A77 | false | import json
# scenario_49
def transform(text):
r=json.loads(text);r.sort(key=lambda x:(-x["priority"],x["age"],x["name"]))
return json.dumps([{"name":x["name"],"priority":x["priority"]} for x in r[:2]],separators=(",",":")) | [{"name":"x3","priority":2,"age":5},{"name":"a3","priority":3,"age":2},{"name":"m3","priority":3,"age":7},{"name":"z3","priority":1,"age":1}] | [
{
"name": "a3",
"priority": 3
},
{
"name": "m3",
"priority": 3
}
] | Select top 2 jobs by priority desc, age/name asc (scenario_49). |
cmsrh2ffm009py8p2lmlmt5lo | contributor_item | Submission LMT5LO | false | import json
# scenario_50
def transform(text):
r=json.loads(text);r.sort(key=lambda x:(-x["priority"],x["age"],x["name"]))
return json.dumps([{"name":x["name"],"priority":x["priority"]} for x in r[:3]],separators=(",",":")) | [{"name":"x4","priority":2,"age":5},{"name":"a4","priority":3,"age":2},{"name":"m4","priority":3,"age":7},{"name":"z4","priority":1,"age":1}] | [
{
"name": "a4",
"priority": 3
},
{
"name": "m4",
"priority": 3
},
{
"name": "x4",
"priority": 2
}
] | Select top 3 jobs by priority desc, age/name asc (scenario_50). |
cmsrkbizf000hjmp26ydmu169 | contributor_item | Submission DMU169 | false | def transform(text):
totals = {}
for line in text.strip().split('\n'):
sku, qty, price = line.split(':')
totals[sku] = totals.get(sku, 0.0) + int(qty) * float(price)
ordered = sorted(totals.items(), key=lambda kv: (-kv[1], kv[0]))
return '\n'.join(f'{sku}={total:.2f}' for sku, total in o... | widget-a:3:2.50
widget-b:1:10.00
widget-a:2:2.50
gadget-x:5:1.20
| "widget-a=12.50\nwidget-b=10.00\ngadget-x=6.00" | Each line is 'sku:quantity:unit_price'. Compute the total revenue per SKU (quantity * unit_price summed across lines) and return lines of 'sku=total' formatted to 2 decimal places, sorted by total descending, then sku ascending. |
cmsrkbizf000fjmp2s195uzci | contributor_item | Submission 95UZCI | false | def transform(text):
counts = {}
for line in text.strip().split('\n'):
parts = line.split()
if len(parts) >= 2 and parts[1] == 'ERROR':
counts[parts[0]] = counts.get(parts[0], 0) + 1
rows = ['date,errors'] + [f'{d},{counts[d]}' for d in sorted(counts)]
return '\n'.join(rows) | 2026-01-15 ERROR db timeout
2026-01-15 INFO started
2026-01-16 ERROR disk full
2026-01-16 ERROR db timeout
2026-01-17 WARN slow query
| "date,errors\n2026-01-15,1\n2026-01-16,2" | Count ERROR lines per date and return a CSV string with header 'date,errors', one row per date that has at least one ERROR, sorted by date ascending. |
cmsrkbizf000djmp21irujzod | contributor_item | Submission RUJZOD | false | import json
def transform(text):
users = json.loads(text)
tag_map = {}
for user in users:
for tag in set(user['tags']):
tag_map.setdefault(tag, []).append(user['name'])
return json.dumps({t: sorted(tag_map[t]) for t in sorted(tag_map)}) | [{"name": "alice", "tags": ["admin", "dev"]}, {"name": "bob", "tags": []}, {"name": "carol", "tags": ["dev", "ops", "dev"]}] | {
"admin": [
"alice"
],
"dev": [
"alice",
"carol"
],
"ops": [
"carol"
]
} | Given a JSON array of users, return a JSON object mapping each distinct tag to the sorted list of user names that carry it. Ignore duplicate tags within a single user. Tags in the result must be sorted alphabetically. |
cmsrkbizf000cjmp288m3mynf | contributor_item | Submission M3MYNF | false | import csv, io, json
def transform(text):
totals = {}
for row in csv.DictReader(io.StringIO(text.strip())):
region = row['region']
totals[region] = totals.get(region, 0.0) + float(row['amount'])
return json.dumps({k: round(totals[k], 2) for k in sorted(totals)}) | id,region,amount
1,north,120.50
2,south,80
3,north,45.25
4,east,200
5,south,19.75
| {
"east": 200,
"north": 165.75,
"south": 99.75
} | Parse the CSV and return a JSON object mapping each region to its total amount (as a float), with regions sorted alphabetically. |
cmsrkbizf000ejmp2r85xx2h9 | contributor_item | Submission 5XX2H9 | false | def transform(text):
seen = []
for part in text.strip().split(';'):
email = part.strip().lower()
if email and email not in seen:
seen.append(email)
return '\n'.join(seen) | alice@example.com; Bob.Smith@Test.ORG ;carol@example.com;bob.smith@test.org;dan@sample.net
| "alice@example.com\nbob.smith@test.org\ncarol@example.com\ndan@sample.net" | Split the semicolon-separated email list, trim whitespace, lowercase every address, remove duplicates while keeping first-seen order, and return them joined by newlines. |
cmsrkbizf000gjmp2xzsq7r6h | contributor_item | Submission SQ7R6H | false | import json
def transform(text):
def flatten(obj, prefix=''):
out = {}
for k, v in obj.items():
key = f'{prefix}.{k}' if prefix else k
if isinstance(v, dict):
out.update(flatten(v, key))
else:
out[key] = v
return out
fl... | {"config": {"server": {"host": "localhost", "port": 8080}, "debug": true, "limits": {"max": 10}}} | {
"config.debug": true,
"config.limits.max": 10,
"config.server.host": "localhost",
"config.server.port": 8080
} | Flatten the nested JSON object into a single-level JSON object whose keys are dot-joined paths (e.g. 'config.server.host'). Keys in the result must be sorted alphabetically. |
cmsrkbizf000ijmp2fnw3pp5e | contributor_item | Submission W3PP5E | false | import json, re
from collections import Counter
def transform(text):
words = re.findall(r'[a-z]+', text.lower())
counts = Counter(words)
top = sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))[:3]
return json.dumps(dict(top)) | The quick brown fox. The lazy dog! A quick test? The FOX runs.
| {
"the": 3,
"fox": 2,
"quick": 2
} | Return a JSON object with the three most frequent words (case-insensitive, punctuation stripped), mapping word to count; break count ties alphabetically. |
cmsrkbizf000jjmp220njxzjw | contributor_item | Submission NJXZJW | false | import json
def transform(text):
readings = json.loads(text)
out = [{'ts': r['ts'], 'temp_c': round((r['temp_f'] - 32) * 5 / 9, 1)} for r in readings]
return json.dumps(out) | [{"ts": "2026-05-01T10:00:00", "temp_f": 68.0}, {"ts": "2026-05-01T11:00:00", "temp_f": 71.6}, {"ts": "2026-05-01T12:00:00", "temp_f": 75.2}] | [
{
"ts": "2026-05-01T10:00:00",
"temp_c": 20
},
{
"ts": "2026-05-01T11:00:00",
"temp_c": 22
},
{
"ts": "2026-05-01T12:00:00",
"temp_c": 24
}
] | Convert each reading's temp_f (Fahrenheit) to Celsius rounded to 1 decimal, rename the key to temp_c, keep ts unchanged, and return the JSON array. |
cmsrkbizf000ljmp2jn0gvz6g | contributor_item | Submission 0GVZ6G | false | import json
from collections import Counter
def transform(text):
nums = [int(x) for x in text.strip().split(',')]
counts = Counter(nums)
top = max(counts.values())
mode = min(v for v, c in counts.items() if c == top)
return json.dumps({'min': min(nums), 'max': max(nums), 'mean': round(sum(nums) / l... | 9,3,7,3,1,9,9,2
| {
"min": 1,
"max": 9,
"mean": 5.38,
"mode": 9,
"distinct": 5
} | Parse the comma-separated integers and return a JSON object with keys 'min', 'max', 'mean' (rounded to 2 decimals), 'mode' (smallest value if tied), and 'distinct' (count of unique values). |
cmsrkbizf000njmp21ljha7t7 | contributor_item | Submission JHA7T7 | false | import json
def transform(text):
data = json.loads(text)['employees']
groups = {}
for e in data:
groups.setdefault(e['dept'], []).append(e['salary'])
return json.dumps({d: {'count': len(s), 'avg_salary': round(sum(s) / len(s))} for d, s in sorted(groups.items())}) | {"employees": [{"name": "Ana", "dept": "eng", "salary": 95000}, {"name": "Raj", "dept": "sales", "salary": 70000}, {"name": "Mia", "dept": "eng", "salary": 105000}, {"name": "Leo", "dept": "sales", "salary": 64000}]} | {
"eng": {
"count": 2,
"avg_salary": 100000
},
"sales": {
"count": 2,
"avg_salary": 67000
}
} | Group employees by dept and return a JSON object mapping dept to {'count': n, 'avg_salary': average rounded to nearest integer}, with depts sorted alphabetically. |
cmsrkbizf000kjmp29ie6fwjc | contributor_item | Submission E6FWJC | false | import json
def transform(text):
lines = text.strip().split('\n')[1:]
result = {}
section = None
for line in lines:
line = line.strip()
if line.startswith('[') and line.endswith(']'):
section = line[1:-1]
result[section] = {}
elif '=' in line and section ... | INI
[database]
host = db.internal
port = 5432
[cache]
host = cache.internal
ttl = 300
| {
"database": {
"host": "db.internal",
"port": "5432"
},
"cache": {
"host": "cache.internal",
"ttl": "300"
}
} | Skip the first line, parse the INI-style sections and key = value pairs, and return a JSON object of {section: {key: value}} with all values kept as strings. Preserve section and key order as they appear. |
cmsrkbizf000mjmp2iqcdafqb | contributor_item | Submission CDAFQB | false | from collections import Counter
def transform(text):
paths = [line.split('?')[0] for line in text.strip().split('\n')]
counts = Counter(paths)
ordered = sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))
return '\n'.join(f'{p} {c}' for p, c in ordered) | /api/users?page=2
/api/users?page=3
/api/orders
/api/users?page=2
/health
/api/orders
| "/api/users 3\n/api/orders 2\n/health 1" | Strip query strings from each request path, count hits per bare path, and return lines of 'path count' sorted by count descending then path ascending. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.