βοΈ About | π Quick start | π Data generation | π§βπ» Training | π Evaluation | β οΈ Limitations
 ## About We introduce StarCoder2-15B-Instruct-v0.1, the very first entirely self-aligned code Large Language Model (LLM) trained with a fully permissive and transparent pipeline. Our open-source pipeline uses StarCoder2-15B to generate thousands of instruction-response pairs, which are then used to fine-tune StarCoder-15B itself without any human annotations or distilled data from huge and proprietary LLMs. - **Model:** [bigcode/starcoder2-15b-instruct-v0.1](https://huggingface.co/bigcode/starcoder2-instruct-15b-v0.1) - **Code:** [bigcode-project/starcoder2-self-align](https://github.com/bigcode-project/starcoder2-self-align) - **Dataset:** [bigcode/self-oss-instruct-sc2-exec-filter-50k](https://huggingface.co/datasets/bigcode/self-oss-instruct-sc2-exec-filter-50k/) - **Authors:** [Yuxiang Wei](https://yuxiang.cs.illinois.edu), [Federico Cassano](https://federico.codes/), [Jiawei Liu](https://jw-liu.xyz), [Yifeng Ding](https://yifeng-ding.com), [Naman Jain](https://naman-ntc.github.io), [Harm de Vries](https://www.harmdevries.com), [Leandro von Werra](https://twitter.com/lvwerra), [Arjun Guha](https://www.khoury.northeastern.edu/home/arjunguha/main/home/), [Lingming Zhang](https://lingming.cs.illinois.edu).  ## Quick start Here is an example to get started with StarCoder2-15B-Instruct-v0.1 using the [transformers](https://huggingface.co/docs/transformers/index) library: ```python import transformers import torch pipeline = transformers.pipeline( model="bigcode/starcoder2-15b-instruct-v0.1", task="text-generation", torch_dtype=torch.bfloat16, device_map="auto", ) def respond(instruction: str, response_prefix: str) -> str: messages = [{"role": "user", "content": instruction}] prompt = pipeline.tokenizer.apply_chat_template(messages, tokenize=False) prompt += response_prefix teminators = [ pipeline.tokenizer.eos_token_id, pipeline.tokenizer.convert_tokens_to_ids("###"), ] result = pipeline( prompt, max_length=256, num_return_sequences=1, do_sample=False, eos_token_id=teminators, pad_token_id=pipeline.tokenizer.eos_token_id, truncation=True, ) response = response_prefix + result[0]["generated_text"][len(prompt) :].split("###")[0].rstrip() return response instruction = "Write a quicksort function in Python with type hints and a 'less_than' parameter for custom sorting criteria." response_prefix = "" print(respond(instruction, response_prefix)) ``` ## Data generation pipeline > Run `pip install -e .` first to install the package locally. Check [seed_gathering](seed_gathering/) for details on how we collected the seeds. By default, we use in-memory vLLM engine for data generation, but we also provide an option to use vLLM's [OpenAI compatible server](https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html) for data generation. Set `CUDA_VISIBLE_DEVICES=...` to specify the GPU devices to use for the vLLM engine. To maximize data generation efficiency, we recommend invoking the script multiple times with different `seed_code_start_index` and `max_new_data` values, each with an vLLM engine running on a separate GPU set. For example, for a 100k seed dataset on a 2-GPU machine, you can have 2 processes each generating 50k samples by setting `CUDA_VISIBLE_DEVICES=0 --seed_code_start_index 0 --max_new_data 50000` and `CUDA_VISIBLE_DEVICES=1 --seed_code_start_index 50000 --max_new_data 50000`.") == 1
assert prompt.count("") == 0
lines = answer.splitlines(keepends=True)
return_line, result_line, begin_line = lines[-3:]
assert return_line.strip().startswith("# return")
assert result_line.strip().startswith("# ")
assert begin_line.strip() == "### BEGIN SOLUTION"
response = "".join(lines[:-3]).strip()
hint = begin_line.replace("###", "#").replace("BEGIN SOLUTION", "Solution")
response += f"\n{hint}\n"
else:
assert "BEGIN SOLUTION" in prompt
assert prompt.count("") == 2
assert prompt.count("") == 1
first_block_start = prompt.index("")
first_block_end = prompt.index("")
second_block_start = prompt.index("", first_block_start + 1)
assert first_block_end < second_block_start
lines = answer.splitlines(keepends=True)
block_end, instruction_line, begin_line, block_start = lines[-4:]
assert begin_line.strip() == "BEGIN SOLUTION"
assert block_start.strip() == ""
if not block_end.strip() == "":
if lines[-6].strip() == "":
response_prefix = lines[:-6]
starting_lines = lines[-5:-2]
else:
assert instruction_line.strip() == ""
response_prefix = lines[:-3]
starting_lines = lines[-2:-2]
else:
response_prefix = lines[:-4]
starting_lines = lines[-3:-2]
starting_lines = [f"# {line.lstrip()}" for line in starting_lines]
response = "".join([*response_prefix, *starting_lines]).strip()
response += "\n# Solution\n"
else:
# hit = True
assert prompt.count("") == 0
assert prompt.count("") == 0
assert prompt.strip().endswith("# SOLUTION START")
code_prefix = prompt[: prompt.rindex("# SOLUTION START")].strip()
instruction = f"""Write a solution to the following problem:
```python
{code_prefix}
```"""
response = f"```python\n{code_prefix}\n# Solution\n"
instruction = instruction.replace("", "```python").replace("", "```")
response = response.replace("", "```python").replace("", "```")
# if hit:
# print("[Instruction]")
# print(instruction)
# print("[Response]")
# print(response)
# breakpoint()
return instruction, response
def preprocess_insertion_prompt(prompt: str) -> str:
pattern = """
BEGIN SOLUTION
[insert]
END SOLUTION"""
pattern_index = prompt.index(pattern)
# pattern_block = prompt[pattern_index:]
prefix = prompt[:pattern_index]
# hit = False
if pattern + "\n" in prompt:
index = prompt.index("", pattern_index + len(pattern))
suffix = prompt[index + len("") :]
else:
# hit = True
assert pattern in prompt
suffix = ""
final_prompt = prefix.strip() + "\n[insert]\n" + suffix.strip()
final_prompt = final_prompt.replace("", "```python").replace("", "```")
# if hit:
# print(final_prompt)
# breakpoint()
return final_prompt
def main():
args = cast(Args, HfArgumentParser(Args).parse_args_into_dataclasses()[0])
dataset = DS1000Dataset(args.dataset_path, mode=args.mode)
global PROMPT
if (inferred := os.getenv("INFER")) is not None:
if inferred == "1":
PROMPT = infer_prompt_template(args.model_name_or_path)
else:
PROMPT = infer_prompt_template(inferred)
print("Using prompt:")
print(PROMPT)
all_problems = [
problem
for problems in dataset.data.values()
for problem in problems
if args.mode == "Completion" or problem["lib"] != "Matplotlib"
]
engine = LLM(
tokenizer=args.model_key, model=args.model_name_or_path or args.model_key
)
# model_context = get_model_context(
# model_key=args.model_key,
# model_name_or_path=args.model_name_or_path,
# )
for problem in tqdm(all_problems):
# generate(args, model_context, problem)
generate(args, engine, problem)
if __name__ == "__main__":
main()
selfcodealign-selfcodealign/evaluation/evalplus_results/ 0000775 0000000 0000000 00000000000 14637551746 0024257 5 ustar 00root root 0000000 0000000 evalplus-starcoder2-15b-instruct-v0.1-humaneval.jsonl 0000664 0000000 0000000 00000124751 14637551746 0036060 0 ustar 00root root 0000000 0000000 selfcodealign-selfcodealign/evaluation/evalplus_results {"task_id": "HumanEval/0", "completion": "\n numbers.sort()\n for i in range(len(numbers) - 1):\n if numbers[i + 1] - numbers[i] < threshold:\n return True\n return False\n"}
{"task_id": "HumanEval/1", "completion": "\n stack = []\n groups = []\n for char in paren_string:\n if char == '(':\n stack.append(char)\n elif char == ')':\n if len(stack) > 0:\n stack.pop()\n else:\n continue\n else:\n continue\n if len(stack) == 0:\n groups.append(''.join(char for char in paren_string[paren_string.index('('):paren_string.index(')') + 1]))\n\n return groups\n"}
{"task_id": "HumanEval/2", "completion": "\n return number - int(number)\n"}
{"task_id": "HumanEval/3", "completion": "\n balance = 0\n for operation in operations:\n balance += operation\n if balance < 0:\n return True\n return False\n"}
{"task_id": "HumanEval/4", "completion": "\n mean = sum(numbers) / len(numbers)\n differences = [abs(x - mean) for x in numbers]\n return sum(differences) / len(numbers)\n"}
{"task_id": "HumanEval/5", "completion": "\n result = []\n for index, number in enumerate(numbers):\n result.append(number)\n if index < len(numbers) - 1:\n result.append(delimeter)\n return result\n"}
{"task_id": "HumanEval/6", "completion": "\n groups = paren_string.split()\n deepest_levels = []\n for group in groups:\n max_depth = 0\n depth = 0\n for char in group:\n if char == \"(\":\n depth += 1\n max_depth = max(max_depth, depth)\n elif char == \")\":\n depth -= 1\n deepest_levels.append(max_depth)\n return deepest_levels\n"}
{"task_id": "HumanEval/7", "completion": "\n return [s for s in strings if substring in s]\n"}
{"task_id": "HumanEval/8", "completion": "\n sum_val = 0\n product_val = 1\n for num in numbers:\n sum_val += num\n product_val *= num\n return sum_val, product_val\n"}
{"task_id": "HumanEval/9", "completion": "\n result = []\n for i in range(len(numbers)):\n result.append(max(numbers[i:]))\n return result\n"}
{"task_id": "HumanEval/10", "completion": "\n if is_palindrome(string):\n return string\n for i in range(len(string)-1, 0, -1):\n if is_palindrome(string[i:]):\n return string + string[i-1::-1]\n"}
{"task_id": "HumanEval/11", "completion": "\n result = \"\"\n for i in range(len(a)):\n result += str(int(a[i]) ^ int(b[i]))\n return result\n"}
{"task_id": "HumanEval/12", "completion": "\n if not strings:\n return None\n\n longest_length = max(len(s) for s in strings)\n longest_strings = [s for s in strings if len(s) == longest_length]\n\n return longest_strings[0]\n"}
{"task_id": "HumanEval/13", "completion": "\n while b!= 0:\n a, b = b, a % b\n return a\n"}
{"task_id": "HumanEval/14", "completion": "\n prefixes = []\n for i in range(len(string)):\n prefixes.append(string[:i+1])\n return prefixes\n"}
{"task_id": "HumanEval/15", "completion": "\n return \" \".join(map(str, range(n+1)))\n"}
{"task_id": "HumanEval/16", "completion": "\n distinct_characters = set()\n for char in string.lower():\n distinct_characters.add(char)\n return len(distinct_characters)\n"}
{"task_id": "HumanEval/17", "completion": "\n beats = {\n 'o': 4,\n 'o|': 2,\n '.|': 1,\n }\n result = []\n for note in music_string.split():\n result.append(beats[note])\n return result\n"}
{"task_id": "HumanEval/18", "completion": "\n if not string or not substring:\n return 0\n count = 0\n start = 0\n while True:\n index = string.find(substring, start)\n if index == -1:\n break\n count += 1\n start = index + 1\n return count\n"}
{"task_id": "HumanEval/19", "completion": "\n number_map = {\n \"zero\": 0,\n \"one\": 1,\n \"two\": 2,\n \"three\": 3,\n \"four\": 4,\n \"five\": 5,\n \"six\": 6,\n \"seven\": 7,\n \"eight\": 8,\n \"nine\": 9,\n }\n number_list = numbers.split()\n sorted_list = sorted(number_list, key=lambda x: number_map[x])\n return \" \".join(sorted_list)\n"}
{"task_id": "HumanEval/20", "completion": "\n numbers.sort()\n min_diff = float(\"inf\")\n min_pair = ()\n for i in range(len(numbers) - 1):\n diff = numbers[i + 1] - numbers[i]\n if diff < min_diff:\n min_diff = diff\n min_pair = (numbers[i], numbers[i + 1])\n return min_pair\n"}
{"task_id": "HumanEval/21", "completion": "\n min_val = min(numbers)\n max_val = max(numbers)\n return [(x - min_val) / (max_val - min_val) for x in numbers]\n"}
{"task_id": "HumanEval/22", "completion": "\n return [value for value in values if isinstance(value, int)]\n"}
{"task_id": "HumanEval/23", "completion": "\n return len(string)\n"}
{"task_id": "HumanEval/24", "completion": "\n for i in range(n // 2, 0, -1):\n if n % i == 0:\n return i\n return 1\n"}
{"task_id": "HumanEval/25", "completion": "\n factors = []\n factor = 2\n while n > 1:\n if n % factor == 0:\n factors.append(factor)\n n //= factor\n else:\n factor += 1\n return factors\n"}
{"task_id": "HumanEval/26", "completion": "\n unique_numbers = set()\n result = []\n for number in numbers:\n if number not in unique_numbers:\n unique_numbers.add(number)\n result.append(number)\n return result\n"}
{"task_id": "HumanEval/27", "completion": "\n return ''.join(char.swapcase() for char in string)\n"}
{"task_id": "HumanEval/28", "completion": "\n return \"\".join(strings)\n"}
{"task_id": "HumanEval/29", "completion": "\n return [s for s in strings if s.startswith(prefix)]\n"}
{"task_id": "HumanEval/30", "completion": "\n return [x for x in l if x > 0]\n"}
{"task_id": "HumanEval/31", "completion": "\n if n < 2:\n return False\n for i in range(2, int(n ** 0.5) + 1):\n if n % i == 0:\n return False\n return True\n"}
{"task_id": "HumanEval/32", "completion": "\n if len(xs) % 2!= 0:\n raise ValueError(\"xs must have an even number of coefficients\")\n if xs[-1] == 0:\n raise ValueError(\"The largest non-zero coefficient must be non-zero\")\n def newton_raphson(x):\n return x - poly(xs, x) / poly([i * coeff for i, coeff in enumerate(xs, 1)], x)\n x = 0\n for _ in range(100):\n x = newton_raphson(x)\n return x\n"}
{"task_id": "HumanEval/33", "completion": "\n l_prime = []\n for i, val in enumerate(l):\n if i % 3 == 0:\n l_prime.append(sorted(l[i:i+3]))\n else:\n l_prime.append(val)\n return [item for sublist in l_prime for item in sublist]\n"}
{"task_id": "HumanEval/34", "completion": "\n return sorted(set(l))\n"}
{"task_id": "HumanEval/35", "completion": "\n max_element = l[0]\n for element in l:\n if element > max_element:\n max_element = element\n return max_element\n"}
{"task_id": "HumanEval/36", "completion": "\n count = 0\n for i in range(1, n):\n if i % 11 == 0 or i % 13 == 0:\n count += str(i).count('7')\n return count\n"}
{"task_id": "HumanEval/37", "completion": "\n even_indicies = [i for i in range(len(l)) if i % 2 == 0]\n even_values = [l[i] for i in even_indicies]\n sorted_even_values = sorted(even_values)\n result = [None] * len(l)\n for i in even_indicies:\n result[i] = sorted_even_values.pop(0)\n for i in range(len(l)):\n if i not in even_indicies:\n result[i] = l[i]\n return result\n"}
{"task_id": "HumanEval/38", "completion": "\n groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]\n groups = [(group[-1:] + group[:-1]) if len(group) == 3 else group for group in groups]\n return \"\".join(groups)\n"}
{"task_id": "HumanEval/39", "completion": "\n fib_list = [0, 1]\n while len(fib_list) < n:\n fib_list.append(fib_list[-1] + fib_list[-2])\n prime_fib_list = [num for num in fib_list if is_prime(num)]\n return prime_fib_list[n - 1]\n\n\ndef is_prime(num: int):\n \"\"\"\n is_prime checks if a number is prime.\n \"\"\"\n if num <= 1:\n return False\n for i in range(2, int(num ** 0.5) + 1):\n if num % i == 0:\n return False\n return True\n"}
{"task_id": "HumanEval/40", "completion": "\n if len(l) < 3:\n return False\n for i in range(len(l) - 2):\n for j in range(i + 1, len(l) - 1):\n for k in range(j + 1, len(l)):\n if l[i] + l[j] + l[k] == 0:\n return True\n return False\n"}
{"task_id": "HumanEval/41", "completion": "\n return n\n"}
{"task_id": "HumanEval/42", "completion": "\n return [x + 1 for x in l]\n"}
{"task_id": "HumanEval/43", "completion": "\n for i in range(len(l)):\n for j in range(i + 1, len(l)):\n if l[i] + l[j] == 0:\n return True\n return False\n"}
{"task_id": "HumanEval/44", "completion": "\n res = \"\"\n while x > 0:\n res = str(x % base) + res\n x //= base\n return res\n"}
{"task_id": "HumanEval/45", "completion": "\n return 0.5 * a * h\n"}
{"task_id": "HumanEval/46", "completion": "\n if n < 0:\n raise ValueError(\"n must be a non-negative integer\")\n if n == 0:\n return 0\n if n == 1:\n return 0\n if n == 2:\n return 2\n if n == 3:\n return 0\n fib_list = [0, 0, 2, 0]\n for i in range(4, n + 1):\n fib_list.append(fib_list[i - 1] + fib_list[i - 2] + fib_list[i - 3] + fib_list[i - 4])\n return fib_list[-1]\n"}
{"task_id": "HumanEval/47", "completion": "\n l.sort()\n n = len(l)\n if n % 2 == 1:\n return l[n // 2]\n else:\n return (l[n // 2 - 1] + l[n // 2]) / 2\n"}
{"task_id": "HumanEval/48", "completion": "\n return text == text[::-1]\n"}
{"task_id": "HumanEval/49", "completion": "\n if n == 0:\n return 1 % p\n if n % 2 == 0:\n return (modp(n // 2, p) ** 2) % p\n else:\n return (2 * modp(n // 2, p) ** 2) % p\n"}
{"task_id": "HumanEval/50", "completion": "\n return \"\".join([chr(((ord(ch) - 5 - ord(\"a\")) % 26) + ord(\"a\")) for ch in s])\n"}
{"task_id": "HumanEval/51", "completion": "\n vowels = 'aeiouAEIOU'\n result = ''\n for char in text:\n if char not in vowels:\n result += char\n return result\n"}
{"task_id": "HumanEval/52", "completion": "\n for num in l:\n if num >= t:\n return False\n return True\n"}
{"task_id": "HumanEval/53", "completion": "\n return x + y\n"}
{"task_id": "HumanEval/54", "completion": "\n s0 = sorted(s0)\n s1 = sorted(s1)\n return s0 == s1\n"}
{"task_id": "HumanEval/55", "completion": "\n if n <= 2:\n return 1\n return fib(n - 1) + fib(n - 2)\n"}
{"task_id": "HumanEval/56", "completion": "\n stack = []\n for bracket in brackets:\n if bracket == \"<\":\n stack.append(bracket)\n elif bracket == \">\":\n if not stack:\n return False\n stack.pop()\n return not stack\n"}
{"task_id": "HumanEval/57", "completion": "\n if len(l) < 2:\n return True\n direction = l[1] - l[0]\n for i in range(1, len(l) - 1):\n diff = l[i + 1] - l[i]\n if diff == 0:\n continue\n if direction == 0:\n direction = diff\n elif direction * diff < 0:\n return False\n return True\n"}
{"task_id": "HumanEval/58", "completion": "\n return sorted(set(l1) & set(l2))\n"}
{"task_id": "HumanEval/59", "completion": "\n if n < 2:\n raise ValueError(\"n must be greater than 1\")\n if n == 2:\n return 2\n if n % 2 == 0:\n return largest_prime_factor(n // 2)\n for i in range(3, int(n ** 0.5) + 1, 2):\n if n % i == 0:\n return largest_prime_factor(n // i)\n return n\n"}
{"task_id": "HumanEval/60", "completion": "\n return n * (n + 1) // 2\n"}
{"task_id": "HumanEval/61", "completion": "\n stack = []\n for bracket in brackets:\n if bracket == \"(\":\n stack.append(bracket)\n elif bracket == \")\":\n if not stack:\n return False\n stack.pop()\n return not stack\n"}
{"task_id": "HumanEval/62", "completion": "\n derivative = []\n for i, x in enumerate(xs):\n derivative.append(x * i)\n return derivative[1:]\n"}
{"task_id": "HumanEval/63", "completion": "\n if n == 0 or n == 1:\n return 0\n if n == 2:\n return 1\n a, b, c = 0, 0, 1\n for _ in range(3, n + 1):\n a, b, c = b, c, a + b + c\n return c\n"}
{"task_id": "HumanEval/64", "completion": "\n vowels = 'aeiou'\n count = 0\n for char in s.lower():\n if char in vowels:\n count += 1\n return count\n"}
{"task_id": "HumanEval/65", "completion": "\n x_str = str(x)\n x_len = len(x_str)\n if shift > x_len:\n return x_str[::-1]\n else:\n return x_str[x_len - shift:] + x_str[:x_len - shift]\n"}
{"task_id": "HumanEval/66", "completion": "\n sum = 0\n for c in s:\n if c.isupper():\n sum += ord(c)\n return sum\n"}
{"task_id": "HumanEval/67", "completion": "\n apples = int(s.split()[0])\n oranges = int(s.split()[3])\n mangoes = n - apples - oranges\n return mangoes\n"}
{"task_id": "HumanEval/68", "completion": "\n smallest_even_value = float('inf')\n smallest_even_index = -1\n for i, value in enumerate(arr):\n if value % 2 == 0 and value < smallest_even_value:\n smallest_even_value = value\n smallest_even_index = i\n if smallest_even_value == float('inf'):\n return []\n return [smallest_even_value, smallest_even_index]\n"}
{"task_id": "HumanEval/69", "completion": "\n freq = {}\n for num in lst:\n freq[num] = freq.get(num, 0) + 1\n for num in sorted(freq, reverse=True):\n if freq[num] >= num:\n return num\n return -1\n"}
{"task_id": "HumanEval/70", "completion": "\n result = []\n while lst:\n result.append(min(lst))\n lst.remove(min(lst))\n if lst:\n result.append(max(lst))\n lst.remove(max(lst))\n return result\n"}
{"task_id": "HumanEval/71", "completion": "\n if a + b <= c or a + c <= b or b + c <= a:\n return -1\n s = (a + b + c) / 2\n area = (s * (s - a) * (s - b) * (s - c)) ** 0.5\n return round(area, 2)\n"}
{"task_id": "HumanEval/72", "completion": "\n def is_palindrome(lst):\n return lst == lst[::-1]\n return is_palindrome(q) and sum(q) <= w\n"}
{"task_id": "HumanEval/73", "completion": "\n n = len(arr)\n dp = [[0] * n for _ in range(n)]\n for i in range(n):\n dp[i][i] = 1\n for l in range(2, n + 1):\n for i in range(n - l + 1):\n j = i + l - 1\n if arr[i] == arr[j]:\n dp[i][j] = dp[i + 1][j - 1]\n else:\n dp[i][j] = 1 + min(dp[i + 1][j], dp[i][j - 1])\n return dp[0][n - 1]\n"}
{"task_id": "HumanEval/74", "completion": "\n total_lst1 = sum(len(s) for s in lst1)\n total_lst2 = sum(len(s) for s in lst2)\n if total_lst1 < total_lst2:\n return lst1\n elif total_lst2 < total_lst1:\n return lst2\n else:\n return lst1\n"}
{"task_id": "HumanEval/75", "completion": "\n prime_numbers = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n if a in prime_numbers:\n return False\n for i in prime_numbers:\n for j in prime_numbers:\n for k in prime_numbers:\n if i * j * k == a:\n return True\n return False\n"}
{"task_id": "HumanEval/76", "completion": "\n if x == 1:\n return True\n if x == n:\n return False\n while x % n == 0:\n x //= n\n return x == 1\n"}
{"task_id": "HumanEval/77", "completion": "\n if a == 0:\n return True\n if a < 0:\n a = -a\n x = a ** (1/3)\n if x.is_integer():\n return True\n return False\n"}
{"task_id": "HumanEval/78", "completion": "\n prime_digits = {2, 3, 5, 7, 11, 13}\n count = 0\n for digit in num:\n if int(digit, 16) in prime_digits:\n count += 1\n return count\n"}
{"task_id": "HumanEval/79", "completion": "\n binary = bin(decimal)[2:]\n return \"db\" + binary + \"db\"\n"}
{"task_id": "HumanEval/80", "completion": "\n if len(s) < 3:\n return False\n\n for i in range(0, len(s) - 2):\n if s[i] == s[i+1] == s[i+2]:\n return False\n\n return True\n"}
{"task_id": "HumanEval/81", "completion": "\n letter_grades = []\n for gpa in grades:\n if gpa >= 4.0:\n letter_grades.append('A+')\n elif gpa >= 3.7:\n letter_grades.append('A')\n elif gpa >= 3.3:\n letter_grades.append('A-')\n elif gpa >= 3.0:\n letter_grades.append('B+')\n elif gpa >= 2.7:\n letter_grades.append('B')\n elif gpa >= 2.3:\n letter_grades.append('B-')\n elif gpa >= 2.0:\n letter_grades.append('C+')\n elif gpa >= 1.7:\n letter_grades.append('C')\n elif gpa >= 1.3:\n letter_grades.append('C-')\n elif gpa >= 1.0:\n letter_grades.append('D+')\n elif gpa >= 0.7:\n letter_grades.append('D')\n elif gpa >= 0.0:\n letter_grades.append('D-')\n else:\n letter_grades.append('E')\n return letter_grades\n"}
{"task_id": "HumanEval/82", "completion": "\n length = len(string)\n if length < 2:\n return False\n for i in range(2, length):\n if length % i == 0:\n return False\n return True\n"}
{"task_id": "HumanEval/83", "completion": "\n if n == 1:\n return 2\n return 10 * starts_one_ends(n - 1)\n"}
{"task_id": "HumanEval/84", "completion": "\n binary_string = bin(N)[2:]\n total_sum = sum(int(digit) for digit in binary_string)\n return str(total_sum)\n"}
{"task_id": "HumanEval/85", "completion": "\n return sum(x for i, x in enumerate(lst) if i % 2 == 0 and x % 2 == 0)\n"}
{"task_id": "HumanEval/86", "completion": "\n words = s.split()\n for i, word in enumerate(words):\n words[i] = \"\".join(sorted(word))\n return \" \".join(words)\n"}
{"task_id": "HumanEval/87", "completion": "\n coordinates = []\n for row, values in enumerate(lst):\n for col, val in enumerate(values):\n if val == x:\n coordinates.append((row, col))\n coordinates.sort(key=lambda x: (x[0], -x[1]))\n return coordinates\n"}
{"task_id": "HumanEval/88", "completion": "\n if not array:\n return []\n if len(array) == 1:\n return array\n first = array[0]\n last = array[-1]\n if (first + last) % 2 == 0:\n return sorted(array, reverse=True)\n else:\n return sorted(array)\n"}
{"task_id": "HumanEval/89", "completion": "\n alphabet = 'abcdefghijklmnopqrstuvwxyz'\n rotated_alphabet = alphabet[2:] + alphabet[:2]\n encrypted_string = ''\n for char in s:\n if char.isalpha():\n index = alphabet.index(char)\n encrypted_string += rotated_alphabet[index]\n else:\n encrypted_string += char\n return encrypted_string\n"}
{"task_id": "HumanEval/90", "completion": "\n if len(lst) < 2:\n return None\n \n lst.sort()\n for i in range(1, len(lst)):\n if lst[i]!= lst[i-1]:\n return lst[i]\n \n return None\n"}
{"task_id": "HumanEval/91", "completion": "\n boredoms = 0\n sentences = S.split('.')\n for sentence in sentences:\n words = sentence.split()\n if len(words) > 0 and words[0] == 'I':\n boredoms += 1\n return boredoms\n"}
{"task_id": "HumanEval/92", "completion": "\n if not (isinstance(x, int) and isinstance(y, int) and isinstance(z, int)):\n return False\n return x == y + z or y == x + z or z == x + y\n"}
{"task_id": "HumanEval/93", "completion": "\n vowels = 'aeiou'\n encoded_message = ''\n for char in message:\n if char.isalpha():\n if char.lower() in vowels:\n encoded_message += chr((ord(char) - ord('a') + 2) % 26 + ord('a'))\n else:\n encoded_message += chr(ord(char) ^ 32)\n else:\n encoded_message += char\n return encoded_message\n"}
{"task_id": "HumanEval/94", "completion": "\n def is_prime(num):\n if num < 2:\n return False\n for i in range(2, int(num ** 0.5) + 1):\n if num % i == 0:\n return False\n return True\n max_prime = -1\n for num in lst:\n if is_prime(num):\n max_prime = max(max_prime, num)\n if max_prime < 0:\n return 0\n return sum(int(digit) for digit in str(max_prime))\n"}
{"task_id": "HumanEval/95", "completion": "\n if not dict:\n return False\n first_key = next(iter(dict))\n if isinstance(first_key, str):\n return all(isinstance(key, str) and (key.islower() or key.isupper()) for key in dict)\n else:\n return False\n"}
{"task_id": "HumanEval/96", "completion": "\n if n < 2:\n return []\n primes = [2]\n for i in range(3, n, 2):\n is_prime = True\n for p in primes:\n if i % p == 0:\n is_prime = False\n break\n if is_prime:\n primes.append(i)\n return primes\n"}
{"task_id": "HumanEval/97", "completion": "\n return (a % 10) * (b % 10)\n"}
{"task_id": "HumanEval/98", "completion": "\n vowels = 'AEIOU'\n count = 0\n for i, c in enumerate(s):\n if i % 2 == 0 and c in vowels:\n count += 1\n return count\n"}
{"task_id": "HumanEval/99", "completion": "\n number = float(value)\n rounded = round(number)\n if number > 0:\n return rounded if abs(number - rounded) < 0.5 else rounded + 1\n else:\n return rounded if abs(number - rounded) <= 0.5 else rounded - 1\n"}
{"task_id": "HumanEval/100", "completion": "\n if n <= 0:\n return []\n\n stones = [n]\n for i in range(1, n):\n if n % 2 == 0:\n n += 2\n else:\n n += 1\n stones.append(n)\n\n return stones\n"}
{"task_id": "HumanEval/101", "completion": "\n return s.replace(\",\", \" \").split()\n"}
{"task_id": "HumanEval/102", "completion": "\n if x > y:\n return -1\n for num in range(y, x-1, -1):\n if num % 2 == 0:\n return num\n return -1\n"}
{"task_id": "HumanEval/103", "completion": "\n if n > m:\n return -1\n total = 0\n for i in range(n, m+1):\n total += i\n avg = total / (m - n + 1)\n rounded_avg = round(avg)\n binary_avg = bin(rounded_avg)\n return binary_avg\n"}
{"task_id": "HumanEval/104", "completion": "\n def has_even_digit(num):\n while num > 0:\n digit = num % 10\n if digit % 2 == 0:\n return True\n num //= 10\n return False\n \n result = []\n for num in x:\n if not has_even_digit(num):\n result.append(num)\n result.sort()\n return result\n"}
{"task_id": "HumanEval/105", "completion": "\n if not arr:\n return []\n digits = [str(d) for d in arr if 1 <= d <= 9]\n digits.sort(reverse=True)\n return [\n \"One\",\n \"Two\",\n \"Three\",\n \"Four\",\n \"Five\",\n \"Six\",\n \"Seven\",\n \"Eight\",\n \"Nine\",\n ][: len(digits)]\n"}
{"task_id": "HumanEval/106", "completion": "\n def factorial(num):\n if num <= 1:\n return 1\n return num * factorial(num - 1)\n\n def sum_from_1_to_n(num):\n return num * (num + 1) // 2\n\n result = []\n for i in range(1, n + 1):\n if i % 2 == 0:\n result.append(factorial(i))\n else:\n result.append(sum_from_1_to_n(i))\n return result\n"}
{"task_id": "HumanEval/107", "completion": "\n def is_palindrome(num):\n return str(num) == str(num)[::-1]\n\n even_count = 0\n odd_count = 0\n for i in range(1, n + 1):\n if is_palindrome(i):\n if i % 2 == 0:\n even_count += 1\n else:\n odd_count += 1\n\n return (even_count, odd_count)\n"}
{"task_id": "HumanEval/108", "completion": "\n count = 0\n for num in arr:\n if sum(int(digit) for digit in str(num)) > 0:\n count += 1\n return count\n"}
{"task_id": "HumanEval/109", "completion": "\n if not arr:\n return True\n sorted_arr = sorted(arr)\n for i in range(len(arr)):\n shifted_arr = arr[i:] + arr[:i]\n if shifted_arr == sorted_arr:\n return True\n return False\n"}
{"task_id": "HumanEval/110", "completion": "\n even_count = sum(1 for x in lst1 if x % 2 == 0)\n odd_count = len(lst1) - even_count\n if even_count == len(lst1):\n return \"YES\"\n for i in range(len(lst2)):\n if lst2[i] % 2 == 0:\n even_count += 1\n else:\n odd_count += 1\n if even_count == len(lst1):\n return \"YES\"\n if i < len(lst2) - 1:\n if lst2[i + 1] % 2 == 0:\n even_count -= 1\n else:\n odd_count -= 1\n return \"NO\"\n"}
{"task_id": "HumanEval/111", "completion": "\n if not test:\n return {}\n \n freq = {}\n for letter in test.split():\n freq[letter] = freq.get(letter, 0) + 1\n \n max_freq = max(freq.values())\n return {letter: freq for letter, freq in freq.items() if freq == max_freq}\n"}
{"task_id": "HumanEval/112", "completion": "\n result = \"\"\n for char in s:\n if char not in c:\n result += char\n return (result, result == result[::-1])\n"}
{"task_id": "HumanEval/113", "completion": "\n output = []\n for i, string in enumerate(lst):\n count = 0\n for digit in string:\n if int(digit) % 2 == 1:\n count += 1\n output.append(f\"the number of odd elements {count}n the str{count}ng {count} of the {count}nput.\")\n return output\n"}
{"task_id": "HumanEval/114", "completion": "\n min_sum = float(\"inf\")\n current_sum = 0\n for num in nums:\n current_sum += num\n min_sum = min(min_sum, current_sum)\n if current_sum > 0:\n current_sum = 0\n return min_sum\n"}
{"task_id": "HumanEval/115", "completion": "\n num_rows = len(grid)\n num_cols = len(grid[0])\n num_buckets = num_rows\n num_fills = 0\n for i in range(num_rows):\n for j in range(num_cols):\n if grid[i][j] == 1:\n num_fills += 1\n num_fills_per_bucket = math.ceil(num_fills / num_buckets)\n return num_fills_per_bucket\n"}
{"task_id": "HumanEval/116", "completion": "\n def count_ones(num):\n count = 0\n while num > 0:\n count += num & 1\n num >>= 1\n return count\n\n return sorted(arr, key=lambda x: (count_ones(abs(x)), x))\n"}
{"task_id": "HumanEval/117", "completion": "\n vowels = \"aeiou\"\n words = s.split()\n result = []\n for word in words:\n consonants = 0\n for letter in word:\n if letter.isalpha() and letter.lower() not in vowels:\n consonants += 1\n if consonants == n:\n result.append(word)\n return result\n"}
{"task_id": "HumanEval/118", "completion": "\n vowels = set(\"aeiouAEIOU\")\n for i in range(len(word)-1, 0, -1):\n if word[i] in vowels:\n return word[i]\n return \"\"\n"}
{"task_id": "HumanEval/119", "completion": "\n stack = []\n for s in lst:\n for c in s:\n if c == '(':\n stack.append(c)\n elif c == ')':\n if not stack or stack[-1]!= '(':\n return 'No'\n stack.pop()\n return 'Yes' if not stack else 'No'\n"}
{"task_id": "HumanEval/120", "completion": "\n arr.sort(reverse=True)\n return arr[:k]\n"}
{"task_id": "HumanEval/121", "completion": "\n result = 0\n for idx, num in enumerate(lst):\n if idx % 2 == 0 and num % 2 == 1:\n result += num\n return result\n"}
{"task_id": "HumanEval/122", "completion": "\n total_sum = 0\n for i in range(k):\n if arr[i] < 100:\n total_sum += arr[i]\n return total_sum\n"}
{"task_id": "HumanEval/123", "completion": "\n collatz_sequence = [n]\n while n!= 1:\n if n % 2 == 0:\n n = n // 2\n else:\n n = 3 * n + 1\n collatz_sequence.append(n)\n odd_numbers = [num for num in collatz_sequence if num % 2 == 1]\n odd_numbers.sort()\n return odd_numbers\n"}
{"task_id": "HumanEval/124", "completion": "\n if not date:\n return False\n date_parts = date.split('-')\n if len(date_parts)!= 3:\n return False\n month, day, year = date_parts\n if not (month and day and year):\n return False\n if not (month.isdigit() and day.isdigit() and year.isdigit()):\n return False\n month = int(month)\n day = int(day)\n year = int(year)\n if not (1 <= month <= 12):\n return False\n if month in (1, 3, 5, 7, 8, 10, 12):\n max_days = 31\n elif month in (4, 6, 9, 11):\n max_days = 30\n elif month == 2:\n max_days = 29\n else:\n return False\n if not (1 <= day <= max_days):\n return False\n return True\n"}
{"task_id": "HumanEval/125", "completion": "\n if'' in txt:\n return txt.split()\n elif ',' in txt:\n return txt.split(',')\n else:\n return sum(1 for c in txt if ord(c) % 2 == 1)\n"}
{"task_id": "HumanEval/126", "completion": "\n if len(lst) <= 1:\n return True\n prev = lst[0]\n for curr in lst[1:]:\n if curr < prev:\n return False\n if curr == prev:\n return False\n prev = curr\n return True\n"}
{"task_id": "HumanEval/127", "completion": "\n start1, end1 = interval1\n start2, end2 = interval2\n if start1 > end2 or start2 > end1:\n return \"NO\"\n intersection_start = max(start1, start2)\n intersection_end = min(end1, end2)\n intersection_length = intersection_end - intersection_start + 1\n if intersection_length < 2:\n return \"NO\"\n for i in range(2, int(intersection_length ** 0.5) + 1):\n if intersection_length % i == 0:\n return \"NO\"\n return \"YES\"\n"}
{"task_id": "HumanEval/128", "completion": "\n if not arr:\n return None\n\n prod = 1\n sum_magnitudes = 0\n\n for num in arr:\n if num == 0:\n prod *= 0\n break\n elif num > 0:\n prod *= 1\n else:\n prod *= -1\n\n sum_magnitudes += abs(num)\n\n return sum_magnitudes * prod\n"}
{"task_id": "HumanEval/129", "completion": "\n N = len(grid)\n min_path = [float('inf')] * k\n min_path_values = [float('inf')] * k\n\n def dfs(row, col, path, path_values):\n if len(path) == k:\n if path < min_path:\n min_path[:] = path\n min_path_values[:] = path_values\n return\n\n for r, c in [(row - 1, col), (row + 1, col), (row, col - 1), (row, col + 1)]:\n if 0 <= r < N and 0 <= c < N and grid[r][c] not in path_values:\n path.append(grid[r][c])\n path_values.add(grid[r][c])\n dfs(r, c, path, path_values)\n path.pop()\n path_values.remove(grid[r][c])\n\n for row in range(N):\n for col in range(N):\n dfs(row, col, [grid[row][col]], {grid[row][col]})\n\n return min_path_values\n"}
{"task_id": "HumanEval/130", "completion": "\n if n == 0:\n return []\n elif n == 1:\n return [1]\n elif n == 2:\n return [1, 3]\n elif n == 3:\n return [1, 3, 2, 8]\n else:\n sequence = [1, 3, 2, 8]\n for i in range(4, n + 1):\n if i % 2 == 0:\n sequence.append(1 + i / 2)\n else:\n sequence.append(sequence[i - 1] + sequence[i - 2] + sequence[i + 1])\n return sequence\n"}
{"task_id": "HumanEval/131", "completion": "\n product = 1\n while n > 0:\n digit = n % 10\n if digit % 2 == 1:\n product *= digit\n n //= 10\n return product\n"}
{"task_id": "HumanEval/132", "completion": "\n stack = []\n for char in string:\n if char == '[':\n stack.append(char)\n elif char == ']':\n if len(stack) == 0:\n return False\n stack.pop()\n return len(stack) == 0\n"}
{"task_id": "HumanEval/133", "completion": "\n return sum(int(x)**2 for x in lst)\n"}
{"task_id": "HumanEval/134", "completion": "\n if not txt:\n return False\n last_char = txt[-1]\n if last_char.isalpha() and last_char!= \" \":\n return True\n return False\n"}
{"task_id": "HumanEval/135", "completion": "\n for i in range(1, len(arr)):\n if arr[i] < arr[i-1]:\n return i-1\n return -1\n"}
{"task_id": "HumanEval/136", "completion": "\n largest_negative = None\n smallest_positive = None\n for num in lst:\n if num < 0:\n if largest_negative is None or num > largest_negative:\n largest_negative = num\n elif num > 0:\n if smallest_positive is None or num < smallest_positive:\n smallest_positive = num\n return (largest_negative, smallest_positive)\n"}
{"task_id": "HumanEval/137", "completion": "\n if type(a)!= type(b):\n return None\n if type(a) in (int, float):\n if a > b:\n return a\n elif b > a:\n return b\n else:\n return None\n if type(a) == str:\n a = a.replace(\",\", \".\")\n b = b.replace(\",\", \".\")\n if float(a) > float(b):\n return a\n elif float(b) > float(a):\n return b\n else:\n return None\n"}
{"task_id": "HumanEval/138", "completion": "\n if n < 8:\n return False\n for a in range(2, n // 2 + 1, 2):\n for b in range(a, n // 2 + 1, 2):\n for c in range(b, n // 2 + 1, 2):\n d = n - a - b - c\n if d > 0 and d % 2 == 0:\n return True\n return False\n"}
{"task_id": "HumanEval/139", "completion": "\n if n <= 0:\n return 1\n result = 1\n for i in range(n, 0, -1):\n result *= i\n return result\n"}
{"task_id": "HumanEval/140", "completion": "\n result = \"\"\n consecutive_spaces = 0\n for char in text:\n if char == \" \":\n consecutive_spaces += 1\n if consecutive_spaces > 2:\n result += \"-\"\n else:\n result += \"_\"\n else:\n result += char\n consecutive_spaces = 0\n return result\n"}
{"task_id": "HumanEval/141", "completion": "\n if len([c for c in file_name if c.isdigit()]) > 3:\n return \"No\"\n if file_name.count(\".\")!= 1:\n return \"No\"\n before_dot, after_dot = file_name.split(\".\")\n if not before_dot or not before_dot[0].isalpha():\n return \"No\"\n if after_dot not in [\"txt\", \"exe\", \"dll\"]:\n return \"No\"\n return \"Yes\"\n"}
{"task_id": "HumanEval/142", "completion": "\n sum = 0\n for i, val in enumerate(lst):\n if i % 3 == 0 and i % 4!= 0:\n lst[i] = val * val\n elif i % 4 == 0:\n lst[i] = val * val * val\n sum += lst[i]\n return sum\n"}
{"task_id": "HumanEval/143", "completion": "\n def is_prime(num):\n if num <= 1:\n return False\n for i in range(2, int(num ** 0.5) + 1):\n if num % i == 0:\n return False\n return True\n\n words = sentence.split()\n result = []\n for word in words:\n if is_prime(len(word)):\n result.append(word)\n return \" \".join(result)\n"}
{"task_id": "HumanEval/144", "completion": "\n def fraction_to_float(fraction):\n numerator, denominator = fraction.split(\"/\")\n return float(numerator) / float(denominator)\n\n x_float = fraction_to_float(x)\n n_float = fraction_to_float(n)\n product = x_float * n_float\n return product.is_integer()\n"}
{"task_id": "HumanEval/145", "completion": "\n def sum_of_digits(num):\n num = abs(num)\n return sum(int(digit) for digit in str(num))\n\n return sorted(nums, key=sum_of_digits)\n"}
{"task_id": "HumanEval/146", "completion": "\n count = 0\n for num in nums:\n if num > 10 and str(num)[0] in '13579' and str(num)[-1] in '13579':\n count += 1\n return count\n"}
{"task_id": "HumanEval/147", "completion": "\n a = [i * i - i + 1 for i in range(1, n + 1)]\n count = 0\n for i in range(len(a) - 2):\n for j in range(i + 1, len(a) - 1):\n for k in range(j + 1, len(a)):\n if (a[i] + a[j] + a[k]) % 3 == 0:\n count += 1\n return count\n"}
{"task_id": "HumanEval/148", "completion": "\n planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\", \"Uranus\", \"Neptune\"]\n if planet1 not in planets or planet2 not in planets:\n return ()\n planet1_index = planets.index(planet1)\n planet2_index = planets.index(planet2)\n if planet1_index > planet2_index:\n planet1_index, planet2_index = planet2_index, planet1_index\n return tuple(planets[planet1_index+1:planet2_index])\n"}
{"task_id": "HumanEval/149", "completion": "\n def is_even(string):\n return len(string) % 2 == 0\n\n def sort_by_length(string1, string2):\n if len(string1) == len(string2):\n return string1 < string2\n return len(string1) < len(string2)\n\n even_length_words = list(filter(is_even, lst))\n sorted_words = sorted(even_length_words, key=lambda word: len(word))\n return sorted_words\n"}
{"task_id": "HumanEval/150", "completion": "\n if n > 1:\n for i in range(2, n):\n if n % i == 0:\n return y\n return x\n else:\n return y\n"}
{"task_id": "HumanEval/151", "completion": "\n if not lst:\n return 0\n \n sum_of_squares = 0\n \n for num in lst:\n if num < 0 or not isinstance(num, int):\n continue\n \n if num % 2 == 1:\n sum_of_squares += num ** 2\n \n return sum_of_squares\n"}
{"task_id": "HumanEval/152", "completion": "\n result = []\n for i in range(len(game)):\n if game[i] == guess[i]:\n result.append(0)\n else:\n result.append(abs(game[i] - guess[i]))\n return result\n"}
{"task_id": "HumanEval/153", "completion": "\n strongest_extension = ''\n max_strength = float('-inf')\n for extension in extensions:\n cap_count = sum(1 for c in extension if c.isupper())\n sm_count = sum(1 for c in extension if c.islower())\n strength = cap_count - sm_count\n if strength > max_strength:\n max_strength = strength\n strongest_extension = extension\n return f'{class_name}.{strongest_extension}'\n"}
{"task_id": "HumanEval/154", "completion": "\n if b in a:\n return True\n for i in range(1, len(b)):\n b = b[1:] + b[0]\n if b in a:\n return True\n return False\n"}
{"task_id": "HumanEval/155", "completion": "\n num = abs(num)\n even_count = 0\n odd_count = 0\n while num > 0:\n digit = num % 10\n if digit % 2 == 0:\n even_count += 1\n else:\n odd_count += 1\n num //= 10\n return (even_count, odd_count)\n"}
{"task_id": "HumanEval/156", "completion": "\n roman_numerals = {\n 1: \"i\",\n 2: \"ii\",\n 3: \"iii\",\n 4: \"iv\",\n 5: \"v\",\n 6: \"vi\",\n 7: \"vii\",\n 8: \"viii\",\n 9: \"ix\",\n 10: \"x\",\n 20: \"xx\",\n 30: \"xxx\",\n 40: \"xl\",\n 50: \"l\",\n 60: \"lx\",\n 70: \"lxx\",\n 80: \"lxxx\",\n 90: \"xc\",\n 100: \"c\",\n 200: \"cc\",\n 300: \"ccc\",\n 400: \"cd\",\n 500: \"d\",\n 600: \"dc\",\n 700: \"dcc\",\n 800: \"dccc\",\n 900: \"cm\",\n 1000: \"m\",\n }\n result = \"\"\n for numeral in (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1):\n while number >= numeral:\n result += roman_numerals[numeral]\n number -= numeral\n return result.lower()\n"}
{"task_id": "HumanEval/157", "completion": "\n if a**2 + b**2 == c**2 or a**2 + c**2 == b**2 or b**2 + c**2 == a**2:\n return True\n else:\n return False\n"}
{"task_id": "HumanEval/158", "completion": "\n max_unique_chars = 0\n max_word = \"\"\n for word in words:\n unique_chars = set(word)\n if len(unique_chars) > max_unique_chars:\n max_unique_chars = len(unique_chars)\n max_word = word\n elif len(unique_chars) == max_unique_chars and word < max_word:\n max_word = word\n\n return max_word\n"}
{"task_id": "HumanEval/159", "completion": "\n if need <= remaining:\n return [number + need, remaining - need]\n else:\n return [number + remaining, 0]\n"}
{"task_id": "HumanEval/160", "completion": "\n expression = \"\"\n for i in range(len(operand)):\n expression += str(operand[i])\n if i < len(operator):\n expression += operator[i]\n return eval(expression)\n"}
{"task_id": "HumanEval/161", "completion": "\n def reverse_case(ch):\n if ch.islower():\n return ch.upper()\n elif ch.isupper():\n return ch.lower()\n else:\n return ch\n\n result = \"\"\n for ch in s:\n result += reverse_case(ch)\n\n if not any(ch.isalpha() for ch in s):\n result = result[::-1]\n\n return result\n"}
{"task_id": "HumanEval/162", "completion": "\n import hashlib\n if not text:\n return None\n m = hashlib.md5()\n m.update(text.encode('utf-8'))\n return m.hexdigest()\n"}
{"task_id": "HumanEval/163", "completion": "\n if a > b:\n a, b = b, a\n even_digits = []\n for num in range(a, b + 1):\n if num % 2 == 0:\n even_digits.append(num)\n return even_digits\n"}
evalplus-starcoder2-15b-instruct-v0.1-humaneval_eval_results.json 0000664 0000000 0000000 00000422032 14637551746 0040465 0 ustar 00root root 0000000 0000000 selfcodealign-selfcodealign/evaluation/evalplus_results {"date": "2024-04-26 12:01", "hash": "84f4b93a1270b492e4c54d5212da7a5b", "eval": {"HumanEval/7": [{"task_id": "HumanEval/7", "solution": "from typing import List\n\n\ndef filter_by_substring(strings: List[str], substring: str) -> List[str]:\n \"\"\" Filter an input list of strings only for ones that contain given substring\n >>> filter_by_substring([], 'a')\n []\n >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')\n ['abc', 'bacd', 'array']\n \"\"\"\n\n return [s for s in strings if substring in s]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/4": [{"task_id": "HumanEval/4", "solution": "from typing import List\n\n\ndef mean_absolute_deviation(numbers: List[float]) -> float:\n \"\"\" For a given list of input numbers, calculate Mean Absolute Deviation\n around the mean of this dataset.\n Mean Absolute Deviation is the average absolute difference between each\n element and a centerpoint (mean in this case):\n MAD = average | x - x_mean |\n >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])\n 1.0\n \"\"\"\n\n mean = sum(numbers) / len(numbers)\n differences = [abs(x - mean) for x in numbers]\n return sum(differences) / len(numbers)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/5": [{"task_id": "HumanEval/5", "solution": "from typing import List\n\n\ndef intersperse(numbers: List[int], delimeter: int) -> List[int]:\n \"\"\" Insert a number 'delimeter' between every two consecutive elements of input list `numbers'\n >>> intersperse([], 4)\n []\n >>> intersperse([1, 2, 3], 4)\n [1, 4, 2, 4, 3]\n \"\"\"\n\n result = []\n for index, number in enumerate(numbers):\n result.append(number)\n if index < len(numbers) - 1:\n result.append(delimeter)\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/6": [{"task_id": "HumanEval/6", "solution": "from typing import List\n\n\ndef parse_nested_parens(paren_string: str) -> List[int]:\n \"\"\" Input to this function is a string represented multiple groups for nested parentheses separated by spaces.\n For each of the group, output the deepest level of nesting of parentheses.\n E.g. (()()) has maximum two levels of nesting while ((())) has three.\n\n >>> parse_nested_parens('(()()) ((())) () ((())()())')\n [2, 3, 1, 3]\n \"\"\"\n\n groups = paren_string.split()\n deepest_levels = []\n for group in groups:\n max_depth = 0\n depth = 0\n for char in group:\n if char == \"(\":\n depth += 1\n max_depth = max(max_depth, depth)\n elif char == \")\":\n depth -= 1\n deepest_levels.append(max_depth)\n return deepest_levels\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/1": [{"task_id": "HumanEval/1", "solution": "from typing import List\n\n\ndef separate_paren_groups(paren_string: str) -> List[str]:\n \"\"\" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to\n separate those group into separate strings and return the list of those.\n Separate groups are balanced (each open brace is properly closed) and not nested within each other\n Ignore any spaces in the input string.\n >>> separate_paren_groups('( ) (( )) (( )( ))')\n ['()', '(())', '(()())']\n \"\"\"\n\n stack = []\n groups = []\n for char in paren_string:\n if char == '(':\n stack.append(char)\n elif char == ')':\n if len(stack) > 0:\n stack.pop()\n else:\n continue\n else:\n continue\n if len(stack) == 0:\n groups.append(''.join(char for char in paren_string[paren_string.index('('):paren_string.index(')') + 1]))\n\n return groups\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["(())"]]}], "HumanEval/0": [{"task_id": "HumanEval/0", "solution": "from typing import List\n\n\ndef has_close_elements(numbers: List[float], threshold: float) -> bool:\n \"\"\" Check if in given list of numbers, are any two numbers closer to each other than\n given threshold.\n >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n False\n >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n True\n \"\"\"\n\n numbers.sort()\n for i in range(len(numbers) - 1):\n if numbers[i + 1] - numbers[i] < threshold:\n return True\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/9": [{"task_id": "HumanEval/9", "solution": "from typing import List, Tuple\n\n\ndef rolling_max(numbers: List[int]) -> List[int]:\n \"\"\" From a given list of integers, generate a list of rolling maximum element found until given moment\n in the sequence.\n >>> rolling_max([1, 2, 3, 2, 3, 4, 2])\n [1, 2, 3, 3, 3, 4, 4]\n \"\"\"\n\n result = []\n for i in range(len(numbers)):\n result.append(max(numbers[i:]))\n return result\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[[1, 2, 3, 4]]], "plus_fail_tests": [[[5, 4, 3, 2, 1]]]}], "HumanEval/11": [{"task_id": "HumanEval/11", "solution": "from typing import List\n\n\ndef string_xor(a: str, b: str) -> str:\n \"\"\" Input are two strings a and b consisting only of 1s and 0s.\n Perform binary XOR on these inputs and return result also as a string.\n >>> string_xor('010', '110')\n '100'\n \"\"\"\n\n result = \"\"\n for i in range(len(a)):\n result += str(int(a[i]) ^ int(b[i]))\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/3": [{"task_id": "HumanEval/3", "solution": "from typing import List\n\n\ndef below_zero(operations: List[int]) -> bool:\n \"\"\" You're given a list of deposit and withdrawal operations on a bank account that starts with\n zero balance. Your task is to detect if at any point the balance of account fallls below zero, and\n at that point function should return True. Otherwise it should return False.\n >>> below_zero([1, 2, 3])\n False\n >>> below_zero([1, 2, -4, 5])\n True\n \"\"\"\n\n balance = 0\n for operation in operations:\n balance += operation\n if balance < 0:\n return True\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/2": [{"task_id": "HumanEval/2", "solution": "\n\ndef truncate_number(number: float) -> float:\n \"\"\" Given a positive floating point number, it can be decomposed into\n and integer part (largest integer smaller than given number) and decimals\n (leftover part always smaller than 1).\n\n Return the decimal part of the number.\n >>> truncate_number(3.5)\n 0.5\n \"\"\"\n\n return number - int(number)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/10": [{"task_id": "HumanEval/10", "solution": "\n\ndef is_palindrome(string: str) -> bool:\n \"\"\" Test if given string is a palindrome \"\"\"\n return string == string[::-1]\n\n\ndef make_palindrome(string: str) -> str:\n \"\"\" Find the shortest palindrome that begins with a supplied string.\n Algorithm idea is simple:\n - Find the longest postfix of supplied string that is a palindrome.\n - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.\n >>> make_palindrome('')\n ''\n >>> make_palindrome('cat')\n 'catac'\n >>> make_palindrome('cata')\n 'catac'\n \"\"\"\n\n if is_palindrome(string):\n return string\n for i in range(len(string)-1, 0, -1):\n if is_palindrome(string[i:]):\n return string + string[i-1::-1]\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["raracece"]]}], "HumanEval/12": [{"task_id": "HumanEval/12", "solution": "from typing import List, Optional\n\n\ndef longest(strings: List[str]) -> Optional[str]:\n \"\"\" Out of list of strings, return the longest one. Return the first one in case of multiple\n strings of the same length. Return None in case the input list is empty.\n >>> longest([])\n\n >>> longest(['a', 'b', 'c'])\n 'a'\n >>> longest(['a', 'bb', 'ccc'])\n 'ccc'\n \"\"\"\n\n if not strings:\n return None\n\n longest_length = max(len(s) for s in strings)\n longest_strings = [s for s in strings if len(s) == longest_length]\n\n return longest_strings[0]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/8": [{"task_id": "HumanEval/8", "solution": "from typing import List, Tuple\n\n\ndef sum_product(numbers: List[int]) -> Tuple[int, int]:\n \"\"\" For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.\n Empty sum should be equal to 0 and empty product should be equal to 1.\n >>> sum_product([])\n (0, 1)\n >>> sum_product([1, 2, 3, 4])\n (10, 24)\n \"\"\"\n\n sum_val = 0\n product_val = 1\n for num in numbers:\n sum_val += num\n product_val *= num\n return sum_val, product_val\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/13": [{"task_id": "HumanEval/13", "solution": "\n\ndef greatest_common_divisor(a: int, b: int) -> int:\n \"\"\" Return a greatest common divisor of two integers a and b\n >>> greatest_common_divisor(3, 5)\n 1\n >>> greatest_common_divisor(25, 15)\n 5\n \"\"\"\n\n while b!= 0:\n a, b = b, a % b\n return a\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/14": [{"task_id": "HumanEval/14", "solution": "from typing import List\n\n\ndef all_prefixes(string: str) -> List[str]:\n \"\"\" Return list of all prefixes from shortest to longest of the input string\n >>> all_prefixes('abc')\n ['a', 'ab', 'abc']\n \"\"\"\n\n prefixes = []\n for i in range(len(string)):\n prefixes.append(string[:i+1])\n return prefixes\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/17": [{"task_id": "HumanEval/17", "solution": "from typing import List\n\n\ndef parse_music(music_string: str) -> List[int]:\n \"\"\" Input to this function is a string representing musical notes in a special ASCII format.\n Your task is to parse this string and return list of integers corresponding to how many beats does each\n not last.\n\n Here is a legend:\n 'o' - whole note, lasts four beats\n 'o|' - half note, lasts two beats\n '.|' - quater note, lasts one beat\n\n >>> parse_music('o o| .| o| o| .| .| .| .| o o')\n [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]\n \"\"\"\n\n beats = {\n 'o': 4,\n 'o|': 2,\n '.|': 1,\n }\n result = []\n for note in music_string.split():\n result.append(beats[note])\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/19": [{"task_id": "HumanEval/19", "solution": "from typing import List\n\n\ndef sort_numbers(numbers: str) -> str:\n \"\"\" Input is a space-delimited string of numberals from 'zero' to 'nine'.\n Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.\n Return the string with numbers sorted from smallest to largest\n >>> sort_numbers('three one five')\n 'one three five'\n \"\"\"\n\n number_map = {\n \"zero\": 0,\n \"one\": 1,\n \"two\": 2,\n \"three\": 3,\n \"four\": 4,\n \"five\": 5,\n \"six\": 6,\n \"seven\": 7,\n \"eight\": 8,\n \"nine\": 9,\n }\n number_list = numbers.split()\n sorted_list = sorted(number_list, key=lambda x: number_map[x])\n return \" \".join(sorted_list)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/39": [{"task_id": "HumanEval/39", "solution": "\n\ndef prime_fib(n: int):\n \"\"\"\n prime_fib returns n-th number that is a Fibonacci number and it's also prime.\n >>> prime_fib(1)\n 2\n >>> prime_fib(2)\n 3\n >>> prime_fib(3)\n 5\n >>> prime_fib(4)\n 13\n >>> prime_fib(5)\n 89\n \"\"\"\n\n fib_list = [0, 1]\n while len(fib_list) < n:\n fib_list.append(fib_list[-1] + fib_list[-2])\n prime_fib_list = [num for num in fib_list if is_prime(num)]\n return prime_fib_list[n - 1]\n\n\ndef is_prime(num: int):\n \"\"\"\n is_prime checks if a number is prime.\n \"\"\"\n if num <= 1:\n return False\n for i in range(2, int(num ** 0.5) + 1):\n if num % i == 0:\n return False\n return True\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/16": [{"task_id": "HumanEval/16", "solution": "\n\ndef count_distinct_characters(string: str) -> int:\n \"\"\" Given a string, find out how many distinct characters (regardless of case) does it consist of\n >>> count_distinct_characters('xyzXYZ')\n 3\n >>> count_distinct_characters('Jerry')\n 4\n \"\"\"\n\n distinct_characters = set()\n for char in string.lower():\n distinct_characters.add(char)\n return len(distinct_characters)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/31": [{"task_id": "HumanEval/31", "solution": "\n\ndef is_prime(n):\n \"\"\"Return true if a given number is prime, and false otherwise.\n >>> is_prime(6)\n False\n >>> is_prime(101)\n True\n >>> is_prime(11)\n True\n >>> is_prime(13441)\n True\n >>> is_prime(61)\n True\n >>> is_prime(4)\n False\n >>> is_prime(1)\n False\n \"\"\"\n\n if n < 2:\n return False\n for i in range(2, int(n ** 0.5) + 1):\n if n % i == 0:\n return False\n return True\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/41": [{"task_id": "HumanEval/41", "solution": "\n\ndef car_race_collision(n: int):\n \"\"\"\n Imagine a road that's a perfectly straight infinitely long line.\n n cars are driving left to right; simultaneously, a different set of n cars\n are driving right to left. The two sets of cars start out being very far from\n each other. All cars move in the same speed. Two cars are said to collide\n when a car that's moving left to right hits a car that's moving right to left.\n However, the cars are infinitely sturdy and strong; as a result, they continue moving\n in their trajectory as if they did not collide.\n\n This function outputs the number of such collisions.\n \"\"\"\n\n return n\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/67": [{"task_id": "HumanEval/67", "solution": "\ndef fruit_distribution(s,n):\n \"\"\"\n In this task, you will be given a string that represents a number of apples and oranges \n that are distributed in a basket of fruit this basket contains \n apples, oranges, and mango fruits. Given the string that represents the total number of \n the oranges and apples and an integer that represent the total number of the fruits \n in the basket return the number of the mango fruits in the basket.\n for examble:\n fruit_distribution(\"5 apples and 6 oranges\", 19) ->19 - 5 - 6 = 8\n fruit_distribution(\"0 apples and 1 oranges\",3) -> 3 - 0 - 1 = 2\n fruit_distribution(\"2 apples and 3 oranges\", 100) -> 100 - 2 - 3 = 95\n fruit_distribution(\"100 apples and 1 oranges\",120) -> 120 - 100 - 1 = 19\n \"\"\"\n\n apples = int(s.split()[0])\n oranges = int(s.split()[3])\n mangoes = n - apples - oranges\n return mangoes\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/18": [{"task_id": "HumanEval/18", "solution": "\n\ndef how_many_times(string: str, substring: str) -> int:\n \"\"\" Find how many times a given substring can be found in the original string. Count overlaping cases.\n >>> how_many_times('', 'a')\n 0\n >>> how_many_times('aaa', 'a')\n 3\n >>> how_many_times('aaaa', 'aa')\n 3\n \"\"\"\n\n if not string or not substring:\n return 0\n count = 0\n start = 0\n while True:\n index = string.find(substring, start)\n if index == -1:\n break\n count += 1\n start = index + 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/20": [{"task_id": "HumanEval/20", "solution": "from typing import List, Tuple\n\n\ndef find_closest_elements(numbers: List[float]) -> Tuple[float, float]:\n \"\"\" From a supplied list of numbers (of length at least two) select and return two that are the closest to each\n other and return them in order (smaller number, larger number).\n >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])\n (2.0, 2.2)\n >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])\n (2.0, 2.0)\n \"\"\"\n\n numbers.sort()\n min_diff = float(\"inf\")\n min_pair = ()\n for i in range(len(numbers) - 1):\n diff = numbers[i + 1] - numbers[i]\n if diff < min_diff:\n min_diff = diff\n min_pair = (numbers[i], numbers[i + 1])\n return min_pair\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/29": [{"task_id": "HumanEval/29", "solution": "from typing import List\n\n\ndef filter_by_prefix(strings: List[str], prefix: str) -> List[str]:\n \"\"\" Filter an input list of strings only for ones that start with a given prefix.\n >>> filter_by_prefix([], 'a')\n []\n >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')\n ['abc', 'array']\n \"\"\"\n\n return [s for s in strings if s.startswith(prefix)]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/54": [{"task_id": "HumanEval/54", "solution": "\n\ndef same_chars(s0: str, s1: str):\n \"\"\"\n Check if two words have the same characters.\n >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')\n True\n >>> same_chars('abcd', 'dddddddabc')\n True\n >>> same_chars('dddddddabc', 'abcd')\n True\n >>> same_chars('eabcd', 'dddddddabc')\n False\n >>> same_chars('abcd', 'dddddddabce')\n False\n >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')\n False\n \"\"\"\n\n s0 = sorted(s0)\n s1 = sorted(s1)\n return s0 == s1\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["aaabbbccc", "abbabcbc"]]}], "HumanEval/32": [{"task_id": "HumanEval/32", "solution": "import math\n\n\ndef poly(xs: list, x: float):\n \"\"\"\n Evaluates polynomial with coefficients xs at point x.\n return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n\n \"\"\"\n return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])\n\n\ndef find_zero(xs: list):\n \"\"\" xs are coefficients of a polynomial.\n find_zero find x such that poly(x) = 0.\n find_zero returns only only zero point, even if there are many.\n Moreover, find_zero only takes list xs having even number of coefficients\n and largest non zero coefficient as it guarantees\n a solution.\n >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x\n -0.5\n >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3\n 1.0\n \"\"\"\n\n if len(xs) % 2!= 0:\n raise ValueError(\"xs must have an even number of coefficients\")\n if xs[-1] == 0:\n raise ValueError(\"The largest non-zero coefficient must be non-zero\")\n def newton_raphson(x):\n return x - poly(xs, x) / poly([i * coeff for i, coeff in enumerate(xs, 1)], x)\n x = 0\n for _ in range(100):\n x = newton_raphson(x)\n return x\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/27": [{"task_id": "HumanEval/27", "solution": "\n\ndef flip_case(string: str) -> str:\n \"\"\" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.\n >>> flip_case('Hello')\n 'hELLO'\n \"\"\"\n\n return ''.join(char.swapcase() for char in string)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/21": [{"task_id": "HumanEval/21", "solution": "from typing import List\n\n\ndef rescale_to_unit(numbers: List[float]) -> List[float]:\n \"\"\" Given list of numbers (of at least two elements), apply a linear transform to that list,\n such that the smallest number will become 0 and the largest will become 1\n >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])\n [0.0, 0.25, 0.5, 0.75, 1.0]\n \"\"\"\n\n min_val = min(numbers)\n max_val = max(numbers)\n return [(x - min_val) / (max_val - min_val) for x in numbers]\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[0.1, 0.5, 0.9, 0.3, 0.7]]]}], "HumanEval/52": [{"task_id": "HumanEval/52", "solution": "\n\ndef below_threshold(l: list, t: int):\n \"\"\"Return True if all numbers in the list l are below threshold t.\n >>> below_threshold([1, 2, 4, 10], 100)\n True\n >>> below_threshold([1, 20, 4, 10], 5)\n False\n \"\"\"\n\n for num in l:\n if num >= t:\n return False\n return True\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/55": [{"task_id": "HumanEval/55", "solution": "\n\ndef fib(n: int):\n \"\"\"Return n-th Fibonacci number.\n >>> fib(10)\n 55\n >>> fib(1)\n 1\n >>> fib(8)\n 21\n \"\"\"\n\n if n <= 2:\n return 1\n return fib(n - 1) + fib(n - 2)\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/33": [{"task_id": "HumanEval/33", "solution": "\n\ndef sort_third(l: list):\n \"\"\"This function takes a list l and returns a list l' such that\n l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal\n to the values of the corresponding indicies of l, but sorted.\n >>> sort_third([1, 2, 3])\n [1, 2, 3]\n >>> sort_third([5, 6, 3, 4, 8, 9, 2])\n [2, 6, 3, 4, 8, 9, 5]\n \"\"\"\n\n l_prime = []\n for i, val in enumerate(l):\n if i % 3 == 0:\n l_prime.append(sorted(l[i:i+3]))\n else:\n l_prime.append(val)\n return [item for sublist in l_prime for item in sublist]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/23": [{"task_id": "HumanEval/23", "solution": "\n\ndef strlen(string: str) -> int:\n \"\"\" Return length of given string\n >>> strlen('')\n 0\n >>> strlen('abc')\n 3\n \"\"\"\n\n return len(string)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/44": [{"task_id": "HumanEval/44", "solution": "\n\ndef change_base(x: int, base: int):\n \"\"\"Change numerical base of input number x to base.\n return string representation after the conversion.\n base numbers are less than 10.\n >>> change_base(8, 3)\n '22'\n >>> change_base(8, 2)\n '1000'\n >>> change_base(7, 2)\n '111'\n \"\"\"\n\n res = \"\"\n while x > 0:\n res = str(x % base) + res\n x //= base\n return res\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[0, 3]]}], "HumanEval/35": [{"task_id": "HumanEval/35", "solution": "\n\ndef max_element(l: list):\n \"\"\"Return maximum element in the list.\n >>> max_element([1, 2, 3])\n 3\n >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n 123\n \"\"\"\n\n max_element = l[0]\n for element in l:\n if element > max_element:\n max_element = element\n return max_element\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/46": [{"task_id": "HumanEval/46", "solution": "\n\ndef fib4(n: int):\n \"\"\"The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:\n fib4(0) -> 0\n fib4(1) -> 0\n fib4(2) -> 2\n fib4(3) -> 0\n fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).\n Please write a function to efficiently compute the n-th element of the fib4 number sequence. Do not use recursion.\n >>> fib4(5)\n 4\n >>> fib4(6)\n 8\n >>> fib4(7)\n 14\n \"\"\"\n\n if n < 0:\n raise ValueError(\"n must be a non-negative integer\")\n if n == 0:\n return 0\n if n == 1:\n return 0\n if n == 2:\n return 2\n if n == 3:\n return 0\n fib_list = [0, 0, 2, 0]\n for i in range(4, n + 1):\n fib_list.append(fib_list[i - 1] + fib_list[i - 2] + fib_list[i - 3] + fib_list[i - 4])\n return fib_list[-1]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/37": [{"task_id": "HumanEval/37", "solution": "\n\ndef sort_even(l: list):\n \"\"\"This function takes a list l and returns a list l' such that\n l' is identical to l in the odd indicies, while its values at the even indicies are equal\n to the values of the even indicies of l, but sorted.\n >>> sort_even([1, 2, 3])\n [1, 2, 3]\n >>> sort_even([5, 6, 3, 4])\n [3, 6, 5, 4]\n \"\"\"\n\n even_indicies = [i for i in range(len(l)) if i % 2 == 0]\n even_values = [l[i] for i in even_indicies]\n sorted_even_values = sorted(even_values)\n result = [None] * len(l)\n for i in even_indicies:\n result[i] = sorted_even_values.pop(0)\n for i in range(len(l)):\n if i not in even_indicies:\n result[i] = l[i]\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/22": [{"task_id": "HumanEval/22", "solution": "from typing import List, Any\n\n\ndef filter_integers(values: List[Any]) -> List[int]:\n \"\"\" Filter given list of any python values only for integers\n >>> filter_integers(['a', 3.14, 5])\n [5]\n >>> filter_integers([1, 2, 3, 'abc', {}, []])\n [1, 2, 3]\n \"\"\"\n\n return [value for value in values if isinstance(value, int)]\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[true, false, null, 0, -10, "test", [], {}, 3.14]]]}], "HumanEval/45": [{"task_id": "HumanEval/45", "solution": "\n\ndef triangle_area(a, h):\n \"\"\"Given length of a side and high return area for a triangle.\n >>> triangle_area(5, 3)\n 7.5\n \"\"\"\n\n return 0.5 * a * h\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/28": [{"task_id": "HumanEval/28", "solution": "from typing import List\n\n\ndef concatenate(strings: List[str]) -> str:\n \"\"\" Concatenate list of strings into a single string\n >>> concatenate([])\n ''\n >>> concatenate(['a', 'b', 'c'])\n 'abc'\n \"\"\"\n\n return \"\".join(strings)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/72": [{"task_id": "HumanEval/72", "solution": "\ndef will_it_fly(q,w):\n '''\n Write a function that returns True if the object q will fly, and False otherwise.\n The object q will fly if it's balanced (it is a palindromic list) and the sum of its elements is less than or equal the maximum possible weight w.\n\n Example:\n will_it_fly([1, 2], 5) \u279e False \n # 1+2 is less than the maximum possible weight, but it's unbalanced.\n\n will_it_fly([3, 2, 3], 1) \u279e False\n # it's balanced, but 3+2+3 is more than the maximum possible weight.\n\n will_it_fly([3, 2, 3], 9) \u279e True\n # 3+2+3 is less than the maximum possible weight, and it's balanced.\n\n will_it_fly([3], 5) \u279e True\n # 3 is less than the maximum possible weight, and it's balanced.\n '''\n\n def is_palindrome(lst):\n return lst == lst[::-1]\n return is_palindrome(q) and sum(q) <= w\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/47": [{"task_id": "HumanEval/47", "solution": "\n\ndef median(l: list):\n \"\"\"Return median of elements in the list l.\n >>> median([3, 1, 2, 4, 5])\n 3\n >>> median([-10, 4, 6, 1000, 10, 20])\n 15.0\n \"\"\"\n\n l.sort()\n n = len(l)\n if n % 2 == 1:\n return l[n // 2]\n else:\n return (l[n // 2 - 1] + l[n // 2]) / 2\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/30": [{"task_id": "HumanEval/30", "solution": "\n\ndef get_positive(l: list):\n \"\"\"Return only positive numbers in the list.\n >>> get_positive([-1, 2, -4, 5, 6])\n [2, 5, 6]\n >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n [5, 3, 2, 3, 9, 123, 1]\n \"\"\"\n\n return [x for x in l if x > 0]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/34": [{"task_id": "HumanEval/34", "solution": "\n\ndef unique(l: list):\n \"\"\"Return sorted unique elements in a list\n >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])\n [0, 2, 3, 5, 9, 123]\n \"\"\"\n\n return sorted(set(l))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/26": [{"task_id": "HumanEval/26", "solution": "from typing import List\n\n\ndef remove_duplicates(numbers: List[int]) -> List[int]:\n \"\"\" From a list of integers, remove all elements that occur more than once.\n Keep order of elements left the same as in the input.\n >>> remove_duplicates([1, 2, 3, 2, 4])\n [1, 3, 4]\n \"\"\"\n\n unique_numbers = set()\n result = []\n for number in numbers:\n if number not in unique_numbers:\n unique_numbers.add(number)\n result.append(number)\n return result\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[[1, 2, 3, 2, 4, 3, 5]]], "plus_fail_tests": []}], "HumanEval/63": [{"task_id": "HumanEval/63", "solution": "\n\ndef fibfib(n: int):\n \"\"\"The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:\n fibfib(0) == 0\n fibfib(1) == 0\n fibfib(2) == 1\n fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).\n Please write a function to efficiently compute the n-th element of the fibfib number sequence.\n >>> fibfib(1)\n 0\n >>> fibfib(5)\n 4\n >>> fibfib(8)\n 24\n \"\"\"\n\n if n == 0 or n == 1:\n return 0\n if n == 2:\n return 1\n a, b, c = 0, 0, 1\n for _ in range(3, n + 1):\n a, b, c = b, c, a + b + c\n return c\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/59": [{"task_id": "HumanEval/59", "solution": "\n\ndef largest_prime_factor(n: int):\n \"\"\"Return the largest prime factor of n. Assume n > 1 and is not a prime.\n >>> largest_prime_factor(13195)\n 29\n >>> largest_prime_factor(2048)\n 2\n \"\"\"\n\n if n < 2:\n raise ValueError(\"n must be greater than 1\")\n if n == 2:\n return 2\n if n % 2 == 0:\n return largest_prime_factor(n // 2)\n for i in range(3, int(n ** 0.5) + 1, 2):\n if n % i == 0:\n return largest_prime_factor(n // i)\n return n\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/60": [{"task_id": "HumanEval/60", "solution": "\n\ndef sum_to_n(n: int):\n \"\"\"sum_to_n is a function that sums numbers from 1 to n.\n >>> sum_to_n(30)\n 465\n >>> sum_to_n(100)\n 5050\n >>> sum_to_n(5)\n 15\n >>> sum_to_n(10)\n 55\n >>> sum_to_n(1)\n 1\n \"\"\"\n\n return n * (n + 1) // 2\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/53": [{"task_id": "HumanEval/53", "solution": "\n\ndef add(x: int, y: int):\n \"\"\"Add two numbers x and y\n >>> add(2, 3)\n 5\n >>> add(5, 7)\n 12\n \"\"\"\n\n return x + y\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/77": [{"task_id": "HumanEval/77", "solution": "\ndef iscube(a):\n '''\n Write a function that takes an integer a and returns True \n if this ingeger is a cube of some integer number.\n Note: you may assume the input is always valid.\n Examples:\n iscube(1) ==> True\n iscube(2) ==> False\n iscube(-1) ==> True\n iscube(64) ==> True\n iscube(0) ==> True\n iscube(180) ==> False\n '''\n\n if a == 0:\n return True\n if a < 0:\n a = -a\n x = a ** (1/3)\n if x.is_integer():\n return True\n return False\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[64]], "plus_fail_tests": [[125]]}], "HumanEval/42": [{"task_id": "HumanEval/42", "solution": "\n\ndef incr_list(l: list):\n \"\"\"Return list with elements incremented by 1.\n >>> incr_list([1, 2, 3])\n [2, 3, 4]\n >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])\n [6, 4, 6, 3, 4, 4, 10, 1, 124]\n \"\"\"\n\n return [x + 1 for x in l]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/68": [{"task_id": "HumanEval/68", "solution": "\ndef pluck(arr):\n \"\"\"\n \"Given an array representing a branch of a tree that has non-negative integer nodes\n your task is to pluck one of the nodes and return it.\n The plucked node should be the node with the smallest even value.\n If multiple nodes with the same smallest even value are found return the node that has smallest index.\n\n The plucked node should be returned in a list, [ smalest_value, its index ],\n If there are no even values or the given array is empty, return [].\n\n Example 1:\n Input: [4,2,3]\n Output: [2, 1]\n Explanation: 2 has the smallest even value, and 2 has the smallest index.\n\n Example 2:\n Input: [1,2,3]\n Output: [2, 1]\n Explanation: 2 has the smallest even value, and 2 has the smallest index. \n\n Example 3:\n Input: []\n Output: []\n \n Example 4:\n Input: [5, 0, 3, 0, 4, 2]\n Output: [0, 1]\n Explanation: 0 is the smallest value, but there are two zeros,\n so we will choose the first zero, which has the smallest index.\n\n Constraints:\n * 1 <= nodes.length <= 10000\n * 0 <= node.value\n \"\"\"\n\n smallest_even_value = float('inf')\n smallest_even_index = -1\n for i, value in enumerate(arr):\n if value % 2 == 0 and value < smallest_even_value:\n smallest_even_value = value\n smallest_even_index = i\n if smallest_even_value == float('inf'):\n return []\n return [smallest_even_value, smallest_even_index]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/76": [{"task_id": "HumanEval/76", "solution": "\ndef is_simple_power(x, n):\n \"\"\"Your task is to write a function that returns true if a number x is a simple\n power of n and false in other cases.\n x is a simple power of n if n**int=x\n For example:\n is_simple_power(1, 4) => true\n is_simple_power(2, 2) => true\n is_simple_power(8, 2) => true\n is_simple_power(3, 2) => false\n is_simple_power(3, 1) => false\n is_simple_power(5, 3) => false\n \"\"\"\n\n if x == 1:\n return True\n if x == n:\n return False\n while x % n == 0:\n x //= n\n return x == 1\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[5, 5]]}], "HumanEval/48": [{"task_id": "HumanEval/48", "solution": "\n\ndef is_palindrome(text: str):\n \"\"\"\n Checks if given string is a palindrome\n >>> is_palindrome('')\n True\n >>> is_palindrome('aba')\n True\n >>> is_palindrome('aaaaa')\n True\n >>> is_palindrome('zbcd')\n False\n \"\"\"\n\n return text == text[::-1]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/51": [{"task_id": "HumanEval/51", "solution": "\n\ndef remove_vowels(text):\n \"\"\"\n remove_vowels is a function that takes string and returns string without vowels.\n >>> remove_vowels('')\n ''\n >>> remove_vowels(\"abcdef\\nghijklm\")\n 'bcdf\\nghjklm'\n >>> remove_vowels('abcdef')\n 'bcdf'\n >>> remove_vowels('aaaaa')\n ''\n >>> remove_vowels('aaBAA')\n 'B'\n >>> remove_vowels('zbcd')\n 'zbcd'\n \"\"\"\n\n vowels = 'aeiouAEIOU'\n result = ''\n for char in text:\n if char not in vowels:\n result += char\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/73": [{"task_id": "HumanEval/73", "solution": "\ndef smallest_change(arr):\n \"\"\"\n Given an array arr of integers, find the minimum number of elements that\n need to be changed to make the array palindromic. A palindromic array is an array that\n is read the same backwards and forwards. In one change, you can change one element to any other element.\n\n For example:\n smallest_change([1,2,3,5,4,7,9,6]) == 4\n smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1\n smallest_change([1, 2, 3, 2, 1]) == 0\n \"\"\"\n\n n = len(arr)\n dp = [[0] * n for _ in range(n)]\n for i in range(n):\n dp[i][i] = 1\n for l in range(2, n + 1):\n for i in range(n - l + 1):\n j = i + l - 1\n if arr[i] == arr[j]:\n dp[i][j] = dp[i + 1][j - 1]\n else:\n dp[i][j] = 1 + min(dp[i + 1][j], dp[i][j - 1])\n return dp[0][n - 1]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/64": [{"task_id": "HumanEval/64", "solution": "\nFIX = \"\"\"\nAdd more test cases.\n\"\"\"\n\ndef vowels_count(s):\n \"\"\"Write a function vowels_count which takes a string representing\n a word as input and returns the number of vowels in the string.\n Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a\n vowel, but only when it is at the end of the given word.\n\n Example:\n >>> vowels_count(\"abcde\")\n 2\n >>> vowels_count(\"ACEDY\")\n 3\n \"\"\"\n\n vowels = 'aeiou'\n count = 0\n for char in s.lower():\n if char in vowels:\n count += 1\n return count\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [["key"]], "plus_fail_tests": [["candy"]]}], "HumanEval/62": [{"task_id": "HumanEval/62", "solution": "\n\ndef derivative(xs: list):\n \"\"\" xs represent coefficients of a polynomial.\n xs[0] + xs[1] * x + xs[2] * x^2 + ....\n Return derivative of this polynomial in the same form.\n >>> derivative([3, 1, 2, 4, 5])\n [1, 4, 12, 20]\n >>> derivative([1, 2, 3])\n [2, 6]\n \"\"\"\n\n derivative = []\n for i, x in enumerate(xs):\n derivative.append(x * i)\n return derivative[1:]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/50": [{"task_id": "HumanEval/50", "solution": "\n\ndef encode_shift(s: str):\n \"\"\"\n returns encoded string by shifting every character by 5 in the alphabet.\n \"\"\"\n return \"\".join([chr(((ord(ch) + 5 - ord(\"a\")) % 26) + ord(\"a\")) for ch in s])\n\n\ndef decode_shift(s: str):\n \"\"\"\n takes as input string encoded with encode_shift function. Returns decoded string.\n \"\"\"\n\n return \"\".join([chr(((ord(ch) - 5 - ord(\"a\")) % 26) + ord(\"a\")) for ch in s])\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/71": [{"task_id": "HumanEval/71", "solution": "\ndef triangle_area(a, b, c):\n '''\n Given the lengths of the three sides of a triangle. Return the area of\n the triangle rounded to 2 decimal points if the three sides form a valid triangle. \n Otherwise return -1\n Three sides make a valid triangle when the sum of any two sides is greater \n than the third side.\n Example:\n triangle_area(3, 4, 5) == 6.00\n triangle_area(1, 2, 10) == -1\n '''\n\n if a + b <= c or a + c <= b or b + c <= a:\n return -1\n s = (a + b + c) / 2\n area = (s * (s - a) * (s - b) * (s - c)) ** 0.5\n return round(area, 2)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/38": [{"task_id": "HumanEval/38", "solution": "\n\ndef encode_cyclic(s: str):\n \"\"\"\n returns encoded string by cycling groups of three characters.\n \"\"\"\n # split string to groups. Each of length 3.\n groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]\n # cycle elements in each group. Unless group has fewer elements than 3.\n groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]\n return \"\".join(groups)\n\n\ndef decode_cyclic(s: str):\n \"\"\"\n takes as input string encoded with encode_cyclic function. Returns decoded string.\n \"\"\"\n\n groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]\n groups = [(group[-1:] + group[:-1]) if len(group) == 3 else group for group in groups]\n return \"\".join(groups)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/69": [{"task_id": "HumanEval/69", "solution": "\ndef search(lst):\n '''\n You are given a non-empty list of positive integers. Return the greatest integer that is greater than \n zero, and has a frequency greater than or equal to the value of the integer itself. \n The frequency of an integer is the number of times it appears in the list.\n If no such a value exist, return -1.\n Examples:\n search([4, 1, 2, 2, 3, 1]) == 2\n search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3\n search([5, 5, 4, 4, 4]) == -1\n '''\n\n freq = {}\n for num in lst:\n freq[num] = freq.get(num, 0) + 1\n for num in sorted(freq, reverse=True):\n if freq[num] >= num:\n return num\n return -1\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/70": [{"task_id": "HumanEval/70", "solution": "\ndef strange_sort_list(lst):\n '''\n Given list of integers, return list in strange order.\n Strange sorting, is when you start with the minimum value,\n then maximum of the remaining integers, then minimum and so on.\n\n Examples:\n strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]\n strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]\n strange_sort_list([]) == []\n '''\n\n result = []\n while lst:\n result.append(min(lst))\n lst.remove(min(lst))\n if lst:\n result.append(max(lst))\n lst.remove(max(lst))\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/56": [{"task_id": "HumanEval/56", "solution": "\n\ndef correct_bracketing(brackets: str):\n \"\"\" brackets is a string of \"<\" and \">\".\n return True if every opening bracket has a corresponding closing bracket.\n\n >>> correct_bracketing(\"<\")\n False\n >>> correct_bracketing(\"<>\")\n True\n >>> correct_bracketing(\"<<><>>\")\n True\n >>> correct_bracketing(\"><<>\")\n False\n \"\"\"\n\n stack = []\n for bracket in brackets:\n if bracket == \"<\":\n stack.append(bracket)\n elif bracket == \">\":\n if not stack:\n return False\n stack.pop()\n return not stack\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/58": [{"task_id": "HumanEval/58", "solution": "\n\ndef common(l1: list, l2: list):\n \"\"\"Return sorted unique common elements for two lists.\n >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])\n [1, 5, 653]\n >>> common([5, 3, 2, 8], [3, 2])\n [2, 3]\n\n \"\"\"\n\n return sorted(set(l1) & set(l2))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/43": [{"task_id": "HumanEval/43", "solution": "\n\ndef pairs_sum_to_zero(l):\n \"\"\"\n pairs_sum_to_zero takes a list of integers as an input.\n it returns True if there are two distinct elements in the list that\n sum to zero, and False otherwise.\n >>> pairs_sum_to_zero([1, 3, 5, 0])\n False\n >>> pairs_sum_to_zero([1, 3, -2, 1])\n False\n >>> pairs_sum_to_zero([1, 2, 3, 7])\n False\n >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])\n True\n >>> pairs_sum_to_zero([1])\n False\n \"\"\"\n\n for i in range(len(l)):\n for j in range(i + 1, len(l)):\n if l[i] + l[j] == 0:\n return True\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/49": [{"task_id": "HumanEval/49", "solution": "\n\ndef modp(n: int, p: int):\n \"\"\"Return 2^n modulo p (be aware of numerics).\n >>> modp(3, 5)\n 3\n >>> modp(1101, 101)\n 2\n >>> modp(0, 101)\n 1\n >>> modp(3, 11)\n 8\n >>> modp(100, 101)\n 1\n \"\"\"\n\n if n == 0:\n return 1 % p\n if n % 2 == 0:\n return (modp(n // 2, p) ** 2) % p\n else:\n return (2 * modp(n // 2, p) ** 2) % p\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/57": [{"task_id": "HumanEval/57", "solution": "\n\ndef monotonic(l: list):\n \"\"\"Return True is list elements are monotonically increasing or decreasing.\n >>> monotonic([1, 2, 4, 20])\n True\n >>> monotonic([1, 20, 4, 10])\n False\n >>> monotonic([4, 1, 0, -10])\n True\n \"\"\"\n\n if len(l) < 2:\n return True\n direction = l[1] - l[0]\n for i in range(1, len(l) - 1):\n diff = l[i + 1] - l[i]\n if diff == 0:\n continue\n if direction == 0:\n direction = diff\n elif direction * diff < 0:\n return False\n return True\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/78": [{"task_id": "HumanEval/78", "solution": "\ndef hex_key(num):\n \"\"\"You have been tasked to write a function that receives \n a hexadecimal number as a string and counts the number of hexadecimal \n digits that are primes (prime number, or a prime, is a natural number \n greater than 1 that is not a product of two smaller natural numbers).\n Hexadecimal digits are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.\n Prime numbers are 2, 3, 5, 7, 11, 13, 17,...\n So you have to determine a number of the following digits: 2, 3, 5, 7, \n B (=decimal 11), D (=decimal 13).\n Note: you may assume the input is always correct or empty string, \n and symbols A,B,C,D,E,F are always uppercase.\n Examples:\n For num = \"AB\" the output should be 1.\n For num = \"1077E\" the output should be 2.\n For num = \"ABED1A33\" the output should be 4.\n For num = \"123456789ABCDEF0\" the output should be 6.\n For num = \"2020\" the output should be 2.\n \"\"\"\n\n prime_digits = {2, 3, 5, 7, 11, 13}\n count = 0\n for digit in num:\n if int(digit, 16) in prime_digits:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/74": [{"task_id": "HumanEval/74", "solution": "\ndef total_match(lst1, lst2):\n '''\n Write a function that accepts two lists of strings and returns the list that has \n total number of chars in the all strings of the list less than the other list.\n\n if the two lists have the same number of chars, return the first list.\n\n Examples\n total_match([], []) \u279e []\n total_match(['hi', 'admin'], ['hI', 'Hi']) \u279e ['hI', 'Hi']\n total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) \u279e ['hi', 'admin']\n total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) \u279e ['hI', 'hi', 'hi']\n total_match(['4'], ['1', '2', '3', '4', '5']) \u279e ['4']\n '''\n\n total_lst1 = sum(len(s) for s in lst1)\n total_lst2 = sum(len(s) for s in lst2)\n if total_lst1 < total_lst2:\n return lst1\n elif total_lst2 < total_lst1:\n return lst2\n else:\n return lst1\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/66": [{"task_id": "HumanEval/66", "solution": "\ndef digitSum(s):\n \"\"\"Task\n Write a function that takes a string as input and returns the sum of the upper characters only'\n ASCII codes.\n\n Examples:\n digitSum(\"\") => 0\n digitSum(\"abAB\") => 131\n digitSum(\"abcCd\") => 67\n digitSum(\"helloE\") => 69\n digitSum(\"woArBld\") => 131\n digitSum(\"aAaaaXa\") => 153\n \"\"\"\n\n sum = 0\n for c in s:\n if c.isupper():\n sum += ord(c)\n return sum\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/61": [{"task_id": "HumanEval/61", "solution": "\n\ndef correct_bracketing(brackets: str):\n \"\"\" brackets is a string of \"(\" and \")\".\n return True if every opening bracket has a corresponding closing bracket.\n\n >>> correct_bracketing(\"(\")\n False\n >>> correct_bracketing(\"()\")\n True\n >>> correct_bracketing(\"(()())\")\n True\n >>> correct_bracketing(\")(()\")\n False\n \"\"\"\n\n stack = []\n for bracket in brackets:\n if bracket == \"(\":\n stack.append(bracket)\n elif bracket == \")\":\n if not stack:\n return False\n stack.pop()\n return not stack\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/40": [{"task_id": "HumanEval/40", "solution": "\n\ndef triples_sum_to_zero(l: list):\n \"\"\"\n triples_sum_to_zero takes a list of integers as an input.\n it returns True if there are three distinct elements in the list that\n sum to zero, and False otherwise.\n\n >>> triples_sum_to_zero([1, 3, 5, 0])\n False\n >>> triples_sum_to_zero([1, 3, -2, 1])\n True\n >>> triples_sum_to_zero([1, 2, 3, 7])\n False\n >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])\n True\n >>> triples_sum_to_zero([1])\n False\n \"\"\"\n\n if len(l) < 3:\n return False\n for i in range(len(l) - 2):\n for j in range(i + 1, len(l) - 1):\n for k in range(j + 1, len(l)):\n if l[i] + l[j] + l[k] == 0:\n return True\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/65": [{"task_id": "HumanEval/65", "solution": "\ndef circular_shift(x, shift):\n \"\"\"Circular shift the digits of the integer x, shift the digits right by shift\n and return the result as a string.\n If shift > number of digits, return digits reversed.\n >>> circular_shift(12, 1)\n \"21\"\n >>> circular_shift(12, 2)\n \"12\"\n \"\"\"\n\n x_str = str(x)\n x_len = len(x_str)\n if shift > x_len:\n return x_str[::-1]\n else:\n return x_str[x_len - shift:] + x_str[:x_len - shift]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/79": [{"task_id": "HumanEval/79", "solution": "\ndef decimal_to_binary(decimal):\n \"\"\"You will be given a number in decimal form and your task is to convert it to\n binary format. The function should return a string, with each character representing a binary\n number. Each character in the string will be '0' or '1'.\n\n There will be an extra couple of characters 'db' at the beginning and at the end of the string.\n The extra characters are there to help with the format.\n\n Examples:\n decimal_to_binary(15) # returns \"db1111db\"\n decimal_to_binary(32) # returns \"db100000db\"\n \"\"\"\n\n binary = bin(decimal)[2:]\n return \"db\" + binary + \"db\"\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/75": [{"task_id": "HumanEval/75", "solution": "\ndef is_multiply_prime(a):\n \"\"\"Write a function that returns true if the given number is the multiplication of 3 prime numbers\n and false otherwise.\n Knowing that (a) is less then 100. \n Example:\n is_multiply_prime(30) == True\n 30 = 2 * 3 * 5\n \"\"\"\n\n prime_numbers = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n if a in prime_numbers:\n return False\n for i in prime_numbers:\n for j in prime_numbers:\n for k in prime_numbers:\n if i * j * k == a:\n return True\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/80": [{"task_id": "HumanEval/80", "solution": "\ndef is_happy(s):\n \"\"\"You are given a string s.\n Your task is to check if the string is happy or not.\n A string is happy if its length is at least 3 and every 3 consecutive letters are distinct\n For example:\n is_happy(a) => False\n is_happy(aa) => False\n is_happy(abcd) => True\n is_happy(aabb) => False\n is_happy(adb) => True\n is_happy(xyy) => False\n \"\"\"\n\n if len(s) < 3:\n return False\n\n for i in range(0, len(s) - 2):\n if s[i] == s[i+1] == s[i+2]:\n return False\n\n return True\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [["aabb"]], "plus_fail_tests": [["agbebf"]]}], "HumanEval/84": [{"task_id": "HumanEval/84", "solution": "\ndef solve(N):\n \"\"\"Given a positive integer N, return the total sum of its digits in binary.\n \n Example\n For N = 1000, the sum of digits will be 1 the output should be \"1\".\n For N = 150, the sum of digits will be 6 the output should be \"110\".\n For N = 147, the sum of digits will be 12 the output should be \"1100\".\n \n Variables:\n @N integer\n Constraints: 0 \u2264 N \u2264 10000.\n Output:\n a string of binary number\n \"\"\"\n\n binary_string = bin(N)[2:]\n total_sum = sum(int(digit) for digit in binary_string)\n return str(total_sum)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[10]]}], "HumanEval/91": [{"task_id": "HumanEval/91", "solution": "\ndef is_bored(S):\n \"\"\"\n You'll be given a string of words, and your task is to count the number\n of boredoms. A boredom is a sentence that starts with the word \"I\".\n Sentences are delimited by '.', '?' or '!'.\n \n For example:\n >>> is_bored(\"Hello world\")\n 0\n >>> is_bored(\"The sky is blue. The sun is shining. I love this weather\")\n 1\n \"\"\"\n\n boredoms = 0\n sentences = S.split('.')\n for sentence in sentences:\n words = sentence.split()\n if len(words) > 0 and words[0] == 'I':\n boredoms += 1\n return boredoms\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["Have you ever gone skydiving before? I did it once and it was amazing."]]}], "HumanEval/81": [{"task_id": "HumanEval/81", "solution": "\ndef numerical_letter_grade(grades):\n \"\"\"It is the last week of the semester and the teacher has to give the grades\n to students. The teacher has been making her own algorithm for grading.\n The only problem is, she has lost the code she used for grading.\n She has given you a list of GPAs for some students and you have to write \n a function that can output a list of letter grades using the following table:\n GPA | Letter grade\n 4.0 A+\n > 3.7 A \n > 3.3 A- \n > 3.0 B+\n > 2.7 B \n > 2.3 B-\n > 2.0 C+\n > 1.7 C\n > 1.3 C-\n > 1.0 D+ \n > 0.7 D \n > 0.0 D-\n 0.0 E\n \n\n Example:\n grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']\n \"\"\"\n\n letter_grades = []\n for gpa in grades:\n if gpa >= 4.0:\n letter_grades.append('A+')\n elif gpa >= 3.7:\n letter_grades.append('A')\n elif gpa >= 3.3:\n letter_grades.append('A-')\n elif gpa >= 3.0:\n letter_grades.append('B+')\n elif gpa >= 2.7:\n letter_grades.append('B')\n elif gpa >= 2.3:\n letter_grades.append('B-')\n elif gpa >= 2.0:\n letter_grades.append('C+')\n elif gpa >= 1.7:\n letter_grades.append('C')\n elif gpa >= 1.3:\n letter_grades.append('C-')\n elif gpa >= 1.0:\n letter_grades.append('D+')\n elif gpa >= 0.7:\n letter_grades.append('D')\n elif gpa >= 0.0:\n letter_grades.append('D-')\n else:\n letter_grades.append('E')\n return letter_grades\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/89": [{"task_id": "HumanEval/89", "solution": "\ndef encrypt(s):\n \"\"\"Create a function encrypt that takes a string as an argument and\n returns a string encrypted with the alphabet being rotated. \n The alphabet should be rotated in a manner such that the letters \n shift down by two multiplied to two places.\n For example:\n encrypt('hi') returns 'lm'\n encrypt('asdfghjkl') returns 'ewhjklnop'\n encrypt('gf') returns 'kj'\n encrypt('et') returns 'ix'\n \"\"\"\n\n alphabet = 'abcdefghijklmnopqrstuvwxyz'\n rotated_alphabet = alphabet[2:] + alphabet[:2]\n encrypted_string = ''\n for char in s:\n if char.isalpha():\n index = alphabet.index(char)\n encrypted_string += rotated_alphabet[index]\n else:\n encrypted_string += char\n return encrypted_string\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/82": [{"task_id": "HumanEval/82", "solution": "\ndef prime_length(string):\n \"\"\"Write a function that takes a string and returns True if the string\n length is a prime number or False otherwise\n Examples\n prime_length('Hello') == True\n prime_length('abcdcba') == True\n prime_length('kittens') == True\n prime_length('orange') == False\n \"\"\"\n\n length = len(string)\n if length < 2:\n return False\n for i in range(2, length):\n if length % i == 0:\n return False\n return True\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/93": [{"task_id": "HumanEval/93", "solution": "\ndef encode(message):\n \"\"\"\n Write a function that takes a message, and encodes in such a \n way that it swaps case of all letters, replaces all vowels in \n the message with the letter that appears 2 places ahead of that \n vowel in the english alphabet. \n Assume only letters. \n \n Examples:\n >>> encode('test')\n 'TGST'\n >>> encode('This is a message')\n 'tHKS KS C MGSSCGG'\n \"\"\"\n\n vowels = 'aeiou'\n encoded_message = ''\n for char in message:\n if char.isalpha():\n if char.lower() in vowels:\n encoded_message += chr((ord(char) - ord('a') + 2) % 26 + ord('a'))\n else:\n encoded_message += chr(ord(char) ^ 32)\n else:\n encoded_message += char\n return encoded_message\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/86": [{"task_id": "HumanEval/86", "solution": "\ndef anti_shuffle(s):\n \"\"\"\n Write a function that takes a string and returns an ordered version of it.\n Ordered version of string, is a string where all words (separated by space)\n are replaced by a new word where all the characters arranged in\n ascending order based on ascii value.\n Note: You should keep the order of words and blank spaces in the sentence.\n\n For example:\n anti_shuffle('Hi') returns 'Hi'\n anti_shuffle('hello') returns 'ehllo'\n anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'\n \"\"\"\n\n words = s.split()\n for i, word in enumerate(words):\n words[i] = \"\".join(sorted(word))\n return \" \".join(words)\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["\n\n123 456\n789\n"]]}], "HumanEval/99": [{"task_id": "HumanEval/99", "solution": "\ndef closest_integer(value):\n '''\n Create a function that takes a value (string) representing a number\n and returns the closest integer to it. If the number is equidistant\n from two integers, round it away from zero.\n\n Examples\n >>> closest_integer(\"10\")\n 10\n >>> closest_integer(\"15.3\")\n 15\n\n Note:\n Rounding away from zero means that if the given number is equidistant\n from two integers, the one you should return is the one that is the\n farthest from zero. For example closest_integer(\"14.5\") should\n return 15 and closest_integer(\"-14.5\") should return -15.\n '''\n\n number = float(value)\n rounded = round(number)\n if number > 0:\n return rounded if abs(number - rounded) < 0.5 else rounded + 1\n else:\n return rounded if abs(number - rounded) <= 0.5 else rounded - 1\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["5.5"]]}], "HumanEval/97": [{"task_id": "HumanEval/97", "solution": "\ndef multiply(a, b):\n \"\"\"Complete the function that takes two integers and returns \n the product of their unit digits.\n Assume the input is always valid.\n Examples:\n multiply(148, 412) should return 16.\n multiply(19, 28) should return 72.\n multiply(2020, 1851) should return 0.\n multiply(14,-15) should return 20.\n \"\"\"\n\n return (a % 10) * (b % 10)\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/83": [{"task_id": "HumanEval/83", "solution": "\ndef starts_one_ends(n):\n \"\"\"\n Given a positive integer n, return the count of the numbers of n-digit\n positive integers that start or end with 1.\n \"\"\"\n\n if n == 1:\n return 2\n return 10 * starts_one_ends(n - 1)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/92": [{"task_id": "HumanEval/92", "solution": "\ndef any_int(x, y, z):\n '''\n Create a function that takes 3 numbers.\n Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.\n Returns false in any other cases.\n \n Examples\n any_int(5, 2, 7) \u279e True\n \n any_int(3, 2, 2) \u279e False\n\n any_int(3, -2, 1) \u279e True\n \n any_int(3.6, -2.2, 2) \u279e False\n \n\n \n '''\n\n if not (isinstance(x, int) and isinstance(y, int) and isinstance(z, int)):\n return False\n return x == y + z or y == x + z or z == x + y\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/85": [{"task_id": "HumanEval/85", "solution": "\ndef add(lst):\n \"\"\"Given a non-empty list of integers lst. add the even elements that are at odd indices..\n\n\n Examples:\n add([4, 2, 6, 7]) ==> 2 \n \"\"\"\n\n return sum(x for i, x in enumerate(lst) if i % 2 == 0 and x % 2 == 0)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[2, 4, 6, 8]]]}], "HumanEval/87": [{"task_id": "HumanEval/87", "solution": "\ndef get_row(lst, x):\n \"\"\"\n You are given a 2 dimensional data, as a nested lists,\n which is similar to matrix, however, unlike matrices,\n each row may contain a different number of columns.\n Given lst, and integer x, find integers x in the list,\n and return list of tuples, [(x1, y1), (x2, y2) ...] such that\n each tuple is a coordinate - (row, columns), starting with 0.\n Sort coordinates initially by rows in ascending order.\n Also, sort coordinates of the row by columns in descending order.\n \n Examples:\n get_row([\n [1,2,3,4,5,6],\n [1,2,3,4,1,6],\n [1,2,3,4,5,1]\n ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]\n get_row([], 1) == []\n get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]\n \"\"\"\n\n coordinates = []\n for row, values in enumerate(lst):\n for col, val in enumerate(values):\n if val == x:\n coordinates.append((row, col))\n coordinates.sort(key=lambda x: (x[0], -x[1]))\n return coordinates\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/95": [{"task_id": "HumanEval/95", "solution": "\ndef check_dict_case(dict):\n \"\"\"\n Given a dictionary, return True if all keys are strings in lower \n case or all keys are strings in upper case, else return False.\n The function should return False is the given dictionary is empty.\n Examples:\n check_dict_case({\"a\":\"apple\", \"b\":\"banana\"}) should return True.\n check_dict_case({\"a\":\"apple\", \"A\":\"banana\", \"B\":\"banana\"}) should return False.\n check_dict_case({\"a\":\"apple\", 8:\"banana\", \"a\":\"apple\"}) should return False.\n check_dict_case({\"Name\":\"John\", \"Age\":\"36\", \"City\":\"Houston\"}) should return False.\n check_dict_case({\"STATE\":\"NC\", \"ZIP\":\"12345\" }) should return True.\n \"\"\"\n\n if not dict:\n return False\n first_key = next(iter(dict))\n if isinstance(first_key, str):\n return all(isinstance(key, str) and (key.islower() or key.isupper()) for key in dict)\n else:\n return False\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[{"p": "pineapple", "A": "banana", "B": "banana"}]], "plus_fail_tests": [[{"PI": 1.7300435058060522, "new yorrk": 2.2762868739904514}]]}], "HumanEval/96": [{"task_id": "HumanEval/96", "solution": "\ndef count_up_to(n):\n \"\"\"Implement a function that takes an non-negative integer and returns an array of the first n\n integers that are prime numbers and less than n.\n for example:\n count_up_to(5) => [2,3]\n count_up_to(11) => [2,3,5,7]\n count_up_to(0) => []\n count_up_to(20) => [2,3,5,7,11,13,17,19]\n count_up_to(1) => []\n count_up_to(18) => [2,3,5,7,11,13,17]\n \"\"\"\n\n if n < 2:\n return []\n primes = [2]\n for i in range(3, n, 2):\n is_prime = True\n for p in primes:\n if i % p == 0:\n is_prime = False\n break\n if is_prime:\n primes.append(i)\n return primes\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/90": [{"task_id": "HumanEval/90", "solution": "\ndef next_smallest(lst):\n \"\"\"\n You are given a list of integers.\n Write a function next_smallest() that returns the 2nd smallest element of the list.\n Return None if there is no such element.\n \n next_smallest([1, 2, 3, 4, 5]) == 2\n next_smallest([5, 1, 4, 3, 2]) == 2\n next_smallest([]) == None\n next_smallest([1, 1]) == None\n \"\"\"\n\n if len(lst) < 2:\n return None\n \n lst.sort()\n for i in range(1, len(lst)):\n if lst[i]!= lst[i-1]:\n return lst[i]\n \n return None\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/88": [{"task_id": "HumanEval/88", "solution": "\ndef sort_array(array):\n \"\"\"\n Given an array of non-negative integers, return a copy of the given array after sorting,\n you will sort the given array in ascending order if the sum( first index value, last index value) is odd,\n or sort it in descending order if the sum( first index value, last index value) is even.\n\n Note:\n * don't change the given array.\n\n Examples:\n * sort_array([]) => []\n * sort_array([5]) => [5]\n * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]\n * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]\n \"\"\"\n\n if not array:\n return []\n if len(array) == 1:\n return array\n first = array[0]\n last = array[-1]\n if (first + last) % 2 == 0:\n return sorted(array, reverse=True)\n else:\n return sorted(array)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/24": [{"task_id": "HumanEval/24", "solution": "\n\ndef largest_divisor(n: int) -> int:\n \"\"\" For a given number n, find the largest number that divides n evenly, smaller than n\n >>> largest_divisor(15)\n 5\n \"\"\"\n\n for i in range(n // 2, 0, -1):\n if n % i == 0:\n return i\n return 1\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/108": [{"task_id": "HumanEval/108", "solution": "\ndef count_nums(arr):\n \"\"\"\n Write a function count_nums which takes an array of integers and returns\n the number of elements which has a sum of digits > 0.\n If a number is negative, then its first signed digit will be negative:\n e.g. -123 has signed digits -1, 2, and 3.\n >>> count_nums([]) == 0\n >>> count_nums([-1, 11, -11]) == 1\n >>> count_nums([1, 1, 2]) == 3\n \"\"\"\n\n count = 0\n for num in arr:\n if sum(int(digit) for digit in str(num)) > 0:\n count += 1\n return count\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[[-1, -2, 0]]], "plus_fail_tests": [[[-1, 0, 1]]]}], "HumanEval/98": [{"task_id": "HumanEval/98", "solution": "\ndef count_upper(s):\n \"\"\"\n Given a string s, count the number of uppercase vowels in even indices.\n \n For example:\n count_upper('aBCdEf') returns 1\n count_upper('abcdefg') returns 0\n count_upper('dBBE') returns 0\n \"\"\"\n\n vowels = 'AEIOU'\n count = 0\n for i, c in enumerate(s):\n if i % 2 == 0 and c in vowels:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/105": [{"task_id": "HumanEval/105", "solution": "\ndef by_length(arr):\n \"\"\"\n Given an array of integers, sort the integers that are between 1 and 9 inclusive,\n reverse the resulting array, and then replace each digit by its corresponding name from\n \"One\", \"Two\", \"Three\", \"Four\", \"Five\", \"Six\", \"Seven\", \"Eight\", \"Nine\".\n\n For example:\n arr = [2, 1, 1, 4, 5, 8, 2, 3] \n -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8] \n -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]\n return [\"Eight\", \"Five\", \"Four\", \"Three\", \"Two\", \"Two\", \"One\", \"One\"]\n \n If the array is empty, return an empty array:\n arr = []\n return []\n \n If the array has any strange number ignore it:\n arr = [1, -1 , 55] \n -> sort arr -> [-1, 1, 55]\n -> reverse arr -> [55, 1, -1]\n return = ['One']\n \"\"\"\n\n if not arr:\n return []\n digits = [str(d) for d in arr if 1 <= d <= 9]\n digits.sort(reverse=True)\n return [\n \"One\",\n \"Two\",\n \"Three\",\n \"Four\",\n \"Five\",\n \"Six\",\n \"Seven\",\n \"Eight\",\n \"Nine\",\n ][: len(digits)]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/102": [{"task_id": "HumanEval/102", "solution": "\ndef choose_num(x, y):\n \"\"\"This function takes two positive numbers x and y and returns the\n biggest even integer number that is in the range [x, y] inclusive. If \n there's no such number, then the function should return -1.\n\n For example:\n choose_num(12, 15) = 14\n choose_num(13, 12) = -1\n \"\"\"\n\n if x > y:\n return -1\n for num in range(y, x-1, -1):\n if num % 2 == 0:\n return num\n return -1\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/101": [{"task_id": "HumanEval/101", "solution": "\ndef words_string(s):\n \"\"\"\n You will be given a string of words separated by commas or spaces. Your task is\n to split the string into words and return an array of the words.\n \n For example:\n words_string(\"Hi, my name is John\") == [\"Hi\", \"my\", \"name\", \"is\", \"John\"]\n words_string(\"One, two, three, four, five, six\") == [\"One\", \"two\", \"three\", \"four\", \"five\", \"six\"]\n \"\"\"\n\n return s.replace(\",\", \" \").split()\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/111": [{"task_id": "HumanEval/111", "solution": "\ndef histogram(test):\n \"\"\"Given a string representing a space separated lowercase letters, return a dictionary\n of the letter with the most repetition and containing the corresponding count.\n If several letters have the same occurrence, return all of them.\n \n Example:\n histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}\n histogram('a b b a') == {'a': 2, 'b': 2}\n histogram('a b c a b') == {'a': 2, 'b': 2}\n histogram('b b b b a') == {'b': 4}\n histogram('') == {}\n\n \"\"\"\n\n if not test:\n return {}\n \n freq = {}\n for letter in test.split():\n freq[letter] = freq.get(letter, 0) + 1\n \n max_freq = max(freq.values())\n return {letter: freq for letter, freq in freq.items() if freq == max_freq}\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/115": [{"task_id": "HumanEval/115", "solution": "import math\n\ndef max_fill(grid, capacity):\n \"\"\"\n You are given a rectangular grid of wells. Each row represents a single well,\n and each 1 in a row represents a single unit of water.\n Each well has a corresponding bucket that can be used to extract water from it, \n and all buckets have the same capacity.\n Your task is to use the buckets to empty the wells.\n Output the number of times you need to lower the buckets.\n\n Example 1:\n Input: \n grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]\n bucket_capacity : 1\n Output: 6\n\n Example 2:\n Input: \n grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]\n bucket_capacity : 2\n Output: 5\n \n Example 3:\n Input: \n grid : [[0,0,0], [0,0,0]]\n bucket_capacity : 5\n Output: 0\n\n Constraints:\n * all wells have the same length\n * 1 <= grid.length <= 10^2\n * 1 <= grid[:,1].length <= 10^2\n * grid[i][j] -> 0 | 1\n * 1 <= capacity <= 10\n \"\"\"\n\n num_rows = len(grid)\n num_cols = len(grid[0])\n num_buckets = num_rows\n num_fills = 0\n for i in range(num_rows):\n for j in range(num_cols):\n if grid[i][j] == 1:\n num_fills += 1\n num_fills_per_bucket = math.ceil(num_fills / num_buckets)\n return num_fills_per_bucket\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/122": [{"task_id": "HumanEval/122", "solution": "\ndef add_elements(arr, k):\n \"\"\"\n Given a non-empty array of integers arr and an integer k, return\n the sum of the elements with at most two digits from the first k elements of arr.\n\n Example:\n\n Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4\n Output: 24 # sum of 21 + 3\n\n Constraints:\n 1. 1 <= len(arr) <= 100\n 2. 1 <= k <= len(arr)\n \"\"\"\n\n total_sum = 0\n for i in range(k):\n if arr[i] < 100:\n total_sum += arr[i]\n return total_sum\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[-100, -89, -77, -55, 900, -44, -22, -11], 7]]}], "HumanEval/107": [{"task_id": "HumanEval/107", "solution": "\ndef even_odd_palindrome(n):\n \"\"\"\n Given a positive integer n, return a tuple that has the number of even and odd\n integer palindromes that fall within the range(1, n), inclusive.\n\n Example 1:\n\n Input: 3\n Output: (1, 2)\n Explanation:\n Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.\n\n Example 2:\n\n Input: 12\n Output: (4, 6)\n Explanation:\n Integer palindrome are 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. four of them are even, and 6 of them are odd.\n\n Note:\n 1. 1 <= n <= 10^3\n 2. returned tuple has the number of even and odd integer palindromes respectively.\n \"\"\"\n\n def is_palindrome(num):\n return str(num) == str(num)[::-1]\n\n even_count = 0\n odd_count = 0\n for i in range(1, n + 1):\n if is_palindrome(i):\n if i % 2 == 0:\n even_count += 1\n else:\n odd_count += 1\n\n return (even_count, odd_count)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/119": [{"task_id": "HumanEval/119", "solution": "\ndef match_parens(lst):\n '''\n You are given a list of two strings, both strings consist of open\n parentheses '(' or close parentheses ')' only.\n Your job is to check if it is possible to concatenate the two strings in\n some order, that the resulting string will be good.\n A string S is considered to be good if and only if all parentheses in S\n are balanced. For example: the string '(())()' is good, while the string\n '())' is not.\n Return 'Yes' if there's a way to make a good string, and return 'No' otherwise.\n\n Examples:\n match_parens(['()(', ')']) == 'Yes'\n match_parens([')', ')']) == 'No'\n '''\n\n stack = []\n for s in lst:\n for c in s:\n if c == '(':\n stack.append(c)\n elif c == ')':\n if not stack or stack[-1]!= '(':\n return 'No'\n stack.pop()\n return 'Yes' if not stack else 'No'\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[[")())", "(()()("]]], "plus_fail_tests": [[[")()()()(()()))", "(("]]]}], "HumanEval/112": [{"task_id": "HumanEval/112", "solution": "\ndef reverse_delete(s,c):\n \"\"\"Task\n We are given two strings s and c, you have to deleted all the characters in s that are equal to any character in c\n then check if the result string is palindrome.\n A string is called palindrome if it reads the same backward as forward.\n You should return a tuple containing the result string and True/False for the check.\n Example\n For s = \"abcde\", c = \"ae\", the result should be ('bcd',False)\n For s = \"abcdef\", c = \"b\" the result should be ('acdef',False)\n For s = \"abcdedcba\", c = \"ab\", the result should be ('cdedc',True)\n \"\"\"\n\n result = \"\"\n for char in s:\n if char not in c:\n result += char\n return (result, result == result[::-1])\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/124": [{"task_id": "HumanEval/124", "solution": "\ndef valid_date(date):\n \"\"\"You have to write a function which validates a given date string and\n returns True if the date is valid otherwise False.\n The date is valid if all of the following rules are satisfied:\n 1. The date string is not empty.\n 2. The number of days is not less than 1 or higher than 31 days for months 1,3,5,7,8,10,12. And the number of days is not less than 1 or higher than 30 days for months 4,6,9,11. And, the number of days is not less than 1 or higher than 29 for the month 2.\n 3. The months should not be less than 1 or higher than 12.\n 4. The date should be in the format: mm-dd-yyyy\n\n for example: \n valid_date('03-11-2000') => True\n\n valid_date('15-01-2012') => False\n\n valid_date('04-0-2040') => False\n\n valid_date('06-04-2020') => True\n\n valid_date('06/04/2020') => False\n \"\"\"\n\n if not date:\n return False\n date_parts = date.split('-')\n if len(date_parts)!= 3:\n return False\n month, day, year = date_parts\n if not (month and day and year):\n return False\n if not (month.isdigit() and day.isdigit() and year.isdigit()):\n return False\n month = int(month)\n day = int(day)\n year = int(year)\n if not (1 <= month <= 12):\n return False\n if month in (1, 3, 5, 7, 8, 10, 12):\n max_days = 31\n elif month in (4, 6, 9, 11):\n max_days = 30\n elif month == 2:\n max_days = 29\n else:\n return False\n if not (1 <= day <= max_days):\n return False\n return True\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["06-04-202"]]}], "HumanEval/126": [{"task_id": "HumanEval/126", "solution": "\ndef is_sorted(lst):\n '''\n Given a list of numbers, return whether or not they are sorted\n in ascending order. If list has more than 1 duplicate of the same\n number, return False. Assume no negative numbers and only integers.\n\n Examples\n is_sorted([5]) \u279e True\n is_sorted([1, 2, 3, 4, 5]) \u279e True\n is_sorted([1, 3, 2, 4, 5]) \u279e False\n is_sorted([1, 2, 3, 4, 5, 6]) \u279e True\n is_sorted([1, 2, 3, 4, 5, 6, 7]) \u279e True\n is_sorted([1, 3, 2, 4, 5, 6, 7]) \u279e False\n is_sorted([1, 2, 2, 3, 3, 4]) \u279e True\n is_sorted([1, 2, 2, 2, 3, 4]) \u279e False\n '''\n\n if len(lst) <= 1:\n return True\n prev = lst[0]\n for curr in lst[1:]:\n if curr < prev:\n return False\n if curr == prev:\n return False\n prev = curr\n return True\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[[1, 2, 2, 3, 3, 4]]], "plus_fail_tests": [[[1, 1, 2, 2, 3, 3, 4]]]}], "HumanEval/106": [{"task_id": "HumanEval/106", "solution": "\ndef f(n):\n \"\"\" Implement the function f that takes n as a parameter,\n and returns a list of size n, such that the value of the element at index i is the factorial of i if i is even\n or the sum of numbers from 1 to i otherwise.\n i starts from 1.\n the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... * i).\n Example:\n f(5) == [1, 2, 6, 24, 15]\n \"\"\"\n\n def factorial(num):\n if num <= 1:\n return 1\n return num * factorial(num - 1)\n\n def sum_from_1_to_n(num):\n return num * (num + 1) // 2\n\n result = []\n for i in range(1, n + 1):\n if i % 2 == 0:\n result.append(factorial(i))\n else:\n result.append(sum_from_1_to_n(i))\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/104": [{"task_id": "HumanEval/104", "solution": "\ndef unique_digits(x):\n \"\"\"Given a list of positive integers x. return a sorted list of all \n elements that hasn't any even digit.\n\n Note: Returned list should be sorted in increasing order.\n \n For example:\n >>> unique_digits([15, 33, 1422, 1])\n [1, 15, 33]\n >>> unique_digits([152, 323, 1422, 10])\n []\n \"\"\"\n\n def has_even_digit(num):\n while num > 0:\n digit = num % 10\n if digit % 2 == 0:\n return True\n num //= 10\n return False\n \n result = []\n for num in x:\n if not has_even_digit(num):\n result.append(num)\n result.sort()\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/118": [{"task_id": "HumanEval/118", "solution": "\ndef get_closest_vowel(word):\n \"\"\"You are given a word. Your task is to find the closest vowel that stands between \n two consonants from the right side of the word (case sensitive).\n \n Vowels in the beginning and ending doesn't count. Return empty string if you didn't\n find any vowel met the above condition. \n\n You may assume that the given string contains English letter only.\n\n Example:\n get_closest_vowel(\"yogurt\") ==> \"u\"\n get_closest_vowel(\"FULL\") ==> \"U\"\n get_closest_vowel(\"quick\") ==> \"\"\n get_closest_vowel(\"ab\") ==> \"\"\n \"\"\"\n\n vowels = set(\"aeiouAEIOU\")\n for i in range(len(word)-1, 0, -1):\n if word[i] in vowels:\n return word[i]\n return \"\"\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [["easy"]], "plus_fail_tests": []}], "HumanEval/125": [{"task_id": "HumanEval/125", "solution": "\ndef split_words(txt):\n '''\n Given a string of words, return a list of words split on whitespace, if no whitespaces exists in the text you\n should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the\n alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25\n Examples\n split_words(\"Hello world!\") \u279e [\"Hello\", \"world!\"]\n split_words(\"Hello,world!\") \u279e [\"Hello\", \"world!\"]\n split_words(\"abcdef\") == 3 \n '''\n\n if'' in txt:\n return txt.split()\n elif ',' in txt:\n return txt.split(',')\n else:\n return sum(1 for c in txt if ord(c) % 2 == 1)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [["Hello,world!"]], "plus_fail_tests": []}], "HumanEval/114": [{"task_id": "HumanEval/114", "solution": "\ndef minSubArraySum(nums):\n \"\"\"\n Given an array of integers nums, find the minimum sum of any non-empty sub-array\n of nums.\n Example\n minSubArraySum([2, 3, 4, 1, 2, 4]) == 1\n minSubArraySum([-1, -2, -3]) == -6\n \"\"\"\n\n min_sum = float(\"inf\")\n current_sum = 0\n for num in nums:\n current_sum += num\n min_sum = min(min_sum, current_sum)\n if current_sum > 0:\n current_sum = 0\n return min_sum\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/100": [{"task_id": "HumanEval/100", "solution": "\ndef make_a_pile(n):\n \"\"\"\n Given a positive integer n, you have to make a pile of n levels of stones.\n The first level has n stones.\n The number of stones in the next level is:\n - the next odd number if n is odd.\n - the next even number if n is even.\n Return the number of stones in each level in a list, where element at index\n i represents the number of stones in the level (i+1).\n\n Examples:\n >>> make_a_pile(3)\n [3, 5, 7]\n \"\"\"\n\n if n <= 0:\n return []\n\n stones = [n]\n for i in range(1, n):\n if n % 2 == 0:\n n += 2\n else:\n n += 1\n stones.append(n)\n\n return stones\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[15]]}], "HumanEval/110": [{"task_id": "HumanEval/110", "solution": "\ndef exchange(lst1, lst2):\n \"\"\"In this problem, you will implement a function that takes two lists of numbers,\n and determines whether it is possible to perform an exchange of elements\n between them to make lst1 a list of only even numbers.\n There is no limit on the number of exchanged elements between lst1 and lst2.\n If it is possible to exchange elements between the lst1 and lst2 to make\n all the elements of lst1 to be even, return \"YES\".\n Otherwise, return \"NO\".\n For example:\n exchange([1, 2, 3, 4], [1, 2, 3, 4]) => \"YES\"\n exchange([1, 2, 3, 4], [1, 5, 3, 4]) => \"NO\"\n It is assumed that the input lists will be non-empty.\n \"\"\"\n\n even_count = sum(1 for x in lst1 if x % 2 == 0)\n odd_count = len(lst1) - even_count\n if even_count == len(lst1):\n return \"YES\"\n for i in range(len(lst2)):\n if lst2[i] % 2 == 0:\n even_count += 1\n else:\n odd_count += 1\n if even_count == len(lst1):\n return \"YES\"\n if i < len(lst2) - 1:\n if lst2[i + 1] % 2 == 0:\n even_count -= 1\n else:\n odd_count -= 1\n return \"NO\"\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[1, 3, 5], [2, 4, 6]]]}], "HumanEval/117": [{"task_id": "HumanEval/117", "solution": "\ndef select_words(s, n):\n \"\"\"Given a string s and a natural number n, you have been tasked to implement \n a function that returns a list of all words from string s that contain exactly \n n consonants, in order these words appear in the string s.\n If the string s is empty then the function should return an empty list.\n Note: you may assume the input string contains only letters and spaces.\n Examples:\n select_words(\"Mary had a little lamb\", 4) ==> [\"little\"]\n select_words(\"Mary had a little lamb\", 3) ==> [\"Mary\", \"lamb\"]\n select_words(\"simple white space\", 2) ==> []\n select_words(\"Hello world\", 4) ==> [\"world\"]\n select_words(\"Uncle sam\", 3) ==> [\"Uncle\"]\n \"\"\"\n\n vowels = \"aeiou\"\n words = s.split()\n result = []\n for word in words:\n consonants = 0\n for letter in word:\n if letter.isalpha() and letter.lower() not in vowels:\n consonants += 1\n if consonants == n:\n result.append(word)\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/123": [{"task_id": "HumanEval/123", "solution": "\ndef get_odd_collatz(n):\n \"\"\"\n Given a positive integer n, return a sorted list that has the odd numbers in collatz sequence.\n\n The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined\n as follows: start with any positive integer n. Then each term is obtained from the \n previous term as follows: if the previous term is even, the next term is one half of \n the previous term. If the previous term is odd, the next term is 3 times the previous\n term plus 1. The conjecture is that no matter what value of n, the sequence will always reach 1.\n\n Note: \n 1. Collatz(1) is [1].\n 2. returned list sorted in increasing order.\n\n For example:\n get_odd_collatz(5) returns [1, 5] # The collatz sequence for 5 is [5, 16, 8, 4, 2, 1], so the odd numbers are only 1, and 5.\n \"\"\"\n\n collatz_sequence = [n]\n while n!= 1:\n if n % 2 == 0:\n n = n // 2\n else:\n n = 3 * n + 1\n collatz_sequence.append(n)\n odd_numbers = [num for num in collatz_sequence if num % 2 == 1]\n odd_numbers.sort()\n return odd_numbers\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/129": [{"task_id": "HumanEval/129", "solution": "\ndef minPath(grid, k):\n \"\"\"\n Given a grid with N rows and N columns (N >= 2) and a positive integer k, \n each cell of the grid contains a value. Every integer in the range [1, N * N]\n inclusive appears exactly once on the cells of the grid.\n\n You have to find the minimum path of length k in the grid. You can start\n from any cell, and in each step you can move to any of the neighbor cells,\n in other words, you can go to cells which share an edge with you current\n cell.\n Please note that a path of length k means visiting exactly k cells (not\n necessarily distinct).\n You CANNOT go off the grid.\n A path A (of length k) is considered less than a path B (of length k) if\n after making the ordered lists of the values on the cells that A and B go\n through (let's call them lst_A and lst_B), lst_A is lexicographically less\n than lst_B, in other words, there exist an integer index i (1 <= i <= k)\n such that lst_A[i] < lst_B[i] and for any j (1 <= j < i) we have\n lst_A[j] = lst_B[j].\n It is guaranteed that the answer is unique.\n Return an ordered list of the values on the cells that the minimum path go through.\n\n Examples:\n\n Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3\n Output: [1, 2, 1]\n\n Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1\n Output: [1]\n \"\"\"\n\n N = len(grid)\n min_path = [float('inf')] * k\n min_path_values = [float('inf')] * k\n\n def dfs(row, col, path, path_values):\n if len(path) == k:\n if path < min_path:\n min_path[:] = path\n min_path_values[:] = path_values\n return\n\n for r, c in [(row - 1, col), (row + 1, col), (row, col - 1), (row, col + 1)]:\n if 0 <= r < N and 0 <= c < N and grid[r][c] not in path_values:\n path.append(grid[r][c])\n path_values.add(grid[r][c])\n dfs(r, c, path, path_values)\n path.pop()\n path_values.remove(grid[r][c])\n\n for row in range(N):\n for col in range(N):\n dfs(row, col, [grid[row][col]], {grid[row][col]})\n\n return min_path_values\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[[1, 2, 3], [4, 5, 6], [7, 8, 9]], 9]]}], "HumanEval/128": [{"task_id": "HumanEval/128", "solution": "\ndef prod_signs(arr):\n \"\"\"\n You are given an array arr of integers and you need to return\n sum of magnitudes of integers multiplied by product of all signs\n of each number in the array, represented by 1, -1 or 0.\n Note: return None for empty arr.\n\n Example:\n >>> prod_signs([1, 2, 2, -4]) == -9\n >>> prod_signs([0, 1]) == 0\n >>> prod_signs([]) == None\n \"\"\"\n\n if not arr:\n return None\n\n prod = 1\n sum_magnitudes = 0\n\n for num in arr:\n if num == 0:\n prod *= 0\n break\n elif num > 0:\n prod *= 1\n else:\n prod *= -1\n\n sum_magnitudes += abs(num)\n\n return sum_magnitudes * prod\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/127": [{"task_id": "HumanEval/127", "solution": "\ndef intersection(interval1, interval2):\n \"\"\"You are given two intervals,\n where each interval is a pair of integers. For example, interval = (start, end) = (1, 2).\n The given intervals are closed which means that the interval (start, end)\n includes both start and end.\n For each given interval, it is assumed that its start is less or equal its end.\n Your task is to determine whether the length of intersection of these two \n intervals is a prime number.\n Example, the intersection of the intervals (1, 3), (2, 4) is (2, 3)\n which its length is 1, which not a prime number.\n If the length of the intersection is a prime number, return \"YES\",\n otherwise, return \"NO\".\n If the two intervals don't intersect, return \"NO\".\n\n\n [input/output] samples:\n intersection((1, 2), (2, 3)) ==> \"NO\"\n intersection((-1, 1), (0, 4)) ==> \"NO\"\n intersection((-3, -1), (-5, 5)) ==> \"YES\"\n \"\"\"\n\n start1, end1 = interval1\n start2, end2 = interval2\n if start1 > end2 or start2 > end1:\n return \"NO\"\n intersection_start = max(start1, start2)\n intersection_end = min(end1, end2)\n intersection_length = intersection_end - intersection_start + 1\n if intersection_length < 2:\n return \"NO\"\n for i in range(2, int(intersection_length ** 0.5) + 1):\n if intersection_length % i == 0:\n return \"NO\"\n return \"YES\"\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[[-1, 1], [0, 4]]], "plus_fail_tests": [[[10, 20], [15, 25]]]}], "HumanEval/113": [{"task_id": "HumanEval/113", "solution": "\ndef odd_count(lst):\n \"\"\"Given a list of strings, where each string consists of only digits, return a list.\n Each element i of the output should be \"the number of odd elements in the\n string i of the input.\" where all the i's should be replaced by the number\n of odd digits in the i'th string of the input.\n\n >>> odd_count(['1234567'])\n [\"the number of odd elements 4n the str4ng 4 of the 4nput.\"]\n >>> odd_count(['3',\"11111111\"])\n [\"the number of odd elements 1n the str1ng 1 of the 1nput.\",\n \"the number of odd elements 8n the str8ng 8 of the 8nput.\"]\n \"\"\"\n\n output = []\n for i, string in enumerate(lst):\n count = 0\n for digit in string:\n if int(digit) % 2 == 1:\n count += 1\n output.append(f\"the number of odd elements {count}n the str{count}ng {count} of the {count}nput.\")\n return output\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/116": [{"task_id": "HumanEval/116", "solution": "\ndef sort_array(arr):\n \"\"\"\n In this Kata, you have to sort an array of non-negative integers according to\n number of ones in their binary representation in ascending order.\n For similar number of ones, sort based on decimal value.\n\n It must be implemented like this:\n >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]\n >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]\n >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]\n \"\"\"\n\n def count_ones(num):\n count = 0\n while num > 0:\n count += num & 1\n num >>= 1\n return count\n\n return sorted(arr, key=lambda x: (count_ones(abs(x)), x))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/109": [{"task_id": "HumanEval/109", "solution": "\ndef move_one_ball(arr):\n \"\"\"We have an array 'arr' of N integers arr[1], arr[2], ..., arr[N].The\n numbers in the array will be randomly ordered. Your task is to determine if\n it is possible to get an array sorted in non-decreasing order by performing \n the following operation on the given array:\n You are allowed to perform right shift operation any number of times.\n \n One right shift operation means shifting all elements of the array by one\n position in the right direction. The last element of the array will be moved to\n the starting position in the array i.e. 0th index. \n\n If it is possible to obtain the sorted array by performing the above operation\n then return True else return False.\n If the given array is empty then return True.\n\n Note: The given list is guaranteed to have unique elements.\n\n For Example:\n \n move_one_ball([3, 4, 5, 1, 2])==>True\n Explanation: By performin 2 right shift operations, non-decreasing order can\n be achieved for the given array.\n move_one_ball([3, 5, 4, 1, 2])==>False\n Explanation:It is not possible to get non-decreasing order for the given\n array by performing any number of right shift operations.\n \n \"\"\"\n\n if not arr:\n return True\n sorted_arr = sorted(arr)\n for i in range(len(arr)):\n shifted_arr = arr[i:] + arr[:i]\n if shifted_arr == sorted_arr:\n return True\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/120": [{"task_id": "HumanEval/120", "solution": "\ndef maximum(arr, k):\n \"\"\"\n Given an array arr of integers and a positive integer k, return a sorted list \n of length k with the maximum k numbers in arr.\n\n Example 1:\n\n Input: arr = [-3, -4, 5], k = 3\n Output: [-4, -3, 5]\n\n Example 2:\n\n Input: arr = [4, -4, 4], k = 2\n Output: [4, 4]\n\n Example 3:\n\n Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1\n Output: [2]\n\n Note:\n 1. The length of the array will be in the range of [1, 1000].\n 2. The elements in the array will be in the range of [-1000, 1000].\n 3. 0 <= k <= len(arr)\n \"\"\"\n\n arr.sort(reverse=True)\n return arr[:k]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/121": [{"task_id": "HumanEval/121", "solution": "\ndef solution(lst):\n \"\"\"Given a non-empty list of integers, return the sum of all of the odd elements that are in even positions.\n \n\n Examples\n solution([5, 8, 7, 1]) ==> 12\n solution([3, 3, 3, 3, 3]) ==> 9\n solution([30, 13, 24, 321]) ==>0\n \"\"\"\n\n result = 0\n for idx, num in enumerate(lst):\n if idx % 2 == 0 and num % 2 == 1:\n result += num\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/138": [{"task_id": "HumanEval/138", "solution": "\ndef is_equal_to_sum_even(n):\n \"\"\"Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers\n Example\n is_equal_to_sum_even(4) == False\n is_equal_to_sum_even(6) == False\n is_equal_to_sum_even(8) == True\n \"\"\"\n\n if n < 8:\n return False\n for a in range(2, n // 2 + 1, 2):\n for b in range(a, n // 2 + 1, 2):\n for c in range(b, n // 2 + 1, 2):\n d = n - a - b - c\n if d > 0 and d % 2 == 0:\n return True\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/134": [{"task_id": "HumanEval/134", "solution": "\ndef check_if_last_char_is_a_letter(txt):\n '''\n Create a function that returns True if the last character\n of a given string is an alphabetical character and is not\n a part of a word, and False otherwise.\n Note: \"word\" is a group of characters separated by space.\n\n Examples:\n check_if_last_char_is_a_letter(\"apple pie\") \u279e False\n check_if_last_char_is_a_letter(\"apple pi e\") \u279e True\n check_if_last_char_is_a_letter(\"apple pi e \") \u279e False\n check_if_last_char_is_a_letter(\"\") \u279e False \n '''\n\n if not txt:\n return False\n last_char = txt[-1]\n if last_char.isalpha() and last_char!= \" \":\n return True\n return False\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["pUMPKIN PIE"]]}], "HumanEval/140": [{"task_id": "HumanEval/140", "solution": "\ndef fix_spaces(text):\n \"\"\"\n Given a string text, replace all spaces in it with underscores, \n and if a string has more than 2 consecutive spaces, \n then replace all consecutive spaces with - \n \n fix_spaces(\"Example\") == \"Example\"\n fix_spaces(\"Example 1\") == \"Example_1\"\n fix_spaces(\" Example 2\") == \"_Example_2\"\n fix_spaces(\" Example 3\") == \"_Example-3\"\n \"\"\"\n\n result = \"\"\n consecutive_spaces = 0\n for char in text:\n if char == \" \":\n consecutive_spaces += 1\n if consecutive_spaces > 2:\n result += \"-\"\n else:\n result += \"_\"\n else:\n result += char\n consecutive_spaces = 0\n return result\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [["Exa mple"]], "plus_fail_tests": []}], "HumanEval/133": [{"task_id": "HumanEval/133", "solution": "\n\ndef sum_squares(lst):\n \"\"\"You are given a list of numbers.\n You need to return the sum of squared numbers in the given list,\n round each element in the list to the upper int(Ceiling) first.\n Examples:\n For lst = [1,2,3] the output should be 14\n For lst = [1,4,9] the output should be 98\n For lst = [1,3,5,7] the output should be 84\n For lst = [1.4,4.2,0] the output should be 29\n For lst = [-2.4,1,1] the output should be 6\n \n\n \"\"\"\n\n return sum(int(x)**2 for x in lst)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[[1.4, 4.2, 0]]], "plus_fail_tests": [[[0, 3.3, 7.7, -2.2]]]}], "HumanEval/132": [{"task_id": "HumanEval/132", "solution": "\ndef is_nested(string):\n '''\n Create a function that takes a string as input which contains only square brackets.\n The function should return True if and only if there is a valid subsequence of brackets \n where at least one bracket in the subsequence is nested.\n\n is_nested('[[]]') \u279e True\n is_nested('[]]]]]]][[[[[]') \u279e False\n is_nested('[][]') \u279e False\n is_nested('[]') \u279e False\n is_nested('[[][]]') \u279e True\n is_nested('[[]][[') \u279e True\n '''\n\n stack = []\n for char in string:\n if char == '[':\n stack.append(char)\n elif char == ']':\n if len(stack) == 0:\n return False\n stack.pop()\n return len(stack) == 0\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [["[][]"]], "plus_fail_tests": [["[[]]]"]]}], "HumanEval/142": [{"task_id": "HumanEval/142", "solution": "\n\n\ndef sum_squares(lst):\n \"\"\"\"\n This function will take a list of integers. For all entries in the list, the function shall square the integer entry if its index is a \n multiple of 3 and will cube the integer entry if its index is a multiple of 4 and not a multiple of 3. The function will not \n change the entries in the list whose indexes are not a multiple of 3 or 4. The function shall then return the sum of all entries. \n \n Examples:\n For lst = [1,2,3] the output should be 6\n For lst = [] the output should be 0\n For lst = [-1,-5,2,-1,-5] the output should be -126\n \"\"\"\n\n sum = 0\n for i, val in enumerate(lst):\n if i % 3 == 0 and i % 4!= 0:\n lst[i] = val * val\n elif i % 4 == 0:\n lst[i] = val * val * val\n sum += lst[i]\n return sum\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[[-1, -1, -1, -1, -1, -1, -1, -1, -1]]], "plus_fail_tests": []}], "HumanEval/135": [{"task_id": "HumanEval/135", "solution": "\ndef can_arrange(arr):\n \"\"\"Create a function which returns the largest index of an element which\n is not greater than or equal to the element immediately preceding it. If\n no such element exists then return -1. The given array will not contain\n duplicate values.\n\n Examples:\n can_arrange([1,2,4,3,5]) = 3\n can_arrange([1,2,3]) = -1\n \"\"\"\n\n for i in range(1, len(arr)):\n if arr[i] < arr[i-1]:\n return i-1\n return -1\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[5, 4, 3, 2, 1]]]}], "HumanEval/156": [{"task_id": "HumanEval/156", "solution": "\ndef int_to_mini_roman(number):\n \"\"\"\n Given a positive integer, obtain its roman numeral equivalent as a string,\n and return it in lowercase.\n Restrictions: 1 <= num <= 1000\n\n Examples:\n >>> int_to_mini_roman(19) == 'xix'\n >>> int_to_mini_roman(152) == 'clii'\n >>> int_to_mini_roman(426) == 'cdxxvi'\n \"\"\"\n\n roman_numerals = {\n 1: \"i\",\n 2: \"ii\",\n 3: \"iii\",\n 4: \"iv\",\n 5: \"v\",\n 6: \"vi\",\n 7: \"vii\",\n 8: \"viii\",\n 9: \"ix\",\n 10: \"x\",\n 20: \"xx\",\n 30: \"xxx\",\n 40: \"xl\",\n 50: \"l\",\n 60: \"lx\",\n 70: \"lxx\",\n 80: \"lxxx\",\n 90: \"xc\",\n 100: \"c\",\n 200: \"cc\",\n 300: \"ccc\",\n 400: \"cd\",\n 500: \"d\",\n 600: \"dc\",\n 700: \"dcc\",\n 800: \"dccc\",\n 900: \"cm\",\n 1000: \"m\",\n }\n result = \"\"\n for numeral in (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1):\n while number >= numeral:\n result += roman_numerals[numeral]\n number -= numeral\n return result.lower()\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/157": [{"task_id": "HumanEval/157", "solution": "\ndef right_angle_triangle(a, b, c):\n '''\n Given the lengths of the three sides of a triangle. Return True if the three\n sides form a right-angled triangle, False otherwise.\n A right-angled triangle is a triangle in which one angle is right angle or \n 90 degree.\n Example:\n right_angle_triangle(3, 4, 5) == True\n right_angle_triangle(1, 2, 3) == False\n '''\n\n if a**2 + b**2 == c**2 or a**2 + c**2 == b**2 or b**2 + c**2 == a**2:\n return True\n else:\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/149": [{"task_id": "HumanEval/149", "solution": "\ndef sorted_list_sum(lst):\n \"\"\"Write a function that accepts a list of strings as a parameter,\n deletes the strings that have odd lengths from it,\n and returns the resulted list with a sorted order,\n The list is always a list of strings and never an array of numbers,\n and it may contain duplicates.\n The order of the list should be ascending by length of each word, and you\n should return the list sorted by that rule.\n If two words have the same length, sort the list alphabetically.\n The function should return a list of strings in sorted order.\n You may assume that all words will have the same length.\n For example:\n assert list_sort([\"aa\", \"a\", \"aaa\"]) => [\"aa\"]\n assert list_sort([\"ab\", \"a\", \"aaa\", \"cd\"]) => [\"ab\", \"cd\"]\n \"\"\"\n\n def is_even(string):\n return len(string) % 2 == 0\n\n def sort_by_length(string1, string2):\n if len(string1) == len(string2):\n return string1 < string2\n return len(string1) < len(string2)\n\n even_length_words = list(filter(is_even, lst))\n sorted_words = sorted(even_length_words, key=lambda word: len(word))\n return sorted_words\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[["d", "dcba", "abcd", "a"]]], "plus_fail_tests": [[["apple", "orange", "banana", "grapefruit"]]]}], "HumanEval/145": [{"task_id": "HumanEval/145", "solution": "\ndef order_by_points(nums):\n \"\"\"\n Write a function which sorts the given list of integers\n in ascending order according to the sum of their digits.\n Note: if there are several items with similar sum of their digits,\n order them based on their index in original list.\n\n For example:\n >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]\n >>> order_by_points([]) == []\n \"\"\"\n\n def sum_of_digits(num):\n num = abs(num)\n return sum(int(digit) for digit in str(num))\n\n return sorted(nums, key=sum_of_digits)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[-5, -12, 9, 15]]]}], "HumanEval/144": [{"task_id": "HumanEval/144", "solution": "\ndef simplify(x, n):\n \"\"\"Your task is to implement a function that will simplify the expression\n x * n. The function returns True if x * n evaluates to a whole number and False\n otherwise. Both x and n, are string representation of a fraction, and have the following format,\n / where both numerator and denominator are positive whole numbers.\n\n You can assume that x, and n are valid fractions, and do not have zero as denominator.\n\n simplify(\"1/5\", \"5/1\") = True\n simplify(\"1/6\", \"2/1\") = False\n simplify(\"7/10\", \"10/2\") = False\n \"\"\"\n\n def fraction_to_float(fraction):\n numerator, denominator = fraction.split(\"/\")\n return float(numerator) / float(denominator)\n\n x_float = fraction_to_float(x)\n n_float = fraction_to_float(n)\n product = x_float * n_float\n return product.is_integer()\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["15/17", "17/15"]]}], "HumanEval/131": [{"task_id": "HumanEval/131", "solution": "\ndef digits(n):\n \"\"\"Given a positive integer n, return the product of the odd digits.\n Return 0 if all digits are even.\n For example:\n digits(1) == 1\n digits(4) == 0\n digits(235) == 15\n \"\"\"\n\n product = 1\n while n > 0:\n digit = n % 10\n if digit % 2 == 1:\n product *= digit\n n //= 10\n return product\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[2468]], "plus_fail_tests": [[246]]}], "HumanEval/136": [{"task_id": "HumanEval/136", "solution": "\ndef largest_smallest_integers(lst):\n '''\n Create a function that returns a tuple (a, b), where 'a' is\n the largest of negative integers, and 'b' is the smallest\n of positive integers in a list.\n If there is no negative or positive integers, return them as None.\n\n Examples:\n largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)\n largest_smallest_integers([]) == (None, None)\n largest_smallest_integers([0]) == (None, None)\n '''\n\n largest_negative = None\n smallest_positive = None\n for num in lst:\n if num < 0:\n if largest_negative is None or num > largest_negative:\n largest_negative = num\n elif num > 0:\n if smallest_positive is None or num < smallest_positive:\n smallest_positive = num\n return (largest_negative, smallest_positive)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/139": [{"task_id": "HumanEval/139", "solution": "\ndef special_factorial(n):\n \"\"\"The Brazilian factorial is defined as:\n brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!\n where n > 0\n\n For example:\n >>> special_factorial(4)\n 288\n\n The function will receive an integer as input and should return the special\n factorial of this integer.\n \"\"\"\n\n if n <= 0:\n return 1\n result = 1\n for i in range(n, 0, -1):\n result *= i\n return result\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[3]]}], "HumanEval/163": [{"task_id": "HumanEval/163", "solution": "\ndef generate_integers(a, b):\n \"\"\"\n Given two positive integers a and b, return the even digits between a\n and b, in ascending order.\n\n For example:\n generate_integers(2, 8) => [2, 4, 6, 8]\n generate_integers(8, 2) => [2, 4, 6, 8]\n generate_integers(10, 14) => []\n \"\"\"\n\n if a > b:\n a, b = b, a\n even_digits = []\n for num in range(a, b + 1):\n if num % 2 == 0:\n even_digits.append(num)\n return even_digits\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/36": [{"task_id": "HumanEval/36", "solution": "\n\ndef fizz_buzz(n: int):\n \"\"\"Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.\n >>> fizz_buzz(50)\n 0\n >>> fizz_buzz(78)\n 2\n >>> fizz_buzz(79)\n 3\n \"\"\"\n\n count = 0\n for i in range(1, n):\n if i % 11 == 0 or i % 13 == 0:\n count += str(i).count('7')\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/137": [{"task_id": "HumanEval/137", "solution": "\ndef compare_one(a, b):\n \"\"\"\n Create a function that takes integers, floats, or strings representing\n real numbers, and returns the larger variable in its given variable type.\n Return None if the values are equal.\n Note: If a real number is represented as a string, the floating point might be . or ,\n\n compare_one(1, 2.5) \u279e 2.5\n compare_one(1, \"2,3\") \u279e \"2,3\"\n compare_one(\"5,1\", \"6\") \u279e \"6\"\n compare_one(\"1\", 1) \u279e None\n \"\"\"\n\n if type(a)!= type(b):\n return None\n if type(a) in (int, float):\n if a > b:\n return a\n elif b > a:\n return b\n else:\n return None\n if type(a) == str:\n a = a.replace(\",\", \".\")\n b = b.replace(\",\", \".\")\n if float(a) > float(b):\n return a\n elif float(b) > float(a):\n return b\n else:\n return None\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[1, 2.5]], "plus_fail_tests": [["5,000", 5000]]}], "HumanEval/146": [{"task_id": "HumanEval/146", "solution": "\ndef specialFilter(nums):\n \"\"\"Write a function that takes an array of numbers as input and returns \n the number of elements in the array that are greater than 10 and both \n first and last digits of a number are odd (1, 3, 5, 7, 9).\n For example:\n specialFilter([15, -73, 14, -15]) => 1 \n specialFilter([33, -2, -3, 45, 21, 109]) => 2\n \"\"\"\n\n count = 0\n for num in nums:\n if num > 10 and str(num)[0] in '13579' and str(num)[-1] in '13579':\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/151": [{"task_id": "HumanEval/151", "solution": "\ndef double_the_difference(lst):\n '''\n Given a list of numbers, return the sum of squares of the numbers\n in the list that are odd. Ignore numbers that are negative or not integers.\n \n double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10\n double_the_difference([-1, -2, 0]) == 0\n double_the_difference([9, -2]) == 81\n double_the_difference([0]) == 0 \n \n If the input list is empty, return 0.\n '''\n\n if not lst:\n return 0\n \n sum_of_squares = 0\n \n for num in lst:\n if num < 0 or not isinstance(num, int):\n continue\n \n if num % 2 == 1:\n sum_of_squares += num ** 2\n \n return sum_of_squares\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/155": [{"task_id": "HumanEval/155", "solution": "\ndef even_odd_count(num):\n \"\"\"Given an integer. return a tuple that has the number of even and odd digits respectively.\n\n Example:\n even_odd_count(-12) ==> (1, 1)\n even_odd_count(123) ==> (1, 2)\n \"\"\"\n\n num = abs(num)\n even_count = 0\n odd_count = 0\n while num > 0:\n digit = num % 10\n if digit % 2 == 0:\n even_count += 1\n else:\n odd_count += 1\n num //= 10\n return (even_count, odd_count)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[0]], "plus_fail_tests": [[0]]}], "HumanEval/148": [{"task_id": "HumanEval/148", "solution": "\ndef bf(planet1, planet2):\n '''\n There are eight planets in our solar system: the closerst to the Sun \n is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn, \n Uranus, Neptune.\n Write a function that takes two planet names as strings planet1 and planet2. \n The function should return a tuple containing all planets whose orbits are \n located between the orbit of planet1 and the orbit of planet2, sorted by \n the proximity to the sun. \n The function should return an empty tuple if planet1 or planet2\n are not correct planet names. \n Examples\n bf(\"Jupiter\", \"Neptune\") ==> (\"Saturn\", \"Uranus\")\n bf(\"Earth\", \"Mercury\") ==> (\"Venus\")\n bf(\"Mercury\", \"Uranus\") ==> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")\n '''\n\n planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\", \"Uranus\", \"Neptune\"]\n if planet1 not in planets or planet2 not in planets:\n return ()\n planet1_index = planets.index(planet1)\n planet2_index = planets.index(planet2)\n if planet1_index > planet2_index:\n planet1_index, planet2_index = planet2_index, planet1_index\n return tuple(planets[planet1_index+1:planet2_index])\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/150": [{"task_id": "HumanEval/150", "solution": "\ndef x_or_y(n, x, y):\n \"\"\"A simple program which should return the value of x if n is \n a prime number and should return the value of y otherwise.\n\n Examples:\n for x_or_y(7, 34, 12) == 34\n for x_or_y(15, 8, 5) == 5\n \n \"\"\"\n\n if n > 1:\n for i in range(2, n):\n if n % i == 0:\n return y\n return x\n else:\n return y\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/141": [{"task_id": "HumanEval/141", "solution": "\ndef file_name_check(file_name):\n \"\"\"Create a function which takes a string representing a file's name, and returns\n 'Yes' if the the file's name is valid, and returns 'No' otherwise.\n A file's name is considered to be valid if and only if all the following conditions \n are met:\n - There should not be more than three digits ('0'-'9') in the file's name.\n - The file's name contains exactly one dot '.'\n - The substring before the dot should not be empty, and it starts with a letter from \n the latin alphapet ('a'-'z' and 'A'-'Z').\n - The substring after the dot should be one of these: ['txt', 'exe', 'dll']\n Examples:\n file_name_check(\"example.txt\") # => 'Yes'\n file_name_check(\"1example.dll\") # => 'No' (the name should start with a latin alphapet letter)\n \"\"\"\n\n if len([c for c in file_name if c.isdigit()]) > 3:\n return \"No\"\n if file_name.count(\".\")!= 1:\n return \"No\"\n before_dot, after_dot = file_name.split(\".\")\n if not before_dot or not before_dot[0].isalpha():\n return \"No\"\n if after_dot not in [\"txt\", \"exe\", \"dll\"]:\n return \"No\"\n return \"Yes\"\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/153": [{"task_id": "HumanEval/153", "solution": "\ndef Strongest_Extension(class_name, extensions):\n \"\"\"You will be given the name of a class (a string) and a list of extensions.\n The extensions are to be used to load additional classes to the class. The\n strength of the extension is as follows: Let CAP be the number of the uppercase\n letters in the extension's name, and let SM be the number of lowercase letters \n in the extension's name, the strength is given by the fraction CAP - SM. \n You should find the strongest extension and return a string in this \n format: ClassName.StrongestExtensionName.\n If there are two or more extensions with the same strength, you should\n choose the one that comes first in the list.\n For example, if you are given \"Slices\" as the class and a list of the\n extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] then you should\n return 'Slices.SErviNGSliCes' since 'SErviNGSliCes' is the strongest extension \n (its strength is -1).\n Example:\n for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'\n \"\"\"\n\n strongest_extension = ''\n max_strength = float('-inf')\n for extension in extensions:\n cap_count = sum(1 for c in extension if c.isupper())\n sm_count = sum(1 for c in extension if c.islower())\n strength = cap_count - sm_count\n if strength > max_strength:\n max_strength = strength\n strongest_extension = extension\n return f'{class_name}.{strongest_extension}'\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/154": [{"task_id": "HumanEval/154", "solution": "\ndef cycpattern_check(a , b):\n \"\"\"You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word\n cycpattern_check(\"abcd\",\"abd\") => False\n cycpattern_check(\"hello\",\"ell\") => True\n cycpattern_check(\"whassup\",\"psus\") => False\n cycpattern_check(\"abab\",\"baa\") => True\n cycpattern_check(\"efef\",\"eeff\") => False\n cycpattern_check(\"himenss\",\"simen\") => True\n\n \"\"\"\n\n if b in a:\n return True\n for i in range(1, len(b)):\n b = b[1:] + b[0]\n if b in a:\n return True\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/143": [{"task_id": "HumanEval/143", "solution": "\ndef words_in_sentence(sentence):\n \"\"\"\n You are given a string representing a sentence,\n the sentence contains some words separated by a space,\n and you have to return a string that contains the words from the original sentence,\n whose lengths are prime numbers,\n the order of the words in the new string should be the same as the original one.\n\n Example 1:\n Input: sentence = \"This is a test\"\n Output: \"is\"\n\n Example 2:\n Input: sentence = \"lets go for swimming\"\n Output: \"go for\"\n\n Constraints:\n * 1 <= len(sentence) <= 100\n * sentence contains only letters\n \"\"\"\n\n def is_prime(num):\n if num <= 1:\n return False\n for i in range(2, int(num ** 0.5) + 1):\n if num % i == 0:\n return False\n return True\n\n words = sentence.split()\n result = []\n for word in words:\n if is_prime(len(word)):\n result.append(word)\n return \" \".join(result)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/152": [{"task_id": "HumanEval/152", "solution": "\ndef compare(game,guess):\n \"\"\"I think we all remember that feeling when the result of some long-awaited\n event is finally known. The feelings and thoughts you have at that moment are\n definitely worth noting down and comparing.\n Your task is to determine if a person correctly guessed the results of a number of matches.\n You are given two arrays of scores and guesses of equal length, where each index shows a match. \n Return an array of the same length denoting how far off each guess was. If they have guessed correctly,\n the value is 0, and if not, the value is the absolute difference between the guess and the score.\n \n \n example:\n\n compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]\n compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]\n \"\"\"\n\n result = []\n for i in range(len(game)):\n if game[i] == guess[i]:\n result.append(0)\n else:\n result.append(abs(game[i] - guess[i]))\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/162": [{"task_id": "HumanEval/162", "solution": "\ndef string_to_md5(text):\n \"\"\"\n Given a string 'text', return its md5 hash equivalent string.\n If 'text' is an empty string, return None.\n\n >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'\n \"\"\"\n\n import hashlib\n if not text:\n return None\n m = hashlib.md5()\n m.update(text.encode('utf-8'))\n return m.hexdigest()\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/158": [{"task_id": "HumanEval/158", "solution": "\ndef find_max(words):\n \"\"\"Write a function that accepts a list of strings.\n The list contains different words. Return the word with maximum number\n of unique characters. If multiple strings have maximum number of unique\n characters, return the one which comes first in lexicographical order.\n\n find_max([\"name\", \"of\", \"string\"]) == \"string\"\n find_max([\"name\", \"enam\", \"game\"]) == \"enam\"\n find_max([\"aaaaaaa\", \"bb\" ,\"cc\"]) == \"\"aaaaaaa\"\n \"\"\"\n\n max_unique_chars = 0\n max_word = \"\"\n for word in words:\n unique_chars = set(word)\n if len(unique_chars) > max_unique_chars:\n max_unique_chars = len(unique_chars)\n max_word = word\n elif len(unique_chars) == max_unique_chars and word < max_word:\n max_word = word\n\n return max_word\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/159": [{"task_id": "HumanEval/159", "solution": "\ndef eat(number, need, remaining):\n \"\"\"\n You're a hungry rabbit, and you already have eaten a certain number of carrots,\n but now you need to eat more carrots to complete the day's meals.\n you should return an array of [ total number of eaten carrots after your meals,\n the number of carrots left after your meals ]\n if there are not enough remaining carrots, you will eat all remaining carrots, but will still be hungry.\n \n Example:\n * eat(5, 6, 10) -> [11, 4]\n * eat(4, 8, 9) -> [12, 1]\n * eat(1, 10, 10) -> [11, 0]\n * eat(2, 11, 5) -> [7, 0]\n \n Variables:\n @number : integer\n the number of carrots that you have eaten.\n @need : integer\n the number of carrots that you need to eat.\n @remaining : integer\n the number of remaining carrots thet exist in stock\n \n Constrain:\n * 0 <= number <= 1000\n * 0 <= need <= 1000\n * 0 <= remaining <= 1000\n\n Have fun :)\n \"\"\"\n\n if need <= remaining:\n return [number + need, remaining - need]\n else:\n return [number + remaining, 0]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/160": [{"task_id": "HumanEval/160", "solution": "\ndef do_algebra(operator, operand):\n \"\"\"\n Given two lists operator, and operand. The first list has basic algebra operations, and \n the second list is a list of integers. Use the two given lists to build the algebric \n expression and return the evaluation of this expression.\n\n The basic algebra operations:\n Addition ( + ) \n Subtraction ( - ) \n Multiplication ( * ) \n Floor division ( // ) \n Exponentiation ( ** ) \n\n Example:\n operator['+', '*', '-']\n array = [2, 3, 4, 5]\n result = 2 + 3 * 4 - 5\n => result = 9\n\n Note:\n The length of operator list is equal to the length of operand list minus one.\n Operand is a list of of non-negative integers.\n Operator list has at least one operator, and operand list has at least two operands.\n\n \"\"\"\n\n expression = \"\"\n for i in range(len(operand)):\n expression += str(operand[i])\n if i < len(operator):\n expression += operator[i]\n return eval(expression)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/161": [{"task_id": "HumanEval/161", "solution": "\ndef solve(s):\n \"\"\"You are given a string s.\n if s[i] is a letter, reverse its case from lower to upper or vise versa, \n otherwise keep it as it is.\n If the string contains no letters, reverse the string.\n The function should return the resulted string.\n Examples\n solve(\"1234\") = \"4321\"\n solve(\"ab\") = \"AB\"\n solve(\"#a@C\") = \"#A@c\"\n \"\"\"\n\n def reverse_case(ch):\n if ch.islower():\n return ch.upper()\n elif ch.isupper():\n return ch.lower()\n else:\n return ch\n\n result = \"\"\n for ch in s:\n result += reverse_case(ch)\n\n if not any(ch.isalpha() for ch in s):\n result = result[::-1]\n\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/130": [{"task_id": "HumanEval/130", "solution": "\ndef tri(n):\n \"\"\"Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in \n the last couple centuries. However, what people don't know is Tribonacci sequence.\n Tribonacci sequence is defined by the recurrence:\n tri(1) = 3\n tri(n) = 1 + n / 2, if n is even.\n tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.\n For example:\n tri(2) = 1 + (2 / 2) = 2\n tri(4) = 3\n tri(3) = tri(2) + tri(1) + tri(4)\n = 2 + 3 + 3 = 8 \n You are given a non-negative integer number n, you have to a return a list of the \n first n + 1 numbers of the Tribonacci sequence.\n Examples:\n tri(3) = [1, 3, 2, 8]\n \"\"\"\n\n if n == 0:\n return []\n elif n == 1:\n return [1]\n elif n == 2:\n return [1, 3]\n elif n == 3:\n return [1, 3, 2, 8]\n else:\n sequence = [1, 3, 2, 8]\n for i in range(4, n + 1):\n if i % 2 == 0:\n sequence.append(1 + i / 2)\n else:\n sequence.append(sequence[i - 1] + sequence[i - 2] + sequence[i + 1])\n return sequence\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[5]], "plus_fail_tests": []}], "HumanEval/25": [{"task_id": "HumanEval/25", "solution": "from typing import List\n\n\ndef factorize(n: int) -> List[int]:\n \"\"\" Return list of prime factors of given integer in the order from smallest to largest.\n Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.\n Input number should be equal to the product of all factors\n >>> factorize(8)\n [2, 2, 2]\n >>> factorize(25)\n [5, 5]\n >>> factorize(70)\n [2, 5, 7]\n \"\"\"\n\n factors = []\n factor = 2\n while n > 1:\n if n % factor == 0:\n factors.append(factor)\n n //= factor\n else:\n factor += 1\n return factors\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[123456791]]}], "HumanEval/147": [{"task_id": "HumanEval/147", "solution": "\ndef get_max_triples(n):\n \"\"\"\n You are given a positive integer n. You have to create an integer array a of length n.\n For each i (1 \u2264 i \u2264 n), the value of a[i] = i * i - i + 1.\n Return the number of triples (a[i], a[j], a[k]) of a where i < j < k, \n and a[i] + a[j] + a[k] is a multiple of 3.\n\n Example :\n Input: n = 5\n Output: 1\n Explanation: \n a = [1, 3, 7, 13, 21]\n The only valid triple is (1, 7, 13).\n \"\"\"\n\n a = [i * i - i + 1 for i in range(1, n + 1)]\n count = 0\n for i in range(len(a) - 2):\n for j in range(i + 1, len(a) - 1):\n for k in range(j + 1, len(a)):\n if (a[i] + a[j] + a[k]) % 3 == 0:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/15": [{"task_id": "HumanEval/15", "solution": "\n\ndef string_sequence(n: int) -> str:\n \"\"\" Return a string containing space-delimited numbers starting from 0 upto n inclusive.\n >>> string_sequence(0)\n '0'\n >>> string_sequence(5)\n '0 1 2 3 4 5'\n \"\"\"\n\n return \" \".join(map(str, range(n+1)))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/103": [{"task_id": "HumanEval/103", "solution": "\ndef rounded_avg(n, m):\n \"\"\"You are given two positive integers n and m, and your task is to compute the\n average of the integers from n through m (including n and m). \n Round the answer to the nearest integer and convert that to binary.\n If n is greater than m, return -1.\n Example:\n rounded_avg(1, 5) => \"0b11\"\n rounded_avg(7, 5) => -1\n rounded_avg(10, 20) => \"0b1111\"\n rounded_avg(20, 33) => \"0b11010\"\n \"\"\"\n\n if n > m:\n return -1\n total = 0\n for i in range(n, m+1):\n total += i\n avg = total / (m - n + 1)\n rounded_avg = round(avg)\n binary_avg = bin(rounded_avg)\n return binary_avg\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "HumanEval/94": [{"task_id": "HumanEval/94", "solution": "\n\ndef skjkasdkd(lst):\n \"\"\"You are given a list of integers.\n You need to find the largest prime value and return the sum of its digits.\n\n Examples:\n For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] the output should be 10\n For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] the output should be 25\n For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13\n For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11\n For lst = [0,81,12,3,1,21] the output should be 3\n For lst = [0,8,1,2,1,7] the output should be 7\n \"\"\"\n\n def is_prime(num):\n if num < 2:\n return False\n for i in range(2, int(num ** 0.5) + 1):\n if num % i == 0:\n return False\n return True\n max_prime = -1\n for num in lst:\n if is_prime(num):\n max_prime = max(max_prime, num)\n if max_prime < 0:\n return 0\n return sum(int(digit) for digit in str(max_prime))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}]}} evalplus-starcoder2-15b-instruct-v0.1-mbpp.jsonl 0000664 0000000 0000000 00000234513 14637551746 0035034 0 ustar 00root root 0000000 0000000 selfcodealign-selfcodealign/evaluation/evalplus_results {"task_id": "Mbpp/2", "completion": "\ndef similar_elements(list1, list2):\n return set(list1).intersection(set(list2))\n"}
{"task_id": "Mbpp/3", "completion": "\ndef is_not_prime(num):\n if num <= 1:\n return False\n for i in range(2, num):\n if num % i == 0:\n return True\n return False\n"}
{"task_id": "Mbpp/4", "completion": "\ndef heap_queue_largest(nums, n):\n import heapq\n return heapq.nlargest(n, nums)\n"}
{"task_id": "Mbpp/6", "completion": "\ndef differ_At_One_Bit_Pos(num1, num2):\n xor_result = num1 ^ num2\n return xor_result & (xor_result - 1) == 0\n"}
{"task_id": "Mbpp/7", "completion": "\ndef find_char_long(s):\n return [word for word in s.split() if len(word) >= 4]\n"}
{"task_id": "Mbpp/8", "completion": "\ndef square_nums(nums):\n return [num**2 for num in nums]\n"}
{"task_id": "Mbpp/9", "completion": "\ndef find_Rotations(s):\n n = len(s)\n for i in range(1, n):\n if s[i:] + s[:i] == s:\n return i\n return n\n"}
{"task_id": "Mbpp/11", "completion": "\ndef remove_Occ(string, char):\n first_index = string.find(char)\n last_index = string.rfind(char)\n if first_index == last_index:\n return string.replace(char, \"\")\n else:\n return string[:first_index] + string[first_index + 1:last_index] + string[last_index + 1:]\n"}
{"task_id": "Mbpp/12", "completion": "\ndef sort_matrix(matrix):\n row_sums = [sum(row) for row in matrix]\n sorted_indices = sorted(range(len(row_sums)), key=lambda i: row_sums[i])\n sorted_matrix = [matrix[i] for i in sorted_indices]\n return sorted_matrix\n"}
{"task_id": "Mbpp/14", "completion": "\ndef find_Volume(base, height, length):\n area = 0.5 * base * height\n volume = area * length\n return volume\n"}
{"task_id": "Mbpp/16", "completion": "\nimport re\n\ndef text_lowercase_underscore(text):\n pattern = re.compile(r'^[a-z_]+$')\n return pattern.match(text) is not None\n"}
{"task_id": "Mbpp/17", "completion": "\ndef square_perimeter(side_length):\n return 4 * side_length\n"}
{"task_id": "Mbpp/18", "completion": "\ndef remove_dirty_chars(string, dirty_chars):\n char_set = set(dirty_chars)\n clean_string = ''.join(c for c in string if c not in char_set)\n return clean_string\n"}
{"task_id": "Mbpp/19", "completion": "\ndef test_duplicate(arr):\n return len(arr)!= len(set(arr))\n"}
{"task_id": "Mbpp/20", "completion": "\ndef is_woodall(n):\n if n < 0:\n return False\n for i in range(1, n + 1):\n if i ** i!= n:\n return False\n return True\n"}
{"task_id": "Mbpp/56", "completion": "\ndef check(num):\n num_str = str(num)\n reversed_num_str = num_str[::-1]\n reversed_num = int(reversed_num_str)\n return num == reversed_num * 2 - 1\n"}
{"task_id": "Mbpp/57", "completion": "\ndef find_Max_Num(arr):\n arr.sort(reverse=True)\n return int(\"\".join(map(str, arr)))\n"}
{"task_id": "Mbpp/58", "completion": "\ndef opposite_Signs(a, b):\n return a * b < 0\n"}
{"task_id": "Mbpp/59", "completion": "\ndef is_octagonal(n):\n return (3 * n * n - 2 * n) // 2\n"}
{"task_id": "Mbpp/61", "completion": "\ndef count_Substrings(s):\n count = 0\n for i in range(len(s)):\n for j in range(i+1, len(s)+1):\n substring = s[i:j]\n if sum(int(digit) for digit in substring) == len(substring):\n count += 1\n return count\n"}
{"task_id": "Mbpp/62", "completion": "\ndef smallest_num(list):\n return min(list)\n"}
{"task_id": "Mbpp/63", "completion": "\ndef max_difference(tuples):\n differences = []\n for i, (x, y) in enumerate(tuples):\n for j, (x2, y2) in enumerate(tuples):\n if i!= j:\n differences.append(abs(x - x2) + abs(y - y2))\n return max(differences)\n"}
{"task_id": "Mbpp/64", "completion": "\ndef subject_marks(marks):\n return sorted(marks, key=lambda x: x[1])\n"}
{"task_id": "Mbpp/65", "completion": "\ndef recursive_list_sum(input_list):\n total = 0\n for element in input_list:\n if type(element) == type([]):\n total += recursive_list_sum(element)\n else:\n total += element\n return total\n"}
{"task_id": "Mbpp/66", "completion": "\ndef pos_count(lst):\n count = 0\n for num in lst:\n if num > 0:\n count += 1\n return count\n"}
{"task_id": "Mbpp/67", "completion": "\ndef bell_number(n):\n if n == 0:\n return 1\n else:\n return sum(bell_number(k) * bell_number(n - k - 1) for k in range(n))\n"}
{"task_id": "Mbpp/68", "completion": "\ndef is_Monotonic(arr):\n return all(arr[i] <= arr[i + 1] for i in range(len(arr) - 1)) or all(arr[i] >= arr[i + 1] for i in range(len(arr) - 1))\n"}
{"task_id": "Mbpp/69", "completion": "\ndef is_sublist(lst, sublist):\n n = len(sublist)\n return any(sublist == lst[i:i+n] for i in range(len(lst)-n+1))\n"}
{"task_id": "Mbpp/70", "completion": "\ndef get_equal(tuples):\n lengths = set(len(t) for t in tuples)\n return len(lengths) == 1\n"}
{"task_id": "Mbpp/71", "completion": "\ndef comb_sort(elements):\n gap = len(elements)\n shrink = 1.3\n while gap > 1:\n gap = int(gap / shrink)\n for i in range(len(elements) - gap):\n if elements[i] > elements[i + gap]:\n elements[i], elements[i + gap] = elements[i + gap], elements[i]\n return elements\n"}
{"task_id": "Mbpp/72", "completion": "\nimport math\n\ndef dif_Square(n):\n if n < 0:\n return False\n for a in range(int(math.sqrt(n)) + 1):\n b = math.sqrt(n - a**2)\n if b == int(b):\n return True\n return False\n"}
{"task_id": "Mbpp/74", "completion": "\ndef is_samepatterns(colors, patterns):\n pattern_dict = {\"red\": \"a\", \"green\": \"b\", \"blue\": \"c\"}\n mapped_patterns = [pattern_dict[color] for color in colors]\n return mapped_patterns == patterns\n"}
{"task_id": "Mbpp/75", "completion": "\ndef find_tuples(tuples, k):\n return [t for t in tuples if all(element % k == 0 for element in t)]\n"}
{"task_id": "Mbpp/77", "completion": "\ndef is_Divisible(num):\n num_str = str(num)\n odd_sum = 0\n even_sum = 0\n for i in range(len(num_str)):\n digit = int(num_str[i])\n if i % 2 == 0:\n even_sum += digit\n else:\n odd_sum += digit\n return (odd_sum - even_sum) % 11 == 0\n"}
{"task_id": "Mbpp/79", "completion": "\ndef word_len(word):\n return len(word) % 2 == 1\n"}
{"task_id": "Mbpp/80", "completion": "\ndef tetrahedral_number(n):\n return n * (n + 1) * (n + 2) // 6\n"}
{"task_id": "Mbpp/82", "completion": "\nimport math\n\ndef volume_sphere(radius):\n return 4 / 3 * math.pi * radius ** 3\n"}
{"task_id": "Mbpp/83", "completion": "\ndef get_Char(string):\n sum_ascii = 0\n for char in string:\n sum_ascii += ord(char)\n remainder = sum_ascii % 26\n return chr(remainder + ord(\"a\"))\n"}
{"task_id": "Mbpp/84", "completion": "\ndef sequence(n):\n if n == 1:\n return 1\n if n == 2:\n return 1\n if n == 3:\n return 2\n prev_term = sequence(n - 1)\n count = 1\n index = n - 2\n while count < prev_term:\n if sequence(index) == 1:\n count += 1\n index -= 1\n return n - index - 1\n"}
{"task_id": "Mbpp/85", "completion": "\nimport math\n\ndef surfacearea_sphere(radius):\n return 4 * math.pi * radius ** 2\n"}
{"task_id": "Mbpp/86", "completion": "\ndef centered_hexagonal_number(n):\n return 3 * n * (n - 1) + 1\n"}
{"task_id": "Mbpp/87", "completion": "\ndef merge_dictionaries_three(dict1, dict2, dict3):\n return {**dict1, **dict2, **dict3}\n"}
{"task_id": "Mbpp/88", "completion": "\ndef freq_count(lst):\n freq_dict = {}\n for element in lst:\n if element in freq_dict:\n freq_dict[element] += 1\n else:\n freq_dict[element] = 1\n return freq_dict\n"}
{"task_id": "Mbpp/89", "completion": "\ndef closest_num(n):\n num_str = str(n)\n for i in range(len(num_str)-1, 0, -1):\n if num_str[i] < num_str[i-1]:\n num_str = num_str[:i-1] + num_str[i:]\n num_str = num_str[:i] + ''.join(reversed(sorted(num_str[i:])))\n return int(num_str)\n return n\n"}
{"task_id": "Mbpp/90", "completion": "\ndef len_log(words):\n max_len = 0\n for word in words:\n if len(word) > max_len:\n max_len = len(word)\n return max_len\n"}
{"task_id": "Mbpp/91", "completion": "\ndef find_substring(list_of_strings, substring):\n for string in list_of_strings:\n if substring in string:\n return True\n return False\n"}
{"task_id": "Mbpp/92", "completion": "\ndef is_undulating(num):\n num_str = str(num)\n for i in range(len(num_str) - 2):\n if num_str[i] == num_str[i+1] or num_str[i+1] == num_str[i+2]:\n return False\n return True\n"}
{"task_id": "Mbpp/93", "completion": "\ndef power(a, b):\n return a ** b\n"}
{"task_id": "Mbpp/94", "completion": "\ndef index_minimum(tuples):\n return min(tuples, key=lambda x: x[1])[0]\n"}
{"task_id": "Mbpp/95", "completion": "\ndef Find_Min_Length(lists):\n min_length = float('inf')\n for lst in lists:\n min_length = min(min_length, len(lst))\n return min_length\n"}
{"task_id": "Mbpp/96", "completion": "\ndef divisor(n):\n count = 0\n for i in range(1, n+1):\n if n % i == 0:\n count += 1\n return count\n"}
{"task_id": "Mbpp/97", "completion": "\nfrom collections import Counter\n\ndef frequency_lists(lists):\n flattened_list = [item for sublist in lists for item in sublist]\n frequency_dict = Counter(flattened_list)\n return frequency_dict\n"}
{"task_id": "Mbpp/98", "completion": "\nimport math\n\ndef multiply_num(numbers):\n result = 1\n for num in numbers:\n result *= num\n return result / len(numbers)\n"}
{"task_id": "Mbpp/99", "completion": "\ndef decimal_to_binary(decimal_number):\n binary_string = bin(decimal_number)[2:]\n return binary_string\n"}
{"task_id": "Mbpp/100", "completion": "\ndef next_smallest_palindrome(num: int) -> int:\n num_str = str(num)\n if num_str == num_str[::-1]:\n return int(num_str)\n else:\n num_list = list(num_str)\n for i in range(len(num_list) // 2):\n if num_list[i]!= num_list[-i - 1]:\n num_list[i] = num_list[-i - 1] = max(num_list[i], num_list[-i - 1])\n break\n return int(\"\".join(num_list))\n"}
{"task_id": "Mbpp/101", "completion": "\ndef kth_element(arr, k):\n return arr[k-1]\n"}
{"task_id": "Mbpp/102", "completion": "\ndef snake_to_camel(s):\n return ''.join(x.capitalize() if i else x.lower() for i, x in enumerate(s.split('_')))\n"}
{"task_id": "Mbpp/103", "completion": "\ndef eulerian_num(n, m):\n if n == 0 and m == 0:\n return 1\n elif n < m or m < 0:\n return 0\n else:\n return eulerian_num(n - 1, m - 1) + (n - 1) * eulerian_num(n - 1, m)\n"}
{"task_id": "Mbpp/104", "completion": "\ndef sort_sublists(input_list):\n return [[sorted(sublist)] for sublist in input_list]\n"}
{"task_id": "Mbpp/105", "completion": "\ndef count(lst):\n return sum(1 for x in lst if x)\n"}
{"task_id": "Mbpp/106", "completion": "\ndef add_lists(list_to_append, tuple_to_append_to):\n return tuple_to_append_to + tuple(list_to_append)\n"}
{"task_id": "Mbpp/108", "completion": "\ndef merge_sorted_list(list1, list2, list3):\n merged_list = list1 + list2 + list3\n merged_list.sort()\n return merged_list\n"}
{"task_id": "Mbpp/109", "completion": "\ndef odd_Equivalent(s, n):\n count = 0\n for i in range(len(s)):\n rotated_s = s[i:] + s[:i]\n if int(rotated_s, 2) % 2 == 1:\n count += 1\n return count\n"}
{"task_id": "Mbpp/111", "completion": "\ndef common_in_nested_lists(nested_lists):\n common_elements = set(nested_lists[0])\n for lst in nested_lists[1:]:\n common_elements &= set(lst)\n return list(common_elements)\n"}
{"task_id": "Mbpp/113", "completion": "\ndef check_integer(s):\n try:\n int(s)\n return True\n except ValueError:\n return False\n"}
{"task_id": "Mbpp/115", "completion": "\ndef empty_dit(list):\n for i in list:\n if not i:\n return False\n return True\n"}
{"task_id": "Mbpp/116", "completion": "\ndef tuple_to_int(tup):\n return int(\"\".join(map(str, tup)))\n"}
{"task_id": "Mbpp/117", "completion": "\ndef list_to_float(input_list):\n return [(float(x), float(y)) for x, y in input_list]\n"}
{"task_id": "Mbpp/118", "completion": "\ndef string_to_list(string):\n return string.split()\n"}
{"task_id": "Mbpp/119", "completion": "\ndef search(nums):\n left, right = 0, len(nums) - 1\n while left < right:\n mid = (left + right) // 2\n if nums[mid] == nums[mid + 1]:\n left = mid + 2\n else:\n right = mid\n return nums[left]\n"}
{"task_id": "Mbpp/120", "completion": "\ndef max_product_tuple(lst):\n max_product = float(\"-inf\")\n for a, b in lst:\n max_product = max(max_product, a * b, -a * b)\n return max_product\n"}
{"task_id": "Mbpp/123", "completion": "\ndef amicable_numbers_sum(n):\n def get_divisors_sum(num):\n divisors_sum = 0\n for i in range(1, num):\n if num % i == 0:\n divisors_sum += i\n return divisors_sum\n\n amicable_numbers_sum = 0\n for a in range(1, n + 1):\n b = get_divisors_sum(a)\n if a!= b and get_divisors_sum(b) == a:\n amicable_numbers_sum += a\n return amicable_numbers_sum\n"}
{"task_id": "Mbpp/124", "completion": "\nimport cmath\n\ndef angle_complex(real, imag):\n return cmath.phase(complex(real, imag))\n"}
{"task_id": "Mbpp/125", "completion": "\ndef find_length(s):\n n = len(s)\n max_diff = 0\n for i in range(n):\n for j in range(i, n):\n num_zeros = s[i:j + 1].count('0')\n num_ones = s[i:j + 1].count('1')\n diff = abs(num_zeros - num_ones)\n max_diff = max(max_diff, diff)\n return max_diff\n"}
{"task_id": "Mbpp/126", "completion": "\ndef sum(num1, num2):\n sum = 0\n for i in range(1, min(num1, num2) + 1):\n if num1 % i == 0 and num2 % i == 0:\n sum += i\n return sum\n"}
{"task_id": "Mbpp/127", "completion": "\ndef multiply_int(a, b):\n if a == 0 or b == 0:\n return 0\n if a == 1:\n return b\n if b == 1:\n return a\n return a + multiply_int(a, b - 1)\n"}
{"task_id": "Mbpp/128", "completion": "\ndef long_words(n,words):\n return [word for word in words if len(word) > n]\n"}
{"task_id": "Mbpp/129", "completion": "\ndef magic_square_test(matrix):\n n = len(matrix)\n magic_sum = sum(matrix[0])\n for row in matrix:\n if sum(row)!= magic_sum:\n return False\n for col in range(n):\n col_sum = sum(matrix[i][col] for i in range(n))\n if col_sum!= magic_sum:\n return False\n diagonal_sum = sum(matrix[i][i] for i in range(n))\n if diagonal_sum!= magic_sum:\n return False\n diagonal_sum = sum(matrix[i][n - i - 1] for i in range(n))\n if diagonal_sum!= magic_sum:\n return False\n return True\n"}
{"task_id": "Mbpp/130", "completion": "\ndef max_occurrences(lst):\n freq = {}\n for item in lst:\n if item in freq:\n freq[item] += 1\n else:\n freq[item] = 1\n return max(freq, key=freq.get)\n"}
{"task_id": "Mbpp/131", "completion": "\ndef reverse_vowels(s):\n vowels = {'a', 'e', 'i', 'o', 'u'}\n chars = list(s)\n i, j = 0, len(s) - 1\n while i < j:\n if chars[i].lower() in vowels:\n if chars[j].lower() in vowels:\n chars[i], chars[j] = chars[j], chars[i]\n i += 1\n j -= 1\n else:\n j -= 1\n else:\n i += 1\n return ''.join(chars)\n"}
{"task_id": "Mbpp/132", "completion": "\ndef tup_string(tup):\n str = ''.join(tup)\n return str\n"}
{"task_id": "Mbpp/133", "completion": "\ndef sum_negativenum(num_list):\n sum = 0\n for num in num_list:\n if num < 0:\n sum += num\n return sum\n"}
{"task_id": "Mbpp/135", "completion": "\ndef hexagonal_num(n):\n return 2 * n * (2 * n - 1)\n"}
{"task_id": "Mbpp/137", "completion": "\nimport numpy as np\n\ndef zero_count(arr):\n arr = np.array(arr)\n num_zeroes = np.count_nonzero(arr == 0)\n num_non_zeroes = np.count_nonzero(arr!= 0)\n return num_zeroes / (num_zeroes + num_non_zeroes)\n"}
{"task_id": "Mbpp/138", "completion": "\ndef is_Sum_Of_Powers_Of_Two(num):\n while num > 0:\n if num == 1:\n return True\n power_of_two = 1\n while power_of_two <= num // 2:\n if num - power_of_two == 1:\n return True\n elif num - power_of_two > 1:\n if is_Sum_Of_Powers_Of_Two(num - power_of_two):\n return True\n power_of_two *= 2\n num -= 1\n return False\n"}
{"task_id": "Mbpp/139", "completion": "\nimport math\n\ndef circle_circumference(radius):\n return 2 * math.pi * radius\n"}
{"task_id": "Mbpp/140", "completion": "\ndef extract_singly(lst):\n return [num for sublist in lst for num in sublist]\n"}
{"task_id": "Mbpp/141", "completion": "\ndef pancake_sort(lst):\n def flip(lst, i):\n lst[:] = lst[:i+1][::-1] + lst[i+1:]\n\n n = len(lst)\n for i in range(n-1, 0, -1):\n max_idx = lst[:i+1].index(max(lst[:i+1]))\n flip(lst, max_idx)\n flip(lst, i)\n return lst\n"}
{"task_id": "Mbpp/142", "completion": "\ndef count_samepair(list1,list2,list3):\n count=0\n for i in range(len(list1)):\n if list1[i]==list2[i]==list3[i]:\n count+=1\n return count\n"}
{"task_id": "Mbpp/143", "completion": "\ndef find_lists(input_tuple):\n count = 0\n for element in input_tuple:\n if isinstance(element, list):\n count += 1\n return count\n"}
{"task_id": "Mbpp/145", "completion": "\ndef max_Abs_Diff(arr):\n max_diff = 0\n for i in range(len(arr)):\n for j in range(i+1, len(arr)):\n diff = abs(arr[i] - arr[j])\n if diff > max_diff:\n max_diff = diff\n return max_diff\n"}
{"task_id": "Mbpp/160", "completion": "\ndef find_solution(a, b, n):\n def gcd(a, b):\n if a == 0:\n return b\n return gcd(b % a, a)\n\n if n % gcd(a, b)!= 0:\n return None\n x0 = 0\n y0 = n // b\n while a * x0 + b * y0!= n:\n x0 -= n // b\n y0 += n // a\n return (x0, y0)\n"}
{"task_id": "Mbpp/161", "completion": "\ndef remove_elements(lst, remove_lst):\n return [x for x in lst if x not in remove_lst]\n"}
{"task_id": "Mbpp/162", "completion": "\ndef sum_series(n):\n sum = 0\n for i in range(0, n // 2 + 1):\n sum += n - 2 * i\n return sum\n"}
{"task_id": "Mbpp/164", "completion": "\ndef are_equivalent(num1, num2):\n sum_divisors1 = 0\n for i in range(1, num1 + 1):\n if num1 % i == 0:\n sum_divisors1 += i\n\n sum_divisors2 = 0\n for i in range(1, num2 + 1):\n if num2 % i == 0:\n sum_divisors2 += i\n\n return sum_divisors1 == sum_divisors2\n"}
{"task_id": "Mbpp/165", "completion": "\nimport string\n\ndef count_char_position(s):\n count = 0\n for i, c in enumerate(s.lower()):\n if c == string.ascii_lowercase[i]:\n count += 1\n return count\n"}
{"task_id": "Mbpp/166", "completion": "\ndef find_even_pair(nums):\n count = 0\n for i in range(len(nums)):\n for j in range(i + 1, len(nums)):\n if (nums[i] ^ nums[j]) % 2 == 0:\n count += 1\n return count\n"}
{"task_id": "Mbpp/167", "completion": "\ndef next_power_of_2(n):\n result = 1\n while result < n:\n result *= 2\n return result\n"}
{"task_id": "Mbpp/168", "completion": "\ndef frequency(lst, num):\n count = 0\n for i in lst:\n if i == num:\n count += 1\n return count\n"}
{"task_id": "Mbpp/170", "completion": "\ndef sum_range_list(lst, start, end):\n return sum(lst[start:end+1])\n"}
{"task_id": "Mbpp/171", "completion": "\ndef perimeter_pentagon(side_length):\n return 5 * side_length\n"}
{"task_id": "Mbpp/172", "completion": "\ndef count_occurance(string):\n count = 0\n for i in range(len(string)-2):\n if string[i:i+3] == \"std\":\n count += 1\n return count\n"}
{"task_id": "Mbpp/222", "completion": "\ndef check_type(tup):\n data_type = type(tup[0])\n for element in tup:\n if type(element)!= data_type:\n return False\n return True\n"}
{"task_id": "Mbpp/223", "completion": "\ndef is_majority(arr, n, element):\n first_occurrence = binary_search(arr, 0, n - 1, element)\n if first_occurrence == -1:\n return False\n last_occurrence = binary_search(arr, first_occurrence + 1, n - 1, element)\n if last_occurrence == -1:\n return False\n return last_occurrence - first_occurrence + 1 > n // 2\n\ndef binary_search(arr, low, high, element):\n if high >= low:\n mid = (low + high) // 2\n if (mid == 0 or arr[mid - 1] < element) and arr[mid] == element:\n return mid\n elif arr[mid] < element:\n return binary_search(arr, mid + 1, high, element)\n else:\n return binary_search(arr, low, mid - 1, element)\n return -1\n"}
{"task_id": "Mbpp/224", "completion": "\ndef count_Set_Bits(num):\n return bin(num).count('1')\n"}
{"task_id": "Mbpp/226", "completion": "\ndef odd_values_string(string):\n return ''.join([char for i, char in enumerate(string) if i % 2 == 0])\n"}
{"task_id": "Mbpp/227", "completion": "\ndef min_of_three(a,b,c):\n if a= 0]\n return negative_elements + positive_elements\n"}
{"task_id": "Mbpp/230", "completion": "\ndef replace_blank(string, char):\n return string.replace(' ', char)\n"}
{"task_id": "Mbpp/232", "completion": "\ndef larg_nnum(lst,n):\n lst.sort(reverse=True)\n return lst[:n]\n"}
{"task_id": "Mbpp/233", "completion": "\nimport math\n\ndef lateralsuface_cylinder(radius, height):\n return 2 * math.pi * radius * height\n"}
{"task_id": "Mbpp/234", "completion": "\ndef volume_cube(side_length):\n return side_length ** 3\n"}
{"task_id": "Mbpp/235", "completion": "\ndef even_bit_set_number(number):\n return number | 0x55555555\n"}
{"task_id": "Mbpp/237", "completion": "\ndef check_occurences(tuple_list):\n occurences = {}\n for t in tuple_list:\n if t in occurences:\n occurences[t] += 1\n else:\n occurences[t] = 1\n return occurences\n"}
{"task_id": "Mbpp/238", "completion": "\ndef number_of_substrings(string):\n return len(string) * (len(string) + 1) // 2\n"}
{"task_id": "Mbpp/239", "completion": "\ndef get_total_number_of_sequences(m, n):\n dp = [[0] * (n + 1) for _ in range(m + 1)]\n for i in range(1, m + 1):\n dp[i][1] = 1\n for i in range(1, m + 1):\n for j in range(2, n + 1):\n for k in range(1, i // 2 + 1):\n dp[i][j] += dp[k][j - 1]\n\n return sum(dp[i][n] for i in range(1, m + 1))\n"}
{"task_id": "Mbpp/240", "completion": "\ndef replace_list(list1, list2):\n list1[-1:] = list2\n return list1\n"}
{"task_id": "Mbpp/242", "completion": "\ndef count_charac(string):\n return len(string)\n"}
{"task_id": "Mbpp/244", "completion": "\nimport math\n\ndef next_Perfect_Square(num):\n root = math.sqrt(num)\n if root.is_integer():\n return num + 1\n next_root = math.ceil(root)\n return (next_root + 1) ** 2\n"}
{"task_id": "Mbpp/245", "completion": "\ndef max_sum(arr):\n n = len(arr)\n increasing = [0] * n\n decreasing = [0] * n\n increasing[0] = arr[0]\n for i in range(1, n):\n increasing[i] = arr[i] + max(increasing[i - 1], 0)\n decreasing[n - 1] = arr[n - 1]\n for i in range(n - 2, -1, -1):\n decreasing[i] = arr[i] + max(decreasing[i + 1], 0)\n max_sum = 0\n for i in range(n):\n max_sum = max(max_sum, increasing[i] + decreasing[i] - arr[i])\n\n return max_sum\n"}
{"task_id": "Mbpp/247", "completion": "\ndef lps(s):\n n = len(s)\n dp = [[0] * n for _ in range(n)]\n for i in range(n):\n dp[i][i] = 1\n for l in range(2, n + 1):\n for i in range(n - l + 1):\n j = i + l - 1\n if s[i] == s[j] and l == 2:\n dp[i][j] = 2\n elif s[i] == s[j]:\n dp[i][j] = dp[i + 1][j - 1] + 2\n else:\n dp[i][j] = max(dp[i + 1][j], dp[i][j - 1])\n return dp[0][n - 1]\n"}
{"task_id": "Mbpp/249", "completion": "\ndef intersection_array(arr1, arr2):\n return list(set(arr1) & set(arr2))\n"}
{"task_id": "Mbpp/250", "completion": "\ndef count_X(tup, x):\n return tup.count(x)\n"}
{"task_id": "Mbpp/251", "completion": "\ndef insert_element(lst, element):\n return [element] + lst\n"}
{"task_id": "Mbpp/252", "completion": "\nimport cmath\n\ndef convert(z):\n return cmath.polar(z)\n"}
{"task_id": "Mbpp/253", "completion": "\ndef count_integer(lst):\n count = 0\n for element in lst:\n if isinstance(element, int):\n count += 1\n return count\n"}
{"task_id": "Mbpp/255", "completion": "\nfrom itertools import combinations_with_replacement\n\ndef combinations_colors(colors, n):\n return list(combinations_with_replacement(colors, n))\n"}
{"task_id": "Mbpp/256", "completion": "\ndef is_prime(num):\n if num <= 1:\n return False\n for i in range(2, int(num**0.5) + 1):\n if num % i == 0:\n return False\n return True\n\ndef count_Primes_nums(num):\n count = 0\n for i in range(num):\n if is_prime(i):\n count += 1\n return count\n"}
{"task_id": "Mbpp/257", "completion": "\ndef swap_numbers(num1, num2):\n return (num2, num1)\n"}
{"task_id": "Mbpp/259", "completion": "\ndef maximize_elements(tuple1, tuple2):\n zipped_tuples = zip(tuple1, tuple2)\n max_elements = map(lambda x: max(x[0][1], x[1][1]), zipped_tuples)\n return tuple(max_elements)\n"}
{"task_id": "Mbpp/260", "completion": "\ndef newman_prime(n):\n primes = [2]\n i = 3\n while len(primes) < n:\n is_prime = True\n for p in primes:\n if i % p == 0:\n is_prime = False\n break\n if is_prime:\n primes.append(i)\n i += 2\n return primes[-1]\n"}
{"task_id": "Mbpp/261", "completion": "\ndef division_elements(tuple1, tuple2):\n return tuple(map(lambda x, y: x / y, tuple1, tuple2))\n"}
{"task_id": "Mbpp/262", "completion": "\ndef split_two_parts(lst, L):\n return lst[:L], lst[L:]\n"}
{"task_id": "Mbpp/264", "completion": "\ndef dog_age(human_age):\n if human_age <= 2:\n dog_age = human_age * 10.5\n else:\n dog_age = 21 + (human_age - 2) * 4\n return dog_age\n"}
{"task_id": "Mbpp/265", "completion": "\ndef list_split(lst, n):\n return [lst[i::n] for i in range(n)]\n"}
{"task_id": "Mbpp/266", "completion": "\ndef lateralsurface_cube(side_length):\n return 4 * side_length * side_length\n"}
{"task_id": "Mbpp/267", "completion": "\ndef square_Sum(n):\n sum = 0\n for i in range(1, 2 * n + 1, 2):\n sum += i * i\n return sum\n"}
{"task_id": "Mbpp/268", "completion": "\ndef find_star_num(n):\n count = 0\n num = 1\n while count < n:\n if str(num).count('1') > 0:\n count += 1\n num += 1\n return num - 1\n"}
{"task_id": "Mbpp/269", "completion": "\ndef ascii_value(char):\n return ord(char)\n"}
{"task_id": "Mbpp/270", "completion": "\ndef sum_even_and_even_index(lst):\n return sum(n for i, n in enumerate(lst) if i % 2 == 0 and n % 2 == 0)\n"}
{"task_id": "Mbpp/271", "completion": "\ndef even_Power_Sum(n):\n sum = 0\n for i in range(1, n+1):\n num = 2 * i\n sum += num ** 5\n return sum\n"}
{"task_id": "Mbpp/272", "completion": "\ndef rear_extract(tuples):\n return [x[-1] for x in tuples]\n"}
{"task_id": "Mbpp/273", "completion": "\ndef substract_elements(tuple1, tuple2):\n result = ()\n for i in range(len(tuple1)):\n result += (tuple1[i] - tuple2[i],)\n return result\n"}
{"task_id": "Mbpp/274", "completion": "\nfrom math import factorial\n\ndef even_binomial_Coeff_Sum(n):\n sum_even_index_binomial_coeffs = 0\n for i in range(0, n+1, 2):\n binomial_coeff = factorial(n) // (factorial(i) * factorial(n - i))\n sum_even_index_binomial_coeffs += binomial_coeff\n return sum_even_index_binomial_coeffs\n"}
{"task_id": "Mbpp/276", "completion": "\nimport math\n\ndef volume_cylinder(radius, height):\n return math.pi * radius**2 * height\n"}
{"task_id": "Mbpp/277", "completion": "\ndef dict_filter(d, n):\n return {k: v for k, v in d.items() if v >= n}\n"}
{"task_id": "Mbpp/278", "completion": "\ndef count_first_elements(tup):\n count = 0\n for element in tup:\n if isinstance(element, tuple):\n count += 1\n if element[0] in element:\n return count\n return count\n"}
{"task_id": "Mbpp/279", "completion": "\ndef is_num_decagonal(n):\n return (5 * n * (2 * n - 1)) // 2\n"}
{"task_id": "Mbpp/280", "completion": "\ndef sequential_search(arr, element):\n for i, e in enumerate(arr):\n if e == element:\n return True, i\n return False, -1\n"}
{"task_id": "Mbpp/281", "completion": "\ndef all_unique(lst):\n return len(lst) == len(set(lst))\n"}
{"task_id": "Mbpp/282", "completion": "\ndef sub_list(list1, list2):\n return [a - b for a, b in zip(list1, list2)]\n"}
{"task_id": "Mbpp/283", "completion": "\ndef validate(num: int) -> bool:\n freq = [0] * 10\n while num > 0:\n digit = num % 10\n freq[digit] += 1\n num //= 10\n for i, count in enumerate(freq):\n if count > i:\n return False\n return True\n"}
{"task_id": "Mbpp/284", "completion": "\ndef check_element(list,element):\n for i in list:\n if i!= element:\n return False\n return True\n"}
{"task_id": "Mbpp/285", "completion": "\nimport re\n\ndef text_match_two_three(input):\n pattern = r\"a(bb|bbb)\"\n if re.search(pattern, input):\n return True\n else:\n return False\n"}
{"task_id": "Mbpp/286", "completion": "\ndef max_sub_array_sum_repeated(arr, n, k):\n max_sum = float(\"-inf\")\n for i in range(n):\n sum = 0\n for j in range(i, n * k):\n sum += arr[j % n]\n if sum > max_sum:\n max_sum = sum\n return max_sum\n"}
{"task_id": "Mbpp/287", "completion": "\ndef square_Sum(n):\n sum = 0\n for i in range(1, n+1):\n sum += (2*i)**2\n return sum\n"}
{"task_id": "Mbpp/290", "completion": "\ndef max_length(lst):\n max_len = max(len(sublist) for sublist in lst)\n return max_len, [sublist for sublist in lst if len(sublist) == max_len]\n"}
{"task_id": "Mbpp/292", "completion": "\ndef find(numerator, denominator):\n return numerator // denominator\n"}
{"task_id": "Mbpp/293", "completion": "\ndef otherside_rightangle(a, b):\n return (a**2 + b**2)**0.5\n"}
{"task_id": "Mbpp/294", "completion": "\ndef max_val(lst):\n max_val = None\n for item in lst:\n if isinstance(item, int) or isinstance(item, float):\n if max_val is None or item > max_val:\n max_val = item\n elif isinstance(item, list):\n sub_max = max_val(item)\n if max_val is None or sub_max > max_val:\n max_val = sub_max\n return max_val\n"}
{"task_id": "Mbpp/295", "completion": "\ndef sum_div(n):\n sum = 0\n for i in range(1, n+1):\n if n % i == 0:\n sum += i\n return sum\n"}
{"task_id": "Mbpp/296", "completion": "\ndef get_Inv_Count(arr):\n inv_count = 0\n for i in range(len(arr)):\n for j in range(i + 1, len(arr)):\n if arr[i] > arr[j]:\n inv_count += 1\n return inv_count\n"}
{"task_id": "Mbpp/297", "completion": "\ndef flatten_list(lst):\n flattened = []\n for element in lst:\n if isinstance(element, list):\n flattened.extend(flatten_list(element))\n else:\n flattened.append(element)\n return flattened\n"}
{"task_id": "Mbpp/299", "completion": "\ndef max_aggregate(lst):\n d = {}\n for name, score in lst:\n d[name] = d.get(name, 0) + score\n return max(d.items(), key=lambda x: x[1])\n"}
{"task_id": "Mbpp/300", "completion": "\nimport math\n\ndef count_binary_seq(n):\n return math.pow(2, n)\n"}
{"task_id": "Mbpp/301", "completion": "\ndef dict_depth(d):\n if not isinstance(d, dict):\n return 0\n return 1 + max(dict_depth(v) for v in d.values())\n"}
{"task_id": "Mbpp/305", "completion": "\ndef start_withp(words):\n p_words = [word for word in words if word.startswith('p')]\n return p_words[0], p_words[1]\n"}
{"task_id": "Mbpp/306", "completion": "\ndef max_sum_increasing_subseq(nums, n, k, i):\n dp = [0] * n\n dp[0] = nums[0]\n for j in range(1, n):\n dp[j] = nums[j]\n for p in range(j):\n if nums[p] < nums[j] and dp[p] + nums[j] > dp[j]:\n dp[j] = dp[p] + nums[j]\n max_sum = 0\n for j in range(i, n):\n if nums[j] > nums[i] and dp[j] > max_sum:\n max_sum = dp[j]\n return max_sum\n"}
{"task_id": "Mbpp/308", "completion": "\ndef large_product(list1, list2, n):\n products = [x * y for x in list1 for y in list2]\n products.sort(reverse=True)\n return products[:n]\n"}
{"task_id": "Mbpp/309", "completion": "\ndef maximum(a, b):\n if a > b:\n return a\n else:\n return b\n"}
{"task_id": "Mbpp/310", "completion": "\ndef string_to_tuple(input_string):\n return tuple(input_string)\n"}
{"task_id": "Mbpp/311", "completion": "\ndef set_left_most_unset_bit(num):\n return num | (1 << num.bit_length())\n"}
{"task_id": "Mbpp/312", "completion": "\nimport math\n\ndef volume_cone(radius, height):\n return math.pi * radius**2 * height / 3\n"}
{"task_id": "Mbpp/388", "completion": "\ndef highest_Power_of_2(n):\n power = 0\n while (1 << power) <= n:\n power += 1\n return 1 << (power - 1)\n"}
{"task_id": "Mbpp/389", "completion": "\ndef find_lucas(n):\n if n == 0:\n return 2\n if n == 1:\n return 1\n return find_lucas(n - 1) + find_lucas(n - 2)\n"}
{"task_id": "Mbpp/390", "completion": "\ndef add_string(list_of_elements, format_string):\n return [format_string.format(e) for e in list_of_elements]\n"}
{"task_id": "Mbpp/391", "completion": "\ndef convert_list_dictionary(list1, list2, list3):\n result = []\n for i in range(len(list1)):\n d = {}\n d[list1[i]] = {list2[i]: list3[i]}\n result.append(d)\n return result\n"}
{"task_id": "Mbpp/392", "completion": "\ndef get_max_sum(n):\n if n <= 0:\n return 0\n if n == 1:\n return 1\n return max(get_max_sum(n // 2) + get_max_sum(n // 3) + get_max_sum(n // 4) + get_max_sum(n // 5), n)\n"}
{"task_id": "Mbpp/394", "completion": "\ndef check_distinct(tup):\n return len(tup) == len(set(tup))\n"}
{"task_id": "Mbpp/395", "completion": "\ndef first_non_repeating_character(string):\n char_counts = {}\n for char in string:\n if char in char_counts:\n char_counts[char] += 1\n else:\n char_counts[char] = 1\n for char in string:\n if char_counts[char] == 1:\n return char\n return None\n"}
{"task_id": "Mbpp/396", "completion": "\ndef check_char(string):\n if string[0] == string[-1]:\n return \"Valid\"\n else:\n return \"Invalid\"\n"}
{"task_id": "Mbpp/397", "completion": "\ndef median_numbers(a, b, c):\n numbers = [a, b, c]\n numbers.sort()\n return numbers[1]\n"}
{"task_id": "Mbpp/398", "completion": "\ndef sum_of_digits(numbers):\n total_sum = 0\n for num in numbers:\n while num > 0:\n digit = num % 10\n total_sum += digit\n num //= 10\n return total_sum\n"}
{"task_id": "Mbpp/400", "completion": "\ndef extract_freq(lst):\n unique_tuples = set(lst)\n return len(unique_tuples)\n"}
{"task_id": "Mbpp/404", "completion": "\ndef minimum(a, b):\n if a < b:\n return a\n else:\n return b\n"}
{"task_id": "Mbpp/405", "completion": "\ndef check_tuplex(tup, x):\n for element in tup:\n if element == x:\n return True\n return False\n"}
{"task_id": "Mbpp/406", "completion": "\ndef find_Parity(num):\n return num % 2 == 1\n"}
{"task_id": "Mbpp/407", "completion": "\ndef rearrange_bigger(num):\n num_str = str(num)\n for i in range(len(num_str)-1, 0, -1):\n if num_str[i] > num_str[i-1]:\n break\n else:\n return -1\n for j in range(len(num_str)-1, i, -1):\n if num_str[j] > num_str[i-1]:\n break\n num_str = num_str[:i-1] + num_str[j] + num_str[i:j] + num_str[i-1] + num_str[j+1:]\n return int(num_str)\n"}
{"task_id": "Mbpp/409", "completion": "\ndef min_product_tuple(list_of_tuples):\n min_product = float('inf')\n for t in list_of_tuples:\n product = t[0] * t[1]\n if product < min_product:\n min_product = product\n return min_product\n"}
{"task_id": "Mbpp/410", "completion": "\ndef min_val(lst):\n return min(lst, key=lambda x: (type(x), x))\n"}
{"task_id": "Mbpp/412", "completion": "\ndef remove_odd(lst):\n return [n for n in lst if n % 2 == 0]\n"}
{"task_id": "Mbpp/413", "completion": "\ndef extract_nth_element(list_of_tuples, n):\n return [tup[n] for tup in list_of_tuples]\n"}
{"task_id": "Mbpp/414", "completion": "\ndef overlapping(seq1, seq2):\n return any(x in seq1 for x in seq2)\n"}
{"task_id": "Mbpp/415", "completion": "\ndef max_Product(arr):\n arr = sorted(arr, reverse=True)\n return arr[0], arr[1]\n"}
{"task_id": "Mbpp/418", "completion": "\ndef Find_Max(list1):\n max = 0\n index = 0\n for i in range(len(list1)):\n if len(list1[i]) > max:\n max = len(list1[i])\n index = i\n return list1[index]\n"}
{"task_id": "Mbpp/419", "completion": "\ndef round_and_sum(numbers):\n total_sum = 0\n for num in numbers:\n rounded_num = round(num)\n total_sum += rounded_num\n return total_sum * len(numbers)\n"}
{"task_id": "Mbpp/420", "completion": "\ndef cube_Sum(n):\n sum = 0\n for i in range(2, 2 * n + 1, 2):\n sum += i ** 3\n return sum\n"}
{"task_id": "Mbpp/421", "completion": "\ndef concatenate_tuple(input_tuple, delimiter=\"-\"):\n return delimiter.join(map(str, input_tuple))\n"}
{"task_id": "Mbpp/422", "completion": "\ndef find_Average_Of_Cube(n):\n sum = 0\n for i in range(1, n+1):\n sum += i**3\n return sum/n\n"}
{"task_id": "Mbpp/424", "completion": "\ndef extract_rear(tuple_of_strings):\n return [string[-1] for string in tuple_of_strings]\n"}
{"task_id": "Mbpp/425", "completion": "\ndef count_element_in_list(lst, element):\n count = 0\n for sublist in lst:\n if element in sublist:\n count += 1\n return count\n"}
{"task_id": "Mbpp/426", "completion": "\ndef filter_oddnumbers(numbers):\n return [num for num in numbers if num % 2 == 0]\n"}
{"task_id": "Mbpp/427", "completion": "\ndef change_date_format(date):\n year, month, day = date.split('-')\n return f'{day}-{month}-{year}'\n"}
{"task_id": "Mbpp/428", "completion": "\ndef shell_sort(arr):\n n = len(arr)\n gap = n // 2\n\n while gap > 0:\n for i in range(gap, n):\n temp = arr[i]\n j = i\n while j >= gap and arr[j - gap] > temp:\n arr[j] = arr[j - gap]\n j -= gap\n arr[j] = temp\n gap //= 2\n\n return arr\n"}
{"task_id": "Mbpp/429", "completion": "\ndef and_tuples(tuple1, tuple2):\n return tuple(a & b for a, b in zip(tuple1, tuple2))\n"}
{"task_id": "Mbpp/430", "completion": "\ndef parabola_directrix(p, a, b):\n return 16*p*a*b\n"}
{"task_id": "Mbpp/431", "completion": "\ndef common_element(list1, list2):\n set1 = set(list1)\n set2 = set(list2)\n return len(set1.intersection(set2)) > 0\n"}
{"task_id": "Mbpp/432", "completion": "\ndef median_trapezium(a, b, c):\n s = (a + b + c) / 2\n area = (s*(s-a)*(s-b)*(s-c)) ** 0.5\n median_length = (2*area) / (a+b)\n return median_length\n"}
{"task_id": "Mbpp/433", "completion": "\ndef check_greater(arr, num):\n return all(num > elem for elem in arr)\n"}
{"task_id": "Mbpp/435", "completion": "\ndef last_Digit(num):\n return num % 10\n"}
{"task_id": "Mbpp/436", "completion": "\ndef neg_nos(list1):\n negative_nos = []\n for i in list1:\n if i < 0:\n negative_nos.append(i)\n return negative_nos\n"}
{"task_id": "Mbpp/437", "completion": "\ndef remove_odd(string):\n new_string = \"\"\n for i, c in enumerate(string):\n if i % 2 == 0:\n new_string += c\n return new_string\n"}
{"task_id": "Mbpp/438", "completion": "\ndef count_bidirectional(tuples):\n count = 0\n for t in tuples:\n if (t[1], t[0]) in tuples:\n count += 1\n return count\n"}
{"task_id": "Mbpp/439", "completion": "\ndef multiple_to_single(num_list):\n return int(\"\".join(map(str, num_list)))\n"}
{"task_id": "Mbpp/440", "completion": "\nimport re\n\ndef find_adverb_position(sentence):\n adverb_pattern = r\"\\w+ly\"\n match = re.search(adverb_pattern, sentence)\n if match:\n return (match.start(), match.end(), match.group())\n else:\n return None\n"}
{"task_id": "Mbpp/441", "completion": "\ndef surfacearea_cube(size):\n return 6 * size * size\n"}
{"task_id": "Mbpp/442", "completion": "\ndef positive_count(arr):\n count = 0\n for num in arr:\n if num > 0:\n count += 1\n return count / len(arr)\n"}
{"task_id": "Mbpp/445", "completion": "\ndef index_multiplication(tuple1, tuple2):\n result = ()\n for i in range(len(tuple1)):\n result += (tuple1[i] * tuple2[i],)\n return result\n"}
{"task_id": "Mbpp/446", "completion": "\ndef count_Occurrence(tup, lst):\n count = 0\n for item in tup:\n if item in lst:\n count += 1\n return count\n"}
{"task_id": "Mbpp/447", "completion": "\ndef cube_nums(nums):\n return [num**3 for num in nums]\n"}
{"task_id": "Mbpp/448", "completion": "\ndef perrin(n):\n if n == 0:\n return 3\n elif n == 1 or n == 2:\n return 0\n else:\n return perrin(n - 2) + perrin(n - 3)\n\ndef cal_sum(n):\n if n == 0:\n return 0\n else:\n return perrin(n - 1) + cal_sum(n - 1)\n"}
{"task_id": "Mbpp/450", "completion": "\ndef extract_string(str_list, size):\n return [str_val for str_val in str_list if len(str_val) == size]\n"}
{"task_id": "Mbpp/451", "completion": "\ndef remove_whitespaces(string):\n return string.replace(' ', '')\n"}
{"task_id": "Mbpp/453", "completion": "\ndef sumofFactors(num):\n sum = 0\n for i in range(1, num+1):\n if num % i == 0:\n if i % 2 == 0:\n sum += i\n return sum\n"}
{"task_id": "Mbpp/454", "completion": "\nimport re\n\ndef text_match_wordz(text):\n pattern = r\"\\w*z\\w*\"\n if re.search(pattern, text):\n return True\n else:\n return False\n"}
{"task_id": "Mbpp/455", "completion": "\ndef check_monthnumb_number(month_number):\n if month_number in [1, 3, 5, 7, 8, 10, 12]:\n return True\n elif month_number in [4, 6, 9, 11]:\n return False\n else:\n return \"Invalid month number\"\n"}
{"task_id": "Mbpp/456", "completion": "\ndef reverse_string_list(string_list):\n return [s[::-1] for s in string_list]\n"}
{"task_id": "Mbpp/457", "completion": "\ndef Find_Min(lst):\n min_len = float('inf')\n min_sublist = []\n for sublist in lst:\n if len(sublist) < min_len:\n min_len = len(sublist)\n min_sublist = sublist\n return min_sublist\n"}
{"task_id": "Mbpp/458", "completion": "\ndef rectangle_area(length, width):\n return length * width\n"}
{"task_id": "Mbpp/459", "completion": "\nimport re\n\ndef remove_uppercase(s):\n return re.sub(r'[A-Z]+', '', s)\n"}
{"task_id": "Mbpp/460", "completion": "\ndef Extract(lst):\n return [sublst[0] for sublst in lst]\n"}
{"task_id": "Mbpp/461", "completion": "\ndef upper_ctr(s):\n count = 0\n for c in s:\n if c.isupper():\n count += 1\n return count\n"}
{"task_id": "Mbpp/462", "completion": "\ndef combinations_list(lst):\n if not lst:\n return [[]]\n else:\n res = []\n for i in range(len(lst)):\n elem = lst[i]\n remaining_elems = lst[i+1:]\n for combination in combinations_list(remaining_elems):\n res.append(combination)\n res.append(combination + [elem])\n return res\n"}
{"task_id": "Mbpp/463", "completion": "\ndef max_subarray_product(nums):\n max_product = nums[0]\n min_product = nums[0]\n max_product_so_far = nums[0]\n\n for num in nums[1:]:\n temp_max_product = max_product\n max_product = max(num, max_product * num, min_product * num)\n min_product = min(num, temp_max_product * num, min_product * num)\n max_product_so_far = max(max_product_so_far, max_product)\n\n return max_product_so_far\n"}
{"task_id": "Mbpp/465", "completion": "\ndef drop_empty(d):\n return {k: v for k, v in d.items() if v is not None}\n"}
{"task_id": "Mbpp/468", "completion": "\ndef max_product(nums):\n max_product = 1\n max_product_so_far = 1\n for num in nums:\n max_product *= num\n if max_product > max_product_so_far:\n max_product_so_far = max_product\n if num == 0:\n max_product = 1\n return max_product_so_far\n"}
{"task_id": "Mbpp/470", "completion": "\ndef add_pairwise(tup):\n result = []\n for i in range(len(tup) - 1):\n result.append(tup[i] + tup[i+1])\n return tuple(result)\n"}
{"task_id": "Mbpp/471", "completion": "\ndef find_remainder(arr, n):\n result = 1\n for i in arr:\n result = (result * i) % n\n return result\n"}
{"task_id": "Mbpp/472", "completion": "\ndef check_Consecutive(lst):\n lst.sort()\n for i in range(len(lst)-1):\n if lst[i+1] - lst[i]!= 1:\n return False\n return True\n"}
{"task_id": "Mbpp/473", "completion": "\ndef tuple_intersection(tuple_list_1, tuple_list_2):\n set_1 = {tuple(sorted(t)) for t in tuple_list_1}\n set_2 = {tuple(sorted(t)) for t in tuple_list_2}\n return set_1.intersection(set_2)\n"}
{"task_id": "Mbpp/474", "completion": "\ndef replace_char(string, old, new):\n return string.replace(old, new)\n"}
{"task_id": "Mbpp/475", "completion": "\ndef sort_counter(counter):\n return sorted(counter.items(), key=lambda x: x[1], reverse=True)\n"}
{"task_id": "Mbpp/476", "completion": "\ndef big_sum(arr):\n return max(arr) + min(arr)\n"}
{"task_id": "Mbpp/477", "completion": "\ndef is_lower(s):\n return s.lower()\n"}
{"task_id": "Mbpp/478", "completion": "\ndef remove_lowercase(s):\n result = \"\"\n for c in s:\n if not c.islower():\n result += c\n return result\n"}
{"task_id": "Mbpp/479", "completion": "\ndef first_Digit(input_str):\n for char in input_str:\n if char.isdigit():\n return int(char)\n"}
{"task_id": "Mbpp/554", "completion": "\ndef Split(lst):\n return [x for x in lst if x % 2!= 0]\n"}
{"task_id": "Mbpp/555", "completion": "\ndef difference(n):\n sum_of_cubes = sum(i**3 for i in range(1, n+1))\n sum_of_numbers = sum(i for i in range(1, n+1))\n return sum_of_cubes - sum_of_numbers**2\n"}
{"task_id": "Mbpp/556", "completion": "\ndef find_Odd_Pair(arr,n):\n count = 0\n for i in range(n):\n for j in range(i+1,n):\n if (arr[i] ^ arr[j]) & 1:\n count += 1\n return count\n"}
{"task_id": "Mbpp/557", "completion": "\ndef toggle_string(s):\n new_string = \"\"\n for char in s:\n if char.islower():\n new_string += char.upper()\n elif char.isupper():\n new_string += char.lower()\n else:\n new_string += char # Add any non-alphabetic characters as is\n return new_string\n"}
{"task_id": "Mbpp/558", "completion": "\ndef digit_distance_nums(num1, num2):\n num1_str = str(num1)\n num2_str = str(num2)\n sum_diff = 0\n for i in range(len(num1_str)):\n if i < len(num2_str):\n diff = abs(int(num1_str[i]) - int(num2_str[i]))\n sum_diff += diff\n return sum_diff\n"}
{"task_id": "Mbpp/559", "completion": "\ndef max_sub_array_sum(nums, k):\n max_sum = float(\"-inf\")\n for i in range(len(nums) - k + 1):\n sub_array = nums[i:i+k]\n sub_array_sum = sum(sub_array)\n if sub_array_sum > max_sum:\n max_sum = sub_array_sum\n return max_sum\n"}
{"task_id": "Mbpp/560", "completion": "\ndef union_elements(tuple1, tuple2):\n set1 = set(tuple1)\n set2 = set(tuple2)\n union = set1.union(set2)\n return tuple(sorted(union))\n"}
{"task_id": "Mbpp/562", "completion": "\ndef Find_Max_Length(lists):\n max_length = 0\n for sublist in lists:\n max_length = max(max_length, len(sublist))\n return max_length\n"}
{"task_id": "Mbpp/563", "completion": "\nimport re\n\ndef extract_values(input_string):\n pattern = r'\"([^\"]*)\"'\n return re.findall(pattern, input_string)\n"}
{"task_id": "Mbpp/564", "completion": "\ndef count_Pairs(arr,n):\n count = 0\n for i in range(n):\n for j in range(i+1,n):\n if arr[i]!= arr[j]:\n count += 1\n return count\n"}
{"task_id": "Mbpp/565", "completion": "\ndef split(string):\n return list(string)\n"}
{"task_id": "Mbpp/566", "completion": "\ndef sum_digits(num):\n sum = 0\n while num > 0:\n digit = num % 10\n sum += digit\n num //= 10\n return sum\n"}
{"task_id": "Mbpp/567", "completion": "\ndef issort_list(l):\n return all(l[i] <= l[i+1] for i in range(len(l)-1))\n"}
{"task_id": "Mbpp/568", "completion": "\ndef empty_list(n):\n return [{} for _ in range(n)]\n"}
{"task_id": "Mbpp/569", "completion": "\ndef sort_sublists(lst):\n return [[sorted(sublist)] for sublist in lst]\n"}
{"task_id": "Mbpp/572", "completion": "\ndef two_unique_nums(nums):\n unique_nums = set()\n for num in nums:\n if num not in unique_nums:\n unique_nums.add(num)\n return list(unique_nums)\n"}
{"task_id": "Mbpp/573", "completion": "\ndef unique_product(lst):\n unique_numbers = set(lst)\n product = 1\n for num in unique_numbers:\n product *= num\n return product\n"}
{"task_id": "Mbpp/574", "completion": "\nimport math\n\ndef surfacearea_cylinder(radius, height):\n return 2 * math.pi * radius * (radius + height)\n"}
{"task_id": "Mbpp/576", "completion": "\ndef is_Sub_Array(arr1,arr2):\n n = len(arr1)\n m = len(arr2)\n if m > n:\n return False\n for i in range(n-m+1):\n if arr1[i] == arr2[0] and arr1[i+1] == arr2[1]:\n return True\n return False\n"}
{"task_id": "Mbpp/577", "completion": "\ndef last_Digit_Factorial(num):\n if num < 0:\n return -1\n elif num == 0:\n return 1\n else:\n fact = 1\n for i in range(1, num + 1):\n fact = fact * i\n return int(str(fact)[-1])\n"}
{"task_id": "Mbpp/578", "completion": "\ndef interleave_lists(list1, list2, list3):\n return [x for tup in zip(list1, list2, list3) for x in tup]\n"}
{"task_id": "Mbpp/579", "completion": "\ndef find_dissimilar(tuple1, tuple2):\n set1 = set(tuple1)\n set2 = set(tuple2)\n dissimilar_elements = set1.symmetric_difference(set2)\n return tuple(dissimilar_elements)\n"}
{"task_id": "Mbpp/580", "completion": "\ndef extract_even(nested_tuple):\n even_elements = []\n for element in nested_tuple:\n if isinstance(element, tuple):\n even_elements.append(extract_even(element))\n elif element % 2 == 0:\n even_elements.append(element)\n return tuple(even_elements)\n"}
{"task_id": "Mbpp/581", "completion": "\ndef surface_Area(edge, height):\n base_area = edge ** 2\n lateral_area = edge * (edge ** 0.5) * height\n return 2 * base_area + lateral_area\n"}
{"task_id": "Mbpp/582", "completion": "\ndef my_dict(dictionary):\n if len(dictionary) == 0:\n return True\n else:\n return False\n"}
{"task_id": "Mbpp/583", "completion": "\ndef catalan_number(n):\n if n <= 1:\n return 1\n result = 0\n for i in range(n):\n result += catalan_number(i) * catalan_number(n - i - 1)\n return result\n"}
{"task_id": "Mbpp/585", "completion": "\ndef expensive_items(dataset, n):\n sorted_items = sorted(dataset, key=lambda item: item['price'], reverse=True)\n return sorted_items[:n]\n"}
{"task_id": "Mbpp/586", "completion": "\ndef split_Arr(arr,n):\n return arr[n:]+arr[:n]\n"}
{"task_id": "Mbpp/587", "completion": "\ndef list_tuple(lst):\n return tuple(lst)\n"}
{"task_id": "Mbpp/588", "completion": "\ndef big_diff(nums):\n return max(nums) - min(nums)\n"}
{"task_id": "Mbpp/589", "completion": "\nimport math\n\ndef perfect_squares(num1, num2):\n squares = []\n for i in range(num1, num2 + 1):\n sqrt = math.sqrt(i)\n if sqrt.is_integer():\n squares.append(i)\n return squares\n"}
{"task_id": "Mbpp/590", "completion": "\nimport cmath\n\ndef polar_rect(r, theta):\n x = r * cmath.cos(theta)\n y = r * cmath.sin(theta)\n return (x, y)\n"}
{"task_id": "Mbpp/591", "completion": "\ndef swap_List(newList):\n newList[0], newList[-1] = newList[-1], newList[0]\n return newList\n"}
{"task_id": "Mbpp/592", "completion": "\ndef binomial_coefficient(n, k):\n result = 1\n for i in range(1, k+1):\n result = result * (n + 1 - i) // i\n return result\n\ndef sum_Of_product(n):\n sum = 0\n for i in range(1, n+1):\n sum += binomial_coefficient(n, i) * binomial_coefficient(n + 1, i + 1)\n return sum\n"}
{"task_id": "Mbpp/593", "completion": "\ndef removezero_ip(ip):\n \"\"\"\n Remove leading zeroes from an IP address.\n \"\"\"\n return \".\".join([str(int(i)) for i in ip.split(\".\")])\n"}
{"task_id": "Mbpp/594", "completion": "\ndef diff_even_odd(lst):\n even = None\n odd = None\n for num in lst:\n if num % 2 == 0:\n if even is None:\n even = num\n elif num < even:\n even = num\n else:\n if odd is None:\n odd = num\n elif num < odd:\n odd = num\n if even is not None and odd is not None:\n return even - odd\n else:\n return None\n"}
{"task_id": "Mbpp/595", "completion": "\ndef min_Swaps(num1, num2):\n count = 0\n for i in range(len(num1)):\n if num1[i]!= num2[i]:\n count += 1\n return count // 2\n"}
{"task_id": "Mbpp/596", "completion": "\nimport sys\n\ndef tuple_size(my_tuple):\n return sys.getsizeof(my_tuple)\n"}
{"task_id": "Mbpp/597", "completion": "\ndef find_kth(arr1, arr2, k):\n m, n = len(arr1), len(arr2)\n if m > n:\n return find_kth(arr2, arr1, k)\n if m == 0:\n return arr2[k - 1]\n if k == 1:\n return min(arr1[0], arr2[0])\n i = min(k // 2, m)\n j = k - i\n if arr1[i - 1] <= arr2[j - 1]:\n return find_kth(arr1[i:], arr2, j)\n else:\n return find_kth(arr1, arr2[j:], i)\n"}
{"task_id": "Mbpp/598", "completion": "\ndef armstrong_number(num):\n temp = num\n sum = 0\n while temp > 0:\n digit = temp % 10\n sum += digit ** 3\n temp //= 10\n if num == sum:\n return True\n else:\n return False\n"}
{"task_id": "Mbpp/599", "completion": "\ndef sum_average(n):\n sum = 0\n for i in range(1, n+1):\n sum += i\n average = sum / n\n return sum, average\n"}
{"task_id": "Mbpp/600", "completion": "\ndef is_Even(num):\n if num % 2 == 0:\n return True\n else:\n return False\n"}
{"task_id": "Mbpp/602", "completion": "\ndef first_repeated_char(s):\n char_counts = {}\n for char in s:\n if char in char_counts:\n char_counts[char] += 1\n else:\n char_counts[char] = 1\n for char, count in char_counts.items():\n if count > 1:\n return char\n return None\n"}
{"task_id": "Mbpp/603", "completion": "\ndef get_ludic(n):\n ludic = [i for i in range(1, n + 1)]\n i = 0\n while i < len(ludic):\n ludic = [j for j in ludic if j == ludic[i] or j % ludic[i]!= 0]\n i += 1\n return ludic\n"}
{"task_id": "Mbpp/604", "completion": "\ndef reverse_words(s):\n words = s.split()\n words.reverse()\n return''.join(words)\n"}
{"task_id": "Mbpp/605", "completion": "\ndef prime_num(num):\n if num <= 1:\n return False\n for i in range(2, num):\n if num % i == 0:\n return False\n return True\n"}
{"task_id": "Mbpp/606", "completion": "\nimport math\n\ndef radian_degree(degree):\n return degree*math.pi/180\n"}
{"task_id": "Mbpp/607", "completion": "\nimport re\n\ndef find_literals(text, pattern):\n match = re.search(pattern, text)\n if match:\n return match.group(), match.start(), match.end()\n else:\n return None\n"}
{"task_id": "Mbpp/608", "completion": "\ndef 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]\n"}
{"task_id": "Mbpp/610", "completion": "\ndef remove_kth_element(lst, k):\n return [x for i, x in enumerate(lst) if i!= k]\n"}
{"task_id": "Mbpp/611", "completion": "\ndef max_of_nth(matrix, n):\n return max(row[n] for row in matrix)\n"}
{"task_id": "Mbpp/612", "completion": "\ndef merge(lst):\n return [list(x) for x in zip(*lst)]\n"}
{"task_id": "Mbpp/614", "completion": "\ndef cummulative_sum(tuple_list):\n total_sum = 0\n for tup in tuple_list:\n total_sum += sum(tup)\n return total_sum\n"}
{"task_id": "Mbpp/615", "completion": "\ndef average_tuple(input_tuple):\n average_list = []\n for tup in input_tuple:\n average_list.append(sum(tup)/len(tup))\n return average_list\n"}
{"task_id": "Mbpp/616", "completion": "\ndef tuple_modulo(tuple_1, tuple_2):\n return tuple(a % b for a, b in zip(tuple_1, tuple_2))\n"}
{"task_id": "Mbpp/618", "completion": "\ndef div_list(list1, list2):\n return [float(x)/float(y) for x, y in zip(list1, list2)]\n"}
{"task_id": "Mbpp/619", "completion": "\ndef move_num(s):\n return ''.join(sorted(s, key=lambda c: c.isdigit()))\n"}
{"task_id": "Mbpp/620", "completion": "\ndef largest_subset(numbers):\n numbers.sort()\n dp = [1] * len(numbers)\n for i in range(len(numbers)):\n for j in range(i):\n if numbers[i] % numbers[j] == 0:\n dp[i] = max(dp[i], dp[j] + 1)\n return max(dp)\n"}
{"task_id": "Mbpp/622", "completion": "\ndef get_median(list1, list2, n):\n m1 = m2 = 0\n count = 0\n while count < n:\n if list1[m1] < list2[m2]:\n m1 += 1\n else:\n m2 += 1\n count += 1\n return (list1[m1 - 1] + list2[m2 - 1]) / 2.0\n"}
{"task_id": "Mbpp/623", "completion": "\ndef nth_nums(nums, n):\n return [num**n for num in nums]\n"}
{"task_id": "Mbpp/624", "completion": "\ndef is_upper(s):\n return s.upper()\n"}
{"task_id": "Mbpp/626", "completion": "\nimport math\n\ndef triangle_area(radius):\n if radius < 0:\n return None\n return (radius ** 2) * (math.pi / 4)\n"}
{"task_id": "Mbpp/628", "completion": "\ndef replace_spaces(s):\n return s.replace(' ', '%20')\n"}
{"task_id": "Mbpp/629", "completion": "\ndef Split(arr):\n return [num for num in arr if num % 2 == 0]\n"}
{"task_id": "Mbpp/630", "completion": "\ndef get_coordinates(coordinate):\n x, y = coordinate\n return [[x - 1, y - 1], [x - 1, y], [x - 1, y + 1], [x, y - 1], [x, y], [x, y + 1], [x + 1, y - 1], [x + 1, y], [x + 1, y + 1]]\n"}
{"task_id": "Mbpp/631", "completion": "\ndef replace_spaces(string):\n return string.replace(' ', '_').replace('_','')\n"}
{"task_id": "Mbpp/632", "completion": "\ndef move_zero(lst):\n n = len(lst)\n next_nonzero = 0\n for i in range(n):\n if lst[i]!= 0:\n lst[i], lst[next_nonzero] = lst[next_nonzero], lst[i]\n next_nonzero += 1\n return lst\n"}
{"task_id": "Mbpp/633", "completion": "\ndef pair_xor_Sum(arr,n):\n xor_sum = 0\n for i in range(n):\n xor_sum ^= arr[i]\n return xor_sum\n"}
{"task_id": "Mbpp/635", "completion": "\ndef heapify(arr, n, i):\n largest = i\n l = 2 * i + 1\n r = 2 * i + 2\n if l < n and arr[i] < arr[l]:\n largest = l\n if r < n and arr[largest] < arr[r]:\n largest = r\n if largest!= i:\n arr[i],arr[largest] = arr[largest],arr[i]\n heapify(arr, n, largest)\ndef heap_sort(arr):\n n = len(arr)\n for i in range(n//2 - 1, -1, -1):\n heapify(arr, n, i)\n for i in range(n-1, 0, -1):\n arr[i], arr[0] = arr[0], arr[i]\n heapify(arr, i, 0)\n return arr\n"}
{"task_id": "Mbpp/637", "completion": "\ndef noprofit_noloss(cost_price, sell_price):\n return sell_price == cost_price\n"}
{"task_id": "Mbpp/638", "completion": "\ndef wind_chill(velocity, temperature):\n wind_chill_index = 13.12 + 0.6215 * temperature - 11.37 * velocity ** 0.16 + 0.3965 * temperature * velocity ** 0.16\n return round(wind_chill_index)\n"}
{"task_id": "Mbpp/639", "completion": "\ndef sample_nam(names):\n return sum(len(name) for name in names if name[0].isupper())\n"}
{"task_id": "Mbpp/640", "completion": "\ndef remove_parenthesis(string):\n new_string = \"\"\n for char in string:\n if char!= \"(\":\n if char!= \")\":\n new_string += char\n return new_string\n"}
{"task_id": "Mbpp/641", "completion": "\ndef is_nonagonal(num):\n n = (1 + (1 + 24 * num) ** 0.5) / 2\n return n % 1 == 0\n"}
{"task_id": "Mbpp/643", "completion": "\nimport re\n\ndef text_match_wordz_middle(text):\n pattern = r\"\\Bz\\B\"\n if re.search(pattern, text):\n return True\n else:\n return False\n"}
{"task_id": "Mbpp/644", "completion": "\ndef reverse_Array_Upto_K(arr,k):\n arr[:k+1] = arr[:k+1][::-1]\n return arr\n"}
{"task_id": "Mbpp/720", "completion": "\ndef add_dict_to_tuple(tup, dict_to_add):\n return tup + (dict_to_add,)\n"}
{"task_id": "Mbpp/721", "completion": "\ndef maxAverageOfPath(matrix):\n n = len(matrix)\n dp = [[0] * n for _ in range(n)]\n dp[0][0] = matrix[0][0]\n for i in range(1, n):\n dp[0][i] = dp[0][i-1] + matrix[0][i]\n for i in range(1, n):\n dp[i][0] = dp[i-1][0] + matrix[i][0]\n for i in range(1, n):\n for j in range(1, n):\n dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + matrix[i][j]\n return dp[n-1][n-1] / (n * 2 - 1)\n"}
{"task_id": "Mbpp/722", "completion": "\ndef filter_data(data, min_height, min_weight):\n return {\n name: height_weight\n for name, height_weight in data.items()\n if height_weight[0] >= min_height and height_weight[1] >= min_weight\n }\n"}
{"task_id": "Mbpp/723", "completion": "\ndef count_same_pair(list1, list2):\n count = 0\n for i in range(len(list1)):\n if list1[i] == list2[i]:\n count += 1\n return count\n"}
{"task_id": "Mbpp/724", "completion": "\ndef power_base_sum(base, power):\n return sum(int(digit) for digit in str(base ** power))\n"}
{"task_id": "Mbpp/725", "completion": "\nimport re\n\ndef extract_quotation(string):\n return re.findall(r'\".*?\"', string)\n"}
{"task_id": "Mbpp/726", "completion": "\ndef multiply_elements(input_tuple):\n output_tuple = ()\n for i in range(len(input_tuple) - 1):\n output_tuple += (input_tuple[i] * input_tuple[i+1],)\n return output_tuple\n"}
{"task_id": "Mbpp/728", "completion": "\ndef sum_list(list1, list2):\n return [x + y for x, y in zip(list1, list2)]\n"}
{"task_id": "Mbpp/730", "completion": "\ndef consecutive_duplicates(lst):\n result = []\n previous = None\n for item in lst:\n if item!= previous:\n result.append(item)\n previous = item\n return result\n"}
{"task_id": "Mbpp/731", "completion": "\nimport math\n\ndef lateralsurface_cone(r, h):\n return math.pi * r * math.sqrt(r**2 + h**2)\n"}
{"task_id": "Mbpp/732", "completion": "\ndef replace_specialchar(text):\n return text.replace(' ', ':').replace(',', ':').replace('.', ':')\n"}
{"task_id": "Mbpp/733", "completion": "\ndef find_first_occurrence(nums, target):\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] >= target:\n right = mid - 1\n else:\n left = mid + 1\n if left < len(nums) and nums[left] == target:\n return left\n else:\n return -1\n"}
{"task_id": "Mbpp/734", "completion": "\ndef sum_Of_Subarray_Prod(arr):\n n = len(arr)\n prefix_prod = [1] * n\n suffix_prod = [1] * n\n for i in range(1, n):\n prefix_prod[i] = prefix_prod[i-1] * arr[i-1]\n for i in range(n-2, -1, -1):\n suffix_prod[i] = suffix_prod[i+1] * arr[i+1]\n result = 0\n for i in range(n):\n result += prefix_prod[i] * suffix_prod[i]\n\n return result\n"}
{"task_id": "Mbpp/735", "completion": "\ndef toggle_middle_bits(num):\n mask = 0b10\n while mask < (1 << (len(bin(num)) - 4)):\n num ^= mask\n mask <<= 1\n return num\n"}
{"task_id": "Mbpp/736", "completion": "\ndef left_insertion(lst, value):\n low = 0\n high = len(lst) - 1\n while low <= high:\n mid = (low + high) // 2\n if lst[mid] < value:\n low = mid + 1\n else:\n high = mid - 1\n return low\n"}
{"task_id": "Mbpp/737", "completion": "\nimport re\n\ndef check_str(string):\n return re.match(r\"^[aeiou]\", string, re.IGNORECASE) is not None\n"}
{"task_id": "Mbpp/739", "completion": "\ndef find_Index(n):\n num = 1\n count = 1\n while count < n:\n num += 1\n count = len(str(num * (num + 1) // 2))\n return num\n"}
{"task_id": "Mbpp/740", "completion": "\ndef tuple_to_dict(input_tuple):\n return dict(zip(input_tuple[::2], input_tuple[1::2]))\n"}
{"task_id": "Mbpp/741", "completion": "\ndef all_Characters_Same(string):\n return len(set(string)) == 1\n"}
{"task_id": "Mbpp/742", "completion": "\nimport math\n\ndef area_tetrahedron(a):\n return math.sqrt(3) * a**2 / 2\n"}
{"task_id": "Mbpp/743", "completion": "\ndef rotate_right(lst, n):\n return lst[-n:] + lst[:-n]\n"}
{"task_id": "Mbpp/744", "completion": "\ndef check_none(tup):\n return None in tup\n"}
{"task_id": "Mbpp/745", "completion": "\ndivisible_by_digits = lambda startnum, endnum: [num for num in range(startnum, endnum+1) if all(num % digit == 0 for digit in map(int, str(num)))]\n"}
{"task_id": "Mbpp/746", "completion": "\nimport math\n\ndef sector_area(radius, angle):\n if angle > 360:\n return None\n return 0.5 * radius ** 2 * math.radians(angle)\n"}
{"task_id": "Mbpp/748", "completion": "\nimport re\n\ndef capital_words_spaces(text):\n return re.sub(r\"(\\w)([A-Z])\", r\"\\1 \\2\", text)\n"}
{"task_id": "Mbpp/749", "completion": "\ndef sort_numeric_strings(input_list):\n def convert(string):\n return int(string) if string.isdigit() else string.lower()\n\n def alphanum_key(string):\n return [convert(c) for c in re.split('([0-9]+)', string)]\n\n return sorted(input_list, key=alphanum_key)\n"}
{"task_id": "Mbpp/750", "completion": "\ndef add_tuple(lst, tup):\n lst.extend(tup)\n return lst\n"}
{"task_id": "Mbpp/751", "completion": "\ndef check_min_heap(arr):\n n = len(arr)\n for i in range(n):\n left_child = 2 * i + 1\n right_child = 2 * i + 2\n if left_child < n and arr[i] > arr[left_child]:\n return False\n if right_child < n and arr[i] > arr[right_child]:\n return False\n return True\n"}
{"task_id": "Mbpp/752", "completion": "\ndef jacobsthal_num(n):\n if n == 0:\n return 0\n elif n == 1:\n return 1\n else:\n return jacobsthal_num(n - 1) + 2 * jacobsthal_num(n - 2)\n"}
{"task_id": "Mbpp/753", "completion": "\ndef min_k(tuples, k):\n return sorted(tuples, key=lambda x: x[1])[:k]\n"}
{"task_id": "Mbpp/754", "completion": "\ndef extract_index_list(l1, l2, l3):\n common_elements = []\n for i in range(len(l1)):\n if l1[i] == l2[i] == l3[i]:\n common_elements.append(l1[i])\n return common_elements\n"}
{"task_id": "Mbpp/755", "completion": "\ndef second_smallest(lst):\n smallest = second_smallest = float('inf')\n for num in lst:\n if num < smallest:\n smallest, second_smallest = num, smallest\n elif num < second_smallest:\n second_smallest = num\n return second_smallest\n"}
{"task_id": "Mbpp/757", "completion": "\ndef count_reverse_pairs(string_list):\n count = 0\n for i in range(len(string_list)):\n for j in range(i + 1, len(string_list)):\n if string_list[i] == string_list[j][::-1]:\n count += 1\n return count\n"}
{"task_id": "Mbpp/758", "completion": "\ndef unique_sublists(lst):\n tuples_count = {}\n for sublist in lst:\n sublist_tuple = tuple(sublist)\n if sublist_tuple not in tuples_count:\n tuples_count[sublist_tuple] = 1\n else:\n tuples_count[sublist_tuple] += 1\n return tuples_count\n"}
{"task_id": "Mbpp/759", "completion": "\nimport re\n\ndef is_decimal(s):\n return bool(re.match(r'^-?\\d+\\.\\d{2}$', s))\n"}
{"task_id": "Mbpp/760", "completion": "\ndef unique_Element(lst):\n return len(set(lst)) == 1\n"}
{"task_id": "Mbpp/762", "completion": "\ndef check_monthnumber_number(month_number):\n if month_number in [4, 6, 9, 11]:\n return True\n else:\n return False\n"}
{"task_id": "Mbpp/763", "completion": "\ndef find_min_diff(arr, n):\n arr.sort()\n min_diff = float('inf')\n for i in range(n-1):\n min_diff = min(min_diff, arr[i+1] - arr[i])\n return min_diff\n"}
{"task_id": "Mbpp/764", "completion": "\ndef number_ctr(string):\n count = 0\n for char in string:\n if char.isdigit():\n count += 1\n return count\n"}
{"task_id": "Mbpp/765", "completion": "\ndef is_polite(n):\n for i in range(1, n + 1):\n if i * (i + 1) // 2 == n:\n return i\n return -1\n"}
{"task_id": "Mbpp/766", "completion": "\ndef pair_wise(lst):\n return [(lst[i], lst[i+1]) for i in range(len(lst)-1)]\n"}
{"task_id": "Mbpp/767", "completion": "\ndef get_pairs_count(nums, sum):\n count = 0\n for i in range(len(nums)):\n for j in range(i+1, len(nums)):\n if nums[i] + nums[j] == sum:\n count += 1\n return count\n"}
{"task_id": "Mbpp/769", "completion": "\ndef Diff(list1, list2):\n return list(set(list1) - set(list2))\n"}
{"task_id": "Mbpp/770", "completion": "\ndef odd_num_sum(n):\n sum = 0\n for i in range(1, n + 1):\n num = 2 * i - 1\n sum += num ** 4\n return sum\n"}
{"task_id": "Mbpp/771", "completion": "\ndef check_expression(expression):\n stack = []\n opening_brackets = [\"(\", \"[\", \"{\"]\n closing_brackets = [\")\", \"]\", \"}\"]\n for char in expression:\n if char in opening_brackets:\n stack.append(char)\n elif char in closing_brackets:\n if not stack or opening_brackets[closing_brackets.index(char)]!= stack[-1]:\n return False\n stack.pop()\n return len(stack) == 0\n"}
{"task_id": "Mbpp/772", "completion": "\ndef remove_length(s, k):\n return''.join([word for word in s.split() if len(word)!= k])\n"}
{"task_id": "Mbpp/773", "completion": "\ndef occurance_substring(string, substring):\n pos = string.find(substring)\n if pos!= -1:\n return substring, pos, pos + len(substring) - 1\n else:\n return None\n"}
{"task_id": "Mbpp/775", "completion": "\ndef odd_position(lst):\n for i in range(len(lst)):\n if i % 2 == 1 and lst[i] % 2 == 0:\n return False\n return True\n"}
{"task_id": "Mbpp/777", "completion": "\ndef find_sum(lst):\n unique_elements = set()\n sum_of_elements = 0\n for element in lst:\n if element not in unique_elements:\n unique_elements.add(element)\n sum_of_elements += element\n return sum_of_elements\n"}
{"task_id": "Mbpp/778", "completion": "\ndef pack_consecutive_duplicates(lst):\n result = []\n current_sublist = []\n previous_element = None\n for element in lst:\n if element == previous_element:\n current_sublist.append(element)\n else:\n if current_sublist:\n result.append(current_sublist)\n current_sublist = [element]\n previous_element = element\n if current_sublist:\n result.append(current_sublist)\n return result\n"}
{"task_id": "Mbpp/780", "completion": "\ndef find_combinations(tuple_list):\n combinations = []\n for i in range(len(tuple_list)):\n for j in range(i + 1, len(tuple_list)):\n first_tuple = tuple_list[i]\n second_tuple = tuple_list[j]\n combinations.append((first_tuple[0] + second_tuple[0], first_tuple[1] + second_tuple[1]))\n return combinations\n"}
{"task_id": "Mbpp/781", "completion": "\ndef count_divisors(num):\n count = 0\n for i in range(1, num + 1):\n if num % i == 0:\n count += 1\n return count % 2 == 0\n"}
{"task_id": "Mbpp/782", "completion": "\ndef odd_length_sum(arr):\n n = len(arr)\n sum = 0\n for i in range(n):\n for j in range(i, n):\n if (j - i + 1) % 2!= 0:\n sum += sum(arr[i:j + 1])\n return sum\n"}
{"task_id": "Mbpp/783", "completion": "\ndef rgb_to_hsv(r, g, b):\n r, g, b = r/255.0, g/255.0, b/255.0\n max_value = max(r, g, b)\n min_value = min(r, g, b)\n diff = max_value - min_value\n if max_value == min_value:\n hue = 0\n elif max_value == r:\n hue = (60 * ((g - b) / diff) + 360) % 360\n elif max_value == g:\n hue = (60 * ((b - r) / diff) + 120) % 360\n elif max_value == b:\n hue = (60 * ((r - g) / diff) + 240) % 360\n if max_value == 0:\n saturation = 0\n else:\n saturation = (diff / max_value) * 100\n value = max_value * 100\n return round(hue, 2), round(saturation, 2), round(value, 2)\n"}
{"task_id": "Mbpp/784", "completion": "\ndef mul_even_odd(lst):\n even = None\n odd = None\n for num in lst:\n if num % 2 == 0:\n if even is None:\n even = num\n else:\n even *= num\n else:\n if odd is None:\n odd = num\n else:\n odd *= num\n if even is not None and odd is not None:\n return even * odd\n else:\n return None\n"}
{"task_id": "Mbpp/785", "completion": "\ndef tuple_str_int(tuple_str):\n return tuple(map(int, tuple_str[1:-1].split(\", \")))\n"}
{"task_id": "Mbpp/786", "completion": "\ndef right_insertion(lst, val):\n low = 0\n high = len(lst) - 1\n while low <= high:\n mid = (low + high) // 2\n if lst[mid] < val:\n low = mid + 1\n else:\n high = mid - 1\n return low\n"}
{"task_id": "Mbpp/787", "completion": "\nimport re\n\ndef text_match_three(text):\n pattern = r\"ab{3}\"\n return re.search(pattern, text)\n"}
{"task_id": "Mbpp/788", "completion": "\ndef new_tuple(list, string):\n return tuple(list + [string])\n"}
{"task_id": "Mbpp/790", "completion": "\ndef even_position(nums):\n for i in range(len(nums)):\n if i % 2 == 0 and nums[i] % 2!= 0:\n return False\n return True\n"}
{"task_id": "Mbpp/791", "completion": "\ndef remove_nested(tup):\n result = []\n for item in tup:\n if isinstance(item, tuple):\n result.extend(remove_nested(item))\n else:\n result.append(item)\n return tuple(result)\n"}
{"task_id": "Mbpp/792", "completion": "\ndef count_list(lists):\n count = 0\n for item in lists:\n if isinstance(item, list):\n count += 1\n return count\n"}
{"task_id": "Mbpp/793", "completion": "\ndef last(nums, target):\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] <= target:\n left = mid + 1\n else:\n right = mid - 1\n return right\n"}
{"task_id": "Mbpp/794", "completion": "\nimport re\n\ndef text_starta_endb(text):\n pattern = re.compile(r\"^a.*b$\")\n return pattern.match(text) is not None\n"}
{"task_id": "Mbpp/796", "completion": "\ndef return_sum(input_dict):\n total = 0\n for value in input_dict.values():\n total += value\n return total\n"}
{"task_id": "Mbpp/797", "completion": "\ndef sum_in_range(l, r):\n sum = 0\n for i in range(l, r+1):\n if i % 2 == 1:\n sum += i\n return sum\n"}
{"task_id": "Mbpp/798", "completion": "\ndef _sum(arr):\n total = 0\n for num in arr:\n total += num\n return total\n"}
{"task_id": "Mbpp/799", "completion": "\ndef left_rotate(n, d):\n return (n << d) | (n >> (32 - d))\n"}
{"task_id": "Mbpp/800", "completion": "\ndef remove_all_spaces(string):\n new_string = ''\n for char in string:\n if char!='':\n new_string += char\n return new_string\n"}
{"task_id": "Mbpp/801", "completion": "\ndef test_three_equal(a, b, c):\n count = 0\n if a == b == c:\n count = 3\n elif a == b or a == c or b == c:\n count = 2\n return count\n"}
{"task_id": "Mbpp/803", "completion": "\ndef is_perfect_square(num):\n return num ** 0.5 % 1 == 0\n"}
{"task_id": "Mbpp/804", "completion": "\ndef is_product_even(numbers):\n product = 1\n for num in numbers:\n product *= num\n return product % 2 == 0\n"}
{"task_id": "Mbpp/805", "completion": "\ndef max_sum_list(lst):\n max_sum = 0\n max_list = []\n for sublist in lst:\n if sum(sublist) > max_sum:\n max_sum = sum(sublist)\n max_list = sublist\n return max_list\n"}
{"task_id": "Mbpp/806", "completion": "\ndef max_run_uppercase(s):\n max_run = 0\n current_run = 0\n for c in s:\n if c.isupper():\n current_run += 1\n else:\n max_run = max(max_run, current_run)\n current_run = 0\n max_run = max(max_run, current_run)\n return max_run\n"}
{"task_id": "Mbpp/807", "completion": "\ndef first_odd(numbers):\n for num in numbers:\n if num % 2 == 1:\n return num\n return None\n"}
{"task_id": "Mbpp/808", "completion": "\ndef check_K(tuple, k):\n return k in tuple\n"}
{"task_id": "Mbpp/809", "completion": "\ndef check_smaller(tuple1, tuple2):\n return all(x < y for x, y in zip(tuple1, tuple2))\n"}
evalplus-starcoder2-15b-instruct-v0.1-mbpp_eval_results.json 0000664 0000000 0000000 00000571143 14637551746 0037453 0 ustar 00root root 0000000 0000000 selfcodealign-selfcodealign/evaluation/evalplus_results {"date": "2024-04-26 12:03", "hash": "ebe95df0d5220f00cedd6f4bddea35e4", "eval": {"Mbpp/2": [{"task_id": "Mbpp/2", "solution": "\"\"\"\nWrite a function to find the shared elements from the given two lists.\nassert set(similar_elements((3, 4, 5, 6),(5, 7, 4, 10))) == set((4, 5))\n\"\"\"\n\ndef similar_elements(list1, list2):\n return set(list1).intersection(set(list2))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/18": [{"task_id": "Mbpp/18", "solution": "\"\"\"\nWrite a function to remove characters from the first string which are present in the second string.\nassert remove_dirty_chars(\"probasscurve\", \"pros\") == 'bacuve'\n\"\"\"\n\ndef remove_dirty_chars(string, dirty_chars):\n char_set = set(dirty_chars)\n clean_string = ''.join(c for c in string if c not in char_set)\n return clean_string\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/6": [{"task_id": "Mbpp/6", "solution": "\"\"\"\nWrite a python function to check whether the two numbers differ at one bit position only or not.\nassert differ_At_One_Bit_Pos(13,9) == True\n\"\"\"\n\ndef differ_At_One_Bit_Pos(num1, num2):\n xor_result = num1 ^ num2\n return xor_result & (xor_result - 1) == 0\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/63": [{"task_id": "Mbpp/63", "solution": "\"\"\"\nWrite a function to find the maximum difference between available pairs in the given tuple list.\nassert max_difference([(3, 5), (1, 7), (10, 3), (1, 2)]) == 7\n\"\"\"\n\ndef max_difference(tuples):\n differences = []\n for i, (x, y) in enumerate(tuples):\n for j, (x2, y2) in enumerate(tuples):\n if i!= j:\n differences.append(abs(x - x2) + abs(y - y2))\n return max(differences)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/3": [{"task_id": "Mbpp/3", "solution": "\"\"\"\nWrite a python function to identify non-prime numbers.\nassert is_not_prime(2) == False\n\"\"\"\n\ndef is_not_prime(num):\n if num <= 1:\n return False\n for i in range(2, num):\n if num % i == 0:\n return True\n return False\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[true]]}], "Mbpp/87": [{"task_id": "Mbpp/87", "solution": "\"\"\"\nWrite a function to merge three dictionaries into a single dictionary.\nassert merge_dictionaries_three({ \"R\": \"Red\", \"B\": \"Black\", \"P\": \"Pink\" }, { \"G\": \"Green\", \"W\": \"White\" },{ \"O\": \"Orange\", \"W\": \"White\", \"B\": \"Black\" })=={'B': 'Black', 'R': 'Red', 'P': 'Pink', 'G': 'Green', 'W': 'White', 'O': 'Orange'}\n\"\"\"\n\ndef merge_dictionaries_three(dict1, dict2, dict3):\n return {**dict1, **dict2, **dict3}\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/58": [{"task_id": "Mbpp/58", "solution": "\"\"\"\nWrite a python function to check whether the given two integers have opposite sign or not.\nassert opposite_Signs(1,-2) == True\n\"\"\"\n\ndef opposite_Signs(a, b):\n return a * b < 0\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/69": [{"task_id": "Mbpp/69", "solution": "\"\"\"\nWrite a function to check whether a list contains the given sublist or not.\nassert is_sublist([2,4,3,5,7],[3,7])==False\n\"\"\"\n\ndef is_sublist(lst, sublist):\n n = len(sublist)\n return any(sublist == lst[i:i+n] for i in range(len(lst)-n+1))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/90": [{"task_id": "Mbpp/90", "solution": "\"\"\"\nWrite a python function to find the length of the longest word.\nassert len_log([\"python\",\"PHP\",\"bigdata\"]) == 7\n\"\"\"\n\ndef len_log(words):\n max_len = 0\n for word in words:\n if len(word) > max_len:\n max_len = len(word)\n return max_len\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/100": [{"task_id": "Mbpp/100", "solution": "\"\"\"\nWrite a function to find the next smallest palindrome of a specified integer, returned as an integer.\nassert next_smallest_palindrome(99)==101\n\"\"\"\n\ndef next_smallest_palindrome(num: int) -> int:\n num_str = str(num)\n if num_str == num_str[::-1]:\n return int(num_str)\n else:\n num_list = list(num_str)\n for i in range(len(num_list) // 2):\n if num_list[i]!= num_list[-i - 1]:\n num_list[i] = num_list[-i - 1] = max(num_list[i], num_list[-i - 1])\n break\n return int(\"\".join(num_list))\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/8": [{"task_id": "Mbpp/8", "solution": "\"\"\"\nWrite a function to find squares of individual elements in a list.\nassert square_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n\"\"\"\n\ndef square_nums(nums):\n return [num**2 for num in nums]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/20": [{"task_id": "Mbpp/20", "solution": "\"\"\"\nWrite a function to check if the given number is woodball or not.\nassert is_woodall(383) == True\n\"\"\"\n\ndef is_woodall(n):\n if n < 0:\n return False\n for i in range(1, n + 1):\n if i ** i!= n:\n return False\n return True\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[false]]}], "Mbpp/79": [{"task_id": "Mbpp/79", "solution": "\"\"\"\nWrite a python function to check whether the length of the word is odd or not.\nassert word_len(\"Hadoop\") == False\n\"\"\"\n\ndef word_len(word):\n return len(word) % 2 == 1\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/101": [{"task_id": "Mbpp/101", "solution": "\"\"\"\nWrite a function to find the kth element in the given array using 1-based indexing.\nassert kth_element([12,3,5,7,19], 2) == 3\n\"\"\"\n\ndef kth_element(arr, k):\n return arr[k-1]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/105": [{"task_id": "Mbpp/105", "solution": "\"\"\"\nWrite a python function to count true booleans in the given list.\nassert count([True,False,True]) == 2\n\"\"\"\n\ndef count(lst):\n return sum(1 for x in lst if x)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/11": [{"task_id": "Mbpp/11", "solution": "\"\"\"\nWrite a python function to remove first and last occurrence of a given character from the string.\nassert remove_Occ(\"hello\",\"l\") == \"heo\"\n\"\"\"\n\ndef remove_Occ(string, char):\n first_index = string.find(char)\n last_index = string.rfind(char)\n if first_index == last_index:\n return string.replace(char, \"\")\n else:\n return string[:first_index] + string[first_index + 1:last_index] + string[last_index + 1:]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/70": [{"task_id": "Mbpp/70", "solution": "\"\"\"\nWrite a function to find whether all the given tuples have equal length or not.\nassert get_equal([(11, 22, 33), (44, 55, 66)]) == True\n\"\"\"\n\ndef get_equal(tuples):\n lengths = set(len(t) for t in tuples)\n return len(lengths) == 1\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/85": [{"task_id": "Mbpp/85", "solution": "\"\"\"\nWrite a function to find the surface area of a sphere.\nassert math.isclose(surfacearea_sphere(10), 1256.6370614359173, rel_tol=0.001)\n\"\"\"\n\nimport math\n\ndef surfacearea_sphere(radius):\n return 4 * math.pi * radius ** 2\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/57": [{"task_id": "Mbpp/57", "solution": "\"\"\"\nWrite a python function to find the largest number that can be formed with the given list of digits.\nassert find_Max_Num([1,2,3]) == 321\n\"\"\"\n\ndef find_Max_Num(arr):\n arr.sort(reverse=True)\n return int(\"\".join(map(str, arr)))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/72": [{"task_id": "Mbpp/72", "solution": "\"\"\"\nWrite a python function to check whether the given number can be represented as the difference of two squares or not.\nassert dif_Square(5) == True\n\"\"\"\n\nimport math\n\ndef dif_Square(n):\n if n < 0:\n return False\n for a in range(int(math.sqrt(n)) + 1):\n b = math.sqrt(n - a**2)\n if b == int(b):\n return True\n return False\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[10]], "plus_fail_tests": []}], "Mbpp/16": [{"task_id": "Mbpp/16", "solution": "\"\"\"\nWrite a function to that returns true if the input string contains sequences of lowercase letters joined with an underscore and false otherwise.\nassert text_lowercase_underscore(\"aab_cbbbc\")==(True)\n\"\"\"\n\nimport re\n\ndef text_lowercase_underscore(text):\n pattern = re.compile(r'^[a-z_]+$')\n return pattern.match(text) is not None\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["_"]]}], "Mbpp/64": [{"task_id": "Mbpp/64", "solution": "\"\"\"\nWrite a function to sort a list of tuples using the second value of each tuple.\nassert subject_marks([('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)])==[('Social sciences', 82), ('English', 88), ('Science', 90), ('Maths', 97)]\n\"\"\"\n\ndef subject_marks(marks):\n return sorted(marks, key=lambda x: x[1])\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/74": [{"task_id": "Mbpp/74", "solution": "\"\"\"\nWrite a function to check whether it follows the sequence given in the patterns array.\nassert is_samepatterns([\"red\",\"green\",\"green\"], [\"a\", \"b\", \"b\"])==True\n\"\"\"\n\ndef is_samepatterns(colors, patterns):\n pattern_dict = {\"red\": \"a\", \"green\": \"b\", \"blue\": \"c\"}\n mapped_patterns = [pattern_dict[color] for color in colors]\n return mapped_patterns == patterns\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[["red", "green", "greenn"], ["a", "b", "b"]]], "plus_fail_tests": [[["red", "blue", "green"], ["a", "b", "c"]]]}], "Mbpp/71": [{"task_id": "Mbpp/71", "solution": "\"\"\"\nWrite a function to sort a list of elements.\nassert comb_sort([5, 15, 37, 25, 79]) == [5, 15, 25, 37, 79]\n\"\"\"\n\ndef comb_sort(elements):\n gap = len(elements)\n shrink = 1.3\n while gap > 1:\n gap = int(gap / shrink)\n for i in range(len(elements) - gap):\n if elements[i] > elements[i + gap]:\n elements[i], elements[i + gap] = elements[i + gap], elements[i]\n return elements\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/80": [{"task_id": "Mbpp/80", "solution": "\"\"\"\nWrite a function to find the nth tetrahedral number.\nassert tetrahedral_number(5) == 35\n\"\"\"\n\ndef tetrahedral_number(n):\n return n * (n + 1) * (n + 2) // 6\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/77": [{"task_id": "Mbpp/77", "solution": "\"\"\"\nWrite a python function to find whether a number is divisible by 11.\nassert is_Diff (12345) == False\n\"\"\"\n\ndef is_Divisible(num):\n num_str = str(num)\n odd_sum = 0\n even_sum = 0\n for i in range(len(num_str)):\n digit = int(num_str[i])\n if i % 2 == 0:\n even_sum += digit\n else:\n odd_sum += digit\n return (odd_sum - even_sum) % 11 == 0\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/66": [{"task_id": "Mbpp/66", "solution": "\"\"\"\nWrite a python function to count the number of positive numbers in a list.\nassert pos_count([1,-2,3,-4]) == 2\n\"\"\"\n\ndef pos_count(lst):\n count = 0\n for num in lst:\n if num > 0:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/9": [{"task_id": "Mbpp/9", "solution": "\"\"\"\nWrite a python function to find the minimum number of rotations (greater than 0) required to get the same string.\nassert find_Rotations(\"aaaa\") == 1\n\"\"\"\n\ndef find_Rotations(s):\n n = len(s)\n for i in range(1, n):\n if s[i:] + s[:i] == s:\n return i\n return n\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/19": [{"task_id": "Mbpp/19", "solution": "\"\"\"\nWrite a function to find whether a given array of integers contains any duplicate element.\nassert test_duplicate(([1,2,3,4,5]))==False\n\"\"\"\n\ndef test_duplicate(arr):\n return len(arr)!= len(set(arr))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/98": [{"task_id": "Mbpp/98", "solution": "\"\"\"\nWrite a function to multiply all the numbers in a list and divide with the length of the list.\nassert math.isclose(multiply_num((8, 2, 3, -1, 7)), -67.2, rel_tol=0.001)\n\"\"\"\n\nimport math\n\ndef multiply_num(numbers):\n result = 1\n for num in numbers:\n result *= num\n return result / len(numbers)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/59": [{"task_id": "Mbpp/59", "solution": "\"\"\"\nWrite a function to find the nth octagonal number.\nassert is_octagonal(5) == 65\n\"\"\"\n\ndef is_octagonal(n):\n return (3 * n * n - 2 * n) // 2\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/14": [{"task_id": "Mbpp/14", "solution": "\"\"\"\nWrite a python function to find the volume of a triangular prism.\nassert find_Volume(10,8,6) == 240\n\"\"\"\n\ndef find_Volume(base, height, length):\n area = 0.5 * base * height\n volume = area * length\n return volume\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[123456789, 987654321, 12345]]}], "Mbpp/7": [{"task_id": "Mbpp/7", "solution": "\"\"\"\nWrite a function to find all words which are at least 4 characters long in a string.\nassert set(find_char_long('Please move back to stream')) == set(['Please', 'move', 'back', 'stream'])\n\"\"\"\n\ndef find_char_long(s):\n return [word for word in s.split() if len(word) >= 4]\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["This is a very long string with no words that are at least 4 characters long."]]}], "Mbpp/95": [{"task_id": "Mbpp/95", "solution": "\"\"\"\nWrite a python function to find the length of the smallest list in a list of lists.\nassert Find_Min_Length([[1],[1,2]]) == 1\n\"\"\"\n\ndef Find_Min_Length(lists):\n min_length = float('inf')\n for lst in lists:\n min_length = min(min_length, len(lst))\n return min_length\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/97": [{"task_id": "Mbpp/97", "solution": "\"\"\"\nWrite a function to find frequency of each element in a flattened list of lists, returned in a dictionary.\nassert 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}\n\"\"\"\n\nfrom collections import Counter\n\ndef frequency_lists(lists):\n flattened_list = [item for sublist in lists for item in sublist]\n frequency_dict = Counter(flattened_list)\n return frequency_dict\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/94": [{"task_id": "Mbpp/94", "solution": "\"\"\"\nGiven a list of tuples, write a function that returns the first value of the tuple with the smallest second value.\nassert index_minimum([('Rash', 143), ('Manjeet', 200), ('Varsha', 100)]) == 'Varsha'\n\"\"\"\n\ndef index_minimum(tuples):\n return min(tuples, key=lambda x: x[1])[0]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/56": [{"task_id": "Mbpp/56", "solution": "\"\"\"\nWrite a python function to check if a given number is one less than twice its reverse.\nassert check(70) == False\n\"\"\"\n\ndef check(num):\n num_str = str(num)\n reversed_num_str = num_str[::-1]\n reversed_num = int(reversed_num_str)\n return num == reversed_num * 2 - 1\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/103": [{"task_id": "Mbpp/103", "solution": "\"\"\"\nWrite a function to find the Eulerian number a(n, m).\nassert eulerian_num(3, 1) == 4\n\"\"\"\n\ndef eulerian_num(n, m):\n if n == 0 and m == 0:\n return 1\n elif n < m or m < 0:\n return 0\n else:\n return eulerian_num(n - 1, m - 1) + (n - 1) * eulerian_num(n - 1, m)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/102": [{"task_id": "Mbpp/102", "solution": "\"\"\"\nWrite a function to convert a snake case string to camel case string.\nassert snake_to_camel('python_program')=='PythonProgram'\n\"\"\"\n\ndef snake_to_camel(s):\n return ''.join(x.capitalize() if i else x.lower() for i, x in enumerate(s.split('_')))\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/68": [{"task_id": "Mbpp/68", "solution": "\"\"\"\nWrite a python function to check whether the given array is monotonic or not.\nassert is_Monotonic([6, 5, 4, 4]) == True\n\"\"\"\n\ndef is_Monotonic(arr):\n return all(arr[i] <= arr[i + 1] for i in range(len(arr) - 1)) or all(arr[i] >= arr[i + 1] for i in range(len(arr) - 1))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/83": [{"task_id": "Mbpp/83", "solution": "\"\"\"\nWrite a python function to find the character made by adding the ASCII value of all the characters of the given string modulo 26.\nassert get_Char(\"abc\") == \"f\"\n\"\"\"\n\ndef get_Char(string):\n sum_ascii = 0\n for char in string:\n sum_ascii += ord(char)\n remainder = sum_ascii % 26\n return chr(remainder + ord(\"a\"))\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/99": [{"task_id": "Mbpp/99", "solution": "\"\"\"\nWrite a function to convert the given decimal number to its binary equivalent, represented as a string with no leading zeros.\nassert decimal_to_binary(8) == '1000'\n\"\"\"\n\ndef decimal_to_binary(decimal_number):\n binary_string = bin(decimal_number)[2:]\n return binary_string\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[-5]]}], "Mbpp/93": [{"task_id": "Mbpp/93", "solution": "\"\"\"\nWrite a function to calculate the value of 'a' to the power 'b'.\nassert power(3,4) == 81\n\"\"\"\n\ndef power(a, b):\n return a ** b\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/65": [{"task_id": "Mbpp/65", "solution": "\"\"\"\nWrite a function to flatten a list and sum all of its elements.\nassert recursive_list_sum(([1, 2, [3,4],[5,6]]))==21\n\"\"\"\n\ndef recursive_list_sum(input_list):\n total = 0\n for element in input_list:\n if type(element) == type([]):\n total += recursive_list_sum(element)\n else:\n total += element\n return total\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/4": [{"task_id": "Mbpp/4", "solution": "\"\"\"\nWrite a function to find the n largest integers from a given list of numbers, returned in descending order.\nassert heap_queue_largest( [25, 35, 22, 85, 14, 65, 75, 22, 58],3)==[85, 75, 65]\n\"\"\"\n\ndef heap_queue_largest(nums, n):\n import heapq\n return heapq.nlargest(n, nums)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/84": [{"task_id": "Mbpp/84", "solution": "\"\"\"\nWrite a function to find the nth number in the newman conway sequence.\nassert sequence(10) == 6\n\"\"\"\n\ndef sequence(n):\n if n == 1:\n return 1\n if n == 2:\n return 1\n if n == 3:\n return 2\n prev_term = sequence(n - 1)\n count = 1\n index = n - 2\n while count < prev_term:\n if sequence(index) == 1:\n count += 1\n index -= 1\n return n - index - 1\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/92": [{"task_id": "Mbpp/92", "solution": "\"\"\"\nWrite a function to check whether the given number is undulating or not.\nassert is_undulating(1212121) == True\n\"\"\"\n\ndef is_undulating(num):\n num_str = str(num)\n for i in range(len(num_str) - 2):\n if num_str[i] == num_str[i+1] or num_str[i+1] == num_str[i+2]:\n return False\n return True\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[2121212121212123]]}], "Mbpp/62": [{"task_id": "Mbpp/62", "solution": "\"\"\"\nWrite a python function to find smallest number in a list.\nassert smallest_num([10, 20, 1, 45, 99]) == 1\n\"\"\"\n\ndef smallest_num(list):\n return min(list)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/75": [{"task_id": "Mbpp/75", "solution": "\"\"\"\nWrite a function to find tuples which have all elements divisible by k from the given list of tuples.\nassert find_tuples([(6, 24, 12), (7, 9, 6), (12, 18, 21)], 6) == [(6, 24, 12)]\n\"\"\"\n\ndef find_tuples(tuples, k):\n return [t for t in tuples if all(element % k == 0 for element in t)]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/17": [{"task_id": "Mbpp/17", "solution": "\"\"\"\nWrite a function that returns the perimeter of a square given its side length as input.\nassert square_perimeter(10)==40\n\"\"\"\n\ndef square_perimeter(side_length):\n return 4 * side_length\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/88": [{"task_id": "Mbpp/88", "solution": "\"\"\"\nWrite a function to get the frequency of all the elements in a list, returned as a dictionary.\nassert 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})\n\"\"\"\n\ndef freq_count(lst):\n freq_dict = {}\n for element in lst:\n if element in freq_dict:\n freq_dict[element] += 1\n else:\n freq_dict[element] = 1\n return freq_dict\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/12": [{"task_id": "Mbpp/12", "solution": "\"\"\"\nWrite a function to sort a given matrix in ascending order according to the sum of its rows.\nassert sort_matrix([[1, 2, 3], [2, 4, 5], [1, 1, 1]])==[[1, 1, 1], [1, 2, 3], [2, 4, 5]]\n\"\"\"\n\ndef sort_matrix(matrix):\n row_sums = [sum(row) for row in matrix]\n sorted_indices = sorted(range(len(row_sums)), key=lambda i: row_sums[i])\n sorted_matrix = [matrix[i] for i in sorted_indices]\n return sorted_matrix\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/104": [{"task_id": "Mbpp/104", "solution": "\"\"\"\nWrite a function to sort each sublist of strings in a given list of lists.\nassert sort_sublists(([\"green\", \"orange\"], [\"black\", \"white\"], [\"white\", \"black\", \"orange\"]))==[['green', 'orange'], ['black', 'white'], ['black', 'orange', 'white']]\n\"\"\"\n\ndef sort_sublists(input_list):\n return [[sorted(sublist)] for sublist in input_list]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[["apple", "banana", "cherry"], ["banana", "cherry", "apple"], ["cherry", "apple", "banana"]]]]}], "Mbpp/82": [{"task_id": "Mbpp/82", "solution": "\"\"\"\nWrite a function to find the volume of a sphere.\nassert math.isclose(volume_sphere(10), 4188.790204786391, rel_tol=0.001)\n\"\"\"\n\nimport math\n\ndef volume_sphere(radius):\n return 4 / 3 * math.pi * radius ** 3\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/108": [{"task_id": "Mbpp/108", "solution": "\"\"\"\nWrite a function to merge three lists into a single sorted list.\nassert merge_sorted_list([25, 24, 15, 4, 5, 29, 110],[19, 20, 11, 56, 25, 233, 154],[24, 26, 54, 48])==[4, 5, 11, 15, 19, 20, 24, 24, 25, 25, 26, 29, 48, 54, 56, 110, 154, 233]\n\"\"\"\n\ndef merge_sorted_list(list1, list2, list3):\n merged_list = list1 + list2 + list3\n merged_list.sort()\n return merged_list\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/91": [{"task_id": "Mbpp/91", "solution": "\"\"\"\nWrite a function to check if a string is present as a substring in a given list of string values.\nassert find_substring([\"red\", \"black\", \"white\", \"green\", \"orange\"],\"ack\")==True\n\"\"\"\n\ndef find_substring(list_of_strings, substring):\n for string in list_of_strings:\n if substring in string:\n return True\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/106": [{"task_id": "Mbpp/106", "solution": "\"\"\"\nWrite a function to append the given list to the given tuples.\nassert add_lists([5, 6, 7], (9, 10)) == (9, 10, 5, 6, 7)\n\"\"\"\n\ndef add_lists(list_to_append, tuple_to_append_to):\n return tuple_to_append_to + tuple(list_to_append)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/89": [{"task_id": "Mbpp/89", "solution": "\"\"\"\nWrite a function to find the closest smaller number than n.\nassert closest_num(11) == 10\n\"\"\"\n\ndef closest_num(n):\n num_str = str(n)\n for i in range(len(num_str)-1, 0, -1):\n if num_str[i] < num_str[i-1]:\n num_str = num_str[:i-1] + num_str[i:]\n num_str = num_str[:i] + ''.join(reversed(sorted(num_str[i:])))\n return int(num_str)\n return n\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/109": [{"task_id": "Mbpp/109", "solution": "\"\"\"\nWrite a python function to find the number of numbers with an odd value when rotating a binary string the given number of times.\nassert odd_Equivalent(\"011001\",6) == 3\n\"\"\"\n\ndef odd_Equivalent(s, n):\n count = 0\n for i in range(len(s)):\n rotated_s = s[i:] + s[:i]\n if int(rotated_s, 2) % 2 == 1:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/86": [{"task_id": "Mbpp/86", "solution": "\"\"\"\nWrite a function to find nth centered hexagonal number.\nassert centered_hexagonal_number(10) == 271\n\"\"\"\n\ndef centered_hexagonal_number(n):\n return 3 * n * (n - 1) + 1\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/111": [{"task_id": "Mbpp/111", "solution": "\"\"\"\nWrite a function to find the common elements in given nested lists.\nassert set(common_in_nested_lists([[12, 18, 23, 25, 45], [7, 12, 18, 24, 28], [1, 5, 8, 12, 15, 16, 18]]))==set([18, 12])\n\"\"\"\n\ndef common_in_nested_lists(nested_lists):\n common_elements = set(nested_lists[0])\n for lst in nested_lists[1:]:\n common_elements &= set(lst)\n return list(common_elements)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/96": [{"task_id": "Mbpp/96", "solution": "\"\"\"\nWrite a python function to find the number of divisors of a given integer.\nassert divisor(15) == 4\n\"\"\"\n\ndef divisor(n):\n count = 0\n for i in range(1, n+1):\n if n % i == 0:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/115": [{"task_id": "Mbpp/115", "solution": "\"\"\"\nWrite a function to check whether all dictionaries in a list are empty or not.\nassert empty_dit([{},{},{}])==True\n\"\"\"\n\ndef empty_dit(list):\n for i in list:\n if not i:\n return False\n return True\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/113": [{"task_id": "Mbpp/113", "solution": "\"\"\"\nWrite a function to check if a string represents an integer or not.\nassert check_integer(\"python\")==False\n\"\"\"\n\ndef check_integer(s):\n try:\n int(s)\n return True\n except ValueError:\n return False\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/172": [{"task_id": "Mbpp/172", "solution": "\"\"\"\nWrite a function to count the number of occurence of the string 'std' in a given string.\nassert count_occurance(\"letstdlenstdporstd\") == 3\n\"\"\"\n\ndef count_occurance(string):\n count = 0\n for i in range(len(string)-2):\n if string[i:i+3] == \"std\":\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/131": [{"task_id": "Mbpp/131", "solution": "\"\"\"\nWrite a python function to reverse only the vowels of a given string (where y is not a vowel).\nassert reverse_vowels(\"Python\") == \"Python\"\n\"\"\"\n\ndef reverse_vowels(s):\n vowels = {'a', 'e', 'i', 'o', 'u'}\n chars = list(s)\n i, j = 0, len(s) - 1\n while i < j:\n if chars[i].lower() in vowels:\n if chars[j].lower() in vowels:\n chars[i], chars[j] = chars[j], chars[i]\n i += 1\n j -= 1\n else:\n j -= 1\n else:\n i += 1\n return ''.join(chars)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/140": [{"task_id": "Mbpp/140", "solution": "\"\"\"\nWrite a function to flatten the list of lists into a single set of numbers.\nassert set(extract_singly([(3, 4, 5), (4, 5, 7), (1, 4)])) == set([3, 4, 5, 7, 1])\n\"\"\"\n\ndef extract_singly(lst):\n return [num for sublist in lst for num in sublist]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/244": [{"task_id": "Mbpp/244", "solution": "\"\"\"\nWrite a python function to find the next perfect square greater than a given number.\nassert next_Perfect_Square(35) == 36\n\"\"\"\n\nimport math\n\ndef next_Perfect_Square(num):\n root = math.sqrt(num)\n if root.is_integer():\n return num + 1\n next_root = math.ceil(root)\n return (next_root + 1) ** 2\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/230": [{"task_id": "Mbpp/230", "solution": "\"\"\"\nWrite a function that takes in a string and character, replaces blank spaces in the string with the character, and returns the string.\nassert replace_blank(\"hello people\",'@')==(\"hello@people\")\n\"\"\"\n\ndef replace_blank(string, char):\n return string.replace(' ', char)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/223": [{"task_id": "Mbpp/223", "solution": "\"\"\"\nWrite a function that takes in a sorted array, its length (n), and an element and returns whether the element is the majority element in the given sorted array. (The majority element is the element that occurs more than n/2 times.)\nassert is_majority([1, 2, 3, 3, 3, 3, 10], 7, 3) == True\n\"\"\"\n\ndef is_majority(arr, n, element):\n first_occurrence = binary_search(arr, 0, n - 1, element)\n if first_occurrence == -1:\n return False\n last_occurrence = binary_search(arr, first_occurrence + 1, n - 1, element)\n if last_occurrence == -1:\n return False\n return last_occurrence - first_occurrence + 1 > n // 2\n\ndef binary_search(arr, low, high, element):\n if high >= low:\n mid = (low + high) // 2\n if (mid == 0 or arr[mid - 1] < element) and arr[mid] == element:\n return mid\n elif arr[mid] < element:\n return binary_search(arr, mid + 1, high, element)\n else:\n return binary_search(arr, low, mid - 1, element)\n return -1\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[], 1, 0]]}], "Mbpp/238": [{"task_id": "Mbpp/238", "solution": "\"\"\"\nWrite a python function to count the number of non-empty substrings of a given string.\nassert number_of_substrings(\"abc\") == 6\n\"\"\"\n\ndef number_of_substrings(string):\n return len(string) * (len(string) + 1) // 2\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/125": [{"task_id": "Mbpp/125", "solution": "\"\"\"\nWrite 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.\nassert find_length(\"11000010001\") == 6\n\"\"\"\n\ndef find_length(s):\n n = len(s)\n max_diff = 0\n for i in range(n):\n for j in range(i, n):\n num_zeros = s[i:j + 1].count('0')\n num_ones = s[i:j + 1].count('1')\n diff = abs(num_zeros - num_ones)\n max_diff = max(max_diff, diff)\n return max_diff\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [["10111"]], "plus_fail_tests": [["0000000000001111111111111"]]}], "Mbpp/245": [{"task_id": "Mbpp/245", "solution": "\"\"\"\nWrite a function that takes an array and finds the maximum sum of a bitonic subsequence for the given array, where a sequence is bitonic if it is first increasing and then decreasing.\nassert max_sum([1, 15, 51, 45, 33, 100, 12, 18, 9]) == 194\n\"\"\"\n\ndef max_sum(arr):\n n = len(arr)\n increasing = [0] * n\n decreasing = [0] * n\n increasing[0] = arr[0]\n for i in range(1, n):\n increasing[i] = arr[i] + max(increasing[i - 1], 0)\n decreasing[n - 1] = arr[n - 1]\n for i in range(n - 2, -1, -1):\n decreasing[i] = arr[i] + max(decreasing[i + 1], 0)\n max_sum = 0\n for i in range(n):\n max_sum = max(max_sum, increasing[i] + decreasing[i] - arr[i])\n\n return max_sum\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[10, 9, 8, 7, 6, 5, 4, 4, 3, 2, 1]]]}], "Mbpp/167": [{"task_id": "Mbpp/167", "solution": "\"\"\"\nWrite a python function to find the smallest power of 2 greater than or equal to n.\nassert next_power_of_2(0) == 1\n\"\"\"\n\ndef next_power_of_2(n):\n result = 1\n while result < n:\n result *= 2\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/170": [{"task_id": "Mbpp/170", "solution": "\"\"\"\nWrite a function to find the sum of numbers in a list within a range specified by two indices.\nassert sum_range_list([2,1,5,6,8,3,4,9,10,11,8,12], 8, 10) == 29\n\"\"\"\n\ndef sum_range_list(lst, start, end):\n return sum(lst[start:end+1])\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/235": [{"task_id": "Mbpp/235", "solution": "\"\"\"\nWrite a python function to set all even bits of a given number.\nassert even_bit_set_number(10) == 10\n\"\"\"\n\ndef even_bit_set_number(number):\n return number | 0x55555555\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/137": [{"task_id": "Mbpp/137", "solution": "\"\"\"\nWrite a function to find the ratio of zeroes to non-zeroes in an array of integers.\nassert math.isclose(zero_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8]), 0.181818, rel_tol=0.001)\n\"\"\"\n\nimport numpy as np\n\ndef zero_count(arr):\n arr = np.array(arr)\n num_zeroes = np.count_nonzero(arr == 0)\n num_non_zeroes = np.count_nonzero(arr!= 0)\n return num_zeroes / (num_zeroes + num_non_zeroes)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/232": [{"task_id": "Mbpp/232", "solution": "\"\"\"\nWrite a function that takes in a list and an integer n and returns a list containing the n largest items from the list.\nassert set(larg_nnum([10, 20, 50, 70, 90, 20, 50, 40, 60, 80, 100],2))==set([100,90])\n\"\"\"\n\ndef larg_nnum(lst,n):\n lst.sort(reverse=True)\n return lst[:n]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/168": [{"task_id": "Mbpp/168", "solution": "\"\"\"\nWrite a function to count the number of occurrences of a number in a given list.\nassert frequency([1,2,3], 4) == 0\n\"\"\"\n\ndef frequency(lst, num):\n count = 0\n for i in lst:\n if i == num:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/116": [{"task_id": "Mbpp/116", "solution": "\"\"\"\nWrite a function to convert a given tuple of positive integers into a single integer.\nassert tuple_to_int((1,2,3))==123\n\"\"\"\n\ndef tuple_to_int(tup):\n return int(\"\".join(map(str, tup)))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/127": [{"task_id": "Mbpp/127", "solution": "\"\"\"\nWrite a function to multiply two integers.\nassert multiply_int(10,20)==200\n\"\"\"\n\ndef multiply_int(a, b):\n if a == 0 or b == 0:\n return 0\n if a == 1:\n return b\n if b == 1:\n return a\n return a + multiply_int(a, b - 1)\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/118": [{"task_id": "Mbpp/118", "solution": "\"\"\"\nWrite a function to convert a string to a list of strings split on the space character.\nassert string_to_list(\"python programming\")==['python','programming']\n\"\"\"\n\ndef string_to_list(string):\n return string.split()\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/227": [{"task_id": "Mbpp/227", "solution": "\"\"\"\nWrite a function to find minimum of three numbers.\nassert min_of_three(10,20,0)==0\n\"\"\"\n\ndef min_of_three(a,b,c):\n if a n]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/166": [{"task_id": "Mbpp/166", "solution": "\"\"\"\nWrite a function that counts the number of pairs of integers in a list that xor to an even number.\nassert find_even_pair([5, 4, 7, 2, 1]) == 4\n\"\"\"\n\ndef find_even_pair(nums):\n count = 0\n for i in range(len(nums)):\n for j in range(i + 1, len(nums)):\n if (nums[i] ^ nums[j]) % 2 == 0:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/135": [{"task_id": "Mbpp/135", "solution": "\"\"\"\nWrite a function to find the nth hexagonal number.\nassert hexagonal_num(10) == 190\n\"\"\"\n\ndef hexagonal_num(n):\n return 2 * n * (2 * n - 1)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/143": [{"task_id": "Mbpp/143", "solution": "\"\"\"\nWrite a function to find number of lists present in the given tuple.\nassert find_lists(([1, 2, 3, 4], [5, 6, 7, 8])) == 2\n\"\"\"\n\ndef find_lists(input_tuple):\n count = 0\n for element in input_tuple:\n if isinstance(element, list):\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/222": [{"task_id": "Mbpp/222", "solution": "\"\"\"\nWrite a function to check if all the elements in tuple have same data type or not.\nassert check_type((5, 6, 7, 3, 5, 6) ) == True\n\"\"\"\n\ndef check_type(tup):\n data_type = type(tup[0])\n for element in tup:\n if type(element)!= data_type:\n return False\n return True\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/138": [{"task_id": "Mbpp/138", "solution": "\"\"\"\nWrite a python function to check whether the given number can be represented as sum of non-zero powers of 2 or not.\nassert is_Sum_Of_Powers_Of_Two(10) == True\n\"\"\"\n\ndef is_Sum_Of_Powers_Of_Two(num):\n while num > 0:\n if num == 1:\n return True\n power_of_two = 1\n while power_of_two <= num // 2:\n if num - power_of_two == 1:\n return True\n elif num - power_of_two > 1:\n if is_Sum_Of_Powers_Of_Two(num - power_of_two):\n return True\n power_of_two *= 2\n num -= 1\n return False\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[7]], "plus_fail_tests": []}], "Mbpp/124": [{"task_id": "Mbpp/124", "solution": "\"\"\"\nWrite a function to get the angle of a complex number.\nassert math.isclose(angle_complex(0,1j), 1.5707963267948966, rel_tol=0.001)\n\"\"\"\n\nimport cmath\n\ndef angle_complex(real, imag):\n return cmath.phase(complex(real, imag))\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["0.0", "1j"]]}], "Mbpp/139": [{"task_id": "Mbpp/139", "solution": "\"\"\"\nWrite a function to find the circumference of a circle.\nassert math.isclose(circle_circumference(10), 62.830000000000005, rel_tol=0.001)\n\"\"\"\n\nimport math\n\ndef circle_circumference(radius):\n return 2 * math.pi * radius\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/226": [{"task_id": "Mbpp/226", "solution": "\"\"\"\nWrite a python function to remove the characters which have odd index values of a given string.\nassert odd_values_string('abcdef') == 'ace'\n\"\"\"\n\ndef odd_values_string(string):\n return ''.join([char for i, char in enumerate(string) if i % 2 == 0])\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/234": [{"task_id": "Mbpp/234", "solution": "\"\"\"\nWrite a function to find the volume of a cube given its side length.\nassert volume_cube(3)==27\n\"\"\"\n\ndef volume_cube(side_length):\n return side_length ** 3\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/117": [{"task_id": "Mbpp/117", "solution": "\"\"\"\nWrite a function to convert all possible convertible elements in a list of lists to floats.\nassert 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)]\n\"\"\"\n\ndef list_to_float(input_list):\n return [(float(x), float(y)) for x, y in input_list]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/119": [{"task_id": "Mbpp/119", "solution": "\"\"\"\nWrite a python function to find the element that appears only once in a sorted array.\nassert search([1,1,2,2,3]) == 3\n\"\"\"\n\ndef search(nums):\n left, right = 0, len(nums) - 1\n while left < right:\n mid = (left + right) // 2\n if nums[mid] == nums[mid + 1]:\n left = mid + 2\n else:\n right = mid\n return nums[left]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[[1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8]]], "plus_fail_tests": []}], "Mbpp/233": [{"task_id": "Mbpp/233", "solution": "\"\"\"\nWrite a function to find the lateral surface area of a cylinder.\nassert math.isclose(lateralsuface_cylinder(10,5), 314.15000000000003, rel_tol=0.001)\n\"\"\"\n\nimport math\n\ndef lateralsuface_cylinder(radius, height):\n return 2 * math.pi * radius * height\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/133": [{"task_id": "Mbpp/133", "solution": "\"\"\"\nWrite a function to calculate the sum of the negative numbers of a given list of numbers.\nassert sum_negativenum([2, 4, -6, -9, 11, -12, 14, -5, 17])==-32\n\"\"\"\n\ndef sum_negativenum(num_list):\n sum = 0\n for num in num_list:\n if num < 0:\n sum += num\n return sum\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/129": [{"task_id": "Mbpp/129", "solution": "\"\"\"\nWrite a function to calculate whether the matrix is a magic square.\nassert magic_square_test([[7, 12, 1, 14], [2, 13, 8, 11], [16, 3, 10, 5], [9, 6, 15, 4]])==True\n\"\"\"\n\ndef magic_square_test(matrix):\n n = len(matrix)\n magic_sum = sum(matrix[0])\n for row in matrix:\n if sum(row)!= magic_sum:\n return False\n for col in range(n):\n col_sum = sum(matrix[i][col] for i in range(n))\n if col_sum!= magic_sum:\n return False\n diagonal_sum = sum(matrix[i][i] for i in range(n))\n if diagonal_sum!= magic_sum:\n return False\n diagonal_sum = sum(matrix[i][n - i - 1] for i in range(n))\n if diagonal_sum!= magic_sum:\n return False\n return True\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/120": [{"task_id": "Mbpp/120", "solution": "\"\"\"\nWrite a function to find the maximum absolute product between numbers in pairs of tuples within a given list.\nassert max_product_tuple([(2, 7), (2, 6), (1, 8), (4, 9)] )==36\n\"\"\"\n\ndef max_product_tuple(lst):\n max_product = float(\"-inf\")\n for a, b in lst:\n max_product = max(max_product, a * b, -a * b)\n return max_product\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/240": [{"task_id": "Mbpp/240", "solution": "\"\"\"\nWrite a function that takes in two lists and replaces the last element of the first list with the elements of the second list.\nassert replace_list([1, 3, 5, 7, 9, 10],[2, 4, 6, 8])==[1, 3, 5, 7, 9, 2, 4, 6, 8]\n\"\"\"\n\ndef replace_list(list1, list2):\n list1[-1:] = list2\n return list1\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/145": [{"task_id": "Mbpp/145", "solution": "\"\"\"\nWrite a python function to find the maximum difference between any two elements in a given array.\nassert max_Abs_Diff((2,1,5,3)) == 4\n\"\"\"\n\ndef max_Abs_Diff(arr):\n max_diff = 0\n for i in range(len(arr)):\n for j in range(i+1, len(arr)):\n diff = abs(arr[i] - arr[j])\n if diff > max_diff:\n max_diff = diff\n return max_diff\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/164": [{"task_id": "Mbpp/164", "solution": "\"\"\"\nWrite a function to determine if the sum of the divisors of two integers are the same.\nassert are_equivalent(36, 57) == False\n\"\"\"\n\ndef are_equivalent(num1, num2):\n sum_divisors1 = 0\n for i in range(1, num1 + 1):\n if num1 % i == 0:\n sum_divisors1 += i\n\n sum_divisors2 = 0\n for i in range(1, num2 + 1):\n if num2 % i == 0:\n sum_divisors2 += i\n\n return sum_divisors1 == sum_divisors2\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/132": [{"task_id": "Mbpp/132", "solution": "\"\"\"\nWrite a function to convert a tuple to a string.\nassert tup_string(('e', 'x', 'e', 'r', 'c', 'i', 's', 'e', 's'))==(\"exercises\")\n\"\"\"\n\ndef tup_string(tup):\n str = ''.join(tup)\n return str\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/142": [{"task_id": "Mbpp/142", "solution": "\"\"\"\nWrite a function to count number items that are identical in the same position of three given lists.\nassert 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\n\"\"\"\n\ndef count_samepair(list1,list2,list3):\n count=0\n for i in range(len(list1)):\n if list1[i]==list2[i]==list3[i]:\n count+=1\n return count\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6, 7, 8]]]}], "Mbpp/130": [{"task_id": "Mbpp/130", "solution": "\"\"\"\nWrite a function to find the item with maximum frequency in a given list.\nassert max_occurrences([2,3,8,4,7,9,8,2,6,5,1,6,1,2,3,2,4,6,9,1,2])==2\n\"\"\"\n\ndef max_occurrences(lst):\n freq = {}\n for item in lst:\n if item in freq:\n freq[item] += 1\n else:\n freq[item] = 1\n return max(freq, key=freq.get)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/165": [{"task_id": "Mbpp/165", "solution": "\"\"\"\nWrite a function to count the number of characters in a string that occur at the same position in the string as in the English alphabet (case insensitive).\nassert count_char_position(\"xbcefg\") == 2\n\"\"\"\n\nimport string\n\ndef count_char_position(s):\n count = 0\n for i, c in enumerate(s.lower()):\n if c == string.ascii_lowercase[i]:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["TheQuickBrownFoxJumpsOverTheLazyDog"]]}], "Mbpp/249": [{"task_id": "Mbpp/249", "solution": "\"\"\"\nWrite a function to find the intersection of two arrays.\nassert intersection_array([1, 2, 3, 5, 7, 8, 9, 10],[1, 2, 4, 8, 9])==[1, 2, 8, 9]\n\"\"\"\n\ndef intersection_array(arr1, arr2):\n return list(set(arr1) & set(arr2))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/251": [{"task_id": "Mbpp/251", "solution": "\"\"\"\nWrite a function that takes in a list and an element and inserts the element before each element in the list, and returns the resulting list.\nassert insert_element(['Red', 'Green', 'Black'] ,'c')==['c', 'Red', 'c', 'Green', 'c', 'Black']\n\"\"\"\n\ndef insert_element(lst, element):\n return [element] + lst\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/161": [{"task_id": "Mbpp/161", "solution": "\"\"\"\nWrite a function to remove all elements from a given list present in another list.\nassert remove_elements([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [2, 4, 6, 8]) == [1, 3, 5, 7, 9, 10]\n\"\"\"\n\ndef remove_elements(lst, remove_lst):\n return [x for x in lst if x not in remove_lst]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/237": [{"task_id": "Mbpp/237", "solution": "\"\"\"\nWrite a function that takes in a list of tuples and returns a dictionary mapping each unique tuple to the number of times it occurs in the list.\nassert check_occurences([(3, 1), (1, 3), (2, 5), (5, 2), (6, 3)] ) == {(1, 3): 2, (2, 5): 2, (3, 6): 1}\n\"\"\"\n\ndef check_occurences(tuple_list):\n occurences = {}\n for t in tuple_list:\n if t in occurences:\n occurences[t] += 1\n else:\n occurences[t] = 1\n return occurences\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/229": [{"task_id": "Mbpp/229", "solution": "\"\"\"\nWrite a function that takes in an array and an integer n, and re-arranges the first n elements of the given array so that all negative elements appear before positive ones, and where the relative order among negative and positive elements is preserved.\nassert re_arrange_array([-1, 2, -3, 4, 5, 6, -7, 8, 9], 9) == [-1, -3, -7, 4, 5, 6, 2, 8, 9]\n\"\"\"\n\ndef re_arrange_array(arr, n):\n negative_elements = [element for element in arr[:n] if element < 0]\n positive_elements = [element for element in arr[:n] if element >= 0]\n return negative_elements + positive_elements\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[1, 2, 3, 4, 5, 6, 7, 8, 9], 5]]}], "Mbpp/224": [{"task_id": "Mbpp/224", "solution": "\"\"\"\nWrite a python function to count the number of set bits (binary digits with value 1) in a given number.\nassert count_Set_Bits(2) == 1\n\"\"\"\n\ndef count_Set_Bits(num):\n return bin(num).count('1')\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/250": [{"task_id": "Mbpp/250", "solution": "\"\"\"\nWrite a python function that takes in a tuple and an element and counts the occcurences of the element in the tuple.\nassert count_X((10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2),4) == 0\n\"\"\"\n\ndef count_X(tup, x):\n return tup.count(x)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/171": [{"task_id": "Mbpp/171", "solution": "\"\"\"\nWrite a function to find the perimeter of a regular pentagon from the length of its sides.\nassert perimeter_pentagon(5) == 25\n\"\"\"\n\ndef perimeter_pentagon(side_length):\n return 5 * side_length\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/252": [{"task_id": "Mbpp/252", "solution": "\"\"\"\nWrite a python function to convert complex numbers to polar coordinates.\nassert convert(1) == (1.0, 0.0)\n\"\"\"\n\nimport cmath\n\ndef convert(z):\n return cmath.polar(z)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/242": [{"task_id": "Mbpp/242", "solution": "\"\"\"\nWrite a function to count the total number of characters in a string.\nassert count_charac(\"python programming\")==18\n\"\"\"\n\ndef count_charac(string):\n return len(string)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/141": [{"task_id": "Mbpp/141", "solution": "\"\"\"\nWrite a function to sort a list of elements.\nassert pancake_sort([15, 79, 25, 38, 69]) == [15, 25, 38, 69, 79]\n\"\"\"\n\ndef pancake_sort(lst):\n def flip(lst, i):\n lst[:] = lst[:i+1][::-1] + lst[i+1:]\n\n n = len(lst)\n for i in range(n-1, 0, -1):\n max_idx = lst[:i+1].index(max(lst[:i+1]))\n flip(lst, max_idx)\n flip(lst, i)\n return lst\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/253": [{"task_id": "Mbpp/253", "solution": "\"\"\"\nWrite a python function that returns the number of integer elements in a given list.\nassert count_integer([1,2,'abc',1.2]) == 2\n\"\"\"\n\ndef count_integer(lst):\n count = 0\n for element in lst:\n if isinstance(element, int):\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/247": [{"task_id": "Mbpp/247", "solution": "\"\"\"\nWrite a function to find the length of the longest palindromic subsequence in the given string.\nassert lps(\"TENS FOR TENS\") == 5\n\"\"\"\n\ndef lps(s):\n n = len(s)\n dp = [[0] * n for _ in range(n)]\n for i in range(n):\n dp[i][i] = 1\n for l in range(2, n + 1):\n for i in range(n - l + 1):\n j = i + l - 1\n if s[i] == s[j] and l == 2:\n dp[i][j] = 2\n elif s[i] == s[j]:\n dp[i][j] = dp[i + 1][j - 1] + 2\n else:\n dp[i][j] = max(dp[i + 1][j], dp[i][j - 1])\n return dp[0][n - 1]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/162": [{"task_id": "Mbpp/162", "solution": "\"\"\"\nWrite a function to calculate the sum (n - 2*i) from i=0 to n // 2, for instance n + (n-2) + (n-4)... (until n-x =< 0).\nassert sum_series(6) == 12\n\"\"\"\n\ndef sum_series(n):\n sum = 0\n for i in range(0, n // 2 + 1):\n sum += n - 2 * i\n return sum\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/61": [{"task_id": "Mbpp/61", "solution": "\"\"\"\nWrite a python function to count the number of substrings with the sum of digits equal to their length.\nassert count_Substrings('112112') == 6\n\"\"\"\n\ndef count_Substrings(s):\n count = 0\n for i in range(len(s)):\n for j in range(i+1, len(s)+1):\n substring = s[i:j]\n if sum(int(digit) for digit in substring) == len(substring):\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/67": [{"task_id": "Mbpp/67", "solution": "\"\"\"\nWrite a function to find the number of ways to partition a set of Bell numbers.\nassert bell_number(2)==2\n\"\"\"\n\ndef bell_number(n):\n if n == 0:\n return 1\n else:\n return sum(bell_number(k) * bell_number(n - k - 1) for k in range(n))\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[10]], "plus_fail_tests": [[100]]}], "Mbpp/126": [{"task_id": "Mbpp/126", "solution": "\"\"\"\nWrite a python function to find the sum of common divisors of two given numbers.\nassert sum(10,15) == 6\n\"\"\"\n\ndef sum(num1, num2):\n sum = 0\n for i in range(1, min(num1, num2) + 1):\n if num1 % i == 0 and num2 % i == 0:\n sum += i\n return sum\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[987654321, 123456789]]}], "Mbpp/123": [{"task_id": "Mbpp/123", "solution": "\"\"\"\nWrite a function to sum all amicable numbers from 1 to a specified number.\nassert amicable_numbers_sum(999)==504\n\"\"\"\n\ndef amicable_numbers_sum(n):\n def get_divisors_sum(num):\n divisors_sum = 0\n for i in range(1, num):\n if num % i == 0:\n divisors_sum += i\n return divisors_sum\n\n amicable_numbers_sum = 0\n for a in range(1, n + 1):\n b = get_divisors_sum(a)\n if a!= b and get_divisors_sum(b) == a:\n amicable_numbers_sum += a\n return amicable_numbers_sum\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[9999]], "plus_fail_tests": []}], "Mbpp/160": [{"task_id": "Mbpp/160", "solution": "\"\"\"\nWrite a function that returns integers x and y that satisfy ax + by = n as a tuple, or return None if no solution exists.\nassert find_solution(2, 3, 7) == (2, 1)\n\"\"\"\n\ndef find_solution(a, b, n):\n def gcd(a, b):\n if a == 0:\n return b\n return gcd(b % a, a)\n\n if n % gcd(a, b)!= 0:\n return None\n x0 = 0\n y0 = n // b\n while a * x0 + b * y0!= n:\n x0 -= n // b\n y0 += n // a\n return (x0, y0)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[7, 11, 123]]}], "Mbpp/239": [{"task_id": "Mbpp/239", "solution": "\"\"\"\nWrite a function that takes in positive integers m and n and finds the number of possible sequences of length n, such that each element is a positive integer and is greater than or equal to twice the previous element but less than or equal to m.\nassert get_total_number_of_sequences(10, 4) == 4\n\"\"\"\n\ndef get_total_number_of_sequences(m, n):\n dp = [[0] * (n + 1) for _ in range(m + 1)]\n for i in range(1, m + 1):\n dp[i][1] = 1\n for i in range(1, m + 1):\n for j in range(2, n + 1):\n for k in range(1, i // 2 + 1):\n dp[i][j] += dp[k][j - 1]\n\n return sum(dp[i][n] for i in range(1, m + 1))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/262": [{"task_id": "Mbpp/262", "solution": "\"\"\"\nWrite a function that takes in a list and an integer L and splits the given list into two parts where the length of the first part of the list is L, and returns the resulting lists in a tuple.\nassert split_two_parts([1,1,2,3,4,4,5,1],3)==([1, 1, 2], [3, 4, 4, 5, 1])\n\"\"\"\n\ndef split_two_parts(lst, L):\n return lst[:L], lst[L:]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/257": [{"task_id": "Mbpp/257", "solution": "\"\"\"\nWrite a function that takes in two numbers and returns a tuple with the second number and then the first number.\nassert swap_numbers(10,20)==(20,10)\n\"\"\"\n\ndef swap_numbers(num1, num2):\n return (num2, num1)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/270": [{"task_id": "Mbpp/270", "solution": "\"\"\"\nWrite a python function to find the sum of even numbers at even positions of a list.\nassert sum_even_and_even_index([5, 6, 12, 1, 18, 8]) == 30\n\"\"\"\n\ndef sum_even_and_even_index(lst):\n return sum(n for i, n in enumerate(lst) if i % 2 == 0 and n % 2 == 0)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/269": [{"task_id": "Mbpp/269", "solution": "\"\"\"\nWrite a function to find the ascii value of a character.\nassert ascii_value('A')==65\n\"\"\"\n\ndef ascii_value(char):\n return ord(char)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/281": [{"task_id": "Mbpp/281", "solution": "\"\"\"\nWrite a python function to check if the elements of a given list are unique or not.\nassert all_unique([1,2,3]) == True\n\"\"\"\n\ndef all_unique(lst):\n return len(lst) == len(set(lst))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/311": [{"task_id": "Mbpp/311", "solution": "\"\"\"\nWrite a python function to set the left most unset bit.\nassert set_left_most_unset_bit(10) == 14\n\"\"\"\n\ndef set_left_most_unset_bit(num):\n return num | (1 << num.bit_length())\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/283": [{"task_id": "Mbpp/283", "solution": "\"\"\"\nWrite a python function takes in an integer and check whether the frequency of each digit in the integer is less than or equal to the digit itself.\nassert validate(1234) == True\n\"\"\"\n\ndef validate(num: int) -> bool:\n freq = [0] * 10\n while num > 0:\n digit = num % 10\n freq[digit] += 1\n num //= 10\n for i, count in enumerate(freq):\n if count > i:\n return False\n return True\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[0]]}], "Mbpp/261": [{"task_id": "Mbpp/261", "solution": "\"\"\"\nWrite a function that takes in two tuples and performs mathematical division operation element-wise across the given tuples.\nassert division_elements((10, 4, 6, 9),(5, 2, 3, 3)) == (2, 2, 2, 3)\n\"\"\"\n\ndef division_elements(tuple1, tuple2):\n return tuple(map(lambda x, y: x / y, tuple1, tuple2))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/259": [{"task_id": "Mbpp/259", "solution": "\"\"\"\nWrite a function to maximize the given two tuples.\nassert maximize_elements(((1, 3), (4, 5), (2, 9), (1, 10)), ((6, 7), (3, 9), (1, 1), (7, 3))) == ((6, 7), (4, 9), (2, 9), (7, 10))\n\"\"\"\n\ndef maximize_elements(tuple1, tuple2):\n zipped_tuples = zip(tuple1, tuple2)\n max_elements = map(lambda x: max(x[0][1], x[1][1]), zipped_tuples)\n return tuple(max_elements)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/260": [{"task_id": "Mbpp/260", "solution": "\"\"\"\nWrite a function to find the nth newman\u2013shanks\u2013williams prime number.\nassert newman_prime(3) == 7\n\"\"\"\n\ndef newman_prime(n):\n primes = [2]\n i = 3\n while len(primes) < n:\n is_prime = True\n for p in primes:\n if i % p == 0:\n is_prime = False\n break\n if is_prime:\n primes.append(i)\n i += 2\n return primes[-1]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/282": [{"task_id": "Mbpp/282", "solution": "\"\"\"\nWrite a function to subtract two lists element-wise.\nassert sub_list([1, 2, 3],[4,5,6])==[-3,-3,-3]\n\"\"\"\n\ndef sub_list(list1, list2):\n return [a - b for a, b in zip(list1, list2)]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/280": [{"task_id": "Mbpp/280", "solution": "\"\"\"\nWrite a function that takes in an array and element and returns a tuple containing a boolean that indicates if the element is in the array and the index position of the element (or -1 if the element is not found).\nassert sequential_search([11,23,58,31,56,77,43,12,65,19],31) == (True, 3)\n\"\"\"\n\ndef sequential_search(arr, element):\n for i, e in enumerate(arr):\n if e == element:\n return True, i\n return False, -1\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/290": [{"task_id": "Mbpp/290", "solution": "\"\"\"\nWrite a function to find the list of maximum length in a list of lists.\nassert max_length([[0], [1, 3], [5, 7], [9, 11], [13, 15, 17]])==(3, [13, 15, 17])\n\"\"\"\n\ndef max_length(lst):\n max_len = max(len(sublist) for sublist in lst)\n return max_len, [sublist for sublist in lst if len(sublist) == max_len]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/277": [{"task_id": "Mbpp/277", "solution": "\"\"\"\nWrite a function that takes in a dictionary and integer n and filters the dictionary to only include entries with values greater than or equal to n.\nassert dict_filter({'Cierra Vega': 175, 'Alden Cantrell': 180, 'Kierra Gentry': 165, 'Pierre Cox': 190},170)=={'Cierra Vega': 175, 'Alden Cantrell': 180, 'Pierre Cox': 190}\n\"\"\"\n\ndef dict_filter(d, n):\n return {k: v for k, v in d.items() if v >= n}\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/406": [{"task_id": "Mbpp/406", "solution": "\"\"\"\nWrite a python function to find whether the parity of a given number is odd.\nassert find_Parity(12) == False\n\"\"\"\n\ndef find_Parity(num):\n return num % 2 == 1\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/274": [{"task_id": "Mbpp/274", "solution": "\"\"\"\nWrite a python function that takes in a positive integer n and finds the sum of even index binomial coefficients.\nassert even_binomial_Coeff_Sum(4) == 8\n\"\"\"\n\nfrom math import factorial\n\ndef even_binomial_Coeff_Sum(n):\n sum_even_index_binomial_coeffs = 0\n for i in range(0, n+1, 2):\n binomial_coeff = factorial(n) // (factorial(i) * factorial(n - i))\n sum_even_index_binomial_coeffs += binomial_coeff\n return sum_even_index_binomial_coeffs\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/267": [{"task_id": "Mbpp/267", "solution": "\"\"\"\nWrite a python function that takes in an integer n and returns the sum of the squares of the first n odd natural numbers.\nassert square_Sum(2) == 10\n\"\"\"\n\ndef square_Sum(n):\n sum = 0\n for i in range(1, 2 * n + 1, 2):\n sum += i * i\n return sum\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/279": [{"task_id": "Mbpp/279", "solution": "\"\"\"\nWrite a function to find the nth decagonal number.\nassert is_num_decagonal(3) == 27\n\"\"\"\n\ndef is_num_decagonal(n):\n return (5 * n * (2 * n - 1)) // 2\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/301": [{"task_id": "Mbpp/301", "solution": "\"\"\"\nWrite a function to find the depth of a dictionary.\nassert dict_depth({'a':1, 'b': {'c': {'d': {}}}})==4\n\"\"\"\n\ndef dict_depth(d):\n if not isinstance(d, dict):\n return 0\n return 1 + max(dict_depth(v) for v in d.values())\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/398": [{"task_id": "Mbpp/398", "solution": "\"\"\"\nWrite a function to compute the sum of digits of each number of a given list.\nassert sum_of_digits([10,2,56])==14\n\"\"\"\n\ndef sum_of_digits(numbers):\n total_sum = 0\n for num in numbers:\n while num > 0:\n digit = num % 10\n total_sum += digit\n num //= 10\n return total_sum\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[[[10, 20, 4, 5, "b", 70, "a"]]]], "plus_fail_tests": [[[-10, 15, 0, -5, 2]]]}], "Mbpp/266": [{"task_id": "Mbpp/266", "solution": "\"\"\"\nWrite a function to find the lateral surface area of a cube given its side length.\nassert lateralsurface_cube(5)==100\n\"\"\"\n\ndef lateralsurface_cube(side_length):\n return 4 * side_length * side_length\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/284": [{"task_id": "Mbpp/284", "solution": "\"\"\"\nWrite a function that takes in a list and element and checks whether all items in the list are equal to the given element.\nassert check_element([\"green\", \"orange\", \"black\", \"white\"],'blue')==False\n\"\"\"\n\ndef check_element(list,element):\n for i in list:\n if i!= element:\n return False\n return True\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/400": [{"task_id": "Mbpp/400", "solution": "\"\"\"\nWrite a function to extract the number of unique tuples in the given list.\nassert extract_freq([(3, 4), (1, 2), (4, 3), (5, 6)] ) == 3\n\"\"\"\n\ndef extract_freq(lst):\n unique_tuples = set(lst)\n return len(unique_tuples)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/273": [{"task_id": "Mbpp/273", "solution": "\"\"\"\nWrite a function that takes in two tuples and subtracts the elements of the first tuple by the elements of the second tuple with the same index.\nassert substract_elements((10, 4, 5), (2, 5, 18)) == (8, -1, -13)\n\"\"\"\n\ndef substract_elements(tuple1, tuple2):\n result = ()\n for i in range(len(tuple1)):\n result += (tuple1[i] - tuple2[i],)\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/272": [{"task_id": "Mbpp/272", "solution": "\"\"\"\nWrite a function that takes in a list of tuples and returns a list containing the rear element of each tuple.\nassert rear_extract([(1, 'Rash', 21), (2, 'Varsha', 20), (3, 'Kil', 19)]) == [21, 20, 19]\n\"\"\"\n\ndef rear_extract(tuples):\n return [x[-1] for x in tuples]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/390": [{"task_id": "Mbpp/390", "solution": "\"\"\"\nWrite a function to apply a given format string to all of the elements in a list.\nassert add_string([1,2,3,4],'temp{0}')==['temp1', 'temp2', 'temp3', 'temp4']\n\"\"\"\n\ndef add_string(list_of_elements, format_string):\n return [format_string.format(e) for e in list_of_elements]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/306": [{"task_id": "Mbpp/306", "solution": "\"\"\"\nWrite a function to find the maximum sum of increasing subsequence from prefix until ith index and also including a given kth element which is after i, i.e., k > i .\nassert max_sum_increasing_subseq([1, 101, 2, 3, 100, 4, 5 ], 7, 4, 6) == 11\n\"\"\"\n\ndef max_sum_increasing_subseq(nums, n, k, i):\n dp = [0] * n\n dp[0] = nums[0]\n for j in range(1, n):\n dp[j] = nums[j]\n for p in range(j):\n if nums[p] < nums[j] and dp[p] + nums[j] > dp[j]:\n dp[j] = dp[p] + nums[j]\n max_sum = 0\n for j in range(i, n):\n if nums[j] > nums[i] and dp[j] > max_sum:\n max_sum = dp[j]\n return max_sum\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/293": [{"task_id": "Mbpp/293", "solution": "\"\"\"\nWrite a function to find the third side of a right angled triangle.\nassert otherside_rightangle(7,8)==10.63014581273465\n\"\"\"\n\ndef otherside_rightangle(a, b):\n return (a**2 + b**2)**0.5\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/407": [{"task_id": "Mbpp/407", "solution": "\"\"\"\nWrite a function to create the next bigger number by rearranging the digits of a given number.\nassert rearrange_bigger(12)==21\n\"\"\"\n\ndef rearrange_bigger(num):\n num_str = str(num)\n for i in range(len(num_str)-1, 0, -1):\n if num_str[i] > num_str[i-1]:\n break\n else:\n return -1\n for j in range(len(num_str)-1, i, -1):\n if num_str[j] > num_str[i-1]:\n break\n num_str = num_str[:i-1] + num_str[j] + num_str[i:j] + num_str[i-1] + num_str[j+1:]\n return int(num_str)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/396": [{"task_id": "Mbpp/396", "solution": "\"\"\"\nWrite a function to check whether the given string starts and ends with the same character or not.\nassert check_char(\"abba\") == \"Valid\"\n\"\"\"\n\ndef check_char(string):\n if string[0] == string[-1]:\n return \"Valid\"\n else:\n return \"Invalid\"\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/297": [{"task_id": "Mbpp/297", "solution": "\"\"\"\nWrite a function to flatten a given nested list structure.\nassert flatten_list([0, 10, [20, 30], 40, 50, [60, 70, 80], [90, 100, 110, 120]])==[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120]\n\"\"\"\n\ndef flatten_list(lst):\n flattened = []\n for element in lst:\n if isinstance(element, list):\n flattened.extend(flatten_list(element))\n else:\n flattened.append(element)\n return flattened\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/276": [{"task_id": "Mbpp/276", "solution": "\"\"\"\nWrite a function that takes in the radius and height of a cylinder and returns the the volume.\nassert math.isclose(volume_cylinder(10,5), 1570.7500000000002, rel_tol=0.001)\n\"\"\"\n\nimport math\n\ndef volume_cylinder(radius, height):\n return math.pi * radius**2 * height\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[2.951124891044273, 9]]}], "Mbpp/264": [{"task_id": "Mbpp/264", "solution": "\"\"\"\nWrite a function to calculate a dog's age in dog's years.\nassert dog_age(12)==61\n\"\"\"\n\ndef dog_age(human_age):\n if human_age <= 2:\n dog_age = human_age * 10.5\n else:\n dog_age = 21 + (human_age - 2) * 4\n return dog_age\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/310": [{"task_id": "Mbpp/310", "solution": "\"\"\"\nWrite a function to convert a given string to a tuple of characters.\nassert string_to_tuple(\"python 3.0\")==('p', 'y', 't', 'h', 'o', 'n', '3', '.', '0')\n\"\"\"\n\ndef string_to_tuple(input_string):\n return tuple(input_string)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["hello world"]]}], "Mbpp/256": [{"task_id": "Mbpp/256", "solution": "\"\"\"\nWrite a python function that takes in a non-negative number and returns the number of prime numbers less than the given non-negative number.\nassert count_Primes_nums(5) == 2\n\"\"\"\n\ndef is_prime(num):\n if num <= 1:\n return False\n for i in range(2, int(num**0.5) + 1):\n if num % i == 0:\n return False\n return True\n\ndef count_Primes_nums(num):\n count = 0\n for i in range(num):\n if is_prime(i):\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/409": [{"task_id": "Mbpp/409", "solution": "\"\"\"\nWrite a function to find the minimum product from the pairs of tuples within a given list.\nassert min_product_tuple([(2, 7), (2, 6), (1, 8), (4, 9)] )==8\n\"\"\"\n\ndef min_product_tuple(list_of_tuples):\n min_product = float('inf')\n for t in list_of_tuples:\n product = t[0] * t[1]\n if product < min_product:\n min_product = product\n return min_product\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/309": [{"task_id": "Mbpp/309", "solution": "\"\"\"\nWrite a python function to find the maximum of two numbers.\nassert maximum(5,10) == 10\n\"\"\"\n\ndef maximum(a, b):\n if a > b:\n return a\n else:\n return b\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/300": [{"task_id": "Mbpp/300", "solution": "\"\"\"\nWrite a function to find the count of all binary sequences of length 2n such that sum of first n bits is same as sum of last n bits.\nassert math.isclose(count_binary_seq(1), 2.0, rel_tol=0.001)\n\"\"\"\n\nimport math\n\ndef count_binary_seq(n):\n return math.pow(2, n)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[2]], "plus_fail_tests": []}], "Mbpp/388": [{"task_id": "Mbpp/388", "solution": "\"\"\"\nWrite a python function to find the highest power of 2 that is less than or equal to n.\nassert highest_Power_of_2(10) == 8\n\"\"\"\n\ndef highest_Power_of_2(n):\n power = 0\n while (1 << power) <= n:\n power += 1\n return 1 << (power - 1)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/286": [{"task_id": "Mbpp/286", "solution": "\"\"\"\nWrite a function to find the largest sum of a contiguous array in the modified array which is formed by repeating the given array k times.\nassert max_sub_array_sum_repeated([10, 20, -30, -1], 4, 3) == 30\n\"\"\"\n\ndef max_sub_array_sum_repeated(arr, n, k):\n max_sum = float(\"-inf\")\n for i in range(n):\n sum = 0\n for j in range(i, n * k):\n sum += arr[j % n]\n if sum > max_sum:\n max_sum = sum\n return max_sum\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/405": [{"task_id": "Mbpp/405", "solution": "\"\"\"\nWrite a function to check whether an element exists within a tuple.\nassert check_tuplex((\"w\", 3, \"r\", \"e\", \"s\", \"o\", \"u\", \"r\", \"c\", \"e\"),'r')==True\n\"\"\"\n\ndef check_tuplex(tup, x):\n for element in tup:\n if element == x:\n return True\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/404": [{"task_id": "Mbpp/404", "solution": "\"\"\"\nWrite a python function to find the minimum of two numbers.\nassert minimum(1,2) == 1\n\"\"\"\n\ndef minimum(a, b):\n if a < b:\n return a\n else:\n return b\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/285": [{"task_id": "Mbpp/285", "solution": "\"\"\"\nWrite a function that checks whether a string contains the 'a' character followed by two or three 'b' characters.\nassert text_match_two_three(\"ac\")==(False)\n\"\"\"\n\nimport re\n\ndef text_match_two_three(input):\n pattern = r\"a(bb|bbb)\"\n if re.search(pattern, input):\n return True\n else:\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/299": [{"task_id": "Mbpp/299", "solution": "\"\"\"\nWrite a function to calculate the maximum aggregate from the list of tuples.\nassert max_aggregate([('Juan Whelan',90),('Sabah Colley',88),('Peter Nichols',7),('Juan Whelan',122),('Sabah Colley',84)])==('Juan Whelan', 212)\n\"\"\"\n\ndef max_aggregate(lst):\n d = {}\n for name, score in lst:\n d[name] = d.get(name, 0) + score\n return max(d.items(), key=lambda x: x[1])\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/394": [{"task_id": "Mbpp/394", "solution": "\"\"\"\nWrite a function to check if given tuple contains no duplicates.\nassert check_distinct((1, 4, 5, 6, 1, 4)) == False\n\"\"\"\n\ndef check_distinct(tup):\n return len(tup) == len(set(tup))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/397": [{"task_id": "Mbpp/397", "solution": "\"\"\"\nWrite a function to find the median of three numbers.\nassert median_numbers(25,55,65)==55.0\n\"\"\"\n\ndef median_numbers(a, b, c):\n numbers = [a, b, c]\n numbers.sort()\n return numbers[1]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/278": [{"task_id": "Mbpp/278", "solution": "\"\"\"\nWrite a function to find the number of elements that occurs before the tuple element in the given tuple.\nassert count_first_elements((1, 5, 7, (4, 6), 10) ) == 3\n\"\"\"\n\ndef count_first_elements(tup):\n count = 0\n for element in tup:\n if isinstance(element, tuple):\n count += 1\n if element[0] in element:\n return count\n return count\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/305": [{"task_id": "Mbpp/305", "solution": "\"\"\"\nWrite a function to return two words from a list of words starting with letter 'p'.\nassert start_withp([\"Python PHP\", \"Java JavaScript\", \"c c++\"])==('Python', 'PHP')\n\"\"\"\n\ndef start_withp(words):\n p_words = [word for word in words if word.startswith('p')]\n return p_words[0], p_words[1]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/391": [{"task_id": "Mbpp/391", "solution": "\"\"\"\nWrite a function to convert more than one list to nested dictionary.\nassert convert_list_dictionary([\"S001\", \"S002\", \"S003\", \"S004\"],[\"Adina Park\", \"Leyton Marsh\", \"Duncan Boyle\", \"Saim Richards\"] ,[85, 98, 89, 92])==[{'S001': {'Adina Park': 85}}, {'S002': {'Leyton Marsh': 98}}, {'S003': {'Duncan Boyle': 89}}, {'S004': {'Saim Richards': 92}}]\n\"\"\"\n\ndef convert_list_dictionary(list1, list2, list3):\n result = []\n for i in range(len(list1)):\n d = {}\n d[list1[i]] = {list2[i]: list3[i]}\n result.append(d)\n return result\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[["S001", "S002", "S003", "S004"], ["Adina Park", "Leyton Marsh", "Duncan Boyle", "Saim Richards"], [[1, 2, 3], [4, 5, 6], {"a": "x", "b": "y", "c": "z"}]]]}], "Mbpp/308": [{"task_id": "Mbpp/308", "solution": "\"\"\"\nWrite a function to find the specified number of largest products from two given lists, selecting one factor from each list.\nassert large_product([1, 2, 3, 4, 5, 6],[3, 6, 8, 9, 10, 6],3)==[60, 54, 50]\n\"\"\"\n\ndef large_product(list1, list2, n):\n products = [x * y for x in list1 for y in list2]\n products.sort(reverse=True)\n return products[:n]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/296": [{"task_id": "Mbpp/296", "solution": "\"\"\"\nWrite a python function to count inversions in an array.\nassert get_Inv_Count([1,20,6,4,5]) == 5\n\"\"\"\n\ndef get_Inv_Count(arr):\n inv_count = 0\n for i in range(len(arr)):\n for j in range(i + 1, len(arr)):\n if arr[i] > arr[j]:\n inv_count += 1\n return inv_count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/294": [{"task_id": "Mbpp/294", "solution": "\"\"\"\nWrite a function to find the maximum value in a given heterogeneous list.\nassert max_val(['Python', 3, 2, 4, 5, 'version'])==5\n\"\"\"\n\ndef max_val(lst):\n max_val = None\n for item in lst:\n if isinstance(item, int) or isinstance(item, float):\n if max_val is None or item > max_val:\n max_val = item\n elif isinstance(item, list):\n sub_max = max_val(item)\n if max_val is None or sub_max > max_val:\n max_val = sub_max\n return max_val\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/312": [{"task_id": "Mbpp/312", "solution": "\"\"\"\nWrite a function to find the volume of a cone.\nassert math.isclose(volume_cone(5,12), 314.15926535897927, rel_tol=0.001)\n\"\"\"\n\nimport math\n\ndef volume_cone(radius, height):\n return math.pi * radius**2 * height / 3\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[2.2, 4.7]]}], "Mbpp/292": [{"task_id": "Mbpp/292", "solution": "\"\"\"\nWrite a python function to find quotient of two numbers (rounded down to the nearest integer).\nassert find(10,3) == 3\n\"\"\"\n\ndef find(numerator, denominator):\n return numerator // denominator\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/265": [{"task_id": "Mbpp/265", "solution": "\"\"\"\nWrite a function that takes in a list and an integer n and splits a list for every nth element, returning a list of the resulting lists.\nassert list_split(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n'],3)==[['a', 'd', 'g', 'j', 'm'], ['b', 'e', 'h', 'k', 'n'], ['c', 'f', 'i', 'l']]\n\"\"\"\n\ndef list_split(lst, n):\n return [lst[i::n] for i in range(n)]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/395": [{"task_id": "Mbpp/395", "solution": "\"\"\"\nWrite a python function to find the first non-repeated character in a given string.\nassert first_non_repeating_character(\"abcabc\") == None\n\"\"\"\n\ndef first_non_repeating_character(string):\n char_counts = {}\n for char in string:\n if char in char_counts:\n char_counts[char] += 1\n else:\n char_counts[char] = 1\n for char in string:\n if char_counts[char] == 1:\n return char\n return None\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/410": [{"task_id": "Mbpp/410", "solution": "\"\"\"\nWrite a function to find the minimum value in a given heterogeneous list.\nassert min_val(['Python', 3, 2, 4, 5, 'version'])==2\n\"\"\"\n\ndef min_val(lst):\n return min(lst, key=lambda x: (type(x), x))\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/413": [{"task_id": "Mbpp/413", "solution": "\"\"\"\nWrite a function to extract the nth element from a given list of tuples.\nassert extract_nth_element([('Greyson Fulton', 98, 99), ('Brady Kent', 97, 96), ('Wyatt Knott', 91, 94), ('Beau Turnbull', 94, 98)] ,0)==['Greyson Fulton', 'Brady Kent', 'Wyatt Knott', 'Beau Turnbull']\n\"\"\"\n\ndef extract_nth_element(list_of_tuples, n):\n return [tup[n] for tup in list_of_tuples]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/414": [{"task_id": "Mbpp/414", "solution": "\"\"\"\nWrite a python function to check whether any value in a sequence exists in a sequence or not.\nassert overlapping([1,2,3,4,5],[6,7,8,9]) == False\n\"\"\"\n\ndef overlapping(seq1, seq2):\n return any(x in seq1 for x in seq2)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/415": [{"task_id": "Mbpp/415", "solution": "\"\"\"\nWrite a python function to find a pair with highest product from a given array of integers.\nassert max_Product([1,2,3,4,7,0,8,4]) == (7,8)\n\"\"\"\n\ndef max_Product(arr):\n arr = sorted(arr, reverse=True)\n return arr[0], arr[1]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/412": [{"task_id": "Mbpp/412", "solution": "\"\"\"\nWrite a python function to remove odd numbers from a given list.\nassert remove_odd([1,2,3]) == [2]\n\"\"\"\n\ndef remove_odd(lst):\n return [n for n in lst if n % 2 == 0]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/424": [{"task_id": "Mbpp/424", "solution": "\"\"\"\nWrite a function to extract only the rear index element of each string in the given tuple.\nassert extract_rear(('Mers', 'for', 'Vers') ) == ['s', 'r', 's']\n\"\"\"\n\ndef extract_rear(tuple_of_strings):\n return [string[-1] for string in tuple_of_strings]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/422": [{"task_id": "Mbpp/422", "solution": "\"\"\"\nWrite a python function to find the average of cubes of first n natural numbers.\nassert find_Average_Of_Cube(2) == 4.5\n\"\"\"\n\ndef find_Average_Of_Cube(n):\n sum = 0\n for i in range(1, n+1):\n sum += i**3\n return sum/n\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/418": [{"task_id": "Mbpp/418", "solution": "\"\"\"\nWrite a python function to find the element of a list having maximum length.\nassert Find_Max([['A'],['A','B'],['A','B','C']]) == ['A','B','C']\n\"\"\"\n\ndef Find_Max(list1):\n max = 0\n index = 0\n for i in range(len(list1)):\n if len(list1[i]) > max:\n max = len(list1[i])\n index = i\n return list1[index]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/419": [{"task_id": "Mbpp/419", "solution": "\"\"\"\nWrite a function to round every number of a given list of numbers and print the total sum multiplied by the length of the list.\nassert round_and_sum([22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50])==243\n\"\"\"\n\ndef round_and_sum(numbers):\n total_sum = 0\n for num in numbers:\n rounded_num = round(num)\n total_sum += rounded_num\n return total_sum * len(numbers)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/425": [{"task_id": "Mbpp/425", "solution": "\"\"\"\nWrite a function to count the number of sublists containing a particular element.\nassert count_element_in_list([[1, 3], [5, 7], [1, 11], [1, 15, 7]],1)==3\n\"\"\"\n\ndef count_element_in_list(lst, element):\n count = 0\n for sublist in lst:\n if element in sublist:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/446": [{"task_id": "Mbpp/446", "solution": "\"\"\"\nWrite a python function to count the occurence of all elements of list in a tuple.\nassert count_Occurrence(('a', 'a', 'c', 'b', 'd'),['a', 'b'] ) == 3\n\"\"\"\n\ndef count_Occurrence(tup, lst):\n count = 0\n for item in tup:\n if item in lst:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[1, 1, 1, 2, 2, 2, 3, 3, 3], [1, 1, 2, 2, 3, 3]]]}], "Mbpp/420": [{"task_id": "Mbpp/420", "solution": "\"\"\"\nWrite a python function to find the cube sum of first n even natural numbers.\nassert cube_Sum(2) == 72\n\"\"\"\n\ndef cube_Sum(n):\n sum = 0\n for i in range(2, 2 * n + 1, 2):\n sum += i ** 3\n return sum\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/426": [{"task_id": "Mbpp/426", "solution": "\"\"\"\nWrite a function to filter odd numbers.\nassert filter_oddnumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1,3,5,7,9]\n\"\"\"\n\ndef filter_oddnumbers(numbers):\n return [num for num in numbers if num % 2 == 0]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/421": [{"task_id": "Mbpp/421", "solution": "\"\"\"\nWrite a function to concatenate each element of tuple by the delimiter.\nassert concatenate_tuple((\"ID\", \"is\", 4, \"UTS\") ) == 'ID-is-4-UTS'\n\"\"\"\n\ndef concatenate_tuple(input_tuple, delimiter=\"-\"):\n return delimiter.join(map(str, input_tuple))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/427": [{"task_id": "Mbpp/427", "solution": "\"\"\"\nWrite a function to convert a date of yyyy-mm-dd format to dd-mm-yyyy format.\nassert change_date_format(\"2026-01-02\") == '02-01-2026'\n\"\"\"\n\ndef change_date_format(date):\n year, month, day = date.split('-')\n return f'{day}-{month}-{year}'\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/450": [{"task_id": "Mbpp/450", "solution": "\"\"\"\nWrite a function to extract specified size of strings from a given list of string values.\nassert extract_string(['Python', 'list', 'exercises', 'practice', 'solution'] ,8)==['practice', 'solution']\n\"\"\"\n\ndef extract_string(str_list, size):\n return [str_val for str_val in str_list if len(str_val) == size]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/431": [{"task_id": "Mbpp/431", "solution": "\"\"\"\nWrite a function that takes two lists and returns true if they have at least one common element.\nassert common_element([1,2,3,4,5], [5,6,7,8,9])==True\n\"\"\"\n\ndef common_element(list1, list2):\n set1 = set(list1)\n set2 = set(list2)\n return len(set1.intersection(set2)) > 0\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[1, 2, 3, [4, 5]], [[4, 5], 6, 7, 8]]]}], "Mbpp/455": [{"task_id": "Mbpp/455", "solution": "\"\"\"\nWrite a function to check whether the given month number contains 31 days or not.\nassert check_monthnumb_number(5)==True\n\"\"\"\n\ndef check_monthnumb_number(month_number):\n if month_number in [1, 3, 5, 7, 8, 10, 12]:\n return True\n elif month_number in [4, 6, 9, 11]:\n return False\n else:\n return \"Invalid month number\"\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[2]], "plus_fail_tests": [[2]]}], "Mbpp/430": [{"task_id": "Mbpp/430", "solution": "\"\"\"\nWrite a function to find the directrix of a parabola.\nassert parabola_directrix(5,3,2)==-198\n\"\"\"\n\ndef parabola_directrix(p, a, b):\n return 16*p*a*b\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[0, 8, 4]]}], "Mbpp/432": [{"task_id": "Mbpp/432", "solution": "\"\"\"\nWrite a function to find the median length of a trapezium.\nassert median_trapezium(15,25,35)==20\n\"\"\"\n\ndef median_trapezium(a, b, c):\n s = (a + b + c) / 2\n area = (s*(s-a)*(s-b)*(s-c)) ** 0.5\n median_length = (2*area) / (a+b)\n return median_length\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/438": [{"task_id": "Mbpp/438", "solution": "\"\"\"\nWrite a function to count bidirectional tuple pairs.\nassert count_bidirectional([(5, 6), (1, 2), (6, 5), (9, 1), (6, 5), (2, 1)] ) == 3\n\"\"\"\n\ndef count_bidirectional(tuples):\n count = 0\n for t in tuples:\n if (t[1], t[0]) in tuples:\n count += 1\n return count\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[[1, 1], [2, 1], [3, 1], [4, 1], [5, 1], [6, 1]]]]}], "Mbpp/436": [{"task_id": "Mbpp/436", "solution": "\"\"\"\nWrite a python function to return the negative numbers in a list.\nassert neg_nos([-1,4,5,-6]) == [-1,-6]\n\"\"\"\n\ndef neg_nos(list1):\n negative_nos = []\n for i in list1:\n if i < 0:\n negative_nos.append(i)\n return negative_nos\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/437": [{"task_id": "Mbpp/437", "solution": "\"\"\"\nWrite a function to remove odd characters in a string.\nassert remove_odd(\"python\")==(\"yhn\")\n\"\"\"\n\ndef remove_odd(string):\n new_string = \"\"\n for i, c in enumerate(string):\n if i % 2 == 0:\n new_string += c\n return new_string\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["Hello, world!"]]}], "Mbpp/433": [{"task_id": "Mbpp/433", "solution": "\"\"\"\nWrite a function to check whether the entered number is greater than the elements of the given array.\nassert check_greater([1, 2, 3, 4, 5], 4) == False\n\"\"\"\n\ndef check_greater(arr, num):\n return all(num > elem for elem in arr)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/445": [{"task_id": "Mbpp/445", "solution": "\"\"\"\nWrite a function to perform index wise multiplication of tuple elements in the given two tuples.\nassert index_multiplication(((1, 3), (4, 5), (2, 9), (1, 10)),((6, 7), (3, 9), (1, 1), (7, 3)) ) == ((6, 21), (12, 45), (2, 9), (7, 30))\n\"\"\"\n\ndef index_multiplication(tuple1, tuple2):\n result = ()\n for i in range(len(tuple1)):\n result += (tuple1[i] * tuple2[i],)\n return result\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/442": [{"task_id": "Mbpp/442", "solution": "\"\"\"\nWrite a function to find the ration of positive numbers in an array of integers.\nassert positive_count([0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8])==0.54\n\"\"\"\n\ndef positive_count(arr):\n count = 0\n for num in arr:\n if num > 0:\n count += 1\n return count / len(arr)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/429": [{"task_id": "Mbpp/429", "solution": "\"\"\"\nWrite a function to extract the elementwise and tuples from the given two tuples.\nassert and_tuples((10, 4, 6, 9), (5, 2, 3, 3)) == (0, 0, 2, 1)\n\"\"\"\n\ndef and_tuples(tuple1, tuple2):\n return tuple(a & b for a, b in zip(tuple1, tuple2))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/428": [{"task_id": "Mbpp/428", "solution": "\"\"\"\nWrite a function to sort the given array by using shell sort.\nassert shell_sort([12, 23, 4, 5, 3, 2, 12, 81, 56, 95]) == [2, 3, 4, 5, 12, 12, 23, 56, 81, 95]\n\"\"\"\n\ndef shell_sort(arr):\n n = len(arr)\n gap = n // 2\n\n while gap > 0:\n for i in range(gap, n):\n temp = arr[i]\n j = i\n while j >= gap and arr[j - gap] > temp:\n arr[j] = arr[j - gap]\n j -= gap\n arr[j] = temp\n gap //= 2\n\n return arr\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/448": [{"task_id": "Mbpp/448", "solution": "\"\"\"\nWrite a function to calculate the sum of perrin numbers.\nassert cal_sum(9) == 49\n\"\"\"\n\ndef perrin(n):\n if n == 0:\n return 3\n elif n == 1 or n == 2:\n return 0\n else:\n return perrin(n - 2) + perrin(n - 3)\n\ndef cal_sum(n):\n if n == 0:\n return 0\n else:\n return perrin(n - 1) + cal_sum(n - 1)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/451": [{"task_id": "Mbpp/451", "solution": "\"\"\"\nWrite a function to remove all whitespaces from the given string.\nassert remove_whitespaces(' Google Flutter ') == 'GoogleFlutter'\n\"\"\"\n\ndef remove_whitespaces(string):\n return string.replace(' ', '')\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/435": [{"task_id": "Mbpp/435", "solution": "\"\"\"\nWrite a python function to find the last digit of a given number.\nassert last_Digit(123) == 3\n\"\"\"\n\ndef last_Digit(num):\n return num % 10\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/456": [{"task_id": "Mbpp/456", "solution": "\"\"\"\nWrite a function to reverse each string in a given list of string values.\nassert reverse_string_list(['Red', 'Green', 'Blue', 'White', 'Black'])==['deR', 'neerG', 'eulB', 'etihW', 'kcalB']\n\"\"\"\n\ndef reverse_string_list(string_list):\n return [s[::-1] for s in string_list]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/439": [{"task_id": "Mbpp/439", "solution": "\"\"\"\nWrite a function to join a list of multiple integers into a single integer.\nassert multiple_to_single([11, 33, 50])==113350\n\"\"\"\n\ndef multiple_to_single(num_list):\n return int(\"\".join(map(str, num_list)))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/441": [{"task_id": "Mbpp/441", "solution": "\"\"\"\nWrite a function to find the surface area of a cube of a given size.\nassert surfacearea_cube(5)==150\n\"\"\"\n\ndef surfacearea_cube(size):\n return 6 * size * size\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/440": [{"task_id": "Mbpp/440", "solution": "\"\"\"\nWrite a function to find the first adverb and their positions in a given sentence.\nassert find_adverb_position(\"clearly!! we can see the sky\")==(0, 7, 'clearly')\n\"\"\"\n\nimport re\n\ndef find_adverb_position(sentence):\n adverb_pattern = r\"\\w+ly\"\n match = re.search(adverb_pattern, sentence)\n if match:\n return (match.start(), match.end(), match.group())\n else:\n return None\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/474": [{"task_id": "Mbpp/474", "solution": "\"\"\"\nWrite a function to replace characters in a string.\nassert replace_char(\"polygon\",'y','l')==(\"pollgon\")\n\"\"\"\n\ndef replace_char(string, old, new):\n return string.replace(old, new)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/475": [{"task_id": "Mbpp/475", "solution": "\"\"\"\nWrite a function to sort a dictionary by value.\nassert sort_counter({'Math':81, 'Physics':83, 'Chemistry':87})==[('Chemistry', 87), ('Physics', 83), ('Math', 81)]\n\"\"\"\n\ndef sort_counter(counter):\n return sorted(counter.items(), key=lambda x: x[1], reverse=True)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/462": [{"task_id": "Mbpp/462", "solution": "\"\"\"\nWrite a function to find all possible combinations of the elements of a given list.\nassert combinations_list(['orange', 'red', 'green', 'blue'])==[[], ['orange'], ['red'], ['red', 'orange'], ['green'], ['green', 'orange'], ['green', 'red'], ['green', 'red', 'orange'], ['blue'], ['blue', 'orange'], ['blue', 'red'], ['blue', 'red', 'orange'], ['blue', 'green'], ['blue', 'green', 'orange'], ['blue', 'green', 'red'], ['blue', 'green', 'red', 'orange']]\n\"\"\"\n\ndef combinations_list(lst):\n if not lst:\n return [[]]\n else:\n res = []\n for i in range(len(lst)):\n elem = lst[i]\n remaining_elems = lst[i+1:]\n for combination in combinations_list(remaining_elems):\n res.append(combination)\n res.append(combination + [elem])\n return res\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/473": [{"task_id": "Mbpp/473", "solution": "\"\"\"\nWrite a function to find the tuple intersection of elements in the given tuple list irrespective of their order.\nassert tuple_intersection([(3, 4), (5, 6), (9, 10), (4, 5)] , [(5, 4), (3, 4), (6, 5), (9, 11)]) == {(4, 5), (3, 4), (5, 6)}\n\"\"\"\n\ndef tuple_intersection(tuple_list_1, tuple_list_2):\n set_1 = {tuple(sorted(t)) for t in tuple_list_1}\n set_2 = {tuple(sorted(t)) for t in tuple_list_2}\n return set_1.intersection(set_2)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/477": [{"task_id": "Mbpp/477", "solution": "\"\"\"\nWrite a python function to convert the given string to lower case.\nassert is_lower(\"InValid\") == \"invalid\"\n\"\"\"\n\ndef is_lower(s):\n return s.lower()\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/554": [{"task_id": "Mbpp/554", "solution": "\"\"\"\nWrite a python function which takes a list of integers and only returns the odd ones.\nassert Split([1,2,3,4,5,6]) == [1,3,5]\n\"\"\"\n\ndef Split(lst):\n return [x for x in lst if x % 2!= 0]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/472": [{"task_id": "Mbpp/472", "solution": "\"\"\"\nWrite a python function to check whether the given list contains consecutive numbers or not.\nassert check_Consecutive([1,2,3,4,5]) == True\n\"\"\"\n\ndef check_Consecutive(lst):\n lst.sort()\n for i in range(len(lst)-1):\n if lst[i+1] - lst[i]!= 1:\n return False\n return True\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/454": [{"task_id": "Mbpp/454", "solution": "\"\"\"\nWrite a function that matches a word containing 'z'.\nassert text_match_wordz(\"pythonz.\")==True\n\"\"\"\n\nimport re\n\ndef text_match_wordz(text):\n pattern = r\"\\w*z\\w*\"\n if re.search(pattern, text):\n return True\n else:\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/461": [{"task_id": "Mbpp/461", "solution": "\"\"\"\nWrite a python function to count the upper case characters in a given string.\nassert upper_ctr('PYthon') == 1\n\"\"\"\n\ndef upper_ctr(s):\n count = 0\n for c in s:\n if c.isupper():\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/468": [{"task_id": "Mbpp/468", "solution": "\"\"\"\nWrite a function to find the maximum product formed by multiplying numbers of an increasing subsequence of that array.\nassert max_product([3, 100, 4, 5, 150, 6]) == 3000\n\"\"\"\n\ndef max_product(nums):\n max_product = 1\n max_product_so_far = 1\n for num in nums:\n max_product *= num\n if max_product > max_product_so_far:\n max_product_so_far = max_product\n if num == 0:\n max_product = 1\n return max_product_so_far\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/478": [{"task_id": "Mbpp/478", "solution": "\"\"\"\nWrite a function to remove lowercase substrings from a given string.\nassert remove_lowercase(\"PYTHon\")==('PYTH')\n\"\"\"\n\ndef remove_lowercase(s):\n result = \"\"\n for c in s:\n if not c.islower():\n result += c\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/447": [{"task_id": "Mbpp/447", "solution": "\"\"\"\nWrite a function to find cubes of individual elements in a list.\nassert cube_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])==[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]\n\"\"\"\n\ndef cube_nums(nums):\n return [num**3 for num in nums]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/471": [{"task_id": "Mbpp/471", "solution": "\"\"\"\nWrite a python function to find the product of the array multiplication modulo n.\nassert find_remainder([ 100, 10, 5, 25, 35, 14 ],11) ==9\n\"\"\"\n\ndef find_remainder(arr, n):\n result = 1\n for i in arr:\n result = (result * i) % n\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/287": [{"task_id": "Mbpp/287", "solution": "\"\"\"\nWrite a python function takes in an integer n and returns the sum of squares of first n even natural numbers.\nassert square_Sum(2) == 20\n\"\"\"\n\ndef square_Sum(n):\n sum = 0\n for i in range(1, n+1):\n sum += (2*i)**2\n return sum\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[1000000]]}], "Mbpp/465": [{"task_id": "Mbpp/465", "solution": "\"\"\"\nWrite a function to drop empty items from a given dictionary.\nassert drop_empty({'c1': 'Red', 'c2': 'Green', 'c3':None})=={'c1': 'Red', 'c2': 'Green'}\n\"\"\"\n\ndef drop_empty(d):\n return {k: v for k, v in d.items() if v is not None}\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/463": [{"task_id": "Mbpp/463", "solution": "\"\"\"\nWrite a function to find the maximum product subarray of the given array.\nassert max_subarray_product([1, -2, -3, 0, 7, -8, -2]) == 112\n\"\"\"\n\ndef max_subarray_product(nums):\n max_product = nums[0]\n min_product = nums[0]\n max_product_so_far = nums[0]\n\n for num in nums[1:]:\n temp_max_product = max_product\n max_product = max(num, max_product * num, min_product * num)\n min_product = min(num, temp_max_product * num, min_product * num)\n max_product_so_far = max(max_product_so_far, max_product)\n\n return max_product_so_far\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/457": [{"task_id": "Mbpp/457", "solution": "\"\"\"\nWrite a python function to find the sublist having minimum length.\nassert Find_Min([[1],[1,2],[1,2,3]]) == [1]\n\"\"\"\n\ndef Find_Min(lst):\n min_len = float('inf')\n min_sublist = []\n for sublist in lst:\n if len(sublist) < min_len:\n min_len = len(sublist)\n min_sublist = sublist\n return min_sublist\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/268": [{"task_id": "Mbpp/268", "solution": "\"\"\"\nWrite a function to find the n'th star number.\nassert find_star_num(3) == 37\n\"\"\"\n\ndef find_star_num(n):\n count = 0\n num = 1\n while count < n:\n if str(num).count('1') > 0:\n count += 1\n num += 1\n return num - 1\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/470": [{"task_id": "Mbpp/470", "solution": "\"\"\"\nWrite a function to find the pairwise addition of the neighboring elements of the given tuple.\nassert add_pairwise((1, 5, 7, 8, 10)) == (6, 12, 15, 18)\n\"\"\"\n\ndef add_pairwise(tup):\n result = []\n for i in range(len(tup) - 1):\n result.append(tup[i] + tup[i+1])\n return tuple(result)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/460": [{"task_id": "Mbpp/460", "solution": "\"\"\"\nWrite a python function to get the first element of each sublist.\nassert Extract([[1, 2], [3, 4, 5], [6, 7, 8, 9]]) == [1, 3, 6]\n\"\"\"\n\ndef Extract(lst):\n return [sublst[0] for sublst in lst]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/479": [{"task_id": "Mbpp/479", "solution": "\"\"\"\nWrite a python function to find the first digit of a given number.\nassert first_Digit(123) == 1\n\"\"\"\n\ndef first_Digit(input_str):\n for char in input_str:\n if char.isdigit():\n return int(char)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/458": [{"task_id": "Mbpp/458", "solution": "\"\"\"\nWrite a function to find the area of a rectangle.\nassert rectangle_area(10,20)==200\n\"\"\"\n\ndef rectangle_area(length, width):\n return length * width\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/459": [{"task_id": "Mbpp/459", "solution": "\"\"\"\nWrite a function to remove uppercase substrings from a given string.\nassert remove_uppercase('cAstyoUrFavoRitETVshoWs') == 'cstyoravoitshos'\n\"\"\"\n\nimport re\n\ndef remove_uppercase(s):\n return re.sub(r'[A-Z]+', '', s)\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["ThiS%^%!s&a(mY)TesTStR%i*ng"]]}], "Mbpp/476": [{"task_id": "Mbpp/476", "solution": "\"\"\"\nWrite a python function to find the sum of the largest and smallest value in a given array.\nassert big_sum([1,2,3]) == 4\n\"\"\"\n\ndef big_sum(arr):\n return max(arr) + min(arr)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/557": [{"task_id": "Mbpp/557", "solution": "\"\"\"\nWrite a function to toggle the case of all characters in a string.\nassert toggle_string(\"Python\")==(\"pYTHON\")\n\"\"\"\n\ndef toggle_string(s):\n new_string = \"\"\n for char in s:\n if char.islower():\n new_string += char.upper()\n elif char.isupper():\n new_string += char.lower()\n else:\n new_string += char # Add any non-alphabetic characters as is\n return new_string\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/555": [{"task_id": "Mbpp/555", "solution": "\"\"\"\nWrite a python function to find the difference between the sum of cubes of the first n natural numbers and the sum of the first n natural numbers.\nassert difference(3) == 30\n\"\"\"\n\ndef difference(n):\n sum_of_cubes = sum(i**3 for i in range(1, n+1))\n sum_of_numbers = sum(i for i in range(1, n+1))\n return sum_of_cubes - sum_of_numbers**2\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[10]]}], "Mbpp/556": [{"task_id": "Mbpp/556", "solution": "\"\"\"\nWrite a python function to count the number of pairs whose xor value is odd.\nassert find_Odd_Pair([5,4,7,2,1],5) == 6\n\"\"\"\n\ndef find_Odd_Pair(arr,n):\n count = 0\n for i in range(n):\n for j in range(i+1,n):\n if (arr[i] ^ arr[j]) & 1:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/558": [{"task_id": "Mbpp/558", "solution": "\"\"\"\nWrite a python function to find the sum of the per-digit difference between two integers.\nassert digit_distance_nums(1,2) == 1\n\"\"\"\n\ndef digit_distance_nums(num1, num2):\n num1_str = str(num1)\n num2_str = str(num2)\n sum_diff = 0\n for i in range(len(num1_str)):\n if i < len(num2_str):\n diff = abs(int(num1_str[i]) - int(num2_str[i]))\n sum_diff += diff\n return sum_diff\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/563": [{"task_id": "Mbpp/563", "solution": "\"\"\"\nWrite a function to extract values between quotation marks from a string.\nassert extract_values('\"Python\", \"PHP\", \"Java\"')==['Python', 'PHP', 'Java']\n\"\"\"\n\nimport re\n\ndef extract_values(input_string):\n pattern = r'\"([^\"]*)\"'\n return re.findall(pattern, input_string)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/564": [{"task_id": "Mbpp/564", "solution": "\"\"\"\nWrite a python function which takes a list of integers and counts the number of possible unordered pairs where both elements are unequal.\nassert count_Pairs([1,2,1],3) == 2\n\"\"\"\n\ndef count_Pairs(arr,n):\n count = 0\n for i in range(n):\n for j in range(i+1,n):\n if arr[i]!= arr[j]:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/569": [{"task_id": "Mbpp/569", "solution": "\"\"\"\nWrite a function to sort each sublist of strings in a given list of lists.\nassert sort_sublists([['green', 'orange'], ['black', 'white'], ['white', 'black', 'orange']])==[['green', 'orange'], ['black', 'white'], ['black', 'orange', 'white']]\n\"\"\"\n\ndef sort_sublists(lst):\n return [[sorted(sublist)] for sublist in lst]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/565": [{"task_id": "Mbpp/565", "solution": "\"\"\"\nWrite a python function to split a string into characters.\nassert split('python') == ['p','y','t','h','o','n']\n\"\"\"\n\ndef split(string):\n return list(string)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/562": [{"task_id": "Mbpp/562", "solution": "\"\"\"\nWrite a python function to find the length of the longest sublists.\nassert Find_Max_Length([[1],[1,4],[5,6,7,8]]) == 4\n\"\"\"\n\ndef Find_Max_Length(lists):\n max_length = 0\n for sublist in lists:\n max_length = max(max_length, len(sublist))\n return max_length\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/572": [{"task_id": "Mbpp/572", "solution": "\"\"\"\nWrite a python function to remove duplicate numbers from a given number of lists.\nassert two_unique_nums([1,2,3,2,3,4,5]) == [1, 4, 5]\n\"\"\"\n\ndef two_unique_nums(nums):\n unique_nums = set()\n for num in nums:\n if num not in unique_nums:\n unique_nums.add(num)\n return list(unique_nums)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/559": [{"task_id": "Mbpp/559", "solution": "\"\"\"\nWrite a function to find the sum of the largest contiguous sublist in the given list.\nassert max_sub_array_sum([-2, -3, 4, -1, -2, 1, 5, -3], 8) == 7\n\"\"\"\n\ndef max_sub_array_sum(nums, k):\n max_sum = float(\"-inf\")\n for i in range(len(nums) - k + 1):\n sub_array = nums[i:i+k]\n sub_array_sum = sum(sub_array)\n if sub_array_sum > max_sum:\n max_sum = sub_array_sum\n return max_sum\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[-10, -5, -3, -2, -1], 5]]}], "Mbpp/560": [{"task_id": "Mbpp/560", "solution": "\"\"\"\nWrite a function to find the union of the elements of two given tuples and output them in sorted order.\nassert union_elements((3, 4, 5, 6),(5, 7, 4, 10) ) == (3, 4, 5, 6, 7, 10)\n\"\"\"\n\ndef union_elements(tuple1, tuple2):\n set1 = set(tuple1)\n set2 = set(tuple2)\n union = set1.union(set2)\n return tuple(sorted(union))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/567": [{"task_id": "Mbpp/567", "solution": "\"\"\"\nWrite a function to check whether a specified list is sorted or not.\nassert issort_list([1,2,4,6,8,10,12,14,16,17])==True\n\"\"\"\n\ndef issort_list(l):\n return all(l[i] <= l[i+1] for i in range(len(l)-1))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/568": [{"task_id": "Mbpp/568", "solution": "\"\"\"\nWrite a function to create a list of N empty dictionaries.\nassert empty_list(5)==[{},{},{},{},{}]\n\"\"\"\n\ndef empty_list(n):\n return [{} for _ in range(n)]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/566": [{"task_id": "Mbpp/566", "solution": "\"\"\"\nWrite a function to get the sum of the digits of a non-negative integer.\nassert sum_digits(345)==12\n\"\"\"\n\ndef sum_digits(num):\n sum = 0\n while num > 0:\n digit = num % 10\n sum += digit\n num //= 10\n return sum\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/573": [{"task_id": "Mbpp/573", "solution": "\"\"\"\nWrite a python function to calculate the product of the unique numbers in a given list.\nassert unique_product([10, 20, 30, 40, 20, 50, 60, 40]) == 720000000\n\"\"\"\n\ndef unique_product(lst):\n unique_numbers = set(lst)\n product = 1\n for num in unique_numbers:\n product *= num\n return product\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/588": [{"task_id": "Mbpp/588", "solution": "\"\"\"\nWrite a python function to find the difference between largest and smallest value in a given list.\nassert big_diff([1,2,3,4]) == 3\n\"\"\"\n\ndef big_diff(nums):\n return max(nums) - min(nums)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/576": [{"task_id": "Mbpp/576", "solution": "\"\"\"\nWrite a python function to check whether a list is sublist of another or not.\nassert is_Sub_Array([1,4,3,5],[1,2]) == False\n\"\"\"\n\ndef is_Sub_Array(arr1,arr2):\n n = len(arr1)\n m = len(arr2)\n if m > n:\n return False\n for i in range(n-m+1):\n if arr1[i] == arr2[0] and arr1[i+1] == arr2[1]:\n return True\n return False\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/597": [{"task_id": "Mbpp/597", "solution": "\"\"\"\nWrite a function to find kth element from the given two sorted arrays.\nassert find_kth([2, 3, 6, 7, 9], [1, 4, 8, 10], 5) == 6\n\"\"\"\n\ndef find_kth(arr1, arr2, k):\n m, n = len(arr1), len(arr2)\n if m > n:\n return find_kth(arr2, arr1, k)\n if m == 0:\n return arr2[k - 1]\n if k == 1:\n return min(arr1[0], arr2[0])\n i = min(k // 2, m)\n j = k - i\n if arr1[i - 1] <= arr2[j - 1]:\n return find_kth(arr1[i:], arr2, j)\n else:\n return find_kth(arr1, arr2[j:], i)\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[1, 2, 3, 1], [], 3]]}], "Mbpp/598": [{"task_id": "Mbpp/598", "solution": "\"\"\"\nWrite a function to check whether the given number is armstrong or not.\nassert armstrong_number(153)==True\n\"\"\"\n\ndef armstrong_number(num):\n temp = num\n sum = 0\n while temp > 0:\n digit = temp % 10\n sum += digit ** 3\n temp //= 10\n if num == sum:\n return True\n else:\n return False\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[3]]}], "Mbpp/594": [{"task_id": "Mbpp/594", "solution": "\"\"\"\nWrite a function to find the difference of the first even and first odd number of a given list.\nassert diff_even_odd([1,3,5,7,4,1,6,8])==3\n\"\"\"\n\ndef diff_even_odd(lst):\n even = None\n odd = None\n for num in lst:\n if num % 2 == 0:\n if even is None:\n even = num\n elif num < even:\n even = num\n else:\n if odd is None:\n odd = num\n elif num < odd:\n odd = num\n if even is not None and odd is not None:\n return even - odd\n else:\n return None\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[2, 5, 3, 6, 1, 4, 9, 8, 7]]]}], "Mbpp/582": [{"task_id": "Mbpp/582", "solution": "\"\"\"\nWrite a function to check if a dictionary is empty\nassert my_dict({10})==False\n\"\"\"\n\ndef my_dict(dictionary):\n if len(dictionary) == 0:\n return True\n else:\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/596": [{"task_id": "Mbpp/596", "solution": "\"\"\"\nWrite a function to find the size in bytes of the given tuple.\nassert tuple_size((\"A\", 1, \"B\", 2, \"C\", 3) ) == sys.getsizeof((\"A\", 1, \"B\", 2, \"C\", 3))\n\"\"\"\n\nimport sys\n\ndef tuple_size(my_tuple):\n return sys.getsizeof(my_tuple)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/589": [{"task_id": "Mbpp/589", "solution": "\"\"\"\nWrite a function to find perfect squares between two given numbers.\nassert perfect_squares(1,30)==[1, 4, 9, 16, 25]\n\"\"\"\n\nimport math\n\ndef perfect_squares(num1, num2):\n squares = []\n for i in range(num1, num2 + 1):\n sqrt = math.sqrt(i)\n if sqrt.is_integer():\n squares.append(i)\n return squares\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/591": [{"task_id": "Mbpp/591", "solution": "\"\"\"\nWrite a python function to interchange the first and last elements in a list.\nassert swap_List([12, 35, 9, 56, 24]) == [24, 35, 9, 56, 12]\n\"\"\"\n\ndef swap_List(newList):\n newList[0], newList[-1] = newList[-1], newList[0]\n return newList\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/595": [{"task_id": "Mbpp/595", "solution": "\"\"\"\nWrite a python function to count minimum number of swaps required to convert one binary number represented as a string to another.\nassert min_Swaps(\"1101\",\"1110\") == 1\n\"\"\"\n\ndef min_Swaps(num1, num2):\n count = 0\n for i in range(len(num1)):\n if num1[i]!= num2[i]:\n count += 1\n return count // 2\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [["111", "000"]], "plus_fail_tests": [["1111111111111111111101110111111001111100111111110111111111111001", "0000111111111111111111001111111111111111111111101111111001111000"]]}], "Mbpp/578": [{"task_id": "Mbpp/578", "solution": "\"\"\"\nWrite a function to interleave 3 lists of the same length into a single flat list.\nassert interleave_lists([1,2,3,4,5,6,7],[10,20,30,40,50,60,70],[100,200,300,400,500,600,700])==[1, 10, 100, 2, 20, 200, 3, 30, 300, 4, 40, 400, 5, 50, 500, 6, 60, 600, 7, 70, 700]\n\"\"\"\n\ndef interleave_lists(list1, list2, list3):\n return [x for tup in zip(list1, list2, list3) for x in tup]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/604": [{"task_id": "Mbpp/604", "solution": "\"\"\"\nWrite a function to reverse words seperated by spaces in a given string.\nassert reverse_words(\"python program\")==(\"program python\")\n\"\"\"\n\ndef reverse_words(s):\n words = s.split()\n words.reverse()\n return''.join(words)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[" a a a a a a "]]}], "Mbpp/600": [{"task_id": "Mbpp/600", "solution": "\"\"\"\nWrite a python function to check whether the given number is even or not.\nassert is_Even(1) == False\n\"\"\"\n\ndef is_Even(num):\n if num % 2 == 0:\n return True\n else:\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/577": [{"task_id": "Mbpp/577", "solution": "\"\"\"\nWrite a python function to find the last digit in factorial of a given number.\nassert last_Digit_Factorial(4) == 4\n\"\"\"\n\ndef last_Digit_Factorial(num):\n if num < 0:\n return -1\n elif num == 0:\n return 1\n else:\n fact = 1\n for i in range(1, num + 1):\n fact = fact * i\n return int(str(fact)[-1])\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[2.5]]}], "Mbpp/587": [{"task_id": "Mbpp/587", "solution": "\"\"\"\nWrite a function to convert a list to a tuple.\nassert list_tuple([5, 10, 7, 4, 15, 3])==(5, 10, 7, 4, 15, 3)\n\"\"\"\n\ndef list_tuple(lst):\n return tuple(lst)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/579": [{"task_id": "Mbpp/579", "solution": "\"\"\"\nWrite a function to find the dissimilar elements in the given two tuples.\nassert find_dissimilar((3, 4, 5, 6), (5, 7, 4, 10)) == (3, 6, 7, 10)\n\"\"\"\n\ndef find_dissimilar(tuple1, tuple2):\n set1 = set(tuple1)\n set2 = set(tuple2)\n dissimilar_elements = set1.symmetric_difference(set2)\n return tuple(dissimilar_elements)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/574": [{"task_id": "Mbpp/574", "solution": "\"\"\"\nWrite a function to find the surface area of a cylinder.\nassert surfacearea_cylinder(10,5)==942.45\n\"\"\"\n\nimport math\n\ndef surfacearea_cylinder(radius, height):\n return 2 * math.pi * radius * (radius + height)\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[5, 1]]}], "Mbpp/593": [{"task_id": "Mbpp/593", "solution": "\"\"\"\nWrite a function to remove leading zeroes from an ip address.\nassert removezero_ip(\"216.08.094.196\")==('216.8.94.196')\n\"\"\"\n\ndef removezero_ip(ip):\n \"\"\"\n Remove leading zeroes from an IP address.\n \"\"\"\n return \".\".join([str(int(i)) for i in ip.split(\".\")])\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/611": [{"task_id": "Mbpp/611", "solution": "\"\"\"\nWrite a function which given a matrix represented as a list of lists returns the max of the n'th column.\nassert max_of_nth([[5, 6, 7], [1, 3, 5], [8, 9, 19]], 2) == 19\n\"\"\"\n\ndef max_of_nth(matrix, n):\n return max(row[n] for row in matrix)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/603": [{"task_id": "Mbpp/603", "solution": "\"\"\"\nWrite a function to get all lucid numbers smaller than or equal to a given integer.\nassert get_ludic(10) == [1, 2, 3, 5, 7]\n\"\"\"\n\ndef get_ludic(n):\n ludic = [i for i in range(1, n + 1)]\n i = 0\n while i < len(ludic):\n ludic = [j for j in ludic if j == ludic[i] or j % ludic[i]!= 0]\n i += 1\n return ludic\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/580": [{"task_id": "Mbpp/580", "solution": "\"\"\"\nWrite a function to remove uneven elements in the nested mixed tuple.\nassert extract_even((4, 5, (7, 6, (2, 4)), 6, 8)) == (4, (6, (2, 4)), 6, 8)\n\"\"\"\n\ndef extract_even(nested_tuple):\n even_elements = []\n for element in nested_tuple:\n if isinstance(element, tuple):\n even_elements.append(extract_even(element))\n elif element % 2 == 0:\n even_elements.append(element)\n return tuple(even_elements)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/614": [{"task_id": "Mbpp/614", "solution": "\"\"\"\nWrite a function to find the cumulative sum of all the values that are present in the given tuple list.\nassert cummulative_sum([(1, 3), (5, 6, 7), (2, 6)]) == 30\n\"\"\"\n\ndef cummulative_sum(tuple_list):\n total_sum = 0\n for tup in tuple_list:\n total_sum += sum(tup)\n return total_sum\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/602": [{"task_id": "Mbpp/602", "solution": "\"\"\"\nWrite a python function to find the first repeated character in a given string.\nassert first_repeated_char(\"abcabc\") == \"a\"\n\"\"\"\n\ndef first_repeated_char(s):\n char_counts = {}\n for char in s:\n if char in char_counts:\n char_counts[char] += 1\n else:\n char_counts[char] = 1\n for char, count in char_counts.items():\n if count > 1:\n return char\n return None\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["abcdefgxhinjklmnopqrstuvwxyz"]]}], "Mbpp/590": [{"task_id": "Mbpp/590", "solution": "\"\"\"\nWrite a function to convert polar coordinates to rectangular coordinates.\nassert polar_rect(3,4)==((5.0, 0.9272952180016122), (-2+2.4492935982947064e-16j))\n\"\"\"\n\nimport cmath\n\ndef polar_rect(r, theta):\n x = r * cmath.cos(theta)\n y = r * cmath.sin(theta)\n return (x, y)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/610": [{"task_id": "Mbpp/610", "solution": "\"\"\"\nWrite a python function which takes a list and returns a list with the same elements, but the k'th element removed.\nassert remove_kth_element([1,1,2,3,4,4,5,1],3)==[1, 1, 3, 4, 4, 5, 1]\n\"\"\"\n\ndef remove_kth_element(lst, k):\n return [x for i, x in enumerate(lst) if i!= k]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/592": [{"task_id": "Mbpp/592", "solution": "\"\"\"\nWrite a python function to find the sum of the product of consecutive binomial co-efficients.\nassert sum_Of_product(3) == 15\n\"\"\"\n\ndef binomial_coefficient(n, k):\n result = 1\n for i in range(1, k+1):\n result = result * (n + 1 - i) // i\n return result\n\ndef sum_Of_product(n):\n sum = 0\n for i in range(1, n+1):\n sum += binomial_coefficient(n, i) * binomial_coefficient(n + 1, i + 1)\n return sum\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/607": [{"task_id": "Mbpp/607", "solution": "\"\"\"\nWrite a function to search a string for a regex pattern. The function should return the matching subtring, a start index and an end index.\nassert find_literals('The quick brown fox jumps over the lazy dog.', 'fox') == ('fox', 16, 19)\n\"\"\"\n\nimport re\n\ndef find_literals(text, pattern):\n match = re.search(pattern, text)\n if match:\n return match.group(), match.start(), match.end()\n else:\n return None\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/612": [{"task_id": "Mbpp/612", "solution": "\"\"\"\nWrite a python function which takes a list of lists, where each sublist has two elements, and returns a list of two lists where the first list has the first element of each sublist and the second one has the second.\nassert merge([['x', 'y'], ['a', 'b'], ['m', 'n']]) == [['x', 'a', 'm'], ['y', 'b', 'n']]\n\"\"\"\n\ndef merge(lst):\n return [list(x) for x in zip(*lst)]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/616": [{"task_id": "Mbpp/616", "solution": "\"\"\"\nWrite a function which takes two tuples of the same length and performs the element wise modulo.\nassert tuple_modulo((10, 4, 5, 6), (5, 6, 7, 5)) == (0, 4, 5, 1)\n\"\"\"\n\ndef tuple_modulo(tuple_1, tuple_2):\n return tuple(a % b for a, b in zip(tuple_1, tuple_2))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/586": [{"task_id": "Mbpp/586", "solution": "\"\"\"\nWrite a python function to split a list at the nth eelment and add the first part to the end.\nassert split_Arr([12,10,5,6,52,36],2) == [5,6,52,36,12,10]\n\"\"\"\n\ndef split_Arr(arr,n):\n return arr[n:]+arr[:n]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/585": [{"task_id": "Mbpp/585", "solution": "\"\"\"\nWrite a function to find the n most expensive items in a given dataset.\nassert expensive_items([{'name': 'Item-1', 'price': 101.1},{'name': 'Item-2', 'price': 555.22}],1)==[{'name': 'Item-2', 'price': 555.22}]\n\"\"\"\n\ndef expensive_items(dataset, n):\n sorted_items = sorted(dataset, key=lambda item: item['price'], reverse=True)\n return sorted_items[:n]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/622": [{"task_id": "Mbpp/622", "solution": "\"\"\"\nWrite a function to find the median of two sorted lists of same size.\nassert get_median([1, 12, 15, 26, 38], [2, 13, 17, 30, 45], 5) == 16.0\n\"\"\"\n\ndef get_median(list1, list2, n):\n m1 = m2 = 0\n count = 0\n while count < n:\n if list1[m1] < list2[m2]:\n m1 += 1\n else:\n m2 += 1\n count += 1\n return (list1[m1 - 1] + list2[m2 - 1]) / 2.0\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/615": [{"task_id": "Mbpp/615", "solution": "\"\"\"\nWrite a function which takes a tuple of tuples and returns the average value for each tuple as a list.\nassert 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]\n\"\"\"\n\ndef average_tuple(input_tuple):\n average_list = []\n for tup in input_tuple:\n average_list.append(sum(tup)/len(tup))\n return average_list\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/581": [{"task_id": "Mbpp/581", "solution": "\"\"\"\nWrite a python function to find the surface area of a square pyramid with a given base edge and height.\nassert surface_Area(3,4) == 33\n\"\"\"\n\ndef surface_Area(edge, height):\n base_area = edge ** 2\n lateral_area = edge * (edge ** 0.5) * height\n return 2 * base_area + lateral_area\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/620": [{"task_id": "Mbpp/620", "solution": "\"\"\"\nWrite a function to find the size of the largest subset of a list of numbers so that every pair is divisible.\nassert largest_subset([ 1, 3, 6, 13, 17, 18 ]) == 4\n\"\"\"\n\ndef largest_subset(numbers):\n numbers.sort()\n dp = [1] * len(numbers)\n for i in range(len(numbers)):\n for j in range(i):\n if numbers[i] % numbers[j] == 0:\n dp[i] = max(dp[i], dp[j] + 1)\n return max(dp)\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[9, 3, 12, 7, 16, 3, 11, 8, 4, 13, 13]]]}], "Mbpp/606": [{"task_id": "Mbpp/606", "solution": "\"\"\"\nWrite a function to convert degrees to radians.\nassert radian_degree(90)==1.5707963267948966\n\"\"\"\n\nimport math\n\ndef radian_degree(degree):\n return degree*math.pi/180\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/608": [{"task_id": "Mbpp/608", "solution": "\"\"\"\nWrite a python function to find nth bell number.\nassert bell_Number(2) == 2\n\"\"\"\n\ndef 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]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/619": [{"task_id": "Mbpp/619", "solution": "\"\"\"\nWrite a function to move all the numbers to the end of the given string.\nassert move_num('I1love143you55three3000thousand') == 'Iloveyouthreethousand1143553000'\n\"\"\"\n\ndef move_num(s):\n return ''.join(sorted(s, key=lambda c: c.isdigit()))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/618": [{"task_id": "Mbpp/618", "solution": "\"\"\"\nWrite a function to divide two lists element wise.\nassert div_list([4,5,6],[1, 2, 3])==[4.0,2.5,2.0]\n\"\"\"\n\ndef div_list(list1, list2):\n return [float(x)/float(y) for x, y in zip(list1, list2)]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/628": [{"task_id": "Mbpp/628", "solution": "\"\"\"\nWrite a function to replace all spaces in the given string with '%20'.\nassert replace_spaces(\"My Name is Dawood\") == 'My%20Name%20is%20Dawood'\n\"\"\"\n\ndef replace_spaces(s):\n return s.replace(' ', '%20')\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/623": [{"task_id": "Mbpp/623", "solution": "\"\"\"\nWrite a function to compute the n-th power of each number in a list.\nassert nth_nums([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],2)==[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n\"\"\"\n\ndef nth_nums(nums, n):\n return [num**n for num in nums]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/626": [{"task_id": "Mbpp/626", "solution": "\"\"\"\nWrite a python function to find the area of the largest triangle that can be inscribed in a semicircle with a given radius.\nassert triangle_area(-1) == None\n\"\"\"\n\nimport math\n\ndef triangle_area(radius):\n if radius < 0:\n return None\n return (radius ** 2) * (math.pi / 4)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[2]], "plus_fail_tests": [[0.5]]}], "Mbpp/629": [{"task_id": "Mbpp/629", "solution": "\"\"\"\nWrite a python function to find even numbers from a list of numbers.\nassert Split([1,2,3,4,5]) == [2,4]\n\"\"\"\n\ndef Split(arr):\n return [num for num in arr if num % 2 == 0]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/624": [{"task_id": "Mbpp/624", "solution": "\"\"\"\nWrite a python function to convert a given string to uppercase.\nassert is_upper(\"person\") ==\"PERSON\"\n\"\"\"\n\ndef is_upper(s):\n return s.upper()\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/635": [{"task_id": "Mbpp/635", "solution": "\"\"\"\nWrite a function to sort the given list.\nassert heap_sort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])==[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n\"\"\"\n\ndef heapify(arr, n, i):\n largest = i\n l = 2 * i + 1\n r = 2 * i + 2\n if l < n and arr[i] < arr[l]:\n largest = l\n if r < n and arr[largest] < arr[r]:\n largest = r\n if largest!= i:\n arr[i],arr[largest] = arr[largest],arr[i]\n heapify(arr, n, largest)\ndef heap_sort(arr):\n n = len(arr)\n for i in range(n//2 - 1, -1, -1):\n heapify(arr, n, i)\n for i in range(n-1, 0, -1):\n arr[i], arr[0] = arr[0], arr[i]\n heapify(arr, i, 0)\n return arr\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/640": [{"task_id": "Mbpp/640", "solution": "\"\"\"\nWrite a function to remove the parenthesis and what is inbetween them from a string.\nassert remove_parenthesis([\"python (chrome)\"])==(\"python\")\n\"\"\"\n\ndef remove_parenthesis(string):\n new_string = \"\"\n for char in string:\n if char!= \"(\":\n if char!= \")\":\n new_string += char\n return new_string\n", "base_status": "fail", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/631": [{"task_id": "Mbpp/631", "solution": "\"\"\"\nWrite a function to replace whitespaces with an underscore and vice versa in a given string.\nassert replace_spaces('Jumanji The Jungle') == 'Jumanji_The_Jungle'\n\"\"\"\n\ndef replace_spaces(string):\n return string.replace(' ', '_').replace('_','')\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[" Jumanji The Jungle "]]}], "Mbpp/730": [{"task_id": "Mbpp/730", "solution": "\"\"\"\nWrite a function to remove consecutive duplicates of a given list.\nassert 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]\n\"\"\"\n\ndef consecutive_duplicates(lst):\n result = []\n previous = None\n for item in lst:\n if item!= previous:\n result.append(item)\n previous = item\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/641": [{"task_id": "Mbpp/641", "solution": "\"\"\"\nWrite a function to find the nth nonagonal number.\nassert is_nonagonal(10) == 325\n\"\"\"\n\ndef is_nonagonal(num):\n n = (1 + (1 + 24 * num) ** 0.5) / 2\n return n % 1 == 0\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/740": [{"task_id": "Mbpp/740", "solution": "\"\"\"\nWrite a function to convert the given tuple to a key-value dictionary using adjacent elements. https://www.geeksforgeeks.org/python-convert-tuple-to-adjacent-pair-dictionary/\nassert tuple_to_dict((1, 5, 7, 10, 13, 5)) == {1: 5, 7: 10, 13: 5}\n\"\"\"\n\ndef tuple_to_dict(input_tuple):\n return dict(zip(input_tuple[::2], input_tuple[1::2]))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/722": [{"task_id": "Mbpp/722", "solution": "\"\"\"\nThe input is given as - a dictionary with a student name as a key and a tuple of float (student_height, student_weight) as a value, - minimal height, - minimal weight. Write a function to filter students that have height and weight above the minimum.\nassert filter_data({'Cierra Vega': (6.2, 70), 'Alden Cantrell': (5.9, 65), 'Kierra Gentry': (6.0, 68), 'Pierre Cox': (5.8, 66)},6.0,70)=={'Cierra Vega': (6.2, 70)}\n\"\"\"\n\ndef filter_data(data, min_height, min_weight):\n return {\n name: height_weight\n for name, height_weight in data.items()\n if height_weight[0] >= min_height and height_weight[1] >= min_weight\n }\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/735": [{"task_id": "Mbpp/735", "solution": "\"\"\"\nWrite a python function to toggle bits of the number except the first and the last bit. https://www.geeksforgeeks.org/toggle-bits-number-expect-first-last-bits/\nassert toggle_middle_bits(9) == 15\n\"\"\"\n\ndef toggle_middle_bits(num):\n mask = 0b10\n while mask < (1 << (len(bin(num)) - 4)):\n num ^= mask\n mask <<= 1\n return num\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/637": [{"task_id": "Mbpp/637", "solution": "\"\"\"\nWrite a function to check whether the given amount has no profit and no loss\nassert noprofit_noloss(1500,1200)==False\n\"\"\"\n\ndef noprofit_noloss(cost_price, sell_price):\n return sell_price == cost_price\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/639": [{"task_id": "Mbpp/639", "solution": "\"\"\"\nWrite 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.\nassert sample_nam(['sally', 'Dylan', 'rebecca', 'Diana', 'Joanne', 'keith'])==16\n\"\"\"\n\ndef sample_nam(names):\n return sum(len(name) for name in names if name[0].isupper())\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[["AbCdE", "fGH", "IJKLMnOp", "qrs", "TUVW", "xyz"]]]}], "Mbpp/632": [{"task_id": "Mbpp/632", "solution": "\"\"\"\nWrite a python function to move all zeroes to the end of the given list.\nassert move_zero([1,0,2,0,3,4]) == [1,2,3,4,0,0]\n\"\"\"\n\ndef move_zero(lst):\n n = len(lst)\n next_nonzero = 0\n for i in range(n):\n if lst[i]!= 0:\n lst[i], lst[next_nonzero] = lst[next_nonzero], lst[i]\n next_nonzero += 1\n return lst\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/734": [{"task_id": "Mbpp/734", "solution": "\"\"\"\nWrite a python function to find sum of products of all possible sublists of a given list. https://www.geeksforgeeks.org/sum-of-products-of-all-possible-subarrays/\nassert sum_Of_Subarray_Prod([1,2,3]) == 20\n\"\"\"\n\ndef sum_Of_Subarray_Prod(arr):\n n = len(arr)\n prefix_prod = [1] * n\n suffix_prod = [1] * n\n for i in range(1, n):\n prefix_prod[i] = prefix_prod[i-1] * arr[i-1]\n for i in range(n-2, -1, -1):\n suffix_prod[i] = suffix_prod[i+1] * arr[i+1]\n result = 0\n for i in range(n):\n result += prefix_prod[i] * suffix_prod[i]\n\n return result\n", "base_status": "fail", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/736": [{"task_id": "Mbpp/736", "solution": "\"\"\"\nWrite a function to locate the left insertion point for a specified value in sorted order. https://www.w3resource.com/python-exercises/data-structures-and-algorithms/python-data-structure-exercise-24.php\nassert left_insertion([1,2,4,5],6)==4\n\"\"\"\n\ndef left_insertion(lst, value):\n low = 0\n high = len(lst) - 1\n while low <= high:\n mid = (low + high) // 2\n if lst[mid] < value:\n low = mid + 1\n else:\n high = mid - 1\n return low\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/723": [{"task_id": "Mbpp/723", "solution": "\"\"\"\nThe input is defined as two lists of the same length. Write a function to count indices where the lists have the same values.\nassert count_same_pair([1, 2, 3, 4, 5, 6, 7, 8],[2, 2, 3, 1, 2, 6, 7, 9])==4\n\"\"\"\n\ndef count_same_pair(list1, list2):\n count = 0\n for i in range(len(list1)):\n if list1[i] == list2[i]:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/644": [{"task_id": "Mbpp/644", "solution": "\"\"\"\nWrite a python function to reverse an array upto a given position.\nassert reverse_Array_Upto_K([1, 2, 3, 4, 5, 6],4) == [4, 3, 2, 1, 5, 6]\n\"\"\"\n\ndef reverse_Array_Upto_K(arr,k):\n arr[:k+1] = arr[:k+1][::-1]\n return arr\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/638": [{"task_id": "Mbpp/638", "solution": "\"\"\"\nWrite a function to calculate the wind chill index rounded to the next integer given the wind velocity in km/h and a temperature in celsius.\nassert wind_chill(120,35)==40\n\"\"\"\n\ndef wind_chill(velocity, temperature):\n wind_chill_index = 13.12 + 0.6215 * temperature - 11.37 * velocity ** 0.16 + 0.3965 * temperature * velocity ** 0.16\n return round(wind_chill_index)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/633": [{"task_id": "Mbpp/633", "solution": "\"\"\"\nWrite a python function to find the sum of xor of all pairs of numbers in the given list.\nassert pair_xor_Sum([5,9,7,6],4) == 47\n\"\"\"\n\ndef pair_xor_Sum(arr,n):\n xor_sum = 0\n for i in range(n):\n xor_sum ^= arr[i]\n return xor_sum\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/725": [{"task_id": "Mbpp/725", "solution": "\"\"\"\nWrite a function to extract values between quotation marks \" \" of the given string.\nassert extract_quotation('Cortex \"A53\" Based \"multi\" tasking \"Processor\"') == ['A53', 'multi', 'Processor']\n\"\"\"\n\nimport re\n\ndef extract_quotation(string):\n return re.findall(r'\".*?\"', string)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/731": [{"task_id": "Mbpp/731", "solution": "\"\"\"\nWrite a function to find the lateral surface area of a cone given radius r and the height h.\nassert lateralsurface_cone(5,12)==204.20352248333654\n\"\"\"\n\nimport math\n\ndef lateralsurface_cone(r, h):\n return math.pi * r * math.sqrt(r**2 + h**2)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/733": [{"task_id": "Mbpp/733", "solution": "\"\"\"\nWrite a function to find the index of the first occurrence of a given number in a sorted array.\nassert find_first_occurrence([2, 5, 5, 5, 6, 6, 8, 9, 9, 9], 5) == 1\n\"\"\"\n\ndef find_first_occurrence(nums, target):\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] >= target:\n right = mid - 1\n else:\n left = mid + 1\n if left < len(nums) and nums[left] == target:\n return left\n else:\n return -1\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/728": [{"task_id": "Mbpp/728", "solution": "\"\"\"\nWrite a function takes as input two lists [a_1,...,a_n], [b_1,...,b_n] and returns [a_1+b_1,...,a_n+b_n].\nassert sum_list([10,20,30],[15,25,35])==[25,45,65]\n\"\"\"\n\ndef sum_list(list1, list2):\n return [x + y for x, y in zip(list1, list2)]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/737": [{"task_id": "Mbpp/737", "solution": "\"\"\"\nWrite a function to check whether the given string is starting with a vowel or not using regex.\nassert check_str(\"annie\")\n\"\"\"\n\nimport re\n\ndef check_str(string):\n return re.match(r\"^[aeiou]\", string, re.IGNORECASE) is not None\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/742": [{"task_id": "Mbpp/742", "solution": "\"\"\"\nWrite a function to caluclate the area of a tetrahedron.\nassert area_tetrahedron(3)==15.588457268119894\n\"\"\"\n\nimport math\n\ndef area_tetrahedron(a):\n return math.sqrt(3) * a**2 / 2\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/741": [{"task_id": "Mbpp/741", "solution": "\"\"\"\nWrite a python function to check whether all the characters are same or not.\nassert all_Characters_Same(\"python\") == False\n\"\"\"\n\ndef all_Characters_Same(string):\n return len(set(string)) == 1\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/748": [{"task_id": "Mbpp/748", "solution": "\"\"\"\nWrite a function to put spaces between words starting with capital letters in a given string.\nassert capital_words_spaces(\"Python\") == 'Python'\n\"\"\"\n\nimport re\n\ndef capital_words_spaces(text):\n return re.sub(r\"(\\w)([A-Z])\", r\"\\1 \\2\", text)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/764": [{"task_id": "Mbpp/764", "solution": "\"\"\"\nWrite a python function to count number of digits in a given string.\nassert number_ctr('program2bedone') == 1\n\"\"\"\n\ndef number_ctr(string):\n count = 0\n for char in string:\n if char.isdigit():\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/721": [{"task_id": "Mbpp/721", "solution": "\"\"\"\nGiven a square matrix of size N*N given as a list of lists, where each cell is associated with a specific cost. A path is defined as a specific sequence of cells that starts from the top-left cell move only right or down and ends on bottom right cell. We want to find a path with the maximum average over all existing paths. Average is computed as total cost divided by the number of cells visited in the path.\nassert maxAverageOfPath([[1, 2, 3], [6, 5, 4], [7, 3, 9]]) == 5.2\n\"\"\"\n\ndef maxAverageOfPath(matrix):\n n = len(matrix)\n dp = [[0] * n for _ in range(n)]\n dp[0][0] = matrix[0][0]\n for i in range(1, n):\n dp[0][i] = dp[0][i-1] + matrix[0][i]\n for i in range(1, n):\n dp[i][0] = dp[i-1][0] + matrix[i][0]\n for i in range(1, n):\n for j in range(1, n):\n dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + matrix[i][j]\n return dp[n-1][n-1] / (n * 2 - 1)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/755": [{"task_id": "Mbpp/755", "solution": "\"\"\"\nWrite a function to find the second smallest number in a list.\nassert second_smallest([1, 2, -8, -2, 0, -2])==-2\n\"\"\"\n\ndef second_smallest(lst):\n smallest = second_smallest = float('inf')\n for num in lst:\n if num < smallest:\n smallest, second_smallest = num, smallest\n elif num < second_smallest:\n second_smallest = num\n return second_smallest\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[[1, 1, -0.5, 0, 2, -2, -2]]], "plus_fail_tests": []}], "Mbpp/760": [{"task_id": "Mbpp/760", "solution": "\"\"\"\nWrite a python function to check whether a list of numbers contains only one distinct element or not.\nassert unique_Element([1,1,1]) == True\n\"\"\"\n\ndef unique_Element(lst):\n return len(set(lst)) == 1\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/745": [{"task_id": "Mbpp/745", "solution": "\"\"\"\nWrite a function to find numbers within a given range from startnum ti endnum where every number is divisible by every digit it contains. https://www.w3resource.com/python-exercises/lambda/python-lambda-exercise-24.php\nassert divisible_by_digits(1,22)==[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]\n\"\"\"\n\ndivisible_by_digits = lambda startnum, endnum: [num for num in range(startnum, endnum+1) if all(num % digit == 0 for digit in map(int, str(num)))]\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/754": [{"task_id": "Mbpp/754", "solution": "\"\"\"\nWe say that an element is common for lists l1, l2, l3 if it appears in all three lists under the same index. Write a function to find common elements from three lists. The function should return a list.\nassert 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]\n\"\"\"\n\ndef extract_index_list(l1, l2, l3):\n common_elements = []\n for i in range(len(l1)):\n if l1[i] == l2[i] == l3[i]:\n common_elements.append(l1[i])\n return common_elements\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[2, 4, 6, 8, 10, 12, 14], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]]]}], "Mbpp/726": [{"task_id": "Mbpp/726", "solution": "\"\"\"\nWrite a function that takes as input a tuple of numbers (t_1,...,t_{N+1}) and returns a tuple of length N where the i-th element of the tuple is equal to t_i * t_{i+1}.\nassert multiply_elements((1, 5, 7, 8, 10)) == (5, 35, 56, 80)\n\"\"\"\n\ndef multiply_elements(input_tuple):\n output_tuple = ()\n for i in range(len(input_tuple) - 1):\n output_tuple += (input_tuple[i] * input_tuple[i+1],)\n return output_tuple\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/643": [{"task_id": "Mbpp/643", "solution": "\"\"\"\nWrite a function that checks if a strings contains 'z', except at the start and end of the word.\nassert text_match_wordz_middle(\"pythonzabc.\")==True\n\"\"\"\n\nimport re\n\ndef text_match_wordz_middle(text):\n pattern = r\"\\Bz\\B\"\n if re.search(pattern, text):\n return True\n else:\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/744": [{"task_id": "Mbpp/744", "solution": "\"\"\"\nWrite a function to check if the given tuple has any none value or not.\nassert check_none((10, 4, 5, 6, None)) == True\n\"\"\"\n\ndef check_none(tup):\n return None in tup\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/758": [{"task_id": "Mbpp/758", "solution": "\"\"\"\nWrite a function to count lists within a list. The function should return a dictionary where every list is converted to a tuple and the value of such tuple is the number of its occurencies in the original list.\nassert 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}\n\"\"\"\n\ndef unique_sublists(lst):\n tuples_count = {}\n for sublist in lst:\n sublist_tuple = tuple(sublist)\n if sublist_tuple not in tuples_count:\n tuples_count[sublist_tuple] = 1\n else:\n tuples_count[sublist_tuple] += 1\n return tuples_count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/743": [{"task_id": "Mbpp/743", "solution": "\"\"\"\nWrite a function to rotate a given list by specified number of items to the right direction. https://www.geeksforgeeks.org/python-program-right-rotate-list-n/\nassert rotate_right([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],3)==[8, 9, 10, 1, 2, 3, 4, 5, 6, 7]\n\"\"\"\n\ndef rotate_right(lst, n):\n return lst[-n:] + lst[:-n]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/749": [{"task_id": "Mbpp/749", "solution": "\"\"\"\nWrite a function to sort a given list of strings of numbers numerically. https://www.geeksforgeeks.org/python-sort-numeric-strings-in-a-list/\nassert sort_numeric_strings( ['4','12','45','7','0','100','200','-12','-500'])==[-500, -12, 0, 4, 7, 12, 45, 100, 200]\n\"\"\"\n\ndef sort_numeric_strings(input_list):\n def convert(string):\n return int(string) if string.isdigit() else string.lower()\n\n def alphanum_key(string):\n return [convert(c) for c in re.split('([0-9]+)', string)]\n\n return sorted(input_list, key=alphanum_key)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/759": [{"task_id": "Mbpp/759", "solution": "\"\"\"\nWrite a function to check whether a given string is a decimal number with a precision of 2.\nassert is_decimal('123.11')==True\n\"\"\"\n\nimport re\n\ndef is_decimal(s):\n return bool(re.match(r'^-?\\d+\\.\\d{2}$', s))\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["-123.11"]]}], "Mbpp/763": [{"task_id": "Mbpp/763", "solution": "\"\"\"\nWrite a python function to find the minimum difference between any two elements in a given array. https://www.geeksforgeeks.org/find-minimum-difference-pair/\nassert find_min_diff((1,5,3,19,18,25),6) == 1\n\"\"\"\n\ndef find_min_diff(arr, n):\n arr.sort()\n min_diff = float('inf')\n for i in range(n-1):\n min_diff = min(min_diff, arr[i+1] - arr[i])\n return min_diff\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/762": [{"task_id": "Mbpp/762", "solution": "\"\"\"\nWrite a function to check whether the given month number contains 30 days or not. Months are given as number from 1 to 12.\nassert check_monthnumber_number(6)==True\n\"\"\"\n\ndef check_monthnumber_number(month_number):\n if month_number in [4, 6, 9, 11]:\n return True\n else:\n return False\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/732": [{"task_id": "Mbpp/732", "solution": "\"\"\"\nWrite a function to replace all occurrences of spaces, commas, or dots with a colon.\nassert replace_specialchar('Python language, Programming language.')==('Python:language::Programming:language:')\n\"\"\"\n\ndef replace_specialchar(text):\n return text.replace(' ', ':').replace(',', ':').replace('.', ':')\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/720": [{"task_id": "Mbpp/720", "solution": "\"\"\"\nWrite a function to add a dictionary to the tuple. The output should be a tuple.\nassert add_dict_to_tuple((4, 5, 6), {\"MSAM\" : 1, \"is\" : 2, \"best\" : 3} ) == (4, 5, 6, {'MSAM': 1, 'is': 2, 'best': 3})\n\"\"\"\n\ndef add_dict_to_tuple(tup, dict_to_add):\n return tup + (dict_to_add,)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/746": [{"task_id": "Mbpp/746", "solution": "\"\"\"\nWrite a function to find area of a sector. The function takes the radius and angle as inputs. Function should return None if the angle is larger than 360 degrees.\nassert sector_area(4,45)==6.283185307179586\n\"\"\"\n\nimport math\n\ndef sector_area(radius, angle):\n if angle > 360:\n return None\n return 0.5 * radius ** 2 * math.radians(angle)\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[44, 44]]}], "Mbpp/724": [{"task_id": "Mbpp/724", "solution": "\"\"\"\nWrite a function that takes base and power as arguments and calculate the sum of all digits of the base to the specified power.\nassert power_base_sum(2,100)==115\n\"\"\"\n\ndef power_base_sum(base, power):\n return sum(int(digit) for digit in str(base ** power))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/750": [{"task_id": "Mbpp/750", "solution": "\"\"\"\nWrite a function to add the given tuple to the given list.\nassert add_tuple([5, 6, 7], (9, 10)) == [5, 6, 7, 9, 10]\n\"\"\"\n\ndef add_tuple(lst, tup):\n lst.extend(tup)\n return lst\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/753": [{"task_id": "Mbpp/753", "solution": "\"\"\"\nWrite a function to find minimum k records from tuple list. https://www.geeksforgeeks.org/python-find-minimum-k-records-from-tuple-list/ - in this case a verbatim copy of test cases\nassert min_k([('Manjeet', 10), ('Akshat', 4), ('Akash', 2), ('Nikhil', 8)], 2) == [('Akash', 2), ('Akshat', 4)]\n\"\"\"\n\ndef min_k(tuples, k):\n return sorted(tuples, key=lambda x: x[1])[:k]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/751": [{"task_id": "Mbpp/751", "solution": "\"\"\"\nWrite a function to check if the given array represents min heap or not. https://www.geeksforgeeks.org/how-to-check-if-a-given-array-represents-a-binary-heap/\nassert check_min_heap([1, 2, 3, 4, 5, 6]) == True\n\"\"\"\n\ndef check_min_heap(arr):\n n = len(arr)\n for i in range(n):\n left_child = 2 * i + 1\n right_child = 2 * i + 2\n if left_child < n and arr[i] > arr[left_child]:\n return False\n if right_child < n and arr[i] > arr[right_child]:\n return False\n return True\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/757": [{"task_id": "Mbpp/757", "solution": "\"\"\"\nWrite a function to count the pairs of reverse strings in the given string list. https://www.geeksforgeeks.org/python-program-to-count-the-pairs-of-reverse-strings/\nassert count_reverse_pairs([\"julia\", \"best\", \"tseb\", \"for\", \"ailuj\"])== 2\n\"\"\"\n\ndef count_reverse_pairs(string_list):\n count = 0\n for i in range(len(string_list)):\n for j in range(i + 1, len(string_list)):\n if string_list[i] == string_list[j][::-1]:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/767": [{"task_id": "Mbpp/767", "solution": "\"\"\"\nWrite a python function to count the number of pairs whose sum is equal to \u2018sum\u2019. The funtion gets as input a list of numbers and the sum,\nassert get_pairs_count([1,1,1,1],2) == 6\n\"\"\"\n\ndef get_pairs_count(nums, sum):\n count = 0\n for i in range(len(nums)):\n for j in range(i+1, len(nums)):\n if nums[i] + nums[j] == sum:\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/769": [{"task_id": "Mbpp/769", "solution": "\"\"\"\nWrite a python function to get the difference between two lists.\nassert (Diff([10, 15, 20, 25, 30, 35, 40], [25, 40, 35])) == [10, 20, 30, 15]\n\"\"\"\n\ndef Diff(list1, list2):\n return list(set(list1) - set(list2))\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[[1, 2, 3, 4, 5], [6, 7, 1]]], "plus_fail_tests": [[[], [1, 2, 3]]]}], "Mbpp/766": [{"task_id": "Mbpp/766", "solution": "\"\"\"\nWrite a function to return a list of all pairs of consecutive items in a given list.\nassert pair_wise([1,1,2,3,3,4,4,5])==[(1, 1), (1, 2), (2, 3), (3, 3), (3, 4), (4, 4), (4, 5)]\n\"\"\"\n\ndef pair_wise(lst):\n return [(lst[i], lst[i+1]) for i in range(len(lst)-1)]\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/453": [{"task_id": "Mbpp/453", "solution": "\"\"\"\nWrite a python function to find the sum of even factors of a number.\nassert sumofFactors(18) == 26\n\"\"\"\n\ndef sumofFactors(num):\n sum = 0\n for i in range(1, num+1):\n if num % i == 0:\n if i % 2 == 0:\n sum += i\n return sum\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/295": [{"task_id": "Mbpp/295", "solution": "\"\"\"\nWrite a function to return the sum of all divisors of a number.\nassert sum_div(8)==7\n\"\"\"\n\ndef sum_div(n):\n sum = 0\n for i in range(1, n+1):\n if n % i == 0:\n sum += i\n return sum\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/770": [{"task_id": "Mbpp/770", "solution": "\"\"\"\nWrite a python function to find the sum of fourth power of first n odd natural numbers.\nassert odd_num_sum(2) == 82\n\"\"\"\n\ndef odd_num_sum(n):\n sum = 0\n for i in range(1, n + 1):\n num = 2 * i - 1\n sum += num ** 4\n return sum\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/771": [{"task_id": "Mbpp/771", "solution": "\"\"\"\nWrite a function to check if the given expression is balanced or not. https://www.geeksforgeeks.org/check-for-balanced-parentheses-in-an-expression/\nassert check_expression(\"{()}[{}]\") == True\n\"\"\"\n\ndef check_expression(expression):\n stack = []\n opening_brackets = [\"(\", \"[\", \"{\"]\n closing_brackets = [\")\", \"]\", \"}\"]\n for char in expression:\n if char in opening_brackets:\n stack.append(char)\n elif char in closing_brackets:\n if not stack or opening_brackets[closing_brackets.index(char)]!= stack[-1]:\n return False\n stack.pop()\n return len(stack) == 0\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/782": [{"task_id": "Mbpp/782", "solution": "\"\"\"\nWrite a python function to find the sum of all odd length subarrays. https://www.geeksforgeeks.org/sum-of-all-odd-length-subarrays/\nassert odd_length_sum([1,2,4]) == 14\n\"\"\"\n\ndef odd_length_sum(arr):\n n = len(arr)\n sum = 0\n for i in range(n):\n for j in range(i, n):\n if (j - i + 1) % 2!= 0:\n sum += sum(arr[i:j + 1])\n return sum\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/780": [{"task_id": "Mbpp/780", "solution": "\"\"\"\nWrite a function to find the combinations of sums with tuples in the given tuple list. https://www.geeksforgeeks.org/python-combinations-of-sum-with-tuples-in-tuple-list/\nassert find_combinations([(2, 4), (6, 7), (5, 1), (6, 10)]) == [(8, 11), (7, 5), (8, 14), (11, 8), (12, 17), (11, 11)]\n\"\"\"\n\ndef find_combinations(tuple_list):\n combinations = []\n for i in range(len(tuple_list)):\n for j in range(i + 1, len(tuple_list)):\n first_tuple = tuple_list[i]\n second_tuple = tuple_list[j]\n combinations.append((first_tuple[0] + second_tuple[0], first_tuple[1] + second_tuple[1]))\n return combinations\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]]]]}], "Mbpp/791": [{"task_id": "Mbpp/791", "solution": "\"\"\"\nWrite a function to remove tuples from the given tuple.\nassert remove_nested((1, 5, 7, (4, 6), 10)) == (1, 5, 7, 10)\n\"\"\"\n\ndef remove_nested(tup):\n result = []\n for item in tup:\n if isinstance(item, tuple):\n result.extend(remove_nested(item))\n else:\n result.append(item)\n return tuple(result)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/790": [{"task_id": "Mbpp/790", "solution": "\"\"\"\nWrite a python function to check whether every even index contains even numbers of a given list.\nassert even_position([3,2,1]) == False\n\"\"\"\n\ndef even_position(nums):\n for i in range(len(nums)):\n if i % 2 == 0 and nums[i] % 2!= 0:\n return False\n return True\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/788": [{"task_id": "Mbpp/788", "solution": "\"\"\"\nWrite a function to create a new tuple from the given string and list.\nassert new_tuple([\"WEB\", \"is\"], \"best\") == ('WEB', 'is', 'best')\n\"\"\"\n\ndef new_tuple(list, string):\n return tuple(list + [string])\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/784": [{"task_id": "Mbpp/784", "solution": "\"\"\"\nWrite a function to find the product of first even and odd number of a given list.\nassert mul_even_odd([1,3,5,7,4,1,6,8])==4\n\"\"\"\n\ndef mul_even_odd(lst):\n even = None\n odd = None\n for num in lst:\n if num % 2 == 0:\n if even is None:\n even = num\n else:\n even *= num\n else:\n if odd is None:\n odd = num\n else:\n odd *= num\n if even is not None and odd is not None:\n return even * odd\n else:\n return None\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/772": [{"task_id": "Mbpp/772", "solution": "\"\"\"\nWrite a function to remove all the words with k length in the given string.\nassert remove_length('The person is most value tet', 3) == 'person is most value'\n\"\"\"\n\ndef remove_length(s, k):\n return''.join([word for word in s.split() if len(word)!= k])\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["This is a very long and complex sentence that contains words of different lengths such as abracadabra, internationalization, and antidisestablishmentarianism.", 10]]}], "Mbpp/792": [{"task_id": "Mbpp/792", "solution": "\"\"\"\nWrite a python function to count the number of lists in a given number of lists.\nassert count_list([[1, 3], [5, 7], [9, 11], [13, 15, 17]]) == 4\n\"\"\"\n\ndef count_list(lists):\n count = 0\n for item in lists:\n if isinstance(item, list):\n count += 1\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/786": [{"task_id": "Mbpp/786", "solution": "\"\"\"\nWrite a function to locate the right insertion point for a specified value in sorted order.\nassert right_insertion([1,2,4,5],6)==4\n\"\"\"\n\ndef right_insertion(lst, val):\n low = 0\n high = len(lst) - 1\n while low <= high:\n mid = (low + high) // 2\n if lst[mid] < val:\n low = mid + 1\n else:\n high = mid - 1\n return low\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[50.64327388212607, -72.16612625583227, 95.25630303581863, -75.73998556144497, 11.857449640680656, -90.20293226837086, -12.02758648076636, -35.964731488229475], false]]}], "Mbpp/785": [{"task_id": "Mbpp/785", "solution": "\"\"\"\nWrite a function to convert tuple string to integer tuple.\nassert tuple_str_int(\"(7, 8, 9)\") == (7, 8, 9)\n\"\"\"\n\ndef tuple_str_int(tuple_str):\n return tuple(map(int, tuple_str[1:-1].split(\", \")))\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["((7, 8, 9)"]]}], "Mbpp/775": [{"task_id": "Mbpp/775", "solution": "\"\"\"\nWrite a python function to check whether every odd index contains odd numbers of a given list.\nassert odd_position([2,1,4,3,6,7,6,3]) == True\n\"\"\"\n\ndef odd_position(lst):\n for i in range(len(lst)):\n if i % 2 == 1 and lst[i] % 2 == 0:\n return False\n return True\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/773": [{"task_id": "Mbpp/773", "solution": "\"\"\"\nWrite a function to find the occurrence and position of the substrings within a string. Return None if there is no match.\nassert occurance_substring('python programming, python language','python')==('python', 0, 6)\n\"\"\"\n\ndef occurance_substring(string, substring):\n pos = string.find(substring)\n if pos!= -1:\n return substring, pos, pos + len(substring) - 1\n else:\n return None\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/777": [{"task_id": "Mbpp/777", "solution": "\"\"\"\nWrite a python function to find the sum of non-repeated elements in a given list.\nassert find_sum([1,2,3,1,1,4,5,6]) == 21\n\"\"\"\n\ndef find_sum(lst):\n unique_elements = set()\n sum_of_elements = 0\n for element in lst:\n if element not in unique_elements:\n unique_elements.add(element)\n sum_of_elements += element\n return sum_of_elements\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/783": [{"task_id": "Mbpp/783", "solution": "\"\"\"\nWrite a function to convert rgb color to hsv color. https://www.geeksforgeeks.org/program-change-rgb-color-model-hsv-color-model/\nassert rgb_to_hsv(255, 255, 255)==(0, 0.0, 100.0)\n\"\"\"\n\ndef rgb_to_hsv(r, g, b):\n r, g, b = r/255.0, g/255.0, b/255.0\n max_value = max(r, g, b)\n min_value = min(r, g, b)\n diff = max_value - min_value\n if max_value == min_value:\n hue = 0\n elif max_value == r:\n hue = (60 * ((g - b) / diff) + 360) % 360\n elif max_value == g:\n hue = (60 * ((b - r) / diff) + 120) % 360\n elif max_value == b:\n hue = (60 * ((r - g) / diff) + 240) % 360\n if max_value == 0:\n saturation = 0\n else:\n saturation = (diff / max_value) * 100\n value = max_value * 100\n return round(hue, 2), round(saturation, 2), round(value, 2)\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [[0, 215, 0]], "plus_fail_tests": [[0, 0, 1]]}], "Mbpp/801": [{"task_id": "Mbpp/801", "solution": "\"\"\"\nWrite a python function to count the number of equal numbers from three given integers.\nassert test_three_equal(1,1,1) == 3\n\"\"\"\n\ndef test_three_equal(a, b, c):\n count = 0\n if a == b == c:\n count = 3\n elif a == b or a == c or b == c:\n count = 2\n return count\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/787": [{"task_id": "Mbpp/787", "solution": "\"\"\"\nWrite a function that matches a string that has an a followed by three 'b'.\nassert not text_match_three(\"ac\")\n\"\"\"\n\nimport re\n\ndef text_match_three(text):\n pattern = r\"ab{3}\"\n return re.search(pattern, text)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/778": [{"task_id": "Mbpp/778", "solution": "\"\"\"\nWrite a function to pack consecutive duplicates of a given list elements into sublists.\nassert 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]]\n\"\"\"\n\ndef pack_consecutive_duplicates(lst):\n result = []\n current_sublist = []\n previous_element = None\n for element in lst:\n if element == previous_element:\n current_sublist.append(element)\n else:\n if current_sublist:\n result.append(current_sublist)\n current_sublist = [element]\n previous_element = element\n if current_sublist:\n result.append(current_sublist)\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/793": [{"task_id": "Mbpp/793", "solution": "\"\"\"\nWrite a python function to find the last position of an element in a sorted array.\nassert last([1,2,3],1) == 0\n\"\"\"\n\ndef last(nums, target):\n left, right = 0, len(nums) - 1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] <= target:\n left = mid + 1\n else:\n right = mid - 1\n return right\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/796": [{"task_id": "Mbpp/796", "solution": "\"\"\"\nWrite function to find the sum of all items in the given dictionary.\nassert return_sum({'a': 100, 'b':200, 'c':300}) == 600\n\"\"\"\n\ndef return_sum(input_dict):\n total = 0\n for value in input_dict.values():\n total += value\n return total\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/800": [{"task_id": "Mbpp/800", "solution": "\"\"\"\nWrite a function to remove all whitespaces from a string.\nassert remove_all_spaces('python program')==('pythonprogram')\n\"\"\"\n\ndef remove_all_spaces(string):\n new_string = ''\n for char in string:\n if char!='':\n new_string += char\n return new_string\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/805": [{"task_id": "Mbpp/805", "solution": "\"\"\"\nWrite a function that returns the list in a list of lists whose sum of elements is the highest.\nassert max_sum_list([[1,2,3], [4,5,6], [10,11,12], [7,8,9]])==[10, 11, 12]\n\"\"\"\n\ndef max_sum_list(lst):\n max_sum = 0\n max_list = []\n for sublist in lst:\n if sum(sublist) > max_sum:\n max_sum = sum(sublist)\n max_list = sublist\n return max_list\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[[-10, -20, -30], [-40, -50, -60], [-70, -80, -90], [-100, -110, -120]]]]}], "Mbpp/806": [{"task_id": "Mbpp/806", "solution": "\"\"\"\nWrite a function to find maximum run of uppercase characters in the given string.\nassert max_run_uppercase('GeMKSForGERksISBESt') == 5\n\"\"\"\n\ndef max_run_uppercase(s):\n max_run = 0\n current_run = 0\n for c in s:\n if c.isupper():\n current_run += 1\n else:\n max_run = max(max_run, current_run)\n current_run = 0\n max_run = max(max_run, current_run)\n return max_run\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["Aaa"]]}], "Mbpp/808": [{"task_id": "Mbpp/808", "solution": "\"\"\"\nWrite a function to check if the given tuples contain the k or not.\nassert check_K((10, 4, 5, 6, 8), 6) == True\n\"\"\"\n\ndef check_K(tuple, k):\n return k in tuple\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/799": [{"task_id": "Mbpp/799", "solution": "\"\"\"\nWrite a function to that rotate left bits by d bits a given number. We assume that the number is 32 bit.\nassert left_rotate(16,2) == 64\n\"\"\"\n\ndef left_rotate(n, d):\n return (n << d) | (n >> (32 - d))\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/798": [{"task_id": "Mbpp/798", "solution": "\"\"\"\nWrite a python function to find the sum of an array.\nassert _sum([1, 2, 3]) == 6\n\"\"\"\n\ndef _sum(arr):\n total = 0\n for num in arr:\n total += num\n return total\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/392": [{"task_id": "Mbpp/392", "solution": "\"\"\"\nWrite a function to find the maximum sum possible by using the given equation f(n) = max( (f(n/2) + f(n/3) + f(n/4) + f(n/5)), n).\nassert get_max_sum(60) == 106\n\"\"\"\n\ndef get_max_sum(n):\n if n <= 0:\n return 0\n if n == 1:\n return 1\n return max(get_max_sum(n // 2) + get_max_sum(n // 3) + get_max_sum(n // 4) + get_max_sum(n // 5), n)\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[1000000]]}], "Mbpp/794": [{"task_id": "Mbpp/794", "solution": "\"\"\"\nWrite a function that matches a string that has an 'a' followed by anything, ending in 'b'.\nassert text_starta_endb(\"aabbbb\")\n\"\"\"\n\nimport re\n\ndef text_starta_endb(text):\n pattern = re.compile(r\"^a.*b$\")\n return pattern.match(text) is not None\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [["xaabbyz1323ababb"]]}], "Mbpp/804": [{"task_id": "Mbpp/804", "solution": "\"\"\"\nWrite a function to check whether the product of numbers in a list is even or not.\nassert is_product_even([1,2,3])\n\"\"\"\n\ndef is_product_even(numbers):\n product = 1\n for num in numbers:\n product *= num\n return product % 2 == 0\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/803": [{"task_id": "Mbpp/803", "solution": "\"\"\"\nWrite a function to check whether the given number is a perfect square or not. https://www.geeksforgeeks.org/check-if-given-number-is-perfect-square-in-cpp/\nassert not is_perfect_square(10)\n\"\"\"\n\ndef is_perfect_square(num):\n return num ** 0.5 % 1 == 0\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/807": [{"task_id": "Mbpp/807", "solution": "\"\"\"\nWrite a python function to find the first odd number in a given list of numbers.\nassert first_odd([1,3,5]) == 1\n\"\"\"\n\ndef first_odd(numbers):\n for num in numbers:\n if num % 2 == 1:\n return num\n return None\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/809": [{"task_id": "Mbpp/809", "solution": "\"\"\"\nWrite a function to check if each element of second tuple is smaller than its corresponding element in the first tuple.\nassert check_smaller((1, 2, 3), (2, 3, 4)) == False\n\"\"\"\n\ndef check_smaller(tuple1, tuple2):\n return all(x < y for x, y in zip(tuple1, tuple2))\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[[3, 7, 11, 15, 19], [2, 6, 10, 14, 18]]]}], "Mbpp/797": [{"task_id": "Mbpp/797", "solution": "\"\"\"\nWrite a python function to find the sum of all odd natural numbers within the range l and r.\nassert sum_in_range(2,5) == 8\n\"\"\"\n\ndef sum_in_range(l, r):\n sum = 0\n for i in range(l, r+1):\n if i % 2 == 1:\n sum += i\n return sum\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/630": [{"task_id": "Mbpp/630", "solution": "\"\"\"\nWrite a function to extract all the adjacent coordinates of the given coordinate tuple.\nassert get_coordinates((3, 4)) == [[2, 3], [2, 4], [2, 5], [3, 3], [3, 4], [3, 5], [4, 3], [4, 4], [4, 5]]\n\"\"\"\n\ndef get_coordinates(coordinate):\n x, y = coordinate\n return [[x - 1, y - 1], [x - 1, y], [x - 1, y + 1], [x, y - 1], [x, y], [x, y + 1], [x + 1, y - 1], [x + 1, y], [x + 1, y + 1]]\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/605": [{"task_id": "Mbpp/605", "solution": "\"\"\"\nWrite a function to check if the given integer is a prime number.\nassert prime_num(13)==True\n\"\"\"\n\ndef prime_num(num):\n if num <= 1:\n return False\n for i in range(2, num):\n if num % i == 0:\n return False\n return True\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[999999999989]]}], "Mbpp/583": [{"task_id": "Mbpp/583", "solution": "\"\"\"\nWrite a function which returns nth catalan number.\nassert catalan_number(10)==16796\n\"\"\"\n\ndef catalan_number(n):\n if n <= 1:\n return 1\n result = 0\n for i in range(n):\n result += catalan_number(i) * catalan_number(n - i - 1)\n return result\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/765": [{"task_id": "Mbpp/765", "solution": "\"\"\"\nWrite a function to find nth polite number. geeksforgeeks.org/n-th-polite-number/\nassert is_polite(7) == 11\n\"\"\"\n\ndef is_polite(n):\n for i in range(1, n + 1):\n if i * (i + 1) // 2 == n:\n return i\n return -1\n", "base_status": "fail", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/739": [{"task_id": "Mbpp/739", "solution": "\"\"\"\nWrite a python function to find the index of smallest triangular number with n digits. https://www.geeksforgeeks.org/index-of-smallest-triangular-number-with-n-digits/\nassert find_Index(2) == 4\n\"\"\"\n\ndef find_Index(n):\n num = 1\n count = 1\n while count < n:\n num += 1\n count = len(str(num * (num + 1) // 2))\n return num\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[100]]}], "Mbpp/752": [{"task_id": "Mbpp/752", "solution": "\"\"\"\nWrite a function to find the nth jacobsthal number. https://www.geeksforgeeks.org/jacobsthal-and-jacobsthal-lucas-numbers/ 0, 1, 1, 3, 5, 11, 21, 43, 85, 171, 341, 683, 1365, 2731, ...\nassert jacobsthal_num(5) == 11\n\"\"\"\n\ndef jacobsthal_num(n):\n if n == 0:\n return 0\n elif n == 1:\n return 1\n else:\n return jacobsthal_num(n - 1) + 2 * jacobsthal_num(n - 2)\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/781": [{"task_id": "Mbpp/781", "solution": "\"\"\"\nWrite a python function to check whether the count of divisors is even. https://www.w3resource.com/python-exercises/basic/python-basic-1-exercise-24.php\nassert count_divisors(10)\n\"\"\"\n\ndef count_divisors(num):\n count = 0\n for i in range(1, num + 1):\n if num % i == 0:\n count += 1\n return count % 2 == 0\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[987654321]]}], "Mbpp/389": [{"task_id": "Mbpp/389", "solution": "\"\"\"\nWrite a function to find the n'th lucas number.\nassert find_lucas(9) == 76\n\"\"\"\n\ndef find_lucas(n):\n if n == 0:\n return 2\n if n == 1:\n return 1\n return find_lucas(n - 1) + find_lucas(n - 2)\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/255": [{"task_id": "Mbpp/255", "solution": "\"\"\"\nWrite a function that takes in a list and length n, and generates all combinations (with repetition) of the elements of the list and returns a list with a tuple for each combination.\nassert combinations_colors( [\"Red\",\"Green\",\"Blue\"],1)==[('Red',), ('Green',), ('Blue',)]\n\"\"\"\n\nfrom itertools import combinations_with_replacement\n\ndef combinations_colors(colors, n):\n return list(combinations_with_replacement(colors, n))\n", "base_status": "pass", "plus_status": "fail", "base_fail_tests": [], "plus_fail_tests": [[["Dog", "Cat", "CatBird", "Bird", "Fish"], 77]]}], "Mbpp/271": [{"task_id": "Mbpp/271", "solution": "\"\"\"\nWrite a python function that takes in an integer n and finds the sum of the first n even natural numbers that are raised to the fifth power.\nassert even_Power_Sum(2) == 1056\n\"\"\"\n\ndef even_Power_Sum(n):\n sum = 0\n for i in range(1, n+1):\n num = 2 * i\n sum += num ** 5\n return sum\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}], "Mbpp/599": [{"task_id": "Mbpp/599", "solution": "\"\"\"\nWrite a function to find sum and average of first n natural numbers.\nassert sum_average(10)==(55, 5.5)\n\"\"\"\n\ndef sum_average(n):\n sum = 0\n for i in range(1, n+1):\n sum += i\n average = sum / n\n return sum, average\n", "base_status": "pass", "plus_status": "pass", "base_fail_tests": [], "plus_fail_tests": []}]}} selfcodealign-selfcodealign/evaluation/text2code.py 0000664 0000000 0000000 00000011457 14637551746 0023126 0 ustar 00root root 0000000 0000000 import warnings
if __name__ == "__main__":
# Deprecate warning
warnings.warn(
"This module is deprecated. Use `evaluation.text2code_vllm` instead.",
DeprecationWarning,
)
# Press y to continue
if input("Do you want to continue? [y/N]: ").lower() != "y":
exit()
import itertools
from dataclasses import dataclass
from pathlib import Path
from typing import Literal, TypedDict, cast
from evalplus.data import get_human_eval_plus, get_mbpp_plus, write_jsonl
from tqdm.auto import tqdm
from transformers import HfArgumentParser
from star_align.llm_wrapper import GenerationConfig, get_model_context
from star_align.prompt_template import SC2_INSTRUCT_PROMPT as PROMPT_TEMPLATE
from star_align.utils import chunked
class Text2CodeProblem(TypedDict):
id: str
instruction: str
response_prefix: str
def get_mbpp_raw_problems() -> list[dict]:
problems = get_mbpp_plus()
return list(problems.values())
def get_humaneval_raw_problems() -> list[dict]:
problems = get_human_eval_plus()
return list(problems.values())
def map_mbpp_problem(p: dict) -> Text2CodeProblem:
id = p["task_id"]
prompt = p["prompt"]
start_index = prompt.index('"""')
end_index = prompt.rindex('"""')
prompt = prompt[start_index + 3 : end_index]
assert_index = prompt.index("assert")
instruction = prompt[:assert_index].strip()
if not instruction.endswith("."):
instruction += "."
assertion = prompt[assert_index:].strip()
instruction = f"""{instruction}
Your code should pass the following assertion:
```python
{assertion}
```"""
prefix = "" if PROMPT_TEMPLATE.endswith("\n") else "\n"
response_prefix = f"""{prefix}```python"""
return Text2CodeProblem(
id=str(id), instruction=instruction, response_prefix=response_prefix
)
def map_humaneval_problem(p: dict) -> Text2CodeProblem:
id = p["task_id"]
prompt = p["prompt"]
prompt = prompt.strip()
prompt_header = "Write a Python function to solve the given task:"
instruction = f"""{prompt_header}
```python
{prompt}
```"""
prefix = "" if PROMPT_TEMPLATE.endswith("\n") else "\n"
prefix_template = "```python\n{prompt}"
response_prefix = prefix + (
prefix_template.replace("{prompt}", prompt)
if "{prompt}" in prefix_template
else prefix_template
)
return Text2CodeProblem(
id=id, instruction=instruction, response_prefix=response_prefix
)
@dataclass(frozen=True)
class Args:
model_key: str
dataset: Literal["humaneval", "mbpp"]
save_path: str
n_batches: int
n_problems_per_batch: int
n_samples_per_problem: int
model_name_or_path: str | None = None
def main():
parser = HfArgumentParser((Args, GenerationConfig))
args, generation_config = cast(
tuple[Args, GenerationConfig],
parser.parse_args_into_dataclasses(),
)
raw_problem_fn, map_problem_fn = (
(get_humaneval_raw_problems, map_humaneval_problem)
if args.dataset == "humaneval"
else (get_mbpp_raw_problems, map_mbpp_problem)
)
raw_problems = raw_problem_fn()
problems = list(map(map_problem_fn, raw_problems))
state = get_model_context(args.model_key, args.model_name_or_path)
problems_chunked = list(chunked(list(problems), args.n_problems_per_batch))
iter = itertools.product(problems_chunked, range(args.n_batches))
n_total = len(problems_chunked) * args.n_batches
Path(args.save_path).write_text("")
for problems, batch_idx in tqdm(iter, total=n_total):
task_ids = [problem["id"] for problem in problems]
prompts = [
# TODO: make it generic for all models
PROMPT_TEMPLATE.format(
instruction=problem["instruction"], response=problem["response_prefix"]
)
for problem in problems
]
print("PROMPT")
print(prompts[-1])
all_prompts = prompts * args.n_samples_per_problem
all_task_ids = task_ids * args.n_samples_per_problem
response = state.complete(generation_config, all_prompts, stop_tokens=["\n```"])
completions = response.decoded_outputs
assert len(problems) <= args.n_problems_per_batch
assert len(completions) == len(problems) * args.n_samples_per_problem
print("COMPLETION")
print(completions[-1])
samples = [
dict(
task_id=task_id,
completion=completion[
: (
index
if (index := completion.find("```")) != -1
else len(completion)
)
],
)
for task_id, completion in zip(all_task_ids, completions)
]
write_jsonl(args.save_path, samples, append=True)
if __name__ == "__main__":
main()
selfcodealign-selfcodealign/evaluation/text2code_vllm.py 0000664 0000000 0000000 00000013721 14637551746 0024154 0 ustar 00root root 0000000 0000000 import os
from dataclasses import dataclass, field
from pathlib import Path
from typing import Literal, TypedDict, cast
from evalplus.data import get_human_eval_plus, get_mbpp_plus, write_jsonl
from evoeval.data import get_evo_eval
from transformers import HfArgumentParser
from star_align.utils import infer_prompt_template, is_base_model
from vllm import LLM, SamplingParams
class Text2CodeProblem(TypedDict):
id: str
prompt: str
instruction: str
response_prefix: str
# MBPP_INSTRUCTION = """{nl_description} Your code should satisfy the following assertion:
# ```python
# {assertions}
# ```
# Enclose your solution in ```python and ```"""
def get_mbpp_raw_problems() -> list[dict]:
problems = get_mbpp_plus()
return list(problems.values())
def get_humaneval_raw_problems() -> list[dict]:
problems = get_human_eval_plus()
return list(problems.values())
def get_evoeval_raw_problems(dataset: str):
def get_raw_problems() -> list[dict]:
problems = get_evo_eval(dataset)
return list(problems.values())
return get_raw_problems
def map_mbpp_problem(p: dict) -> Text2CodeProblem:
id = p["task_id"]
prompt = p["prompt"]
start_index = prompt.index('"""')
end_index = prompt.rindex('"""')
prompt = prompt[start_index + 3 : end_index]
assert_index = prompt.index("assert")
instruction = prompt[:assert_index].strip()
if not instruction.endswith("."):
instruction += "."
assertion = prompt[assert_index:].strip()
instruction = f"""{instruction}
```python
{assertion}
```"""
prefix = ""
response_prefix = f"""{prefix}```python"""
return Text2CodeProblem(
id=str(id),
prompt=prompt,
instruction=instruction,
response_prefix=response_prefix,
)
def map_humaneval_problem(p: dict) -> Text2CodeProblem:
id = p["task_id"]
prompt = p["prompt"]
prompt = prompt.strip()
# try:
# docstring_index = prompt.index('"""')
# except ValueError:
# docstring_index = prompt.index("'''")
# signature = prompt[:docstring_index].strip()
# Instruction
# instruction = f"""Complete the implementation of the following function:
prompt_header = os.getenv(
"PROMPT_HEADER", "Write a Python function to solve the following task:"
)
instruction = f"""{prompt_header}
```python
{prompt}
```"""
prefix = ""
prefix_template = os.getenv("PREFIX_TEMPLATE", "```python")
response_prefix = prefix + (
prefix_template.replace("{prompt}", prompt)
if "{prompt}" in prefix_template
else prefix_template
)
# response_prefix = f"""{prefix}```python
# {prompt}"""
return Text2CodeProblem(
id=id,
prompt=prompt,
instruction=instruction,
response_prefix=response_prefix,
)
@dataclass(frozen=True)
class Args:
model_key: str
dataset: Literal[
"humaneval",
"mbpp",
"EvoEval_difficult",
"EvoEval_creative",
"EvoEval_subtle",
"EvoEval_combine",
"EvoEval_tool_use",
"EvoEval_verbose",
"EvoEval_concise",
]
save_path: str
n_samples_per_problem: int = field(default=1)
max_new_tokens: int = field(default=1024)
top_p: float = field(default=1.0)
temperature: float = field(default=0.0)
model_name_or_path: str | None = None
def main():
args = cast(Args, HfArgumentParser(Args).parse_args_into_dataclasses()[0])
raw_problem_fn, map_problem_fn = (
(get_evoeval_raw_problems(args.dataset), map_humaneval_problem)
if args.dataset.startswith("EvoEval_")
else (
(get_humaneval_raw_problems, map_humaneval_problem)
if args.dataset == "humaneval"
else (get_mbpp_raw_problems, map_mbpp_problem)
)
)
raw_problems = raw_problem_fn()
problems = list(map(map_problem_fn, raw_problems))
engine = LLM(
tokenizer=args.model_key, model=args.model_name_or_path or args.model_key
)
base_model_prompt = is_base_model(args.model_key)
stop: str | list[str] = (
"\n```\n"
if not base_model_prompt
else ["\ndef ", "\nclass ", "\nimport ", "\nfrom ", "\nassert ", "\n# "]
)
sampling_params = SamplingParams(
n=args.n_samples_per_problem,
temperature=args.temperature,
max_tokens=args.max_new_tokens,
top_k=-1,
top_p=args.top_p,
stop=stop,
)
if base_model_prompt:
print("Base model")
else:
prompt_template = infer_prompt_template(
os.getenv("TOKENIZER") or args.model_name_or_path or args.model_key
)
# prompt_template = PROMPT_TEMPLATE
print("Using:", prompt_template)
prompts: list[str] = []
for problem in problems:
if not base_model_prompt:
prompt = prompt_template.format(
instruction=problem["instruction"], response=problem["response_prefix"]
)
else:
prompt = problem["prompt"]
prompts.append(prompt)
results = engine.generate(prompts, sampling_params)
Path(args.save_path).write_text("")
step = 20
print_or_not = [idx == 0 or idx % step == 0 for idx in range(len(problems))]
def sanitize(output: str) -> str:
if not base_model_prompt:
return output.split("```python")[-1].split("```")[0]
for s in stop:
output = output.rsplit(s, 1)[0]
return output
for problem, prompt, result, print_debug in zip(
problems, prompts, results, print_or_not
):
if print_debug:
print("[Example Prompt]")
print(prompt)
print("[Example Completion]")
print(result.outputs[0].text)
samples = [
dict(
task_id=problem["id"],
completion=sanitize(output.text),
)
for output in result.outputs
]
write_jsonl(args.save_path, samples, append=True)
if __name__ == "__main__":
main()
selfcodealign-selfcodealign/prompts/ 0000775 0000000 0000000 00000000000 14637551746 0020200 5 ustar 00root root 0000000 0000000 selfcodealign-selfcodealign/prompts/self-ossinstruct-fewshot.txt 0000664 0000000 0000000 00000205531 14637551746 0025753 0 ustar 00root root 0000000 0000000 ### System: I->R
You are an extremely intelligent AI coding assistant. Please provide an accurate and reliable response to each user instruction. After delivering your response, verify its consistency and correctness by writing a series of executable tests.
### System: C->I
Create a series of independent coding tasks that are original, distinct, diverse, and high-quality, fostering logical thinking. Each task must adhere to specified properties:
- category: the type of task (e.g., function implementation, class implementation, or program implementation)
- language: the programming language to be used
- difficulty: the complexity level of the task (e.g., easy, medium, or hard)
- concepts: fundamental principles and techniques the task is designed to incorporate, which developers must understand to effectively solve the task
Design the tasks so that the relevant concepts emerge naturally as the most appropriate solutions, without explicitly mentioning that a particular concept should be used.
### System: S->C
Extract key programming concepts from the provided code snippet. Programming concepts refer to the foundational principles and techniques used in programming, which are crucial for developers to master. List these concepts in a comma-separated format.
### System: S->I
Gain inspiration from the given code snippets and create a series of independent coding tasks that are original, distinct, diverse, and high-quality, fostering logical thinking.
### Example 1
[Code]
value = int(round((value - prev) * 1e5))
value = ~(value << 1) if value < 0 else (value << 1)
chunks = _split_into_chunks(value)
return (chr(chunk + 63) for chunk in chunks)
def _split_into_chunks(value):
while value >= 32: # 2^5, while there are at least 5 bits
# first & with 2^5-1, zeros out all the bits other than the first five
# then OR with 0x20 if another bit chunk follows
yield (value & 31) | 0x20
value >>= 5
[Property]
category: function implementation
language: Python
difficulty: medium
concepts: 5-bit chunk encoding with bitwise shifts, ASCII value manipulation, continuation bit signaling
[Instruction]
Create a Python function to encode an integer into a sequence of encoded characters, where each character represents a 5-bit chunk of the integer. The ASCII value of each chunk character is formed by adding 63 to the 5-bit chunk's value. For all chunks except the last one, set the 6th bit to 1 to indicate continuation. Employ bitwise operations for this encoding process.
[Response]
To encode an integer into a sequence of encoded characters based on the specified criteria, let's follow these steps:
1. Break down the integer into 5-bit chunks: Extract 5-bit chunks from the integer using using `& 31` (`0x1F`), because the binary representation of `31` (`11111`) has the last five bits set, which will effectively extract the 5 bits we are interested in. We start from the least significant bits (LSB).
2. Set continuation bit: For all chunks except the last one, set the 6th bit to 1 using `| 32` (`0x20`) because the binary representation of `32` (`100000`) has the 6th bit set to 1. This indicates that there's another continuation chunk following.
3. Shift right: Right-shift the value by 5 to process the next 5 bits.
4. Convert to characters: Use `ord` and `chr` to convert each chunk (now effectively 6 bits due to the continuation bit) into a character by adding 63 to its value. This ensures that the character is within a printable ASCII range.
5. Assembly: Assemble these characters into the final encoded string while maintaining the order of the chunks through `reversed`.
Here's how you can implement this function:
```python
def encode_integer_to_chars(value: int) -> str:
if value == 0:
return chr(63)
encoded_chars = []
while value > 0:
chunk = (value & 31) + 63
value >>= 5
if value > 0:
chunk |= 32
encoded_chars.append(chr(chunk))
return ''.join(reversed(encoded_chars))
```
Keep in mind that this function is designed for non-negative integers. In Python, right-shifting (`>>`) a negative integer preserves the sign bit, which could lead to infinite loops or other incorrect behaviors if the same encoding approach is applied to negative integers without appropriate adjustments.
[Tests]
You can validate this function with the following test cases that cover scenarios from zero to a number requiring more than one chunk, ensuring the function operates as expected:
```python
assert encode_integer_to_chars(0) == chr(63)
assert encode_integer_to_chars(1) == chr(63 + 1)
assert encode_integer_to_chars(31) == chr(63 + 31)
assert encode_integer_to_chars(int(0b1)) == chr(0b1 + 63)
assert encode_integer_to_chars(int(0b1000001)) == chr(0b10 + 63) + chr(63 + 0b100001)
```
### Example 2
[Code]
def ceil_shift(n, b):
"""Return ceil(n / 2**b) without performing any floating-point or division operations.
This is done by right-shifting n by b bits and incrementing the result by 1
if any '1' bits were shifted out.
"""
if not isinstance(n, int) or not isinstance(b, int):
raise TypeError("unsupported operand type(s): %r and %r" % (type(n).__name__, type(b).__name__))
assert n >= 0 and b >= 0 # I haven't tested or even thought about negative values
mask = (1 << b) - 1
if n & mask:
return (n >> b) + 1
else:
[Property]
category: function implementation
language: Python
difficulty: medium
concepts: bitwise operation for division, ceiling without division or float, input validation with assertions, non-negative integer checks
[Instruction]
Develop a Python function `ceil_divide_without_div` that computes the ceiling of `n / 2**b` without using division, floating-point operations, built-in functions like `math.ceil`, or converting it into computing the floor. Instead, use bit manipulation to achieve the result. You write assertions to ensure both `n` and `b` are non-negative integers.
[Response]
We can leverage the properties of bitwise operations to develop a Python function that computes the ceiling of `n / 2**b` without using division, floating-point operations, or any built-in functions like `math.ceil`, and strictly avoiding converting the problem into a floor computation.
In the context, dividing by `2**b` is equivalent to right-shifting `n` by `b` bits in binary representation when `n` is divisible by `2**b`. Otherwise, this approach inherently computes the floor of the division. To adjust for the ceiling without directly calculating it, we can consider two cases:
1. If `n` is divisible by `2**b`, the result of the division is simply the value of right-shifting `n` by `b` bits.
2. Otherwise, we need to increment the right-shifted result by 1 to achieve the ceiling effect.
To determine the divisibility of `n` by `2**b`, we can check if the first `b` bits of `n` are all 0. This can be done using a mask with the first `b` bits set to 1, and then performing a bitwise AND operation with `n`. If the result is 0, it indicates that `n` is divisible by `2**b`. The mask can be created using `mask = (1 << b) - 1`.
We'll also include assertions to ensure that `n` and `b` are non-negative integers.
Here is the implementation of `ceil_divide_without_div`:
```python
def ceil_divide_without_div(n: int, b: int) -> int:
assert isinstance(n, int) and n >= 0, "n must be a non-negative integer"
assert isinstance(b, int) and b >= 0, "b must be a non-negative integer"
mask = (1 << b) - 1
divisible = (n & mask) == 0
result = n >> b
if not divisible:
result += 1
return result
```
This function calculates the ceiling of `n / 2**b` purely through bitwise manipulation and integer arithmetic. The assertions ensure the input constraints are met, as specified.
[Tests]
To verify the correctness of the function, we can compare the results of our function with the expected results obtained using `math.ceil` to ensure the correctness of the ceiling division operation:
```python
import math
assert ceil_divide_without_div(10, 3) == math.ceil(10 / 2**3)
assert ceil_divide_without_div(17, 4) == math.ceil(17 / 2**4)
assert ceil_divide_without_div(100, 5) == math.ceil(100 / 2**5)
assert ceil_divide_without_div(0, 3) == math.ceil(0 / 2**3)
assert ceil_divide_without_div(1, 0) == math.ceil(1 / 2**0)
```
### Example 3
[Code]
isprime = n >= 2 and 1 or 0
for prime in prime_list: # Check for factors with all primes
if prime * prime > n: break # ... up to sqrt(n)
if not n % prime:
isprime = 0
break
if isprime: prime_dict[n] = 1 # Maintain a dictionary for fast lookup
return isprime
def prime(x):
''' Returns the xth prime '''
lastn = prime_list[-1]
while len(prime_list) <= x: # Keep working until we've got the xth prime
lastn = lastn + 1 # Check the next number
[Property]
category: class implementation
language: Python
difficulty: medium
concepts: prime number memoization, n-th prime calculation, efficiency in prime checks
[Instruction]
Implement a Python class with a method `find_nth_prime_memoized(n)` that returns the nth prime number, where n is a positive integer. Utilize memoization to store already found prime numbers in a list within the class to avoid recalculating primes for multiple method calls. Ensure the method efficiently updates and references this list to find new primes as needed. Additionally, enhance performance by avoiding unnecessary prime checks.
[Response]
Implementing the required Python class with the method `find_nth_prime_memoized(n)` involves several key steps:
1. The class should have a constructor `__init__` that initializes the cache list to store the memoized prime numbers. Initially, the list can be seeded with the first two prime numbers, 2 and 3.
2. The method `find_nth_prime_memoized` will check if the requested `n`th prime is already in the memoized list. If it is, it will return that prime directly. If not, it will start from the last cached prime and continue to find and cache new primes until the `n`th prime is found.
3. A helper method `is_prime` can be defined to check if a number is prime. To efficiently check for primality:
- It checks if the number is divisible by each of the primes already in the cache.
- It only checks up to the square root of the number to be tested, implemented by comparing the square of the prime with the number.
- It skips even numbers by incrementing by 2 for each prime check. This is sound since the cache is initialized with the first **two** primes, 2 and 3.
Here is how you could implement such a class:
```python
class PrimeFinder:
def __init__(self):
self.primes = [2, 3]
def is_prime(self, num: int) -> bool:
if num < 2:
return False
for prime in self.primes:
if prime * prime > num:
break
if num % prime == 0:
return False
return True
def find_nth_prime_memoized(self, n: int) -> int:
if n <= len(self.primes):
return self.primes[n - 1]
current_num = self.primes[-1] + 2
while len(self.primes) < n:
if self.is_prime(current_num):
self.primes.append(current_num)
current_num += 2
return self.primes[n - 1]
```
[Tests]
Here's how you can test this class by verifying that the class correctly finds the first few primes and that subsequent calls return the memoized results directly:
```python
first_few_primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
prime_finder = PrimeFinder()
for i, prime in enumerate(first_few_primes, 1):
assert prime_finder.find_nth_prime_memoized(i) == prime
for i, prime in enumerate(first_few_primes, 1):
assert prime_finder.find_nth_prime_memoized(i) == prime
```
### Example 4
[Code]
return (a + 1) * (b + 1) - 1
def keys_count(a, b):
return powerset(a, b) * 2 - a - b
def formula(k):
if k % 2 != 0:
return ((k + 1) ** 2) / 2 + k + 1
else:
return (k ** 2) / 2 + 2 * k + 1
def multiset_powerset(multiset):
n = len(multiset)
c = [0] * n
while True:
changed = False
i = n - 1
while i >= 0 and not changed:
[Property]
category: function implementation
language: Python
difficulty: easy
concepts: special formula implementation, odd and even number handling, function composition
[Instruction]
Here are two special formulas:
$$
f_1(a, b) = (a + 1) \cdot (b + 1) - 1
$$
$$
f_2(k) = \begin{cases}
\frac{(k + 1)^2}{2} + k + 1 & \text{if } k \text{ is odd} \\
\frac{k^2}{2} + 2k + 1 & \text{if } k \text{ is even}
\end{cases}
$$
Write a Python function to return $f_2(f_1(a, b))$ for given `a` and `b`.
[Response]
Based on the formulas you provided, we can define two Python functions, `f1(a, b)` and `f2(k)`, respectively, and then combine them to calculate $f2(f1(a, b))$ for given `a` and `b`.
Here is the implementation:
```python
def f1(a, b):
return (a + 1) * (b + 1) - 1
def f2(k):
if k % 2 == 0:
return (k**2) / 2 + 2 * k + 1
else:
return ((k + 1)**2) / 2 + k + 1
def f1_f2_combined(a, b):
return f2(f1(a, b))
```
In this implementation:
- `f1(a, b)` calculates the first formula you've given.
- `f2(k)` calculates the second formula, with a conditional branch for whether `k` is even or odd.
- `f1_f2_combined(a, b)` uses the output of `f1(a, b)` as the input for `f2(k)` and returns the result.
[Tests]
To test this combined function, you can simply compare it with the direct application of `f2` to the result of `f1` for different values of `a` and `b`:
```python
assert f1_f2_combined(2, 3) == f2(f1(2, 3))
assert f1_f2_combined(4, 5) == f2(f1(4, 5))
assert f1_f2_combined(6, 7) == f2(f1(6, 7))
```
### Example 5
[Code]
while left= start and left <= ryt:
mid = (left+ryt)//2
if arr[mid] == target:
return mid
elif arr[mid] > target:
ryt = mid-1
else:
left = mid+1
return left
def tripletsSorting(nums, t):
# TimeComplexity = O((n^2)logn)
nums.sort()
count = 0
for i in range(len(nums)):
[Property]
category: function implementation
language: Python
difficulty: easy
concepts: insertion point for a sorted array, optimized time complexity
[Instruction]
Design a Python function that takes a sorted array and a target value, and return a valid index where target can be inserted to maintain the array's sorted order. Optimize the function to run in logarithmic time complexity.
For example, given `array = [1, 3, 5, 5, 6]` and `target = 5`, the function should return either 2 or 3 because 5 presents at both indices 2 and 3.
[Response]
To solve this problem efficiently and ensure logarithmic time complexity, we can use a binary search algorithm. Compared with a standard binary search that looks for an exact match, we can modify the algorithm such that when the target is not found, we return the `left` bound, which represents the index where the target can be inserted to maintain the array's sorted order. Since any valid index for insertion is acceptable, we can direclty return the index if there is an exact match.
Here is a Python function that implements this approach:
```python
from typing import List
def search_insert_position(nums: List[int], target: int) -> int:
"""
Finds the index to insert `target` into `nums` to maintain sorted order. For example,
given `nums = [1, 3, 5, 5, 6]` and `target = 5`, this function returns either 2 or 3,
as `target` can be inserted at index 2 or 3 to maintain the sorted order.
"""
left, right = 0, len(nums) - 1
while left <= right:
mid = (left + right) // 2
if nums[mid] == target:
return mid
elif nums[mid] < target:
left = mid + 1
else:
right = mid - 1
return left
```
This implementation ensures that when `target` is not found, `left` represents the correct insertion index. This is because at the end of the loop, all elements to the left of `left` are smaller than `target`, all elements to the right of `left` are equal to or larger than `target`, and `left > right`. Therefore, `left` is the correct index for insertion to maintain the sorted order.
[Tests]
You can test the function with scenarios where the target is found at multiple indices and where the target is not present in the array:
```python
assert search_insert_position([1, 3, 5, 5, 6], 5) in [2, 3]
assert search_insert_position([1, 3, 5, 5, 6], 2) == 1
assert search_insert_position([1, 3, 5, 5, 6], 7) == 5
assert search_insert_position([1, 3, 5, 5, 6], 0) == 0
```
### Example 6
[Code]
def decompress(self):
source = self.compressed
if isinstance(source, (bytes, bytearray)):
return self.decompress_bytes()
pos = 0
node = self.root
res = bytearray()
while pos < len(source):
code = int(source[pos])
child = node.children[code]
if child.is_leaf:
res.append(child)
node = self.root
else:
node = child
pos += 1
return bytes(res)
[Property]
category: function implementation
language: Python
difficulty: medium
concepts: decoding compressed data, binary tree traversal, byte array processing
[Instruction]
Write a Python function `huffman_decompress` that takes two arguments: `compressed_data`, a byte array of 0/1 sequence representing Huffman compressed data, and `huffman_tree`, a Huffman tree that stores the actual data (each leaf is associated with a character). The function should return the original uncompressed data as `bytes`. Define the `HuffmanNode` class yourself as a general tree structure with a `children` list.
[Response]
To accomplish the Huffman decompression, we first need to define the `HuffmanNode` class, which, as required, should be a general tree structure with a `children` list and an optional `value` attribute to store the character associated with a leaf node.
Then, we'll implement the `huffman_decompress` function. This function will traverse the Huffman tree according to the bits in `compressed_data`. When it encounters a leaf node, the associated character will be appended to the result, and the traversal restarts from the root of the tree. This process continues until the entire `compressed_data` is processed.
You said that `compressed_data` is a byte array of 0/1 sequence, so I assume that each byte, not each bit, represents a step in the Huffman tree. In practice, it is more efficient
Here's how we can implement this:
```python
class HuffmanNode:
def __init__(self, value=None):
self.value = value
self.children = []
def huffman_decompress(compressed_data, huffman_tree):
result = []
node = huffman_tree
# Each byte represents a bit in `compressed_data`
for bit in compressed_data:
if len(node.children) > 0:
node = node.children[int(bit)]
if len(node.children) == 0:
result.append(node.value)
node = huffman_tree
return "".join(result).encode()
```
In this implementation, each byte in `compressed_data` represents a bit, guiding the traversal of the Huffman tree. Characters are appended upon reaching leaf nodes and the result is then encoded to `bytes`.
[Tests]
You can test this function with a sample Huffman tree and compressed data to verify that the decompression works correctly:
```python
root = HuffmanNode()
root.children = [HuffmanNode('A'), HuffmanNode('B')]
root.children[0].children = [HuffmanNode('C'), HuffmanNode('D')]
root.children[1].children = [HuffmanNode('E'), HuffmanNode('F')]
compressed_data = bytearray([0, 1, 0, 0, 1, 1])
# 01 -> D, 00 -> C, 11 -> F
assert huffman_decompress(compressed_data, root) == b'DCF'
```
### Example 7
[Code]
def format_size(num):
"""http://stackoverflow.com/a/1094933
"""
for x in ['bytes', 'KB', 'MB', 'GB']:
if num < 1024.0 and num > -1024.0:
return "%3.1f%s" % (num, x)
num /= 1024.0
return "%3.1f%s" % (num, 'TB')
assert format_size(1024**2 - 1) == '1024.0KB'
assert format_size(1024*512) == '512.0KB'
[Property]
category: function implementation
language: Python
difficulty: easy
concepts: arithmetic operations for size conversion, rounding numbers, dynamic unit selection, string interpolation
[Instruction]
Create a Python function to format a file size in bytes into a human-readable string representation, using 'bytes', 'KB' (kilobytes), 'MB' (megabytes), 'GB' (gigabytes), or 'TB' (terabytes) units. The output should be rounded to one decimal place and follow the format: "{X.Y}{Unit}", where "Unit" is the appropriate size unit and "X.Y" is the rounded size. For example, `format_size(1024 * 512)` should return `'512.0KB'`, and `format_size(1024**2 - 1)` should return `'1024.0KB'`.
[Response]
To create such a function, we can use a loop to iterate through a predefined list of units (`['bytes', 'KB', 'MB', 'GB', 'TB']`) and check if the given number of bytes fits into the current unit by comparing it with 1024.0 and -1024.0 (for handling negative sizes). We'll keep dividing the number by 1024.0 until the correct unit is found where the number is less than 1024.0. Then, we'll format the result using the appropriate unit and the rounded size.
```python
def format_size(size_bytes):
units = ['bytes', 'KB', 'MB', 'GB', 'TB']
# Directly return for 0 bytes to avoid division by zero in loop
if size_bytes == 0:
return "0.0bytes"
num = abs(size_bytes)
unit = units[0]
for u in units[1:]:
if num < 1024.0:
break
num /= 1024.0
unit = u
formatted_size = f"{num:.1f}{unit}"
return formatted_size if size_bytes >= 0 else f"-{formatted_size}"
```
This implementation handles both positive and negative file sizes and returns the formatted size as a string, even though negative sizes are not common in real-world scenarios.
[Tests]
We can write tests that cover both positive and negative sizes across different units to validate the correctness of the `format_size` function:
```python
test_data = [
(1024 ** 2, "1.0MB"),
(1024 ** 2 - 1, "1024.0KB"),
(1024 ** 3 * 512, "512.0GB"),
(1024 ** 4 * 512, "512.0TB"),
]
for size, expected_output in test_data:
assert format_size(size) == expected_output
assert format_size(-size) == f"-{expected_output}"
```
### Example 8
[Code]
def unify_stringlist(L: list):
""" Adds asterisks to strings that appear multiple times, so the resulting
list has only unique strings but still the same length, order, and meaning.
For example:
unify_stringlist(['a','a','b','a','c']) -> ['a','a*','b','a**','c']
"""
assert(all([isinstance(l,str) for l in L]))
return [L[i]+"*"*L[:i].count(L[i]) for i in range(len(L))]
assert unify_stringlist(list("abc")) == list("abc")
[Property]
category: function implementation
language: Python
difficulty: easy
concepts: list comprehension, unique string creation, precondition checking for type validation
[Instruction]
Design a Python function to encode a list of strings into a unique list with the same length, order, and meaning. The new list is formed by appending asterisks (*) to duplicate strings. For instance, given ['a', 'a', 'b', 'a', 'c'], the function should return ['a', 'a*', 'b', 'a**', 'c'], while for ['a', 'b', 'c'] it should return ['a', 'b', 'c'] without any changes. Write assertions to ensure the input is a list of strings.
Solve the problem in two lines of code, one for the precondition check and the other for the main logic.
[Response]
You can achieve this functionality by first ensuring the input meets your requirements using an `assert` statement with list comprehension. Then, use another list comprehension to iterate through the input list and append `'*'` to the strings. The number of `'*'` is the number of occurrences of the string before the current index.
Here's how you can do it in two lines of Python code:
```python
def encode_strings(input_list):
assert all(isinstance(item, str) for item in input_list), "Input must be a list of strings"
return [s + '*' * input_list[:i].count(s) for i, s in enumerate(input_list)]
```
Note that although the function is concise, it is not the most efficient solution for large lists, as the `count` method has a time complexity of O(n) for each iteration.
[Tests]
You can test the function with the provided examples to ensure it correctly encodes the strings as expected:
```python
assert encode_strings(['a', 'a', 'b', 'a', 'c']) == ['a', 'a*', 'b', 'a**', 'c']
assert encode_strings(['a', 'b', 'c']) == ['a', 'b', 'c']
```
### Example 9
[Code]
def _create_folds_list(data, count):
"""
Creates folds from the given data.
:param data: the data to fold
:param count: the number of folds to create
:return: a list of folds
"""
fold_count = len(data) / count
folds = list()
for fold_index in range(count):
low = int(fold_index * fold_count)
high = int((fold_index + 1) * fold_count)
fold = data[low:high]
folds.append(fold)
return folds
[Property]
category: function implementation
language: Python
difficulty: medium
concepts: data partitioning and slicing, learning from input-output examples
[Instruction]
Construct a Python function `create_folds(data, count)` to create a list of folds from the given data, where each fold is a subsequence of the original data. The length of each fold should be approximately equal with at most a difference of 1. The function should satisfy the following assertions:
```python
assert create_folds(range(12), 2) == [range(0, 6), range(6, 12)]
assert create_folds(range(8), 2) == [range(0, 4), range(4, 8)]
assert create_folds(range(25), -5) == []
assert create_folds(range(6), 2) == [range(0, 3), range(3, 6)]
```
[Response]
To create a Python function that generates a list of folds from given data with each fold having approximately equal length (with at most a difference of 1 between any two folds), you can follow these steps:
1. Return an empty list immediately if `count` is non-positive since it's not possible to create a valid number of folds.
2. Divide the total length of the data by `count`, rounding down, to get the minimum number of items each fold should have.
3. Calculate the remainder to see how many extra items need to be distributed among the folds. They are distributed one by one to the first `remainder` folds.
4. Use a loop to create each fold, adjusting the starting and ending indices based on the calculations above to ensure each fold has the correct number of items.
Here's how you can implement this:
```python
def create_folds(data, count):
# Return an empty list if count is non-positive
if count <= 0:
return []
data_length = len(data)
fold_size = data_length // count
remainder = data_length % count
folds = []
start_index = 0
for i in range(count):
# Add 1 element to each of the first `remainder` folds
end_index = start_index + fold_size + (1 if i < remainder else 0)
folds.append(range(start_index, end_index))
start_index = end_index
return folds
```
This implementation ensures that each fold has an equal length with at most a difference of 1 between any two folds. It handles edge cases, such as a non-positive `count`, by returning an empty list as specified.
[Tests]
You can test your code with the provided assertions to verify that the function works correctly:
```python
assert create_folds(range(12), 2) == [range(0, 6), range(6, 12)]
assert create_folds(range(8), 2) == [range(0, 4), range(4, 8)]
assert create_folds(range(25), -5) == []
assert create_folds(range(6), 2) == [range(0, 3), range(3, 6)]
```
### Example 10
[Code]
def duration(string):
match = re.match(PATTERN, string)
if not match:
raise ValueError('Invalid duration: {}'.format(string))
suffix = match.group(2)
if suffix not in SUFFIX_MAP:
raise ValueError('Invalid duration suffix: {}'.format(string))
return int(match.group(1)) * SUFFIX_MAP[suffix]
[Property]
category: function implementation
language: Python
difficulty: medium
concepts: regular expression for pattern matching, dictionary lookup for suffix mapping, error handling with exceptions
[Instruction]
Create a Python function that converts a string representation of a time duration into its total number of seconds.
The input string should follow a format that includes a numeric part followed by a time unit suffix without any spaces between.
The time unit can be seconds in the form of 's' or 'sec', minutes in the form of 'm' or 'min', hours in the form of 'h' or 'hour', and days in the form of 'd' or 'day' (units are in small case).
If the input format is invalid, the function should raise a ValueError.
For example, the function should pass the following assertions:
```python
assert parse_duration('15s') == 15
assert parse_duration('2min') == 120
assert parse_duration('1h') == 3600
assert parse_duration('1d') == 86400
try:
parse_duration('30')
except ValueError as e:
pass
```
[Response]
The desired function aims to transform a string representation into its total number of seconds. The implementation can be split into two parts:
Input validation:
1. The input string includes two parts: a number as the prefix and the unit as the suffix.
2. We can use regular expression to assert the prefix must be a number (d+) and suffix must be one of s/sec/m/min/h/hour/d/day.
3. If the input string cannot the regular expression, we raise a ValueError.
Result computation:
1. Based on the matches of regular expression, we capture the number and unit part.
2. We convert the unit to seconds: 's'/'sec' -> 1 second, 'm'/'min' -> 60 seconds, 'h'/'hour' -> 3600 seconds, 'd'/'day' -> 86400 seconds.
3. We multiply the seconds of the unit and the prefix number and return it as an integer.
Here's how you can implement this:
```python
import re
def parse_duration(duration_str):
pattern = re.compile(r"(\d+)(s|sec|m|min|h|hour|d|day)$")
match = pattern.match(duration_str)
if not match:
raise ValueError(f"Invalid duration: {duration_str}")
value, suffix = match.groups()
value = int(value)
suffix_map = {
's': 1, 'sec': 1,
'm': 60, 'min': 60,
'h': 3600, 'hour': 3600,
'd': 86400, 'day': 86400
}
return value * suffix_map[suffix]
```
[Tests]
You can test your code on various valid and invalid inputs to ensure that the function behaves as expected:
```python
# Test additional valid inputs with different suffix representations
assert parse_duration('10sec') == 10, "Check for 'sec' suffix"
assert parse_duration('3min') == 180, "Check for 'min' suffix"
assert parse_duration('5h') == 18000, "Check for 'h' suffix"
assert parse_duration('2hour') == 7200, "Check for 'hour' suffix"
assert parse_duration('1day') == 86400, "Check for 'day' suffix"
# Test edge cases
assert parse_duration('0s') == 0, "Zero duration"
assert parse_duration('0min') == 0, "Zero minutes"
# Test inputs with leading zeros
assert parse_duration('001s') == 1, "Leading zeros"
assert parse_duration('010min') == 600, "Leading zeros with minutes"
# Test case sensitivity and invalid suffix handling
def assert_value_error(duration_str):
try:
parse_duration(duration_str)
except ValueError:
pass
assert_value_error('10S')
assert_value_error('2hours')
assert_value_error('5 mins')
assert_value_error('h1')
assert_value_error('100')
# Test extremely large numbers
assert parse_duration('1000000s') == 1000000, "Very large number of seconds"
```
### Example 11
[Code]
class Restaurant():
def __init__(self, name, cuisine_type):
self.name = name.title()
self.cuisine_type = cuisine_type
self.number_served = 0
def describe_restaurant(self):
msg = f"{self.name} tiene los mejores {self.cuisine_type}."
print(f"\n{msg}")
def open_restaurant(self):
msg = f"{self.name} EstΓ‘ Abierta. Β‘Adelante! \n"
print(f"\n{msg}")
def set_number_served(self, number_served):
self.number_served = number_served #AquΓ establecemos la cantidad de clientes atendidos
def increment_number_served(self, additional_served):
self.number_served += additional_served #AquΓ incrementamos la cantidad de clientes atendidos
[Property]
category: class implementation
language: Python
difficulty: hard
concepts: object-oriented programming, string formatting and manipulation, encapsulation, input validation
[Instruction]
Develop a Python class `StringEnhancer` that offers advanced tools for managing a string. The class should maintain an internal state that is initially an empty string. The class should support extending the string with additional prefix or suffix, converting the entire string to lowercase or uppercase, and altering specific characters within the string. All the operations are communicated through a central method: `apply_operation(self, operation: str)`.
The method `apply_operation` interprets the operations specified in the form of `"[opname]:[arg]"`. Here are the detailed formats for each operation, explained through examples:
- Prefix addition: `apply_operation("prefix:Hello, ")`
- Suffix addition: `apply_operation("suffix: World!")`
- Lowercase conversion: `apply_operation("lower:")`
- Uppercase conversion: `apply_operation("upper:")`
- Character replacement: `apply_operation("replace:a->e")`
The class should handle erroneous inputs gracefully, such as incorrect operation formats or arguments. Additionally, implement the `__str__` method to return a formatted string showing the current value of the string and a list of operations that have been applied to it.
[Response]
The goal is to create a Python class `StringEnhancer` capable of managing a string through various operations, using a central method `apply_operation`. The class also needs to handle errors gracefully and record the operation history. Here are the key steps to implement this class:
- Initialize the class with an empty string and an empty list to store the operations.
- Inside the `apply_operation` method:
- Parse the operation string to determine the operation type and argument (if any).
- Gracefully handle any errors in the input format by printing an error message without actually raising an exception.
- Execute the correct string manipulation based on the operation.
- Append the operation to the records list.
- Implement the `__str__` method by concatenating the current string value and the recorded operations.
Here's how you can implement the `StringEnhancer` class:
```python
class StringEnhancer:
def __init__(self):
self.string = ""
self.operations = []
def apply_operation(self, operation: str):
parts = operation.split(":")
if len(parts) == 1:
print("Invalid operation format. Expected '[opname]:[arg]'")
return
opname, arg = parts[0], parts[1]
if opname == "prefix":
self.string = arg + self.string
elif opname == "suffix":
self.string += arg
elif opname == "lower":
self.string = self.string.lower()
elif opname == "upper":
self.string = self.string.upper()
elif opname == "replace":
if "->" not in arg:
print("Invalid replace operation format. Expected 'replace:a->b'")
return
old_char, new_char = arg.split("->")
self.string = self.string.replace(old_char, new_char)
else:
print(f"Unknown operation: {opname}")
self.operations.append(operation)
def __str__(self):
operation_history = ', '.join(self.operations)
return f"Current String: {self.string}\nOperations: {operation_history}"
```
[Tests]
To test the class, you should apply different operations and check if the string and operation history are updated correctly:
```python
enhancer = StringEnhancer()
enhancer.apply_operation("prefix:Hello")
enhancer.apply_operation("suffix:, World!")
enhancer.apply_operation("lower:")
enhancer.apply_operation("replace:o->a")
expected_operation_history = ["prefix:Hello", "suffix:, World!", "lower:", "replace:o->a"]
expected_operation_history_str = ', '.join(expected_operation_history)
expected_str_value = "hella, warld!"
assert enhancer.operations == expected_operation_history
assert str(enhancer) == f"Current String: {expected_str_value}\nOperations: {expected_operation_history_str}"
```
### Example 12
[Code]
while cur_num < len(sorted_importances):
cluster_idx = int(sorted_importances[cur_num][1])
filter_idx = int(sorted_importances[cur_num][2])
if tmp_pruning_quotas[cluster_idx] > 0:
tmp_pruning_quotas[cluster_idx] -= 1
else:
cur_num += 1
continue
cluster = self.pruned_module_groups_info.get_cluster_by_id(cluster_idx)
for node in cluster.elements:
[Property]
category: function implementation
language: Python
difficulty: easy
concepts: iteration with a while loop, index-based data access, conditional branching, nested loops
[Instruction]
Create a Python function that identifies all pairs of elements within a list of integers where the second element of the pair is at least greater than the first by `growth_ratio` and the indices of the elements are within a specified `maximum_distance` from each other.
[Response]
You can write a Python function `find_pairs` that takes three parameters:
- `numbers`: The list of integers.
- `growth_ratio`: A non-negative `float` that specifies the ratio by which the second element should be greater than the first.
- `maximum_distance`: A non-negative integer that indicates the maximum index distance allowed between the two elements in the pair.
The function will return a list of tuples where each tuple contains the indices of the pair of elements that satisfy the conditions.
Here is how you can implement this function:
```python
from typing import List, Tuple
def find_pairs(numbers: List[int], growth_ratio: float, maximum_distance: int) -> List[Tuple[int, int]]:
"""
Find pairs of elements within a list of integers where the second element is at least `growth_ratio` greater than the first and the indices are within `maximum_distance` from each other.
"""
pairs: List[int] = []
for i in range(len(numbers)):
# For each number, look ahead up to `maximum_distance` elements
for j in range(i + 1, min(i + 1 + maximum_distance, len(numbers))):
if numbers[j] - numbers[i] >= growth_ratio:
pairs.append((i, j))
return pairs
```
This function iterates over the pairs of elements in the list whose indices satisfy the distance constraint and stores the valid pairs that meet the growth ratio condition.
[Tests]
To ensure the function's correct behavior, you can compare your implementation against a brute-force approach that leverages list comprehension to first generate all possible pairs and then filter them based on the conditions. The tests should cover both the basic functionality where pairs are found, and edge cases where no pairs are found, while also altering the `growth_ratio` and `maximum_distance` parameters to cover more cases:
```python
def brute_force_pairs(numbers: List[int], growth_ratio: float, maximum_distance: int) -> List[Tuple[int, int]]:
return [
(i, j)
for i in range(len(numbers))
for j in range(i + 1, min(i + 1 + maximum_distance, len(numbers)))
if numbers[j] - numbers[i] >= growth_ratio
]
test_cases = [
([30, 15, 60, 7, 77, 13, 10], 8, 3),
([30, 15, 60, 7, 77, 13, 10], 0.2, 3),
([30, 15, 60, 7, 77, 13, 10], 30, 0),
([30, 15, 60, 7, 77, 13, 10], 0, 2),
([], 1, 3),
([8, 8, 8, 8], 1, 0)
]
for numbers, growth_ratio, maximum_distance in test_cases:
expected_pairs = brute_force_pairs(numbers, growth_ratio, maximum_distance)
assert find_pairs(numbers, growth_ratio, maximum_distance) == expected_pairs
```
### Example 13
[Code]
def accuracy(output, target, topk=(1,)):
"""Computes the precision@k for the specified values of k"""
maxk = max(topk)
batch_size = target.size(0)
_, pred = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, -1).expand_as(pred))
res = []
for k in topk:
correct_k = correct[:k].view(-1).float().sum(0)
res.append(correct_k.mul_(100.0 / batch_size))
return res
[Property]
category: function implementation
language: Python
difficulty: medium
concepts: top-k accuracy computation, tensor operations in PyTorch, batch processing, default arguments
[Instruction]
Create a Python function `calculate_top_k_accuracy` using PyTorch that calculates the top-k accuracy from a batch of predictions and actual labels. It should accept two tensors, `predictions` and `targets`, and an integer `k` (default 3). The function should return the average top-k accuracy as a float, determining if the true label is within the top `k` predictions for each input.
[Response]
The function will take the following parameters as input:
- `predictions`: a tensor of shape `(batch_size, num_classes)` that contains the predicted scores for each class.
- `targets`: a tensor of shape `(batch_size,)` that contains the true class labels for each input.
- `k`: an integer representing the number of top predictions to consider for computing the accuracy. The default value should be 3.
Here is how you can write this function using PyTorch:
```python
import torch
def calculate_top_k_accuracy(predictions: torch.Tensor, targets: torch.Tensor, k: int = 3) -> float:
# Ensure this function works even if k is greater than the number of classes
k = min(k, predictions.size(1))
_, top_k_indices = predictions.topk(k, dim=1)
target_expanded = targets.unsqueeze(1).expand_as(top_k_indices)
correct_predictions = top_k_indices.eq(target_expanded)
correct = correct_predictions.any(dim=1)
accuracy = correct.float().mean()
return accuracy.item()
```
The function retrieves the top k predictions' indices, aligns shapes for comparison with true labels, computes accuracy by checking matches, and returns the average accuracy as a float.
[Tests]
```python
# Test 1: Basic functionality test
k = 1
labels = torch.tensor([2, 0, 1, 1])
preds = torch.tensor([
[0.1, 0.2, 0.9], # yes
[1.0, 0.2, 0.3], # yes
[0.3, 1.1, 0.2], # yes
[0.6, 0.1, 0.3], # no
])
accuracy = calculate_top_k_accuracy(preds, labels, k)
assert accuracy == 0.75
# Test 2: Edge case with k = number of classes
k = 3
preds = torch.tensor([
[0.5, -1.2, 0.3], # yes
[-1.0, 0.1, 1.2], # yes
])
labels = torch.tensor([0, 2])
accuracy = calculate_top_k_accuracy(preds, labels, k)
assert accuracy == 1.0
# Test 3: k greater than the number of classes should still work
preds = torch.tensor([
[0.1, -0.2], # yes
[-0.3, 0.4], # yes
])
labels = torch.tensor([1, 0])
accuracy = calculate_top_k_accuracy(preds, labels, k=5)
assert accuracy == 1.0
```
### Example 14
[Code]
def alternatingCharacters(s):
i = 0
j = 1
count = 0
while j= 0 and j < len(str2):
if str1[i] == str2[j]:
count += 1
i -= 1
j += 1
elif strict:
break
else:
i -= 1
return count
```
[Tests]
The function can be tested with various inputs to ensure it handles both strict and non-strict cases correctly:
```python
# Test function with matching characters
assert count_conditional_matches("hello", "o", True) == 1
assert count_conditional_matches("fancy", "nancy", False) == 2
assert count_conditional_matches("abcde", "e", False) == 1
assert count_conditional_matches("helicopter", "ranges", True) == 1
# Test function with no matches
assert count_conditional_matches("apple", "banana", True) == 0
assert count_conditional_matches("abcdef", "xyzab", False) == 0
# Test when both strings are empty
assert count_conditional_matches("", "", True) == 0
assert count_conditional_matches("", "", False) == 0
# Test when one string is empty
assert count_conditional_matches("nonempty", "", True) == 0
assert count_conditional_matches("", "nonempty", False) == 0
```
### Example 15
[Code]
def oxford_comma_text_to_list(phrase):
"""Examples:
- 'Eeeny, Meeny, Miney, and Moe' --> ['Eeeny', 'Meeny', 'Miney', 'Moe']
- 'Black and White' --> ['Black', 'White']
- 'San Francisco and Saint Francis' -->
['San Francisco', 'Saint Francisco']
"""
items = []
for subphrase in phrase.split(', '):
items.extend(
[item.strip() for item in subphrase.split(' and ')])
return items
[Property]
category: function implementation
language: Python
difficulty: easy
concepts: string manipulation and parsing, list comprehension, iterative list extension, handling text connectors
[Instruction]
Create a concise Python function that transforms a string into a list of individual items. The input string contains a list of items separated by commas and the last item preceded by an optional "and". For example:
- Input: "Eeeny, Meeny, Miney, Moe" --> Output: ['Eeeny', 'Meeny', 'Miney', 'Moe']
- Input: "Eeeny, Meeny, Miney, and Moe" --> Output: ['Eeeny', 'Meeny', 'Miney', 'Moe']
- Input: "San Francisco and San Mateo" --> Output: ['San Francisco', 'San Mateo']
Remove any leading or trailing whitespace.
[Response]
Here's a concise function `string_to_list` to transform a comma-separated string into a list, replacing " and " with a comma, splitting the result, and stripping whitespace:
```python
def string_to_list(s):
return [item.strip() for item in s.replace(" and ", ",").split(",") if item.strip() != ""]
```
This approach ensures no empty strings are included if there are excess commas or spaces.
[Tests]
We can test this function on different input strings (e.g., with and without the "and" connector, different numbers of items):
```python
assert string_to_list("Eeeny, Meeny, Miney, Moe") == ['Eeeny', 'Meeny', 'Miney', 'Moe']
assert string_to_list("Eeeny, Meeny, Miney, and Moe") == ['Eeeny', 'Meeny', 'Miney', 'Moe']
assert string_to_list("San Francisco and San Mateo") == ['San Francisco', 'San Mateo']
assert string_to_list("Single Item") == ['Single Item']
```
### Example 16
[Code]
def get_hashes(buf):
hexdigests = namedtuple('Digests', 'md5 sha1 sha256 sha512 ctph')
if isinstance(buf, str):
buf = open(buf, 'rb').read()
md5 = hashlib.md5(buf).hexdigest()
sha1 = hashlib.sha1(buf).hexdigest()
sha256 = hashlib.sha256(buf).hexdigest()
sha512 = hashlib.sha512(buf).hexdigest()
ctph = ssdeep.hash(buf)
return hexdigests._make((md5, sha1, sha256, sha512, ctph))
[Property]
category: function implementation
language: Python
difficulty: easy
concepts: binary string hash computation, file content reading, string hashing, named tuples, conditional file content reading
[Instruction]
Implement a Python function that computes different types of hash values for the binary content of a file whose path is defined by an input string. You should calculate 'md5', 'sha1', 'sha256', and 'sha512' and return a `namedtuple` of these fields. When the input string does not correspond to a file, the function should directly compute the hash values of path itself.
[Response]
To compute the hashes of a file or a string, we'll follow these steps:
1. If the input is a valid file path, read the binary content of the file.
2. Otherwise, convert the input string to a binary string.
3. Compute hash values of all types using the `hashlib` module.
4. Return the hash values as a `namedtuple` for easy access.
Here's how you can implement this function:
```python
import hashlib
from collections import namedtuple
from pathlib import Path
HashValues = namedtuple('HashValues', ['md5', 'sha1', 'sha256', 'sha512'])
def compute_hashes(file_path):
try:
with open(file_path, 'rb') as f:
content = f.read()
# Handle cases where the file does not exist or the path is a directory
except (FileNotFoundError, IsADirectoryError):
content = file_path.encode()
md5_hash = hashlib.md5(content).hexdigest()
sha1_hash = hashlib.sha1(content).hexdigest()
sha256_hash = hashlib.sha256(content).hexdigest()
sha512_hash = hashlib.sha512(content).hexdigest()
return HashValues(md5_hash, sha1_hash, sha256_hash, sha512_hash)
```
[Tests]
To test the function, you can provide string inputs to avoid file I/O operations and verify that the hash values are correctly computed:
```python
string = 'random string'
binary = string.encode()
computed_hashes = compute_hashes(string)
assert computed_hashes.md5 == hashlib.md5(binary).hexdigest()
assert computed_hashes.sha1 == hashlib.sha1(binary).hexdigest()
assert computed_hashes.sha256 == hashlib.sha256(binary).hexdigest()
assert computed_hashes.sha512 == hashlib.sha512(binary).hexdigest()
```
### Example 17
[Code]
from collections import Counter
class Solution:
def sumOfUnique(self, nums: List[int]) -> int:
return sum(k for k, v in Counter(nums).items() if v == 1)
[Property]
category: function implementation
language: Python
difficulty: easy
concepts: dictionary-based counting, filtering unique elements with list comprehension, summation of elements based on condition
[Instruction]
Write a Python function that takes a list from user input and prints the sum of counts for elements that occur more than once. Use a dictionary to count frequencies efficiently. Utilize a list comprehension to extract repeated elements based on the frequency counts, and sum their corresponding counts from the dictionary.
[Response]
To implement this function, we first need to parse the user input as a list of integers and then count the frequency of each element using a dictionary. We can then calculate the sum of the counts for elements that occur more than once.
Here's a Python function that accomplishes this:
```python
def sum_repeated_counts():
nums = list(map(int, input().split()))
freq_dict = {}
for num in nums:
freq_dict[num] = freq_dict.get(num, 0) + 1
sum_of_repeats = sum(v for k, v in freq_dict.items() if v > 1)
print(sum_of_repeats)
```
[Tests]
We can test this program with I/O redirection to simulate user input and output. Here is an example:
```python
import sys
from io import StringIO
test_cases = [
("1 2 2 3 3 3\n", "5\n"),
("1 1 1 1 1\n", "5\n"),
("1 2 3 4 5\n", "0\n"),
("\n", "0\n")
]
for input_data, expected_output in test_cases:
stdin, stdout = sys.stdin, sys.stdout
sys.stdin = StringIO(input_data)
sys.stdout = StringIO()
sum_repeated_counts()
output = sys.stdout.getvalue()
assert output == expected_output
```
### Example 18
[Code]
fp=open('cmd.sh','r')
lines=fp.readlines()
for i,line in enumerate(lines):
cmd=line.replace('\n','')
print i,cmd
p=os.popen(cmd)
x=p.read()
p.close()
fp.close
[Property]
category: program implementation
language: Python
difficulty: medium
concepts: iterating over file lines, command execution from file input, new line character removal
[Instruction]
Develop a Python program that reads a text file containing one shell command per line and executes these commands sequentially. Each command should be sanitized by removing unnecessary newline characters before execution. Provide clear error handling and logging to manage exceptions that might occur during the execution of the commands.
[Response]
To create a Python program that reads and executes shell commands from a text file, we can use Pythonβs built-in module `subprocess` for running the commands and `logging` for handling logs and errors. The program will involve reading and sanitizing the commands from a file, executing them sequentially, and logging the results or errors.
Below is the Python script that demonstrates this:
```python
import subprocess
import logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s:%(levelname)s:%(message)s')
def read_commands(file_path):
"""Reads a text file and returns a list of commands."""
try:
with open(file_path, 'r') as file:
commands = file.readlines()
commands = [cmd.strip() for cmd in commands] # Remove newline characters and spaces
return commands
except FileNotFoundError:
logging.error(f"The file {file_path} was not found.")
raise
except Exception as e:
logging.error(f"An error occurred while reading the file: {str(e)}")
raise
def execute_command(command):
"""Executes a single shell command."""
try:
logging.info(f"Executing command: {command}")
result = subprocess.run(command, shell=True, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
logging.info(f"Command output: {result.stdout.decode().strip()}")
except subprocess.CalledProcessError as e:
logging.error(f"Error executing command '{command}': {e.stderr.decode()}")
except Exception as e:
logging.error(f"An unexpected error occurred: {str(e)}")
def main(file_path):
"""Main function to read commands from a file and execute them."""
commands = read_commands(file_path)
for command in commands:
execute_command(command)
```
[Tests]
To test this program, we can use Python's `unittest` framework along with `mock_open` to simulate file operations, `patch` to mock `subprocess.run` for testing command execution, and `assertLogs` to verify the logging output. Here's an example of how you can write tests for this program:
```python
import unittest
from unittest.mock import mock_open, patch, MagicMock
class TestCommandExecutor(unittest.TestCase):
def test_read_commands_success(self):
m = mock_open(read_data="ls\npwd\n")
with patch('builtins.open', m):
result = read_commands("dummy_path")
self.assertEqual(result, ['ls', 'pwd'])
def test_read_commands_file_not_found(self):
with patch('builtins.open', mock_open()) as mocked_file:
mocked_file.side_effect = FileNotFoundError
with self.assertRaises(FileNotFoundError):
read_commands("nonexistent_path")
@patch('subprocess.run')
def test_execute_command_success(self, mock_run):
mock_run.return_value = MagicMock(stdout=b"Execution successful", stderr=b"")
execute_command("ls")
mock_run.assert_called_once_with("ls", shell=True, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
@patch('subprocess.run')
def test_execute_command_failure(self, mock_run):
error_message = b"Command failed"
mock_run.side_effect = subprocess.CalledProcessError(1, 'ls', stderr=error_message)
with self.assertLogs(level='ERROR') as log:
execute_command("ls")
self.assertIn("Error executing command 'ls'", log.output[0])
self.assertIn("Command failed", log.output[0])
if __name__ == "__main__":
unittest.main()
```
### Example 19
[Code]
def busca_linear_recursiva(array,elemento):
i = -1
return busca_recursiva(array,elemento, i)
def busca_recursiva(array,elemento, i):
i += 1
if(i == len(array)):
return -1
if(array[i] == elemento):
return i
return busca_recursiva(array,elemento,i)
[Property]
category: program implementation
language: Python
difficulty: medium
concepts: linear search with recursion, default parameter initialization, multiple base cases in recursion
[Instruction]
Design a Python program that not only searches for a target value in a list using recursion but also constructs a trace of the indices it checks. This program should return both the index of the target, if found, or `-1` if not, alongside a list of the indices it examined during the search. The function should handle cases where the target is not present in the list.
[Response]
We can implement a recursive linear search function that returns the index of the target element if found or `-1` if not. To keep track of the indices examined during the search, we can pass a list as an additional parameter to store these indices.
Here is the Python program that implements this functionality:
```python
def search_recursive(arr, target, index, indices_checked):
"""Recursive function to search for the target value in the list."""
if index >= len(arr):
return -1
indices_checked.append(index)
if arr[index] == target:
return index
return search_recursive(arr, target, index + 1, indices_checked)
def recursive_search(arr, target):
"""Wrapper function to initiate recursive search."""
indices_checked = []
result = search_recursive(arr, target, 0, indices_checked)
return result, indices_checked
# Example usage
if __name__ == "__main__":
array = [2, 3, 4, 8, 5, 9, 1, 6, 5, 7, 5]
target = 6
result, indices = recursive_search(array, target)
print(f"Target {target} found at index {result} with indices checked: {indices}")
```
In this program, the `search_recursive` function recursively searches for the target element in the list and appends the indices checked to the `indices_checked` list. The `recursive_search` function acts as a wrapper to initiate the recursive search and return the result along with the list of indices checked.
[Tests]
To test the implementation, we need to ensure that both the index of the target element and the list of indices checked are correct. Here are the test cases:
```python
# Test case 1: Target found in the list
arr1 = [2, 3, 4, 8, 5, 9, 1, 6, 5, 7, 5]
target1 = 6
expected_result1 = arr1.index(target1)
expected_indices1 = list(range(expected_result1 + 1))
result1, indices_checked1 = recursive_search(arr1, target1)
assert result1 == expected_result1
assert indices_checked1 == expected_indices1
# Test case 2: Target not found in the list
arr2 = [1, 2, 3, 4, 5]
target2 = 6
expected_result2 = -1
expected_indices2 = list(range(len(arr2)))
result2, indices_checked2 = recursive_search(arr2, target2)
assert result2 == expected_result2
assert indices_checked2 == expected_indices2
# Test case 3: Target found at the end of the list
arr3 = [5, 4, 3, 2, 1]
target3 = 1
expected_result3 = len(arr3) - 1
expected_indices3 = list(range(expected_result3 + 1))
result3, indices_checked3 = recursive_search(arr3, target3)
assert result3 == expected_result3
assert indices_checked3 == expected_indices3
```
### Example 20
[Code]
Data = np.zeros([break_points[-1],size_blocks])
Data_stacked = np.zeros([break_points[-1]-num_blocks+1, size_blocks*num_blocks])
cluster_point_list = []
for counter in xrange(len(break_points)):
break_pt = break_points[counter]
cluster = seg_ids[counter]
if counter == 0:
old_break_pt = 0
else:
old_break_pt = break_points[counter-1]
for num in xrange(old_break_pt,break_pt):
##generate the point from this cluster
# print "num is:", num
if num == 0:
[Property]
category: program implementation
language: Python
difficulty: medium
concepts: NumPy array initialization, iteration over break points, cluster segmentation, nested loops
[Instruction]
Implement a Python program that initializes a NumPy array randomly (0--1) and segments it into clusters based on provided breakpoints. Each cluster is defined by consecutive elements between two breakpoints. The output should be a list of NumPy arrays representing these clusters.
For example, given a size 10 and breakpoints `[3, 6, 8]`, the program should first initialize a NumPy array of 10 random elements between 0 and 1 and then output three clusters: elements at indices `0-2`, `3-5`, `6-7`, and `8-9`. Ensure that the program handles cases where breakpoints are at the boundaries of the array or if there are no breakpoints, in which case the entire array should be a single cluster. Include error handling to manage invalid inputs such as negative array sizes or breakpoints that are out of range.
[Response]
Here is the program that achieves what you've described:
```python
import numpy as np
def segment_array(data, break_points):
"""Segment the given array into clusters based on specified breakpoints."""
break_points = [0] + break_points + [len(data)]
segmented_arrays = []
for i in range(len(break_points) - 1):
start_index = break_points[i]
end_index = break_points[i + 1]
segmented_arrays.append(data[start_index:end_index])
return segmented_arrays
def create_clusters(size, break_points):
"""Generate and segment a random array of given size using breakpoints."""
if size <= 0:
raise ValueError("Array size must be positive.")
data = np.random.rand(size)
clusters = segment_array(data, break_points)
return clusters
# Example usage
if __name__ == "__main__":
size = 10
break_points = [3, 6, 8]
clusters = create_clusters(size, break_points)
for i, cluster in enumerate(clusters):
print(f"Cluster {i}: {cluster}")
```
In this implementation, `segment_array` transforms the input data array into a list of NumPy arrays based on the provided breakpoints. The `main` function initializes a random NumPy array of a specified size and calls `segment_array` to segment the array into clusters based on the breakpoints.
[Tests]
To test the program, we can verify that the values in each cluster are within the expected range (0--1) and that the clusters are correctly segmented. Here are some test cases:
```python
def test_segmentation(size, break_points):
clusters = create_clusters(size, break_points)
for cluster in clusters:
assert np.all(cluster >= 0) and np.all(cluster <= 1)
break_points = [0] + break_points + [size]
for i in range(len(break_points) - 1):
assert len(clusters[i]) == break_points[i + 1] - break_points[i]
# Test cases
test_cases = [
(20, [5, 10, 15]),
(10, [3, 6, 8]),
(15, [3, 6, 12]),
(30, [7, 14, 21, 27]),
(5, [1]),
(10, []),
(50, [10, 20, 30, 40]),
]
for size, breakpoints in test_cases:
test_segmentation(size, breakpoints)
```
### Example 21
[Code]
if match_case == 'auto':
if len(set([ch_name.lower() for ch_name in ch_names])) < len(set(ch_names)):
match_case = True
else:
match_case = False
if match_case:
picks = mne.pick_channels(ch_names, pick_chs, ordered=ordered)
else:
ch_names = [ch_name.lower() for ch_name in ch_names]
pick_chs = [pick_ch.lower() for pick_ch in pick_chs]
picks = mne.pick_channels(ch_names, pick_chs, ordered=ordered)
return picks
[Property]
category: program implementation
language: Python
difficulty: medium
concepts: case-insensitive string matching, controlled case matching based on an option, list comprehension
[Instruction]
Construct a Python program that processes a list of strings provided by the user. The first element is a target string, the second is either 'CaseSensitive' or 'CaseInsensitive' to determine the matching approach, and the remaining elements are candidates for comparison. The program should output the number of times the target appears among the candidates according to the specified matching rule. The solution should include robust error handling to validate the matching rule and check that at least two strings are provided before proceeding.
For example, given the input `['apple', 'CaseInsensitive', 'Apple', 'banana', 'APPLE']`, the program should output `2` since 'Apple' and 'APPLE' match the target 'apple' in a case-insensitive manner.
[Response]
Here's a Python program that fulfills the requirements you specified. It first parses the input list to validate the presence of the target string and matching rule. Then, it compares the target with the candidate strings, adjusting for case sensitivity as specified. Finally, it outputs the count of matches.
```python
def count_matches(input_list):
if not input_list or len(input_list) < 2:
raise ValueError("Input list must contain at least two items: the target string and the matching rule.")
target_string, matching_rule = input_list[0], input_list[1]
if matching_rule not in ['CaseSensitive', 'CaseInsensitive']:
raise ValueError("Matching rule must be either 'CaseSensitive' or 'CaseInsensitive'.")
candidates = input_list[2:]
if matching_rule == 'CaseSensitive':
match_count = sum(1 for candidate in candidates if candidate == target_string)
else:
target_string = target_string.lower()
match_count = sum(1 for candidate in candidates if candidate.lower() == target_string)
return match_count
def main():
input_list = input().split()
print(count_matches(input_list))
if __name__ == "__main__":
main()
```
The `count_matches` function implements the main logic of the program, counting the occurrences of the target string among the candidate strings based on the specified matching rule. The `main` function reads the input list from the user, calls `count_matches`, and prints the count of matches.
[Tests]
You can test the program with various inputs to ensure it handles different scenarios correctly:
```python
assert count_matches(['apple', 'CaseInsensitive', 'Apple', 'banana', 'APPLE']) == 2
assert count_matches(['apple', 'CaseSensitive', 'Apple', 'banana', 'APPLE']) == 0
assert count_matches(['apple', 'CaseInsensitive']) == 0
assert count_matches(['apple', 'CaseInsensitive', 'apple', 'APPLE', 'aPpLe', 'banana']) == 3
assert count_matches(['apple', 'CaseSensitive', 'apple', 'APPLE', 'aPpLe', 'banana']) == 1
try:
count_matches(['apple'])
assert False
except ValueError as e:
assert str(e) == "Input list must contain at least two items: the target string and the matching rule."
try:
count_matches(['apple', 'InvalidRule', 'Apple'])
assert False
except ValueError as e:
assert str(e) == "Matching rule must be either 'CaseSensitive' or 'CaseInsensitive'."
``` selfcodealign-selfcodealign/pyproject.toml 0000664 0000000 0000000 00000001317 14637551746 0021412 0 ustar 00root root 0000000 0000000 [project]
description = "StarCoder2-Instruct: Fully Transparent and Permissive Self-Alignment for Code Generation"
dynamic = ["dependencies"]
license = {text = "Apache-2.0"}
name = "star_align"
readme = "README.md"
requires-python = ">=3.10"
version = "0.1.0"
[tool.setuptools.packages.find]
include = ["star_align*"]
where = ["src"]
[tool.black]
include = '\.pyi?$'
line-length = 88
target-version = ["py310"]
[tool.isort]
line_length = 88
profile = "black"
skip_gitignore = true
[tool.setuptools.dynamic]
dependencies = {file = ["requirements.txt"]}
[tool.mypy]
check_untyped_defs = true
follow_imports = "silent"
ignore_missing_imports = true
mypy_path = "src"
packages = ["star_align"]
python_version = "3.10"
selfcodealign-selfcodealign/requirements.txt 0000664 0000000 0000000 00000000375 14637551746 0021765 0 ustar 00root root 0000000 0000000 transformers==4.40.1
vllm==0.4.1
torch>=2.0.1
openai>=1.3.7
tenacity~=8.2.3
tiktoken~=0.6.0
accelerate>=0.27.2
datasets>=2.17.1
evalplus @ git+https://github.com/evalplus/evalplus.git@25e195e024b614f2671ad9ac5b8fdcd9b95a2b24#egg=evalplus
evoeval~=0.1.0
selfcodealign-selfcodealign/sanitize.sh 0000775 0000000 0000000 00000001762 14637551746 0020667 0 ustar 00root root 0000000 0000000 #!/bin/bash
set -e
SOURCE=$1
TARGET=$2
echo "Sanitizing.."
python -m star_align.sanitize_data \
--data_files $SOURCE \
--output_file $TARGET \
--parse_raw_response True \
--exact_match_dedup True \
--passing_only True \
--include_left_failed False
if [[ -n $DECONTAMINATION ]]; then
echo "Decontaminating.. (saving to decontamination-output)"
python -m star_align.decontamination.find_substrings \
--dataset_name "json" \
--output_file $TARGET \
--output_dir decontamination-output \
--columns instruction response \
--data_files $TARGET
fi
echo "Minihash dedup.."
python -m star_align.minhash_dedup \
--data_files $TARGET \
--column instruction \
--output $TARGET
python -m star_align.minhash_dedup \
--data_files $TARGET \
--column response \
--output $TARGET
python -m star_align.minhash_dedup \
--data_files $TARGET \
--column code_representation \
--ignore_empty True \
--output $TARGET
selfcodealign-selfcodealign/seed_gathering/ 0000775 0000000 0000000 00000000000 14637551746 0021444 5 ustar 00root root 0000000 0000000 selfcodealign-selfcodealign/seed_gathering/README.md 0000664 0000000 0000000 00000006174 14637551746 0022733 0 ustar 00root root 0000000 0000000 # Code for gathering seed functions
The pipeline for gathering seed functions is composed of three scripts, to be run in the following order:
1. `./generate_from_the_stack.py`: Gathers unfiltered seed functions with docstrings from The Stack v1.
2. `./high_quality_subset.py`: Transforms the seed functions using `autoimport`, and filters them by checking for a return statement and type-checking them with Pyright.
3. `./filter_dataset.py`: Further filters the seed functions by decontaminating the dataset, using StarCoder2-15B as a judge to remove bad examples, and using a set of static heuristics.
## 1. Generate from the Stack
In this step, we simply extract all functions from The Stack v1 (dedup) that have docstrings using tree-sitter. This is done by running the following command:
```bash
python3 generate_from_the_stack.py --push "/"
```
This step may take a couple hours depending on your hardware. The resulting dataset will be pushed to the specified Hugging Face repository.
After running the command, we also run near-deduplication with MinHash, LSH, and Jaccard Similarity of 0.5.
We utilize the following repository for this step: https://github.com/ChenghaoMou/text-dedup
The dataset resulting from this step can be found here: https://huggingface.co/datasets/bigcode/stack-dedup-python-fns
## 2. High-quality subset
Here, we take the previously generated dataset and filter it and transform it using a set of heuristics.
We run the following steps:
1. We filter all functions which do not have a "return statement". This is done such that our execution
filtering step in the instruction-generation pipeline does not have to deal with functions that do not return anything, which
are hard to test. Another benefit is that this strengthens the type-checking step, as we can now validate the return type for all functions.
2. We infer imports for the functions using `autoimport`. Such that our standalone functions now correctly import any required modules.
3. We type-check each function using Pyright. This is done to filter any functions that may reference undefined identifiers or have static type errors (as detected by
Pyright).
The dataset resulting from this step can be found here: https://huggingface.co/datasets/bigcode/python-stack-v1-functions-filtered
## 3. Filter dataset
Now, we further filter the dataset generated in in the previous with different methods:
1. We remove functions that contain a set of words that are likely to be bad examples (e.g. "TODO").
2. We also remove functions that import problematic packages, which can lead to issues in execution filtering (e.g. `os` or `sys`).
3. We remove functions which contains either solutions or prompts of benchmarks on which we evaluated the models.
4. We filter out functions that do not have any arguments, as these are likely to be bad examples in this constrained setting.
5. Finally, we utilize the base model StarCoder2-15B as a classifier to remove any examples that has bad documentation or low-quality code.
The dataset resulting from this step can be found here: https://huggingface.co/datasets/bigcode/python-stack-v1-functions-filtered-sc2
selfcodealign-selfcodealign/seed_gathering/benchmark_data.py 0000664 0000000 0000000 00000007300 14637551746 0024741 0 ustar 00root root 0000000 0000000 """data to filter out of the dataset"""
import json
import itertools
from pathlib import Path
from datasets import load_dataset
TEST_IDS = list(range(11, 511))
# HumanEval solutions that are considered simple/generic enough to be kept in the training dataset
HUMAN_EVAL_STRINGS_OK = [
'return x + y', 'return len(string)', 'return n**2', 'return ''.join(strings)']
DS_1000_PATH = Path("/data/ds-1000/ds1000_data/")
def extract_ds_1000_prompt(prompt: str):
if "SOLUTION START" in prompt:
assert prompt.count("SOLUTION START") == 1
return prompt.split("SOLUTION START")[0]
elif "BEGIN SOLUTION" in prompt:
assert prompt.count("BEGIN SOLUTION") == 1
return prompt.split("BEGIN SOLUTION")[0]
else:
raise ValueError()
def load_ds_1000():
data = []
for prompt_file in DS_1000_PATH.glob("*/Insertion/q*/prompt.txt"):
with open(prompt_file) as f:
data.append(extract_ds_1000_prompt(f.read()))
return data
def load_mbpp():
dataset = load_dataset("mbpp", "sanitized", split="train")
return dataset
def mbpp_docstrings():
data = load_mbpp()
return [sample["prompt"] for sample in data]
def mbpp_solutions():
data = load_mbpp()
return [sample["code"] for sample in data]
def extract_docstring(prompt: str) -> str:
if '"""' in prompt:
if prompt.count('"""') == 2:
return prompt.split('"""')[1].strip()
elif prompt.count('"""') == 4:
return prompt.split('"""')[3].strip()
else:
raise ValueError()
elif '\'\'\'' in prompt:
assert prompt.count('\'\'\'') == 2
return prompt.split('\'\'\'')[1].strip()
else:
raise ValueError()
def human_eval_docstrings():
ds = load_dataset("openai_humaneval", split="test")
docstrings = [extract_docstring(v['prompt']) for v in ds]
return docstrings
def apps_solutions():
"""
Solutions column contains a list of strings
"""
ds = load_dataset("codeparrot/apps", split="test")
solutions = [sample["solutions"]
for sample in ds if len(sample["solutions"]) > 0]
res = itertools.chain.from_iterable(
json.loads(sample) for sample in solutions)
return list(res)
def multipl_e_docstrings():
languages = [
"cpp", "cs", "d", "go", "java", "jl", "js", "lua", "php", "pl", "py", "r",
"rb", "rkt", "rs", "scala", "sh", "swift", "ts"
]
# languages = ["py", "java", "js"]
src_datas = ["humaneval", "mbpp"]
variations = ["", "-remove"]
data = []
for lang in languages:
for src_data in src_datas:
for variation in variations:
if src_data == "mbpp" and variation == "-remove":
continue
ds = load_dataset(
"nuprl/MultiPL-E", f"{src_data}-{lang}{variation}", split="test")
data += [sample["prompt"].strip() for sample in ds]
return data
def load_dataset_column(dataset: str, column: str, split: str, name=None):
ds = load_dataset(dataset, split=split, name=name)
res = [sample[column].strip() for sample in ds]
# Only return non-empty strings
return [sample for sample in res if len(sample) > 0]
def filter_out():
FILTER_OUT = {
"mbpp_docstrings": mbpp_docstrings(),
"mbpp_solutions": mbpp_solutions(),
"human_eval_docstrings": human_eval_docstrings(),
"human_eval_solutions": [
s for s in load_dataset_column("openai_humaneval", "canonical_solution", "test")
if s not in HUMAN_EVAL_STRINGS_OK
],
}
for benchmark, values in FILTER_OUT.items():
print(f"num strings from {benchmark}: {len(values)}")
return FILTER_OUT
selfcodealign-selfcodealign/seed_gathering/filter_dataset.py 0000664 0000000 0000000 00000031000 14637551746 0025002 0 ustar 00root root 0000000 0000000 import datasets
import os
from tree_sitter_parser import global_parser, LANGUAGE, does_have_return, make_parser
import benchmark_data
from tqdm import tqdm
import torch
import argparse
from vllm import LLM, SamplingParams
import random
parser = argparse.ArgumentParser()
parser.add_argument('--dataset', type=str, required=True)
parser.add_argument('--model', type=str,
default="bigcode/starcoder2-15b")
parser.add_argument('--batch-size', type=int, default=512)
parser.add_argument('--sample-size', type=int, default=None)
parser.add_argument('--num-gpus', type=int, default=1)
parser.add_argument('--content_col', type=str, default="content")
parser.add_argument('--push', type=str, required=True)
args = parser.parse_args()
random.seed(42)
FN_BLOCK_QUERY = LANGUAGE.query("""
(function_definition
body: (block) @fn-block)
""")
def template_few_shot(code, answer, rationale):
doc, code = py_extract_docstring(code)
assert answer == "No" or answer == "Yes"
prompt = f"""username_0: I have a function in Python and I'd like someone to check my description of this function.
I'm doing this so that I can write a good docstring for this function.
Here is the code for the function:
```py
{code}
```
Here is my description of this program:
```
{doc}
```
Do not attempt to execute the function or to judge its correctness.
Answer with "Yes" or "No" depending on if my description has enough information alone to re-implement the function.
Also, answer with "No" if the description does not match the function.username_1: Sure, no problem. I will be able to help.
My answer is: {answer}
{rationale}
Upvotes: 200"""
return prompt
FEW_SHOTS = [
(
'''def simple_scan_network():
"""
Do a simple network scan, which only works if your network configuration
is 192.168.1.x
"""
base_ip = "192.168.1."
addresses = ['127.0.0.1']
for index in range(1, 255):
addresses.extend([base_ip + str(index)])
return addresses''',
"No",
"The simple_scan_network function you have provided seems to generate addresses that then would be used for a network scan, but does not actually perform it, unlike the function claims.",
),
(
'''import pandas
def coerce_integer(df):
"""
Loop through the columns of a df, if it is numeric,
convert it to integer and fill nans with zeros.
This is somewhat heavy-handed in an attempt to force
Esri to recognize sparse columns as integers.
"""
# Numeric columns to not coerce to integer
EXCEPT = ["latitude", "longitude", "zipCode"]
def numeric_column_to_int(series):
return (
series.fillna(0).astype(int)
if pandas.api.types.is_numeric_dtype(series) and series.name not in EXCEPT
else series
)
return df.transform(numeric_column_to_int, axis=0)''',
"Yes",
"The docstring does seem to match the implementation! The function loops through the columns of a df and coerces it as explained.",
),
('''def __trans_df_into_dict(data):
"""Converte DataFrame to dictionary.
Args:
data (pandas.DataFrame): DataFrame.
Returns:
dict: Name dictionary.
"""
data["en_name"] = data["en_name"].str.upper()
data["en_name_f"] = data["en_name"].str.split(" ", expand=True)[0]
data["en_name_l"] = data["en_name"].str.split(" ", expand=True)[1]
data["jp_name_f"] = data["jp_name"].str.split("γ»", expand=True)[0]
data["jp_name_l"] = data["jp_name"].str.split("γ»", expand=True)[1]
fullname_dict = dict(zip(data["en_name"], data["jp_name"]))
fname_dict = dict(zip(data["en_name_f"], data["jp_name_f"]))
lname_dict = dict(zip(data["en_name_l"], data["jp_name_l"]))
return fullname_dict, fname_dict, lname_dict''',
"No",
"The function__trans_df_into_dict does indeed convert a dataframe into a dictionary, however, it converts various columns that were not described in the docstring.\nFor instance, nowhere in the docstring it mentions handling japanese characters or the name of the column.",
),
(
'''def inchesToMeters(inches):
"""Convert inches to meters."""
return inches * 0.0254''',
"Yes",
"inchesToMeters is a very simple function, the doccstring explains concisely its purpose, which is of converting inches to meters.",
),
('''def square_crop(im, target_size=None):
""" Crop image to `target_size`. If that's None the image is squared
to the smallest size
"""
w = im.size[0]
h = im.size[1]
target_size = target_size if target_size else min(w, h)
dx = (w - target_size) / 2
dy = (h - target_size) / 2
return im.crop((dx, dy, dx + target_size, dy + target_size))''',
"Yes",
"Following the standard description for docstrings for functions and methods, the square_crop function description tells exactly what the function does."
),
('''def _setup_motifs_files(args):
"""convenience fn, make sure setup is same across
multiplicity/orientation/spacing workflows
"""
motifs_files = {}
motifs_files["early"] = "{}/{}/ggr.scanmotifs.h5".format(
args.inputs["inference"][args.cluster]["scanmotifs_dir"],
args.inputs["inference"][args.cluster]["scanmotifs_early_dir"])
motifs_files["mid"] = "{}/{}/ggr.scanmotifs.h5".format(
args.inputs["inference"][args.cluster]["scanmotifs_dir"],
args.inputs["inference"][args.cluster]["scanmotifs_mid_dir"])
motifs_files["late"] = "{}/{}/ggr.scanmotifs.h5".format(
args.inputs["inference"][args.cluster]["scanmotifs_dir"],
args.inputs["inference"][args.cluster]["scanmotifs_late_dir"])
return motifs_files''',
"No",
"The docstring for _setup_motifs_files just says this is a convenience function. There is definitely not enough information to re-implement this function from the docstring alone.",
),
('''def trip(u, v):
"""
Returns the scalar triple product of vectors u and v and z axis.
The convention is z dot (u cross v). Dotting with the z axis simplifies
it to the z component of the u cross v
The product is:
positive if v is to the left of u, that is,
the shortest right hand rotation from u to v is ccw
negative if v is to the right of u, that is,
the shortest right hand rotation from u to v is cw
zero if v is colinear with u
Essentially trip is the z component of the cross product of u x v
"""
return (u[0] * v[1] - u[1] * v[0])''',
"Yes",
"The docstring for the trip function is very detailed and describes the function's purpose and the mathematical formula used to calculate the scalar triple product.",
)
]
def prompt_fmt(code):
doc, code = py_extract_docstring(code)
random.shuffle(FEW_SHOTS)
buf = ""
for few in FEW_SHOTS:
buf += template_few_shot(*few)
buf += f"""username_0: I have a function in Python and I'd like someone to check my description of this function.
I'm doing this so that I can write a good docstring for this function.
Here is the code for the function:
```py
{code}
```
Here is my description of this program:
```
{doc}
```
Do not attempt to execute the function or to judge its correctness.
Answer with "Yes" or "No" depending on if my description has enough information alone to re-implement the function.
Also, answer with "No" if the description does not match the function.
Upvotes: 100username_1: Sure, no problem. I will be able to help.
My answer is:"""
return buf
def auto_dtype():
if torch.cuda.is_bf16_supported():
return "bfloat16"
return "auto"
def chunkify(lst, n):
chunks = []
for i in range(0, len(lst), n):
chunk = []
for j in range(n):
if i + j < len(lst):
chunk.append(lst[i + j])
chunks.append(chunk)
return chunks
dataset = datasets.load_dataset(args.dataset, split="train")
print(f"Loaded {len(dataset)} examples. Running pre-filtering...")
BAD_WORDS = ["todo", "fixme", "bug"]
BAD_IMPORTS = ["argparse", "os", "subprocess", "sys", "setuptools",
"distutils", "matplotlib", "seaborn"]
BAD_IMPORTS = [f"import {b}" for b in BAD_IMPORTS] + \
[f"from {b}" for b in BAD_IMPORTS]
BAD_SUBSTRINGS = BAD_WORDS + BAD_IMPORTS
bench_filter = benchmark_data.filter_out()
all_bench = bench_filter["human_eval_docstrings"] + \
bench_filter["human_eval_solutions"] + \
bench_filter["mbpp_docstrings"] + \
bench_filter["mbpp_solutions"]
def pre_filtering(ex):
code = ex[args.content_col]
code_bytes = code.encode('utf-8')
# filter out bad substrings
lower = code.lower()
for word in BAD_SUBSTRINGS:
if word in lower:
return False
for b in all_bench:
if b in code: # contaminated sample!
return False
# too many lines of code -- say 150
lines = code.split("\n")
if len(lines) > 150:
return False
# filter functions which don't have an argument
# 1. find first def statement in lines
# 2. check if contains ():
for line in lines:
if line.startswith("def ") and "():" in line:
return False
# filter out functions with no return statement
parser = make_parser()
if not does_have_return(code, parser=parser):
return False
try:
tree = global_parser.parse(code_bytes)
block, _ = FN_BLOCK_QUERY.captures(tree.root_node)[0]
# get the docstring, filter if not a docstring
exp = block.children[0]
if not exp.type == 'expression_statement' and not exp.children[0].type == 'string':
return False
docstring = exp.children[0]
docstring_text = docstring.text.decode('utf-8')
if not docstring_text.startswith('"""') and not docstring_text.endswith('"""'):
return False
except Exception as e:
print(f"Error in filtering: {e}")
return False
return True # all good!
threads = os.cpu_count() - 1 # type: ignore
dataset = dataset.filter(pre_filtering, num_proc=threads)
model = LLM(args.model, dtype=auto_dtype(),
gpu_memory_utilization=0.95, tensor_parallel_size=args.num_gpus)
tokenizer = model.get_tokenizer()
if args.sample_size is not None:
dataset = dataset.shuffle()
dataset = dataset.select(range(args.sample_size))
print(f"Now running stage 3 filtering on {len(dataset)} examples...")
def unindent(s):
lines = s.splitlines()
non_blank_lines = [line for line in lines if line.strip()]
min_indent = min(len(line) - len(line.lstrip())
for line in non_blank_lines) if non_blank_lines else 0
unindented_lines = [line[min_indent:] if len(
line) >= min_indent else line for line in lines]
return '\n'.join(unindented_lines)
def py_extract_docstring(code):
first_doc = code.find('"""')
assert first_doc != -1
first_doc = first_doc + 3
second_doc = code[first_doc+1:].find('"""')
assert second_doc != -1
second_doc = second_doc + first_doc + 1
doc = code[first_doc:second_doc]
doc = unindent(doc).strip()
code = code[:first_doc-3] + code[second_doc+3:]
return doc, code
# this is such a hack, but it works
dummy = 'def dummy(): \n """\n """\n pass'
dummy_prompt = prompt_fmt(dummy)
few_shot_toks = len(tokenizer.encode(
dummy_prompt)) - len(tokenizer.encode(dummy))
print(f"Few-shot prompt has {few_shot_toks} tokens")
prompts = []
for ex in tqdm(dataset, total=len(dataset), desc="Generating prompts"):
code = ex[args.content_col]
toks = len(tokenizer.encode(code)) + few_shot_toks
if toks > 16380:
print(f"Skipping example with {toks} tokens")
# to skip, just add dummy prompt
prompts.append(dummy_prompt)
continue
p = prompt_fmt(code)
prompts.append(p)
responses = []
for chunk in tqdm(chunkify(prompts, args.batch_size), desc="Generating responses"):
outs = model.generate(chunk, SamplingParams(
temperature=0.0, stop="\n", max_tokens=5))
contents = [o.outputs[0].text for o in outs]
for c in contents:
yes_count = c.lower().count("yes")
no_count = c.lower().count("no")
if yes_count > no_count:
responses.append(True)
elif yes_count < no_count:
responses.append(False)
else:
# default to No
responses.append(False)
new_ds = dataset.filter( # horrible hack!
lambda ex, i: responses[i] and "def dummy()" not in ex[args.content_col], with_indices=True)
print(f"Filtered {len(dataset) - len(new_ds)} examples")
new_ds.push_to_hub(args.push, private=True)
selfcodealign-selfcodealign/seed_gathering/generate_from_the_stack.py 0000664 0000000 0000000 00000010767 14637551746 0026673 0 ustar 00root root 0000000 0000000 from tree_sitter_parser import LANGUAGE, make_parser, node_to_string
import datasets
import os
import signal
from multiprocessing import Pool
TOPLEVEL_DOCSTRING_QUERY = LANGUAGE.query("""
(
(function_definition
name: (identifier)
body: (block .
(expression_statement
(string
(string_start) @docstring.start
(string_content)
(string_end) @docstring.end)))) @function.def
(#eq? @docstring.start "\\\"\\\"\\\"")
(#eq? @docstring.end "\\\"\\\"\\\"")
)
""")
def get_fns_with_docstrings(src, tree):
captures = TOPLEVEL_DOCSTRING_QUERY.captures(tree.root_node)
res = []
for capture in captures:
node, ty = capture
if ty != "function.def":
continue
# if the starting col is not 0, then it's not a top-level fn
_, col = node.start_point
if col != 0:
continue
res.append(node_to_string(src, node))
return res
def parse_ex(parser, ex):
ex = ex["content"]
try:
buf = bytes(ex, "utf8")
tree = parser.parse(buf)
return get_fns_with_docstrings(buf, tree)
except:
return []
# if one parser segfaults, we can just make a new one and other parsers will still be fine
# WE LOVE TREE SITTER!
PARSERS = None
def process_chunk(idx_and_chunk):
assert PARSERS is not None
idx, chunk = idx_and_chunk
parser = PARSERS[idx]
chunk_new_funs = set()
for ex in chunk:
chunk_new_funs.update(parse_ex(parser, ex))
return chunk_new_funs
def main(args):
global PARSERS
ds = datasets.load_dataset(
args.dataset,
data_dir=args.data_dir,
split="train",
)
funs = set()
PARSERS = [make_parser() for _ in range(args.num_workers)]
total_len = len(ds)
CHUNK_SIZE = 1000 * args.num_workers
print(f"Total length: {total_len}")
print(f"Chunk size: {CHUNK_SIZE}")
chunk = []
p = Pool(args.num_workers)
for i, ex in enumerate(ds):
if i % (total_len // 100) == 0:
print(f"{i}/{total_len}")
try:
chunk.append(ex)
if len(chunk) == CHUNK_SIZE or i == total_len - 1:
print(f"Processing chunk {i // CHUNK_SIZE}")
# divide the chunk into NUM_WORKERS chunks
subchunk_size = len(chunk) // args.num_workers
subchunks = [chunk[i:i + subchunk_size]
for i in range(0, len(chunk), subchunk_size)]
new_funs_iter = p.imap(
process_chunk, [(i, subchunk) for i, subchunk in enumerate(subchunks)])
print("Getting new functions")
len_before = len(funs)
while True:
try:
def timeout_handler(_, __):
raise KeyboardInterrupt # it's fineeeeeee
signal.signal(signal.SIGALRM, timeout_handler)
signal.alarm(60)
funs.update(next(new_funs_iter))
signal.alarm(0)
except KeyboardInterrupt:
signal.alarm(0)
print("Keyboard interrupt. Terminating pool")
p.terminate()
p = Pool(args.num_workers)
break
except StopIteration:
break
except Exception as e:
print(e)
signal.alarm(0)
PARSERS = [make_parser() for _ in range(args.num_workers)]
print(
f"Done processing chunk {i // CHUNK_SIZE}. Got {len(funs) - len_before} new functions")
chunk = []
except Exception as e:
print(e)
chunk = []
if i == total_len - 1:
break
p.close()
new_ds_dict = {
"content": list(funs),
"id": list(range(len(funs)))
}
new_ds = datasets.Dataset.from_dict(new_ds_dict)
new_ds.push_to_hub(args.push, private=True)
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--num_workers", type=int, default=os.cpu_count())
parser.add_argument("--dataset", type=str,
default="bigcode/the-stack-dedup")
parser.add_argument("--data_dir", type=str, default="data/python")
parser.add_argument("--push", type=str, required=True)
args = parser.parse_args()
main(args)
selfcodealign-selfcodealign/seed_gathering/high_quality_subset.py 0000664 0000000 0000000 00000011370 14637551746 0026074 0 ustar 00root root 0000000 0000000 import datasets
import subprocess
import tempfile
import signal
import hashlib
import os
import argparse
from typing import List, Dict
from tqdm import tqdm
from tree_sitter_parser import LANGUAGE, global_parser
RETURN_QUERY = LANGUAGE.query("""
(return_statement) @return
""")
def does_have_return(src):
tree = global_parser.parse(bytes(src, "utf8"))
root = tree.root_node
captures = RETURN_QUERY.captures(root)
for node, _ in captures:
# if it doesn't have an argument, it's not a return with a value
if len(node.children) <= 1: # includes "return" itself
continue
else:
return True
return False
if __name__ == "__main__":
print(does_have_return("def foo():\n return"))
# runs pyright in the given directory, returns stdout
# then, it logs the number of errors for each file
def run_pyright(d):
try:
outs = subprocess.run(
["pyright", "*"],
cwd=d,
capture_output=True,
timeout=120,
text=True,
).stdout
except Exception as e:
print(e)
return None
cur_file = ""
filemap = {}
lines = outs.split("\n")
for i, line in enumerate(lines):
if i == len(lines) - 2:
break
if line.startswith(" "):
if "- error:" in line:
filemap[cur_file] += 1
else:
file = line.split("/")[-1]
filemap[file] = 0
cur_file = file
return filemap
def typecheck_batch(files: List[str]) -> Dict[str, str]:
# Create a temporary directory using the tempfile module
filemap: Dict[str, str] = {}
with tempfile.TemporaryDirectory() as tempdir:
for contents in files:
hash_object = hashlib.sha1(bytes(contents, "utf8"))
hex_dig = hash_object.hexdigest()
filemap[hex_dig] = contents
name = os.path.join(tempdir, hex_dig + ".py")
with open(name, "w") as f:
f.write(contents)
# Run pyright in the temporary directory
typecheck_map = run_pyright(tempdir)
if typecheck_map is None:
return {}
for contents, errors in typecheck_map.items():
no_py = contents.replace(".py", "")
if errors == 0:
continue
if no_py in filemap:
del filemap[no_py]
print(f"Pass rate: {len(filemap)}/{len(files)}")
return filemap
def infer_imports(code: str) -> str:
import autoimport
try:
def handler(signum, frame):
raise Exception("Timeout")
signal.signal(signal.SIGALRM, handler)
signal.alarm(10)
inferred = autoimport.fix_code(code)
signal.alarm(0)
return inferred
except Exception as e:
signal.alarm(0)
print(f"Error while inferring imports: {e}")
return code
def main(args):
ds = datasets.load_dataset(args.dataset,
data_dir="data", split="train")
print("Filtering to only functions with return statements")
ds = ds.filter(lambda ex: does_have_return(
ex["content"]), num_proc=os.cpu_count())
if args.infer_imports:
print("Inferring imports for functions")
ds = ds.map(lambda ex: {"content": infer_imports(
ex["content"])}, num_proc=os.cpu_count())
batch = []
max_i = len(ds) - 1
new_ds = {
"content": [],
"sha1": [],
"id": [],
}
e_id = 0
for i, ex in enumerate(tqdm(ds, total=len(ds))):
try:
code = ex["content"]
batch.append(code)
if len(batch) == args.batch_size or i == max_i:
filemap = typecheck_batch(batch)
for sha1, contents in filemap.items():
new_ds["content"].append(contents)
new_ds["sha1"].append(sha1)
new_ds["id"].append(e_id)
e_id += 1
batch = []
except Exception as e:
print(f"There was an error: {e}")
continue
new_ds_hf = datasets.Dataset.from_dict(new_ds)
new_ds_hf.push_to_hub(args.push, private=True)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--dataset", type=str,
help="Points to dataset of python functions with docstrings. Columns: 'content'",
required=True)
parser.add_argument(
"--push", type=str, required=True, help="Push to this dataset to which repo")
parser.add_argument(
"--infer-imports", action="store_true", help="Infer imports for functions")
parser.add_argument(
"--batch-size", type=int, default=250, help="Batch size for typechecking")
args = parser.parse_args()
main(args)
selfcodealign-selfcodealign/seed_gathering/requirements.txt 0000664 0000000 0000000 00000000113 14637551746 0024723 0 ustar 00root root 0000000 0000000 datasets==2.18.0
tree-sitter==0.20.4
tqdm==4.65.0
torch==2.1.2
vllm==0.4.1
selfcodealign-selfcodealign/seed_gathering/tree-sitter-python/ 0000775 0000000 0000000 00000000000 14637551746 0025232 5 ustar 00root root 0000000 0000000 selfcodealign-selfcodealign/seed_gathering/tree_sitter_parser.py 0000664 0000000 0000000 00000002600 14637551746 0025721 0 ustar 00root root 0000000 0000000 from tree_sitter import Language, Parser
Language.build_library(
'build/lang.so',
[
'./tree-sitter-python'
]
)
LANGUAGE = Language('build/lang.so', 'python')
QUERY = LANGUAGE.query("""
(function_definition name: (identifier) @fn-name)
""")
global_parser = Parser()
global_parser.set_language(LANGUAGE)
def get_fn_name(code, parser=global_parser):
src = bytes(code, "utf8")
tree = parser.parse(src)
node = tree.root_node
for cap, typ in QUERY.captures(node):
if typ == "fn-name":
return node_to_string(src, cap)
return None
def node_to_string(src: bytes, node):
return src[node.start_byte:node.end_byte].decode("utf8")
def make_parser():
_parser = Parser()
_parser.set_language(LANGUAGE)
return _parser
RETURN_QUERY = LANGUAGE.query("""
(return_statement) @return
""")
def does_have_return(src, parser=global_parser):
tree = parser.parse(bytes(src, "utf8"))
root = tree.root_node
captures = RETURN_QUERY.captures(root)
for node, _ in captures:
# if it doesn't have an argument, it's not a return with a value
if len(node.children) <= 1: # includes "return" itself
continue
else:
return True
return False
if __name__ == "__main__":
code = """
import ble
from a import b
"""
print(global_parser.parse(bytes(code, "utf8")).root_node.sexp())
selfcodealign-selfcodealign/self_ossinstruct_sc2.sh 0000775 0000000 0000000 00000002324 14637551746 0023214 0 ustar 00root root 0000000 0000000 #!/bin/bash
echo "MODE: $MODE"
echo "SEED_DATA_FILE: $SEED_DATA_FILE"
echo "INDEX: $INDEX"
echo "MAX_NEW_DATA: $MAX_NEW_DATA"
echo "DIR: $1"
# if mode is "I->R", num of samples is 10, otherwise 1
if [[ "$MODE" == "I->R" ]]; then
N_SAMPLES=1
NUM_FEWSHOTS=1
NUM_BATCHED_REQUESTS=4096
ASYNC_MICRO_BATCH_SIZE=16
else
N_SAMPLES=1
NUM_FEWSHOTS=8
NUM_BATCHED_REQUESTS=4096
ASYNC_MICRO_BATCH_SIZE=8
fi
echo "N_SAMPLES: $N_SAMPLES"
echo "NUM_FEWSHOTS: $NUM_FEWSHOTS"
echo "NUM_BATCHED_REQUESTS: $NUM_BATCHED_REQUESTS"
echo "ASYNC_MICRO_BATCH_SIZE: $ASYNC_MICRO_BATCH_SIZE"
COMMAND="python -m star_align.self_ossinstruct \
--async_micro_batch_size $ASYNC_MICRO_BATCH_SIZE \
--use_vllm_server True \
--instruct_mode '$MODE' \
--seed_data_files $SEED_DATA_FILE \
--max_new_data $MAX_NEW_DATA \
--tag sc2-${NUM_FEWSHOTS}shot \
--temperature 0.7 \
--seed_code_start_index $INDEX \
--model bigcode/starcoder2-15b \
--num_fewshots $NUM_FEWSHOTS \
--num_batched_requests $NUM_BATCHED_REQUESTS \
--num_sample_per_request $N_SAMPLES \
--save_dir $1"
if [[ -n "$2" ]]; then
COMMAND="$COMMAND --continue_from $2"
fi
echo "Running command: $COMMAND"
eval $COMMAND
selfcodealign-selfcodealign/self_ossinstruct_sc2_parallel.sh 0000775 0000000 0000000 00000004541 14637551746 0025073 0 ustar 00root root 0000000 0000000 #!/bin/bash
echo "MODE: $MODE"
echo "SEED_DATA_FILE: $SEED_DATA_FILE"
echo "INDEX: $INDEX"
echo "MAX_NEW_DATA: $MAX_NEW_DATA"
echo "DIR: $1"
NUM_GPUS=$(nvidia-smi --query-gpu=count --format=csv,noheader,nounits | head -n 1)
DATA_CHUNK_SIZE=$(($MAX_NEW_DATA / $NUM_GPUS))
REMAINDER=$(($MAX_NEW_DATA % $NUM_GPUS))
if [[ "$MODE" == "I->R" ]]; then
N_SAMPLES=1
NUM_FEWSHOTS=1
NUM_BATCHED_REQUESTS=4096
ASYNC_MICRO_BATCH_SIZE=16
else
N_SAMPLES=1
NUM_FEWSHOTS=8
NUM_BATCHED_REQUESTS=4096
ASYNC_MICRO_BATCH_SIZE=8
fi
echo "N_SAMPLES: $N_SAMPLES"
echo "NUM_FEWSHOTS: $NUM_FEWSHOTS"
echo "NUM_BATCHED_REQUESTS: $NUM_BATCHED_REQUESTS"
echo "ASYNC_MICRO_BATCH_SIZE: $ASYNC_MICRO_BATCH_SIZE"
PIDS=()
function killall_pids {
for pid in ${PIDS[@]}; do
kill $pid
done
}
trap killall_pids SIGINT SIGTERM
for (( GPU_ID=0; GPU_ID<$NUM_GPUS; GPU_ID++ ))
do
START_INDEX=$(($INDEX + $GPU_ID * $DATA_CHUNK_SIZE))
if [[ $GPU_ID -lt $REMAINDER ]]; then
CHUNK_SIZE=$(($DATA_CHUNK_SIZE + 1))
else
CHUNK_SIZE=$DATA_CHUNK_SIZE
fi
END_INDEX=$(($START_INDEX + $CHUNK_SIZE - 1))
echo "Starting process for GPU $GPU_ID with data from $START_INDEX to $END_INDEX..."
OUTDIR="$1/$GPU_ID"
mkdir -p $OUTDIR
CUDA_VISIBLE_DEVICES=$GPU_ID python -m star_align.self_ossinstruct \
--async_micro_batch_size $ASYNC_MICRO_BATCH_SIZE \
--use_vllm_server False \
--instruct_mode "$MODE" \
--seed_data_files $SEED_DATA_FILE \
--max_new_data $CHUNK_SIZE \
--tag sc2-${NUM_FEWSHOTS}shot \
--temperature 0.7 \
--seed_code_start_index $START_INDEX \
--model bigcode/starcoder2-15b \
--num_fewshots $NUM_FEWSHOTS \
--num_batched_requests $NUM_BATCHED_REQUESTS \
--num_sample_per_request $N_SAMPLES \
--save_dir $OUTDIR &
PIDS+=($!)
done
wait
if [[ $? -ne 0 ]]; then
echo "Error in one of the processes. Exiting... Check logs for more details."
exit 1
fi
# dir for final res
FINAL="$1/final"
FINAL_FILE="$FINAL/aggregated-${MODE}.jsonl"
echo "All processes finished. Aggregating results... to $FINAL_FILE"
# aggregate!
mkdir -p $FINAL
touch $FINAL_FILE
for (( GPU_ID=0; GPU_ID<$NUM_GPUS; GPU_ID++ ))
do
# get first file for dir
FILE=$(ls $1/$GPU_ID | head -n 1)
cat $1/$GPU_ID/$FILE >> $FINAL_FILE
done
echo "Done!"
selfcodealign-selfcodealign/src/ 0000775 0000000 0000000 00000000000 14637551746 0017263 5 ustar 00root root 0000000 0000000 selfcodealign-selfcodealign/src/star_align/ 0000775 0000000 0000000 00000000000 14637551746 0021406 5 ustar 00root root 0000000 0000000 selfcodealign-selfcodealign/src/star_align/__init__.py 0000664 0000000 0000000 00000000024 14637551746 0023513 0 ustar 00root root 0000000 0000000 from . import utils
selfcodealign-selfcodealign/src/star_align/clean_data.py 0000664 0000000 0000000 00000006017 14637551746 0024037 0 ustar 00root root 0000000 0000000 import ast
import random
from dataclasses import dataclass, field
from pathlib import Path
from typing import cast
from tqdm.auto import tqdm
from transformers import HfArgumentParser
from star_align.utils import find_code_blocks, read_jsonl, write_jsonl
@dataclass(frozen=True)
class Args:
data_files: list[str]
output_file: str
diversify_func_names: bool = field(default=False)
def extract_and_concat_function_names(python_content):
"""
Extracts all function names from a given Python content string and concatenates them into a single string.
Parameters:
- python_content: A string containing the Python code to analyze.
Returns:
- A string containing all function names defined in the content, concatenated.
"""
tree = ast.parse(python_content)
function_names = []
# Define a node visitor that adds the name of each function definition it visits
class FunctionDefVisitor(ast.NodeVisitor):
def visit_FunctionDef(self, node):
function_names.append(node.name)
# Process the subtree for this node
self.generic_visit(node)
def visit_AsyncFunctionDef(self, node):
function_names.append(node.name)
self.generic_visit(node)
# Create a node visitor and walk through the AST
visitor = FunctionDefVisitor()
visitor.visit(tree)
# Concatenate all function names into a single string
return " ".join(function_names)
def main():
args = cast(Args, HfArgumentParser(Args).parse_args_into_dataclasses()[0])
raw_data: list[dict] = []
for data_file in args.data_files:
data = read_jsonl(Path(data_file))
# language = data_file.split("-")[1]
# assert language in ALL_LANGS, f"Unknown language {language}"
# raw_data.extend(dict(lang=language, **d) for d in data)
raw_data.extend(data)
# common keys for all d in data
common_keys = set.intersection(*(set(d.keys()) for d in raw_data))
raw_data = [{k: d[k] for k in common_keys} for d in raw_data]
print(f"Common keys: {common_keys}")
# counter = defaultdict[str, int](int)
def mk_key(instruction: str) -> str:
return "".join(instruction.split())
random.seed(0)
random.shuffle(raw_data)
seen_keys = set[str]()
new_data = list[dict]()
for d in tqdm(raw_data):
key_i, key_r = mk_key(d["instruction"]), mk_key(d["response"])
if key_i in seen_keys or key_r in seen_keys:
continue
if args.diversify_func_names:
code_block = find_code_blocks(d["response"])[0]
try:
fn_names = extract_and_concat_function_names(code_block)
except SyntaxError:
continue
if fn_names in seen_keys:
continue
seen_keys.add(fn_names)
new_data.append(d)
seen_keys.add(key_i)
seen_keys.add(key_r)
print(f"Chose {len(new_data)} out of {len(raw_data)}")
write_jsonl(Path(args.output_file), new_data)
if __name__ == "__main__":
main()
selfcodealign-selfcodealign/src/star_align/code_exec_server/ 0000775 0000000 0000000 00000000000 14637551746 0024712 5 ustar 00root root 0000000 0000000 selfcodealign-selfcodealign/src/star_align/collect_snippets.py 0000664 0000000 0000000 00000052040 14637551746 0025333 0 ustar 00root root 0000000 0000000 import json
import random
import re
import textwrap
import warnings
from dataclasses import dataclass, field
from pathlib import Path
from typing import Generator, cast
from datasets import Dataset, concatenate_datasets, load_dataset
from tqdm.auto import tqdm
from transformers import HfArgumentParser
import star_align
print("Warning: ignoring warnings")
warnings.filterwarnings("ignore")
@dataclass(frozen=True)
class Args:
data_dirs: list[str]
data_mix_weights: list[float]
max_seeds_to_collect: int = field(default=100000000)
continue_from: str | None = field(default=None)
# Keep the following arguments unchanged for reproducibility
seed: int = field(default=976)
min_lines: int = field(default=5)
max_lines: int = field(default=30)
min_doc_lines: int = field(default=10)
max_doc_lines: int = field(default=5000)
max_avg_chars_per_line: int = field(default=80)
# max_fragments: int = field(default=3)
chunk_size: int = field(default=1000)
# A small value lets one document be used by multiple seeds
content_chunk_lines: int = field(default=100)
dataset_name: str = field(default="bigcode/starcoderdata")
data_files: list[str] | None = field(default=None)
max_considered_data: int | None = field(default=500000000)
collect_function: bool = field(default=False)
max_nodes_to_traverse: int = field(default=20000)
tag: str = field(
default="",
metadata={
"help": "Custom tag as part of the output filename, not affecting the fingerprint"
},
)
text_wrap: int | None = field(default=None)
std_lib_only: bool = field(default=False)
min_stars: int = field(default=0)
n_cores: int = field(default=star_align.utils.N_CORES)
def fingerprint(self) -> str:
# The combination of arguments can uniquely determine the generation process
args = [
self.data_dirs,
self.data_mix_weights,
self.seed,
self.min_lines,
self.max_lines,
self.min_doc_lines,
self.max_doc_lines,
self.max_avg_chars_per_line,
self.chunk_size,
self.dataset_name,
self.max_considered_data,
self.content_chunk_lines,
self.min_stars,
self.text_wrap,
self.data_files,
self.collect_function,
self.max_nodes_to_traverse,
]
# for backward compatibility, only add if needed
# if self.text_wrap is not None:
# args.append(self.text_wrap)
# if self.data_files is not None:
# args.append(self.data_files)
return star_align.utils.compute_fingerprint(*args, hash_length=5)
# def fragments_to_text(fragments: list[str]) -> str:
# return "...\n".join(fragments)
ASTTypeMap = {
"cpp": [
"function_definition"
], # https://github.com/tree-sitter/tree-sitter-cpp/blob/master/grammar.js
# "csharp": [
# "method_declaration"
# ], # https://github.com/tree-sitter/tree-sitter-c-sharp/blob/master/grammar.js
"java": [
"method_declaration"
], # https://github.com/tree-sitter/tree-sitter-java/blob/master/grammar.js
"php": [
"method_declaration"
], # https://github.com/tree-sitter/tree-sitter-php/blob/master/grammar.js
"python": [
"function_definition"
], # https://github.com/tree-sitter/tree-sitter-python/blob/master/grammar.js
"rust": [
"function_item"
], # https://github.com/tree-sitter/tree-sitter-rust/blob/master/grammar.js
# "swift": [
# "function_declaration"
# ], # https://github.com/alex-pinkus/tree-sitter-swift/blob/main/grammar.js
"typescript": [
"function_declaration",
"method_definition",
], # https://github.com/tree-sitter/tree-sitter-typescript/blob/master/typescript/grammar.js
# "bash": [
# "function_definition"
# ], # https://github.com/tree-sitter/tree-sitter-bash/blob/master/grammar.js
}
EXCLUDED_PATTERNS = {
"python": {
"function_definition": [
"def __[a-zA-Z0-9_]*__\\(", # Broadly exclude magic methods, but note this may also exclude some user-defined dunder methods which might be 'interesting'
"def test[a-zA-Z0-9_]*\\(", # Exclude test functions
# ends with pass
# "\\(self[,\\)]",
"pass$",
]
},
"cpp": {
"function_definition": [
"~[a-zA-Z0-9_]*\\(", # Exclude C++ destructors
]
},
"java": {
"function_definition": [
"[gs]et[A-Z][0-9a-zA-Z_]*\\(",
]
},
"php": {
"function_definition": [
"function __[A-Za-z0-9_]*", # Exclude PHP magic methods
"function test[a-zA-Z0-9_]*\\(", # Exclude PHP magic methods
]
},
"rust": {
"function_definition": [
"fn new(",
"fn default(",
"fn test[a-zA-Z0-9_]*\\(",
]
},
"typescript": {
"function_definition": [
"constructor(",
]
},
}
def extract_snippets_with_constraints(
tree,
source_code: str,
considered_types: list[str],
min_lines: int,
max_lines: int,
max_nodes_to_traverse: int,
excluded_patterns: dict[str, list[str]],
) -> list[str]:
"""
Extract snippets from the source code that match the given constraints.
"""
from tree_sitter import Node, Tree
assert isinstance(tree, Tree)
matching_snippets = list[str]()
# source_code = root_node.text.decode()
# https://github.com/tree-sitter/py-tree-sitter/blob/master/examples/walk_tree.py
def traverse_tree(tree: Tree) -> Generator[Node, None, None]:
cursor = tree.walk()
visited_children = False
while True:
if not visited_children:
yield cursor.node
if not cursor.goto_first_child():
visited_children = True
elif cursor.goto_next_sibling():
visited_children = False
elif not cursor.goto_parent():
break
all_nodes_iter = traverse_tree(tree)
for node, _ in zip(all_nodes_iter, range(max_nodes_to_traverse)):
if node.type in considered_types:
start_line = node.start_point[0] # line numbers are zero-indexed
end_line = node.end_point[0]
line_count = end_line - start_line + 1
if min_lines <= line_count <= max_lines:
snippet = extract_code_with_indentation(node, source_code)
# Check if the fragment contains any of the excluded keywords
if all(
re.search(pattern, snippet) is None
for pattern in excluded_patterns.get(node.type, [])
):
snippet = textwrap.dedent(snippet)
matching_snippets.append(snippet)
return matching_snippets
def extract_code_with_indentation(node, source_code: str) -> str:
"""
Extract the source code corresponding to a given node from the original source code string,
including the indentation based on the node's starting line.
"""
start_byte = node.start_byte
end_byte = node.end_byte
# Find the newline character before the node starts, to determine the start of the line
start_of_line = (
source_code.rfind("\n", 0, start_byte) + 1
) # +1 to move past the newline character
# Calculate the indentation by counting whitespace characters from the start of the line to the node start
indentation = ""
for i in range(start_of_line, start_byte):
if source_code[i].isspace():
indentation += source_code[i]
else:
break
# Extract the code and prepend the indentation to each line
code_fragment = source_code[start_byte:end_byte]
indented_code_fragment = indentation + code_fragment
return indented_code_fragment
def chunk_content(examples: dict, indices: list[int], args: Args) -> dict:
contents = examples["content"]
examples["raw_index"] = indices
def chunk(content: str) -> list[str]:
lines = content.splitlines(keepends=True)
chunks = list[str]()
for end_idx in range(len(lines), 0, -args.content_chunk_lines):
# throw away the last chunk if it's too small
if end_idx < args.content_chunk_lines and len(chunks) > 0:
break
chunks.append("".join(lines[end_idx - args.content_chunk_lines : end_idx]))
return chunks
new_data: dict = dict()
for index in range(len(contents)):
content = contents[index]
chunked_contents = chunk(content)
new_data.setdefault("chunked_content", []).extend(chunked_contents)
for key in examples.keys():
new_others = [examples[key][index]] * len(chunked_contents)
new_data.setdefault(key, []).extend(new_others)
return new_data
def map_dataset(examples: dict, indices: list[int], args: Args, data_dir: str) -> dict:
random.seed(args.seed + sum(map(ord, data_dir)) + indices[0])
stars = list(map(int, examples["max_stars_count"]))
content_key = "chunked_content" if not args.collect_function else "content"
contents = list(map(sanitize_document, examples[content_key]))
assert len(contents) == len(stars)
if not args.collect_function:
seed_fragments = [
(
extract_fragment(args, content)
if content is not None and star >= args.min_stars
else None
)
for star, content in zip(stars, contents)
]
# seed = [
# (fragments_to_text(fragments) if fragments is not None else None)
# for fragments in seed_fragments
# ]
assert len(seed_fragments) == len(indices)
return {
"seed": seed_fragments,
"repo": examples["max_stars_repo_name"],
"star": stars,
"id": list(map(int, indices)),
"raw_index": examples["raw_index"],
"data_dir": [data_dir for _ in indices],
# "content": examples["content"]
}
from tree_sitter_languages import get_parser
parser = get_parser(data_dir)
repos = examples["max_stars_repo_name"]
ids = examples["id"]
raw_indices = indices
data_dirs = [data_dir for _ in indices]
data: dict[str, list] = {
"seed": [],
"repo": [],
"star": [],
"id": [],
"raw_index": [],
"data_dir": [],
}
for repo, star, id, raw_index, content, data_dir in zip(
repos, stars, ids, raw_indices, contents, data_dirs
):
if (
content is None
or star < args.min_stars
or (n_lines := content.count("\n")) < args.min_doc_lines
or n_lines > args.max_doc_lines
or len(content) > args.max_avg_chars_per_line * args.max_doc_lines
):
continue
try:
content_encoded = content.encode()
if len(content_encoded) != len(content):
# probably Non-english
continue
tree = parser.parse(content_encoded)
root_node = tree.root_node
if root_node.has_error:
continue
# if len(root_node.text) != len(content):
# # probably Non-english
# continue
snippets = extract_snippets_with_constraints(
tree=tree,
source_code=content,
considered_types=ASTTypeMap[data_dir],
min_lines=args.min_lines,
max_lines=args.max_lines,
max_nodes_to_traverse=args.max_nodes_to_traverse,
excluded_patterns=EXCLUDED_PATTERNS[data_dir],
)
data["seed"].extend(snippets)
for key in ["repo", "star", "id", "raw_index", "data_dir"]:
data[key].extend([locals()[key]] * len(snippets))
except UnicodeError:
pass
return data
# def uniform_partition(n: int, k: int) -> list[int]:
# """Partition n into k non-negative integers. Stars and bars method.
# x1 + x2 + ... + xk = n; xi >= 0. Can be transformed to positive case:
# y1 + y2 + ... + yk = n - k; yi = xi + 1 > 0"""
# assert n >= 0, "n should be >= 0"
# assert k > 0, " should be > 0"
# random_numbers = [random.randint(0, n) for _ in range(k - 1)]
# values = [0] + sorted(random_numbers) + [n]
# intervals = [values[i + 1] - values[i] for i in range(len(values) - 1)]
# assert sum(intervals) == n
# assert len(intervals) == k
# return intervals
# def uniform_partition_positive(n: int, k: int) -> list[int]:
# return [x + 1 for x in uniform_partition(n - k, k)]
# def is_en(content: str, seed: int) -> bool:
# import langdetect
# langdetect.DetectorFactory.seed = seed
# try:
# return langdetect.detect(content) == "en"
# except langdetect.lang_detect_exception.LangDetectException:
# return False
# def place_blocks(n: int, sizes: list[int]) -> list[int]:
# """Randomly place k blocks of sizes `sizes` in a line of length n. Return the starting positions."""
# assert n >= 0, "n should be >= 0"
# k = len(sizes)
# assert k > 0, "k should be > 0"
# assert sum(sizes) <= n, "sum(sizes) should be <= n"
# if k == 1:
# return [random.randint(0, n - sizes[0])]
# all_but_last_pos = place_blocks(n - sizes[-1], sizes[:-1])
# last_pos = random.randint(all_but_last_pos[-1] + sizes[-2], n - sizes[-1])
# result = all_but_last_pos + [last_pos]
# assert len(result) == k
# for i in range(k - 1):
# assert result[i] + sizes[i] <= result[i + 1]
# return result
def sanitize_document(document: str) -> str | None:
"""Sanitize the document by removing the first line if it's a placeholder."""
if (
document.startswith("")
or document.startswith("")
or document.startswith("")
):
# remove the first line
newline_index = document.find("\n")
if newline_index == -1:
return None
document = document[newline_index + 1 :]
return document
def extract_fragment(args: Args, document: str) -> str | None:
if args.std_lib_only:
if not check_std_libs_only(document):
return None
else:
return document
if args.text_wrap is not None:
document = textwrap.fill(
document,
width=args.text_wrap,
replace_whitespace=False,
expand_tabs=False,
break_on_hyphens=False,
drop_whitespace=False,
break_long_words=False,
)
# if args.data_dir == "markdown" and not is_en(document, args.seed):
# return None
document = document.replace("\r", "")
document = re.sub(r"\n\n+", "\n\n", document)
lines = document.splitlines(keepends=True)
# special rules
# if args.data_dir == "jupyter-scripts-dedup-filtered":
# lines = [
# line
# for line in lines
# if "jupyter" not in line.lower() and "jupytext" not in line.lower()
# ]
# elif args.data_dir == "markdown":
# lines = [
# line
# for line in lines
# if "http:" not in line and "https:" not in line and "www." not in line
# ]
# lines = [line for line in lines if line.strip() != ""]
# if len(lines) < args.min_lines or len(lines) == 0:
if len(lines) < args.min_doc_lines or len(lines) > args.max_doc_lines:
return None
# avg chars
if len(document) > args.max_avg_chars_per_line * args.max_doc_lines:
return None
max_lines = min(args.max_lines, len(lines))
assert args.max_lines >= args.min_lines
n_lines_to_consider = random.randint(args.min_lines, max_lines)
# max_fragments = min(n_lines_to_consider, args.max_fragments)
# n_fragments = random.randint(1, max_fragments)
# fragment_sizes = uniform_partition_positive(n_lines_to_consider, n_fragments)
# fragment_indices = place_blocks(len(lines), fragment_sizes)
# fragments = [
# "".join(lines[i : i + size])
# for i, size in zip(fragment_indices, fragment_sizes)
# ]
start_index = random.randint(0, len(lines) - n_lines_to_consider)
# random.shuffle(fragments)
content = "".join(lines[start_index : start_index + n_lines_to_consider])
content = textwrap.dedent(content.replace("\t", " "))
return content
import sys
def is_std_lib(name):
"""Check if a module is a standard library."""
return name in {*sys.builtin_module_names, *sys.stdlib_module_names}
def check_std_libs_only(code):
"""Check if all imported libraries in the given code are standard libraries."""
lines = code.split("\n")
for line in lines:
if line.startswith("import ") or line.startswith("from "):
parts = line.split()
if len(parts) < 2:
# special case
return False
if line.startswith("import "):
module_name = parts[1].split(".")[0] # Get the base module name
else: # from ... import ...
module_name = parts[1]
if not is_std_lib(module_name):
return False
return True
def main():
args = cast(Args, HfArgumentParser(Args).parse_args_into_dataclasses()[0])
assert len(args.data_dirs) == len(args.data_mix_weights)
sum_weights = sum(args.data_mix_weights)
data_mix_ratios = [w / sum_weights for w in args.data_mix_weights]
random.seed(args.seed)
raw_datasets: list[Dataset] = []
num_proc = args.n_cores
# num_proc = 1
for data_dir, ratio in zip(args.data_dirs, data_mix_ratios):
max_considered_data = (
None
if args.max_considered_data is None
else int(args.max_considered_data * ratio)
)
print(f"Loading {data_dir} with max_considered_data={max_considered_data}")
split = (
f"train[:{max_considered_data}]"
if max_considered_data is not None
else "train"
)
try:
kwargs = dict(
data_dir=data_dir,
split=split,
data_files=args.data_files,
num_proc=num_proc,
ignore_verifications=True,
)
sub_dataset = load_dataset(args.dataset_name, **kwargs)
except ValueError:
print(
f"Failed to load {data_dir} with split=train[:{max_considered_data}]. Trying split=train"
)
kwargs["split"] = "train"
sub_dataset = load_dataset(args.dataset_name, **kwargs)
if not args.collect_function:
sub_dataset = sub_dataset.map(
function=chunk_content,
fn_kwargs=dict(args=args),
with_indices=True,
batched=True,
batch_size=args.chunk_size,
num_proc=num_proc,
remove_columns=["content"],
)
raw_datasets.append(sub_dataset)
# map_fn = get_map_dataset(args)
datasets: list[Dataset] = []
for data_dir, sub_dataset in zip(args.data_dirs, raw_datasets):
sub_dataset = sub_dataset.map(
function=map_dataset,
fn_kwargs=dict(args=args, data_dir=data_dir),
with_indices=True,
batched=True,
num_proc=num_proc,
batch_size=args.chunk_size,
remove_columns=sub_dataset.column_names,
load_from_cache_file=False,
)
datasets.append(sub_dataset)
dataset = concatenate_datasets(datasets)
dataset = dataset.shuffle(seed=args.seed)
# Every run should produce the same data as long as the default params are not changed
data_fingerprint = args.fingerprint()
timestamp = star_align.utils.timestamp()
tag = "" if args.tag == "" else f"-{args.tag}"
path = Path(f"data-seed{tag}-{data_fingerprint}-{timestamp}.jsonl")
assert not path.exists()
with path.open("w") as f_out:
print("Saving to", path)
n_success = 0
all_seed_texts = set[str]()
def get_seed_text(seed: str) -> str:
return "".join(seed.split())
pbar = tqdm(total=min(args.max_seeds_to_collect, len(dataset)))
for example in dataset:
if n_success >= args.max_seeds_to_collect:
break
if example["seed"] is None:
continue
seed_text = get_seed_text(example["seed"])
# remove those with only symbols
if all(not c.isalpha() for c in seed_text):
# print("[filter(symbols Only)]", example["seed"], sep="\n")
continue
if seed_text in all_seed_texts:
# print("[filter(duplicate)]", example["seed"], sep="\n")
continue
all_seed_texts.add(seed_text)
data = example
# print("[Seed]", example["seed"], sep="\n")
f_out.write(json.dumps(data) + "\n")
n_success += 1
pbar.update(1)
print("Success:", n_success)
if __name__ == "__main__":
main()
selfcodealign-selfcodealign/src/star_align/decontamination/ 0000775 0000000 0000000 00000000000 14637551746 0024562 5 ustar 00root root 0000000 0000000 selfcodealign-selfcodealign/src/star_align/decontamination/benchmark_data.py 0000664 0000000 0000000 00000013227 14637551746 0030064 0 ustar 00root root 0000000 0000000 """Migrated from: https://github.com/bigcode-project/bigcode-dataset. License: Apache 2.0"""
"""data to filter out of the dataset"""
import itertools
import json
import os
from pathlib import Path
from datasets import load_dataset
# HumanEval solutions that are considered simple/generic enough to be kept in the training dataset
HUMAN_EVAL_STRINGS_OK = [
"return x + y",
"return len(string)",
"return n**2",
"return " ".join(strings)",
]
def extract_ds_1000_prompt(prompt: str):
if "SOLUTION START" in prompt:
assert prompt.count("SOLUTION START") == 1
return prompt.split("SOLUTION START")[0]
elif "BEGIN SOLUTION" in prompt:
assert prompt.count("BEGIN SOLUTION") == 1
return prompt.split("BEGIN SOLUTION")[0]
else:
raise ValueError()
def load_ds_1000():
DS1000_PATH_NAME = os.getenv("DS1000_PATH", None)
assert (
DS1000_PATH_NAME is not None
), "Please set the environment variable DS1000_PATH to the path of `ds1000_data`"
DS1000_PATH = Path(DS1000_PATH_NAME) # type: ignore
data: dict = {}
for prompt_file in DS1000_PATH.glob("*/Insertion/q*/prompt.txt"):
with open(prompt_file) as f:
data[extract_ds_1000_prompt(f.read())] = prompt_file.as_posix()
return data
def load_mbpp():
MBPP_PATH_NAME = os.getenv("MBPP_PATH", None)
assert (
MBPP_PATH_NAME is not None
), "Please set the environment variable MBPP_PATH to the path of `mbpp.jsonl`"
MBPP_PATH = Path(MBPP_PATH_NAME)
TEST_IDS = list(range(11, 511))
data = []
with open(MBPP_PATH) as f:
for line in f:
data.append(json.loads(line))
data = [sample for sample in data if sample["task_id"] in TEST_IDS]
assert len(data) == 500
# Checksum / version issues here
# dataset = load_dataset("mbpp", split="test")
return data
def mbpp_docstrings():
data = load_mbpp()
return {sample["text"]: str(sample["task_id"]) for sample in data}
def mbpp_solutions():
data = load_mbpp()
return {sample["code"]: str(sample["task_id"]) for sample in data}
def extract_docstring(prompt: str) -> str:
if '"""' in prompt:
if prompt.count('"""') == 2:
return prompt.split('"""')[1].strip()
elif prompt.count('"""') == 4:
return prompt.split('"""')[3].strip()
else:
raise ValueError()
elif "'''" in prompt:
assert prompt.count("'''") == 2
return prompt.split("'''")[1].strip()
else:
raise ValueError()
def human_eval_docstrings():
ds = load_dataset("openai_humaneval", split="test")
docstrings = {extract_docstring(v["prompt"]): str(v["task_id"]) for v in ds}
return docstrings
def apps_solutions():
"""
Solutions column contains a list of strings
"""
ds = load_dataset("codeparrot/apps", split="test")
solutions = [sample["solutions"] for sample in ds if len(sample["solutions"]) > 0]
res = itertools.chain.from_iterable(json.loads(sample) for sample in solutions)
return list(res)
def multipl_e_docstrings():
languages = [
"cpp",
"cs",
"d",
"go",
"java",
"jl",
"js",
"lua",
"php",
"pl",
"py",
"r",
"rb",
"rkt",
"rs",
"scala",
"sh",
"swift",
"ts",
]
# languages = ["py", "java", "js"]
src_datas = ["humaneval", "mbpp"]
variations = ["", "-remove"]
data = []
for lang in languages:
for src_data in src_datas:
for variation in variations:
if src_data == "mbpp" and variation == "-remove":
continue
ds = load_dataset(
"nuprl/MultiPL-E", f"{src_data}-{lang}{variation}", split="test"
)
data += [sample["prompt"].strip() for sample in ds]
return data
def load_dataset_column(dataset: str, column: str, split: str, name=None):
ds = load_dataset(dataset, split=split, name=name)
# res = [sample[column].strip() for sample in ds]
# Only return non-empty strings
return {
sample_col_stripped: str(
sample["task_id"] if "task_id" in sample else f"{dataset}/{idx}"
)
for idx, sample in enumerate(ds)
if len(sample_col_stripped := sample[column].strip()) > 0
}
LAZY_FILTER_OUT = {
"human_eval_docstrings": lambda: human_eval_docstrings(),
"human_eval_solutions": lambda: {
s: v
for s, v in load_dataset_column(
"openai_humaneval", "canonical_solution", "test"
).items()
if s not in HUMAN_EVAL_STRINGS_OK
},
# "apps_docstrings": lambda: load_dataset_column(
# "codeparrot/apps", "question", "test"
# ),
# 115212 examples to filter-out in apps-solutions, which would take way too much time without any hashing trick
# "apps_solutions": apps_solutions(),
# MultiPL-E samples are from HumanEval and MBPP: we are already looking for them
# "multipl-e_docstrings": multipl_e_docstrings(),
# There is no solution provided with multipl-e
"gsm8k_questions": lambda: load_dataset_column("gsm8k", "question", "test", "main"),
"ds_1000_prompts": lambda: load_ds_1000(),
"mbpp_docstrings": lambda: mbpp_docstrings(),
"mbpp_solutions": lambda: mbpp_solutions(),
}
IGNORED = os.getenv("IGNORED", "").split(":")
print("Ignoring:", IGNORED)
for ignored in IGNORED:
if ignored != "" and ignored in LAZY_FILTER_OUT:
del LAZY_FILTER_OUT[ignored]
FILTER_OUT = {k: v() for k, v in LAZY_FILTER_OUT.items()}
for benchmark, values in FILTER_OUT.items():
print(f"num strings from {benchmark}: {len(values)}")
selfcodealign-selfcodealign/src/star_align/decontamination/find_substrings.py 0000664 0000000 0000000 00000032172 14637551746 0030344 0 ustar 00root root 0000000 0000000 # type: ignore
"""Migrated from: https://github.com/bigcode-project/bigcode-dataset. License: Apache 2.0"""
import argparse
import json
import os
import shutil
from copy import deepcopy
from glob import glob
from pathlib import Path
from datasets import load_dataset
from star_align.utils import write_jsonl
from .benchmark_data import FILTER_OUT
from .utils import add_dict, shard_dataset
SHARD_SIZE = 1000 << 20 # 1GB
LANGUAGE_COL = "lang"
# LANGUAGES = ["Python", "Java", "JavaScript"]
def dump_benchmarks(file_path: str):
"""
Dump the dictionary of benchmark samples that are filtered out
"""
with open(file_path, "w") as f:
json.dump(FILTER_OUT, f, indent=2)
def filter_reason_to_benchmark_name(filter_reason: str):
assert filter_reason.endswith("_match")
return filter_reason[:-6]
def benchmark_name_to_filter_reason(benchmark_name: str):
return f"{benchmark_name}_match"
def update_benchmark_dict(
filter_out: dict, benchmark_cache: str, excluded_data_cache: str
):
"""
Iterates on current benchmark-samples. If a sample is found in the cached benchmark-samples, it is removed (it does not need to be searched),
and the corresponding data-samples from the cache are added to `exclude_data`
Returns:
- `updated`: an updated benchmark dict where samples from the cache are removed (they do not need to be searched anymore)
- `exclude_data`: a list of files to remove from the dataset
"""
updated = deepcopy(filter_out)
exclude_data = []
with open(benchmark_cache) as f:
benchmark_cache = json.load(f)
with open(excluded_data_cache) as f:
excluded_data_cache = json.load(f)
for bench, samples in filter_out.items():
for bench_sample in samples:
# Benchmark-sample was found in cache
if bench in benchmark_cache and bench_sample in benchmark_cache[bench]:
# No need to search for this sample in the dataset
updated[bench].remove(bench_sample)
# Corresponding data-samples will be excluded from the dataset.
exclude_data += [
data_sample
for data_sample in excluded_data_cache
if data_sample["filter_reason"]
== benchmark_name_to_filter_reason(bench)
and data_sample["matched_substring"] == bench_sample
]
print("After loading cache, will search for:")
for benchmark, values in updated.items():
print(f" num strings from {benchmark}: {len(values)}")
# Remove empty benchmarks
updated = {key: value for key, value in updated.items() if len(value) > 0}
return updated, exclude_data
def find_substrings(data, columns, filter_out, return_matched=False):
"""
filter_out: Dict[str, List[str]] mapping from benchmark name to list of strings that need to be
filtered-out.
Return True, None if the file should be included in the dataset.
Otherwise return False and some metadata about the file excluded
"""
content = "\n\n".join([data[col].lower() for col in columns])
# For each substring, try to find it in the file (case insensitive)
for benchmark, substrings in filter_out.items():
for substring in substrings:
if substring.lower() in content:
if return_matched:
return False, benchmark_name_to_filter_reason(benchmark), substring
else:
return False, benchmark_name_to_filter_reason(benchmark)
# Return True, None if none of the substrings was found
if return_matched:
return True, None, None
else:
return True, None
def aggregate_meta(tmp_meta_dir: str):
res = {}
for file in glob(f"{tmp_meta_dir}/*-meta.json"):
with open(file, "r") as f:
meta = json.load(f)
add_dict(res, meta)
return res
def concatenate_meta(tmp_meta_dir: str):
res = []
for file in glob(f"{tmp_meta_dir}/*-excluded-data.json"):
with open(file, "r") as f:
meta = json.load(f)
res += meta
return res
class Meta:
def __init__(self) -> None:
self.meta_dict = dict()
def update(self, lang: str, filter_reason: str):
if lang not in self.meta_dict:
self.meta_dict[lang] = {}
if filter_reason not in self.meta_dict[lang]:
self.meta_dict[lang][filter_reason] = 0
self.meta_dict[lang][filter_reason] += 1
class SubstringFilterer(object):
def __init__(
self,
output_dir: str,
output_file: str,
cached_decontamination_dir: str,
split_languages: bool,
cache_retrieval_key: str,
columns: list[str],
tmp_meta_dir=None,
data_dir=None,
) -> None:
self.output_dir = output_dir
self.output_file = output_file
self.split_languages = split_languages
self.cache_retrieval_key = cache_retrieval_key
self.columns = columns
self.tmp_meta_dir = (
tmp_meta_dir if tmp_meta_dir is not None else f"{output_dir}/tmp/meta"
)
self.data_dir = data_dir if data_dir is not None else f"{output_dir}/data"
os.makedirs(self.tmp_meta_dir, exist_ok=True)
os.makedirs(self.data_dir, exist_ok=True)
# Save benchmark data
self.excluded_data_cache = os.path.join(self.output_dir, "excluded-data.json")
self.benchmarks_cache = os.path.join(output_dir, "benchmarks.json")
dump_benchmarks(self.benchmarks_cache)
if cached_decontamination_dir is not None:
# Load cache
self.filter_out, self.exclude_data = update_benchmark_dict(
FILTER_OUT,
os.path.join(cached_decontamination_dir, "benchmarks.json"),
os.path.join(cached_decontamination_dir, "excluded-data.json"),
)
# All hashes should be unique
hash_list = [
data_sample["data"][self.cache_retrieval_key]
for data_sample in self.exclude_data
]
assert len(hash_list) == len(set(hash_list))
# dict: retrieval-key (hash/content) -> data-sample
self.exclude_data_index = {
data_sample["data"][self.cache_retrieval_key]: data_sample
for data_sample in self.exclude_data
}
self.use_cached_decontamination = True
else:
self.filter_out = FILTER_OUT
self.exclude_data = None
self.exclude_data_index = {}
self.use_cached_decontamination = False
def _filter_file(self, sample):
should_include, filter_reason, matched_substring = True, None, None
if self.use_cached_decontamination:
# According to cache, this data sample should be excluded
if sample[self.cache_retrieval_key] in self.exclude_data_index:
should_include = False
filter_reason = self.exclude_data_index[
sample[self.cache_retrieval_key]
]["filter_reason"]
matched_substring = self.exclude_data_index[
sample[self.cache_retrieval_key]
]["matched_substring"]
# If sample has passed the cache, check the other substrings
if should_include:
should_include, filter_reason, matched_substring = find_substrings(
sample, self.columns, self.filter_out, return_matched=True
)
return should_include, filter_reason, matched_substring
def _filter(self, batch: dict, idx):
meta = Meta()
excluded_data = []
features = batch.keys()
res = {k: [] for k in features}
for sample in zip(*[batch[k] for k in features]):
sample = {k: v for k, v in zip(features, sample)}
should_include, filter_reason, matched_substring = self._filter_file(sample)
if not should_include:
meta.update(sample.get(LANGUAGE_COL, "unknown"), filter_reason)
excluded_data.append(
{
"data": sample,
"filter_reason": filter_reason,
"matched_substring": matched_substring,
}
)
else:
# Add to output
for k in features:
res[k].append(sample[k])
# Record Meta
with open(
os.path.join(self.tmp_meta_dir, f"{idx[0]}-{idx[-1]}-meta.json"), "w"
) as f:
json.dump(meta.meta_dict, f)
with open(
os.path.join(self.tmp_meta_dir, f"{idx[0]}-{idx[-1]}-excluded-data.json"),
"w",
) as f:
json.dump(excluded_data, f, indent=2)
return res
def filter_dataset(self, ds, num_proc, batch_size):
filtered = ds.map(
self._filter,
batched=True,
batch_size=batch_size,
with_indices=True,
num_proc=num_proc,
load_from_cache_file=False,
)
print("Number of samples in the new dataset: ", len(filtered))
return filtered
def finalize(self):
# Dump meta
meta = aggregate_meta(self.tmp_meta_dir)
print(meta)
with open(os.path.join(self.output_dir, "meta.json"), "w") as f:
json.dump(meta, f, indent=2)
# Dump excluded-data.json
meta = concatenate_meta(self.tmp_meta_dir)
print("Number of excluded examples: ", len(meta))
with open(self.excluded_data_cache, "w") as f:
json.dump(meta, f, indent=2)
# delete temporary meta data
shutil.rmtree(self.tmp_meta_dir)
# def save(self, filtered, num_proc):
# # Save shards
# if self.split_languages:
# for lang in LANGUAGES:
# print(f"Sharding subset: {lang}")
# target_dir = os.path.join(self.data_dir, lang.lower())
# os.makedirs(target_dir, exist_ok=True)
# subset = filtered.filter(lambda example: example[LANGUAGE_COL] == lang, num_proc=num_proc)
# shard_dataset(subset, SHARD_SIZE, target_dir, num_proc=16)
# else:
# shard_dataset(filtered, SHARD_SIZE, self.data_dir, num_proc=16)
def run(self, dataset, num_proc, batch_size):
filtered = self.filter_dataset(dataset, num_proc, batch_size)
write_jsonl(Path(self.output_file), filtered)
# Finalize meta-data
self.finalize()
# Save filtered dataset.
# NOTE: we save to jsonl so this is not needed
# self.save(filtered, num_proc)
return filtered
def arguments():
parser = argparse.ArgumentParser()
parser.add_argument(
"--dataset_name",
default="json",
type=str,
help="Name or path of the HF dataset to decontaminate",
)
parser.add_argument("--data_files", nargs="+", default=None, help="Data files")
parser.add_argument(
"--columns",
nargs="+",
required=True,
help="Columns to form the text to search for",
)
parser.add_argument(
"--output_file", required=True, type=str, help="Path to save output jsonl data"
)
parser.add_argument(
"--output_dir",
required=True,
type=str,
help="Path to save output data and metadata",
)
parser.add_argument("--num_proc", type=int, default=200, help="Number of processes")
parser.add_argument(
"--batch_size",
type=int,
default=10000,
help="Size of batches passed to Dataset.map",
)
parser.add_argument(
"--cached_decontamination_dir",
type=str,
default=None,
help="Directory containing a `benchmarks.json` and `excluded_data.json` files from a previous decontamination run."
"Will use this data to avoid searching again for strings that were previously decontaminated."
"It's up to the user to ensure that the dataset being decontaminated is a subset of the one from the cached decontamination run"
"(Otherwise not all the benchmark samples will be checked against new data samples)",
)
parser.add_argument(
"--cache_retrieval_key",
type=str,
default="hexsha",
help="Key used to retrieve examples from the cache. Ideally `hexsha`. Otherwise, another unique feature in case the hash is not present, like `content`)",
)
parser.add_argument(
"--split_languages",
action="store_true",
help="If True, will create one subfolder per language for the output dataset.",
)
return parser.parse_args()
def main():
args = arguments()
filterer = SubstringFilterer(
output_dir=args.output_dir,
output_file=args.output_file,
columns=args.columns,
cached_decontamination_dir=args.cached_decontamination_dir,
split_languages=args.split_languages,
cache_retrieval_key=args.cache_retrieval_key,
)
ds = load_dataset(
args.dataset_name,
split="train",
data_files=args.data_files,
# chunksize=40 << 20
)
filterer.run(ds, args.num_proc, args.batch_size)
if __name__ == "__main__":
main()
selfcodealign-selfcodealign/src/star_align/decontamination/utils.py 0000664 0000000 0000000 00000003713 14637551746 0026300 0 ustar 00root root 0000000 0000000 """Migrated from: https://github.com/bigcode-project/bigcode-dataset. License: Apache 2.0"""
import time
from multiprocessing import Pool
from tqdm import tqdm
def save_shard(shard_tuple):
"""Save shard"""
filename, shard = shard_tuple
# use to_json instead to save as json file
shard.to_parquet(filename)
def shard_dataset(ds, shard_size, output_dir, num_proc):
if ds._indices is not None:
dataset_nbytes = ds.data.nbytes * len(ds._indices) / len(ds.data)
else:
dataset_nbytes = ds.data.nbytes
num_shards = int(dataset_nbytes / shard_size) + 1
print(f"Number of shards: {num_shards}")
print("sharding the dataset")
t_start = time.time()
shards = (
ds.shard(num_shards=num_shards, index=i, contiguous=True)
for i in range(num_shards)
)
# use f"{OUT_PATH}/data/train-{index:05d}-of-{num_shards:05d}.json" instead for json files
filenames = (
f"{output_dir}/train-{index:05d}-of-{num_shards:05d}.parquet"
for index in range(num_shards)
)
with Pool(num_proc) as p:
list(
tqdm(
p.imap_unordered(save_shard, zip(filenames, shards), chunksize=4),
total=num_shards,
)
)
print(f"Time to save dataset: {time.time()-t_start:.2f}")
def add_dict(dict1: dict, dict2: dict) -> None:
"""
Add the values of dict2 to dict1. All values must be int, float or dictionaries that also verify this condition.
Will modify dict1 and return None
"""
for key, value in dict2.items():
if isinstance(value, (int, float)):
if key not in dict1:
dict1[key] = 0
dict1[key] += value
elif isinstance(value, dict):
if key not in dict1:
dict1[key] = {}
assert isinstance(dict1[key], dict)
add_dict(dict1[key], value)
else:
raise ValueError(f"Invalid type for key/value {key}: {value}")
selfcodealign-selfcodealign/src/star_align/execution_filter.py 0000664 0000000 0000000 00000023223 14637551746 0025332 0 ustar 00root root 0000000 0000000 import ast
import json
import os
import shutil
import sys
from concurrent.futures import ProcessPoolExecutor, as_completed
from multiprocessing import Process, cpu_count
from evalplus.eval.utils import (
create_tempdir,
reliability_guard,
swallow_io,
time_limit,
)
from tqdm.auto import tqdm
from datasets import load_dataset
from star_align.utils import chunked, find_code_blocks
from transformers import HfArgumentParser
from dataclasses import dataclass, field
from typing import cast
_magic_splitter_ = "### -- what do you think? -- ###"
def make_python_membound_code_prefix(limit_mb):
maximum_memory_bytes = limit_mb * 1024 * 1024
return f"""\
import resource
import platform
resource.setrlimit(
resource.RLIMIT_AS, ({maximum_memory_bytes}, {maximum_memory_bytes})
)
resource.setrlimit(
resource.RLIMIT_DATA, ({maximum_memory_bytes}, {maximum_memory_bytes})
)
if not platform.uname().system == "Darwin":
resource.setrlimit(
resource.RLIMIT_STACK, ({maximum_memory_bytes}, {maximum_memory_bytes})
)
{_magic_splitter_}
"""
@dataclass(frozen=True)
class Args:
response_paths: list[str]
result_path: str
save_request_errors: bool = False
shuffle: bool = field(default=True)
cache_paths: list[str] = field(default_factory=list)
load_pass_only_cache: bool = field(default=False)
max_batched_tasks: int = 10000
max_workers: int = cpu_count()
container_server: str | None = None
def suppress_output(func):
def wrapper(*args, **kwargs):
original_stdout = sys.stdout
original_stderr = sys.stderr
sys.stdout = open(os.devnull, "w")
sys.stderr = sys.stdout
try:
result = func(*args, **kwargs)
finally:
sys.stdout.close()
sys.stdout = original_stdout
sys.stderr = original_stderr
return result
return wrapper
# Note: only run this within a safe subprocess
def _run(code) -> None:
with create_tempdir():
# These system calls are needed when cleaning up tempdir.
rmtree = shutil.rmtree
rmdir = os.rmdir
chdir = os.chdir
getcwd = os.getcwd
maximum_memory_bytes = 1 * 1024 * 1024 * 1024
reliability_guard(maximum_memory_bytes=maximum_memory_bytes)
# Disable functionalities that can make destructive changes to the test.
# allow only 1GB memory usage
# run the function
with swallow_io():
with time_limit(4): # max 4 seconds
# run the function
exec(code)
# Needed for cleaning up.
shutil.rmtree = rmtree
os.rmdir = rmdir
os.chdir = chdir
os.getcwd = getcwd
def containerized_run(item, limit_mb=4 * 1024):
from star_align.code_exec_server.code_exec_reqs import exec_test
idx, result, code, srv = item
membound_code = make_python_membound_code_prefix(limit_mb) + code
passed, output = exec_test(
srv, membound_code, "", timeout=10, timeout_on_client=True
)
return (idx, result, code, passed, output)
def fork_run(item):
idx, response, code, _ = item
sys.stdout = open(os.devnull, "w")
sys.stderr = sys.stdout
p = Process(target=_run, args=(code,))
p.start()
p.join(timeout=10)
passed = p.exitcode == 0
return (idx, response, code, passed, "NOT SUPPORTED")
def is_compilable(code):
try:
ast.parse(code)
return True
except (SyntaxError, ValueError):
return False
def extract_code(response: str) -> str:
def sanitize_codeblock(code: str) -> str:
if "input" not in code:
return code.strip()
# Only remove the `if __name__..` when `input` is present because
# it will block the code execution.
key = 'if __name__ == "__main__":'
key_alt = "if __name__ == '__main__':"
index = code.find(key)
if index == -1:
index = code.find(key_alt)
if index == -1:
return code.strip()
assert index != -1
code = code[:index].strip()
return code
code_blocks = list(map(sanitize_codeblock, find_code_blocks(response)))
return "\n\n".join(code_blocks)
def form_new_data(
item: dict,
response: str,
extracted_code: str,
pass_execution: bool,
output: str,
) -> dict:
newdata = {k: v for k, v in item.items() if k not in ["response", "parsing_result"]}
newdata["response"] = response
newdata["extracted_code"] = extracted_code
newdata["pass"] = pass_execution
newdata["output"] = output
return newdata
def main():
args = cast(Args, HfArgumentParser(Args).parse_args_into_dataclasses()[0])
if args.container_server is None:
option = input(
"WARNING: container_server is not set. You will run the code locally, which can lead to unexpected side effects. Continue? (y/n): "
).strip()
if option.lower() != "y":
return
if os.path.exists(args.result_path):
option = input(
f"WARNING: {args.result_path} already exists. Overwrite? (y/n): "
).strip()
if option.lower() != "y":
return
cleanup_command = os.getenv("CLEANUP_COMMAND", None)
if cleanup_command is not None:
print(f"NOTE: the cleanup command is set to:")
print(cleanup_command)
raw_data = load_dataset("json", data_files=args.response_paths, split="train")
if args.shuffle:
raw_data = raw_data.shuffle()
if len(args.cache_paths) > 0:
cached_data = load_dataset("json", data_files=args.cache_paths, split="train")
if args.load_pass_only_cache:
cached_dict: dict[str, dict] = {
item["extracted_code"]: item for item in cached_data if item["pass"]
}
else:
cached_dict = {item["extracted_code"]: item for item in cached_data}
else:
cached_dict = {}
all_tasks: list[tuple[int, str, str, str | None]] = []
eval_results: list[dict] = []
for idx, item in enumerate(tqdm(raw_data, desc="Preprocessing: extracting code")):
# passing_results = []
if "parsing_result" not in item:
item["parsing_result"] = [dict(response=item["response"])]
for result in item["parsing_result"]:
response = result["response"]
code = extract_code(response)
if (hit_item := cached_dict.get(code, None)) is not None:
assert code == hit_item["extracted_code"]
new_data = form_new_data(
item=item,
response=response,
extracted_code=code,
pass_execution=hit_item["pass"],
output=hit_item["output"],
)
eval_results.append(new_data)
else:
all_tasks.append((idx, response, code, args.container_server))
def pass_rate_str(passed: int, total: int, tag: str = "") -> str:
percentage = f"{passed/total * 100:.2f}%" if total > 0 else "N/A"
ratio = f"{passed}/{total}"
tag = f"{tag} " if len(tag) > 0 else ""
return f"{tag}Passed: {ratio} ({percentage})"
n_cached_passed = sum(item["pass"] for item in eval_results)
n_cached_total = len(eval_results)
print(f"Cached: {len(eval_results)}, Active: {len(all_tasks)}")
print(pass_rate_str(n_cached_passed, n_cached_total, "Cached"))
run_func = containerized_run if args.container_server else fork_run
tasks_chunks = list(chunked(all_tasks, args.max_batched_tasks))
n_processed = 0
n_passed = 0
with open(args.result_path, "w") as f:
for cached_result in eval_results:
f.write(json.dumps(cached_result) + "\n")
with ProcessPoolExecutor(max_workers=args.max_workers) as executor:
pbar = tqdm(tasks_chunks)
for chunked_tasks in pbar:
futures = [executor.submit(run_func, task) for task in chunked_tasks]
# NOTE: futures do not return in the same order as before
pbar_inner = tqdm(
as_completed(futures),
total=len(futures),
leave=False,
)
n_passed_inner = 0
for n_processed_inner, future in enumerate(pbar_inner, start=1):
n_processed += 1
try:
future_result = future.result()
except Exception as e:
continue
idx, response, code, passed, output = future_result
if "Failed to execute program" in output:
if not args.save_request_errors:
continue
newdata = form_new_data(
item=raw_data[idx],
response=response,
extracted_code=code,
pass_execution=passed,
output=output,
)
f.write(json.dumps(newdata) + "\n")
n_passed += passed
n_passed_inner += passed
pbar_inner.set_description(
pass_rate_str(n_passed_inner, n_processed_inner)
)
pbar.set_description(pass_rate_str(n_passed, n_processed))
if cleanup_command is not None:
print(f"Cleaning up: {cleanup_command}")
os.system(cleanup_command)
print("Cleanup done.")
n_total_passed = n_cached_passed + n_passed
n_total = len(all_tasks) + n_cached_total
print(pass_rate_str(n_total_passed, n_total, "Total"))
if __name__ == "__main__":
main()
selfcodealign-selfcodealign/src/star_align/llm_wrapper.py 0000664 0000000 0000000 00000045550 14637551746 0024315 0 ustar 00root root 0000000 0000000 import os
from dataclasses import dataclass, field
from enum import Enum
from typing import Callable, Literal
import torch
from transformers import AutoModelForCausalLM, AutoModelWithLMHead, AutoTokenizer
from transformers import GenerationConfig as TransformersGenerationConfig
from transformers import (
PreTrainedModel,
PreTrainedTokenizer,
StoppingCriteria,
StoppingCriteriaList,
)
# from peft import PeftModel, PeftConfig
# Tokenization side modeling
PaddingSide = Literal["left", "right"]
# Input: a batch of chat pieces; Output: a batch of instructions and responses
# The instances should encode in a way that the model can predict response from instruction
InputIds = list[int]
# Adopted from https://github.com/huggingface/transformers/pull/14897
class EndOfFunctionCriteria(StoppingCriteria):
def __init__(self, start_length, eos, tokenizer, *args, **kwargs):
super().__init__(*args, **kwargs)
self.start_length = start_length
self.eos = eos
self.tokenizer = tokenizer
self.end_length = {}
def __call__(self, input_ids, scores, **kwargs):
"""Returns true if all generated sequences contain any of the end-of-function strings."""
decoded_generations = self.tokenizer.batch_decode(
input_ids[:, self.start_length :]
)
done = []
for index, decoded_generation in enumerate(decoded_generations):
finished = any(
[stop_string in decoded_generation for stop_string in self.eos]
)
if (
finished and index not in self.end_length
): # ensures first time we see it
for stop_string in self.eos:
if stop_string in decoded_generation:
self.end_length[index] = len(
input_ids[
index, # get length of actual generation
self.start_length : -len(
self.tokenizer.encode(
stop_string,
add_special_tokens=False,
return_tensors="pt",
)[0]
),
]
)
done.append(finished)
return all(done)
@dataclass(frozen=True)
class DecodingConfig:
skip_special_tokens: bool
@staticmethod
def default() -> "DecodingConfig":
return DecodingConfig(skip_special_tokens=True)
# TransformChatPieceFunc = Callable[[ChatPiece], tuple[str, str]]
@dataclass(frozen=True)
class EncodingConfig:
add_bos: bool
add_eos: bool
truncation: int | None = field(default=None)
@staticmethod
def default() -> "EncodingConfig":
return EncodingConfig(add_bos=False, add_eos=False)
@dataclass(frozen=True)
class TokenizationContext:
tokenizer: PreTrainedTokenizer
pad_token_id: int
bos_token: str
eos_token: str
@property
def eos_token_id(self) -> int:
return self.tokenizer.eos_token_id
@staticmethod
def from_model_key(
model_key: str, model_name_or_path: str | None = None
) -> "TokenizationContext":
# use_fast = model_key not in SupportedModelKeys.codellama_models()
use_fast = True
# if model_name_or_path is None:
# model_name_or_path = model_key
# TODO: check if tokenizers cannot be loaded with path
model_name_or_path = model_key
tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, use_fast=use_fast)
tokenization_context = TokenizationContext.from_tokenizer(tokenizer)
return tokenization_context
@staticmethod
def from_tokenizer(tokenizer: PreTrainedTokenizer) -> "TokenizationContext":
if (pad_token_id := tokenizer.pad_token_id) is None:
pad_token_id = tokenizer.eos_token_id
assert pad_token_id is not None
bos_token = tokenizer.bos_token
eos_token = tokenizer.eos_token
return TokenizationContext(
tokenizer=tokenizer,
pad_token_id=pad_token_id,
bos_token=bos_token,
eos_token=eos_token,
)
def encode(self, config: EncodingConfig, text_list: list[str]) -> list[list[int]]:
# eos_token = self.eos_token if config.add_eos else ""
# bos_token = self.bos_token if config.add_bos else ""
# if eos_token != "" or bos_token != "":
# text_list = [f"{bos_token}{text}{eos_token}" for text in text_list]
# The string concatenation above may not always work for all tokenizers (strange).
# e.g., when codellama's tokenizer is used with "[INST]".
if config.truncation is not None:
extra_args = dict(truncation=True, max_length=config.truncation)
else:
extra_args = {}
input_ids = self.tokenizer(
text_list,
add_special_tokens=False,
**extra_args,
)["input_ids"]
bos_token_id = self.tokenizer.bos_token_id
eos_token_id = self.tokenizer.eos_token_id
bos_token_ids = (
[bos_token_id] if config.add_bos and bos_token_id is not None else []
)
eos_token_ids = (
[eos_token_id] if config.add_eos and eos_token_id is not None else []
)
if len(bos_token_ids) > 0 or len(eos_token_ids) > 0:
input_ids = [
bos_token_ids + input_id + eos_token_ids for input_id in input_ids
]
return input_ids
def decode(
self, config: DecodingConfig, input_ids: list[InputIds] | torch.Tensor
) -> list[str]:
return self.tokenizer.batch_decode(
input_ids, skip_special_tokens=config.skip_special_tokens
)
def encode_with_padding(
self, padding_side: PaddingSide, config: EncodingConfig, text_list: list[str]
) -> torch.Tensor:
input_ids_unpadded = self.encode(config, text_list)
return pad_sequences(
sequences=input_ids_unpadded,
pad_value=self.pad_token_id,
padding_side=padding_side,
)
def pad_sequences(
sequences: list[list[int]],
pad_value: int,
padding_side: Literal["left", "right"],
dtype: torch.dtype = torch.long,
padding_length: int | None = None,
) -> torch.Tensor:
tensors = [torch.tensor(sequence, dtype=dtype) for sequence in sequences]
max_len = max(len(sequence) for sequence in sequences)
if padding_length is not None:
assert padding_length >= max_len, "padding_length must be >= max_len"
max_len = padding_length
if padding_side == "right":
result = torch.nn.utils.rnn.pad_sequence(
tensors, batch_first=True, padding_value=pad_value
)
remaining_length = max_len - result.shape[-1]
# padding matrix of (batch_size * remaining_length)
shape = result.shape[:-1] + (remaining_length,)
padding_matrix = torch.full(shape, pad_value, dtype=dtype)
result = torch.cat([result, padding_matrix], dim=-1)
else:
padded_tensors: list[torch.Tensor] = []
for tensor in tensors:
n_pad_values = max_len - len(tensor)
padded_values = torch.full((n_pad_values,), pad_value, dtype=dtype)
padded_tensor = torch.cat([padded_values, tensor], dim=0)
assert len(padded_tensor) == max_len
padded_tensors.append(padded_tensor)
result = torch.stack(padded_tensors, dim=0)
assert result.shape == torch.Size([len(sequences), max_len])
return result
# Inference side modeling
@dataclass(frozen=True)
class GenerationConfig:
max_new_tokens: int
top_p: float
temperature: float
max_length: int = field(
default=99999999999999999,
metadata={
"help": "The max length of the sequence to generate, including inputs."
"Will be considered in tandem with max_new_tokens. Whichever is more restrictive will be used."
},
)
def to_transformers_generation_config(
self, eos_token_id: int, pad_token_id: int
) -> TransformersGenerationConfig:
do_sample = self.temperature != 0.0
kwargs = dict(
max_new_tokens=self.max_new_tokens,
top_p=self.top_p,
eos_token_id=eos_token_id,
pad_token_id=pad_token_id,
do_sample=do_sample,
)
if do_sample:
kwargs["temperature"] = self.temperature
return TransformersGenerationConfig(**kwargs)
def with_max_new_tokens_being(self, max_new_tokens: int) -> "GenerationConfig":
return GenerationConfig(max_new_tokens, self.top_p, self.temperature)
@staticmethod
def default() -> "GenerationConfig":
return GenerationConfig(200, 1.0, 1.0)
@dataclass(frozen=True)
class Response:
raw_inputs: torch.Tensor
raw_outputs: torch.Tensor
decoded_outputs: list[str]
@dataclass
class ModelContext:
tokenization_context: TokenizationContext
model: PreTrainedModel
max_context_size: int
def generate(
self,
config: GenerationConfig,
input_ids: torch.Tensor,
stop_tokens: list[str] | None = None,
) -> torch.Tensor:
"""Raise ValueError when input_ids exceeds the context."""
# NOTE: this implementation is only for decoder-only models
# Recalculate the max number of tokens to avoid overflowing the context window
input_len = input_ids.shape[1]
if input_len >= self.max_context_size:
raise ValueError(
f"Input length {input_len} >= Context size {self.max_context_size}"
)
if input_len >= config.max_length:
raise ValueError(
f"Input length {input_len} >= Max length {config.max_length}"
)
assert input_len < self.max_context_size
assert input_len < config.max_length
max_new_tokens = min(
self.max_context_size - input_len,
config.max_new_tokens,
config.max_length - input_len,
)
config = config.with_max_new_tokens_being(max_new_tokens)
tf_config = config.to_transformers_generation_config(
eos_token_id=self.tokenization_context.eos_token_id,
pad_token_id=self.tokenization_context.pad_token_id,
)
attention_mask = input_ids.ne(self.tokenization_context.pad_token_id)
# breakpoint()
extra_kwargs: dict = {}
if stop_tokens is not None:
stopping_criteria = StoppingCriteriaList(
[
EndOfFunctionCriteria(
start_length=len(input_ids[0]),
eos=stop_tokens,
tokenizer=self.tokenization_context.tokenizer,
)
]
)
extra_kwargs["stopping_criteria"] = stopping_criteria
outputs = self.model.generate(
input_ids=input_ids,
attention_mask=attention_mask,
generation_config=tf_config,
**extra_kwargs,
)
# input_len = input_ids.shape[1]
return outputs[:, input_len:]
def complete(
self,
config: GenerationConfig,
prompts: list[str],
stop_tokens: list[str] | None = None,
) -> Response:
encoding_config = EncodingConfig(add_bos=True, add_eos=False)
input_ids = self.tokenization_context.encode_with_padding(
"left", encoding_config, prompts
)
input_ids = input_ids.to(self.model.device)
output_ids = self.generate(config, input_ids, stop_tokens)
decoding_config = DecodingConfig(skip_special_tokens=True)
output_strings = self.tokenization_context.decode(decoding_config, output_ids)
return Response(
raw_inputs=input_ids,
raw_outputs=output_ids,
decoded_outputs=output_strings,
)
class SupportedModelKeys(Enum):
# StarCoder-based models
STARCODER_15B = "bigcode/starcoder"
WIZARDCODER_STARCODER_15B = "WizardLM/WizardCoder-15B-V1.0"
# CodeLlama-based models
WIZARDCODER_CODELLAMA_PYTHON_7B = "WizardLM/WizardCoder-Python-7B-V1.0"
WIZARDCODER_CODELLAMA_PYTHON_13B = "WizardLM/WizardCoder-Python-13B-V1.0"
WIZARDCODER_CODELLAMA_PYTHON_34B = "WizardLM/WizardCoder-Python-34B-V1.0"
CODELLAMA_PYTHON_7B = "codellama/CodeLlama-7b-Python-hf"
CODELLAMA_PYTHON_13B = "codellama/CodeLlama-13b-Python-hf"
CODELLAMA_PYTHON_34B = "codellama/CodeLlama-34b-Python-hf"
# DeepSeek-Coder-based models
DEEPSEEK_CODER_1_3B = "deepseek-ai/deepseek-coder-1.3b-base"
DEEPSEEK_CODER_6_7B = "deepseek-ai/deepseek-coder-6.7b-base"
DEEPSEEK_CODER_33B = "deepseek-ai/deepseek-coder-33b-base"
@staticmethod
def all() -> list[str]:
return [member.value for member in SupportedModelKeys]
@staticmethod
def codellama_models() -> list[str]:
return [
SupportedModelKeys.CODELLAMA_PYTHON_7B.value,
SupportedModelKeys.CODELLAMA_PYTHON_13B.value,
SupportedModelKeys.CODELLAMA_PYTHON_34B.value,
# SupportedModelKeys.WIZARDCODER_CODELLAMA_PYTHON_7B.value,
# SupportedModelKeys.WIZARDCODER_CODELLAMA_PYTHON_13B.value,
# SupportedModelKeys.WIZARDCODER_CODELLAMA_PYTHON_34B.value,
]
@staticmethod
def codellama_based_models() -> list[str]:
return SupportedModelKeys.codellama_models() + [
SupportedModelKeys.WIZARDCODER_CODELLAMA_PYTHON_7B.value,
SupportedModelKeys.WIZARDCODER_CODELLAMA_PYTHON_13B.value,
SupportedModelKeys.WIZARDCODER_CODELLAMA_PYTHON_34B.value,
]
@staticmethod
def starcoder_based_models() -> list[str]:
return [
SupportedModelKeys.STARCODER_15B.value,
SupportedModelKeys.WIZARDCODER_STARCODER_15B.value,
]
@staticmethod
def deepseekcoder_based_models() -> list[str]:
return [
SupportedModelKeys.DEEPSEEK_CODER_1_3B.value,
SupportedModelKeys.DEEPSEEK_CODER_6_7B.value,
SupportedModelKeys.DEEPSEEK_CODER_33B.value,
]
def get_model_context(
model_key: str,
model_name_or_path: str | None = None,
tokenization_context: TokenizationContext | None = None,
inference_mode: bool = True,
use_flash_attention: bool = False,
attention_dropout: float | None = None,
residual_dropout: float | None = None,
embedding_dropout: float | None = None,
) -> ModelContext:
# `model_key` defines the model and the tokenizer to use, while `model_name_or_path`
# defines where to load the weights. It can be from a local directory.
# assert model_key in SupportedModelKeys.all(), model_key
if model_key not in SupportedModelKeys.all():
import warnings
warnings.warn(
f"{model_key} not explicitly supported. This may or may not lead to unexpected behaviors."
)
if model_name_or_path is None:
model_name_or_path = model_key
if model_key in SupportedModelKeys.codellama_based_models():
max_context_size = 16384
elif model_key in SupportedModelKeys.starcoder_based_models():
max_context_size = 8192
elif model_key in SupportedModelKeys.deepseekcoder_based_models():
max_context_size = 16384
else:
import warnings
warnings.warn(
f"{model_key} does not have a specified max context, using default 4096"
)
max_context_size = 4096
if tokenization_context is None:
tokenization_context = TokenizationContext.from_model_key(model_key)
# TODO: check if all these models use bfloat16
dtype = torch.bfloat16
other_kwargs: dict = {}
if inference_mode:
other_kwargs["device_map"] = "auto"
if use_flash_attention:
# if "starcoder2" in model_key:
# other_kwargs["attn_implementation"] = "flash_attention_2"
# else:
import transformers
if transformers.__version__ <= "4.35.0":
other_kwargs["use_flash_attention_2"] = True
else:
other_kwargs["attn_implementation"] = "flash_attention_2"
# other_kwargs["use_flash_attention_2"] = True
# cls = AutoModelWithLMHead if "starcoder2-3b" in model_key else AutoModelForCausalLM
if "starcoder" in model_key.lower():
print("Hack for starcoder")
attention_dropout = attention_dropout or 0.0
residual_dropout = residual_dropout or 0.0
embedding_dropout = embedding_dropout or 0.0
if attention_dropout is not None:
other_kwargs["attention_dropout"] = attention_dropout
if residual_dropout is not None:
other_kwargs["residual_dropout"] = residual_dropout
if embedding_dropout is not None:
other_kwargs["embedding_dropout"] = embedding_dropout
# if (dropout := os.getenv("ATTENTION_DROPOUT")) is not None:
# other_kwargs["attention_dropout"] = float(dropout)
# print(f"Using attention dropout: {dropout}")
model = AutoModelForCausalLM.from_pretrained(
model_name_or_path,
torch_dtype=dtype,
# hack
# revision=os.getenv("REVISION"),
**other_kwargs,
)
print("Successfully loaded model.")
print(model.config)
return ModelContext(tokenization_context, model, max_context_size)
def form_starcoder_infill(prefix: str, suffix: str) -> str:
FIM_PREFIX = ""
FIM_MIDDLE = ""
FIM_SUFFIX = ""
prompt = f"{FIM_PREFIX}{prefix}{FIM_SUFFIX}{suffix}{FIM_MIDDLE}"
return prompt
def form_codellama_infill(prefix: str, suffix: str) -> str:
# NOTE: not using because it's treated as a special token
# but we pass `add_special_tokens=False` to the tokenizer
return f"β{prefix}β{suffix}β"
def form_deepseekcoder_infill(
tokenizer: PreTrainedTokenizer, prefix: str, suffix: str
) -> str:
def get_token(idx: int) -> str:
return tokenizer.convert_ids_to_tokens([idx])[0]
FIM_PREFIX = get_token(32016)
FIM_MIDDLE = get_token(32015)
FIM_SUFFIX = get_token(32017)
assert "begin" in FIM_PREFIX and "hole" in FIM_MIDDLE and "end" in FIM_SUFFIX
prompt = f"{FIM_PREFIX}{prefix}{FIM_MIDDLE}{suffix}{FIM_SUFFIX}"
return prompt
def create_infilling_prompt(
model_key: str,
prefix: str,
suffix: str,
tokenizer: PreTrainedTokenizer | None = None,
) -> str:
if model_key in SupportedModelKeys.starcoder_based_models():
return form_starcoder_infill(prefix, suffix)
elif (
model_key in SupportedModelKeys.codellama_based_models()
and not "python" in model_key.lower()
):
return form_codellama_infill(prefix, suffix)
elif model_key in SupportedModelKeys.deepseekcoder_based_models():
assert tokenizer is not None
return form_deepseekcoder_infill(tokenizer, prefix, suffix)
# TODO: other models
assert False, f"Unsupported model key: {model_key}"
selfcodealign-selfcodealign/src/star_align/minhash_dedup.py 0000664 0000000 0000000 00000034356 14637551746 0024603 0 ustar 00root root 0000000 0000000 import json
import argparse
import random
import multiprocessing as mp
import os
import re
from collections import defaultdict
from typing import Any, Callable, List
import click
import datasets
import numpy as np
from tqdm import tqdm
import pickle # nosec
from collections import Counter
from pathlib import Path
from itertools import tee
from scipy.integrate import quad as integrate
import hashlib
import struct
from hashlib import md5
from hashlib import sha256
import xxhash
from xxhash import xxh3_64
from xxhash import xxh3_64_digest
from xxhash import xxh3_128
from xxhash import xxh3_128_digest
parser = argparse.ArgumentParser()
# IO Args
parser.add_argument("--data_files", type=str, required=True)
parser.add_argument("--output", type=str, required=True)
parser.add_argument("--num_proc", type=int, default=os.cpu_count())
# Meta Args
parser.add_argument("--column", type=str, required=True)
parser.add_argument("--batch_size", type=int, default=10_000)
# MinHash Args
parser.add_argument("--ngram", type=int, default=5)
parser.add_argument("--min_length", type=int, default=5)
parser.add_argument("--ignore_empty", type=bool, default=False)
parser.add_argument("--seed", type=int, default=42)
parser.add_argument("--num_perm", type=int, default=250)
parser.add_argument("--threshold", type=float, default=0.7)
parser.add_argument("--b", type=int, default=None)
parser.add_argument("--r", type=int, default=None)
parser.add_argument("--hash_func", type=str, default="sha1")
parser.add_argument("--hash_bits", type=int, default=64)
args = parser.parse_args()
def ngrams(sequence: List[str], n: int, min_length: int = 5):
"""
Return the ngrams generated from a sequence of items, as an iterator.
This is a modified version of nltk.util.ngrams.
"""
if len(sequence) < min_length:
return []
if len(sequence) < n:
return [tuple(sequence)]
iterables = tee(iter(sequence), n)
for i, sub_iterable in enumerate(iterables):
for _ in range(i):
next(sub_iterable, None)
return zip(*iterables)
class UnionFind:
"""
A data structure for maintaining disjoint sets. This helps build connected components for given duplicate pairs.
"""
def __init__(self):
self.parent = {}
# Counter is a subclass of dict with slightly different python and c implementations
# you can think of it as an optimized defaultdict(int)
self.rank = Counter()
def find(self, x):
try:
# path compression
if self.parent[x] != x:
self.parent[x] = self.find(self.parent[x])
except KeyError:
# KeyError happens if x not in parent
self.parent[x] = x
finally:
return self.parent[x]
def union(self, x, y):
px = self.find(x)
py = self.find(y)
# If both elements are already in the same set, do nothing
# The line in original UnionFind `self.parent[px] = self.parent[py] = min(px, py)` is redundant when px == py
if px == py:
return
if self.rank[px] == self.rank[py]:
# If ranks are equal, choose one as the new root and increment its rank
# with few duplicates this is likely to be the most common case
self.parent[py] = px
self.rank[px] += 1
# otherwise, assume that leftside is more likely to be higher rank
# Attach the smaller rank tree under the root of the larger rank tree
elif self.rank[px] > self.rank[py]:
self.parent[py] = px
else:
self.parent[px] = py
def reset(self):
self.parent = {}
self.rank = Counter()
def dump(self, path: str | Path, id2id=None):
if id2id is not None:
new_uf = UnionFind()
for i in self.parent:
new_uf.union(id2id[i], id2id[self.find(i)])
else:
new_uf = self
with open(path, "wb") as f:
pickle.dump(new_uf, f, protocol=pickle.HIGHEST_PROTOCOL)
RNG = np.random.RandomState(args.seed)
NON_ALPHA = re.compile(r"\W", re.UNICODE)
datasets.logging.set_verbosity_error()
SIGNATURE_COLUMN = "__signatures__"
INDEX_COLUMN = "__index__"
CLUSTER_COLUMN = "__cluster__"
# for is originally used to reduce memory usage in MacOS but also ensures that the Union Find data structure
# is not copied to child processes as long as it is not modified.
mp.set_start_method("fork", force=True)
uf = UnionFind()
def sha1_hash(data: bytes, d: int = 32) -> int:
"""
Generate a d-bit hash value from the given data.
"""
if d == 32:
return struct.unpack(
" int:
"""
Generate a 16-bit xxhash based hash value from the given data.
As of python xxhash 3.3.0 (and since 0.3.0) outputs in big-endian.
This is useful as a special purpose xxhash when you only want 16 bits.
bit masked xxh3_64 hashes are faster than xxh32 in modern systems.
"""
return xxhash.xxh3_64_intdigest(data, seed) & 0xFFFF
def xxh3_32hash(data: bytes, seed: int = 0) -> int:
"""
Generate a 32-bit xxhash based hash value from the given data.
As of python xxhash 3.3.0 (and since 0.3.0) outputs in big-endian.
This is useful as a special purpose xxhash when you only want 32bits.
bit masked xxh3_64 hashes are faster than xxh32 in modern systems.
"""
return xxhash.xxh3_64_intdigest(data, seed) & 0xFFFFFFFF
def optimal_param(
threshold: float,
num_perm: int,
false_positive_weight: float = 0.5,
false_negative_weight: float = 0.5,
):
"""
Compute the optimal `MinHashLSH` parameter that minimizes the weighted sum
of probabilities of false positive and false negative, taken from datasketch.
"""
def false_positive_area(threshold: float, b: int, r: int):
"""Source: `datasketch.lsh`"""
def proba(s):
return 1 - (1 - s ** float(r)) ** float(b)
a, _ = integrate(proba, 0.0, threshold)
return a
def false_negative_area(threshold: float, b: int, r: int):
"""Source: `datasketch.lsh`"""
def proba(s):
return 1 - (1 - (1 - s ** float(r)) ** float(b))
a, _ = integrate(proba, threshold, 1.0)
return a
min_error = float("inf")
opt = (0, 0)
for b in range(1, num_perm + 1):
max_r = int(num_perm / b)
for r in range(1, max_r + 1):
fp = false_positive_area(threshold, b, r)
fn = false_negative_area(threshold, b, r)
error = fp * false_positive_weight + fn * false_negative_weight
if error < min_error:
min_error = error
opt = (b, r)
return opt
def embed_func(
content: str,
idx: int,
*,
num_perm: int,
ngram_size: int,
min_length: int,
hashranges: list[tuple[int, int]],
permutations: np.ndarray,
hash_func: Callable,
dtype: type,
max_hash: np.uint,
modulo_prime: np.uint,
) -> dict[str, Any]:
"""
Calculate hash values for the content.
"""
# a, b are each np.ndarray arrays containing {num_perm} pairs of random numbers used for building new hashes
# the formula is a * x(base hash of each shingle) + b
a, b = permutations
# split content on whitespace (NON_ALPHA regex), tokenize with ngrams(), and join these n-grams into a single space separated string.
# we then convert to lower case and then bytestrings which is then hashed. Only unique hashed n-grams are left.
tokens: set[bytes] = {
bytes(" ".join(t).lower(), "utf-8")
for t in ngrams(NON_ALPHA.split(content.lower()), ngram_size, min_length)
}
hashvalues: np.ndarray = np.array(
[hash_func(token) for token in tokens], dtype=dtype
).reshape(len(tokens), 1)
# Permute the hash values to produce new universal hashes
# Element-wise multiplication with 'hashvalues' and a (non 0 random value) and then adding b
# Then, take modulo 'MODULO_PRIME' and bitwise_and with 'MAX_HASH' to keep only the necessary bits.
hashvalues = (hashvalues * a + b) % modulo_prime & max_hash
# this part is where the name "min" of minhash comes from
# this stacks all the hashes and then takes the minimum from each column
masks: np.ndarray = np.full(shape=num_perm, dtype=dtype, fill_value=max_hash)
hashvalues = np.vstack([hashvalues, masks]).min(axis=0)
# Originally, byteswap was done for speed. Testing show it has a negligible impact
# keeping for backward compatibility, even though theoretically and empirically
# it doesnt matter if it is there or not. github.com/ekzhu/datasketch/issues/114
Hs: list[bytes] = [
bytes(hashvalues[start:end].byteswap().data) for start, end in hashranges
]
return {SIGNATURE_COLUMN: Hs, INDEX_COLUMN: idx}
def main():
global uf
uf.reset()
HASH_BITS: int = args.hash_bits
HASH_CONFIG: dict[int, tuple[type, Any, Any]] = {
64: (np.uint64, np.uint32((1 << 32) - 1), np.uint64((1 << 61) - 1)),
# 32, 16 bit config does not use a mersenne prime.
# The original reason for using mersenne prime was speed.
# Testing reveals, there is no benefit to using a 2^61 mersenne prime for division
32: (np.uint32, np.uint32((1 << 32) - 1), np.uint32((1 << 32) - 5)),
16: (np.uint16, np.uint16((1 << 16) - 1), np.uint16((1 << 16) - 15)),
}
DTYPE, MAX_HASH, MODULO_PRIME = HASH_CONFIG.get(HASH_BITS, HASH_CONFIG[64])
match args.hash_func:
case "sha1":
def hash_func(byte_data):
return sha1_hash(byte_data, d=min(HASH_BITS, 32))
case "xxh3":
if HASH_BITS == 16:
hash_func = xxh3_16hash
else:
hash_func = xxh3_32hash
if args.b is not None and args.r is not None:
B, R = args.b, args.r
else:
# Compute the optimal `MinHashLSH` parameter that minimizes the weighted sum
# of probabilities of false positive and false negative, taken from datasketch.
B, R = optimal_param(
args.threshold,
args.num_perm,
false_positive_weight=0.5,
false_negative_weight=0.5,
)
HASH_RANGES = [(i * R, (i + 1) * R) for i in range(B)]
HASH_TABLES = [defaultdict(set) for _ in range(B)]
PERMUTATIONS = (
RNG.randint(
1, MODULO_PRIME, size=(args.num_perm,), dtype=DTYPE
), # a is a multiplier so should not be 0
RNG.randint(0, MODULO_PRIME, size=(args.num_perm,), dtype=DTYPE), # b
)
# Loading
data_files_list = [x.strip() for x in args.data_files.split(",")]
ds = datasets.load_dataset("json", data_files=data_files_list, split="train")
ds = ds.map(
lambda x, i: {INDEX_COLUMN: i}, with_indices=True, num_proc=args.num_proc
)
if args.ignore_empty:
ds_rest = ds.filter(lambda x: len(x[args.column].strip()) == 0)
ds = ds.filter(lambda x: len(x[args.column].strip()) > 0)
ds = ds.filter(
lambda x: len(NON_ALPHA.split(x[args.column].lower())) >= args.min_length,
num_proc=args.num_proc,
)
LEN_DATASET = len(ds)
if args.ignore_empty:
LEN_DATASET += len(ds_rest)
# MinHashing
embedded = ds.map(
function=embed_func,
fn_kwargs={
"num_perm": args.num_perm,
"hashranges": HASH_RANGES,
"ngram_size": args.ngram,
"min_length": args.min_length,
"permutations": PERMUTATIONS,
"hash_func": hash_func,
"dtype": DTYPE,
"max_hash": MAX_HASH,
"modulo_prime": MODULO_PRIME,
},
input_columns=[args.column, INDEX_COLUMN],
remove_columns=[col for col in ds.column_names if col != INDEX_COLUMN],
num_proc=args.num_proc,
with_indices=False,
desc="Fingerprinting...",
)
LEN_EMBEDDED = len(embedded)
NUM_SHARDS = np.ceil(LEN_EMBEDDED / args.batch_size).astype(int)
# Clustering
edges = []
for i in tqdm(
range(0, NUM_SHARDS),
dynamic_ncols=True,
desc="Iterating MinHashes...", # noqa: E501
):
embedded_shard = embedded.shard(
num_shards=NUM_SHARDS,
index=i,
contiguous=True,
writer_batch_size=args.batch_size,
)
for key, Hs in zip(
embedded_shard[INDEX_COLUMN], embedded_shard[SIGNATURE_COLUMN]
):
for i, H in enumerate(Hs):
HASH_TABLES[i][H].add(key)
print(f"Number of clusters: {len(HASH_TABLES)}")
for table in tqdm(HASH_TABLES, dynamic_ncols=True, desc="Clustering..."):
# cluster: Set[int]
for cluster in table.values():
if len(cluster) <= 1:
continue
idx = min(cluster)
for x in cluster:
edges.append((x, idx))
uf.union(x, idx)
print(f"Number of edges: {len(set(edges))}")
# Filtering
ds = ds.map(
function=lambda record: {CLUSTER_COLUMN: uf.find(record[INDEX_COLUMN])},
with_indices=False,
num_proc=args.num_proc,
new_fingerprint=str(random.getrandbits(128)),
desc="Finding clusters...",
)
# This is where the deduplication happens
# Since there is no easy groupby in datasets
# I will use this simple filter for now
final_data = ds.filter(
function=lambda record: record[CLUSTER_COLUMN] == record[INDEX_COLUMN],
with_indices=False,
num_proc=args.num_proc,
desc="Filtering clusters...",
)
if args.ignore_empty and len(ds_rest) > 0:
final_data = datasets.concatenate_datasets([ds_rest, final_data])
# Saving
final_data = final_data.remove_columns([CLUSTER_COLUMN, INDEX_COLUMN])
final_data.to_json(args.output)
print("Before:", LEN_DATASET)
print("After:", len(final_data))
# Cleaning
ds.cleanup_cache_files()
final_data.cleanup_cache_files()
if __name__ == "__main__":
main()
selfcodealign-selfcodealign/src/star_align/prompt_template.py 0000664 0000000 0000000 00000001471 14637551746 0025177 0 ustar 00root root 0000000 0000000 SC2_INSTRUCT_PROMPT = """You are an exceptionally intelligent coding assistant that consistently delivers accurate and reliable responses to user instructions.
### Instruction
{instruction}
### Response
{response}"""
CHAT_TEMPLATE = """{{bos_token}}{{'You are an exceptionally intelligent coding assistant that consistently delivers accurate and reliable responses to user instructions.\n\n'}}
{%- for message in messages %}
{%- if message['role'] == 'system' %}
{{ raise_exception('System messages are not allowed in this template.') }}
{%- else %}
{%- if message['role'] == 'user' %}
{{'### Instruction\n' + message['content'] + '\n\n'}}
{%- else %}
{{'### Response\n' + message['content'] + eos_token + '\n\n'}}
{%- endif %}
{%- endif %}
{%- endfor %}
{{'### Response\n'}}""" selfcodealign-selfcodealign/src/star_align/sanitize_data.py 0000664 0000000 0000000 00000035443 14637551746 0024610 0 ustar 00root root 0000000 0000000 """Deduplication, filtering, and selection"""
import random
import os
import ast
import re
import warnings
from dataclasses import dataclass, field
from pathlib import Path
from typing import cast, Literal
from datasets import load_dataset, Dataset
from tqdm.auto import tqdm
from transformers import HfArgumentParser
from star_align.utils import find_code_blocks, write_jsonl, find_codeblock_indices
LLAMA3 = os.getenv("LLAMA3") is not None
if LLAMA3:
print("LLAMA3 mode activated")
@dataclass(frozen=True)
class Args:
data_files: list[str]
output_file: str
shuffle: bool = field(default=True)
remove_strange: bool = field(default=True)
parse_raw_response: bool = field(default=True)
passing_only: bool = field(default=True)
data_augmentation: bool = field(default=False)
exact_match_dedup: bool = field(default=True)
get_code_representation: bool = field(default=True)
remove_comments_docstrings: bool = field(default=False)
include_left_failed: bool = field(default=False)
n_cores: int = field(default=os.cpu_count() or 1)
diversify_func_names: bool = field(default=True)
align_with: list[str] = field(default_factory=list)
priority: Literal["passed", "failed", "none"] = field(default="none")
seed: int = field(default=6666)
def extract_and_concat_function_names(python_content):
"""
Extracts all function names from a given Python content string and concatenates them into a single string.
Parameters:
- python_content: A string containing the Python code to analyze.
Returns:
- A string containing all function names defined in the content, concatenated.
"""
tree = ast.parse(python_content)
function_names = []
class_names = []
# Define a node visitor that adds the name of each function definition it visits
class FuncClassDefVisitor(ast.NodeVisitor):
def visit_ClassDef(self, node: ast.ClassDef):
class_names.append(node.name)
self.generic_visit(node)
def visit_FunctionDef(self, node):
function_names.append(node.name)
# Process the subtree for this node
self.generic_visit(node)
def visit_AsyncFunctionDef(self, node):
function_names.append(node.name)
self.generic_visit(node)
# Create a node visitor and walk through the AST
visitor = FuncClassDefVisitor()
visitor.visit(tree)
def compress_name(name: str) -> str:
return name.replace("_", "").lower()
return frozenset(map(compress_name, function_names)), frozenset(
map(compress_name, class_names)
)
INCOMPLETE_SUBSTRINGS = [
"todo",
"fixme",
"write your code here",
"your code here",
"your code goes here",
"notimplemented",
]
RESPONSE_TEST_SPLIT = "\n\n"
# special handling for llama3 since it has more examples not following the format
LLAMA3_DEFAULT_TEST_SPLIT = r"### Tests \d\n"
LLAMA3_ADDITIONAL_PATTERNS = [
"We can verify the functionality",
"We can verify the correctness",
"You can verify the correctness",
"You can verify the functionality",
"To ensure the correctness",
"To verify the correctness",
"To test the",
"To test this",
"To test this",
"You can test the",
"We can test the",
"We can test this",
"Now, we'll test",
]
def split_llama3_response_tests(response: str) -> list[str]:
splits = re.split(LLAMA3_DEFAULT_TEST_SPLIT, response)
if len(splits) > 2:
return []
if len(splits) == 2:
return splits
for pattern in LLAMA3_ADDITIONAL_PATTERNS:
index = response.find(pattern)
if index != -1:
return [response[:index], response[index:]]
return []
def preprocess_and_filter(x: dict) -> dict:
"""Filter out responses with wrong format"""
def wrong_format(x: dict) -> dict:
return {k: v for k, v in x.items()} | dict(wrong_format=True, tests="")
response: str = x["response"]
if not LLAMA3 and RESPONSE_TEST_SPLIT not in response:
return wrong_format(x)
if any(substring in response.lower() for substring in INCOMPLETE_SUBSTRINGS):
return wrong_format(x)
if LLAMA3:
splits = split_llama3_response_tests(response)
else:
splits = response.split(RESPONSE_TEST_SPLIT)
if len(splits) != 2:
return wrong_format(x)
response, tests = cast(tuple[str, str], tuple(map(str.strip, splits)))
response_codeblocks = find_code_blocks(response, "python")
tests_codeblocks = find_code_blocks(tests, "python")
if len(response_codeblocks) == 0 or len(tests_codeblocks) == 0:
return wrong_format(x)
tests_content = "\n".join(tests_codeblocks)
if "assert" not in tests or all(
l.startswith("def")
or l.startswith("class")
or l.startswith("import")
or l.startswith("from")
for l in tests_content.splitlines()
if len(l) > 0 and l[0].isalpha()
):
return wrong_format(x)
newx = {k: v for k, v in x.items() if k != "response"} | dict(
response=response, tests=tests, wrong_format=False
)
return newx
def augment_data(x: dict, index: int) -> dict:
random.seed(index)
tests_content = "\n".join(find_code_blocks(x["tests"]))
lines = tests_content.splitlines()
if all(l.startswith("assert") for l in lines):
ks = [1, 2, 3, 4, 5]
assertions = random.sample(lines, k=min(random.choice(ks), len(lines)))
assertion = "\n".join(assertions)
assertion_term = "assertion" + ("s" if len(assertions) > 1 else "")
else:
assertion = tests_content
assertion_term = "test case"
if (
"assert" in assertion
# 5 lines augmented block max
and len(assertion.splitlines()) <= 5
and random.random() < 0.5
and "assert" not in x["instruction"]
and "for example" not in x["instruction"].lower()
and "test" not in x["instruction"].lower()
):
assert "assert" in assertion
assertion_str = (
f"Your code should pass the following {assertion_term}:\n```python\n"
+ assertion.strip()
+ "\n```"
)
new_instruction = f"{x['instruction']}\n\n{assertion_str}"
newx = {k: v for k, v in x.items()} | dict(instruction=new_instruction)
return newx
return x
# raw response -> response + test
# response/test -> passing (opt: passing)
# (not)passing -> unique
# unique -> aug / minihash / selection / educational -> final
def remove_ast_docstrings(tree):
# ref: https://gist.github.com/phpdude/1ae6f19de213d66286c8183e9e3b9ec1
for node in ast.walk(tree):
# let's work only on functions & classes definitions
if not isinstance(node, (ast.FunctionDef, ast.ClassDef, ast.AsyncFunctionDef)):
continue
if len(node.body) == 0:
continue
if not isinstance(node.body[0], ast.Expr):
continue
if (
not hasattr(node.body[0], "value")
or not isinstance(node.body[0].value, ast.Str)
# or not isinstance(node.body[0].value.value, str)
):
continue
node.body = node.body[1:] # type: ignore
return tree
def remove_comments_from_code_blocks(
content: str,
) -> str:
code_blocks = find_codeblock_indices(content)
# Current index in the original content for tracking purposes
current_index = 0
# Buffer to store the new content
new_content: list[str] = []
# Iterate over each code block
for start, end in code_blocks:
# Append the content before this code block
new_content.append(content[current_index:start])
# Extract the code block content
code_block_content = content[start:end]
# Split into lines, process, and rejoin
modified_block_content = remove_comments(code_block_content)
new_content.append(modified_block_content)
# Update current index
current_index = end
# Add the remaining part of the original content after the last code block
new_content.append(content[current_index:])
# Join all parts to form the final modified content
return "".join(new_content)
def remove_comments(code: str) -> str:
"""Remove comments and docstrings using AST"""
tree = ast.parse(code)
tree = remove_ast_docstrings(tree)
return ast.unparse(tree)
def get_code_representation(response: str) -> str:
"""Keep classes and functions, removing comments and docstrings"""
raw_code = "\n".join(find_code_blocks(response))
tree = ast.parse(raw_code)
class ClassFunctionTransformer(ast.NodeTransformer):
def visit_Module(self, node):
# Visit all children nodes of the module
node = self.generic_visit(node)
# Filter out only function and class definitions
node.body = [
n for n in node.body if isinstance(n, (ast.FunctionDef, ast.ClassDef))
]
return node
visitor = ClassFunctionTransformer()
tree = visitor.visit(tree)
tree = remove_ast_docstrings(tree)
return ast.unparse(tree)
def map_code_representation(x: dict) -> dict:
try:
representation = get_code_representation(x["response"])
except SyntaxError:
representation = ""
return {k: v for k, v in x.items()} | dict(code_representation=representation)
# def concat_list(lists: list[list]) -> list:
# return [item for sublist in lists for item in sublist]
def map_examples_batched(examples: dict, map_one) -> dict:
all_keys = list(examples.keys())
list_of_examples = [
{k: examples[k][i] for k in all_keys} for i in range(len(examples[all_keys[0]]))
]
results = [map_one(example) for example in list_of_examples]
result_dict = {k: [result[k] for result in results] for k in results[0].keys()}
return result_dict
def map_remove_comments(x: dict) -> dict:
try:
response = x["response"]
except SyntaxError:
response = ""
return {k: v for k, v in x.items() if k != "response"} | dict(response=response)
def main():
args = cast(Args, HfArgumentParser(Args).parse_args_into_dataclasses()[0])
raw_data = load_dataset("json", data_files=args.data_files, split="train")
if args.align_with:
ref_data = load_dataset("json", data_files=args.align_with, split="train")
ref_data_instructions = set(map(lambda x: x["instruction"], ref_data))
raw_data = raw_data.filter(
lambda x: x["instruction"] in ref_data_instructions, num_proc=args.n_cores
)
print("Raw samples:", len(raw_data))
if args.parse_raw_response:
raw_data = raw_data.map(
map_examples_batched,
fn_kwargs=dict(map_one=preprocess_and_filter),
batched=True,
num_proc=args.n_cores,
)
raw_data = raw_data.filter(
lambda x: not x["wrong_format"], num_proc=args.n_cores
)
raw_data = raw_data.remove_columns(["wrong_format"])
print("Correct format:", len(raw_data))
if args.include_left_failed:
failed_data = raw_data.filter(lambda x: not x["pass"], num_proc=args.n_cores)
if args.passing_only:
raw_data = raw_data.filter(lambda x: x["pass"], num_proc=args.n_cores)
print("Passing only:", len(raw_data))
if args.shuffle:
raw_data = raw_data.shuffle(seed=args.seed)
if args.include_left_failed:
failed_data = failed_data.shuffle(seed=args.seed)
if args.priority != "none":
# Sort the examples such that failed/passed are at first
raw_data = raw_data.map(
map_examples_batched,
fn_kwargs=dict(map_one=lambda x: dict(**x, rank=int(x["pass"]))),
batched=True,
num_proc=args.n_cores,
)
reverse = args.priority == "passed"
raw_data = raw_data.sort(column_names="rank", reverse=reverse)
raw_data = raw_data.remove_columns("rank")
def mk_key(instruction: str) -> str:
return "".join(instruction.split())
seen_ids = set[frozenset[str]]()
seen_keys = set[str]()
if args.exact_match_dedup:
new_data = list[dict]()
def iterate(dataset: Dataset):
for d in tqdm(dataset):
if args.remove_strange:
# NOTE: newly added
if len(d["instruction"].split()) > 200:
continue
key_i, key_r = mk_key(d["instruction"]), mk_key(d["response"])
if key_i in seen_keys or key_r in seen_keys:
continue
if args.diversify_func_names:
code_block = find_code_blocks(d["response"])[0]
try:
fn_names, class_names = extract_and_concat_function_names(
code_block
)
except SyntaxError:
continue
if (len(fn_names) > 0 and fn_names in seen_ids) or (
len(class_names) > 0 and class_names in seen_ids
):
continue
seen_ids.add(fn_names)
seen_ids.add(class_names)
new_data.append(d)
seen_keys.add(key_i)
seen_keys.add(key_r)
iterate(raw_data)
if args.include_left_failed:
iterate(failed_data)
print("Non exact matches:", len(new_data))
else:
new_data = raw_data.to_list()
if args.include_left_failed:
new_data.extend(failed_data.to_list())
new_dataset = Dataset.from_list(new_data)
if args.get_code_representation:
new_dataset = new_dataset.map(
map_examples_batched,
fn_kwargs=dict(map_one=map_code_representation),
batched=True,
batch_size=1000,
# num_proc=args.n_cores,
)
new_dataset = new_dataset.filter(
lambda x: x["code_representation"] != "",
num_proc=args.n_cores,
)
print("Extracted code representation:", len(new_dataset))
if args.remove_comments_docstrings:
new_dataset = new_dataset.map(
map_examples_batched,
fn_kwargs=dict(map_one=map_remove_comments),
batched=True,
# num_proc=args.n_cores,
)
new_dataset = new_dataset.filter(
lambda x: x["response"] != "",
num_proc=args.n_cores,
)
print("Removed comments/docstrings:", len(new_dataset))
if args.data_augmentation:
new_dataset = new_dataset.map(
augment_data,
num_proc=args.n_cores,
with_indices=True,
)
print("Augmented:", len(new_dataset))
write_jsonl(Path(args.output_file), new_dataset)
if __name__ == "__main__":
main()
selfcodealign-selfcodealign/src/star_align/self_ossinstruct.py 0000664 0000000 0000000 00000062365 14637551746 0025405 0 ustar 00root root 0000000 0000000 import asyncio
import json
import os
import random
import re
import time
from dataclasses import dataclass, field
from pathlib import Path
from typing import Any, Literal, cast
from openai.types import CompletionChoice, Completion
from datasets import Dataset, load_dataset
from tqdm.auto import tqdm
from transformers import HfArgumentParser
import star_align
InstructMode = Literal["I->R", "S->C", "C->I", "S->I"]
LANGUAGE_MAP = {
"cpp": "C++",
"java": "Java",
"php": "PHP",
"python": "Python",
"rust": "Rust",
"typescript": "TypeScript",
}
LLAMA3 = os.getenv("LLAMA3") is not None
if LLAMA3:
print("Use Llama-3 prompt format")
def flatten_openai_responses(responses: list[Completion]) -> list[Completion]:
# assert all(len(response.choices) == chunk_size for response in responses)
completions = list[Completion]()
for idx, response in enumerate(responses):
completions.extend(
Completion(
id=f"{response.id}:{idx}",
created=response.created,
object=response.object,
model=response.model,
choices=[choice],
system_fingerprint=response.system_fingerprint,
)
for choice in response.choices
)
return completions
@dataclass(frozen=True)
class Args:
seed_data_files: list[str] = field(
metadata={"help": "Path to the seed code snippets"}
)
# `seed_code_start_index` + `max_new_data` is the last-to-end seed code index
max_new_data: int
model: str
instruct_mode: InstructMode
use_vllm_server: bool = field(default=True)
seed_code_start_index: int = field(default=0)
continue_from: str | None = field(default=None)
# Keep the following arguments unchanged for reproducibility
seed: int = field(default=3407)
temperature: float = field(default=0.7)
max_output_tokens: int = field(default=1536)
prompting_mode: Literal["chat", "completion"] = field(default="completion")
num_fewshots: int = field(default=8)
async_micro_batch_size: int = field(
default=1,
metadata={
"help": "Number of prompts to batch in a single async request."
"Won't be effective if `use_vllm_server` is False."
"It should be divisible by `num_batched_requests` for a balance load"
"if multiple vllm instances are served through a round-robin load balancer."
},
)
num_batched_requests: int = field(
default=1, metadata={"help": "Number of requests to send concurrently"}
)
num_sample_per_request: int = field(
default=32, metadata={"help": "Number of samples to generate per request"}
)
sleep: float | None = field(
default=None, metadata={"help": "Sleep between requests in seconds"}
)
delay: float | None = field(
default=None, metadata={"help": "Delay between batched requests in seconds"}
)
tag: str = field(
default="",
metadata={
"help": "Custom tag as part of the output filename, not affecting the fingerprint"
},
)
save_dir: str = field(default="./")
def fingerprint(self, fewshot: "Fewshot | None") -> str:
# The combination of arguments can uniquely determine the generation process
args = (
self.seed_data_files,
self.seed,
self.prompting_mode,
self.num_fewshots,
self.temperature,
self.model,
self.max_output_tokens,
fewshot,
)
return star_align.utils.compute_fingerprint(*args, hash_length=5)
@dataclass(frozen=True)
class Property:
category: str
language: str
concepts: list[str]
difficulty: str
@staticmethod
def random_exercise(concepts: list[str], language: str) -> "Property":
category = random.choice(
[
"function implementation",
"function implementation",
"class implementation",
"program implementation",
]
)
difficulty = random.choice(["easy", "medium", "hard"])
return Property(
category=category,
language=language,
concepts=concepts,
difficulty=difficulty,
)
def concepts_prompt(self) -> str:
return ", ".join(self.concepts)
def prompt(self) -> str:
category = f"category: {self.category}"
language = f"language: {self.language}"
difficulty = f"difficulty: {self.difficulty}"
concepts = f"concepts: {self.concepts_prompt()}"
return "\n".join([category, language, difficulty, concepts])
def to_json(self) -> dict[str, str | list[str]]:
return dict(
category=self.category,
language=self.language,
concepts=self.concepts,
difficulty=self.difficulty,
)
@staticmethod
def from_json(data: dict) -> "Property":
assert all(
isinstance(data[key], str) for key in ["category", "language", "difficulty"]
)
assert isinstance(data["concepts"], list)
return Property(
category=data["category"],
language=data["language"],
concepts=data["concepts"],
difficulty=data["difficulty"],
)
@dataclass(frozen=True)
class Example:
property: Property
snippet: str
instruction: str
response: str
tests: str
@staticmethod
def prefix_template(mode: InstructMode) -> str:
if mode == "I->R":
if LLAMA3:
template = (
"### Instruction {index} \n{instruction}\n\n### Response {index}\n"
)
else:
template = (
"\n{instruction}\n \n\n\n"
)
return template
elif mode == "S->C":
return "### Snippet\n{snippet}\n\n### Concepts\n"
elif mode == "C->I":
return "### Properties\n{property}\n\n### Task\n"
elif mode == "S->I":
return "### Snippet\n{snippet}\n\n### Task\n"
else:
assert False
def prompt(
self,
mode: InstructMode,
return_in_separate: bool = False,
index: int | None = None,
) -> str | tuple[str, str]:
assert index is None or (mode == "I->R" and LLAMA3)
if mode == "I->R":
kwargs = dict(instruction=self.instruction)
if LLAMA3:
assert index is not None
kwargs["index"] = str(index)
suffix = f"{self.response}\n\n### Tests {index}\n{self.tests}"
else:
suffix = (
f"{self.response}\n \n\n\n{self.tests}\n "
)
elif mode == "S->C":
kwargs = dict(snippet=self.snippet)
suffix = self.property.concepts_prompt()
elif mode == "C->I":
property_prompt = self.property.prompt()
# num_words = len(self.instruction.split())
# property_prompt += f"\nnum_words: {num_words}"
kwargs = dict(property=property_prompt)
suffix = self.instruction
elif mode == "S->I":
kwargs = dict(snippet=self.snippet)
suffix = self.instruction
else:
assert False
prefix = self.prefix_template(mode).format(**kwargs)
if return_in_separate:
return prefix, suffix
else:
return prefix + suffix
@dataclass(frozen=True)
class Fewshot:
sys_i_r: str
sys_c_i: str
sys_s_c: str
sys_s_i: str
examples: list[Example]
def system_prompt(self, mode: InstructMode) -> str:
attr_name = "sys_" + mode.replace("->", "_").replace("-", "_").lower()
return getattr(self, attr_name)
def valid_examples(self, mode: InstructMode) -> list[Example]:
# if mode in ["E->S", "I->RT", "I->R"]:
# return [
# example for example in self.examples if example.solution is not None
# ]
return self.examples
def random_prompt(
self,
mode: InstructMode,
num_fewshots: int,
prompting_mode: Literal["chat", "completion"],
**format_args: str,
) -> str:
valid_examples = self.valid_examples(mode)
assert (
0 < num_fewshots <= len(valid_examples)
), f"{num_fewshots=}, {len(valid_examples)=}"
# if mode == "I->R":
# # Hack
# category = format_args["category"]
# matching_examples = [
# example
# for example in valid_examples
# if example.property.category == category
# ]
# assert len(matching_examples) > 0, f"{category=}"
# matching_example = random.choice(matching_examples)
# rest_of_examples = [
# example for example in valid_examples if example is not matching_example
# ]
# assert len(rest_of_examples) == len(self.examples) - 1
# examples = [matching_example] + random.sample(
# rest_of_examples, k=num_fewshots - 1
# )
# random.shuffle(examples)
# else:
examples = random.sample(valid_examples, k=num_fewshots)
assert len(examples) == num_fewshots
body = "\n\n".join(
f"## Example {idx + 1}\n{example.prompt(mode, index=idx + 1 if LLAMA3 and mode == 'I->R' else None)}"
for idx, example in enumerate(examples)
)
# content = f"{self.system_prompt}\n\n{body}"
prefix_template = Example.prefix_template(mode)
if mode == "I->R" and LLAMA3:
format_args["index"] = str(len(examples) + 1)
prefix = f"## Example {len(examples) + 1}\n" + prefix_template.format(
**format_args
)
system_prompt = self.system_prompt(mode)
full_prompt = f"{system_prompt}\n\n{body}\n\n{prefix}"
assert prompting_mode == "completion", "Only completion is supported for now"
return full_prompt
def parse_property(content: str) -> Property | None:
content = content.strip()
lines = content.split("\n")
if len(lines) != 4:
return None
try:
lines = [line[line.index(":") + 1 :].strip() for line in lines]
except ValueError:
return None
category, language, difficulty, concepts_str = lines
concepts = list(map(str.strip, concepts_str.split(",")))
return Property(category, language, concepts, difficulty)
def get_ossinstruct_fewshots() -> Fewshot:
content = Path("prompts/self-ossinstruct-fewshot.txt").read_text().strip()
# split according to the example tag, but exclude the tag. Strip each string.
splits = re.split(r"### Example \d+", content)
system_prompt = splits[0].strip()
# "I->R", "E->S", "I->I", "PI->PI", "S->C"
sys_pattern = r"### System: I->R|### System: C->I|### System: S->C|### System: S->I"
_, i_r, c_i, s_c, s_i = list(map(str.strip, re.split(sys_pattern, system_prompt)))
if LLAMA3:
i_r = f"{i_r}\n\nFor each '## Example' below, make sure you provide a '### Response' and a '### Tests' section."
# system_prompt = re.split(r"### System: Instruction", system_prompt)[1]
# instruction_system_prompt, response_system_prompt = system_prompt.split(
# "### System: Response"
# )
# instruction_system_prompt = instruction_system_prompt.strip()
# response_system_prompt = response_system_prompt.strip()
examples_str = [example.strip() for example in splits[1:]]
assert len(examples_str) == 21, len(examples_str)
examples = list[Example]()
for example_str in examples_str:
pattern = (
r"\[Code\]\n|\[Property\]\n|\[Instruction\]\n|\[Response\]\n|\[Tests\]\n"
)
_, snippet, property, instruction, response, tests = re.split(
pattern, example_str
)
snippet = snippet.rstrip()
property = parse_property(property)
assert property is not None
instruction = instruction.strip()
response = response.strip()
tests = tests.strip()
example = Example(property, snippet, instruction, response, tests)
examples.append(example)
# if args.external_data is not None:
# examples.extend(external_examples)
return Fewshot(
sys_i_r=i_r,
sys_c_i=c_i,
sys_s_c=s_c,
sys_s_i=s_i,
examples=examples,
)
def parse_generated_content(content: str, instruct_mode: InstructMode) -> dict | None:
if instruct_mode == "I->R":
return dict(response=content.strip())
elif instruct_mode == "S->C":
concepts = list(map(str.strip, content.split(",")))
return dict(concepts=concepts)
elif instruct_mode == "C->I":
return dict(instruction=content.strip())
elif instruct_mode == "S->I":
return dict(instruction=content.strip())
else:
assert False
def build_kwargs(instruct_mode: InstructMode, example: dict) -> dict[str, str]:
kwargs = dict[str, str]()
if instruct_mode == "I->R":
kwargs["instruction"] = example["instruction"]
# Hack
# category_index = example["prompt"].rindex("category: ") + len("category: ")
# category_end = example["prompt"].index("\n", category_index)
# category = example["prompt"][category_index:category_end].strip()
# kwargs["category"] = category # type: ignore
elif instruct_mode in ["S->C", "S->I"]:
kwargs["snippet"] = example["seed"]
elif instruct_mode == "C->I":
lang = example.get("data_dir", "dummy_key_not_in_example")
language = LANGUAGE_MAP.get(lang, "Python")
property = Property.random_exercise(example["concepts"], language=language)
property_prompt = property.prompt()
# 45 / 152 are the min/max word lengths in the fewshot examples
# num_words = random.randint(1000, 1500)
# property_prompt += f"\nnum_words: {num_words}"
kwargs["property"] = property_prompt
# Hack
kwargs["property_obj"] = property # type: ignore
else:
assert False
return kwargs
def get_readable_prefix(instruct_mode: InstructMode, example: dict) -> str:
mode_pattern = instruct_mode.split("->")[0]
mode_map = {
"I": "Instruction",
"S": "Seed",
"R": "Response",
"C": "Concepts",
"P": "Property",
}
prefix = "\n\n".join(
f"@@@{mode_map[mode]}\n{example[mode_map[mode].lower()]}"
for mode in mode_pattern
)
return prefix
async def main():
args = cast(Args, HfArgumentParser(Args).parse_args_into_dataclasses()[0])
# Sanity check
assert args.num_batched_requests % args.async_micro_batch_size == 0
if args.async_micro_batch_size > 1:
assert (
args.num_sample_per_request == 1
), "Only support 1 sample with batched async requests"
if args.use_vllm_server:
openai_client = star_align.utils.OpenAIClient()
raw_dataset: Dataset = load_dataset(
"json",
data_files=args.seed_data_files,
split="train",
num_proc=star_align.utils.N_CORES,
)
id_key = "seed"
if os.getenv("IGNORE_SEED_CHECK") is None:
assert len(set(d[id_key] for d in raw_dataset)) == len(
raw_dataset
), "Duplicate seeds appear in the dataset"
else:
print("[Warning] Ignoring seed check")
# Every run should produce the same data as long as the default params are not changed
start_index = args.seed_code_start_index
end_index = min(start_index + args.max_new_data, len(raw_dataset))
raw_dataset = raw_dataset.select(range(start_index, end_index))
dataset = raw_dataset.to_list()
assert args.prompting_mode == "completion", "Only completion is supported for now"
fewshot = get_ossinstruct_fewshots()
data_fingerprint = args.fingerprint(fewshot)
timestamp = star_align.utils.timestamp()
if args.continue_from is not None:
if os.getenv("IGNORE_FINGERPRINT") is None:
assert (
data_fingerprint in args.continue_from
), f"Fingerprint mismatch: {data_fingerprint}"
assert f"-{start_index}-" in args.continue_from, "Index mismatch"
old_path = Path(args.continue_from)
assert old_path.exists()
old_data = star_align.utils.read_jsonl(old_path)
assert len(old_data) > 0
last_seed = old_data[-1][id_key]
# Find seed
seed_index = next(
idx for idx, d in enumerate(dataset) if d[id_key] == last_seed
)
n_skipped = seed_index + 1
# n_skipped = last_index - start_index + 1
print(f"Continuing from {old_path} with {n_skipped} seed snippets skipped")
f_out = old_path.open("a")
else:
tag = "" if args.tag == "" else f"-{args.tag}"
mode_str = args.instruct_mode.replace("->", "_").lower()
path = Path(
args.save_dir,
f"data{tag}-{mode_str}-{data_fingerprint}-{start_index}-{timestamp}.jsonl",
)
assert not path.exists()
f_out = path.open("w")
print("Saving to", path)
n_skipped = 0
dataset = dataset[n_skipped:]
chunked_dataset = list(
star_align.utils.chunked(dataset, n=args.num_batched_requests)
)
pbar = tqdm(chunked_dataset)
n_succeeded = 0
if not args.use_vllm_server:
from vllm import LLM, SamplingParams, RequestOutput
import torch
engine = LLM(args.model, tensor_parallel_size=torch.cuda.device_count())
def vllm_response_to_openai(response: RequestOutput) -> Completion:
created = 0
choices = list[CompletionChoice]()
for output in response.outputs:
choice = CompletionChoice(
text=output.text,
index=0,
finish_reason=(
"stop" if output.finish_reason == "stop" else "length"
),
)
choices.append(choice)
model = "not-specified"
id = response.request_id
return Completion(
id=id,
created=created,
object="text_completion",
model=model,
choices=choices,
system_fingerprint="None",
)
for chunk_index, examples in enumerate(pbar):
# map to the index in the original seed snippets
effective_index = (
chunk_index * args.num_batched_requests + start_index + n_skipped
)
print("Effective index:", effective_index)
if chunk_index > 0 and args.sleep is not None:
print(f"Sleeping for {args.sleep} seconds...")
time.sleep(args.sleep)
# assert index + start_index == example["index"]
request_params = list[dict[str, Any]]()
all_prompts = list[str]()
for index, example in enumerate(examples):
seed = args.seed + effective_index + index
random.seed(seed)
kwargs = build_kwargs(args.instruct_mode, example)
prompt = fewshot.random_prompt(
args.instruct_mode,
args.num_fewshots,
prompting_mode=args.prompting_mode,
**kwargs,
)
prompt = prompt.rstrip()
all_prompts.append(prompt)
max_new_tokens = args.max_output_tokens
params: dict = dict(
model=args.model,
max_tokens=max_new_tokens,
n=args.num_sample_per_request,
temperature=args.temperature,
seed=seed,
)
params["prompt"] = prompt
params["stop"] = ["## Example"]
if args.instruct_mode == "I->R":
params["stop"].append(" ")
request_params.append(params)
assert len(request_params) == len(examples)
print(f"Ready to make {len(request_params)} requests")
if args.use_vllm_server:
dispatch_requests = (
openai_client.dispatch_chat_completions
if args.prompting_mode == "chat"
else openai_client.dispatch_completions
)
if args.async_micro_batch_size == 1:
responses = await dispatch_requests(request_params, delay=args.delay)
else:
# Construct micro batches for async requests
assert args.num_sample_per_request == 1
request_params_batched: list[dict[str, Any]] = []
request_params_chunks = star_align.utils.chunked(
request_params, args.async_micro_batch_size
)
for request_params_chunk in request_params_chunks:
request_param = {
k: v
for k, v in request_params_chunk[0].items()
if k != "prompt"
}
request_param["prompt"] = [
req["prompt"] for req in request_params_chunk
]
request_params_batched.append(request_param)
n_async_chunks = (
args.num_batched_requests // args.async_micro_batch_size
)
assert len(request_params_batched) in [
n_async_chunks,
n_async_chunks + 1,
], (request_params_batched, n_async_chunks)
print(
f"Ready to make {len(request_params_batched)} batched async requests"
)
responses_batched = await dispatch_requests(
request_params_batched, delay=args.delay
)
responses = flatten_openai_responses(responses_batched)
assert len(responses) == len(examples)
else:
stop = ["## Example"]
if args.instruct_mode == "I->R":
stop.append("")
sampling_params = SamplingParams(
temperature=args.temperature,
max_tokens=args.max_output_tokens,
seed=args.seed + effective_index,
n=args.num_sample_per_request,
stop=stop,
)
vllm_responses = engine.generate(all_prompts, sampling_params)
responses = list(map(vllm_response_to_openai, vllm_responses))
assert len(examples) == len(responses)
for prompt, example, response in zip(all_prompts, examples, responses):
if isinstance(response, BaseException):
print("Exception when generating response:", response)
continue
fingerprint = response.system_fingerprint
original_mapping = {
k: v for k, v in example.items() if k not in ["prompt", "fingerprint"]
}
success_parsing_res: list[dict] = []
for choice in response.choices:
if choice.finish_reason in ["stop", "eos_token"]:
if args.prompting_mode == "chat":
content = choice.message.content
else:
content = choice.text
parsing_result = parse_generated_content(
content, args.instruct_mode
)
if parsing_result is None:
print("[WRONG FORMAT]")
print("@@@Prompt", prompt, sep="\n", end="\n\n")
print("@@@Response", content, sep="\n", end="\n\n")
continue
success_parsing_res.append(parsing_result)
else:
print("Failed reason:", choice.finish_reason)
n_failed_samples = args.num_sample_per_request - len(success_parsing_res)
print(f"β
Success samples: {len(success_parsing_res)}")
print(f"β Failed samples: {n_failed_samples}")
if len(success_parsing_res) == 0:
print("No successful choices")
continue
data = dict(
prompt=prompt,
fingerprint=fingerprint,
**original_mapping,
)
if args.num_sample_per_request > 1:
data["parsing_result"] = success_parsing_res
prefix = prompt
else:
assert len(success_parsing_res) == 1
parsing_result = success_parsing_res[0]
data = dict(**data, **parsing_result)
prefix = prompt
# prefix = get_readable_prefix(args.instruct_mode, example)
print(
"@@@Prefix",
prefix,
f"@@@Generation (1 example)",
content,
# "@@@Instruction",
# data["instruction"],
# "@@@Response",
# data["response"],
sep="\n",
end="\n\n",
)
# breakpoint()
n_succeeded += 1
f_out.write(json.dumps(data) + "\n")
f_out.flush()
total_requests = chunk_index * args.num_batched_requests + len(examples)
pbar.set_description(f"Success ratio: {n_succeeded} / {total_requests}")
if __name__ == "__main__":
asyncio.run(main())
selfcodealign-selfcodealign/src/star_align/train.py 0000664 0000000 0000000 00000020240 14637551746 0023073 0 ustar 00root root 0000000 0000000 from dataclasses import dataclass, field
from typing import cast
import torch
from datasets import load_dataset
from transformers import HfArgumentParser, Trainer, TrainingArguments
from star_align.llm_wrapper import (
DecodingConfig,
EncodingConfig,
TokenizationContext,
get_model_context,
pad_sequences,
)
from star_align.prompt_template import CHAT_TEMPLATE, SC2_INSTRUCT_PROMPT as PROMPT_TEMPLATE
from star_align.utils import N_CORES
@dataclass(frozen=True)
class ModelArguments:
model_key: str
model_name_or_path: str | None = None
attention_dropout: float | None = field(default=None)
residual_dropout: float | None = field(default=None)
embedding_dropout: float | None = field(default=None)
# Ignored index in CrossEntropyLoss
IGNORED_INDEX = -100
def map_dataset(
examples: dict[str, list[str]],
args: "Args",
context: TokenizationContext,
) -> dict:
if args.prompt_completion_mode:
prompts = examples["prompt"]
completions = examples["completion"]
else:
instructions = examples["instruction"]
responses = examples["response"]
prompts = [
PROMPT_TEMPLATE.format(instruction=instruction, response="")
for instruction in instructions
]
completions = responses
assert len(prompts) == len(completions)
prompt_config = EncodingConfig(add_bos=True, add_eos=False)
completion_config = EncodingConfig(add_bos=False, add_eos=True)
prompt_id_batches = context.encode(prompt_config, prompts)
completion_id_batches = context.encode(completion_config, completions)
# prompt_id_batches = context.tokenization_context.encode(prompt_config, prompts)
# completion_id_batches = context.tokenization_context.encode(
# completion_config, completions
# )
assert len(prompt_id_batches) == len(completion_id_batches)
untruncated_input_ids = [
(instruction_ids + response_ids)
for instruction_ids, response_ids in zip(
prompt_id_batches, completion_id_batches
)
]
exceeding_length = [
len(input_id) > args.max_training_seq_length
for input_id in untruncated_input_ids
]
input_ids = [
input_id[: args.max_training_seq_length] for input_id in untruncated_input_ids
]
# NOTE: no need to set EOF to IGNORED_INDEX as it is *implicitly* ignored inside
# the model.forward that shifts the logits left by 1
labels = [
(list(map(lambda _: IGNORED_INDEX, instruction_ids)) + response_ids)[
: args.max_training_seq_length
]
for instruction_ids, response_ids in zip(
prompt_id_batches, completion_id_batches
)
]
# `len` of each returned value must be the same, which is required by `tokenizer.map`
# After `map`, they are treated as individual pieces of data, not as a batch.
assert len(input_ids) == len(labels)
for input_id_batch, label_batch in zip(input_ids, labels):
assert len(input_id_batch) == len(label_batch)
print(context.decode(DecodingConfig.default(), input_ids[0:])[0])
return {
"input_ids": input_ids,
"labels": labels,
"exceeding_length": exceeding_length,
}
def get_data_collator(model_key: str, args: "Args", pad_token_id: int):
"""Pad input_ids to the right, create labels by setting the padding tokens to -100, and
create attention_mask to ignore the padding tokens"""
def collate(examples: list[dict[str, list[int]]]) -> dict[str, torch.Tensor]:
input_ids_unpadded = [example["input_ids"] for example in examples]
labels_unpadded = [example["labels"] for example in examples]
padding_length = (
args.max_training_seq_length if args.pad_to_max_length else None
)
input_ids = pad_sequences(
input_ids_unpadded, pad_token_id, "right", padding_length=padding_length
)
labels = pad_sequences(
labels_unpadded, IGNORED_INDEX, "right", padding_length=padding_length
)
assert input_ids.shape == labels.shape
assert len(input_ids) == len(examples)
# Enforced in `map_raw_dataset`
assert input_ids.shape[-1] <= args.max_training_seq_length
if args.pad_to_max_length:
assert input_ids.shape[-1] == args.max_training_seq_length
if "starcoder2" in model_key:
attention_mask = torch.ones(input_ids.shape, dtype=torch.bool)
else:
attention_mask = input_ids.ne(pad_token_id)
# when bos == eos, the first token will be masked by mistake
attention_mask[:, 0] = True
return {
"input_ids": input_ids,
"labels": labels,
"attention_mask": attention_mask,
}
return collate
@dataclass(frozen=True)
class Args:
datafile_paths: list[str] = field(default_factory=list)
max_training_seq_length: int = field(default=1216)
pad_to_max_length: bool = field(default=False)
eval_dataset_size: float = field(
default=0.05, metadata={"help": "0--1 means ratio, >1 means number of examples"}
)
use_flash_attention: bool = field(default=False)
prompt_completion_mode: bool = field(default=False)
def train():
parser = HfArgumentParser((ModelArguments, TrainingArguments, Args))
model_args, training_args, args = cast(
tuple[ModelArguments, TrainingArguments, Args],
parser.parse_args_into_dataclasses(),
)
dataset = load_dataset("json", data_files=args.datafile_paths, split="train")
model_key = model_args.model_key
if (model_name_or_path := model_args.model_name_or_path) is None:
model_name_or_path = model_key
tokenization_context = TokenizationContext.from_model_key(
model_key, model_name_or_path
)
# if dataset_config.dpo_jsonl_path is None or dataset_config.dpo_sft:
train_dataset = dataset.map(
function=map_dataset,
fn_kwargs=dict(args=args, context=tokenization_context),
batched=True,
num_proc=N_CORES,
remove_columns=dataset.column_names,
load_from_cache_file=False, # not args.overwrite_cache
desc="Running tokenizer on train dataset",
)
msg = f"#Examples truncated: {sum(train_dataset['exceeding_length'])} / {len(train_dataset)}"
print(msg)
# else:
# train_dataset = dataset
# Shuffling
if training_args.eval_steps is None and training_args.evaluation_strategy == "no":
train_dataset = train_dataset.shuffle(seed=training_args.seed)
eval_dataset = None
else:
print("Splitting dataset")
split_dataset = train_dataset.train_test_split(
test_size=args.eval_dataset_size,
shuffle=True,
seed=training_args.seed,
)
train_dataset = split_dataset["train"]
eval_dataset = split_dataset["test"]
state = get_model_context(
model_key,
model_name_or_path,
tokenization_context,
inference_mode=False,
use_flash_attention=args.use_flash_attention,
attention_dropout=model_args.attention_dropout,
residual_dropout=model_args.residual_dropout,
embedding_dropout=model_args.embedding_dropout,
)
if "codeqwen" in model_key.lower():
print(f"Hack for {model_key}")
state.model.generation_config.do_sample = True
print("Parallel mode:", training_args.parallel_mode)
data_collator = get_data_collator(
model_args.model_key, args, state.tokenization_context.pad_token_id
)
# neftune_noise_alpha
trainer = Trainer(
model=state.model,
args=training_args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
data_collator=data_collator,
# eval_dataset=small_eval_dataset,
# compute_metrics=compute_metrics,
)
# NOTE: the checkpoint will override the initialized model
trainer.train(resume_from_checkpoint=training_args.resume_from_checkpoint)
trainer.save_state()
trainer.save_model(training_args.output_dir)
state.tokenization_context.tokenizer.chat_template = CHAT_TEMPLATE
state.tokenization_context.tokenizer.save_pretrained(training_args.output_dir)
if __name__ == "__main__":
train()
selfcodealign-selfcodealign/src/star_align/utils.py 0000664 0000000 0000000 00000017441 14637551746 0023127 0 ustar 00root root 0000000 0000000 import asyncio
import hashlib
import json
import os
import time
from pathlib import Path
from typing import Any, Iterable, Literal, Mapping, Sequence, TypeVar
import openai
import tenacity
import tiktoken
N_CORES = 1 if (count := os.cpu_count()) is None or count == 0 else count // 2
def read_jsonl(path: str | Path) -> list[Any]:
"""Read lines of JSON from a file (including '\n')."""
with Path(path).open("r") as f:
return [json.loads(line) for line in f]
def write_jsonl(path: str | Path, data: Sequence[Mapping], mode: str = "w"):
# cannot use `dict` here as it is invariant
with Path(path).open(mode) as f:
for item in data:
f.write(json.dumps(item) + "\n")
_T = TypeVar("_T")
def chunked(seq: Sequence[_T], n: int) -> Iterable[Sequence[_T]]:
"""Yield successive n-sized chunks from seq."""
return (seq[i : i + n] for i in range(0, len(seq), n))
def retry(errors: Any, max_attempts: int = 5):
return tenacity.retry(
retry=tenacity.retry_if_exception_type(errors),
wait=tenacity.wait_exponential(multiplier=1, min=5, max=20),
stop=tenacity.stop_after_attempt(max_attempts),
before_sleep=print,
)
ERRORS = (
openai.RateLimitError,
openai.APIError,
openai.APIConnectionError,
openai.InternalServerError,
)
class OpenAIClient:
def __init__(self):
self.client = openai.OpenAI()
self.async_client = openai.AsyncClient()
@retry(ERRORS)
def chat_completions_with_backoff(self, *args, **kwargs):
return self.client.chat.completions.create(*args, **kwargs)
@retry(ERRORS)
def completions_with_backoff(self, *args, **kwargs):
return self.client.completions.create(*args, **kwargs)
@retry(ERRORS)
async def chat_completions_with_backoff_async(self, *args, **kwargs):
return await self.async_client.chat.completions.create(*args, **kwargs)
@retry(ERRORS)
async def completions_with_backoff_async(self, *args, **kwargs):
return await self.async_client.completions.create(*args, **kwargs)
async def delayed_request(
self,
request: dict[str, Any],
mode: Literal["chat", "completion"],
delay: float | None,
):
"""Prevent quantized rate limit:
https://help.openai.com/en/articles/6891753-rate-limit-advice"""
if delay is not None:
# synchronized sleep
time.sleep(delay)
if mode == "chat":
func = self.chat_completions_with_backoff_async
else:
func = self.completions_with_backoff_async
return await func(**request)
async def dispatch_chat_completions(
self,
requests: list[dict[str, Any]],
delay: float | None = None,
):
"""Dispatch chat completions requests asynchronously.
Args:
requests: a list of API argument names to values.
delay: interval between requests.
"""
tasks = [self.delayed_request(request, "chat", delay) for request in requests]
return await asyncio.gather(*tasks, return_exceptions=True)
async def dispatch_completions(
self,
requests: list[dict[str, Any]],
delay: float | None = None,
):
"""Dispatch completions requests asynchronously.
Args:
requests: a list of API argument names to values.
delay: interval between requests.
"""
tasks = [
self.delayed_request(request, "completion", delay) for request in requests
]
return await asyncio.gather(*tasks, return_exceptions=True)
# https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
def num_tokens_from_string(string: str, model: str) -> int:
"""Returns the number of tokens in a text string."""
encoding = tiktoken.encoding_for_model(model)
# encoding = tiktoken.get_encoding(encoding_name)
num_tokens = len(encoding.encode(string, disallowed_special=()))
return num_tokens
def timestamp() -> str:
return time.strftime("%Y%m%d_%H%M%S")
def compute_fingerprint(*args: Any, hash_length: int | None = None) -> str:
combined = "".join(map(str, args))
content = hashlib.sha256(combined.encode()).hexdigest()
if hash_length is not None:
content = content[:hash_length]
return content
def find_code_blocks(response: str, tag: str | None = None) -> list[str]:
"""Find all enclosed code blocks in the response, optionally filtering by language tag."""
all_indices = find_codeblock_indices(response, tag)
return [response[start:end].strip() for start, end in all_indices]
def find_codeblock_indices(
response: str, tag: str | None = None
) -> list[tuple[int, int]]:
"""Find all enclosed code blocks in the response, optionally filtering by language tag."""
all_indices: list[tuple[int, int]] = []
search_start = (
0 # Variable to keep track of where to start searching for the next code block
)
while "```" in response[search_start:]:
# Find the start of the code block (excluding the backticks)
code_start_index = response.find("```", search_start) + 3
# Find the end of the language tag line (or the start of the code if no tag line)
code_start_endline = response.find("\n", code_start_index)
if code_start_endline == -1: # Handle case where there's no newline after ```
code_start_endline = code_start_index
# Extract the language tag (if any)
extracted_tag = response[code_start_index:code_start_endline].strip()
# Adjust the start index if a language tag is found
if extracted_tag:
actual_code_start = code_start_endline + 1
else:
actual_code_start = code_start_index
# Find the end of the code block
code_end_index = response.find("```", actual_code_start)
if code_end_index == -1:
break # Exit if there's no closing ```
# Extract the code
# code = response[actual_code_start:code_end_index].strip()
# Check if the extracted code block matches the requested language tag (if any)
if tag is None or extracted_tag.lower() == tag.lower():
all_indices.append((actual_code_start, code_end_index))
# Update the search_start to look for the next code block
search_start = code_end_index + 3
return all_indices
DEFAULT_TEMPLATE = """\
### Instruction
{instruction}
### Response
{response}"""
def is_base_model(tokenizer_name: str) -> bool:
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained(tokenizer_name)
return tokenizer.chat_template is None and "octocoder" not in tokenizer_name
OCTOCODER_CHAT_TEMPLATE = """\
{%- for message in messages %}
{%- if message['role'] == 'system' %}
{{ raise_exception('System messages are not allowed in this template.') }}
{%- else %}
{%- if message['role'] == 'user' %}
{{'Question: ' + message['content'] + '\n\n'}}
{%- else %}
{{'Answer: ' + message['content'] + '\n\n'}}
{%- endif %}
{%- endif %}
{%- endfor %}
{{'Question: '}}"""
def infer_prompt_template(tokenizer_name: str) -> str:
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained(tokenizer_name)
if "octocoder" in tokenizer_name:
tokenizer.chat_template = OCTOCODER_CHAT_TEMPLATE
if tokenizer.chat_template is not None:
template = tokenizer.apply_chat_template(
[
{"role": "user", "content": "{instruction}"},
{"role": "assistant", "content": "{response}"},
],
tokenize=False,
)
else:
template = DEFAULT_TEMPLATE
end_index = template.rindex("{response}") + len("{response}")
template = template[:end_index]
return template