{"i": 0, "src_path": "src/00000.py", "pyc_path": "pyc/00000.pyc", "input": "CODE ()\n RESUME 0\n PUSH_NULL\n LOAD_BUILD_CLASS\n LOAD_CONST \n MAKE_FUNCTION 0\n LOAD_CONST 'Pair'\n LOAD_NAME object\n CALL 3\n STORE_NAME Pair\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME max_chain_length\n RETURN_CONST None\nEND\nCODE Pair()\n DOC 'Pair'\n RESUME 0\n LOAD_NAME __name__\n STORE_NAME __module__\n LOAD_CONST 'Pair'\n STORE_NAME __qualname__\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME __init__\n RETURN_CONST None\nEND\nCODE Pair.__init__(self, a, b)\n RESUME 0\n LOAD_FAST a\n LOAD_FAST self\n STORE_ATTR a\n LOAD_FAST b\n LOAD_FAST self\n STORE_ATTR b\n RETURN_CONST None\nEND\nCODE max_chain_length(arr, n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST max\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_CONST 1\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST mcl\n STORE_FAST i\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST n\n CALL 2\n GET_ITER\nL5:\n FOR_ITER L10\n STORE_FAST i\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_FAST i\n CALL 2\n GET_ITER\nL6:\n FOR_ITER L9\n STORE_FAST j\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_ATTR a\n LOAD_FAST arr\n LOAD_FAST j\n BINARY_SUBSCR\n LOAD_ATTR b\n COMPARE_OP >\n POP_JUMP_IF_TRUE L7\n JUMP_BACKWARD L6\nL7:\n LOAD_FAST mcl\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST mcl\n LOAD_FAST j\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +\n COMPARE_OP <\n POP_JUMP_IF_TRUE L8\n JUMP_BACKWARD L6\nL8:\n LOAD_FAST mcl\n LOAD_FAST j\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST mcl\n LOAD_FAST i\n STORE_SUBSCR\n JUMP_BACKWARD L6\nL9:\n END_FOR\n JUMP_BACKWARD L5\nL10:\n END_FOR\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL11:\n FOR_ITER L13\n STORE_FAST i\n LOAD_FAST max\n LOAD_FAST mcl\n LOAD_FAST i\n BINARY_SUBSCR\n COMPARE_OP <\n POP_JUMP_IF_TRUE L12\n JUMP_BACKWARD L11\nL12:\n LOAD_FAST mcl\n LOAD_FAST i\n BINARY_SUBSCR\n STORE_FAST max\n JUMP_BACKWARD L11\nL13:\n END_FOR\n LOAD_FAST max\n RETURN_VALUE\nL14:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\n EXC try=L1..L4 -> handler=L14 depth=2 lasti=False\nEND", "expected": "class Pair(object):\n\n def __init__(self, a, b):\n self.a = a\n self.b = b\n\ndef max_chain_length(arr, n):\n max = 0\n mcl = [1 for i in range(n)]\n for i in range(1, n):\n for j in range(0, i):\n if arr[i].a > arr[j].b and mcl[i] < mcl[j] + 1:\n mcl[i] = mcl[j] + 1\n for i in range(n):\n if max < mcl[i]:\n max = mcl[i]\n return max", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 601, "mbpp_split": "train", "prompt": "Write a function to find the longest chain which can be formed from the given set of pairs.", "test_list": ["assert max_chain_length([Pair(5, 24), Pair(15, 25),Pair(27, 40), Pair(50, 60)], 4) == 3", "assert max_chain_length([Pair(1, 2), Pair(3, 4),Pair(5, 6), Pair(7, 8)], 4) == 4", "assert max_chain_length([Pair(19, 10), Pair(11, 12),Pair(13, 14), Pair(15, 16), Pair(31, 54)], 5) == 5"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_601", "n_instr": 146} {"i": 1, "src_path": "src/00001.py", "pyc_path": "pyc/00001.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME first_repeated_char\n RETURN_CONST None\nEND\nCODE first_repeated_char(str1)\n RESUME 0\n LOAD_GLOBAL NULL + enumerate\n LOAD_FAST str1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST index\n STORE_FAST c\n LOAD_FAST str1\n LOAD_CONST None\n LOAD_FAST index\n LOAD_CONST 1\n BINARY_OP +\n BINARY_SLICE\n LOAD_ATTR NULL|self + count\n LOAD_FAST c\n CALL 1\n LOAD_CONST 1\n COMPARE_OP >\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST c\n SWAP 2\n POP_TOP\n RETURN_VALUE\nL3:\n END_FOR\n RETURN_CONST 'None'\nEND", "expected": "def first_repeated_char(str1):\n for index, c in enumerate(str1):\n if str1[:index + 1].count(c) > 1:\n return c\n return 'None'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 602, "mbpp_split": "train", "prompt": "Write a python function to find the first repeated character in a given string.", "test_list": ["assert first_repeated_char(\"abcabc\") == \"a\"", "assert first_repeated_char(\"abc\") == \"None\"", "assert first_repeated_char(\"123123\") == \"1\""], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_602", "n_instr": 39} {"i": 2, "src_path": "src/00002.py", "pyc_path": "pyc/00002.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_ludic\n RETURN_CONST None\nEND\nCODE get_ludic(n)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST ludics\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST ludics\n LOAD_ATTR NULL|self + append\n LOAD_FAST i\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_CONST 1\n STORE_FAST index\n LOAD_FAST index\n LOAD_GLOBAL NULL + len\n LOAD_FAST ludics\n CALL 1\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L6\nL3:\n LOAD_FAST ludics\n LOAD_FAST index\n BINARY_SUBSCR\n STORE_FAST first_ludic\n LOAD_FAST index\n LOAD_FAST first_ludic\n BINARY_OP +\n STORE_FAST remove_index\n LOAD_FAST remove_index\n LOAD_GLOBAL NULL + len\n LOAD_FAST ludics\n CALL 1\n COMPARE_OP <\n POP_JUMP_IF_FALSE L5\nL4:\n LOAD_FAST ludics\n LOAD_ATTR NULL|self + remove\n LOAD_FAST ludics\n LOAD_FAST remove_index\n BINARY_SUBSCR\n CALL 1\n POP_TOP\n LOAD_FAST remove_index\n LOAD_FAST first_ludic\n BINARY_OP +\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST remove_index\n LOAD_FAST remove_index\n LOAD_GLOBAL NULL + len\n LOAD_FAST ludics\n CALL 1\n COMPARE_OP <\n POP_JUMP_IF_FALSE L5\n JUMP_BACKWARD L4\nL5:\n LOAD_FAST index\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST index\n LOAD_FAST index\n LOAD_GLOBAL NULL + len\n LOAD_FAST ludics\n CALL 1\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L6\n JUMP_BACKWARD L3\nL6:\n LOAD_FAST ludics\n RETURN_VALUE\nEND", "expected": "def get_ludic(n):\n ludics = []\n for i in range(1, n + 1):\n ludics.append(i)\n index = 1\n while index != len(ludics):\n first_ludic = ludics[index]\n remove_index = index + first_ludic\n while remove_index < len(ludics):\n ludics.remove(ludics[remove_index])\n remove_index = remove_index + first_ludic - 1\n index += 1\n return ludics", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 603, "mbpp_split": "train", "prompt": "Write a function to get a lucid number smaller than or equal to n.", "test_list": ["assert get_ludic(10) == [1, 2, 3, 5, 7]", "assert get_ludic(25) == [1, 2, 3, 5, 7, 11, 13, 17, 23, 25]", "assert get_ludic(45) == [1, 2, 3, 5, 7, 11, 13, 17, 23, 25, 29, 37, 41, 43]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_603", "n_instr": 88} {"i": 3, "src_path": "src/00003.py", "pyc_path": "pyc/00003.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME reverse_words\n RETURN_CONST None\nEND\nCODE reverse_words(s)\n RESUME 0\n LOAD_CONST ' '\n LOAD_ATTR NULL|self + join\n LOAD_GLOBAL NULL + reversed\n LOAD_FAST s\n LOAD_ATTR NULL|self + split\n CALL 0\n CALL 1\n CALL 1\n RETURN_VALUE\nEND", "expected": "def reverse_words(s):\n return ' '.join(reversed(s.split()))", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 604, "mbpp_split": "train", "prompt": "Write a function to reverse words in a given string.", "test_list": ["assert reverse_words(\"python program\")==(\"program python\")", "assert reverse_words(\"java language\")==(\"language java\")", "assert reverse_words(\"indian man\")==(\"man indian\")"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_604", "n_instr": 18} {"i": 4, "src_path": "src/00004.py", "pyc_path": "pyc/00004.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME prime_num\n RETURN_CONST None\nEND\nCODE prime_num(num)\n RESUME 0\n LOAD_FAST num\n LOAD_CONST 1\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L3\n LOAD_GLOBAL NULL + range\n LOAD_CONST 2\n LOAD_FAST num\n LOAD_CONST 2\n BINARY_OP //\n CALL 2\n GET_ITER\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST num\n LOAD_FAST i\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n POP_TOP\n RETURN_CONST False\nL1:\n POP_TOP\n RETURN_CONST True\nL2:\n END_FOR\n RETURN_CONST None\nL3:\n RETURN_CONST False\nEND", "expected": "def prime_num(num):\n if num >= 1:\n for i in range(2, num // 2):\n if num % i == 0:\n return False\n else:\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 605, "mbpp_split": "train", "prompt": "Write a function to check if the given integer is a prime number.", "test_list": ["assert prime_num(13)==True", "assert prime_num(7)==True", "assert prime_num(-1010)==False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_605", "n_instr": 38} {"i": 5, "src_path": "src/00005.py", "pyc_path": "pyc/00005.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME radian_degree\n RETURN_CONST None\nEND\nCODE radian_degree(degree)\n RESUME 0\n LOAD_FAST degree\n LOAD_GLOBAL math\n LOAD_ATTR pi\n LOAD_CONST 180\n BINARY_OP /\n BINARY_OP *\n STORE_FAST radian\n LOAD_FAST radian\n RETURN_VALUE\nEND", "expected": "import math\n\ndef radian_degree(degree):\n radian = degree * (math.pi / 180)\n return radian", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 606, "mbpp_split": "train", "prompt": "Write a function to convert degrees to radians.", "test_list": ["assert radian_degree(90)==1.5707963267948966", "assert radian_degree(60)==1.0471975511965976", "assert radian_degree(120)==2.0943951023931953"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_606", "n_instr": 22} {"i": 6, "src_path": "src/00006.py", "pyc_path": "pyc/00006.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME bell_Number\n RETURN_CONST None\nEND\nCODE bell_Number(n)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n CALL 1\n GET_ITER\n LOAD_FAST_AND_CLEAR j\n LOAD_FAST_AND_CLEAR i\n SWAP 3\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L7\n STORE_FAST j\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n CALL 1\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL3:\n BUILD_LIST 0\n SWAP 2\nL4:\n FOR_ITER L5\n STORE_FAST i\n LOAD_CONST 0\n LIST_APPEND 2\n JUMP_BACKWARD L4\nL5:\n END_FOR\nL6:\n SWAP 2\n STORE_FAST i\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL7:\n END_FOR\nL8:\n STORE_FAST bell\n STORE_FAST j\n STORE_FAST i\n LOAD_CONST 1\n LOAD_FAST bell\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_CONST 0\n STORE_SUBSCR\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL9:\n FOR_ITER L12\n STORE_FAST i\n LOAD_FAST bell\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n LOAD_FAST bell\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST 0\n STORE_SUBSCR\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL10:\n FOR_ITER L11\n STORE_FAST j\n LOAD_FAST bell\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n LOAD_FAST j\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n LOAD_FAST bell\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST j\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n BINARY_OP +\n LOAD_FAST bell\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST j\n STORE_SUBSCR\n JUMP_BACKWARD L10\nL11:\n END_FOR\n JUMP_BACKWARD L9\nL12:\n END_FOR\n LOAD_FAST bell\n LOAD_FAST n\n BINARY_SUBSCR\n LOAD_CONST 0\n BINARY_SUBSCR\n RETURN_VALUE\nL13:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\nL14:\n SWAP 2\n POP_TOP\n SWAP 3\n STORE_FAST i\n STORE_FAST j\n RERAISE 0\n EXC try=L1..L3 -> handler=L14 depth=3 lasti=False\n EXC try=L3..L6 -> handler=L13 depth=6 lasti=False\n EXC try=L6..L8 -> handler=L14 depth=3 lasti=False\n EXC try=L13..L14 -> handler=L14 depth=3 lasti=False\nEND", "expected": "def bell_Number(n):\n bell = [[0 for i in range(n + 1)] for j in range(n + 1)]\n bell[0][0] = 1\n for i in range(1, n + 1):\n bell[i][0] = bell[i - 1][i - 1]\n for j in range(1, i + 1):\n bell[i][j] = bell[i - 1][j - 1] + bell[i][j - 1]\n return bell[n][0]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 608, "mbpp_split": "train", "prompt": "Write a python function to find nth bell number.", "test_list": ["assert bell_Number(2) == 2", "assert bell_Number(3) == 5", "assert bell_Number(4) == 15"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_608", "n_instr": 145} {"i": 7, "src_path": "src/00007.py", "pyc_path": "pyc/00007.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove_kth_element\n RETURN_CONST None\nEND\nCODE remove_kth_element(list1, L)\n RESUME 0\n LOAD_FAST list1\n LOAD_CONST None\n LOAD_FAST L\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SLICE\n LOAD_FAST list1\n LOAD_FAST L\n LOAD_CONST None\n BINARY_SLICE\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def remove_kth_element(list1, L):\n return list1[:L - 1] + list1[L:]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 610, "mbpp_split": "train", "prompt": "Write a python function to remove the k'th element from a given list.", "test_list": ["assert remove_kth_element([1,1,2,3,4,4,5,1],3)==[1, 1, 3, 4, 4, 5, 1]", "assert remove_kth_element([0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4],4)==[0, 0, 1, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4]", "assert remove_kth_element([10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10],5)==[10,10,15,19, 18, 17, 26, 26, 17, 18, 10]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_610", "n_instr": 21} {"i": 8, "src_path": "src/00008.py", "pyc_path": "pyc/00008.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME merge\n RETURN_CONST None\nEND\nCODE merge(lst)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + zip\n LOAD_FAST lst\n CALL_FUNCTION_EX 0\n CALL 1\n GET_ITER\n LOAD_FAST_AND_CLEAR ele\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST ele\n LOAD_GLOBAL NULL + list\n LOAD_FAST ele\n CALL 1\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n SWAP 2\n STORE_FAST ele\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST ele\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=2 lasti=False\nEND", "expected": "def merge(lst):\n return [list(ele) for ele in list(zip(*lst))]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 612, "mbpp_split": "train", "prompt": "Write a python function to merge the first and last elements separately in a list of lists.", "test_list": ["assert merge([['x', 'y'], ['a', 'b'], ['m', 'n']]) == [['x', 'a', 'm'], ['y', 'b', 'n']]", "assert merge([[1, 2], [3, 4], [5, 6], [7, 8]]) == [[1, 3, 5, 7], [2, 4, 6, 8]]", "assert merge([['x', 'y','z' ], ['a', 'b','c'], ['m', 'n','o']]) == [['x', 'a', 'm'], ['y', 'b', 'n'],['z', 'c','o']]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_612", "n_instr": 41} {"i": 9, "src_path": "src/00009.py", "pyc_path": "pyc/00009.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME maximum_value\n RETURN_CONST None\nEND\nCODE maximum_value(test_list)\n RESUME 0\n LOAD_FAST test_list\n GET_ITER\n LOAD_FAST_AND_CLEAR key\n LOAD_FAST_AND_CLEAR lst\n SWAP 3\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST key\n STORE_FAST lst\n LOAD_FAST key\n LOAD_GLOBAL NULL + max\n LOAD_FAST lst\n CALL 1\n BUILD_TUPLE 2\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST res\n STORE_FAST key\n STORE_FAST lst\n LOAD_FAST res\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 3\n STORE_FAST lst\n STORE_FAST key\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=3 lasti=False\nEND", "expected": "def maximum_value(test_list):\n res = [(key, max(lst)) for key, lst in test_list]\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 613, "mbpp_split": "train", "prompt": "Write a function to find the maximum value in record list as tuple attribute in the given tuple list.", "test_list": ["assert maximum_value([('key1', [3, 4, 5]), ('key2', [1, 4, 2]), ('key3', [9, 3])]) == [('key1', 5), ('key2', 4), ('key3', 9)]", "assert maximum_value([('key1', [4, 5, 6]), ('key2', [2, 5, 3]), ('key3', [10, 4])]) == [('key1', 6), ('key2', 5), ('key3', 10)]", "assert maximum_value([('key1', [5, 6, 7]), ('key2', [3, 6, 4]), ('key3', [11, 5])]) == [('key1', 7), ('key2', 6), ('key3', 11)]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_613", "n_instr": 45} {"i": 10, "src_path": "src/00010.py", "pyc_path": "pyc/00010.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME cummulative_sum\n RETURN_CONST None\nEND\nCODE cummulative_sum(test_list)\n RESUME 0\n LOAD_GLOBAL NULL + sum\n LOAD_GLOBAL NULL + map\n LOAD_GLOBAL sum\n LOAD_FAST test_list\n CALL 2\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def cummulative_sum(test_list):\n res = sum(map(sum, test_list))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 614, "mbpp_split": "train", "prompt": "Write a function to find the cumulative sum of all the values that are present in the given tuple list.", "test_list": ["assert cummulative_sum([(1, 3), (5, 6, 7), (2, 6)]) == 30", "assert cummulative_sum([(2, 4), (6, 7, 8), (3, 7)]) == 37", "assert cummulative_sum([(3, 5), (7, 8, 9), (4, 8)]) == 44"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_614", "n_instr": 18} {"i": 11, "src_path": "src/00011.py", "pyc_path": "pyc/00011.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME average_tuple\n RETURN_CONST None\nEND\nCODE average_tuple(nums)\n RESUME 0\n LOAD_GLOBAL NULL + zip\n LOAD_FAST nums\n CALL_FUNCTION_EX 0\n GET_ITER\n LOAD_FAST_AND_CLEAR x\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST x\n LOAD_GLOBAL NULL + sum\n LOAD_FAST x\n CALL 1\n LOAD_GLOBAL NULL + len\n LOAD_FAST x\n CALL 1\n BINARY_OP /\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST result\n STORE_FAST x\n LOAD_FAST result\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST x\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=2 lasti=False\nEND", "expected": "def average_tuple(nums):\n result = [sum(x) / len(x) for x in zip(*nums)]\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 615, "mbpp_split": "train", "prompt": "Write a function to find average value of the numbers in a given tuple of tuples.", "test_list": ["assert average_tuple(((10, 10, 10, 12), (30, 45, 56, 45), (81, 80, 39, 32), (1, 2, 3, 4)))==[30.5, 34.25, 27.0, 23.25]", "assert average_tuple(((1, 1, -5), (30, -15, 56), (81, -60, -39), (-10, 2, 3)))== [25.5, -18.0, 3.75]", "assert average_tuple( ((100, 100, 100, 120), (300, 450, 560, 450), (810, 800, 390, 320), (10, 20, 30, 40)))==[305.0, 342.5, 270.0, 232.5]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_615", "n_instr": 44} {"i": 12, "src_path": "src/00012.py", "pyc_path": "pyc/00012.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME tuple_modulo\n RETURN_CONST None\nEND\nCODE tuple_modulo(test_tup1, test_tup2)\n RESUME 0\n LOAD_GLOBAL NULL + tuple\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_GLOBAL NULL + zip\n LOAD_FAST test_tup1\n LOAD_FAST test_tup2\n CALL 2\n GET_ITER\n CALL 0\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND\nCODE tuple_modulo..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST ele1\n STORE_FAST ele2\n LOAD_FAST ele1\n LOAD_FAST ele2\n BINARY_OP %\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def tuple_modulo(test_tup1, test_tup2):\n res = tuple((ele1 % ele2 for ele1, ele2 in zip(test_tup1, test_tup2)))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 616, "mbpp_split": "train", "prompt": "Write a function to perfom the modulo of tuple elements in the given two tuples.", "test_list": ["assert tuple_modulo((10, 4, 5, 6), (5, 6, 7, 5)) == (0, 4, 5, 1)", "assert tuple_modulo((11, 5, 6, 7), (6, 7, 8, 6)) == (5, 5, 6, 1)", "assert tuple_modulo((12, 6, 7, 8), (7, 8, 9, 7)) == (5, 6, 7, 1)"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_616", "n_instr": 48} {"i": 13, "src_path": "src/00013.py", "pyc_path": "pyc/00013.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME div_list\n RETURN_CONST None\nEND\nCODE div_list(nums1, nums2)\n RESUME 0\n LOAD_GLOBAL NULL + map\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST nums1\n LOAD_FAST nums2\n CALL 3\n STORE_FAST result\n LOAD_GLOBAL NULL + list\n LOAD_FAST result\n CALL 1\n RETURN_VALUE\nEND\nCODE div_list..(x, y)\n RESUME 0\n LOAD_FAST x\n LOAD_FAST y\n BINARY_OP /\n RETURN_VALUE\nEND", "expected": "def div_list(nums1, nums2):\n result = map(lambda x, y: x / y, nums1, nums2)\n return list(result)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 618, "mbpp_split": "train", "prompt": "Write a function to divide two lists using map and lambda function.", "test_list": ["assert div_list([4,5,6],[1, 2, 3])==[4.0,2.5,2.0]", "assert div_list([3,2],[1,4])==[3.0, 0.5]", "assert div_list([90,120],[50,70])==[1.8, 1.7142857142857142]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_618", "n_instr": 27} {"i": 14, "src_path": "src/00014.py", "pyc_path": "pyc/00014.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME move_num\n RETURN_CONST None\nEND\nCODE move_num(test_str)\n RESUME 0\n LOAD_CONST ''\n STORE_FAST res\n LOAD_CONST ''\n STORE_FAST dig\n LOAD_FAST test_str\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST ele\n LOAD_FAST ele\n LOAD_ATTR NULL|self + isdigit\n CALL 0\n POP_JUMP_IF_FALSE L2\n LOAD_FAST dig\n LOAD_FAST ele\n BINARY_OP +=\n STORE_FAST dig\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST res\n LOAD_FAST ele\n BINARY_OP +=\n STORE_FAST res\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST res\n LOAD_FAST dig\n BINARY_OP +=\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def move_num(test_str):\n res = ''\n dig = ''\n for ele in test_str:\n if ele.isdigit():\n dig += ele\n else:\n res += ele\n res += dig\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 619, "mbpp_split": "train", "prompt": "Write a function to move all the numbers in it to the given string.", "test_list": ["assert move_num('I1love143you55three3000thousand') == 'Iloveyouthreethousand1143553000'", "assert move_num('Avengers124Assemble') == 'AvengersAssemble124'", "assert move_num('Its11our12path13to14see15things16do17things') == 'Itsourpathtoseethingsdothings11121314151617'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_619", "n_instr": 41} {"i": 15, "src_path": "src/00015.py", "pyc_path": "pyc/00015.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME increment_numerics\n RETURN_CONST None\nEND\nCODE increment_numerics(test_list, K)\n RESUME 0\n LOAD_FAST test_list\n GET_ITER\n LOAD_FAST_AND_CLEAR ele\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L5\n STORE_FAST ele\n LOAD_FAST ele\n LOAD_ATTR NULL|self + isdigit\n CALL 0\n POP_JUMP_IF_FALSE L3\n LOAD_GLOBAL NULL + str\n LOAD_GLOBAL NULL + int\n LOAD_FAST ele\n CALL 1\n LOAD_FAST K\n BINARY_OP +\n CALL 1\n JUMP_FORWARD L4\nL3:\n LOAD_FAST ele\nL4:\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL5:\n END_FOR\nL6:\n STORE_FAST res\n STORE_FAST ele\n LOAD_FAST res\n RETURN_VALUE\nL7:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST ele\n RERAISE 0\n EXC try=L1..L6 -> handler=L7 depth=2 lasti=False\nEND", "expected": "def increment_numerics(test_list, K):\n res = [str(int(ele) + K) if ele.isdigit() else ele for ele in test_list]\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 621, "mbpp_split": "train", "prompt": "Write a function to increment the numeric values in the given strings by k.", "test_list": ["assert increment_numerics([\"MSM\", \"234\", \"is\", \"98\", \"123\", \"best\", \"4\"] , 6) == ['MSM', '240', 'is', '104', '129', 'best', '10']", "assert increment_numerics([\"Dart\", \"356\", \"is\", \"88\", \"169\", \"Super\", \"6\"] , 12) == ['Dart', '368', 'is', '100', '181', 'Super', '18']", "assert increment_numerics([\"Flutter\", \"451\", \"is\", \"44\", \"96\", \"Magnificent\", \"12\"] , 33) == ['Flutter', '484', 'is', '77', '129', 'Magnificent', '45']"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_621", "n_instr": 50} {"i": 16, "src_path": "src/00016.py", "pyc_path": "pyc/00016.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_median\n RETURN_CONST None\nEND\nCODE get_median(arr1, arr2, n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST i\n LOAD_CONST 0\n STORE_FAST j\n LOAD_CONST -1\n STORE_FAST m1\n LOAD_CONST -1\n STORE_FAST m2\n LOAD_CONST 0\n STORE_FAST count\n LOAD_FAST count\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n COMPARE_OP <\n POP_JUMP_IF_FALSE L6\nL1:\n LOAD_FAST count\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST count\n LOAD_FAST i\n LOAD_FAST n\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_FAST m2\n STORE_FAST m1\n LOAD_FAST arr2\n LOAD_CONST 0\n BINARY_SUBSCR\n STORE_FAST m2\n JUMP_FORWARD L6\nL2:\n LOAD_FAST j\n LOAD_FAST n\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n LOAD_FAST m2\n STORE_FAST m1\n LOAD_FAST arr1\n LOAD_CONST 0\n BINARY_SUBSCR\n STORE_FAST m2\n JUMP_FORWARD L6\nL3:\n LOAD_FAST arr1\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr2\n LOAD_FAST j\n BINARY_SUBSCR\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L4\n LOAD_FAST m2\n STORE_FAST m1\n LOAD_FAST arr1\n LOAD_FAST i\n BINARY_SUBSCR\n STORE_FAST m2\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST i\n JUMP_FORWARD L5\nL4:\n LOAD_FAST m2\n STORE_FAST m1\n LOAD_FAST arr2\n LOAD_FAST j\n BINARY_SUBSCR\n STORE_FAST m2\n LOAD_FAST j\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST j\nL5:\n LOAD_FAST count\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n COMPARE_OP <\n POP_JUMP_IF_FALSE L6\n JUMP_BACKWARD L1\nL6:\n LOAD_FAST m1\n LOAD_FAST m2\n BINARY_OP +\n LOAD_CONST 2\n BINARY_OP /\n RETURN_VALUE\nEND", "expected": "def get_median(arr1, arr2, n):\n i = 0\n j = 0\n m1 = -1\n m2 = -1\n count = 0\n while count < n + 1:\n count += 1\n if i == n:\n m1 = m2\n m2 = arr2[0]\n break\n elif j == n:\n m1 = m2\n m2 = arr1[0]\n break\n if arr1[i] <= arr2[j]:\n m1 = m2\n m2 = arr1[i]\n i += 1\n else:\n m1 = m2\n m2 = arr2[j]\n j += 1\n return (m1 + m2) / 2", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 622, "mbpp_split": "train", "prompt": "Write a function to find the median of two sorted arrays of same size.", "test_list": ["assert get_median([1, 12, 15, 26, 38], [2, 13, 17, 30, 45], 5) == 16.0", "assert get_median([2, 4, 8, 9], [7, 13, 19, 28], 4) == 8.5", "assert get_median([3, 6, 14, 23, 36, 42], [2, 18, 27, 39, 49, 55], 6) == 25.0"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_622", "n_instr": 99} {"i": 17, "src_path": "src/00017.py", "pyc_path": "pyc/00017.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME nth_nums\n RETURN_CONST None\nEND\nCODE nth_nums(nums, n)\n MAKE_CELL n\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + map\n LOAD_CLOSURE n\n BUILD_TUPLE 1\n LOAD_CONST .>\n MAKE_FUNCTION closure\n LOAD_FAST nums\n CALL 2\n CALL 1\n STORE_FAST nth_nums\n LOAD_FAST nth_nums\n RETURN_VALUE\nEND\nCODE nth_nums..(x)\n COPY_FREE_VARS 1\n RESUME 0\n LOAD_FAST x\n LOAD_DEREF n\n BINARY_OP **\n RETURN_VALUE\nEND", "expected": "def nth_nums(nums, n):\n nth_nums = list(map(lambda x: x ** n, nums))\n return nth_nums", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 623, "mbpp_split": "train", "prompt": "Write a function to find the n-th power of individual elements in a list using lambda function.", "test_list": ["assert nth_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],2)==[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]", "assert nth_nums([10,20,30],3)==([1000, 8000, 27000])", "assert nth_nums([12,15],5)==([248832, 759375])"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_623", "n_instr": 30} {"i": 18, "src_path": "src/00018.py", "pyc_path": "pyc/00018.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME swap_List\n RETURN_CONST None\nEND\nCODE swap_List(newList)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST newList\n CALL 1\n STORE_FAST size\n LOAD_FAST newList\n LOAD_CONST 0\n BINARY_SUBSCR\n STORE_FAST temp\n LOAD_FAST newList\n LOAD_FAST size\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n LOAD_FAST newList\n LOAD_CONST 0\n STORE_SUBSCR\n LOAD_FAST temp\n LOAD_FAST newList\n LOAD_FAST size\n LOAD_CONST 1\n BINARY_OP -\n STORE_SUBSCR\n LOAD_FAST newList\n RETURN_VALUE\nEND", "expected": "def swap_List(newList):\n size = len(newList)\n temp = newList[0]\n newList[0] = newList[size - 1]\n newList[size - 1] = temp\n return newList", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 625, "mbpp_split": "train", "prompt": "Write a python function to interchange first and last elements in a given list.", "test_list": ["assert swap_List([1,2,3]) == [3,2,1]", "assert swap_List([1,2,3,4,4]) == [4,2,3,4,1]", "assert swap_List([4,5,6]) == [6,5,4]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_625", "n_instr": 33} {"i": 19, "src_path": "src/00019.py", "pyc_path": "pyc/00019.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME triangle_area\n RETURN_CONST None\nEND\nCODE triangle_area(r)\n RESUME 0\n LOAD_FAST r\n LOAD_CONST 0\n COMPARE_OP <\n POP_JUMP_IF_FALSE L1\n RETURN_CONST -1\nL1:\n LOAD_FAST r\n LOAD_FAST r\n BINARY_OP *\n RETURN_VALUE\nEND", "expected": "def triangle_area(r):\n if r < 0:\n return -1\n return r * r", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 626, "mbpp_split": "train", "prompt": "Write a python function to find the largest triangle that can be inscribed in the semicircle.", "test_list": ["assert triangle_area(0) == 0", "assert triangle_area(-1) == -1", "assert triangle_area(2) == 4"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_626", "n_instr": 19} {"i": 20, "src_path": "src/00020.py", "pyc_path": "pyc/00020.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 1000\n STORE_NAME MAX\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME replace_spaces\n RETURN_CONST None\nEND\nCODE replace_spaces(string)\n RESUME 0\n LOAD_FAST string\n LOAD_ATTR NULL|self + strip\n CALL 0\n STORE_FAST string\n LOAD_GLOBAL NULL + len\n LOAD_FAST string\n CALL 1\n STORE_FAST i\n LOAD_FAST string\n LOAD_ATTR NULL|self + count\n LOAD_CONST ' '\n CALL 1\n STORE_FAST space_count\n LOAD_FAST i\n LOAD_FAST space_count\n LOAD_CONST 2\n BINARY_OP *\n BINARY_OP +\n STORE_FAST new_length\n LOAD_FAST new_length\n LOAD_GLOBAL MAX\n COMPARE_OP >\n POP_JUMP_IF_FALSE L1\n RETURN_CONST -1\nL1:\n LOAD_FAST new_length\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST index\n LOAD_GLOBAL NULL + list\n LOAD_FAST string\n CALL 1\n STORE_FAST string\n LOAD_GLOBAL NULL + range\n LOAD_FAST i\n LOAD_CONST 2\n BINARY_OP -\n LOAD_FAST new_length\n LOAD_CONST 2\n BINARY_OP -\n CALL 2\n GET_ITER\nL2:\n FOR_ITER L3\n STORE_FAST f\n LOAD_FAST string\n LOAD_ATTR NULL|self + append\n LOAD_CONST '0'\n CALL 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n LOAD_GLOBAL NULL + range\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP -\n LOAD_CONST 0\n LOAD_CONST -1\n CALL 3\n GET_ITER\nL4:\n FOR_ITER L6\n STORE_FAST j\n LOAD_FAST string\n LOAD_FAST j\n BINARY_SUBSCR\n LOAD_CONST ' '\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L5\n LOAD_CONST '0'\n LOAD_FAST string\n LOAD_FAST index\n STORE_SUBSCR\n LOAD_CONST '2'\n LOAD_FAST string\n LOAD_FAST index\n LOAD_CONST 1\n BINARY_OP -\n STORE_SUBSCR\n LOAD_CONST '%'\n LOAD_FAST string\n LOAD_FAST index\n LOAD_CONST 2\n BINARY_OP -\n STORE_SUBSCR\n LOAD_FAST index\n LOAD_CONST 3\n BINARY_OP -\n STORE_FAST index\n JUMP_BACKWARD L4\nL5:\n LOAD_FAST string\n LOAD_FAST j\n BINARY_SUBSCR\n LOAD_FAST string\n LOAD_FAST index\n STORE_SUBSCR\n LOAD_FAST index\n LOAD_CONST 1\n BINARY_OP -=\n STORE_FAST index\n JUMP_BACKWARD L4\nL6:\n END_FOR\n LOAD_CONST ''\n LOAD_ATTR NULL|self + join\n LOAD_FAST string\n CALL 1\n RETURN_VALUE\nEND", "expected": "MAX = 1000\n\ndef replace_spaces(string):\n string = string.strip()\n i = len(string)\n space_count = string.count(' ')\n new_length = i + space_count * 2\n if new_length > MAX:\n return -1\n index = new_length - 1\n string = list(string)\n for f in range(i - 2, new_length - 2):\n string.append('0')\n for j in range(i - 1, 0, -1):\n if string[j] == ' ':\n string[index] = '0'\n string[index - 1] = '2'\n string[index - 2] = '%'\n index = index - 3\n else:\n string[index] = string[j]\n index -= 1\n return ''.join(string)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 628, "mbpp_split": "train", "prompt": "Write a function to replace all spaces in the given string with character * list item * list item * list item * list item '%20'.", "test_list": ["assert replace_spaces(\"My Name is Dawood\") == 'My%20Name%20is%20Dawood'", "assert replace_spaces(\"I am a Programmer\") == 'I%20am%20a%20Programmer'", "assert replace_spaces(\"I love Coding\") == 'I%20love%20Coding'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_628", "n_instr": 121} {"i": 21, "src_path": "src/00021.py", "pyc_path": "pyc/00021.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME Split\n RETURN_CONST None\nEND\nCODE Split(list)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST ev_li\n LOAD_FAST list\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST i\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST ev_li\n LOAD_ATTR NULL|self + append\n LOAD_FAST i\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST ev_li\n RETURN_VALUE\nEND", "expected": "def Split(list):\n ev_li = []\n for i in list:\n if i % 2 == 0:\n ev_li.append(i)\n return ev_li", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 629, "mbpp_split": "train", "prompt": "Write a python function to find even numbers from a mixed list.", "test_list": ["assert Split([1,2,3,4,5]) == [2,4]", "assert Split([4,5,6,7,8,0,1]) == [4,6,8,0]", "assert Split ([8,12,15,19]) == [8,12]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_629", "n_instr": 34} {"i": 22, "src_path": "src/00022.py", "pyc_path": "pyc/00022.pyc", "input": "CODE ()\n RESUME 0\n BUILD_LIST 0\n BUILD_TUPLE 1\n LOAD_CONST \n MAKE_FUNCTION defaults\n STORE_NAME adjac\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_coordinates\n RETURN_CONST None\nEND\nCODE adjac(ele, sub)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST ele\n POP_JUMP_IF_TRUE L2\n LOAD_FAST sub\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n RETURN_CONST None\nL2:\n LOAD_GLOBAL NULL + range\n LOAD_FAST ele\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP -\n LOAD_FAST ele\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_CONST 2\n BINARY_OP +\n CALL 2\n GET_ITER\n LOAD_FAST_AND_CLEAR j\n LOAD_FAST_AND_CLEAR idx\n SWAP 3\nL3:\n BUILD_LIST 0\n SWAP 2\nL4:\n FOR_ITER L7\n STORE_FAST j\n LOAD_GLOBAL NULL + adjac\n LOAD_FAST ele\n LOAD_CONST 1\n LOAD_CONST None\n BINARY_SLICE\n LOAD_FAST sub\n LOAD_FAST j\n BUILD_LIST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL5:\n FOR_ITER L6\n STORE_FAST idx\n LOAD_FAST idx\n LIST_APPEND 3\n JUMP_BACKWARD L5\nL6:\n END_FOR\n JUMP_BACKWARD L4\nL7:\n END_FOR\nL8:\n SWAP 3\n STORE_FAST idx\n STORE_FAST j\n GET_YIELD_FROM_ITER\n LOAD_CONST None\nL9:\n SEND L12\nL10:\n YIELD_VALUE 2\nL11:\n RESUME 2\n JUMP_BACKWARD_NO_INTERRUPT L9\nL12:\n END_SEND\n POP_TOP\n RETURN_CONST None\nL13:\n SWAP 2\n POP_TOP\n SWAP 3\n STORE_FAST idx\n STORE_FAST j\n RERAISE 0\nL14:\n CLEANUP_THROW\nL15:\n JUMP_BACKWARD L12\nL16:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L3 -> handler=L16 depth=0 lasti=True\n EXC try=L3..L8 -> handler=L13 depth=3 lasti=False\n EXC try=L8..L10 -> handler=L16 depth=0 lasti=True\n EXC try=L10..L11 -> handler=L14 depth=2 lasti=False\n EXC try=L11..L15 -> handler=L16 depth=0 lasti=True\nEND\nCODE get_coordinates(test_tup)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + adjac\n LOAD_FAST test_tup\n CALL 1\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def adjac(ele, sub=[]):\n if not ele:\n yield sub\n else:\n yield from [idx for j in range(ele[0] - 1, ele[0] + 2) for idx in adjac(ele[1:], sub + [j])]\n\ndef get_coordinates(test_tup):\n res = list(adjac(test_tup))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 630, "mbpp_split": "train", "prompt": "Write a function to extract all the adjacent coordinates of the given coordinate tuple.", "test_list": ["assert get_coordinates((3, 4)) == [[2, 3], [2, 4], [2, 5], [3, 3], [3, 4], [3, 5], [4, 3], [4, 4], [4, 5]]", "assert get_coordinates((4, 5)) ==[[3, 4], [3, 5], [3, 6], [4, 4], [4, 5], [4, 6], [5, 4], [5, 5], [5, 6]]", "assert get_coordinates((5, 6)) == [[4, 5], [4, 6], [4, 7], [5, 5], [5, 6], [5, 7], [6, 5], [6, 6], [6, 7]]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_630", "n_instr": 116} {"i": 23, "src_path": "src/00023.py", "pyc_path": "pyc/00023.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST 'Python Exercises'\n STORE_NAME text\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME replace_spaces\n RETURN_CONST None\nEND\nCODE replace_spaces(text)\n RESUME 0\n LOAD_FAST text\n LOAD_ATTR NULL|self + replace\n LOAD_CONST ' '\n LOAD_CONST '_'\n CALL 2\n STORE_FAST text\n LOAD_FAST text\n RETURN_VALUE\nEND", "expected": "import re\ntext = 'Python Exercises'\n\ndef replace_spaces(text):\n text = text.replace(' ', '_')\n return text\n text = text.replace('_', ' ')\n return text", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 631, "mbpp_split": "train", "prompt": "Write a function to replace whitespaces with an underscore and vice versa in a given string by using regex.", "test_list": ["assert replace_spaces('Jumanji The Jungle') == 'Jumanji_The_Jungle'", "assert replace_spaces('The Avengers') == 'The_Avengers'", "assert replace_spaces('Fast and Furious') == 'Fast_and_Furious'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_631", "n_instr": 23} {"i": 24, "src_path": "src/00024.py", "pyc_path": "pyc/00024.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME move_zero\n RETURN_CONST None\nEND\nCODE move_zero(num_list)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_FAST num_list\n LOAD_ATTR NULL|self + count\n LOAD_CONST 0\n CALL 1\n CALL 1\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_CONST 0\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST a\n STORE_FAST i\n LOAD_FAST num_list\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL5:\n BUILD_LIST 0\n SWAP 2\nL6:\n FOR_ITER L9\n STORE_FAST i\n LOAD_FAST i\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L8\nL7:\n JUMP_BACKWARD L6\nL8:\n LOAD_FAST i\n LIST_APPEND 2\n JUMP_BACKWARD L6\nL9:\n END_FOR\nL10:\n STORE_FAST x\n STORE_FAST i\n LOAD_FAST x\n LOAD_ATTR NULL|self + extend\n LOAD_FAST a\n CALL 1\n POP_TOP\n LOAD_FAST x\n RETURN_VALUE\nL11:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\nL12:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\n EXC try=L1..L4 -> handler=L11 depth=2 lasti=False\n EXC try=L5..L7 -> handler=L12 depth=2 lasti=False\n EXC try=L8..L10 -> handler=L12 depth=2 lasti=False\nEND", "expected": "def move_zero(num_list):\n a = [0 for i in range(num_list.count(0))]\n x = [i for i in num_list if i != 0]\n x.extend(a)\n return x", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 632, "mbpp_split": "train", "prompt": "Write a python function to move all zeroes to the end of the given list.", "test_list": ["assert move_zero([1,0,2,0,3,4]) == [1,2,3,4,0,0]", "assert move_zero([2,3,2,0,0,4,0,5,0]) == [2,3,2,4,5,0,0,0,0]", "assert move_zero([0,1,0,1,1]) == [1,1,1,0,0]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_632", "n_instr": 79} {"i": 25, "src_path": "src/00025.py", "pyc_path": "pyc/00025.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME pair_OR_Sum\n RETURN_CONST None\nEND\nCODE pair_OR_Sum(arr, n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST ans\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_FAST n\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L4\n STORE_FAST i\n LOAD_GLOBAL NULL + range\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST n\n CALL 2\n GET_ITER\nL2:\n FOR_ITER L3\n STORE_FAST j\n LOAD_FAST ans\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST j\n BINARY_SUBSCR\n BINARY_OP ^\n BINARY_OP +\n STORE_FAST ans\n JUMP_BACKWARD L2\nL3:\n END_FOR\n JUMP_BACKWARD L1\nL4:\n END_FOR\n LOAD_FAST ans\n RETURN_VALUE\nEND", "expected": "def pair_OR_Sum(arr, n):\n ans = 0\n for i in range(0, n):\n for j in range(i + 1, n):\n ans = ans + (arr[i] ^ arr[j])\n return ans", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 633, "mbpp_split": "train", "prompt": "Write a python function to find the sum of xor of all pairs of numbers in the given array.", "test_list": ["assert pair_OR_Sum([5,9,7,6],4) == 47", "assert pair_OR_Sum([7,3,5],3) == 12", "assert pair_OR_Sum([7,3],2) == 4"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_633", "n_instr": 47} {"i": 26, "src_path": "src/00026.py", "pyc_path": "pyc/00026.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME even_Power_Sum\n RETURN_CONST None\nEND\nCODE even_Power_Sum(n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST sum\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_CONST 2\n LOAD_FAST i\n BINARY_OP *\n STORE_FAST j\n LOAD_FAST sum\n LOAD_FAST j\n LOAD_FAST j\n BINARY_OP *\n LOAD_FAST j\n BINARY_OP *\n LOAD_FAST j\n BINARY_OP *\n BINARY_OP +\n STORE_FAST sum\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST sum\n RETURN_VALUE\nEND", "expected": "def even_Power_Sum(n):\n sum = 0\n for i in range(1, n + 1):\n j = 2 * i\n sum = sum + j * j * j * j\n return sum", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 634, "mbpp_split": "train", "prompt": "Write a python function to find the sum of fourth power of first n even natural numbers.", "test_list": ["assert even_Power_Sum(2) == 272", "assert even_Power_Sum(3) == 1568", "assert even_Power_Sum(4) == 5664"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_634", "n_instr": 40} {"i": 27, "src_path": "src/00027.py", "pyc_path": "pyc/00027.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME heapq\n STORE_NAME hq\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME heap_sort\n RETURN_CONST None\nEND\nCODE heap_sort(iterable)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST h\n LOAD_FAST iterable\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST value\n LOAD_GLOBAL NULL + hq\n LOAD_ATTR heappush\n LOAD_FAST h\n LOAD_FAST value\n CALL 2\n POP_TOP\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST h\n CALL 1\n CALL 1\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL3:\n BUILD_LIST 0\n SWAP 2\nL4:\n FOR_ITER L5\n STORE_FAST i\n LOAD_GLOBAL NULL + hq\n LOAD_ATTR heappop\n LOAD_FAST h\n CALL 1\n LIST_APPEND 2\n JUMP_BACKWARD L4\nL5:\n END_FOR\nL6:\n SWAP 2\n STORE_FAST i\n RETURN_VALUE\nL7:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\n EXC try=L3..L6 -> handler=L7 depth=2 lasti=False\nEND", "expected": "import heapq as hq\n\ndef heap_sort(iterable):\n h = []\n for value in iterable:\n hq.heappush(h, value)\n return [hq.heappop(h) for i in range(len(h))]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 635, "mbpp_split": "train", "prompt": "Write a function to push all values into a heap and then pop off the smallest values one at a time.", "test_list": ["assert heap_sort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])==[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]", "assert heap_sort([25, 35, 22, 85, 14, 65, 75, 25, 58])==[14, 22, 25, 25, 35, 58, 65, 75, 85]", "assert heap_sort( [7, 1, 9, 5])==[1,5,7,9]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_635", "n_instr": 62} {"i": 28, "src_path": "src/00028.py", "pyc_path": "pyc/00028.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME Check_Solution\n RETURN_CONST None\nEND\nCODE Check_Solution(a, b, c)\n RESUME 0\n LOAD_FAST a\n LOAD_FAST c\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Yes'\nL1:\n RETURN_CONST 'No'\nEND", "expected": "def Check_Solution(a, b, c):\n if a == c:\n return 'Yes'\n else:\n return 'No'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 636, "mbpp_split": "train", "prompt": "Write a python function to check if roots of a quadratic equation are reciprocal of each other or not.", "test_list": ["assert Check_Solution(2,0,2) == \"Yes\"", "assert Check_Solution(2,-5,2) == \"Yes\"", "assert Check_Solution(1,2,3) == \"No\""], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_636", "n_instr": 16} {"i": 29, "src_path": "src/00029.py", "pyc_path": "pyc/00029.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME noprofit_noloss\n RETURN_CONST None\nEND\nCODE noprofit_noloss(actual_cost, sale_amount)\n RESUME 0\n LOAD_FAST sale_amount\n LOAD_FAST actual_cost\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST True\nL1:\n RETURN_CONST False\nEND", "expected": "def noprofit_noloss(actual_cost, sale_amount):\n if sale_amount == actual_cost:\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 637, "mbpp_split": "train", "prompt": "Write a function to check whether the given amount has no profit and no loss", "test_list": ["assert noprofit_noloss(1500,1200)==False", "assert noprofit_noloss(100,100)==True", "assert noprofit_noloss(2000,5000)==False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_637", "n_instr": 16} {"i": 30, "src_path": "src/00030.py", "pyc_path": "pyc/00030.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sample_nam\n RETURN_CONST None\nEND\nCODE sample_nam(sample_names)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + filter\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST sample_names\n CALL 2\n CALL 1\n STORE_FAST sample_names\n LOAD_GLOBAL NULL + len\n LOAD_CONST ''\n LOAD_ATTR NULL|self + join\n LOAD_FAST sample_names\n CALL 1\n CALL 1\n RETURN_VALUE\nEND\nCODE sample_nam..(el)\n RESUME 0\n LOAD_FAST el\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_ATTR NULL|self + isupper\n CALL 0\n COPY 1\n POP_JUMP_IF_FALSE L1\n POP_TOP\n LOAD_FAST el\n LOAD_CONST 1\n LOAD_CONST None\n BINARY_SLICE\n LOAD_ATTR NULL|self + islower\n CALL 0\nL1:\n RETURN_VALUE\nEND", "expected": "def sample_nam(sample_names):\n sample_names = list(filter(lambda el: el[0].isupper() and el[1:].islower(), sample_names))\n return len(''.join(sample_names))", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 639, "mbpp_split": "train", "prompt": "Write a function to sum the length of the names of a given list of names after removing the names that start with a lowercase letter.", "test_list": ["assert sample_nam(['sally', 'Dylan', 'rebecca', 'Diana', 'Joanne', 'keith'])==16", "assert sample_nam([\"php\", \"res\", \"Python\", \"abcd\", \"Java\", \"aaa\"])==10", "assert sample_nam([\"abcd\", \"Python\", \"abba\", \"aba\"])==6"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_639", "n_instr": 43} {"i": 31, "src_path": "src/00031.py", "pyc_path": "pyc/00031.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove_parenthesis\n RETURN_CONST None\nEND\nCODE remove_parenthesis(items)\n RESUME 0\n LOAD_FAST items\n GET_ITER\n FOR_ITER L1\n STORE_FAST item\n LOAD_GLOBAL NULL + re\n LOAD_ATTR sub\n LOAD_CONST ' ?\\\\([^)]+\\\\)'\n LOAD_CONST ''\n LOAD_FAST item\n CALL 3\n SWAP 2\n POP_TOP\n RETURN_VALUE\nL1:\n END_FOR\n RETURN_CONST None\nEND", "expected": "import re\n\ndef remove_parenthesis(items):\n for item in items:\n return re.sub(' ?\\\\([^)]+\\\\)', '', item)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 640, "mbpp_split": "train", "prompt": "Write a function to remove the parenthesis area in a string.", "test_list": ["assert remove_parenthesis([\"python (chrome)\"])==(\"python\")", "assert remove_parenthesis([\"string(.abc)\"])==(\"string\")", "assert remove_parenthesis([\"alpha(num)\"])==(\"alpha\")"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_640", "n_instr": 29} {"i": 32, "src_path": "src/00032.py", "pyc_path": "pyc/00032.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_nonagonal\n RETURN_CONST None\nEND\nCODE is_nonagonal(n)\n RESUME 0\n LOAD_GLOBAL NULL + int\n LOAD_FAST n\n LOAD_CONST 7\n LOAD_FAST n\n BINARY_OP *\n LOAD_CONST 5\n BINARY_OP -\n BINARY_OP *\n LOAD_CONST 2\n BINARY_OP /\n CALL 1\n RETURN_VALUE\nEND", "expected": "def is_nonagonal(n):\n return int(n * (7 * n - 5) / 2)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 641, "mbpp_split": "train", "prompt": "Write a function to find the nth nonagonal number.", "test_list": ["assert is_nonagonal(10) == 325", "assert is_nonagonal(15) == 750", "assert is_nonagonal(18) == 1089"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_641", "n_instr": 21} {"i": 33, "src_path": "src/00033.py", "pyc_path": "pyc/00033.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove_similar_row\n RETURN_CONST None\nEND\nCODE remove_similar_row(test_list)\n RESUME 0\n LOAD_GLOBAL NULL + set\n LOAD_GLOBAL NULL + sorted\n LOAD_FAST test_list\n GET_ITER\n LOAD_FAST_AND_CLEAR sub\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST sub\n LOAD_GLOBAL NULL + tuple\n LOAD_GLOBAL NULL + sorted\n LOAD_GLOBAL NULL + set\n LOAD_FAST sub\n CALL 1\n CALL 1\n CALL 1\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n SWAP 2\n STORE_FAST sub\n CALL 1\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST sub\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=6 lasti=False\nEND", "expected": "def remove_similar_row(test_list):\n res = set(sorted([tuple(sorted(set(sub))) for sub in test_list]))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 642, "mbpp_split": "train", "prompt": "Write a function to remove similar rows from the given tuple matrix.", "test_list": ["assert remove_similar_row([[(4, 5), (3, 2)], [(2, 2), (4, 6)], [(3, 2), (4, 5)]] ) == {((2, 2), (4, 6)), ((3, 2), (4, 5))}", "assert remove_similar_row([[(5, 6), (4, 3)], [(3, 3), (5, 7)], [(4, 3), (5, 6)]] ) == {((4, 3), (5, 6)), ((3, 3), (5, 7))}", "assert remove_similar_row([[(6, 7), (5, 4)], [(4, 4), (6, 8)], [(5, 4), (6, 7)]] ) =={((4, 4), (6, 8)), ((5, 4), (6, 7))}"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_642", "n_instr": 47} {"i": 34, "src_path": "src/00034.py", "pyc_path": "pyc/00034.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME text_match_wordz_middle\n RETURN_CONST None\nEND\nCODE text_match_wordz_middle(text)\n RESUME 0\n LOAD_CONST '\\\\Bz\\\\B'\n STORE_FAST patterns\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_FAST patterns\n LOAD_FAST text\n CALL 2\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Found a match!'\nL1:\n RETURN_CONST 'Not matched!'\nEND", "expected": "import re\n\ndef text_match_wordz_middle(text):\n patterns = '\\\\Bz\\\\B'\n if re.search(patterns, text):\n return 'Found a match!'\n else:\n return 'Not matched!'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 643, "mbpp_split": "train", "prompt": "Write a function that matches a word containing 'z', not at the start or end of the word.", "test_list": ["assert text_match_wordz_middle(\"pythonzabc.\")==('Found a match!')", "assert text_match_wordz_middle(\"xyzabc.\")==('Found a match!')", "assert text_match_wordz_middle(\" lang .\")==('Not matched!')"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_643", "n_instr": 24} {"i": 35, "src_path": "src/00035.py", "pyc_path": "pyc/00035.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME reverse_Array_Upto_K\n RETURN_CONST None\nEND\nCODE reverse_Array_Upto_K(input, k)\n RESUME 0\n LOAD_FAST input\n LOAD_FAST k\n LOAD_CONST 1\n BINARY_OP -\n LOAD_CONST None\n LOAD_CONST -1\n BUILD_SLICE 3\n BINARY_SUBSCR\n LOAD_FAST input\n LOAD_FAST k\n LOAD_CONST None\n BINARY_SLICE\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def reverse_Array_Upto_K(input, k):\n return input[k - 1::-1] + input[k:]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 644, "mbpp_split": "train", "prompt": "Write a python function to reverse an array upto a given position.", "test_list": ["assert reverse_Array_Upto_K([1, 2, 3, 4, 5, 6],4) == [4, 3, 2, 1, 5, 6]", "assert reverse_Array_Upto_K([4, 5, 6, 7], 2) == [5, 4, 6, 7]", "assert reverse_Array_Upto_K([9, 8, 7, 6, 5],3) == [7, 8, 9, 6, 5]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_644", "n_instr": 23} {"i": 36, "src_path": "src/00036.py", "pyc_path": "pyc/00036.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_product\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_k_product\n RETURN_CONST None\nEND\nCODE get_product(val)\n RESUME 0\n LOAD_CONST 1\n STORE_FAST res\n LOAD_FAST val\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST ele\n LOAD_FAST res\n LOAD_FAST ele\n BINARY_OP *=\n STORE_FAST res\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST res\n RETURN_VALUE\nEND\nCODE find_k_product(test_list, K)\n RESUME 0\n LOAD_GLOBAL NULL + get_product\n LOAD_FAST test_list\n GET_ITER\n LOAD_FAST_AND_CLEAR sub\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST sub\n LOAD_FAST sub\n LOAD_FAST K\n BINARY_SUBSCR\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n SWAP 2\n STORE_FAST sub\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST sub\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=4 lasti=False\nEND", "expected": "def get_product(val):\n res = 1\n for ele in val:\n res *= ele\n return res\n\ndef find_k_product(test_list, K):\n res = get_product([sub[K] for sub in test_list])\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 645, "mbpp_split": "train", "prompt": "Write a function to find the product of it\u2019s kth index in the given tuples.", "test_list": ["assert find_k_product([(5, 6, 7), (1, 3, 5), (8, 9, 19)], 2) == 665", "assert find_k_product([(6, 7, 8), (2, 4, 6), (9, 10, 20)], 1) == 280", "assert find_k_product([(7, 8, 9), (3, 5, 7), (10, 11, 21)], 0) == 210"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_645", "n_instr": 63} {"i": 37, "src_path": "src/00037.py", "pyc_path": "pyc/00037.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME No_of_cubes\n RETURN_CONST None\nEND\nCODE No_of_cubes(N, K)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST No\n LOAD_FAST N\n LOAD_FAST K\n BINARY_OP -\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST No\n LOAD_GLOBAL NULL + pow\n LOAD_FAST No\n LOAD_CONST 3\n CALL 2\n STORE_FAST No\n LOAD_FAST No\n RETURN_VALUE\nEND", "expected": "def No_of_cubes(N, K):\n No = 0\n No = N - K + 1\n No = pow(No, 3)\n return No", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 646, "mbpp_split": "train", "prompt": "Write a python function to count number of cubes of size k in a cube of size n.", "test_list": ["assert No_of_cubes(2,1) == 8", "assert No_of_cubes(5,2) == 64", "assert No_of_cubes(1,1) == 1"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_646", "n_instr": 24} {"i": 38, "src_path": "src/00038.py", "pyc_path": "pyc/00038.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('zip_longest', 'chain', 'tee')\n IMPORT_NAME itertools\n IMPORT_FROM zip_longest\n STORE_NAME zip_longest\n IMPORT_FROM chain\n STORE_NAME chain\n IMPORT_FROM tee\n STORE_NAME tee\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME exchange_elements\n RETURN_CONST None\nEND\nCODE exchange_elements(lst)\n RESUME 0\n LOAD_GLOBAL NULL + tee\n LOAD_GLOBAL NULL + iter\n LOAD_FAST lst\n CALL 1\n LOAD_CONST 2\n CALL 2\n UNPACK_SEQUENCE 2\n STORE_FAST lst1\n STORE_FAST lst2\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + chain\n LOAD_ATTR from_iterable\n LOAD_GLOBAL NULL + zip_longest\n LOAD_FAST lst\n LOAD_CONST 1\n LOAD_CONST None\n LOAD_CONST 2\n BUILD_SLICE 3\n BINARY_SUBSCR\n LOAD_FAST lst\n LOAD_CONST None\n LOAD_CONST None\n LOAD_CONST 2\n BUILD_SLICE 3\n BINARY_SUBSCR\n CALL 2\n CALL 1\n CALL 1\n RETURN_VALUE\nEND", "expected": "from itertools import zip_longest, chain, tee\n\ndef exchange_elements(lst):\n lst1, lst2 = tee(iter(lst), 2)\n return list(chain.from_iterable(zip_longest(lst[1::2], lst[::2])))", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 648, "mbpp_split": "train", "prompt": "Write a function to exchange the position of every n-th value with (n+1)th value and (n+1)th value with n-th value in a given list.", "test_list": ["assert exchange_elements([0,1,2,3,4,5])==[1, 0, 3, 2, 5, 4] ", "assert exchange_elements([5,6,7,8,9,10])==[6,5,8,7,10,9] ", "assert exchange_elements([25,35,45,55,75,95])==[35,25,55,45,95,75] "], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_648", "n_instr": 48} {"i": 39, "src_path": "src/00039.py", "pyc_path": "pyc/00039.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME are_Equal\n RETURN_CONST None\nEND\nCODE are_Equal(arr1, arr2, n, m)\n RESUME 0\n LOAD_FAST n\n LOAD_FAST m\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L1\n RETURN_CONST False\nL1:\n LOAD_FAST arr1\n LOAD_ATTR NULL|self + sort\n CALL 0\n POP_TOP\n LOAD_FAST arr2\n LOAD_ATTR NULL|self + sort\n CALL 0\n POP_TOP\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n CALL 2\n GET_ITER\nL2:\n FOR_ITER L4\n STORE_FAST i\n LOAD_FAST arr1\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr2\n LOAD_FAST i\n BINARY_SUBSCR\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L2\nL3:\n POP_TOP\n RETURN_CONST False\nL4:\n END_FOR\n RETURN_CONST True\nEND", "expected": "def are_Equal(arr1, arr2, n, m):\n if n != m:\n return False\n arr1.sort()\n arr2.sort()\n for i in range(0, n - 1):\n if arr1[i] != arr2[i]:\n return False\n return True", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 650, "mbpp_split": "train", "prompt": "Write a python function to check whether the given two arrays are equal or not.", "test_list": ["assert are_Equal([1,2,3],[3,2,1],3,3) == True", "assert are_Equal([1,1,1],[2,2,2],3,3) == False", "assert are_Equal([8,9],[4,5,6],2,3) == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_650", "n_instr": 48} {"i": 40, "src_path": "src/00040.py", "pyc_path": "pyc/00040.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_subset\n RETURN_CONST None\nEND\nCODE check_subset(test_tup1, test_tup2)\n RESUME 0\n LOAD_GLOBAL NULL + set\n LOAD_FAST test_tup2\n CALL 1\n LOAD_ATTR NULL|self + issubset\n LOAD_FAST test_tup1\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def check_subset(test_tup1, test_tup2):\n res = set(test_tup2).issubset(test_tup1)\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 651, "mbpp_split": "train", "prompt": "Write a function to check if one tuple is a subset of another tuple.", "test_list": ["assert check_subset((10, 4, 5, 6), (5, 10)) == True", "assert check_subset((1, 2, 3, 4), (5, 6)) == False", "assert check_subset((7, 8, 9, 10), (10, 8)) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_651", "n_instr": 18} {"i": 41, "src_path": "src/00041.py", "pyc_path": "pyc/00041.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME matrix_to_list\n RETURN_CONST None\nEND\nCODE matrix_to_list(test_list)\n RESUME 0\n LOAD_FAST test_list\n GET_ITER\n LOAD_FAST_AND_CLEAR sub\n LOAD_FAST_AND_CLEAR ele\n SWAP 3\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L5\n STORE_FAST sub\n LOAD_FAST sub\n GET_ITER\nL3:\n FOR_ITER L4\n STORE_FAST ele\n LOAD_FAST ele\n LIST_APPEND 3\n JUMP_BACKWARD L3\nL4:\n END_FOR\n JUMP_BACKWARD L2\nL5:\n END_FOR\nL6:\n STORE_FAST temp\n STORE_FAST sub\n STORE_FAST ele\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + zip\n LOAD_FAST temp\n CALL_FUNCTION_EX 0\n CALL 1\n STORE_FAST res\n LOAD_GLOBAL NULL + str\n LOAD_FAST res\n CALL 1\n RETURN_VALUE\nL7:\n SWAP 2\n POP_TOP\n SWAP 3\n STORE_FAST ele\n STORE_FAST sub\n RERAISE 0\n EXC try=L1..L6 -> handler=L7 depth=3 lasti=False\nEND", "expected": "def matrix_to_list(test_list):\n temp = [ele for sub in test_list for ele in sub]\n res = list(zip(*temp))\n return str(res)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 652, "mbpp_split": "train", "prompt": "Write a function to flatten the given tuple matrix into the tuple list with each tuple representing each column.", "test_list": ["assert matrix_to_list([[(4, 5), (7, 8)], [(10, 13), (18, 17)], [(0, 4), (10, 1)]]) == '[(4, 7, 10, 18, 0, 10), (5, 8, 13, 17, 4, 1)]'", "assert matrix_to_list([[(5, 6), (8, 9)], [(11, 14), (19, 18)], [(1, 5), (11, 2)]]) == '[(5, 8, 11, 19, 1, 11), (6, 9, 14, 18, 5, 2)]'", "assert matrix_to_list([[(6, 7), (9, 10)], [(12, 15), (20, 21)], [(23, 7), (15, 8)]]) == '[(6, 9, 12, 20, 23, 15), (7, 10, 15, 21, 7, 8)]'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_652", "n_instr": 55} {"i": 42, "src_path": "src/00042.py", "pyc_path": "pyc/00042.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('defaultdict',)\n IMPORT_NAME collections\n IMPORT_FROM defaultdict\n STORE_NAME defaultdict\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME grouping_dictionary\n RETURN_CONST None\nEND\nCODE grouping_dictionary(l)\n RESUME 0\n LOAD_GLOBAL NULL + defaultdict\n LOAD_GLOBAL list\n CALL 1\n STORE_FAST d\n LOAD_FAST l\n GET_ITER\nL1:\n FOR_ITER L2\n UNPACK_SEQUENCE 2\n STORE_FAST k\n STORE_FAST v\n LOAD_FAST d\n LOAD_FAST k\n BINARY_SUBSCR\n LOAD_ATTR NULL|self + append\n LOAD_FAST v\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST d\n RETURN_VALUE\nEND", "expected": "from collections import defaultdict\n\ndef grouping_dictionary(l):\n d = defaultdict(list)\n for k, v in l:\n d[k].append(v)\n return d", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 653, "mbpp_split": "train", "prompt": "Write a function to group a sequence of key-value pairs into a dictionary of lists using collections module.", "test_list": ["assert grouping_dictionary([('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)])== ({'yellow': [1, 3], 'blue': [2, 4], 'red': [1]})", "assert grouping_dictionary([('yellow', 10), ('blue', 20), ('yellow', 30), ('blue', 40), ('red', 10)])== ({'yellow': [10, 30], 'blue': [20, 40], 'red': [10]})", "assert grouping_dictionary([('yellow', 15), ('blue', 25), ('yellow', 35), ('blue', 45), ('red', 15)])== ({'yellow': [15, 35], 'blue': [25, 45], 'red': [15]})"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_653", "n_instr": 38} {"i": 43, "src_path": "src/00043.py", "pyc_path": "pyc/00043.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME rectangle_perimeter\n RETURN_CONST None\nEND\nCODE rectangle_perimeter(l, b)\n RESUME 0\n LOAD_CONST 2\n LOAD_FAST l\n LOAD_FAST b\n BINARY_OP +\n BINARY_OP *\n STORE_FAST perimeter\n LOAD_FAST perimeter\n RETURN_VALUE\nEND", "expected": "def rectangle_perimeter(l, b):\n perimeter = 2 * (l + b)\n return perimeter", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 654, "mbpp_split": "train", "prompt": "Write a function to find the perimeter of a rectangle.", "test_list": ["assert rectangle_perimeter(10,20)==60", "assert rectangle_perimeter(10,5)==30", "assert rectangle_perimeter(4,2)==12"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_654", "n_instr": 17} {"i": 44, "src_path": "src/00044.py", "pyc_path": "pyc/00044.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME fifth_Power_Sum\n RETURN_CONST None\nEND\nCODE fifth_Power_Sum(n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST sm\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST sm\n LOAD_FAST i\n LOAD_FAST i\n BINARY_OP *\n LOAD_FAST i\n BINARY_OP *\n LOAD_FAST i\n BINARY_OP *\n LOAD_FAST i\n BINARY_OP *\n BINARY_OP +\n STORE_FAST sm\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST sm\n RETURN_VALUE\nEND", "expected": "def fifth_Power_Sum(n):\n sm = 0\n for i in range(1, n + 1):\n sm = sm + i * i * i * i * i\n return sm", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 655, "mbpp_split": "train", "prompt": "Write a python function to find the sum of fifth power of n natural numbers.", "test_list": ["assert fifth_Power_Sum(2) == 33", "assert fifth_Power_Sum(4) == 1300", "assert fifth_Power_Sum(3) == 276"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_655", "n_instr": 38} {"i": 45, "src_path": "src/00045.py", "pyc_path": "pyc/00045.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME first_Digit\n RETURN_CONST None\nEND\nCODE first_Digit(n)\n RESUME 0\n LOAD_CONST 1\n STORE_FAST fact\n LOAD_GLOBAL NULL + range\n LOAD_CONST 2\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L4\n STORE_FAST i\n LOAD_FAST fact\n LOAD_FAST i\n BINARY_OP *\n STORE_FAST fact\n LOAD_FAST fact\n LOAD_CONST 10\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_GLOBAL NULL + int\n LOAD_FAST fact\n LOAD_CONST 10\n BINARY_OP /\n CALL 1\n STORE_FAST fact\n LOAD_FAST fact\n LOAD_CONST 10\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n JUMP_BACKWARD L2\nL3:\n JUMP_BACKWARD L1\nL4:\n END_FOR\n LOAD_FAST fact\n LOAD_CONST 10\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L6\nL5:\n LOAD_GLOBAL NULL + int\n LOAD_FAST fact\n LOAD_CONST 10\n BINARY_OP /\n CALL 1\n STORE_FAST fact\n LOAD_FAST fact\n LOAD_CONST 10\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L6\n JUMP_BACKWARD L5\nL6:\n LOAD_GLOBAL NULL + math\n LOAD_ATTR floor\n LOAD_FAST fact\n CALL 1\n RETURN_VALUE\nEND", "expected": "import math\n\ndef first_Digit(n):\n fact = 1\n for i in range(2, n + 1):\n fact = fact * i\n while fact % 10 == 0:\n fact = int(fact / 10)\n while fact >= 10:\n fact = int(fact / 10)\n return math.floor(fact)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 657, "mbpp_split": "train", "prompt": "Write a python function to find the first digit in factorial of a given number.", "test_list": ["assert first_Digit(5) == 1", "assert first_Digit(10) == 3", "assert first_Digit(7) == 5"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_657", "n_instr": 76} {"i": 46, "src_path": "src/00046.py", "pyc_path": "pyc/00046.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME max_occurrences\n RETURN_CONST None\nEND\nCODE max_occurrences(list1)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST max_val\n LOAD_FAST list1\n LOAD_CONST 0\n BINARY_SUBSCR\n STORE_FAST result\n LOAD_FAST list1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST list1\n LOAD_ATTR NULL|self + count\n LOAD_FAST i\n CALL 1\n STORE_FAST occu\n LOAD_FAST occu\n LOAD_FAST max_val\n COMPARE_OP >\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST occu\n STORE_FAST max_val\n LOAD_FAST i\n STORE_FAST result\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST result\n RETURN_VALUE\nEND", "expected": "def max_occurrences(list1):\n max_val = 0\n result = list1[0]\n for i in list1:\n occu = list1.count(i)\n if occu > max_val:\n max_val = occu\n result = i\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 658, "mbpp_split": "train", "prompt": "Write a function to find the item with maximum occurrences in a given list.", "test_list": ["assert max_occurrences([2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,4,6,9,1,2])==2", "assert max_occurrences([1, 3,5, 7,1, 3,13, 15, 17,5, 7,9,1, 11])==1", "assert max_occurrences([1, 2, 3,2, 4, 5,1, 1, 1])==1"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_658", "n_instr": 40} {"i": 47, "src_path": "src/00047.py", "pyc_path": "pyc/00047.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME Repeat\n RETURN_CONST None\nEND\nCODE Repeat(x)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST x\n CALL 1\n STORE_FAST _size\n BUILD_LIST 0\n STORE_FAST repeated\n LOAD_GLOBAL NULL + range\n LOAD_FAST _size\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L6\n STORE_FAST i\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST k\n LOAD_GLOBAL NULL + range\n LOAD_FAST k\n LOAD_FAST _size\n CALL 2\n GET_ITER\nL2:\n FOR_ITER L5\n STORE_FAST j\n LOAD_FAST x\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST x\n LOAD_FAST j\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L2\nL3:\n LOAD_FAST x\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST repeated\n CONTAINS_OP 1\n POP_JUMP_IF_TRUE L4\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST repeated\n LOAD_ATTR NULL|self + append\n LOAD_FAST x\n LOAD_FAST i\n BINARY_SUBSCR\n CALL 1\n POP_TOP\n JUMP_BACKWARD L2\nL5:\n END_FOR\n JUMP_BACKWARD L1\nL6:\n END_FOR\n LOAD_FAST repeated\n RETURN_VALUE\nEND", "expected": "def Repeat(x):\n _size = len(x)\n repeated = []\n for i in range(_size):\n k = i + 1\n for j in range(k, _size):\n if x[i] == x[j] and x[i] not in repeated:\n repeated.append(x[i])\n return repeated", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 659, "mbpp_split": "train", "prompt": "Write a python function to print duplicants from a list of integers.", "test_list": ["assert Repeat([10, 20, 30, 20, 20, 30, 40, 50, -20, 60, 60, -20, -20]) == [20, 30, -20, 60]", "assert Repeat([-1, 1, -1, 8]) == [-1]", "assert Repeat([1, 2, 3, 1, 2,]) == [1, 2]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_659", "n_instr": 67} {"i": 48, "src_path": "src/00048.py", "pyc_path": "pyc/00048.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_Points\n RETURN_CONST None\nEND\nCODE find_Points(l1, r1, l2, r2)\n RESUME 0\n LOAD_FAST l1\n LOAD_FAST l2\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L1\n LOAD_GLOBAL NULL + min\n LOAD_FAST l1\n LOAD_FAST l2\n CALL 2\n JUMP_FORWARD L2\nL1:\n LOAD_CONST -1\nL2:\n STORE_FAST x\n LOAD_FAST r1\n LOAD_FAST r2\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L3\n LOAD_GLOBAL NULL + max\n LOAD_FAST r1\n LOAD_FAST r2\n CALL 2\n JUMP_FORWARD L4\nL3:\n LOAD_CONST -1\nL4:\n STORE_FAST y\n LOAD_FAST x\n LOAD_FAST y\n BUILD_TUPLE 2\n RETURN_VALUE\nEND", "expected": "def find_Points(l1, r1, l2, r2):\n x = min(l1, l2) if l1 != l2 else -1\n y = max(r1, r2) if r1 != r2 else -1\n return (x, y)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 660, "mbpp_split": "train", "prompt": "Write a python function to choose points from two ranges such that no point lies in both the ranges.", "test_list": ["assert find_Points(5,10,1,5) == (1,10)", "assert find_Points(3,5,7,9) == (3,9)", "assert find_Points(1,5,2,8) == (1,8)"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_660", "n_instr": 39} {"i": 49, "src_path": "src/00049.py", "pyc_path": "pyc/00049.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME max_sum_of_three_consecutive\n RETURN_CONST None\nEND\nCODE max_sum_of_three_consecutive(arr, n)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\n LOAD_FAST_AND_CLEAR k\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST k\n LOAD_CONST 0\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST sum\n STORE_FAST k\n LOAD_FAST n\n LOAD_CONST 1\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L5\n LOAD_FAST arr\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST sum\n LOAD_CONST 0\n STORE_SUBSCR\nL5:\n LOAD_FAST n\n LOAD_CONST 2\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L6\n LOAD_FAST arr\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_CONST 1\n BINARY_SUBSCR\n BINARY_OP +\n LOAD_FAST sum\n LOAD_CONST 1\n STORE_SUBSCR\nL6:\n LOAD_FAST n\n LOAD_CONST 2\n COMPARE_OP >\n POP_JUMP_IF_FALSE L7\n LOAD_GLOBAL NULL + max\n LOAD_FAST sum\n LOAD_CONST 1\n BINARY_SUBSCR\n LOAD_GLOBAL NULL + max\n LOAD_FAST arr\n LOAD_CONST 1\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_CONST 2\n BINARY_SUBSCR\n BINARY_OP +\n LOAD_FAST arr\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_CONST 2\n BINARY_SUBSCR\n BINARY_OP +\n CALL 2\n CALL 2\n LOAD_FAST sum\n LOAD_CONST 2\n STORE_SUBSCR\nL7:\n LOAD_GLOBAL NULL + range\n LOAD_CONST 3\n LOAD_FAST n\n CALL 2\n GET_ITER\nL8:\n FOR_ITER L9\n STORE_FAST i\n LOAD_GLOBAL NULL + max\n LOAD_GLOBAL NULL + max\n LOAD_FAST sum\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n LOAD_FAST sum\n LOAD_FAST i\n LOAD_CONST 2\n BINARY_OP -\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_OP +\n CALL 2\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n BINARY_OP +\n LOAD_FAST sum\n LOAD_FAST i\n LOAD_CONST 3\n BINARY_OP -\n BINARY_SUBSCR\n BINARY_OP +\n CALL 2\n LOAD_FAST sum\n LOAD_FAST i\n STORE_SUBSCR\n JUMP_BACKWARD L8\nL9:\n END_FOR\n LOAD_FAST sum\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n RETURN_VALUE\nL10:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST k\n RERAISE 0\n EXC try=L1..L4 -> handler=L10 depth=2 lasti=False\nEND", "expected": "def max_sum_of_three_consecutive(arr, n):\n sum = [0 for k in range(n)]\n if n >= 1:\n sum[0] = arr[0]\n if n >= 2:\n sum[1] = arr[0] + arr[1]\n if n > 2:\n sum[2] = max(sum[1], max(arr[1] + arr[2], arr[0] + arr[2]))\n for i in range(3, n):\n sum[i] = max(max(sum[i - 1], sum[i - 2] + arr[i]), arr[i] + arr[i - 1] + sum[i - 3])\n return sum[n - 1]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 661, "mbpp_split": "train", "prompt": "Write a function to find the maximum sum that can be formed which has no three consecutive elements present.", "test_list": ["assert max_sum_of_three_consecutive([100, 1000, 100, 1000, 1], 5) == 2101", "assert max_sum_of_three_consecutive([3000, 2000, 1000, 3, 10], 5) == 5013", "assert max_sum_of_three_consecutive([1, 2, 3, 4, 5, 6, 7, 8], 8) == 27"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_661", "n_instr": 144} {"i": 50, "src_path": "src/00050.py", "pyc_path": "pyc/00050.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME average_Even\n RETURN_CONST None\nEND\nCODE average_Even(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Invalid Input'\nL1:\n LOAD_CONST 0\n STORE_FAST sm\n LOAD_CONST 0\n STORE_FAST count\n LOAD_FAST n\n LOAD_CONST 2\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L3\nL2:\n LOAD_FAST count\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST count\n LOAD_FAST sm\n LOAD_FAST n\n BINARY_OP +\n STORE_FAST sm\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP -\n STORE_FAST n\n LOAD_FAST n\n LOAD_CONST 2\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L3\n JUMP_BACKWARD L2\nL3:\n LOAD_FAST sm\n LOAD_FAST count\n BINARY_OP //\n RETURN_VALUE\nEND", "expected": "def average_Even(n):\n if n % 2 != 0:\n return 'Invalid Input'\n return -1\n sm = 0\n count = 0\n while n >= 2:\n count = count + 1\n sm = sm + n\n n = n - 2\n return sm // count", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 664, "mbpp_split": "train", "prompt": "Write a python function to find the average of even numbers till a given even number.", "test_list": ["assert average_Even(2) == 2", "assert average_Even(4) == 3", "assert average_Even(100) == 51"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_664", "n_instr": 48} {"i": 51, "src_path": "src/00051.py", "pyc_path": "pyc/00051.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME move_last\n RETURN_CONST None\nEND\nCODE move_last(num_list)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_FAST num_list\n LOAD_ATTR NULL|self + count\n LOAD_FAST num_list\n LOAD_CONST 0\n BINARY_SUBSCR\n CALL 1\n CALL 1\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST num_list\n LOAD_CONST 0\n BINARY_SUBSCR\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST a\n STORE_FAST i\n LOAD_FAST num_list\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL5:\n BUILD_LIST 0\n SWAP 2\nL6:\n FOR_ITER L9\n STORE_FAST i\n LOAD_FAST i\n LOAD_FAST num_list\n LOAD_CONST 0\n BINARY_SUBSCR\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L8\nL7:\n JUMP_BACKWARD L6\nL8:\n LOAD_FAST i\n LIST_APPEND 2\n JUMP_BACKWARD L6\nL9:\n END_FOR\nL10:\n STORE_FAST x\n STORE_FAST i\n LOAD_FAST x\n LOAD_ATTR NULL|self + extend\n LOAD_FAST a\n CALL 1\n POP_TOP\n LOAD_FAST x\n RETURN_VALUE\nL11:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\nL12:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\n EXC try=L1..L4 -> handler=L11 depth=2 lasti=False\n EXC try=L5..L7 -> handler=L12 depth=2 lasti=False\n EXC try=L8..L10 -> handler=L12 depth=2 lasti=False\nEND", "expected": "def move_last(num_list):\n a = [num_list[0] for i in range(num_list.count(num_list[0]))]\n x = [i for i in num_list if i != num_list[0]]\n x.extend(a)\n return x", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 665, "mbpp_split": "train", "prompt": "Write a python function to shift first element to the end of given list.", "test_list": ["assert move_last([1,2,3,4]) == [2,3,4,1]", "assert move_last([2,3,4,1,5,0]) == [3,4,1,5,0,2]", "assert move_last([5,4,3,2,1]) == [4,3,2,1,5]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_665", "n_instr": 85} {"i": 52, "src_path": "src/00052.py", "pyc_path": "pyc/00052.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_char\n RETURN_CONST None\nEND\nCODE count_char(string, char)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST count\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST string\n CALL 1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST string\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST char\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST count\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST count\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST count\n RETURN_VALUE\nEND", "expected": "def count_char(string, char):\n count = 0\n for i in range(len(string)):\n if string[i] == char:\n count = count + 1\n return count", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 666, "mbpp_split": "train", "prompt": "Write a function to count occurrence of a character in a string.", "test_list": ["assert count_char(\"Python\",'o')==1", "assert count_char(\"little\",'t')==2", "assert count_char(\"assert\",'s')==2"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_666", "n_instr": 37} {"i": 53, "src_path": "src/00053.py", "pyc_path": "pyc/00053.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME Check_Vow\n RETURN_CONST None\nEND\nCODE Check_Vow(string, vowels)\n RESUME 0\n LOAD_FAST string\n GET_ITER\n LOAD_FAST_AND_CLEAR each\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L5\n STORE_FAST each\n LOAD_FAST each\n LOAD_FAST vowels\n CONTAINS_OP 0\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST each\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL5:\n END_FOR\nL6:\n STORE_FAST final\n STORE_FAST each\n LOAD_GLOBAL NULL + len\n LOAD_FAST final\n CALL 1\n RETURN_VALUE\nL7:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST each\n RERAISE 0\n EXC try=L1..L3 -> handler=L7 depth=2 lasti=False\n EXC try=L4..L6 -> handler=L7 depth=2 lasti=False\nEND", "expected": "def Check_Vow(string, vowels):\n final = [each for each in string if each in vowels]\n return len(final)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 667, "mbpp_split": "train", "prompt": "Write a python function to count number of vowels in the string.", "test_list": ["assert Check_Vow('corner','AaEeIiOoUu') == 2", "assert Check_Vow('valid','AaEeIiOoUu') == 2", "assert Check_Vow('true','AaEeIiOoUu') ==2"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_667", "n_instr": 46} {"i": 54, "src_path": "src/00054.py", "pyc_path": "pyc/00054.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST '^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\\\.( \\n\\t\\t\\t25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\\\.( \\n\\t\\t\\t25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\\\.( \\n\\t\\t\\t25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)$'\n STORE_NAME regex\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_IP\n RETURN_CONST None\nEND\nCODE check_IP(Ip)\n RESUME 0\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_GLOBAL regex\n LOAD_FAST Ip\n CALL 2\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Valid IP address'\nL1:\n RETURN_CONST 'Invalid IP address'\nEND", "expected": "import re\nregex = '^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\\\.( \\n\\t\\t\\t25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\\\.( \\n\\t\\t\\t25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\\\.( \\n\\t\\t\\t25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)$'\n\ndef check_IP(Ip):\n if re.search(regex, Ip):\n return 'Valid IP address'\n else:\n return 'Invalid IP address'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 669, "mbpp_split": "train", "prompt": "Write a function to check whether the given ip address is valid or not using regex.", "test_list": ["assert check_IP(\"192.168.0.1\") == 'Valid IP address'", "assert check_IP(\"110.234.52.124\") == 'Valid IP address'", "assert check_IP(\"366.1.2.2\") == 'Invalid IP address'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_669", "n_instr": 24} {"i": 55, "src_path": "src/00055.py", "pyc_path": "pyc/00055.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME decreasing_trend\n RETURN_CONST None\nEND\nCODE decreasing_trend(nums)\n RESUME 0\n LOAD_GLOBAL NULL + sorted\n LOAD_FAST nums\n CALL 1\n LOAD_FAST nums\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST True\nL1:\n RETURN_CONST False\nEND", "expected": "def decreasing_trend(nums):\n if sorted(nums) == nums:\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 670, "mbpp_split": "train", "prompt": "Write a python function to check whether a sequence of numbers has a decreasing trend or not.", "test_list": ["assert decreasing_trend([-4,-3,-2,-1]) == True", "assert decreasing_trend([1,2,3]) == True", "assert decreasing_trend([3,2,1]) == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_670", "n_instr": 18} {"i": 56, "src_path": "src/00056.py", "pyc_path": "pyc/00056.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_Pos_Of_Right_most_Set_Bit\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME set_Right_most_Unset_Bit\n RETURN_CONST None\nEND\nCODE get_Pos_Of_Right_most_Set_Bit(n)\n RESUME 0\n LOAD_GLOBAL NULL + int\n LOAD_GLOBAL NULL + math\n LOAD_ATTR log2\n LOAD_FAST n\n LOAD_FAST n\n UNARY_NEGATIVE\n BINARY_OP &\n CALL 1\n LOAD_CONST 1\n BINARY_OP +\n CALL 1\n RETURN_VALUE\nEND\nCODE set_Right_most_Unset_Bit(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 1\nL1:\n LOAD_FAST n\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP &\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_FAST n\n RETURN_VALUE\nL2:\n LOAD_GLOBAL NULL + get_Pos_Of_Right_most_Set_Bit\n LOAD_FAST n\n UNARY_INVERT\n CALL 1\n STORE_FAST pos\n LOAD_CONST 1\n LOAD_FAST pos\n LOAD_CONST 1\n BINARY_OP -\n BINARY_OP <<\n LOAD_FAST n\n BINARY_OP |\n RETURN_VALUE\nEND", "expected": "import math\n\ndef get_Pos_Of_Right_most_Set_Bit(n):\n return int(math.log2(n & -n) + 1)\n\ndef set_Right_most_Unset_Bit(n):\n if n == 0:\n return 1\n if n & n + 1 == 0:\n return n\n pos = get_Pos_Of_Right_most_Set_Bit(~n)\n return 1 << pos - 1 | n", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 671, "mbpp_split": "train", "prompt": "Write a python function to set the right most unset bit.", "test_list": ["assert set_Right_most_Unset_Bit(21) == 23", "assert set_Right_most_Unset_Bit(11) == 15", "assert set_Right_most_Unset_Bit(15) == 15"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_671", "n_instr": 61} {"i": 57, "src_path": "src/00057.py", "pyc_path": "pyc/00057.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME convert\n RETURN_CONST None\nEND\nCODE convert(list)\n RESUME 0\n LOAD_FAST list\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_GLOBAL NULL + str\n LOAD_FAST i\n CALL 1\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST s\n STORE_FAST i\n LOAD_GLOBAL NULL + int\n LOAD_CONST ''\n LOAD_ATTR NULL|self + join\n LOAD_FAST s\n CALL 1\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=2 lasti=False\nEND", "expected": "def convert(list):\n s = [str(i) for i in list]\n res = int(''.join(s))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 673, "mbpp_split": "train", "prompt": "Write a python function to convert a list of multiple integers into a single integer.", "test_list": ["assert convert([1,2,3]) == 123", "assert convert([4,5,6]) == 456", "assert convert([7,8,9]) == 789"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_673", "n_instr": 45} {"i": 58, "src_path": "src/00058.py", "pyc_path": "pyc/00058.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('OrderedDict',)\n IMPORT_NAME collections\n IMPORT_FROM OrderedDict\n STORE_NAME OrderedDict\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove_duplicate\n RETURN_CONST None\nEND\nCODE remove_duplicate(string)\n RESUME 0\n LOAD_CONST ' '\n LOAD_ATTR NULL|self + join\n LOAD_GLOBAL NULL + OrderedDict\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST string\n LOAD_ATTR NULL|self + split\n CALL 0\n GET_ITER\n CALL 0\n CALL 1\n LOAD_ATTR NULL|self + keys\n CALL 0\n CALL 1\n STORE_FAST result\n LOAD_FAST result\n RETURN_VALUE\nEND\nCODE remove_duplicate..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n STORE_FAST w\n LOAD_FAST w\n LOAD_FAST w\n BUILD_TUPLE 2\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "from collections import OrderedDict\n\ndef remove_duplicate(string):\n result = ' '.join(OrderedDict(((w, w) for w in string.split())).keys())\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 674, "mbpp_split": "train", "prompt": "Write a function to remove duplicate words from a given string using collections module.", "test_list": ["assert remove_duplicate(\"Python Exercises Practice Solution Exercises\")==(\"Python Exercises Practice Solution\")", "assert remove_duplicate(\"Python Exercises Practice Solution Python\")==(\"Python Exercises Practice Solution\")", "assert remove_duplicate(\"Python Exercises Practice Solution Practice\")==(\"Python Exercises Practice Solution\")"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_674", "n_instr": 56} {"i": 59, "src_path": "src/00059.py", "pyc_path": "pyc/00059.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove_spaces\n RETURN_CONST None\nEND\nCODE remove_spaces(str1)\n RESUME 0\n LOAD_FAST str1\n LOAD_ATTR NULL|self + replace\n LOAD_CONST ' '\n LOAD_CONST ''\n CALL 2\n STORE_FAST str1\n LOAD_FAST str1\n RETURN_VALUE\nEND", "expected": "def remove_spaces(str1):\n str1 = str1.replace(' ', '')\n return str1", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 678, "mbpp_split": "train", "prompt": "Write a python function to remove spaces from a given string.", "test_list": ["assert remove_spaces(\"a b c\") == \"abc\"", "assert remove_spaces(\"1 2 3\") == \"123\"", "assert remove_spaces(\" b c\") == \"bc\""], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_678", "n_instr": 17} {"i": 60, "src_path": "src/00060.py", "pyc_path": "pyc/00060.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME access_key\n RETURN_CONST None\nEND\nCODE access_key(ditionary, key)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_FAST ditionary\n CALL 1\n LOAD_FAST key\n BINARY_SUBSCR\n RETURN_VALUE\nEND", "expected": "def access_key(ditionary, key):\n return list(ditionary)[key]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 679, "mbpp_split": "train", "prompt": "Write a function to access dictionary key\u2019s element by index.", "test_list": ["assert access_key({'physics': 80, 'math': 90, 'chemistry': 86},0)== 'physics'", "assert access_key({'python':10, 'java': 20, 'C++':30},2)== 'C++'", "assert access_key({'program':15,'computer':45},1)== 'computer'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_679", "n_instr": 15} {"i": 61, "src_path": "src/00061.py", "pyc_path": "pyc/00061.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME smallest_Divisor\n RETURN_CONST None\nEND\nCODE smallest_Divisor(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 2\nL1:\n LOAD_CONST 3\n STORE_FAST i\n LOAD_FAST i\n LOAD_FAST i\n BINARY_OP *\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L4\nL2:\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n LOAD_FAST i\n RETURN_VALUE\nL3:\n LOAD_FAST i\n LOAD_CONST 2\n BINARY_OP +=\n STORE_FAST i\n LOAD_FAST i\n LOAD_FAST i\n BINARY_OP *\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L4\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST n\n RETURN_VALUE\nEND", "expected": "def smallest_Divisor(n):\n if n % 2 == 0:\n return 2\n i = 3\n while i * i <= n:\n if n % i == 0:\n return i\n i += 2\n return n", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 681, "mbpp_split": "train", "prompt": "Write a python function to find the smallest prime divisor of a number.", "test_list": ["assert smallest_Divisor(10) == 2", "assert smallest_Divisor(25) == 5", "assert smallest_Divisor(31) == 31"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_681", "n_instr": 49} {"i": 62, "src_path": "src/00062.py", "pyc_path": "pyc/00062.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME mul_list\n RETURN_CONST None\nEND\nCODE mul_list(nums1, nums2)\n RESUME 0\n LOAD_GLOBAL NULL + map\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST nums1\n LOAD_FAST nums2\n CALL 3\n STORE_FAST result\n LOAD_GLOBAL NULL + list\n LOAD_FAST result\n CALL 1\n RETURN_VALUE\nEND\nCODE mul_list..(x, y)\n RESUME 0\n LOAD_FAST x\n LOAD_FAST y\n BINARY_OP *\n RETURN_VALUE\nEND", "expected": "def mul_list(nums1, nums2):\n result = map(lambda x, y: x * y, nums1, nums2)\n return list(result)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 682, "mbpp_split": "train", "prompt": "Write a function to multiply two lists using map and lambda function.", "test_list": ["assert mul_list([1, 2, 3],[4,5,6])==[4,10,18]", "assert mul_list([1,2],[3,4])==[3,8]", "assert mul_list([90,120],[50,70])==[4500,8400]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_682", "n_instr": 27} {"i": 63, "src_path": "src/00063.py", "pyc_path": "pyc/00063.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_Square\n RETURN_CONST None\nEND\nCODE sum_Square(n)\n RESUME 0\n LOAD_CONST 1\n STORE_FAST i\n LOAD_FAST i\n LOAD_FAST i\n BINARY_OP *\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L5\nL1:\n LOAD_CONST 1\n STORE_FAST j\n LOAD_FAST j\n LOAD_FAST j\n BINARY_OP *\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L4\nL2:\n LOAD_FAST i\n LOAD_FAST i\n BINARY_OP *\n LOAD_FAST j\n LOAD_FAST j\n BINARY_OP *\n BINARY_OP +\n LOAD_FAST n\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n RETURN_CONST True\nL3:\n LOAD_FAST j\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST j\n LOAD_FAST j\n LOAD_FAST j\n BINARY_OP *\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L4\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST i\n LOAD_FAST i\n LOAD_FAST i\n BINARY_OP *\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L5\n JUMP_BACKWARD L1\nL5:\n RETURN_CONST False\nEND", "expected": "def sum_Square(n):\n i = 1\n while i * i <= n:\n j = 1\n while j * j <= n:\n if i * i + j * j == n:\n return True\n j = j + 1\n i = i + 1\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 683, "mbpp_split": "train", "prompt": "Write a python function to check whether the given number can be represented by sum of two squares or not.", "test_list": ["assert sum_Square(25) == True", "assert sum_Square(24) == False", "assert sum_Square(17) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_683", "n_instr": 64} {"i": 64, "src_path": "src/00064.py", "pyc_path": "pyc/00064.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_Char\n RETURN_CONST None\nEND\nCODE count_Char(str, x)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST count\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST str\n CALL 1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST str\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST x\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST count\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST count\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_CONST 10\n STORE_FAST n\n LOAD_FAST n\n LOAD_GLOBAL NULL + len\n LOAD_FAST str\n CALL 1\n BINARY_OP //\n STORE_FAST repititions\n LOAD_FAST count\n LOAD_FAST repititions\n BINARY_OP *\n STORE_FAST count\n LOAD_FAST n\n LOAD_GLOBAL NULL + len\n LOAD_FAST str\n CALL 1\n BINARY_OP %\n STORE_FAST l\n LOAD_GLOBAL NULL + range\n LOAD_FAST l\n CALL 1\n GET_ITER\nL4:\n FOR_ITER L6\n STORE_FAST i\n LOAD_FAST str\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST x\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L5\n JUMP_BACKWARD L4\nL5:\n LOAD_FAST count\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST count\n JUMP_BACKWARD L4\nL6:\n END_FOR\n LOAD_FAST count\n RETURN_VALUE\nEND", "expected": "def count_Char(str, x):\n count = 0\n for i in range(len(str)):\n if str[i] == x:\n count += 1\n n = 10\n repititions = n // len(str)\n count = count * repititions\n l = n % len(str)\n for i in range(l):\n if str[i] == x:\n count += 1\n return count", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 684, "mbpp_split": "train", "prompt": "Write a python function to count occurences of a character in a repeated string.", "test_list": ["assert count_Char(\"abcac\",'a') == 4", "assert count_Char(\"abca\",'c') == 2", "assert count_Char(\"aba\",'a') == 7"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_684", "n_instr": 77} {"i": 65, "src_path": "src/00065.py", "pyc_path": "pyc/00065.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_Of_Primes\n RETURN_CONST None\nEND\nCODE sum_Of_Primes(n)\n RESUME 0\n LOAD_CONST True\n BUILD_LIST 1\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP *\n STORE_FAST prime\n LOAD_CONST 2\n STORE_FAST p\n LOAD_FAST p\n LOAD_FAST p\n BINARY_OP *\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L4\nL1:\n LOAD_FAST prime\n LOAD_FAST p\n BINARY_SUBSCR\n LOAD_CONST True\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n LOAD_FAST p\n LOAD_CONST 2\n BINARY_OP *\n STORE_FAST i\n LOAD_FAST i\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L3\nL2:\n LOAD_CONST False\n LOAD_FAST prime\n LOAD_FAST i\n STORE_SUBSCR\n LOAD_FAST i\n LOAD_FAST p\n BINARY_OP +=\n STORE_FAST i\n LOAD_FAST i\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L3\n JUMP_BACKWARD L2\nL3:\n LOAD_FAST p\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST p\n LOAD_FAST p\n LOAD_FAST p\n BINARY_OP *\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L4\n JUMP_BACKWARD L1\nL4:\n LOAD_CONST 0\n STORE_FAST sum\n LOAD_GLOBAL NULL + range\n LOAD_CONST 2\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL5:\n FOR_ITER L7\n STORE_FAST i\n LOAD_FAST prime\n LOAD_FAST i\n BINARY_SUBSCR\n POP_JUMP_IF_TRUE L6\n JUMP_BACKWARD L5\nL6:\n LOAD_FAST sum\n LOAD_FAST i\n BINARY_OP +=\n STORE_FAST sum\n JUMP_BACKWARD L5\nL7:\n END_FOR\n LOAD_FAST sum\n RETURN_VALUE\nEND", "expected": "def sum_Of_Primes(n):\n prime = [True] * (n + 1)\n p = 2\n while p * p <= n:\n if prime[p] == True:\n i = p * 2\n while i <= n:\n prime[i] = False\n i += p\n p += 1\n sum = 0\n for i in range(2, n + 1):\n if prime[i]:\n sum += i\n return sum", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 685, "mbpp_split": "train", "prompt": "Write a python function to find sum of prime numbers between 1 to n.", "test_list": ["assert sum_Of_Primes(10) == 17", "assert sum_Of_Primes(20) == 77", "assert sum_Of_Primes(5) == 10"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_685", "n_instr": 93} {"i": 66, "src_path": "src/00066.py", "pyc_path": "pyc/00066.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('defaultdict',)\n IMPORT_NAME collections\n IMPORT_FROM defaultdict\n STORE_NAME defaultdict\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME freq_element\n RETURN_CONST None\nEND\nCODE freq_element(test_tup)\n RESUME 0\n LOAD_GLOBAL NULL + defaultdict\n LOAD_GLOBAL int\n CALL 1\n STORE_FAST res\n LOAD_FAST test_tup\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST ele\n LOAD_FAST res\n LOAD_FAST ele\n COPY 2\n COPY 2\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +=\n SWAP 3\n SWAP 2\n STORE_SUBSCR\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_GLOBAL NULL + str\n LOAD_GLOBAL NULL + dict\n LOAD_FAST res\n CALL 1\n CALL 1\n RETURN_VALUE\nEND", "expected": "from collections import defaultdict\n\ndef freq_element(test_tup):\n res = defaultdict(int)\n for ele in test_tup:\n res[ele] += 1\n return str(dict(res))", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 686, "mbpp_split": "train", "prompt": "Write a function to find the frequency of each element in the given list.", "test_list": ["assert freq_element((4, 5, 4, 5, 6, 6, 5, 5, 4) ) == '{4: 3, 5: 4, 6: 2}'", "assert freq_element((7, 8, 8, 9, 4, 7, 6, 5, 4) ) == '{7: 2, 8: 2, 9: 1, 4: 2, 6: 1, 5: 1}'", "assert freq_element((1, 4, 3, 1, 4, 5, 2, 6, 2, 7) ) == '{1: 2, 4: 2, 3: 1, 5: 1, 2: 2, 6: 1, 7: 1}'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_686", "n_instr": 43} {"i": 67, "src_path": "src/00067.py", "pyc_path": "pyc/00067.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME cmath\n STORE_NAME cmath\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME len_complex\n RETURN_CONST None\nEND\nCODE len_complex(a, b)\n RESUME 0\n LOAD_GLOBAL NULL + complex\n LOAD_FAST a\n LOAD_FAST b\n CALL 2\n STORE_FAST cn\n LOAD_GLOBAL NULL + abs\n LOAD_FAST cn\n CALL 1\n STORE_FAST length\n LOAD_FAST length\n RETURN_VALUE\nEND", "expected": "import cmath\n\ndef len_complex(a, b):\n cn = complex(a, b)\n length = abs(cn)\n return length", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 688, "mbpp_split": "train", "prompt": "Write a function to get the length of a complex number.", "test_list": ["assert len_complex(3,4)==5.0", "assert len_complex(9,10)==13.45362404707371", "assert len_complex(7,9)==11.40175425099138"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_688", "n_instr": 24} {"i": 68, "src_path": "src/00068.py", "pyc_path": "pyc/00068.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME min_jumps\n RETURN_CONST None\nEND\nCODE min_jumps(arr, n)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_CONST 0\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST jumps\n STORE_FAST i\n LOAD_FAST n\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L5\n LOAD_FAST arr\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L6\nL5:\n LOAD_GLOBAL NULL + float\n LOAD_CONST 'inf'\n CALL 1\n RETURN_VALUE\nL6:\n LOAD_CONST 0\n LOAD_FAST jumps\n LOAD_CONST 0\n STORE_SUBSCR\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST n\n CALL 2\n GET_ITER\nL7:\n FOR_ITER L12\n STORE_FAST i\n LOAD_GLOBAL NULL + float\n LOAD_CONST 'inf'\n CALL 1\n LOAD_FAST jumps\n LOAD_FAST i\n STORE_SUBSCR\n LOAD_GLOBAL NULL + range\n LOAD_FAST i\n CALL 1\n GET_ITER\nL8:\n FOR_ITER L11\n STORE_FAST j\n LOAD_FAST i\n LOAD_FAST j\n LOAD_FAST arr\n LOAD_FAST j\n BINARY_SUBSCR\n BINARY_OP +\n COMPARE_OP <=\n POP_JUMP_IF_TRUE L9\n JUMP_BACKWARD L8\nL9:\n LOAD_FAST jumps\n LOAD_FAST j\n BINARY_SUBSCR\n LOAD_GLOBAL NULL + float\n LOAD_CONST 'inf'\n CALL 1\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L10\n JUMP_BACKWARD L8\nL10:\n LOAD_GLOBAL NULL + min\n LOAD_FAST jumps\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST jumps\n LOAD_FAST j\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n LOAD_FAST jumps\n LOAD_FAST i\n STORE_SUBSCR\n POP_TOP\n JUMP_BACKWARD L7\nL11:\n END_FOR\n JUMP_BACKWARD L7\nL12:\n END_FOR\n LOAD_FAST jumps\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n RETURN_VALUE\nL13:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\n EXC try=L1..L4 -> handler=L13 depth=2 lasti=False\nEND", "expected": "def min_jumps(arr, n):\n jumps = [0 for i in range(n)]\n if n == 0 or arr[0] == 0:\n return float('inf')\n jumps[0] = 0\n for i in range(1, n):\n jumps[i] = float('inf')\n for j in range(i):\n if i <= j + arr[j] and jumps[j] != float('inf'):\n jumps[i] = min(jumps[i], jumps[j] + 1)\n break\n return jumps[n - 1]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 689, "mbpp_split": "train", "prompt": "## write a function to find the minimum number of jumps to reach the end of the array for the given array of integers where each element represents the max number of steps that can be made forward from that element. > indented block > indented block", "test_list": ["assert min_jumps([1, 3, 6, 1, 0, 9], 6) == 3", "assert min_jumps([1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9], 11) == 3", "assert min_jumps([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 11) == 10"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_689", "n_instr": 123} {"i": 69, "src_path": "src/00069.py", "pyc_path": "pyc/00069.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME mul_consecutive_nums\n RETURN_CONST None\nEND\nCODE mul_consecutive_nums(nums)\n RESUME 0\n LOAD_GLOBAL NULL + zip\n LOAD_FAST nums\n LOAD_CONST None\n LOAD_CONST -1\n BINARY_SLICE\n LOAD_FAST nums\n LOAD_CONST 1\n LOAD_CONST None\n BINARY_SLICE\n CALL 2\n GET_ITER\n LOAD_FAST_AND_CLEAR a\n LOAD_FAST_AND_CLEAR b\n SWAP 3\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST a\n STORE_FAST b\n LOAD_FAST b\n LOAD_FAST a\n BINARY_OP *\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST result\n STORE_FAST a\n STORE_FAST b\n LOAD_FAST result\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 3\n STORE_FAST b\n STORE_FAST a\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=3 lasti=False\nEND", "expected": "def mul_consecutive_nums(nums):\n result = [b * a for a, b in zip(nums[:-1], nums[1:])]\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 690, "mbpp_split": "train", "prompt": "Write a function to multiply consecutive numbers of a given list.", "test_list": ["assert mul_consecutive_nums([1, 1, 3, 4, 4, 5, 6, 7])==[1, 3, 12, 16, 20, 30, 42]", "assert mul_consecutive_nums([4, 5, 8, 9, 6, 10])==[20, 40, 72, 54, 60]", "assert mul_consecutive_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[2, 6, 12, 20, 30, 42, 56, 72, 90]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_690", "n_instr": 52} {"i": 70, "src_path": "src/00070.py", "pyc_path": "pyc/00070.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('groupby',)\n IMPORT_NAME itertools\n IMPORT_FROM groupby\n STORE_NAME groupby\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME group_element\n RETURN_CONST None\nEND\nCODE group_element(test_list)\n RESUME 0\n LOAD_GLOBAL NULL + dict\n CALL 0\n STORE_FAST res\n LOAD_GLOBAL NULL + groupby\n LOAD_GLOBAL NULL + sorted\n LOAD_FAST test_list\n LOAD_CONST .>\n MAKE_FUNCTION 0\n KW_NAMES ('key',)\n CALL 2\n LOAD_CONST .>\n MAKE_FUNCTION 0\n KW_NAMES ('key',)\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L6\n UNPACK_SEQUENCE 2\n STORE_FAST key\n STORE_FAST val\n LOAD_FAST val\n GET_ITER\n LOAD_FAST_AND_CLEAR ele\n SWAP 2\nL2:\n BUILD_LIST 0\n SWAP 2\nL3:\n FOR_ITER L4\n STORE_FAST ele\n LOAD_FAST ele\n LOAD_CONST 0\n BINARY_SUBSCR\n LIST_APPEND 2\n JUMP_BACKWARD L3\nL4:\n END_FOR\nL5:\n SWAP 2\n STORE_FAST ele\n LOAD_FAST res\n LOAD_FAST key\n STORE_SUBSCR\n JUMP_BACKWARD L1\nL6:\n END_FOR\n LOAD_FAST res\n RETURN_VALUE\nL7:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST ele\n RERAISE 0\n EXC try=L2..L5 -> handler=L7 depth=3 lasti=False\nEND\nCODE group_element..(ele)\n RESUME 0\n LOAD_FAST ele\n LOAD_CONST 1\n BINARY_SUBSCR\n RETURN_VALUE\nEND\nCODE group_element..(ele)\n RESUME 0\n LOAD_FAST ele\n LOAD_CONST 1\n BINARY_SUBSCR\n RETURN_VALUE\nEND", "expected": "from itertools import groupby\n\ndef group_element(test_list):\n res = dict()\n for key, val in groupby(sorted(test_list, key=lambda ele: ele[1]), key=lambda ele: ele[1]):\n res[key] = [ele[0] for ele in val]\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 691, "mbpp_split": "train", "prompt": "Write a function to group the 1st elements on the basis of 2nd elements in the given tuple list.", "test_list": ["assert group_element([(6, 5), (2, 7), (2, 5), (8, 7), (9, 8), (3, 7)]) == {5: [6, 2], 7: [2, 8, 3], 8: [9]}", "assert group_element([(7, 6), (3, 8), (3, 6), (9, 8), (10, 9), (4, 8)]) == {6: [7, 3], 8: [3, 9, 4], 9: [10]}", "assert group_element([(8, 7), (4, 9), (4, 7), (10, 9), (11, 10), (5, 9)]) == {7: [8, 4], 9: [4, 10, 5], 10: [11]}"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_691", "n_instr": 84} {"i": 71, "src_path": "src/00071.py", "pyc_path": "pyc/00071.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME last_Two_Digits\n RETURN_CONST None\nEND\nCODE last_Two_Digits(N)\n RESUME 0\n LOAD_FAST N\n LOAD_CONST 10\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L1\n RETURN_CONST None\nL1:\n LOAD_CONST 1\n STORE_FAST fac\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST N\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST fac\n LOAD_FAST i\n BINARY_OP *\n LOAD_CONST 100\n BINARY_OP %\n STORE_FAST fac\n JUMP_BACKWARD L2\nL3:\n END_FOR\n LOAD_FAST fac\n RETURN_VALUE\nEND", "expected": "def last_Two_Digits(N):\n if N >= 10:\n return\n fac = 1\n for i in range(1, N + 1):\n fac = fac * i % 100\n return fac", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 692, "mbpp_split": "train", "prompt": "Write a python function to find the last two digits in factorial of a given number.", "test_list": ["assert last_Two_Digits(7) == 40", "assert last_Two_Digits(5) == 20", "assert last_Two_Digits(2) == 2"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_692", "n_instr": 38} {"i": 72, "src_path": "src/00072.py", "pyc_path": "pyc/00072.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_greater\n RETURN_CONST None\nEND\nCODE check_greater(test_tup1, test_tup2)\n RESUME 0\n LOAD_GLOBAL NULL + all\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_GLOBAL NULL + zip\n LOAD_FAST test_tup1\n LOAD_FAST test_tup2\n CALL 2\n GET_ITER\n CALL 0\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND\nCODE check_greater..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST x\n STORE_FAST y\n LOAD_FAST x\n LOAD_FAST y\n COMPARE_OP <\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def check_greater(test_tup1, test_tup2):\n res = all((x < y for x, y in zip(test_tup1, test_tup2)))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 695, "mbpp_split": "train", "prompt": "Write a function to check if each element of the second tuple is greater than its corresponding index in the first tuple.", "test_list": ["assert check_greater((10, 4, 5), (13, 5, 18)) == True", "assert check_greater((1, 2, 3), (2, 1, 4)) == False", "assert check_greater((4, 5, 6), (5, 6, 7)) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_695", "n_instr": 48} {"i": 73, "src_path": "src/00073.py", "pyc_path": "pyc/00073.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME zip_list\n RETURN_CONST None\nEND\nCODE zip_list(list1, list2)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + map\n LOAD_GLOBAL list\n LOAD_ATTR __add__\n LOAD_FAST list1\n LOAD_FAST list2\n CALL 3\n CALL 1\n STORE_FAST result\n LOAD_FAST result\n RETURN_VALUE\nEND", "expected": "def zip_list(list1, list2):\n result = list(map(list.__add__, list1, list2))\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 696, "mbpp_split": "train", "prompt": "Write a function to zip two given lists of lists.", "test_list": ["assert zip_list([[1, 3], [5, 7], [9, 11]] ,[[2, 4], [6, 8], [10, 12, 14]] )==[[1, 3, 2, 4], [5, 7, 6, 8], [9, 11, 10, 12, 14]]", "assert zip_list([[1, 2], [3, 4], [5, 6]] ,[[7, 8], [9, 10], [11, 12]] )==[[1, 2, 7, 8], [3, 4, 9, 10], [5, 6, 11, 12]]", "assert zip_list([['a','b'],['c','d']] , [['e','f'],['g','h']] )==[['a','b','e','f'],['c','d','g','h']]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_696", "n_instr": 20} {"i": 74, "src_path": "src/00074.py", "pyc_path": "pyc/00074.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_even\n RETURN_CONST None\nEND\nCODE count_even(array_nums)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + filter\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST array_nums\n CALL 2\n CALL 1\n CALL 1\n STORE_FAST count_even\n LOAD_FAST count_even\n RETURN_VALUE\nEND\nCODE count_even..(x)\n RESUME 0\n LOAD_FAST x\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n RETURN_VALUE\nEND", "expected": "def count_even(array_nums):\n count_even = len(list(filter(lambda x: x % 2 == 0, array_nums)))\n return count_even", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 697, "mbpp_split": "train", "prompt": "Write a function to find number of even elements in the given list using lambda function.", "test_list": ["assert count_even([1, 2, 3, 5, 7, 8, 9, 10])==3", "assert count_even([10,15,14,13,-18,12,-20])==5", "assert count_even([1, 2, 4, 8, 9])==3"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_697", "n_instr": 30} {"i": 75, "src_path": "src/00075.py", "pyc_path": "pyc/00075.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME min_Swaps\n RETURN_CONST None\nEND\nCODE min_Swaps(str1, str2)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST count\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST str1\n CALL 1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST str1\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST str2\n LOAD_FAST i\n BINARY_SUBSCR\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST count\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST count\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST count\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L4\n LOAD_FAST count\n LOAD_CONST 2\n BINARY_OP //\n RETURN_VALUE\nL4:\n RETURN_CONST 'Not Possible'\nEND", "expected": "def min_Swaps(str1, str2):\n count = 0\n for i in range(len(str1)):\n if str1[i] != str2[i]:\n count += 1\n if count % 2 == 0:\n return count // 2\n else:\n return 'Not Possible'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 699, "mbpp_split": "train", "prompt": "Write a python function to find the minimum number of swaps required to convert one binary string to another.", "test_list": ["assert min_Swaps(\"1101\",\"1110\") == 1", "assert min_Swaps(\"1111\",\"0100\") == \"Not Possible\"", "assert min_Swaps(\"1110000\",\"0001101\") == 3"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_699", "n_instr": 49} {"i": 76, "src_path": "src/00076.py", "pyc_path": "pyc/00076.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_range_in_list\n RETURN_CONST None\nEND\nCODE count_range_in_list(li, min, max)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST ctr\n LOAD_FAST li\n GET_ITER\nL1:\n FOR_ITER L5\n STORE_FAST x\n LOAD_FAST min\n LOAD_FAST x\n SWAP 2\n COPY 2\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L3\n LOAD_FAST max\n COMPARE_OP <=\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n JUMP_FORWARD L4\nL3:\n POP_TOP\n JUMP_BACKWARD L1\nL4:\n LOAD_FAST ctr\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST ctr\n JUMP_BACKWARD L1\nL5:\n END_FOR\n LOAD_FAST ctr\n RETURN_VALUE\nEND", "expected": "def count_range_in_list(li, min, max):\n ctr = 0\n for x in li:\n if min <= x <= max:\n ctr += 1\n return ctr", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 700, "mbpp_split": "train", "prompt": "Write a function to count the number of elements in a list which are within a specific range.", "test_list": ["assert count_range_in_list([10,20,30,40,40,40,70,80,99],40,100)==6", "assert count_range_in_list(['a','b','c','d','e','f'],'a','e')==5", "assert count_range_in_list([7,8,9,15,17,19,45],15,20)==3"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_700", "n_instr": 41} {"i": 77, "src_path": "src/00077.py", "pyc_path": "pyc/00077.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME equilibrium_index\n RETURN_CONST None\nEND\nCODE equilibrium_index(arr)\n RESUME 0\n LOAD_GLOBAL NULL + sum\n LOAD_FAST arr\n CALL 1\n STORE_FAST total_sum\n LOAD_CONST 0\n STORE_FAST left_sum\n LOAD_GLOBAL NULL + enumerate\n LOAD_FAST arr\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST i\n STORE_FAST num\n LOAD_FAST total_sum\n LOAD_FAST num\n BINARY_OP -=\n STORE_FAST total_sum\n LOAD_FAST left_sum\n LOAD_FAST total_sum\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_FAST i\n SWAP 2\n POP_TOP\n RETURN_VALUE\nL2:\n LOAD_FAST left_sum\n LOAD_FAST num\n BINARY_OP +=\n STORE_FAST left_sum\n JUMP_BACKWARD L1\nL3:\n END_FOR\n RETURN_CONST -1\nEND", "expected": "def equilibrium_index(arr):\n total_sum = sum(arr)\n left_sum = 0\n for i, num in enumerate(arr):\n total_sum -= num\n if left_sum == total_sum:\n return i\n left_sum += num\n return -1", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 701, "mbpp_split": "train", "prompt": "Write a function to find the equilibrium index of the given array.", "test_list": ["assert equilibrium_index([1, 2, 3, 4, 1, 2, 3]) == 3", "assert equilibrium_index([-7, 1, 5, 2, -4, 3, 0]) == 3", "assert equilibrium_index([1, 2, 3]) == -1"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_701", "n_instr": 45} {"i": 78, "src_path": "src/00078.py", "pyc_path": "pyc/00078.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME harmonic_sum\n RETURN_CONST None\nEND\nCODE harmonic_sum(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 2\n COMPARE_OP <\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 1\nL1:\n LOAD_CONST 1\n LOAD_FAST n\n BINARY_OP /\n LOAD_GLOBAL NULL + harmonic_sum\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def harmonic_sum(n):\n if n < 2:\n return 1\n else:\n return 1 / n + harmonic_sum(n - 1)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 704, "mbpp_split": "train", "prompt": "Write a function to calculate the harmonic sum of n-1.", "test_list": ["assert harmonic_sum(10)==2.9289682539682538", "assert harmonic_sum(4)==2.083333333333333", "assert harmonic_sum(7)==2.5928571428571425 "], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_704", "n_instr": 25} {"i": 79, "src_path": "src/00079.py", "pyc_path": "pyc/00079.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sort_sublists\n RETURN_CONST None\nEND\nCODE sort_sublists(list1)\n RESUME 0\n LOAD_FAST list1\n LOAD_ATTR NULL|self + sort\n CALL 0\n POP_TOP\n LOAD_FAST list1\n LOAD_ATTR NULL|self + sort\n LOAD_GLOBAL len\n KW_NAMES ('key',)\n CALL 1\n POP_TOP\n LOAD_FAST list1\n RETURN_VALUE\nEND", "expected": "def sort_sublists(list1):\n list1.sort()\n list1.sort(key=len)\n return list1", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 705, "mbpp_split": "train", "prompt": "Write a function to sort a list of lists by length and value.", "test_list": ["assert sort_sublists([[2], [0], [1, 3], [0, 7], [9, 11], [13, 15, 17]])==[[0], [2], [0, 7], [1, 3], [9, 11], [13, 15, 17]]", "assert sort_sublists([[1], [2, 3], [4, 5, 6], [7], [10, 11]])==[[1], [7], [2, 3], [10, 11], [4, 5, 6]]", "assert sort_sublists([[\"python\"],[\"java\",\"C\",\"C++\"],[\"DBMS\"],[\"SQL\",\"HTML\"]])==[['DBMS'], ['python'], ['SQL', 'HTML'], ['java', 'C', 'C++']]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_705", "n_instr": 21} {"i": 80, "src_path": "src/00080.py", "pyc_path": "pyc/00080.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_Set_Bits\n RETURN_CONST None\nEND\nCODE count_Set_Bits(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST n\n LOAD_CONST 2\n STORE_FAST powerOf2\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP //\n STORE_FAST cnt\n LOAD_FAST powerOf2\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L4\nL1:\n LOAD_FAST n\n LOAD_FAST powerOf2\n BINARY_OP //\n STORE_FAST totalPairs\n LOAD_FAST cnt\n LOAD_FAST totalPairs\n LOAD_CONST 2\n BINARY_OP //\n LOAD_FAST powerOf2\n BINARY_OP *\n BINARY_OP +=\n STORE_FAST cnt\n LOAD_FAST totalPairs\n LOAD_CONST 1\n BINARY_OP &\n POP_JUMP_IF_FALSE L2\n LOAD_FAST cnt\n LOAD_FAST n\n LOAD_FAST powerOf2\n BINARY_OP %\n BINARY_OP +=\n STORE_FAST cnt\n JUMP_FORWARD L3\nL2:\n LOAD_FAST cnt\n LOAD_CONST 0\n BINARY_OP +=\n STORE_FAST cnt\nL3:\n LOAD_FAST powerOf2\n LOAD_CONST 1\n BINARY_OP <<=\n STORE_FAST powerOf2\n LOAD_FAST powerOf2\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L4\n JUMP_BACKWARD L1\nL4:\n LOAD_FAST cnt\n RETURN_VALUE\nEND", "expected": "def count_Set_Bits(n):\n n += 1\n powerOf2 = 2\n cnt = n // 2\n while powerOf2 <= n:\n totalPairs = n // powerOf2\n cnt += totalPairs // 2 * powerOf2\n if totalPairs & 1:\n cnt += n % powerOf2\n else:\n cnt += 0\n powerOf2 <<= 1\n return cnt", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 707, "mbpp_split": "train", "prompt": "Write a python function to count the total set bits from 1 to n.", "test_list": ["assert count_Set_Bits(16) == 33", "assert count_Set_Bits(2) == 2", "assert count_Set_Bits(14) == 28"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_707", "n_instr": 65} {"i": 81, "src_path": "src/00081.py", "pyc_path": "pyc/00081.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME Convert\n RETURN_CONST None\nEND\nCODE Convert(string)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_FAST string\n LOAD_ATTR NULL|self + split\n LOAD_CONST ' '\n CALL 1\n CALL 1\n STORE_FAST li\n LOAD_FAST li\n RETURN_VALUE\nEND", "expected": "def Convert(string):\n li = list(string.split(' '))\n return li", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 708, "mbpp_split": "train", "prompt": "Write a python function to convert a string to a list.", "test_list": ["assert Convert('python program') == ['python','program']", "assert Convert('Data Analysis') ==['Data','Analysis']", "assert Convert('Hadoop Training') == ['Hadoop','Training']"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_708", "n_instr": 18} {"i": 82, "src_path": "src/00082.py", "pyc_path": "pyc/00082.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('defaultdict',)\n IMPORT_NAME collections\n IMPORT_FROM defaultdict\n STORE_NAME defaultdict\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_unique\n RETURN_CONST None\nEND\nCODE get_unique(test_list)\n RESUME 0\n LOAD_GLOBAL NULL + defaultdict\n LOAD_GLOBAL list\n CALL 1\n STORE_FAST res\n LOAD_FAST test_list\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST sub\n LOAD_FAST res\n LOAD_FAST sub\n LOAD_CONST 1\n BINARY_SUBSCR\n BINARY_SUBSCR\n LOAD_ATTR NULL|self + append\n LOAD_FAST sub\n LOAD_CONST 0\n BINARY_SUBSCR\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_GLOBAL NULL + dict\n LOAD_FAST res\n CALL 1\n STORE_FAST res\n LOAD_GLOBAL NULL + dict\n CALL 0\n STORE_FAST res_dict\n LOAD_FAST res\n GET_ITER\nL3:\n FOR_ITER L4\n STORE_FAST key\n LOAD_GLOBAL NULL + len\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + set\n LOAD_FAST res\n LOAD_FAST key\n BINARY_SUBSCR\n CALL 1\n CALL 1\n CALL 1\n LOAD_FAST res_dict\n LOAD_FAST key\n STORE_SUBSCR\n JUMP_BACKWARD L3\nL4:\n END_FOR\n LOAD_GLOBAL NULL + str\n LOAD_FAST res_dict\n CALL 1\n RETURN_VALUE\nEND", "expected": "from collections import defaultdict\n\ndef get_unique(test_list):\n res = defaultdict(list)\n for sub in test_list:\n res[sub[1]].append(sub[0])\n res = dict(res)\n res_dict = dict()\n for key in res:\n res_dict[key] = len(list(set(res[key])))\n return str(res_dict)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 709, "mbpp_split": "train", "prompt": "Write a function to count unique keys for each value present in the tuple.", "test_list": ["assert get_unique([(3, 4), (1, 2), (2, 4), (8, 2), (7, 2), (8, 1), (9, 1), (8, 4), (10, 4)] ) == '{4: 4, 2: 3, 1: 2}'", "assert get_unique([(4, 5), (2, 3), (3, 5), (9, 3), (8, 3), (9, 2), (10, 2), (9, 5), (11, 5)] ) == '{5: 4, 3: 3, 2: 2}'", "assert get_unique([(6, 5), (3, 4), (2, 6), (11, 1), (8, 22), (8, 11), (4, 3), (14, 3), (11, 6)] ) == '{5: 1, 4: 1, 6: 2, 1: 1, 22: 1, 11: 1, 3: 2}'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_709", "n_instr": 69} {"i": 83, "src_path": "src/00083.py", "pyc_path": "pyc/00083.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME front_and_rear\n RETURN_CONST None\nEND\nCODE front_and_rear(test_tup)\n RESUME 0\n LOAD_FAST test_tup\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST test_tup\n LOAD_CONST -1\n BINARY_SUBSCR\n BUILD_TUPLE 2\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def front_and_rear(test_tup):\n res = (test_tup[0], test_tup[-1])\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 710, "mbpp_split": "train", "prompt": "Write a function to access the initial and last data of the given tuple record.", "test_list": ["assert front_and_rear((10, 4, 5, 6, 7)) == (10, 7)", "assert front_and_rear((1, 2, 3, 4, 5)) == (1, 5)", "assert front_and_rear((6, 7, 8, 9, 10)) == (6, 10)"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_710", "n_instr": 19} {"i": 84, "src_path": "src/00084.py", "pyc_path": "pyc/00084.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME product_Equal\n RETURN_CONST None\nEND\nCODE product_Equal(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 10\n COMPARE_OP <\n POP_JUMP_IF_FALSE L1\n RETURN_CONST False\nL1:\n LOAD_CONST 1\n STORE_FAST prodOdd\n LOAD_CONST 1\n STORE_FAST prodEven\n LOAD_FAST n\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_FALSE L4\nL2:\n LOAD_FAST n\n LOAD_CONST 10\n BINARY_OP %\n STORE_FAST digit\n LOAD_FAST prodOdd\n LOAD_FAST digit\n BINARY_OP *=\n STORE_FAST prodOdd\n LOAD_FAST n\n LOAD_CONST 10\n BINARY_OP //\n STORE_FAST n\n LOAD_FAST n\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n JUMP_FORWARD L4\nL3:\n LOAD_FAST n\n LOAD_CONST 10\n BINARY_OP %\n STORE_FAST digit\n LOAD_FAST prodEven\n LOAD_FAST digit\n BINARY_OP *=\n STORE_FAST prodEven\n LOAD_FAST n\n LOAD_CONST 10\n BINARY_OP //\n STORE_FAST n\n LOAD_FAST n\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_FALSE L4\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST prodOdd\n LOAD_FAST prodEven\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L5\n RETURN_CONST True\nL5:\n RETURN_CONST False\nEND", "expected": "def product_Equal(n):\n if n < 10:\n return False\n prodOdd = 1\n prodEven = 1\n while n > 0:\n digit = n % 10\n prodOdd *= digit\n n = n // 10\n if n == 0:\n break\n digit = n % 10\n prodEven *= digit\n n = n // 10\n if prodOdd == prodEven:\n return True\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 711, "mbpp_split": "train", "prompt": "Write a python function to check whether the product of digits of a number at even and odd places is equal or not.", "test_list": ["assert product_Equal(2841) == True", "assert product_Equal(1234) == False", "assert product_Equal(1212) == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_711", "n_instr": 67} {"i": 85, "src_path": "src/00085.py", "pyc_path": "pyc/00085.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME itertools\n STORE_NAME itertools\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove_duplicate\n RETURN_CONST None\nEND\nCODE remove_duplicate(list1)\n RESUME 0\n LOAD_GLOBAL list\n LOAD_ATTR NULL|self + sort\n LOAD_FAST list1\n CALL 1\n POP_TOP\n LOAD_GLOBAL NULL + list\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_GLOBAL NULL + itertools\n LOAD_ATTR groupby\n LOAD_FAST list1\n CALL 1\n GET_ITER\n CALL 0\n CALL 1\n STORE_FAST remove_duplicate\n LOAD_FAST remove_duplicate\n RETURN_VALUE\nEND\nCODE remove_duplicate..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST list1\n STORE_FAST _\n LOAD_FAST list1\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "import itertools\n\ndef remove_duplicate(list1):\n list.sort(list1)\n remove_duplicate = list((list1 for list1, _ in itertools.groupby(list1)))\n return remove_duplicate", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 712, "mbpp_split": "train", "prompt": "Write a function to remove duplicates from a list of lists.", "test_list": ["assert remove_duplicate([[10, 20], [40], [30, 56, 25], [10, 20], [33], [40]])==[[10, 20], [30, 56, 25], [33], [40]] ", "assert remove_duplicate([\"a\", \"b\", \"a\", \"c\", \"c\"] )==[\"a\", \"b\", \"c\"]", "assert remove_duplicate([1, 3, 5, 6, 3, 5, 6, 1] )==[1, 3, 5, 6]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_712", "n_instr": 55} {"i": 86, "src_path": "src/00086.py", "pyc_path": "pyc/00086.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_valid\n RETURN_CONST None\nEND\nCODE check_valid(test_tup)\n RESUME 0\n LOAD_GLOBAL NULL + any\n LOAD_GLOBAL NULL + map\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST test_tup\n CALL 2\n CALL 1\n UNARY_NOT\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND\nCODE check_valid..(ele)\n RESUME 0\n LOAD_FAST ele\n UNARY_NOT\n RETURN_VALUE\nEND", "expected": "def check_valid(test_tup):\n res = not any(map(lambda ele: not ele, test_tup))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 713, "mbpp_split": "train", "prompt": "Write a function to check if the given tuple contains all valid values or not.", "test_list": ["assert check_valid((True, True, True, True) ) == True", "assert check_valid((True, False, True, True) ) == False", "assert check_valid((True, True, True, True) ) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_713", "n_instr": 26} {"i": 87, "src_path": "src/00087.py", "pyc_path": "pyc/00087.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_Fac\n RETURN_CONST None\nEND\nCODE count_Fac(n)\n RESUME 0\n LOAD_FAST n\n STORE_FAST m\n LOAD_CONST 0\n STORE_FAST count\n LOAD_CONST 2\n STORE_FAST i\n LOAD_FAST i\n LOAD_FAST i\n BINARY_OP *\n LOAD_FAST m\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L6\nL1:\n LOAD_CONST 0\n STORE_FAST total\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\nL2:\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP /=\n STORE_FAST n\n LOAD_FAST total\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST total\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n JUMP_BACKWARD L2\nL3:\n LOAD_CONST 0\n STORE_FAST temp\n LOAD_CONST 1\n STORE_FAST j\n LOAD_FAST temp\n LOAD_FAST j\n BINARY_OP +\n LOAD_FAST total\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L5\nL4:\n LOAD_FAST temp\n LOAD_FAST j\n BINARY_OP +=\n STORE_FAST temp\n LOAD_FAST count\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST count\n LOAD_FAST j\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST j\n LOAD_FAST temp\n LOAD_FAST j\n BINARY_OP +\n LOAD_FAST total\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L5\n JUMP_BACKWARD L4\nL5:\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST i\n LOAD_FAST i\n LOAD_FAST i\n BINARY_OP *\n LOAD_FAST m\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L6\n JUMP_BACKWARD L1\nL6:\n LOAD_FAST n\n LOAD_CONST 1\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L7\n LOAD_FAST count\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST count\nL7:\n LOAD_FAST count\n RETURN_VALUE\nEND", "expected": "def count_Fac(n):\n m = n\n count = 0\n i = 2\n while i * i <= m:\n total = 0\n while n % i == 0:\n n /= i\n total += 1\n temp = 0\n j = 1\n while temp + j <= total:\n temp += j\n count += 1\n j += 1\n i += 1\n if n != 1:\n count += 1\n return count", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 714, "mbpp_split": "train", "prompt": "Write a python function to count the number of distinct power of prime factor of given number.", "test_list": ["assert count_Fac(24) == 3", "assert count_Fac(12) == 2", "assert count_Fac(4) == 1"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_714", "n_instr": 101} {"i": 88, "src_path": "src/00088.py", "pyc_path": "pyc/00088.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME rombus_perimeter\n RETURN_CONST None\nEND\nCODE rombus_perimeter(a)\n RESUME 0\n LOAD_CONST 4\n LOAD_FAST a\n BINARY_OP *\n STORE_FAST perimeter\n LOAD_FAST perimeter\n RETURN_VALUE\nEND", "expected": "def rombus_perimeter(a):\n perimeter = 4 * a\n return perimeter", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 716, "mbpp_split": "train", "prompt": "Write a function to find the perimeter of a rombus.", "test_list": ["assert rombus_perimeter(10)==40", "assert rombus_perimeter(5)==20", "assert rombus_perimeter(4)==16"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_716", "n_instr": 15} {"i": 89, "src_path": "src/00089.py", "pyc_path": "pyc/00089.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME sys\n STORE_NAME sys\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sd_calc\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME avg_calc\n RETURN_CONST None\nEND\nCODE sd_calc(data)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST data\n CALL 1\n STORE_FAST n\n LOAD_FAST n\n LOAD_CONST 1\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 0.0\nL1:\n LOAD_GLOBAL NULL + avg_calc\n LOAD_FAST data\n CALL 1\n LOAD_CONST 0.0\n STORE_FAST sd\n STORE_FAST mean\n LOAD_FAST data\n GET_ITER\nL2:\n FOR_ITER L3\n STORE_FAST el\n LOAD_FAST sd\n LOAD_GLOBAL NULL + float\n LOAD_FAST el\n CALL 1\n LOAD_FAST mean\n BINARY_OP -\n LOAD_CONST 2\n BINARY_OP **\n BINARY_OP +=\n STORE_FAST sd\n JUMP_BACKWARD L2\nL3:\n END_FOR\n LOAD_GLOBAL NULL + math\n LOAD_ATTR sqrt\n LOAD_FAST sd\n LOAD_GLOBAL NULL + float\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n BINARY_OP /\n CALL 1\n STORE_FAST sd\n LOAD_FAST sd\n RETURN_VALUE\nEND\nCODE avg_calc(ls)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST ls\n CALL 1\n LOAD_CONST 0.0\n STORE_FAST mean\n STORE_FAST n\n LOAD_FAST n\n LOAD_CONST 1\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L1\n LOAD_FAST ls\n LOAD_CONST 0\n BINARY_SUBSCR\n RETURN_VALUE\nL1:\n LOAD_FAST ls\n GET_ITER\nL2:\n FOR_ITER L3\n STORE_FAST el\n LOAD_FAST mean\n LOAD_GLOBAL NULL + float\n LOAD_FAST el\n CALL 1\n BINARY_OP +\n STORE_FAST mean\n JUMP_BACKWARD L2\nL3:\n END_FOR\n LOAD_FAST mean\n LOAD_GLOBAL NULL + float\n LOAD_FAST n\n CALL 1\n BINARY_OP /\n STORE_FAST mean\n LOAD_FAST mean\n RETURN_VALUE\nEND", "expected": "import math\nimport sys\n\ndef sd_calc(data):\n n = len(data)\n if n <= 1:\n return 0.0\n mean, sd = (avg_calc(data), 0.0)\n for el in data:\n sd += (float(el) - mean) ** 2\n sd = math.sqrt(sd / float(n - 1))\n return sd\n\ndef avg_calc(ls):\n n, mean = (len(ls), 0.0)\n if n <= 1:\n return ls[0]\n for el in ls:\n mean = mean + float(el)\n mean = mean / float(n)\n return mean", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 717, "mbpp_split": "train", "prompt": "Write a function to calculate the standard deviation.", "test_list": ["assert sd_calc([4, 2, 5, 8, 6])== 2.23606797749979", "assert sd_calc([1,2,3,4,5,6,7])==2.160246899469287", "assert sd_calc([5,9,10,15,6,4])==4.070217029430577"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_717", "n_instr": 107} {"i": 90, "src_path": "src/00090.py", "pyc_path": "pyc/00090.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME alternate_elements\n RETURN_CONST None\nEND\nCODE alternate_elements(list1)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST result\n LOAD_FAST list1\n LOAD_CONST None\n LOAD_CONST None\n LOAD_CONST 2\n BUILD_SLICE 3\n BINARY_SUBSCR\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST item\n LOAD_FAST result\n LOAD_ATTR NULL|self + append\n LOAD_FAST item\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST result\n RETURN_VALUE\nEND", "expected": "def alternate_elements(list1):\n result = []\n for item in list1[::2]:\n result.append(item)\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 718, "mbpp_split": "train", "prompt": "Write a function to create a list taking alternate elements from another given list.", "test_list": ["assert alternate_elements([\"red\", \"black\", \"white\", \"green\", \"orange\"])==['red', 'white', 'orange']", "assert alternate_elements([2, 0, 3, 4, 0, 2, 8, 3, 4, 2])==[2, 3, 0, 8, 4]", "assert alternate_elements([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1,3,5,7,9]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_718", "n_instr": 31} {"i": 91, "src_path": "src/00091.py", "pyc_path": "pyc/00091.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME text_match\n RETURN_CONST None\nEND\nCODE text_match(text)\n RESUME 0\n LOAD_CONST 'ab*?'\n STORE_FAST patterns\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_FAST patterns\n LOAD_FAST text\n CALL 2\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Found a match!'\nL1:\n RETURN_CONST 'Not matched!'\nEND", "expected": "import re\n\ndef text_match(text):\n patterns = 'ab*?'\n if re.search(patterns, text):\n return 'Found a match!'\n else:\n return 'Not matched!'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 719, "mbpp_split": "train", "prompt": "Write a function that matches a string that has an a followed by zero or more b's.", "test_list": ["assert text_match(\"ac\")==('Found a match!')", "assert text_match(\"dc\")==('Not matched!')", "assert text_match(\"abba\")==('Found a match!')"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_719", "n_instr": 24} {"i": 92, "src_path": "src/00092.py", "pyc_path": "pyc/00092.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME add_dict_to_tuple\n RETURN_CONST None\nEND\nCODE add_dict_to_tuple(test_tup, test_dict)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_FAST test_tup\n CALL 1\n STORE_FAST test_tup\n LOAD_FAST test_tup\n LOAD_ATTR NULL|self + append\n LOAD_FAST test_dict\n CALL 1\n POP_TOP\n LOAD_GLOBAL NULL + tuple\n LOAD_FAST test_tup\n CALL 1\n STORE_FAST test_tup\n LOAD_FAST test_tup\n RETURN_VALUE\nEND", "expected": "def add_dict_to_tuple(test_tup, test_dict):\n test_tup = list(test_tup)\n test_tup.append(test_dict)\n test_tup = tuple(test_tup)\n return test_tup", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 720, "mbpp_split": "train", "prompt": "Write a function to add a dictionary to the tuple.", "test_list": ["assert add_dict_to_tuple((4, 5, 6), {\"MSAM\" : 1, \"is\" : 2, \"best\" : 3} ) == (4, 5, 6, {'MSAM': 1, 'is': 2, 'best': 3})", "assert add_dict_to_tuple((1, 2, 3), {\"UTS\" : 2, \"is\" : 3, \"Worst\" : 4} ) == (1, 2, 3, {'UTS': 2, 'is': 3, 'Worst': 4})", "assert add_dict_to_tuple((8, 9, 10), {\"POS\" : 3, \"is\" : 4, \"Okay\" : 5} ) == (8, 9, 10, {'POS': 3, 'is': 4, 'Okay': 5})"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_720", "n_instr": 24} {"i": 93, "src_path": "src/00093.py", "pyc_path": "pyc/00093.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('eq',)\n IMPORT_NAME operator\n IMPORT_FROM eq\n STORE_NAME eq\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_same_pair\n RETURN_CONST None\nEND\nCODE count_same_pair(nums1, nums2)\n RESUME 0\n LOAD_GLOBAL NULL + sum\n LOAD_GLOBAL NULL + map\n LOAD_GLOBAL eq\n LOAD_FAST nums1\n LOAD_FAST nums2\n CALL 3\n CALL 1\n STORE_FAST result\n LOAD_FAST result\n RETURN_VALUE\nEND", "expected": "from operator import eq\n\ndef count_same_pair(nums1, nums2):\n result = sum(map(eq, nums1, nums2))\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 723, "mbpp_split": "train", "prompt": "Write a function to count the same pair in two given lists using map function.", "test_list": ["assert count_same_pair([1, 2, 3, 4, 5, 6, 7, 8],[2, 2, 3, 1, 2, 6, 7, 9])==4", "assert count_same_pair([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8],[2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8])==11", "assert count_same_pair([2, 4, -6, -9, 11, -12, 14, -5, 17],[2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8])==1"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_723", "n_instr": 25} {"i": 94, "src_path": "src/00094.py", "pyc_path": "pyc/00094.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME multiply_elements\n RETURN_CONST None\nEND\nCODE multiply_elements(test_tup)\n RESUME 0\n LOAD_GLOBAL NULL + tuple\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_GLOBAL NULL + zip\n LOAD_FAST test_tup\n LOAD_FAST test_tup\n LOAD_CONST 1\n LOAD_CONST None\n BINARY_SLICE\n CALL 2\n GET_ITER\n CALL 0\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND\nCODE multiply_elements..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST i\n STORE_FAST j\n LOAD_FAST i\n LOAD_FAST j\n BINARY_OP *\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def multiply_elements(test_tup):\n res = tuple((i * j for i, j in zip(test_tup, test_tup[1:])))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 726, "mbpp_split": "train", "prompt": "Write a function to multiply the adjacent elements of the given tuple.", "test_list": ["assert multiply_elements((1, 5, 7, 8, 10)) == (5, 35, 56, 80)", "assert multiply_elements((2, 4, 5, 6, 7)) == (8, 20, 30, 42)", "assert multiply_elements((12, 13, 14, 9, 15)) == (156, 182, 126, 135)"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_726", "n_instr": 51} {"i": 95, "src_path": "src/00095.py", "pyc_path": "pyc/00095.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_list\n RETURN_CONST None\nEND\nCODE sum_list(lst1, lst2)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST lst1\n CALL 1\n CALL 1\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST lst1\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST lst2\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_OP +\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST res_list\n STORE_FAST i\n LOAD_FAST res_list\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=2 lasti=False\nEND", "expected": "def sum_list(lst1, lst2):\n res_list = [lst1[i] + lst2[i] for i in range(len(lst1))]\n return res_list", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 728, "mbpp_split": "train", "prompt": "Write a function to sum elements in two lists.", "test_list": ["assert sum_list([10,20,30],[15,25,35])==[25,45,65]", "assert sum_list([1,2,3],[5,6,7])==[6,8,10]", "assert sum_list([15,20,30],[15,45,75])==[30,65,105]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_728", "n_instr": 46} {"i": 96, "src_path": "src/00096.py", "pyc_path": "pyc/00096.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME add_list\n RETURN_CONST None\nEND\nCODE add_list(nums1, nums2)\n RESUME 0\n LOAD_GLOBAL NULL + map\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST nums1\n LOAD_FAST nums2\n CALL 3\n STORE_FAST result\n LOAD_GLOBAL NULL + list\n LOAD_FAST result\n CALL 1\n RETURN_VALUE\nEND\nCODE add_list..(x, y)\n RESUME 0\n LOAD_FAST x\n LOAD_FAST y\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def add_list(nums1, nums2):\n result = map(lambda x, y: x + y, nums1, nums2)\n return list(result)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 729, "mbpp_split": "train", "prompt": "Write a function to add two lists using map and lambda function.", "test_list": ["assert add_list([1, 2, 3],[4,5,6])==[5, 7, 9]", "assert add_list([1,2],[3,4])==[4,6]", "assert add_list([10,20],[50,70])==[60,90]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_729", "n_instr": 27} {"i": 97, "src_path": "src/00097.py", "pyc_path": "pyc/00097.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('groupby',)\n IMPORT_NAME itertools\n IMPORT_FROM groupby\n STORE_NAME groupby\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME consecutive_duplicates\n RETURN_CONST None\nEND\nCODE consecutive_duplicates(nums)\n RESUME 0\n LOAD_GLOBAL NULL + groupby\n LOAD_FAST nums\n CALL 1\n GET_ITER\n LOAD_FAST_AND_CLEAR key\n LOAD_FAST_AND_CLEAR group\n SWAP 3\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST key\n STORE_FAST group\n LOAD_FAST key\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n SWAP 3\n STORE_FAST group\n STORE_FAST key\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 3\n STORE_FAST group\n STORE_FAST key\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=3 lasti=False\nEND", "expected": "from itertools import groupby\n\ndef consecutive_duplicates(nums):\n return [key for key, group in groupby(nums)]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 730, "mbpp_split": "train", "prompt": "Write a function to remove consecutive duplicates of a given list.", "test_list": ["assert consecutive_duplicates([0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4 ])==[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4]", "assert consecutive_duplicates([10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10])==[10, 15, 19, 18, 17, 26, 17, 18, 10]", "assert consecutive_duplicates(['a', 'a', 'b', 'c', 'd', 'd'])==['a', 'b', 'c', 'd']"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_730", "n_instr": 48} {"i": 98, "src_path": "src/00098.py", "pyc_path": "pyc/00098.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME lateralsurface_cone\n RETURN_CONST None\nEND\nCODE lateralsurface_cone(r, h)\n RESUME 0\n LOAD_GLOBAL NULL + math\n LOAD_ATTR sqrt\n LOAD_FAST r\n LOAD_FAST r\n BINARY_OP *\n LOAD_FAST h\n LOAD_FAST h\n BINARY_OP *\n BINARY_OP +\n CALL 1\n STORE_FAST l\n LOAD_GLOBAL math\n LOAD_ATTR pi\n LOAD_FAST r\n BINARY_OP *\n LOAD_FAST l\n BINARY_OP *\n STORE_FAST LSA\n LOAD_FAST LSA\n RETURN_VALUE\nEND", "expected": "import math\n\ndef lateralsurface_cone(r, h):\n l = math.sqrt(r * r + h * h)\n LSA = math.pi * r * l\n return LSA", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 731, "mbpp_split": "train", "prompt": "Write a function to find the lateral surface area of a cone.", "test_list": ["assert lateralsurface_cone(5,12)==204.20352248333654", "assert lateralsurface_cone(10,15)==566.3586699569488", "assert lateralsurface_cone(19,17)==1521.8090132193388"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_731", "n_instr": 33} {"i": 99, "src_path": "src/00099.py", "pyc_path": "pyc/00099.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_first_occurrence\n RETURN_CONST None\nEND\nCODE find_first_occurrence(A, x)\n RESUME 0\n LOAD_CONST 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST A\n CALL 1\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST right\n STORE_FAST left\n LOAD_CONST -1\n STORE_FAST result\n LOAD_FAST left\n LOAD_FAST right\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L5\nL1:\n LOAD_FAST left\n LOAD_FAST right\n BINARY_OP +\n LOAD_CONST 2\n BINARY_OP //\n STORE_FAST mid\n LOAD_FAST x\n LOAD_FAST A\n LOAD_FAST mid\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_FAST mid\n STORE_FAST result\n LOAD_FAST mid\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST right\n JUMP_FORWARD L4\nL2:\n LOAD_FAST x\n LOAD_FAST A\n LOAD_FAST mid\n BINARY_SUBSCR\n COMPARE_OP <\n POP_JUMP_IF_FALSE L3\n LOAD_FAST mid\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST right\n JUMP_FORWARD L4\nL3:\n LOAD_FAST mid\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST left\nL4:\n LOAD_FAST left\n LOAD_FAST right\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L5\n JUMP_BACKWARD L1\nL5:\n LOAD_FAST result\n RETURN_VALUE\nEND", "expected": "def find_first_occurrence(A, x):\n left, right = (0, len(A) - 1)\n result = -1\n while left <= right:\n mid = (left + right) // 2\n if x == A[mid]:\n result = mid\n right = mid - 1\n elif x < A[mid]:\n right = mid - 1\n else:\n left = mid + 1\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 733, "mbpp_split": "train", "prompt": "Write a function to find the index of the first occurrence of a given number in a sorted array.", "test_list": ["assert find_first_occurrence([2, 5, 5, 5, 6, 6, 8, 9, 9, 9], 5) == 1", "assert find_first_occurrence([2, 3, 5, 5, 6, 6, 8, 9, 9, 9], 5) == 2", "assert find_first_occurrence([2, 4, 1, 5, 6, 6, 8, 9, 9, 9], 6) == 4"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_733", "n_instr": 69} {"i": 100, "src_path": "src/00100.py", "pyc_path": "pyc/00100.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_Of_Subarray_Prod\n RETURN_CONST None\nEND\nCODE sum_Of_Subarray_Prod(arr, n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST ans\n LOAD_CONST 0\n STORE_FAST res\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST i\n LOAD_FAST i\n LOAD_CONST 0\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST 1\n LOAD_FAST res\n BINARY_OP +\n BINARY_OP *\n STORE_FAST incr\n LOAD_FAST ans\n LOAD_FAST incr\n BINARY_OP +=\n STORE_FAST ans\n LOAD_FAST incr\n STORE_FAST res\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP -=\n STORE_FAST i\n LOAD_FAST i\n LOAD_CONST 0\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST ans\n RETURN_VALUE\nEND", "expected": "def sum_Of_Subarray_Prod(arr, n):\n ans = 0\n res = 0\n i = n - 1\n while i >= 0:\n incr = arr[i] * (1 + res)\n ans += incr\n res = incr\n i -= 1\n return ans", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 734, "mbpp_split": "train", "prompt": "Write a python function to find sum of products of all possible subarrays.", "test_list": ["assert sum_Of_Subarray_Prod([1,2,3],3) == 20", "assert sum_Of_Subarray_Prod([1,2],2) == 5", "assert sum_Of_Subarray_Prod([1,2,3,4],4) == 84"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_734", "n_instr": 48} {"i": 101, "src_path": "src/00101.py", "pyc_path": "pyc/00101.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME set_middle_bits\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME toggle_middle_bits\n RETURN_CONST None\nEND\nCODE set_middle_bits(n)\n RESUME 0\n LOAD_FAST n\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP >>\n BINARY_OP |=\n STORE_FAST n\n LOAD_FAST n\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP >>\n BINARY_OP |=\n STORE_FAST n\n LOAD_FAST n\n LOAD_FAST n\n LOAD_CONST 4\n BINARY_OP >>\n BINARY_OP |=\n STORE_FAST n\n LOAD_FAST n\n LOAD_FAST n\n LOAD_CONST 8\n BINARY_OP >>\n BINARY_OP |=\n STORE_FAST n\n LOAD_FAST n\n LOAD_FAST n\n LOAD_CONST 16\n BINARY_OP >>\n BINARY_OP |=\n STORE_FAST n\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP >>\n LOAD_CONST 1\n BINARY_OP ^\n RETURN_VALUE\nEND\nCODE toggle_middle_bits(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 1\nL1:\n LOAD_FAST n\n LOAD_GLOBAL NULL + set_middle_bits\n LOAD_FAST n\n CALL 1\n BINARY_OP ^\n RETURN_VALUE\nEND", "expected": "def set_middle_bits(n):\n n |= n >> 1\n n |= n >> 2\n n |= n >> 4\n n |= n >> 8\n n |= n >> 16\n return n >> 1 ^ 1\n\ndef toggle_middle_bits(n):\n if n == 1:\n return 1\n return n ^ set_middle_bits(n)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 735, "mbpp_split": "train", "prompt": "Write a python function to toggle bits of the number except the first and the last bit.", "test_list": ["assert toggle_middle_bits(9) == 15", "assert toggle_middle_bits(10) == 12", "assert toggle_middle_bits(11) == 13"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_735", "n_instr": 63} {"i": 102, "src_path": "src/00102.py", "pyc_path": "pyc/00102.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME bisect\n STORE_NAME bisect\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME left_insertion\n RETURN_CONST None\nEND\nCODE left_insertion(a, x)\n RESUME 0\n LOAD_GLOBAL NULL + bisect\n LOAD_ATTR bisect_left\n LOAD_FAST a\n LOAD_FAST x\n CALL 2\n STORE_FAST i\n LOAD_FAST i\n RETURN_VALUE\nEND", "expected": "import bisect\n\ndef left_insertion(a, x):\n i = bisect.bisect_left(a, x)\n return i", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 736, "mbpp_split": "train", "prompt": "Write a function to locate the left insertion point for a specified value in sorted order.", "test_list": ["assert left_insertion([1,2,4,5],6)==4", "assert left_insertion([1,2,4,5],3)==2", "assert left_insertion([1,2,4,5],7)==4"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_736", "n_instr": 21} {"i": 103, "src_path": "src/00103.py", "pyc_path": "pyc/00103.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST '^[aeiouAEIOU][A-Za-z0-9_]*'\n STORE_NAME regex\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_str\n RETURN_CONST None\nEND\nCODE check_str(string)\n RESUME 0\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_GLOBAL regex\n LOAD_FAST string\n CALL 2\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Valid'\nL1:\n RETURN_CONST 'Invalid'\nEND", "expected": "import re\nregex = '^[aeiouAEIOU][A-Za-z0-9_]*'\n\ndef check_str(string):\n if re.search(regex, string):\n return 'Valid'\n else:\n return 'Invalid'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 737, "mbpp_split": "train", "prompt": "Write a function to check whether the given string is starting with a vowel or not using regex.", "test_list": ["assert check_str(\"annie\") == 'Valid'", "assert check_str(\"dawood\") == 'Invalid'", "assert check_str(\"Else\") == 'Valid'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_737", "n_instr": 24} {"i": 104, "src_path": "src/00104.py", "pyc_path": "pyc/00104.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME geometric_sum\n RETURN_CONST None\nEND\nCODE geometric_sum(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 0\n COMPARE_OP <\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 0\nL1:\n LOAD_CONST 1\n LOAD_GLOBAL NULL + pow\n LOAD_CONST 2\n LOAD_FAST n\n CALL 2\n BINARY_OP /\n LOAD_GLOBAL NULL + geometric_sum\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def geometric_sum(n):\n if n < 0:\n return 0\n else:\n return 1 / pow(2, n) + geometric_sum(n - 1)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 738, "mbpp_split": "train", "prompt": "Write a function to calculate the geometric sum of n-1.", "test_list": ["assert geometric_sum(7) == 1.9921875", "assert geometric_sum(4) == 1.9375", "assert geometric_sum(8) == 1.99609375"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_738", "n_instr": 28} {"i": 105, "src_path": "src/00105.py", "pyc_path": "pyc/00105.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_Index\n RETURN_CONST None\nEND\nCODE find_Index(n)\n RESUME 0\n LOAD_GLOBAL NULL + math\n LOAD_ATTR sqrt\n LOAD_CONST 2\n LOAD_GLOBAL NULL + math\n LOAD_ATTR pow\n LOAD_CONST 10\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n CALL 2\n BINARY_OP *\n CALL 1\n STORE_FAST x\n LOAD_GLOBAL NULL + round\n LOAD_FAST x\n CALL 1\n RETURN_VALUE\nEND", "expected": "import math\n\ndef find_Index(n):\n x = math.sqrt(2 * math.pow(10, n - 1))\n return round(x)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 739, "mbpp_split": "train", "prompt": "Write a python function to find the index of smallest triangular number with n digits.", "test_list": ["assert find_Index(2) == 4", "assert find_Index(3) == 14", "assert find_Index(4) == 45"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_739", "n_instr": 30} {"i": 106, "src_path": "src/00106.py", "pyc_path": "pyc/00106.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME tuple_to_dict\n RETURN_CONST None\nEND\nCODE tuple_to_dict(test_tup)\n MAKE_CELL test_tup\n RESUME 0\n LOAD_GLOBAL NULL + dict\n LOAD_CLOSURE test_tup\n BUILD_TUPLE 1\n LOAD_CONST .>\n MAKE_FUNCTION closure\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_GLOBAL NULL + len\n LOAD_DEREF test_tup\n CALL 1\n LOAD_CONST 2\n CALL 3\n GET_ITER\n CALL 0\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND\nCODE tuple_to_dict..(.0)\n COPY_FREE_VARS 1\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n STORE_FAST idx\n LOAD_DEREF test_tup\n LOAD_FAST idx\n LOAD_FAST idx\n LOAD_CONST 2\n BINARY_OP +\n BINARY_SLICE\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def tuple_to_dict(test_tup):\n res = dict((test_tup[idx:idx + 2] for idx in range(0, len(test_tup), 2)))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 740, "mbpp_split": "train", "prompt": "Write a function to convert the given tuple to a key-value dictionary using adjacent elements.", "test_list": ["assert tuple_to_dict((1, 5, 7, 10, 13, 5)) == {1: 5, 7: 10, 13: 5}", "assert tuple_to_dict((1, 2, 3, 4, 5, 6)) == {1: 2, 3: 4, 5: 6}", "assert tuple_to_dict((7, 8, 9, 10, 11, 12)) == {7: 8, 9: 10, 11: 12}"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_740", "n_instr": 56} {"i": 107, "src_path": "src/00107.py", "pyc_path": "pyc/00107.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME all_Characters_Same\n RETURN_CONST None\nEND\nCODE all_Characters_Same(s)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST s\n CALL 1\n STORE_FAST n\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST n\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST s\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST s\n LOAD_CONST 0\n BINARY_SUBSCR\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n POP_TOP\n RETURN_CONST False\nL3:\n END_FOR\n RETURN_CONST True\nEND", "expected": "def all_Characters_Same(s):\n n = len(s)\n for i in range(1, n):\n if s[i] != s[0]:\n return False\n return True", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 741, "mbpp_split": "train", "prompt": "Write a python function to check whether all the characters are same or not.", "test_list": ["assert all_Characters_Same(\"python\") == False", "assert all_Characters_Same(\"aaa\") == True", "assert all_Characters_Same(\"data\") == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_741", "n_instr": 36} {"i": 108, "src_path": "src/00108.py", "pyc_path": "pyc/00108.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME area_tetrahedron\n RETURN_CONST None\nEND\nCODE area_tetrahedron(side)\n RESUME 0\n LOAD_GLOBAL NULL + math\n LOAD_ATTR sqrt\n LOAD_CONST 3\n CALL 1\n LOAD_FAST side\n LOAD_FAST side\n BINARY_OP *\n BINARY_OP *\n STORE_FAST area\n LOAD_FAST area\n RETURN_VALUE\nEND", "expected": "import math\n\ndef area_tetrahedron(side):\n area = math.sqrt(3) * (side * side)\n return area", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 742, "mbpp_split": "train", "prompt": "Write a function to caluclate the area of a tetrahedron.", "test_list": ["assert area_tetrahedron(3)==15.588457268119894", "assert area_tetrahedron(20)==692.8203230275509", "assert area_tetrahedron(10)==173.20508075688772"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_742", "n_instr": 24} {"i": 109, "src_path": "src/00109.py", "pyc_path": "pyc/00109.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_none\n RETURN_CONST None\nEND\nCODE check_none(test_tup)\n RESUME 0\n LOAD_GLOBAL NULL + any\n LOAD_GLOBAL NULL + map\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST test_tup\n CALL 2\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND\nCODE check_none..(ele)\n RESUME 0\n LOAD_FAST ele\n LOAD_CONST None\n IS_OP 0\n RETURN_VALUE\nEND", "expected": "def check_none(test_tup):\n res = any(map(lambda ele: ele is None, test_tup))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 744, "mbpp_split": "train", "prompt": "Write a function to check if the given tuple has any none value or not.", "test_list": ["assert check_none((10, 4, 5, 6, None)) == True", "assert check_none((7, 8, 9, 11, 14)) == False", "assert check_none((1, 2, 3, 4, None)) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_744", "n_instr": 26} {"i": 110, "src_path": "src/00110.py", "pyc_path": "pyc/00110.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sector_area\n RETURN_CONST None\nEND\nCODE sector_area(r, a)\n RESUME 0\n LOAD_CONST 3.142857142857143\n STORE_FAST pi\n LOAD_FAST a\n LOAD_CONST 360\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L1\n RETURN_CONST None\nL1:\n LOAD_FAST pi\n LOAD_FAST r\n LOAD_CONST 2\n BINARY_OP **\n BINARY_OP *\n LOAD_FAST a\n LOAD_CONST 360\n BINARY_OP /\n BINARY_OP *\n STORE_FAST sectorarea\n LOAD_FAST sectorarea\n RETURN_VALUE\nEND", "expected": "def sector_area(r, a):\n pi = 22 / 7\n if a >= 360:\n return None\n sectorarea = pi * r ** 2 * (a / 360)\n return sectorarea", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 746, "mbpp_split": "train", "prompt": "Write a function to find area of a sector.", "test_list": ["assert sector_area(4,45)==6.285714285714286", "assert sector_area(9,45)==31.82142857142857", "assert sector_area(9,360)==None"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_746", "n_instr": 29} {"i": 111, "src_path": "src/00111.py", "pyc_path": "pyc/00111.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sort_numeric_strings\n RETURN_CONST None\nEND\nCODE sort_numeric_strings(nums_str)\n RESUME 0\n LOAD_FAST nums_str\n GET_ITER\n LOAD_FAST_AND_CLEAR x\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST x\n LOAD_GLOBAL NULL + int\n LOAD_FAST x\n CALL 1\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST result\n STORE_FAST x\n LOAD_FAST result\n LOAD_ATTR NULL|self + sort\n CALL 0\n POP_TOP\n LOAD_FAST result\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST x\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=2 lasti=False\nEND", "expected": "def sort_numeric_strings(nums_str):\n result = [int(x) for x in nums_str]\n result.sort()\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 749, "mbpp_split": "train", "prompt": "Write a function to sort a given list of strings of numbers numerically.", "test_list": ["assert sort_numeric_strings( ['4','12','45','7','0','100','200','-12','-500'])==[-500, -12, 0, 4, 7, 12, 45, 100, 200]", "assert sort_numeric_strings(['2','3','8','4','7','9','8','2','6','5','1','6','1','2','3','4','6','9','1','2'])==[1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 8, 9, 9]", "assert sort_numeric_strings(['1','3','5','7','1', '3','13', '15', '17','5', '7 ','9','1', '11'])==[1, 1, 1, 3, 3, 5, 5, 7, 7, 9, 11, 13, 15, 17]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_749", "n_instr": 42} {"i": 112, "src_path": "src/00112.py", "pyc_path": "pyc/00112.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_min_heap\n RETURN_CONST None\nEND\nCODE check_min_heap(arr, i)\n RESUME 0\n LOAD_CONST 2\n LOAD_FAST i\n BINARY_OP *\n LOAD_CONST 2\n BINARY_OP +\n LOAD_GLOBAL NULL + len\n LOAD_FAST arr\n CALL 1\n COMPARE_OP >\n POP_JUMP_IF_FALSE L1\n RETURN_CONST True\nL1:\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_CONST 2\n LOAD_FAST i\n BINARY_OP *\n LOAD_CONST 1\n BINARY_OP +\n BINARY_SUBSCR\n COMPARE_OP <=\n COPY 1\n POP_JUMP_IF_FALSE L2\n POP_TOP\n LOAD_GLOBAL NULL + check_min_heap\n LOAD_FAST arr\n LOAD_CONST 2\n LOAD_FAST i\n BINARY_OP *\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\nL2:\n STORE_FAST left_child\n LOAD_CONST 2\n LOAD_FAST i\n BINARY_OP *\n LOAD_CONST 2\n BINARY_OP +\n LOAD_GLOBAL NULL + len\n LOAD_FAST arr\n CALL 1\n COMPARE_OP ==\n COPY 1\n POP_JUMP_IF_TRUE L3\n POP_TOP\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_CONST 2\n LOAD_FAST i\n BINARY_OP *\n LOAD_CONST 2\n BINARY_OP +\n BINARY_SUBSCR\n COMPARE_OP <=\n COPY 1\n POP_JUMP_IF_FALSE L3\n POP_TOP\n LOAD_GLOBAL NULL + check_min_heap\n LOAD_FAST arr\n LOAD_CONST 2\n LOAD_FAST i\n BINARY_OP *\n LOAD_CONST 2\n BINARY_OP +\n CALL 2\nL3:\n STORE_FAST right_child\n LOAD_FAST left_child\n COPY 1\n POP_JUMP_IF_FALSE L4\n POP_TOP\n LOAD_FAST right_child\nL4:\n RETURN_VALUE\nEND", "expected": "def check_min_heap(arr, i):\n if 2 * i + 2 > len(arr):\n return True\n left_child = arr[i] <= arr[2 * i + 1] and check_min_heap(arr, 2 * i + 1)\n right_child = 2 * i + 2 == len(arr) or (arr[i] <= arr[2 * i + 2] and check_min_heap(arr, 2 * i + 2))\n return left_child and right_child", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 751, "mbpp_split": "train", "prompt": "Write a function to check if the given array represents min heap or not.", "test_list": ["assert check_min_heap([1, 2, 3, 4, 5, 6], 0) == True", "assert check_min_heap([2, 3, 4, 5, 10, 15], 0) == True", "assert check_min_heap([2, 10, 4, 5, 3, 15], 0) == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_751", "n_instr": 88} {"i": 113, "src_path": "src/00113.py", "pyc_path": "pyc/00113.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME jacobsthal_num\n RETURN_CONST None\nEND\nCODE jacobsthal_num(n)\n RESUME 0\n LOAD_CONST 0\n BUILD_LIST 1\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP *\n STORE_FAST dp\n LOAD_CONST 0\n LOAD_FAST dp\n LOAD_CONST 0\n STORE_SUBSCR\n LOAD_CONST 1\n LOAD_FAST dp\n LOAD_CONST 1\n STORE_SUBSCR\n LOAD_GLOBAL NULL + range\n LOAD_CONST 2\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST dp\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n LOAD_CONST 2\n LOAD_FAST dp\n LOAD_FAST i\n LOAD_CONST 2\n BINARY_OP -\n BINARY_SUBSCR\n BINARY_OP *\n BINARY_OP +\n LOAD_FAST dp\n LOAD_FAST i\n STORE_SUBSCR\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST dp\n LOAD_FAST n\n BINARY_SUBSCR\n RETURN_VALUE\nEND", "expected": "def jacobsthal_num(n):\n dp = [0] * (n + 1)\n dp[0] = 0\n dp[1] = 1\n for i in range(2, n + 1):\n dp[i] = dp[i - 1] + 2 * dp[i - 2]\n return dp[n]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 752, "mbpp_split": "train", "prompt": "Write a function to find the nth jacobsthal number.", "test_list": ["assert jacobsthal_num(5) == 11", "assert jacobsthal_num(2) == 1", "assert jacobsthal_num(4) == 5"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_752", "n_instr": 57} {"i": 114, "src_path": "src/00114.py", "pyc_path": "pyc/00114.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME extract_index_list\n RETURN_CONST None\nEND\nCODE extract_index_list(l1, l2, l3)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST result\n LOAD_GLOBAL NULL + zip\n LOAD_FAST l1\n LOAD_FAST l2\n LOAD_FAST l3\n CALL 3\n GET_ITER\nL1:\n FOR_ITER L5\n UNPACK_SEQUENCE 3\n STORE_FAST m\n STORE_FAST n\n STORE_FAST o\n LOAD_FAST m\n LOAD_FAST n\n SWAP 2\n COPY 2\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n LOAD_FAST o\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n JUMP_FORWARD L4\nL3:\n POP_TOP\n JUMP_BACKWARD L1\nL4:\n LOAD_FAST result\n LOAD_ATTR NULL|self + append\n LOAD_FAST m\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL5:\n END_FOR\n LOAD_FAST result\n RETURN_VALUE\nEND", "expected": "def extract_index_list(l1, l2, l3):\n result = []\n for m, n, o in zip(l1, l2, l3):\n if m == n == o:\n result.append(m)\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 754, "mbpp_split": "train", "prompt": "Write a function to find common index elements from three lists.", "test_list": ["assert extract_index_list([1, 1, 3, 4, 5, 6, 7],[0, 1, 2, 3, 4, 5, 7],[0, 1, 2, 3, 4, 5, 7])==[1, 7]", "assert extract_index_list([1, 1, 3, 4, 5, 6, 7],[0, 1, 2, 3, 4, 6, 5],[0, 1, 2, 3, 4, 6, 7])==[1, 6]", "assert extract_index_list([1, 1, 3, 4, 6, 5, 6],[0, 1, 2, 3, 4, 5, 7],[0, 1, 2, 3, 4, 5, 7])==[1, 5]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_754", "n_instr": 49} {"i": 115, "src_path": "src/00115.py", "pyc_path": "pyc/00115.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME second_smallest\n RETURN_CONST None\nEND\nCODE second_smallest(numbers)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST numbers\n CALL 1\n LOAD_CONST 2\n COMPARE_OP <\n POP_JUMP_IF_FALSE L1\n RETURN_CONST None\nL1:\n LOAD_GLOBAL NULL + len\n LOAD_FAST numbers\n CALL 1\n LOAD_CONST 2\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_FAST numbers\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST numbers\n LOAD_CONST 1\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n RETURN_CONST None\nL2:\n LOAD_GLOBAL NULL + set\n CALL 0\n STORE_FAST dup_items\n BUILD_LIST 0\n STORE_FAST uniq_items\n LOAD_FAST numbers\n GET_ITER\nL3:\n FOR_ITER L5\n STORE_FAST x\n LOAD_FAST x\n LOAD_FAST dup_items\n CONTAINS_OP 1\n POP_JUMP_IF_TRUE L4\n JUMP_BACKWARD L3\nL4:\n LOAD_FAST uniq_items\n LOAD_ATTR NULL|self + append\n LOAD_FAST x\n CALL 1\n POP_TOP\n LOAD_FAST dup_items\n LOAD_ATTR NULL|self + add\n LOAD_FAST x\n CALL 1\n POP_TOP\n JUMP_BACKWARD L3\nL5:\n END_FOR\n LOAD_FAST uniq_items\n LOAD_ATTR NULL|self + sort\n CALL 0\n POP_TOP\n LOAD_FAST uniq_items\n LOAD_CONST 1\n BINARY_SUBSCR\n RETURN_VALUE\nEND", "expected": "def second_smallest(numbers):\n if len(numbers) < 2:\n return\n if len(numbers) == 2 and numbers[0] == numbers[1]:\n return\n dup_items = set()\n uniq_items = []\n for x in numbers:\n if x not in dup_items:\n uniq_items.append(x)\n dup_items.add(x)\n uniq_items.sort()\n return uniq_items[1]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 755, "mbpp_split": "train", "prompt": "Write a function to find the second smallest number in a list.", "test_list": ["assert second_smallest([1, 2, -8, -2, 0, -2])==-2", "assert second_smallest([1, 1, -0.5, 0, 2, -2, -2])==-0.5", "assert second_smallest([2,2])==None"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_755", "n_instr": 70} {"i": 116, "src_path": "src/00116.py", "pyc_path": "pyc/00116.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME text_match_zero_one\n RETURN_CONST None\nEND\nCODE text_match_zero_one(text)\n RESUME 0\n LOAD_CONST 'ab?'\n STORE_FAST patterns\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_FAST patterns\n LOAD_FAST text\n CALL 2\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Found a match!'\nL1:\n RETURN_CONST 'Not matched!'\nEND", "expected": "import re\n\ndef text_match_zero_one(text):\n patterns = 'ab?'\n if re.search(patterns, text):\n return 'Found a match!'\n else:\n return 'Not matched!'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 756, "mbpp_split": "train", "prompt": "Write a function that matches a string that has an a followed by zero or one 'b'.", "test_list": ["assert text_match_zero_one(\"ac\")==('Found a match!')", "assert text_match_zero_one(\"dc\")==('Not matched!')", "assert text_match_zero_one(\"abbbba\")==('Found a match!')"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_756", "n_instr": 24} {"i": 117, "src_path": "src/00117.py", "pyc_path": "pyc/00117.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_reverse_pairs\n RETURN_CONST None\nEND\nCODE count_reverse_pairs(test_list)\n RESUME 0\n LOAD_GLOBAL NULL + sum\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST test_list\n CALL 1\n CALL 2\n GET_ITER\n LOAD_FAST_AND_CLEAR idx\n LOAD_FAST_AND_CLEAR idxn\n SWAP 3\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L7\n STORE_FAST idx\n LOAD_GLOBAL NULL + range\n LOAD_FAST idx\n LOAD_GLOBAL NULL + len\n LOAD_FAST test_list\n CALL 1\n CALL 2\n GET_ITER\nL3:\n FOR_ITER L6\n STORE_FAST idxn\n LOAD_FAST test_list\n LOAD_FAST idxn\n BINARY_SUBSCR\n LOAD_GLOBAL NULL + str\n LOAD_CONST ''\n LOAD_ATTR NULL|self + join\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + reversed\n LOAD_FAST test_list\n LOAD_FAST idx\n BINARY_SUBSCR\n CALL 1\n CALL 1\n CALL 1\n CALL 1\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L5\nL4:\n JUMP_BACKWARD L3\nL5:\n LOAD_CONST 1\n LIST_APPEND 3\n JUMP_BACKWARD L3\nL6:\n END_FOR\n JUMP_BACKWARD L2\nL7:\n END_FOR\nL8:\n SWAP 3\n STORE_FAST idxn\n STORE_FAST idx\n CALL 1\n STORE_FAST res\n LOAD_GLOBAL NULL + str\n LOAD_FAST res\n CALL 1\n RETURN_VALUE\nL9:\n SWAP 2\n POP_TOP\n SWAP 3\n STORE_FAST idxn\n STORE_FAST idx\n RERAISE 0\n EXC try=L1..L4 -> handler=L9 depth=5 lasti=False\n EXC try=L5..L8 -> handler=L9 depth=5 lasti=False\nEND", "expected": "def count_reverse_pairs(test_list):\n res = sum([1 for idx in range(0, len(test_list)) for idxn in range(idx, len(test_list)) if test_list[idxn] == str(''.join(list(reversed(test_list[idx]))))])\n return str(res)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 757, "mbpp_split": "train", "prompt": "Write a function to count the pairs of reverse strings in the given string list.", "test_list": ["assert count_reverse_pairs([\"julia\", \"best\", \"tseb\", \"for\", \"ailuj\"])== '2'", "assert count_reverse_pairs([\"geeks\", \"best\", \"for\", \"skeeg\"]) == '1'", "assert count_reverse_pairs([\"makes\", \"best\", \"sekam\", \"for\", \"rof\"]) == '2' "], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_757", "n_instr": 83} {"i": 118, "src_path": "src/00118.py", "pyc_path": "pyc/00118.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME unique_sublists\n RETURN_CONST None\nEND\nCODE unique_sublists(list1)\n RESUME 0\n BUILD_MAP 0\n STORE_FAST result\n LOAD_FAST list1\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST l\n LOAD_FAST result\n LOAD_ATTR NULL|self + setdefault\n LOAD_GLOBAL NULL + tuple\n LOAD_FAST l\n CALL 1\n LOAD_GLOBAL NULL + list\n CALL 0\n CALL 2\n LOAD_ATTR NULL|self + append\n LOAD_CONST 1\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST result\n LOAD_ATTR NULL|self + items\n CALL 0\n GET_ITER\nL3:\n FOR_ITER L4\n UNPACK_SEQUENCE 2\n STORE_FAST a\n STORE_FAST b\n LOAD_GLOBAL NULL + sum\n LOAD_FAST b\n CALL 1\n LOAD_FAST result\n LOAD_FAST a\n STORE_SUBSCR\n JUMP_BACKWARD L3\nL4:\n END_FOR\n LOAD_FAST result\n RETURN_VALUE\nEND", "expected": "def unique_sublists(list1):\n result = {}\n for l in list1:\n result.setdefault(tuple(l), list()).append(1)\n for a, b in result.items():\n result[a] = sum(b)\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 758, "mbpp_split": "train", "prompt": "Write a function to count number of unique lists within a list.", "test_list": ["assert unique_sublists([[1, 3], [5, 7], [1, 3], [13, 15, 17], [5, 7], [9, 11]] )=={(1, 3): 2, (5, 7): 2, (13, 15, 17): 1, (9, 11): 1}", "assert unique_sublists([['green', 'orange'], ['black'], ['green', 'orange'], ['white']])=={('green', 'orange'): 2, ('black',): 1, ('white',): 1}", "assert unique_sublists([[10, 20, 30, 40], [60, 70, 50, 50], [90, 100, 200]])=={(10, 20, 30, 40): 1, (60, 70, 50, 50): 1, (90, 100, 200): 1}"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_758", "n_instr": 51} {"i": 119, "src_path": "src/00119.py", "pyc_path": "pyc/00119.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_decimal\n RETURN_CONST None\nEND\nCODE is_decimal(num)\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_FAST re\n LOAD_FAST re\n LOAD_ATTR NULL|self + compile\n LOAD_CONST '^[0-9]+(\\\\.[0-9]{1,2})?$'\n CALL 1\n STORE_FAST dnumre\n LOAD_FAST dnumre\n LOAD_ATTR NULL|self + search\n LOAD_FAST num\n CALL 1\n STORE_FAST result\n LOAD_GLOBAL NULL + bool\n LOAD_FAST result\n CALL 1\n RETURN_VALUE\nEND", "expected": "def is_decimal(num):\n import re\n dnumre = re.compile('^[0-9]+(\\\\.[0-9]{1,2})?$')\n result = dnumre.search(num)\n return bool(result)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 759, "mbpp_split": "train", "prompt": "Write a function to check a decimal with a precision of 2.", "test_list": ["assert is_decimal('123.11')==True", "assert is_decimal('e666.86')==False", "assert is_decimal('3.124587')==False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_759", "n_instr": 27} {"i": 120, "src_path": "src/00120.py", "pyc_path": "pyc/00120.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME unique_Element\n RETURN_CONST None\nEND\nCODE unique_Element(arr, n)\n RESUME 0\n LOAD_GLOBAL NULL + set\n LOAD_FAST arr\n CALL 1\n STORE_FAST s\n LOAD_GLOBAL NULL + len\n LOAD_FAST s\n CALL 1\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'YES'\nL1:\n RETURN_CONST 'NO'\nEND", "expected": "def unique_Element(arr, n):\n s = set(arr)\n if len(s) == 1:\n return 'YES'\n else:\n return 'NO'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 760, "mbpp_split": "train", "prompt": "Write a python function to check whether an array contains only one distinct element or not.", "test_list": ["assert unique_Element([1,1,1],3) == 'YES'", "assert unique_Element([1,2,1,2],4) == 'NO'", "assert unique_Element([1,2,3,4,5],5) == 'NO'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_760", "n_instr": 22} {"i": 121, "src_path": "src/00121.py", "pyc_path": "pyc/00121.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME arc_length\n RETURN_CONST None\nEND\nCODE arc_length(d, a)\n RESUME 0\n LOAD_CONST 3.142857142857143\n STORE_FAST pi\n LOAD_FAST a\n LOAD_CONST 360\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L1\n RETURN_CONST None\nL1:\n LOAD_FAST pi\n LOAD_FAST d\n BINARY_OP *\n LOAD_FAST a\n LOAD_CONST 360\n BINARY_OP /\n BINARY_OP *\n STORE_FAST arclength\n LOAD_FAST arclength\n RETURN_VALUE\nEND", "expected": "def arc_length(d, a):\n pi = 22 / 7\n if a >= 360:\n return None\n arclength = pi * d * (a / 360)\n return arclength", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 761, "mbpp_split": "train", "prompt": "Write a function to caluclate arc length of an angle.", "test_list": ["assert arc_length(9,45)==3.5357142857142856", "assert arc_length(9,480)==None", "assert arc_length(5,270)==11.785714285714285"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_761", "n_instr": 27} {"i": 122, "src_path": "src/00122.py", "pyc_path": "pyc/00122.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_monthnumber_number\n RETURN_CONST None\nEND\nCODE check_monthnumber_number(monthnum3)\n RESUME 0\n LOAD_FAST monthnum3\n LOAD_CONST 4\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L1\n LOAD_FAST monthnum3\n LOAD_CONST 6\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L1\n LOAD_FAST monthnum3\n LOAD_CONST 9\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L1\n LOAD_FAST monthnum3\n LOAD_CONST 11\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\nL1:\n RETURN_CONST True\nL2:\n RETURN_CONST False\nEND", "expected": "def check_monthnumber_number(monthnum3):\n if monthnum3 == 4 or monthnum3 == 6 or monthnum3 == 9 or (monthnum3 == 11):\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 762, "mbpp_split": "train", "prompt": "Write a function to check whether the given month number contains 30 days or not.", "test_list": ["assert check_monthnumber_number(6)==True", "assert check_monthnumber_number(2)==False", "assert check_monthnumber_number(12)==False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_762", "n_instr": 29} {"i": 123, "src_path": "src/00123.py", "pyc_path": "pyc/00123.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_Min_Diff\n RETURN_CONST None\nEND\nCODE find_Min_Diff(arr, n)\n RESUME 0\n LOAD_GLOBAL NULL + sorted\n LOAD_FAST arr\n CALL 1\n STORE_FAST arr\n LOAD_CONST 100000000000000000000\n STORE_FAST diff\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST arr\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_OP -\n LOAD_FAST diff\n COMPARE_OP <\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST arr\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_OP -\n STORE_FAST diff\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST diff\n RETURN_VALUE\nEND", "expected": "def find_Min_Diff(arr, n):\n arr = sorted(arr)\n diff = 10 ** 20\n for i in range(n - 1):\n if arr[i + 1] - arr[i] < diff:\n diff = arr[i + 1] - arr[i]\n return diff", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 763, "mbpp_split": "train", "prompt": "Write a python function to find the minimum difference between any two elements in a given array.", "test_list": ["assert find_Min_Diff((1,5,3,19,18,25),6) == 1", "assert find_Min_Diff((4,3,2,6),4) == 1", "assert find_Min_Diff((30,5,20,9),4) == 4"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_763", "n_instr": 53} {"i": 124, "src_path": "src/00124.py", "pyc_path": "pyc/00124.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME number_ctr\n RETURN_CONST None\nEND\nCODE number_ctr(str)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST number_ctr\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST str\n CALL 1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L4\n STORE_FAST i\n LOAD_FAST str\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST '0'\n COMPARE_OP >=\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST str\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST '9'\n COMPARE_OP <=\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L1\nL3:\n LOAD_FAST number_ctr\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST number_ctr\n JUMP_BACKWARD L1\nL4:\n END_FOR\n LOAD_FAST number_ctr\n RETURN_VALUE\nEND", "expected": "def number_ctr(str):\n number_ctr = 0\n for i in range(len(str)):\n if str[i] >= '0' and str[i] <= '9':\n number_ctr += 1\n return number_ctr", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 764, "mbpp_split": "train", "prompt": "Write a python function to count numeric values in a given string.", "test_list": ["assert number_ctr('program2bedone') == 1", "assert number_ctr('3wonders') ==1", "assert number_ctr('123') == 3"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_764", "n_instr": 45} {"i": 125, "src_path": "src/00125.py", "pyc_path": "pyc/00125.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_polite\n RETURN_CONST None\nEND\nCODE is_polite(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST n\n LOAD_GLOBAL NULL + int\n LOAD_FAST n\n LOAD_GLOBAL NULL + math\n LOAD_ATTR log\n LOAD_FAST n\n LOAD_GLOBAL NULL + math\n LOAD_ATTR log\n LOAD_FAST n\n LOAD_CONST 2\n CALL 2\n BINARY_OP +\n LOAD_CONST 2\n CALL 2\n BINARY_OP +\n CALL 1\n RETURN_VALUE\nEND", "expected": "import math\n\ndef is_polite(n):\n n = n + 1\n return int(n + math.log(n + math.log(n, 2), 2))", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 765, "mbpp_split": "train", "prompt": "Write a function to find nth polite number.", "test_list": ["assert is_polite(7) == 11", "assert is_polite(4) == 7", "assert is_polite(9) == 13"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_765", "n_instr": 33} {"i": 126, "src_path": "src/00126.py", "pyc_path": "pyc/00126.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME pair_wise\n RETURN_CONST None\nEND\nCODE pair_wise(l1)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST temp\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST l1\n CALL 1\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST l1\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST l1\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n BINARY_SUBSCR\n STORE_FAST next_element\n STORE_FAST current_element\n LOAD_FAST current_element\n LOAD_FAST next_element\n BUILD_TUPLE 2\n STORE_FAST x\n LOAD_FAST temp\n LOAD_ATTR NULL|self + append\n LOAD_FAST x\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST temp\n RETURN_VALUE\nEND", "expected": "def pair_wise(l1):\n temp = []\n for i in range(len(l1) - 1):\n current_element, next_element = (l1[i], l1[i + 1])\n x = (current_element, next_element)\n temp.append(x)\n return temp", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 766, "mbpp_split": "train", "prompt": "Write a function to iterate over all pairs of consecutive items in a given list.", "test_list": ["assert pair_wise([1,1,2,3,3,4,4,5])==[(1, 1), (1, 2), (2, 3), (3, 3), (3, 4), (4, 4), (4, 5)]", "assert pair_wise([1,5,7,9,10])==[(1, 5), (5, 7), (7, 9), (9, 10)]", "assert pair_wise([1,2,3,4,5,6,7,8,9,10])==[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10)]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_766", "n_instr": 46} {"i": 127, "src_path": "src/00127.py", "pyc_path": "pyc/00127.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_Pairs_Count\n RETURN_CONST None\nEND\nCODE get_Pairs_Count(arr, n, sum)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST count\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_FAST n\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L5\n STORE_FAST i\n LOAD_GLOBAL NULL + range\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST n\n CALL 2\n GET_ITER\nL2:\n FOR_ITER L4\n STORE_FAST j\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST j\n BINARY_SUBSCR\n BINARY_OP +\n LOAD_FAST sum\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L2\nL3:\n LOAD_FAST count\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST count\n JUMP_BACKWARD L2\nL4:\n END_FOR\n JUMP_BACKWARD L1\nL5:\n END_FOR\n LOAD_FAST count\n RETURN_VALUE\nEND", "expected": "def get_Pairs_Count(arr, n, sum):\n count = 0\n for i in range(0, n):\n for j in range(i + 1, n):\n if arr[i] + arr[j] == sum:\n count += 1\n return count", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 767, "mbpp_split": "train", "prompt": "Write a python function to count the number of pairs whose sum is equal to \u2018sum\u2019.", "test_list": ["assert get_Pairs_Count([1,1,1,1],4,2) == 6", "assert get_Pairs_Count([1,5,7,-1,5],5,6) == 3", "assert get_Pairs_Count([1,-2,3],3,1) == 1"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_767", "n_instr": 53} {"i": 128, "src_path": "src/00128.py", "pyc_path": "pyc/00128.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_Odd_Parity\n RETURN_CONST None\nEND\nCODE check_Odd_Parity(x)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST parity\n LOAD_FAST x\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_FAST x\n LOAD_FAST x\n LOAD_CONST 1\n BINARY_OP -\n BINARY_OP &\n STORE_FAST x\n LOAD_FAST parity\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST parity\n LOAD_FAST x\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST parity\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n RETURN_CONST True\nL3:\n RETURN_CONST False\nEND", "expected": "def check_Odd_Parity(x):\n parity = 0\n while x != 0:\n x = x & x - 1\n parity += 1\n if parity % 2 == 1:\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 768, "mbpp_split": "train", "prompt": "Write a python function to check for odd parity of a given number.", "test_list": ["assert check_Odd_Parity(13) == True", "assert check_Odd_Parity(21) == True", "assert check_Odd_Parity(18) == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_768", "n_instr": 41} {"i": 129, "src_path": "src/00129.py", "pyc_path": "pyc/00129.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME Diff\n RETURN_CONST None\nEND\nCODE Diff(li1, li2)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + set\n LOAD_FAST li1\n CALL 1\n LOAD_GLOBAL NULL + set\n LOAD_FAST li2\n CALL 1\n BINARY_OP -\n CALL 1\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + set\n LOAD_FAST li2\n CALL 1\n LOAD_GLOBAL NULL + set\n LOAD_FAST li1\n CALL 1\n BINARY_OP -\n CALL 1\n BINARY_OP +\n CALL 1\n RETURN_VALUE\nEND", "expected": "def Diff(li1, li2):\n return list(list(set(li1) - set(li2)) + list(set(li2) - set(li1)))", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 769, "mbpp_split": "train", "prompt": "Write a python function to get the difference between two lists.", "test_list": ["assert (Diff([10, 15, 20, 25, 30, 35, 40], [25, 40, 35])) == [10, 20, 30, 15]", "assert (Diff([1,2,3,4,5], [6,7,1])) == [2,3,4,5,6,7]", "assert (Diff([1,2,3], [6,7,1])) == [2,3,6,7]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_769", "n_instr": 31} {"i": 130, "src_path": "src/00130.py", "pyc_path": "pyc/00130.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME odd_Num_Sum\n RETURN_CONST None\nEND\nCODE odd_Num_Sum(n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST j\n LOAD_CONST 0\n STORE_FAST sm\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_CONST 2\n LOAD_FAST i\n BINARY_OP *\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST j\n LOAD_FAST sm\n LOAD_FAST j\n LOAD_FAST j\n BINARY_OP *\n LOAD_FAST j\n BINARY_OP *\n LOAD_FAST j\n BINARY_OP *\n BINARY_OP +\n STORE_FAST sm\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST sm\n RETURN_VALUE\nEND", "expected": "def odd_Num_Sum(n):\n j = 0\n sm = 0\n for i in range(1, n + 1):\n j = 2 * i - 1\n sm = sm + j * j * j * j\n return sm", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 770, "mbpp_split": "train", "prompt": "Write a python function to find the sum of fourth power of first n odd natural numbers.", "test_list": ["assert odd_Num_Sum(2) == 82", "assert odd_Num_Sum(3) == 707", "assert odd_Num_Sum(4) == 3108"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_770", "n_instr": 44} {"i": 131, "src_path": "src/00131.py", "pyc_path": "pyc/00131.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('deque',)\n IMPORT_NAME collections\n IMPORT_FROM deque\n STORE_NAME deque\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_expression\n RETURN_CONST None\nEND\nCODE check_expression(exp)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST exp\n CALL 1\n LOAD_CONST 1\n BINARY_OP &\n POP_JUMP_IF_FALSE L1\n RETURN_CONST False\nL1:\n LOAD_GLOBAL NULL + deque\n CALL 0\n STORE_FAST stack\n LOAD_FAST exp\n GET_ITER\nL2:\n FOR_ITER L11\n STORE_FAST ch\n LOAD_FAST ch\n LOAD_CONST '('\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L3\n LOAD_FAST ch\n LOAD_CONST '{'\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L3\n LOAD_FAST ch\n LOAD_CONST '['\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L4\nL3:\n LOAD_FAST stack\n LOAD_ATTR NULL|self + append\n LOAD_FAST ch\n CALL 1\n POP_TOP\nL4:\n LOAD_FAST ch\n LOAD_CONST ')'\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L5\n LOAD_FAST ch\n LOAD_CONST '}'\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L5\n LOAD_FAST ch\n LOAD_CONST ']'\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L5\n JUMP_BACKWARD L2\nL5:\n LOAD_FAST stack\n POP_JUMP_IF_TRUE L6\n POP_TOP\n RETURN_CONST False\nL6:\n LOAD_FAST stack\n LOAD_ATTR NULL|self + pop\n CALL 0\n STORE_FAST top\n LOAD_FAST top\n LOAD_CONST '('\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L7\n LOAD_FAST ch\n LOAD_CONST ')'\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L10\nL7:\n LOAD_FAST top\n LOAD_CONST '{'\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L8\n LOAD_FAST ch\n LOAD_CONST '}'\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L10\nL8:\n LOAD_FAST top\n LOAD_CONST '['\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L9\n JUMP_BACKWARD L2\nL9:\n LOAD_FAST ch\n LOAD_CONST ']'\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L10\n JUMP_BACKWARD L2\nL10:\n POP_TOP\n RETURN_CONST False\nL11:\n END_FOR\n LOAD_FAST stack\n UNARY_NOT\n RETURN_VALUE\nEND", "expected": "from collections import deque\n\ndef check_expression(exp):\n if len(exp) & 1:\n return False\n stack = deque()\n for ch in exp:\n if ch == '(' or ch == '{' or ch == '[':\n stack.append(ch)\n if ch == ')' or ch == '}' or ch == ']':\n if not stack:\n return False\n top = stack.pop()\n if top == '(' and ch != ')' or (top == '{' and ch != '}' or (top == '[' and ch != ']')):\n return False\n return not stack", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 771, "mbpp_split": "train", "prompt": "Write a function to check if the given expression is balanced or not.", "test_list": ["assert check_expression(\"{()}[{}]\") == True", "assert check_expression(\"{()}[{]\") == False", "assert check_expression(\"{()}[{}][]({})\") == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_771", "n_instr": 110} {"i": 132, "src_path": "src/00132.py", "pyc_path": "pyc/00132.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove_length\n RETURN_CONST None\nEND\nCODE remove_length(test_str, K)\n RESUME 0\n LOAD_FAST test_str\n LOAD_ATTR NULL|self + split\n CALL 0\n STORE_FAST temp\n LOAD_FAST temp\n GET_ITER\n LOAD_FAST_AND_CLEAR ele\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L5\n STORE_FAST ele\n LOAD_GLOBAL NULL + len\n LOAD_FAST ele\n CALL 1\n LOAD_FAST K\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST ele\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL5:\n END_FOR\nL6:\n STORE_FAST res\n STORE_FAST ele\n LOAD_CONST ' '\n LOAD_ATTR NULL|self + join\n LOAD_FAST res\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nL7:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST ele\n RERAISE 0\n EXC try=L1..L3 -> handler=L7 depth=2 lasti=False\n EXC try=L4..L6 -> handler=L7 depth=2 lasti=False\nEND", "expected": "def remove_length(test_str, K):\n temp = test_str.split()\n res = [ele for ele in temp if len(ele) != K]\n res = ' '.join(res)\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 772, "mbpp_split": "train", "prompt": "Write a function to remove all the words with k length in the given string.", "test_list": ["assert remove_length('The person is most value tet', 3) == 'person is most value'", "assert remove_length('If you told me about this ok', 4) == 'If you me about ok'", "assert remove_length('Forces of darkeness is come into the play', 4) == 'Forces of darkeness is the'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_772", "n_instr": 55} {"i": 133, "src_path": "src/00133.py", "pyc_path": "pyc/00133.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST '^[a-z0-9]+[\\\\._]?[a-z0-9]+[@]\\\\w+[.]\\\\w{2,3}$'\n STORE_NAME regex\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_email\n RETURN_CONST None\nEND\nCODE check_email(email)\n RESUME 0\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_GLOBAL regex\n LOAD_FAST email\n CALL 2\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Valid Email'\nL1:\n RETURN_CONST 'Invalid Email'\nEND", "expected": "import re\nregex = '^[a-z0-9]+[\\\\._]?[a-z0-9]+[@]\\\\w+[.]\\\\w{2,3}$'\n\ndef check_email(email):\n if re.search(regex, email):\n return 'Valid Email'\n else:\n return 'Invalid Email'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 774, "mbpp_split": "train", "prompt": "Write a function to check if the string is a valid email address or not using regex.", "test_list": ["assert check_email(\"ankitrai326@gmail.com\") == 'Valid Email'", "assert check_email(\"my.ownsite@ourearth.org\") == 'Valid Email'", "assert check_email(\"ankitaoie326.com\") == 'Invalid Email'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_774", "n_instr": 24} {"i": 134, "src_path": "src/00134.py", "pyc_path": "pyc/00134.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME odd_position\n RETURN_CONST None\nEND\nCODE odd_position(nums)\n MAKE_CELL nums\n RESUME 0\n LOAD_GLOBAL NULL + all\n LOAD_CLOSURE nums\n BUILD_TUPLE 1\n LOAD_CONST .>\n MAKE_FUNCTION closure\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_DEREF nums\n CALL 1\n CALL 1\n GET_ITER\n CALL 0\n CALL 1\n RETURN_VALUE\nEND\nCODE odd_position..(.0)\n COPY_FREE_VARS 1\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_DEREF nums\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST 2\n BINARY_OP %\n LOAD_FAST i\n LOAD_CONST 2\n BINARY_OP %\n COMPARE_OP ==\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def odd_position(nums):\n return all((nums[i] % 2 == i % 2 for i in range(len(nums))))", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 775, "mbpp_split": "train", "prompt": "Write a python function to check whether every odd index contains odd numbers of a given list.", "test_list": ["assert odd_position([2,1,4,3,6,7,6,3]) == True", "assert odd_position([4,1,2]) == True", "assert odd_position([1,2,3]) == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_775", "n_instr": 55} {"i": 135, "src_path": "src/00135.py", "pyc_path": "pyc/00135.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_vowels\n RETURN_CONST None\nEND\nCODE count_vowels(test_str)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST res\n BUILD_LIST 0\n LOAD_CONST ('a', 'e', 'i', 'o', 'u')\n LIST_EXTEND 1\n STORE_FAST vow_list\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_GLOBAL NULL + len\n LOAD_FAST test_str\n CALL 1\n LOAD_CONST 1\n BINARY_OP -\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L4\n STORE_FAST idx\n LOAD_FAST test_str\n LOAD_FAST idx\n BINARY_SUBSCR\n LOAD_FAST vow_list\n CONTAINS_OP 1\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST test_str\n LOAD_FAST idx\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n LOAD_FAST vow_list\n CONTAINS_OP 0\n POP_JUMP_IF_TRUE L3\n LOAD_FAST test_str\n LOAD_FAST idx\n LOAD_CONST 1\n BINARY_OP +\n BINARY_SUBSCR\n LOAD_FAST vow_list\n CONTAINS_OP 0\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L1\nL3:\n LOAD_FAST res\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST res\n JUMP_BACKWARD L1\nL4:\n END_FOR\n LOAD_FAST test_str\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST vow_list\n CONTAINS_OP 1\n POP_JUMP_IF_FALSE L5\n LOAD_FAST test_str\n LOAD_CONST 1\n BINARY_SUBSCR\n LOAD_FAST vow_list\n CONTAINS_OP 0\n POP_JUMP_IF_FALSE L5\n LOAD_FAST res\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST res\nL5:\n LOAD_FAST test_str\n LOAD_CONST -1\n BINARY_SUBSCR\n LOAD_FAST vow_list\n CONTAINS_OP 1\n POP_JUMP_IF_FALSE L6\n LOAD_FAST test_str\n LOAD_CONST -2\n BINARY_SUBSCR\n LOAD_FAST vow_list\n CONTAINS_OP 0\n POP_JUMP_IF_FALSE L6\n LOAD_FAST res\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST res\nL6:\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def count_vowels(test_str):\n res = 0\n vow_list = ['a', 'e', 'i', 'o', 'u']\n for idx in range(1, len(test_str) - 1):\n if test_str[idx] not in vow_list and (test_str[idx - 1] in vow_list or test_str[idx + 1] in vow_list):\n res += 1\n if test_str[0] not in vow_list and test_str[1] in vow_list:\n res += 1\n if test_str[-1] not in vow_list and test_str[-2] in vow_list:\n res += 1\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 776, "mbpp_split": "train", "prompt": "Write a function to count those characters which have vowels as their neighbors in the given string.", "test_list": ["assert count_vowels('bestinstareels') == 7", "assert count_vowels('partofthejourneyistheend') == 12", "assert count_vowels('amazonprime') == 5"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_776", "n_instr": 96} {"i": 136, "src_path": "src/00136.py", "pyc_path": "pyc/00136.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('groupby',)\n IMPORT_NAME itertools\n IMPORT_FROM groupby\n STORE_NAME groupby\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME pack_consecutive_duplicates\n RETURN_CONST None\nEND\nCODE pack_consecutive_duplicates(list1)\n RESUME 0\n LOAD_GLOBAL NULL + groupby\n LOAD_FAST list1\n CALL 1\n GET_ITER\n LOAD_FAST_AND_CLEAR key\n LOAD_FAST_AND_CLEAR group\n SWAP 3\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST key\n STORE_FAST group\n LOAD_GLOBAL NULL + list\n LOAD_FAST group\n CALL 1\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n SWAP 3\n STORE_FAST group\n STORE_FAST key\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 3\n STORE_FAST group\n STORE_FAST key\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=3 lasti=False\nEND", "expected": "from itertools import groupby\n\ndef pack_consecutive_duplicates(list1):\n return [list(group) for key, group in groupby(list1)]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 778, "mbpp_split": "train", "prompt": "Write a function to pack consecutive duplicates of a given list elements into sublists.", "test_list": ["assert pack_consecutive_duplicates([0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4])==[[0, 0], [1], [2], [3], [4, 4], [5], [6, 6, 6], [7], [8], [9], [4, 4]]", "assert pack_consecutive_duplicates([10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10])==[[10, 10], [15], [19], [18, 18], [17], [26, 26], [17], [18], [10]]", "assert pack_consecutive_duplicates(['a', 'a', 'b', 'c', 'd', 'd'])==[['a', 'a'], ['b'], ['c'], ['d', 'd']]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_778", "n_instr": 50} {"i": 137, "src_path": "src/00137.py", "pyc_path": "pyc/00137.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('combinations',)\n IMPORT_NAME itertools\n IMPORT_FROM combinations\n STORE_NAME combinations\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_combinations\n RETURN_CONST None\nEND\nCODE find_combinations(test_list)\n RESUME 0\n LOAD_GLOBAL NULL + combinations\n LOAD_FAST test_list\n LOAD_CONST 2\n CALL 2\n GET_ITER\n LOAD_FAST_AND_CLEAR a1\n LOAD_FAST_AND_CLEAR a2\n LOAD_FAST_AND_CLEAR b1\n LOAD_FAST_AND_CLEAR b2\n SWAP 5\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n UNPACK_SEQUENCE 2\n STORE_FAST a1\n STORE_FAST a2\n UNPACK_SEQUENCE 2\n STORE_FAST b1\n STORE_FAST b2\n LOAD_FAST b1\n LOAD_FAST a1\n BINARY_OP +\n LOAD_FAST b2\n LOAD_FAST a2\n BINARY_OP +\n BUILD_TUPLE 2\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST res\n STORE_FAST b1\n STORE_FAST a2\n STORE_FAST a1\n STORE_FAST b2\n LOAD_FAST res\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 5\n STORE_FAST b2\n STORE_FAST b1\n STORE_FAST a2\n STORE_FAST a1\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=5 lasti=False\nEND", "expected": "from itertools import combinations\n\ndef find_combinations(test_list):\n res = [(b1 + a1, b2 + a2) for (a1, a2), (b1, b2) in combinations(test_list, 2)]\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 780, "mbpp_split": "train", "prompt": "Write a function to find the combinations of sums with tuples in the given tuple list.", "test_list": ["assert find_combinations([(2, 4), (6, 7), (5, 1), (6, 10)]) == [(8, 11), (7, 5), (8, 14), (11, 8), (12, 17), (11, 11)]", "assert find_combinations([(3, 5), (7, 8), (6, 2), (7, 11)]) == [(10, 13), (9, 7), (10, 16), (13, 10), (14, 19), (13, 13)]", "assert find_combinations([(4, 6), (8, 9), (7, 3), (8, 12)]) == [(12, 15), (11, 9), (12, 18), (15, 12), (16, 21), (15, 15)]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_780", "n_instr": 66} {"i": 138, "src_path": "src/00138.py", "pyc_path": "pyc/00138.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_Divisors\n RETURN_CONST None\nEND\nCODE count_Divisors(n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST count\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_GLOBAL NULL + int\n LOAD_GLOBAL NULL + math\n LOAD_ATTR sqrt\n LOAD_FAST n\n CALL 1\n CALL 1\n LOAD_CONST 2\n BINARY_OP +\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L4\n STORE_FAST i\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP //\n LOAD_FAST i\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n LOAD_FAST count\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST count\n JUMP_BACKWARD L1\nL3:\n LOAD_FAST count\n LOAD_CONST 2\n BINARY_OP +\n STORE_FAST count\n JUMP_BACKWARD L1\nL4:\n END_FOR\n LOAD_FAST count\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L5\n RETURN_CONST 'Even'\nL5:\n RETURN_CONST 'Odd'\nEND", "expected": "import math\n\ndef count_Divisors(n):\n count = 0\n for i in range(1, int(math.sqrt(n)) + 2):\n if n % i == 0:\n if n // i == i:\n count = count + 1\n else:\n count = count + 2\n if count % 2 == 0:\n return 'Even'\n else:\n return 'Odd'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 781, "mbpp_split": "train", "prompt": "Write a python function to check whether the count of divisors is even or odd.", "test_list": ["assert count_Divisors(10) == \"Even\"", "assert count_Divisors(100) == \"Odd\"", "assert count_Divisors(125) == \"Even\""], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_781", "n_instr": 66} {"i": 139, "src_path": "src/00139.py", "pyc_path": "pyc/00139.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME Odd_Length_Sum\n RETURN_CONST None\nEND\nCODE Odd_Length_Sum(arr)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST Sum\n LOAD_GLOBAL NULL + len\n LOAD_FAST arr\n CALL 1\n STORE_FAST l\n LOAD_GLOBAL NULL + range\n LOAD_FAST l\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST Sum\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST l\n LOAD_FAST i\n BINARY_OP -\n BINARY_OP *\n LOAD_CONST 1\n BINARY_OP +\n LOAD_CONST 2\n BINARY_OP //\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_OP *\n BINARY_OP +=\n STORE_FAST Sum\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST Sum\n RETURN_VALUE\nEND", "expected": "def Odd_Length_Sum(arr):\n Sum = 0\n l = len(arr)\n for i in range(l):\n Sum += ((i + 1) * (l - i) + 1) // 2 * arr[i]\n return Sum", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 782, "mbpp_split": "train", "prompt": "Write a python function to find the sum of all odd length subarrays.", "test_list": ["assert Odd_Length_Sum([1,2,4]) == 14", "assert Odd_Length_Sum([1,2,1,2]) == 15", "assert Odd_Length_Sum([1,7]) == 8"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_782", "n_instr": 45} {"i": 140, "src_path": "src/00140.py", "pyc_path": "pyc/00140.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME mul_even_odd\n RETURN_CONST None\nEND\nCODE mul_even_odd(list1)\n RESUME 0\n LOAD_GLOBAL NULL + next\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST list1\n GET_ITER\n CALL 0\n LOAD_CONST -1\n CALL 2\n STORE_FAST first_even\n LOAD_GLOBAL NULL + next\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST list1\n GET_ITER\n CALL 0\n LOAD_CONST -1\n CALL 2\n STORE_FAST first_odd\n LOAD_FAST first_even\n LOAD_FAST first_odd\n BINARY_OP *\n RETURN_VALUE\nEND\nCODE mul_even_odd..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L5\n STORE_FAST el\n LOAD_FAST el\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST el\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL5:\n END_FOR\n RETURN_CONST None\nL6:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L3 -> handler=L6 depth=0 lasti=True\n EXC try=L4..L6 -> handler=L6 depth=0 lasti=True\nEND\nCODE mul_even_odd..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L5\n STORE_FAST el\n LOAD_FAST el\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST el\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL5:\n END_FOR\n RETURN_CONST None\nL6:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L3 -> handler=L6 depth=0 lasti=True\n EXC try=L4..L6 -> handler=L6 depth=0 lasti=True\nEND", "expected": "def mul_even_odd(list1):\n first_even = next((el for el in list1 if el % 2 == 0), -1)\n first_odd = next((el for el in list1 if el % 2 != 0), -1)\n return first_even * first_odd", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 784, "mbpp_split": "train", "prompt": "Write a function to find the product of first even and odd number of a given list.", "test_list": ["assert mul_even_odd([1,3,5,7,4,1,6,8])==4", "assert mul_even_odd([1,2,3,4,5,6,7,8,9,10])==2", "assert mul_even_odd([1,5,7,9,10])==10"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_784", "n_instr": 95} {"i": 141, "src_path": "src/00141.py", "pyc_path": "pyc/00141.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME bisect\n STORE_NAME bisect\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME right_insertion\n RETURN_CONST None\nEND\nCODE right_insertion(a, x)\n RESUME 0\n LOAD_GLOBAL NULL + bisect\n LOAD_ATTR bisect_right\n LOAD_FAST a\n LOAD_FAST x\n CALL 2\n STORE_FAST i\n LOAD_FAST i\n RETURN_VALUE\nEND", "expected": "import bisect\n\ndef right_insertion(a, x):\n i = bisect.bisect_right(a, x)\n return i", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 786, "mbpp_split": "train", "prompt": "Write a function to locate the right insertion point for a specified value in sorted order.", "test_list": ["assert right_insertion([1,2,4,5],6)==4", "assert right_insertion([1,2,4,5],3)==2", "assert right_insertion([1,2,4,5],7)==4"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_786", "n_instr": 21} {"i": 142, "src_path": "src/00142.py", "pyc_path": "pyc/00142.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME text_match_three\n RETURN_CONST None\nEND\nCODE text_match_three(text)\n RESUME 0\n LOAD_CONST 'ab{3}?'\n STORE_FAST patterns\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_FAST patterns\n LOAD_FAST text\n CALL 2\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Found a match!'\nL1:\n RETURN_CONST 'Not matched!'\nEND", "expected": "import re\n\ndef text_match_three(text):\n patterns = 'ab{3}?'\n if re.search(patterns, text):\n return 'Found a match!'\n else:\n return 'Not matched!'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 787, "mbpp_split": "train", "prompt": "Write a function that matches a string that has an a followed by three 'b'.", "test_list": ["assert text_match_three(\"ac\")==('Not matched!')", "assert text_match_three(\"dc\")==('Not matched!')", "assert text_match_three(\"abbbba\")==('Found a match!')"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_787", "n_instr": 24} {"i": 143, "src_path": "src/00143.py", "pyc_path": "pyc/00143.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME new_tuple\n RETURN_CONST None\nEND\nCODE new_tuple(test_list, test_str)\n RESUME 0\n LOAD_GLOBAL NULL + tuple\n LOAD_FAST test_list\n LOAD_FAST test_str\n BUILD_LIST 1\n BINARY_OP +\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def new_tuple(test_list, test_str):\n res = tuple(test_list + [test_str])\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 788, "mbpp_split": "train", "prompt": "Write a function to create a new tuple from the given string and list.", "test_list": ["assert new_tuple([\"WEB\", \"is\"], \"best\") == ('WEB', 'is', 'best')", "assert new_tuple([\"We\", \"are\"], \"Developers\") == ('We', 'are', 'Developers')", "assert new_tuple([\"Part\", \"is\"], \"Wrong\") == ('Part', 'is', 'Wrong')"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_788", "n_instr": 18} {"i": 144, "src_path": "src/00144.py", "pyc_path": "pyc/00144.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('tan', 'pi')\n IMPORT_NAME math\n IMPORT_FROM tan\n STORE_NAME tan\n IMPORT_FROM pi\n STORE_NAME pi\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME perimeter_polygon\n RETURN_CONST None\nEND\nCODE perimeter_polygon(s, l)\n RESUME 0\n LOAD_FAST s\n LOAD_FAST l\n BINARY_OP *\n STORE_FAST perimeter\n LOAD_FAST perimeter\n RETURN_VALUE\nEND", "expected": "from math import tan, pi\n\ndef perimeter_polygon(s, l):\n perimeter = s * l\n return perimeter", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 789, "mbpp_split": "train", "prompt": "Write a function to calculate the perimeter of a regular polygon.", "test_list": ["assert perimeter_polygon(4,20)==80", "assert perimeter_polygon(10,15)==150", "assert perimeter_polygon(9,7)==63"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_789", "n_instr": 23} {"i": 145, "src_path": "src/00145.py", "pyc_path": "pyc/00145.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove_nested\n RETURN_CONST None\nEND\nCODE remove_nested(test_tup)\n RESUME 0\n LOAD_GLOBAL NULL + tuple\n CALL 0\n STORE_FAST res\n LOAD_GLOBAL NULL + enumerate\n LOAD_FAST test_tup\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST count\n STORE_FAST ele\n LOAD_GLOBAL NULL + isinstance\n LOAD_FAST ele\n LOAD_GLOBAL tuple\n CALL 2\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST res\n LOAD_FAST ele\n BUILD_TUPLE 1\n BINARY_OP +\n STORE_FAST res\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def remove_nested(test_tup):\n res = tuple()\n for count, ele in enumerate(test_tup):\n if not isinstance(ele, tuple):\n res = res + (ele,)\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 791, "mbpp_split": "train", "prompt": "Write a function to remove the nested record from the given tuple.", "test_list": ["assert remove_nested((1, 5, 7, (4, 6), 10)) == (1, 5, 7, 10)", "assert remove_nested((2, 6, 8, (5, 7), 11)) == (2, 6, 8, 11)", "assert remove_nested((3, 7, 9, (6, 8), 12)) == (3, 7, 9, 12)"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_791", "n_instr": 38} {"i": 146, "src_path": "src/00146.py", "pyc_path": "pyc/00146.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME last\n RETURN_CONST None\nEND\nCODE last(arr, x, n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST low\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST high\n LOAD_CONST -1\n STORE_FAST res\n LOAD_FAST low\n LOAD_FAST high\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L5\nL1:\n LOAD_FAST low\n LOAD_FAST high\n BINARY_OP +\n LOAD_CONST 2\n BINARY_OP //\n STORE_FAST mid\n LOAD_FAST arr\n LOAD_FAST mid\n BINARY_SUBSCR\n LOAD_FAST x\n COMPARE_OP >\n POP_JUMP_IF_FALSE L2\n LOAD_FAST mid\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST high\n JUMP_FORWARD L4\nL2:\n LOAD_FAST arr\n LOAD_FAST mid\n BINARY_SUBSCR\n LOAD_FAST x\n COMPARE_OP <\n POP_JUMP_IF_FALSE L3\n LOAD_FAST mid\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST low\n JUMP_FORWARD L4\nL3:\n LOAD_FAST mid\n STORE_FAST res\n LOAD_FAST mid\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST low\nL4:\n LOAD_FAST low\n LOAD_FAST high\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L5\n JUMP_BACKWARD L1\nL5:\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def last(arr, x, n):\n low = 0\n high = n - 1\n res = -1\n while low <= high:\n mid = (low + high) // 2\n if arr[mid] > x:\n high = mid - 1\n elif arr[mid] < x:\n low = mid + 1\n else:\n res = mid\n low = mid + 1\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 793, "mbpp_split": "train", "prompt": "Write a python function to find the last position of an element in a sorted array.", "test_list": ["assert last([1,2,3],1,3) == 0", "assert last([1,1,1,2,3,4],1,6) == 2", "assert last([2,3,2,3,6,8,9],3,8) == 3"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_793", "n_instr": 67} {"i": 147, "src_path": "src/00147.py", "pyc_path": "pyc/00147.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME text_starta_endb\n RETURN_CONST None\nEND\nCODE text_starta_endb(text)\n RESUME 0\n LOAD_CONST 'a.*?b$'\n STORE_FAST patterns\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_FAST patterns\n LOAD_FAST text\n CALL 2\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Found a match!'\nL1:\n RETURN_CONST 'Not matched!'\nEND", "expected": "import re\n\ndef text_starta_endb(text):\n patterns = 'a.*?b$'\n if re.search(patterns, text):\n return 'Found a match!'\n else:\n return 'Not matched!'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 794, "mbpp_split": "train", "prompt": "Write a function that matches a string that has an 'a' followed by anything, ending in 'b'.", "test_list": ["assert text_starta_endb(\"aabbbb\")==('Found a match!')", "assert text_starta_endb(\"aabAbbbc\")==('Not matched!')", "assert text_starta_endb(\"accddbbjjj\")==('Not matched!')"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_794", "n_instr": 24} {"i": 148, "src_path": "src/00148.py", "pyc_path": "pyc/00148.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_Odd\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_in_Range\n RETURN_CONST None\nEND\nCODE sum_Odd(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n LOAD_CONST 2\n BINARY_OP //\n STORE_FAST terms\n LOAD_FAST terms\n LOAD_FAST terms\n BINARY_OP *\n STORE_FAST sum1\n LOAD_FAST sum1\n RETURN_VALUE\nEND\nCODE sum_in_Range(l, r)\n RESUME 0\n LOAD_GLOBAL NULL + sum_Odd\n LOAD_FAST r\n CALL 1\n LOAD_GLOBAL NULL + sum_Odd\n LOAD_FAST l\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n BINARY_OP -\n RETURN_VALUE\nEND", "expected": "def sum_Odd(n):\n terms = (n + 1) // 2\n sum1 = terms * terms\n return sum1\n\ndef sum_in_Range(l, r):\n return sum_Odd(r) - sum_Odd(l - 1)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 797, "mbpp_split": "train", "prompt": "Write a python function to find the sum of all odd natural numbers within the range l and r.", "test_list": ["assert sum_in_Range(2,5) == 8", "assert sum_in_Range(5,7) == 12", "assert sum_in_Range(7,13) == 40"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_797", "n_instr": 37} {"i": 149, "src_path": "src/00149.py", "pyc_path": "pyc/00149.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME test_three_equal\n RETURN_CONST None\nEND\nCODE test_three_equal(x, y, z)\n RESUME 0\n LOAD_GLOBAL NULL + set\n LOAD_FAST x\n LOAD_FAST y\n LOAD_FAST z\n BUILD_LIST 3\n CALL 1\n STORE_FAST result\n LOAD_GLOBAL NULL + len\n LOAD_FAST result\n CALL 1\n LOAD_CONST 3\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 0\nL1:\n LOAD_CONST 4\n LOAD_GLOBAL NULL + len\n LOAD_FAST result\n CALL 1\n BINARY_OP -\n RETURN_VALUE\nEND", "expected": "def test_three_equal(x, y, z):\n result = set([x, y, z])\n if len(result) == 3:\n return 0\n else:\n return 4 - len(result)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 801, "mbpp_split": "train", "prompt": "Write a python function to count the number of equal numbers from three given integers.", "test_list": ["assert test_three_equal(1,1,1) == 3", "assert test_three_equal(-1,-2,-3) == 0", "assert test_three_equal(1,2,2) == 2"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_801", "n_instr": 30} {"i": 150, "src_path": "src/00150.py", "pyc_path": "pyc/00150.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_Rotation\n RETURN_CONST None\nEND\nCODE count_Rotation(arr, n)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST n\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n COMPARE_OP <\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST i\n SWAP 2\n POP_TOP\n RETURN_VALUE\nL3:\n END_FOR\n RETURN_CONST 0\nEND", "expected": "def count_Rotation(arr, n):\n for i in range(1, n):\n if arr[i] < arr[i - 1]:\n return i\n return 0", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 802, "mbpp_split": "train", "prompt": "Write a python function to count the number of rotations required to generate a sorted array.", "test_list": ["assert count_Rotation([3,2,1],3) == 1", "assert count_Rotation([4,5,1,2,3],5) == 2", "assert count_Rotation([7,8,9,1,2,3],6) == 3"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_802", "n_instr": 36} {"i": 151, "src_path": "src/00151.py", "pyc_path": "pyc/00151.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_Perfect_Square\n RETURN_CONST None\nEND\nCODE is_Perfect_Square(n)\n RESUME 0\n LOAD_CONST 1\n STORE_FAST i\n LOAD_FAST i\n LOAD_FAST i\n BINARY_OP *\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L3\nL1:\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP /\n LOAD_FAST i\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n RETURN_CONST True\nL2:\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST i\n LOAD_FAST i\n LOAD_FAST i\n BINARY_OP *\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L3\n JUMP_BACKWARD L1\nL3:\n RETURN_CONST False\nEND", "expected": "def is_Perfect_Square(n):\n i = 1\n while i * i <= n:\n if n % i == 0 and n / i == i:\n return True\n i = i + 1\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 803, "mbpp_split": "train", "prompt": "Write a python function to check whether the given number is a perfect square or not.", "test_list": ["assert is_Perfect_Square(10) == False", "assert is_Perfect_Square(36) == True", "assert is_Perfect_Square(14) == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_803", "n_instr": 45} {"i": 152, "src_path": "src/00152.py", "pyc_path": "pyc/00152.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_Product_Even\n RETURN_CONST None\nEND\nCODE is_Product_Even(arr, n)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_FAST n\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP &\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n POP_TOP\n RETURN_CONST True\nL3:\n END_FOR\n RETURN_CONST False\nEND", "expected": "def is_Product_Even(arr, n):\n for i in range(0, n):\n if arr[i] & 1 == 0:\n return True\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 804, "mbpp_split": "train", "prompt": "Write a python function to check whether the product of numbers is even or not.", "test_list": ["assert is_Product_Even([1,2,3],3) == True", "assert is_Product_Even([1,2,1,4],4) == True", "assert is_Product_Even([1,1],2) == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_804", "n_instr": 32} {"i": 153, "src_path": "src/00153.py", "pyc_path": "pyc/00153.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME max_run_uppercase\n RETURN_CONST None\nEND\nCODE max_run_uppercase(test_str)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST cnt\n LOAD_CONST 0\n STORE_FAST res\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST test_str\n CALL 1\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST idx\n LOAD_FAST test_str\n LOAD_FAST idx\n BINARY_SUBSCR\n LOAD_ATTR NULL|self + isupper\n CALL 0\n POP_JUMP_IF_FALSE L2\n LOAD_FAST cnt\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST cnt\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST cnt\n STORE_FAST res\n LOAD_CONST 0\n STORE_FAST cnt\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST test_str\n LOAD_GLOBAL NULL + len\n LOAD_FAST test_str\n CALL 1\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n LOAD_ATTR NULL|self + isupper\n CALL 0\n POP_JUMP_IF_FALSE L4\n LOAD_FAST cnt\n STORE_FAST res\nL4:\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def max_run_uppercase(test_str):\n cnt = 0\n res = 0\n for idx in range(0, len(test_str)):\n if test_str[idx].isupper():\n cnt += 1\n else:\n res = cnt\n cnt = 0\n if test_str[len(test_str) - 1].isupper():\n res = cnt\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 806, "mbpp_split": "train", "prompt": "Write a function to find maximum run of uppercase characters in the given string.", "test_list": ["assert max_run_uppercase('GeMKSForGERksISBESt') == 5", "assert max_run_uppercase('PrECIOusMOVemENTSYT') == 6", "assert max_run_uppercase('GooGLEFluTTER') == 4"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_806", "n_instr": 57} {"i": 154, "src_path": "src/00154.py", "pyc_path": "pyc/00154.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME first_odd\n RETURN_CONST None\nEND\nCODE first_odd(nums)\n RESUME 0\n LOAD_GLOBAL NULL + next\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST nums\n GET_ITER\n CALL 0\n LOAD_CONST -1\n CALL 2\n STORE_FAST first_odd\n LOAD_FAST first_odd\n RETURN_VALUE\nEND\nCODE first_odd..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L5\n STORE_FAST el\n LOAD_FAST el\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST el\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL5:\n END_FOR\n RETURN_CONST None\nL6:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L3 -> handler=L6 depth=0 lasti=True\n EXC try=L4..L6 -> handler=L6 depth=0 lasti=True\nEND", "expected": "def first_odd(nums):\n first_odd = next((el for el in nums if el % 2 != 0), -1)\n return first_odd", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 807, "mbpp_split": "train", "prompt": "Write a python function to find the first odd number in a given list of numbers.", "test_list": ["assert first_odd([1,3,5]) == 1", "assert first_odd([2,4,1,3]) == 1", "assert first_odd ([8,9,1]) == 9"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_807", "n_instr": 52} {"i": 155, "src_path": "src/00155.py", "pyc_path": "pyc/00155.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_K\n RETURN_CONST None\nEND\nCODE check_K(test_tup, K)\n RESUME 0\n LOAD_CONST False\n STORE_FAST res\n LOAD_FAST test_tup\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST ele\n LOAD_FAST ele\n LOAD_FAST K\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_CONST True\n STORE_FAST res\n POP_TOP\n LOAD_FAST res\n RETURN_VALUE\nL3:\n END_FOR\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def check_K(test_tup, K):\n res = False\n for ele in test_tup:\n if ele == K:\n res = True\n break\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 808, "mbpp_split": "train", "prompt": "Write a function to check if the given tuples contain the k or not.", "test_list": ["assert check_K((10, 4, 5, 6, 8), 6) == True", "assert check_K((1, 2, 3, 4, 5, 6), 7) == False", "assert check_K((7, 8, 9, 44, 11, 12), 11) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_808", "n_instr": 31} {"i": 156, "src_path": "src/00156.py", "pyc_path": "pyc/00156.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_smaller\n RETURN_CONST None\nEND\nCODE check_smaller(test_tup1, test_tup2)\n RESUME 0\n LOAD_GLOBAL NULL + all\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_GLOBAL NULL + zip\n LOAD_FAST test_tup1\n LOAD_FAST test_tup2\n CALL 2\n GET_ITER\n CALL 0\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND\nCODE check_smaller..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST x\n STORE_FAST y\n LOAD_FAST x\n LOAD_FAST y\n COMPARE_OP >\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def check_smaller(test_tup1, test_tup2):\n res = all((x > y for x, y in zip(test_tup1, test_tup2)))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 809, "mbpp_split": "train", "prompt": "Write a function to check if each element of second tuple is smaller than its corresponding index in first tuple.", "test_list": ["assert check_smaller((1, 2, 3), (2, 3, 4)) == False", "assert check_smaller((4, 5, 6), (3, 4, 5)) == True", "assert check_smaller((11, 12, 13), (10, 11, 12)) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_809", "n_instr": 48} {"i": 157, "src_path": "src/00157.py", "pyc_path": "pyc/00157.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_identical\n RETURN_CONST None\nEND\nCODE check_identical(test_list1, test_list2)\n RESUME 0\n LOAD_FAST test_list1\n LOAD_FAST test_list2\n COMPARE_OP ==\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def check_identical(test_list1, test_list2):\n res = test_list1 == test_list2\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 811, "mbpp_split": "train", "prompt": "Write a function to check if two lists of tuples are identical or not.", "test_list": ["assert check_identical([(10, 4), (2, 5)], [(10, 4), (2, 5)]) == True", "assert check_identical([(1, 2), (3, 7)], [(12, 14), (12, 45)]) == False", "assert check_identical([(2, 14), (12, 25)], [(2, 14), (12, 25)]) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_811", "n_instr": 15} {"i": 158, "src_path": "src/00158.py", "pyc_path": "pyc/00158.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME rombus_area\n RETURN_CONST None\nEND\nCODE rombus_area(p, q)\n RESUME 0\n LOAD_FAST p\n LOAD_FAST q\n BINARY_OP *\n LOAD_CONST 2\n BINARY_OP /\n STORE_FAST area\n LOAD_FAST area\n RETURN_VALUE\nEND", "expected": "def rombus_area(p, q):\n area = p * q / 2\n return area", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 814, "mbpp_split": "train", "prompt": "Write a function to find the area of a rombus.", "test_list": ["assert rombus_area(10,20)==100", "assert rombus_area(10,5)==25", "assert rombus_area(4,2)==4"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_814", "n_instr": 17} {"i": 159, "src_path": "src/00159.py", "pyc_path": "pyc/00159.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sort_by_dnf\n RETURN_CONST None\nEND\nCODE sort_by_dnf(arr, n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST low\n LOAD_CONST 0\n STORE_FAST mid\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST high\n LOAD_FAST mid\n LOAD_FAST high\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L5\nL1:\n LOAD_FAST arr\n LOAD_FAST mid\n BINARY_SUBSCR\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_FAST arr\n LOAD_FAST mid\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST low\n BINARY_SUBSCR\n SWAP 2\n LOAD_FAST arr\n LOAD_FAST low\n STORE_SUBSCR\n LOAD_FAST arr\n LOAD_FAST mid\n STORE_SUBSCR\n LOAD_FAST low\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST low\n LOAD_FAST mid\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST mid\n JUMP_FORWARD L4\nL2:\n LOAD_FAST arr\n LOAD_FAST mid\n BINARY_SUBSCR\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n LOAD_FAST mid\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST mid\n JUMP_FORWARD L4\nL3:\n LOAD_FAST arr\n LOAD_FAST high\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST mid\n BINARY_SUBSCR\n SWAP 2\n LOAD_FAST arr\n LOAD_FAST mid\n STORE_SUBSCR\n LOAD_FAST arr\n LOAD_FAST high\n STORE_SUBSCR\n LOAD_FAST high\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST high\nL4:\n LOAD_FAST mid\n LOAD_FAST high\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L5\n JUMP_BACKWARD L1\nL5:\n LOAD_FAST arr\n RETURN_VALUE\nEND", "expected": "def sort_by_dnf(arr, n):\n low = 0\n mid = 0\n high = n - 1\n while mid <= high:\n if arr[mid] == 0:\n arr[low], arr[mid] = (arr[mid], arr[low])\n low = low + 1\n mid = mid + 1\n elif arr[mid] == 1:\n mid = mid + 1\n else:\n arr[mid], arr[high] = (arr[high], arr[mid])\n high = high - 1\n return arr", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 815, "mbpp_split": "train", "prompt": "Write a function to sort the given array without using any sorting algorithm. the given array consists of only 0, 1, and 2.", "test_list": ["assert sort_by_dnf([1,2,0,1,0,1,2,1,1], 9) == [0, 0, 1, 1, 1, 1, 1, 2, 2]", "assert sort_by_dnf([1,0,0,1,2,1,2,2,1,0], 10) == [0, 0, 0, 1, 1, 1, 1, 2, 2, 2]", "assert sort_by_dnf([2,2,1,0,0,0,1,1,2,1], 10) == [0, 0, 0, 1, 1, 1, 1, 2, 2, 2]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_815", "n_instr": 89} {"i": 160, "src_path": "src/00160.py", "pyc_path": "pyc/00160.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME clear_tuple\n RETURN_CONST None\nEND\nCODE clear_tuple(test_tup)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_FAST test_tup\n CALL 1\n STORE_FAST temp\n LOAD_FAST temp\n LOAD_ATTR NULL|self + clear\n CALL 0\n POP_TOP\n LOAD_GLOBAL NULL + tuple\n LOAD_FAST temp\n CALL 1\n STORE_FAST test_tup\n LOAD_FAST test_tup\n RETURN_VALUE\nEND", "expected": "def clear_tuple(test_tup):\n temp = list(test_tup)\n temp.clear()\n test_tup = tuple(temp)\n return test_tup", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 816, "mbpp_split": "train", "prompt": "Write a function to clear the values of the given tuples.", "test_list": ["assert clear_tuple((1, 5, 3, 6, 8)) == ()", "assert clear_tuple((2, 1, 4 ,5 ,6)) == ()", "assert clear_tuple((3, 2, 5, 6, 8)) == ()"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_816", "n_instr": 23} {"i": 161, "src_path": "src/00161.py", "pyc_path": "pyc/00161.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME div_of_nums\n RETURN_CONST None\nEND\nCODE div_of_nums(nums, m, n)\n MAKE_CELL m\n MAKE_CELL n\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + filter\n LOAD_CLOSURE m\n LOAD_CLOSURE n\n BUILD_TUPLE 2\n LOAD_CONST .>\n MAKE_FUNCTION closure\n LOAD_FAST nums\n CALL 2\n CALL 1\n STORE_FAST result\n LOAD_FAST result\n RETURN_VALUE\nEND\nCODE div_of_nums..(x)\n COPY_FREE_VARS 2\n RESUME 0\n LOAD_FAST x\n LOAD_DEREF m\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n COPY 1\n POP_JUMP_IF_TRUE L1\n POP_TOP\n LOAD_FAST x\n LOAD_DEREF n\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\nL1:\n RETURN_VALUE\nEND", "expected": "def div_of_nums(nums, m, n):\n result = list(filter(lambda x: x % m == 0 or x % n == 0, nums))\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 817, "mbpp_split": "train", "prompt": "Write a function to find numbers divisible by m or n from a list of numbers using lambda function.", "test_list": ["assert div_of_nums([19, 65, 57, 39, 152, 639, 121, 44, 90, 190],19,13)==[19, 65, 57, 39, 152, 190]", "assert div_of_nums([1, 2, 3, 5, 7, 8, 10],2,5)==[2, 5, 8, 10]", "assert div_of_nums([10,15,14,13,18,12,20],10,5)==[10, 15, 20]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_817", "n_instr": 43} {"i": 162, "src_path": "src/00162.py", "pyc_path": "pyc/00162.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME lower_ctr\n RETURN_CONST None\nEND\nCODE lower_ctr(str)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST lower_ctr\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST str\n CALL 1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L4\n STORE_FAST i\n LOAD_FAST str\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST 'a'\n COMPARE_OP >=\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST str\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST 'z'\n COMPARE_OP <=\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L1\nL3:\n LOAD_FAST lower_ctr\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST lower_ctr\n JUMP_BACKWARD L1\nL4:\n END_FOR\n LOAD_FAST lower_ctr\n RETURN_VALUE\nEND", "expected": "def lower_ctr(str):\n lower_ctr = 0\n for i in range(len(str)):\n if str[i] >= 'a' and str[i] <= 'z':\n lower_ctr += 1\n return lower_ctr", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 818, "mbpp_split": "train", "prompt": "Write a python function to count lower case letters in a given string.", "test_list": ["assert lower_ctr('abc') == 3", "assert lower_ctr('string') == 6", "assert lower_ctr('Python') == 5"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_818", "n_instr": 45} {"i": 163, "src_path": "src/00163.py", "pyc_path": "pyc/00163.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_duplic\n RETURN_CONST None\nEND\nCODE count_duplic(lists)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST element\n BUILD_LIST 0\n STORE_FAST frequency\n LOAD_FAST lists\n POP_JUMP_IF_TRUE L1\n LOAD_FAST element\n RETURN_VALUE\nL1:\n LOAD_CONST 1\n STORE_FAST running_count\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST lists\n CALL 1\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n GET_ITER\nL2:\n FOR_ITER L4\n STORE_FAST i\n LOAD_FAST lists\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST lists\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n LOAD_FAST running_count\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST running_count\n JUMP_BACKWARD L2\nL3:\n LOAD_FAST frequency\n LOAD_ATTR NULL|self + append\n LOAD_FAST running_count\n CALL 1\n POP_TOP\n LOAD_FAST element\n LOAD_ATTR NULL|self + append\n LOAD_FAST lists\n LOAD_FAST i\n BINARY_SUBSCR\n CALL 1\n POP_TOP\n LOAD_CONST 1\n STORE_FAST running_count\n JUMP_BACKWARD L2\nL4:\n END_FOR\n LOAD_FAST frequency\n LOAD_ATTR NULL|self + append\n LOAD_FAST running_count\n CALL 1\n POP_TOP\n LOAD_FAST element\n LOAD_ATTR NULL|self + append\n LOAD_FAST lists\n LOAD_FAST_CHECK i\n LOAD_CONST 1\n BINARY_OP +\n BINARY_SUBSCR\n CALL 1\n POP_TOP\n LOAD_FAST element\n LOAD_FAST frequency\n BUILD_TUPLE 2\n RETURN_VALUE\nEND", "expected": "def count_duplic(lists):\n element = []\n frequency = []\n if not lists:\n return element\n running_count = 1\n for i in range(len(lists) - 1):\n if lists[i] == lists[i + 1]:\n running_count += 1\n else:\n frequency.append(running_count)\n element.append(lists[i])\n running_count = 1\n frequency.append(running_count)\n element.append(lists[i + 1])\n return (element, frequency)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 819, "mbpp_split": "train", "prompt": "Write a function to count the frequency of consecutive duplicate elements in a given list of numbers.", "test_list": ["assert count_duplic([1,2,2,2,4,4,4,5,5,5,5])==([1, 2, 4, 5], [1, 3, 3, 4])", "assert count_duplic([2,2,3,1,2,6,7,9])==([2, 3, 1, 2, 6, 7, 9], [2, 1, 1, 1, 1, 1, 1])", "assert count_duplic([2,1,5,6,8,3,4,9,10,11,8,12])==([2, 1, 5, 6, 8, 3, 4, 9, 10, 11, 8, 12], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_819", "n_instr": 82} {"i": 164, "src_path": "src/00164.py", "pyc_path": "pyc/00164.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_monthnum_number\n RETURN_CONST None\nEND\nCODE check_monthnum_number(monthnum1)\n RESUME 0\n LOAD_FAST monthnum1\n LOAD_CONST 2\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST True\nL1:\n RETURN_CONST False\nEND", "expected": "def check_monthnum_number(monthnum1):\n if monthnum1 == 2:\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 820, "mbpp_split": "train", "prompt": "Write a function to check whether the given month number contains 28 days or not.", "test_list": ["assert check_monthnum_number(2)==True", "assert check_monthnum_number(1)==False", "assert check_monthnum_number(3)==False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_820", "n_instr": 16} {"i": 165, "src_path": "src/00165.py", "pyc_path": "pyc/00165.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME pass_validity\n RETURN_CONST None\nEND\nCODE pass_validity(p)\n RESUME 0\n LOAD_CONST True\n STORE_FAST x\n LOAD_FAST x\n POP_JUMP_IF_FALSE L8\n LOAD_GLOBAL NULL + len\n LOAD_FAST p\n CALL 1\n LOAD_CONST 6\n COMPARE_OP <\n POP_JUMP_IF_TRUE L1\n LOAD_GLOBAL NULL + len\n LOAD_FAST p\n CALL 1\n LOAD_CONST 12\n COMPARE_OP >\n POP_JUMP_IF_FALSE L2\nL1:\n JUMP_FORWARD L8\nL2:\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_CONST '[a-z]'\n LOAD_FAST p\n CALL 2\n POP_JUMP_IF_TRUE L3\n JUMP_FORWARD L8\nL3:\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_CONST '[0-9]'\n LOAD_FAST p\n CALL 2\n POP_JUMP_IF_TRUE L4\n JUMP_FORWARD L8\nL4:\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_CONST '[A-Z]'\n LOAD_FAST p\n CALL 2\n POP_JUMP_IF_TRUE L5\n JUMP_FORWARD L8\nL5:\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_CONST '[$#@]'\n LOAD_FAST p\n CALL 2\n POP_JUMP_IF_TRUE L6\n JUMP_FORWARD L8\nL6:\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_CONST '\\\\s'\n LOAD_FAST p\n CALL 2\n POP_JUMP_IF_FALSE L7\n JUMP_FORWARD L8\nL7:\n RETURN_CONST True\nL8:\n LOAD_FAST x\n POP_JUMP_IF_FALSE L9\n RETURN_CONST False\nL9:\n RETURN_CONST None\nEND", "expected": "import re\n\ndef pass_validity(p):\n x = True\n while x:\n if len(p) < 6 or len(p) > 12:\n break\n elif not re.search('[a-z]', p):\n break\n elif not re.search('[0-9]', p):\n break\n elif not re.search('[A-Z]', p):\n break\n elif not re.search('[$#@]', p):\n break\n elif re.search('\\\\s', p):\n break\n else:\n return True\n x = False\n break\n if x:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 822, "mbpp_split": "train", "prompt": "Write a function to return true if the password is valid.", "test_list": ["assert pass_validity(\"password\")==False", "assert pass_validity(\"Password@10\")==True", "assert pass_validity(\"password@10\")==False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_822", "n_instr": 79} {"i": 166, "src_path": "src/00166.py", "pyc_path": "pyc/00166.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_substring\n RETURN_CONST None\nEND\nCODE check_substring(string, sample)\n RESUME 0\n LOAD_FAST sample\n LOAD_FAST string\n CONTAINS_OP 0\n POP_JUMP_IF_FALSE L2\n LOAD_CONST '\\\\A'\n LOAD_FAST sample\n BINARY_OP +\n STORE_FAST y\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_FAST y\n LOAD_FAST string\n CALL 2\n STORE_FAST x\n LOAD_FAST x\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'string starts with the given substring'\nL1:\n RETURN_CONST 'string doesnt start with the given substring'\nL2:\n RETURN_CONST 'entered string isnt a substring'\nEND", "expected": "import re\n\ndef check_substring(string, sample):\n if sample in string:\n y = '\\\\A' + sample\n x = re.search(y, string)\n if x:\n return 'string starts with the given substring'\n else:\n return 'string doesnt start with the given substring'\n else:\n return 'entered string isnt a substring'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 823, "mbpp_split": "train", "prompt": "Write a function to check if the given string starts with a substring using regex.", "test_list": ["assert check_substring(\"dreams for dreams makes life fun\", \"makes\") == 'string doesnt start with the given substring'", "assert check_substring(\"Hi there how are you Hi alex\", \"Hi\") == 'string starts with the given substring'", "assert check_substring(\"Its been a long day\", \"been\") == 'string doesnt start with the given substring'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_823", "n_instr": 34} {"i": 167, "src_path": "src/00167.py", "pyc_path": "pyc/00167.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove_even\n RETURN_CONST None\nEND\nCODE remove_even(l)\n RESUME 0\n LOAD_FAST l\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST i\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST l\n LOAD_ATTR NULL|self + remove\n LOAD_FAST i\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST l\n RETURN_VALUE\nEND", "expected": "def remove_even(l):\n for i in l:\n if i % 2 == 0:\n l.remove(i)\n return l", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 824, "mbpp_split": "train", "prompt": "Write a python function to remove even numbers from a given list.", "test_list": ["assert remove_even([1,3,5,2]) == [1,3,5]", "assert remove_even([5,6,7]) == [5,7]", "assert remove_even([1,2,3,4]) == [1,3]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_824", "n_instr": 32} {"i": 168, "src_path": "src/00168.py", "pyc_path": "pyc/00168.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME access_elements\n RETURN_CONST None\nEND\nCODE access_elements(nums, list_index)\n RESUME 0\n LOAD_FAST list_index\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST nums\n LOAD_FAST i\n BINARY_SUBSCR\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST result\n STORE_FAST i\n LOAD_FAST result\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=2 lasti=False\nEND", "expected": "def access_elements(nums, list_index):\n result = [nums[i] for i in list_index]\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 825, "mbpp_split": "train", "prompt": "Write a python function to access multiple elements of specified index from a given list.", "test_list": ["assert access_elements([2,3,8,4,7,9],[0,3,5]) == [2, 4, 9]", "assert access_elements([1, 2, 3, 4, 5],[1,2]) == [2,3]", "assert access_elements([1,0,2,3],[0,1]) == [1,0]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_825", "n_instr": 38} {"i": 169, "src_path": "src/00169.py", "pyc_path": "pyc/00169.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_column\n RETURN_CONST None\nEND\nCODE sum_column(list1, C)\n MAKE_CELL C\n RESUME 0\n LOAD_GLOBAL NULL + sum\n LOAD_CLOSURE C\n BUILD_TUPLE 1\n LOAD_CONST .>\n MAKE_FUNCTION closure\n LOAD_FAST list1\n GET_ITER\n CALL 0\n CALL 1\n STORE_FAST result\n LOAD_FAST result\n RETURN_VALUE\nEND\nCODE sum_column..(.0)\n COPY_FREE_VARS 1\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n STORE_FAST row\n LOAD_FAST row\n LOAD_DEREF C\n BINARY_SUBSCR\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def sum_column(list1, C):\n result = sum((row[C] for row in list1))\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 827, "mbpp_split": "train", "prompt": "Write a function to sum a specific column of a list in a given list of lists.", "test_list": ["assert sum_column( [[1,2,3,2],[4,5,6,2],[7,8,9,5],],0)==12", "assert sum_column( [[1,2,3,2],[4,5,6,2],[7,8,9,5],],1)==15", "assert sum_column( [[1,2,3,2],[4,5,6,2],[7,8,9,5],],3)==9"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_827", "n_instr": 47} {"i": 170, "src_path": "src/00170.py", "pyc_path": "pyc/00170.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_alpha_dig_spl\n RETURN_CONST None\nEND\nCODE count_alpha_dig_spl(string)\n RESUME 0\n LOAD_CONST 0\n COPY 1\n STORE_FAST alphabets\n COPY 1\n STORE_FAST digits\n STORE_FAST special\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST string\n CALL 1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L4\n STORE_FAST i\n LOAD_FAST string\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_ATTR NULL|self + isalpha\n CALL 0\n POP_JUMP_IF_FALSE L2\n LOAD_FAST alphabets\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST alphabets\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST string\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_ATTR NULL|self + isdigit\n CALL 0\n POP_JUMP_IF_FALSE L3\n LOAD_FAST digits\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST digits\n JUMP_BACKWARD L1\nL3:\n LOAD_FAST special\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST special\n JUMP_BACKWARD L1\nL4:\n END_FOR\n LOAD_FAST alphabets\n LOAD_FAST digits\n LOAD_FAST special\n BUILD_TUPLE 3\n RETURN_VALUE\nEND", "expected": "def count_alpha_dig_spl(string):\n alphabets = digits = special = 0\n for i in range(len(string)):\n if string[i].isalpha():\n alphabets = alphabets + 1\n elif string[i].isdigit():\n digits = digits + 1\n else:\n special = special + 1\n return (alphabets, digits, special)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 828, "mbpp_split": "train", "prompt": "Write a function to count alphabets,digits and special charactes in a given string.", "test_list": ["assert count_alpha_dig_spl(\"abc!@#123\")==(3,3,3)", "assert count_alpha_dig_spl(\"dgsuy@#$%&1255\")==(5,4,5)", "assert count_alpha_dig_spl(\"fjdsif627348#%$^&\")==(6,6,5)"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_828", "n_instr": 60} {"i": 171, "src_path": "src/00171.py", "pyc_path": "pyc/00171.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('Counter',)\n IMPORT_NAME collections\n IMPORT_FROM Counter\n STORE_NAME Counter\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME second_frequent\n RETURN_CONST None\nEND\nCODE second_frequent(input)\n RESUME 0\n LOAD_GLOBAL NULL + Counter\n LOAD_FAST input\n CALL 1\n STORE_FAST dict\n LOAD_GLOBAL NULL + sorted\n LOAD_FAST dict\n LOAD_ATTR NULL|self + values\n CALL 0\n LOAD_CONST True\n KW_NAMES ('reverse',)\n CALL 2\n STORE_FAST value\n LOAD_FAST value\n LOAD_CONST 1\n BINARY_SUBSCR\n STORE_FAST second_large\n LOAD_FAST dict\n LOAD_ATTR NULL|self + items\n CALL 0\n GET_ITER\nL1:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST key\n STORE_FAST val\n LOAD_FAST val\n LOAD_FAST second_large\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST key\n SWAP 2\n POP_TOP\n RETURN_VALUE\nL3:\n END_FOR\n RETURN_CONST None\nEND", "expected": "from collections import Counter\n\ndef second_frequent(input):\n dict = Counter(input)\n value = sorted(dict.values(), reverse=True)\n second_large = value[1]\n for key, val in dict.items():\n if val == second_large:\n return key", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 829, "mbpp_split": "train", "prompt": "Write a function to find out the second most repeated (or frequent) string in the given sequence.", "test_list": ["assert second_frequent(['aaa','bbb','ccc','bbb','aaa','aaa']) == 'bbb'", "assert second_frequent(['abc','bcd','abc','bcd','bcd','bcd']) == 'abc'", "assert second_frequent(['cdma','gsm','hspa','gsm','cdma','cdma']) == 'gsm'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_829", "n_instr": 53} {"i": 172, "src_path": "src/00172.py", "pyc_path": "pyc/00172.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_Pairs\n RETURN_CONST None\nEND\nCODE count_Pairs(arr, n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST cnt\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L5\n STORE_FAST i\n LOAD_GLOBAL NULL + range\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST n\n CALL 2\n GET_ITER\nL2:\n FOR_ITER L4\n STORE_FAST j\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST j\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L2\nL3:\n LOAD_FAST cnt\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST cnt\n JUMP_BACKWARD L2\nL4:\n END_FOR\n JUMP_BACKWARD L1\nL5:\n END_FOR\n LOAD_FAST cnt\n RETURN_VALUE\nEND", "expected": "def count_Pairs(arr, n):\n cnt = 0\n for i in range(n):\n for j in range(i + 1, n):\n if arr[i] == arr[j]:\n cnt += 1\n return cnt", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 831, "mbpp_split": "train", "prompt": "Write a python function to count equal element pairs from the given array.", "test_list": ["assert count_Pairs([1,1,1,1],4) == 6", "assert count_Pairs([1,5,1],3) == 1", "assert count_Pairs([3,2,1,7,8,9],6) == 0"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_831", "n_instr": 50} {"i": 173, "src_path": "src/00173.py", "pyc_path": "pyc/00173.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME generate_matrix\n RETURN_CONST None\nEND\nCODE generate_matrix(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 0\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L1\n BUILD_LIST 0\n RETURN_VALUE\nL1:\n LOAD_CONST 0\n BUILD_LIST 1\n LOAD_FAST n\n BINARY_OP *\n BUILD_LIST 1\n LOAD_FAST n\n BINARY_OP *\n GET_ITER\n LOAD_FAST_AND_CLEAR row\n SWAP 2\nL2:\n BUILD_LIST 0\n SWAP 2\nL3:\n FOR_ITER L4\n STORE_FAST row\n LOAD_FAST row\n LOAD_CONST None\n LOAD_CONST None\n BINARY_SLICE\n LIST_APPEND 2\n JUMP_BACKWARD L3\nL4:\n END_FOR\nL5:\n STORE_FAST matrix\n STORE_FAST row\n LOAD_CONST 0\n STORE_FAST row_st\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST row_ed\n LOAD_CONST 0\n STORE_FAST col_st\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST col_ed\n LOAD_CONST 1\n STORE_FAST current\n NOP\nL6:\n LOAD_FAST current\n LOAD_FAST n\n LOAD_FAST n\n BINARY_OP *\n COMPARE_OP >\n POP_JUMP_IF_FALSE L7\n NOP\n LOAD_FAST matrix\n RETURN_VALUE\nL7:\n LOAD_GLOBAL NULL + range\n LOAD_FAST col_st\n LOAD_FAST col_ed\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL8:\n FOR_ITER L9\n STORE_FAST c\n LOAD_FAST current\n LOAD_FAST matrix\n LOAD_FAST row_st\n BINARY_SUBSCR\n LOAD_FAST c\n STORE_SUBSCR\n LOAD_FAST current\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST current\n JUMP_BACKWARD L8\nL9:\n END_FOR\n LOAD_FAST row_st\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST row_st\n LOAD_GLOBAL NULL + range\n LOAD_FAST row_st\n LOAD_FAST row_ed\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL10:\n FOR_ITER L11\n STORE_FAST r\n LOAD_FAST current\n LOAD_FAST matrix\n LOAD_FAST r\n BINARY_SUBSCR\n LOAD_FAST col_ed\n STORE_SUBSCR\n LOAD_FAST current\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST current\n JUMP_BACKWARD L10\nL11:\n END_FOR\n LOAD_FAST col_ed\n LOAD_CONST 1\n BINARY_OP -=\n STORE_FAST col_ed\n LOAD_GLOBAL NULL + range\n LOAD_FAST col_ed\n LOAD_FAST col_st\n LOAD_CONST 1\n BINARY_OP -\n LOAD_CONST -1\n CALL 3\n GET_ITER\nL12:\n FOR_ITER L13\n STORE_FAST c\n LOAD_FAST current\n LOAD_FAST matrix\n LOAD_FAST row_ed\n BINARY_SUBSCR\n LOAD_FAST c\n STORE_SUBSCR\n LOAD_FAST current\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST current\n JUMP_BACKWARD L12\nL13:\n END_FOR\n LOAD_FAST row_ed\n LOAD_CONST 1\n BINARY_OP -=\n STORE_FAST row_ed\n LOAD_GLOBAL NULL + range\n LOAD_FAST row_ed\n LOAD_FAST row_st\n LOAD_CONST 1\n BINARY_OP -\n LOAD_CONST -1\n CALL 3\n GET_ITER\nL14:\n FOR_ITER L15\n STORE_FAST r\n LOAD_FAST current\n LOAD_FAST matrix\n LOAD_FAST r\n BINARY_SUBSCR\n LOAD_FAST col_st\n STORE_SUBSCR\n LOAD_FAST current\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST current\n JUMP_BACKWARD L14\nL15:\n END_FOR\n LOAD_FAST col_st\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST col_st\n JUMP_BACKWARD L6\nL16:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST row\n RERAISE 0\n EXC try=L2..L5 -> handler=L16 depth=2 lasti=False\nEND", "expected": "def generate_matrix(n):\n if n <= 0:\n return []\n matrix = [row[:] for row in [[0] * n] * n]\n row_st = 0\n row_ed = n - 1\n col_st = 0\n col_ed = n - 1\n current = 1\n while True:\n if current > n * n:\n break\n for c in range(col_st, col_ed + 1):\n matrix[row_st][c] = current\n current += 1\n row_st += 1\n for r in range(row_st, row_ed + 1):\n matrix[r][col_ed] = current\n current += 1\n col_ed -= 1\n for c in range(col_ed, col_st - 1, -1):\n matrix[row_ed][c] = current\n current += 1\n row_ed -= 1\n for r in range(row_ed, row_st - 1, -1):\n matrix[r][col_st] = current\n current += 1\n col_st += 1\n return matrix", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 834, "mbpp_split": "train", "prompt": "Write a function to generate a square matrix filled with elements from 1 to n raised to the power of 2 in spiral order.", "test_list": ["assert generate_matrix(3)==[[1, 2, 3], [8, 9, 4], [7, 6, 5]] ", "assert generate_matrix(2)==[[1,2],[4,3]]", "assert generate_matrix(7)==[[1, 2, 3, 4, 5, 6, 7], [24, 25, 26, 27, 28, 29, 8], [23, 40, 41, 42, 43, 30, 9], [22, 39, 48, 49, 44, 31, 10], [21, 38, 47, 46, 45, 32, 11], [20, 37, 36, 35, 34, 33, 12], [19, 18, 17, 16, 15, 14, 13]]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_834", "n_instr": 187} {"i": 174, "src_path": "src/00174.py", "pyc_path": "pyc/00174.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('maxsize',)\n IMPORT_NAME sys\n IMPORT_FROM maxsize\n STORE_NAME maxsize\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME max_sub_array_sum\n RETURN_CONST None\nEND\nCODE max_sub_array_sum(a, size)\n RESUME 0\n LOAD_GLOBAL maxsize\n UNARY_NEGATIVE\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST max_so_far\n LOAD_CONST 0\n STORE_FAST max_ending_here\n LOAD_CONST 0\n STORE_FAST start\n LOAD_CONST 0\n STORE_FAST end\n LOAD_CONST 0\n STORE_FAST s\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_FAST size\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L4\n STORE_FAST i\n LOAD_FAST max_ending_here\n LOAD_FAST a\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_OP +=\n STORE_FAST max_ending_here\n LOAD_FAST max_so_far\n LOAD_FAST max_ending_here\n COMPARE_OP <\n POP_JUMP_IF_FALSE L2\n LOAD_FAST max_ending_here\n STORE_FAST max_so_far\n LOAD_FAST s\n STORE_FAST start\n LOAD_FAST i\n STORE_FAST end\nL2:\n LOAD_FAST max_ending_here\n LOAD_CONST 0\n COMPARE_OP <\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L1\nL3:\n LOAD_CONST 0\n STORE_FAST max_ending_here\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST s\n JUMP_BACKWARD L1\nL4:\n END_FOR\n LOAD_FAST end\n LOAD_FAST start\n BINARY_OP -\n LOAD_CONST 1\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "from sys import maxsize\n\ndef max_sub_array_sum(a, size):\n max_so_far = -maxsize - 1\n max_ending_here = 0\n start = 0\n end = 0\n s = 0\n for i in range(0, size):\n max_ending_here += a[i]\n if max_so_far < max_ending_here:\n max_so_far = max_ending_here\n start = s\n end = i\n if max_ending_here < 0:\n max_ending_here = 0\n s = i + 1\n return end - start + 1", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 836, "mbpp_split": "train", "prompt": "Write a function to find length of the subarray having maximum sum.", "test_list": ["assert max_sub_array_sum([-2, -3, 4, -1, -2, 1, 5, -3],8) == 5", "assert max_sub_array_sum([1, -2, 1, 1, -2, 1],6) == 2", "assert max_sub_array_sum([-1, -2, 3, 4, 5],5) == 3"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_836", "n_instr": 74} {"i": 175, "src_path": "src/00175.py", "pyc_path": "pyc/00175.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME cube_Sum\n RETURN_CONST None\nEND\nCODE cube_Sum(n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST sum\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_FAST n\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST sum\n LOAD_CONST 2\n LOAD_FAST i\n BINARY_OP *\n LOAD_CONST 1\n BINARY_OP +\n LOAD_CONST 2\n LOAD_FAST i\n BINARY_OP *\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP *\n LOAD_CONST 2\n LOAD_FAST i\n BINARY_OP *\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP *\n BINARY_OP +=\n STORE_FAST sum\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST sum\n RETURN_VALUE\nEND", "expected": "def cube_Sum(n):\n sum = 0\n for i in range(0, n):\n sum += (2 * i + 1) * (2 * i + 1) * (2 * i + 1)\n return sum", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 837, "mbpp_split": "train", "prompt": "Write a python function to find the cube sum of first n odd natural numbers.", "test_list": ["assert cube_Sum(2) == 28", "assert cube_Sum(3) == 153", "assert cube_Sum(4) == 496"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_837", "n_instr": 44} {"i": 176, "src_path": "src/00176.py", "pyc_path": "pyc/00176.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME min_Swaps\n RETURN_CONST None\nEND\nCODE min_Swaps(s1, s2)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST c0\n LOAD_CONST 0\n STORE_FAST c1\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST s1\n CALL 1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L5\n STORE_FAST i\n LOAD_FAST s1\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST '0'\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_FAST s2\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST '1'\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_FAST c0\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST c0\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST s1\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST '1'\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L1\nL3:\n LOAD_FAST s2\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST '0'\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L4\n JUMP_BACKWARD L1\nL4:\n LOAD_FAST c1\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST c1\n JUMP_BACKWARD L1\nL5:\n END_FOR\n LOAD_FAST c0\n LOAD_CONST 2\n BINARY_OP //\n LOAD_FAST c1\n LOAD_CONST 2\n BINARY_OP //\n BINARY_OP +\n STORE_FAST result\n LOAD_FAST c0\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L6\n LOAD_FAST c1\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L6\n LOAD_FAST result\n RETURN_VALUE\nL6:\n LOAD_FAST c0\n LOAD_FAST c1\n BINARY_OP +\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L7\n LOAD_FAST result\n LOAD_CONST 2\n BINARY_OP +\n RETURN_VALUE\nL7:\n RETURN_CONST -1\nEND", "expected": "def min_Swaps(s1, s2):\n c0 = 0\n c1 = 0\n for i in range(len(s1)):\n if s1[i] == '0' and s2[i] == '1':\n c0 += 1\n elif s1[i] == '1' and s2[i] == '0':\n c1 += 1\n result = c0 // 2 + c1 // 2\n if c0 % 2 == 0 and c1 % 2 == 0:\n return result\n elif (c0 + c1) % 2 == 0:\n return result + 2\n else:\n return -1", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 838, "mbpp_split": "train", "prompt": "Write a python function to find minimum number swaps required to make two binary strings equal.", "test_list": ["assert min_Swaps(\"0011\",\"1111\") == 1", "assert min_Swaps(\"00011\",\"01001\") == 2", "assert min_Swaps(\"111\",\"111\") == 0"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_838", "n_instr": 100} {"i": 177, "src_path": "src/00177.py", "pyc_path": "pyc/00177.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sort_tuple\n RETURN_CONST None\nEND\nCODE sort_tuple(tup)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST tup\n CALL 1\n STORE_FAST n\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L5\n STORE_FAST i\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP -\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n GET_ITER\nL2:\n FOR_ITER L4\n STORE_FAST j\n LOAD_FAST tup\n LOAD_FAST j\n BINARY_SUBSCR\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST tup\n LOAD_FAST j\n LOAD_CONST 1\n BINARY_OP +\n BINARY_SUBSCR\n LOAD_CONST 0\n BINARY_SUBSCR\n COMPARE_OP >\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L2\nL3:\n LOAD_FAST tup\n LOAD_FAST j\n LOAD_CONST 1\n BINARY_OP +\n BINARY_SUBSCR\n LOAD_FAST tup\n LOAD_FAST j\n BINARY_SUBSCR\n SWAP 2\n LOAD_FAST tup\n LOAD_FAST j\n STORE_SUBSCR\n LOAD_FAST tup\n LOAD_FAST j\n LOAD_CONST 1\n BINARY_OP +\n STORE_SUBSCR\n JUMP_BACKWARD L2\nL4:\n END_FOR\n JUMP_BACKWARD L1\nL5:\n END_FOR\n LOAD_FAST tup\n RETURN_VALUE\nEND", "expected": "def sort_tuple(tup):\n n = len(tup)\n for i in range(n):\n for j in range(n - i - 1):\n if tup[j][0] > tup[j + 1][0]:\n tup[j], tup[j + 1] = (tup[j + 1], tup[j])\n return tup", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 839, "mbpp_split": "train", "prompt": "Write a function to sort the tuples alphabetically by the first item of each tuple.", "test_list": ["assert sort_tuple([(\"Amana\", 28), (\"Zenat\", 30), (\"Abhishek\", 29),(\"Nikhil\", 21), (\"B\", \"C\")]) == [('Abhishek', 29), ('Amana', 28), ('B', 'C'), ('Nikhil', 21), ('Zenat', 30)]", "assert sort_tuple([(\"aaaa\", 28), (\"aa\", 30), (\"bab\", 29), (\"bb\", 21), (\"csa\", \"C\")]) == [('aa', 30), ('aaaa', 28), ('bab', 29), ('bb', 21), ('csa', 'C')]", "assert sort_tuple([(\"Sarala\", 28), (\"Ayesha\", 30), (\"Suman\", 29),(\"Sai\", 21), (\"G\", \"H\")]) == [('Ayesha', 30), ('G', 'H'), ('Sai', 21), ('Sarala', 28), ('Suman', 29)]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_839", "n_instr": 72} {"i": 178, "src_path": "src/00178.py", "pyc_path": "pyc/00178.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME Check_Solution\n RETURN_CONST None\nEND\nCODE Check_Solution(a, b, c)\n RESUME 0\n LOAD_FAST b\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Yes'\nL1:\n RETURN_CONST 'No'\nEND", "expected": "def Check_Solution(a, b, c):\n if b == 0:\n return 'Yes'\n else:\n return 'No'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 840, "mbpp_split": "train", "prompt": "Write a python function to check whether the roots of a quadratic equation are numerically equal but opposite in sign or not.", "test_list": ["assert Check_Solution(2,0,-1) == \"Yes\"", "assert Check_Solution(1,-5,6) == \"No\"", "assert Check_Solution(2,0,2) == \"Yes\""], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_840", "n_instr": 16} {"i": 179, "src_path": "src/00179.py", "pyc_path": "pyc/00179.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_inv_count\n RETURN_CONST None\nEND\nCODE get_inv_count(arr, n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST inv_count\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L5\n STORE_FAST i\n LOAD_GLOBAL NULL + range\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST n\n CALL 2\n GET_ITER\nL2:\n FOR_ITER L4\n STORE_FAST j\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST j\n BINARY_SUBSCR\n COMPARE_OP >\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L2\nL3:\n LOAD_FAST inv_count\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST inv_count\n JUMP_BACKWARD L2\nL4:\n END_FOR\n JUMP_BACKWARD L1\nL5:\n END_FOR\n LOAD_FAST inv_count\n RETURN_VALUE\nEND", "expected": "def get_inv_count(arr, n):\n inv_count = 0\n for i in range(n):\n for j in range(i + 1, n):\n if arr[i] > arr[j]:\n inv_count += 1\n return inv_count", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 841, "mbpp_split": "train", "prompt": "Write a function to count the number of inversions in the given array.", "test_list": ["assert get_inv_count([1, 20, 6, 4, 5], 5) == 5", "assert get_inv_count([8, 4, 2, 1], 4) == 6", "assert get_inv_count([3, 1, 2], 3) == 2"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_841", "n_instr": 50} {"i": 180, "src_path": "src/00180.py", "pyc_path": "pyc/00180.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_odd_occurence\n RETURN_CONST None\nEND\nCODE get_odd_occurence(arr, arr_size)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_FAST arr_size\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L6\n STORE_FAST i\n LOAD_CONST 0\n STORE_FAST count\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_FAST arr_size\n CALL 2\n GET_ITER\nL2:\n FOR_ITER L4\n STORE_FAST j\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST j\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L2\nL3:\n LOAD_FAST count\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST count\n JUMP_BACKWARD L2\nL4:\n END_FOR\n LOAD_FAST count\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L5\n JUMP_BACKWARD L1\nL5:\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n SWAP 2\n POP_TOP\n RETURN_VALUE\nL6:\n END_FOR\n RETURN_CONST -1\nEND", "expected": "def get_odd_occurence(arr, arr_size):\n for i in range(0, arr_size):\n count = 0\n for j in range(0, arr_size):\n if arr[i] == arr[j]:\n count += 1\n if count % 2 != 0:\n return arr[i]\n return -1", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 842, "mbpp_split": "train", "prompt": "Write a function to find the number which occurs for odd number of times in the given array.", "test_list": ["assert get_odd_occurence([2, 3, 5, 4, 5, 2, 4, 3, 5, 2, 4, 4, 2], 13) == 5", "assert get_odd_occurence([1, 2, 3, 2, 3, 1, 3], 7) == 3", "assert get_odd_occurence([5, 7, 2, 7, 5, 2, 5], 7) == 5"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_842", "n_instr": 61} {"i": 181, "src_path": "src/00181.py", "pyc_path": "pyc/00181.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME heapq\n STORE_NAME heapq\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME nth_super_ugly_number\n RETURN_CONST None\nEND\nCODE nth_super_ugly_number(n, primes)\n MAKE_CELL uglies\n RESUME 0\n LOAD_CONST 1\n BUILD_LIST 1\n STORE_DEREF uglies\n LOAD_CLOSURE uglies\n BUILD_TUPLE 1\n LOAD_CONST .gen>\n MAKE_FUNCTION closure\n STORE_FAST gen\n LOAD_GLOBAL NULL + heapq\n LOAD_ATTR merge\n LOAD_GLOBAL NULL + map\n LOAD_FAST gen\n LOAD_FAST primes\n CALL 2\n CALL_FUNCTION_EX 0\n STORE_FAST merged\n LOAD_GLOBAL NULL + len\n LOAD_DEREF uglies\n CALL 1\n LOAD_FAST n\n COMPARE_OP <\n POP_JUMP_IF_FALSE L3\nL1:\n LOAD_GLOBAL NULL + next\n LOAD_FAST merged\n CALL 1\n STORE_FAST ugly\n LOAD_FAST ugly\n LOAD_DEREF uglies\n LOAD_CONST -1\n BINARY_SUBSCR\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L2\n LOAD_DEREF uglies\n LOAD_ATTR NULL|self + append\n LOAD_FAST ugly\n CALL 1\n POP_TOP\nL2:\n LOAD_GLOBAL NULL + len\n LOAD_DEREF uglies\n CALL 1\n LOAD_FAST n\n COMPARE_OP <\n POP_JUMP_IF_FALSE L3\n JUMP_BACKWARD L1\nL3:\n LOAD_DEREF uglies\n LOAD_CONST -1\n BINARY_SUBSCR\n RETURN_VALUE\nEND\nCODE nth_super_ugly_number..gen(prime)\n COPY_FREE_VARS 1\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_DEREF uglies\n GET_ITER\nL2:\n FOR_ITER L3\n STORE_FAST ugly\n LOAD_FAST ugly\n LOAD_FAST prime\n BINARY_OP *\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "import heapq\n\ndef nth_super_ugly_number(n, primes):\n uglies = [1]\n\n def gen(prime):\n for ugly in uglies:\n yield (ugly * prime)\n merged = heapq.merge(*map(gen, primes))\n while len(uglies) < n:\n ugly = next(merged)\n if ugly != uglies[-1]:\n uglies.append(ugly)\n return uglies[-1]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 843, "mbpp_split": "train", "prompt": "Write a function to find the nth super ugly number from a given prime list of size k using heap queue algorithm.", "test_list": ["assert nth_super_ugly_number(12,[2,7,13,19])==32", "assert nth_super_ugly_number(10,[2,7,13,19])==26", "assert nth_super_ugly_number(100,[2,7,13,19])==5408"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_843", "n_instr": 91} {"i": 182, "src_path": "src/00182.py", "pyc_path": "pyc/00182.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_Digits\n RETURN_CONST None\nEND\nCODE find_Digits(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 0\n COMPARE_OP <\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 0\nL1:\n LOAD_FAST n\n LOAD_CONST 1\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L2\n RETURN_CONST 1\nL2:\n LOAD_FAST n\n LOAD_GLOBAL NULL + math\n LOAD_ATTR log10\n LOAD_FAST n\n LOAD_GLOBAL math\n LOAD_ATTR e\n BINARY_OP /\n CALL 1\n BINARY_OP *\n LOAD_GLOBAL NULL + math\n LOAD_ATTR log10\n LOAD_CONST 2\n LOAD_GLOBAL math\n LOAD_ATTR pi\n BINARY_OP *\n LOAD_FAST n\n BINARY_OP *\n CALL 1\n LOAD_CONST 2.0\n BINARY_OP /\n BINARY_OP +\n STORE_FAST x\n LOAD_GLOBAL NULL + math\n LOAD_ATTR floor\n LOAD_FAST x\n CALL 1\n LOAD_CONST 1\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "import math\n\ndef find_Digits(n):\n if n < 0:\n return 0\n if n <= 1:\n return 1\n x = n * math.log10(n / math.e) + math.log10(2 * math.pi * n) / 2.0\n return math.floor(x) + 1", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 845, "mbpp_split": "train", "prompt": "Write a python function to count the number of digits in factorial of a given number.", "test_list": ["assert find_Digits(7) == 4", "assert find_Digits(5) == 3", "assert find_Digits(4) == 2"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_845", "n_instr": 54} {"i": 183, "src_path": "src/00183.py", "pyc_path": "pyc/00183.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME Sum\n RETURN_CONST None\nEND\nCODE Sum(N)\n RESUME 0\n LOAD_CONST 0\n BUILD_LIST 1\n LOAD_FAST N\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP *\n STORE_FAST SumOfPrimeDivisors\n LOAD_GLOBAL NULL + range\n LOAD_CONST 2\n LOAD_FAST N\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L5\n STORE_FAST i\n LOAD_FAST SumOfPrimeDivisors\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_GLOBAL NULL + range\n LOAD_FAST i\n LOAD_FAST N\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST i\n CALL 3\n GET_ITER\nL3:\n FOR_ITER L4\n STORE_FAST j\n LOAD_FAST SumOfPrimeDivisors\n LOAD_FAST j\n COPY 2\n COPY 2\n BINARY_SUBSCR\n LOAD_FAST i\n BINARY_OP +=\n SWAP 3\n SWAP 2\n STORE_SUBSCR\n JUMP_BACKWARD L3\nL4:\n END_FOR\n JUMP_BACKWARD L1\nL5:\n END_FOR\n LOAD_FAST SumOfPrimeDivisors\n LOAD_FAST N\n BINARY_SUBSCR\n RETURN_VALUE\nEND", "expected": "def Sum(N):\n SumOfPrimeDivisors = [0] * (N + 1)\n for i in range(2, N + 1):\n if SumOfPrimeDivisors[i] == 0:\n for j in range(i, N + 1, i):\n SumOfPrimeDivisors[j] += i\n return SumOfPrimeDivisors[N]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 849, "mbpp_split": "train", "prompt": "Write a python function to find sum of all prime divisors of a given number.", "test_list": ["assert Sum(60) == 10", "assert Sum(39) == 16", "assert Sum(40) == 7"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_849", "n_instr": 65} {"i": 184, "src_path": "src/00184.py", "pyc_path": "pyc/00184.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_triangleexists\n RETURN_CONST None\nEND\nCODE is_triangleexists(a, b, c)\n RESUME 0\n LOAD_FAST a\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L3\n LOAD_FAST b\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L3\n LOAD_FAST c\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L3\n LOAD_FAST a\n LOAD_FAST b\n BINARY_OP +\n LOAD_FAST c\n BINARY_OP +\n LOAD_CONST 180\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n LOAD_FAST a\n LOAD_FAST b\n BINARY_OP +\n LOAD_FAST c\n COMPARE_OP >=\n POP_JUMP_IF_TRUE L1\n LOAD_FAST b\n LOAD_FAST c\n BINARY_OP +\n LOAD_FAST a\n COMPARE_OP >=\n POP_JUMP_IF_TRUE L1\n LOAD_FAST a\n LOAD_FAST c\n BINARY_OP +\n LOAD_FAST b\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L2\nL1:\n RETURN_CONST True\nL2:\n RETURN_CONST False\nL3:\n RETURN_CONST False\nEND", "expected": "def is_triangleexists(a, b, c):\n if a != 0 and b != 0 and (c != 0) and (a + b + c == 180):\n if a + b >= c or b + c >= a or a + c >= b:\n return True\n else:\n return False\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 850, "mbpp_split": "train", "prompt": "Write a function to check if a triangle of positive area is possible with the given angles.", "test_list": ["assert is_triangleexists(50,60,70)==True", "assert is_triangleexists(90,45,45)==True", "assert is_triangleexists(150,30,70)==False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_850", "n_instr": 53} {"i": 185, "src_path": "src/00185.py", "pyc_path": "pyc/00185.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME Sum_of_Inverse_Divisors\n RETURN_CONST None\nEND\nCODE Sum_of_Inverse_Divisors(N, Sum)\n RESUME 0\n LOAD_GLOBAL NULL + float\n LOAD_FAST Sum\n CALL 1\n LOAD_CONST 1.0\n BINARY_OP *\n LOAD_GLOBAL NULL + float\n LOAD_FAST N\n CALL 1\n BINARY_OP /\n STORE_FAST ans\n LOAD_GLOBAL NULL + round\n LOAD_FAST ans\n LOAD_CONST 2\n CALL 2\n RETURN_VALUE\nEND", "expected": "def Sum_of_Inverse_Divisors(N, Sum):\n ans = float(Sum) * 1.0 / float(N)\n return round(ans, 2)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 851, "mbpp_split": "train", "prompt": "Write a python function to find sum of inverse of divisors.", "test_list": ["assert Sum_of_Inverse_Divisors(6,12) == 2", "assert Sum_of_Inverse_Divisors(9,13) == 1.44", "assert Sum_of_Inverse_Divisors(1,4) == 4"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_851", "n_instr": 24} {"i": 186, "src_path": "src/00186.py", "pyc_path": "pyc/00186.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove_negs\n RETURN_CONST None\nEND\nCODE remove_negs(num_list)\n RESUME 0\n LOAD_FAST num_list\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST item\n LOAD_FAST item\n LOAD_CONST 0\n COMPARE_OP <\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST num_list\n LOAD_ATTR NULL|self + remove\n LOAD_FAST item\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST num_list\n RETURN_VALUE\nEND", "expected": "def remove_negs(num_list):\n for item in num_list:\n if item < 0:\n num_list.remove(item)\n return num_list", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 852, "mbpp_split": "train", "prompt": "Write a python function to remove negative numbers from a list.", "test_list": ["assert remove_negs([1,-2,3,-4]) == [1,3]", "assert remove_negs([1,2,3,-4]) == [1,2,3]", "assert remove_negs([4,5,-6,7,-8]) == [4,5,7]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_852", "n_instr": 30} {"i": 187, "src_path": "src/00187.py", "pyc_path": "pyc/00187.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_of_odd_Factors\n RETURN_CONST None\nEND\nCODE sum_of_odd_Factors(n)\n RESUME 0\n LOAD_CONST 1\n STORE_FAST res\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP //\n STORE_FAST n\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_GLOBAL NULL + range\n LOAD_CONST 3\n LOAD_GLOBAL NULL + int\n LOAD_GLOBAL NULL + math\n LOAD_ATTR sqrt\n LOAD_FAST n\n CALL 1\n LOAD_CONST 1\n BINARY_OP +\n CALL 1\n CALL 2\n GET_ITER\nL3:\n FOR_ITER L6\n STORE_FAST i\n LOAD_CONST 0\n STORE_FAST count\n LOAD_CONST 1\n STORE_FAST curr_sum\n LOAD_CONST 1\n STORE_FAST curr_term\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L5\nL4:\n LOAD_FAST count\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST count\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP //\n STORE_FAST n\n LOAD_FAST curr_term\n LOAD_FAST i\n BINARY_OP *=\n STORE_FAST curr_term\n LOAD_FAST curr_sum\n LOAD_FAST curr_term\n BINARY_OP +=\n STORE_FAST curr_sum\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L5\n JUMP_BACKWARD L4\nL5:\n LOAD_FAST res\n LOAD_FAST curr_sum\n BINARY_OP *=\n STORE_FAST res\n JUMP_BACKWARD L3\nL6:\n END_FOR\n LOAD_FAST n\n LOAD_CONST 2\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L7\n LOAD_FAST res\n LOAD_CONST 1\n LOAD_FAST n\n BINARY_OP +\n BINARY_OP *=\n STORE_FAST res\nL7:\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "import math\n\ndef sum_of_odd_Factors(n):\n res = 1\n while n % 2 == 0:\n n = n // 2\n for i in range(3, int(math.sqrt(n) + 1)):\n count = 0\n curr_sum = 1\n curr_term = 1\n while n % i == 0:\n count += 1\n n = n // i\n curr_term *= i\n curr_sum += curr_term\n res *= curr_sum\n if n >= 2:\n res *= 1 + n\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 853, "mbpp_split": "train", "prompt": "Write a python function to find sum of odd factors of a number.", "test_list": ["assert sum_of_odd_Factors(30) == 24", "assert sum_of_odd_Factors(18) == 13", "assert sum_of_odd_Factors(2) == 1"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_853", "n_instr": 106} {"i": 188, "src_path": "src/00188.py", "pyc_path": "pyc/00188.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME heapq\n STORE_NAME hq\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME raw_heap\n RETURN_CONST None\nEND\nCODE raw_heap(rawheap)\n RESUME 0\n LOAD_GLOBAL NULL + hq\n LOAD_ATTR heapify\n LOAD_FAST rawheap\n CALL 1\n POP_TOP\n LOAD_FAST rawheap\n RETURN_VALUE\nEND", "expected": "import heapq as hq\n\ndef raw_heap(rawheap):\n hq.heapify(rawheap)\n return rawheap", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 854, "mbpp_split": "train", "prompt": "Write a function which accepts an arbitrary list and converts it to a heap using heap queue algorithm.", "test_list": ["assert raw_heap([25, 44, 68, 21, 39, 23, 89])==[21, 25, 23, 44, 39, 68, 89]", "assert raw_heap([25, 35, 22, 85, 14, 65, 75, 25, 58])== [14, 25, 22, 25, 35, 65, 75, 85, 58]", "assert raw_heap([4, 5, 6, 2])==[2, 4, 6, 5]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_854", "n_instr": 20} {"i": 189, "src_path": "src/00189.py", "pyc_path": "pyc/00189.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_Even_Parity\n RETURN_CONST None\nEND\nCODE check_Even_Parity(x)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST parity\n LOAD_FAST x\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_FAST x\n LOAD_FAST x\n LOAD_CONST 1\n BINARY_OP -\n BINARY_OP &\n STORE_FAST x\n LOAD_FAST parity\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST parity\n LOAD_FAST x\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST parity\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n RETURN_CONST True\nL3:\n RETURN_CONST False\nEND", "expected": "def check_Even_Parity(x):\n parity = 0\n while x != 0:\n x = x & x - 1\n parity += 1\n if parity % 2 == 0:\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 855, "mbpp_split": "train", "prompt": "Write a python function to check for even parity of a given number.", "test_list": ["assert check_Even_Parity(10) == True", "assert check_Even_Parity(11) == False", "assert check_Even_Parity(18) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_855", "n_instr": 41} {"i": 190, "src_path": "src/00190.py", "pyc_path": "pyc/00190.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_list\n RETURN_CONST None\nEND\nCODE count_list(input_list)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST input_list\n CALL 1\n LOAD_CONST 2\n BINARY_OP **\n RETURN_VALUE\nEND", "expected": "def count_list(input_list):\n return len(input_list) ** 2", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 858, "mbpp_split": "train", "prompt": "Write a function to count number of lists in a given list of lists and square the count.", "test_list": ["assert count_list([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==25", "assert count_list([[1, 3], [5, 7], [9, 11], [13, 15, 17]] )==16", "assert count_list([[2, 4], [[6,8], [4,5,8]], [10, 12, 14]])==9"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_858", "n_instr": 15} {"i": 191, "src_path": "src/00191.py", "pyc_path": "pyc/00191.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('combinations',)\n IMPORT_NAME itertools\n IMPORT_FROM combinations\n STORE_NAME combinations\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sub_lists\n RETURN_CONST None\nEND\nCODE sub_lists(my_list)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST subs\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST my_list\n CALL 1\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L7\n STORE_FAST i\n LOAD_GLOBAL NULL + combinations\n LOAD_FAST my_list\n LOAD_FAST i\n CALL 2\n GET_ITER\n LOAD_FAST_AND_CLEAR x\n SWAP 2\nL2:\n BUILD_LIST 0\n SWAP 2\nL3:\n FOR_ITER L4\n STORE_FAST x\n LOAD_GLOBAL NULL + list\n LOAD_FAST x\n CALL 1\n LIST_APPEND 2\n JUMP_BACKWARD L3\nL4:\n END_FOR\nL5:\n STORE_FAST temp\n STORE_FAST x\n LOAD_GLOBAL NULL + len\n LOAD_FAST temp\n CALL 1\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_TRUE L6\n JUMP_BACKWARD L1\nL6:\n LOAD_FAST subs\n LOAD_ATTR NULL|self + extend\n LOAD_FAST temp\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL7:\n END_FOR\n LOAD_FAST subs\n RETURN_VALUE\nL8:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST x\n RERAISE 0\n EXC try=L2..L5 -> handler=L8 depth=3 lasti=False\nEND", "expected": "from itertools import combinations\n\ndef sub_lists(my_list):\n subs = []\n for i in range(0, len(my_list) + 1):\n temp = [list(x) for x in combinations(my_list, i)]\n if len(temp) > 0:\n subs.extend(temp)\n return subs", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 859, "mbpp_split": "train", "prompt": "Write a function to generate all sublists of a given list.", "test_list": ["assert sub_lists([10, 20, 30, 40])==[[], [10], [20], [30], [40], [10, 20], [10, 30], [10, 40], [20, 30], [20, 40], [30, 40], [10, 20, 30], [10, 20, 40], [10, 30, 40], [20, 30, 40], [10, 20, 30, 40]]", "assert sub_lists(['X', 'Y', 'Z'])==[[], ['X'], ['Y'], ['Z'], ['X', 'Y'], ['X', 'Z'], ['Y', 'Z'], ['X', 'Y', 'Z']]", "assert sub_lists([1,2,3])==[[],[1],[2],[3],[1,2],[1,3],[2,3],[1,2,3]]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_859", "n_instr": 77} {"i": 192, "src_path": "src/00192.py", "pyc_path": "pyc/00192.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST '[a-zA-z0-9]$'\n STORE_NAME regex\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_alphanumeric\n RETURN_CONST None\nEND\nCODE check_alphanumeric(string)\n RESUME 0\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_GLOBAL regex\n LOAD_FAST string\n CALL 2\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Accept'\nL1:\n RETURN_CONST 'Discard'\nEND", "expected": "import re\nregex = '[a-zA-z0-9]$'\n\ndef check_alphanumeric(string):\n if re.search(regex, string):\n return 'Accept'\n else:\n return 'Discard'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 860, "mbpp_split": "train", "prompt": "Write a function to check whether the given string is ending with only alphanumeric characters or not using regex.", "test_list": ["assert check_alphanumeric(\"dawood@\") == 'Discard'", "assert check_alphanumeric(\"skdmsam326\") == 'Accept'", "assert check_alphanumeric(\"cooltricks@\") == 'Discard'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_860", "n_instr": 24} {"i": 193, "src_path": "src/00193.py", "pyc_path": "pyc/00193.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('Counter',)\n IMPORT_NAME collections\n IMPORT_FROM Counter\n STORE_NAME Counter\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME anagram_lambda\n RETURN_CONST None\nEND\nCODE anagram_lambda(texts, str)\n MAKE_CELL str\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + filter\n LOAD_CLOSURE str\n BUILD_TUPLE 1\n LOAD_CONST .>\n MAKE_FUNCTION closure\n LOAD_FAST texts\n CALL 2\n CALL 1\n STORE_FAST result\n LOAD_FAST result\n RETURN_VALUE\nEND\nCODE anagram_lambda..(x)\n COPY_FREE_VARS 1\n RESUME 0\n LOAD_GLOBAL NULL + Counter\n LOAD_DEREF str\n CALL 1\n LOAD_GLOBAL NULL + Counter\n LOAD_FAST x\n CALL 1\n COMPARE_OP ==\n RETURN_VALUE\nEND", "expected": "from collections import Counter\n\ndef anagram_lambda(texts, str):\n result = list(filter(lambda x: Counter(str) == Counter(x), texts))\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 861, "mbpp_split": "train", "prompt": "Write a function to find all anagrams of a string in a given list of strings using lambda function.", "test_list": ["assert anagram_lambda([\"bcda\", \"abce\", \"cbda\", \"cbea\", \"adcb\"],\"abcd\")==['bcda', 'cbda', 'adcb']", "assert anagram_lambda([\"recitals\",\" python\"], \"articles\" )==[\"recitals\"]", "assert anagram_lambda([\" keep\",\" abcdef\",\" xyz\"],\" peek\")==[\" keep\"]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_861", "n_instr": 40} {"i": 194, "src_path": "src/00194.py", "pyc_path": "pyc/00194.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('Counter',)\n IMPORT_NAME collections\n IMPORT_FROM Counter\n STORE_NAME Counter\n POP_TOP\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME n_common_words\n RETURN_CONST None\nEND\nCODE n_common_words(text, n)\n RESUME 0\n LOAD_GLOBAL NULL + re\n LOAD_ATTR findall\n LOAD_CONST '\\\\w+'\n LOAD_FAST text\n CALL 2\n STORE_FAST words\n LOAD_GLOBAL NULL + Counter\n LOAD_FAST words\n CALL 1\n LOAD_ATTR NULL|self + most_common\n LOAD_FAST n\n CALL 1\n STORE_FAST n_common_words\n LOAD_GLOBAL NULL + list\n LOAD_FAST n_common_words\n CALL 1\n RETURN_VALUE\nEND", "expected": "from collections import Counter\nimport re\n\ndef n_common_words(text, n):\n words = re.findall('\\\\w+', text)\n n_common_words = Counter(words).most_common(n)\n return list(n_common_words)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 862, "mbpp_split": "train", "prompt": "Write a function to find the occurrences of n most common words in a given text.", "test_list": ["assert n_common_words(\"python is a programming language\",1)==[('python', 1)]", "assert n_common_words(\"python is a programming language\",1)==[('python', 1)]", "assert n_common_words(\"python is a programming language\",5)==[('python', 1),('is', 1), ('a', 1), ('programming', 1), ('language', 1)]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_862", "n_instr": 36} {"i": 195, "src_path": "src/00195.py", "pyc_path": "pyc/00195.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME palindrome_lambda\n RETURN_CONST None\nEND\nCODE palindrome_lambda(texts)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + filter\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST texts\n CALL 2\n CALL 1\n STORE_FAST result\n LOAD_FAST result\n RETURN_VALUE\nEND\nCODE palindrome_lambda..(x)\n RESUME 0\n LOAD_FAST x\n LOAD_CONST ''\n LOAD_ATTR NULL|self + join\n LOAD_GLOBAL NULL + reversed\n LOAD_FAST x\n CALL 1\n CALL 1\n COMPARE_OP ==\n RETURN_VALUE\nEND", "expected": "def palindrome_lambda(texts):\n result = list(filter(lambda x: x == ''.join(reversed(x)), texts))\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 864, "mbpp_split": "train", "prompt": "Write a function to find palindromes in a given list of strings using lambda function.", "test_list": ["assert palindrome_lambda([\"php\", \"res\", \"Python\", \"abcd\", \"Java\", \"aaa\"])==['php', 'aaa']", "assert palindrome_lambda([\"abcd\", \"Python\", \"abba\", \"aba\"])==['abba', 'aba']", "assert palindrome_lambda([\"abcd\", \"abbccbba\", \"abba\", \"aba\"])==['abbccbba', 'abba', 'aba']"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_864", "n_instr": 31} {"i": 196, "src_path": "src/00196.py", "pyc_path": "pyc/00196.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME ntimes_list\n RETURN_CONST None\nEND\nCODE ntimes_list(nums, n)\n MAKE_CELL n\n RESUME 0\n LOAD_GLOBAL NULL + map\n LOAD_CLOSURE n\n BUILD_TUPLE 1\n LOAD_CONST .>\n MAKE_FUNCTION closure\n LOAD_FAST nums\n CALL 2\n STORE_FAST result\n LOAD_GLOBAL NULL + list\n LOAD_FAST result\n CALL 1\n RETURN_VALUE\nEND\nCODE ntimes_list..(x)\n COPY_FREE_VARS 1\n RESUME 0\n LOAD_DEREF n\n LOAD_FAST x\n BINARY_OP *\n RETURN_VALUE\nEND", "expected": "def ntimes_list(nums, n):\n result = map(lambda x: n * x, nums)\n return list(result)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 865, "mbpp_split": "train", "prompt": "Write a function to print n-times a list using map function.", "test_list": ["assert ntimes_list([1, 2, 3, 4, 5, 6, 7],3)==[3, 6, 9, 12, 15, 18, 21]", "assert ntimes_list([1, 2, 3, 4, 5, 6, 7],4)==[4, 8, 12, 16, 20, 24, 28]", "assert ntimes_list([1, 2, 3, 4, 5, 6, 7],10)==[10, 20, 30, 40, 50, 60, 70]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_865", "n_instr": 30} {"i": 197, "src_path": "src/00197.py", "pyc_path": "pyc/00197.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_monthnumb\n RETURN_CONST None\nEND\nCODE check_monthnumb(monthname2)\n RESUME 0\n LOAD_FAST monthname2\n LOAD_CONST 'January'\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L1\n LOAD_FAST monthname2\n LOAD_CONST 'March'\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L1\n LOAD_FAST monthname2\n LOAD_CONST 'May'\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L1\n LOAD_FAST monthname2\n LOAD_CONST 'July'\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L1\n LOAD_FAST monthname2\n LOAD_CONST 'Augest'\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L1\n LOAD_FAST monthname2\n LOAD_CONST 'October'\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L1\n LOAD_FAST monthname2\n LOAD_CONST 'December'\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\nL1:\n RETURN_CONST True\nL2:\n RETURN_CONST False\nEND", "expected": "def check_monthnumb(monthname2):\n if monthname2 == 'January' or monthname2 == 'March' or monthname2 == 'May' or (monthname2 == 'July') or (monthname2 == 'Augest') or (monthname2 == 'October') or (monthname2 == 'December'):\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 866, "mbpp_split": "train", "prompt": "Write a function to check whether the given month name contains 31 days or not.", "test_list": ["assert check_monthnumb(\"February\")==False", "assert check_monthnumb(\"January\")==True", "assert check_monthnumb(\"March\")==True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_866", "n_instr": 41} {"i": 198, "src_path": "src/00198.py", "pyc_path": "pyc/00198.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME min_Num\n RETURN_CONST None\nEND\nCODE min_Num(arr, n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST odd\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST 2\n BINARY_OP %\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST odd\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST odd\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST odd\n LOAD_CONST 2\n BINARY_OP %\n POP_JUMP_IF_FALSE L4\n RETURN_CONST 1\nL4:\n RETURN_CONST 2\nEND", "expected": "def min_Num(arr, n):\n odd = 0\n for i in range(n):\n if arr[i] % 2:\n odd += 1\n if odd % 2:\n return 1\n return 2", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 867, "mbpp_split": "train", "prompt": "Write a python function to add a minimum number such that the sum of array becomes even.", "test_list": ["assert min_Num([1,2,3,4,5,6,7,8,9],9) == 1", "assert min_Num([1,2,3,4,5,6,7,8],8) == 2", "assert min_Num([1,2,3],3) == 2"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_867", "n_instr": 40} {"i": 199, "src_path": "src/00199.py", "pyc_path": "pyc/00199.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME length_Of_Last_Word\n RETURN_CONST None\nEND\nCODE length_Of_Last_Word(a)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST l\n LOAD_FAST a\n LOAD_ATTR NULL|self + strip\n CALL 0\n STORE_FAST x\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST x\n CALL 1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST x\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST ' '\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_CONST 0\n STORE_FAST l\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST l\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST l\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST l\n RETURN_VALUE\nEND", "expected": "def length_Of_Last_Word(a):\n l = 0\n x = a.strip()\n for i in range(len(x)):\n if x[i] == ' ':\n l = 0\n else:\n l += 1\n return l", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 868, "mbpp_split": "train", "prompt": "Write a python function to find the length of the last word in a given string.", "test_list": ["assert length_Of_Last_Word(\"python language\") == 8", "assert length_Of_Last_Word(\"PHP\") == 3", "assert length_Of_Last_Word(\"\") == 0"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_868", "n_instr": 43} {"i": 200, "src_path": "src/00200.py", "pyc_path": "pyc/00200.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove_list_range\n RETURN_CONST None\nEND\nCODE remove_list_range(list1, leftrange, rigthrange)\n RESUME 0\n LOAD_FAST list1\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L7\n STORE_FAST i\n LOAD_GLOBAL NULL + min\n LOAD_FAST i\n CALL 1\n LOAD_FAST leftrange\n COMPARE_OP >=\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_GLOBAL NULL + max\n LOAD_FAST i\n CALL 1\n LOAD_FAST rigthrange\n COMPARE_OP <=\n POP_JUMP_IF_TRUE L6\nL5:\n JUMP_BACKWARD L2\nL6:\n LOAD_FAST i\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL7:\n END_FOR\nL8:\n STORE_FAST result\n STORE_FAST i\n LOAD_FAST result\n RETURN_VALUE\nL9:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\n EXC try=L1..L3 -> handler=L9 depth=2 lasti=False\n EXC try=L4..L5 -> handler=L9 depth=2 lasti=False\n EXC try=L6..L8 -> handler=L9 depth=2 lasti=False\nEND", "expected": "def remove_list_range(list1, leftrange, rigthrange):\n result = [i for i in list1 if min(i) >= leftrange and max(i) <= rigthrange]\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 869, "mbpp_split": "train", "prompt": "Write a function to remove sublists from a given list of lists, which are outside a given range.", "test_list": ["assert remove_list_range([[2], [0], [1, 2, 3], [0, 1, 2, 3, 6, 7], [9, 11], [13, 14, 15, 17]],13,17)==[[13, 14, 15, 17]]", "assert remove_list_range([[2], [0], [1, 2, 3], [0, 1, 2, 3, 6, 7], [9, 11], [13, 14, 15, 17]],1,3)==[[2], [1, 2, 3]]", "assert remove_list_range([[2], [0], [1, 2, 3], [0, 1, 2, 3, 6, 7], [9, 11], [13, 14, 15, 17]],0,7)==[[2], [0], [1, 2, 3], [0, 1, 2, 3, 6, 7]]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_869", "n_instr": 56} {"i": 201, "src_path": "src/00201.py", "pyc_path": "pyc/00201.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_positivenum\n RETURN_CONST None\nEND\nCODE sum_positivenum(nums)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + filter\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST nums\n CALL 2\n CALL 1\n STORE_FAST sum_positivenum\n LOAD_GLOBAL NULL + sum\n LOAD_FAST sum_positivenum\n CALL 1\n RETURN_VALUE\nEND\nCODE sum_positivenum..(nums)\n RESUME 0\n LOAD_FAST nums\n LOAD_CONST 0\n COMPARE_OP >\n RETURN_VALUE\nEND", "expected": "def sum_positivenum(nums):\n sum_positivenum = list(filter(lambda nums: nums > 0, nums))\n return sum(sum_positivenum)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 870, "mbpp_split": "train", "prompt": "Write a function to calculate the sum of the positive numbers of a given list of numbers using lambda function.", "test_list": ["assert sum_positivenum([2, 4, -6, -9, 11, -12, 14, -5, 17])==48", "assert sum_positivenum([10,15,-14,13,-18,12,-20])==50", "assert sum_positivenum([19, -65, 57, 39, 152,-639, 121, 44, 90, -190])==522"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_870", "n_instr": 28} {"i": 202, "src_path": "src/00202.py", "pyc_path": "pyc/00202.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME are_Rotations\n RETURN_CONST None\nEND\nCODE are_Rotations(string1, string2)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST string1\n CALL 1\n STORE_FAST size1\n LOAD_GLOBAL NULL + len\n LOAD_FAST string2\n CALL 1\n STORE_FAST size2\n LOAD_CONST ''\n STORE_FAST temp\n LOAD_FAST size1\n LOAD_FAST size2\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L1\n RETURN_CONST False\nL1:\n LOAD_FAST string1\n LOAD_FAST string1\n BINARY_OP +\n STORE_FAST temp\n LOAD_FAST temp\n LOAD_ATTR NULL|self + count\n LOAD_FAST string2\n CALL 1\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_FALSE L2\n RETURN_CONST True\nL2:\n RETURN_CONST False\nEND", "expected": "def are_Rotations(string1, string2):\n size1 = len(string1)\n size2 = len(string2)\n temp = ''\n if size1 != size2:\n return False\n temp = string1 + string1\n if temp.count(string2) > 0:\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 871, "mbpp_split": "train", "prompt": "Write a python function to check whether the given strings are rotations of each other or not.", "test_list": ["assert are_Rotations(\"abc\",\"cba\") == False", "assert are_Rotations(\"abcd\",\"cdba\") == False", "assert are_Rotations(\"abacd\",\"cdaba\") == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_871", "n_instr": 39} {"i": 203, "src_path": "src/00203.py", "pyc_path": "pyc/00203.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_subset\n RETURN_CONST None\nEND\nCODE check_subset(list1, list2)\n RESUME 0\n LOAD_GLOBAL NULL + all\n LOAD_GLOBAL NULL + map\n LOAD_FAST list1\n LOAD_ATTR __contains__\n LOAD_FAST list2\n CALL 2\n CALL 1\n RETURN_VALUE\nEND", "expected": "def check_subset(list1, list2):\n return all(map(list1.__contains__, list2))", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 872, "mbpp_split": "train", "prompt": "Write a function to check if a nested list is a subset of another nested list.", "test_list": ["assert check_subset([[1, 3], [5, 7], [9, 11], [13, 15, 17]] ,[[1, 3],[13,15,17]])==True", "assert check_subset([[1, 2], [2, 3], [3, 4], [5, 6]],[[3, 4], [5, 6]])==True", "assert check_subset([[[1, 2], [2, 3]], [[3, 4], [5, 7]]],[[[3, 4], [5, 6]]])==False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_872", "n_instr": 17} {"i": 204, "src_path": "src/00204.py", "pyc_path": "pyc/00204.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME fibonacci\n RETURN_CONST None\nEND\nCODE fibonacci(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L1\n LOAD_FAST n\n LOAD_CONST 2\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\nL1:\n RETURN_CONST 1\nL2:\n LOAD_GLOBAL NULL + fibonacci\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n LOAD_GLOBAL NULL + fibonacci\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP -\n CALL 1\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def fibonacci(n):\n if n == 1 or n == 2:\n return 1\n else:\n return fibonacci(n - 1) + fibonacci(n - 2)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 873, "mbpp_split": "train", "prompt": "Write a function to solve the fibonacci sequence using recursion.", "test_list": ["assert fibonacci(7) == 13", "assert fibonacci(8) == 21", "assert fibonacci(9) == 34"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_873", "n_instr": 32} {"i": 205, "src_path": "src/00205.py", "pyc_path": "pyc/00205.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_Concat\n RETURN_CONST None\nEND\nCODE check_Concat(str1, str2)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST str1\n CALL 1\n STORE_FAST N\n LOAD_GLOBAL NULL + len\n LOAD_FAST str2\n CALL 1\n STORE_FAST M\n LOAD_FAST N\n LOAD_FAST M\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L1\n RETURN_CONST False\nL1:\n LOAD_GLOBAL NULL + range\n LOAD_FAST N\n CALL 1\n GET_ITER\nL2:\n FOR_ITER L4\n STORE_FAST i\n LOAD_FAST str1\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST str2\n LOAD_FAST i\n LOAD_FAST M\n BINARY_OP %\n BINARY_SUBSCR\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L2\nL3:\n POP_TOP\n RETURN_CONST False\nL4:\n END_FOR\n RETURN_CONST True\nEND", "expected": "def check_Concat(str1, str2):\n N = len(str1)\n M = len(str2)\n if N % M != 0:\n return False\n for i in range(N):\n if str1[i] != str2[i % M]:\n return False\n return True", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 874, "mbpp_split": "train", "prompt": "Write a python function to check if the string is a concatenation of another string.", "test_list": ["assert check_Concat(\"abcabcabc\",\"abc\") == True", "assert check_Concat(\"abcab\",\"abc\") == False", "assert check_Concat(\"aba\",\"ab\") == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_874", "n_instr": 49} {"i": 206, "src_path": "src/00206.py", "pyc_path": "pyc/00206.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sort_String\n RETURN_CONST None\nEND\nCODE sort_String(str)\n RESUME 0\n LOAD_CONST ''\n LOAD_ATTR NULL|self + join\n LOAD_GLOBAL NULL + sorted\n LOAD_FAST str\n CALL 1\n CALL 1\n STORE_FAST str\n LOAD_FAST str\n RETURN_VALUE\nEND", "expected": "def sort_String(str):\n str = ''.join(sorted(str))\n return str", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 877, "mbpp_split": "train", "prompt": "Write a python function to sort the given string.", "test_list": ["assert sort_String(\"cba\") == \"abc\"", "assert sort_String(\"data\") == \"aadt\"", "assert sort_String(\"zxy\") == \"xyz\""], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_877", "n_instr": 18} {"i": 207, "src_path": "src/00207.py", "pyc_path": "pyc/00207.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_tuples\n RETURN_CONST None\nEND\nCODE check_tuples(test_tuple, K)\n MAKE_CELL K\n RESUME 0\n LOAD_GLOBAL NULL + all\n LOAD_CLOSURE K\n BUILD_TUPLE 1\n LOAD_CONST .>\n MAKE_FUNCTION closure\n LOAD_FAST test_tuple\n GET_ITER\n CALL 0\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND\nCODE check_tuples..(.0)\n COPY_FREE_VARS 1\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n STORE_FAST ele\n LOAD_FAST ele\n LOAD_DEREF K\n CONTAINS_OP 0\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def check_tuples(test_tuple, K):\n res = all((ele in K for ele in test_tuple))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 878, "mbpp_split": "train", "prompt": "Write a function to check if the given tuple contains only k elements.", "test_list": ["assert check_tuples((3, 5, 6, 5, 3, 6),[3, 6, 5]) == True", "assert check_tuples((4, 5, 6, 4, 6, 5),[4, 5, 6]) == True", "assert check_tuples((9, 8, 7, 6, 8, 9),[9, 8, 1]) == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_878", "n_instr": 47} {"i": 208, "src_path": "src/00208.py", "pyc_path": "pyc/00208.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_even_odd\n RETURN_CONST None\nEND\nCODE sum_even_odd(list1)\n RESUME 0\n LOAD_GLOBAL NULL + next\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST list1\n GET_ITER\n CALL 0\n LOAD_CONST -1\n CALL 2\n STORE_FAST first_even\n LOAD_GLOBAL NULL + next\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST list1\n GET_ITER\n CALL 0\n LOAD_CONST -1\n CALL 2\n STORE_FAST first_odd\n LOAD_FAST first_even\n LOAD_FAST first_odd\n BINARY_OP +\n RETURN_VALUE\nEND\nCODE sum_even_odd..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L5\n STORE_FAST el\n LOAD_FAST el\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST el\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL5:\n END_FOR\n RETURN_CONST None\nL6:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L3 -> handler=L6 depth=0 lasti=True\n EXC try=L4..L6 -> handler=L6 depth=0 lasti=True\nEND\nCODE sum_even_odd..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L5\n STORE_FAST el\n LOAD_FAST el\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST el\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL5:\n END_FOR\n RETURN_CONST None\nL6:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L3 -> handler=L6 depth=0 lasti=True\n EXC try=L4..L6 -> handler=L6 depth=0 lasti=True\nEND", "expected": "def sum_even_odd(list1):\n first_even = next((el for el in list1 if el % 2 == 0), -1)\n first_odd = next((el for el in list1 if el % 2 != 0), -1)\n return first_even + first_odd", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 881, "mbpp_split": "train", "prompt": "Write a function to find the sum of first even and odd number of a given list.", "test_list": ["assert sum_even_odd([1,3,5,7,4,1,6,8])==5", "assert sum_even_odd([1,2,3,4,5,6,7,8,9,10])==3", "assert sum_even_odd([1,5,7,9,10])==11"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_881", "n_instr": 95} {"i": 209, "src_path": "src/00209.py", "pyc_path": "pyc/00209.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME parallelogram_perimeter\n RETURN_CONST None\nEND\nCODE parallelogram_perimeter(b, h)\n RESUME 0\n LOAD_CONST 2\n LOAD_FAST b\n LOAD_FAST h\n BINARY_OP *\n BINARY_OP *\n STORE_FAST perimeter\n LOAD_FAST perimeter\n RETURN_VALUE\nEND", "expected": "def parallelogram_perimeter(b, h):\n perimeter = 2 * (b * h)\n return perimeter", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 882, "mbpp_split": "train", "prompt": "Write a function to caluclate perimeter of a parallelogram.", "test_list": ["assert parallelogram_perimeter(10,20)==400", "assert parallelogram_perimeter(15,20)==600", "assert parallelogram_perimeter(8,9)==144"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_882", "n_instr": 17} {"i": 210, "src_path": "src/00210.py", "pyc_path": "pyc/00210.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME div_of_nums\n RETURN_CONST None\nEND\nCODE div_of_nums(nums, m, n)\n MAKE_CELL m\n MAKE_CELL n\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + filter\n LOAD_CLOSURE m\n LOAD_CLOSURE n\n BUILD_TUPLE 2\n LOAD_CONST .>\n MAKE_FUNCTION closure\n LOAD_FAST nums\n CALL 2\n CALL 1\n STORE_FAST result\n LOAD_FAST result\n RETURN_VALUE\nEND\nCODE div_of_nums..(x)\n COPY_FREE_VARS 2\n RESUME 0\n LOAD_FAST x\n LOAD_DEREF m\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n COPY 1\n POP_JUMP_IF_FALSE L1\n POP_TOP\n LOAD_FAST x\n LOAD_DEREF n\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\nL1:\n RETURN_VALUE\nEND", "expected": "def div_of_nums(nums, m, n):\n result = list(filter(lambda x: x % m == 0 and x % n == 0, nums))\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 883, "mbpp_split": "train", "prompt": "Write a function to find numbers divisible by m and n from a list of numbers using lambda function.", "test_list": ["assert div_of_nums([19, 65, 57, 39, 152, 639, 121, 44, 90, 190],2,4)==[ 152,44]", "assert div_of_nums([1, 2, 3, 5, 7, 8, 10],2,5)==[10]", "assert div_of_nums([10,15,14,13,18,12,20],10,5)==[10,20]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_883", "n_instr": 43} {"i": 211, "src_path": "src/00211.py", "pyc_path": "pyc/00211.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_Isomorphic\n RETURN_CONST None\nEND\nCODE is_Isomorphic(str1, str2)\n RESUME 0\n BUILD_MAP 0\n STORE_FAST dict_str1\n BUILD_MAP 0\n STORE_FAST dict_str2\n LOAD_GLOBAL NULL + enumerate\n LOAD_FAST str1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L2\n UNPACK_SEQUENCE 2\n STORE_FAST i\n STORE_FAST value\n LOAD_FAST dict_str1\n LOAD_ATTR NULL|self + get\n LOAD_FAST value\n BUILD_LIST 0\n CALL 2\n LOAD_FAST i\n BUILD_LIST 1\n BINARY_OP +\n LOAD_FAST dict_str1\n LOAD_FAST value\n STORE_SUBSCR\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_GLOBAL NULL + enumerate\n LOAD_FAST str2\n CALL 1\n GET_ITER\nL3:\n FOR_ITER L4\n UNPACK_SEQUENCE 2\n STORE_FAST j\n STORE_FAST value\n LOAD_FAST dict_str2\n LOAD_ATTR NULL|self + get\n LOAD_FAST value\n BUILD_LIST 0\n CALL 2\n LOAD_FAST j\n BUILD_LIST 1\n BINARY_OP +\n LOAD_FAST dict_str2\n LOAD_FAST value\n STORE_SUBSCR\n JUMP_BACKWARD L3\nL4:\n END_FOR\n LOAD_GLOBAL NULL + sorted\n LOAD_FAST dict_str1\n LOAD_ATTR NULL|self + values\n CALL 0\n CALL 1\n LOAD_GLOBAL NULL + sorted\n LOAD_FAST dict_str2\n LOAD_ATTR NULL|self + values\n CALL 0\n CALL 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L5\n RETURN_CONST True\nL5:\n RETURN_CONST False\nEND", "expected": "def is_Isomorphic(str1, str2):\n dict_str1 = {}\n dict_str2 = {}\n for i, value in enumerate(str1):\n dict_str1[value] = dict_str1.get(value, []) + [i]\n for j, value in enumerate(str2):\n dict_str2[value] = dict_str2.get(value, []) + [j]\n if sorted(dict_str1.values()) == sorted(dict_str2.values()):\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 885, "mbpp_split": "train", "prompt": "Write a python function to check whether the two given strings are isomorphic to each other or not.", "test_list": ["assert is_Isomorphic(\"paper\",\"title\") == True", "assert is_Isomorphic(\"ab\",\"ba\") == True", "assert is_Isomorphic(\"ab\",\"aa\") == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_885", "n_instr": 74} {"i": 212, "src_path": "src/00212.py", "pyc_path": "pyc/00212.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_num\n RETURN_CONST None\nEND\nCODE sum_num(numbers)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST total\n LOAD_FAST numbers\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST x\n LOAD_FAST total\n LOAD_FAST x\n BINARY_OP +=\n STORE_FAST total\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST total\n LOAD_GLOBAL NULL + len\n LOAD_FAST numbers\n CALL 1\n BINARY_OP /\n RETURN_VALUE\nEND", "expected": "def sum_num(numbers):\n total = 0\n for x in numbers:\n total += x\n return total / len(numbers)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 886, "mbpp_split": "train", "prompt": "Write a function to add all the numbers in a list and divide it with the length of the list.", "test_list": ["assert sum_num((8, 2, 3, 0, 7))==4.0", "assert sum_num((-10,-20,-30))==-20.0", "assert sum_num((19,15,18))==17.333333333333332"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_886", "n_instr": 29} {"i": 213, "src_path": "src/00213.py", "pyc_path": "pyc/00213.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_odd\n RETURN_CONST None\nEND\nCODE is_odd(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP ^\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST True\nL1:\n RETURN_CONST False\nEND", "expected": "def is_odd(n):\n if n ^ 1 == n - 1:\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 887, "mbpp_split": "train", "prompt": "Write a python function to check whether the given number is odd or not using bitwise operator.", "test_list": ["assert is_odd(5) == True", "assert is_odd(6) == False", "assert is_odd(7) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_887", "n_instr": 20} {"i": 214, "src_path": "src/00214.py", "pyc_path": "pyc/00214.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME substract_elements\n RETURN_CONST None\nEND\nCODE substract_elements(test_tup1, test_tup2)\n RESUME 0\n LOAD_GLOBAL NULL + tuple\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_GLOBAL NULL + zip\n LOAD_FAST test_tup1\n LOAD_FAST test_tup2\n CALL 2\n GET_ITER\n CALL 0\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND\nCODE substract_elements..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST tup1\n STORE_FAST tup2\n LOAD_GLOBAL NULL + tuple\n LOAD_CONST ..>\n MAKE_FUNCTION 0\n LOAD_GLOBAL NULL + zip\n LOAD_FAST tup1\n LOAD_FAST tup2\n CALL 2\n GET_ITER\n CALL 0\n CALL 1\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND\nCODE substract_elements...(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST a\n STORE_FAST b\n LOAD_FAST a\n LOAD_FAST b\n BINARY_OP -\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def substract_elements(test_tup1, test_tup2):\n res = tuple((tuple((a - b for a, b in zip(tup1, tup2))) for tup1, tup2 in zip(test_tup1, test_tup2)))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 888, "mbpp_split": "train", "prompt": "Write a function to substract the elements of the given nested tuples.", "test_list": ["assert substract_elements(((1, 3), (4, 5), (2, 9), (1, 10)), ((6, 7), (3, 9), (1, 1), (7, 3))) == ((-5, -4), (1, -4), (1, 8), (-6, 7))", "assert substract_elements(((13, 4), (14, 6), (13, 10), (12, 11)), ((19, 8), (14, 10), (12, 2), (18, 4))) == ((-6, -4), (0, -4), (1, 8), (-6, 7))", "assert substract_elements(((19, 5), (18, 7), (19, 11), (17, 12)), ((12, 9), (17, 11), (13, 3), (19, 5))) == ((7, -4), (1, -4), (6, 8), (-2, 7))"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_888", "n_instr": 81} {"i": 215, "src_path": "src/00215.py", "pyc_path": "pyc/00215.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME reverse_list_lists\n RETURN_CONST None\nEND\nCODE reverse_list_lists(lists)\n RESUME 0\n LOAD_FAST lists\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST l\n LOAD_FAST l\n LOAD_ATTR NULL|self + sort\n LOAD_CONST True\n KW_NAMES ('reverse',)\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST lists\n RETURN_VALUE\nEND", "expected": "def reverse_list_lists(lists):\n for l in lists:\n l.sort(reverse=True)\n return lists", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 889, "mbpp_split": "train", "prompt": "Write a function to reverse each list in a given list of lists.", "test_list": ["assert reverse_list_lists([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])==[[4, 3, 2, 1], [8, 7, 6, 5], [12, 11, 10, 9], [16, 15, 14, 13]]", "assert reverse_list_lists([[1,2],[2,3],[3,4]])==[[2,1],[3,2],[4,3]]", "assert reverse_list_lists([[10,20],[30,40]])==[[20,10],[40,30]]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_889", "n_instr": 25} {"i": 216, "src_path": "src/00216.py", "pyc_path": "pyc/00216.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_Extra\n RETURN_CONST None\nEND\nCODE find_Extra(arr1, arr2, n)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_FAST n\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST arr1\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr2\n LOAD_FAST i\n BINARY_SUBSCR\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST i\n SWAP 2\n POP_TOP\n RETURN_VALUE\nL3:\n END_FOR\n LOAD_FAST n\n RETURN_VALUE\nEND", "expected": "def find_Extra(arr1, arr2, n):\n for i in range(0, n):\n if arr1[i] != arr2[i]:\n return i\n return n", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 890, "mbpp_split": "train", "prompt": "Write a python function to find the index of an extra element present in one sorted array.", "test_list": ["assert find_Extra([1,2,3,4],[1,2,3],3) == 3", "assert find_Extra([2,4,6,8,10],[2,4,6,8],4) == 4", "assert find_Extra([1,3,5,7,9,11],[1,3,5,7,9],5) == 5"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_890", "n_instr": 35} {"i": 217, "src_path": "src/00217.py", "pyc_path": "pyc/00217.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME same_Length\n RETURN_CONST None\nEND\nCODE same_Length(A, B)\n RESUME 0\n LOAD_FAST A\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_FALSE L2\n LOAD_FAST B\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_FAST A\n LOAD_CONST 10\n BINARY_OP /\n STORE_FAST A\n LOAD_FAST B\n LOAD_CONST 10\n BINARY_OP /\n STORE_FAST B\n LOAD_FAST A\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_FALSE L2\n LOAD_FAST B\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST A\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n LOAD_FAST B\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n RETURN_CONST True\nL3:\n RETURN_CONST False\nEND", "expected": "def same_Length(A, B):\n while A > 0 and B > 0:\n A = A / 10\n B = B / 10\n if A == 0 and B == 0:\n return True\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 891, "mbpp_split": "train", "prompt": "Write a python function to check whether the given two numbers have same number of digits or not.", "test_list": ["assert same_Length(12,1) == False", "assert same_Length(2,2) == True", "assert same_Length(10,20) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_891", "n_instr": 47} {"i": 218, "src_path": "src/00218.py", "pyc_path": "pyc/00218.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME max_sum_subseq\n RETURN_CONST None\nEND\nCODE max_sum_subseq(A)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST A\n CALL 1\n STORE_FAST n\n LOAD_FAST n\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n LOAD_FAST A\n LOAD_CONST 0\n BINARY_SUBSCR\n RETURN_VALUE\nL1:\n LOAD_CONST None\n BUILD_LIST 1\n LOAD_FAST n\n BINARY_OP *\n STORE_FAST look_up\n LOAD_FAST A\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST look_up\n LOAD_CONST 0\n STORE_SUBSCR\n LOAD_GLOBAL NULL + max\n LOAD_FAST A\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST A\n LOAD_CONST 1\n BINARY_SUBSCR\n CALL 2\n LOAD_FAST look_up\n LOAD_CONST 1\n STORE_SUBSCR\n LOAD_GLOBAL NULL + range\n LOAD_CONST 2\n LOAD_FAST n\n CALL 2\n GET_ITER\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_GLOBAL NULL + max\n LOAD_FAST look_up\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n LOAD_FAST look_up\n LOAD_FAST i\n LOAD_CONST 2\n BINARY_OP -\n BINARY_SUBSCR\n LOAD_FAST A\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_OP +\n CALL 2\n LOAD_FAST look_up\n LOAD_FAST i\n STORE_SUBSCR\n LOAD_GLOBAL NULL + max\n LOAD_FAST look_up\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST A\n LOAD_FAST i\n BINARY_SUBSCR\n CALL 2\n LOAD_FAST look_up\n LOAD_FAST i\n STORE_SUBSCR\n JUMP_BACKWARD L2\nL3:\n END_FOR\n LOAD_FAST look_up\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n RETURN_VALUE\nEND", "expected": "def max_sum_subseq(A):\n n = len(A)\n if n == 1:\n return A[0]\n look_up = [None] * n\n look_up[0] = A[0]\n look_up[1] = max(A[0], A[1])\n for i in range(2, n):\n look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])\n look_up[i] = max(look_up[i], A[i])\n return look_up[n - 1]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 895, "mbpp_split": "train", "prompt": "Write a function to find the maximum sum of subsequences of given array with no adjacent elements.", "test_list": ["assert max_sum_subseq([1, 2, 9, 4, 5, 0, 4, 11, 6]) == 26", "assert max_sum_subseq([1, 2, 9, 5, 6, 0, 5, 12, 7]) == 28", "assert max_sum_subseq([1, 3, 10, 5, 6, 0, 6, 14, 21]) == 44"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_895", "n_instr": 91} {"i": 219, "src_path": "src/00219.py", "pyc_path": "pyc/00219.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME last\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sort_list_last\n RETURN_CONST None\nEND\nCODE last(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST -1\n BINARY_SUBSCR\n RETURN_VALUE\nEND\nCODE sort_list_last(tuples)\n RESUME 0\n LOAD_GLOBAL NULL + sorted\n LOAD_FAST tuples\n LOAD_GLOBAL last\n KW_NAMES ('key',)\n CALL 2\n RETURN_VALUE\nEND", "expected": "def last(n):\n return n[-1]\n\ndef sort_list_last(tuples):\n return sorted(tuples, key=last)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 896, "mbpp_split": "train", "prompt": "Write a function to sort a list in increasing order by the last element in each tuple from a given list of non-empty tuples.", "test_list": ["assert sort_list_last([(2, 5), (1, 2), (4, 4), (2, 3), (2, 1)])==[(2, 1), (1, 2), (2, 3), (4, 4), (2, 5)] ", "assert sort_list_last([(9,8), (4, 7), (3,5), (7,9), (1,2)])==[(1,2), (3,5), (4,7), (9,8), (7,9)] ", "assert sort_list_last([(20,50), (10,20), (40,40)])==[(10,20),(40,40),(20,50)] "], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_896", "n_instr": 25} {"i": 220, "src_path": "src/00220.py", "pyc_path": "pyc/00220.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_Word_Present\n RETURN_CONST None\nEND\nCODE is_Word_Present(sentence, word)\n RESUME 0\n LOAD_FAST sentence\n LOAD_ATTR NULL|self + split\n LOAD_CONST ' '\n CALL 1\n STORE_FAST s\n LOAD_FAST s\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST i\n LOAD_FAST word\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n POP_TOP\n RETURN_CONST True\nL3:\n END_FOR\n RETURN_CONST False\nEND", "expected": "def is_Word_Present(sentence, word):\n s = sentence.split(' ')\n for i in s:\n if i == word:\n return True\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 897, "mbpp_split": "train", "prompt": "Write a python function to check whether the word is present in a given sentence or not.", "test_list": ["assert is_Word_Present(\"machine learning\",\"machine\") == True", "assert is_Word_Present(\"easy\",\"fun\") == False", "assert is_Word_Present(\"python language\",\"code\") == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_897", "n_instr": 30} {"i": 221, "src_path": "src/00221.py", "pyc_path": "pyc/00221.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('groupby',)\n IMPORT_NAME itertools\n IMPORT_FROM groupby\n STORE_NAME groupby\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME extract_elements\n RETURN_CONST None\nEND\nCODE extract_elements(numbers, n)\n RESUME 0\n LOAD_GLOBAL NULL + groupby\n LOAD_FAST numbers\n CALL 1\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n LOAD_FAST_AND_CLEAR j\n SWAP 3\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L5\n UNPACK_SEQUENCE 2\n STORE_FAST i\n STORE_FAST j\n LOAD_GLOBAL NULL + len\n LOAD_GLOBAL NULL + list\n LOAD_FAST j\n CALL 1\n CALL 1\n LOAD_FAST n\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST i\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL5:\n END_FOR\nL6:\n STORE_FAST result\n STORE_FAST i\n STORE_FAST j\n LOAD_FAST result\n RETURN_VALUE\nL7:\n SWAP 2\n POP_TOP\n SWAP 3\n STORE_FAST j\n STORE_FAST i\n RERAISE 0\n EXC try=L1..L3 -> handler=L7 depth=3 lasti=False\n EXC try=L4..L6 -> handler=L7 depth=3 lasti=False\nEND", "expected": "from itertools import groupby\n\ndef extract_elements(numbers, n):\n result = [i for i, j in groupby(numbers) if len(list(j)) == n]\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 898, "mbpp_split": "train", "prompt": "Write a function to extract specified number of elements from a given list, which follow each other continuously.", "test_list": ["assert extract_elements([1, 1, 3, 4, 4, 5, 6, 7],2)==[1, 4]", "assert extract_elements([0, 1, 2, 3, 4, 4, 4, 4, 5, 7],4)==[4]", "assert extract_elements([0,0,0,0,0],5)==[0]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_898", "n_instr": 61} {"i": 222, "src_path": "src/00222.py", "pyc_path": "pyc/00222.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check\n RETURN_CONST None\nEND\nCODE check(arr, n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST g\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST n\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L4\n STORE_FAST i\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n BINARY_OP -\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_FALSE L2\n LOAD_FAST g\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n POP_TOP\n RETURN_CONST False\nL2:\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_OP -\n LOAD_CONST 0\n COMPARE_OP <\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L1\nL3:\n LOAD_CONST 1\n STORE_FAST g\n JUMP_BACKWARD L1\nL4:\n END_FOR\n RETURN_CONST True\nEND", "expected": "def check(arr, n):\n g = 0\n for i in range(1, n):\n if arr[i] - arr[i - 1] > 0 and g == 1:\n return False\n if arr[i] - arr[i] < 0:\n g = 1\n return True", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 899, "mbpp_split": "train", "prompt": "Write a python function to check whether an array can be sorted or not by picking only the corner elements.", "test_list": ["assert check([3,2,1,2,3,4],6) == True", "assert check([2,1,4,5,1],5) == True", "assert check([1,2,2,1,2,3],6) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_899", "n_instr": 56} {"i": 223, "src_path": "src/00223.py", "pyc_path": "pyc/00223.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME match_num\n RETURN_CONST None\nEND\nCODE match_num(string)\n RESUME 0\n LOAD_GLOBAL NULL + re\n LOAD_ATTR compile\n LOAD_CONST '^5'\n CALL 1\n STORE_FAST text\n LOAD_FAST text\n LOAD_ATTR NULL|self + match\n LOAD_FAST string\n CALL 1\n POP_JUMP_IF_FALSE L1\n RETURN_CONST True\nL1:\n RETURN_CONST False\nEND", "expected": "import re\n\ndef match_num(string):\n text = re.compile('^5')\n if text.match(string):\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 900, "mbpp_split": "train", "prompt": "Write a function where a string will start with a specific number.", "test_list": ["assert match_num('5-2345861')==True", "assert match_num('6-2345861')==False", "assert match_num('78910')==False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_900", "n_instr": 26} {"i": 224, "src_path": "src/00224.py", "pyc_path": "pyc/00224.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME smallest_multiple\n RETURN_CONST None\nEND\nCODE smallest_multiple(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 2\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L1\n LOAD_FAST n\n RETURN_VALUE\nL1:\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP *\n STORE_FAST i\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n LOAD_CONST 1\n LOAD_CONST -1\n CALL 3\n GET_ITER\n LOAD_FAST_AND_CLEAR number\n SWAP 2\nL2:\n BUILD_LIST 0\n SWAP 2\nL3:\n FOR_ITER L6\n STORE_FAST number\n LOAD_FAST number\n LOAD_CONST 2\n BINARY_OP *\n LOAD_FAST n\n COMPARE_OP >\n POP_JUMP_IF_TRUE L5\nL4:\n JUMP_BACKWARD L3\nL5:\n LOAD_FAST number\n LIST_APPEND 2\n JUMP_BACKWARD L3\nL6:\n END_FOR\nL7:\n STORE_FAST factors\n STORE_FAST number\n NOP\nL8:\n LOAD_FAST factors\n GET_ITER\nL9:\n FOR_ITER L13\n STORE_FAST a\n LOAD_FAST i\n LOAD_FAST a\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L10\n LOAD_FAST i\n LOAD_FAST n\n BINARY_OP +=\n STORE_FAST i\n POP_TOP\n JUMP_FORWARD L14\nL10:\n LOAD_FAST a\n LOAD_FAST factors\n LOAD_CONST -1\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L11\n JUMP_BACKWARD L9\nL11:\n LOAD_FAST i\n LOAD_FAST a\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L12\n JUMP_BACKWARD L9\nL12:\n LOAD_FAST i\n SWAP 2\n POP_TOP\n RETURN_VALUE\nL13:\n END_FOR\nL14:\n JUMP_BACKWARD L8\nL15:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST number\n RERAISE 0\n EXC try=L2..L4 -> handler=L15 depth=2 lasti=False\n EXC try=L5..L7 -> handler=L15 depth=2 lasti=False\nEND", "expected": "def smallest_multiple(n):\n if n <= 2:\n return n\n i = n * 2\n factors = [number for number in range(n, 1, -1) if number * 2 > n]\n while True:\n for a in factors:\n if i % a != 0:\n i += n\n break\n if a == factors[-1] and i % a == 0:\n return i", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 901, "mbpp_split": "train", "prompt": "Write a function to find the smallest multiple of the first n numbers.", "test_list": ["assert smallest_multiple(13)==360360", "assert smallest_multiple(2)==2", "assert smallest_multiple(1)==1"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_901", "n_instr": 103} {"i": 225, "src_path": "src/00225.py", "pyc_path": "pyc/00225.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('Counter',)\n IMPORT_NAME collections\n IMPORT_FROM Counter\n STORE_NAME Counter\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME add_dict\n RETURN_CONST None\nEND\nCODE add_dict(d1, d2)\n RESUME 0\n LOAD_GLOBAL NULL + Counter\n LOAD_FAST d1\n CALL 1\n LOAD_GLOBAL NULL + Counter\n LOAD_FAST d2\n CALL 1\n BINARY_OP +\n STORE_FAST add_dict\n LOAD_FAST add_dict\n RETURN_VALUE\nEND", "expected": "from collections import Counter\n\ndef add_dict(d1, d2):\n add_dict = Counter(d1) + Counter(d2)\n return add_dict", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 902, "mbpp_split": "train", "prompt": "Write a function to combine two dictionaries by adding values for common keys.", "test_list": ["assert add_dict({'a': 100, 'b': 200, 'c':300},{'a': 300, 'b': 200, 'd':400})==({'b': 400, 'd': 400, 'a': 400, 'c': 300}) ", "assert add_dict({'a': 500, 'b': 700, 'c':900},{'a': 500, 'b': 600, 'd':900})==({'b': 1300, 'd': 900, 'a': 1000, 'c': 900}) ", "assert add_dict({'a':900,'b':900,'d':900},{'a':900,'b':900,'d':900})==({'b': 1800, 'd': 1800, 'a': 1800})"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_902", "n_instr": 25} {"i": 226, "src_path": "src/00226.py", "pyc_path": "pyc/00226.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_Unset_Bits\n RETURN_CONST None\nEND\nCODE count_Unset_Bits(n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST cnt\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L5\n STORE_FAST i\n LOAD_FAST i\n STORE_FAST temp\n LOAD_FAST temp\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST temp\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n LOAD_FAST cnt\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST cnt\nL3:\n LOAD_FAST temp\n LOAD_CONST 2\n BINARY_OP //\n STORE_FAST temp\n LOAD_FAST temp\n POP_JUMP_IF_FALSE L4\n JUMP_BACKWARD L2\nL4:\n JUMP_BACKWARD L1\nL5:\n END_FOR\n LOAD_FAST cnt\n RETURN_VALUE\nEND", "expected": "def count_Unset_Bits(n):\n cnt = 0\n for i in range(1, n + 1):\n temp = i\n while temp:\n if temp % 2 == 0:\n cnt += 1\n temp = temp // 2\n return cnt", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 903, "mbpp_split": "train", "prompt": "Write a python function to count the total unset bits from 1 to n.", "test_list": ["assert count_Unset_Bits(2) == 1", "assert count_Unset_Bits(5) == 4", "assert count_Unset_Bits(14) == 17"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_903", "n_instr": 51} {"i": 227, "src_path": "src/00227.py", "pyc_path": "pyc/00227.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME even_num\n RETURN_CONST None\nEND\nCODE even_num(x)\n RESUME 0\n LOAD_FAST x\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST True\nL1:\n RETURN_CONST False\nEND", "expected": "def even_num(x):\n if x % 2 == 0:\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 904, "mbpp_split": "train", "prompt": "Write a function to return true if the given number is even else return false.", "test_list": ["assert even_num(13.5)==False", "assert even_num(0)==True", "assert even_num(-9)==False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_904", "n_instr": 18} {"i": 228, "src_path": "src/00228.py", "pyc_path": "pyc/00228.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME factorial\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_of_square\n RETURN_CONST None\nEND\nCODE factorial(start, end)\n RESUME 0\n LOAD_CONST 1\n STORE_FAST res\n LOAD_GLOBAL NULL + range\n LOAD_FAST start\n LOAD_FAST end\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST res\n LOAD_FAST i\n BINARY_OP *=\n STORE_FAST res\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST res\n RETURN_VALUE\nEND\nCODE sum_of_square(n)\n RESUME 0\n LOAD_GLOBAL NULL + int\n LOAD_GLOBAL NULL + factorial\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n LOAD_CONST 2\n LOAD_FAST n\n BINARY_OP *\n CALL 2\n LOAD_GLOBAL NULL + factorial\n LOAD_CONST 1\n LOAD_FAST n\n CALL 2\n BINARY_OP /\n CALL 1\n RETURN_VALUE\nEND", "expected": "def factorial(start, end):\n res = 1\n for i in range(start, end + 1):\n res *= i\n return res\n\ndef sum_of_square(n):\n return int(factorial(n + 1, 2 * n) / factorial(1, n))", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 905, "mbpp_split": "train", "prompt": "Write a python function to find the sum of squares of binomial co-efficients.", "test_list": ["assert sum_of_square(4) == 70", "assert sum_of_square(5) == 252", "assert sum_of_square(2) == 6"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_905", "n_instr": 52} {"i": 229, "src_path": "src/00229.py", "pyc_path": "pyc/00229.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME lucky_num\n RETURN_CONST None\nEND\nCODE lucky_num(n)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_CONST -1\n LOAD_FAST n\n LOAD_FAST n\n BINARY_OP *\n LOAD_CONST 9\n BINARY_OP +\n LOAD_CONST 2\n CALL 3\n STORE_FAST List\n LOAD_CONST 2\n STORE_FAST i\n LOAD_FAST List\n LOAD_FAST i\n LOAD_CONST None\n BINARY_SLICE\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_GLOBAL NULL + sorted\n LOAD_GLOBAL NULL + set\n LOAD_FAST List\n CALL 1\n LOAD_GLOBAL NULL + set\n LOAD_FAST List\n LOAD_FAST List\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST None\n LOAD_FAST List\n LOAD_FAST i\n BINARY_SUBSCR\n BUILD_SLICE 3\n BINARY_SUBSCR\n CALL 1\n BINARY_OP -\n CALL 1\n STORE_FAST List\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST i\n LOAD_FAST List\n LOAD_FAST i\n LOAD_CONST None\n BINARY_SLICE\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST List\n LOAD_CONST 1\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n BINARY_SLICE\n RETURN_VALUE\nEND", "expected": "def lucky_num(n):\n List = range(-1, n * n + 9, 2)\n i = 2\n while List[i:]:\n List = sorted(set(List) - set(List[List[i]::List[i]]))\n i += 1\n return List[1:n + 1]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 907, "mbpp_split": "train", "prompt": "Write a function to print the first n lucky numbers.", "test_list": ["assert lucky_num(10)==[1, 3, 7, 9, 13, 15, 21, 25, 31, 33] ", "assert lucky_num(5)==[1, 3, 7, 9, 13]", "assert lucky_num(8)==[1, 3, 7, 9, 13, 15, 21, 25]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_907", "n_instr": 64} {"i": 230, "src_path": "src/00230.py", "pyc_path": "pyc/00230.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_fixed_point\n RETURN_CONST None\nEND\nCODE find_fixed_point(arr, n)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST i\n IS_OP 0\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST i\n SWAP 2\n POP_TOP\n RETURN_VALUE\nL3:\n END_FOR\n RETURN_CONST -1\nEND", "expected": "def find_fixed_point(arr, n):\n for i in range(n):\n if arr[i] is i:\n return i\n return -1", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 908, "mbpp_split": "train", "prompt": "Write a function to find the fixed point in the given array.", "test_list": ["assert find_fixed_point([-10, -1, 0, 3, 10, 11, 30, 50, 100],9) == 3", "assert find_fixed_point([1, 2, 3, 4, 5, 6, 7, 8],8) == -1", "assert find_fixed_point([0, 2, 5, 8, 17],5) == 0"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_908", "n_instr": 31} {"i": 231, "src_path": "src/00231.py", "pyc_path": "pyc/00231.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME previous_palindrome\n RETURN_CONST None\nEND\nCODE previous_palindrome(num)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_FAST num\n LOAD_CONST 1\n BINARY_OP -\n LOAD_CONST 0\n LOAD_CONST -1\n CALL 3\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST x\n LOAD_GLOBAL NULL + str\n LOAD_FAST x\n CALL 1\n LOAD_GLOBAL NULL + str\n LOAD_FAST x\n CALL 1\n LOAD_CONST None\n LOAD_CONST None\n LOAD_CONST -1\n BUILD_SLICE 3\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST x\n SWAP 2\n POP_TOP\n RETURN_VALUE\nL3:\n END_FOR\n RETURN_CONST None\nEND", "expected": "def previous_palindrome(num):\n for x in range(num - 1, 0, -1):\n if str(x) == str(x)[::-1]:\n return x", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 909, "mbpp_split": "train", "prompt": "Write a function to find the previous palindrome of a specified number.", "test_list": ["assert previous_palindrome(99)==88", "assert previous_palindrome(1221)==1111", "assert previous_palindrome(120)==111"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_909", "n_instr": 42} {"i": 232, "src_path": "src/00232.py", "pyc_path": "pyc/00232.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME datetime\n STORE_NAME datetime\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_date\n RETURN_CONST None\nEND\nCODE check_date(m, d, y)\n RESUME 0\n NOP\nL1:\n LOAD_GLOBAL NULL + map\n LOAD_GLOBAL int\n LOAD_FAST m\n LOAD_FAST d\n LOAD_FAST y\n BUILD_TUPLE 3\n CALL 2\n UNPACK_SEQUENCE 3\n STORE_FAST m\n STORE_FAST d\n STORE_FAST y\n LOAD_GLOBAL NULL + datetime\n LOAD_ATTR date\n LOAD_FAST y\n LOAD_FAST m\n LOAD_FAST d\n CALL 3\n POP_TOP\nL2:\n RETURN_CONST True\nL3:\n PUSH_EXC_INFO\n LOAD_GLOBAL ValueError\n CHECK_EXC_MATCH\n POP_JUMP_IF_FALSE L5\n POP_TOP\nL4:\n POP_EXCEPT\n RETURN_CONST False\nL5:\n RERAISE 0\nL6:\n COPY 3\n POP_EXCEPT\n RERAISE 1\n EXC try=L1..L2 -> handler=L3 depth=0 lasti=False\n EXC try=L3..L4 -> handler=L6 depth=1 lasti=True\n EXC try=L5..L6 -> handler=L6 depth=1 lasti=True\nEND", "expected": "import datetime\n\ndef check_date(m, d, y):\n try:\n m, d, y = map(int, (m, d, y))\n datetime.date(y, m, d)\n return True\n except ValueError:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 910, "mbpp_split": "train", "prompt": "Write a function to validate a gregorian date.", "test_list": ["assert check_date(11,11,2002)==True", "assert check_date(13,11,2002)==False", "assert check_date('11','11','2002')==True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_910", "n_instr": 53} {"i": 233, "src_path": "src/00233.py", "pyc_path": "pyc/00233.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME end_num\n RETURN_CONST None\nEND\nCODE end_num(string)\n RESUME 0\n LOAD_GLOBAL NULL + re\n LOAD_ATTR compile\n LOAD_CONST '.*[0-9]$'\n CALL 1\n STORE_FAST text\n LOAD_FAST text\n LOAD_ATTR NULL|self + match\n LOAD_FAST string\n CALL 1\n POP_JUMP_IF_FALSE L1\n RETURN_CONST True\nL1:\n RETURN_CONST False\nEND", "expected": "import re\n\ndef end_num(string):\n text = re.compile('.*[0-9]$')\n if text.match(string):\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 913, "mbpp_split": "train", "prompt": "Write a function to check for a number at the end of a string.", "test_list": ["assert end_num('abcdef')==False", "assert end_num('abcdef7')==True", "assert end_num('abc')==False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_913", "n_instr": 26} {"i": 234, "src_path": "src/00234.py", "pyc_path": "pyc/00234.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_Two_Alter\n RETURN_CONST None\nEND\nCODE is_Two_Alter(s)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST s\n CALL 1\n LOAD_CONST 2\n BINARY_OP -\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST s\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST s\n LOAD_FAST i\n LOAD_CONST 2\n BINARY_OP +\n BINARY_SUBSCR\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n POP_TOP\n RETURN_CONST False\nL3:\n END_FOR\n LOAD_FAST s\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST s\n LOAD_CONST 1\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L4\n RETURN_CONST False\nL4:\n RETURN_CONST True\nEND", "expected": "def is_Two_Alter(s):\n for i in range(len(s) - 2):\n if s[i] != s[i + 2]:\n return False\n if s[0] == s[1]:\n return False\n return True", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 914, "mbpp_split": "train", "prompt": "Write a python function to check whether the given string is made up of two alternating characters or not.", "test_list": ["assert is_Two_Alter(\"abab\") == True", "assert is_Two_Alter(\"aaaa\") == False", "assert is_Two_Alter(\"xyz\") == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_914", "n_instr": 47} {"i": 235, "src_path": "src/00235.py", "pyc_path": "pyc/00235.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME rearrange_numbs\n RETURN_CONST None\nEND\nCODE rearrange_numbs(array_nums)\n RESUME 0\n LOAD_GLOBAL NULL + sorted\n LOAD_FAST array_nums\n LOAD_CONST .>\n MAKE_FUNCTION 0\n KW_NAMES ('key',)\n CALL 2\n STORE_FAST result\n LOAD_FAST result\n RETURN_VALUE\nEND\nCODE rearrange_numbs..(i)\n RESUME 0\n LOAD_FAST i\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n LOAD_CONST 0\n RETURN_VALUE\nL1:\n LOAD_CONST -1\n LOAD_FAST i\n BINARY_OP /\n RETURN_VALUE\nEND", "expected": "def rearrange_numbs(array_nums):\n result = sorted(array_nums, key=lambda i: 0 if i == 0 else -1 / i)\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 915, "mbpp_split": "train", "prompt": "Write a function to rearrange positive and negative numbers in a given array using lambda function.", "test_list": ["assert rearrange_numbs([-1, 2, -3, 5, 7, 8, 9, -10])==[2, 5, 7, 8, 9, -10, -3, -1]", "assert rearrange_numbs([10,15,14,13,-18,12,-20])==[10, 12, 13, 14, 15, -20, -18]", "assert rearrange_numbs([-20,20,-10,10,-30,30])==[10, 20, 30, -30, -20, -10]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_915", "n_instr": 32} {"i": 236, "src_path": "src/00236.py", "pyc_path": "pyc/00236.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_triplet_array\n RETURN_CONST None\nEND\nCODE find_triplet_array(A, arr_size, sum)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_FAST arr_size\n LOAD_CONST 2\n BINARY_OP -\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L7\n STORE_FAST i\n LOAD_GLOBAL NULL + range\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST arr_size\n LOAD_CONST 1\n BINARY_OP -\n CALL 2\n GET_ITER\nL2:\n FOR_ITER L6\n STORE_FAST j\n LOAD_GLOBAL NULL + range\n LOAD_FAST j\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST arr_size\n CALL 2\n GET_ITER\nL3:\n FOR_ITER L5\n STORE_FAST k\n LOAD_FAST A\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST A\n LOAD_FAST j\n BINARY_SUBSCR\n BINARY_OP +\n LOAD_FAST A\n LOAD_FAST k\n BINARY_SUBSCR\n BINARY_OP +\n LOAD_FAST sum\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L4\n JUMP_BACKWARD L3\nL4:\n LOAD_FAST A\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST A\n LOAD_FAST j\n BINARY_SUBSCR\n LOAD_FAST A\n LOAD_FAST k\n BINARY_SUBSCR\n BUILD_TUPLE 3\n SWAP 2\n POP_TOP\n SWAP 2\n POP_TOP\n SWAP 2\n POP_TOP\n RETURN_VALUE\nL5:\n END_FOR\n JUMP_BACKWARD L2\nL6:\n END_FOR\n JUMP_BACKWARD L1\nL7:\n END_FOR\n RETURN_CONST False\nEND", "expected": "def find_triplet_array(A, arr_size, sum):\n for i in range(0, arr_size - 2):\n for j in range(i + 1, arr_size - 1):\n for k in range(j + 1, arr_size):\n if A[i] + A[j] + A[k] == sum:\n return (A[i], A[j], A[k])\n return True\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 916, "mbpp_split": "train", "prompt": "Write a function to find if there is a triplet in the array whose sum is equal to a given value.", "test_list": ["assert find_triplet_array([1, 4, 45, 6, 10, 8], 6, 22) == (4, 10, 8)", "assert find_triplet_array([12, 3, 5, 2, 6, 9], 6, 24) == (12, 3, 9)", "assert find_triplet_array([1, 2, 3, 4, 5], 5, 9) == (1, 3, 5)"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_916", "n_instr": 83} {"i": 237, "src_path": "src/00237.py", "pyc_path": "pyc/00237.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME text_uppercase_lowercase\n RETURN_CONST None\nEND\nCODE text_uppercase_lowercase(text)\n RESUME 0\n LOAD_CONST '[A-Z]+[a-z]+$'\n STORE_FAST patterns\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_FAST patterns\n LOAD_FAST text\n CALL 2\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Found a match!'\nL1:\n RETURN_CONST 'Not matched!'\nEND", "expected": "import re\n\ndef text_uppercase_lowercase(text):\n patterns = '[A-Z]+[a-z]+$'\n if re.search(patterns, text):\n return 'Found a match!'\n else:\n return 'Not matched!'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 917, "mbpp_split": "train", "prompt": "Write a function to find the sequences of one upper case letter followed by lower case letters.", "test_list": ["assert text_uppercase_lowercase(\"AaBbGg\")==('Found a match!')", "assert text_uppercase_lowercase(\"aA\")==('Not matched!')", "assert text_uppercase_lowercase(\"PYTHON\")==('Not matched!')"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_917", "n_instr": 24} {"i": 238, "src_path": "src/00238.py", "pyc_path": "pyc/00238.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove_tuple\n RETURN_CONST None\nEND\nCODE remove_tuple(test_list)\n RESUME 0\n LOAD_FAST test_list\n GET_ITER\n LOAD_FAST_AND_CLEAR sub\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L5\n STORE_FAST sub\n LOAD_GLOBAL NULL + all\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST sub\n GET_ITER\n CALL 0\n CALL 1\n POP_JUMP_IF_FALSE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST sub\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL5:\n END_FOR\nL6:\n STORE_FAST res\n STORE_FAST sub\n LOAD_GLOBAL NULL + str\n LOAD_FAST res\n CALL 1\n RETURN_VALUE\nL7:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST sub\n RERAISE 0\n EXC try=L1..L3 -> handler=L7 depth=2 lasti=False\n EXC try=L4..L6 -> handler=L7 depth=2 lasti=False\nEND\nCODE remove_tuple..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n STORE_FAST ele\n LOAD_FAST ele\n LOAD_CONST None\n COMPARE_OP ==\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def remove_tuple(test_list):\n res = [sub for sub in test_list if not all((ele == None for ele in sub))]\n return str(res)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 920, "mbpp_split": "train", "prompt": "Write a function to remove all tuples with all none values in the given tuple list.", "test_list": ["assert remove_tuple([(None, 2), (None, None), (3, 4), (12, 3), (None, )] ) == '[(None, 2), (3, 4), (12, 3)]'", "assert remove_tuple([(None, None), (None, None), (3, 6), (17, 3), (None,1 )] ) == '[(3, 6), (17, 3), (None, 1)]'", "assert remove_tuple([(1, 2), (2, None), (3, None), (24, 3), (None, None )] ) == '[(1, 2), (2, None), (3, None), (24, 3)]'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_920", "n_instr": 74} {"i": 239, "src_path": "src/00239.py", "pyc_path": "pyc/00239.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME chunk_tuples\n RETURN_CONST None\nEND\nCODE chunk_tuples(test_tup, N)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST test_tup\n CALL 1\n LOAD_FAST N\n CALL 3\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST test_tup\n LOAD_FAST i\n LOAD_FAST i\n LOAD_FAST N\n BINARY_OP +\n BINARY_SLICE\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST res\n STORE_FAST i\n LOAD_FAST res\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=2 lasti=False\nEND", "expected": "def chunk_tuples(test_tup, N):\n res = [test_tup[i:i + N] for i in range(0, len(test_tup), N)]\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 921, "mbpp_split": "train", "prompt": "Write a function to perform chunking of tuples each of size n.", "test_list": ["assert chunk_tuples((10, 4, 5, 6, 7, 6, 8, 3, 4), 3) == [(10, 4, 5), (6, 7, 6), (8, 3, 4)]", "assert chunk_tuples((1, 2, 3, 4, 5, 6, 7, 8, 9), 2) == [(1, 2), (3, 4), (5, 6), (7, 8), (9,)]", "assert chunk_tuples((11, 14, 16, 17, 19, 21, 22, 25), 4) == [(11, 14, 16, 17), (19, 21, 22, 25)]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_921", "n_instr": 47} {"i": 240, "src_path": "src/00240.py", "pyc_path": "pyc/00240.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME max_product\n RETURN_CONST None\nEND\nCODE max_product(arr)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST arr\n CALL 1\n STORE_FAST arr_len\n LOAD_FAST arr_len\n LOAD_CONST 2\n COMPARE_OP <\n POP_JUMP_IF_FALSE L1\n RETURN_CONST None\nL1:\n LOAD_FAST arr\n LOAD_CONST 0\n BINARY_SUBSCR\n STORE_FAST x\n LOAD_FAST arr\n LOAD_CONST 1\n BINARY_SUBSCR\n STORE_FAST y\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_FAST arr_len\n CALL 2\n GET_ITER\nL2:\n FOR_ITER L6\n STORE_FAST i\n LOAD_GLOBAL NULL + range\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST arr_len\n CALL 2\n GET_ITER\nL3:\n FOR_ITER L5\n STORE_FAST j\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST j\n BINARY_SUBSCR\n BINARY_OP *\n LOAD_FAST x\n LOAD_FAST y\n BINARY_OP *\n COMPARE_OP >\n POP_JUMP_IF_TRUE L4\n JUMP_BACKWARD L3\nL4:\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n STORE_FAST x\n LOAD_FAST arr\n LOAD_FAST j\n BINARY_SUBSCR\n STORE_FAST y\n JUMP_BACKWARD L3\nL5:\n END_FOR\n JUMP_BACKWARD L2\nL6:\n END_FOR\n LOAD_FAST x\n LOAD_FAST y\n BUILD_TUPLE 2\n RETURN_VALUE\nEND", "expected": "def max_product(arr):\n arr_len = len(arr)\n if arr_len < 2:\n return None\n x = arr[0]\n y = arr[1]\n for i in range(0, arr_len):\n for j in range(i + 1, arr_len):\n if arr[i] * arr[j] > x * y:\n x = arr[i]\n y = arr[j]\n return (x, y)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 922, "mbpp_split": "train", "prompt": "Write a function to find a pair with the highest product from a given array of integers.", "test_list": ["assert max_product([1, 2, 3, 4, 7, 0, 8, 4])==(7, 8)", "assert max_product([0, -1, -2, -4, 5, 0, -6])==(-4, -6)", "assert max_product([1, 3, 5, 6, 8, 9])==(8,9)"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_922", "n_instr": 77} {"i": 241, "src_path": "src/00241.py", "pyc_path": "pyc/00241.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME super_seq\n RETURN_CONST None\nEND\nCODE super_seq(X, Y, m, n)\n RESUME 0\n LOAD_FAST m\n POP_JUMP_IF_TRUE L1\n LOAD_FAST n\n RETURN_VALUE\nL1:\n LOAD_FAST n\n POP_JUMP_IF_TRUE L2\n LOAD_FAST m\n RETURN_VALUE\nL2:\n LOAD_FAST X\n LOAD_FAST m\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n LOAD_FAST Y\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n LOAD_CONST 1\n LOAD_GLOBAL NULL + super_seq\n LOAD_FAST X\n LOAD_FAST Y\n LOAD_FAST m\n LOAD_CONST 1\n BINARY_OP -\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n CALL 4\n BINARY_OP +\n RETURN_VALUE\nL3:\n LOAD_CONST 1\n LOAD_GLOBAL NULL + min\n LOAD_GLOBAL NULL + super_seq\n LOAD_FAST X\n LOAD_FAST Y\n LOAD_FAST m\n LOAD_CONST 1\n BINARY_OP -\n LOAD_FAST n\n CALL 4\n LOAD_GLOBAL NULL + super_seq\n LOAD_FAST X\n LOAD_FAST Y\n LOAD_FAST m\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n CALL 4\n CALL 2\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def super_seq(X, Y, m, n):\n if not m:\n return n\n if not n:\n return m\n if X[m - 1] == Y[n - 1]:\n return 1 + super_seq(X, Y, m - 1, n - 1)\n return 1 + min(super_seq(X, Y, m - 1, n), super_seq(X, Y, m, n - 1))", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 923, "mbpp_split": "train", "prompt": "Write a function to find the length of the shortest string that has both str1 and str2 as subsequences.", "test_list": ["assert super_seq(\"AGGTAB\", \"GXTXAYB\", 6, 7) == 9", "assert super_seq(\"feek\", \"eke\", 4, 3) == 5", "assert super_seq(\"PARRT\", \"RTA\", 5, 3) == 6"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_923", "n_instr": 66} {"i": 242, "src_path": "src/00242.py", "pyc_path": "pyc/00242.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME max_of_two\n RETURN_CONST None\nEND\nCODE max_of_two(x, y)\n RESUME 0\n LOAD_FAST x\n LOAD_FAST y\n COMPARE_OP >\n POP_JUMP_IF_FALSE L1\n LOAD_FAST x\n RETURN_VALUE\nL1:\n LOAD_FAST y\n RETURN_VALUE\nEND", "expected": "def max_of_two(x, y):\n if x > y:\n return x\n return y", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 924, "mbpp_split": "train", "prompt": "Write a function to find maximum of two numbers.", "test_list": ["assert max_of_two(10,20)==20", "assert max_of_two(19,15)==19", "assert max_of_two(-10,-20)==-10"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_924", "n_instr": 18} {"i": 243, "src_path": "src/00243.py", "pyc_path": "pyc/00243.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME mutiple_tuple\n RETURN_CONST None\nEND\nCODE mutiple_tuple(nums)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_FAST nums\n CALL 1\n STORE_FAST temp\n LOAD_CONST 1\n STORE_FAST product\n LOAD_FAST temp\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST x\n LOAD_FAST product\n LOAD_FAST x\n BINARY_OP *=\n STORE_FAST product\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST product\n RETURN_VALUE\nEND", "expected": "def mutiple_tuple(nums):\n temp = list(nums)\n product = 1\n for x in temp:\n product *= x\n return product", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 925, "mbpp_split": "train", "prompt": "Write a python function to calculate the product of all the numbers of a given tuple.", "test_list": ["assert mutiple_tuple((4, 3, 2, 2, -1, 18)) == -864", "assert mutiple_tuple((1,2,3)) == 6", "assert mutiple_tuple((-2,-4,-6)) == -48"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_925", "n_instr": 29} {"i": 244, "src_path": "src/00244.py", "pyc_path": "pyc/00244.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME change_date_format\n RETURN_CONST None\nEND\nCODE change_date_format(dt)\n RESUME 0\n LOAD_GLOBAL NULL + re\n LOAD_ATTR sub\n LOAD_CONST '(\\\\d{4})-(\\\\d{1,2})-(\\\\d{1,2})'\n LOAD_CONST '\\\\3-\\\\2-\\\\1'\n LOAD_FAST dt\n CALL 3\n RETURN_VALUE\nEND", "expected": "import re\n\ndef change_date_format(dt):\n return re.sub('(\\\\d{4})-(\\\\d{1,2})-(\\\\d{1,2})', '\\\\3-\\\\2-\\\\1', dt)\n return change_date_format(dt)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 928, "mbpp_split": "train", "prompt": "Write a function to convert a date of yyyy-mm-dd format to dd-mm-yyyy format.", "test_list": ["assert change_date_format('2026-01-02')=='02-01-2026'", "assert change_date_format('2021-01-04')=='04-01-2021'", "assert change_date_format('2030-06-06')=='06-06-2030'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_928", "n_instr": 20} {"i": 245, "src_path": "src/00245.py", "pyc_path": "pyc/00245.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_series\n RETURN_CONST None\nEND\nCODE sum_series(number)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST total\n LOAD_GLOBAL NULL + math\n LOAD_ATTR pow\n LOAD_FAST number\n LOAD_FAST number\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP *\n LOAD_CONST 2\n BINARY_OP /\n LOAD_CONST 2\n CALL 2\n STORE_FAST total\n LOAD_FAST total\n RETURN_VALUE\nEND", "expected": "import math\n\ndef sum_series(number):\n total = 0\n total = math.pow(number * (number + 1) / 2, 2)\n return total", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 931, "mbpp_split": "train", "prompt": "Write a function to calculate the sum of series 1\u00b3+2\u00b3+3\u00b3+\u2026.+n\u00b3.", "test_list": ["assert sum_series(7)==784", "assert sum_series(5)==225", "assert sum_series(15)==14400"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_931", "n_instr": 29} {"i": 246, "src_path": "src/00246.py", "pyc_path": "pyc/00246.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME dealnnoy_num\n RETURN_CONST None\nEND\nCODE dealnnoy_num(n, m)\n RESUME 0\n LOAD_FAST m\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L1\n LOAD_FAST n\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\nL1:\n RETURN_CONST 1\nL2:\n LOAD_GLOBAL NULL + dealnnoy_num\n LOAD_FAST m\n LOAD_CONST 1\n BINARY_OP -\n LOAD_FAST n\n CALL 2\n LOAD_GLOBAL NULL + dealnnoy_num\n LOAD_FAST m\n LOAD_CONST 1\n BINARY_OP -\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n CALL 2\n BINARY_OP +\n LOAD_GLOBAL NULL + dealnnoy_num\n LOAD_FAST m\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n CALL 2\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def dealnnoy_num(n, m):\n if m == 0 or n == 0:\n return 1\n return dealnnoy_num(m - 1, n) + dealnnoy_num(m - 1, n - 1) + dealnnoy_num(m, n - 1)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 934, "mbpp_split": "train", "prompt": "Write a function to find the nth delannoy number.", "test_list": ["assert dealnnoy_num(3, 4) == 129", "assert dealnnoy_num(3, 3) == 63", "assert dealnnoy_num(4, 5) == 681"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_934", "n_instr": 43} {"i": 247, "src_path": "src/00247.py", "pyc_path": "pyc/00247.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME series_sum\n RETURN_CONST None\nEND\nCODE series_sum(number)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST total\n LOAD_FAST number\n LOAD_FAST number\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP *\n LOAD_CONST 2\n LOAD_FAST number\n BINARY_OP *\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP *\n LOAD_CONST 6\n BINARY_OP /\n STORE_FAST total\n LOAD_FAST total\n RETURN_VALUE\nEND", "expected": "def series_sum(number):\n total = 0\n total = number * (number + 1) * (2 * number + 1) / 6\n return total", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 935, "mbpp_split": "train", "prompt": "Write a function to calculate the sum of series 1\u00b2+2\u00b2+3\u00b2+\u2026.+n\u00b2.", "test_list": ["assert series_sum(6)==91", "assert series_sum(7)==140", "assert series_sum(12)==650"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_935", "n_instr": 27} {"i": 248, "src_path": "src/00248.py", "pyc_path": "pyc/00248.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('Counter',)\n IMPORT_NAME collections\n IMPORT_FROM Counter\n STORE_NAME Counter\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME max_char\n RETURN_CONST None\nEND\nCODE max_char(str1)\n RESUME 0\n LOAD_GLOBAL NULL + Counter\n LOAD_FAST str1\n CALL 1\n STORE_FAST temp\n LOAD_GLOBAL NULL + max\n LOAD_FAST temp\n LOAD_FAST temp\n LOAD_ATTR get\n KW_NAMES ('key',)\n CALL 2\n STORE_FAST max_char\n LOAD_FAST max_char\n RETURN_VALUE\nEND", "expected": "from collections import Counter\n\ndef max_char(str1):\n temp = Counter(str1)\n max_char = max(temp, key=temp.get)\n return max_char", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 937, "mbpp_split": "train", "prompt": "Write a function to count the most common character in a given string.", "test_list": ["assert max_char(\"hello world\")==('l')", "assert max_char(\"hello \")==('l')", "assert max_char(\"python pr\")==('p')"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_937", "n_instr": 28} {"i": 249, "src_path": "src/00249.py", "pyc_path": "pyc/00249.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sorted_models\n RETURN_CONST None\nEND\nCODE sorted_models(models)\n RESUME 0\n LOAD_GLOBAL NULL + sorted\n LOAD_FAST models\n LOAD_CONST .>\n MAKE_FUNCTION 0\n KW_NAMES ('key',)\n CALL 2\n STORE_FAST sorted_models\n LOAD_FAST sorted_models\n RETURN_VALUE\nEND\nCODE sorted_models..(x)\n RESUME 0\n LOAD_FAST x\n LOAD_CONST 'color'\n BINARY_SUBSCR\n RETURN_VALUE\nEND", "expected": "def sorted_models(models):\n sorted_models = sorted(models, key=lambda x: x['color'])\n return sorted_models", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 939, "mbpp_split": "train", "prompt": "Write a function to sort a list of dictionaries using lambda function.", "test_list": ["assert sorted_models([{'make':'Nokia', 'model':216, 'color':'Black'}, {'make':'Mi Max', 'model':2, 'color':'Gold'}, {'make':'Samsung', 'model': 7, 'color':'Blue'}])==[{'make': 'Nokia', 'model': 216, 'color': 'Black'}, {'make': 'Samsung', 'model': 7, 'color': 'Blue'}, {'make': 'Mi Max', 'model': 2, 'color': 'Gold'}]", "assert sorted_models([{'make':'Vivo', 'model':20,'color':'Blue'},{'make': 'oppo','model':17,'color':'Gold'},{'make':'Apple','model':11,'color':'red'}])==([{'make':'Vivo', 'model':20,'color':'Blue'},{'make': 'oppo','model':17,'color':'Gold'},{'make':'Apple','model':11,'color':'red'}])", "assert sorted_models([{'make':'micromax','model':40,'color':'grey'},{'make':'poco','model':60,'color':'blue'}])==([{'make':'poco','model':60,'color':'blue'},{'make':'micromax','model':40,'color':'grey'}])"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_939", "n_instr": 25} {"i": 250, "src_path": "src/00250.py", "pyc_path": "pyc/00250.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_elim\n RETURN_CONST None\nEND\nCODE count_elim(num)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST count_elim\n LOAD_FAST num\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST n\n LOAD_GLOBAL NULL + isinstance\n LOAD_FAST n\n LOAD_GLOBAL tuple\n CALL 2\n POP_JUMP_IF_FALSE L2\n POP_TOP\n LOAD_FAST count_elim\n RETURN_VALUE\nL2:\n LOAD_FAST count_elim\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST count_elim\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST count_elim\n RETURN_VALUE\nEND", "expected": "def count_elim(num):\n count_elim = 0\n for n in num:\n if isinstance(n, tuple):\n break\n count_elim += 1\n return count_elim", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 941, "mbpp_split": "train", "prompt": "Write a function to count the elements in a list until an element is a tuple.", "test_list": ["assert count_elim([10,20,30,(10,20),40])==3", "assert count_elim([10,(20,30),(10,20),40])==1", "assert count_elim([(10,(20,30,(10,20),40))])==0"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_941", "n_instr": 34} {"i": 251, "src_path": "src/00251.py", "pyc_path": "pyc/00251.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_element\n RETURN_CONST None\nEND\nCODE check_element(test_tup, check_list)\n RESUME 0\n LOAD_CONST False\n STORE_FAST res\n LOAD_FAST check_list\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST ele\n LOAD_FAST ele\n LOAD_FAST test_tup\n CONTAINS_OP 0\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_CONST True\n STORE_FAST res\n POP_TOP\n LOAD_FAST res\n RETURN_VALUE\nL3:\n END_FOR\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def check_element(test_tup, check_list):\n res = False\n for ele in check_list:\n if ele in test_tup:\n res = True\n break\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 942, "mbpp_split": "train", "prompt": "Write a function to check if any list element is present in the given list.", "test_list": ["assert check_element((4, 5, 7, 9, 3), [6, 7, 10, 11]) == True", "assert check_element((1, 2, 3, 4), [4, 6, 7, 8, 9]) == True", "assert check_element((3, 2, 1, 4, 5), [9, 8, 7, 6]) == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_942", "n_instr": 31} {"i": 252, "src_path": "src/00252.py", "pyc_path": "pyc/00252.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('merge',)\n IMPORT_NAME heapq\n IMPORT_FROM merge\n STORE_NAME merge\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME combine_lists\n RETURN_CONST None\nEND\nCODE combine_lists(num1, num2)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + merge\n LOAD_FAST num1\n LOAD_FAST num2\n CALL 2\n CALL 1\n STORE_FAST combine_lists\n LOAD_FAST combine_lists\n RETURN_VALUE\nEND", "expected": "from heapq import merge\n\ndef combine_lists(num1, num2):\n combine_lists = list(merge(num1, num2))\n return combine_lists", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 943, "mbpp_split": "train", "prompt": "Write a function to combine two given sorted lists using heapq module.", "test_list": ["assert combine_lists([1, 3, 5, 7, 9, 11],[0, 2, 4, 6, 8, 10])==[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]", "assert combine_lists([1, 3, 5, 6, 8, 9], [2, 5, 7, 11])==[1,2,3,5,5,6,7,8,9,11]", "assert combine_lists([1,3,7],[2,4,6])==[1,2,3,4,6,7]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_943", "n_instr": 24} {"i": 253, "src_path": "src/00253.py", "pyc_path": "pyc/00253.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME num_position\n RETURN_CONST None\nEND\nCODE num_position(text)\n RESUME 0\n LOAD_GLOBAL NULL + re\n LOAD_ATTR finditer\n LOAD_CONST '\\\\d+'\n LOAD_FAST text\n CALL 2\n GET_ITER\n FOR_ITER L1\n STORE_FAST m\n LOAD_FAST m\n LOAD_ATTR NULL|self + start\n CALL 0\n SWAP 2\n POP_TOP\n RETURN_VALUE\nL1:\n END_FOR\n RETURN_CONST None\nEND", "expected": "import re\n\ndef num_position(text):\n for m in re.finditer('\\\\d+', text):\n return m.start()", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 944, "mbpp_split": "train", "prompt": "Write a function to separate and print the numbers and their position of a given string.", "test_list": ["assert num_position(\"there are 70 flats in this apartment\")==10", "assert num_position(\"every adult have 32 teeth\")==17", "assert num_position(\"isha has 79 chocolates in her bag\")==9"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_944", "n_instr": 30} {"i": 254, "src_path": "src/00254.py", "pyc_path": "pyc/00254.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('Counter',)\n IMPORT_NAME collections\n IMPORT_FROM Counter\n STORE_NAME Counter\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME most_common_elem\n RETURN_CONST None\nEND\nCODE most_common_elem(s, a)\n RESUME 0\n LOAD_GLOBAL NULL + Counter\n LOAD_FAST s\n CALL 1\n LOAD_ATTR NULL|self + most_common\n LOAD_FAST a\n CALL 1\n STORE_FAST most_common_elem\n LOAD_FAST most_common_elem\n RETURN_VALUE\nEND", "expected": "from collections import Counter\n\ndef most_common_elem(s, a):\n most_common_elem = Counter(s).most_common(a)\n return most_common_elem", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 946, "mbpp_split": "train", "prompt": "Write a function to find the most common elements and their counts of a specified text.", "test_list": ["assert most_common_elem('lkseropewdssafsdfafkpwe',3)==[('s', 4), ('e', 3), ('f', 3)] ", "assert most_common_elem('lkseropewdssafsdfafkpwe',2)==[('s', 4), ('e', 3)]", "assert most_common_elem('lkseropewdssafsdfafkpwe',7)==[('s', 4), ('e', 3), ('f', 3), ('k', 2), ('p', 2), ('w', 2), ('d', 2)]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_946", "n_instr": 24} {"i": 255, "src_path": "src/00255.py", "pyc_path": "pyc/00255.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME len_log\n RETURN_CONST None\nEND\nCODE len_log(list1)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST list1\n LOAD_CONST 0\n BINARY_SUBSCR\n CALL 1\n STORE_FAST min\n LOAD_FAST list1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_GLOBAL NULL + len\n LOAD_FAST i\n CALL 1\n LOAD_FAST min\n COMPARE_OP <\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_GLOBAL NULL + len\n LOAD_FAST i\n CALL 1\n STORE_FAST min\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST min\n RETURN_VALUE\nEND", "expected": "def len_log(list1):\n min = len(list1[0])\n for i in list1:\n if len(i) < min:\n min = len(i)\n return min", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 947, "mbpp_split": "train", "prompt": "Write a python function to find the length of the shortest word.", "test_list": ["assert len_log([\"win\",\"lose\",\"great\"]) == 3", "assert len_log([\"a\",\"ab\",\"abc\"]) == 1", "assert len_log([\"12\",\"12\",\"1234\"]) == 2"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_947", "n_instr": 37} {"i": 256, "src_path": "src/00256.py", "pyc_path": "pyc/00256.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_item\n RETURN_CONST None\nEND\nCODE get_item(tup1, index)\n RESUME 0\n LOAD_FAST tup1\n LOAD_FAST index\n BINARY_SUBSCR\n STORE_FAST item\n LOAD_FAST item\n RETURN_VALUE\nEND", "expected": "def get_item(tup1, index):\n item = tup1[index]\n return item", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 948, "mbpp_split": "train", "prompt": "Write a function to get an item of a tuple.", "test_list": ["assert get_item((\"w\", 3, \"r\", \"e\", \"s\", \"o\", \"u\", \"r\", \"c\", \"e\"),3)==('e')", "assert get_item((\"w\", 3, \"r\", \"e\", \"s\", \"o\", \"u\", \"r\", \"c\", \"e\"),-4)==('u')", "assert get_item((\"w\", 3, \"r\", \"e\", \"s\", \"o\", \"u\", \"r\", \"c\", \"e\"),-3)==('r')"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_948", "n_instr": 15} {"i": 257, "src_path": "src/00257.py", "pyc_path": "pyc/00257.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_digs\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sort_list\n RETURN_CONST None\nEND\nCODE count_digs(tup)\n RESUME 0\n LOAD_GLOBAL NULL + sum\n LOAD_FAST tup\n GET_ITER\n LOAD_FAST_AND_CLEAR ele\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST ele\n LOAD_GLOBAL NULL + len\n LOAD_GLOBAL NULL + str\n LOAD_FAST ele\n CALL 1\n CALL 1\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n SWAP 2\n STORE_FAST ele\n CALL 1\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST ele\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=4 lasti=False\nEND\nCODE sort_list(test_list)\n RESUME 0\n LOAD_FAST test_list\n LOAD_ATTR NULL|self + sort\n LOAD_GLOBAL count_digs\n KW_NAMES ('key',)\n CALL 1\n POP_TOP\n LOAD_GLOBAL NULL + str\n LOAD_FAST test_list\n CALL 1\n RETURN_VALUE\nEND", "expected": "def count_digs(tup):\n return sum([len(str(ele)) for ele in tup])\n\ndef sort_list(test_list):\n test_list.sort(key=count_digs)\n return str(test_list)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 949, "mbpp_split": "train", "prompt": "Write a function to sort the given tuple list basis the total digits in tuple.", "test_list": ["assert sort_list([(3, 4, 6, 723), (1, 2), (12345,), (134, 234, 34)] ) == '[(1, 2), (12345,), (3, 4, 6, 723), (134, 234, 34)]'", "assert sort_list([(3, 4, 8), (1, 2), (1234335,), (1345, 234, 334)] ) == '[(1, 2), (3, 4, 8), (1234335,), (1345, 234, 334)]'", "assert sort_list([(34, 4, 61, 723), (1, 2), (145,), (134, 23)] ) == '[(1, 2), (145,), (134, 23), (34, 4, 61, 723)]'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_949", "n_instr": 57} {"i": 258, "src_path": "src/00258.py", "pyc_path": "pyc/00258.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME chinese_zodiac\n RETURN_CONST None\nEND\nCODE chinese_zodiac(year)\n RESUME 0\n LOAD_FAST year\n LOAD_CONST 2000\n BINARY_OP -\n LOAD_CONST 12\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n LOAD_CONST 'Dragon'\n STORE_FAST sign\n LOAD_FAST sign\n RETURN_VALUE\nL1:\n LOAD_FAST year\n LOAD_CONST 2000\n BINARY_OP -\n LOAD_CONST 12\n BINARY_OP %\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_CONST 'Snake'\n STORE_FAST sign\n LOAD_FAST sign\n RETURN_VALUE\nL2:\n LOAD_FAST year\n LOAD_CONST 2000\n BINARY_OP -\n LOAD_CONST 12\n BINARY_OP %\n LOAD_CONST 2\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n LOAD_CONST 'Horse'\n STORE_FAST sign\n LOAD_FAST sign\n RETURN_VALUE\nL3:\n LOAD_FAST year\n LOAD_CONST 2000\n BINARY_OP -\n LOAD_CONST 12\n BINARY_OP %\n LOAD_CONST 3\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L4\n LOAD_CONST 'sheep'\n STORE_FAST sign\n LOAD_FAST sign\n RETURN_VALUE\nL4:\n LOAD_FAST year\n LOAD_CONST 2000\n BINARY_OP -\n LOAD_CONST 12\n BINARY_OP %\n LOAD_CONST 4\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L5\n LOAD_CONST 'Monkey'\n STORE_FAST sign\n LOAD_FAST sign\n RETURN_VALUE\nL5:\n LOAD_FAST year\n LOAD_CONST 2000\n BINARY_OP -\n LOAD_CONST 12\n BINARY_OP %\n LOAD_CONST 5\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L6\n LOAD_CONST 'Rooster'\n STORE_FAST sign\n LOAD_FAST sign\n RETURN_VALUE\nL6:\n LOAD_FAST year\n LOAD_CONST 2000\n BINARY_OP -\n LOAD_CONST 12\n BINARY_OP %\n LOAD_CONST 6\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L7\n LOAD_CONST 'Dog'\n STORE_FAST sign\n LOAD_FAST sign\n RETURN_VALUE\nL7:\n LOAD_FAST year\n LOAD_CONST 2000\n BINARY_OP -\n LOAD_CONST 12\n BINARY_OP %\n LOAD_CONST 7\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L8\n LOAD_CONST 'Pig'\n STORE_FAST sign\n LOAD_FAST sign\n RETURN_VALUE\nL8:\n LOAD_FAST year\n LOAD_CONST 2000\n BINARY_OP -\n LOAD_CONST 12\n BINARY_OP %\n LOAD_CONST 8\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L9\n LOAD_CONST 'Rat'\n STORE_FAST sign\n LOAD_FAST sign\n RETURN_VALUE\nL9:\n LOAD_FAST year\n LOAD_CONST 2000\n BINARY_OP -\n LOAD_CONST 12\n BINARY_OP %\n LOAD_CONST 9\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L10\n LOAD_CONST 'Ox'\n STORE_FAST sign\n LOAD_FAST sign\n RETURN_VALUE\nL10:\n LOAD_FAST year\n LOAD_CONST 2000\n BINARY_OP -\n LOAD_CONST 12\n BINARY_OP %\n LOAD_CONST 10\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L11\n LOAD_CONST 'Tiger'\n STORE_FAST sign\n LOAD_FAST sign\n RETURN_VALUE\nL11:\n LOAD_CONST 'Hare'\n STORE_FAST sign\n LOAD_FAST sign\n RETURN_VALUE\nEND", "expected": "def chinese_zodiac(year):\n if (year - 2000) % 12 == 0:\n sign = 'Dragon'\n elif (year - 2000) % 12 == 1:\n sign = 'Snake'\n elif (year - 2000) % 12 == 2:\n sign = 'Horse'\n elif (year - 2000) % 12 == 3:\n sign = 'sheep'\n elif (year - 2000) % 12 == 4:\n sign = 'Monkey'\n elif (year - 2000) % 12 == 5:\n sign = 'Rooster'\n elif (year - 2000) % 12 == 6:\n sign = 'Dog'\n elif (year - 2000) % 12 == 7:\n sign = 'Pig'\n elif (year - 2000) % 12 == 8:\n sign = 'Rat'\n elif (year - 2000) % 12 == 9:\n sign = 'Ox'\n elif (year - 2000) % 12 == 10:\n sign = 'Tiger'\n else:\n sign = 'Hare'\n return sign", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 950, "mbpp_split": "train", "prompt": "Write a function to display sign of the chinese zodiac for given year.", "test_list": ["assert chinese_zodiac(1997)==('Ox')", "assert chinese_zodiac(1998)==('Tiger')", "assert chinese_zodiac(1994)==('Dog')"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_950", "n_instr": 156} {"i": 259, "src_path": "src/00259.py", "pyc_path": "pyc/00259.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME max_similar_indices\n RETURN_CONST None\nEND\nCODE max_similar_indices(test_list1, test_list2)\n RESUME 0\n LOAD_GLOBAL NULL + zip\n LOAD_FAST test_list1\n LOAD_FAST test_list2\n CALL 2\n GET_ITER\n LOAD_FAST_AND_CLEAR x\n LOAD_FAST_AND_CLEAR y\n SWAP 3\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST x\n STORE_FAST y\n LOAD_GLOBAL NULL + max\n LOAD_FAST x\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST y\n LOAD_CONST 0\n BINARY_SUBSCR\n CALL 2\n LOAD_GLOBAL NULL + max\n LOAD_FAST x\n LOAD_CONST 1\n BINARY_SUBSCR\n LOAD_FAST y\n LOAD_CONST 1\n BINARY_SUBSCR\n CALL 2\n BUILD_TUPLE 2\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST res\n STORE_FAST x\n STORE_FAST y\n LOAD_FAST res\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 3\n STORE_FAST y\n STORE_FAST x\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=3 lasti=False\nEND", "expected": "def max_similar_indices(test_list1, test_list2):\n res = [(max(x[0], y[0]), max(x[1], y[1])) for x, y in zip(test_list1, test_list2)]\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 951, "mbpp_split": "train", "prompt": "Write a function to find the maximum of similar indices in two lists of tuples.", "test_list": ["assert max_similar_indices([(2, 4), (6, 7), (5, 1)],[(5, 4), (8, 10), (8, 14)]) == [(5, 4), (8, 10), (8, 14)]", "assert max_similar_indices([(3, 5), (7, 8), (6, 2)],[(6, 5), (9, 11), (9, 15)]) == [(6, 5), (9, 11), (9, 15)]", "assert max_similar_indices([(4, 6), (8, 9), (7, 3)],[(7, 6), (10, 12), (10, 16)]) == [(7, 6), (10, 12), (10, 16)]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_951", "n_instr": 60} {"i": 260, "src_path": "src/00260.py", "pyc_path": "pyc/00260.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME profit_amount\n RETURN_CONST None\nEND\nCODE profit_amount(actual_cost, sale_amount)\n RESUME 0\n LOAD_FAST actual_cost\n LOAD_FAST sale_amount\n COMPARE_OP >\n POP_JUMP_IF_FALSE L1\n LOAD_FAST actual_cost\n LOAD_FAST sale_amount\n BINARY_OP -\n STORE_FAST amount\n LOAD_FAST amount\n RETURN_VALUE\nL1:\n RETURN_CONST None\nEND", "expected": "def profit_amount(actual_cost, sale_amount):\n if actual_cost > sale_amount:\n amount = actual_cost - sale_amount\n return amount\n else:\n return None", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 954, "mbpp_split": "train", "prompt": "Write a function that gives profit amount if the given amount has profit else return none.", "test_list": ["assert profit_amount(1500,1200)==300", "assert profit_amount(100,200)==None", "assert profit_amount(2000,5000)==None"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_954", "n_instr": 21} {"i": 261, "src_path": "src/00261.py", "pyc_path": "pyc/00261.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_abundant\n RETURN_CONST None\nEND\nCODE is_abundant(n)\n RESUME 0\n LOAD_GLOBAL NULL + sum\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST n\n CALL 2\n GET_ITER\n LOAD_FAST_AND_CLEAR fctr\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L5\n STORE_FAST fctr\n LOAD_FAST n\n LOAD_FAST fctr\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST fctr\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL5:\n END_FOR\nL6:\n SWAP 2\n STORE_FAST fctr\n CALL 1\n STORE_FAST fctrsum\n LOAD_FAST fctrsum\n LOAD_FAST n\n COMPARE_OP >\n RETURN_VALUE\nL7:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST fctr\n RERAISE 0\n EXC try=L1..L3 -> handler=L7 depth=4 lasti=False\n EXC try=L4..L6 -> handler=L7 depth=4 lasti=False\nEND", "expected": "def is_abundant(n):\n fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])\n return fctrsum > n", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 955, "mbpp_split": "train", "prompt": "Write a function to find out, if the given number is abundant.", "test_list": ["assert is_abundant(12)==True", "assert is_abundant(13)==False", "assert is_abundant(9)==False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_955", "n_instr": 54} {"i": 262, "src_path": "src/00262.py", "pyc_path": "pyc/00262.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_First_Set_Bit_Pos\n RETURN_CONST None\nEND\nCODE get_First_Set_Bit_Pos(n)\n RESUME 0\n LOAD_GLOBAL NULL + math\n LOAD_ATTR log2\n LOAD_FAST n\n LOAD_FAST n\n UNARY_NEGATIVE\n BINARY_OP &\n CALL 1\n LOAD_CONST 1\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "import math\n\ndef get_First_Set_Bit_Pos(n):\n return math.log2(n & -n) + 1", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 957, "mbpp_split": "train", "prompt": "Write a python function to get the position of rightmost set bit.", "test_list": ["assert get_First_Set_Bit_Pos(12) == 3", "assert get_First_Set_Bit_Pos(18) == 2", "assert get_First_Set_Bit_Pos(16) == 5"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_957", "n_instr": 23} {"i": 263, "src_path": "src/00263.py", "pyc_path": "pyc/00263.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME int_to_roman\n RETURN_CONST None\nEND\nCODE int_to_roman(num)\n RESUME 0\n BUILD_LIST 0\n LOAD_CONST (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1)\n LIST_EXTEND 1\n STORE_FAST val\n BUILD_LIST 0\n LOAD_CONST ('M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I')\n LIST_EXTEND 1\n STORE_FAST syb\n LOAD_CONST ''\n STORE_FAST roman_num\n LOAD_CONST 0\n STORE_FAST i\n LOAD_FAST num\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_FALSE L4\nL1:\n LOAD_GLOBAL NULL + range\n LOAD_FAST num\n LOAD_FAST val\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_OP //\n CALL 1\n GET_ITER\nL2:\n FOR_ITER L3\n STORE_FAST _\n LOAD_FAST roman_num\n LOAD_FAST syb\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_OP +=\n STORE_FAST roman_num\n LOAD_FAST num\n LOAD_FAST val\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_OP -=\n STORE_FAST num\n JUMP_BACKWARD L2\nL3:\n END_FOR\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST i\n LOAD_FAST num\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_FALSE L4\n JUMP_BACKWARD L1\nL4:\n LOAD_FAST roman_num\n RETURN_VALUE\nEND", "expected": "def int_to_roman(num):\n val = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]\n syb = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']\n roman_num = ''\n i = 0\n while num > 0:\n for _ in range(num // val[i]):\n roman_num += syb[i]\n num -= val[i]\n i += 1\n return roman_num", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 958, "mbpp_split": "train", "prompt": "Write a function to convert an integer into a roman numeral.", "test_list": ["assert int_to_roman(1)==(\"I\")", "assert int_to_roman(50)==(\"L\")", "assert int_to_roman(4)==(\"IV\")"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_958", "n_instr": 64} {"i": 264, "src_path": "src/00264.py", "pyc_path": "pyc/00264.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_noOfways\n RETURN_CONST None\nEND\nCODE get_noOfways(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 0\nL1:\n LOAD_FAST n\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n RETURN_CONST 1\nL2:\n LOAD_GLOBAL NULL + get_noOfways\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n LOAD_GLOBAL NULL + get_noOfways\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP -\n CALL 1\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def get_noOfways(n):\n if n == 0:\n return 0\n if n == 1:\n return 1\n return get_noOfways(n - 1) + get_noOfways(n - 2)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 960, "mbpp_split": "train", "prompt": "Write a function to solve tiling problem.", "test_list": ["assert get_noOfways(4)==3", "assert get_noOfways(3)==2", "assert get_noOfways(5)==5"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_960", "n_instr": 33} {"i": 265, "src_path": "src/00265.py", "pyc_path": "pyc/00265.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME roman_to_int\n RETURN_CONST None\nEND\nCODE roman_to_int(s)\n RESUME 0\n LOAD_CONST 1\n LOAD_CONST 5\n LOAD_CONST 10\n LOAD_CONST 50\n LOAD_CONST 100\n LOAD_CONST 500\n LOAD_CONST 1000\n LOAD_CONST ('I', 'V', 'X', 'L', 'C', 'D', 'M')\n BUILD_CONST_KEY_MAP 7\n STORE_FAST rom_val\n LOAD_CONST 0\n STORE_FAST int_val\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST s\n CALL 1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST i\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_FALSE L2\n LOAD_FAST rom_val\n LOAD_FAST s\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_SUBSCR\n LOAD_FAST rom_val\n LOAD_FAST s\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n BINARY_SUBSCR\n COMPARE_OP >\n POP_JUMP_IF_FALSE L2\n LOAD_FAST int_val\n LOAD_FAST rom_val\n LOAD_FAST s\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_SUBSCR\n LOAD_CONST 2\n LOAD_FAST rom_val\n LOAD_FAST s\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n BINARY_SUBSCR\n BINARY_OP *\n BINARY_OP -\n BINARY_OP +=\n STORE_FAST int_val\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST int_val\n LOAD_FAST rom_val\n LOAD_FAST s\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_SUBSCR\n BINARY_OP +=\n STORE_FAST int_val\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST int_val\n RETURN_VALUE\nEND", "expected": "def roman_to_int(s):\n rom_val = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}\n int_val = 0\n for i in range(len(s)):\n if i > 0 and rom_val[s[i]] > rom_val[s[i - 1]]:\n int_val += rom_val[s[i]] - 2 * rom_val[s[i - 1]]\n else:\n int_val += rom_val[s[i]]\n return int_val", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 961, "mbpp_split": "train", "prompt": "Write a function to convert a roman numeral to an integer.", "test_list": ["assert roman_to_int('MMMCMLXXXVI')==3986", "assert roman_to_int('MMMM')==4000", "assert roman_to_int('C')==100"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_961", "n_instr": 81} {"i": 266, "src_path": "src/00266.py", "pyc_path": "pyc/00266.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_Natural\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_Even\n RETURN_CONST None\nEND\nCODE sum_Natural(n)\n RESUME 0\n LOAD_FAST n\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP *\n STORE_FAST sum\n LOAD_GLOBAL NULL + int\n LOAD_FAST sum\n CALL 1\n RETURN_VALUE\nEND\nCODE sum_Even(l, r)\n RESUME 0\n LOAD_GLOBAL NULL + sum_Natural\n LOAD_GLOBAL NULL + int\n LOAD_FAST r\n LOAD_CONST 2\n BINARY_OP /\n CALL 1\n CALL 1\n LOAD_GLOBAL NULL + sum_Natural\n LOAD_GLOBAL NULL + int\n LOAD_FAST l\n LOAD_CONST 1\n BINARY_OP -\n LOAD_CONST 2\n BINARY_OP /\n CALL 1\n CALL 1\n BINARY_OP -\n RETURN_VALUE\nEND", "expected": "def sum_Natural(n):\n sum = n * (n + 1)\n return int(sum)\n\ndef sum_Even(l, r):\n return sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2))", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 962, "mbpp_split": "train", "prompt": "Write a python function to find the sum of all even natural numbers within the range l and r.", "test_list": ["assert sum_Even(2,5) == 6", "assert sum_Even(3,8) == 18", "assert sum_Even(4,6) == 10"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_962", "n_instr": 43} {"i": 267, "src_path": "src/00267.py", "pyc_path": "pyc/00267.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME word_len\n RETURN_CONST None\nEND\nCODE word_len(s)\n RESUME 0\n LOAD_FAST s\n LOAD_ATTR NULL|self + split\n LOAD_CONST ' '\n CALL 1\n STORE_FAST s\n LOAD_FAST s\n GET_ITER\n FOR_ITER L2\n STORE_FAST word\n LOAD_GLOBAL NULL + len\n LOAD_FAST word\n CALL 1\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n POP_TOP\n RETURN_CONST True\nL1:\n POP_TOP\n RETURN_CONST False\nL2:\n END_FOR\n RETURN_CONST None\nEND", "expected": "def word_len(s):\n s = s.split(' ')\n for word in s:\n if len(word) % 2 == 0:\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 964, "mbpp_split": "train", "prompt": "Write a python function to check whether the length of the word is even or not.", "test_list": ["assert word_len(\"program\") == False", "assert word_len(\"solution\") == True", "assert word_len(\"data\") == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_964", "n_instr": 34} {"i": 268, "src_path": "src/00268.py", "pyc_path": "pyc/00268.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME camel_to_snake\n RETURN_CONST None\nEND\nCODE camel_to_snake(text)\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_FAST re\n LOAD_FAST re\n LOAD_ATTR NULL|self + sub\n LOAD_CONST '(.)([A-Z][a-z]+)'\n LOAD_CONST '\\\\1_\\\\2'\n LOAD_FAST text\n CALL 3\n STORE_FAST str1\n LOAD_FAST re\n LOAD_ATTR NULL|self + sub\n LOAD_CONST '([a-z0-9])([A-Z])'\n LOAD_CONST '\\\\1_\\\\2'\n LOAD_FAST str1\n CALL 3\n LOAD_ATTR NULL|self + lower\n CALL 0\n RETURN_VALUE\nEND", "expected": "def camel_to_snake(text):\n import re\n str1 = re.sub('(.)([A-Z][a-z]+)', '\\\\1_\\\\2', text)\n return re.sub('([a-z0-9])([A-Z])', '\\\\1_\\\\2', str1).lower()", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 965, "mbpp_split": "train", "prompt": "Write a function to convert camel case string to snake case string.", "test_list": ["assert camel_to_snake('PythonProgram')==('python_program')", "assert camel_to_snake('pythonLanguage')==('python_language')", "assert camel_to_snake('ProgrammingLanguage')==('programming_language')"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_965", "n_instr": 29} {"i": 269, "src_path": "src/00269.py", "pyc_path": "pyc/00269.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove_empty\n RETURN_CONST None\nEND\nCODE remove_empty(tuple1)\n RESUME 0\n LOAD_FAST tuple1\n GET_ITER\n LOAD_FAST_AND_CLEAR t\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L5\n STORE_FAST t\n LOAD_FAST t\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST t\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL5:\n END_FOR\nL6:\n STORE_FAST tuple1\n STORE_FAST t\n LOAD_FAST tuple1\n RETURN_VALUE\nL7:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST t\n RERAISE 0\n EXC try=L1..L3 -> handler=L7 depth=2 lasti=False\n EXC try=L4..L6 -> handler=L7 depth=2 lasti=False\nEND", "expected": "def remove_empty(tuple1):\n tuple1 = [t for t in tuple1 if t]\n return tuple1", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 966, "mbpp_split": "train", "prompt": "Write a function to remove an empty tuple from a list of tuples.", "test_list": ["assert remove_empty([(), (), ('',), ('a', 'b'), ('a', 'b', 'c'), ('d')])==[('',), ('a', 'b'), ('a', 'b', 'c'), 'd'] ", "assert remove_empty([(), (), ('',), (\"python\"), (\"program\")])==[('',), (\"python\"), (\"program\")] ", "assert remove_empty([(), (), ('',), (\"java\")])==[('',),(\"java\") ] "], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_966", "n_instr": 42} {"i": 270, "src_path": "src/00270.py", "pyc_path": "pyc/00270.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check\n RETURN_CONST None\nEND\nCODE check(string)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_GLOBAL NULL + set\n LOAD_FAST string\n CALL 1\n LOAD_ATTR NULL|self + intersection\n LOAD_CONST 'AEIOUaeiou'\n CALL 1\n CALL 1\n LOAD_CONST 5\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'accepted'\nL1:\n RETURN_CONST 'not accepted'\nEND", "expected": "def check(string):\n if len(set(string).intersection('AEIOUaeiou')) >= 5:\n return 'accepted'\n else:\n return 'not accepted'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 967, "mbpp_split": "train", "prompt": "Write a python function to accept the strings which contains all vowels.", "test_list": ["assert check(\"SEEquoiaL\") == 'accepted'", "assert check('program') == \"not accepted\"", "assert check('fine') == \"not accepted\""], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_967", "n_instr": 23} {"i": 271, "src_path": "src/00271.py", "pyc_path": "pyc/00271.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME join_tuples\n RETURN_CONST None\nEND\nCODE join_tuples(test_list)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST res\n LOAD_FAST test_list\n GET_ITER\nL1:\n FOR_ITER L7\n STORE_FAST sub\n LOAD_FAST res\n POP_JUMP_IF_FALSE L2\n LOAD_FAST res\n LOAD_CONST -1\n BINARY_SUBSCR\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST sub\n LOAD_CONST 0\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_FAST res\n LOAD_CONST -1\n BINARY_SUBSCR\n LOAD_ATTR NULL|self + extend\n LOAD_FAST sub\n LOAD_CONST 1\n LOAD_CONST None\n BINARY_SLICE\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST res\n LOAD_ATTR NULL|self + append\n LOAD_FAST sub\n GET_ITER\n LOAD_FAST_AND_CLEAR ele\n SWAP 2\nL3:\n BUILD_LIST 0\n SWAP 2\nL4:\n FOR_ITER L5\n STORE_FAST ele\n LOAD_FAST ele\n LIST_APPEND 2\n JUMP_BACKWARD L4\nL5:\n END_FOR\nL6:\n SWAP 2\n STORE_FAST ele\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL7:\n END_FOR\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + map\n LOAD_GLOBAL tuple\n LOAD_FAST res\n CALL 2\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nL8:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST ele\n RERAISE 0\n EXC try=L3..L6 -> handler=L8 depth=5 lasti=False\nEND", "expected": "def join_tuples(test_list):\n res = []\n for sub in test_list:\n if res and res[-1][0] == sub[0]:\n res[-1].extend(sub[1:])\n else:\n res.append([ele for ele in sub])\n res = list(map(tuple, res))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 969, "mbpp_split": "train", "prompt": "Write a function to join the tuples if they have similar initial elements.", "test_list": ["assert join_tuples([(5, 6), (5, 7), (6, 8), (6, 10), (7, 13)] ) == [(5, 6, 7), (6, 8, 10), (7, 13)]", "assert join_tuples([(6, 7), (6, 8), (7, 9), (7, 11), (8, 14)] ) == [(6, 7, 8), (7, 9, 11), (8, 14)]", "assert join_tuples([(7, 8), (7, 9), (8, 10), (8, 12), (9, 15)] ) == [(7, 8, 9), (8, 10, 12), (9, 15)]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_969", "n_instr": 81} {"i": 272, "src_path": "src/00272.py", "pyc_path": "pyc/00272.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME min_of_two\n RETURN_CONST None\nEND\nCODE min_of_two(x, y)\n RESUME 0\n LOAD_FAST x\n LOAD_FAST y\n COMPARE_OP <\n POP_JUMP_IF_FALSE L1\n LOAD_FAST x\n RETURN_VALUE\nL1:\n LOAD_FAST y\n RETURN_VALUE\nEND", "expected": "def min_of_two(x, y):\n if x < y:\n return x\n return y", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 970, "mbpp_split": "train", "prompt": "Write a function to find minimum of two numbers.", "test_list": ["assert min_of_two(10,20)==10", "assert min_of_two(19,15)==15", "assert min_of_two(-10,-20)==-20"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_970", "n_instr": 18} {"i": 273, "src_path": "src/00273.py", "pyc_path": "pyc/00273.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME maximum_segments\n RETURN_CONST None\nEND\nCODE maximum_segments(n, a, b, c)\n RESUME 0\n LOAD_CONST -1\n BUILD_LIST 1\n LOAD_FAST n\n LOAD_CONST 10\n BINARY_OP +\n BINARY_OP *\n STORE_FAST dp\n LOAD_CONST 0\n LOAD_FAST dp\n LOAD_CONST 0\n STORE_SUBSCR\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_FAST n\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L6\n STORE_FAST i\n LOAD_FAST dp\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST -1\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST i\n LOAD_FAST a\n BINARY_OP +\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L3\n LOAD_GLOBAL NULL + max\n LOAD_FAST dp\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST dp\n LOAD_FAST i\n LOAD_FAST a\n BINARY_OP +\n BINARY_SUBSCR\n CALL 2\n LOAD_FAST dp\n LOAD_FAST i\n LOAD_FAST a\n BINARY_OP +\n STORE_SUBSCR\nL3:\n LOAD_FAST i\n LOAD_FAST b\n BINARY_OP +\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L4\n LOAD_GLOBAL NULL + max\n LOAD_FAST dp\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST dp\n LOAD_FAST i\n LOAD_FAST b\n BINARY_OP +\n BINARY_SUBSCR\n CALL 2\n LOAD_FAST dp\n LOAD_FAST i\n LOAD_FAST b\n BINARY_OP +\n STORE_SUBSCR\nL4:\n LOAD_FAST i\n LOAD_FAST c\n BINARY_OP +\n LOAD_FAST n\n COMPARE_OP <=\n POP_JUMP_IF_TRUE L5\n JUMP_BACKWARD L1\nL5:\n LOAD_GLOBAL NULL + max\n LOAD_FAST dp\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST dp\n LOAD_FAST i\n LOAD_FAST c\n BINARY_OP +\n BINARY_SUBSCR\n CALL 2\n LOAD_FAST dp\n LOAD_FAST i\n LOAD_FAST c\n BINARY_OP +\n STORE_SUBSCR\n JUMP_BACKWARD L1\nL6:\n END_FOR\n LOAD_FAST dp\n LOAD_FAST n\n BINARY_SUBSCR\n RETURN_VALUE\nEND", "expected": "def maximum_segments(n, a, b, c):\n dp = [-1] * (n + 10)\n dp[0] = 0\n for i in range(0, n):\n if dp[i] != -1:\n if i + a <= n:\n dp[i + a] = max(dp[i] + 1, dp[i + a])\n if i + b <= n:\n dp[i + b] = max(dp[i] + 1, dp[i + b])\n if i + c <= n:\n dp[i + c] = max(dp[i] + 1, dp[i + c])\n return dp[n]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 971, "mbpp_split": "train", "prompt": "Write a function to find the maximum number of segments of lengths a, b and c that can be formed from n.", "test_list": ["assert maximum_segments(7, 5, 2, 5) == 2", "assert maximum_segments(17, 2, 1, 3) == 17", "assert maximum_segments(18, 16, 3, 6) == 6"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_971", "n_instr": 116} {"i": 274, "src_path": "src/00274.py", "pyc_path": "pyc/00274.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME concatenate_nested\n RETURN_CONST None\nEND\nCODE concatenate_nested(test_tup1, test_tup2)\n RESUME 0\n LOAD_FAST test_tup1\n LOAD_FAST test_tup2\n BINARY_OP +\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def concatenate_nested(test_tup1, test_tup2):\n res = test_tup1 + test_tup2\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 972, "mbpp_split": "train", "prompt": "Write a function to concatenate the given two tuples to a nested tuple.", "test_list": ["assert concatenate_nested((3, 4), (5, 6)) == (3, 4, 5, 6)", "assert concatenate_nested((1, 2), (3, 4)) == (1, 2, 3, 4)", "assert concatenate_nested((4, 5), (6, 8)) == (4, 5, 6, 8)"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_972", "n_instr": 15} {"i": 275, "src_path": "src/00275.py", "pyc_path": "pyc/00275.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME left_rotate\n RETURN_CONST None\nEND\nCODE left_rotate(s, d)\n RESUME 0\n LOAD_FAST s\n LOAD_FAST d\n LOAD_CONST None\n BINARY_SLICE\n LOAD_FAST s\n LOAD_CONST 0\n LOAD_FAST d\n BINARY_SLICE\n BINARY_OP +\n STORE_FAST tmp\n LOAD_FAST tmp\n RETURN_VALUE\nEND", "expected": "def left_rotate(s, d):\n tmp = s[d:] + s[0:d]\n return tmp", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 973, "mbpp_split": "train", "prompt": "Write a python function to left rotate the string.", "test_list": ["assert left_rotate(\"python\",2) == \"thonpy\" ", "assert left_rotate(\"bigdata\",3 ) == \"databig\" ", "assert left_rotate(\"hadoop\",1 ) == \"adooph\" "], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_973", "n_instr": 21} {"i": 276, "src_path": "src/00276.py", "pyc_path": "pyc/00276.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove_Occ\n RETURN_CONST None\nEND\nCODE remove_Occ(s, ch)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST s\n CALL 1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST s\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST ch\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST s\n LOAD_CONST 0\n LOAD_FAST i\n BINARY_SLICE\n LOAD_FAST s\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n LOAD_CONST None\n BINARY_SLICE\n BINARY_OP +\n STORE_FAST s\n POP_TOP\n JUMP_FORWARD L4\nL3:\n END_FOR\nL4:\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST s\n CALL 1\n LOAD_CONST 1\n BINARY_OP -\n LOAD_CONST -1\n LOAD_CONST -1\n CALL 3\n GET_ITER\nL5:\n FOR_ITER L7\n STORE_FAST i\n LOAD_FAST s\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST ch\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L6\n JUMP_BACKWARD L5\nL6:\n LOAD_FAST s\n LOAD_CONST 0\n LOAD_FAST i\n BINARY_SLICE\n LOAD_FAST s\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n LOAD_CONST None\n BINARY_SLICE\n BINARY_OP +\n STORE_FAST s\n POP_TOP\n LOAD_FAST s\n RETURN_VALUE\nL7:\n END_FOR\n LOAD_FAST s\n RETURN_VALUE\nEND", "expected": "def remove_Occ(s, ch):\n for i in range(len(s)):\n if s[i] == ch:\n s = s[0:i] + s[i + 1:]\n break\n for i in range(len(s) - 1, -1, -1):\n if s[i] == ch:\n s = s[0:i] + s[i + 1:]\n break\n return s", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 11, "mbpp_split": "test", "prompt": "Write a python function to remove first and last occurrence of a given character from the string.", "test_list": ["assert remove_Occ(\"hello\",\"l\") == \"heo\"", "assert remove_Occ(\"abcda\",\"a\") == \"bcd\"", "assert remove_Occ(\"PHP\",\"P\") == \"H\""], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_11", "n_instr": 83} {"i": 277, "src_path": "src/00277.py", "pyc_path": "pyc/00277.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sort_matrix\n RETURN_CONST None\nEND\nCODE sort_matrix(M)\n RESUME 0\n LOAD_GLOBAL NULL + sorted\n LOAD_FAST M\n LOAD_GLOBAL sum\n KW_NAMES ('key',)\n CALL 2\n STORE_FAST result\n LOAD_FAST result\n RETURN_VALUE\nEND", "expected": "def sort_matrix(M):\n result = sorted(M, key=sum)\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 12, "mbpp_split": "test", "prompt": "Write a function to sort a given matrix in ascending order according to the sum of its rows.", "test_list": ["assert sort_matrix([[1, 2, 3], [2, 4, 5], [1, 1, 1]])==[[1, 1, 1], [1, 2, 3], [2, 4, 5]]", "assert sort_matrix([[1, 2, 3], [-2, 4, -5], [1, -1, 1]])==[[-2, 4, -5], [1, -1, 1], [1, 2, 3]]", "assert sort_matrix([[5,8,9],[6,4,3],[2,1,4]])==[[2, 1, 4], [6, 4, 3], [5, 8, 9]]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_12", "n_instr": 17} {"i": 278, "src_path": "src/00278.py", "pyc_path": "pyc/00278.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('Counter',)\n IMPORT_NAME collections\n IMPORT_FROM Counter\n STORE_NAME Counter\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_common\n RETURN_CONST None\nEND\nCODE count_common(words)\n RESUME 0\n LOAD_GLOBAL NULL + Counter\n LOAD_FAST words\n CALL 1\n STORE_FAST word_counts\n LOAD_FAST word_counts\n LOAD_ATTR NULL|self + most_common\n LOAD_CONST 4\n CALL 1\n STORE_FAST top_four\n LOAD_FAST top_four\n RETURN_VALUE\nEND", "expected": "from collections import Counter\n\ndef count_common(words):\n word_counts = Counter(words)\n top_four = word_counts.most_common(4)\n return top_four", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 13, "mbpp_split": "test", "prompt": "Write a function to count the most common words in a dictionary.", "test_list": ["assert count_common(['red','green','black','pink','black','white','black','eyes','white','black','orange','pink','pink','red','red','white','orange','white',\"black\",'pink','green','green','pink','green','pink','white','orange',\"orange\",'red']) == [('pink', 6), ('black', 5), ('white', 5), ('red', 4)]", "assert count_common(['one', 'two', 'three', 'four', 'five', 'one', 'two', 'one', 'three', 'one']) == [('one', 4), ('two', 2), ('three', 2), ('four', 1)]", "assert count_common(['Facebook', 'Apple', 'Amazon', 'Netflix', 'Google', 'Apple', 'Netflix', 'Amazon']) == [('Apple', 2), ('Amazon', 2), ('Netflix', 2), ('Facebook', 1)]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_13", "n_instr": 26} {"i": 279, "src_path": "src/00279.py", "pyc_path": "pyc/00279.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME text_lowercase_underscore\n RETURN_CONST None\nEND\nCODE text_lowercase_underscore(text)\n RESUME 0\n LOAD_CONST '^[a-z]+_[a-z]+$'\n STORE_FAST patterns\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_FAST patterns\n LOAD_FAST text\n CALL 2\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Found a match!'\nL1:\n RETURN_CONST 'Not matched!'\nEND", "expected": "import re\n\ndef text_lowercase_underscore(text):\n patterns = '^[a-z]+_[a-z]+$'\n if re.search(patterns, text):\n return 'Found a match!'\n else:\n return 'Not matched!'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 16, "mbpp_split": "test", "prompt": "Write a function to find sequences of lowercase letters joined with an underscore.", "test_list": ["assert text_lowercase_underscore(\"aab_cbbbc\")==('Found a match!')", "assert text_lowercase_underscore(\"aab_Abbbc\")==('Not matched!')", "assert text_lowercase_underscore(\"Aaab_abbbc\")==('Not matched!')"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_16", "n_instr": 24} {"i": 280, "src_path": "src/00280.py", "pyc_path": "pyc/00280.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 256\n STORE_NAME NO_OF_CHARS\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME str_to_list\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME lst_to_string\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_char_count_array\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove_dirty_chars\n RETURN_CONST None\nEND\nCODE str_to_list(string)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST temp\n LOAD_FAST string\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST x\n LOAD_FAST temp\n LOAD_ATTR NULL|self + append\n LOAD_FAST x\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST temp\n RETURN_VALUE\nEND\nCODE lst_to_string(List)\n RESUME 0\n LOAD_CONST ''\n LOAD_ATTR NULL|self + join\n LOAD_FAST List\n CALL 1\n RETURN_VALUE\nEND\nCODE get_char_count_array(string)\n RESUME 0\n LOAD_CONST 0\n BUILD_LIST 1\n LOAD_GLOBAL NO_OF_CHARS\n BINARY_OP *\n STORE_FAST count\n LOAD_FAST string\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST count\n LOAD_GLOBAL NULL + ord\n LOAD_FAST i\n CALL 1\n COPY 2\n COPY 2\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +=\n SWAP 3\n SWAP 2\n STORE_SUBSCR\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST count\n RETURN_VALUE\nEND\nCODE remove_dirty_chars(string, second_string)\n RESUME 0\n LOAD_GLOBAL NULL + get_char_count_array\n LOAD_FAST second_string\n CALL 1\n STORE_FAST count\n LOAD_CONST 0\n STORE_FAST ip_ind\n LOAD_CONST 0\n STORE_FAST res_ind\n LOAD_CONST ''\n STORE_FAST temp\n LOAD_GLOBAL NULL + str_to_list\n LOAD_FAST string\n CALL 1\n STORE_FAST str_list\n LOAD_FAST ip_ind\n LOAD_GLOBAL NULL + len\n LOAD_FAST str_list\n CALL 1\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L3\nL1:\n LOAD_FAST str_list\n LOAD_FAST ip_ind\n BINARY_SUBSCR\n STORE_FAST temp\n LOAD_FAST count\n LOAD_GLOBAL NULL + ord\n LOAD_FAST temp\n CALL 1\n BINARY_SUBSCR\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_FAST str_list\n LOAD_FAST ip_ind\n BINARY_SUBSCR\n LOAD_FAST str_list\n LOAD_FAST res_ind\n STORE_SUBSCR\n LOAD_FAST res_ind\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST res_ind\nL2:\n LOAD_FAST ip_ind\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST ip_ind\n LOAD_FAST ip_ind\n LOAD_GLOBAL NULL + len\n LOAD_FAST str_list\n CALL 1\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L3\n JUMP_BACKWARD L1\nL3:\n LOAD_GLOBAL NULL + lst_to_string\n LOAD_FAST str_list\n LOAD_CONST 0\n LOAD_FAST res_ind\n BINARY_SLICE\n CALL 1\n RETURN_VALUE\nEND", "expected": "NO_OF_CHARS = 256\n\ndef str_to_list(string):\n temp = []\n for x in string:\n temp.append(x)\n return temp\n\ndef lst_to_string(List):\n return ''.join(List)\n\ndef get_char_count_array(string):\n count = [0] * NO_OF_CHARS\n for i in string:\n count[ord(i)] += 1\n return count\n\ndef remove_dirty_chars(string, second_string):\n count = get_char_count_array(second_string)\n ip_ind = 0\n res_ind = 0\n temp = ''\n str_list = str_to_list(string)\n while ip_ind != len(str_list):\n temp = str_list[ip_ind]\n if count[ord(temp)] == 0:\n str_list[res_ind] = str_list[ip_ind]\n res_ind += 1\n ip_ind += 1\n return lst_to_string(str_list[0:res_ind])", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 18, "mbpp_split": "test", "prompt": "Write a function to remove characters from the first string which are present in the second string.", "test_list": ["assert remove_dirty_chars(\"probasscurve\", \"pros\") == 'bacuve'", "assert remove_dirty_chars(\"digitalindia\", \"talent\") == 'digiidi'", "assert remove_dirty_chars(\"exoticmiles\", \"toxic\") == 'emles' "], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_18", "n_instr": 141} {"i": 281, "src_path": "src/00281.py", "pyc_path": "pyc/00281.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME test_duplicate\n RETURN_CONST None\nEND\nCODE test_duplicate(arraynums)\n RESUME 0\n LOAD_GLOBAL NULL + set\n LOAD_FAST arraynums\n CALL 1\n STORE_FAST nums_set\n LOAD_GLOBAL NULL + len\n LOAD_FAST arraynums\n CALL 1\n LOAD_GLOBAL NULL + len\n LOAD_FAST nums_set\n CALL 1\n COMPARE_OP !=\n RETURN_VALUE\nEND", "expected": "def test_duplicate(arraynums):\n nums_set = set(arraynums)\n return len(arraynums) != len(nums_set)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 19, "mbpp_split": "test", "prompt": "Write a function to find whether a given array of integers contains any duplicate element.", "test_list": ["assert test_duplicate(([1,2,3,4,5]))==False", "assert test_duplicate(([1,2,3,4, 4]))==True", "assert test_duplicate([1,1,2,2,3,3,4,4,5])==True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_19", "n_instr": 21} {"i": 282, "src_path": "src/00282.py", "pyc_path": "pyc/00282.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_woodall\n RETURN_CONST None\nEND\nCODE is_woodall(x)\n RESUME 0\n LOAD_FAST x\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST False\nL1:\n LOAD_FAST x\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n RETURN_CONST True\nL2:\n LOAD_FAST x\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST x\n LOAD_CONST 0\n STORE_FAST p\n LOAD_FAST x\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L5\nL3:\n LOAD_FAST x\n LOAD_CONST 2\n BINARY_OP /\n STORE_FAST x\n LOAD_FAST p\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST p\n LOAD_FAST p\n LOAD_FAST x\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L4\n RETURN_CONST True\nL4:\n LOAD_FAST x\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L5\n JUMP_BACKWARD L3\nL5:\n RETURN_CONST False\nEND", "expected": "def is_woodall(x):\n if x % 2 == 0:\n return False\n if x == 1:\n return True\n x = x + 1\n p = 0\n while x % 2 == 0:\n x = x / 2\n p = p + 1\n if p == x:\n return True\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 20, "mbpp_split": "test", "prompt": "Write a function to check if the given number is woodball or not.", "test_list": ["assert is_woodall(383) == True", "assert is_woodall(254) == False", "assert is_woodall(200) == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_20", "n_instr": 59} {"i": 283, "src_path": "src/00283.py", "pyc_path": "pyc/00283.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_first_duplicate\n RETURN_CONST None\nEND\nCODE find_first_duplicate(nums)\n RESUME 0\n LOAD_GLOBAL NULL + set\n CALL 0\n STORE_FAST num_set\n LOAD_CONST -1\n STORE_FAST no_duplicate\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST nums\n CALL 1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST nums\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST num_set\n CONTAINS_OP 0\n POP_JUMP_IF_FALSE L2\n LOAD_FAST nums\n LOAD_FAST i\n BINARY_SUBSCR\n SWAP 2\n POP_TOP\n RETURN_VALUE\nL2:\n LOAD_FAST num_set\n LOAD_ATTR NULL|self + add\n LOAD_FAST nums\n LOAD_FAST i\n BINARY_SUBSCR\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST no_duplicate\n RETURN_VALUE\nEND", "expected": "def find_first_duplicate(nums):\n num_set = set()\n no_duplicate = -1\n for i in range(len(nums)):\n if nums[i] in num_set:\n return nums[i]\n else:\n num_set.add(nums[i])\n return no_duplicate", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 22, "mbpp_split": "test", "prompt": "Write a function to find the first duplicate element in a given array of integers.", "test_list": ["assert find_first_duplicate(([1, 2, 3, 4, 4, 5]))==4", "assert find_first_duplicate([1, 2, 3, 4])==-1", "assert find_first_duplicate([1, 1, 2, 3, 3, 2, 2])==1"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_22", "n_instr": 48} {"i": 284, "src_path": "src/00284.py", "pyc_path": "pyc/00284.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME maximum_Sum\n RETURN_CONST None\nEND\nCODE maximum_Sum(list1)\n RESUME 0\n LOAD_CONST -100000\n STORE_FAST maxi\n LOAD_FAST list1\n GET_ITER\nL1:\n FOR_ITER L4\n STORE_FAST x\n LOAD_CONST 0\n STORE_FAST sum\n LOAD_FAST x\n GET_ITER\nL2:\n FOR_ITER L3\n STORE_FAST y\n LOAD_FAST sum\n LOAD_FAST y\n BINARY_OP +=\n STORE_FAST sum\n JUMP_BACKWARD L2\nL3:\n END_FOR\n LOAD_GLOBAL NULL + max\n LOAD_FAST sum\n LOAD_FAST maxi\n CALL 2\n STORE_FAST maxi\n JUMP_BACKWARD L1\nL4:\n END_FOR\n LOAD_FAST maxi\n RETURN_VALUE\nEND", "expected": "def maximum_Sum(list1):\n maxi = -100000\n for x in list1:\n sum = 0\n for y in x:\n sum += y\n maxi = max(sum, maxi)\n return maxi", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 23, "mbpp_split": "test", "prompt": "Write a python function to find the maximum sum of elements of list in a list of lists.", "test_list": ["assert maximum_Sum([[1,2,3],[4,5,6],[10,11,12],[7,8,9]]) == 33", "assert maximum_Sum([[0,1,1],[1,1,2],[3,2,1]]) == 6", "assert maximum_Sum([[0,1,3],[1,2,1],[9,8,2],[0,1,0],[6,4,8]]) == 19"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_23", "n_instr": 40} {"i": 285, "src_path": "src/00285.py", "pyc_path": "pyc/00285.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME binary_to_decimal\n RETURN_CONST None\nEND\nCODE binary_to_decimal(binary)\n RESUME 0\n LOAD_FAST binary\n STORE_FAST binary1\n LOAD_CONST (0, 0, 0)\n UNPACK_SEQUENCE 3\n STORE_FAST decimal\n STORE_FAST i\n STORE_FAST n\n LOAD_FAST binary\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_FAST binary\n LOAD_CONST 10\n BINARY_OP %\n STORE_FAST dec\n LOAD_FAST decimal\n LOAD_FAST dec\n LOAD_GLOBAL NULL + pow\n LOAD_CONST 2\n LOAD_FAST i\n CALL 2\n BINARY_OP *\n BINARY_OP +\n STORE_FAST decimal\n LOAD_FAST binary\n LOAD_CONST 10\n BINARY_OP //\n STORE_FAST binary\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST i\n LOAD_FAST binary\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST decimal\n RETURN_VALUE\nEND", "expected": "def binary_to_decimal(binary):\n binary1 = binary\n decimal, i, n = (0, 0, 0)\n while binary != 0:\n dec = binary % 10\n decimal = decimal + dec * pow(2, i)\n binary = binary // 10\n i += 1\n return decimal", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 24, "mbpp_split": "test", "prompt": "Write a function to convert the given binary number to its decimal equivalent.", "test_list": ["assert binary_to_decimal(100) == 4", "assert binary_to_decimal(1011) == 11", "assert binary_to_decimal(1101101) == 109"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_24", "n_instr": 50} {"i": 286, "src_path": "src/00286.py", "pyc_path": "pyc/00286.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_k_elements\n RETURN_CONST None\nEND\nCODE check_k_elements(test_list, K)\n RESUME 0\n LOAD_CONST True\n STORE_FAST res\n LOAD_FAST test_list\n GET_ITER\nL1:\n FOR_ITER L5\n STORE_FAST tup\n LOAD_FAST tup\n GET_ITER\nL2:\n FOR_ITER L4\n STORE_FAST ele\n LOAD_FAST ele\n LOAD_FAST K\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L2\nL3:\n LOAD_CONST False\n STORE_FAST res\n JUMP_BACKWARD L2\nL4:\n END_FOR\n JUMP_BACKWARD L1\nL5:\n END_FOR\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def check_k_elements(test_list, K):\n res = True\n for tup in test_list:\n for ele in tup:\n if ele != K:\n res = False\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 26, "mbpp_split": "test", "prompt": "Write a function to check if the given tuple list has all k elements.", "test_list": ["assert check_k_elements([(4, 4), (4, 4, 4), (4, 4), (4, 4, 4, 4), (4, )], 4) == True", "assert check_k_elements([(7, 7, 7), (7, 7)], 7) == True", "assert check_k_elements([(9, 9), (9, 9, 9, 9)], 7) == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_26", "n_instr": 37} {"i": 287, "src_path": "src/00287.py", "pyc_path": "pyc/00287.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME remove\n RETURN_CONST None\nEND\nCODE remove(list)\n RESUME 0\n LOAD_CONST '[0-9]'\n STORE_FAST pattern\n LOAD_FAST list\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_GLOBAL NULL + re\n LOAD_ATTR sub\n LOAD_FAST pattern\n LOAD_CONST ''\n LOAD_FAST i\n CALL 3\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST list\n STORE_FAST i\n LOAD_FAST list\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=2 lasti=False\nEND", "expected": "import re\n\ndef remove(list):\n pattern = '[0-9]'\n list = [re.sub(pattern, '', i) for i in list]\n return list", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 27, "mbpp_split": "test", "prompt": "Write a python function to remove all digits from a list of strings.", "test_list": ["assert remove(['4words', '3letters', '4digits']) == ['words', 'letters', 'digits']", "assert remove(['28Jan','12Jan','11Jan']) == ['Jan','Jan','Jan']", "assert remove(['wonder1','wonder2','wonder3']) == ['wonder','wonder','wonder']"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_27", "n_instr": 47} {"i": 288, "src_path": "src/00288.py", "pyc_path": "pyc/00288.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME binomial_Coeff\n RETURN_CONST None\nEND\nCODE binomial_Coeff(n, k)\n RESUME 0\n LOAD_FAST k\n LOAD_FAST n\n COMPARE_OP >\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 0\nL1:\n LOAD_FAST k\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n LOAD_FAST k\n LOAD_FAST n\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\nL2:\n RETURN_CONST 1\nL3:\n LOAD_GLOBAL NULL + binomial_Coeff\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n LOAD_FAST k\n LOAD_CONST 1\n BINARY_OP -\n CALL 2\n LOAD_GLOBAL NULL + binomial_Coeff\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n LOAD_FAST k\n CALL 2\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def binomial_Coeff(n, k):\n if k > n:\n return 0\n if k == 0 or k == n:\n return 1\n return binomial_Coeff(n - 1, k - 1) + binomial_Coeff(n - 1, k)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 28, "mbpp_split": "test", "prompt": "Write a python function to find binomial co-efficient.", "test_list": ["assert binomial_Coeff(5,2) == 10", "assert binomial_Coeff(4,3) == 4", "assert binomial_Coeff(3,2) == 3"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_28", "n_instr": 42} {"i": 289, "src_path": "src/00289.py", "pyc_path": "pyc/00289.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_Equality\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_Substring_With_Equal_Ends\n RETURN_CONST None\nEND\nCODE check_Equality(s)\n RESUME 0\n LOAD_GLOBAL NULL + ord\n LOAD_FAST s\n LOAD_CONST 0\n BINARY_SUBSCR\n CALL 1\n LOAD_GLOBAL NULL + ord\n LOAD_FAST s\n LOAD_GLOBAL NULL + len\n LOAD_FAST s\n CALL 1\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n CALL 1\n COMPARE_OP ==\n RETURN_VALUE\nEND\nCODE count_Substring_With_Equal_Ends(s)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST result\n LOAD_GLOBAL NULL + len\n LOAD_FAST s\n CALL 1\n STORE_FAST n\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L5\n STORE_FAST i\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP -\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL2:\n FOR_ITER L4\n STORE_FAST j\n LOAD_GLOBAL NULL + check_Equality\n LOAD_FAST s\n LOAD_FAST i\n LOAD_FAST i\n LOAD_FAST j\n BINARY_OP +\n BINARY_SLICE\n CALL 1\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L2\nL3:\n LOAD_FAST result\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST result\n JUMP_BACKWARD L2\nL4:\n END_FOR\n JUMP_BACKWARD L1\nL5:\n END_FOR\n LOAD_FAST result\n RETURN_VALUE\nEND", "expected": "def check_Equality(s):\n return ord(s[0]) == ord(s[len(s) - 1])\n\ndef count_Substring_With_Equal_Ends(s):\n result = 0\n n = len(s)\n for i in range(n):\n for j in range(1, n - i + 1):\n if check_Equality(s[i:i + j]):\n result += 1\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 30, "mbpp_split": "test", "prompt": "Write a python function to count all the substrings starting and ending with same characters.", "test_list": ["assert count_Substring_With_Equal_Ends(\"abc\") == 3", "assert count_Substring_With_Equal_Ends(\"abcda\") == 6", "assert count_Substring_With_Equal_Ends(\"ab\") == 2"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_30", "n_instr": 79} {"i": 290, "src_path": "src/00290.py", "pyc_path": "pyc/00290.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME func\n RETURN_CONST None\nEND\nCODE func(nums, k)\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME collections\n STORE_FAST collections\n LOAD_FAST collections\n LOAD_ATTR NULL|self + defaultdict\n LOAD_GLOBAL int\n CALL 1\n STORE_FAST d\n LOAD_FAST nums\n GET_ITER\nL1:\n FOR_ITER L4\n STORE_FAST row\n LOAD_FAST row\n GET_ITER\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST d\n LOAD_FAST i\n COPY 2\n COPY 2\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +=\n SWAP 3\n SWAP 2\n STORE_SUBSCR\n JUMP_BACKWARD L2\nL3:\n END_FOR\n JUMP_BACKWARD L1\nL4:\n END_FOR\n BUILD_LIST 0\n STORE_FAST temp\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME heapq\n STORE_FAST heapq\n LOAD_FAST d\n LOAD_ATTR NULL|self + items\n CALL 0\n GET_ITER\nL5:\n FOR_ITER L9\n UNPACK_SEQUENCE 2\n STORE_FAST key\n STORE_FAST v\n LOAD_GLOBAL NULL + len\n LOAD_FAST temp\n CALL 1\n LOAD_FAST k\n COMPARE_OP <\n POP_JUMP_IF_FALSE L7\n LOAD_FAST temp\n LOAD_ATTR NULL|self + append\n LOAD_FAST v\n LOAD_FAST key\n BUILD_TUPLE 2\n CALL 1\n POP_TOP\n LOAD_GLOBAL NULL + len\n LOAD_FAST temp\n CALL 1\n LOAD_FAST k\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L6\n JUMP_BACKWARD L5\nL6:\n LOAD_FAST heapq\n LOAD_ATTR NULL|self + heapify\n LOAD_FAST temp\n CALL 1\n POP_TOP\n JUMP_BACKWARD L5\nL7:\n LOAD_FAST v\n LOAD_FAST temp\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_CONST 0\n BINARY_SUBSCR\n COMPARE_OP >\n POP_JUMP_IF_TRUE L8\n JUMP_BACKWARD L5\nL8:\n LOAD_FAST heapq\n LOAD_ATTR NULL|self + heappop\n LOAD_FAST temp\n CALL 1\n POP_TOP\n LOAD_FAST heapq\n LOAD_ATTR NULL|self + heappush\n LOAD_FAST temp\n LOAD_FAST v\n LOAD_FAST key\n BUILD_TUPLE 2\n CALL 2\n POP_TOP\n JUMP_BACKWARD L5\nL9:\n END_FOR\n BUILD_LIST 0\n STORE_FAST result\n LOAD_FAST temp\n POP_JUMP_IF_FALSE L11\nL10:\n LOAD_FAST heapq\n LOAD_ATTR NULL|self + heappop\n LOAD_FAST temp\n CALL 1\n UNPACK_SEQUENCE 2\n STORE_FAST v\n STORE_FAST key\n LOAD_FAST result\n LOAD_ATTR NULL|self + append\n LOAD_FAST key\n CALL 1\n POP_TOP\n LOAD_FAST temp\n POP_JUMP_IF_FALSE L11\n JUMP_BACKWARD L10\nL11:\n LOAD_FAST result\n RETURN_VALUE\nEND", "expected": "def func(nums, k):\n import collections\n d = collections.defaultdict(int)\n for row in nums:\n for i in row:\n d[i] += 1\n temp = []\n import heapq\n for key, v in d.items():\n if len(temp) < k:\n temp.append((v, key))\n if len(temp) == k:\n heapq.heapify(temp)\n elif v > temp[0][0]:\n heapq.heappop(temp)\n heapq.heappush(temp, (v, key))\n result = []\n while temp:\n v, key = heapq.heappop(temp)\n result.append(key)\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 31, "mbpp_split": "test", "prompt": "Write a function to find the top k integers that occur most frequently from given lists of sorted and distinct integers using heap queue algorithm.", "test_list": ["assert func([[1, 2, 6], [1, 3, 4, 5, 7, 8], [1, 3, 5, 6, 8, 9], [2, 5, 7, 11], [1, 4, 7, 8, 12]],3)==[5, 7, 1]", "assert func([[1, 2, 6], [1, 3, 4, 5, 7, 8], [1, 3, 5, 6, 8, 9], [2, 5, 7, 11], [1, 4, 7, 8, 12]],1)==[1]", "assert func([[1, 2, 6], [1, 3, 4, 5, 7, 8], [1, 3, 5, 6, 8, 9], [2, 5, 7, 11], [1, 4, 7, 8, 12]],5)==[6, 5, 7, 8, 1]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_31", "n_instr": 136} {"i": 291, "src_path": "src/00291.py", "pyc_path": "pyc/00291.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME max_Prime_Factors\n RETURN_CONST None\nEND\nCODE max_Prime_Factors(n)\n RESUME 0\n LOAD_CONST -1\n STORE_FAST maxPrime\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_CONST 2\n STORE_FAST maxPrime\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP >>=\n STORE_FAST n\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_GLOBAL NULL + range\n LOAD_CONST 3\n LOAD_GLOBAL NULL + int\n LOAD_GLOBAL NULL + math\n LOAD_ATTR sqrt\n LOAD_FAST n\n CALL 1\n CALL 1\n LOAD_CONST 1\n BINARY_OP +\n LOAD_CONST 2\n CALL 3\n GET_ITER\nL3:\n FOR_ITER L6\n STORE_FAST i\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L4\n JUMP_BACKWARD L3\nL4:\n LOAD_FAST i\n STORE_FAST maxPrime\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP /\n STORE_FAST n\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L5\n JUMP_BACKWARD L4\nL5:\n JUMP_BACKWARD L3\nL6:\n END_FOR\n LOAD_FAST n\n LOAD_CONST 2\n COMPARE_OP >\n POP_JUMP_IF_FALSE L7\n LOAD_FAST n\n STORE_FAST maxPrime\nL7:\n LOAD_GLOBAL NULL + int\n LOAD_FAST maxPrime\n CALL 1\n RETURN_VALUE\nEND", "expected": "import math\n\ndef max_Prime_Factors(n):\n maxPrime = -1\n while n % 2 == 0:\n maxPrime = 2\n n >>= 1\n for i in range(3, int(math.sqrt(n)) + 1, 2):\n while n % i == 0:\n maxPrime = i\n n = n / i\n if n > 2:\n maxPrime = n\n return int(maxPrime)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 32, "mbpp_split": "test", "prompt": "Write a python function to find the largest prime factor of a given number.", "test_list": ["assert max_Prime_Factors(15) == 5", "assert max_Prime_Factors(6) == 3", "assert max_Prime_Factors(2) == 2"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_32", "n_instr": 88} {"i": 292, "src_path": "src/00292.py", "pyc_path": "pyc/00292.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME decimal_To_Binary\n RETURN_CONST None\nEND\nCODE decimal_To_Binary(N)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST B_Number\n LOAD_CONST 0\n STORE_FAST cnt\n LOAD_FAST N\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_FAST N\n LOAD_CONST 2\n BINARY_OP %\n STORE_FAST rem\n LOAD_GLOBAL NULL + pow\n LOAD_CONST 10\n LOAD_FAST cnt\n CALL 2\n STORE_FAST c\n LOAD_FAST B_Number\n LOAD_FAST rem\n LOAD_FAST c\n BINARY_OP *\n BINARY_OP +=\n STORE_FAST B_Number\n LOAD_FAST N\n LOAD_CONST 2\n BINARY_OP //=\n STORE_FAST N\n LOAD_FAST cnt\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST cnt\n LOAD_FAST N\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST B_Number\n RETURN_VALUE\nEND", "expected": "def decimal_To_Binary(N):\n B_Number = 0\n cnt = 0\n while N != 0:\n rem = N % 2\n c = pow(10, cnt)\n B_Number += rem * c\n N //= 2\n cnt += 1\n return B_Number", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 33, "mbpp_split": "test", "prompt": "Write a python function to convert a decimal number to binary number.", "test_list": ["assert decimal_To_Binary(10) == 1010", "assert decimal_To_Binary(1) == 1", "assert decimal_To_Binary(20) == 10100"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_33", "n_instr": 49} {"i": 293, "src_path": "src/00293.py", "pyc_path": "pyc/00293.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_missing\n RETURN_CONST None\nEND\nCODE find_missing(ar, N)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST l\n LOAD_FAST N\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST r\n LOAD_FAST l\n LOAD_FAST r\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L5\nL1:\n LOAD_FAST l\n LOAD_FAST r\n BINARY_OP +\n LOAD_CONST 2\n BINARY_OP /\n STORE_FAST mid\n LOAD_GLOBAL NULL + int\n LOAD_FAST mid\n CALL 1\n STORE_FAST mid\n LOAD_FAST ar\n LOAD_FAST mid\n BINARY_SUBSCR\n LOAD_FAST mid\n LOAD_CONST 1\n BINARY_OP +\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L2\n LOAD_FAST ar\n LOAD_FAST mid\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n LOAD_FAST mid\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_FAST mid\n LOAD_CONST 1\n BINARY_OP +\n RETURN_VALUE\nL2:\n LOAD_FAST ar\n LOAD_FAST mid\n BINARY_SUBSCR\n LOAD_FAST mid\n LOAD_CONST 1\n BINARY_OP +\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L3\n LOAD_FAST mid\n LOAD_CONST 1\n BINARY_OP -\n STORE_FAST r\n JUMP_FORWARD L4\nL3:\n LOAD_FAST mid\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST l\nL4:\n LOAD_FAST l\n LOAD_FAST r\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L5\n JUMP_BACKWARD L1\nL5:\n RETURN_CONST -1\nEND", "expected": "def find_missing(ar, N):\n l = 0\n r = N - 1\n while l <= r:\n mid = (l + r) / 2\n mid = int(mid)\n if ar[mid] != mid + 1 and ar[mid - 1] == mid:\n return mid + 1\n elif ar[mid] != mid + 1:\n r = mid - 1\n else:\n l = mid + 1\n return -1", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 34, "mbpp_split": "test", "prompt": "Write a python function to find the missing number in a sorted array.", "test_list": ["assert find_missing([1,2,3,5],4) == 4", "assert find_missing([1,3,4,5],4) == 2", "assert find_missing([1,2,3,5,6,7],5) == 4"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_34", "n_instr": 77} {"i": 294, "src_path": "src/00294.py", "pyc_path": "pyc/00294.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_rect_num\n RETURN_CONST None\nEND\nCODE find_rect_num(n)\n RESUME 0\n LOAD_FAST n\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP *\n RETURN_VALUE\nEND", "expected": "def find_rect_num(n):\n return n * (n + 1)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 35, "mbpp_split": "test", "prompt": "Write a function to find the n-th rectangular number.", "test_list": ["assert find_rect_num(4) == 20", "assert find_rect_num(5) == 30", "assert find_rect_num(6) == 42"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_35", "n_instr": 15} {"i": 295, "src_path": "src/00295.py", "pyc_path": "pyc/00295.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sort_mixed_list\n RETURN_CONST None\nEND\nCODE sort_mixed_list(mixed_list)\n RESUME 0\n LOAD_GLOBAL NULL + sorted\n LOAD_FAST mixed_list\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L5\n STORE_FAST i\n LOAD_GLOBAL NULL + type\n LOAD_FAST i\n CALL 1\n LOAD_GLOBAL int\n IS_OP 0\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST i\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL5:\n END_FOR\nL6:\n SWAP 2\n STORE_FAST i\n CALL 1\n STORE_FAST int_part\n LOAD_GLOBAL NULL + sorted\n LOAD_FAST mixed_list\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL7:\n BUILD_LIST 0\n SWAP 2\nL8:\n FOR_ITER L11\n STORE_FAST i\n LOAD_GLOBAL NULL + type\n LOAD_FAST i\n CALL 1\n LOAD_GLOBAL str\n IS_OP 0\n POP_JUMP_IF_TRUE L10\nL9:\n JUMP_BACKWARD L8\nL10:\n LOAD_FAST i\n LIST_APPEND 2\n JUMP_BACKWARD L8\nL11:\n END_FOR\nL12:\n SWAP 2\n STORE_FAST i\n CALL 1\n STORE_FAST str_part\n LOAD_FAST int_part\n LOAD_FAST str_part\n BINARY_OP +\n RETURN_VALUE\nL13:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\nL14:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\n EXC try=L1..L3 -> handler=L13 depth=4 lasti=False\n EXC try=L4..L6 -> handler=L13 depth=4 lasti=False\n EXC try=L7..L9 -> handler=L14 depth=4 lasti=False\n EXC try=L10..L12 -> handler=L14 depth=4 lasti=False\nEND", "expected": "def sort_mixed_list(mixed_list):\n int_part = sorted([i for i in mixed_list if type(i) is int])\n str_part = sorted([i for i in mixed_list if type(i) is str])\n return int_part + str_part", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 37, "mbpp_split": "test", "prompt": "Write a function to sort a given mixed list of integers and strings.", "test_list": ["assert sort_mixed_list([19,'red',12,'green','blue', 10,'white','green',1])==[1, 10, 12, 19, 'blue', 'green', 'green', 'red', 'white']", "assert sort_mixed_list([19,'red',12,'green','blue', 10,'white','green',1])==[1, 10, 12, 19, 'blue', 'green', 'green', 'red', 'white']", "assert sort_mixed_list([19,'red',12,'green','blue', 10,'white','green',1])==[1, 10, 12, 19, 'blue', 'green', 'green', 'red', 'white']"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_37", "n_instr": 89} {"i": 296, "src_path": "src/00296.py", "pyc_path": "pyc/00296.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME div_even_odd\n RETURN_CONST None\nEND\nCODE div_even_odd(list1)\n RESUME 0\n LOAD_GLOBAL NULL + next\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST list1\n GET_ITER\n CALL 0\n LOAD_CONST -1\n CALL 2\n STORE_FAST first_even\n LOAD_GLOBAL NULL + next\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST list1\n GET_ITER\n CALL 0\n LOAD_CONST -1\n CALL 2\n STORE_FAST first_odd\n LOAD_FAST first_even\n LOAD_FAST first_odd\n BINARY_OP /\n RETURN_VALUE\nEND\nCODE div_even_odd..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L5\n STORE_FAST el\n LOAD_FAST el\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST el\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL5:\n END_FOR\n RETURN_CONST None\nL6:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L3 -> handler=L6 depth=0 lasti=True\n EXC try=L4..L6 -> handler=L6 depth=0 lasti=True\nEND\nCODE div_even_odd..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L5\n STORE_FAST el\n LOAD_FAST el\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST el\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL5:\n END_FOR\n RETURN_CONST None\nL6:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L3 -> handler=L6 depth=0 lasti=True\n EXC try=L4..L6 -> handler=L6 depth=0 lasti=True\nEND", "expected": "def div_even_odd(list1):\n first_even = next((el for el in list1 if el % 2 == 0), -1)\n first_odd = next((el for el in list1 if el % 2 != 0), -1)\n return first_even / first_odd", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 38, "mbpp_split": "test", "prompt": "Write a function to find the division of first even and odd number of a given list.", "test_list": ["assert div_even_odd([1,3,5,7,4,1,6,8])==4", "assert div_even_odd([1,2,3,4,5,6,7,8,9,10])==2", "assert div_even_odd([1,5,7,9,10])==10"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_38", "n_instr": 95} {"i": 297, "src_path": "src/00297.py", "pyc_path": "pyc/00297.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME heapq\n STORE_NAME heapq\n LOAD_CONST 0\n LOAD_CONST ('Counter',)\n IMPORT_NAME collections\n IMPORT_FROM Counter\n STORE_NAME Counter\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME rearange_string\n RETURN_CONST None\nEND\nCODE rearange_string(S)\n RESUME 0\n LOAD_GLOBAL NULL + Counter\n LOAD_FAST S\n CALL 1\n STORE_FAST ctr\n LOAD_FAST ctr\n LOAD_ATTR NULL|self + items\n CALL 0\n GET_ITER\n LOAD_FAST_AND_CLEAR key\n LOAD_FAST_AND_CLEAR value\n SWAP 3\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST key\n STORE_FAST value\n LOAD_FAST value\n UNARY_NEGATIVE\n LOAD_FAST key\n BUILD_TUPLE 2\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST heap\n STORE_FAST key\n STORE_FAST value\n LOAD_GLOBAL NULL + heapq\n LOAD_ATTR heapify\n LOAD_FAST heap\n CALL 1\n POP_TOP\n LOAD_FAST heap\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_CONST 0\n BINARY_SUBSCR\n UNARY_NEGATIVE\n LOAD_CONST 2\n BINARY_OP *\n LOAD_GLOBAL NULL + len\n LOAD_FAST S\n CALL 1\n LOAD_CONST 1\n BINARY_OP +\n COMPARE_OP >\n POP_JUMP_IF_FALSE L5\n RETURN_CONST ''\nL5:\n BUILD_LIST 0\n STORE_FAST ans\n LOAD_GLOBAL NULL + len\n LOAD_FAST heap\n CALL 1\n LOAD_CONST 2\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L9\nL6:\n LOAD_GLOBAL NULL + heapq\n LOAD_ATTR heappop\n LOAD_FAST heap\n CALL 1\n UNPACK_SEQUENCE 2\n STORE_FAST nct1\n STORE_FAST char1\n LOAD_GLOBAL NULL + heapq\n LOAD_ATTR heappop\n LOAD_FAST heap\n CALL 1\n UNPACK_SEQUENCE 2\n STORE_FAST nct2\n STORE_FAST char2\n LOAD_FAST ans\n LOAD_ATTR NULL|self + extend\n LOAD_FAST char1\n LOAD_FAST char2\n BUILD_LIST 2\n CALL 1\n POP_TOP\n LOAD_FAST nct1\n LOAD_CONST 1\n BINARY_OP +\n POP_JUMP_IF_FALSE L7\n LOAD_GLOBAL NULL + heapq\n LOAD_ATTR heappush\n LOAD_FAST heap\n LOAD_FAST nct1\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST char1\n BUILD_TUPLE 2\n CALL 2\n POP_TOP\nL7:\n LOAD_FAST nct2\n LOAD_CONST 1\n BINARY_OP +\n POP_JUMP_IF_FALSE L8\n LOAD_GLOBAL NULL + heapq\n LOAD_ATTR heappush\n LOAD_FAST heap\n LOAD_FAST nct2\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST char2\n BUILD_TUPLE 2\n CALL 2\n POP_TOP\nL8:\n LOAD_GLOBAL NULL + len\n LOAD_FAST heap\n CALL 1\n LOAD_CONST 2\n COMPARE_OP >=\n POP_JUMP_IF_FALSE L9\n JUMP_BACKWARD L6\nL9:\n LOAD_CONST ''\n LOAD_ATTR NULL|self + join\n LOAD_FAST ans\n CALL 1\n LOAD_FAST heap\n POP_JUMP_IF_FALSE L10\n LOAD_FAST heap\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_SUBSCR\n BINARY_OP +\n RETURN_VALUE\nL10:\n LOAD_CONST ''\n BINARY_OP +\n RETURN_VALUE\nL11:\n SWAP 2\n POP_TOP\n SWAP 3\n STORE_FAST value\n STORE_FAST key\n RERAISE 0\n EXC try=L1..L4 -> handler=L11 depth=3 lasti=False\nEND", "expected": "import heapq\nfrom collections import Counter\n\ndef rearange_string(S):\n ctr = Counter(S)\n heap = [(-value, key) for key, value in ctr.items()]\n heapq.heapify(heap)\n if -heap[0][0] * 2 > len(S) + 1:\n return ''\n ans = []\n while len(heap) >= 2:\n nct1, char1 = heapq.heappop(heap)\n nct2, char2 = heapq.heappop(heap)\n ans.extend([char1, char2])\n if nct1 + 1:\n heapq.heappush(heap, (nct1 + 1, char1))\n if nct2 + 1:\n heapq.heappush(heap, (nct2 + 1, char2))\n return ''.join(ans) + (heap[0][1] if heap else '')", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 39, "mbpp_split": "test", "prompt": "Write a function to check if the letters of a given string can be rearranged so that two characters that are adjacent to each other are different.", "test_list": ["assert rearange_string(\"aab\")==('aba')", "assert rearange_string(\"aabb\")==('abab')", "assert rearange_string(\"abccdd\")==('cdabcd')"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_39", "n_instr": 165} {"i": 298, "src_path": "src/00298.py", "pyc_path": "pyc/00298.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('Counter',)\n IMPORT_NAME collections\n IMPORT_FROM Counter\n STORE_NAME Counter\n POP_TOP\n LOAD_CONST 0\n LOAD_CONST ('chain',)\n IMPORT_NAME itertools\n IMPORT_FROM chain\n STORE_NAME chain\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME freq_element\n RETURN_CONST None\nEND\nCODE freq_element(nums)\n RESUME 0\n LOAD_GLOBAL NULL + Counter\n LOAD_GLOBAL NULL + chain\n LOAD_ATTR from_iterable\n LOAD_FAST nums\n CALL 1\n CALL 1\n STORE_FAST result\n LOAD_FAST result\n RETURN_VALUE\nEND", "expected": "from collections import Counter\nfrom itertools import chain\n\ndef freq_element(nums):\n result = Counter(chain.from_iterable(nums))\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 40, "mbpp_split": "test", "prompt": "Write a function to find frequency of the elements in a given list of lists using collections module.", "test_list": ["assert freq_element([[1, 2, 3, 2], [4, 5, 6, 2], [7, 1, 9, 5]])==({2: 3, 1: 2, 5: 2, 3: 1, 4: 1, 6: 1, 7: 1, 9: 1})", "assert freq_element([[1,2,3,4],[5,6,7,8],[9,10,11,12]])==({1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1, 12: 1})", "assert freq_element([[15,20,30,40],[80,90,100,110],[30,30,80,90]])==({30: 3, 80: 2, 90: 2, 15: 1, 20: 1, 40: 1, 100: 1, 110: 1})"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_40", "n_instr": 30} {"i": 299, "src_path": "src/00299.py", "pyc_path": "pyc/00299.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME filter_evennumbers\n RETURN_CONST None\nEND\nCODE filter_evennumbers(nums)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + filter\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST nums\n CALL 2\n CALL 1\n STORE_FAST even_nums\n LOAD_FAST even_nums\n RETURN_VALUE\nEND\nCODE filter_evennumbers..(x)\n RESUME 0\n LOAD_FAST x\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n RETURN_VALUE\nEND", "expected": "def filter_evennumbers(nums):\n even_nums = list(filter(lambda x: x % 2 == 0, nums))\n return even_nums", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 41, "mbpp_split": "test", "prompt": "Write a function to filter even numbers using lambda function.", "test_list": ["assert filter_evennumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[2, 4, 6, 8, 10]", "assert filter_evennumbers([10,20,45,67,84,93])==[10,20,84]", "assert filter_evennumbers([5,7,9,8,6,4,3])==[8,6,4]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_41", "n_instr": 28} {"i": 300, "src_path": "src/00300.py", "pyc_path": "pyc/00300.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_Sum\n RETURN_CONST None\nEND\nCODE find_Sum(arr, n)\n RESUME 0\n LOAD_GLOBAL NULL + sum\n LOAD_FAST arr\n GET_ITER\n LOAD_FAST_AND_CLEAR x\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L5\n STORE_FAST x\n LOAD_FAST arr\n LOAD_ATTR NULL|self + count\n LOAD_FAST x\n CALL 1\n LOAD_CONST 1\n COMPARE_OP >\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST x\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL5:\n END_FOR\nL6:\n SWAP 2\n STORE_FAST x\n CALL 1\n RETURN_VALUE\nL7:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST x\n RERAISE 0\n EXC try=L1..L3 -> handler=L7 depth=4 lasti=False\n EXC try=L4..L6 -> handler=L7 depth=4 lasti=False\nEND", "expected": "def find_Sum(arr, n):\n return sum([x for x in arr if arr.count(x) > 1])", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 42, "mbpp_split": "test", "prompt": "Write a python function to find the sum of repeated elements in a given array.", "test_list": ["assert find_Sum([1,2,3,1,1,4,5,6],8) == 3", "assert find_Sum([1,2,3,1,1],5) == 3", "assert find_Sum([1,1,2],3) == 2"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_42", "n_instr": 48} {"i": 301, "src_path": "src/00301.py", "pyc_path": "pyc/00301.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_NAME re\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME text_match_string\n RETURN_CONST None\nEND\nCODE text_match_string(text)\n RESUME 0\n LOAD_CONST '^\\\\w+'\n STORE_FAST patterns\n LOAD_GLOBAL NULL + re\n LOAD_ATTR search\n LOAD_FAST patterns\n LOAD_FAST text\n CALL 2\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Found a match!'\nL1:\n RETURN_CONST 'Not matched!'\nEND", "expected": "import re\n\ndef text_match_string(text):\n patterns = '^\\\\w+'\n if re.search(patterns, text):\n return 'Found a match!'\n else:\n return 'Not matched!'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 44, "mbpp_split": "test", "prompt": "Write a function that matches a word at the beginning of a string.", "test_list": ["assert text_match_string(\" python\")==('Not matched!')", "assert text_match_string(\"python\")==('Found a match!')", "assert text_match_string(\" lang\")==('Not matched!')"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_44", "n_instr": 24} {"i": 302, "src_path": "src/00302.py", "pyc_path": "pyc/00302.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_gcd\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_gcd\n RETURN_CONST None\nEND\nCODE find_gcd(x, y)\n RESUME 0\n LOAD_FAST y\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_FAST y\n LOAD_FAST x\n LOAD_FAST y\n BINARY_OP %\n STORE_FAST y\n STORE_FAST x\n LOAD_FAST y\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST x\n RETURN_VALUE\nEND\nCODE get_gcd(l)\n RESUME 0\n LOAD_FAST l\n LOAD_CONST 0\n BINARY_SUBSCR\n STORE_FAST num1\n LOAD_FAST l\n LOAD_CONST 1\n BINARY_SUBSCR\n STORE_FAST num2\n LOAD_GLOBAL NULL + find_gcd\n LOAD_FAST num1\n LOAD_FAST num2\n CALL 2\n STORE_FAST gcd\n LOAD_GLOBAL NULL + range\n LOAD_CONST 2\n LOAD_GLOBAL NULL + len\n LOAD_FAST l\n CALL 1\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_GLOBAL NULL + find_gcd\n LOAD_FAST gcd\n LOAD_FAST l\n LOAD_FAST i\n BINARY_SUBSCR\n CALL 2\n STORE_FAST gcd\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST gcd\n RETURN_VALUE\nEND", "expected": "def find_gcd(x, y):\n while y:\n x, y = (y, x % y)\n return x\n\ndef get_gcd(l):\n num1 = l[0]\n num2 = l[1]\n gcd = find_gcd(num1, num2)\n for i in range(2, len(l)):\n gcd = find_gcd(gcd, l[i])\n return gcd", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 45, "mbpp_split": "test", "prompt": "Write a function to find the gcd of the given array elements.", "test_list": ["assert get_gcd([2, 4, 6, 8, 16]) == 2", "assert get_gcd([1, 2, 3]) == 1", "assert get_gcd([2, 4, 6, 8]) == 2 "], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_45", "n_instr": 65} {"i": 303, "src_path": "src/00303.py", "pyc_path": "pyc/00303.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME test_distinct\n RETURN_CONST None\nEND\nCODE test_distinct(data)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST data\n CALL 1\n LOAD_GLOBAL NULL + len\n LOAD_GLOBAL NULL + set\n LOAD_FAST data\n CALL 1\n CALL 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST True\nL1:\n RETURN_CONST False\nEND", "expected": "def test_distinct(data):\n if len(data) == len(set(data)):\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 46, "mbpp_split": "test", "prompt": "Write a python function to determine whether all the numbers are different from each other are not.", "test_list": ["assert test_distinct([1,5,7,9]) == True", "assert test_distinct([2,4,5,5,7,9]) == False", "assert test_distinct([1,2,3]) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_46", "n_instr": 22} {"i": 304, "src_path": "src/00304.py", "pyc_path": "pyc/00304.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME odd_bit_set_number\n RETURN_CONST None\nEND\nCODE odd_bit_set_number(n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST count\n LOAD_CONST 0\n STORE_FAST res\n LOAD_FAST n\n STORE_FAST temp\n LOAD_FAST temp\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_FALSE L3\nL1:\n LOAD_FAST count\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_FAST res\n LOAD_CONST 1\n LOAD_FAST count\n BINARY_OP <<\n BINARY_OP |=\n STORE_FAST res\nL2:\n LOAD_FAST count\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST count\n LOAD_FAST temp\n LOAD_CONST 1\n BINARY_OP >>=\n STORE_FAST temp\n LOAD_FAST temp\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_FALSE L3\n JUMP_BACKWARD L1\nL3:\n LOAD_FAST n\n LOAD_FAST res\n BINARY_OP |\n RETURN_VALUE\nEND", "expected": "def odd_bit_set_number(n):\n count = 0\n res = 0\n temp = n\n while temp > 0:\n if count % 2 == 0:\n res |= 1 << count\n count += 1\n temp >>= 1\n return n | res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 48, "mbpp_split": "test", "prompt": "Write a python function to set all odd bits of a given number.", "test_list": ["assert odd_bit_set_number(10) == 15", "assert odd_bit_set_number(20) == 21", "assert odd_bit_set_number(30) == 31"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_48", "n_instr": 51} {"i": 305, "src_path": "src/00305.py", "pyc_path": "pyc/00305.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME min_length_list\n RETURN_CONST None\nEND\nCODE min_length_list(input_list)\n RESUME 0\n LOAD_GLOBAL NULL + min\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST input_list\n GET_ITER\n CALL 0\n CALL 1\n STORE_FAST min_length\n LOAD_GLOBAL NULL + min\n LOAD_FAST input_list\n LOAD_CONST .>\n MAKE_FUNCTION 0\n KW_NAMES ('key',)\n CALL 2\n STORE_FAST min_list\n LOAD_FAST min_length\n LOAD_FAST min_list\n BUILD_TUPLE 2\n RETURN_VALUE\nEND\nCODE min_length_list..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n STORE_FAST x\n LOAD_GLOBAL NULL + len\n LOAD_FAST x\n CALL 1\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND\nCODE min_length_list..(i)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST i\n CALL 1\n RETURN_VALUE\nEND", "expected": "def min_length_list(input_list):\n min_length = min((len(x) for x in input_list))\n min_list = min(input_list, key=lambda i: len(i))\n return (min_length, min_list)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 50, "mbpp_split": "test", "prompt": "Write a function to find the list with minimum length using lambda function.", "test_list": ["assert min_length_list([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==(1, [0])", "assert min_length_list([[1,2,3,4,5],[1,2,3,4],[1,2,3],[1,2],[1]])==(1,[1])", "assert min_length_list([[3,4,5],[6,7,8,9],[10,11,12],[1,2]])==(2,[1,2])"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_50", "n_instr": 59} {"i": 306, "src_path": "src/00306.py", "pyc_path": "pyc/00306.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_equilateral\n RETURN_CONST None\nEND\nCODE check_equilateral(x, y, z)\n RESUME 0\n LOAD_FAST x\n LOAD_FAST y\n SWAP 2\n COPY 2\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n LOAD_FAST z\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n RETURN_CONST True\nL1:\n POP_TOP\n RETURN_CONST False\nL2:\n RETURN_CONST False\nEND", "expected": "def check_equilateral(x, y, z):\n if x == y == z:\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 51, "mbpp_split": "test", "prompt": "Write a function to print check if the triangle is equilateral or not.", "test_list": ["assert check_equilateral(6,8,12)==False ", "assert check_equilateral(6,6,12)==False", "assert check_equilateral(6,6,6)==True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_51", "n_instr": 24} {"i": 307, "src_path": "src/00307.py", "pyc_path": "pyc/00307.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_Equality\n RETURN_CONST None\nEND\nCODE check_Equality(str)\n RESUME 0\n LOAD_FAST str\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST str\n LOAD_CONST -1\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'Equal'\nL1:\n RETURN_CONST 'Not Equal'\nEND", "expected": "def check_Equality(str):\n if str[0] == str[-1]:\n return 'Equal'\n else:\n return 'Not Equal'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 53, "mbpp_split": "test", "prompt": "Write a python function to check whether the first and last characters of a given string are equal or not.", "test_list": ["assert check_Equality(\"abcda\") == \"Equal\"", "assert check_Equality(\"ab\") == \"Not Equal\"", "assert check_Equality(\"mad\") == \"Not Equal\""], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_53", "n_instr": 20} {"i": 308, "src_path": "src/00308.py", "pyc_path": "pyc/00308.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME counting_sort\n RETURN_CONST None\nEND\nCODE counting_sort(my_list)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST max_value\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST my_list\n CALL 1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST my_list\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST max_value\n COMPARE_OP >\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST my_list\n LOAD_FAST i\n BINARY_SUBSCR\n STORE_FAST max_value\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_CONST 0\n BUILD_LIST 1\n LOAD_FAST max_value\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP *\n STORE_FAST buckets\n LOAD_FAST my_list\n GET_ITER\nL4:\n FOR_ITER L5\n STORE_FAST i\n LOAD_FAST buckets\n LOAD_FAST i\n COPY 2\n COPY 2\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +=\n SWAP 3\n SWAP 2\n STORE_SUBSCR\n JUMP_BACKWARD L4\nL5:\n END_FOR\n LOAD_CONST 0\n STORE_FAST i\n LOAD_GLOBAL NULL + range\n LOAD_FAST max_value\n LOAD_CONST 1\n BINARY_OP +\n CALL 1\n GET_ITER\nL6:\n FOR_ITER L9\n STORE_FAST j\n LOAD_GLOBAL NULL + range\n LOAD_FAST buckets\n LOAD_FAST j\n BINARY_SUBSCR\n CALL 1\n GET_ITER\nL7:\n FOR_ITER L8\n STORE_FAST a\n LOAD_FAST j\n LOAD_FAST my_list\n LOAD_FAST i\n STORE_SUBSCR\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST i\n JUMP_BACKWARD L7\nL8:\n END_FOR\n JUMP_BACKWARD L6\nL9:\n END_FOR\n LOAD_FAST my_list\n RETURN_VALUE\nEND", "expected": "def counting_sort(my_list):\n max_value = 0\n for i in range(len(my_list)):\n if my_list[i] > max_value:\n max_value = my_list[i]\n buckets = [0] * (max_value + 1)\n for i in my_list:\n buckets[i] += 1\n i = 0\n for j in range(max_value + 1):\n for a in range(buckets[j]):\n my_list[i] = j\n i += 1\n return my_list", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 54, "mbpp_split": "test", "prompt": "Write a function to sort the given array by using counting sort.", "test_list": ["assert counting_sort([1,23,4,5,6,7,8]) == [1, 4, 5, 6, 7, 8, 23]", "assert counting_sort([12, 9, 28, 33, 69, 45]) == [9, 12, 28, 33, 45, 69]", "assert counting_sort([8, 4, 14, 3, 2, 1]) == [1, 2, 3, 4, 8, 14]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_54", "n_instr": 96} {"i": 309, "src_path": "src/00309.py", "pyc_path": "pyc/00309.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME rev\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check\n RETURN_CONST None\nEND\nCODE rev(num)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST rev_num\n LOAD_FAST num\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_FAST rev_num\n LOAD_CONST 10\n BINARY_OP *\n LOAD_FAST num\n LOAD_CONST 10\n BINARY_OP %\n BINARY_OP +\n STORE_FAST rev_num\n LOAD_FAST num\n LOAD_CONST 10\n BINARY_OP //\n STORE_FAST num\n LOAD_FAST num\n LOAD_CONST 0\n COMPARE_OP >\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST rev_num\n RETURN_VALUE\nEND\nCODE check(n)\n RESUME 0\n LOAD_CONST 2\n LOAD_GLOBAL NULL + rev\n LOAD_FAST n\n CALL 1\n BINARY_OP *\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n COMPARE_OP ==\n RETURN_VALUE\nEND", "expected": "def rev(num):\n rev_num = 0\n while num > 0:\n rev_num = rev_num * 10 + num % 10\n num = num // 10\n return rev_num\n\ndef check(n):\n return 2 * rev(n) == n + 1", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 56, "mbpp_split": "test", "prompt": "Write a python function to check if a given number is one less than twice its reverse.", "test_list": ["assert check(70) == False", "assert check(23) == False", "assert check(73) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_56", "n_instr": 52} {"i": 310, "src_path": "src/00310.py", "pyc_path": "pyc/00310.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_octagonal\n RETURN_CONST None\nEND\nCODE is_octagonal(n)\n RESUME 0\n LOAD_CONST 3\n LOAD_FAST n\n BINARY_OP *\n LOAD_FAST n\n BINARY_OP *\n LOAD_CONST 2\n LOAD_FAST n\n BINARY_OP *\n BINARY_OP -\n RETURN_VALUE\nEND", "expected": "def is_octagonal(n):\n return 3 * n * n - 2 * n", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 59, "mbpp_split": "test", "prompt": "Write a function to find the nth octagonal number.", "test_list": ["assert is_octagonal(5) == 65", "assert is_octagonal(10) == 280", "assert is_octagonal(15) == 645"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_59", "n_instr": 19} {"i": 311, "src_path": "src/00311.py", "pyc_path": "pyc/00311.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME max_len_sub\n RETURN_CONST None\nEND\nCODE max_len_sub(arr, n)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST mls\n LOAD_CONST 0\n STORE_FAST max\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST mls\n LOAD_ATTR NULL|self + append\n LOAD_CONST 1\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL3:\n FOR_ITER L8\n STORE_FAST i\n LOAD_GLOBAL NULL + range\n LOAD_FAST i\n CALL 1\n GET_ITER\nL4:\n FOR_ITER L7\n STORE_FAST j\n LOAD_GLOBAL NULL + abs\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST j\n BINARY_SUBSCR\n BINARY_OP -\n CALL 1\n LOAD_CONST 1\n COMPARE_OP <=\n POP_JUMP_IF_TRUE L5\n JUMP_BACKWARD L4\nL5:\n LOAD_FAST mls\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST mls\n LOAD_FAST j\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +\n COMPARE_OP <\n POP_JUMP_IF_TRUE L6\n JUMP_BACKWARD L4\nL6:\n LOAD_FAST mls\n LOAD_FAST j\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +\n LOAD_FAST mls\n LOAD_FAST i\n STORE_SUBSCR\n JUMP_BACKWARD L4\nL7:\n END_FOR\n JUMP_BACKWARD L3\nL8:\n END_FOR\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL9:\n FOR_ITER L11\n STORE_FAST i\n LOAD_FAST max\n LOAD_FAST mls\n LOAD_FAST i\n BINARY_SUBSCR\n COMPARE_OP <\n POP_JUMP_IF_TRUE L10\n JUMP_BACKWARD L9\nL10:\n LOAD_FAST mls\n LOAD_FAST i\n BINARY_SUBSCR\n STORE_FAST max\n JUMP_BACKWARD L9\nL11:\n END_FOR\n LOAD_FAST max\n RETURN_VALUE\nEND", "expected": "def max_len_sub(arr, n):\n mls = []\n max = 0\n for i in range(n):\n mls.append(1)\n for i in range(n):\n for j in range(i):\n if abs(arr[i] - arr[j]) <= 1 and mls[i] < mls[j] + 1:\n mls[i] = mls[j] + 1\n for i in range(n):\n if max < mls[i]:\n max = mls[i]\n return max", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 60, "mbpp_split": "test", "prompt": "Write a function to find the maximum length of the subsequence with difference between adjacent elements for the given array.", "test_list": ["assert max_len_sub([2, 5, 6, 3, 7, 6, 5, 8], 8) == 5", "assert max_len_sub([-2, -1, 5, -1, 4, 0, 3], 7) == 4", "assert max_len_sub([9, 11, 13, 15, 18], 5) == 1"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_60", "n_instr": 106} {"i": 312, "src_path": "src/00312.py", "pyc_path": "pyc/00312.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('defaultdict',)\n IMPORT_NAME collections\n IMPORT_FROM defaultdict\n STORE_NAME defaultdict\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_Substrings\n RETURN_CONST None\nEND\nCODE count_Substrings(s, n)\n RESUME 0\n LOAD_CONST (0, 0)\n UNPACK_SEQUENCE 2\n STORE_FAST count\n STORE_FAST sum\n LOAD_GLOBAL NULL + defaultdict\n LOAD_CONST .>\n MAKE_FUNCTION 0\n CALL 1\n STORE_FAST mp\n LOAD_FAST mp\n LOAD_CONST 0\n COPY 2\n COPY 2\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +=\n SWAP 3\n SWAP 2\n STORE_SUBSCR\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST sum\n LOAD_GLOBAL NULL + ord\n LOAD_FAST s\n LOAD_FAST i\n BINARY_SUBSCR\n CALL 1\n LOAD_GLOBAL NULL + ord\n LOAD_CONST '0'\n CALL 1\n BINARY_OP -\n BINARY_OP +=\n STORE_FAST sum\n LOAD_FAST count\n LOAD_FAST mp\n LOAD_FAST sum\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP -\n BINARY_SUBSCR\n BINARY_OP +=\n STORE_FAST count\n LOAD_FAST mp\n LOAD_FAST sum\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP -\n COPY 2\n COPY 2\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +=\n SWAP 3\n SWAP 2\n STORE_SUBSCR\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST count\n RETURN_VALUE\nEND\nCODE count_Substrings..()\n RESUME 0\n RETURN_CONST 0\nEND", "expected": "from collections import defaultdict\n\ndef count_Substrings(s, n):\n count, sum = (0, 0)\n mp = defaultdict(lambda: 0)\n mp[0] += 1\n for i in range(n):\n sum += ord(s[i]) - ord('0')\n count += mp[sum - (i + 1)]\n mp[sum - (i + 1)] += 1\n return count", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 61, "mbpp_split": "test", "prompt": "Write a python function to count number of substrings with the sum of digits equal to their length.", "test_list": ["assert count_Substrings('112112',6) == 6", "assert count_Substrings('111',3) == 6", "assert count_Substrings('1101112',7) == 12"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_61", "n_instr": 86} {"i": 313, "src_path": "src/00313.py", "pyc_path": "pyc/00313.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME recursive_list_sum\n RETURN_CONST None\nEND\nCODE recursive_list_sum(data_list)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST total\n LOAD_FAST data_list\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST element\n LOAD_GLOBAL NULL + type\n LOAD_FAST element\n CALL 1\n LOAD_GLOBAL NULL + type\n BUILD_LIST 0\n CALL 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_FAST total\n LOAD_GLOBAL NULL + recursive_list_sum\n LOAD_FAST element\n CALL 1\n BINARY_OP +\n STORE_FAST total\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST total\n LOAD_FAST element\n BINARY_OP +\n STORE_FAST total\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST total\n RETURN_VALUE\nEND", "expected": "def recursive_list_sum(data_list):\n total = 0\n for element in data_list:\n if type(element) == type([]):\n total = total + recursive_list_sum(element)\n else:\n total = total + element\n return total", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 65, "mbpp_split": "test", "prompt": "Write a function of recursion list sum.", "test_list": ["assert recursive_list_sum(([1, 2, [3,4],[5,6]]))==21", "assert recursive_list_sum(([7, 10, [15,14],[19,41]]))==106", "assert recursive_list_sum(([10, 20, [30,40],[50,60]]))==210"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_65", "n_instr": 41} {"i": 314, "src_path": "src/00314.py", "pyc_path": "pyc/00314.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME pos_count\n RETURN_CONST None\nEND\nCODE pos_count(list)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST pos_count\n LOAD_FAST list\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST num\n LOAD_FAST num\n LOAD_CONST 0\n COMPARE_OP >=\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST pos_count\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST pos_count\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST pos_count\n RETURN_VALUE\nEND", "expected": "def pos_count(list):\n pos_count = 0\n for num in list:\n if num >= 0:\n pos_count += 1\n return pos_count", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 66, "mbpp_split": "test", "prompt": "Write a python function to count positive numbers in a list.", "test_list": ["assert pos_count([1,-2,3,-4]) == 2", "assert pos_count([3,4,5,-1]) == 3", "assert pos_count([1,2,3,4]) == 4"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_66", "n_instr": 31} {"i": 315, "src_path": "src/00315.py", "pyc_path": "pyc/00315.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_Monotonic\n RETURN_CONST None\nEND\nCODE is_Monotonic(A)\n MAKE_CELL A\n RESUME 0\n LOAD_GLOBAL NULL + all\n LOAD_CLOSURE A\n BUILD_TUPLE 1\n LOAD_CONST .>\n MAKE_FUNCTION closure\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_DEREF A\n CALL 1\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n GET_ITER\n CALL 0\n CALL 1\n COPY 1\n POP_JUMP_IF_TRUE L1\n POP_TOP\n LOAD_GLOBAL NULL + all\n LOAD_CLOSURE A\n BUILD_TUPLE 1\n LOAD_CONST .>\n MAKE_FUNCTION closure\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_DEREF A\n CALL 1\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n GET_ITER\n CALL 0\n CALL 1\nL1:\n RETURN_VALUE\nEND\nCODE is_Monotonic..(.0)\n COPY_FREE_VARS 1\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_DEREF A\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_DEREF A\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n BINARY_SUBSCR\n COMPARE_OP <=\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND\nCODE is_Monotonic..(.0)\n COPY_FREE_VARS 1\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_DEREF A\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_DEREF A\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n BINARY_SUBSCR\n COMPARE_OP >=\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def is_Monotonic(A):\n return all((A[i] <= A[i + 1] for i in range(len(A) - 1))) or all((A[i] >= A[i + 1] for i in range(len(A) - 1)))", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 68, "mbpp_split": "test", "prompt": "Write a python function to check whether the given array is monotonic or not.", "test_list": ["assert is_Monotonic([6, 5, 4, 4]) == True", "assert is_Monotonic([1, 2, 2, 3]) == True", "assert is_Monotonic([1, 3, 2]) == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_68", "n_instr": 107} {"i": 316, "src_path": "src/00316.py", "pyc_path": "pyc/00316.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_sublist\n RETURN_CONST None\nEND\nCODE is_sublist(l, s)\n RESUME 0\n LOAD_CONST False\n STORE_FAST sub_set\n LOAD_FAST s\n BUILD_LIST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n LOAD_CONST True\n STORE_FAST sub_set\n LOAD_FAST sub_set\n RETURN_VALUE\nL1:\n LOAD_FAST s\n LOAD_FAST l\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_CONST True\n STORE_FAST sub_set\n LOAD_FAST sub_set\n RETURN_VALUE\nL2:\n LOAD_GLOBAL NULL + len\n LOAD_FAST s\n CALL 1\n LOAD_GLOBAL NULL + len\n LOAD_FAST l\n CALL 1\n COMPARE_OP >\n POP_JUMP_IF_FALSE L3\n LOAD_CONST False\n STORE_FAST sub_set\n LOAD_FAST sub_set\n RETURN_VALUE\nL3:\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST l\n CALL 1\n CALL 1\n GET_ITER\nL4:\n FOR_ITER L9\n STORE_FAST i\n LOAD_FAST l\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST s\n LOAD_CONST 0\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L5\n JUMP_BACKWARD L4\nL5:\n LOAD_CONST 1\n STORE_FAST n\n LOAD_FAST n\n LOAD_GLOBAL NULL + len\n LOAD_FAST s\n CALL 1\n COMPARE_OP <\n POP_JUMP_IF_FALSE L7\n LOAD_FAST l\n LOAD_FAST i\n LOAD_FAST n\n BINARY_OP +\n BINARY_SUBSCR\n LOAD_FAST s\n LOAD_FAST n\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L7\nL6:\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST n\n LOAD_FAST n\n LOAD_GLOBAL NULL + len\n LOAD_FAST s\n CALL 1\n COMPARE_OP <\n POP_JUMP_IF_FALSE L7\n LOAD_FAST l\n LOAD_FAST i\n LOAD_FAST n\n BINARY_OP +\n BINARY_SUBSCR\n LOAD_FAST s\n LOAD_FAST n\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L7\n JUMP_BACKWARD L6\nL7:\n LOAD_FAST n\n LOAD_GLOBAL NULL + len\n LOAD_FAST s\n CALL 1\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L8\n JUMP_BACKWARD L4\nL8:\n LOAD_CONST True\n STORE_FAST sub_set\n JUMP_BACKWARD L4\nL9:\n END_FOR\n LOAD_FAST sub_set\n RETURN_VALUE\nEND", "expected": "def is_sublist(l, s):\n sub_set = False\n if s == []:\n sub_set = True\n elif s == l:\n sub_set = True\n elif len(s) > len(l):\n sub_set = False\n else:\n for i in range(len(l)):\n if l[i] == s[0]:\n n = 1\n while n < len(s) and l[i + n] == s[n]:\n n += 1\n if n == len(s):\n sub_set = True\n return sub_set", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 69, "mbpp_split": "test", "prompt": "Write a function to check whether a list contains the given sublist or not.", "test_list": ["assert is_sublist([2,4,3,5,7],[3,7])==False", "assert is_sublist([2,4,3,5,7],[4,3])==True", "assert is_sublist([2,4,3,5,7],[1,6])==False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_69", "n_instr": 117} {"i": 317, "src_path": "src/00317.py", "pyc_path": "pyc/00317.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_equal_tuple\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_equal\n RETURN_CONST None\nEND\nCODE find_equal_tuple(Input, k)\n RESUME 0\n LOAD_CONST 1\n STORE_FAST flag\n LOAD_FAST Input\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST tuple\n LOAD_GLOBAL NULL + len\n LOAD_FAST tuple\n CALL 1\n LOAD_FAST k\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_CONST 0\n STORE_FAST flag\n POP_TOP\n LOAD_FAST flag\n RETURN_VALUE\nL3:\n END_FOR\n LOAD_FAST flag\n RETURN_VALUE\nEND\nCODE get_equal(Input, k)\n RESUME 0\n LOAD_GLOBAL NULL + find_equal_tuple\n LOAD_FAST Input\n LOAD_FAST k\n CALL 2\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 'All tuples have same length'\nL1:\n RETURN_CONST 'All tuples do not have same length'\nEND", "expected": "def find_equal_tuple(Input, k):\n flag = 1\n for tuple in Input:\n if len(tuple) != k:\n flag = 0\n break\n return flag\n\ndef get_equal(Input, k):\n if find_equal_tuple(Input, k) == 1:\n return 'All tuples have same length'\n else:\n return 'All tuples do not have same length'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 70, "mbpp_split": "test", "prompt": "Write a function to find whether all the given tuples have equal length or not.", "test_list": ["assert get_equal([(11, 22, 33), (44, 55, 66)], 3) == 'All tuples have same length'", "assert get_equal([(1, 2, 3), (4, 5, 6, 7)], 3) == 'All tuples do not have same length'", "assert get_equal([(1, 2), (3, 4)], 2) == 'All tuples have same length'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_70", "n_instr": 49} {"i": 318, "src_path": "src/00318.py", "pyc_path": "pyc/00318.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME comb_sort\n RETURN_CONST None\nEND\nCODE comb_sort(nums)\n RESUME 0\n LOAD_CONST 1.3\n STORE_FAST shrink_fact\n LOAD_GLOBAL NULL + len\n LOAD_FAST nums\n CALL 1\n STORE_FAST gaps\n LOAD_CONST True\n STORE_FAST swapped\n LOAD_CONST 0\n STORE_FAST i\n LOAD_FAST gaps\n LOAD_CONST 1\n COMPARE_OP >\n POP_JUMP_IF_TRUE L1\n LOAD_FAST swapped\n POP_JUMP_IF_FALSE L6\nL1:\n LOAD_GLOBAL NULL + int\n LOAD_GLOBAL NULL + float\n LOAD_FAST gaps\n CALL 1\n LOAD_FAST shrink_fact\n BINARY_OP /\n CALL 1\n STORE_FAST gaps\n LOAD_CONST False\n STORE_FAST swapped\n LOAD_CONST 0\n STORE_FAST i\n LOAD_FAST gaps\n LOAD_FAST i\n BINARY_OP +\n LOAD_GLOBAL NULL + len\n LOAD_FAST nums\n CALL 1\n COMPARE_OP <\n POP_JUMP_IF_FALSE L4\nL2:\n LOAD_FAST nums\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST nums\n LOAD_FAST i\n LOAD_FAST gaps\n BINARY_OP +\n BINARY_SUBSCR\n COMPARE_OP >\n POP_JUMP_IF_FALSE L3\n LOAD_FAST nums\n LOAD_FAST i\n LOAD_FAST gaps\n BINARY_OP +\n BINARY_SUBSCR\n LOAD_FAST nums\n LOAD_FAST i\n BINARY_SUBSCR\n SWAP 2\n LOAD_FAST nums\n LOAD_FAST i\n STORE_SUBSCR\n LOAD_FAST nums\n LOAD_FAST i\n LOAD_FAST gaps\n BINARY_OP +\n STORE_SUBSCR\n LOAD_CONST True\n STORE_FAST swapped\nL3:\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST i\n LOAD_FAST gaps\n LOAD_FAST i\n BINARY_OP +\n LOAD_GLOBAL NULL + len\n LOAD_FAST nums\n CALL 1\n COMPARE_OP <\n POP_JUMP_IF_FALSE L4\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST gaps\n LOAD_CONST 1\n COMPARE_OP >\n POP_JUMP_IF_FALSE L5\n JUMP_BACKWARD L1\nL5:\n LOAD_FAST swapped\n POP_JUMP_IF_FALSE L6\n JUMP_BACKWARD L1\nL6:\n LOAD_FAST nums\n RETURN_VALUE\nEND", "expected": "def comb_sort(nums):\n shrink_fact = 1.3\n gaps = len(nums)\n swapped = True\n i = 0\n while gaps > 1 or swapped:\n gaps = int(float(gaps) / shrink_fact)\n swapped = False\n i = 0\n while gaps + i < len(nums):\n if nums[i] > nums[i + gaps]:\n nums[i], nums[i + gaps] = (nums[i + gaps], nums[i])\n swapped = True\n i += 1\n return nums", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 71, "mbpp_split": "test", "prompt": "Write a function to sort a list of elements using comb sort.", "test_list": ["assert comb_sort([5, 15, 37, 25, 79]) == [5, 15, 25, 37, 79]", "assert comb_sort([41, 32, 15, 19, 22]) == [15, 19, 22, 32, 41]", "assert comb_sort([99, 15, 13, 47]) == [13, 15, 47, 99]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_71", "n_instr": 103} {"i": 319, "src_path": "src/00319.py", "pyc_path": "pyc/00319.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME dif_Square\n RETURN_CONST None\nEND\nCODE dif_Square(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 4\n BINARY_OP %\n LOAD_CONST 2\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L1\n RETURN_CONST True\nL1:\n RETURN_CONST False\nEND", "expected": "def dif_Square(n):\n if n % 4 != 2:\n return True\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 72, "mbpp_split": "test", "prompt": "Write a python function to check whether the given number can be represented as difference of two squares or not.", "test_list": ["assert dif_Square(5) == True", "assert dif_Square(10) == False", "assert dif_Square(15) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_72", "n_instr": 18} {"i": 320, "src_path": "src/00320.py", "pyc_path": "pyc/00320.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_samepatterns\n RETURN_CONST None\nEND\nCODE is_samepatterns(colors, patterns)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST colors\n CALL 1\n LOAD_GLOBAL NULL + len\n LOAD_FAST patterns\n CALL 1\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L1\n RETURN_CONST False\nL1:\n BUILD_MAP 0\n STORE_FAST sdict\n LOAD_GLOBAL NULL + set\n CALL 0\n STORE_FAST pset\n LOAD_GLOBAL NULL + set\n CALL 0\n STORE_FAST sset\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST patterns\n CALL 1\n CALL 1\n GET_ITER\nL2:\n FOR_ITER L4\n STORE_FAST i\n LOAD_FAST pset\n LOAD_ATTR NULL|self + add\n LOAD_FAST patterns\n LOAD_FAST i\n BINARY_SUBSCR\n CALL 1\n POP_TOP\n LOAD_FAST sset\n LOAD_ATTR NULL|self + add\n LOAD_FAST colors\n LOAD_FAST i\n BINARY_SUBSCR\n CALL 1\n POP_TOP\n LOAD_FAST patterns\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST sdict\n LOAD_ATTR NULL|self + keys\n CALL 0\n CONTAINS_OP 1\n POP_JUMP_IF_FALSE L3\n BUILD_LIST 0\n LOAD_FAST sdict\n LOAD_FAST patterns\n LOAD_FAST i\n BINARY_SUBSCR\n STORE_SUBSCR\nL3:\n LOAD_FAST sdict\n LOAD_FAST patterns\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_SUBSCR\n STORE_FAST keys\n LOAD_FAST keys\n LOAD_ATTR NULL|self + append\n LOAD_FAST colors\n LOAD_FAST i\n BINARY_SUBSCR\n CALL 1\n POP_TOP\n LOAD_FAST keys\n LOAD_FAST sdict\n LOAD_FAST patterns\n LOAD_FAST i\n BINARY_SUBSCR\n STORE_SUBSCR\n JUMP_BACKWARD L2\nL4:\n END_FOR\n LOAD_GLOBAL NULL + len\n LOAD_FAST pset\n CALL 1\n LOAD_GLOBAL NULL + len\n LOAD_FAST sset\n CALL 1\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L5\n RETURN_CONST False\nL5:\n LOAD_FAST sdict\n LOAD_ATTR NULL|self + values\n CALL 0\n GET_ITER\nL6:\n FOR_ITER L10\n STORE_FAST values\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST values\n CALL 1\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n GET_ITER\nL7:\n FOR_ITER L9\n STORE_FAST i\n LOAD_FAST values\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST values\n LOAD_FAST i\n LOAD_CONST 1\n BINARY_OP +\n BINARY_SUBSCR\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L8\n JUMP_BACKWARD L7\nL8:\n POP_TOP\n POP_TOP\n RETURN_CONST False\nL9:\n END_FOR\n JUMP_BACKWARD L6\nL10:\n END_FOR\n RETURN_CONST True\nEND", "expected": "def is_samepatterns(colors, patterns):\n if len(colors) != len(patterns):\n return False\n sdict = {}\n pset = set()\n sset = set()\n for i in range(len(patterns)):\n pset.add(patterns[i])\n sset.add(colors[i])\n if patterns[i] not in sdict.keys():\n sdict[patterns[i]] = []\n keys = sdict[patterns[i]]\n keys.append(colors[i])\n sdict[patterns[i]] = keys\n if len(pset) != len(sset):\n return False\n for values in sdict.values():\n for i in range(len(values) - 1):\n if values[i] != values[i + 1]:\n return False\n return True", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 74, "mbpp_split": "test", "prompt": "Write a function to check whether it follows the sequence given in the patterns array.", "test_list": ["assert is_samepatterns([\"red\",\"green\",\"green\"], [\"a\", \"b\", \"b\"])==True ", "assert is_samepatterns([\"red\",\"green\",\"greenn\"], [\"a\",\"b\",\"b\"])==False ", "assert is_samepatterns([\"red\",\"green\",\"greenn\"], [\"a\",\"b\"])==False "], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_74", "n_instr": 136} {"i": 321, "src_path": "src/00321.py", "pyc_path": "pyc/00321.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_tuples\n RETURN_CONST None\nEND\nCODE find_tuples(test_list, K)\n MAKE_CELL K\n RESUME 0\n LOAD_FAST test_list\n GET_ITER\n LOAD_FAST_AND_CLEAR sub\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L5\n STORE_FAST sub\n LOAD_GLOBAL NULL + all\n LOAD_CLOSURE K\n BUILD_TUPLE 1\n LOAD_CONST .>\n MAKE_FUNCTION closure\n LOAD_FAST sub\n GET_ITER\n CALL 0\n CALL 1\n POP_JUMP_IF_TRUE L4\nL3:\n JUMP_BACKWARD L2\nL4:\n LOAD_FAST sub\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL5:\n END_FOR\nL6:\n STORE_FAST res\n STORE_FAST sub\n LOAD_GLOBAL NULL + str\n LOAD_FAST res\n CALL 1\n RETURN_VALUE\nL7:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST sub\n RERAISE 0\n EXC try=L1..L3 -> handler=L7 depth=2 lasti=False\n EXC try=L4..L6 -> handler=L7 depth=2 lasti=False\nEND\nCODE find_tuples..(.0)\n COPY_FREE_VARS 1\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n STORE_FAST ele\n LOAD_FAST ele\n LOAD_DEREF K\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def find_tuples(test_list, K):\n res = [sub for sub in test_list if all((ele % K == 0 for ele in sub))]\n return str(res)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 75, "mbpp_split": "test", "prompt": "Write a function to find tuples which have all elements divisible by k from the given list of tuples.", "test_list": ["assert find_tuples([(6, 24, 12), (7, 9, 6), (12, 18, 21)], 6) == '[(6, 24, 12)]'", "assert find_tuples([(5, 25, 30), (4, 2, 3), (7, 8, 9)], 5) == '[(5, 25, 30)]'", "assert find_tuples([(7, 9, 16), (8, 16, 4), (19, 17, 18)], 4) == '[(8, 16, 4)]'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_75", "n_instr": 80} {"i": 322, "src_path": "src/00322.py", "pyc_path": "pyc/00322.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_Squares\n RETURN_CONST None\nEND\nCODE count_Squares(m, n)\n RESUME 0\n LOAD_FAST n\n LOAD_FAST m\n COMPARE_OP <\n POP_JUMP_IF_FALSE L1\n LOAD_FAST m\n STORE_FAST temp\n LOAD_FAST n\n STORE_FAST m\n LOAD_FAST temp\n STORE_FAST n\nL1:\n LOAD_FAST m\n LOAD_FAST m\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP *\n LOAD_CONST 2\n LOAD_FAST m\n BINARY_OP *\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP *\n LOAD_CONST 6\n BINARY_OP /\n LOAD_FAST n\n LOAD_FAST m\n BINARY_OP -\n LOAD_FAST m\n BINARY_OP *\n LOAD_FAST m\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP *\n LOAD_CONST 2\n BINARY_OP /\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def count_Squares(m, n):\n if n < m:\n temp = m\n m = n\n n = temp\n return m * (m + 1) * (2 * m + 1) / 6 + (n - m) * m * (m + 1) / 2", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 76, "mbpp_split": "test", "prompt": "Write a python function to count the number of squares in a rectangle.", "test_list": ["assert count_Squares(4,3) == 20", "assert count_Squares(2,2) == 5", "assert count_Squares(1,1) == 1"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_76", "n_instr": 46} {"i": 323, "src_path": "src/00323.py", "pyc_path": "pyc/00323.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_With_Odd_SetBits\n RETURN_CONST None\nEND\nCODE count_With_Odd_SetBits(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L1\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n LOAD_CONST 2\n BINARY_OP /\n RETURN_VALUE\nL1:\n LOAD_GLOBAL NULL + bin\n LOAD_FAST n\n CALL 1\n LOAD_ATTR NULL|self + count\n LOAD_CONST '1'\n CALL 1\n STORE_FAST count\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP /\n STORE_FAST ans\n LOAD_FAST count\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L2\n LOAD_FAST ans\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST ans\nL2:\n LOAD_FAST ans\n RETURN_VALUE\nEND", "expected": "def count_With_Odd_SetBits(n):\n if n % 2 != 0:\n return (n + 1) / 2\n count = bin(n).count('1')\n ans = n / 2\n if count % 2 != 0:\n ans += 1\n return ans", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 78, "mbpp_split": "test", "prompt": "Write a python function to find number of integers with odd number of set bits.", "test_list": ["assert count_With_Odd_SetBits(5) == 3", "assert count_With_Odd_SetBits(10) == 5", "assert count_With_Odd_SetBits(15) == 8"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_78", "n_instr": 46} {"i": 324, "src_path": "src/00324.py", "pyc_path": "pyc/00324.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME word_len\n RETURN_CONST None\nEND\nCODE word_len(s)\n RESUME 0\n LOAD_FAST s\n LOAD_ATTR NULL|self + split\n LOAD_CONST ' '\n CALL 1\n STORE_FAST s\n LOAD_FAST s\n GET_ITER\n FOR_ITER L2\n STORE_FAST word\n LOAD_GLOBAL NULL + len\n LOAD_FAST word\n CALL 1\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L1\n POP_TOP\n RETURN_CONST True\nL1:\n POP_TOP\n RETURN_CONST False\nL2:\n END_FOR\n RETURN_CONST None\nEND", "expected": "def word_len(s):\n s = s.split(' ')\n for word in s:\n if len(word) % 2 != 0:\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 79, "mbpp_split": "test", "prompt": "Write a python function to check whether the length of the word is odd or not.", "test_list": ["assert word_len(\"Hadoop\") == False", "assert word_len(\"great\") == True", "assert word_len(\"structure\") == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_79", "n_instr": 34} {"i": 325, "src_path": "src/00325.py", "pyc_path": "pyc/00325.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME tetrahedral_number\n RETURN_CONST None\nEND\nCODE tetrahedral_number(n)\n RESUME 0\n LOAD_FAST n\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP *\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP +\n BINARY_OP *\n LOAD_CONST 6\n BINARY_OP /\n RETURN_VALUE\nEND", "expected": "def tetrahedral_number(n):\n return n * (n + 1) * (n + 2) / 6", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 80, "mbpp_split": "test", "prompt": "Write a function to find the nth tetrahedral number.", "test_list": ["assert tetrahedral_number(5) == 35.0", "assert tetrahedral_number(6) == 56.0", "assert tetrahedral_number(7) == 84.0"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_80", "n_instr": 21} {"i": 326, "src_path": "src/00326.py", "pyc_path": "pyc/00326.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME zip_tuples\n RETURN_CONST None\nEND\nCODE zip_tuples(test_tup1, test_tup2)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST res\n LOAD_GLOBAL NULL + enumerate\n LOAD_FAST test_tup1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L2\n UNPACK_SEQUENCE 2\n STORE_FAST i\n STORE_FAST j\n LOAD_FAST res\n LOAD_ATTR NULL|self + append\n LOAD_FAST j\n LOAD_FAST test_tup2\n LOAD_FAST i\n LOAD_GLOBAL NULL + len\n LOAD_FAST test_tup2\n CALL 1\n BINARY_OP %\n BINARY_SUBSCR\n BUILD_TUPLE 2\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def zip_tuples(test_tup1, test_tup2):\n res = []\n for i, j in enumerate(test_tup1):\n res.append((j, test_tup2[i % len(test_tup2)]))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 81, "mbpp_split": "test", "prompt": "Write a function to zip the two given tuples.", "test_list": ["assert zip_tuples((7, 8, 4, 5, 9, 10),(1, 5, 6) ) == [(7, 1), (8, 5), (4, 6), (5, 1), (9, 5), (10, 6)]", "assert zip_tuples((8, 9, 5, 6, 10, 11),(2, 6, 7) ) == [(8, 2), (9, 6), (5, 7), (6, 2), (10, 6), (11, 7)]", "assert zip_tuples((9, 10, 6, 7, 11, 12),(3, 7, 8) ) == [(9, 3), (10, 7), (6, 8), (7, 3), (11, 7), (12, 8)]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_81", "n_instr": 38} {"i": 327, "src_path": "src/00327.py", "pyc_path": "pyc/00327.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME volume_sphere\n RETURN_CONST None\nEND\nCODE volume_sphere(r)\n RESUME 0\n LOAD_CONST 1.3333333333333333\n LOAD_GLOBAL math\n LOAD_ATTR pi\n BINARY_OP *\n LOAD_FAST r\n BINARY_OP *\n LOAD_FAST r\n BINARY_OP *\n LOAD_FAST r\n BINARY_OP *\n STORE_FAST volume\n LOAD_FAST volume\n RETURN_VALUE\nEND", "expected": "import math\n\ndef volume_sphere(r):\n volume = 4 / 3 * math.pi * r * r * r\n return volume", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 82, "mbpp_split": "test", "prompt": "Write a function to find the volume of a sphere.", "test_list": ["assert volume_sphere(10)==4188.790204786391", "assert volume_sphere(25)==65449.84694978735", "assert volume_sphere(20)==33510.32163829113"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_82", "n_instr": 26} {"i": 328, "src_path": "src/00328.py", "pyc_path": "pyc/00328.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME get_Char\n RETURN_CONST None\nEND\nCODE get_Char(strr)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST summ\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST strr\n CALL 1\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST summ\n LOAD_GLOBAL NULL + ord\n LOAD_FAST strr\n LOAD_FAST i\n BINARY_SUBSCR\n CALL 1\n LOAD_GLOBAL NULL + ord\n LOAD_CONST 'a'\n CALL 1\n BINARY_OP -\n LOAD_CONST 1\n BINARY_OP +\n BINARY_OP +=\n STORE_FAST summ\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST summ\n LOAD_CONST 26\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n LOAD_GLOBAL NULL + ord\n LOAD_CONST 'z'\n CALL 1\n RETURN_VALUE\nL3:\n LOAD_FAST summ\n LOAD_CONST 26\n BINARY_OP %\n STORE_FAST summ\n LOAD_GLOBAL NULL + chr\n LOAD_GLOBAL NULL + ord\n LOAD_CONST 'a'\n CALL 1\n LOAD_FAST summ\n BINARY_OP +\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n RETURN_VALUE\nEND", "expected": "def get_Char(strr):\n summ = 0\n for i in range(len(strr)):\n summ += ord(strr[i]) - ord('a') + 1\n if summ % 26 == 0:\n return ord('z')\n else:\n summ = summ % 26\n return chr(ord('a') + summ - 1)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 83, "mbpp_split": "test", "prompt": "Write a python function to find the character made by adding all the characters of the given string.", "test_list": ["assert get_Char(\"abc\") == \"f\"", "assert get_Char(\"gfg\") == \"t\"", "assert get_Char(\"ab\") == \"c\""], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_83", "n_instr": 62} {"i": 329, "src_path": "src/00329.py", "pyc_path": "pyc/00329.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sequence\n RETURN_CONST None\nEND\nCODE sequence(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L1\n LOAD_FAST n\n LOAD_CONST 2\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\nL1:\n RETURN_CONST 1\nL2:\n LOAD_GLOBAL NULL + sequence\n LOAD_GLOBAL NULL + sequence\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n CALL 1\n LOAD_GLOBAL NULL + sequence\n LOAD_FAST n\n LOAD_GLOBAL NULL + sequence\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n CALL 1\n BINARY_OP -\n CALL 1\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def sequence(n):\n if n == 1 or n == 2:\n return 1\n else:\n return sequence(sequence(n - 1)) + sequence(n - sequence(n - 1))", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 84, "mbpp_split": "test", "prompt": "Write a function to find the n-th number in newman conway sequence.", "test_list": ["assert sequence(10) == 6", "assert sequence(2) == 1", "assert sequence(3) == 2"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_84", "n_instr": 38} {"i": 330, "src_path": "src/00330.py", "pyc_path": "pyc/00330.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME math\n STORE_NAME math\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME surfacearea_sphere\n RETURN_CONST None\nEND\nCODE surfacearea_sphere(r)\n RESUME 0\n LOAD_CONST 4\n LOAD_GLOBAL math\n LOAD_ATTR pi\n BINARY_OP *\n LOAD_FAST r\n BINARY_OP *\n LOAD_FAST r\n BINARY_OP *\n STORE_FAST surfacearea\n LOAD_FAST surfacearea\n RETURN_VALUE\nEND", "expected": "import math\n\ndef surfacearea_sphere(r):\n surfacearea = 4 * math.pi * r * r\n return surfacearea", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 85, "mbpp_split": "test", "prompt": "Write a function to find the surface area of a sphere.", "test_list": ["assert surfacearea_sphere(10)==1256.6370614359173", "assert surfacearea_sphere(15)==2827.4333882308138", "assert surfacearea_sphere(20)==5026.548245743669"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_85", "n_instr": 24} {"i": 331, "src_path": "src/00331.py", "pyc_path": "pyc/00331.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME centered_hexagonal_number\n RETURN_CONST None\nEND\nCODE centered_hexagonal_number(n)\n RESUME 0\n LOAD_CONST 3\n LOAD_FAST n\n BINARY_OP *\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n BINARY_OP *\n LOAD_CONST 1\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def centered_hexagonal_number(n):\n return 3 * n * (n - 1) + 1", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 86, "mbpp_split": "test", "prompt": "Write a function to find nth centered hexagonal number.", "test_list": ["assert centered_hexagonal_number(10) == 271", "assert centered_hexagonal_number(2) == 7", "assert centered_hexagonal_number(9) == 217"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_86", "n_instr": 19} {"i": 332, "src_path": "src/00332.py", "pyc_path": "pyc/00332.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME collections\n STORE_NAME collections\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME freq_count\n RETURN_CONST None\nEND\nCODE freq_count(list1)\n RESUME 0\n LOAD_GLOBAL NULL + collections\n LOAD_ATTR Counter\n LOAD_FAST list1\n CALL 1\n STORE_FAST freq_count\n LOAD_FAST freq_count\n RETURN_VALUE\nEND", "expected": "import collections\n\ndef freq_count(list1):\n freq_count = collections.Counter(list1)\n return freq_count", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 88, "mbpp_split": "test", "prompt": "Write a function to get the frequency of the elements in a list.", "test_list": ["assert freq_count([10,10,10,10,20,20,20,20,40,40,50,50,30])==({10: 4, 20: 4, 40: 2, 50: 2, 30: 1}) ", "assert freq_count([1,2,3,4,3,2,4,1,3,1,4])==({1:3, 2:2,3:3,4:3}) ", "assert freq_count([5,6,7,4,9,10,4,5,6,7,9,5])==({10:1,5:3,6:2,7:2,4:2,9:2}) "], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_88", "n_instr": 20} {"i": 333, "src_path": "src/00333.py", "pyc_path": "pyc/00333.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME len_log\n RETURN_CONST None\nEND\nCODE len_log(list1)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST list1\n LOAD_CONST 0\n BINARY_SUBSCR\n CALL 1\n STORE_FAST max\n LOAD_FAST list1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_GLOBAL NULL + len\n LOAD_FAST i\n CALL 1\n LOAD_FAST max\n COMPARE_OP >\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_GLOBAL NULL + len\n LOAD_FAST i\n CALL 1\n STORE_FAST max\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST max\n RETURN_VALUE\nEND", "expected": "def len_log(list1):\n max = len(list1[0])\n for i in list1:\n if len(i) > max:\n max = len(i)\n return max", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 90, "mbpp_split": "test", "prompt": "Write a python function to find the length of the longest word.", "test_list": ["assert len_log([\"python\",\"PHP\",\"bigdata\"]) == 7", "assert len_log([\"a\",\"ab\",\"abc\"]) == 3", "assert len_log([\"small\",\"big\",\"tall\"]) == 5"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_90", "n_instr": 37} {"i": 334, "src_path": "src/00334.py", "pyc_path": "pyc/00334.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_substring\n RETURN_CONST None\nEND\nCODE find_substring(str1, sub_str)\n MAKE_CELL sub_str\n RESUME 0\n LOAD_GLOBAL NULL + any\n LOAD_CLOSURE sub_str\n BUILD_TUPLE 1\n LOAD_CONST .>\n MAKE_FUNCTION closure\n LOAD_FAST str1\n GET_ITER\n CALL 0\n CALL 1\n POP_JUMP_IF_FALSE L1\n RETURN_CONST True\nL1:\n RETURN_CONST False\nEND\nCODE find_substring..(.0)\n COPY_FREE_VARS 1\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n STORE_FAST s\n LOAD_DEREF sub_str\n LOAD_FAST s\n CONTAINS_OP 0\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def find_substring(str1, sub_str):\n if any((sub_str in s for s in str1)):\n return True\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 91, "mbpp_split": "test", "prompt": "Write a function to check if a substring is present in a given list of string values.", "test_list": ["assert find_substring([\"red\", \"black\", \"white\", \"green\", \"orange\"],\"ack\")==True", "assert find_substring([\"red\", \"black\", \"white\", \"green\", \"orange\"],\"abc\")==False", "assert find_substring([\"red\", \"black\", \"white\", \"green\", \"orange\"],\"ange\")==True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_91", "n_instr": 48} {"i": 335, "src_path": "src/00335.py", "pyc_path": "pyc/00335.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_undulating\n RETURN_CONST None\nEND\nCODE is_undulating(n)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST n\n CALL 1\n LOAD_CONST 2\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L1\n RETURN_CONST False\nL1:\n LOAD_GLOBAL NULL + range\n LOAD_CONST 2\n LOAD_GLOBAL NULL + len\n LOAD_FAST n\n CALL 1\n CALL 2\n GET_ITER\nL2:\n FOR_ITER L4\n STORE_FAST i\n LOAD_FAST n\n LOAD_FAST i\n LOAD_CONST 2\n BINARY_OP -\n BINARY_SUBSCR\n LOAD_FAST n\n LOAD_FAST i\n BINARY_SUBSCR\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L2\nL3:\n POP_TOP\n RETURN_CONST False\nL4:\n END_FOR\n RETURN_CONST True\nEND", "expected": "def is_undulating(n):\n if len(n) <= 2:\n return False\n for i in range(2, len(n)):\n if n[i - 2] != n[i]:\n return False\n return True", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 92, "mbpp_split": "test", "prompt": "Write a function to check whether the given number is undulating or not.", "test_list": ["assert is_undulating(\"1212121\") == True", "assert is_undulating(\"1991\") == False", "assert is_undulating(\"121\") == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_92", "n_instr": 44} {"i": 336, "src_path": "src/00336.py", "pyc_path": "pyc/00336.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME power\n RETURN_CONST None\nEND\nCODE power(a, b)\n RESUME 0\n LOAD_FAST b\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 1\nL1:\n LOAD_FAST a\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n RETURN_CONST 0\nL2:\n LOAD_FAST b\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n LOAD_FAST a\n RETURN_VALUE\nL3:\n LOAD_FAST a\n LOAD_GLOBAL NULL + power\n LOAD_FAST a\n LOAD_FAST b\n LOAD_CONST 1\n BINARY_OP -\n CALL 2\n BINARY_OP *\n RETURN_VALUE\nEND", "expected": "def power(a, b):\n if b == 0:\n return 1\n elif a == 0:\n return 0\n elif b == 1:\n return a\n else:\n return a * power(a, b - 1)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 93, "mbpp_split": "test", "prompt": "Write a function to calculate the value of 'a' to the power 'b'.", "test_list": ["assert power(3,4) == 81", "assert power(2,3) == 8", "assert power(5,5) == 3125"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_93", "n_instr": 37} {"i": 337, "src_path": "src/00337.py", "pyc_path": "pyc/00337.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME Find_Min_Length\n RETURN_CONST None\nEND\nCODE Find_Min_Length(lst)\n RESUME 0\n LOAD_GLOBAL NULL + min\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST lst\n GET_ITER\n CALL 0\n CALL 1\n STORE_FAST minLength\n LOAD_FAST minLength\n RETURN_VALUE\nEND\nCODE Find_Min_Length..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n STORE_FAST x\n LOAD_GLOBAL NULL + len\n LOAD_FAST x\n CALL 1\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def Find_Min_Length(lst):\n minLength = min((len(x) for x in lst))\n return minLength", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 95, "mbpp_split": "test", "prompt": "Write a python function to find the minimum length of sublist.", "test_list": ["assert Find_Min_Length([[1],[1,2]]) == 1", "assert Find_Min_Length([[1,2],[1,2,3],[1,2,3,4]]) == 2", "assert Find_Min_Length([[3,3,3],[4,4,4,4]]) == 3"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_95", "n_instr": 43} {"i": 338, "src_path": "src/00338.py", "pyc_path": "pyc/00338.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME divisor\n RETURN_CONST None\nEND\nCODE divisor(n)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L8\n STORE_FAST i\n LOAD_GLOBAL NULL + len\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL2:\n BUILD_LIST 0\n SWAP 2\nL3:\n FOR_ITER L6\n STORE_FAST i\n LOAD_FAST n\n LOAD_FAST i\n BINARY_OP %\n POP_JUMP_IF_FALSE L5\nL4:\n JUMP_BACKWARD L3\nL5:\n LOAD_FAST i\n LIST_APPEND 2\n JUMP_BACKWARD L3\nL6:\n END_FOR\nL7:\n SWAP 2\n STORE_FAST i\n CALL 1\n STORE_FAST x\n JUMP_BACKWARD L1\nL8:\n END_FOR\n LOAD_FAST_CHECK x\n RETURN_VALUE\nL9:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\n EXC try=L2..L4 -> handler=L9 depth=5 lasti=False\n EXC try=L5..L7 -> handler=L9 depth=5 lasti=False\nEND", "expected": "def divisor(n):\n for i in range(n):\n x = len([i for i in range(1, n + 1) if not n % i])\n return x", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 96, "mbpp_split": "test", "prompt": "Write a python function to find the number of divisors of a given integer.", "test_list": ["assert divisor(15) == 4 ", "assert divisor(12) == 6", "assert divisor(9) == 3"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_96", "n_instr": 62} {"i": 339, "src_path": "src/00339.py", "pyc_path": "pyc/00339.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME frequency_lists\n RETURN_CONST None\nEND\nCODE frequency_lists(list1)\n RESUME 0\n LOAD_FAST list1\n GET_ITER\n LOAD_FAST_AND_CLEAR sublist\n LOAD_FAST_AND_CLEAR item\n SWAP 3\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L5\n STORE_FAST sublist\n LOAD_FAST sublist\n GET_ITER\nL3:\n FOR_ITER L4\n STORE_FAST item\n LOAD_FAST item\n LIST_APPEND 3\n JUMP_BACKWARD L3\nL4:\n END_FOR\n JUMP_BACKWARD L2\nL5:\n END_FOR\nL6:\n STORE_FAST list1\n STORE_FAST sublist\n STORE_FAST item\n BUILD_MAP 0\n STORE_FAST dic_data\n LOAD_FAST list1\n GET_ITER\nL7:\n FOR_ITER L9\n STORE_FAST num\n LOAD_FAST num\n LOAD_FAST dic_data\n LOAD_ATTR NULL|self + keys\n CALL 0\n CONTAINS_OP 0\n POP_JUMP_IF_FALSE L8\n LOAD_FAST dic_data\n LOAD_FAST num\n COPY 2\n COPY 2\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +=\n SWAP 3\n SWAP 2\n STORE_SUBSCR\n JUMP_BACKWARD L7\nL8:\n LOAD_FAST num\n STORE_FAST key\n LOAD_CONST 1\n STORE_FAST value\n LOAD_FAST value\n LOAD_FAST dic_data\n LOAD_FAST key\n STORE_SUBSCR\n JUMP_BACKWARD L7\nL9:\n END_FOR\n LOAD_FAST dic_data\n RETURN_VALUE\nL10:\n SWAP 2\n POP_TOP\n SWAP 3\n STORE_FAST item\n STORE_FAST sublist\n RERAISE 0\n EXC try=L1..L6 -> handler=L10 depth=3 lasti=False\nEND", "expected": "def frequency_lists(list1):\n list1 = [item for sublist in list1 for item in sublist]\n dic_data = {}\n for num in list1:\n if num in dic_data.keys():\n dic_data[num] += 1\n else:\n key = num\n value = 1\n dic_data[key] = value\n return dic_data", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 97, "mbpp_split": "test", "prompt": "Write a function to find frequency count of list of lists.", "test_list": ["assert frequency_lists([[1, 2, 3, 2], [4, 5, 6, 2], [7, 8, 9, 5]])=={1: 1, 2: 3, 3: 1, 4: 1, 5: 2, 6: 1, 7: 1, 8: 1, 9: 1}", "assert frequency_lists([[1,2,3,4],[5,6,7,8],[9,10,11,12]])=={1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 1, 8: 1, 9: 1,10:1,11:1,12:1}", "assert frequency_lists([[20,30,40,17],[18,16,14,13],[10,20,30,40]])=={20:2,30:2,40:2,17: 1,18:1, 16: 1,14: 1,13: 1, 10: 1}"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_97", "n_instr": 83} {"i": 340, "src_path": "src/00340.py", "pyc_path": "pyc/00340.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME multiply_num\n RETURN_CONST None\nEND\nCODE multiply_num(numbers)\n RESUME 0\n LOAD_CONST 1\n STORE_FAST total\n LOAD_FAST numbers\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST x\n LOAD_FAST total\n LOAD_FAST x\n BINARY_OP *=\n STORE_FAST total\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST total\n LOAD_GLOBAL NULL + len\n LOAD_FAST numbers\n CALL 1\n BINARY_OP /\n RETURN_VALUE\nEND", "expected": "def multiply_num(numbers):\n total = 1\n for x in numbers:\n total *= x\n return total / len(numbers)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 98, "mbpp_split": "test", "prompt": "Write a function to multiply all the numbers in a list and divide with the length of the list.", "test_list": ["assert multiply_num((8, 2, 3, -1, 7))==-67.2", "assert multiply_num((-10,-20,-30))==-2000.0", "assert multiply_num((19,15,18))==1710.0"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_98", "n_instr": 29} {"i": 341, "src_path": "src/00341.py", "pyc_path": "pyc/00341.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME decimal_to_binary\n RETURN_CONST None\nEND\nCODE decimal_to_binary(n)\n RESUME 0\n LOAD_GLOBAL NULL + bin\n LOAD_FAST n\n CALL 1\n LOAD_ATTR NULL|self + replace\n LOAD_CONST '0b'\n LOAD_CONST ''\n CALL 2\n RETURN_VALUE\nEND", "expected": "def decimal_to_binary(n):\n return bin(n).replace('0b', '')", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 99, "mbpp_split": "test", "prompt": "Write a function to convert the given decimal number to its binary equivalent.", "test_list": ["assert decimal_to_binary(8) == '1000'", "assert decimal_to_binary(18) == '10010'", "assert decimal_to_binary(7) == '111' "], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_99", "n_instr": 17} {"i": 342, "src_path": "src/00342.py", "pyc_path": "pyc/00342.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME sys\n STORE_NAME sys\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME next_smallest_palindrome\n RETURN_CONST None\nEND\nCODE next_smallest_palindrome(num)\n RESUME 0\n LOAD_GLOBAL NULL + str\n LOAD_FAST num\n CALL 1\n STORE_FAST numstr\n LOAD_GLOBAL NULL + range\n LOAD_FAST num\n LOAD_CONST 1\n BINARY_OP +\n LOAD_GLOBAL sys\n LOAD_ATTR maxsize\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_GLOBAL NULL + str\n LOAD_FAST i\n CALL 1\n LOAD_GLOBAL NULL + str\n LOAD_FAST i\n CALL 1\n LOAD_CONST None\n LOAD_CONST None\n LOAD_CONST -1\n BUILD_SLICE 3\n BINARY_SUBSCR\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST i\n SWAP 2\n POP_TOP\n RETURN_VALUE\nL3:\n END_FOR\n RETURN_CONST None\nEND", "expected": "import sys\n\ndef next_smallest_palindrome(num):\n numstr = str(num)\n for i in range(num + 1, sys.maxsize):\n if str(i) == str(i)[::-1]:\n return i", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 100, "mbpp_split": "test", "prompt": "Write a function to find the next smallest palindrome of a specified number.", "test_list": ["assert next_smallest_palindrome(99)==101", "assert next_smallest_palindrome(1221)==1331", "assert next_smallest_palindrome(120)==121"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_100", "n_instr": 50} {"i": 343, "src_path": "src/00343.py", "pyc_path": "pyc/00343.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME snake_to_camel\n RETURN_CONST None\nEND\nCODE snake_to_camel(word)\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME re\n STORE_FAST re\n LOAD_CONST ''\n LOAD_ATTR NULL|self + join\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST word\n LOAD_ATTR NULL|self + split\n LOAD_CONST '_'\n CALL 1\n GET_ITER\n CALL 0\n CALL 1\n RETURN_VALUE\nEND\nCODE snake_to_camel..(.0)\n DOC '_'\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L4\n STORE_FAST x\n LOAD_FAST x\n LOAD_ATTR NULL|self + capitalize\n CALL 0\n COPY 1\n POP_JUMP_IF_TRUE L3\n POP_TOP\n LOAD_CONST '_'\nL3:\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL4:\n END_FOR\n RETURN_CONST None\nL5:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L5 -> handler=L5 depth=0 lasti=True\nEND", "expected": "def snake_to_camel(word):\n import re\n return ''.join((x.capitalize() or '_' for x in word.split('_')))", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 102, "mbpp_split": "test", "prompt": "Write a function to convert snake case string to camel case string.", "test_list": ["assert snake_to_camel('python_program')=='PythonProgram'", "assert snake_to_camel('python_language')==('PythonLanguage')", "assert snake_to_camel('programming_language')==('ProgrammingLanguage')"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_102", "n_instr": 55} {"i": 344, "src_path": "src/00344.py", "pyc_path": "pyc/00344.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME eulerian_num\n RETURN_CONST None\nEND\nCODE eulerian_num(n, m)\n RESUME 0\n LOAD_FAST m\n LOAD_FAST n\n COMPARE_OP >=\n POP_JUMP_IF_TRUE L1\n LOAD_FAST n\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\nL1:\n RETURN_CONST 0\nL2:\n LOAD_FAST m\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n RETURN_CONST 1\nL3:\n LOAD_FAST n\n LOAD_FAST m\n BINARY_OP -\n LOAD_GLOBAL NULL + eulerian_num\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n LOAD_FAST m\n LOAD_CONST 1\n BINARY_OP -\n CALL 2\n BINARY_OP *\n LOAD_FAST m\n LOAD_CONST 1\n BINARY_OP +\n LOAD_GLOBAL NULL + eulerian_num\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n LOAD_FAST m\n CALL 2\n BINARY_OP *\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def eulerian_num(n, m):\n if m >= n or n == 0:\n return 0\n if m == 0:\n return 1\n return (n - m) * eulerian_num(n - 1, m - 1) + (m + 1) * eulerian_num(n - 1, m)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 103, "mbpp_split": "test", "prompt": "Write a function to find eulerian number a(n, m).", "test_list": ["assert eulerian_num(3, 1) == 4", "assert eulerian_num(4, 1) == 11", "assert eulerian_num(5, 3) == 26"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_103", "n_instr": 50} {"i": 345, "src_path": "src/00345.py", "pyc_path": "pyc/00345.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sort_sublists\n RETURN_CONST None\nEND\nCODE sort_sublists(input_list)\n RESUME 0\n LOAD_FAST input_list\n GET_ITER\n LOAD_FAST_AND_CLEAR x\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST x\n LOAD_GLOBAL NULL + sorted\n LOAD_FAST x\n LOAD_CONST .>\n MAKE_FUNCTION 0\n KW_NAMES ('key',)\n CALL 2\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST result\n STORE_FAST x\n LOAD_FAST result\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST x\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=2 lasti=False\nEND\nCODE sort_sublists..(x)\n RESUME 0\n LOAD_FAST x\n LOAD_CONST 0\n BINARY_SUBSCR\n RETURN_VALUE\nEND", "expected": "def sort_sublists(input_list):\n result = [sorted(x, key=lambda x: x[0]) for x in input_list]\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 104, "mbpp_split": "test", "prompt": "Write a function to sort each sublist of strings in a given list of lists using lambda function.", "test_list": ["assert sort_sublists(([\"green\", \"orange\"], [\"black\", \"white\"], [\"white\", \"black\", \"orange\"]))==[['green', 'orange'], ['black', 'white'], ['black', 'orange', 'white']]", "assert sort_sublists(([\" red \",\"green\" ],[\"blue \",\" black\"],[\" orange\",\"brown\"]))==[[' red ', 'green'], [' black', 'blue '], [' orange', 'brown']]", "assert sort_sublists(([\"zilver\",\"gold\"], [\"magnesium\",\"aluminium\"], [\"steel\", \"bronze\"]))==[['gold', 'zilver'],['aluminium', 'magnesium'], ['bronze', 'steel']]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_104", "n_instr": 48} {"i": 346, "src_path": "src/00346.py", "pyc_path": "pyc/00346.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME add_lists\n RETURN_CONST None\nEND\nCODE add_lists(test_list, test_tup)\n RESUME 0\n LOAD_GLOBAL NULL + tuple\n LOAD_GLOBAL NULL + list\n LOAD_FAST test_tup\n CALL 1\n LOAD_FAST test_list\n BINARY_OP +\n CALL 1\n STORE_FAST res\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def add_lists(test_list, test_tup):\n res = tuple(list(test_tup) + test_list)\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 106, "mbpp_split": "test", "prompt": "Write a function to add the given list to the given tuples.", "test_list": ["assert add_lists([5, 6, 7], (9, 10)) == (9, 10, 5, 6, 7)", "assert add_lists([6, 7, 8], (10, 11)) == (10, 11, 6, 7, 8)", "assert add_lists([7, 8, 9], (11, 12)) == (11, 12, 7, 8, 9)"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_106", "n_instr": 19} {"i": 347, "src_path": "src/00347.py", "pyc_path": "pyc/00347.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME odd_Equivalent\n RETURN_CONST None\nEND\nCODE odd_Equivalent(s, n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST count\n LOAD_GLOBAL NULL + range\n LOAD_CONST 0\n LOAD_FAST n\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST i\n LOAD_FAST s\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST '1'\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST count\n LOAD_CONST 1\n BINARY_OP +\n STORE_FAST count\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_FAST count\n RETURN_VALUE\nEND", "expected": "def odd_Equivalent(s, n):\n count = 0\n for i in range(0, n):\n if s[i] == '1':\n count = count + 1\n return count", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 109, "mbpp_split": "test", "prompt": "Write a python function to find the count of rotations of a binary string with odd value.", "test_list": ["assert odd_Equivalent(\"011001\",6) == 3", "assert odd_Equivalent(\"11011\",5) == 4", "assert odd_Equivalent(\"1010\",4) == 2"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_109", "n_instr": 36} {"i": 348, "src_path": "src/00348.py", "pyc_path": "pyc/00348.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME extract_missing\n RETURN_CONST None\nEND\nCODE extract_missing(test_list, strt_val, stop_val)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST res\n LOAD_FAST test_list\n GET_ITER\nL1:\n FOR_ITER L4\n STORE_FAST sub\n LOAD_FAST sub\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST strt_val\n COMPARE_OP >\n POP_JUMP_IF_FALSE L2\n LOAD_FAST res\n LOAD_ATTR NULL|self + append\n LOAD_FAST strt_val\n LOAD_FAST sub\n LOAD_CONST 0\n BINARY_SUBSCR\n BUILD_TUPLE 2\n CALL 1\n POP_TOP\n LOAD_FAST sub\n LOAD_CONST 1\n BINARY_SUBSCR\n STORE_FAST strt_val\nL2:\n LOAD_FAST strt_val\n LOAD_FAST stop_val\n COMPARE_OP <\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L1\nL3:\n LOAD_FAST res\n LOAD_ATTR NULL|self + append\n LOAD_FAST strt_val\n LOAD_FAST stop_val\n BUILD_TUPLE 2\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL4:\n END_FOR\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def extract_missing(test_list, strt_val, stop_val):\n res = []\n for sub in test_list:\n if sub[0] > strt_val:\n res.append((strt_val, sub[0]))\n strt_val = sub[1]\n if strt_val < stop_val:\n res.append((strt_val, stop_val))\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 110, "mbpp_split": "test", "prompt": "Write a function to extract the ranges that are missing from the given list with the given start range and end range values.", "test_list": ["assert extract_missing([(6, 9), (15, 34), (48, 70)], 2, 100) == [(2, 6), (9, 100), (9, 15), (34, 100), (34, 48), (70, 100)]", "assert extract_missing([(7, 2), (15, 19), (38, 50)], 5, 60) == [(5, 7), (2, 60), (2, 15), (19, 60), (19, 38), (50, 60)]", "assert extract_missing([(7, 2), (15, 19), (38, 50)], 1, 52) == [(1, 7), (2, 52), (2, 15), (19, 52), (19, 38), (50, 52)]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_110", "n_instr": 54} {"i": 349, "src_path": "src/00349.py", "pyc_path": "pyc/00349.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME common_in_nested_lists\n RETURN_CONST None\nEND\nCODE common_in_nested_lists(nestedlist)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + set\n LOAD_ATTR intersection\n LOAD_GLOBAL NULL + map\n LOAD_GLOBAL set\n LOAD_FAST nestedlist\n CALL 2\n CALL_FUNCTION_EX 0\n CALL 1\n STORE_FAST result\n LOAD_FAST result\n RETURN_VALUE\nEND", "expected": "def common_in_nested_lists(nestedlist):\n result = list(set.intersection(*map(set, nestedlist)))\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 111, "mbpp_split": "test", "prompt": "Write a function to find common elements in given nested lists. * list item * list item * list item * list item", "test_list": ["assert common_in_nested_lists([[12, 18, 23, 25, 45], [7, 12, 18, 24, 28], [1, 5, 8, 12, 15, 16, 18]])==[18, 12]", "assert common_in_nested_lists([[12, 5, 23, 25, 45], [7, 11, 5, 23, 28], [1, 5, 8, 18, 23, 16]])==[5,23]", "assert common_in_nested_lists([[2, 3,4, 1], [4, 5], [6,4, 8],[4, 5], [6, 8,4]])==[4]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_111", "n_instr": 21} {"i": 350, "src_path": "src/00350.py", "pyc_path": "pyc/00350.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME perimeter\n RETURN_CONST None\nEND\nCODE perimeter(diameter, height)\n RESUME 0\n LOAD_CONST 2\n LOAD_FAST diameter\n LOAD_FAST height\n BINARY_OP +\n BINARY_OP *\n RETURN_VALUE\nEND", "expected": "def perimeter(diameter, height):\n return 2 * (diameter + height)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 112, "mbpp_split": "test", "prompt": "Write a python function to find the perimeter of a cylinder.", "test_list": ["assert perimeter(2,4) == 12", "assert perimeter(1,2) == 6", "assert perimeter(3,1) == 8"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_112", "n_instr": 15} {"i": 351, "src_path": "src/00351.py", "pyc_path": "pyc/00351.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_integer\n RETURN_CONST None\nEND\nCODE check_integer(text)\n MAKE_CELL text\n RESUME 0\n LOAD_DEREF text\n LOAD_ATTR NULL|self + strip\n CALL 0\n STORE_DEREF text\n LOAD_GLOBAL NULL + len\n LOAD_DEREF text\n CALL 1\n LOAD_CONST 1\n COMPARE_OP <\n POP_JUMP_IF_FALSE L1\n RETURN_CONST None\nL1:\n LOAD_GLOBAL NULL + all\n LOAD_CLOSURE text\n BUILD_TUPLE 1\n LOAD_CONST .>\n MAKE_FUNCTION closure\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_DEREF text\n CALL 1\n CALL 1\n GET_ITER\n CALL 0\n CALL 1\n POP_JUMP_IF_FALSE L2\n RETURN_CONST True\nL2:\n LOAD_DEREF text\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_CONST '+-'\n CONTAINS_OP 0\n POP_JUMP_IF_FALSE L3\n LOAD_GLOBAL NULL + all\n LOAD_CLOSURE text\n BUILD_TUPLE 1\n LOAD_CONST .>\n MAKE_FUNCTION closure\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_GLOBAL NULL + len\n LOAD_DEREF text\n CALL 1\n CALL 2\n GET_ITER\n CALL 0\n CALL 1\n POP_JUMP_IF_FALSE L3\n RETURN_CONST True\nL3:\n RETURN_CONST False\nEND\nCODE check_integer..(.0)\n DOC '0123456789'\n COPY_FREE_VARS 1\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_DEREF text\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST '0123456789'\n CONTAINS_OP 0\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND\nCODE check_integer..(.0)\n DOC '0123456789'\n COPY_FREE_VARS 1\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_DEREF text\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST '0123456789'\n CONTAINS_OP 0\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def check_integer(text):\n text = text.strip()\n if len(text) < 1:\n return None\n elif all((text[i] in '0123456789' for i in range(len(text)))):\n return True\n elif text[0] in '+-' and all((text[i] in '0123456789' for i in range(1, len(text)))):\n return True\n else:\n return False", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 113, "mbpp_split": "test", "prompt": "Write a function to check if a string represents an integer or not.", "test_list": ["assert check_integer(\"python\")==False", "assert check_integer(\"1\")==True", "assert check_integer(\"12345\")==True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_113", "n_instr": 118} {"i": 352, "src_path": "src/00352.py", "pyc_path": "pyc/00352.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('Counter',)\n IMPORT_NAME collections\n IMPORT_FROM Counter\n STORE_NAME Counter\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME assign_freq\n RETURN_CONST None\nEND\nCODE assign_freq(test_list)\n RESUME 0\n LOAD_GLOBAL NULL + Counter\n LOAD_FAST test_list\n CALL 1\n LOAD_ATTR NULL|self + items\n CALL 0\n GET_ITER\n LOAD_FAST_AND_CLEAR key\n LOAD_FAST_AND_CLEAR val\n SWAP 3\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n UNPACK_SEQUENCE 2\n STORE_FAST key\n STORE_FAST val\n BUILD_LIST 0\n LOAD_FAST key\n LIST_EXTEND 1\n LOAD_FAST val\n LIST_APPEND 1\n CALL_INTRINSIC_1 INTRINSIC_LIST_TO_TUPLE\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST res\n STORE_FAST key\n STORE_FAST val\n LOAD_GLOBAL NULL + str\n LOAD_FAST res\n CALL 1\n RETURN_VALUE\nL5:\n SWAP 2\n POP_TOP\n SWAP 3\n STORE_FAST val\n STORE_FAST key\n RERAISE 0\n EXC try=L1..L4 -> handler=L5 depth=3 lasti=False\nEND", "expected": "from collections import Counter\n\ndef assign_freq(test_list):\n res = [(*key, val) for key, val in Counter(test_list).items()]\n return str(res)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 114, "mbpp_split": "test", "prompt": "Write a function to assign frequency to each tuple in the given tuple list.", "test_list": ["assert assign_freq([(6, 5, 8), (2, 7), (6, 5, 8), (6, 5, 8), (9, ), (2, 7)] ) == '[(6, 5, 8, 3), (2, 7, 2), (9, 1)]'", "assert assign_freq([(4, 2, 4), (7, 1), (4, 8), (4, 2, 4), (9, 2), (7, 1)] ) == '[(4, 2, 4, 2), (7, 1, 2), (4, 8, 1), (9, 2, 1)]'", "assert assign_freq([(11, 13, 10), (17, 21), (4, 2, 3), (17, 21), (9, 2), (4, 2, 3)] ) == '[(11, 13, 10, 1), (17, 21, 2), (4, 2, 3, 2), (9, 2, 1)]'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_114", "n_instr": 58} {"i": 353, "src_path": "src/00353.py", "pyc_path": "pyc/00353.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME empty_dit\n RETURN_CONST None\nEND\nCODE empty_dit(list1)\n RESUME 0\n LOAD_GLOBAL NULL + all\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST list1\n GET_ITER\n CALL 0\n CALL 1\n STORE_FAST empty_dit\n LOAD_FAST empty_dit\n RETURN_VALUE\nEND\nCODE empty_dit..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L3\n STORE_FAST d\n LOAD_FAST d\n UNARY_NOT\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n END_FOR\n RETURN_CONST None\nL4:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L4 -> handler=L4 depth=0 lasti=True\nEND", "expected": "def empty_dit(list1):\n empty_dit = all((not d for d in list1))\n return empty_dit", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 115, "mbpp_split": "test", "prompt": "Write a function to check whether all dictionaries in a list are empty or not.", "test_list": ["assert empty_dit([{},{},{}])==True", "assert empty_dit([{1,2},{},{}])==False", "assert empty_dit({})==True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_115", "n_instr": 42} {"i": 354, "src_path": "src/00354.py", "pyc_path": "pyc/00354.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME tuple_to_int\n RETURN_CONST None\nEND\nCODE tuple_to_int(nums)\n RESUME 0\n LOAD_GLOBAL NULL + int\n LOAD_CONST ''\n LOAD_ATTR NULL|self + join\n LOAD_GLOBAL NULL + map\n LOAD_GLOBAL str\n LOAD_FAST nums\n CALL 2\n CALL 1\n CALL 1\n STORE_FAST result\n LOAD_FAST result\n RETURN_VALUE\nEND", "expected": "def tuple_to_int(nums):\n result = int(''.join(map(str, nums)))\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 116, "mbpp_split": "test", "prompt": "Write a function to convert a given tuple of positive integers into an integer.", "test_list": ["assert tuple_to_int((1,2,3))==123", "assert tuple_to_int((4,5,6))==456", "assert tuple_to_int((5,6,7))==567"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_116", "n_instr": 21} {"i": 355, "src_path": "src/00355.py", "pyc_path": "pyc/00355.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME list_to_float\n RETURN_CONST None\nEND\nCODE list_to_float(test_list)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST res\n LOAD_FAST test_list\n GET_ITER\nL1:\n FOR_ITER L5\n STORE_FAST tup\n BUILD_LIST 0\n STORE_FAST temp\n LOAD_FAST tup\n GET_ITER\nL2:\n FOR_ITER L4\n STORE_FAST ele\n LOAD_FAST ele\n LOAD_ATTR NULL|self + isalpha\n CALL 0\n POP_JUMP_IF_FALSE L3\n LOAD_FAST temp\n LOAD_ATTR NULL|self + append\n LOAD_FAST ele\n CALL 1\n POP_TOP\n JUMP_BACKWARD L2\nL3:\n LOAD_FAST temp\n LOAD_ATTR NULL|self + append\n LOAD_GLOBAL NULL + float\n LOAD_FAST ele\n CALL 1\n CALL 1\n POP_TOP\n JUMP_BACKWARD L2\nL4:\n END_FOR\n LOAD_FAST res\n LOAD_ATTR NULL|self + append\n LOAD_FAST temp\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST temp\n LOAD_CONST 1\n BINARY_SUBSCR\n BUILD_TUPLE 2\n CALL 1\n POP_TOP\n JUMP_BACKWARD L1\nL5:\n END_FOR\n LOAD_GLOBAL NULL + str\n LOAD_FAST res\n CALL 1\n RETURN_VALUE\nEND", "expected": "def list_to_float(test_list):\n res = []\n for tup in test_list:\n temp = []\n for ele in tup:\n if ele.isalpha():\n temp.append(ele)\n else:\n temp.append(float(ele))\n res.append((temp[0], temp[1]))\n return str(res)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 117, "mbpp_split": "test", "prompt": "Write a function to convert all possible convertible elements in the list to float.", "test_list": ["assert list_to_float( [(\"3\", \"4\"), (\"1\", \"26.45\"), (\"7.32\", \"8\"), (\"4\", \"8\")] ) == '[(3.0, 4.0), (1.0, 26.45), (7.32, 8.0), (4.0, 8.0)]'", "assert list_to_float( [(\"4\", \"4\"), (\"2\", \"27\"), (\"4.12\", \"9\"), (\"7\", \"11\")] ) == '[(4.0, 4.0), (2.0, 27.0), (4.12, 9.0), (7.0, 11.0)]'", "assert list_to_float( [(\"6\", \"78\"), (\"5\", \"26.45\"), (\"1.33\", \"4\"), (\"82\", \"13\")] ) == '[(6.0, 78.0), (5.0, 26.45), (1.33, 4.0), (82.0, 13.0)]'"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_117", "n_instr": 62} {"i": 356, "src_path": "src/00356.py", "pyc_path": "pyc/00356.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME search\n RETURN_CONST None\nEND\nCODE search(arr, n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST XOR\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST XOR\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_OP ^\n STORE_FAST XOR\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST XOR\n RETURN_VALUE\nEND", "expected": "def search(arr, n):\n XOR = 0\n for i in range(n):\n XOR = XOR ^ arr[i]\n return XOR", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 119, "mbpp_split": "test", "prompt": "Write a python function to find the element that appears only once in a sorted array.", "test_list": ["assert search([1,1,2,2,3],5) == 3", "assert search([1,1,3,3,4,4,5,5,7,7,8],11) == 8", "assert search([1,2,2,3,3,4,4],7) == 1"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_119", "n_instr": 29} {"i": 357, "src_path": "src/00357.py", "pyc_path": "pyc/00357.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_triplet\n RETURN_CONST None\nEND\nCODE check_triplet(A, n, sum, count)\n RESUME 0\n LOAD_FAST count\n LOAD_CONST 3\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n LOAD_FAST sum\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST True\nL1:\n LOAD_FAST count\n LOAD_CONST 3\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n LOAD_FAST n\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n LOAD_FAST sum\n LOAD_CONST 0\n COMPARE_OP <\n POP_JUMP_IF_FALSE L3\nL2:\n RETURN_CONST False\nL3:\n LOAD_GLOBAL NULL + check_triplet\n LOAD_FAST A\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n LOAD_FAST sum\n LOAD_FAST A\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n BINARY_OP -\n LOAD_FAST count\n LOAD_CONST 1\n BINARY_OP +\n CALL 4\n COPY 1\n POP_JUMP_IF_TRUE L4\n POP_TOP\n LOAD_GLOBAL NULL + check_triplet\n LOAD_FAST A\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n LOAD_FAST sum\n LOAD_FAST count\n CALL 4\nL4:\n RETURN_VALUE\nEND", "expected": "def check_triplet(A, n, sum, count):\n if count == 3 and sum == 0:\n return True\n if count == 3 or n == 0 or sum < 0:\n return False\n return check_triplet(A, n - 1, sum - A[n - 1], count + 1) or check_triplet(A, n - 1, sum, count)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 121, "mbpp_split": "test", "prompt": "Write a function to find the triplet with sum of the given array", "test_list": ["assert check_triplet([2, 7, 4, 0, 9, 5, 1, 3], 8, 6, 0) == True", "assert check_triplet([1, 4, 5, 6, 7, 8, 5, 9], 8, 6, 0) == False", "assert check_triplet([10, 4, 2, 3, 5], 5, 15, 0) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_121", "n_instr": 63} {"i": 358, "src_path": "src/00358.py", "pyc_path": "pyc/00358.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 3000\n STORE_NAME MAX\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME smartNumber\n RETURN_CONST None\nEND\nCODE smartNumber(n)\n RESUME 0\n LOAD_CONST 0\n BUILD_LIST 1\n LOAD_GLOBAL MAX\n BINARY_OP *\n STORE_FAST primes\n BUILD_LIST 0\n STORE_FAST result\n LOAD_GLOBAL NULL + range\n LOAD_CONST 2\n LOAD_GLOBAL MAX\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L6\n STORE_FAST i\n LOAD_FAST primes\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_CONST 1\n LOAD_FAST primes\n LOAD_FAST i\n STORE_SUBSCR\n LOAD_FAST i\n LOAD_CONST 2\n BINARY_OP *\n STORE_FAST j\n LOAD_FAST j\n LOAD_GLOBAL MAX\n COMPARE_OP <\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L1\nL3:\n LOAD_FAST primes\n LOAD_FAST j\n COPY 2\n COPY 2\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP -=\n SWAP 3\n SWAP 2\n STORE_SUBSCR\n LOAD_FAST primes\n LOAD_FAST j\n BINARY_SUBSCR\n LOAD_CONST 3\n BINARY_OP +\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L4\n LOAD_FAST result\n LOAD_ATTR NULL|self + append\n LOAD_FAST j\n CALL 1\n POP_TOP\nL4:\n LOAD_FAST j\n LOAD_FAST i\n BINARY_OP +\n STORE_FAST j\n LOAD_FAST j\n LOAD_GLOBAL MAX\n COMPARE_OP <\n POP_JUMP_IF_FALSE L5\n JUMP_BACKWARD L3\nL5:\n JUMP_BACKWARD L1\nL6:\n END_FOR\n LOAD_FAST result\n LOAD_ATTR NULL|self + sort\n CALL 0\n POP_TOP\n LOAD_FAST result\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n BINARY_SUBSCR\n RETURN_VALUE\nEND", "expected": "MAX = 3000\n\ndef smartNumber(n):\n primes = [0] * MAX\n result = []\n for i in range(2, MAX):\n if primes[i] == 0:\n primes[i] = 1\n j = i * 2\n while j < MAX:\n primes[j] -= 1\n if primes[j] + 3 == 0:\n result.append(j)\n j = j + i\n result.sort()\n return result[n - 1]", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 122, "mbpp_split": "test", "prompt": "Write a function to find n\u2019th smart number.", "test_list": ["assert smartNumber(1) == 30", "assert smartNumber(50) == 273", "assert smartNumber(1000) == 2664"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_122", "n_instr": 95} {"i": 359, "src_path": "src/00359.py", "pyc_path": "pyc/00359.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME amicable_numbers_sum\n RETURN_CONST None\nEND\nCODE amicable_numbers_sum(limit)\n RESUME 0\n LOAD_GLOBAL NULL + isinstance\n LOAD_FAST limit\n LOAD_GLOBAL int\n CALL 2\n POP_JUMP_IF_TRUE L1\n RETURN_CONST 'Input is not an integer!'\nL1:\n LOAD_FAST limit\n LOAD_CONST 1\n COMPARE_OP <\n POP_JUMP_IF_FALSE L2\n RETURN_CONST 'Input must be bigger than 0!'\nL2:\n LOAD_GLOBAL NULL + set\n CALL 0\n STORE_FAST amicables\n LOAD_GLOBAL NULL + range\n LOAD_CONST 2\n LOAD_FAST limit\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n GET_ITER\nL3:\n FOR_ITER L19\n STORE_FAST num\n LOAD_FAST num\n LOAD_FAST amicables\n CONTAINS_OP 0\n POP_JUMP_IF_FALSE L4\n JUMP_BACKWARD L3\nL4:\n LOAD_GLOBAL NULL + sum\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST num\n CALL 2\n GET_ITER\n LOAD_FAST_AND_CLEAR fact\n SWAP 2\nL5:\n BUILD_LIST 0\n SWAP 2\nL6:\n FOR_ITER L9\n STORE_FAST fact\n LOAD_FAST num\n LOAD_FAST fact\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L8\nL7:\n JUMP_BACKWARD L6\nL8:\n LOAD_FAST fact\n LIST_APPEND 2\n JUMP_BACKWARD L6\nL9:\n END_FOR\nL10:\n SWAP 2\n STORE_FAST fact\n CALL 1\n STORE_FAST sum_fact\n LOAD_GLOBAL NULL + sum\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_FAST sum_fact\n CALL 2\n GET_ITER\n LOAD_FAST_AND_CLEAR fact\n SWAP 2\nL11:\n BUILD_LIST 0\n SWAP 2\nL12:\n FOR_ITER L15\n STORE_FAST fact\n LOAD_FAST sum_fact\n LOAD_FAST fact\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L14\nL13:\n JUMP_BACKWARD L12\nL14:\n LOAD_FAST fact\n LIST_APPEND 2\n JUMP_BACKWARD L12\nL15:\n END_FOR\nL16:\n SWAP 2\n STORE_FAST fact\n CALL 1\n STORE_FAST sum_fact2\n LOAD_FAST num\n LOAD_FAST sum_fact2\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L17\n JUMP_BACKWARD L3\nL17:\n LOAD_FAST num\n LOAD_FAST sum_fact\n COMPARE_OP !=\n POP_JUMP_IF_TRUE L18\n JUMP_BACKWARD L3\nL18:\n LOAD_FAST amicables\n LOAD_ATTR NULL|self + add\n LOAD_FAST num\n CALL 1\n POP_TOP\n LOAD_FAST amicables\n LOAD_ATTR NULL|self + add\n LOAD_FAST sum_fact2\n CALL 1\n POP_TOP\n JUMP_BACKWARD L3\nL19:\n END_FOR\n LOAD_GLOBAL NULL + sum\n LOAD_FAST amicables\n CALL 1\n RETURN_VALUE\nL20:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST fact\n RERAISE 0\nL21:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST fact\n RERAISE 0\n EXC try=L5..L7 -> handler=L20 depth=5 lasti=False\n EXC try=L8..L10 -> handler=L20 depth=5 lasti=False\n EXC try=L11..L13 -> handler=L21 depth=5 lasti=False\n EXC try=L14..L16 -> handler=L21 depth=5 lasti=False\nEND", "expected": "def amicable_numbers_sum(limit):\n if not isinstance(limit, int):\n return 'Input is not an integer!'\n if limit < 1:\n return 'Input must be bigger than 0!'\n amicables = set()\n for num in range(2, limit + 1):\n if num in amicables:\n continue\n sum_fact = sum([fact for fact in range(1, num) if num % fact == 0])\n sum_fact2 = sum([fact for fact in range(1, sum_fact) if sum_fact % fact == 0])\n if num == sum_fact2 and num != sum_fact:\n amicables.add(num)\n amicables.add(sum_fact2)\n return sum(amicables)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 123, "mbpp_split": "test", "prompt": "Write a function to sum all amicable numbers from 1 to a specified number.", "test_list": ["assert amicable_numbers_sum(999)==504", "assert amicable_numbers_sum(9999)==31626", "assert amicable_numbers_sum(99)==0"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_123", "n_instr": 152} {"i": 360, "src_path": "src/00360.py", "pyc_path": "pyc/00360.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST None\n IMPORT_NAME cmath\n STORE_NAME cmath\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME angle_complex\n RETURN_CONST None\nEND\nCODE angle_complex(a, b)\n RESUME 0\n LOAD_GLOBAL NULL + complex\n LOAD_FAST a\n LOAD_FAST b\n CALL 2\n STORE_FAST cn\n LOAD_GLOBAL NULL + cmath\n LOAD_ATTR phase\n LOAD_FAST a\n LOAD_FAST b\n BINARY_OP +\n CALL 1\n STORE_FAST angle\n LOAD_FAST angle\n RETURN_VALUE\nEND", "expected": "import cmath\n\ndef angle_complex(a, b):\n cn = complex(a, b)\n angle = cmath.phase(a + b)\n return angle", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 124, "mbpp_split": "test", "prompt": "Write a function to get the angle of a complex number.", "test_list": ["assert angle_complex(0,1j)==1.5707963267948966 ", "assert angle_complex(2,1j)==0.4636476090008061", "assert angle_complex(0,2j)==1.5707963267948966"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_124", "n_instr": 27} {"i": 361, "src_path": "src/00361.py", "pyc_path": "pyc/00361.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_length\n RETURN_CONST None\nEND\nCODE find_length(string, n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST current_sum\n LOAD_CONST 0\n STORE_FAST max_sum\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L5\n STORE_FAST i\n LOAD_FAST current_sum\n LOAD_FAST string\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_CONST '0'\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_CONST 1\n JUMP_FORWARD L3\nL2:\n LOAD_CONST -1\nL3:\n BINARY_OP +=\n STORE_FAST current_sum\n LOAD_FAST current_sum\n LOAD_CONST 0\n COMPARE_OP <\n POP_JUMP_IF_FALSE L4\n LOAD_CONST 0\n STORE_FAST current_sum\nL4:\n LOAD_GLOBAL NULL + max\n LOAD_FAST current_sum\n LOAD_FAST max_sum\n CALL 2\n STORE_FAST max_sum\n JUMP_BACKWARD L1\nL5:\n END_FOR\n LOAD_FAST max_sum\n POP_JUMP_IF_FALSE L6\n LOAD_FAST max_sum\n RETURN_VALUE\nL6:\n LOAD_CONST 0\n RETURN_VALUE\nEND", "expected": "def find_length(string, n):\n current_sum = 0\n max_sum = 0\n for i in range(n):\n current_sum += 1 if string[i] == '0' else -1\n if current_sum < 0:\n current_sum = 0\n max_sum = max(current_sum, max_sum)\n return max_sum if max_sum else 0", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 125, "mbpp_split": "test", "prompt": "Write a function to find the maximum difference between the number of 0s and number of 1s in any sub-string of the given binary string.", "test_list": ["assert find_length(\"11000010001\", 11) == 6", "assert find_length(\"10111\", 5) == 1", "assert find_length(\"11011101100101\", 14) == 2 "], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_125", "n_instr": 56} {"i": 362, "src_path": "src/00362.py", "pyc_path": "pyc/00362.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum\n RETURN_CONST None\nEND\nCODE sum(a, b)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST sum\n LOAD_GLOBAL NULL + range\n LOAD_CONST 1\n LOAD_GLOBAL NULL + min\n LOAD_FAST a\n LOAD_FAST b\n CALL 2\n CALL 2\n GET_ITER\nL1:\n FOR_ITER L4\n STORE_FAST i\n LOAD_FAST a\n LOAD_FAST i\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST b\n LOAD_FAST i\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L1\nL3:\n LOAD_FAST sum\n LOAD_FAST i\n BINARY_OP +=\n STORE_FAST sum\n JUMP_BACKWARD L1\nL4:\n END_FOR\n LOAD_FAST sum\n RETURN_VALUE\nEND", "expected": "def sum(a, b):\n sum = 0\n for i in range(1, min(a, b)):\n if a % i == 0 and b % i == 0:\n sum += i\n return sum", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 126, "mbpp_split": "test", "prompt": "Write a python function to find the sum of common divisors of two given numbers.", "test_list": ["assert sum(10,15) == 6", "assert sum(100,150) == 93", "assert sum(4,6) == 3"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_126", "n_instr": 47} {"i": 363, "src_path": "src/00363.py", "pyc_path": "pyc/00363.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME multiply_int\n RETURN_CONST None\nEND\nCODE multiply_int(x, y)\n RESUME 0\n LOAD_FAST y\n LOAD_CONST 0\n COMPARE_OP <\n POP_JUMP_IF_FALSE L1\n LOAD_GLOBAL NULL + multiply_int\n LOAD_FAST x\n LOAD_FAST y\n UNARY_NEGATIVE\n CALL 2\n UNARY_NEGATIVE\n RETURN_VALUE\nL1:\n LOAD_FAST y\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n RETURN_CONST 0\nL2:\n LOAD_FAST y\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n LOAD_FAST x\n RETURN_VALUE\nL3:\n LOAD_FAST x\n LOAD_GLOBAL NULL + multiply_int\n LOAD_FAST x\n LOAD_FAST y\n LOAD_CONST 1\n BINARY_OP -\n CALL 2\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def multiply_int(x, y):\n if y < 0:\n return -multiply_int(x, -y)\n elif y == 0:\n return 0\n elif y == 1:\n return x\n else:\n return x + multiply_int(x, y - 1)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 127, "mbpp_split": "test", "prompt": "Write a function to multiply two integers without using the * operator in python.", "test_list": ["assert multiply_int(10,20)==200", "assert multiply_int(5,10)==50", "assert multiply_int(4,8)==32"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_127", "n_instr": 43} {"i": 364, "src_path": "src/00364.py", "pyc_path": "pyc/00364.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('defaultdict',)\n IMPORT_NAME collections\n IMPORT_FROM defaultdict\n STORE_NAME defaultdict\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME max_occurrences\n RETURN_CONST None\nEND\nCODE max_occurrences(nums)\n RESUME 0\n LOAD_GLOBAL NULL + defaultdict\n LOAD_GLOBAL int\n CALL 1\n STORE_FAST dict\n LOAD_FAST nums\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST dict\n LOAD_FAST i\n COPY 2\n COPY 2\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +=\n SWAP 3\n SWAP 2\n STORE_SUBSCR\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_GLOBAL NULL + max\n LOAD_FAST dict\n LOAD_ATTR NULL|self + items\n CALL 0\n LOAD_CONST .>\n MAKE_FUNCTION 0\n KW_NAMES ('key',)\n CALL 2\n STORE_FAST result\n LOAD_FAST result\n RETURN_VALUE\nEND\nCODE max_occurrences..(x)\n RESUME 0\n LOAD_FAST x\n LOAD_CONST 1\n BINARY_SUBSCR\n RETURN_VALUE\nEND", "expected": "from collections import defaultdict\n\ndef max_occurrences(nums):\n dict = defaultdict(int)\n for i in nums:\n dict[i] += 1\n result = max(dict.items(), key=lambda x: x[1])\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 130, "mbpp_split": "test", "prompt": "Write a function to find the item with maximum frequency in a given list.", "test_list": ["assert max_occurrences([2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,2,4,6,9,1,2])==(2, 5)", "assert max_occurrences([2,3,8,4,7,9,8,7,9,15,14,10,12,13,16,16,18])==(8, 2)", "assert max_occurrences([10,20,20,30,40,90,80,50,30,20,50,10])==(20, 3)"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_130", "n_instr": 55} {"i": 365, "src_path": "src/00365.py", "pyc_path": "pyc/00365.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME reverse_vowels\n RETURN_CONST None\nEND\nCODE reverse_vowels(str1)\n RESUME 0\n LOAD_CONST ''\n STORE_FAST vowels\n LOAD_FAST str1\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST char\n LOAD_FAST char\n LOAD_CONST 'aeiouAEIOU'\n CONTAINS_OP 0\n POP_JUMP_IF_TRUE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST vowels\n LOAD_FAST char\n BINARY_OP +=\n STORE_FAST vowels\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_CONST ''\n STORE_FAST result_string\n LOAD_FAST str1\n GET_ITER\nL4:\n FOR_ITER L6\n STORE_FAST char\n LOAD_FAST char\n LOAD_CONST 'aeiouAEIOU'\n CONTAINS_OP 0\n POP_JUMP_IF_FALSE L5\n LOAD_FAST result_string\n LOAD_FAST vowels\n LOAD_CONST -1\n BINARY_SUBSCR\n BINARY_OP +=\n STORE_FAST result_string\n LOAD_FAST vowels\n LOAD_CONST None\n LOAD_CONST -1\n BINARY_SLICE\n STORE_FAST vowels\n JUMP_BACKWARD L4\nL5:\n LOAD_FAST result_string\n LOAD_FAST char\n BINARY_OP +=\n STORE_FAST result_string\n JUMP_BACKWARD L4\nL6:\n END_FOR\n LOAD_FAST result_string\n RETURN_VALUE\nEND", "expected": "def reverse_vowels(str1):\n vowels = ''\n for char in str1:\n if char in 'aeiouAEIOU':\n vowels += char\n result_string = ''\n for char in str1:\n if char in 'aeiouAEIOU':\n result_string += vowels[-1]\n vowels = vowels[:-1]\n else:\n result_string += char\n return result_string", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 131, "mbpp_split": "test", "prompt": "Write a python function to reverse only the vowels of a given string.", "test_list": ["assert reverse_vowels(\"Python\") == \"Python\"", "assert reverse_vowels(\"USA\") == \"ASU\"", "assert reverse_vowels(\"ab\") == \"ab\""], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_131", "n_instr": 62} {"i": 366, "src_path": "src/00366.py", "pyc_path": "pyc/00366.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_negativenum\n RETURN_CONST None\nEND\nCODE sum_negativenum(nums)\n RESUME 0\n LOAD_GLOBAL NULL + list\n LOAD_GLOBAL NULL + filter\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_FAST nums\n CALL 2\n CALL 1\n STORE_FAST sum_negativenum\n LOAD_GLOBAL NULL + sum\n LOAD_FAST sum_negativenum\n CALL 1\n RETURN_VALUE\nEND\nCODE sum_negativenum..(nums)\n RESUME 0\n LOAD_FAST nums\n LOAD_CONST 0\n COMPARE_OP <\n RETURN_VALUE\nEND", "expected": "def sum_negativenum(nums):\n sum_negativenum = list(filter(lambda nums: nums < 0, nums))\n return sum(sum_negativenum)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 133, "mbpp_split": "test", "prompt": "Write a function to calculate the sum of the negative numbers of a given list of numbers using lambda function.", "test_list": ["assert sum_negativenum([2, 4, -6, -9, 11, -12, 14, -5, 17])==-32", "assert sum_negativenum([10,15,-14,13,-18,12,-20])==-52", "assert sum_negativenum([19, -65, 57, 39, 152,-639, 121, 44, 90, -190])==-894"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_133", "n_instr": 28} {"i": 367, "src_path": "src/00367.py", "pyc_path": "pyc/00367.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME check_last\n RETURN_CONST None\nEND\nCODE check_last(arr, n, p)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST _sum\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST _sum\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_OP +\n STORE_FAST _sum\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST p\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L4\n LOAD_FAST _sum\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L3\n RETURN_CONST 'ODD'\nL3:\n RETURN_CONST 'EVEN'\nL4:\n RETURN_CONST 'EVEN'\nEND", "expected": "def check_last(arr, n, p):\n _sum = 0\n for i in range(n):\n _sum = _sum + arr[i]\n if p == 1:\n if _sum % 2 == 0:\n return 'ODD'\n else:\n return 'EVEN'\n return 'EVEN'", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 134, "mbpp_split": "test", "prompt": "Write a python function to check whether the last element of given array is even or odd after performing an operation p times.", "test_list": ["assert check_last([5,7,10],3,1) == \"ODD\"", "assert check_last([2,3],2,3) == \"EVEN\"", "assert check_last([1,2,3],3,1) == \"ODD\""], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_134", "n_instr": 42} {"i": 368, "src_path": "src/00368.py", "pyc_path": "pyc/00368.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME hexagonal_num\n RETURN_CONST None\nEND\nCODE hexagonal_num(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 2\n LOAD_FAST n\n BINARY_OP *\n LOAD_CONST 1\n BINARY_OP -\n BINARY_OP *\n RETURN_VALUE\nEND", "expected": "def hexagonal_num(n):\n return n * (2 * n - 1)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 135, "mbpp_split": "test", "prompt": "Write a function to find the nth hexagonal number.", "test_list": ["assert hexagonal_num(10) == 190", "assert hexagonal_num(5) == 45", "assert hexagonal_num(7) == 91"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_135", "n_instr": 17} {"i": 369, "src_path": "src/00369.py", "pyc_path": "pyc/00369.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME cal_electbill\n RETURN_CONST None\nEND\nCODE cal_electbill(units)\n RESUME 0\n LOAD_FAST units\n LOAD_CONST 50\n COMPARE_OP <\n POP_JUMP_IF_FALSE L1\n LOAD_FAST units\n LOAD_CONST 2.6\n BINARY_OP *\n STORE_FAST amount\n LOAD_CONST 25\n STORE_FAST surcharge\n JUMP_FORWARD L4\nL1:\n LOAD_FAST units\n LOAD_CONST 100\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L2\n LOAD_CONST 130\n LOAD_FAST units\n LOAD_CONST 50\n BINARY_OP -\n LOAD_CONST 3.25\n BINARY_OP *\n BINARY_OP +\n STORE_FAST amount\n LOAD_CONST 35\n STORE_FAST surcharge\n JUMP_FORWARD L4\nL2:\n LOAD_FAST units\n LOAD_CONST 200\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L3\n LOAD_CONST 292.5\n LOAD_FAST units\n LOAD_CONST 100\n BINARY_OP -\n LOAD_CONST 5.26\n BINARY_OP *\n BINARY_OP +\n STORE_FAST amount\n LOAD_CONST 45\n STORE_FAST surcharge\n JUMP_FORWARD L4\nL3:\n LOAD_CONST 818.5\n LOAD_FAST units\n LOAD_CONST 200\n BINARY_OP -\n LOAD_CONST 8.45\n BINARY_OP *\n BINARY_OP +\n STORE_FAST amount\n LOAD_CONST 75\n STORE_FAST surcharge\nL4:\n LOAD_FAST amount\n LOAD_FAST surcharge\n BINARY_OP +\n STORE_FAST total\n LOAD_FAST total\n RETURN_VALUE\nEND", "expected": "def cal_electbill(units):\n if units < 50:\n amount = units * 2.6\n surcharge = 25\n elif units <= 100:\n amount = 130 + (units - 50) * 3.25\n surcharge = 35\n elif units <= 200:\n amount = 130 + 162.5 + (units - 100) * 5.26\n surcharge = 45\n else:\n amount = 130 + 162.5 + 526 + (units - 200) * 8.45\n surcharge = 75\n total = amount + surcharge\n return total", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 136, "mbpp_split": "test", "prompt": "Write a function to calculate electricity bill.", "test_list": ["assert cal_electbill(75)==246.25", "assert cal_electbill(265)==1442.75", "assert cal_electbill(100)==327.5"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_136", "n_instr": 70} {"i": 370, "src_path": "src/00370.py", "pyc_path": "pyc/00370.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST 0\n LOAD_CONST ('array',)\n IMPORT_NAME array\n IMPORT_FROM array\n STORE_NAME array\n POP_TOP\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME zero_count\n RETURN_CONST None\nEND\nCODE zero_count(nums)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST nums\n CALL 1\n STORE_FAST n\n LOAD_CONST 0\n STORE_FAST n1\n LOAD_FAST nums\n GET_ITER\nL1:\n FOR_ITER L3\n STORE_FAST x\n LOAD_FAST x\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\n LOAD_FAST n1\n LOAD_CONST 1\n BINARY_OP +=\n STORE_FAST n1\n JUMP_BACKWARD L1\nL2:\n JUMP_BACKWARD L1\nL3:\n END_FOR\n LOAD_GLOBAL NULL + round\n LOAD_FAST n1\n LOAD_FAST n\n BINARY_OP /\n LOAD_CONST 2\n CALL 2\n RETURN_VALUE\nEND", "expected": "from array import array\n\ndef zero_count(nums):\n n = len(nums)\n n1 = 0\n for x in nums:\n if x == 0:\n n1 += 1\n else:\n None\n return round(n1 / n, 2)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 137, "mbpp_split": "test", "prompt": "Write a function to find the ration of zeroes in an array of integers.", "test_list": ["assert zero_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8])==0.15", "assert zero_count([2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8])==0.00", "assert zero_count([2, 4, -6, -9, 11, -12, 14, -5, 17])==0.00"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_137", "n_instr": 46} {"i": 371, "src_path": "src/00371.py", "pyc_path": "pyc/00371.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_Sum_Of_Powers_Of_Two\n RETURN_CONST None\nEND\nCODE is_Sum_Of_Powers_Of_Two(n)\n RESUME 0\n LOAD_FAST n\n LOAD_CONST 2\n BINARY_OP %\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L1\n RETURN_CONST False\nL1:\n RETURN_CONST True\nEND", "expected": "def is_Sum_Of_Powers_Of_Two(n):\n if n % 2 == 1:\n return False\n else:\n return True", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 138, "mbpp_split": "test", "prompt": "Write a python function to check whether the given number can be represented as sum of non-zero powers of 2 or not.", "test_list": ["assert is_Sum_Of_Powers_Of_Two(10) == True", "assert is_Sum_Of_Powers_Of_Two(7) == False", "assert is_Sum_Of_Powers_Of_Two(14) == True"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_138", "n_instr": 18} {"i": 372, "src_path": "src/00372.py", "pyc_path": "pyc/00372.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME circle_circumference\n RETURN_CONST None\nEND\nCODE circle_circumference(r)\n RESUME 0\n LOAD_CONST 6.283\n LOAD_FAST r\n BINARY_OP *\n STORE_FAST perimeter\n LOAD_FAST perimeter\n RETURN_VALUE\nEND", "expected": "def circle_circumference(r):\n perimeter = 2 * 3.1415 * r\n return perimeter", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 139, "mbpp_split": "test", "prompt": "Write a function to find the circumference of a circle.", "test_list": ["assert circle_circumference(10)==62.830000000000005", "assert circle_circumference(5)==31.415000000000003", "assert circle_circumference(4)==25.132"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_139", "n_instr": 15} {"i": 373, "src_path": "src/00373.py", "pyc_path": "pyc/00373.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME extract_singly\n RETURN_CONST None\nEND\nCODE extract_singly(test_list)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST res\n LOAD_GLOBAL NULL + set\n CALL 0\n STORE_FAST temp\n LOAD_FAST test_list\n GET_ITER\nL1:\n FOR_ITER L5\n STORE_FAST inner\n LOAD_FAST inner\n GET_ITER\nL2:\n FOR_ITER L4\n STORE_FAST ele\n LOAD_FAST ele\n LOAD_FAST temp\n CONTAINS_OP 1\n POP_JUMP_IF_TRUE L3\n JUMP_BACKWARD L2\nL3:\n LOAD_FAST temp\n LOAD_ATTR NULL|self + add\n LOAD_FAST ele\n CALL 1\n POP_TOP\n LOAD_FAST res\n LOAD_ATTR NULL|self + append\n LOAD_FAST ele\n CALL 1\n POP_TOP\n JUMP_BACKWARD L2\nL4:\n END_FOR\n JUMP_BACKWARD L1\nL5:\n END_FOR\n LOAD_FAST res\n RETURN_VALUE\nEND", "expected": "def extract_singly(test_list):\n res = []\n temp = set()\n for inner in test_list:\n for ele in inner:\n if not ele in temp:\n temp.add(ele)\n res.append(ele)\n return res", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 140, "mbpp_split": "test", "prompt": "Write a function to extract elements that occur singly in the given tuple list.", "test_list": ["assert extract_singly([(3, 4, 5), (4, 5, 7), (1, 4)]) == [3, 4, 5, 7, 1]", "assert extract_singly([(1, 2, 3), (4, 2, 3), (7, 8)]) == [1, 2, 3, 4, 7, 8]", "assert extract_singly([(7, 8, 9), (10, 11, 12), (10, 11)]) == [7, 8, 9, 10, 11, 12]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_140", "n_instr": 48} {"i": 374, "src_path": "src/00374.py", "pyc_path": "pyc/00374.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME pancake_sort\n RETURN_CONST None\nEND\nCODE pancake_sort(nums)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST nums\n CALL 1\n STORE_FAST arr_len\n LOAD_FAST arr_len\n LOAD_CONST 1\n COMPARE_OP >\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_FAST nums\n LOAD_ATTR NULL|self + index\n LOAD_GLOBAL NULL + max\n LOAD_FAST nums\n LOAD_CONST 0\n LOAD_FAST arr_len\n BINARY_SLICE\n CALL 1\n CALL 1\n STORE_FAST mi\n LOAD_FAST nums\n LOAD_FAST mi\n LOAD_CONST None\n LOAD_CONST -1\n BUILD_SLICE 3\n BINARY_SUBSCR\n LOAD_FAST nums\n LOAD_FAST mi\n LOAD_CONST 1\n BINARY_OP +\n LOAD_GLOBAL NULL + len\n LOAD_FAST nums\n CALL 1\n BINARY_SLICE\n BINARY_OP +\n STORE_FAST nums\n LOAD_FAST nums\n LOAD_FAST arr_len\n LOAD_CONST 1\n BINARY_OP -\n LOAD_CONST None\n LOAD_CONST -1\n BUILD_SLICE 3\n BINARY_SUBSCR\n LOAD_FAST nums\n LOAD_FAST arr_len\n LOAD_GLOBAL NULL + len\n LOAD_FAST nums\n CALL 1\n BINARY_SLICE\n BINARY_OP +\n STORE_FAST nums\n LOAD_FAST arr_len\n LOAD_CONST 1\n BINARY_OP -=\n STORE_FAST arr_len\n LOAD_FAST arr_len\n LOAD_CONST 1\n COMPARE_OP >\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST nums\n RETURN_VALUE\nEND", "expected": "def pancake_sort(nums):\n arr_len = len(nums)\n while arr_len > 1:\n mi = nums.index(max(nums[0:arr_len]))\n nums = nums[mi::-1] + nums[mi + 1:len(nums)]\n nums = nums[arr_len - 1::-1] + nums[arr_len:len(nums)]\n arr_len -= 1\n return nums", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 141, "mbpp_split": "test", "prompt": "Write a function to sort a list of elements using pancake sort.", "test_list": ["assert pancake_sort([15, 79, 25, 38, 69]) == [15, 25, 38, 69, 79]", "assert pancake_sort([98, 12, 54, 36, 85]) == [12, 36, 54, 85, 98]", "assert pancake_sort([41, 42, 32, 12, 23]) == [12, 23, 32, 41, 42]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_141", "n_instr": 72} {"i": 375, "src_path": "src/00375.py", "pyc_path": "pyc/00375.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME count_samepair\n RETURN_CONST None\nEND\nCODE count_samepair(list1, list2, list3)\n RESUME 0\n LOAD_GLOBAL NULL + sum\n LOAD_CONST .>\n MAKE_FUNCTION 0\n LOAD_GLOBAL NULL + zip\n LOAD_FAST list1\n LOAD_FAST list2\n LOAD_FAST list3\n CALL 3\n GET_ITER\n CALL 0\n CALL 1\n STORE_FAST result\n LOAD_FAST result\n RETURN_VALUE\nEND\nCODE count_samepair..(.0)\n RETURN_GENERATOR\n POP_TOP\nL1:\n RESUME 0\n LOAD_FAST .0\nL2:\n FOR_ITER L5\n UNPACK_SEQUENCE 3\n STORE_FAST m\n STORE_FAST n\n STORE_FAST o\n LOAD_FAST m\n LOAD_FAST n\n SWAP 2\n COPY 2\n COMPARE_OP ==\n COPY 1\n POP_JUMP_IF_FALSE L3\n POP_TOP\n LOAD_FAST o\n COMPARE_OP ==\n JUMP_FORWARD L4\nL3:\n SWAP 2\n POP_TOP\nL4:\n YIELD_VALUE 1\n RESUME 1\n POP_TOP\n JUMP_BACKWARD L2\nL5:\n END_FOR\n RETURN_CONST None\nL6:\n CALL_INTRINSIC_1 INTRINSIC_STOPITERATION_ERROR\n RERAISE 1\n EXC try=L1..L6 -> handler=L6 depth=0 lasti=True\nEND", "expected": "def count_samepair(list1, list2, list3):\n result = sum((m == n == o for m, n, o in zip(list1, list2, list3)))\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 142, "mbpp_split": "test", "prompt": "Write a function to count the same pair in three given lists.", "test_list": ["assert count_samepair([1,2,3,4,5,6,7,8],[2,2,3,1,2,6,7,9],[2,1,3,1,2,6,7,9])==3", "assert count_samepair([1,2,3,4,5,6,7,8],[2,2,3,1,2,6,7,8],[2,1,3,1,2,6,7,8])==4", "assert count_samepair([1,2,3,4,2,6,7,8],[2,2,3,1,2,6,7,8],[2,1,3,1,2,6,7,8])==5"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_142", "n_instr": 62} {"i": 376, "src_path": "src/00376.py", "pyc_path": "pyc/00376.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME find_lists\n RETURN_CONST None\nEND\nCODE find_lists(Input)\n RESUME 0\n LOAD_GLOBAL NULL + isinstance\n LOAD_FAST Input\n LOAD_GLOBAL list\n CALL 2\n POP_JUMP_IF_FALSE L1\n RETURN_CONST 1\nL1:\n LOAD_GLOBAL NULL + len\n LOAD_FAST Input\n CALL 1\n RETURN_VALUE\nEND", "expected": "def find_lists(Input):\n if isinstance(Input, list):\n return 1\n else:\n return len(Input)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 143, "mbpp_split": "test", "prompt": "Write a function to find number of lists present in the given tuple.", "test_list": ["assert find_lists(([1, 2, 3, 4], [5, 6, 7, 8])) == 2", "assert find_lists(([1, 2], [3, 4], [5, 6])) == 3", "assert find_lists(([9, 8, 7, 6, 5, 4, 3, 2, 1])) == 1"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_143", "n_instr": 20} {"i": 377, "src_path": "src/00377.py", "pyc_path": "pyc/00377.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_Pairs\n RETURN_CONST None\nEND\nCODE sum_Pairs(arr, n)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST sum\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n LOAD_CONST -1\n LOAD_CONST -1\n CALL 3\n GET_ITER\nL1:\n FOR_ITER L2\n STORE_FAST i\n LOAD_FAST sum\n LOAD_FAST i\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_OP *\n LOAD_FAST n\n LOAD_CONST 1\n BINARY_OP -\n LOAD_FAST i\n BINARY_OP -\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n BINARY_OP *\n BINARY_OP -\n BINARY_OP +=\n STORE_FAST sum\n JUMP_BACKWARD L1\nL2:\n END_FOR\n LOAD_FAST sum\n RETURN_VALUE\nEND", "expected": "def sum_Pairs(arr, n):\n sum = 0\n for i in range(n - 1, -1, -1):\n sum += i * arr[i] - (n - 1 - i) * arr[i]\n return sum", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 144, "mbpp_split": "test", "prompt": "Write a python function to find the sum of absolute differences in all pairs of the given array.", "test_list": ["assert sum_Pairs([1,8,9,15,16],5) == 74", "assert sum_Pairs([1,2,3,4],4) == 10", "assert sum_Pairs([1,2,3,4,5,7,9,11,14],9) == 188"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_144", "n_instr": 45} {"i": 378, "src_path": "src/00378.py", "pyc_path": "pyc/00378.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME ascii_value_string\n RETURN_CONST None\nEND\nCODE ascii_value_string(str1)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_GLOBAL NULL + len\n LOAD_FAST str1\n CALL 1\n CALL 1\n GET_ITER\n FOR_ITER L1\n STORE_FAST i\n LOAD_GLOBAL NULL + ord\n LOAD_FAST str1\n LOAD_FAST i\n BINARY_SUBSCR\n CALL 1\n SWAP 2\n POP_TOP\n RETURN_VALUE\nL1:\n END_FOR\n RETURN_CONST None\nEND", "expected": "def ascii_value_string(str1):\n for i in range(len(str1)):\n return ord(str1[i])", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 146, "mbpp_split": "test", "prompt": "Write a function to find the ascii value of total characters in a string.", "test_list": ["assert ascii_value_string(\"python\")==112", "assert ascii_value_string(\"Program\")==80", "assert ascii_value_string(\"Language\")==76"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_146", "n_instr": 28} {"i": 379, "src_path": "src/00379.py", "pyc_path": "pyc/00379.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_digits_single\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME closest\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME sum_digits_twoparts\n RETURN_CONST None\nEND\nCODE sum_digits_single(x)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST ans\n LOAD_FAST x\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_FAST ans\n LOAD_FAST x\n LOAD_CONST 10\n BINARY_OP %\n BINARY_OP +=\n STORE_FAST ans\n LOAD_FAST x\n LOAD_CONST 10\n BINARY_OP //=\n STORE_FAST x\n LOAD_FAST x\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST ans\n RETURN_VALUE\nEND\nCODE closest(x)\n RESUME 0\n LOAD_CONST 0\n STORE_FAST ans\n LOAD_FAST ans\n LOAD_CONST 10\n BINARY_OP *\n LOAD_CONST 9\n BINARY_OP +\n LOAD_FAST x\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_FAST ans\n LOAD_CONST 10\n BINARY_OP *\n LOAD_CONST 9\n BINARY_OP +\n STORE_FAST ans\n LOAD_FAST ans\n LOAD_CONST 10\n BINARY_OP *\n LOAD_CONST 9\n BINARY_OP +\n LOAD_FAST x\n COMPARE_OP <=\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST ans\n RETURN_VALUE\nEND\nCODE sum_digits_twoparts(N)\n RESUME 0\n LOAD_GLOBAL NULL + closest\n LOAD_FAST N\n CALL 1\n STORE_FAST A\n LOAD_GLOBAL NULL + sum_digits_single\n LOAD_FAST A\n CALL 1\n LOAD_GLOBAL NULL + sum_digits_single\n LOAD_FAST N\n LOAD_FAST A\n BINARY_OP -\n CALL 1\n BINARY_OP +\n RETURN_VALUE\nEND", "expected": "def sum_digits_single(x):\n ans = 0\n while x:\n ans += x % 10\n x //= 10\n return ans\n\ndef closest(x):\n ans = 0\n while ans * 10 + 9 <= x:\n ans = ans * 10 + 9\n return ans\n\ndef sum_digits_twoparts(N):\n A = closest(N)\n return sum_digits_single(A) + sum_digits_single(N - A)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 148, "mbpp_split": "test", "prompt": "Write a function to divide a number into two parts such that the sum of digits is maximum.", "test_list": ["assert sum_digits_twoparts(35)==17", "assert sum_digits_twoparts(7)==7", "assert sum_digits_twoparts(100)==19"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_148", "n_instr": 85} {"i": 380, "src_path": "src/00380.py", "pyc_path": "pyc/00380.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME longest_subseq_with_diff_one\n RETURN_CONST None\nEND\nCODE longest_subseq_with_diff_one(arr, n)\n RESUME 0\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\n LOAD_FAST_AND_CLEAR i\n SWAP 2\nL1:\n BUILD_LIST 0\n SWAP 2\nL2:\n FOR_ITER L3\n STORE_FAST i\n LOAD_CONST 1\n LIST_APPEND 2\n JUMP_BACKWARD L2\nL3:\n END_FOR\nL4:\n STORE_FAST dp\n STORE_FAST i\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL5:\n FOR_ITER L9\n STORE_FAST i\n LOAD_GLOBAL NULL + range\n LOAD_FAST i\n CALL 1\n GET_ITER\nL6:\n FOR_ITER L8\n STORE_FAST j\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST j\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L7\n LOAD_FAST arr\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST arr\n LOAD_FAST j\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP -\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L7\n JUMP_BACKWARD L6\nL7:\n LOAD_GLOBAL NULL + max\n LOAD_FAST dp\n LOAD_FAST i\n BINARY_SUBSCR\n LOAD_FAST dp\n LOAD_FAST j\n BINARY_SUBSCR\n LOAD_CONST 1\n BINARY_OP +\n CALL 2\n LOAD_FAST dp\n LOAD_FAST i\n STORE_SUBSCR\n JUMP_BACKWARD L6\nL8:\n END_FOR\n JUMP_BACKWARD L5\nL9:\n END_FOR\n LOAD_CONST 1\n STORE_FAST result\n LOAD_GLOBAL NULL + range\n LOAD_FAST n\n CALL 1\n GET_ITER\nL10:\n FOR_ITER L12\n STORE_FAST i\n LOAD_FAST result\n LOAD_FAST dp\n LOAD_FAST i\n BINARY_SUBSCR\n COMPARE_OP <\n POP_JUMP_IF_TRUE L11\n JUMP_BACKWARD L10\nL11:\n LOAD_FAST dp\n LOAD_FAST i\n BINARY_SUBSCR\n STORE_FAST result\n JUMP_BACKWARD L10\nL12:\n END_FOR\n LOAD_FAST result\n RETURN_VALUE\nL13:\n SWAP 2\n POP_TOP\n SWAP 2\n STORE_FAST i\n RERAISE 0\n EXC try=L1..L4 -> handler=L13 depth=2 lasti=False\nEND", "expected": "def longest_subseq_with_diff_one(arr, n):\n dp = [1 for i in range(n)]\n for i in range(n):\n for j in range(i):\n if arr[i] == arr[j] + 1 or arr[i] == arr[j] - 1:\n dp[i] = max(dp[i], dp[j] + 1)\n result = 1\n for i in range(n):\n if result < dp[i]:\n result = dp[i]\n return result", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 149, "mbpp_split": "test", "prompt": "Write a function to find the longest subsequence such that the difference between adjacents is one for the given array.", "test_list": ["assert longest_subseq_with_diff_one([1, 2, 3, 4, 5, 3, 2], 7) == 6", "assert longest_subseq_with_diff_one([10, 9, 4, 5, 4, 8, 6], 7) == 3", "assert longest_subseq_with_diff_one([1, 2, 3, 2, 3, 7, 2, 1], 8) == 7"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_149", "n_instr": 117} {"i": 381, "src_path": "src/00381.py", "pyc_path": "pyc/00381.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME gcd\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME is_coprime\n RETURN_CONST None\nEND\nCODE gcd(p, q)\n RESUME 0\n LOAD_FAST q\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_FAST q\n LOAD_FAST p\n LOAD_FAST q\n BINARY_OP %\n STORE_FAST q\n STORE_FAST p\n LOAD_FAST q\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L2\n JUMP_BACKWARD L1\nL2:\n LOAD_FAST p\n RETURN_VALUE\nEND\nCODE is_coprime(x, y)\n RESUME 0\n LOAD_GLOBAL NULL + gcd\n LOAD_FAST x\n LOAD_FAST y\n CALL 2\n LOAD_CONST 1\n COMPARE_OP ==\n RETURN_VALUE\nEND", "expected": "def gcd(p, q):\n while q != 0:\n p, q = (q, p % q)\n return p\n\ndef is_coprime(x, y):\n return gcd(x, y) == 1", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 151, "mbpp_split": "test", "prompt": "Write a python function to check whether the given number is co-prime or not.", "test_list": ["assert is_coprime(17,13) == True", "assert is_coprime(15,21) == False", "assert is_coprime(25,45) == False"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_151", "n_instr": 41} {"i": 382, "src_path": "src/00382.py", "pyc_path": "pyc/00382.pyc", "input": "CODE ()\n RESUME 0\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME merge\n LOAD_CONST \n MAKE_FUNCTION 0\n STORE_NAME merge_sort\n RETURN_CONST None\nEND\nCODE merge(a, b)\n RESUME 0\n BUILD_LIST 0\n STORE_FAST c\n LOAD_GLOBAL NULL + len\n LOAD_FAST a\n CALL 1\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L4\n LOAD_GLOBAL NULL + len\n LOAD_FAST b\n CALL 1\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L4\nL1:\n LOAD_FAST a\n LOAD_CONST 0\n BINARY_SUBSCR\n LOAD_FAST b\n LOAD_CONST 0\n BINARY_SUBSCR\n COMPARE_OP <\n POP_JUMP_IF_FALSE L2\n LOAD_FAST c\n LOAD_ATTR NULL|self + append\n LOAD_FAST a\n LOAD_CONST 0\n BINARY_SUBSCR\n CALL 1\n POP_TOP\n LOAD_FAST a\n LOAD_ATTR NULL|self + remove\n LOAD_FAST a\n LOAD_CONST 0\n BINARY_SUBSCR\n CALL 1\n POP_TOP\n JUMP_FORWARD L3\nL2:\n LOAD_FAST c\n LOAD_ATTR NULL|self + append\n LOAD_FAST b\n LOAD_CONST 0\n BINARY_SUBSCR\n CALL 1\n POP_TOP\n LOAD_FAST b\n LOAD_ATTR NULL|self + remove\n LOAD_FAST b\n LOAD_CONST 0\n BINARY_SUBSCR\n CALL 1\n POP_TOP\nL3:\n LOAD_GLOBAL NULL + len\n LOAD_FAST a\n CALL 1\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L4\n LOAD_GLOBAL NULL + len\n LOAD_FAST b\n CALL 1\n LOAD_CONST 0\n COMPARE_OP !=\n POP_JUMP_IF_FALSE L4\n JUMP_BACKWARD L1\nL4:\n LOAD_GLOBAL NULL + len\n LOAD_FAST a\n CALL 1\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L5\n LOAD_FAST c\n LOAD_FAST b\n BINARY_OP +=\n STORE_FAST c\n LOAD_FAST c\n RETURN_VALUE\nL5:\n LOAD_FAST c\n LOAD_FAST a\n BINARY_OP +=\n STORE_FAST c\n LOAD_FAST c\n RETURN_VALUE\nEND\nCODE merge_sort(x)\n RESUME 0\n LOAD_GLOBAL NULL + len\n LOAD_FAST x\n CALL 1\n LOAD_CONST 0\n COMPARE_OP ==\n POP_JUMP_IF_TRUE L1\n LOAD_GLOBAL NULL + len\n LOAD_FAST x\n CALL 1\n LOAD_CONST 1\n COMPARE_OP ==\n POP_JUMP_IF_FALSE L2\nL1:\n LOAD_FAST x\n RETURN_VALUE\nL2:\n LOAD_GLOBAL NULL + len\n LOAD_FAST x\n CALL 1\n LOAD_CONST 2\n BINARY_OP //\n STORE_FAST middle\n LOAD_GLOBAL NULL + merge_sort\n LOAD_FAST x\n LOAD_CONST None\n LOAD_FAST middle\n BINARY_SLICE\n CALL 1\n STORE_FAST a\n LOAD_GLOBAL NULL + merge_sort\n LOAD_FAST x\n LOAD_FAST middle\n LOAD_CONST None\n BINARY_SLICE\n CALL 1\n STORE_FAST b\n LOAD_GLOBAL NULL + merge\n LOAD_FAST a\n LOAD_FAST b\n CALL 2\n RETURN_VALUE\nEND", "expected": "def merge(a, b):\n c = []\n while len(a) != 0 and len(b) != 0:\n if a[0] < b[0]:\n c.append(a[0])\n a.remove(a[0])\n else:\n c.append(b[0])\n b.remove(b[0])\n if len(a) == 0:\n c += b\n else:\n c += a\n return c\n\ndef merge_sort(x):\n if len(x) == 0 or len(x) == 1:\n return x\n else:\n middle = len(x) // 2\n a = merge_sort(x[:middle])\n b = merge_sort(x[middle:])\n return merge(a, b)", "provenance": {"dataset": "google-research-datasets/mbpp (config 'full')", "task_id": 152, "mbpp_split": "test", "prompt": "Write a function to sort the given array by using merge sort.", "test_list": ["assert merge_sort([3, 4, 2, 6, 5, 7, 1, 9]) == [1, 2, 3, 4, 5, 6, 7, 9]", "assert merge_sort([7, 25, 45, 78, 11, 33, 19]) == [7, 11, 19, 25, 33, 45, 78]", "assert merge_sort([3, 1, 4, 9, 8]) == [1, 3, 4, 8, 9]"], "transform": "ast.unparse via scripts/pybytecode/gen.py:canonicalise"}, "license": {"spdx": "CC-BY-4.0", "name": "Creative Commons Attribution 4.0 International", "attribution": "MBPP (Mostly Basic Python Problems), Austin et al. 2021, Google Research", "source_url": "https://huggingface.co/datasets/google-research-datasets/mbpp"}, "csn_repo": "mbpp", "csn_func": "mbpp_152", "n_instr": 143}