items.jsonl

{"input": {"description": "Write a Python function `is_prime(n)` that returns True iff n is a prime number greater than 1."}, "expected_output": {"code": "def is_prime(n: int) -> bool:\n    if n < 2: return False\n    if n < 4: return True\n    if n % 2 == 0: return False\n    for i in range(3, int(n ** 0.5) + 1, 2):\n        if n % i == 0: return False\n    return True"}}
{"input": {"description": "Write a Python class `Stack` with push(x), pop(), peek(), and is_empty() methods."}, "expected_output": {"code": "class Stack:\n    def __init__(self):\n        self._items = []\n    def push(self, x):\n        self._items.append(x)\n    def pop(self):\n        return self._items.pop()\n    def peek(self):\n        return self._items[-1]\n    def is_empty(self) -> bool:\n        return len(self._items) == 0"}}
{"input": {"description": "Write a Python function `roman_to_int(s)` that converts a Roman numeral string to its integer value."}, "expected_output": {"code": "def roman_to_int(s: str) -> int:\n    values = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}\n    total = 0\n    prev = 0\n    for ch in reversed(s):\n        v = values[ch]\n        if v < prev: total -= v\n        else: total += v; prev = v\n    return total"}}
{"input": {"description": "Write a JavaScript function `debounce(fn, ms)` that returns a debounced version of fn."}, "expected_output": {"code": "function debounce(fn, ms) {\n  let timer = null;\n  return function(...args) {\n    if (timer) clearTimeout(timer);\n    timer = setTimeout(() => fn.apply(this, args), ms);\n  };\n}"}}
{"input": {"description": "Write a Python function `levenshtein(a, b)` that returns the edit distance between two strings."}, "expected_output": {"code": "def levenshtein(a: str, b: str) -> int:\n    if not a: return len(b)\n    if not b: return len(a)\n    prev = list(range(len(b) + 1))\n    for i, ca in enumerate(a, 1):\n        curr = [i] + [0] * len(b)\n        for j, cb in enumerate(b, 1):\n            cost = 0 if ca == cb else 1\n            curr[j] = min(curr[j-1] + 1, prev[j] + 1, prev[j-1] + cost)\n        prev = curr\n    return prev[-1]"}}
{"input": {"description": "Write a Python decorator `retry(times)` that retries the wrapped function up to `times` times on any exception."}, "expected_output": {"code": "import functools\n\ndef retry(times: int):\n    def decorator(fn):\n        @functools.wraps(fn)\n        def wrapper(*args, **kwargs):\n            last = None\n            for _ in range(times):\n                try:\n                    return fn(*args, **kwargs)\n                except Exception as e:\n                    last = e\n            raise last\n        return wrapper\n    return decorator"}}
{"input": {"description": "Write a Python function `flatten_deep(nested)` that flattens an arbitrarily nested list of lists into one flat list."}, "expected_output": {"code": "def flatten_deep(nested) -> list:\n    out = []\n    for x in nested:\n        if isinstance(x, list):\n            out.extend(flatten_deep(x))\n        else:\n            out.append(x)\n    return out"}}
{"input": {"description": "Write a SQL query that returns each user's longest streak of consecutive daily logins. Table: logins(user_id INT, login_date DATE)."}, "expected_output": {"code": "WITH grouped AS (\n  SELECT\n    user_id,\n    login_date,\n    login_date - (ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY login_date))::INT * INTERVAL '1 day' AS streak_grp\n  FROM logins\n)\nSELECT user_id, MAX(streak_len) AS longest_streak\nFROM (\n  SELECT user_id, streak_grp, COUNT(*) AS streak_len FROM grouped GROUP BY user_id, streak_grp\n) s\nGROUP BY user_id"}}
{"input": {"description": "Write a Python generator `chunked(it, size)` that yields successive chunks of size `size` from any iterable `it`."}, "expected_output": {"code": "def chunked(it, size: int):\n    buf = []\n    for x in it:\n        buf.append(x)\n        if len(buf) == size:\n            yield buf\n            buf = []\n    if buf:\n        yield buf"}}
{"input": {"description": "Write a Python function `binary_search(arr, target)` that returns the index of `target` in sorted `arr`, or -1 if not present."}, "expected_output": {"code": "def binary_search(arr: list[int], target: int) -> int:\n    lo, hi = 0, len(arr) - 1\n    while lo <= hi:\n        mid = (lo + hi) // 2\n        if arr[mid] == target:\n            return mid\n        if arr[mid] < target:\n            lo = mid + 1\n        else:\n            hi = mid - 1\n    return -1"}}