Spaces:
Runtime error
Runtime error
| """Per-task reference implementations. | |
| These are the *known-correct* solutions for each of the 15 tasks the OpenSleuth | |
| env exposes. They mirror the rows pushed to ``anugrah55/opensleuth-tasks`` by | |
| ``env/opensleuth_env/scripts/bootstrap_tasks_dataset.py`` (which itself mirrors | |
| the in-process oracle in ``env/opensleuth_env/black_box.py``). | |
| The "oracle" demo backend just looks up the task name here and submits the | |
| canonical source. It exists so the viewer can immediately see what a perfect | |
| score looks like end-to-end (signature → probes → submit → +100 reward). | |
| """ | |
| from __future__ import annotations | |
| from typing import Dict | |
| ORACLE_SOLUTIONS: Dict[str, str] = { | |
| # ---- 9 builtins ------------------------------------------------------- | |
| "fibonacci": ( | |
| "def fibonacci(n):\n" | |
| " if not isinstance(n, int) or isinstance(n, bool) or n <= 0 or n > 90:\n" | |
| " raise ValueError('Input must be a positive integer <= 90.')\n" | |
| " a, b = 0, 1\n" | |
| " for _ in range(n - 1):\n" | |
| " a, b = b, a + b\n" | |
| " return b if n > 0 else a\n" | |
| ), | |
| "reverse_string": ( | |
| "def reverse_string(s):\n" | |
| " if not isinstance(s, str):\n" | |
| " raise TypeError('Input must be a string.')\n" | |
| " return s[::-1]\n" | |
| ), | |
| "is_palindrome": ( | |
| "def is_palindrome(s):\n" | |
| " if not isinstance(s, str):\n" | |
| " raise TypeError('Input must be a string.')\n" | |
| " cleaned = ''.join(ch.lower() for ch in s if ch.isalnum())\n" | |
| " return cleaned == cleaned[::-1]\n" | |
| ), | |
| "digit_sum": ( | |
| "def digit_sum(n):\n" | |
| " if not isinstance(n, int) or isinstance(n, bool):\n" | |
| " raise TypeError('Input must be int.')\n" | |
| " if n < 0:\n" | |
| " raise ValueError('Input must be non-negative.')\n" | |
| " return sum(int(c) for c in str(n))\n" | |
| ), | |
| "count_vowels": ( | |
| "def count_vowels(s):\n" | |
| " if not isinstance(s, str):\n" | |
| " raise TypeError('Input must be a string.')\n" | |
| " return sum(1 for c in s.lower() if c in 'aeiou')\n" | |
| ), | |
| "gcd": ( | |
| "def gcd(pair):\n" | |
| " if not isinstance(pair, (list, tuple)) or len(pair) != 2:\n" | |
| " raise TypeError('Input must be a 2-element list or tuple.')\n" | |
| " a, b = pair\n" | |
| " if not all(isinstance(x, int) and not isinstance(x, bool) for x in (a, b)):\n" | |
| " raise TypeError('Both elements must be int.')\n" | |
| " if a < 0 or b < 0:\n" | |
| " raise ValueError('Both elements must be non-negative.')\n" | |
| " while b:\n" | |
| " a, b = b, a % b\n" | |
| " return a\n" | |
| ), | |
| "sort_unique": ( | |
| "def sort_unique(xs):\n" | |
| " if not isinstance(xs, list):\n" | |
| " raise TypeError('Input must be a list.')\n" | |
| " if not all(isinstance(x, int) and not isinstance(x, bool) for x in xs):\n" | |
| " raise TypeError('All elements must be int.')\n" | |
| " return sorted(set(xs))\n" | |
| ), | |
| "caesar_cipher": ( | |
| "def caesar_cipher(s):\n" | |
| " if not isinstance(s, str):\n" | |
| " raise TypeError('Input must be a string.')\n" | |
| " out = []\n" | |
| " for ch in s:\n" | |
| " if 'a' <= ch <= 'z':\n" | |
| " out.append(chr((ord(ch) - ord('a') + 3) % 26 + ord('a')))\n" | |
| " else:\n" | |
| " out.append(ch)\n" | |
| " return ''.join(out)\n" | |
| ), | |
| "is_prime": ( | |
| "def is_prime(n):\n" | |
| " if not isinstance(n, int) or isinstance(n, bool):\n" | |
| " raise TypeError('Input must be int.')\n" | |
| " if n < 2:\n" | |
| " return False\n" | |
| " if n < 4:\n" | |
| " return True\n" | |
| " if n % 2 == 0:\n" | |
| " return False\n" | |
| " i = 3\n" | |
| " while i * i <= n:\n" | |
| " if n % i == 0:\n" | |
| " return False\n" | |
| " i += 2\n" | |
| " return True\n" | |
| ), | |
| # ---- 6 hub-pushed tasks ----------------------------------------------- | |
| "roman_to_int": ( | |
| "def roman_to_int(s):\n" | |
| " if not isinstance(s, str):\n" | |
| " raise TypeError('input must be str')\n" | |
| " table = {'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.upper()):\n" | |
| " if ch not in table:\n" | |
| " raise ValueError(f'invalid roman numeral character: {ch!r}')\n" | |
| " v = table[ch]\n" | |
| " if v < prev:\n" | |
| " total -= v\n" | |
| " else:\n" | |
| " total += v\n" | |
| " prev = v\n" | |
| " return total\n" | |
| ), | |
| "levenshtein_distance": ( | |
| "def levenshtein_distance(a, b):\n" | |
| " if not isinstance(a, str) or not isinstance(b, str):\n" | |
| " raise TypeError('both arguments must be str')\n" | |
| " if a == b:\n" | |
| " return 0\n" | |
| " if not a:\n" | |
| " return len(b)\n" | |
| " if not b:\n" | |
| " return len(a)\n" | |
| " prev = list(range(len(b) + 1))\n" | |
| " for i, ca in enumerate(a, 1):\n" | |
| " cur = [i] + [0] * len(b)\n" | |
| " for j, cb in enumerate(b, 1):\n" | |
| " ins = cur[j-1] + 1\n" | |
| " dele = prev[j] + 1\n" | |
| " sub = prev[j-1] + (ca != cb)\n" | |
| " cur[j] = min(ins, dele, sub)\n" | |
| " prev = cur\n" | |
| " return prev[-1]\n" | |
| ), | |
| "flatten_list": ( | |
| "def flatten_list(xs):\n" | |
| " if not isinstance(xs, (list, tuple)):\n" | |
| " raise TypeError('input must be list or tuple')\n" | |
| " out = []\n" | |
| " rev = []\n" | |
| " rev.extend(reversed(list(xs)))\n" | |
| " while rev:\n" | |
| " x = rev.pop()\n" | |
| " if isinstance(x, (list, tuple)):\n" | |
| " for y in reversed(x):\n" | |
| " rev.append(y)\n" | |
| " else:\n" | |
| " out.append(x)\n" | |
| " return out\n" | |
| ), | |
| "merge_sorted": ( | |
| "def merge_sorted(a, b):\n" | |
| " if not isinstance(a, list) or not isinstance(b, list):\n" | |
| " raise TypeError('both arguments must be list')\n" | |
| " for x in (*a, *b):\n" | |
| " if not isinstance(x, int) or isinstance(x, bool):\n" | |
| " raise TypeError('elements must be int')\n" | |
| " out = []\n" | |
| " i = j = 0\n" | |
| " while i < len(a) and j < len(b):\n" | |
| " if a[i] <= b[j]:\n" | |
| " out.append(a[i]); i += 1\n" | |
| " else:\n" | |
| " out.append(b[j]); j += 1\n" | |
| " out.extend(a[i:])\n" | |
| " out.extend(b[j:])\n" | |
| " return out\n" | |
| ), | |
| "run_length_encode": ( | |
| "def run_length_encode(s):\n" | |
| " if not isinstance(s, str):\n" | |
| " raise TypeError('input must be str')\n" | |
| " if not s:\n" | |
| " return []\n" | |
| " out = []\n" | |
| " cur = s[0]\n" | |
| " n = 1\n" | |
| " for ch in s[1:]:\n" | |
| " if ch == cur:\n" | |
| " n += 1\n" | |
| " else:\n" | |
| " out.append((cur, n))\n" | |
| " cur = ch\n" | |
| " n = 1\n" | |
| " out.append((cur, n))\n" | |
| " return out\n" | |
| ), | |
| "binary_search": ( | |
| "def binary_search(arr, target):\n" | |
| " if not isinstance(arr, list):\n" | |
| " raise TypeError('arr must be list')\n" | |
| " if not isinstance(target, int) or isinstance(target, bool):\n" | |
| " raise TypeError('target must be int')\n" | |
| " lo, hi = 0, len(arr) - 1\n" | |
| " while lo <= hi:\n" | |
| " mid = (lo + hi) // 2\n" | |
| " v = arr[mid]\n" | |
| " if v == target:\n" | |
| " return mid\n" | |
| " if v < target:\n" | |
| " lo = mid + 1\n" | |
| " else:\n" | |
| " hi = mid - 1\n" | |
| " return -1\n" | |
| ), | |
| } | |
| def get_oracle_code(task_name: str) -> str: | |
| """Return the canonical source for ``task_name``, or a stub raising | |
| NotImplementedError if the task isn't in the oracle catalog.""" | |
| code = ORACLE_SOLUTIONS.get(task_name) | |
| if code is not None: | |
| return code | |
| return ( | |
| f"def {task_name}(*args, **kwargs):\n" | |
| f" raise NotImplementedError(\n" | |
| f" 'No oracle reference for {task_name!r}. Try the model backends.'\n" | |
| f" )\n" | |
| ) | |