| {"snippet": "def f(a):\n return a", "input": "\"Hello world\"", "output": "\"Hello world\"", "imports": [], "original_snippet": "def f(a):\n return a", "composite_functions": []} | |
| {"snippet": "def f(number):\n a = number % 10\n b = (number % 100 - a) / 10\n c = (number % 1000 - 10 * b - a) / 100\n d = (number % 10000 - 100 * b - 10 * a - c) / 1000\n e = (number % 100000 - 1000 * b - 100 * a - 10 * c - d) / 10000", "input": "4321", "output": "None", "imports": [], "original_snippet": "def f(number):\n a = number % 10\n b = (number % 100 - a) / 10\n c = (number % 1000 - 10 * b - a) / 100\n d = (number % 10000 - 100 * b - 10 * a - c) / 1000\n e = (number % 100000 - 1000 * b - 100 * a - 10 * c - d) / 10000", "composite_functions": [], "_input_type": "int", "_output_type": "NoneType"} | |
| {"snippet": "def f(text: str):\n binary_encoding = bin(int.from_bytes(text.encode(), 'big'))\n return binary_encoding", "input": "\"Python\"", "output": "'0b10100000111100101110100011010000110111101101110'", "imports": [], "original_snippet": "def f(text: str):\n binary_encoding = bin(int.from_bytes(text.encode(), 'big'))\n return binary_encoding", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "from collections import defaultdict\ndef f(input_dict: dict):\n squared_dict = {k: v ** 2 for (k, v) in input_dict.items()}\n return squared_dict", "input": "{'a': 2, 'b': 3}", "output": "{'a': 4, 'b': 9}", "imports": ["from collections import defaultdict"], "original_snippet": "from collections import defaultdict\ndef f(input_dict: dict):\n squared_dict = {k: v ** 2 for (k, v) in input_dict.items()}\n return squared_dict", "composite_functions": [], "_input_type": "dict", "_output_type": "dict"} | |
| {"snippet": "import re\ndef f(input_string: str):\n if len(input_string) == 10:\n input_string = re.sub('ee', 'eeeee', input_string)\n return input_string", "input": "'Hello world'", "output": "'Hello world'", "imports": ["import re"], "original_snippet": "import re\ndef f(input_string: str):\n if len(input_string) == 10:\n input_string = re.sub('ee', 'eeeee', input_string)\n return input_string", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(d: dict, s: str):\n if 'key' in d:\n del d['key']\n d['value'] = s[::-1]\n elif 'value' not in d:\n d['key'] = len(s)\n d['value'] = s\n return d", "input": "{'value': 'abc'}, 'def'", "output": "{'value': 'abc'}", "imports": [], "original_snippet": "def f(d: dict, s: str):\n if 'key' in d:\n del d['key']\n d['value'] = s[::-1]\n elif 'value' not in d:\n d['key'] = len(s)\n d['value'] = s\n return d", "composite_functions": [], "_input_type": "tuple", "_output_type": "dict"} | |
| {"snippet": "def f(a):\n n = 101779791\n return (a ^ a >> 13) * n % 2 ** 17", "input": "4096123512413759491", "output": "109630", "imports": [], "original_snippet": "def f(a):\n n = 101779791\n return (a ^ a >> 13) * n % 2 ** 17", "composite_functions": [], "_input_type": "int", "_output_type": "int"} | |
| {"snippet": "def f(input_string: str) -> str:\n sep = ''\n for _ in reversed(list(input_string)):\n sep += _\n return sep", "input": "\"Hello World\"", "output": "'dlroW olleH'", "imports": [], "original_snippet": "def f(input_string: str) -> str:\n sep = ''\n for _ in reversed(list(input_string)):\n sep += _\n return sep", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(item):\n return item", "input": "'Hello world'", "output": "'Hello world'", "imports": [], "original_snippet": "def f(item):\n return item", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "from collections import defaultdict\ndef f(a: dict):\n reversed_dict = defaultdict(list)\n for (key, value) in a.items():\n reversed_dict[value].append(key)\n reversed_dict = {key: reversed_dict[key] for key in reversed_dict.keys()}\n return reversed_dict", "input": "{1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}", "output": "{'one': [1], 'two': [2], 'three': [3], 'four': [4], 'five': [5]}", "imports": ["from collections import defaultdict"], "original_snippet": "from collections import defaultdict\ndef f(a: dict):\n reversed_dict = defaultdict(list)\n for (key, value) in a.items():\n reversed_dict[value].append(key)\n reversed_dict = {key: reversed_dict[key] for key in reversed_dict.keys()}\n return reversed_dict", "composite_functions": [], "_input_type": "dict", "_output_type": "dict"} | |
| {"snippet": "from typing import Dict, List\ndef f(input_dict: Dict[int, str]) -> Dict[str, List[int]]:\n temp_dict = {}\n for (key, value) in input_dict.items():\n if value in temp_dict:\n temp_dict[value].append(key)\n else:\n temp_dict[value] = [key]\n rev_dict = {value: keys for (value, keys) in temp_dict.items()}\n return rev_dict", "input": "{1: 'one', 2: 'one', 3: 'three'}", "output": "{'one': [1, 2], 'three': [3]}", "imports": ["from typing import Dict, List"], "original_snippet": "from typing import Dict, List\ndef f(input_dict: Dict[int, str]) -> Dict[str, List[int]]:\n temp_dict = {}\n for (key, value) in input_dict.items():\n if value in temp_dict:\n temp_dict[value].append(key)\n else:\n temp_dict[value] = [key]\n rev_dict = {value: keys for (value, keys) in temp_dict.items()}\n return rev_dict", "composite_functions": [], "_input_type": "dict", "_output_type": "dict"} | |
| {"snippet": "def f(input_string: str, custom_dict: dict={'eeddddd': 'eeeeee'}):\n for (key, value) in custom_dict.items():\n if key in input_string:\n input_string = input_string.replace(key, value)\n return input_string", "input": "'Hello world'", "output": "'Hello world'", "imports": [], "original_snippet": "def f(input_string: str, custom_dict: dict={'eeddddd': 'eeeeee'}):\n for (key, value) in custom_dict.items():\n if key in input_string:\n input_string = input_string.replace(key, value)\n return input_string", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "import math\ndef f(numbers):\n sums = []\n averages = []\n standard_deviations = []\n for number in numbers:\n if number not in sums:\n sums.append(number)\n averages.append(sum(numbers) / len(numbers))\n standard_deviations.append(math.sqrt(sum(((number - a) ** 2 for a in averages)) / float(len(numbers))))\n return (sum(sums), sum(averages), sum(standard_deviations) / 2)", "input": "[1, 1, 2, 3, 4, 5]", "output": "(15, 13.333333333333332, 2.2598552666371594)", "imports": ["import math"], "original_snippet": "import math\ndef f(numbers):\n sums = []\n averages = []\n standard_deviations = []\n for number in numbers:\n if number not in sums:\n sums.append(number)\n averages.append(sum(numbers) / len(numbers))\n standard_deviations.append(math.sqrt(sum(((number - a) ** 2 for a in averages)) / float(len(numbers))))\n return (sum(sums), sum(averages), sum(standard_deviations) / 2)", "composite_functions": [], "_input_type": "list", "_output_type": "tuple"} | |
| {"snippet": "from collections import defaultdict\ndef f(item):\n if not hasattr(f, 'dict'):\n f.dict = defaultdict(int)\n if not hasattr(f, 'sum'):\n f.sum = 0\n if not hasattr(f, 'result'):\n f.result = []\n f.sum += item\n f.dict[f.sum] += 1\n if len(f.result) >= item:\n if item in f.result:\n return 'Already seen'\n elif f.result[-1] < item:\n return 'Not defined yet'\n else:\n f.result = reversed(f.result)\n return\n else:\n return None", "input": "5 + 6 + 3 + 2", "output": "None", "imports": ["from collections import defaultdict"], "original_snippet": "from collections import defaultdict\ndef f(item):\n if not hasattr(f, 'dict'):\n f.dict = defaultdict(int)\n if not hasattr(f, 'sum'):\n f.sum = 0\n if not hasattr(f, 'result'):\n f.result = []\n f.sum += item\n f.dict[f.sum] += 1\n if len(f.result) >= item:\n if item in f.result:\n return 'Already seen'\n elif f.result[-1] < item:\n return 'Not defined yet'\n else:\n f.result = reversed(f.result)\n return\n else:\n return None", "composite_functions": [], "_input_type": "str", "_output_type": "NoneType"} | |
| {"snippet": "def f(numbers):\n numbers.reverse()\n numbers = [x * x for x in numbers]\n numbers.reverse()\n numbers = [x + 1 for x in numbers]\n from math import factorial\n numbers = [factorial(x) for x in numbers]\n from functools import reduce\n product = reduce(lambda x, y: x * y, numbers)\n return product", "input": "numbers = [2, 3, 4, 5]", "output": "62464291863199167050758240415917277184000000000000", "imports": ["from math import factorial", "from functools import reduce"], "original_snippet": "def f(numbers):\n numbers.reverse()\n numbers = [x * x for x in numbers]\n numbers.reverse()\n numbers = [x + 1 for x in numbers]\n from math import factorial\n numbers = [factorial(x) for x in numbers]\n from functools import reduce\n product = reduce(lambda x, y: x * y, numbers)\n return product", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(a_dict: dict):\n reversed_dict = {}\n for (key, value) in a_dict.items():\n if value in reversed_dict:\n if key not in reversed_dict[value]:\n reversed_dict[value].append(key)\n else:\n reversed_dict[value] = [key]\n return reversed_dict", "input": "{'a': 2, 'b': 3}", "output": "{2: ['a'], 3: ['b']}", "imports": [], "original_snippet": "def f(a_dict: dict):\n reversed_dict = {}\n for (key, value) in a_dict.items():\n if value in reversed_dict:\n if key not in reversed_dict[value]:\n reversed_dict[value].append(key)\n else:\n reversed_dict[value] = [key]\n return reversed_dict", "composite_functions": [], "_input_type": "dict", "_output_type": "dict"} | |
| {"snippet": "def f(text: str, mapping: dict={'a': 128, 'e': 230, 'i': 345, 'o': 456, 'u': 567}):\n if not hasattr(f, 'reverse_mapping'):\n f.reverse_mapping = {value: key for (key, value) in mapping.items()}\n if not hasattr(f, 'length'):\n f.length = len(text)\n if text.islower():\n capitalization = [c for c in text]\n for i in range(len(text)):\n if i + 1 <= f.length:\n if i + 1 not in mapping:\n capitalization[i] = text[i] if text[i] >= 'A' else text[i].upper()\n if capitalization[i] in mapping:\n alpha_i = mapping[capitalization[i]]\n alpha_i_capitalized = f.reverse_mapping[alpha_i]\n new_char = alpha_i_capitalized\n if new_char >= 'A' and (capitalization[i] < 'a' or capitalization[i].isupper()):\n new_char = new_char.upper()\n if i != 0 and (new_char < 'a' or new_char.islower()):\n new_char = new_char.lower()\n if i <= f.length and (text[i] <= 'Z' and (not text[i].islower())):\n text = text[:i] + new_char + text[i:]\n elif i <= f.length and (text[i] <= 'z' and (not text[i].isupper())):\n text = text[:i] + new_char + text[i:]\n else:\n break\n else:\n return 'Encountered non-mapping or invalid values'\n elif f.length != len(text):\n return \"Total text length isn't equal to initial one\"\n return text", "input": "'hello world'", "output": "", "imports": [], "original_snippet": "def f(text: str, mapping: dict={'a': 128, 'e': 230, 'i': 345, 'o': 456, 'u': 567}):\n if not hasattr(f, 'reverse_mapping'):\n f.reverse_mapping = {value: key for (key, value) in mapping.items()}\n if not hasattr(f, 'length'):\n f.length = len(text)\n if text.islower():\n capitalization = [c for c in text]\n for i in range(len(text)):\n if i + 1 <= f.length:\n if i + 1 not in mapping:\n capitalization[i] = text[i] if text[i] >= 'A' else text[i].upper()\n if capitalization[i] in mapping:\n alpha_i = mapping[capitalization[i]]\n alpha_i_capitalized = f.reverse_mapping[alpha_i]\n new_char = alpha_i_capitalized\n if new_char >= 'A' and (capitalization[i] < 'a' or capitalization[i].isupper()):\n new_char = new_char.upper()\n if i != 0 and (new_char < 'a' or new_char.islower()):\n new_char = new_char.lower()\n if i <= f.length and (text[i] <= 'Z' and (not text[i].islower())):\n text = text[:i] + new_char + text[i:]\n elif i <= f.length and (text[i] <= 'z' and (not text[i].isupper())):\n text = text[:i] + new_char + text[i:]\n else:\n break\n else:\n return 'Encountered non-mapping or invalid values'\n elif f.length != len(text):\n return \"Total text length isn't equal to initial one\"\n return text", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(s: str):\n rev_s = s[::-1]\n result = s[0] + s[1] + rev_s[-3] + rev_s[-2] + rev_s[-1]\n return result", "input": "\"squirre1\"", "output": "'squqs'", "imports": [], "original_snippet": "def f(s: str):\n rev_s = s[::-1]\n result = s[0] + s[1] + rev_s[-3] + rev_s[-2] + rev_s[-1]\n return result", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(input_str: str):\n str_list = list(input_str)\n reversed_str = ''.join(str_list[::-1])\n sum_str = sum((ord(char) for char in reversed_str))\n return sum_str", "input": "'Hello world'", "output": "1084", "imports": [], "original_snippet": "def f(input_str: str):\n str_list = list(input_str)\n reversed_str = ''.join(str_list[::-1])\n sum_str = sum((ord(char) for char in reversed_str))\n return sum_str", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "from collections import deque\ndef f(sorted_array: list):\n stack = deque(sorted_array)\n current_sum = sum(stack)\n current_product = 1\n for idx in range(len(stack)):\n stack[idx] = stack[idx] ** 2\n stack[idx] = stack[idx] % current_sum\n current_product *= stack[idx]\n return current_product", "input": "[1, 2, 3, 4]", "output": "216", "imports": ["from collections import deque"], "original_snippet": "from collections import deque\ndef f(sorted_array: list):\n stack = deque(sorted_array)\n current_sum = sum(stack)\n current_product = 1\n for idx in range(len(stack)):\n stack[idx] = stack[idx] ** 2\n stack[idx] = stack[idx] % current_sum\n current_product *= stack[idx]\n return current_product", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(input_dict: dict):\n if input_dict['b']:\n input_dict['a'] = 'value1' + input_dict['a']\n input_dict['c'] = 20\n input_dict = f(input_dict)\n else:\n input_dict['b'] = 1\n return input_dict", "input": "{'a': 'value0', 'b': 0}", "output": "{'a': 'value0', 'b': 1}", "imports": [], "original_snippet": "def f(input_dict: dict):\n if input_dict['b']:\n input_dict['a'] = 'value1' + input_dict['a']\n input_dict['c'] = 20\n input_dict = f(input_dict)\n else:\n input_dict['b'] = 1\n return input_dict", "composite_functions": [], "_input_type": "dict", "_output_type": "dict"} | |
| {"snippet": "import functools\ndef f(input_tuple: tuple) -> tuple:\n (name, info) = input_tuple\n info = info.upper()\n reversed_info = ''.join(reversed(info.split()))\n return (name, reversed_info)", "input": "('Prof. Gordon', 'I WILL GET MY RING BACK!')", "output": "('Prof. Gordon', 'BACK!RINGMYGETWILLI')", "imports": ["import functools"], "original_snippet": "import functools\ndef f(input_tuple: tuple) -> tuple:\n (name, info) = input_tuple\n info = info.upper()\n reversed_info = ''.join(reversed(info.split()))\n return (name, reversed_info)", "composite_functions": [], "_input_type": "tuple", "_output_type": "tuple"} | |
| {"snippet": "def f(numbers):\n return sorted(numbers)", "input": "[5, 6, 3, 2]", "output": "[2, 3, 5, 6]", "imports": [], "original_snippet": "def f(numbers):\n return sorted(numbers)", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "from typing import List, Dict\ndef f(strings: List[str]) -> Dict[int, List[str]]:\n length_dict = {}\n for string in strings:\n temp_length = len(string)\n if temp_length in length_dict:\n length_dict[temp_length].append(string)\n else:\n length_dict[temp_length] = [string]\n return length_dict", "input": "['one', 'two', 'three', 'four']", "output": "{3: ['one', 'two'], 5: ['three'], 4: ['four']}", "imports": ["from typing import List, Dict"], "original_snippet": "from typing import List, Dict\ndef f(strings: List[str]) -> Dict[int, List[str]]:\n length_dict = {}\n for string in strings:\n temp_length = len(string)\n if temp_length in length_dict:\n length_dict[temp_length].append(string)\n else:\n length_dict[temp_length] = [string]\n return length_dict", "composite_functions": [], "_input_type": "list", "_output_type": "dict"} | |
| {"snippet": "def f(number):\n a = number % 10\n b = (number % 100 - a) / 10\n c = (number % 1000 - 10 * b - a) / 100\n d = (number % 10000 - 100 * b - 10 * a - c) / 1000\n e = (number % 100000 - 1000 * b - 100 * a - 10 * c - d) / 10000\n result = a * 1000 + b * 100 + c * 10 + d * 1 + e\n return result", "input": "number = 123456", "output": "6544.6733108", "imports": [], "original_snippet": "def f(number):\n a = number % 10\n b = (number % 100 - a) / 10\n c = (number % 1000 - 10 * b - a) / 100\n d = (number % 10000 - 100 * b - 10 * a - c) / 1000\n e = (number % 100000 - 1000 * b - 100 * a - 10 * c - d) / 10000\n result = a * 1000 + b * 100 + c * 10 + d * 1 + e\n return result", "composite_functions": [], "_input_type": "str", "_output_type": "float"} | |
| {"snippet": "from collections import namedtuple\ndef f(input_list):\n if not input_list:\n return 'The input list is empty'\n s = sum(input_list)\n if s == 1:\n return 'The list contains a single item'\n elif s - 1 / 2 <= 1:\n return 'The list contains almost a single item'\n elif s % 2 == 0:\n return 'The list contains an even number of items'\n elif s % 3 == 0:\n return 'The list contains an integer multiple of 3 items'\n elif s % 3 != 0:\n return 'The list contains an odd number of items'\n elif 'key' in set(input_list):\n return 'The list contains at least one predefined key'\n elif s >= 2 and s <= 6:\n return 'The list contains a small number of items'\n elif s > 6:\n return 'The list contains a large number of items'\n elif 'key' not in set(input_list) and s != 0:\n return 'The list contains at least one item'\n else:\n return 'The list contains no items'", "input": "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", "output": "'The list contains an odd number of items'", "imports": ["from collections import namedtuple"], "original_snippet": "from collections import namedtuple\ndef f(input_list):\n if not input_list:\n return 'The input list is empty'\n s = sum(input_list)\n if s == 1:\n return 'The list contains a single item'\n elif s - 1 / 2 <= 1:\n return 'The list contains almost a single item'\n elif s % 2 == 0:\n return 'The list contains an even number of items'\n elif s % 3 == 0:\n return 'The list contains an integer multiple of 3 items'\n elif s % 3 != 0:\n return 'The list contains an odd number of items'\n elif 'key' in set(input_list):\n return 'The list contains at least one predefined key'\n elif s >= 2 and s <= 6:\n return 'The list contains a small number of items'\n elif s > 6:\n return 'The list contains a large number of items'\n elif 'key' not in set(input_list) and s != 0:\n return 'The list contains at least one item'\n else:\n return 'The list contains no items'", "composite_functions": [], "_input_type": "list", "_output_type": "str"} | |
| {"snippet": "from typing import Tuple, Dict\ndef f(person_info: Tuple[str, Dict]) -> Tuple[str, str]:\n (name, info) = person_info\n reversed_keys = (key[::-1] for key in info.keys())\n uppercased_keys = (key.upper() for key in reversed_keys)\n final_name = name\n final_keys = ' | '.join(uppercased_keys)\n return (final_name, final_keys)", "input": "('Prof. Gordon', {'age': 20, 'city': 'New York'})", "output": "('Prof. Gordon', 'EGA | YTIC')", "imports": ["from typing import Tuple, Dict"], "original_snippet": "from typing import Tuple, Dict\ndef f(person_info: Tuple[str, Dict]) -> Tuple[str, str]:\n (name, info) = person_info\n reversed_keys = (key[::-1] for key in info.keys())\n uppercased_keys = (key.upper() for key in reversed_keys)\n final_name = name\n final_keys = ' | '.join(uppercased_keys)\n return (final_name, final_keys)", "composite_functions": [], "_input_type": "tuple", "_output_type": "tuple"} | |
| {"snippet": "from collections import namedtuple\ndef f(input_list):\n if not input_list:\n return 'The input list is empty'\n s = sum(input_list)\n if s == 1:\n return 'The list contains a single item'\n elif s - 1 / 2 <= 1:\n return 'The list contains almost a single item'\n elif s % 2 == 0:\n return 'The list contains an even number of items'\n elif s % 3 == 0:\n return 'The list contains an integer multiple of 3 items'\n elif s % 3 != 0:\n return 'The list contains an odd number of items'\n elif 'key' in set(input_list):\n return 'The list contains at least one predefined key'\n elif abs(s - 1) <= 2:\n return 'The list contains a small number of items'\n elif s >= 2 and s <= 6:\n return 'The list contains a small number of items'\n elif s > 6:\n return 'The list contains a large number of items'\n elif 'key' not in set(input_list) and s != 0:\n return 'The list contains at least one item'\n else:\n return 'The list contains no items'", "input": "[2, 4, 6, 8]", "output": "'The list contains an even number of items'", "imports": ["from collections import namedtuple"], "original_snippet": "from collections import namedtuple\ndef f(input_list):\n if not input_list:\n return 'The input list is empty'\n s = sum(input_list)\n if s == 1:\n return 'The list contains a single item'\n elif s - 1 / 2 <= 1:\n return 'The list contains almost a single item'\n elif s % 2 == 0:\n return 'The list contains an even number of items'\n elif s % 3 == 0:\n return 'The list contains an integer multiple of 3 items'\n elif s % 3 != 0:\n return 'The list contains an odd number of items'\n elif 'key' in set(input_list):\n return 'The list contains at least one predefined key'\n elif abs(s - 1) <= 2:\n return 'The list contains a small number of items'\n elif s >= 2 and s <= 6:\n return 'The list contains a small number of items'\n elif s > 6:\n return 'The list contains a large number of items'\n elif 'key' not in set(input_list) and s != 0:\n return 'The list contains at least one item'\n else:\n return 'The list contains no items'", "composite_functions": [], "_input_type": "list", "_output_type": "str"} | |
| {"snippet": "def f(num1: int, num2: int) -> int:\n total = num1 + num2\n return total", "input": "5, 7", "output": "12", "imports": [], "original_snippet": "def f(num1: int, num2: int) -> int:\n total = num1 + num2\n return total", "composite_functions": [], "_input_type": "tuple", "_output_type": "int"} | |
| {"snippet": "def f(x):\n if x == 0:\n return []\n else:\n result = f(x // 2)\n result.append(x % 2)\n return result", "input": "5", "output": "[1, 0, 1]", "imports": [], "original_snippet": "def f(x):\n if x == 0:\n return []\n else:\n result = f(x // 2)\n result.append(x % 2)\n return result", "composite_functions": [], "_input_type": "int", "_output_type": "list"} | |
| {"snippet": "def f(the_string: str):\n output = ''\n for i in range(len(the_string) - 1, -1, -1):\n output += chr(ord(the_string[i]) + i)\n return output", "input": "\"deAR\"", "output": "'UCfd'", "imports": [], "original_snippet": "def f(the_string: str):\n output = ''\n for i in range(len(the_string) - 1, -1, -1):\n output += chr(ord(the_string[i]) + i)\n return output", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "from typing import Dict, List\ndef f(input_dict: Dict[str, int]) -> int:\n temp_dict = {}\n for (key, value) in input_dict.items():\n if value in temp_dict:\n temp_dict[value] += 1\n else:\n temp_dict[value] = 1\n sorted_count_dict = {k: v for (k, v) in sorted(temp_dict.items(), key=lambda item: item[1], reverse=True)}\n result = None\n for (key, value) in sorted_count_dict.items():\n if result is None:\n result = key * value\n else:\n result += key * value\n return result", "input": "{'cat': 1, 'dog': 2, 'bird': 3, 'fish': 5, 'penguin': 1}", "output": "12", "imports": ["from typing import Dict, List"], "original_snippet": "from typing import Dict, List\ndef f(input_dict: Dict[str, int]) -> int:\n temp_dict = {}\n for (key, value) in input_dict.items():\n if value in temp_dict:\n temp_dict[value] += 1\n else:\n temp_dict[value] = 1\n sorted_count_dict = {k: v for (k, v) in sorted(temp_dict.items(), key=lambda item: item[1], reverse=True)}\n result = None\n for (key, value) in sorted_count_dict.items():\n if result is None:\n result = key * value\n else:\n result += key * value\n return result", "composite_functions": [], "_input_type": "dict", "_output_type": "int"} | |
| {"snippet": "def f(text: str) -> str:\n reversed_text = text[::-1]\n reversed_and_or_not = [(reversed_text, text) if text == 'not' else (reversed_text, 'not')]\n extracted_chars = [char + 'a' for char in reversed(reversed_and_or_not[0][1])]\n concatenated_and_reversed = ''.join(extracted_chars) + reversed_text[::-1]\n character_indexes = [(char, index) for (index, char) in enumerate(reversed_text)]\n sorted_indexes = sorted(character_indexes, key=lambda x: x[1])\n concatenated_sorted = ''.join((char for (char, _) in sorted_indexes)) + reversed_text[::-1]\n final_text = concatenated_and_reversed + concatenated_sorted[::-1]\n return final_text[::-1]", "input": "'secret'", "output": "'tercessecrettercesanaoat'", "imports": [], "original_snippet": "def f(text: str) -> str:\n reversed_text = text[::-1]\n reversed_and_or_not = [(reversed_text, text) if text == 'not' else (reversed_text, 'not')]\n extracted_chars = [char + 'a' for char in reversed(reversed_and_or_not[0][1])]\n concatenated_and_reversed = ''.join(extracted_chars) + reversed_text[::-1]\n character_indexes = [(char, index) for (index, char) in enumerate(reversed_text)]\n sorted_indexes = sorted(character_indexes, key=lambda x: x[1])\n concatenated_sorted = ''.join((char for (char, _) in sorted_indexes)) + reversed_text[::-1]\n final_text = concatenated_and_reversed + concatenated_sorted[::-1]\n return final_text[::-1]", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "from collections import defaultdict\ndef f(n: int) -> dict:\n result = defaultdict(lambda : [0, 0])\n for year in range(1851, n + 1):\n if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:\n result['leap_years'][0] += 1\n decade = year % 100 // 10\n if decade in [0, 2, 19, 21]:\n place = 'lisbon'\n else:\n place = 'london'\n result[place][1] += 1\n return dict(result)", "input": "n = 2001", "output": "{'london': [0, 129], 'leap_years': [37, 0], 'lisbon': [0, 22]}", "imports": ["from collections import defaultdict"], "original_snippet": "from collections import defaultdict\ndef f(n: int) -> dict:\n result = defaultdict(lambda : [0, 0])\n for year in range(1851, n + 1):\n if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:\n result['leap_years'][0] += 1\n decade = year % 100 // 10\n if decade in [0, 2, 19, 21]:\n place = 'lisbon'\n else:\n place = 'london'\n result[place][1] += 1\n return dict(result)", "composite_functions": [], "_input_type": "str", "_output_type": "dict"} | |
| {"snippet": "def f(input_string: str) -> list:\n try:\n return [int(num) for num in input_string.split(',')]\n except TypeError:\n raise TypeError('Input must be a string of comma-separated integers.')", "input": "\"1, 2, 3, 4, 5\"", "output": "[1, 2, 3, 4, 5]", "imports": [], "original_snippet": "def f(input_string: str) -> list:\n try:\n return [int(num) for num in input_string.split(',')]\n except TypeError:\n raise TypeError('Input must be a string of comma-separated integers.')", "composite_functions": [], "_input_type": "str", "_output_type": "list"} | |
| {"snippet": "from typing import List, Dict\ndef f(input_string: str, n: int) -> List[str]:\n res = []\n for i in range(0, len(input_string), n):\n sub_str = input_string[i:i + n]\n temp = ord(sub_str[-1])\n count = len([s for s in sub_str if ord(s) == temp])\n res.append(count)\n return res", "input": "\"abcabcabc\", 3", "output": "[1, 1, 1]", "imports": ["from typing import List, Dict"], "original_snippet": "from typing import List, Dict\ndef f(input_string: str, n: int) -> List[str]:\n res = []\n for i in range(0, len(input_string), n):\n sub_str = input_string[i:i + n]\n temp = ord(sub_str[-1])\n count = len([s for s in sub_str if ord(s) == temp])\n res.append(count)\n return res", "composite_functions": [], "_input_type": "tuple", "_output_type": "list"} | |
| {"snippet": "from collections import deque\ndef f(nums: list):\n stack = deque([num ** 2 for num in nums if num % 2 == 0])\n result = 1\n for num in stack:\n result *= num\n stack = deque([num ** 2 for num in nums if num % 3 == 0])\n result *= sum(stack)\n return result", "input": "[4, 6, 8, 9, 12]", "output": "1385496576", "imports": ["from collections import deque"], "original_snippet": "from collections import deque\ndef f(nums: list):\n stack = deque([num ** 2 for num in nums if num % 2 == 0])\n result = 1\n for num in stack:\n result *= num\n stack = deque([num ** 2 for num in nums if num % 3 == 0])\n result *= sum(stack)\n return result", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "from typing import List\ndef f(integers: List[int]) -> float:\n if integers:\n sum_ints = sum(integers)\n average = sum_ints / len(integers)\n return average\n else:\n return 0.0", "input": "None", "output": "0.0", "imports": ["from typing import List"], "original_snippet": "from typing import List\ndef f(integers: List[int]) -> float:\n if integers:\n sum_ints = sum(integers)\n average = sum_ints / len(integers)\n return average\n else:\n return 0.0", "composite_functions": [], "_input_type": "NoneType", "_output_type": "float"} | |
| {"snippet": "def f(input_string: str) -> str:\n alphabets = {chr(i + 97): chr((i + 87) % 26 + 97) for i in range(52)}\n translated_string = input_string.translate(str.maketrans(alphabets))\n return translated_string", "input": "\"aaaaaaaaaaaaAAAaaaAAAaaa\"", "output": "'jjjjjjjjjjjjAAAjjjAAAjjj'", "imports": [], "original_snippet": "def f(input_string: str) -> str:\n alphabets = {chr(i + 97): chr((i + 87) % 26 + 97) for i in range(52)}\n translated_string = input_string.translate(str.maketrans(alphabets))\n return translated_string", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(numbers):\n formatted_numbers = []\n for (i, num) in enumerate(numbers):\n if num % 2 == 0:\n str_num = str(num)\n rev_num = ''.join((str(digit) for digit in reversed(str_num)))\n formatted_numbers.append(f'{rev_num}')\n else:\n formatted_numbers.append('!@#$%')\n return ' '.join(formatted_numbers)", "input": "[1, 2, 3, 4, 5]", "output": "'!@#$% 2 !@#$% 4 !@#$%'", "imports": [], "original_snippet": "def f(numbers):\n formatted_numbers = []\n for (i, num) in enumerate(numbers):\n if num % 2 == 0:\n str_num = str(num)\n rev_num = ''.join((str(digit) for digit in reversed(str_num)))\n formatted_numbers.append(f'{rev_num}')\n else:\n formatted_numbers.append('!@#$%')\n return ' '.join(formatted_numbers)", "composite_functions": [], "_input_type": "list", "_output_type": "str"} | |
| {"snippet": "from collections import defaultdict, deque\ndef f(n: int, x: int) -> bool:\n result = False\n while x != 0:\n if x == 1:\n result = True\n break\n if x % 3 == 0 and x % 4 == 0:\n result = f(n, x // 12)\n if result == True:\n break\n x -= 1\n return result", "input": "10, 23", "output": "True", "imports": ["from collections import defaultdict, deque"], "original_snippet": "from collections import defaultdict, deque\ndef f(n: int, x: int) -> bool:\n result = False\n while x != 0:\n if x == 1:\n result = True\n break\n if x % 3 == 0 and x % 4 == 0:\n result = f(n, x // 12)\n if result == True:\n break\n x -= 1\n return result", "composite_functions": [], "_input_type": "tuple", "_output_type": "bool"} | |
| {"snippet": "from math import factorial\nfrom functools import reduce\ndef f(numbers):\n numbers.reverse()\n numbers = [x * x for x in numbers]\n numbers.reverse()\n numbers = [x + 1 for x in numbers]\n numbers = [factorial(x) for x in numbers]\n product = reduce(lambda x, y: x * y, numbers)\n return product", "input": "numbers = [2, 3, 4, 5]", "output": "62464291863199167050758240415917277184000000000000", "imports": ["from math import factorial", "from functools import reduce"], "original_snippet": "from math import factorial\nfrom functools import reduce\ndef f(numbers):\n numbers.reverse()\n numbers = [x * x for x in numbers]\n numbers.reverse()\n numbers = [x + 1 for x in numbers]\n numbers = [factorial(x) for x in numbers]\n product = reduce(lambda x, y: x * y, numbers)\n return product", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(qubits: list):\n graph = {i: [] for i in range(8)}\n visited = [False] * 8\n for i in range(8):\n for j in range(i + 1, 8):\n if qubits[i] == qubits[j] or abs(qubits[i] - qubits[j]) == abs(i - j):\n graph[i].append(j)\n graph[j].append(i)\n bfs_order = []\n queue = [[0]]\n while queue:\n state = queue.pop(0)\n current_qubit = state[-1]\n if not visited[current_qubit]:\n visited[current_qubit] = True\n next_order = list(state)\n next_order.append(current_qubit)\n bfs_order.append(next_order)\n for neighbor in graph[current_qubit]:\n queue.append(next_order + [neighbor])\n return bfs_order", "input": "[0, 2, 4, 6, 1, 3, 5, 7]", "output": "[[0, 0], [0, 0, 7, 7]]", "imports": [], "original_snippet": "def f(qubits: list):\n graph = {i: [] for i in range(8)}\n visited = [False] * 8\n for i in range(8):\n for j in range(i + 1, 8):\n if qubits[i] == qubits[j] or abs(qubits[i] - qubits[j]) == abs(i - j):\n graph[i].append(j)\n graph[j].append(i)\n bfs_order = []\n queue = [[0]]\n while queue:\n state = queue.pop(0)\n current_qubit = state[-1]\n if not visited[current_qubit]:\n visited[current_qubit] = True\n next_order = list(state)\n next_order.append(current_qubit)\n bfs_order.append(next_order)\n for neighbor in graph[current_qubit]:\n queue.append(next_order + [neighbor])\n return bfs_order", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(list_of_strings):\n unique_elements = list(dict.fromkeys(list_of_strings))\n sum_integers = sum(list(map(int, unique_elements)))\n reference_value = 5\n return sum_integers == reference_value", "input": "['1', '2', '3', '4', '1', '2', '5', '6', '7']", "output": "False", "imports": [], "original_snippet": "def f(list_of_strings):\n unique_elements = list(dict.fromkeys(list_of_strings))\n sum_integers = sum(list(map(int, unique_elements)))\n reference_value = 5\n return sum_integers == reference_value", "composite_functions": [], "_input_type": "list", "_output_type": "bool"} | |
| {"snippet": "def f(s: str) -> str:\n len_s = len(s)\n first_char = s[0]\n last_char = s[len_s - 1]\n replaced_last_char = first_char + last_char * (len_s - 2)\n return replaced_last_char", "input": "'John'", "output": "'Jnn'", "imports": [], "original_snippet": "def f(s: str) -> str:\n len_s = len(s)\n first_char = s[0]\n last_char = s[len_s - 1]\n replaced_last_char = first_char + last_char * (len_s - 2)\n return replaced_last_char", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "import math\ndef f(binary_string: str) -> str:\n reversed_binary_str = binary_string[::-1]\n swapped_string = ''.join(reversed(reversed_binary_str))\n multiplied_num = math.factorial(int(swapped_string))\n result = math.log2(multiplied_num)\n return str(result).count('1')", "input": "'011'", "output": "0", "imports": ["import math"], "original_snippet": "import math\ndef f(binary_string: str) -> str:\n reversed_binary_str = binary_string[::-1]\n swapped_string = ''.join(reversed(reversed_binary_str))\n multiplied_num = math.factorial(int(swapped_string))\n result = math.log2(multiplied_num)\n return str(result).count('1')", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "from collections import defaultdict, deque\ndef f(nums: list):\n if not nums:\n return {}\n unique_indices = deque()\n unique_counts = defaultdict(int)\n unique_counts[0] = 1\n for (i, num) in enumerate(nums):\n if i not in unique_indices and num in nums[:i]:\n continue\n unique_indices.append(i)\n unique_counts[num] += 1\n return unique_counts", "input": "[1, 2, 2, 3, 3, 4]", "output": "defaultdict(<class 'int'>, {0: 1, 1: 1, 2: 1, 3: 1, 4: 1})", "imports": ["from collections import defaultdict, deque"], "original_snippet": "from collections import defaultdict, deque\ndef f(nums: list):\n if not nums:\n return {}\n unique_indices = deque()\n unique_counts = defaultdict(int)\n unique_counts[0] = 1\n for (i, num) in enumerate(nums):\n if i not in unique_indices and num in nums[:i]:\n continue\n unique_indices.append(i)\n unique_counts[num] += 1\n return unique_counts", "composite_functions": [], "_input_type": "list", "_output_type": "str"} | |
| {"snippet": "def f(input_sequence: list):\n n = len(input_sequence)\n result = []\n for (idx, val) in enumerate(input_sequence):\n result.extend([idx] * val)\n return result", "input": "[2, 3, 1, 4, 5]", "output": "[0, 0, 1, 1, 1, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4]", "imports": [], "original_snippet": "def f(input_sequence: list):\n n = len(input_sequence)\n result = []\n for (idx, val) in enumerate(input_sequence):\n result.extend([idx] * val)\n return result", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "from typing import List\ndef f(numbers: List[int]) -> List[int]:\n transformed_numbers = [number * 2 if number % 2 == 0 else number + 3 for number in numbers]\n return transformed_numbers", "input": "[1, 2, 3, 4, 5]", "output": "[4, 4, 6, 8, 8]", "imports": ["from typing import List"], "original_snippet": "from typing import List\ndef f(numbers: List[int]) -> List[int]:\n transformed_numbers = [number * 2 if number % 2 == 0 else number + 3 for number in numbers]\n return transformed_numbers", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "from typing import Dict, List, Tuple\ndef f(s: str) -> Tuple[Dict[int, List[int]], Dict[int, str]]:\n temp_dict = dict()\n indices_dict = {}\n for i in range(len(s)):\n if s[i] in temp_dict:\n temp_dict[s[i]].append(i)\n else:\n temp_dict[s[i]] = [i]\n for (key, value) in temp_dict.items():\n indices_dict[len(key)] = value\n return (indices_dict, temp_dict)", "input": "'special'", "output": "({1: [6]}, {'s': [0], 'p': [1], 'e': [2], 'c': [3], 'i': [4], 'a': [5], 'l': [6]})", "imports": ["from typing import Dict, List, Tuple"], "original_snippet": "from typing import Dict, List, Tuple\ndef f(s: str) -> Tuple[Dict[int, List[int]], Dict[int, str]]:\n temp_dict = dict()\n indices_dict = {}\n for i in range(len(s)):\n if s[i] in temp_dict:\n temp_dict[s[i]].append(i)\n else:\n temp_dict[s[i]] = [i]\n for (key, value) in temp_dict.items():\n indices_dict[len(key)] = value\n return (indices_dict, temp_dict)", "composite_functions": [], "_input_type": "str", "_output_type": "tuple"} | |
| {"snippet": "def f(numbers):\n sum_products = 0\n for i in range(len(numbers) - 1):\n sum_products += numbers[i] * numbers[i + 1]\n return sum_products", "input": "[1, 2, 3, 4, 5, 6]", "output": "70", "imports": [], "original_snippet": "def f(numbers):\n sum_products = 0\n for i in range(len(numbers) - 1):\n sum_products += numbers[i] * numbers[i + 1]\n return sum_products", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(input_string):\n substring = input_string[1:]\n first_letter = input_string[0]\n substring = substring + first_letter + 'ay'\n return substring", "input": "'may'", "output": "'aymay'", "imports": [], "original_snippet": "def f(input_string):\n substring = input_string[1:]\n first_letter = input_string[0]\n substring = substring + first_letter + 'ay'\n return substring", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(nums_dict):\n summ = sum(sorted(nums_dict.values()))\n return summ", "input": "{'a': 12, 'b': 34, 'c': 23}", "output": "69", "imports": [], "original_snippet": "def f(nums_dict):\n summ = sum(sorted(nums_dict.values()))\n return summ", "composite_functions": [], "_input_type": "dict", "_output_type": "int"} | |
| {"snippet": "def f(x, y):\n sum_of_products = 0\n sum_of_x = 0\n sum_of_y = 0\n result_x = 0\n result_y = 0\n for i in range(x):\n sum_of_products += i * i\n sum_of_x += i\n for j in range(y):\n sum_of_y += j\n result_x = sum_of_x * 2 ** sum_of_products\n result_y = sum_of_y / sum_of_products\n return (result_x, result_y)", "input": "15, 2", "output": "(36866753742293587951479891607978046294899918513465271511152653362425646405425002204949980700884357973081273354270500590926118995557644033909665976986610904413409431268771242097679166129161796645590964277283057823687511370402262895614767337122630585746390241448987424443739181295977285570327563309786217840640, 0.0009852216748768472)", "imports": [], "original_snippet": "def f(x, y):\n sum_of_products = 0\n sum_of_x = 0\n sum_of_y = 0\n result_x = 0\n result_y = 0\n for i in range(x):\n sum_of_products += i * i\n sum_of_x += i\n for j in range(y):\n sum_of_y += j\n result_x = sum_of_x * 2 ** sum_of_products\n result_y = sum_of_y / sum_of_products\n return (result_x, result_y)", "composite_functions": [], "_input_type": "tuple", "_output_type": "tuple"} | |
| {"snippet": "def f(word: str) -> int:\n vowel_stack = str.casefold('aeiou')\n shared_vowels = [v for v in word if v in vowel_stack]\n return len(shared_vowels)", "input": "\"Hello\"", "output": "2", "imports": [], "original_snippet": "def f(word: str) -> int:\n vowel_stack = str.casefold('aeiou')\n shared_vowels = [v for v in word if v in vowel_stack]\n return len(shared_vowels)", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(input_string: str) -> str:\n output1 = list(input_string)\n output1.reverse()\n output2 = output1[1:]\n output3 = output1[0:]\n output3 = ''.join(output3) + ''.join(output2) + output1[0]\n return output3", "input": "'happy'", "output": "'yppahppahy'", "imports": [], "original_snippet": "def f(input_string: str) -> str:\n output1 = list(input_string)\n output1.reverse()\n output2 = output1[1:]\n output3 = output1[0:]\n output3 = ''.join(output3) + ''.join(output2) + output1[0]\n return output3", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(numbers):\n if not numbers:\n return 0\n max_diff = abs(numbers[0] - numbers[1])\n for i in range(1, len(numbers) - 1):\n diff = abs(numbers[i] - numbers[i + 1])\n if diff > max_diff:\n max_diff = diff\n return max_diff", "input": "[5, 3, 1, 6, 8, 9]", "output": "5", "imports": [], "original_snippet": "def f(numbers):\n if not numbers:\n return 0\n max_diff = abs(numbers[0] - numbers[1])\n for i in range(1, len(numbers) - 1):\n diff = abs(numbers[i] - numbers[i + 1])\n if diff > max_diff:\n max_diff = diff\n return max_diff", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(nums: list):\n even_sum = 0\n odd_count = 0\n if len(nums) == 0:\n return 'The list is empty'\n if nums[0] % 2 == 0:\n even_sum += nums[0]\n if nums[0] % 2 != 0:\n odd_count += 1\n for i in nums[1:]:\n if i % 2 == 0:\n even_sum += i\n else:\n odd_count += 1\n return f'The sum of even numbers is {even_sum} and the number of odd numbers is {odd_count}'", "input": "[2, 3, 4, 4, 4, 5]", "output": "'The sum of even numbers is 14 and the number of odd numbers is 2'", "imports": [], "original_snippet": "def f(nums: list):\n even_sum = 0\n odd_count = 0\n if len(nums) == 0:\n return 'The list is empty'\n if nums[0] % 2 == 0:\n even_sum += nums[0]\n if nums[0] % 2 != 0:\n odd_count += 1\n for i in nums[1:]:\n if i % 2 == 0:\n even_sum += i\n else:\n odd_count += 1\n return f'The sum of even numbers is {even_sum} and the number of odd numbers is {odd_count}'", "composite_functions": [], "_input_type": "list", "_output_type": "str"} | |
| {"snippet": "def f(word, ap='ap'):\n if not word[0] in word[1:]:\n last_char = word[-1]\n first_char = word[0]\n comb = last_char + first_char + ap\n return comb\n else:\n return None", "input": "'censor'", "output": "'rcap'", "imports": [], "original_snippet": "def f(word, ap='ap'):\n if not word[0] in word[1:]:\n last_char = word[-1]\n first_char = word[0]\n comb = last_char + first_char + ap\n return comb\n else:\n return None", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(input_str: str) -> int:\n sum_str = 0\n for char in input_str:\n sum_str += ord(char)\n return sum_str", "input": "'Hello'", "output": "500", "imports": [], "original_snippet": "def f(input_str: str) -> int:\n sum_str = 0\n for char in input_str:\n sum_str += ord(char)\n return sum_str", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(input_list):\n if not input_list:\n return 'The input list is empty'\n s = sum(input_list)\n if s == 1:\n return 'The list contains a single item'\n elif s - 1 / 2 <= 1:\n return 'The list contains almost a single item'\n elif s % 2 == 0:\n return 'The list contains an even number of items'\n elif s % 3 == 0:\n return 'The list contains an integer multiple of 3 items'\n elif s % 3 != 0:\n return 'The list contains an odd number of items'\n elif 'key' in set(input_list):\n return 'The list contains at least one predefined key'\n elif abs(s - 1) <= 2:\n return 'The list contains a small number of items'\n elif s >= 2 and s <= 6:\n return 'The list contains a small number of items'\n elif s > 6:\n return 'The list contains a large number of items'\n elif 'key' not in set(input_list) and s != 0:\n return 'The list contains at least one item'\n else:\n return 'The list contains no items'", "input": "[2, 4, 6, 8]", "output": "'The list contains an even number of items'", "imports": [], "original_snippet": "def f(input_list):\n if not input_list:\n return 'The input list is empty'\n s = sum(input_list)\n if s == 1:\n return 'The list contains a single item'\n elif s - 1 / 2 <= 1:\n return 'The list contains almost a single item'\n elif s % 2 == 0:\n return 'The list contains an even number of items'\n elif s % 3 == 0:\n return 'The list contains an integer multiple of 3 items'\n elif s % 3 != 0:\n return 'The list contains an odd number of items'\n elif 'key' in set(input_list):\n return 'The list contains at least one predefined key'\n elif abs(s - 1) <= 2:\n return 'The list contains a small number of items'\n elif s >= 2 and s <= 6:\n return 'The list contains a small number of items'\n elif s > 6:\n return 'The list contains a large number of items'\n elif 'key' not in set(input_list) and s != 0:\n return 'The list contains at least one item'\n else:\n return 'The list contains no items'", "composite_functions": [], "_input_type": "list", "_output_type": "str"} | |
| {"snippet": "import math\ndef f(num: int) -> int:\n prime_numbers = [True] * (num + 1)\n p = 2\n while p * p <= num:\n if prime_numbers[p] == True:\n for i in range(p * p, num + 1, p):\n prime_numbers[i] = False\n p += 1\n is_prime = list(filter(lambda x: x, prime_numbers[2:num + 1]))\n return is_prime", "input": "20", "output": "[True, True, True, True, True, True, True, True]", "imports": ["import math"], "original_snippet": "import math\ndef f(num: int) -> int:\n prime_numbers = [True] * (num + 1)\n p = 2\n while p * p <= num:\n if prime_numbers[p] == True:\n for i in range(p * p, num + 1, p):\n prime_numbers[i] = False\n p += 1\n is_prime = list(filter(lambda x: x, prime_numbers[2:num + 1]))\n return is_prime", "composite_functions": [], "_input_type": "int", "_output_type": "list"} | |
| {"snippet": "def f(numbers):\n max_val = float('-inf')\n min_val = float('inf')\n result = 0\n for num in numbers:\n max_val = max(max_val, num)\n min_val = min(min_val, num)\n result |= num\n return max(max_val, min_val) + (max_val | min_val)", "input": "numbers = [1, 2, 3, 4, 5, 6]", "output": "13", "imports": [], "original_snippet": "def f(numbers):\n max_val = float('-inf')\n min_val = float('inf')\n result = 0\n for num in numbers:\n max_val = max(max_val, num)\n min_val = min(min_val, num)\n result |= num\n return max(max_val, min_val) + (max_val | min_val)", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(input_string: str, special_dict: dict={'aab': 'zzz', 'cd': 'vvv'}):\n count = 0\n for (key, value) in special_dict.items():\n if key in input_string:\n count += 1\n input_string = input_string.replace(key, value)\n num_vowels = sum((1 for char in input_string if char.lower() in {'a', 'e', 'i', 'o', 'u'}))\n return num_vowels * 2 + len(input_string)", "input": "'Hello world!'", "output": "18", "imports": [], "original_snippet": "def f(input_string: str, special_dict: dict={'aab': 'zzz', 'cd': 'vvv'}):\n count = 0\n for (key, value) in special_dict.items():\n if key in input_string:\n count += 1\n input_string = input_string.replace(key, value)\n num_vowels = sum((1 for char in input_string if char.lower() in {'a', 'e', 'i', 'o', 'u'}))\n return num_vowels * 2 + len(input_string)", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(numbers):\n transformed_numbers = []\n for x in sorted(numbers, reverse=True):\n transformed_numbers.append(x + (x // 2 if x % 2 != 0 else x))\n return sum(transformed_numbers)", "input": "[1, 2, 3, 4, 5]", "output": "24", "imports": [], "original_snippet": "def f(numbers):\n transformed_numbers = []\n for x in sorted(numbers, reverse=True):\n transformed_numbers.append(x + (x // 2 if x % 2 != 0 else x))\n return sum(transformed_numbers)", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(custom_data: list, input_list: list):\n stack = []\n for (i, elem) in enumerate(input_list):\n for j in range(i, -1, -1):\n if custom_data[i] and stack == []:\n break\n if not custom_data[j] and stack == []:\n break\n if custom_data[j]:\n stack.append((j, elem))\n return [i for (i, _) in stack]", "input": "custom_data = [False, False, False, True, False, True, False],\ninput_list = [1, 2, 3, 4, 5, 6, 7]", "output": "[]", "imports": [], "original_snippet": "def f(custom_data: list, input_list: list):\n stack = []\n for (i, elem) in enumerate(input_list):\n for j in range(i, -1, -1):\n if custom_data[i] and stack == []:\n break\n if not custom_data[j] and stack == []:\n break\n if custom_data[j]:\n stack.append((j, elem))\n return [i for (i, _) in stack]", "composite_functions": [], "_input_type": "str", "_output_type": "list"} | |
| {"snippet": "def f(s: str, c: str):\n reversed_s = s[::-1]\n indices = [i for (i, char) in enumerate(reversed_s) if char == c]\n return indices", "input": "'programming', 'm'", "output": "[3, 4]", "imports": [], "original_snippet": "def f(s: str, c: str):\n reversed_s = s[::-1]\n indices = [i for (i, char) in enumerate(reversed_s) if char == c]\n return indices", "composite_functions": [], "_input_type": "tuple", "_output_type": "list"} | |
| {"snippet": "def f(alist):\n total_sum = 0\n for n in alist:\n total_sum += n\n total_sum *= len(alist)\n reversed_list = alist[::-1]\n total_sum += sum(reversed_list)\n return total_sum", "input": "[1, 2, 3, 4, 5]", "output": "90", "imports": [], "original_snippet": "def f(alist):\n total_sum = 0\n for n in alist:\n total_sum += n\n total_sum *= len(alist)\n reversed_list = alist[::-1]\n total_sum += sum(reversed_list)\n return total_sum", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "from collections import deque\ndef f(input_tuple: tuple) -> tuple:\n solution = []\n d = deque(input_tuple)\n n = len(d) - 1\n while n > 0:\n solution.append(d[n])\n solution.append(d[0])\n d.rotate(-1)\n n -= 1\n if n == 0:\n solution.append(d[0])\n return tuple(solution)", "input": "(1, 2, 3, 4, 5, 6)", "output": "(6, 1, 6, 2, 6, 3, 6, 4, 6, 5, 6)", "imports": ["from collections import deque"], "original_snippet": "from collections import deque\ndef f(input_tuple: tuple) -> tuple:\n solution = []\n d = deque(input_tuple)\n n = len(d) - 1\n while n > 0:\n solution.append(d[n])\n solution.append(d[0])\n d.rotate(-1)\n n -= 1\n if n == 0:\n solution.append(d[0])\n return tuple(solution)", "composite_functions": [], "_input_type": "tuple", "_output_type": "tuple"} | |
| {"snippet": "def f(numbers):\n result = []\n for num in numbers:\n if num % 2 == 0:\n result.append(num * 2)\n else:\n result.append(num + 3)\n return result", "input": "numbers = [2, 3, 4, 5]", "output": "[4, 6, 8, 8]", "imports": [], "original_snippet": "def f(numbers):\n result = []\n for num in numbers:\n if num % 2 == 0:\n result.append(num * 2)\n else:\n result.append(num + 3)\n return result", "composite_functions": [], "_input_type": "str", "_output_type": "list"} | |
| {"snippet": "import collections\ndef f(info_dict: dict) -> str:\n reversed_info = collections.defaultdict(lambda : collections.defaultdict(str))\n for (key, value) in info_dict.items():\n if 'name' in key.lower() and len(key) == 4:\n reversed_info['name'][len(key) - 1] = value\n reversed_info_str = str()\n for value in reversed_info.values():\n for key in value:\n reversed_info_str += value[key] + key\n reversed_info_str += ' '\n return reversed_info_str.strip()", "input": "info_dict = {'Mr Anonymous': 'John', 'Mrs Anonymous': 'Alice', 'Mr John Doe': 'Jane'}", "output": "''", "imports": ["import collections"], "original_snippet": "import collections\ndef f(info_dict: dict) -> str:\n reversed_info = collections.defaultdict(lambda : collections.defaultdict(str))\n for (key, value) in info_dict.items():\n if 'name' in key.lower() and len(key) == 4:\n reversed_info['name'][len(key) - 1] = value\n reversed_info_str = str()\n for value in reversed_info.values():\n for key in value:\n reversed_info_str += value[key] + key\n reversed_info_str += ' '\n return reversed_info_str.strip()", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(input_dict: dict):\n squared_dict = {k: v ** 2 for (k, v) in input_dict.items()}\n return squared_dict", "input": "{1: 4, 2: 9, 3: 16}", "output": "{1: 16, 2: 81, 3: 256}", "imports": [], "original_snippet": "def f(input_dict: dict):\n squared_dict = {k: v ** 2 for (k, v) in input_dict.items()}\n return squared_dict", "composite_functions": [], "_input_type": "dict", "_output_type": "dict"} | |
| {"snippet": "def f(n: int) -> int:\n return n * (n + 1) // 2", "input": "10", "output": "55", "imports": [], "original_snippet": "def f(n: int) -> int:\n return n * (n + 1) // 2", "composite_functions": [], "_input_type": "int", "_output_type": "int"} | |
| {"snippet": "from collections import defaultdict\ndef f(s: str) -> str:\n result = [s[0]]\n count = 1\n for c in s[1:]:\n if c == result[-1][0]:\n count += 1\n else:\n result.append(str(count) + result[-1][0])\n result[-1] = c\n count = 1\n result.append(str(count) + result[-1][0])\n return ''.join(result)", "input": "'aaaaab'", "output": "'ab1b'", "imports": ["from collections import defaultdict"], "original_snippet": "from collections import defaultdict\ndef f(s: str) -> str:\n result = [s[0]]\n count = 1\n for c in s[1:]:\n if c == result[-1][0]:\n count += 1\n else:\n result.append(str(count) + result[-1][0])\n result[-1] = c\n count = 1\n result.append(str(count) + result[-1][0])\n return ''.join(result)", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "import functools\ndef f(input_list: list) -> int:\n sum_of_numbers = functools.reduce(lambda x, y: x + y, input_list)\n return sum_of_numbers % 10", "input": "[1, 2, 3, 4, 5]", "output": "5", "imports": ["import functools"], "original_snippet": "import functools\ndef f(input_list: list) -> int:\n sum_of_numbers = functools.reduce(lambda x, y: x + y, input_list)\n return sum_of_numbers % 10", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(the_string: str):\n original_string = the_string\n start = 0\n end = len(the_string) - 1\n while start < end:\n if the_string[start] != the_string[end]:\n return False\n start += 1\n end -= 1\n return True", "input": "'racecar'", "output": "True", "imports": [], "original_snippet": "def f(the_string: str):\n original_string = the_string\n start = 0\n end = len(the_string) - 1\n while start < end:\n if the_string[start] != the_string[end]:\n return False\n start += 1\n end -= 1\n return True", "composite_functions": [], "_input_type": "str", "_output_type": "bool"} | |
| {"snippet": "def f(string_input):\n digits = [int(c) for c in string_input if c.isdigit()]\n if not digits:\n return 'No digits found'\n digit_rank = {str(d): i for (i, d) in enumerate(digits)}\n if not len(digit_rank):\n return 'No digits found'\n index_digit = sorted(digit_rank.keys(), reverse=True)[:6]\n return [str(d) + ' appears at index ' + str(digit_rank.get(d)) for d in index_digit]", "input": "string_input = 'The 1st digit is 2, the 2nd is 5, the 3rd is 9, the 4th is 1, the 5th is 0 and the 6th is 2.'", "output": "['9 appears at index 5', '6 appears at index 10', '5 appears at index 8', '4 appears at index 6', '3 appears at index 4', '2 appears at index 11']", "imports": [], "original_snippet": "def f(string_input):\n digits = [int(c) for c in string_input if c.isdigit()]\n if not digits:\n return 'No digits found'\n digit_rank = {str(d): i for (i, d) in enumerate(digits)}\n if not len(digit_rank):\n return 'No digits found'\n index_digit = sorted(digit_rank.keys(), reverse=True)[:6]\n return [str(d) + ' appears at index ' + str(digit_rank.get(d)) for d in index_digit]", "composite_functions": [], "_input_type": "str", "_output_type": "list"} | |
| {"snippet": "def f(dna_read: str, dna_ref: str) -> int:\n transform = dna_read.replace('T', '')\n count_diff = sum((transform.count(base) for base in 'AT')) - sum((dna_ref.count(base) for base in 'AT'))\n return count_diff", "input": "'datadog', 'having'", "output": "0", "imports": [], "original_snippet": "def f(dna_read: str, dna_ref: str) -> int:\n transform = dna_read.replace('T', '')\n count_diff = sum((transform.count(base) for base in 'AT')) - sum((dna_ref.count(base) for base in 'AT'))\n return count_diff", "composite_functions": [], "_input_type": "tuple", "_output_type": "int"} | |
| {"snippet": "def f(nums):\n filtered_nums = []\n for n in nums:\n n_str = str(n)\n if '1' in n_str or '7' in n_str:\n filtered_nums.append(n)\n return filtered_nums", "input": "[50, 82, 199, 141, 91, 37, 44]", "output": "[199, 141, 91, 37]", "imports": [], "original_snippet": "def f(nums):\n filtered_nums = []\n for n in nums:\n n_str = str(n)\n if '1' in n_str or '7' in n_str:\n filtered_nums.append(n)\n return filtered_nums", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(input_string: str, rotations=0) -> str:\n rotation_count = rotations\n while '0123456789' in input_string:\n first_digit = input_string.find('0123456789')\n if first_digit >= 0 and first_digit + 3 < len(input_string):\n input_string = input_string[:first_digit + 1] + input_string[first_digit + 1:20] + input_string[:first_digit + 1]\n rotation_count += 1\n return input_string", "input": "f('The 1st digit is 2, the 2nd is 5, the 3rd is 9, the 4th is 1, the 5th is 0 and the 6th is 2.')", "output": "'The 1st digit is 2, the 2nd is 5, the 3rd is 9, the 4th is 1, the 5th is 0 and the 6th is 2.'", "imports": [], "original_snippet": "def f(input_string: str, rotations=0) -> str:\n rotation_count = rotations\n while '0123456789' in input_string:\n first_digit = input_string.find('0123456789')\n if first_digit >= 0 and first_digit + 3 < len(input_string):\n input_string = input_string[:first_digit + 1] + input_string[first_digit + 1:20] + input_string[:first_digit + 1]\n rotation_count += 1\n return input_string", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "from typing import List\ndef f(data: List[int]) -> List[int]:\n if data == []:\n return []\n max_sublist = []\n for i in range(len(data) - 1):\n if len(data[i:i + 2]) == 2 and data[i:i + 2] == [1, data[i + 1]]:\n max_sublist = data[i + 1:]\n break\n return max_sublist", "input": "[1, 2, 0, 1, 0, 1, 1, 1, 1, 1, 1]", "output": "[2, 0, 1, 0, 1, 1, 1, 1, 1, 1]", "imports": ["from typing import List"], "original_snippet": "from typing import List\ndef f(data: List[int]) -> List[int]:\n if data == []:\n return []\n max_sublist = []\n for i in range(len(data) - 1):\n if len(data[i:i + 2]) == 2 and data[i:i + 2] == [1, data[i + 1]]:\n max_sublist = data[i + 1:]\n break\n return max_sublist", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(input_list: list) -> int:\n result = 0\n for index in range(0, len(input_list) - 1):\n result += input_list[index] + input_list[index + 1]\n return result", "input": "[1, 2, 3, 4, 5]", "output": "24", "imports": [], "original_snippet": "def f(input_list: list) -> int:\n result = 0\n for index in range(0, len(input_list) - 1):\n result += input_list[index] + input_list[index + 1]\n return result", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(string_input):\n alphabets = {'a': 'b', 'b': 'c', 'c': 'd', 'd': 'e', 'e': 'f', 'f': 'g', 'g': 'h', 'h': 'i', 'i': 'j', 'j': 'k', 'k': 'l', 'l': 'm', 'm': 'n', 'n': 'o', 'o': 'p', 'p': 'q', 'q': 'r', 'r': 's', 's': 't', 't': 'u', 'u': 'v', 'v': 'w', 'w': 'x', 'x': 'y', 'y': 'z', 'z': 'a'}\n translated_string = ''\n for c in string_input:\n if c in alphabets:\n translated_string += alphabets[c]\n else:\n translated_string += c\n return translated_string", "input": "string_input = 'Hello, World!'", "output": "'Hfmmp, Wpsme!'", "imports": [], "original_snippet": "def f(string_input):\n alphabets = {'a': 'b', 'b': 'c', 'c': 'd', 'd': 'e', 'e': 'f', 'f': 'g', 'g': 'h', 'h': 'i', 'i': 'j', 'j': 'k', 'k': 'l', 'l': 'm', 'm': 'n', 'n': 'o', 'o': 'p', 'p': 'q', 'q': 'r', 'r': 's', 's': 't', 't': 'u', 'u': 'v', 'v': 'w', 'w': 'x', 'x': 'y', 'y': 'z', 'z': 'a'}\n translated_string = ''\n for c in string_input:\n if c in alphabets:\n translated_string += alphabets[c]\n else:\n translated_string += c\n return translated_string", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(name: str, info: dict):\n name_tuple = tuple(name)\n info_str = ','.join(info.keys()) + ' = ' + ', '.join([f'{key}: {info[key]}' for key in info.keys()])\n foo = 'bar'\n bar = 'foo'\n baz = 'baz'\n bslash_foo = '\\\\' + foo\n usual_foo = '' + foo\n usual_baz = '' + baz\n foo_bars = usual_foo + ', ' + bslash_foo\n bslash_foo_separators = usual_foo.split(', ')\n num1 = 111222333\n num2 = 222333111\n transformed_num = (num1 // 100 + num2 // 100 - (num1 % 100 // 10 + num2 % 100 // 10)) % 10\n return f'{info_str} // {transformed_num}'", "input": "'John', {'age': 20, 'city': 'New York'}", "output": "'age,city = age: 20, city: New York // 0'", "imports": [], "original_snippet": "def f(name: str, info: dict):\n name_tuple = tuple(name)\n info_str = ','.join(info.keys()) + ' = ' + ', '.join([f'{key}: {info[key]}' for key in info.keys()])\n foo = 'bar'\n bar = 'foo'\n baz = 'baz'\n bslash_foo = '\\\\' + foo\n usual_foo = '' + foo\n usual_baz = '' + baz\n foo_bars = usual_foo + ', ' + bslash_foo\n bslash_foo_separators = usual_foo.split(', ')\n num1 = 111222333\n num2 = 222333111\n transformed_num = (num1 // 100 + num2 // 100 - (num1 % 100 // 10 + num2 % 100 // 10)) % 10\n return f'{info_str} // {transformed_num}'", "composite_functions": [], "_input_type": "tuple", "_output_type": "str"} | |
| {"snippet": "def f(string: str) -> str:\n return string[::-1]", "input": "'Hello world'", "output": "'dlrow olleH'", "imports": [], "original_snippet": "def f(string: str) -> str:\n return string[::-1]", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "import numpy as np\ndef f(s: str) -> list:\n temp_list = [ch for ch in reversed(s) if ch == '0']\n return ['2' if ch != '0' else 'a' for ch in temp_list]", "input": "'0230456'", "output": "['a', 'a']", "imports": ["import numpy as np"], "original_snippet": "import numpy as np\ndef f(s: str) -> list:\n temp_list = [ch for ch in reversed(s) if ch == '0']\n return ['2' if ch != '0' else 'a' for ch in temp_list]", "composite_functions": [], "_input_type": "str", "_output_type": "list"} | |
| {"snippet": "def f(binary_string: str) -> int:\n decimal = 0\n for digit in binary_string:\n value = int(digit) * 2 ** (len(binary_string) - 1) if digit == '1' else 0\n decimal += value\n binary_string = binary_string[:-1]\n return decimal", "input": "binary_string = '1101'", "output": "13", "imports": [], "original_snippet": "def f(binary_string: str) -> int:\n decimal = 0\n for digit in binary_string:\n value = int(digit) * 2 ** (len(binary_string) - 1) if digit == '1' else 0\n decimal += value\n binary_string = binary_string[:-1]\n return decimal", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(n: int):\n (a, b) = (0, 1)\n for _ in range(n):\n (a, b) = (b, a + b)\n return a", "input": "5", "output": "5", "imports": [], "original_snippet": "def f(n: int):\n (a, b) = (0, 1)\n for _ in range(n):\n (a, b) = (b, a + b)\n return a", "composite_functions": [], "_input_type": "int", "_output_type": "int"} | |
| {"snippet": "import math\ndef f(number: int) -> int:\n digit_list = [str(digit) for digit in list(str(number))]\n digit_list.reverse()\n result = sum([math.pow(int(digit), 3) for digit in digit_list])\n return result", "input": "423", "output": "99.0", "imports": ["import math"], "original_snippet": "import math\ndef f(number: int) -> int:\n digit_list = [str(digit) for digit in list(str(number))]\n digit_list.reverse()\n result = sum([math.pow(int(digit), 3) for digit in digit_list])\n return result", "composite_functions": [], "_input_type": "int", "_output_type": "float"} | |
| {"snippet": "import math\ndef f(nums: list) -> int:\n if not nums:\n return 0\n unique_indices = []\n unique_counts = {}\n for (i, num) in enumerate(nums):\n num_idx = i\n if i not in unique_indices and num in nums[:i]:\n continue\n unique_indices.append(i)\n num_idx = i if num not in unique_counts else unique_counts[num]\n unique_counts[num] = num_idx\n unique_counts[num_idx] = num_idx + 1\n return max(unique_counts.values())", "input": "[1, 2, 1, 2, 3, 3, 4]", "output": "6", "imports": ["import math"], "original_snippet": "import math\ndef f(nums: list) -> int:\n if not nums:\n return 0\n unique_indices = []\n unique_counts = {}\n for (i, num) in enumerate(nums):\n num_idx = i\n if i not in unique_indices and num in nums[:i]:\n continue\n unique_indices.append(i)\n num_idx = i if num not in unique_counts else unique_counts[num]\n unique_counts[num] = num_idx\n unique_counts[num_idx] = num_idx + 1\n return max(unique_counts.values())", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "from collections import deque\ndef f(nums: list):\n swaps = 0\n for i in range(len(nums)):\n for j in range(len(nums) - 1):\n if nums[j] > nums[j + 1]:\n (nums[j], nums[j + 1]) = (nums[j + 1], nums[j])\n swaps += 1\n return swaps", "input": "[3, 2, 1]", "output": "3", "imports": ["from collections import deque"], "original_snippet": "from collections import deque\ndef f(nums: list):\n swaps = 0\n for i in range(len(nums)):\n for j in range(len(nums) - 1):\n if nums[j] > nums[j + 1]:\n (nums[j], nums[j + 1]) = (nums[j + 1], nums[j])\n swaps += 1\n return swaps", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(name, info):\n digits = str(info).replace(',', '').split('.')\n reverse_digits = digits[::-1]\n reverse_string = ''.join(reverse_digits)\n return reverse_string + name", "input": "'5.1, 2, 3', 'hello_world'", "output": "'hello_world5.1, 2, 3'", "imports": [], "original_snippet": "def f(name, info):\n digits = str(info).replace(',', '').split('.')\n reverse_digits = digits[::-1]\n reverse_string = ''.join(reverse_digits)\n return reverse_string + name", "composite_functions": [], "_input_type": "tuple", "_output_type": "str"} | |
| {"snippet": "from collections import defaultdict\ndef f(layers: list[dict[str, int]]) -> dict[str, int]:\n local_counts = defaultdict(int)\n for layer in layers:\n for (key, value) in layer.items():\n local_counts[key] += value\n final_dict = {}\n for (key, value) in local_counts.items():\n all_keys = [k for l in layers for (k, v) in l.items() if k == key]\n if len(all_keys) > 1:\n final_dict[key] = value\n return final_dict", "input": "[{'a': 1, 'b': 2}, {'b': 1, 'c': 1}, {'a': 2, 'b': 1}]", "output": "{'a': 3, 'b': 4}", "imports": ["from collections import defaultdict"], "original_snippet": "from collections import defaultdict\ndef f(layers: list[dict[str, int]]) -> dict[str, int]:\n local_counts = defaultdict(int)\n for layer in layers:\n for (key, value) in layer.items():\n local_counts[key] += value\n final_dict = {}\n for (key, value) in local_counts.items():\n all_keys = [k for l in layers for (k, v) in l.items() if k == key]\n if len(all_keys) > 1:\n final_dict[key] = value\n return final_dict", "composite_functions": [], "_input_type": "list", "_output_type": "dict"} | |
| {"snippet": "def f(input_string):\n output = ''\n for i in range(len(input_string)):\n output += input_string[-(i + 1)]\n return output", "input": "'World'", "output": "'dlroW'", "imports": [], "original_snippet": "def f(input_string):\n output = ''\n for i in range(len(input_string)):\n output += input_string[-(i + 1)]\n return output", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(val):\n val = int(val)\n binary_number = bin(val)\n new_val = bin(val | 1 << 31)\n return new_val[2:]", "input": "0", "output": "'10000000000000000000000000000000'", "imports": [], "original_snippet": "def f(val):\n val = int(val)\n binary_number = bin(val)\n new_val = bin(val | 1 << 31)\n return new_val[2:]", "composite_functions": [], "_input_type": "int", "_output_type": "str"} | |
| {"snippet": "def f(custom_data: list, proposed_list: list):\n new_list = []\n for element in proposed_list:\n stack = []\n for item in custom_data:\n if isinstance(item, dict):\n values = item.values()\n if all((value > element for value in values)):\n stack.append((custom_data.index(item), element))\n elif item > element:\n stack.append((custom_data.index(item), element))\n new_list.append(stack[-1][0] if stack else None)\n return [item if item is not None else False for item in new_list]", "input": "custom_data = [1, 2, 3, 4, 5, 6, 7],\nproposed_list = [9, 8, 7, 6, 5, 4, 3]", "output": "[False, False, False, 6, 6, 6, 6]", "imports": [], "original_snippet": "def f(custom_data: list, proposed_list: list):\n new_list = []\n for element in proposed_list:\n stack = []\n for item in custom_data:\n if isinstance(item, dict):\n values = item.values()\n if all((value > element for value in values)):\n stack.append((custom_data.index(item), element))\n elif item > element:\n stack.append((custom_data.index(item), element))\n new_list.append(stack[-1][0] if stack else None)\n return [item if item is not None else False for item in new_list]", "composite_functions": [], "_input_type": "str", "_output_type": "list"} | |
| {"snippet": "import math\ndef f(input_list: list):\n input_list.sort()\n even_list = [input_list[i] for i in range(len(input_list)) if i % 2 == 0]\n new_list = [even_list[0], even_list[len(even_list) - 1]]\n for i in range(1, len(even_list)):\n avg = (even_list[i] + even_list[i - 1]) / 2\n new_list.append(avg)\n input_list.pop(i)\n while len(input_list) > 1:\n avg = sum(input_list) / len(input_list)\n new_list.append(avg)\n input_list = [input_list[0]]\n new_list.sort(reverse=True)\n product = math.prod(new_list)\n return product", "input": "[3, 5, 7, 11, 17]", "output": "27540.0", "imports": ["import math"], "original_snippet": "import math\ndef f(input_list: list):\n input_list.sort()\n even_list = [input_list[i] for i in range(len(input_list)) if i % 2 == 0]\n new_list = [even_list[0], even_list[len(even_list) - 1]]\n for i in range(1, len(even_list)):\n avg = (even_list[i] + even_list[i - 1]) / 2\n new_list.append(avg)\n input_list.pop(i)\n while len(input_list) > 1:\n avg = sum(input_list) / len(input_list)\n new_list.append(avg)\n input_list = [input_list[0]]\n new_list.sort(reverse=True)\n product = math.prod(new_list)\n return product", "composite_functions": [], "_input_type": "list", "_output_type": "float"} | |
| {"snippet": "def f(output_list: list) -> int:\n if not hasattr(f, 'length'):\n f.length = len(output_list)\n total_sum = 0\n for i in range(f.length):\n total_sum += output_list[i]\n return total_sum", "input": "[1, 8, 3, 4, 6]", "output": "22", "imports": [], "original_snippet": "def f(output_list: list) -> int:\n if not hasattr(f, 'length'):\n f.length = len(output_list)\n total_sum = 0\n for i in range(f.length):\n total_sum += output_list[i]\n return total_sum", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "from typing import List, Dict, Iterator\ndef f(data: List[Dict[str, Dict[str, int]]]) -> Iterator[int]:\n for row in data:\n local_counts = {}\n for (key, val) in row.items():\n if len(val) == 3 and 'name' in val and (val['name'] == 'Deep-Thinking'):\n yield val['value']\n for (key, val) in row.items():\n if 'role' in val and val['role'] == 'Solver':\n all_keys = [k for r in data for (k, v) in r.items() if k == key]\n if len(all_keys) > 1:\n names = [name for r in data for (k, name) in r.items() if k == key]\n yield names[1]", "input": "data = [{'a': {'name': 'Dog', 'role': 'Listener'}, 'counts': {'name': 'Deep-Thinking', 'value': 2}}, \n {'b': {'name': 'Cat', 'role': 'Solver'}, 'counts': {'name': 'Deep-Thinking', 'value': 3}}, \n {'c': {'name': 'Bird', 'role': 'Listener'}, 'counts': {'name': 'Deeper-Then-Deep-Thinking', 'value': 4}}]", "output": "", "imports": ["from typing import List, Dict, Iterator"], "original_snippet": "from typing import List, Dict, Iterator\ndef f(data: List[Dict[str, Dict[str, int]]]) -> Iterator[int]:\n for row in data:\n local_counts = {}\n for (key, val) in row.items():\n if len(val) == 3 and 'name' in val and (val['name'] == 'Deep-Thinking'):\n yield val['value']\n for (key, val) in row.items():\n if 'role' in val and val['role'] == 'Solver':\n all_keys = [k for r in data for (k, v) in r.items() if k == key]\n if len(all_keys) > 1:\n names = [name for r in data for (k, name) in r.items() if k == key]\n yield names[1]", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(x):\n result = ''\n for i in range(len(x)):\n palindrome = x[i] + result + x[i][::-1]\n result = palindrome\n return result", "input": "['abc', 'def', 'ghi']", "output": "'ghidefabccbafedihg'", "imports": [], "original_snippet": "def f(x):\n result = ''\n for i in range(len(x)):\n palindrome = x[i] + result + x[i][::-1]\n result = palindrome\n return result", "composite_functions": [], "_input_type": "list", "_output_type": "str"} | |
| {"snippet": "def f(input_string):\n if len(input_string) == 0:\n return ''\n a_to_f = ['a', 'b', 'c', 'd', 'e', 'f']\n transformed_characters = [''] * len(input_string)\n for (i, curr_char) in enumerate(input_string):\n if i % 3 == 0:\n transformed_characters[i] = 'a'\n elif i % 3 == 1:\n transformed_characters[i] = 'b'\n elif i % 3 == 2:\n transformed_characters[i] = 'c'\n return ''.join(transformed_characters) + input_string[::-1]", "input": "'abcabcdefgabcdefg'", "output": "'abcabcabcabcabcabgfedcbagfedcbacba'", "imports": [], "original_snippet": "def f(input_string):\n if len(input_string) == 0:\n return ''\n a_to_f = ['a', 'b', 'c', 'd', 'e', 'f']\n transformed_characters = [''] * len(input_string)\n for (i, curr_char) in enumerate(input_string):\n if i % 3 == 0:\n transformed_characters[i] = 'a'\n elif i % 3 == 1:\n transformed_characters[i] = 'b'\n elif i % 3 == 2:\n transformed_characters[i] = 'c'\n return ''.join(transformed_characters) + input_string[::-1]", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(n: int) -> int:\n if n == 1:\n return 1\n elif n == 4:\n return 3\n elif n == 7:\n return 6\n elif n == 10:\n return 7\n elif n == 13:\n return 10", "input": "12", "output": "None", "imports": [], "original_snippet": "def f(n: int) -> int:\n if n == 1:\n return 1\n elif n == 4:\n return 3\n elif n == 7:\n return 6\n elif n == 10:\n return 7\n elif n == 13:\n return 10", "composite_functions": [], "_input_type": "int", "_output_type": "NoneType"} | |
| {"snippet": "def f(mystring: str) -> int:\n finallist = []\n stringtemp = str(mystring)\n stringlist = stringtemp.split()\n for word in stringlist:\n if word.isdigit():\n if ''.join(word) in ['12', '31', '365']:\n finallist += [abs(int(word))]\n else:\n finallist += [int(word)]\n else:\n finallist += ['abc']\n return len(finallist)", "input": "\"Jan 1 2022\"", "output": "3", "imports": [], "original_snippet": "def f(mystring: str) -> int:\n finallist = []\n stringtemp = str(mystring)\n stringlist = stringtemp.split()\n for word in stringlist:\n if word.isdigit():\n if ''.join(word) in ['12', '31', '365']:\n finallist += [abs(int(word))]\n else:\n finallist += [int(word)]\n else:\n finallist += ['abc']\n return len(finallist)", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(m: str) -> str:\n middle_char = m[len(m) // 2]\n middle_index = len(m) // 2\n tuple_m_minus_theres = tuple((ord(char) for char in m))\n message_minus_theres_converted = chr(tuple_m_minus_theres[middle_index]) + chr(middle_index)\n final_composition_mess_x = middle_char + message_minus_theres_converted\n final_string_x = final_composition_mess_x[::-1] + 'x'\n return final_string_x", "input": "'Hello world'", "output": "'\\x05 x'", "imports": [], "original_snippet": "def f(m: str) -> str:\n middle_char = m[len(m) // 2]\n middle_index = len(m) // 2\n tuple_m_minus_theres = tuple((ord(char) for char in m))\n message_minus_theres_converted = chr(tuple_m_minus_theres[middle_index]) + chr(middle_index)\n final_composition_mess_x = middle_char + message_minus_theres_converted\n final_string_x = final_composition_mess_x[::-1] + 'x'\n return final_string_x", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(nums: list, target: int) -> list:\n dp = [[False for _ in range(target + 1)] for _ in range(len(nums) + 1)]\n for i in range(len(nums) + 1):\n dp[i][0] = True\n for i in range(1, len(nums) + 1):\n for j in range(1, target + 1):\n if nums[i - 1] > j:\n dp[i][j] = dp[i - 1][j]\n else:\n dp[i][j] = dp[i - 1][j] or dp[i - 1][j - nums[i - 1]]\n result = []\n (i, j) = (len(nums), target)\n while i > 0 and j > 0:\n if dp[i][j] == dp[i - 1][j]:\n i -= 1\n else:\n result.append(nums[i - 1])\n j -= nums[i - 1]\n i -= 1\n result.reverse()\n return result", "input": "[4, 11, 6, 3, 5, 8], 20", "output": "[11, 6, 3]", "imports": [], "original_snippet": "def f(nums: list, target: int) -> list:\n dp = [[False for _ in range(target + 1)] for _ in range(len(nums) + 1)]\n for i in range(len(nums) + 1):\n dp[i][0] = True\n for i in range(1, len(nums) + 1):\n for j in range(1, target + 1):\n if nums[i - 1] > j:\n dp[i][j] = dp[i - 1][j]\n else:\n dp[i][j] = dp[i - 1][j] or dp[i - 1][j - nums[i - 1]]\n result = []\n (i, j) = (len(nums), target)\n while i > 0 and j > 0:\n if dp[i][j] == dp[i - 1][j]:\n i -= 1\n else:\n result.append(nums[i - 1])\n j -= nums[i - 1]\n i -= 1\n result.reverse()\n return result", "composite_functions": [], "_input_type": "tuple", "_output_type": "list"} | |
| {"snippet": "def f(matrix):\n visited = [[False] * len(matrix[0]) for _ in range(len(matrix))]\n start_row = None\n start_col = None\n end_row = None\n end_col = None\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n if matrix[i][j] == 'X':\n start_row = i\n start_col = j\n break\n if start_row is not None:\n break\n for i in range(len(matrix) - 1, -1, -1):\n for j in range(len(matrix[0]) - 1, -1, -1):\n if matrix[i][j] == 'X':\n end_row = i\n end_col = j\n break\n if end_row is not None:\n break\n total_area = len(matrix) * len(matrix[0])\n area = 0\n (dy, dx) = ([1, -1, 0, 0], [0, 0, 1, -1])\n visited[start_row][start_col] = True\n stack = [(start_row, start_col)]\n while stack:\n (y, x) = stack.pop()\n area += 1\n for (dy_, dx_) in zip(dy, dx):\n (ny, nx) = (y + dy_, x + dx_)\n if 0 <= ny < len(matrix) and 0 <= nx < len(matrix[0]) and (matrix[ny][nx] == 'X') and (not visited[ny][nx]):\n stack.append((ny, nx))\n visited[ny][nx] = True\n return total_area - area", "input": "[\n ['X', 'X', 'X', 'X'],\n ['X', 'X', 'X', 'X'],\n ['X', 'X', 'X', 'X'],\n ['X', 'X', 'X', 'X']\n]", "output": "0", "imports": [], "original_snippet": "def f(matrix):\n visited = [[False] * len(matrix[0]) for _ in range(len(matrix))]\n start_row = None\n start_col = None\n end_row = None\n end_col = None\n for i in range(len(matrix)):\n for j in range(len(matrix[0])):\n if matrix[i][j] == 'X':\n start_row = i\n start_col = j\n break\n if start_row is not None:\n break\n for i in range(len(matrix) - 1, -1, -1):\n for j in range(len(matrix[0]) - 1, -1, -1):\n if matrix[i][j] == 'X':\n end_row = i\n end_col = j\n break\n if end_row is not None:\n break\n total_area = len(matrix) * len(matrix[0])\n area = 0\n (dy, dx) = ([1, -1, 0, 0], [0, 0, 1, -1])\n visited[start_row][start_col] = True\n stack = [(start_row, start_col)]\n while stack:\n (y, x) = stack.pop()\n area += 1\n for (dy_, dx_) in zip(dy, dx):\n (ny, nx) = (y + dy_, x + dx_)\n if 0 <= ny < len(matrix) and 0 <= nx < len(matrix[0]) and (matrix[ny][nx] == 'X') and (not visited[ny][nx]):\n stack.append((ny, nx))\n visited[ny][nx] = True\n return total_area - area", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(strings):\n strings.reverse()\n ascii_values = [ord(c) for s in strings for c in s]\n products = {}\n for (i, value) in enumerate(ascii_values):\n if value in products:\n products[value] *= i + 1\n else:\n products[value] = i + 1\n return dict(sorted(products.items(), key=lambda item: item[0]))", "input": "['Code', 'Snippets', 'Have', '5', 'Input', 'Points', '109630']", "output": "{48: 12, 49: 1, 51: 5, 53: 18, 54: 4, 57: 3, 67: 31, 72: 19, 73: 13, 80: 7, 83: 23, 97: 20, 100: 33, 101: 20944, 105: 225, 110: 3360, 111: 256, 112: 10530, 115: 360, 116: 5423, 117: 16, 118: 21}", "imports": [], "original_snippet": "def f(strings):\n strings.reverse()\n ascii_values = [ord(c) for s in strings for c in s]\n products = {}\n for (i, value) in enumerate(ascii_values):\n if value in products:\n products[value] *= i + 1\n else:\n products[value] = i + 1\n return dict(sorted(products.items(), key=lambda item: item[0]))", "composite_functions": [], "_input_type": "list", "_output_type": "dict"} | |
| {"snippet": "import timeit\ndef f(s: str):\n word = 'pith'\n for start in range(len(word)):\n for end in range(len(word)):\n sub = word[start:end + 1]\n if sub == sub[::-1] and s.count(sub) < 1:\n return 'does not end with dummy pith'\n return 'not at pith'", "input": "'addhamama'", "output": "'does not end with dummy pith'", "imports": ["import timeit"], "original_snippet": "import timeit\ndef f(s: str):\n word = 'pith'\n for start in range(len(word)):\n for end in range(len(word)):\n sub = word[start:end + 1]\n if sub == sub[::-1] and s.count(sub) < 1:\n return 'does not end with dummy pith'\n return 'not at pith'", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(n: int) -> int:\n result = 0\n for i in range(1, n + 1):\n result += i * i * (i - 1) % 256\n return result ** 3", "input": "10", "output": "609800192", "imports": [], "original_snippet": "def f(n: int) -> int:\n result = 0\n for i in range(1, n + 1):\n result += i * i * (i - 1) % 256\n return result ** 3", "composite_functions": [], "_input_type": "int", "_output_type": "int"} | |
| {"snippet": "import string\ndef f(words: list) -> dict:\n frequency = {}\n for word in words:\n word = word.strip(string.punctuation)\n word = word.lower()\n if word not in frequency:\n frequency[word] = 1\n else:\n frequency[word] += 1\n return frequency", "input": "['Hello', 'world!', 'Hello,', 'world!', 'Hi', 'world!']", "output": "{'hello': 2, 'world': 3, 'hi': 1}", "imports": ["import string"], "original_snippet": "import string\ndef f(words: list) -> dict:\n frequency = {}\n for word in words:\n word = word.strip(string.punctuation)\n word = word.lower()\n if word not in frequency:\n frequency[word] = 1\n else:\n frequency[word] += 1\n return frequency", "composite_functions": [], "_input_type": "list", "_output_type": "dict"} | |
| {"snippet": "def f(s):\n temp_string = []\n for (i, ch) in enumerate(s):\n if ch.isdigit():\n if len(temp_string) > 0 and int(temp_string[-1]) % 2:\n temp_string.append(ch)\n return temp_string", "input": "'sg112g4f'", "output": "[]", "imports": [], "original_snippet": "def f(s):\n temp_string = []\n for (i, ch) in enumerate(s):\n if ch.isdigit():\n if len(temp_string) > 0 and int(temp_string[-1]) % 2:\n temp_string.append(ch)\n return temp_string", "composite_functions": [], "_input_type": "str", "_output_type": "list"} | |
| {"snippet": "def f(input_string: str) -> str:\n result = ''\n odd = True\n for char in reversed(input_string):\n if odd:\n result += char\n else:\n result = char + result\n odd = not odd\n return result", "input": "input_string = \"GWD\"", "output": "'WDG'", "imports": [], "original_snippet": "def f(input_string: str) -> str:\n result = ''\n odd = True\n for char in reversed(input_string):\n if odd:\n result += char\n else:\n result = char + result\n odd = not odd\n return result", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(numbers):\n sum_of_squares = 0\n for num in numbers:\n sum_of_squares += num ** 2\n return sum_of_squares", "input": "[1, 2, 3, 4, 5]", "output": "55", "imports": [], "original_snippet": "def f(numbers):\n sum_of_squares = 0\n for num in numbers:\n sum_of_squares += num ** 2\n return sum_of_squares", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(numbers):\n if not numbers:\n return {}\n sorted_numbers = sorted(numbers)\n unique_sorted_numbers = {}\n for i in range(len(sorted_numbers)):\n if sorted_numbers[i] not in unique_sorted_numbers:\n unique_sorted_numbers[sorted_numbers[i]] = []\n unique_sorted_numbers[sorted_numbers[i]].append(i)\n return unique_sorted_numbers", "input": "numbers = [5, 6, 3, 2, 1, 1, 4, 5]", "output": "{1: [0, 1], 2: [2], 3: [3], 4: [4], 5: [5, 6], 6: [7]}", "imports": [], "original_snippet": "def f(numbers):\n if not numbers:\n return {}\n sorted_numbers = sorted(numbers)\n unique_sorted_numbers = {}\n for i in range(len(sorted_numbers)):\n if sorted_numbers[i] not in unique_sorted_numbers:\n unique_sorted_numbers[sorted_numbers[i]] = []\n unique_sorted_numbers[sorted_numbers[i]].append(i)\n return unique_sorted_numbers", "composite_functions": [], "_input_type": "str", "_output_type": "dict"} | |
| {"snippet": "def f(list_of_strings):\n unique_elements = list(dict.fromkeys(list_of_strings))\n sub_lists = []\n for i in range(len(unique_elements)):\n for j in range(i + 1, len(unique_elements)):\n sub_lists.append(unique_elements[i:j])\n for sub_list in sub_lists:\n sum_sub_list = sum(list(map(int, sub_list)))\n if sum_sub_list == 5:\n sub_list_str = ''.join((str(i) for i in sub_list))\n return sub_list_str\n return None", "input": "['1', '2', '3', '4', '1', '2', '5', '6', '7']", "output": "'23'", "imports": [], "original_snippet": "def f(list_of_strings):\n unique_elements = list(dict.fromkeys(list_of_strings))\n sub_lists = []\n for i in range(len(unique_elements)):\n for j in range(i + 1, len(unique_elements)):\n sub_lists.append(unique_elements[i:j])\n for sub_list in sub_lists:\n sum_sub_list = sum(list(map(int, sub_list)))\n if sum_sub_list == 5:\n sub_list_str = ''.join((str(i) for i in sub_list))\n return sub_list_str\n return None", "composite_functions": [], "_input_type": "list", "_output_type": "str"} | |
| {"snippet": "def f(input_str: str, s: str) -> dict:\n if len(input_str) != len(s):\n return 'The strings have different lengths'\n output_dict = {}\n for i in range(len(input_str)):\n if input_str[i] == s[i]:\n output_dict[input_str[i]] = i\n return output_dict", "input": "\"abcde\", \"edcba\"", "output": "{'c': 2}", "imports": [], "original_snippet": "def f(input_str: str, s: str) -> dict:\n if len(input_str) != len(s):\n return 'The strings have different lengths'\n output_dict = {}\n for i in range(len(input_str)):\n if input_str[i] == s[i]:\n output_dict[input_str[i]] = i\n return output_dict", "composite_functions": [], "_input_type": "tuple", "_output_type": "dict"} | |
| {"snippet": "import sympy\ndef f(s: str) -> int:\n substr_count = 0\n for i in range(len(s) + 1):\n for j in range(i):\n sub_str = s[j:i]\n digit_sum = sum((int(ch) for ch in sub_str if ch.isdigit()))\n if sympy.isprime(digit_sum):\n substr_count += 1\n return substr_count", "input": "\"abcabcabc\"", "output": "0", "imports": ["import sympy"], "original_snippet": "import sympy\ndef f(s: str) -> int:\n substr_count = 0\n for i in range(len(s) + 1):\n for j in range(i):\n sub_str = s[j:i]\n digit_sum = sum((int(ch) for ch in sub_str if ch.isdigit()))\n if sympy.isprime(digit_sum):\n substr_count += 1\n return substr_count", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(input_string: str) -> str:\n transformed_string = []\n shift_count = 0\n for (i, char) in enumerate(input_string):\n shifted_char = chr(ord(char) + i % len(input_string))\n transformed_string.append(shifted_char)\n return ''.join(transformed_string)", "input": "'hello world'", "output": "'hfnos%}vzun'", "imports": [], "original_snippet": "def f(input_string: str) -> str:\n transformed_string = []\n shift_count = 0\n for (i, char) in enumerate(input_string):\n shifted_char = chr(ord(char) + i % len(input_string))\n transformed_string.append(shifted_char)\n return ''.join(transformed_string)", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(output_string: str) -> str:\n alpha = 'abcdefghijklmnopqrstuvwxyz'\n index = 125\n result = ''\n temp_alpha = ''\n for char in output_string:\n if char.isalpha():\n temp_alpha += char\n else:\n result += (alpha[index - 1] if index - 1 >= 0 else alpha[25]) * len(temp_alpha)\n temp_alpha = alpha[index - 1] if index - 1 >= 0 else alpha[25]\n index += 1\n return result", "input": "'abcdefghijklmnopqrstuvwxyz'", "output": "''", "imports": [], "original_snippet": "def f(output_string: str) -> str:\n alpha = 'abcdefghijklmnopqrstuvwxyz'\n index = 125\n result = ''\n temp_alpha = ''\n for char in output_string:\n if char.isalpha():\n temp_alpha += char\n else:\n result += (alpha[index - 1] if index - 1 >= 0 else alpha[25]) * len(temp_alpha)\n temp_alpha = alpha[index - 1] if index - 1 >= 0 else alpha[25]\n index += 1\n return result", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(word):\n word_length = len(word)\n first_char = word[0]\n last_char = word[-1]\n if word_length == 1 or word_length == 3:\n return word\n first_char_count = f'Jen{last_char}'\n if word_length % 3 == 2 and word[-3] in 'aeiou':\n return first_char + first_char_count + word[1] + 'aph'\n if word_length % 3 == 2 and word[-3] not in 'aeiou':\n return first_char + first_char_count + 'vnz'\n if word_length % 3 == 1 and word[-2] == word[-3]:\n return word + 'oph'\n if word_length % 3 == 1 and word[-2] not in 'aeiou':\n return word + 'oph'\n if word_length % 3 == 0:\n return 'not possible'", "input": "'Jens'", "output": "'Jensoph'", "imports": [], "original_snippet": "def f(word):\n word_length = len(word)\n first_char = word[0]\n last_char = word[-1]\n if word_length == 1 or word_length == 3:\n return word\n first_char_count = f'Jen{last_char}'\n if word_length % 3 == 2 and word[-3] in 'aeiou':\n return first_char + first_char_count + word[1] + 'aph'\n if word_length % 3 == 2 and word[-3] not in 'aeiou':\n return first_char + first_char_count + 'vnz'\n if word_length % 3 == 1 and word[-2] == word[-3]:\n return word + 'oph'\n if word_length % 3 == 1 and word[-2] not in 'aeiou':\n return word + 'oph'\n if word_length % 3 == 0:\n return 'not possible'", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(lst):\n even_list = [lst[i] for i in range(len(lst)) if i % 2 == 0 and lst[i] % 2 == 0]\n new_list = []\n for i in range(len(even_list)):\n if i % 2 == 0:\n new_list.append(even_list[i])\n else:\n new_list.append(even_list[i] * even_list[i - 1])\n result = 1\n for elem in new_list:\n result *= elem\n return result", "input": "[3, 5, 7, 11, 17]", "output": "1", "imports": [], "original_snippet": "def f(lst):\n even_list = [lst[i] for i in range(len(lst)) if i % 2 == 0 and lst[i] % 2 == 0]\n new_list = []\n for i in range(len(even_list)):\n if i % 2 == 0:\n new_list.append(even_list[i])\n else:\n new_list.append(even_list[i] * even_list[i - 1])\n result = 1\n for elem in new_list:\n result *= elem\n return result", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "from collections import deque\ndef f(number_string: str) -> str:\n bin_str = bin(int(number_string, 2))[2:]\n parent_number_str = str(int(bin_str, 2) * 2 ** len(bin_str))\n parent_reverse_str = parent_number_str[::-1]\n child_reverse_str = parent_reverse_str[len(parent_reverse_str) // 2:][::-1]\n result = parent_reverse_str[:len(parent_reverse_str) // 2].ljust(len(parent_reverse_str), '0') + '1' + child_reverse_str\n return result", "input": "'110'", "output": "'8014'", "imports": ["from collections import deque"], "original_snippet": "from collections import deque\ndef f(number_string: str) -> str:\n bin_str = bin(int(number_string, 2))[2:]\n parent_number_str = str(int(bin_str, 2) * 2 ** len(bin_str))\n parent_reverse_str = parent_number_str[::-1]\n child_reverse_str = parent_reverse_str[len(parent_reverse_str) // 2:][::-1]\n result = parent_reverse_str[:len(parent_reverse_str) // 2].ljust(len(parent_reverse_str), '0') + '1' + child_reverse_str\n return result", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(n, fib_dict={}):\n if n in fib_dict:\n return fib_dict[n]\n if n == 0:\n fib_dict[0] = 0\n elif n == 1:\n fib_dict[1] = 1\n else:\n fib_dict[n] = f(n - 1, fib_dict) + f(n - 2, fib_dict)\n return fib_dict[n]", "input": "f(5)", "output": "5", "imports": [], "original_snippet": "def f(n, fib_dict={}):\n if n in fib_dict:\n return fib_dict[n]\n if n == 0:\n fib_dict[0] = 0\n elif n == 1:\n fib_dict[1] = 1\n else:\n fib_dict[n] = f(n - 1, fib_dict) + f(n - 2, fib_dict)\n return fib_dict[n]", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(n: int):\n return f'sum({n - 2 * n // 2} + {n - n // 4})'", "input": "10", "output": "'sum(0 + 8)'", "imports": [], "original_snippet": "def f(n: int):\n return f'sum({n - 2 * n // 2} + {n - n // 4})'", "composite_functions": [], "_input_type": "int", "_output_type": "str"} | |
| {"snippet": "def f(numbers: list) -> int:\n sum_products = 0\n length = len(numbers)\n for i in range(1, length - 1):\n sum_products += numbers[i] * numbers[i + 1]\n return sum_products", "input": "[1, 2, 3, 4, 5, 6]", "output": "68", "imports": [], "original_snippet": "def f(numbers: list) -> int:\n sum_products = 0\n length = len(numbers)\n for i in range(1, length - 1):\n sum_products += numbers[i] * numbers[i + 1]\n return sum_products", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(nums):\n if not nums:\n return 0\n nums.sort()\n total = nums[0]\n prev = nums[0]\n for i in range(1, len(nums)):\n if nums[i] != prev:\n total += nums[i]\n prev = nums[i]\n return total", "input": "[1, 2, 3, 1, 4, 5, 4, 6]", "output": "21", "imports": [], "original_snippet": "def f(nums):\n if not nums:\n return 0\n nums.sort()\n total = nums[0]\n prev = nums[0]\n for i in range(1, len(nums)):\n if nums[i] != prev:\n total += nums[i]\n prev = nums[i]\n return total", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(array: list):\n max_current = array[0]\n max_global = array[0]\n for i in range(1, len(array)):\n max_current = max(array[i], max_current + array[i])\n if max_current > max_global:\n max_global = max_current\n return max_global", "input": "[-2, 1, -3, 4, -1, 2, 1, -5, 4]", "output": "6", "imports": [], "original_snippet": "def f(array: list):\n max_current = array[0]\n max_global = array[0]\n for i in range(1, len(array)):\n max_current = max(array[i], max_current + array[i])\n if max_current > max_global:\n max_global = max_current\n return max_global", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(number_list: list):\n return sum(number_list[::-1])", "input": "[2, 5, 8, 10]", "output": "25", "imports": [], "original_snippet": "def f(number_list: list):\n return sum(number_list[::-1])", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(person: dict, items: list):\n items_set = {item for item in items}\n items_set = {items_set: person.items() for items_set in items_set}\n return items_set", "input": "{\n \"name\": \"John Doe\",\n \"age\": 30,\n \"city\": \"New York\"\n},\n[\"items1\", \"items2\", \"items3\"]", "output": "{'items1': dict_items([('name', 'John Doe'), ('age', 30), ('city', 'New York')]), 'items3': dict_items([('name', 'John Doe'), ('age', 30), ('city', 'New York')]), 'items2': dict_items([('name', 'John Doe'), ('age', 30), ('city', 'New York')])}", "imports": [], "original_snippet": "def f(person: dict, items: list):\n items_set = {item for item in items}\n items_set = {items_set: person.items() for items_set in items_set}\n return items_set", "composite_functions": [], "_input_type": "tuple", "_output_type": "str"} | |
| {"snippet": "def f(the_array: list):\n first = the_array[0]\n last = the_array[-1]\n middle_elements = the_array[1:-1]\n if len(middle_elements) % 2 == 0:\n approx = middle_elements[len(middle_elements) // 2 - 1]\n else:\n approx = (middle_elements[len(middle_elements) // 2] + middle_elements[len(middle_elements) // 2 + 1]) / 2\n product = first * last * approx\n return product", "input": "[3, 5, 7, 11, 17]", "output": "459.0", "imports": [], "original_snippet": "def f(the_array: list):\n first = the_array[0]\n last = the_array[-1]\n middle_elements = the_array[1:-1]\n if len(middle_elements) % 2 == 0:\n approx = middle_elements[len(middle_elements) // 2 - 1]\n else:\n approx = (middle_elements[len(middle_elements) // 2] + middle_elements[len(middle_elements) // 2 + 1]) / 2\n product = first * last * approx\n return product", "composite_functions": [], "_input_type": "list", "_output_type": "float"} | |
| {"snippet": "def f(items_dict: dict, string_to_check: str, head_dict: dict=None) -> dict:\n if not head_dict:\n head_dict = {string_to_check: 0}\n for (key, value) in items_dict.items():\n if key not in head_dict:\n head_dict[key] = 0\n if key == string_to_check:\n head_dict[key] = 1\n return head_dict", "input": "{'first': 'first', 'second': 'second', 'third': 'third', 'fourth': 'fourth', 'fifth': 'fourth', 'sixth': 'fourth'},\n'remove_this'", "output": "{'remove_this': 0, 'first': 0, 'second': 0, 'third': 0, 'fourth': 0, 'fifth': 0, 'sixth': 0}", "imports": [], "original_snippet": "def f(items_dict: dict, string_to_check: str, head_dict: dict=None) -> dict:\n if not head_dict:\n head_dict = {string_to_check: 0}\n for (key, value) in items_dict.items():\n if key not in head_dict:\n head_dict[key] = 0\n if key == string_to_check:\n head_dict[key] = 1\n return head_dict", "composite_functions": [], "_input_type": "tuple", "_output_type": "dict"} | |
| {"snippet": "def f(datalist: list):\n output = []\n for (i, item) in enumerate(datalist):\n if i % 2 == 0:\n sublist = datalist[:i + 1]\n sublist.reverse()\n output.extend(sublist)\n else:\n output.append(item)\n datalist = output\n return output", "input": "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]", "output": "[0, 1, 1, 0, 3, 3, 0, 1, 1, 0, 5, 0, 3, 3, 0, 1, 1, 0, 7, 1, 1, 0, 3, 3, 0, 1, 1, 0, 9]", "imports": [], "original_snippet": "def f(datalist: list):\n output = []\n for (i, item) in enumerate(datalist):\n if i % 2 == 0:\n sublist = datalist[:i + 1]\n sublist.reverse()\n output.extend(sublist)\n else:\n output.append(item)\n datalist = output\n return output", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(input_string: str):\n my_string = ''\n for (i, elem) in enumerate(input_string):\n if i < 2:\n my_string += elem\n else:\n my_string += elem + 'e'\n my_list = [i for i in my_string]\n return my_list", "input": "'Hello world'", "output": "['H', 'e', 'l', 'e', 'l', 'e', 'o', 'e', ' ', 'e', 'w', 'e', 'o', 'e', 'r', 'e', 'l', 'e', 'd', 'e']", "imports": [], "original_snippet": "def f(input_string: str):\n my_string = ''\n for (i, elem) in enumerate(input_string):\n if i < 2:\n my_string += elem\n else:\n my_string += elem + 'e'\n my_list = [i for i in my_string]\n return my_list", "composite_functions": [], "_input_type": "str", "_output_type": "list"} | |
| {"snippet": "from typing import Dict\ndef f(name: str, info: Dict[str, int]):\n if len(name) != len(info):\n return 'The strings have different lengths'\n result = {}\n for i in range(len(name)):\n if name[i] == info.get(name[i], None):\n result[name[i]] = i\n return result", "input": "'abC', {'a': 1, 'b': 2, 'C': 3}", "output": "{}", "imports": ["from typing import Dict"], "original_snippet": "from typing import Dict\ndef f(name: str, info: Dict[str, int]):\n if len(name) != len(info):\n return 'The strings have different lengths'\n result = {}\n for i in range(len(name)):\n if name[i] == info.get(name[i], None):\n result[name[i]] = i\n return result", "composite_functions": [], "_input_type": "tuple", "_output_type": "dict"} | |
| {"snippet": "def f(numbers):\n if len(numbers) == 0:\n return 0\n if len(numbers) == 1:\n return numbers[0]\n max_sum = -float('inf')\n max_length = len(numbers)\n for end in range(3, max_length):\n current_sum = numbers[0]\n for i in range(end):\n current_sum += numbers[i]\n max_sum = max(max_sum, current_sum)\n if end - i > 3:\n current_sum -= numbers[i - (end - i - 1)]\n return max_sum", "input": "[1, 2, 3, 4, 5]", "output": "8", "imports": [], "original_snippet": "def f(numbers):\n if len(numbers) == 0:\n return 0\n if len(numbers) == 1:\n return numbers[0]\n max_sum = -float('inf')\n max_length = len(numbers)\n for end in range(3, max_length):\n current_sum = numbers[0]\n for i in range(end):\n current_sum += numbers[i]\n max_sum = max(max_sum, current_sum)\n if end - i > 3:\n current_sum -= numbers[i - (end - i - 1)]\n return max_sum", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(numbers):\n transformed_numbers = []\n for x in sorted(numbers, reverse=True):\n transformed_numbers.append(x + (x // 2 if x % 2 != 0 else x))\n return sum(transformed_numbers)", "input": "[98, 54, 2, 4, 11]", "output": "332", "imports": [], "original_snippet": "def f(numbers):\n transformed_numbers = []\n for x in sorted(numbers, reverse=True):\n transformed_numbers.append(x + (x // 2 if x % 2 != 0 else x))\n return sum(transformed_numbers)", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(numbers):\n current_sum = 0\n current_product = 1\n for num in numbers:\n num_squared = num ** 2\n current_sum += num_squared\n current_product *= num_squared\n current_product %= current_sum\n return current_product", "input": "[1, 2, 3, 4]", "output": "0", "imports": [], "original_snippet": "def f(numbers):\n current_sum = 0\n current_product = 1\n for num in numbers:\n num_squared = num ** 2\n current_sum += num_squared\n current_product *= num_squared\n current_product %= current_sum\n return current_product", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(s, k):\n if len(s) < k:\n return s\n custom_string = ''\n while len(custom_string) < k:\n custom_string += s[len(s) - k] + s[len(s) - (k - 1):]\n s = s[:-1]\n return custom_string", "input": "'hello world', 4", "output": "'orld'", "imports": [], "original_snippet": "def f(s, k):\n if len(s) < k:\n return s\n custom_string = ''\n while len(custom_string) < k:\n custom_string += s[len(s) - k] + s[len(s) - (k - 1):]\n s = s[:-1]\n return custom_string", "composite_functions": [], "_input_type": "tuple", "_output_type": "str"} | |
| {"snippet": "import string\ndef f(text):\n output = ''\n for char in text:\n if char.lower() in string.ascii_lowercase:\n output += char.upper()\n elif char in string.whitespace:\n output += char\n else:\n output += char.lower()\n half_len = len(text) // 2\n trip_chars = set('trip')\n for (i, char) in enumerate(text):\n if half_len <= i <= len(text) - half_len and char.lower() not in trip_chars:\n output += char\n word_list = output.split()\n i = 0\n for word in word_list:\n if i % 2 == 0:\n output = output.replace(word, word.capitalize())\n i += 1\n else:\n i += 1\n return output[::-1]", "input": "'sunny day'", "output": "' yYAD ynnuS'", "imports": ["import string"], "original_snippet": "import string\ndef f(text):\n output = ''\n for char in text:\n if char.lower() in string.ascii_lowercase:\n output += char.upper()\n elif char in string.whitespace:\n output += char\n else:\n output += char.lower()\n half_len = len(text) // 2\n trip_chars = set('trip')\n for (i, char) in enumerate(text):\n if half_len <= i <= len(text) - half_len and char.lower() not in trip_chars:\n output += char\n word_list = output.split()\n i = 0\n for word in word_list:\n if i % 2 == 0:\n output = output.replace(word, word.capitalize())\n i += 1\n else:\n i += 1\n return output[::-1]", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "from collections import defaultdict\ndef f(nums):\n if not nums:\n return 0\n nums.sort()\n total = nums[0]\n prev = nums[0]\n answers_dict = defaultdict(list)\n for i in range(1, len(nums)):\n if abs(nums[i] - prev) == 2 and (not prev == nums[i]):\n answers_dict[nums[i]].append(prev)\n prev = nums[i]\n for num in sorted(answers_dict.keys(), reverse=True):\n answer_options = [answer for answer in answers_dict[num]]\n if len(answer_options) >= 1:\n return num + sum(answer_options)\n return 0", "input": "[2, 5, 7, 9, 11, 13, 17, 19, 23, 29]", "output": "36", "imports": ["from collections import defaultdict"], "original_snippet": "from collections import defaultdict\ndef f(nums):\n if not nums:\n return 0\n nums.sort()\n total = nums[0]\n prev = nums[0]\n answers_dict = defaultdict(list)\n for i in range(1, len(nums)):\n if abs(nums[i] - prev) == 2 and (not prev == nums[i]):\n answers_dict[nums[i]].append(prev)\n prev = nums[i]\n for num in sorted(answers_dict.keys(), reverse=True):\n answer_options = [answer for answer in answers_dict[num]]\n if len(answer_options) >= 1:\n return num + sum(answer_options)\n return 0", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(custom_arr):\n result_arr = []\n (i, n) = (0, len(custom_arr))\n while i < n:\n if i + 1 < n and custom_arr[i] + 1 == custom_arr[i + 1]:\n i += 1\n continue\n result_arr.append(custom_arr[i])\n result_arr.append(custom_arr[i] + 1)\n i += 1\n return result_arr", "input": "[1, 3, 8, 10, 12]", "output": "[1, 2, 3, 4, 8, 9, 10, 11, 12, 13]", "imports": [], "original_snippet": "def f(custom_arr):\n result_arr = []\n (i, n) = (0, len(custom_arr))\n while i < n:\n if i + 1 < n and custom_arr[i] + 1 == custom_arr[i + 1]:\n i += 1\n continue\n result_arr.append(custom_arr[i])\n result_arr.append(custom_arr[i] + 1)\n i += 1\n return result_arr", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "from collections import Counter\ndef f(strings: list):\n if not strings:\n return {}\n combined_chars = ''.join(strings)\n freq_dict = Counter(combined_chars)\n return sorted(freq_dict.items(), key=lambda pair: (-pair[1], pair[0]))", "input": "['Hello world.', 'Sample text!']", "output": "[('l', 4), ('e', 3), (' ', 2), ('o', 2), ('t', 2), ('!', 1), ('.', 1), ('H', 1), ('S', 1), ('a', 1), ('d', 1), ('m', 1), ('p', 1), ('r', 1), ('w', 1), ('x', 1)]", "imports": ["from collections import Counter"], "original_snippet": "from collections import Counter\ndef f(strings: list):\n if not strings:\n return {}\n combined_chars = ''.join(strings)\n freq_dict = Counter(combined_chars)\n return sorted(freq_dict.items(), key=lambda pair: (-pair[1], pair[0]))", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(input_list: list) -> list:\n transformed_list = []\n for number in input_list:\n if number % 2 == 0 and number % 3 == 0:\n transformed_list.append(number // 3)\n elif number % 2 == 0:\n transformed_list.append(number ** 2)\n elif number % 3 == 0:\n transformed_list.append(number - 1)\n else:\n transformed_list.append(number + 1)\n return transformed_list", "input": "[1, 2, 3, 4, 5, 6, 8, 9, 12, 15]", "output": "[2, 4, 2, 16, 6, 2, 64, 8, 4, 14]", "imports": [], "original_snippet": "def f(input_list: list) -> list:\n transformed_list = []\n for number in input_list:\n if number % 2 == 0 and number % 3 == 0:\n transformed_list.append(number // 3)\n elif number % 2 == 0:\n transformed_list.append(number ** 2)\n elif number % 3 == 0:\n transformed_list.append(number - 1)\n else:\n transformed_list.append(number + 1)\n return transformed_list", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(a_list: list):\n sorted_list = sorted(a_list, reverse=True)\n fibonacci_list = []\n sum_list = []\n for (i, val) in enumerate(sorted_list):\n fibonacci_list.append(val * pow(1.618033988749895, i) - val)\n sum_list.append(sum(fibonacci_list))\n return sum_list[-1]", "input": "[5, 3, 7, 2, 1]", "output": "20.270509831248425", "imports": [], "original_snippet": "def f(a_list: list):\n sorted_list = sorted(a_list, reverse=True)\n fibonacci_list = []\n sum_list = []\n for (i, val) in enumerate(sorted_list):\n fibonacci_list.append(val * pow(1.618033988749895, i) - val)\n sum_list.append(sum(fibonacci_list))\n return sum_list[-1]", "composite_functions": [], "_input_type": "list", "_output_type": "float"} | |
| {"snippet": "def f(n: str):\n alphabet = 'abcdefghijklmnopqrstuvwxyz'\n frequency = {}\n for char in n:\n if char.lower() in alphabet:\n frequency[char.lower()] = frequency.get(char.lower(), 0) + 1\n return [(key, value) for (key, value) in sorted(frequency.items())]", "input": "'Example'", "output": "[('a', 1), ('e', 2), ('l', 1), ('m', 1), ('p', 1), ('x', 1)]", "imports": [], "original_snippet": "def f(n: str):\n alphabet = 'abcdefghijklmnopqrstuvwxyz'\n frequency = {}\n for char in n:\n if char.lower() in alphabet:\n frequency[char.lower()] = frequency.get(char.lower(), 0) + 1\n return [(key, value) for (key, value) in sorted(frequency.items())]", "composite_functions": [], "_input_type": "str", "_output_type": "list"} | |
| {"snippet": "def f(words_list) -> str:\n if len(words_list) == 1:\n result = words_list[0]\n elif words_list[0][0] == 'z':\n words_list.sort(reverse=True)\n result = f(words_list[1:])\n else:\n words_list.sort(key=lambda x: x[0])\n result = words_list[0]\n return result", "input": "['abc', 'smol', 'fs', 'milk', 'world', 'we', 'hello', 'moon', 'twigs', 'kitty', 'desk', 'robot', 'ktg', 'gun',]", "output": "'abc'", "imports": [], "original_snippet": "def f(words_list) -> str:\n if len(words_list) == 1:\n result = words_list[0]\n elif words_list[0][0] == 'z':\n words_list.sort(reverse=True)\n result = f(words_list[1:])\n else:\n words_list.sort(key=lambda x: x[0])\n result = words_list[0]\n return result", "composite_functions": [], "_input_type": "list", "_output_type": "str"} | |
| {"snippet": "from collections.abc import Sequence\ndef f(nums: Sequence[int]) -> int:\n n = len(nums)\n if n == 1:\n return nums[0]\n bestSum = [nums[0]] + [0] * (n - 1)\n for i in range(n - 1):\n currMax = nums[i]\n for j in range(i + 1, n):\n currMax = max(currMax + nums[j], bestSum[j])\n bestSum[i] = currMax\n return max(bestSum)", "input": "[2, 3, 7, 9, 5]", "output": "26", "imports": ["from collections.abc import Sequence"], "original_snippet": "from collections.abc import Sequence\ndef f(nums: Sequence[int]) -> int:\n n = len(nums)\n if n == 1:\n return nums[0]\n bestSum = [nums[0]] + [0] * (n - 1)\n for i in range(n - 1):\n currMax = nums[i]\n for j in range(i + 1, n):\n currMax = max(currMax + nums[j], bestSum[j])\n bestSum[i] = currMax\n return max(bestSum)", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(entry: str) -> str:\n letters = {}\n for i in range(len(entry)):\n if entry[i] in letters:\n letters[entry[i]] += 1\n else:\n letters[entry[i]] = 0\n max_occurrences = max(letters.values())\n count = 0\n result = ''\n for (key, value) in letters.items():\n if value == max_occurrences:\n result += key\n count += 1\n elif value > max_occurrences:\n result += entry[i]\n if count == 1:\n result = result[0]\n else:\n result = result[0]\n return result", "input": "'aaabbbccc'", "output": "'a'", "imports": [], "original_snippet": "def f(entry: str) -> str:\n letters = {}\n for i in range(len(entry)):\n if entry[i] in letters:\n letters[entry[i]] += 1\n else:\n letters[entry[i]] = 0\n max_occurrences = max(letters.values())\n count = 0\n result = ''\n for (key, value) in letters.items():\n if value == max_occurrences:\n result += key\n count += 1\n elif value > max_occurrences:\n result += entry[i]\n if count == 1:\n result = result[0]\n else:\n result = result[0]\n return result", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(string_with_positive_integers: str) -> int:\n total_sum = 0\n numbers = [int(char) for char in string_with_positive_integers]\n total_sum = sum(numbers)\n return total_sum", "input": "'1234'", "output": "10", "imports": [], "original_snippet": "def f(string_with_positive_integers: str) -> int:\n total_sum = 0\n numbers = [int(char) for char in string_with_positive_integers]\n total_sum = sum(numbers)\n return total_sum", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(nums):\n if not nums:\n return 0\n nums.sort()\n max_diff = 0\n for i in range(1, len(nums)):\n diff = abs(nums[i] - nums[i - 1])\n if diff > max_diff:\n max_diff = diff\n return max_diff", "input": "[5, 3, 1, 6, 8, 9]", "output": "2", "imports": [], "original_snippet": "def f(nums):\n if not nums:\n return 0\n nums.sort()\n max_diff = 0\n for i in range(1, len(nums)):\n diff = abs(nums[i] - nums[i - 1])\n if diff > max_diff:\n max_diff = diff\n return max_diff", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(input_list):\n result = 0\n for (i, s) in enumerate(input_list):\n if len(s) % 2 == 0:\n for j in range(len(s) // 2):\n result += ord(s[j]) - ord(s[-1 - j])\n else:\n result += ord(s[int(len(s) / 2)]) - ord(s[int(len(s) / 2) - 1])\n return result", "input": "['a', 'b', 'c', 'd', 'e']", "output": "0", "imports": [], "original_snippet": "def f(input_list):\n result = 0\n for (i, s) in enumerate(input_list):\n if len(s) % 2 == 0:\n for j in range(len(s) // 2):\n result += ord(s[j]) - ord(s[-1 - j])\n else:\n result += ord(s[int(len(s) / 2)]) - ord(s[int(len(s) / 2) - 1])\n return result", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(input_string: str):\n vowels = 'aeiouAEIOU'\n count = sum((char in vowels for char in input_string))\n return count * 2 + len(input_string)", "input": "'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'", "output": "99", "imports": [], "original_snippet": "def f(input_string: str):\n vowels = 'aeiouAEIOU'\n count = sum((char in vowels for char in input_string))\n return count * 2 + len(input_string)", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(dna, ref_strand):\n (a, t) = ('A', 'T')\n (c, g) = ('C', 'G')\n transorn = {a: t, t: a, c: g, g: c}\n transformed_strand = dna.replace('A', '')\n transformed_strand = transformed_strand.replace('T', '')\n transformed_strand = transformed_strand.replace('G', '')\n transformed_strand = transformed_strand.replace('C', '')\n print('AAAAA' * 100000)\n print(dna)\n print(transformed_strand)", "input": "'AAAAA', 'CGCGG'", "output": "None", "imports": [], "original_snippet": "def f(dna, ref_strand):\n (a, t) = ('A', 'T')\n (c, g) = ('C', 'G')\n transorn = {a: t, t: a, c: g, g: c}\n transformed_strand = dna.replace('A', '')\n transformed_strand = transformed_strand.replace('T', '')\n transformed_strand = transformed_strand.replace('G', '')\n transformed_strand = transformed_strand.replace('C', '')\n print('AAAAA' * 100000)\n print(dna)\n print(transformed_strand)", "composite_functions": [], "_input_type": "tuple", "_output_type": "NoneType"} | |
| {"snippet": "def f(some_input: str) -> str:\n new_string = ''\n shift_sum = sum((ord(char) for char in some_input))\n shifted_chars = ''\n for (i, char) in enumerate(some_input):\n shifted_char = chr(ord(char) + shift_sum)\n shifted_chars += shifted_char + str(i)\n new_string = str(shifted_chars)\n return new_string", "input": "'Hello, World!'", "output": "'\u04b10\u04ce1\u04d52\u04d53\u04d84\u04955\u04896\u04c07\u04d88\u04db9\u04d510\u04cd11\u048a12'", "imports": [], "original_snippet": "def f(some_input: str) -> str:\n new_string = ''\n shift_sum = sum((ord(char) for char in some_input))\n shifted_chars = ''\n for (i, char) in enumerate(some_input):\n shifted_char = chr(ord(char) + shift_sum)\n shifted_chars += shifted_char + str(i)\n new_string = str(shifted_chars)\n return new_string", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "from typing import Dict, List\ndef f(count_dict: Dict[str, int]) -> List[str]:\n result = []\n for (key, value) in count_dict.items():\n while value > 3:\n result.append(key)\n value -= 3\n if value > 0:\n result.append(key * (value + 3))\n return result", "input": "{'Cat': 3, 'Dog': 4, 'Bird': 2, 'Fish': 1}", "output": "['CatCatCatCatCatCat', 'Dog', 'DogDogDogDog', 'BirdBirdBirdBirdBird', 'FishFishFishFish']", "imports": ["from typing import Dict, List"], "original_snippet": "from typing import Dict, List\ndef f(count_dict: Dict[str, int]) -> List[str]:\n result = []\n for (key, value) in count_dict.items():\n while value > 3:\n result.append(key)\n value -= 3\n if value > 0:\n result.append(key * (value + 3))\n return result", "composite_functions": [], "_input_type": "dict", "_output_type": "list"} | |
| {"snippet": "def f(n):\n total = 0\n lst = [i for i in range(1, n + 1)]\n for x in lst:\n total += x\n return total", "input": "10", "output": "55", "imports": [], "original_snippet": "def f(n):\n total = 0\n lst = [i for i in range(1, n + 1)]\n for x in lst:\n total += x\n return total", "composite_functions": [], "_input_type": "int", "_output_type": "int"} | |
| {"snippet": "def f(input_string: str):\n if not input_string:\n return ''\n stateDict = {'state': 'start', 'rightendIndex': 0}\n result_index = dict()\n for (index, char) in enumerate(input_string):\n if stateDict['state'] == 'start':\n if char.islower():\n stateDict['state'] = 'alphabets'\n result_index[index] = 0\n else:\n stateDict['state'] = 'numbers'\n result_index[index] = 1\n elif stateDict['state'] == 'alphabets':\n if char.isnumeric():\n stateDict['state'] = 'reject'\n else:\n stateDict['state'] = ''\n result_index[index] = 0\n elif stateDict['state'] == 'numbers':\n if char.islower():\n stateDict['state'] = 'reject'\n else:\n stateDict['state'] = ''\n result_index[index] = 1\n newCharList = list()\n for (key, value) in result_index.items():\n if value == 0:\n newCharList.append(input_string[key])\n else:\n newCharList.append(input_string[key + 1])\n newString = ''.join(newCharList)\n return newString[::-1]", "input": "\"S0p5GEt\"", "output": "'p0'", "imports": [], "original_snippet": "def f(input_string: str):\n if not input_string:\n return ''\n stateDict = {'state': 'start', 'rightendIndex': 0}\n result_index = dict()\n for (index, char) in enumerate(input_string):\n if stateDict['state'] == 'start':\n if char.islower():\n stateDict['state'] = 'alphabets'\n result_index[index] = 0\n else:\n stateDict['state'] = 'numbers'\n result_index[index] = 1\n elif stateDict['state'] == 'alphabets':\n if char.isnumeric():\n stateDict['state'] = 'reject'\n else:\n stateDict['state'] = ''\n result_index[index] = 0\n elif stateDict['state'] == 'numbers':\n if char.islower():\n stateDict['state'] = 'reject'\n else:\n stateDict['state'] = ''\n result_index[index] = 1\n newCharList = list()\n for (key, value) in result_index.items():\n if value == 0:\n newCharList.append(input_string[key])\n else:\n newCharList.append(input_string[key + 1])\n newString = ''.join(newCharList)\n return newString[::-1]", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(d, s):\n if not s:\n return d\n unique_s = dict.fromkeys(s)\n if 'key' in d:\n del d['key']\n d['value'] = s[::-1]\n return unique_s\n elif 'value' in d:\n rev_s = list(reversed(s))\n indices = [i for (i, char) in enumerate(d['value']) if char == rev_s[0]]\n d['value'] = ''.join(d['value']) + ''.join(d['value'][indices[0]:]) + ''.join(d['value'])[:indices[0]]\n return unique_s\n d['key'] = len(s)\n d['value'] = s\n return unique_s", "input": "{'key': 1, 'value': 'aaa'}, 'test'", "output": "{'t': None, 'e': None, 's': None}", "imports": [], "original_snippet": "def f(d, s):\n if not s:\n return d\n unique_s = dict.fromkeys(s)\n if 'key' in d:\n del d['key']\n d['value'] = s[::-1]\n return unique_s\n elif 'value' in d:\n rev_s = list(reversed(s))\n indices = [i for (i, char) in enumerate(d['value']) if char == rev_s[0]]\n d['value'] = ''.join(d['value']) + ''.join(d['value'][indices[0]:]) + ''.join(d['value'])[:indices[0]]\n return unique_s\n d['key'] = len(s)\n d['value'] = s\n return unique_s", "composite_functions": [], "_input_type": "tuple", "_output_type": "dict"} | |
| {"snippet": "def f(n: int, m: int) -> dict:\n result = {}\n for i in range(1, n + 1):\n number = i\n digit_sum = 0\n while number > 0:\n digit = number % 10\n digit_sum += digit ** m\n number //= 10\n result[i] = digit_sum\n return result", "input": "n = 10, m = 2", "output": "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 1}", "imports": [], "original_snippet": "def f(n: int, m: int) -> dict:\n result = {}\n for i in range(1, n + 1):\n number = i\n digit_sum = 0\n while number > 0:\n digit = number % 10\n digit_sum += digit ** m\n number //= 10\n result[i] = digit_sum\n return result", "composite_functions": [], "_input_type": "str", "_output_type": "dict"} | |
| {"snippet": "def f(strings: list) -> dict:\n items = ''.join(strings)\n items = set(items)\n freq_dict = {i: 0 for i in items}\n for i in items:\n freq_dict[i] += strings.count(i)\n sorted_freq_dict = sorted(freq_dict.items(), key=lambda x: (-x[1], x[0]))\n return dict(sorted_freq_dict)", "input": "['Hello world.', 'Sample text!']", "output": "{' ': 0, '!': 0, '.': 0, 'H': 0, 'S': 0, 'a': 0, 'd': 0, 'e': 0, 'l': 0, 'm': 0, 'o': 0, 'p': 0, 'r': 0, 't': 0, 'w': 0, 'x': 0}", "imports": [], "original_snippet": "def f(strings: list) -> dict:\n items = ''.join(strings)\n items = set(items)\n freq_dict = {i: 0 for i in items}\n for i in items:\n freq_dict[i] += strings.count(i)\n sorted_freq_dict = sorted(freq_dict.items(), key=lambda x: (-x[1], x[0]))\n return dict(sorted_freq_dict)", "composite_functions": [], "_input_type": "list", "_output_type": "dict"} | |
| {"snippet": "def f(arr: list) -> list:\n n = len(arr)\n fib_sequence = [0, 1]\n for i in range(2, n):\n if i % 2 == 0:\n fib_sequence.append(arr[i] * fib_sequence[i - 1])\n else:\n fib_sequence.append(arr[i] + fib_sequence[i - 1])\n return fib_sequence", "input": "arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", "output": "[0, 1, 3, 7, 35, 41, 287, 295, 2655, 2665]", "imports": [], "original_snippet": "def f(arr: list) -> list:\n n = len(arr)\n fib_sequence = [0, 1]\n for i in range(2, n):\n if i % 2 == 0:\n fib_sequence.append(arr[i] * fib_sequence[i - 1])\n else:\n fib_sequence.append(arr[i] + fib_sequence[i - 1])\n return fib_sequence", "composite_functions": [], "_input_type": "str", "_output_type": "list"} | |
| {"snippet": "def f(nums, iterations):\n result = [0] * len(nums)\n for i in range(iterations):\n new_list = []\n for (idx, val) in enumerate(nums):\n result[idx] = val + 1 if idx == val % (i + 1) else 0\n new_list.append(result[idx])\n nums = new_list\n return result", "input": "[2, 3, 1, 4, 5], 2", "output": "[0, 0, 0, 0, 0]", "imports": [], "original_snippet": "def f(nums, iterations):\n result = [0] * len(nums)\n for i in range(iterations):\n new_list = []\n for (idx, val) in enumerate(nums):\n result[idx] = val + 1 if idx == val % (i + 1) else 0\n new_list.append(result[idx])\n nums = new_list\n return result", "composite_functions": [], "_input_type": "tuple", "_output_type": "list"} | |
| {"snippet": "def f(lst):\n length_of_lst = len(lst)\n if length_of_lst % 2 == 0:\n half_lst_before_adding_last_two_items = lst[:length_of_lst // 2 - 1]\n last_two_items = lst[length_of_lst - 2:length_of_lst]\n times_elements_are_multiplied = lst[length_of_lst - 2] * lst[length_of_lst - 3:length_of_lst - 1]\n total_elements_are_added = half_lst_before_adding_last_two_items + times_elements_are_multiplied + last_two_items\n return total_elements_are_added\n else:\n half_lst_before_adding_last_two_items = lst[:length_of_lst // 2]\n last_two_items = lst[length_of_lst - 2:length_of_lst]\n times_elements_are_multiplied = lst[length_of_lst - 2] * lst[length_of_lst - 3:length_of_lst]\n total_elements_are_added = half_lst_before_adding_last_two_items + times_elements_are_multiplied + last_two_items\n return total_elements_are_added", "input": "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", "output": "[1, 2, 3, 4, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 9, 10]", "imports": [], "original_snippet": "def f(lst):\n length_of_lst = len(lst)\n if length_of_lst % 2 == 0:\n half_lst_before_adding_last_two_items = lst[:length_of_lst // 2 - 1]\n last_two_items = lst[length_of_lst - 2:length_of_lst]\n times_elements_are_multiplied = lst[length_of_lst - 2] * lst[length_of_lst - 3:length_of_lst - 1]\n total_elements_are_added = half_lst_before_adding_last_two_items + times_elements_are_multiplied + last_two_items\n return total_elements_are_added\n else:\n half_lst_before_adding_last_two_items = lst[:length_of_lst // 2]\n last_two_items = lst[length_of_lst - 2:length_of_lst]\n times_elements_are_multiplied = lst[length_of_lst - 2] * lst[length_of_lst - 3:length_of_lst]\n total_elements_are_added = half_lst_before_adding_last_two_items + times_elements_are_multiplied + last_two_items\n return total_elements_are_added", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(input_list: list) -> int:\n max_diff = 0\n for i in range(len(input_list) - 1):\n for j in range(i + 1, len(input_list)):\n diff = abs(input_list[i] - input_list[j])\n if diff > max_diff:\n max_diff = diff\n return max_diff", "input": "[1, 5, 3, 1, 13, 8, 15]", "output": "14", "imports": [], "original_snippet": "def f(input_list: list) -> int:\n max_diff = 0\n for i in range(len(input_list) - 1):\n for j in range(i + 1, len(input_list)):\n diff = abs(input_list[i] - input_list[j])\n if diff > max_diff:\n max_diff = diff\n return max_diff", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "import math\ndef f(numbers):\n from functools import reduce\n product = reduce(lambda x, y: x * math.factorial(y), numbers)\n return product", "input": "[2, 3, 4]", "output": "288", "imports": ["import math", "from functools import reduce"], "original_snippet": "import math\ndef f(numbers):\n from functools import reduce\n product = reduce(lambda x, y: x * math.factorial(y), numbers)\n return product", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "from typing import List\ndef f(numbers: List[float]) -> List[float]:\n result = []\n for number in numbers:\n result.append(number ** 2 - number)\n return result", "input": "[1.0, 2.0, 3.0, 4.0]", "output": "[0.0, 2.0, 6.0, 12.0]", "imports": ["from typing import List"], "original_snippet": "from typing import List\ndef f(numbers: List[float]) -> List[float]:\n result = []\n for number in numbers:\n result.append(number ** 2 - number)\n return result", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "from typing import Dict\ndef f(numbers: list) -> Dict[int, int]:\n frequency_dict = {}\n for num in numbers:\n if num in frequency_dict:\n frequency_dict[num] += 1\n else:\n frequency_dict[num] = 1\n return frequency_dict", "input": "[1, 2, 3, 3, 2, 4, 3, 4, 4, 4]", "output": "{1: 1, 2: 2, 3: 3, 4: 4}", "imports": ["from typing import Dict"], "original_snippet": "from typing import Dict\ndef f(numbers: list) -> Dict[int, int]:\n frequency_dict = {}\n for num in numbers:\n if num in frequency_dict:\n frequency_dict[num] += 1\n else:\n frequency_dict[num] = 1\n return frequency_dict", "composite_functions": [], "_input_type": "list", "_output_type": "dict"} | |
| {"snippet": "def f(numbers: list) -> int:\n sieve = [True] * (max(numbers) + 1)\n for i in range(2, int(len(sieve) ** 0.5) + 1):\n if not sieve[i]:\n continue\n for j in range(i * i, len(sieve), i):\n sieve[j] = False\n primes = [i for i in range(2, len(sieve)) if sieve[i]]\n prime_count = 0\n for number in numbers:\n if number in primes:\n prime_count += 1\n return prime_count", "input": "numbers = [11, 2, 12, 13, 14, 15, 17, 18, 19, 20]", "output": "5", "imports": [], "original_snippet": "def f(numbers: list) -> int:\n sieve = [True] * (max(numbers) + 1)\n for i in range(2, int(len(sieve) ** 0.5) + 1):\n if not sieve[i]:\n continue\n for j in range(i * i, len(sieve), i):\n sieve[j] = False\n primes = [i for i in range(2, len(sieve)) if sieve[i]]\n prime_count = 0\n for number in numbers:\n if number in primes:\n prime_count += 1\n return prime_count", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(s: str) -> str:\n return ''.join(sorted(s))", "input": "\"Hello!!! World!!\"", "output": "' !!!!!HWdellloor'", "imports": [], "original_snippet": "def f(s: str) -> str:\n return ''.join(sorted(s))", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(input_string: str):\n alphabet = 'abcdefghijklmnopqrstuvwxyz'\n reposition_scheme = {'a': 'a', 'e': 'e', 'i': 'i', 'o': 'o', 'u': 'u', 'A': 'A', 'E': 'E', 'I': 'I', 'O': 'O', 'U': 'U'}\n vowels = []\n new_string = ''\n for c in input_string:\n if c.isalpha():\n char_class = 'vowel' if c in reposition_scheme else 'consonant'\n if char_class == 'vowel':\n vowels.append(c)\n new_string += reposition_scheme[c]\n else:\n new_string += c\n else:\n new_string += c\n for (i, c) in enumerate(vowels):\n new_string = new_string[:i] + c + new_string[i + 1:]\n return new_string", "input": "'Hello, World!'", "output": "'eoolo, World!'", "imports": [], "original_snippet": "def f(input_string: str):\n alphabet = 'abcdefghijklmnopqrstuvwxyz'\n reposition_scheme = {'a': 'a', 'e': 'e', 'i': 'i', 'o': 'o', 'u': 'u', 'A': 'A', 'E': 'E', 'I': 'I', 'O': 'O', 'U': 'U'}\n vowels = []\n new_string = ''\n for c in input_string:\n if c.isalpha():\n char_class = 'vowel' if c in reposition_scheme else 'consonant'\n if char_class == 'vowel':\n vowels.append(c)\n new_string += reposition_scheme[c]\n else:\n new_string += c\n else:\n new_string += c\n for (i, c) in enumerate(vowels):\n new_string = new_string[:i] + c + new_string[i + 1:]\n return new_string", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(numbers: list) -> int:\n product = 1\n for number in numbers:\n if number % 2 == 0:\n product *= number\n return product", "input": "[1, 2, 3, 4, 5]", "output": "8", "imports": [], "original_snippet": "def f(numbers: list) -> int:\n product = 1\n for number in numbers:\n if number % 2 == 0:\n product *= number\n return product", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "from typing import List, Dict\ndef f(s: str) -> int:\n new_string = ''\n for (i, ch) in enumerate(s):\n new_string += s[:i]\n if s[i] == 'a':\n return i\n return -1", "input": "'abcba'", "output": "0", "imports": ["from typing import List, Dict"], "original_snippet": "from typing import List, Dict\ndef f(s: str) -> int:\n new_string = ''\n for (i, ch) in enumerate(s):\n new_string += s[:i]\n if s[i] == 'a':\n return i\n return -1", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(lst):\n for i in range(len(lst)):\n if lst[i] < 1 or lst[i] >= len(lst) or lst[lst[i] - 1] != 0:\n return i + 1", "input": "[1, 2, 3]", "output": "1", "imports": [], "original_snippet": "def f(lst):\n for i in range(len(lst)):\n if lst[i] < 1 or lst[i] >= len(lst) or lst[lst[i] - 1] != 0:\n return i + 1", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(input_string: str, rotations=0) -> str:\n rotated_string = input_string\n rotation_count = 0\n while True:\n first_digit = rotated_string.find('0123456789')\n if first_digit >= 0 and first_digit + 3 < len(rotated_string):\n rotated_string = rotated_string[:first_digit + 1] + rotated_string[first_digit + 1:20] + rotated_string[:first_digit + 1]\n rotation_count += 1\n else:\n break\n if not rotated_string:\n break\n return f'The input string has been rotated {rotation_count} times.'", "input": "'123456789', 0", "output": "'The input string has been rotated 0 times.'", "imports": [], "original_snippet": "def f(input_string: str, rotations=0) -> str:\n rotated_string = input_string\n rotation_count = 0\n while True:\n first_digit = rotated_string.find('0123456789')\n if first_digit >= 0 and first_digit + 3 < len(rotated_string):\n rotated_string = rotated_string[:first_digit + 1] + rotated_string[first_digit + 1:20] + rotated_string[:first_digit + 1]\n rotation_count += 1\n else:\n break\n if not rotated_string:\n break\n return f'The input string has been rotated {rotation_count} times.'", "composite_functions": [], "_input_type": "tuple", "_output_type": "str"} | |
| {"snippet": "def f(nums: list):\n if not nums:\n return 0\n nums.sort()\n diff_max = float('inf')\n diff_min = 0\n for i in range(1, len(nums)):\n diff = abs(nums[i] - nums[i - 1])\n if diff > diff_max:\n diff_max = diff\n elif diff_min == 0 or diff < diff_min:\n diff_min = diff\n return f'The highest difference between two consecutive numbers in the list is {diff_max} and the lowest is {diff_min}.'", "input": "[10, 8, 12, 5, 15, 20, 1, 7]", "output": "'The highest difference between two consecutive numbers in the list is inf and the lowest is 1.'", "imports": [], "original_snippet": "def f(nums: list):\n if not nums:\n return 0\n nums.sort()\n diff_max = float('inf')\n diff_min = 0\n for i in range(1, len(nums)):\n diff = abs(nums[i] - nums[i - 1])\n if diff > diff_max:\n diff_max = diff\n elif diff_min == 0 or diff < diff_min:\n diff_min = diff\n return f'The highest difference between two consecutive numbers in the list is {diff_max} and the lowest is {diff_min}.'", "composite_functions": [], "_input_type": "list", "_output_type": "str"} | |
| {"snippet": "def f(numbers):\n pairs = set()\n pairs_count = {}\n for i in range(len(numbers)):\n for j in range(i + 1, len(numbers)):\n if numbers[i] + numbers[j] not in pairs:\n pairs.add(numbers[i] + numbers[j])\n if numbers[i] + numbers[j] in pairs_count:\n pairs_count[numbers[i] + numbers[j]] += 1\n else:\n pairs_count[numbers[i] + numbers[j]] = 1\n output = []\n for (pair, count) in pairs_count.items():\n if count > 0:\n output.append(f'{pair} - {count}')\n return output", "input": "numbers = [3, 5, 2, 7, 6, 1]", "output": "['8 - 1', '5 - 1', '10 - 1', '9 - 1', '4 - 1', '7 - 1', '12 - 1', '11 - 1', '6 - 1', '3 - 1', '13 - 1']", "imports": [], "original_snippet": "def f(numbers):\n pairs = set()\n pairs_count = {}\n for i in range(len(numbers)):\n for j in range(i + 1, len(numbers)):\n if numbers[i] + numbers[j] not in pairs:\n pairs.add(numbers[i] + numbers[j])\n if numbers[i] + numbers[j] in pairs_count:\n pairs_count[numbers[i] + numbers[j]] += 1\n else:\n pairs_count[numbers[i] + numbers[j]] = 1\n output = []\n for (pair, count) in pairs_count.items():\n if count > 0:\n output.append(f'{pair} - {count}')\n return output", "composite_functions": [], "_input_type": "str", "_output_type": "list"} | |
| {"snippet": "def f(numbers):\n if not numbers or len(numbers) < 3:\n raise ValueError('Input list must contain at least three unique positive integers')\n largest = numbers[0]\n second_largest = float('-inf')\n for num in numbers:\n if num > largest:\n (second_largest, largest) = (largest, num)\n elif second_largest < num < largest:\n second_largest = num\n if second_largest == float('-inf'):\n raise ValueError('Input list must contain at least two unique positive integers to form a pair')\n return second_largest", "input": "[100, 200, 150, 300, 50, 350]", "output": "300", "imports": [], "original_snippet": "def f(numbers):\n if not numbers or len(numbers) < 3:\n raise ValueError('Input list must contain at least three unique positive integers')\n largest = numbers[0]\n second_largest = float('-inf')\n for num in numbers:\n if num > largest:\n (second_largest, largest) = (largest, num)\n elif second_largest < num < largest:\n second_largest = num\n if second_largest == float('-inf'):\n raise ValueError('Input list must contain at least two unique positive integers to form a pair')\n return second_largest", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(data_list: list[int]):\n result = []\n for (index, item) in enumerate(data_list):\n if item % 2 == 0:\n result.append(2 * item)\n else:\n power_of_two = 1\n while power_of_two <= abs(item):\n if item >= 0 and power_of_two <= 1:\n break\n elif item < 0 and power_of_two >= -1:\n break\n power_of_two *= 2\n result.append(-1 ** (item // abs(item)) * abs(item) ** (power_of_two // 2))\n return result[::-1]", "input": "[0, 1, 2, 3, 4, 5]", "output": "[-1, 8, -1, 4, -1, 0]", "imports": [], "original_snippet": "def f(data_list: list[int]):\n result = []\n for (index, item) in enumerate(data_list):\n if item % 2 == 0:\n result.append(2 * item)\n else:\n power_of_two = 1\n while power_of_two <= abs(item):\n if item >= 0 and power_of_two <= 1:\n break\n elif item < 0 and power_of_two >= -1:\n break\n power_of_two *= 2\n result.append(-1 ** (item // abs(item)) * abs(item) ** (power_of_two // 2))\n return result[::-1]", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(n: int) -> list:\n stack = [0]\n for i in range(1, n + 1):\n if i % 2 == 0:\n stack.append(stack.pop())\n stack.append(i)\n else:\n stack.append(stack.pop())\n return stack", "input": "10", "output": "[0, 2, 4, 6, 8, 10]", "imports": [], "original_snippet": "def f(n: int) -> list:\n stack = [0]\n for i in range(1, n + 1):\n if i % 2 == 0:\n stack.append(stack.pop())\n stack.append(i)\n else:\n stack.append(stack.pop())\n return stack", "composite_functions": [], "_input_type": "int", "_output_type": "list"} | |
| {"snippet": "def f(input_string: str):\n if not input_string:\n return ''\n stateDict = {'state': 'start', 'rightendIndex': 0}\n result_index = dict()\n for (index, char) in enumerate(input_string):\n if stateDict['state'] == 'start':\n if char.islower():\n stateDict['state'] = 'alphabets'\n result_index[index] = 0\n elif char.isupper():\n stateDict['state'] = 'numbers'\n result_index[index] = 1\n elif char.isdigit():\n stateDict['state'] = 'numbers'\n result_index[index] = 2\n elif stateDict['state'] == 'alphabets':\n stateDict['rightendIndex'] = index\n if char.islower():\n stateDict['state'] = 'start'\n else:\n stateDict['state'] = 'reject'\n elif stateDict['state'] == 'numbers':\n stateDict['rightendIndex'] = index\n if char.islower():\n stateDict['state'] = 'reject'\n else:\n stateDict['state'] = 'end'\n state_reverse_characters = []\n for i in range(stateDict['rightendIndex'] + 1):\n char = input_string[i]\n if stateDict['state'] == 'start':\n state_reverse_characters.append(char)\n elif stateDict['state'] == 'alphabets':\n state_reverse_characters.insert(0, char)\n elif stateDict['state'] == 'numbers':\n state_reverse_characters.insert(0, char)\n result = ''\n for i in range(stateDict['rightendIndex'] + 1):\n char = input_string[i]\n if stateDict['state'] == 'start':\n result += char\n elif stateDict['state'] == 'alphabets':\n result += char\n elif stateDict['state'] == 'numbers':\n result += char\n for char in state_reverse_characters:\n result += char\n return result[::-1]", "input": "\"753md5\"", "output": "''", "imports": [], "original_snippet": "def f(input_string: str):\n if not input_string:\n return ''\n stateDict = {'state': 'start', 'rightendIndex': 0}\n result_index = dict()\n for (index, char) in enumerate(input_string):\n if stateDict['state'] == 'start':\n if char.islower():\n stateDict['state'] = 'alphabets'\n result_index[index] = 0\n elif char.isupper():\n stateDict['state'] = 'numbers'\n result_index[index] = 1\n elif char.isdigit():\n stateDict['state'] = 'numbers'\n result_index[index] = 2\n elif stateDict['state'] == 'alphabets':\n stateDict['rightendIndex'] = index\n if char.islower():\n stateDict['state'] = 'start'\n else:\n stateDict['state'] = 'reject'\n elif stateDict['state'] == 'numbers':\n stateDict['rightendIndex'] = index\n if char.islower():\n stateDict['state'] = 'reject'\n else:\n stateDict['state'] = 'end'\n state_reverse_characters = []\n for i in range(stateDict['rightendIndex'] + 1):\n char = input_string[i]\n if stateDict['state'] == 'start':\n state_reverse_characters.append(char)\n elif stateDict['state'] == 'alphabets':\n state_reverse_characters.insert(0, char)\n elif stateDict['state'] == 'numbers':\n state_reverse_characters.insert(0, char)\n result = ''\n for i in range(stateDict['rightendIndex'] + 1):\n char = input_string[i]\n if stateDict['state'] == 'start':\n result += char\n elif stateDict['state'] == 'alphabets':\n result += char\n elif stateDict['state'] == 'numbers':\n result += char\n for char in state_reverse_characters:\n result += char\n return result[::-1]", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "from typing import List\ndef f(nums: List[int]) -> bool:\n frequency_dict = {}\n for num in nums:\n if num in frequency_dict:\n return False\n frequency_dict[num] = 1\n return True", "input": "[1, 2, 3, 4, 5]", "output": "True", "imports": ["from typing import List"], "original_snippet": "from typing import List\ndef f(nums: List[int]) -> bool:\n frequency_dict = {}\n for num in nums:\n if num in frequency_dict:\n return False\n frequency_dict[num] = 1\n return True", "composite_functions": [], "_input_type": "list", "_output_type": "bool"} | |
| {"snippet": "def f(str: str) -> str:\n result = ''\n length = len(str)\n for i in range(length):\n if str[i] == 'a':\n result += str[length - 1 - i]\n elif str[i] == '$':\n result += str[:i]\n elif str[i] == '&':\n result += chr(ord(str[i]) * ord(str[length - 1 - i]))\n elif str[i] == '#':\n result += chr(ord(str[i]) + ord(str[length - 1 - i]))\n elif str[i] == 'c':\n result += str[length - 1 - i] * length\n elif str[i] == '*':\n result += str[:i] * length\n elif str[i] == '#':\n result += str[length - 1 - i] - ord(str[i])\n elif str[i] == '%' or str[i] == '/':\n result = str[:i] + str[length - 1 - i] + str[i + 1:length]\n elif str[i] == '^':\n result += str + str\n elif str[i] == 'z':\n result = str[:i] + str[length - 1 - i] * length + str[i + 1:length]\n return result[::-1]", "input": "'xyz#$%%*^&z'", "output": "'xxxxxxxxxxx&^*%%$#zyx'", "imports": [], "original_snippet": "def f(str: str) -> str:\n result = ''\n length = len(str)\n for i in range(length):\n if str[i] == 'a':\n result += str[length - 1 - i]\n elif str[i] == '$':\n result += str[:i]\n elif str[i] == '&':\n result += chr(ord(str[i]) * ord(str[length - 1 - i]))\n elif str[i] == '#':\n result += chr(ord(str[i]) + ord(str[length - 1 - i]))\n elif str[i] == 'c':\n result += str[length - 1 - i] * length\n elif str[i] == '*':\n result += str[:i] * length\n elif str[i] == '#':\n result += str[length - 1 - i] - ord(str[i])\n elif str[i] == '%' or str[i] == '/':\n result = str[:i] + str[length - 1 - i] + str[i + 1:length]\n elif str[i] == '^':\n result += str + str\n elif str[i] == 'z':\n result = str[:i] + str[length - 1 - i] * length + str[i + 1:length]\n return result[::-1]", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(l: list):\n total_sum = 0\n for n in range(len(l) - 1, 0, -1):\n total_sum += l[n]\n total_sum *= len(l) - n\n return total_sum", "input": "[1, 2, 3, 7, 5, 6, 4, 2]", "output": "203", "imports": [], "original_snippet": "def f(l: list):\n total_sum = 0\n for n in range(len(l) - 1, 0, -1):\n total_sum += l[n]\n total_sum *= len(l) - n\n return total_sum", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(lst: list) -> list:\n result = []\n for i in range(len(lst) - 1):\n to_add = lst[i] * (i + 1) + lst[i + 1]\n result.append(to_add)\n return result", "input": "[1, 2, 3]", "output": "[3, 7]", "imports": [], "original_snippet": "def f(lst: list) -> list:\n result = []\n for i in range(len(lst) - 1):\n to_add = lst[i] * (i + 1) + lst[i + 1]\n result.append(to_add)\n return result", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(numbers):\n total_squares = 0\n for num in numbers:\n square = num ** 2\n total_squares += square\n return total_squares", "input": "[1, 2, 3, 4]", "output": "30", "imports": [], "original_snippet": "def f(numbers):\n total_squares = 0\n for num in numbers:\n square = num ** 2\n total_squares += square\n return total_squares", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(custom_data: list, input_list: list):\n binary_slice_mapping = {0: '001', 1: '010', 2: '011', 3: '100', 4: '101', 5: '110', 6: '111'}\n result = []\n for i in range(len(input_list)):\n stack = []\n for j in range(i, -1, -1):\n if custom_data[j] and stack == []:\n break\n if not custom_data[j] and stack == []:\n break\n if custom_data[j]:\n lookup = binary_slice_mapping[input_list[i] & (1 << j) - 1]\n stack.append(lookup)\n if stack:\n result.append(''.join(stack))\n return result", "input": "[False, False, False, True, False, True, False],\nrange(6),", "output": "[]", "imports": [], "original_snippet": "def f(custom_data: list, input_list: list):\n binary_slice_mapping = {0: '001', 1: '010', 2: '011', 3: '100', 4: '101', 5: '110', 6: '111'}\n result = []\n for i in range(len(input_list)):\n stack = []\n for j in range(i, -1, -1):\n if custom_data[j] and stack == []:\n break\n if not custom_data[j] and stack == []:\n break\n if custom_data[j]:\n lookup = binary_slice_mapping[input_list[i] & (1 << j) - 1]\n stack.append(lookup)\n if stack:\n result.append(''.join(stack))\n return result", "composite_functions": [], "_input_type": "str", "_output_type": "list"} | |
| {"snippet": "def f(input_string: str) -> list:\n input_length = len(input_string)\n substrings = set()\n for i in range(input_length):\n for j in range(i + 1, input_length + 1):\n substring = input_string[i:j]\n if len(substring) >= 2 and substring not in substrings:\n substrings.add(substring)\n yield (substring, i)", "input": "'stand-up-circuit-net'", "output": "", "imports": [], "original_snippet": "def f(input_string: str) -> list:\n input_length = len(input_string)\n substrings = set()\n for i in range(input_length):\n for j in range(i + 1, input_length + 1):\n substring = input_string[i:j]\n if len(substring) >= 2 and substring not in substrings:\n substrings.add(substring)\n yield (substring, i)", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(matrix: list) -> int:\n result = 0\n for row in matrix:\n for col in range(len(row)):\n if row[col] != col and any((row[i] != i for i in range(len(row)))):\n result += 1\n return result", "input": "[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20], [21, 22, 23, 24, 25]]", "output": "25", "imports": [], "original_snippet": "def f(matrix: list) -> int:\n result = 0\n for row in matrix:\n for col in range(len(row)):\n if row[col] != col and any((row[i] != i for i in range(len(row)))):\n result += 1\n return result", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "from typing import Dict, List\ndef f(input_dict: Dict[str, int]) -> Dict[str, int]:\n temp_dict = {}\n for (key, value) in input_dict.items():\n if value in temp_dict:\n temp_dict[value] += 1\n else:\n temp_dict[value] = 1\n sorted_count_dict = {k: v for (k, v) in sorted(temp_dict.items(), key=lambda item: item[1], reverse=True)}\n result = {}\n for (key, value) in sorted_count_dict.items():\n if result is None:\n result = {value: key}\n else:\n result[key] = value\n return result", "input": "{1: 4, 4: 9, 1: 16}", "output": "{16: 1, 9: 1}", "imports": ["from typing import Dict, List"], "original_snippet": "from typing import Dict, List\ndef f(input_dict: Dict[str, int]) -> Dict[str, int]:\n temp_dict = {}\n for (key, value) in input_dict.items():\n if value in temp_dict:\n temp_dict[value] += 1\n else:\n temp_dict[value] = 1\n sorted_count_dict = {k: v for (k, v) in sorted(temp_dict.items(), key=lambda item: item[1], reverse=True)}\n result = {}\n for (key, value) in sorted_count_dict.items():\n if result is None:\n result = {value: key}\n else:\n result[key] = value\n return result", "composite_functions": [], "_input_type": "dict", "_output_type": "dict"} | |
| {"snippet": "from typing import Dict\ndef f(hashtable: Dict[int, int]) -> int:\n product = 1\n sorted_hashtable = sorted(list(hashtable.items()), key=lambda item: item[1], reverse=True)\n for (key, val) in sorted_hashtable:\n if product == 1:\n product = val * val\n else:\n product *= key * val\n return product", "input": "{1: 3, 2: 5, 3: 7, 4: 2, 5: 1}", "output": "58800", "imports": ["from typing import Dict"], "original_snippet": "from typing import Dict\ndef f(hashtable: Dict[int, int]) -> int:\n product = 1\n sorted_hashtable = sorted(list(hashtable.items()), key=lambda item: item[1], reverse=True)\n for (key, val) in sorted_hashtable:\n if product == 1:\n product = val * val\n else:\n product *= key * val\n return product", "composite_functions": [], "_input_type": "dict", "_output_type": "int"} | |
| {"snippet": "def f(decoded_vote_results: list) -> list:\n num_votes = 0\n result = []\n for i in range(len(decoded_vote_results)):\n if i % 5 == 0:\n num_votes ^= decoded_vote_results[i] << (i + 1) % 5\n else:\n num_votes += decoded_vote_results[i]\n if i % 5 == 4:\n result.append(num_votes)\n num_votes = 0\n return result", "input": "[1, 0, 1, 2, 0, 1, 1, 2, 1, 0, 2, 1, 1, 0, 1, 1, 0, 1, 1, 0, 2, 3]", "output": "[5, 6, 7, 4]", "imports": [], "original_snippet": "def f(decoded_vote_results: list) -> list:\n num_votes = 0\n result = []\n for i in range(len(decoded_vote_results)):\n if i % 5 == 0:\n num_votes ^= decoded_vote_results[i] << (i + 1) % 5\n else:\n num_votes += decoded_vote_results[i]\n if i % 5 == 4:\n result.append(num_votes)\n num_votes = 0\n return result", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "import collections\ndef f(sequence: tuple) -> dict:\n count_dict = collections.Counter(sequence)\n return count_dict", "input": "('a', 'b', 'c', 'a', 'b', 'b', 'c')", "output": "Counter({'b': 3, 'a': 2, 'c': 2})", "imports": ["import collections"], "original_snippet": "import collections\ndef f(sequence: tuple) -> dict:\n count_dict = collections.Counter(sequence)\n return count_dict", "composite_functions": [], "_input_type": "tuple", "_output_type": "str"} | |
| {"snippet": "def f(input_list):\n filtered_list = []\n for num in input_list:\n num_str = str(num)\n if '1' in num_str or '7' in num_str:\n filtered_list.append(num)\n return filtered_list", "input": "[50, 82, 199, 141, 91, 37, 44]", "output": "[199, 141, 91, 37]", "imports": [], "original_snippet": "def f(input_list):\n filtered_list = []\n for num in input_list:\n num_str = str(num)\n if '1' in num_str or '7' in num_str:\n filtered_list.append(num)\n return filtered_list", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(num):\n nums = [1, 5, 3, 1, 13, 8, 15]\n return abs(nums[0] - num) <= 2", "input": "4.6733108", "output": "False", "imports": [], "original_snippet": "def f(num):\n nums = [1, 5, 3, 1, 13, 8, 15]\n return abs(nums[0] - num) <= 2", "composite_functions": [], "_input_type": "float", "_output_type": "bool"} | |
| {"snippet": "import os\nimport sys\ndef f(input_list: list) -> list:\n output_list = []\n for (i, value) in enumerate(input_list):\n if i % 2 == 0:\n output_list.append(value)\n elif i % 2 == 1:\n output_list.append(-value)\n return output_list", "input": "[1, 2, 3, 4, 5, 6]", "output": "[1, -2, 3, -4, 5, -6]", "imports": ["import os", "import sys"], "original_snippet": "import os\nimport sys\ndef f(input_list: list) -> list:\n output_list = []\n for (i, value) in enumerate(input_list):\n if i % 2 == 0:\n output_list.append(value)\n elif i % 2 == 1:\n output_list.append(-value)\n return output_list", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(x):\n return x[::-1]", "input": "'abcd'", "output": "'dcba'", "imports": [], "original_snippet": "def f(x):\n return x[::-1]", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "import re\ndef f(l):\n l = [str(x) for x in l]\n transformed_string = ''\n for (i, num) in enumerate(l):\n if i % 2 == 0:\n transformed_string += num * 2\n else:\n transformed_string += num\n transformed_list = re.findall('\\\\d', transformed_string)\n transformed_list = [int(x) for x in transformed_list]\n return sum(transformed_list)", "input": "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", "output": "71", "imports": ["import re"], "original_snippet": "import re\ndef f(l):\n l = [str(x) for x in l]\n transformed_string = ''\n for (i, num) in enumerate(l):\n if i % 2 == 0:\n transformed_string += num * 2\n else:\n transformed_string += num\n transformed_list = re.findall('\\\\d', transformed_string)\n transformed_list = [int(x) for x in transformed_list]\n return sum(transformed_list)", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(numbers):\n result = 0\n for num in numbers:\n result += num\n return result", "input": "numbers = [1, 2, 3, 4, 5]", "output": "15", "imports": [], "original_snippet": "def f(numbers):\n result = 0\n for num in numbers:\n result += num\n return result", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "from collections import defaultdict\ndef f(numbers: list) -> list:\n if not hasattr(f, 'temp'):\n f.temp = []\n if not hasattr(f, 'frequency'):\n f.frequency = 0\n if not hasattr(f, 'dict'):\n f.dict = defaultdict(int)\n result = []\n for num in numbers:\n if num in f.temp:\n result.append(num)\n f.frequency += 1\n elif f.frequency >= 2:\n result.append(num)\n f.frequency -= 1\n else:\n f.temp.append(num)\n f.dict[num] += 1\n f.frequency += 1\n if result:\n return result\n else:\n return None", "input": "[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5]", "output": "", "imports": ["from collections import defaultdict"], "original_snippet": "from collections import defaultdict\ndef f(numbers: list) -> list:\n if not hasattr(f, 'temp'):\n f.temp = []\n if not hasattr(f, 'frequency'):\n f.frequency = 0\n if not hasattr(f, 'dict'):\n f.dict = defaultdict(int)\n result = []\n for num in numbers:\n if num in f.temp:\n result.append(num)\n f.frequency += 1\n elif f.frequency >= 2:\n result.append(num)\n f.frequency -= 1\n else:\n f.temp.append(num)\n f.dict[num] += 1\n f.frequency += 1\n if result:\n return result\n else:\n return None", "composite_functions": [], "_input_type": "list", "_output_type": "str"} | |
| {"snippet": "from typing import List\ndef f(numbers: List[int]) -> tuple:\n n = len(numbers)\n half = n // 2\n first_half_sum = sum(numbers[:half])\n last_half_product = 1\n for num in numbers[half:]:\n last_half_product *= num\n return (first_half_sum, last_half_product)", "input": "numbers = [2, 5, 8, 10]", "output": "(7, 80)", "imports": ["from typing import List"], "original_snippet": "from typing import List\ndef f(numbers: List[int]) -> tuple:\n n = len(numbers)\n half = n // 2\n first_half_sum = sum(numbers[:half])\n last_half_product = 1\n for num in numbers[half:]:\n last_half_product *= num\n return (first_half_sum, last_half_product)", "composite_functions": [], "_input_type": "str", "_output_type": "tuple"} | |
| {"snippet": "def f(d: dict, c: str) -> str:\n if c not in d:\n d['condition'] = c\n return d['condition']", "input": "{'condition': 'other'}, 'start'", "output": "'start'", "imports": [], "original_snippet": "def f(d: dict, c: str) -> str:\n if c not in d:\n d['condition'] = c\n return d['condition']", "composite_functions": [], "_input_type": "tuple", "_output_type": "str"} | |
| {"snippet": "from typing import List, Dict\ndef f(numbers: List[int]) -> int:\n sum_of_squares = 0\n for num in numbers:\n sum_of_squares += num ** 2\n return sum_of_squares", "input": "[1, 2, 3, 4, 5]", "output": "55", "imports": ["from typing import List, Dict"], "original_snippet": "from typing import List, Dict\ndef f(numbers: List[int]) -> int:\n sum_of_squares = 0\n for num in numbers:\n sum_of_squares += num ** 2\n return sum_of_squares", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(text):\n reversed_text = text[::-1]\n new_text = ''\n for i in range(len(reversed_text)):\n new_text += chr(ord(reversed_text[i]) - i)\n return (reversed_text, new_text)", "input": "\"Python\"", "output": "('nohtyP', 'nnfquK')", "imports": [], "original_snippet": "def f(text):\n reversed_text = text[::-1]\n new_text = ''\n for i in range(len(reversed_text)):\n new_text += chr(ord(reversed_text[i]) - i)\n return (reversed_text, new_text)", "composite_functions": [], "_input_type": "str", "_output_type": "tuple"} | |
| {"snippet": "def f(numbers):\n if not numbers:\n return 0\n average = sum(numbers) / len(numbers)\n return round(average, 2)", "input": "[98.5, 95.7, 96.3, 97.4, 96.9, 96.5, 95.0, 94.3, 94.5, 94.8, 93.7, 94.1, 95.4]", "output": "95.62", "imports": [], "original_snippet": "def f(numbers):\n if not numbers:\n return 0\n average = sum(numbers) / len(numbers)\n return round(average, 2)", "composite_functions": [], "_input_type": "list", "_output_type": "float"} | |
| {"snippet": "def f(numbers: list) -> list:\n result = []\n for (index, num) in enumerate(numbers):\n if index % 2 == 0:\n sum_previous = sum(numbers[:index])\n result.append(sum_previous)\n else:\n result.append(num)\n for i in range(len(result)):\n if i % 2 == 0:\n result[i] = str(result[i])\n elif isinstance(result[i], str):\n result[i] = int(result[i])\n if not result:\n result = [0]\n return result", "input": "[1, 2, 3, 4, 5]", "output": "['0', 2, '3', 4, '10']", "imports": [], "original_snippet": "def f(numbers: list) -> list:\n result = []\n for (index, num) in enumerate(numbers):\n if index % 2 == 0:\n sum_previous = sum(numbers[:index])\n result.append(sum_previous)\n else:\n result.append(num)\n for i in range(len(result)):\n if i % 2 == 0:\n result[i] = str(result[i])\n elif isinstance(result[i], str):\n result[i] = int(result[i])\n if not result:\n result = [0]\n return result", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(nums: list) -> str:\n if not nums:\n return 'Empty list provided'\n unique_indices = set()\n unique_nums = {}\n unique_entries = []\n for (i, num) in enumerate(nums):\n if i not in unique_indices and num not in unique_nums:\n unique_indices.add(i)\n unique_nums[num] = i\n unique_entries.append(f'{num}: {i}')\n sorted_entry = sorted(unique_entries, key=lambda x: int(x.split(': ')[0]), reverse=True)\n return ', '.join([entry for pair in sorted_entry for entry in [pair + ' appears at index ' + pair.split(': ')[1]] if pair.split(': ')[0].isdigit()])", "input": "[1, 2, 1, 2, 3, 3, 4]", "output": "'4: 6 appears at index 6, 3: 4 appears at index 4, 2: 1 appears at index 1, 1: 0 appears at index 0'", "imports": [], "original_snippet": "def f(nums: list) -> str:\n if not nums:\n return 'Empty list provided'\n unique_indices = set()\n unique_nums = {}\n unique_entries = []\n for (i, num) in enumerate(nums):\n if i not in unique_indices and num not in unique_nums:\n unique_indices.add(i)\n unique_nums[num] = i\n unique_entries.append(f'{num}: {i}')\n sorted_entry = sorted(unique_entries, key=lambda x: int(x.split(': ')[0]), reverse=True)\n return ', '.join([entry for pair in sorted_entry for entry in [pair + ' appears at index ' + pair.split(': ')[1]] if pair.split(': ')[0].isdigit()])", "composite_functions": [], "_input_type": "list", "_output_type": "str"} | |
| {"snippet": "def f(numbers):\n total = 0\n for num in numbers:\n if num > 0:\n product = num * abs(num)\n total += product\n return total", "input": "[1, -2, 3, 4, -5]", "output": "26", "imports": [], "original_snippet": "def f(numbers):\n total = 0\n for num in numbers:\n if num > 0:\n product = num * abs(num)\n total += product\n return total", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(input_str):\n input_str_list = list(input_str)\n uppercase_count = sum((1 if char.isupper() else 0 for char in input_str))\n for _ in range(uppercase_count):\n if input_str[-1].isupper():\n first_char = input_str_list.pop()\n input_str_list[0] = first_char\n reversed_str = ''.join(reversed(input_str_list))\n initial_uppercase_count = sum((1 if char.isupper() else 0 for char in input_str))\n return (reversed_str, initial_uppercase_count)", "input": "'egGEFDH'", "output": "('gG', 5)", "imports": [], "original_snippet": "def f(input_str):\n input_str_list = list(input_str)\n uppercase_count = sum((1 if char.isupper() else 0 for char in input_str))\n for _ in range(uppercase_count):\n if input_str[-1].isupper():\n first_char = input_str_list.pop()\n input_str_list[0] = first_char\n reversed_str = ''.join(reversed(input_str_list))\n initial_uppercase_count = sum((1 if char.isupper() else 0 for char in input_str))\n return (reversed_str, initial_uppercase_count)", "composite_functions": [], "_input_type": "str", "_output_type": "tuple"} | |
| {"snippet": "def f(lst):\n lst = [abs(x) for x in reversed(lst)]\n lst = [sum((abs(x) for x in lst)) ** 2 + x ** 3 for x in lst]\n return [sum((abs(x) for x in lst))] + [sum((x ** 3 * abs(x) - x ** 2 for x in lst))]", "input": "[1, 2, -3, -4]", "output": "[500, 1223583864]", "imports": [], "original_snippet": "def f(lst):\n lst = [abs(x) for x in reversed(lst)]\n lst = [sum((abs(x) for x in lst)) ** 2 + x ** 3 for x in lst]\n return [sum((abs(x) for x in lst))] + [sum((x ** 3 * abs(x) - x ** 2 for x in lst))]", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(numbers):\n if not numbers:\n return 0\n if len(numbers) == 1:\n return numbers[0]\n min_time = float('inf')\n for i in range(len(numbers)):\n current_num = numbers[i]\n remaining_nums = numbers[:i] + numbers[i + 1:]\n total_time = current_num + f(remaining_nums)\n if total_time < min_time:\n min_time = total_time\n return min_time", "input": "numbers = [3, 5, 2, 10, 15]", "output": "35", "imports": [], "original_snippet": "def f(numbers):\n if not numbers:\n return 0\n if len(numbers) == 1:\n return numbers[0]\n min_time = float('inf')\n for i in range(len(numbers)):\n current_num = numbers[i]\n remaining_nums = numbers[:i] + numbers[i + 1:]\n total_time = current_num + f(remaining_nums)\n if total_time < min_time:\n min_time = total_time\n return min_time", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(input_list):\n return [elem ** 2 for elem in input_list]", "input": "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", "output": "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]", "imports": [], "original_snippet": "def f(input_list):\n return [elem ** 2 for elem in input_list]", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "import string\ndef f(text: str, mapping: dict={'a': 128, 'e': 230, 'i': 345, 'o': 456, 'u': 567}):\n if not hasattr(f, 'original_text'):\n f.original_text = text\n if not hasattr(f, 'mapping_dict'):\n f.mapping_dict = mapping\n if len(f.mapping_dict) == 0:\n return text\n if not hasattr(f, 'modified_text'):\n f.modified_text = text\n state = 'check'\n for char in f.modified_text:\n if state == 'check' and char.lower() in f.mapping_dict:\n state = 'replace'\n f.original_text = text\n elif state == 'replace' and f.original_text.count(char) == 1:\n state = 'replace_letter'\n f.mapping_dict = {}\n elif state == 'replace_letter' and char.lower() in string.ascii_lowercase:\n state = 'check'\n f.mapping_dict = {}\n elif state == 'check' and char.isalpha():\n if state == 'check':\n state = 'increase'\n f.mapping_dict = {}\n elif state == 'increase' and char.isdigit():\n state = 'output'\n f.modified_text = f.modified_text.split(char)\n f.original_text = f.original_text.replace(char, '')\n f.modified_text = f.modified_text[0]\n elif state == 'output':\n state = 'break'\n results = []\n for (key, value) in f.mapping_dict.items():\n results.append((key, ''.join([string.ascii_uppercase[ord(char) - ord('a')].upper() if ord(char) in string.ascii_lowercase and chr((ord(char) - ord('a')) * value + ord('A')) else chr((ord(char) - ord('a')) * value + ord('A')) for char in key]), ''.join([string.ascii_lowercase[ord(char) - ord('a')] if ord(char) in string.ascii_lowercase and chr((ord(char) - ord('a')) * value + ord('a')) else chr((ord(char) - ord('a')) * value + ord('a')) for char in key])))\n if not results:\n return text\n else:\n return {'original_string': f.original_text, 'mapping': f.mapping_dict, 'modified_string': f.modified_text, 'results': results}", "input": "'Python\u00e4chsnowlok'", "output": "'Python\u00e4chsnowlok'", "imports": ["import string"], "original_snippet": "import string\ndef f(text: str, mapping: dict={'a': 128, 'e': 230, 'i': 345, 'o': 456, 'u': 567}):\n if not hasattr(f, 'original_text'):\n f.original_text = text\n if not hasattr(f, 'mapping_dict'):\n f.mapping_dict = mapping\n if len(f.mapping_dict) == 0:\n return text\n if not hasattr(f, 'modified_text'):\n f.modified_text = text\n state = 'check'\n for char in f.modified_text:\n if state == 'check' and char.lower() in f.mapping_dict:\n state = 'replace'\n f.original_text = text\n elif state == 'replace' and f.original_text.count(char) == 1:\n state = 'replace_letter'\n f.mapping_dict = {}\n elif state == 'replace_letter' and char.lower() in string.ascii_lowercase:\n state = 'check'\n f.mapping_dict = {}\n elif state == 'check' and char.isalpha():\n if state == 'check':\n state = 'increase'\n f.mapping_dict = {}\n elif state == 'increase' and char.isdigit():\n state = 'output'\n f.modified_text = f.modified_text.split(char)\n f.original_text = f.original_text.replace(char, '')\n f.modified_text = f.modified_text[0]\n elif state == 'output':\n state = 'break'\n results = []\n for (key, value) in f.mapping_dict.items():\n results.append((key, ''.join([string.ascii_uppercase[ord(char) - ord('a')].upper() if ord(char) in string.ascii_lowercase and chr((ord(char) - ord('a')) * value + ord('A')) else chr((ord(char) - ord('a')) * value + ord('A')) for char in key]), ''.join([string.ascii_lowercase[ord(char) - ord('a')] if ord(char) in string.ascii_lowercase and chr((ord(char) - ord('a')) * value + ord('a')) else chr((ord(char) - ord('a')) * value + ord('a')) for char in key])))\n if not results:\n return text\n else:\n return {'original_string': f.original_text, 'mapping': f.mapping_dict, 'modified_string': f.modified_text, 'results': results}", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(binary_string: str) -> str:\n binary_int = int(binary_string, 2)\n reversed_binary_int = binary_int ^ (1 << 8) - 1\n reversed_binary_string = bin(reversed_binary_int)[2:].zfill(len(binary_string))\n return reversed_binary_string", "input": "'10101010'", "output": "'01010101'", "imports": [], "original_snippet": "def f(binary_string: str) -> str:\n binary_int = int(binary_string, 2)\n reversed_binary_int = binary_int ^ (1 << 8) - 1\n reversed_binary_string = bin(reversed_binary_int)[2:].zfill(len(binary_string))\n return reversed_binary_string", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "import collections\nclass String:\n pass\ndef f(sequence: tuple):\n count_dict = collections.Counter({name[::-1]: 0 for name in sequence})\n return count_dict", "input": "('a', 'b', 'c', 'a', 'b', 'b', 'c')", "output": "Counter({'a': 0, 'b': 0, 'c': 0})", "imports": ["import collections"], "original_snippet": "import collections\nclass String:\n pass\ndef f(sequence: tuple):\n count_dict = collections.Counter({name[::-1]: 0 for name in sequence})\n return count_dict", "composite_functions": [], "_input_type": "tuple", "_output_type": "str"} | |
| {"snippet": "from typing import List, Union, Dict\ndef f(the_list: List[Union[int, str]], info: Dict[str, int]) -> int:\n total_sum = 0\n for (n, item) in enumerate(the_list):\n if isinstance(item, int):\n if n % 2 == 0:\n total_sum += item\n else:\n total_sum -= item\n elif isinstance(item, str):\n if len(item) in info.values():\n total_sum += len(item)\n else:\n total_sum -= ord(item[0])\n return total_sum", "input": "[10, 'apple', 15, 'banana', 20, 'cherry'], {'apple': 2, 'banana': 3, 'cherry': 4}", "output": "-249", "imports": ["from typing import List, Union, Dict"], "original_snippet": "from typing import List, Union, Dict\ndef f(the_list: List[Union[int, str]], info: Dict[str, int]) -> int:\n total_sum = 0\n for (n, item) in enumerate(the_list):\n if isinstance(item, int):\n if n % 2 == 0:\n total_sum += item\n else:\n total_sum -= item\n elif isinstance(item, str):\n if len(item) in info.values():\n total_sum += len(item)\n else:\n total_sum -= ord(item[0])\n return total_sum", "composite_functions": [], "_input_type": "tuple", "_output_type": "int"} | |
| {"snippet": "def f(numbers: list) -> int:\n dp = [[0 for _ in range(len(numbers) + 1)] for _ in range(len(numbers) + 1)]\n max_so_far = -float('inf')\n for i in range(len(numbers) + 1):\n dp[i][1] = numbers[i - 1]\n max_so_far = max(max_so_far, numbers[i - 1])\n for i in range(2, len(numbers) + 1):\n for j in range(2, i + 1):\n dp[i][j] = max(dp[i - 2][j - 2] + numbers[i - 1] * (i - 1), dp[i - 1][j - 1] + j * numbers[i - 1])\n max_so_far = max(max_so_far, dp[i][j])\n return max_so_far", "input": "[-1, 3, -4, 5, -3, -4, 6]", "output": "42", "imports": [], "original_snippet": "def f(numbers: list) -> int:\n dp = [[0 for _ in range(len(numbers) + 1)] for _ in range(len(numbers) + 1)]\n max_so_far = -float('inf')\n for i in range(len(numbers) + 1):\n dp[i][1] = numbers[i - 1]\n max_so_far = max(max_so_far, numbers[i - 1])\n for i in range(2, len(numbers) + 1):\n for j in range(2, i + 1):\n dp[i][j] = max(dp[i - 2][j - 2] + numbers[i - 1] * (i - 1), dp[i - 1][j - 1] + j * numbers[i - 1])\n max_so_far = max(max_so_far, dp[i][j])\n return max_so_far", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(company_name: str, years: list[int]) -> int:\n stock_prices = {2015: {'GOOG': [100, 105, 110, 115, 120], 'MSFT': [80, 85, 90, 95, 100]}, 2016: {'GOOG': [120, 125, 130, 135, 140], 'MSFT': [90, 95, 100, 105, 110]}, 2017: {'GOOG': [140, 145, 150, 155, 160], 'MSFT': [110, 115, 120, 125, 130]}, 2018: {'GOOG': [160, 165, 170, 175, 180], 'MSFT': [130, 135, 140, 145, 150]}, 2019: {'GOOG': [180, 185, 190, 195, 200], 'MSFT': [150, 155, 160, 165, 170]}}\n company_price = stock_prices[years[-1]][company_name]\n return sum(company_price)", "input": "'GOOG', [2015, 2017]", "output": "750", "imports": [], "original_snippet": "def f(company_name: str, years: list[int]) -> int:\n stock_prices = {2015: {'GOOG': [100, 105, 110, 115, 120], 'MSFT': [80, 85, 90, 95, 100]}, 2016: {'GOOG': [120, 125, 130, 135, 140], 'MSFT': [90, 95, 100, 105, 110]}, 2017: {'GOOG': [140, 145, 150, 155, 160], 'MSFT': [110, 115, 120, 125, 130]}, 2018: {'GOOG': [160, 165, 170, 175, 180], 'MSFT': [130, 135, 140, 145, 150]}, 2019: {'GOOG': [180, 185, 190, 195, 200], 'MSFT': [150, 155, 160, 165, 170]}}\n company_price = stock_prices[years[-1]][company_name]\n return sum(company_price)", "composite_functions": [], "_input_type": "tuple", "_output_type": "int"} | |
| {"snippet": "def f(n: int):\n queue = [n]\n while True:\n last_val = queue[-1]\n current_step = abs(last_val - queue[0])\n yield abs(current_step)\n queue.pop(0)\n if current_step == 1:\n queue.append(last_val)\n else:\n while True:\n if queue[0] + current_step == last_val:\n queue[0] += current_step\n break\n elif queue[0] - current_step == last_val:\n queue[0] -= current_step\n break\n else:\n queue.append(queue[0])\n break", "input": "10", "output": "", "imports": [], "original_snippet": "def f(n: int):\n queue = [n]\n while True:\n last_val = queue[-1]\n current_step = abs(last_val - queue[0])\n yield abs(current_step)\n queue.pop(0)\n if current_step == 1:\n queue.append(last_val)\n else:\n while True:\n if queue[0] + current_step == last_val:\n queue[0] += current_step\n break\n elif queue[0] - current_step == last_val:\n queue[0] -= current_step\n break\n else:\n queue.append(queue[0])\n break", "composite_functions": [], "_input_type": "int", "_output_type": "str"} | |
| {"snippet": "def f(output_value: str) -> str:\n input_string = ''\n for (i, char) in reversed(list(enumerate(output_value))):\n if char == '1':\n input_string += '0'\n else:\n input_string += '1'\n return reversed(input_string)", "input": "'01001'", "output": "", "imports": [], "original_snippet": "def f(output_value: str) -> str:\n input_string = ''\n for (i, char) in reversed(list(enumerate(output_value))):\n if char == '1':\n input_string += '0'\n else:\n input_string += '1'\n return reversed(input_string)", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(output):\n pass", "input": "[(3, 'root'), (4, 'left'), (5, 'right')]", "output": "None", "imports": [], "original_snippet": "def f(output):\n pass", "composite_functions": [], "_input_type": "list", "_output_type": "NoneType"} | |
| {"snippet": "import math\ndef f(nums: list[int]) -> int:\n max_first = max(nums)\n second_max = max([x for x in nums if x < max_first])\n return 500 * int(second_max / 500)", "input": "[100, 200, 300, 400, 500]", "output": "0", "imports": ["import math"], "original_snippet": "import math\ndef f(nums: list[int]) -> int:\n max_first = max(nums)\n second_max = max([x for x in nums if x < max_first])\n return 500 * int(second_max / 500)", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(numbers: list) -> int:\n total_sum = 0\n for num in numbers:\n total_sum += num\n return 32 - total_sum", "input": "[1, 2, 3]", "output": "26", "imports": [], "original_snippet": "def f(numbers: list) -> int:\n total_sum = 0\n for num in numbers:\n total_sum += num\n return 32 - total_sum", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "from typing import Dict\ndef f(person_info: Dict[str, int]) -> Dict[str, str]:\n (name, info) = person_info\n reversed_keys = {key[::-1].upper(): value for (key, value) in info.items()}\n swapped_dict = {}\n for (key, value) in reversed_keys.items():\n if key in name and value is not None:\n swapped_dict[key[0]] = value\n return swapped_dict", "input": "('Prof. Gordon', {'age': 20, 'city': 'New York', 'hobby': 1})", "output": "{}", "imports": ["from typing import Dict"], "original_snippet": "from typing import Dict\ndef f(person_info: Dict[str, int]) -> Dict[str, str]:\n (name, info) = person_info\n reversed_keys = {key[::-1].upper(): value for (key, value) in info.items()}\n swapped_dict = {}\n for (key, value) in reversed_keys.items():\n if key in name and value is not None:\n swapped_dict[key[0]] = value\n return swapped_dict", "composite_functions": [], "_input_type": "tuple", "_output_type": "dict"} | |
| {"snippet": "def f(input_word: str) -> str:\n translation_table = str.maketrans({chr(i): chr(i + 1) for i in range(ord('a'), ord('z') + 1)})\n return input_word.translate(translation_table)", "input": "'apple'", "output": "'bqqmf'", "imports": [], "original_snippet": "def f(input_word: str) -> str:\n translation_table = str.maketrans({chr(i): chr(i + 1) for i in range(ord('a'), ord('z') + 1)})\n return input_word.translate(translation_table)", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(lst):\n new_list = []\n for x in lst:\n if x % 2 == 0:\n new_list.append('Even')\n else:\n new_list.append('Odd')\n product = 1\n for elem in new_list:\n if elem == 'Even':\n product *= 2\n else:\n product *= x\n return [str(x) for x in range(1, product + 1)]", "input": "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", "output": "['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '30', '31', '32', '33', '34', '35'...', '3199983', '3199984', '3199985', '3199986', '3199987', '3199988', '3199989', '3199990', '3199991', '3199992', '3199993', '3199994', '3199995', '3199996', '3199997', '3199998', '3199999', '3200000']", "imports": [], "original_snippet": "def f(lst):\n new_list = []\n for x in lst:\n if x % 2 == 0:\n new_list.append('Even')\n else:\n new_list.append('Odd')\n product = 1\n for elem in new_list:\n if elem == 'Even':\n product *= 2\n else:\n product *= x\n return [str(x) for x in range(1, product + 1)]", "composite_functions": [], "_input_type": "list", "_output_type": "str"} | |
| {"snippet": "def f(numbers):\n even_sum = 0", "input": "f([2, 4, 6, 8, 10])", "output": "None", "imports": [], "original_snippet": "def f(numbers):\n even_sum = 0", "composite_functions": [], "_input_type": "str", "_output_type": "NoneType"} | |
| {"snippet": "def f(nums):\n if not nums:\n return 0\n nums.sort()\n max_diff = 0\n for i in range(1, len(nums)):\n diff = abs(nums[i] - nums[i - 1])\n if diff > max_diff:\n max_diff = diff\n return max_diff", "input": "[1, 3, 2, 7, 5, 6]", "output": "2", "imports": [], "original_snippet": "def f(nums):\n if not nums:\n return 0\n nums.sort()\n max_diff = 0\n for i in range(1, len(nums)):\n diff = abs(nums[i] - nums[i - 1])\n if diff > max_diff:\n max_diff = diff\n return max_diff", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "from typing import List, Dict\ndef f(lst: List[List[int]]) -> Dict[int, int]:\n sum_dict = {}\n for (i, sublist) in enumerate(lst):\n sum_dict[i] = sum(sublist)\n return sum_dict", "input": "[[1, 2, 3], [4, 5, 6]]", "output": "{0: 6, 1: 15}", "imports": ["from typing import List, Dict"], "original_snippet": "from typing import List, Dict\ndef f(lst: List[List[int]]) -> Dict[int, int]:\n sum_dict = {}\n for (i, sublist) in enumerate(lst):\n sum_dict[i] = sum(sublist)\n return sum_dict", "composite_functions": [], "_input_type": "list", "_output_type": "dict"} | |
| {"snippet": "import math\ndef f(depth):\n radius = depth\n area = math.pi * radius ** 2\n circunference = 2 * math.pi * radius\n cubed_value = math.pow(area, 3)\n cube_root = math.pow(area, 0.5)\n quorients = [circunference / cubed_value, math.log(circunference + 1, math.e), area / cube_root]\n result = sum((1 / q for q in quorients)) / (len(quorients) - 1)\n return result", "input": "4", "output": "2526.8424747235717", "imports": ["import math"], "original_snippet": "import math\ndef f(depth):\n radius = depth\n area = math.pi * radius ** 2\n circunference = 2 * math.pi * radius\n cubed_value = math.pow(area, 3)\n cube_root = math.pow(area, 0.5)\n quorients = [circunference / cubed_value, math.log(circunference + 1, math.e), area / cube_root]\n result = sum((1 / q for q in quorients)) / (len(quorients) - 1)\n return result", "composite_functions": [], "_input_type": "int", "_output_type": "float"} | |
| {"snippet": "def f(input_string: str) -> list[str]:\n reverse_string = []\n for char in input_string[::-1]:\n reverse_string.append(char)\n return reverse_string", "input": "'Hello!!! World!!'", "output": "['!', '!', 'd', 'l', 'r', 'o', 'W', ' ', '!', '!', '!', 'o', 'l', 'l', 'e', 'H']", "imports": [], "original_snippet": "def f(input_string: str) -> list[str]:\n reverse_string = []\n for char in input_string[::-1]:\n reverse_string.append(char)\n return reverse_string", "composite_functions": [], "_input_type": "str", "_output_type": "list"} | |
| {"snippet": "import collections\ndef f(names: list, ingredients: list) -> list:\n ingredient_histogram = collections.Counter(ingredients)\n name_pairs = list(zip(names, ingredients))\n valid_pairs = []\n for (name, ingredient) in name_pairs:\n ingredient_name = ingredient if isinstance(ingredient, str) else str(ingredient)\n if ingredient_histogram[ingredient_name] > 0 and ingredient_name in name:\n valid_pairs.append((name, ingredient))\n ingredient_histogram[ingredient_name] -= 1\n return valid_pairs", "input": "names = ['John, Mary, Peter', 'Alice, Bob, Charles'],\ningredients = ['egg, sugar, flour', 'milk, butter, sugar', 'sugar, eggs, milk']", "output": "[]", "imports": ["import collections"], "original_snippet": "import collections\ndef f(names: list, ingredients: list) -> list:\n ingredient_histogram = collections.Counter(ingredients)\n name_pairs = list(zip(names, ingredients))\n valid_pairs = []\n for (name, ingredient) in name_pairs:\n ingredient_name = ingredient if isinstance(ingredient, str) else str(ingredient)\n if ingredient_histogram[ingredient_name] > 0 and ingredient_name in name:\n valid_pairs.append((name, ingredient))\n ingredient_histogram[ingredient_name] -= 1\n return valid_pairs", "composite_functions": [], "_input_type": "str", "_output_type": "list"} | |
| {"snippet": "from typing import Tuple\ndef f(numbers: list[int]) -> str:\n max_first = max(numbers)\n second_max = max([x for x in numbers if x < max_first])\n even_numbers = [x for x in numbers if x % 2 == 0]\n even_count = len(even_numbers)\n return ' '.join((str(x) for x in [max_first, second_max, even_count]))", "input": "[1, 2, 3, 4, 5]", "output": "'5 4 2'", "imports": ["from typing import Tuple"], "original_snippet": "from typing import Tuple\ndef f(numbers: list[int]) -> str:\n max_first = max(numbers)\n second_max = max([x for x in numbers if x < max_first])\n even_numbers = [x for x in numbers if x % 2 == 0]\n even_count = len(even_numbers)\n return ' '.join((str(x) for x in [max_first, second_max, even_count]))", "composite_functions": [], "_input_type": "list", "_output_type": "str"} | |
| {"snippet": "def f(numbers: list) -> list:\n result = []\n for num in numbers:\n abs_num = abs(num)\n if abs_num % 3 == 0:\n reversed_word = ''.join((str(abs_num) for _ in range(abs_num)))\n result.append(reversed_word[::-1])\n return result", "input": "[-2, 0, 3, 4, -7, -8, -4]", "output": "['', '333']", "imports": [], "original_snippet": "def f(numbers: list) -> list:\n result = []\n for num in numbers:\n abs_num = abs(num)\n if abs_num % 3 == 0:\n reversed_word = ''.join((str(abs_num) for _ in range(abs_num)))\n result.append(reversed_word[::-1])\n return result", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(value: int):\n index = 0\n while value % 10 == value // 10:\n value //= 10\n index += 1\n if len(str(value)) < 6:\n raise ValueError\n else:\n return f'{value}, index: {index}'", "input": "19292229", "output": "'19292229, index: 0'", "imports": [], "original_snippet": "def f(value: int):\n index = 0\n while value % 10 == value // 10:\n value //= 10\n index += 1\n if len(str(value)) < 6:\n raise ValueError\n else:\n return f'{value}, index: {index}'", "composite_functions": [], "_input_type": "int", "_output_type": "str"} | |
| {"snippet": "def f(input_string: str) -> str:\n unique_characters = set()\n max_character = ''\n max_length = 0\n for i in range(len(input_string)):\n current_character = input_string[i]\n character_count = 1\n j = i + 1\n while j < len(input_string) and input_string[j] == current_character:\n character_count += 1\n j += 1\n if character_count > max_length:\n max_length = character_count\n max_character = current_character\n elif character_count == max_length:\n if current_character < max_character:\n max_character = current_character\n return max_character", "input": "'baabaa'", "output": "'a'", "imports": [], "original_snippet": "def f(input_string: str) -> str:\n unique_characters = set()\n max_character = ''\n max_length = 0\n for i in range(len(input_string)):\n current_character = input_string[i]\n character_count = 1\n j = i + 1\n while j < len(input_string) and input_string[j] == current_character:\n character_count += 1\n j += 1\n if character_count > max_length:\n max_length = character_count\n max_character = current_character\n elif character_count == max_length:\n if current_character < max_character:\n max_character = current_character\n return max_character", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(nums):\n if not nums or len(nums) < 2:\n return 0\n product_sum = 0\n n = len(nums)\n for i in range(n):\n for j in range(i + 1, n):\n product = nums[i] * nums[j]\n if product < 0:\n product_sum += product\n else:\n break\n return product_sum", "input": "[1, 2, 3, 4, 5, 6]", "output": "0", "imports": [], "original_snippet": "def f(nums):\n if not nums or len(nums) < 2:\n return 0\n product_sum = 0\n n = len(nums)\n for i in range(n):\n for j in range(i + 1, n):\n product = nums[i] * nums[j]\n if product < 0:\n product_sum += product\n else:\n break\n return product_sum", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "from heapq import heapify, heappush, heappop\nfrom typing import List\ndef f(nums: List[int]) -> List[int]:\n if not nums:\n return []\n nums_copy = [num for num in nums]\n heapify(nums_copy)\n unique_nums = []\n while nums_copy:\n num = heappop(nums_copy)\n if num not in unique_nums:\n unique_nums.append(num)\n return unique_nums", "input": "[5, 3, 1, 6, 8, 9, 1, 2, 3, 4, 5]", "output": "[1, 2, 3, 4, 5, 6, 8, 9]", "imports": ["from heapq import heapify, heappush, heappop", "from typing import List"], "original_snippet": "from heapq import heapify, heappush, heappop\nfrom typing import List\ndef f(nums: List[int]) -> List[int]:\n if not nums:\n return []\n nums_copy = [num for num in nums]\n heapify(nums_copy)\n unique_nums = []\n while nums_copy:\n num = heappop(nums_copy)\n if num not in unique_nums:\n unique_nums.append(num)\n return unique_nums", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(string, mapping):\n length = len(' ' * 1000) - len(''.join((ch for (i, ch) in enumerate(string) if i not in mapping)))\n output = ''\n for (i, ch) in enumerate(string):\n if i not in mapping:\n output = output + ch\n else:\n if len(output) < length // 2:\n output = output[::-1].encode('utf-8')\n output = output.decode('utf-8') + ch\n return (output, len(output))", "input": "'Hello.', {'H': '', 'e': '', 'l': '', 'o': '', '.': ''}", "output": "('Hello.', 6)", "imports": [], "original_snippet": "def f(string, mapping):\n length = len(' ' * 1000) - len(''.join((ch for (i, ch) in enumerate(string) if i not in mapping)))\n output = ''\n for (i, ch) in enumerate(string):\n if i not in mapping:\n output = output + ch\n else:\n if len(output) < length // 2:\n output = output[::-1].encode('utf-8')\n output = output.decode('utf-8') + ch\n return (output, len(output))", "composite_functions": [], "_input_type": "tuple", "_output_type": "tuple"} | |
| {"snippet": "def f(stars: str) -> float:\n stars = stars.replace('*', ',')\n valid_stars = 0\n invalid_stars = 0\n for i in range(1, len(stars)):\n if stars[i] == ',':\n continue\n if stars[i].upper() in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' or stars[i] in 'VMON' or stars[i] == 'ROBINSON':\n valid_stars += 1\n else:\n invalid_stars += 1\n return (valid_stars - 15.0) / max(len(stars), 10)", "input": "'f*,g#,a!!b, c# d,e,V,ABC,XYZ'", "output": "-0.07142857142857142", "imports": [], "original_snippet": "def f(stars: str) -> float:\n stars = stars.replace('*', ',')\n valid_stars = 0\n invalid_stars = 0\n for i in range(1, len(stars)):\n if stars[i] == ',':\n continue\n if stars[i].upper() in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' or stars[i] in 'VMON' or stars[i] == 'ROBINSON':\n valid_stars += 1\n else:\n invalid_stars += 1\n return (valid_stars - 15.0) / max(len(stars), 10)", "composite_functions": [], "_input_type": "str", "_output_type": "float"} | |
| {"snippet": "def f(numbers, dictionary):\n if len(numbers) == 0:\n return (0, None)\n even_numbers = []\n for num in numbers:\n if num % 2 == 0:\n even_numbers.append(num)\n largest_even_number = max(even_numbers)\n filtered_dictionary = {k: v for (k, v) in dictionary.items() if v.get('value', 0) == largest_even_number}\n if len(filtered_dictionary) == 0:\n return (sum(even_numbers), None)\n largest_even_value = max(filtered_dictionary.keys(), key=lambda x: filtered_dictionary[x]['value'])\n return (sum(even_numbers), largest_even_value)", "input": "[2, 4, 6, 8, 10], {'a': {'value': 9, 'name': 'Deep-Thinking', 'role': 'Solver'}, 'b': {'value': 3, 'name': 'Cat', 'role': 'Solver'}, 'c': {'value': 4, 'name': 'Bird', 'role': 'Listener'}}", "output": "(30, None)", "imports": [], "original_snippet": "def f(numbers, dictionary):\n if len(numbers) == 0:\n return (0, None)\n even_numbers = []\n for num in numbers:\n if num % 2 == 0:\n even_numbers.append(num)\n largest_even_number = max(even_numbers)\n filtered_dictionary = {k: v for (k, v) in dictionary.items() if v.get('value', 0) == largest_even_number}\n if len(filtered_dictionary) == 0:\n return (sum(even_numbers), None)\n largest_even_value = max(filtered_dictionary.keys(), key=lambda x: filtered_dictionary[x]['value'])\n return (sum(even_numbers), largest_even_value)", "composite_functions": [], "_input_type": "tuple", "_output_type": "tuple"} | |
| {"snippet": "def f(numbers: list[int]) -> int:\n n = len(numbers)\n min_steps = [float('inf')] * n\n min_steps[0] = 0\n for i in range(1, n):\n for j in range(i):\n if numbers[j] % numbers[i] == 0 or numbers[i] % 2 == 0:\n min_steps[i] = min(min_steps[i], min_steps[j] + abs(numbers[i] - numbers[j]))\n return len(min_steps) if min(min_steps) < float('inf') else -1", "input": "[5, 10, 15, 20]", "output": "4", "imports": [], "original_snippet": "def f(numbers: list[int]) -> int:\n n = len(numbers)\n min_steps = [float('inf')] * n\n min_steps[0] = 0\n for i in range(1, n):\n for j in range(i):\n if numbers[j] % numbers[i] == 0 or numbers[i] % 2 == 0:\n min_steps[i] = min(min_steps[i], min_steps[j] + abs(numbers[i] - numbers[j]))\n return len(min_steps) if min(min_steps) < float('inf') else -1", "composite_functions": [], "_input_type": "list", "_output_type": "int"} | |
| {"snippet": "def f(some_input: str) -> tuple:\n alphabet = 'abcdefghijklmnopqrstuvwxyz'\n shift_count = sum((ord(char) for char in some_input))\n encoded_string = ''\n for char in some_input:\n if char in alphabet:\n index = alphabet.index(char)\n new_index = (index + int(shift_count) % len(alphabet)) % len(alphabet)\n encoded_string += alphabet[new_index]\n else:\n encoded_string += char\n return (encoded_string, shift_count)", "input": "'Hello, World!'", "output": "('Hpwwz, Wzcwo!', 1129)", "imports": [], "original_snippet": "def f(some_input: str) -> tuple:\n alphabet = 'abcdefghijklmnopqrstuvwxyz'\n shift_count = sum((ord(char) for char in some_input))\n encoded_string = ''\n for char in some_input:\n if char in alphabet:\n index = alphabet.index(char)\n new_index = (index + int(shift_count) % len(alphabet)) % len(alphabet)\n encoded_string += alphabet[new_index]\n else:\n encoded_string += char\n return (encoded_string, shift_count)", "composite_functions": [], "_input_type": "str", "_output_type": "tuple"} | |
| {"snippet": "from typing import List, Dict\ndef f(custom_dict: Dict[int, int]) -> List[int]:\n transformed_numbers = []\n for (key, value) in sorted(custom_dict.items()):\n if key % 2 != 0:\n transformed_numbers.append(key)\n elif value % 2 == 0:\n transformed_numbers.append(value)\n return transformed_numbers", "input": "{1: 3, 4: 2, 5: 7, 8: 5}", "output": "[1, 2, 5]", "imports": ["from typing import List, Dict"], "original_snippet": "from typing import List, Dict\ndef f(custom_dict: Dict[int, int]) -> List[int]:\n transformed_numbers = []\n for (key, value) in sorted(custom_dict.items()):\n if key % 2 != 0:\n transformed_numbers.append(key)\n elif value % 2 == 0:\n transformed_numbers.append(value)\n return transformed_numbers", "composite_functions": [], "_input_type": "dict", "_output_type": "list"} | |
| {"snippet": "def f(array: list[int]):\n n = len(array)\n min_steps = [float('inf')] * n\n min_steps[0] = 0\n for i in range(1, n):\n min_steps[i] = float('inf')\n if array[i] >= array[i - 1]:\n min_steps[i] = min(min_steps[i], min_steps[i - 1])\n else:\n for j in range(i - 1):\n if array[j] >= array[i] and array[j] - array[i] <= 1:\n min_steps[i] = min(min_steps[i], min_steps[j] + 1)\n return min_steps[n - 1]", "input": "[1, 2, 3, -4, 5]", "output": "inf", "imports": [], "original_snippet": "def f(array: list[int]):\n n = len(array)\n min_steps = [float('inf')] * n\n min_steps[0] = 0\n for i in range(1, n):\n min_steps[i] = float('inf')\n if array[i] >= array[i - 1]:\n min_steps[i] = min(min_steps[i], min_steps[i - 1])\n else:\n for j in range(i - 1):\n if array[j] >= array[i] and array[j] - array[i] <= 1:\n min_steps[i] = min(min_steps[i], min_steps[j] + 1)\n return min_steps[n - 1]", "composite_functions": [], "_input_type": "list", "_output_type": "str"} | |
| {"snippet": "import math\ndef f(num: int, operators: list[str]) -> int:\n current_num = num\n for op in operators:\n if op == '+':\n current_num += current_num\n elif op == '*':\n current_num *= current_num\n else:\n return -1\n return current_num", "input": "2, ['+', '*', '+']", "output": "32", "imports": ["import math"], "original_snippet": "import math\ndef f(num: int, operators: list[str]) -> int:\n current_num = num\n for op in operators:\n if op == '+':\n current_num += current_num\n elif op == '*':\n current_num *= current_num\n else:\n return -1\n return current_num", "composite_functions": [], "_input_type": "tuple", "_output_type": "int"} | |
| {"snippet": "def f(l: list, r: list) -> list:\n if not l:\n return r\n else:\n return [x + y for (x, y) in zip(l, r)]", "input": "[1, 2, 3, 4, 5], [10, 20, 30]", "output": "[11, 22, 33]", "imports": [], "original_snippet": "def f(l: list, r: list) -> list:\n if not l:\n return r\n else:\n return [x + y for (x, y) in zip(l, r)]", "composite_functions": [], "_input_type": "tuple", "_output_type": "list"} | |
| {"snippet": "def f(n: int) -> int:\n if n == 0:\n return 1\n if n < 0:\n return 0\n if n in [1, 3, 4]:\n return 1\n dp = [0] * (n + 1)\n dp[0] = 1\n for i in range(1, n + 1):\n dp[i] += dp[i - 1]\n if i >= 1:\n dp[i] += dp[i - 3]\n if i >= 3:\n dp[i] += dp[i - 4]\n return dp[n]", "input": "5", "output": "6", "imports": [], "original_snippet": "def f(n: int) -> int:\n if n == 0:\n return 1\n if n < 0:\n return 0\n if n in [1, 3, 4]:\n return 1\n dp = [0] * (n + 1)\n dp[0] = 1\n for i in range(1, n + 1):\n dp[i] += dp[i - 1]\n if i >= 1:\n dp[i] += dp[i - 3]\n if i >= 3:\n dp[i] += dp[i - 4]\n return dp[n]", "composite_functions": [], "_input_type": "int", "_output_type": "int"} | |
| {"snippet": "def f(numbers: list, signs: list) -> int:\n result = 0\n for i in range(len(numbers)):\n if not numbers[i]:\n break\n result += signs[i - 1] * numbers[i]\n return result", "input": "[1, 2, 3, 0, 5, 6, 7], [1, -1, 1, 1, -1, -1, 1]", "output": "0", "imports": [], "original_snippet": "def f(numbers: list, signs: list) -> int:\n result = 0\n for i in range(len(numbers)):\n if not numbers[i]:\n break\n result += signs[i - 1] * numbers[i]\n return result", "composite_functions": [], "_input_type": "tuple", "_output_type": "int"} | |
| {"snippet": "def f(input_set: set) -> int:\n current_input_set = set()\n value = 0\n while value != len(input_set):\n inputs = list(input_set)\n current_input_set = set()\n current_input_set.add(inputs[0])\n for i in range(1, len(inputs)):\n if inputs[i] - inputs[i - 1] == 1:\n current_input_set.add(inputs[i])\n input_set = current_input_set\n value = len(input_set)\n for s in current_input_set:\n print(s)", "input": "{1, 2, 3, 4, 5, 7}", "output": "None", "imports": [], "original_snippet": "def f(input_set: set) -> int:\n current_input_set = set()\n value = 0\n while value != len(input_set):\n inputs = list(input_set)\n current_input_set = set()\n current_input_set.add(inputs[0])\n for i in range(1, len(inputs)):\n if inputs[i] - inputs[i - 1] == 1:\n current_input_set.add(inputs[i])\n input_set = current_input_set\n value = len(input_set)\n for s in current_input_set:\n print(s)", "composite_functions": [], "_input_type": "set", "_output_type": "NoneType"} | |
| {"snippet": "def f(input_string: str) -> str:\n reversed_string = input_string[::-1]\n pieces = [reversed_string[i:i + 4] for i in range(0, len(reversed_string), 4)]\n reversed_pieces = [piece[::-1] for piece in pieces]\n result = ''.join(reversed_pieces)\n return result", "input": "'Hello world!'", "output": "'rld!o woHell'", "imports": [], "original_snippet": "def f(input_string: str) -> str:\n reversed_string = input_string[::-1]\n pieces = [reversed_string[i:i + 4] for i in range(0, len(reversed_string), 4)]\n reversed_pieces = [piece[::-1] for piece in pieces]\n result = ''.join(reversed_pieces)\n return result", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(n):\n return sum((pow(i, 2) for i in range(1, n + 1)))", "input": "5", "output": "55", "imports": [], "original_snippet": "def f(n):\n return sum((pow(i, 2) for i in range(1, n + 1)))", "composite_functions": [], "_input_type": "int", "_output_type": "int"} | |
| {"snippet": "import os\ndef f(test_suite_output: str) -> str:\n result = test_suite_output\n while result.startswith('0'):\n result = result[1:]\n if len(result) >= 5:\n result = result[1:]\n result = result.lower()\n while len(result) > 2 and result[0] == result[1] == result[2]:\n result = result[1:]\n if len(result) >= 5 and len(set(result.replace('0', '').replace('1', ''))) >= 5:\n return result\n else:\n return 'Input is not a valid challenge sequence.'", "input": "'1111100000000001111100000011111100100100000011111001000100111111111111111111111001000000'", "output": "'Input is not a valid challenge sequence.'", "imports": ["import os"], "original_snippet": "import os\ndef f(test_suite_output: str) -> str:\n result = test_suite_output\n while result.startswith('0'):\n result = result[1:]\n if len(result) >= 5:\n result = result[1:]\n result = result.lower()\n while len(result) > 2 and result[0] == result[1] == result[2]:\n result = result[1:]\n if len(result) >= 5 and len(set(result.replace('0', '').replace('1', ''))) >= 5:\n return result\n else:\n return 'Input is not a valid challenge sequence.'", "composite_functions": [], "_input_type": "str", "_output_type": "str"} | |
| {"snippet": "def f(data: list, weights: list) -> float:\n total_weighted_sum = 0.0\n for (i, (value, weight)) in enumerate(zip(data, weights)):\n contribution = value * weight\n total_weighted_sum += contribution\n return total_weighted_sum", "input": "[6, 3, 8, 5], [0.1, 0.2, 0.3, 0.4]", "output": "5.6", "imports": [], "original_snippet": "def f(data: list, weights: list) -> float:\n total_weighted_sum = 0.0\n for (i, (value, weight)) in enumerate(zip(data, weights)):\n contribution = value * weight\n total_weighted_sum += contribution\n return total_weighted_sum", "composite_functions": [], "_input_type": "tuple", "_output_type": "float"} | |
| {"snippet": "def f(numbers: list, sum_value: int=1) -> int:\n if not numbers:\n raise ValueError('No numbers provided.')\n else:\n total_sum = 0\n for num in numbers:\n total_sum += num\n return total_sum * sum_value", "input": "numbers = [1, 2, 3, 4],\nsum_value = 5", "output": "50", "imports": [], "original_snippet": "def f(numbers: list, sum_value: int=1) -> int:\n if not numbers:\n raise ValueError('No numbers provided.')\n else:\n total_sum = 0\n for num in numbers:\n total_sum += num\n return total_sum * sum_value", "composite_functions": [], "_input_type": "str", "_output_type": "int"} | |
| {"snippet": "def f(numbers):\n for index in range(len(numbers)):\n if numbers[index] % 3 == 0:\n numbers[index] = numbers[index] - 2\n return numbers", "input": "[1, 5, 6, 2]", "output": "[1, 5, 4, 2]", "imports": [], "original_snippet": "def f(numbers):\n for index in range(len(numbers)):\n if numbers[index] % 3 == 0:\n numbers[index] = numbers[index] - 2\n return numbers", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |
| {"snippet": "def f(input_list: list) -> list:\n total = 0\n lst = [i ** 2 for i in input_list]\n for x in lst:\n total += int(str(x)[::-1])\n return [str(total)[::-1]]", "input": "[1, 2, 3, 4]", "output": "['57']", "imports": [], "original_snippet": "def f(input_list: list) -> list:\n total = 0\n lst = [i ** 2 for i in input_list]\n for x in lst:\n total += int(str(x)[::-1])\n return [str(total)[::-1]]", "composite_functions": [], "_input_type": "list", "_output_type": "list"} | |