Delete demo

demo/constants.py

@@ -1,81 +0,0 @@
-DND_HEADER = """
-<style>
-.header-gradient {
-    top: 40%;
-    bottom: 40%;
-    padding: 10px 0px;
-    font-weight: bold;
-    font-size: 40px;
-    font-family: Inter, Arial, Helvetica, sans-serif;
-    background: linear-gradient(to right, #67a102, #c0dc90);
-    -webkit-text-fill-color: transparent;
-    -webkit-background-clip: text;
-}
-
-.header-normal {
-    top: 40%;
-    bottom: 40%;
-    padding: 10px 0px;
-    font-weight: bold;
-    font-size: 40px;
-    font-family: Inter, Arial, Helvetica, sans-serif;
-}
-</style>
-
-<div align="center">
-    <span class="header-gradient"> Drag-and-Drop LLMs: Zero-Shot Prompt-to-Weights </span>
-</div>
-<p align="center">
-| <a href=""><b>Documentation</b></a> | <a href=""><b>Github</b></a> | <a href="https://arxiv.org/abs/2506.16406"><b>Paper </b> </a> | <a href="https://x.com/VictorKaiWang1/status/1935905121659240513"><b>Twitter/X</b> </a> |
-</p>"""
-
-DND_INTRODUCTION = """
-🚀 Welcome to the Drag-and-Drop LLMs: Zero-Shot Prompt-to-Weights! 
-
-> Drag-and-Drop LLMs: Zero-Shot Prompt-to-Weights is a zero-shot prompt-to-weights model that can generate a model from a prompt.
-
-- **Zero-Shot**: Drag-and-Drop LLMs: Zero-Shot Prompt-to-Weights can generate a model from a prompt without any training data.
-- **Prompt-to-Weights**: Drag-and-Drop LLMs: Zero-Shot Prompt-to-Weights can generate a model from a prompt.
-- **Easy-to-use**: Drag-and-Drop LLMs: Zero-Shot Prompt-to-Weights provides a unified interface for prompt-to-weights model generation.
-
-"""
-
-TASK_LIST = ["🧠 Commonsense Reasoning", "🔢 Math", "💻 Coding"]
-TASK_DATASET_LIST = {
-    "🧠 Commonsense Reasoning": ["ARC-c", "OBQA"],
-    "🔢 Math": ["GSM-8K"],
-    "💻 Coding": ["HumanEval"],
-}
-EXAMPLE_LIST = ["Example 1", "Example 2", "Example 3", "Example 4", "Example 5"]
-
-TASK_PATH_MAPPING = {
-    "🧠 Commonsense Reasoning": "common",
-    "🔢 Math": "math",
-    "💻 Coding": "coding",
-}
-DATASET_PATH_MAPPING = {
-    "ARC-c": "arc_c",
-    "OBQA": "obqa",
-    "GSM-8K": "gsm8k",
-    "HumanEval": "humaneval",
-}
-EXAMPLE_PATH_MAPPING = {
-    "Example 1": "1",
-    "Example 2": "2",
-    "Example 3": "3",
-    "Example 4": "4",
-    "Example 5": "5",
-}
-
-COLUMN_NAMES = ["Prompt", "Pass@1", "Pass@5", "Pass@10", "Correctness"]
-DATA_TITLE_TYPE = ['markdown', 'number', 'number', 'number', 'markdown']
-
-CITATION_BUTTON_LABEL = "NOTE: We only use preloaded samples. Copy the following snippet to cite these results"
-CITATION_BUTTON_TEXT = r"""
-@article{liang2025drag,
-  title={Drag-and-Drop LLMs: Zero-Shot Prompt-to-Weights},
-  author={Liang, Zhiyuan and Tang, Dongwen and Zhou, Yuhao and Zhao, Xuanlei and Shi, Mingjia and Zhao, Wangbo and Li, Zekai and Wang, Peihao and Sch{\"u}rholt, Konstantin and Borth, Damian and others},
-  journal={arXiv preprint arXiv:2506.16406},
-  year={2025}
-}
-"""

demo/data/coding/humaneval/csv/1.csv

@@ -1,2413 +0,0 @@
-prompt,pass@1,pass@5,pass@10
-"from typing import List
-
-
-def has_close_elements(numbers: List[float], threshold: float) -> bool:
-    """""" Check if in given list of numbers, are any two numbers closer to each other than
-    given threshold.
-    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
-    False
-    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
-    True
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"from typing import List
-
-
-def separate_paren_groups(paren_string: str) -> List[str]:
-    """""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
-    separate those group into separate strings and return the list of those.
-    Separate groups are balanced (each open brace is properly closed) and not nested within each other
-    Ignore any spaces in the input string.
-    >>> separate_paren_groups('( ) (( )) (( )( ))')
-    ['()', '(())', '(()())']
-    """"""
-",0.0,0.0,0.0
-"
-
-def truncate_number(number: float) -> float:
-    """""" Given a positive floating point number, it can be decomposed into
-    and integer part (largest integer smaller than given number) and decimals
-    (leftover part always smaller than 1).
-
-    Return the decimal part of the number.
-    >>> truncate_number(3.5)
-    0.5
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"from typing import List
-
-
-def below_zero(operations: List[int]) -> bool:
-    """""" You're given a list of deposit and withdrawal operations on a bank account that starts with
-    zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
-    at that point function should return True. Otherwise it should return False.
-    >>> below_zero([1, 2, 3])
-    False
-    >>> below_zero([1, 2, -4, 5])
-    True
-    """"""
-",1.0,1.0,1.0
-"from typing import List
-
-
-def mean_absolute_deviation(numbers: List[float]) -> float:
-    """""" For a given list of input numbers, calculate Mean Absolute Deviation
-    around the mean of this dataset.
-    Mean Absolute Deviation is the average absolute difference between each
-    element and a centerpoint (mean in this case):
-    MAD = average | x - x_mean |
-    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
-    1.0
-    """"""
-",1.0,1.0,1.0
-"from typing import List
-
-
-def intersperse(numbers: List[int], delimeter: int) -> List[int]:
-    """""" Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
-    >>> intersperse([], 4)
-    []
-    >>> intersperse([1, 2, 3], 4)
-    [1, 4, 2, 4, 3]
-    """"""
-",0.0,0.0,0.0
-"from typing import List
-
-
-def parse_nested_parens(paren_string: str) -> List[int]:
-    """""" Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
-    For each of the group, output the deepest level of nesting of parentheses.
-    E.g. (()()) has maximum two levels of nesting while ((())) has three.
-
-    >>> parse_nested_parens('(()()) ((())) () ((())()())')
-    [2, 3, 1, 3]
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"from typing import List
-
-
-def filter_by_substring(strings: List[str], substring: str) -> List[str]:
-    """""" Filter an input list of strings only for ones that contain given substring
-    >>> filter_by_substring([], 'a')
-    []
-    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
-    ['abc', 'bacd', 'array']
-    """"""
-",0.8999999999999999,1.0,1.0
-"from typing import List, Tuple
-
-
-def sum_product(numbers: List[int]) -> Tuple[int, int]:
-    """""" For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.
-    Empty sum should be equal to 0 and empty product should be equal to 1.
-    >>> sum_product([])
-    (0, 1)
-    >>> sum_product([1, 2, 3, 4])
-    (10, 24)
-    """"""
-",1.0,1.0,1.0
-"from typing import List, Tuple
-
-
-def rolling_max(numbers: List[int]) -> List[int]:
-    """""" From a given list of integers, generate a list of rolling maximum element found until given moment
-    in the sequence.
-    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
-    [1, 2, 3, 3, 3, 4, 4]
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-
-def is_palindrome(string: str) -> bool:
-    """""" Test if given string is a palindrome """"""
-    return string == string[::-1]
-
-
-def make_palindrome(string: str) -> str:
-    """""" Find the shortest palindrome that begins with a supplied string.
-    Algorithm idea is simple:
-    - Find the longest postfix of supplied string that is a palindrome.
-    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
-    >>> make_palindrome('')
-    ''
-    >>> make_palindrome('cat')
-    'catac'
-    >>> make_palindrome('cata')
-    'catac'
-    """"""
-",0.0,0.0,0.0
-"from typing import List
-
-
-def string_xor(a: str, b: str) -> str:
-    """""" Input are two strings a and b consisting only of 1s and 0s.
-    Perform binary XOR on these inputs and return result also as a string.
-    >>> string_xor('010', '110')
-    '100'
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"from typing import List, Optional
-
-
-def longest(strings: List[str]) -> Optional[str]:
-    """""" Out of list of strings, return the longest one. Return the first one in case of multiple
-    strings of the same length. Return None in case the input list is empty.
-    >>> longest([])
-
-    >>> longest(['a', 'b', 'c'])
-    'a'
-    >>> longest(['a', 'bb', 'ccc'])
-    'ccc'
-    """"""
-",1.0,1.0,1.0
-"
-
-def greatest_common_divisor(a: int, b: int) -> int:
-    """""" Return a greatest common divisor of two integers a and b
-    >>> greatest_common_divisor(3, 5)
-    1
-    >>> greatest_common_divisor(25, 15)
-    5
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"from typing import List
-
-
-def all_prefixes(string: str) -> List[str]:
-    """""" Return list of all prefixes from shortest to longest of the input string
-    >>> all_prefixes('abc')
-    ['a', 'ab', 'abc']
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-
-def string_sequence(n: int) -> str:
-    """""" Return a string containing space-delimited numbers starting from 0 upto n inclusive.
-    >>> string_sequence(0)
-    '0'
-    >>> string_sequence(5)
-    '0 1 2 3 4 5'
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-
-def count_distinct_characters(string: str) -> int:
-    """""" Given a string, find out how many distinct characters (regardless of case) does it consist of
-    >>> count_distinct_characters('xyzXYZ')
-    3
-    >>> count_distinct_characters('Jerry')
-    4
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"from typing import List
-
-
-def parse_music(music_string: str) -> List[int]:
-    """""" Input to this function is a string representing musical notes in a special ASCII format.
-    Your task is to parse this string and return list of integers corresponding to how many beats does each
-    not last.
-
-    Here is a legend:
-    'o' - whole note, lasts four beats
-    'o|' - half note, lasts two beats
-    '.|' - quater note, lasts one beat
-
-    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
-    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"
-
-def how_many_times(string: str, substring: str) -> int:
-    """""" Find how many times a given substring can be found in the original string. Count overlaping cases.
-    >>> how_many_times('', 'a')
-    0
-    >>> how_many_times('aaa', 'a')
-    3
-    >>> how_many_times('aaaa', 'aa')
-    3
-    """"""
-",0.7999999999999999,1.0,1.0
-"from typing import List
-
-
-def sort_numbers(numbers: str) -> str:
-    """""" Input is a space-delimited string of numberals from 'zero' to 'nine'.
-    Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
-    Return the string with numbers sorted from smallest to largest
-    >>> sort_numbers('three one five')
-    'one three five'
-    """"""
-",0.0,0.0,0.0
-"from typing import List, Tuple
-
-
-def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
-    """""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
-    other and return them in order (smaller number, larger number).
-    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
-    (2.0, 2.2)
-    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
-    (2.0, 2.0)
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"from typing import List
-
-
-def rescale_to_unit(numbers: List[float]) -> List[float]:
-    """""" Given list of numbers (of at least two elements), apply a linear transform to that list,
-    such that the smallest number will become 0 and the largest will become 1
-    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
-    [0.0, 0.25, 0.5, 0.75, 1.0]
-    """"""
-",0.75,0.9999355005159959,1.0
-"from typing import List, Any
-
-
-def filter_integers(values: List[Any]) -> List[int]:
-    """""" Filter given list of any python values only for integers
-    >>> filter_integers(['a', 3.14, 5])
-    [5]
-    >>> filter_integers([1, 2, 3, 'abc', {}, []])
-    [1, 2, 3]
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-
-def strlen(string: str) -> int:
-    """""" Return length of given string
-    >>> strlen('')
-    0
-    >>> strlen('abc')
-    3
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-
-def largest_divisor(n: int) -> int:
-    """""" For a given number n, find the largest number that divides n evenly, smaller than n
-    >>> largest_divisor(15)
-    5
-    """"""
-",0.0,0.0,0.0
-"from typing import List
-
-
-def factorize(n: int) -> List[int]:
-    """""" Return list of prime factors of given integer in the order from smallest to largest.
-    Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
-    Input number should be equal to the product of all factors
-    >>> factorize(8)
-    [2, 2, 2]
-    >>> factorize(25)
-    [5, 5]
-    >>> factorize(70)
-    [2, 5, 7]
-    """"""
-",1.0,1.0,1.0
-"from typing import List
-
-
-def remove_duplicates(numbers: List[int]) -> List[int]:
-    """""" From a list of integers, remove all elements that occur more than once.
-    Keep order of elements left the same as in the input.
-    >>> remove_duplicates([1, 2, 3, 2, 4])
-    [1, 3, 4]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-
-def flip_case(string: str) -> str:
-    """""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
-    >>> flip_case('Hello')
-    'hELLO'
-    """"""
-",0.7999999999999999,1.0,1.0
-"from typing import List
-
-
-def concatenate(strings: List[str]) -> str:
-    """""" Concatenate list of strings into a single string
-    >>> concatenate([])
-    ''
-    >>> concatenate(['a', 'b', 'c'])
-    'abc'
-    """"""
-",0.95,1.0,1.0
-"from typing import List
-
-
-def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
-    """""" Filter an input list of strings only for ones that start with a given prefix.
-    >>> filter_by_prefix([], 'a')
-    []
-    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
-    ['abc', 'array']
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-
-def get_positive(l: list):
-    """"""Return only positive numbers in the list.
-    >>> get_positive([-1, 2, -4, 5, 6])
-    [2, 5, 6]
-    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
-    [5, 3, 2, 3, 9, 123, 1]
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-
-def is_prime(n):
-    """"""Return true if a given number is prime, and false otherwise.
-    >>> is_prime(6)
-    False
-    >>> is_prime(101)
-    True
-    >>> is_prime(11)
-    True
-    >>> is_prime(13441)
-    True
-    >>> is_prime(61)
-    True
-    >>> is_prime(4)
-    False
-    >>> is_prime(1)
-    False
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"import math
-
-
-def poly(xs: list, x: float):
-    """"""
-    Evaluates polynomial with coefficients xs at point x.
-    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
-    """"""
-    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
-
-
-def find_zero(xs: list):
-    """""" xs are coefficients of a polynomial.
-    find_zero find x such that poly(x) = 0.
-    find_zero returns only only zero point, even if there are many.
-    Moreover, find_zero only takes list xs having even number of coefficients
-    and largest non zero coefficient as it guarantees
-    a solution.
-    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
-    -0.5
-    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
-    1.0
-    """"""
-",0.0,0.0,0.0
-"
-
-def sort_third(l: list):
-    """"""This function takes a list l and returns a list l' such that
-    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
-    to the values of the corresponding indicies of l, but sorted.
-    >>> sort_third([1, 2, 3])
-    [1, 2, 3]
-    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
-    [2, 6, 3, 4, 8, 9, 5]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-
-def unique(l: list):
-    """"""Return sorted unique elements in a list
-    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
-    [0, 2, 3, 5, 9, 123]
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-
-def max_element(l: list):
-    """"""Return maximum element in the list.
-    >>> max_element([1, 2, 3])
-    3
-    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
-    123
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-
-def fizz_buzz(n: int):
-    """"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
-    >>> fizz_buzz(50)
-    0
-    >>> fizz_buzz(78)
-    2
-    >>> fizz_buzz(79)
-    3
-    """"""
-",0.0,0.0,0.0
-"
-
-def sort_even(l: list):
-    """"""This function takes a list l and returns a list l' such that
-    l' is identical to l in the odd indicies, while its values at the even indicies are equal
-    to the values of the even indicies of l, but sorted.
-    >>> sort_even([1, 2, 3])
-    [1, 2, 3]
-    >>> sort_even([5, 6, 3, 4])
-    [3, 6, 5, 4]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-
-def encode_cyclic(s: str):
-    """"""
-    returns encoded string by cycling groups of three characters.
-    """"""
-    # split string to groups. Each of length 3.
-    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
-    # cycle elements in each group. Unless group has fewer elements than 3.
-    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
-    return """".join(groups)
-
-
-def decode_cyclic(s: str):
-    """"""
-    takes as input string encoded with encode_cyclic function. Returns decoded string.
-    """"""
-",0.0,0.0,0.0
-"
-
-def prime_fib(n: int):
-    """"""
-    prime_fib returns n-th number that is a Fibonacci number and it's also prime.
-    >>> prime_fib(1)
-    2
-    >>> prime_fib(2)
-    3
-    >>> prime_fib(3)
-    5
-    >>> prime_fib(4)
-    13
-    >>> prime_fib(5)
-    89
-    """"""
-",0.0,0.0,0.0
-"
-
-def triples_sum_to_zero(l: list):
-    """"""
-    triples_sum_to_zero takes a list of integers as an input.
-    it returns True if there are three distinct elements in the list that
-    sum to zero, and False otherwise.
-
-    >>> triples_sum_to_zero([1, 3, 5, 0])
-    False
-    >>> triples_sum_to_zero([1, 3, -2, 1])
-    True
-    >>> triples_sum_to_zero([1, 2, 3, 7])
-    False
-    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
-    True
-    >>> triples_sum_to_zero([1])
-    False
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-
-def car_race_collision(n: int):
-    """"""
-    Imagine a road that's a perfectly straight infinitely long line.
-    n cars are driving left to right;  simultaneously, a different set of n cars
-    are driving right to left.   The two sets of cars start out being very far from
-    each other.  All cars move in the same speed.  Two cars are said to collide
-    when a car that's moving left to right hits a car that's moving right to left.
-    However, the cars are infinitely sturdy and strong; as a result, they continue moving
-    in their trajectory as if they did not collide.
-
-    This function outputs the number of such collisions.
-    """"""
-",0.0,0.0,0.0
-"
-
-def incr_list(l: list):
-    """"""Return list with elements incremented by 1.
-    >>> incr_list([1, 2, 3])
-    [2, 3, 4]
-    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
-    [6, 4, 6, 3, 4, 4, 10, 1, 124]
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-
-def pairs_sum_to_zero(l):
-    """"""
-    pairs_sum_to_zero takes a list of integers as an input.
-    it returns True if there are two distinct elements in the list that
-    sum to zero, and False otherwise.
-    >>> pairs_sum_to_zero([1, 3, 5, 0])
-    False
-    >>> pairs_sum_to_zero([1, 3, -2, 1])
-    False
-    >>> pairs_sum_to_zero([1, 2, 3, 7])
-    False
-    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
-    True
-    >>> pairs_sum_to_zero([1])
-    False
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-
-def change_base(x: int, base: int):
-    """"""Change numerical base of input number x to base.
-    return string representation after the conversion.
-    base numbers are less than 10.
-    >>> change_base(8, 3)
-    '22'
-    >>> change_base(8, 2)
-    '1000'
-    >>> change_base(7, 2)
-    '111'
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-
-def triangle_area(a, h):
-    """"""Given length of a side and high return area for a triangle.
-    >>> triangle_area(5, 3)
-    7.5
-    """"""
-",1.0,1.0,1.0
-"
-
-def fib4(n: int):
-    """"""The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
-    fib4(0) -> 0
-    fib4(1) -> 0
-    fib4(2) -> 2
-    fib4(3) -> 0
-    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
-    Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
-    >>> fib4(5)
-    4
-    >>> fib4(6)
-    8
-    >>> fib4(7)
-    14
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-
-def median(l: list):
-    """"""Return median of elements in the list l.
-    >>> median([3, 1, 2, 4, 5])
-    3
-    >>> median([-10, 4, 6, 1000, 10, 20])
-    15.0
-    """"""
-",0.85,1.0,1.0
-"
-
-def is_palindrome(text: str):
-    """"""
-    Checks if given string is a palindrome
-    >>> is_palindrome('')
-    True
-    >>> is_palindrome('aba')
-    True
-    >>> is_palindrome('aaaaa')
-    True
-    >>> is_palindrome('zbcd')
-    False
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-
-def modp(n: int, p: int):
-    """"""Return 2^n modulo p (be aware of numerics).
-    >>> modp(3, 5)
-    3
-    >>> modp(1101, 101)
-    2
-    >>> modp(0, 101)
-    1
-    >>> modp(3, 11)
-    8
-    >>> modp(100, 101)
-    1
-    """"""
-",0.0,0.0,0.0
-"
-
-def encode_shift(s: str):
-    """"""
-    returns encoded string by shifting every character by 5 in the alphabet.
-    """"""
-    return """".join([chr(((ord(ch) + 5 - ord(""a"")) % 26) + ord(""a"")) for ch in s])
-
-
-def decode_shift(s: str):
-    """"""
-    takes as input string encoded with encode_shift function. Returns decoded string.
-    """"""
-",1.0,1.0,1.0
-"
-
-def remove_vowels(text):
-    """"""
-    remove_vowels is a function that takes string and returns string without vowels.
-    >>> remove_vowels('')
-    ''
-    >>> remove_vowels(""abcdef\nghijklm"")
-    'bcdf\nghjklm'
-    >>> remove_vowels('abcdef')
-    'bcdf'
-    >>> remove_vowels('aaaaa')
-    ''
-    >>> remove_vowels('aaBAA')
-    'B'
-    >>> remove_vowels('zbcd')
-    'zbcd'
-    """"""
-",0.7999999999999999,1.0,1.0
-"
-
-def below_threshold(l: list, t: int):
-    """"""Return True if all numbers in the list l are below threshold t.
-    >>> below_threshold([1, 2, 4, 10], 100)
-    True
-    >>> below_threshold([1, 20, 4, 10], 5)
-    False
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-
-def add(x: int, y: int):
-    """"""Add two numbers x and y
-    >>> add(2, 3)
-    5
-    >>> add(5, 7)
-    12
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-
-def same_chars(s0: str, s1: str):
-    """"""
-    Check if two words have the same characters.
-    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
-    True
-    >>> same_chars('abcd', 'dddddddabc')
-    True
-    >>> same_chars('dddddddabc', 'abcd')
-    True
-    >>> same_chars('eabcd', 'dddddddabc')
-    False
-    >>> same_chars('abcd', 'dddddddabce')
-    False
-    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
-    False
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-
-def fib(n: int):
-    """"""Return n-th Fibonacci number.
-    >>> fib(10)
-    55
-    >>> fib(1)
-    1
-    >>> fib(8)
-    21
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-
-def correct_bracketing(brackets: str):
-    """""" brackets is a string of ""<"" and "">"".
-    return True if every opening bracket has a corresponding closing bracket.
-
-    >>> correct_bracketing(""<"")
-    False
-    >>> correct_bracketing(""<>"")
-    True
-    >>> correct_bracketing(""<<><>>"")
-    True
-    >>> correct_bracketing(""><<>"")
-    False
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"
-
-def monotonic(l: list):
-    """"""Return True is list elements are monotonically increasing or decreasing.
-    >>> monotonic([1, 2, 4, 20])
-    True
-    >>> monotonic([1, 20, 4, 10])
-    False
-    >>> monotonic([4, 1, 0, -10])
-    True
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-
-def common(l1: list, l2: list):
-    """"""Return sorted unique common elements for two lists.
-    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
-    [1, 5, 653]
-    >>> common([5, 3, 2, 8], [3, 2])
-    [2, 3]
-
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-
-def largest_prime_factor(n: int):
-    """"""Return the largest prime factor of n. Assume n > 1 and is not a prime.
-    >>> largest_prime_factor(13195)
-    29
-    >>> largest_prime_factor(2048)
-    2
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-
-def sum_to_n(n: int):
-    """"""sum_to_n is a function that sums numbers from 1 to n.
-    >>> sum_to_n(30)
-    465
-    >>> sum_to_n(100)
-    5050
-    >>> sum_to_n(5)
-    15
-    >>> sum_to_n(10)
-    55
-    >>> sum_to_n(1)
-    1
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"
-
-def correct_bracketing(brackets: str):
-    """""" brackets is a string of ""("" and "")"".
-    return True if every opening bracket has a corresponding closing bracket.
-
-    >>> correct_bracketing(""("")
-    False
-    >>> correct_bracketing(""()"")
-    True
-    >>> correct_bracketing(""(()())"")
-    True
-    >>> correct_bracketing("")(()"")
-    False
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-
-def derivative(xs: list):
-    """""" xs represent coefficients of a polynomial.
-    xs[0] + xs[1] * x + xs[2] * x^2 + ....
-     Return derivative of this polynomial in the same form.
-    >>> derivative([3, 1, 2, 4, 5])
-    [1, 4, 12, 20]
-    >>> derivative([1, 2, 3])
-    [2, 6]
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-
-def fibfib(n: int):
-    """"""The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
-    fibfib(0) == 0
-    fibfib(1) == 0
-    fibfib(2) == 1
-    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
-    Please write a function to efficiently compute the n-th element of the fibfib number sequence.
-    >>> fibfib(1)
-    0
-    >>> fibfib(5)
-    4
-    >>> fibfib(8)
-    24
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-FIX = """"""
-Add more test cases.
-""""""
-
-def vowels_count(s):
-    """"""Write a function vowels_count which takes a string representing
-    a word as input and returns the number of vowels in the string.
-    Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
-    vowel, but only when it is at the end of the given word.
-
-    Example:
-    >>> vowels_count(""abcde"")
-    2
-    >>> vowels_count(""ACEDY"")
-    3
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-def circular_shift(x, shift):
-    """"""Circular shift the digits of the integer x, shift the digits right by shift
-    and return the result as a string.
-    If shift > number of digits, return digits reversed.
-    >>> circular_shift(12, 1)
-    ""21""
-    >>> circular_shift(12, 2)
-    ""12""
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def digitSum(s):
-    """"""Task
-    Write a function that takes a string as input and returns the sum of the upper characters only'
-    ASCII codes.
-
-    Examples:
-        digitSum("""") => 0
-        digitSum(""abAB"") => 131
-        digitSum(""abcCd"") => 67
-        digitSum(""helloE"") => 69
-        digitSum(""woArBld"") => 131
-        digitSum(""aAaaaXa"") => 153
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-def fruit_distribution(s,n):
-    """"""
-    In this task, you will be given a string that represents a number of apples and oranges 
-    that are distributed in a basket of fruit this basket contains 
-    apples, oranges, and mango fruits. Given the string that represents the total number of 
-    the oranges and apples and an integer that represent the total number of the fruits 
-    in the basket return the number of the mango fruits in the basket.
-    for examble:
-    fruit_distribution(""5 apples and 6 oranges"", 19) ->19 - 5 - 6 = 8
-    fruit_distribution(""0 apples and 1 oranges"",3) -> 3 - 0 - 1 = 2
-    fruit_distribution(""2 apples and 3 oranges"", 100) -> 100 - 2 - 3 = 95
-    fruit_distribution(""100 apples and 1 oranges"",120) -> 120 - 100 - 1 = 19
-    """"""
-",0.0,0.0,0.0
-"
-def pluck(arr):
-    """"""
-    ""Given an array representing a branch of a tree that has non-negative integer nodes
-    your task is to pluck one of the nodes and return it.
-    The plucked node should be the node with the smallest even value.
-    If multiple nodes with the same smallest even value are found return the node that has smallest index.
-
-    The plucked node should be returned in a list, [ smalest_value, its index ],
-    If there are no even values or the given array is empty, return [].
-
-    Example 1:
-        Input: [4,2,3]
-        Output: [2, 1]
-        Explanation: 2 has the smallest even value, and 2 has the smallest index.
-
-    Example 2:
-        Input: [1,2,3]
-        Output: [2, 1]
-        Explanation: 2 has the smallest even value, and 2 has the smallest index. 
-
-    Example 3:
-        Input: []
-        Output: []
-    
-    Example 4:
-        Input: [5, 0, 3, 0, 4, 2]
-        Output: [0, 1]
-        Explanation: 0 is the smallest value, but  there are two zeros,
-                     so we will choose the first zero, which has the smallest index.
-
-    Constraints:
-        * 1 <= nodes.length <= 10000
-        * 0 <= node.value
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-def search(lst):
-    '''
-    You are given a non-empty list of positive integers. Return the greatest integer that is greater than 
-    zero, and has a frequency greater than or equal to the value of the integer itself. 
-    The frequency of an integer is the number of times it appears in the list.
-    If no such a value exist, return -1.
-    Examples:
-        search([4, 1, 2, 2, 3, 1]) == 2
-        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
-        search([5, 5, 4, 4, 4]) == -1
-    '''
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def strange_sort_list(lst):
-    '''
-    Given list of integers, return list in strange order.
-    Strange sorting, is when you start with the minimum value,
-    then maximum of the remaining integers, then minimum and so on.
-
-    Examples:
-    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
-    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
-    strange_sort_list([]) == []
-    '''
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def triangle_area(a, b, c):
-    '''
-    Given the lengths of the three sides of a triangle. Return the area of
-    the triangle rounded to 2 decimal points if the three sides form a valid triangle. 
-    Otherwise return -1
-    Three sides make a valid triangle when the sum of any two sides is greater 
-    than the third side.
-    Example:
-    triangle_area(3, 4, 5) == 6.00
-    triangle_area(1, 2, 10) == -1
-    '''
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def will_it_fly(q,w):
-    '''
-    Write a function that returns True if the object q will fly, and False otherwise.
-    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.
-
-    Example:
-    will_it_fly([1, 2], 5) ➞ False 
-    # 1+2 is less than the maximum possible weight, but it's unbalanced.
-
-    will_it_fly([3, 2, 3], 1) ➞ False
-    # it's balanced, but 3+2+3 is more than the maximum possible weight.
-
-    will_it_fly([3, 2, 3], 9) ➞ True
-    # 3+2+3 is less than the maximum possible weight, and it's balanced.
-
-    will_it_fly([3], 5) ➞ True
-    # 3 is less than the maximum possible weight, and it's balanced.
-    '''
-",0.5499999999999998,0.9918730650154799,1.0
-"
-def smallest_change(arr):
-    """"""
-    Given an array arr of integers, find the minimum number of elements that
-    need to be changed to make the array palindromic. A palindromic array is an array that
-    is read the same backwards and forwards. In one change, you can change one element to any other element.
-
-    For example:
-    smallest_change([1,2,3,5,4,7,9,6]) == 4
-    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
-    smallest_change([1, 2, 3, 2, 1]) == 0
-    """"""
-",0.0,0.0,0.0
-"
-def total_match(lst1, lst2):
-    '''
-    Write a function that accepts two lists of strings and returns the list that has 
-    total number of chars in the all strings of the list less than the other list.
-
-    if the two lists have the same number of chars, return the first list.
-
-    Examples
-    total_match([], []) ➞ []
-    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
-    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
-    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
-    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
-    '''
-",0.0,0.0,0.0
-"
-def is_multiply_prime(a):
-    """"""Write a function that returns true if the given number is the multiplication of 3 prime numbers
-    and false otherwise.
-    Knowing that (a) is less then 100. 
-    Example:
-    is_multiply_prime(30) == True
-    30 = 2 * 3 * 5
-    """"""
-",0.0,0.0,0.0
-"
-def is_simple_power(x, n):
-    """"""Your task is to write a function that returns true if a number x is a simple
-    power of n and false in other cases.
-    x is a simple power of n if n**int=x
-    For example:
-    is_simple_power(1, 4) => true
-    is_simple_power(2, 2) => true
-    is_simple_power(8, 2) => true
-    is_simple_power(3, 2) => false
-    is_simple_power(3, 1) => false
-    is_simple_power(5, 3) => false
-    """"""
-",0.0,0.0,0.0
-"
-def iscube(a):
-    '''
-    Write a function that takes an integer a and returns True 
-    if this ingeger is a cube of some integer number.
-    Note: you may assume the input is always valid.
-    Examples:
-    iscube(1) ==> True
-    iscube(2) ==> False
-    iscube(-1) ==> True
-    iscube(64) ==> True
-    iscube(0) ==> True
-    iscube(180) ==> False
-    '''
-",0.0,0.0,0.0
-"
-def hex_key(num):
-    """"""You have been tasked to write a function that receives 
-    a hexadecimal number as a string and counts the number of hexadecimal 
-    digits that are primes (prime number, or a prime, is a natural number 
-    greater than 1 that is not a product of two smaller natural numbers).
-    Hexadecimal digits are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
-    Prime numbers are 2, 3, 5, 7, 11, 13, 17,...
-    So you have to determine a number of the following digits: 2, 3, 5, 7, 
-    B (=decimal 11), D (=decimal 13).
-    Note: you may assume the input is always correct or empty string, 
-    and symbols A,B,C,D,E,F are always uppercase.
-    Examples:
-    For num = ""AB"" the output should be 1.
-    For num = ""1077E"" the output should be 2.
-    For num = ""ABED1A33"" the output should be 4.
-    For num = ""123456789ABCDEF0"" the output should be 6.
-    For num = ""2020"" the output should be 2.
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-def decimal_to_binary(decimal):
-    """"""You will be given a number in decimal form and your task is to convert it to
-    binary format. The function should return a string, with each character representing a binary
-    number. Each character in the string will be '0' or '1'.
-
-    There will be an extra couple of characters 'db' at the beginning and at the end of the string.
-    The extra characters are there to help with the format.
-
-    Examples:
-    decimal_to_binary(15)   # returns ""db1111db""
-    decimal_to_binary(32)   # returns ""db100000db""
-    """"""
-",0.85,1.0,1.0
-"
-def is_happy(s):
-    """"""You are given a string s.
-    Your task is to check if the string is happy or not.
-    A string is happy if its length is at least 3 and every 3 consecutive letters are distinct
-    For example:
-    is_happy(a) => False
-    is_happy(aa) => False
-    is_happy(abcd) => True
-    is_happy(aabb) => False
-    is_happy(adb) => True
-    is_happy(xyy) => False
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def numerical_letter_grade(grades):
-    """"""It is the last week of the semester and the teacher has to give the grades
-    to students. The teacher has been making her own algorithm for grading.
-    The only problem is, she has lost the code she used for grading.
-    She has given you a list of GPAs for some students and you have to write 
-    a function that can output a list of letter grades using the following table:
-             GPA       |    Letter grade
-              4.0                A+
-            > 3.7                A 
-            > 3.3                A- 
-            > 3.0                B+
-            > 2.7                B 
-            > 2.3                B-
-            > 2.0                C+
-            > 1.7                C
-            > 1.3                C-
-            > 1.0                D+ 
-            > 0.7                D 
-            > 0.0                D-
-              0.0                E
-    
-
-    Example:
-    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def prime_length(string):
-    """"""Write a function that takes a string and returns True if the string
-    length is a prime number or False otherwise
-    Examples
-    prime_length('Hello') == True
-    prime_length('abcdcba') == True
-    prime_length('kittens') == True
-    prime_length('orange') == False
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def starts_one_ends(n):
-    """"""
-    Given a positive integer n, return the count of the numbers of n-digit
-    positive integers that start or end with 1.
-    """"""
-",0.0,0.0,0.0
-"
-def solve(N):
-    """"""Given a positive integer N, return the total sum of its digits in binary.
-    
-    Example
-        For N = 1000, the sum of digits will be 1 the output should be ""1"".
-        For N = 150, the sum of digits will be 6 the output should be ""110"".
-        For N = 147, the sum of digits will be 12 the output should be ""1100"".
-    
-    Variables:
-        @N integer
-             Constraints: 0 ≤ N ≤ 10000.
-    Output:
-         a string of binary number
-    """"""
-",0.0,0.0,0.0
-"
-def add(lst):
-    """"""Given a non-empty list of integers lst. add the even elements that are at odd indices..
-
-
-    Examples:
-        add([4, 2, 6, 7]) ==> 2 
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"
-def anti_shuffle(s):
-    """"""
-    Write a function that takes a string and returns an ordered version of it.
-    Ordered version of string, is a string where all words (separated by space)
-    are replaced by a new word where all the characters arranged in
-    ascending order based on ascii value.
-    Note: You should keep the order of words and blank spaces in the sentence.
-
-    For example:
-    anti_shuffle('Hi') returns 'Hi'
-    anti_shuffle('hello') returns 'ehllo'
-    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"
-def get_row(lst, x):
-    """"""
-    You are given a 2 dimensional data, as a nested lists,
-    which is similar to matrix, however, unlike matrices,
-    each row may contain a different number of columns.
-    Given lst, and integer x, find integers x in the list,
-    and return list of tuples, [(x1, y1), (x2, y2) ...] such that
-    each tuple is a coordinate - (row, columns), starting with 0.
-    Sort coordinates initially by rows in ascending order.
-    Also, sort coordinates of the row by columns in descending order.
-    
-    Examples:
-    get_row([
-      [1,2,3,4,5,6],
-      [1,2,3,4,1,6],
-      [1,2,3,4,5,1]
-    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
-    get_row([], 1) == []
-    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def sort_array(array):
-    """"""
-    Given an array of non-negative integers, return a copy of the given array after sorting,
-    you will sort the given array in ascending order if the sum( first index value, last index value) is odd,
-    or sort it in descending order if the sum( first index value, last index value) is even.
-
-    Note:
-    * don't change the given array.
-
-    Examples:
-    * sort_array([]) => []
-    * sort_array([5]) => [5]
-    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
-    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def encrypt(s):
-    """"""Create a function encrypt that takes a string as an argument and
-    returns a string encrypted with the alphabet being rotated. 
-    The alphabet should be rotated in a manner such that the letters 
-    shift down by two multiplied to two places.
-    For example:
-    encrypt('hi') returns 'lm'
-    encrypt('asdfghjkl') returns 'ewhjklnop'
-    encrypt('gf') returns 'kj'
-    encrypt('et') returns 'ix'
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def next_smallest(lst):
-    """"""
-    You are given a list of integers.
-    Write a function next_smallest() that returns the 2nd smallest element of the list.
-    Return None if there is no such element.
-    
-    next_smallest([1, 2, 3, 4, 5]) == 2
-    next_smallest([5, 1, 4, 3, 2]) == 2
-    next_smallest([]) == None
-    next_smallest([1, 1]) == None
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-def is_bored(S):
-    """"""
-    You'll be given a string of words, and your task is to count the number
-    of boredoms. A boredom is a sentence that starts with the word ""I"".
-    Sentences are delimited by '.', '?' or '!'.
-   
-    For example:
-    >>> is_bored(""Hello world"")
-    0
-    >>> is_bored(""The sky is blue. The sun is shining. I love this weather"")
-    1
-    """"""
-",0.0,0.0,0.0
-"
-def any_int(x, y, z):
-    '''
-    Create a function that takes 3 numbers.
-    Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
-    Returns false in any other cases.
-    
-    Examples
-    any_int(5, 2, 7) ➞ True
-    
-    any_int(3, 2, 2) ➞ False
-
-    any_int(3, -2, 1) ➞ True
-    
-    any_int(3.6, -2.2, 2) ➞ False
-  
-
-    
-    '''
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-def encode(message):
-    """"""
-    Write a function that takes a message, and encodes in such a 
-    way that it swaps case of all letters, replaces all vowels in 
-    the message with the letter that appears 2 places ahead of that 
-    vowel in the english alphabet. 
-    Assume only letters. 
-    
-    Examples:
-    >>> encode('test')
-    'TGST'
-    >>> encode('This is a message')
-    'tHKS KS C MGSSCGG'
-    """"""
-",0.0,0.0,0.0
-"
-
-def skjkasdkd(lst):
-    """"""You are given a list of integers.
-    You need to find the largest prime value and return the sum of its digits.
-
-    Examples:
-    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
-    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
-    For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13
-    For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11
-    For lst = [0,81,12,3,1,21] the output should be 3
-    For lst = [0,8,1,2,1,7] the output should be 7
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-def check_dict_case(dict):
-    """"""
-    Given a dictionary, return True if all keys are strings in lower 
-    case or all keys are strings in upper case, else return False.
-    The function should return False is the given dictionary is empty.
-    Examples:
-    check_dict_case({""a"":""apple"", ""b"":""banana""}) should return True.
-    check_dict_case({""a"":""apple"", ""A"":""banana"", ""B"":""banana""}) should return False.
-    check_dict_case({""a"":""apple"", 8:""banana"", ""a"":""apple""}) should return False.
-    check_dict_case({""Name"":""John"", ""Age"":""36"", ""City"":""Houston""}) should return False.
-    check_dict_case({""STATE"":""NC"", ""ZIP"":""12345"" }) should return True.
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def count_up_to(n):
-    """"""Implement a function that takes an non-negative integer and returns an array of the first n
-    integers that are prime numbers and less than n.
-    for example:
-    count_up_to(5) => [2,3]
-    count_up_to(11) => [2,3,5,7]
-    count_up_to(0) => []
-    count_up_to(20) => [2,3,5,7,11,13,17,19]
-    count_up_to(1) => []
-    count_up_to(18) => [2,3,5,7,11,13,17]
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-def multiply(a, b):
-    """"""Complete the function that takes two integers and returns 
-    the product of their unit digits.
-    Assume the input is always valid.
-    Examples:
-    multiply(148, 412) should return 16.
-    multiply(19, 28) should return 72.
-    multiply(2020, 1851) should return 0.
-    multiply(14,-15) should return 20.
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def count_upper(s):
-    """"""
-    Given a string s, count the number of uppercase vowels in even indices.
-    
-    For example:
-    count_upper('aBCdEf') returns 1
-    count_upper('abcdefg') returns 0
-    count_upper('dBBE') returns 0
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def closest_integer(value):
-    '''
-    Create a function that takes a value (string) representing a number
-    and returns the closest integer to it. If the number is equidistant
-    from two integers, round it away from zero.
-
-    Examples
-    >>> closest_integer(""10"")
-    10
-    >>> closest_integer(""15.3"")
-    15
-
-    Note:
-    Rounding away from zero means that if the given number is equidistant
-    from two integers, the one you should return is the one that is the
-    farthest from zero. For example closest_integer(""14.5"") should
-    return 15 and closest_integer(""-14.5"") should return -15.
-    '''
-",0.0,0.0,0.0
-"
-def make_a_pile(n):
-    """"""
-    Given a positive integer n, you have to make a pile of n levels of stones.
-    The first level has n stones.
-    The number of stones in the next level is:
-        - the next odd number if n is odd.
-        - the next even number if n is even.
-    Return the number of stones in each level in a list, where element at index
-    i represents the number of stones in the level (i+1).
-
-    Examples:
-    >>> make_a_pile(3)
-    [3, 5, 7]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def words_string(s):
-    """"""
-    You will be given a string of words separated by commas or spaces. Your task is
-    to split the string into words and return an array of the words.
-    
-    For example:
-    words_string(""Hi, my name is John"") == [""Hi"", ""my"", ""name"", ""is"", ""John""]
-    words_string(""One, two, three, four, five, six"") == [""One"", ""two"", ""three"", ""four"", ""five"", ""six""]
-    """"""
-",0.0,0.0,0.0
-"
-def choose_num(x, y):
-    """"""This function takes two positive numbers x and y and returns the
-    biggest even integer number that is in the range [x, y] inclusive. If 
-    there's no such number, then the function should return -1.
-
-    For example:
-    choose_num(12, 15) = 14
-    choose_num(13, 12) = -1
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def rounded_avg(n, m):
-    """"""You are given two positive integers n and m, and your task is to compute the
-    average of the integers from n through m (including n and m). 
-    Round the answer to the nearest integer and convert that to binary.
-    If n is greater than m, return -1.
-    Example:
-    rounded_avg(1, 5) => ""0b11""
-    rounded_avg(7, 5) => -1
-    rounded_avg(10, 20) => ""0b1111""
-    rounded_avg(20, 33) => ""0b11010""
-    """"""
-",0.0,0.0,0.0
-"
-def unique_digits(x):
-    """"""Given a list of positive integers x. return a sorted list of all 
-    elements that hasn't any even digit.
-
-    Note: Returned list should be sorted in increasing order.
-    
-    For example:
-    >>> unique_digits([15, 33, 1422, 1])
-    [1, 15, 33]
-    >>> unique_digits([152, 323, 1422, 10])
-    []
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def by_length(arr):
-    """"""
-    Given an array of integers, sort the integers that are between 1 and 9 inclusive,
-    reverse the resulting array, and then replace each digit by its corresponding name from
-    ""One"", ""Two"", ""Three"", ""Four"", ""Five"", ""Six"", ""Seven"", ""Eight"", ""Nine"".
-
-    For example:
-      arr = [2, 1, 1, 4, 5, 8, 2, 3]   
-            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8] 
-            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
-      return [""Eight"", ""Five"", ""Four"", ""Three"", ""Two"", ""Two"", ""One"", ""One""]
-    
-      If the array is empty, return an empty array:
-      arr = []
-      return []
-    
-      If the array has any strange number ignore it:
-      arr = [1, -1 , 55] 
-            -> sort arr -> [-1, 1, 55]
-            -> reverse arr -> [55, 1, -1]
-      return = ['One']
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def f(n):
-    """""" Implement the function f that takes n as a parameter,
-    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
-    or the sum of numbers from 1 to i otherwise.
-    i starts from 1.
-    the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... * i).
-    Example:
-    f(5) == [1, 2, 6, 24, 15]
-    """"""
-",0.0,0.0,0.0
-"
-def even_odd_palindrome(n):
-    """"""
-    Given a positive integer n, return a tuple that has the number of even and odd
-    integer palindromes that fall within the range(1, n), inclusive.
-
-    Example 1:
-
-        Input: 3
-        Output: (1, 2)
-        Explanation:
-        Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.
-
-    Example 2:
-
-        Input: 12
-        Output: (4, 6)
-        Explanation:
-        Integer palindrome are 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. four of them are even, and 6 of them are odd.
-
-    Note:
-        1. 1 <= n <= 10^3
-        2. returned tuple has the number of even and odd integer palindromes respectively.
-    """"""
-",0.85,1.0,1.0
-"
-def count_nums(arr):
-    """"""
-    Write a function count_nums which takes an array of integers and returns
-    the number of elements which has a sum of digits > 0.
-    If a number is negative, then its first signed digit will be negative:
-    e.g. -123 has signed digits -1, 2, and 3.
-    >>> count_nums([]) == 0
-    >>> count_nums([-1, 11, -11]) == 1
-    >>> count_nums([1, 1, 2]) == 3
-    """"""
-",0.0,0.0,0.0
-"
-def move_one_ball(arr):
-    """"""We have an array 'arr' of N integers arr[1], arr[2], ..., arr[N].The
-    numbers in the array will be randomly ordered. Your task is to determine if
-    it is possible to get an array sorted in non-decreasing order by performing 
-    the following operation on the given array:
-        You are allowed to perform right shift operation any number of times.
-    
-    One right shift operation means shifting all elements of the array by one
-    position in the right direction. The last element of the array will be moved to
-    the starting position in the array i.e. 0th index. 
-
-    If it is possible to obtain the sorted array by performing the above operation
-    then return True else return False.
-    If the given array is empty then return True.
-
-    Note: The given list is guaranteed to have unique elements.
-
-    For Example:
-    
-    move_one_ball([3, 4, 5, 1, 2])==>True
-    Explanation: By performin 2 right shift operations, non-decreasing order can
-                 be achieved for the given array.
-    move_one_ball([3, 5, 4, 1, 2])==>False
-    Explanation:It is not possible to get non-decreasing order for the given
-                array by performing any number of right shift operations.
-                
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def exchange(lst1, lst2):
-    """"""In this problem, you will implement a function that takes two lists of numbers,
-    and determines whether it is possible to perform an exchange of elements
-    between them to make lst1 a list of only even numbers.
-    There is no limit on the number of exchanged elements between lst1 and lst2.
-    If it is possible to exchange elements between the lst1 and lst2 to make
-    all the elements of lst1 to be even, return ""YES"".
-    Otherwise, return ""NO"".
-    For example:
-    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => ""YES""
-    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => ""NO""
-    It is assumed that the input lists will be non-empty.
-    """"""
-",0.0,0.0,0.0
-"
-def histogram(test):
-    """"""Given a string representing a space separated lowercase letters, return a dictionary
-    of the letter with the most repetition and containing the corresponding count.
-    If several letters have the same occurrence, return all of them.
-    
-    Example:
-    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
-    histogram('a b b a') == {'a': 2, 'b': 2}
-    histogram('a b c a b') == {'a': 2, 'b': 2}
-    histogram('b b b b a') == {'b': 4}
-    histogram('') == {}
-
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def reverse_delete(s,c):
-    """"""Task
-    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
-    then check if the result string is palindrome.
-    A string is called palindrome if it reads the same backward as forward.
-    You should return a tuple containing the result string and True/False for the check.
-    Example
-    For s = ""abcde"", c = ""ae"", the result should be ('bcd',False)
-    For s = ""abcdef"", c = ""b""  the result should be ('acdef',False)
-    For s = ""abcdedcba"", c = ""ab"", the result should be ('cdedc',True)
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-def odd_count(lst):
-    """"""Given a list of strings, where each string consists of only digits, return a list.
-    Each element i of the output should be ""the number of odd elements in the
-    string i of the input."" where all the i's should be replaced by the number
-    of odd digits in the i'th string of the input.
-
-    >>> odd_count(['1234567'])
-    [""the number of odd elements 4n the str4ng 4 of the 4nput.""]
-    >>> odd_count(['3',""11111111""])
-    [""the number of odd elements 1n the str1ng 1 of the 1nput."",
-     ""the number of odd elements 8n the str8ng 8 of the 8nput.""]
-    """"""
-",0.0,0.0,0.0
-"
-def minSubArraySum(nums):
-    """"""
-    Given an array of integers nums, find the minimum sum of any non-empty sub-array
-    of nums.
-    Example
-    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
-    minSubArraySum([-1, -2, -3]) == -6
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def max_fill(grid, capacity):
-    import math
-    """"""
-    You are given a rectangular grid of wells. Each row represents a single well,
-    and each 1 in a row represents a single unit of water.
-    Each well has a corresponding bucket that can be used to extract water from it, 
-    and all buckets have the same capacity.
-    Your task is to use the buckets to empty the wells.
-    Output the number of times you need to lower the buckets.
-
-    Example 1:
-        Input: 
-            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
-            bucket_capacity : 1
-        Output: 6
-
-    Example 2:
-        Input: 
-            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
-            bucket_capacity : 2
-        Output: 5
-    
-    Example 3:
-        Input: 
-            grid : [[0,0,0], [0,0,0]]
-            bucket_capacity : 5
-        Output: 0
-
-    Constraints:
-        * all wells have the same length
-        * 1 <= grid.length <= 10^2
-        * 1 <= grid[:,1].length <= 10^2
-        * grid[i][j] -> 0 | 1
-        * 1 <= capacity <= 10
-    """"""
-",0.0,0.0,0.0
-"
-def sort_array(arr):
-    """"""
-    In this Kata, you have to sort an array of non-negative integers according to
-    number of ones in their binary representation in ascending order.
-    For similar number of ones, sort based on decimal value.
-
-    It must be implemented like this:
-    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
-    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
-    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
-    """"""
-",1.0,1.0,1.0
-"
-def select_words(s, n):
-    """"""Given a string s and a natural number n, you have been tasked to implement 
-    a function that returns a list of all words from string s that contain exactly 
-    n consonants, in order these words appear in the string s.
-    If the string s is empty then the function should return an empty list.
-    Note: you may assume the input string contains only letters and spaces.
-    Examples:
-    select_words(""Mary had a little lamb"", 4) ==> [""little""]
-    select_words(""Mary had a little lamb"", 3) ==> [""Mary"", ""lamb""]
-    select_words(""simple white space"", 2) ==> []
-    select_words(""Hello world"", 4) ==> [""world""]
-    select_words(""Uncle sam"", 3) ==> [""Uncle""]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def get_closest_vowel(word):
-    """"""You are given a word. Your task is to find the closest vowel that stands between 
-    two consonants from the right side of the word (case sensitive).
-    
-    Vowels in the beginning and ending doesn't count. Return empty string if you didn't
-    find any vowel met the above condition. 
-
-    You may assume that the given string contains English letter only.
-
-    Example:
-    get_closest_vowel(""yogurt"") ==> ""u""
-    get_closest_vowel(""FULL"") ==> ""U""
-    get_closest_vowel(""quick"") ==> """"
-    get_closest_vowel(""ab"") ==> """"
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def match_parens(lst):
-    '''
-    You are given a list of two strings, both strings consist of open
-    parentheses '(' or close parentheses ')' only.
-    Your job is to check if it is possible to concatenate the two strings in
-    some order, that the resulting string will be good.
-    A string S is considered to be good if and only if all parentheses in S
-    are balanced. For example: the string '(())()' is good, while the string
-    '())' is not.
-    Return 'Yes' if there's a way to make a good string, and return 'No' otherwise.
-
-    Examples:
-    match_parens(['()(', ')']) == 'Yes'
-    match_parens([')', ')']) == 'No'
-    '''
-",0.0,0.0,0.0
-"
-def maximum(arr, k):
-    """"""
-    Given an array arr of integers and a positive integer k, return a sorted list 
-    of length k with the maximum k numbers in arr.
-
-    Example 1:
-
-        Input: arr = [-3, -4, 5], k = 3
-        Output: [-4, -3, 5]
-
-    Example 2:
-
-        Input: arr = [4, -4, 4], k = 2
-        Output: [4, 4]
-
-    Example 3:
-
-        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
-        Output: [2]
-
-    Note:
-        1. The length of the array will be in the range of [1, 1000].
-        2. The elements in the array will be in the range of [-1000, 1000].
-        3. 0 <= k <= len(arr)
-    """"""
-",0.0,0.0,0.0
-"
-def solution(lst):
-    """"""Given a non-empty list of integers, return the sum of all of the odd elements that are in even positions.
-    
-
-    Examples
-    solution([5, 8, 7, 1]) ==> 12
-    solution([3, 3, 3, 3, 3]) ==> 9
-    solution([30, 13, 24, 321]) ==>0
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def add_elements(arr, k):
-    """"""
-    Given a non-empty array of integers arr and an integer k, return
-    the sum of the elements with at most two digits from the first k elements of arr.
-
-    Example:
-
-        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
-        Output: 24 # sum of 21 + 3
-
-    Constraints:
-        1. 1 <= len(arr) <= 100
-        2. 1 <= k <= len(arr)
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def get_odd_collatz(n):
-    """"""
-    Given a positive integer n, return a sorted list that has the odd numbers in collatz sequence.
-
-    The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined
-    as follows: start with any positive integer n. Then each term is obtained from the 
-    previous term as follows: if the previous term is even, the next term is one half of 
-    the previous term. If the previous term is odd, the next term is 3 times the previous
-    term plus 1. The conjecture is that no matter what value of n, the sequence will always reach 1.
-
-    Note: 
-        1. Collatz(1) is [1].
-        2. returned list sorted in increasing order.
-
-    For example:
-    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.
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-def valid_date(date):
-    """"""You have to write a function which validates a given date string and
-    returns True if the date is valid otherwise False.
-    The date is valid if all of the following rules are satisfied:
-    1. The date string is not empty.
-    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.
-    3. The months should not be less than 1 or higher than 12.
-    4. The date should be in the format: mm-dd-yyyy
-
-    for example: 
-    valid_date('03-11-2000') => True
-
-    valid_date('15-01-2012') => False
-
-    valid_date('04-0-2040') => False
-
-    valid_date('06-04-2020') => True
-
-    valid_date('06/04/2020') => False
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def split_words(txt):
-    '''
-    Given a string of words, return a list of words split on whitespace, if no whitespaces exists in the text you
-    should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
-    alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
-    Examples
-    split_words(""Hello world!"") ➞ [""Hello"", ""world!""]
-    split_words(""Hello,world!"") ➞ [""Hello"", ""world!""]
-    split_words(""abcdef"") == 3 
-    '''
-",0.0,0.0,0.0
-"
-def is_sorted(lst):
-    '''
-    Given a list of numbers, return whether or not they are sorted
-    in ascending order. If list has more than 1 duplicate of the same
-    number, return False. Assume no negative numbers and only integers.
-
-    Examples
-    is_sorted([5]) ➞ True
-    is_sorted([1, 2, 3, 4, 5]) ➞ True
-    is_sorted([1, 3, 2, 4, 5]) ➞ False
-    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
-    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
-    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
-    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
-    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
-    '''
-",0.0,0.0,0.0
-"
-def intersection(interval1, interval2):
-    """"""You are given two intervals,
-    where each interval is a pair of integers. For example, interval = (start, end) = (1, 2).
-    The given intervals are closed which means that the interval (start, end)
-    includes both start and end.
-    For each given interval, it is assumed that its start is less or equal its end.
-    Your task is to determine whether the length of intersection of these two 
-    intervals is a prime number.
-    Example, the intersection of the intervals (1, 3), (2, 4) is (2, 3)
-    which its length is 1, which not a prime number.
-    If the length of the intersection is a prime number, return ""YES"",
-    otherwise, return ""NO"".
-    If the two intervals don't intersect, return ""NO"".
-
-
-    [input/output] samples:
-    intersection((1, 2), (2, 3)) ==> ""NO""
-    intersection((-1, 1), (0, 4)) ==> ""NO""
-    intersection((-3, -1), (-5, 5)) ==> ""YES""
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-def prod_signs(arr):
-    """"""
-    You are given an array arr of integers and you need to return
-    sum of magnitudes of integers multiplied by product of all signs
-    of each number in the array, represented by 1, -1 or 0.
-    Note: return None for empty arr.
-
-    Example:
-    >>> prod_signs([1, 2, 2, -4]) == -9
-    >>> prod_signs([0, 1]) == 0
-    >>> prod_signs([]) == None
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def minPath(grid, k):
-    """"""
-    Given a grid with N rows and N columns (N >= 2) and a positive integer k, 
-    each cell of the grid contains a value. Every integer in the range [1, N * N]
-    inclusive appears exactly once on the cells of the grid.
-
-    You have to find the minimum path of length k in the grid. You can start
-    from any cell, and in each step you can move to any of the neighbor cells,
-    in other words, you can go to cells which share an edge with you current
-    cell.
-    Please note that a path of length k means visiting exactly k cells (not
-    necessarily distinct).
-    You CANNOT go off the grid.
-    A path A (of length k) is considered less than a path B (of length k) if
-    after making the ordered lists of the values on the cells that A and B go
-    through (let's call them lst_A and lst_B), lst_A is lexicographically less
-    than lst_B, in other words, there exist an integer index i (1 <= i <= k)
-    such that lst_A[i] < lst_B[i] and for any j (1 <= j < i) we have
-    lst_A[j] = lst_B[j].
-    It is guaranteed that the answer is unique.
-    Return an ordered list of the values on the cells that the minimum path go through.
-
-    Examples:
-
-        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
-        Output: [1, 2, 1]
-
-        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
-        Output: [1]
-    """"""
-",0.0,0.0,0.0
-"
-def tri(n):
-    """"""Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in 
-    the last couple centuries. However, what people don't know is Tribonacci sequence.
-    Tribonacci sequence is defined by the recurrence:
-    tri(1) = 3
-    tri(n) = 1 + n / 2, if n is even.
-    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
-    For example:
-    tri(2) = 1 + (2 / 2) = 2
-    tri(4) = 3
-    tri(3) = tri(2) + tri(1) + tri(4)
-           = 2 + 3 + 3 = 8 
-    You are given a non-negative integer number n, you have to a return a list of the 
-    first n + 1 numbers of the Tribonacci sequence.
-    Examples:
-    tri(3) = [1, 3, 2, 8]
-    """"""
-",0.0,0.0,0.0
-"
-def digits(n):
-    """"""Given a positive integer n, return the product of the odd digits.
-    Return 0 if all digits are even.
-    For example:
-    digits(1)  == 1
-    digits(4)  == 0
-    digits(235) == 15
-    """"""
-",0.0,0.0,0.0
-"
-def is_nested(string):
-    '''
-    Create a function that takes a string as input which contains only square brackets.
-    The function should return True if and only if there is a valid subsequence of brackets 
-    where at least one bracket in the subsequence is nested.
-
-    is_nested('[[]]') ➞ True
-    is_nested('[]]]]]]][[[[[]') ➞ False
-    is_nested('[][]') ➞ False
-    is_nested('[]') ➞ False
-    is_nested('[[][]]') ➞ True
-    is_nested('[[]][[') ➞ True
-    '''
-",0.0,0.0,0.0
-"
-
-def sum_squares(lst):
-    """"""You are given a list of numbers.
-    You need to return the sum of squared numbers in the given list,
-    round each element in the list to the upper int(Ceiling) first.
-    Examples:
-    For lst = [1,2,3] the output should be 14
-    For lst = [1,4,9] the output should be 98
-    For lst = [1,3,5,7] the output should be 84
-    For lst = [1.4,4.2,0] the output should be 29
-    For lst = [-2.4,1,1] the output should be 6
-    
-
-    """"""
-",0.0,0.0,0.0
-"
-def check_if_last_char_is_a_letter(txt):
-    '''
-    Create a function that returns True if the last character
-    of a given string is an alphabetical character and is not
-    a part of a word, and False otherwise.
-    Note: ""word"" is a group of characters separated by space.
-
-    Examples:
-    check_if_last_char_is_a_letter(""apple pie"") ➞ False
-    check_if_last_char_is_a_letter(""apple pi e"") ➞ True
-    check_if_last_char_is_a_letter(""apple pi e "") ➞ False
-    check_if_last_char_is_a_letter("""") ➞ False 
-    '''
-",0.0,0.0,0.0
-"
-def can_arrange(arr):
-    """"""Create a function which returns the largest index of an element which
-    is not greater than or equal to the element immediately preceding it. If
-    no such element exists then return -1. The given array will not contain
-    duplicate values.
-
-    Examples:
-    can_arrange([1,2,4,3,5]) = 3
-    can_arrange([1,2,3]) = -1
-    """"""
-",0.0,0.0,0.0
-"
-def largest_smallest_integers(lst):
-    '''
-    Create a function that returns a tuple (a, b), where 'a' is
-    the largest of negative integers, and 'b' is the smallest
-    of positive integers in a list.
-    If there is no negative or positive integers, return them as None.
-
-    Examples:
-    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
-    largest_smallest_integers([]) == (None, None)
-    largest_smallest_integers([0]) == (None, None)
-    '''
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def compare_one(a, b):
-    """"""
-    Create a function that takes integers, floats, or strings representing
-    real numbers, and returns the larger variable in its given variable type.
-    Return None if the values are equal.
-    Note: If a real number is represented as a string, the floating point might be . or ,
-
-    compare_one(1, 2.5) ➞ 2.5
-    compare_one(1, ""2,3"") ➞ ""2,3""
-    compare_one(""5,1"", ""6"") ➞ ""6""
-    compare_one(""1"", 1) ➞ None
-    """"""
-",0.0,0.0,0.0
-"
-def is_equal_to_sum_even(n):
-    """"""Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
-    Example
-    is_equal_to_sum_even(4) == False
-    is_equal_to_sum_even(6) == False
-    is_equal_to_sum_even(8) == True
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def special_factorial(n):
-    """"""The Brazilian factorial is defined as:
-    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
-    where n > 0
-
-    For example:
-    >>> special_factorial(4)
-    288
-
-    The function will receive an integer as input and should return the special
-    factorial of this integer.
-    """"""
-",0.0,0.0,0.0
-"
-def fix_spaces(text):
-    """"""
-    Given a string text, replace all spaces in it with underscores, 
-    and if a string has more than 2 consecutive spaces, 
-    then replace all consecutive spaces with - 
-    
-    fix_spaces(""Example"") == ""Example""
-    fix_spaces(""Example 1"") == ""Example_1""
-    fix_spaces("" Example 2"") == ""_Example_2""
-    fix_spaces("" Example   3"") == ""_Example-3""
-    """"""
-",0.0,0.0,0.0
-"
-def file_name_check(file_name):
-    """"""Create a function which takes a string representing a file's name, and returns
-    'Yes' if the the file's name is valid, and returns 'No' otherwise.
-    A file's name is considered to be valid if and only if all the following conditions 
-    are met:
-    - There should not be more than three digits ('0'-'9') in the file's name.
-    - The file's name contains exactly one dot '.'
-    - The substring before the dot should not be empty, and it starts with a letter from 
-    the latin alphapet ('a'-'z' and 'A'-'Z').
-    - The substring after the dot should be one of these: ['txt', 'exe', 'dll']
-    Examples:
-    file_name_check(""example.txt"") # => 'Yes'
-    file_name_check(""1example.dll"") # => 'No' (the name should start with a latin alphapet letter)
-    """"""
-",0.0,0.0,0.0
-"
-
-
-def sum_squares(lst):
-    """"""""
-    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 
-    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 
-    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. 
-    
-    Examples:
-    For lst = [1,2,3] the output should be 6
-    For lst = []  the output should be 0
-    For lst = [-1,-5,2,-1,-5]  the output should be -126
-    """"""
-",0.0,0.0,0.0
-"
-def words_in_sentence(sentence):
-    """"""
-    You are given a string representing a sentence,
-    the sentence contains some words separated by a space,
-    and you have to return a string that contains the words from the original sentence,
-    whose lengths are prime numbers,
-    the order of the words in the new string should be the same as the original one.
-
-    Example 1:
-        Input: sentence = ""This is a test""
-        Output: ""is""
-
-    Example 2:
-        Input: sentence = ""lets go for swimming""
-        Output: ""go for""
-
-    Constraints:
-        * 1 <= len(sentence) <= 100
-        * sentence contains only letters
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-def simplify(x, n):
-    """"""Your task is to implement a function that will simplify the expression
-    x * n. The function returns True if x * n evaluates to a whole number and False
-    otherwise. Both x and n, are string representation of a fraction, and have the following format,
-    <numerator>/<denominator> where both numerator and denominator are positive whole numbers.
-
-    You can assume that x, and n are valid fractions, and do not have zero as denominator.
-
-    simplify(""1/5"", ""5/1"") = True
-    simplify(""1/6"", ""2/1"") = False
-    simplify(""7/10"", ""10/2"") = False
-    """"""
-",0.0,0.0,0.0
-"
-def order_by_points(nums):
-    """"""
-    Write a function which sorts the given list of integers
-    in ascending order according to the sum of their digits.
-    Note: if there are several items with similar sum of their digits,
-    order them based on their index in original list.
-
-    For example:
-    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
-    >>> order_by_points([]) == []
-    """"""
-",0.0,0.0,0.0
-"
-def specialFilter(nums):
-    """"""Write a function that takes an array of numbers as input and returns 
-    the number of elements in the array that are greater than 10 and both 
-    first and last digits of a number are odd (1, 3, 5, 7, 9).
-    For example:
-    specialFilter([15, -73, 14, -15]) => 1 
-    specialFilter([33, -2, -3, 45, 21, 109]) => 2
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def get_max_triples(n):
-    """"""
-    You are given a positive integer n. You have to create an integer array a of length n.
-        For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
-        Return the number of triples (a[i], a[j], a[k]) of a where i < j < k, 
-    and a[i] + a[j] + a[k] is a multiple of 3.
-
-    Example :
-        Input: n = 5
-        Output: 1
-        Explanation: 
-        a = [1, 3, 7, 13, 21]
-        The only valid triple is (1, 7, 13).
-    """"""
-",0.0,0.0,0.0
-"
-def bf(planet1, planet2):
-    '''
-    There are eight planets in our solar system: the closerst to the Sun 
-    is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn, 
-    Uranus, Neptune.
-    Write a function that takes two planet names as strings planet1 and planet2. 
-    The function should return a tuple containing all planets whose orbits are 
-    located between the orbit of planet1 and the orbit of planet2, sorted by 
-    the proximity to the sun. 
-    The function should return an empty tuple if planet1 or planet2
-    are not correct planet names. 
-    Examples
-    bf(""Jupiter"", ""Neptune"") ==> (""Saturn"", ""Uranus"")
-    bf(""Earth"", ""Mercury"") ==> (""Venus"")
-    bf(""Mercury"", ""Uranus"") ==> (""Venus"", ""Earth"", ""Mars"", ""Jupiter"", ""Saturn"")
-    '''
-",0.95,1.0,1.0
-"
-def sorted_list_sum(lst):
-    """"""Write a function that accepts a list of strings as a parameter,
-    deletes the strings that have odd lengths from it,
-    and returns the resulted list with a sorted order,
-    The list is always a list of strings and never an array of numbers,
-    and it may contain duplicates.
-    The order of the list should be ascending by length of each word, and you
-    should return the list sorted by that rule.
-    If two words have the same length, sort the list alphabetically.
-    The function should return a list of strings in sorted order.
-    You may assume that all words will have the same length.
-    For example:
-    assert list_sort([""aa"", ""a"", ""aaa""]) => [""aa""]
-    assert list_sort([""ab"", ""a"", ""aaa"", ""cd""]) => [""ab"", ""cd""]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def x_or_y(n, x, y):
-    """"""A simple program which should return the value of x if n is 
-    a prime number and should return the value of y otherwise.
-
-    Examples:
-    for x_or_y(7, 34, 12) == 34
-    for x_or_y(15, 8, 5) == 5
-    
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def double_the_difference(lst):
-    '''
-    Given a list of numbers, return the sum of squares of the numbers
-    in the list that are odd. Ignore numbers that are negative or not integers.
-    
-    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
-    double_the_difference([-1, -2, 0]) == 0
-    double_the_difference([9, -2]) == 81
-    double_the_difference([0]) == 0  
-   
-    If the input list is empty, return 0.
-    '''
-",0.7,0.9996130030959752,1.0
-"
-def compare(game,guess):
-    """"""I think we all remember that feeling when the result of some long-awaited
-    event is finally known. The feelings and thoughts you have at that moment are
-    definitely worth noting down and comparing.
-    Your task is to determine if a person correctly guessed the results of a number of matches.
-    You are given two arrays of scores and guesses of equal length, where each index shows a match. 
-    Return an array of the same length denoting how far off each guess was. If they have guessed correctly,
-    the value is 0, and if not, the value is the absolute difference between the guess and the score.
-    
-    
-    example:
-
-    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
-    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
-    """"""
-",0.85,1.0,1.0
-"
-def Strongest_Extension(class_name, extensions):
-    """"""You will be given the name of a class (a string) and a list of extensions.
-    The extensions are to be used to load additional classes to the class. The
-    strength of the extension is as follows: Let CAP be the number of the uppercase
-    letters in the extension's name, and let SM be the number of lowercase letters 
-    in the extension's name, the strength is given by the fraction CAP - SM. 
-    You should find the strongest extension and return a string in this 
-    format: ClassName.StrongestExtensionName.
-    If there are two or more extensions with the same strength, you should
-    choose the one that comes first in the list.
-    For example, if you are given ""Slices"" as the class and a list of the
-    extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] then you should
-    return 'Slices.SErviNGSliCes' since 'SErviNGSliCes' is the strongest extension 
-    (its strength is -1).
-    Example:
-    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
-    """"""
-",0.0,0.0,0.0
-"
-def cycpattern_check(a , b):
-    """"""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
-    cycpattern_check(""abcd"",""abd"") => False
-    cycpattern_check(""hello"",""ell"") => True
-    cycpattern_check(""whassup"",""psus"") => False
-    cycpattern_check(""abab"",""baa"") => True
-    cycpattern_check(""efef"",""eeff"") => False
-    cycpattern_check(""himenss"",""simen"") => True
-
-    """"""
-",0.0,0.0,0.0
-"
-def even_odd_count(num):
-    """"""Given an integer. return a tuple that has the number of even and odd digits respectively.
-
-     Example:
-        even_odd_count(-12) ==> (1, 1)
-        even_odd_count(123) ==> (1, 2)
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-def int_to_mini_roman(number):
-    """"""
-    Given a positive integer, obtain its roman numeral equivalent as a string,
-    and return it in lowercase.
-    Restrictions: 1 <= num <= 1000
-
-    Examples:
-    >>> int_to_mini_roman(19) == 'xix'
-    >>> int_to_mini_roman(152) == 'clii'
-    >>> int_to_mini_roman(426) == 'cdxxvi'
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-def right_angle_triangle(a, b, c):
-    '''
-    Given the lengths of the three sides of a triangle. Return True if the three
-    sides form a right-angled triangle, False otherwise.
-    A right-angled triangle is a triangle in which one angle is right angle or 
-    90 degree.
-    Example:
-    right_angle_triangle(3, 4, 5) == True
-    right_angle_triangle(1, 2, 3) == False
-    '''
-",0.4,0.9489164086687306,0.9996427720885925
-"
-def find_max(words):
-    """"""Write a function that accepts a list of strings.
-    The list contains different words. Return the word with maximum number
-    of unique characters. If multiple strings have maximum number of unique
-    characters, return the one which comes first in lexicographical order.
-
-    find_max([""name"", ""of"", ""string""]) == ""string""
-    find_max([""name"", ""enam"", ""game""]) == ""enam""
-    find_max([""aaaaaaa"", ""bb"" ,""cc""]) == """"aaaaaaa""
-    """"""
-",1.0,1.0,1.0
-"
-def eat(number, need, remaining):
-    """"""
-    You're a hungry rabbit, and you already have eaten a certain number of carrots,
-    but now you need to eat more carrots to complete the day's meals.
-    you should return an array of [ total number of eaten carrots after your meals,
-                                    the number of carrots left after your meals ]
-    if there are not enough remaining carrots, you will eat all remaining carrots, but will still be hungry.
-    
-    Example:
-    * eat(5, 6, 10) -> [11, 4]
-    * eat(4, 8, 9) -> [12, 1]
-    * eat(1, 10, 10) -> [11, 0]
-    * eat(2, 11, 5) -> [7, 0]
-    
-    Variables:
-    @number : integer
-        the number of carrots that you have eaten.
-    @need : integer
-        the number of carrots that you need to eat.
-    @remaining : integer
-        the number of remaining carrots thet exist in stock
-    
-    Constrain:
-    * 0 <= number <= 1000
-    * 0 <= need <= 1000
-    * 0 <= remaining <= 1000
-
-    Have fun :)
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def do_algebra(operator, operand):
-    """"""
-    Given two lists operator, and operand. The first list has basic algebra operations, and 
-    the second list is a list of integers. Use the two given lists to build the algebric 
-    expression and return the evaluation of this expression.
-
-    The basic algebra operations:
-    Addition ( + ) 
-    Subtraction ( - ) 
-    Multiplication ( * ) 
-    Floor division ( // ) 
-    Exponentiation ( ** ) 
-
-    Example:
-    operator['+', '*', '-']
-    array = [2, 3, 4, 5]
-    result = 2 + 3 * 4 - 5
-    => result = 9
-
-    Note:
-        The length of operator list is equal to the length of operand list minus one.
-        Operand is a list of of non-negative integers.
-        Operator list has at least one operator, and operand list has at least two operands.
-
-    """"""
-",0.0,0.0,0.0
-"
-def solve(s):
-    """"""You are given a string s.
-    if s[i] is a letter, reverse its case from lower to upper or vise versa, 
-    otherwise keep it as it is.
-    If the string contains no letters, reverse the string.
-    The function should return the resulted string.
-    Examples
-    solve(""1234"") = ""4321""
-    solve(""ab"") = ""AB""
-    solve(""#a@C"") = ""#A@c""
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-def string_to_md5(text):
-    """"""
-    Given a string 'text', return its md5 hash equivalent string.
-    If 'text' is an empty string, return None.
-
-    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-def generate_integers(a, b):
-    """"""
-    Given two positive integers a and b, return the even digits between a
-    and b, in ascending order.
-
-    For example:
-    generate_integers(2, 8) => [2, 4, 6, 8]
-    generate_integers(8, 2) => [2, 4, 6, 8]
-    generate_integers(10, 14) => []
-    """"""
-",0.0,0.0,0.0

demo/data/coding/humaneval/csv/2.csv

@@ -1,2413 +0,0 @@
-prompt,pass@1,pass@5,pass@10
-"from typing import List
-
-
-def has_close_elements(numbers: List[float], threshold: float) -> bool:
-    """""" Check if in given list of numbers, are any two numbers closer to each other than
-    given threshold.
-    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
-    False
-    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
-    True
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"from typing import List
-
-
-def separate_paren_groups(paren_string: str) -> List[str]:
-    """""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
-    separate those group into separate strings and return the list of those.
-    Separate groups are balanced (each open brace is properly closed) and not nested within each other
-    Ignore any spaces in the input string.
-    >>> separate_paren_groups('( ) (( )) (( )( ))')
-    ['()', '(())', '(()())']
-    """"""
-",0.0,0.0,0.0
-"
-
-def truncate_number(number: float) -> float:
-    """""" Given a positive floating point number, it can be decomposed into
-    and integer part (largest integer smaller than given number) and decimals
-    (leftover part always smaller than 1).
-
-    Return the decimal part of the number.
-    >>> truncate_number(3.5)
-    0.5
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"from typing import List
-
-
-def below_zero(operations: List[int]) -> bool:
-    """""" You're given a list of deposit and withdrawal operations on a bank account that starts with
-    zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
-    at that point function should return True. Otherwise it should return False.
-    >>> below_zero([1, 2, 3])
-    False
-    >>> below_zero([1, 2, -4, 5])
-    True
-    """"""
-",1.0,1.0,1.0
-"from typing import List
-
-
-def mean_absolute_deviation(numbers: List[float]) -> float:
-    """""" For a given list of input numbers, calculate Mean Absolute Deviation
-    around the mean of this dataset.
-    Mean Absolute Deviation is the average absolute difference between each
-    element and a centerpoint (mean in this case):
-    MAD = average | x - x_mean |
-    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
-    1.0
-    """"""
-",0.95,1.0,1.0
-"from typing import List
-
-
-def intersperse(numbers: List[int], delimeter: int) -> List[int]:
-    """""" Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
-    >>> intersperse([], 4)
-    []
-    >>> intersperse([1, 2, 3], 4)
-    [1, 4, 2, 4, 3]
-    """"""
-",0.0,0.0,0.0
-"from typing import List
-
-
-def parse_nested_parens(paren_string: str) -> List[int]:
-    """""" Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
-    For each of the group, output the deepest level of nesting of parentheses.
-    E.g. (()()) has maximum two levels of nesting while ((())) has three.
-
-    >>> parse_nested_parens('(()()) ((())) () ((())()())')
-    [2, 3, 1, 3]
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"from typing import List
-
-
-def filter_by_substring(strings: List[str], substring: str) -> List[str]:
-    """""" Filter an input list of strings only for ones that contain given substring
-    >>> filter_by_substring([], 'a')
-    []
-    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
-    ['abc', 'bacd', 'array']
-    """"""
-",1.0,1.0,1.0
-"from typing import List, Tuple
-
-
-def sum_product(numbers: List[int]) -> Tuple[int, int]:
-    """""" For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.
-    Empty sum should be equal to 0 and empty product should be equal to 1.
-    >>> sum_product([])
-    (0, 1)
-    >>> sum_product([1, 2, 3, 4])
-    (10, 24)
-    """"""
-",1.0,1.0,1.0
-"from typing import List, Tuple
-
-
-def rolling_max(numbers: List[int]) -> List[int]:
-    """""" From a given list of integers, generate a list of rolling maximum element found until given moment
-    in the sequence.
-    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
-    [1, 2, 3, 3, 3, 4, 4]
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-
-def is_palindrome(string: str) -> bool:
-    """""" Test if given string is a palindrome """"""
-    return string == string[::-1]
-
-
-def make_palindrome(string: str) -> str:
-    """""" Find the shortest palindrome that begins with a supplied string.
-    Algorithm idea is simple:
-    - Find the longest postfix of supplied string that is a palindrome.
-    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
-    >>> make_palindrome('')
-    ''
-    >>> make_palindrome('cat')
-    'catac'
-    >>> make_palindrome('cata')
-    'catac'
-    """"""
-",0.0,0.0,0.0
-"from typing import List
-
-
-def string_xor(a: str, b: str) -> str:
-    """""" Input are two strings a and b consisting only of 1s and 0s.
-    Perform binary XOR on these inputs and return result also as a string.
-    >>> string_xor('010', '110')
-    '100'
-    """"""
-",0.7,0.9996130030959752,1.0
-"from typing import List, Optional
-
-
-def longest(strings: List[str]) -> Optional[str]:
-    """""" Out of list of strings, return the longest one. Return the first one in case of multiple
-    strings of the same length. Return None in case the input list is empty.
-    >>> longest([])
-
-    >>> longest(['a', 'b', 'c'])
-    'a'
-    >>> longest(['a', 'bb', 'ccc'])
-    'ccc'
-    """"""
-",1.0,1.0,1.0
-"
-
-def greatest_common_divisor(a: int, b: int) -> int:
-    """""" Return a greatest common divisor of two integers a and b
-    >>> greatest_common_divisor(3, 5)
-    1
-    >>> greatest_common_divisor(25, 15)
-    5
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"from typing import List
-
-
-def all_prefixes(string: str) -> List[str]:
-    """""" Return list of all prefixes from shortest to longest of the input string
-    >>> all_prefixes('abc')
-    ['a', 'ab', 'abc']
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-
-def string_sequence(n: int) -> str:
-    """""" Return a string containing space-delimited numbers starting from 0 upto n inclusive.
-    >>> string_sequence(0)
-    '0'
-    >>> string_sequence(5)
-    '0 1 2 3 4 5'
-    """"""
-",0.75,0.9999355005159959,1.0
-"
-
-def count_distinct_characters(string: str) -> int:
-    """""" Given a string, find out how many distinct characters (regardless of case) does it consist of
-    >>> count_distinct_characters('xyzXYZ')
-    3
-    >>> count_distinct_characters('Jerry')
-    4
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"from typing import List
-
-
-def parse_music(music_string: str) -> List[int]:
-    """""" Input to this function is a string representing musical notes in a special ASCII format.
-    Your task is to parse this string and return list of integers corresponding to how many beats does each
-    not last.
-
-    Here is a legend:
-    'o' - whole note, lasts four beats
-    'o|' - half note, lasts two beats
-    '.|' - quater note, lasts one beat
-
-    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
-    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
-    """"""
-",0.75,0.9999355005159959,1.0
-"
-
-def how_many_times(string: str, substring: str) -> int:
-    """""" Find how many times a given substring can be found in the original string. Count overlaping cases.
-    >>> how_many_times('', 'a')
-    0
-    >>> how_many_times('aaa', 'a')
-    3
-    >>> how_many_times('aaaa', 'aa')
-    3
-    """"""
-",0.75,0.9999355005159959,1.0
-"from typing import List
-
-
-def sort_numbers(numbers: str) -> str:
-    """""" Input is a space-delimited string of numberals from 'zero' to 'nine'.
-    Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
-    Return the string with numbers sorted from smallest to largest
-    >>> sort_numbers('three one five')
-    'one three five'
-    """"""
-",0.0,0.0,0.0
-"from typing import List, Tuple
-
-
-def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
-    """""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
-    other and return them in order (smaller number, larger number).
-    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
-    (2.0, 2.2)
-    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
-    (2.0, 2.0)
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"from typing import List
-
-
-def rescale_to_unit(numbers: List[float]) -> List[float]:
-    """""" Given list of numbers (of at least two elements), apply a linear transform to that list,
-    such that the smallest number will become 0 and the largest will become 1
-    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
-    [0.0, 0.25, 0.5, 0.75, 1.0]
-    """"""
-",0.8999999999999999,1.0,1.0
-"from typing import List, Any
-
-
-def filter_integers(values: List[Any]) -> List[int]:
-    """""" Filter given list of any python values only for integers
-    >>> filter_integers(['a', 3.14, 5])
-    [5]
-    >>> filter_integers([1, 2, 3, 'abc', {}, []])
-    [1, 2, 3]
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-
-def strlen(string: str) -> int:
-    """""" Return length of given string
-    >>> strlen('')
-    0
-    >>> strlen('abc')
-    3
-    """"""
-",0.75,0.9999355005159959,1.0
-"
-
-def largest_divisor(n: int) -> int:
-    """""" For a given number n, find the largest number that divides n evenly, smaller than n
-    >>> largest_divisor(15)
-    5
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"from typing import List
-
-
-def factorize(n: int) -> List[int]:
-    """""" Return list of prime factors of given integer in the order from smallest to largest.
-    Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
-    Input number should be equal to the product of all factors
-    >>> factorize(8)
-    [2, 2, 2]
-    >>> factorize(25)
-    [5, 5]
-    >>> factorize(70)
-    [2, 5, 7]
-    """"""
-",1.0,1.0,1.0
-"from typing import List
-
-
-def remove_duplicates(numbers: List[int]) -> List[int]:
-    """""" From a list of integers, remove all elements that occur more than once.
-    Keep order of elements left the same as in the input.
-    >>> remove_duplicates([1, 2, 3, 2, 4])
-    [1, 3, 4]
-    """"""
-",0.0,0.0,0.0
-"
-
-def flip_case(string: str) -> str:
-    """""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
-    >>> flip_case('Hello')
-    'hELLO'
-    """"""
-",1.0,1.0,1.0
-"from typing import List
-
-
-def concatenate(strings: List[str]) -> str:
-    """""" Concatenate list of strings into a single string
-    >>> concatenate([])
-    ''
-    >>> concatenate(['a', 'b', 'c'])
-    'abc'
-    """"""
-",0.65,0.9986455108359134,1.0
-"from typing import List
-
-
-def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
-    """""" Filter an input list of strings only for ones that start with a given prefix.
-    >>> filter_by_prefix([], 'a')
-    []
-    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
-    ['abc', 'array']
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-
-def get_positive(l: list):
-    """"""Return only positive numbers in the list.
-    >>> get_positive([-1, 2, -4, 5, 6])
-    [2, 5, 6]
-    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
-    [5, 3, 2, 3, 9, 123, 1]
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-
-def is_prime(n):
-    """"""Return true if a given number is prime, and false otherwise.
-    >>> is_prime(6)
-    False
-    >>> is_prime(101)
-    True
-    >>> is_prime(11)
-    True
-    >>> is_prime(13441)
-    True
-    >>> is_prime(61)
-    True
-    >>> is_prime(4)
-    False
-    >>> is_prime(1)
-    False
-    """"""
-",0.65,0.9986455108359134,1.0
-"import math
-
-
-def poly(xs: list, x: float):
-    """"""
-    Evaluates polynomial with coefficients xs at point x.
-    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
-    """"""
-    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
-
-
-def find_zero(xs: list):
-    """""" xs are coefficients of a polynomial.
-    find_zero find x such that poly(x) = 0.
-    find_zero returns only only zero point, even if there are many.
-    Moreover, find_zero only takes list xs having even number of coefficients
-    and largest non zero coefficient as it guarantees
-    a solution.
-    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
-    -0.5
-    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
-    1.0
-    """"""
-",0.0,0.0,0.0
-"
-
-def sort_third(l: list):
-    """"""This function takes a list l and returns a list l' such that
-    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
-    to the values of the corresponding indicies of l, but sorted.
-    >>> sort_third([1, 2, 3])
-    [1, 2, 3]
-    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
-    [2, 6, 3, 4, 8, 9, 5]
-    """"""
-",0.0,0.0,0.0
-"
-
-def unique(l: list):
-    """"""Return sorted unique elements in a list
-    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
-    [0, 2, 3, 5, 9, 123]
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"
-
-def max_element(l: list):
-    """"""Return maximum element in the list.
-    >>> max_element([1, 2, 3])
-    3
-    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
-    123
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-
-def fizz_buzz(n: int):
-    """"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
-    >>> fizz_buzz(50)
-    0
-    >>> fizz_buzz(78)
-    2
-    >>> fizz_buzz(79)
-    3
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-
-def sort_even(l: list):
-    """"""This function takes a list l and returns a list l' such that
-    l' is identical to l in the odd indicies, while its values at the even indicies are equal
-    to the values of the even indicies of l, but sorted.
-    >>> sort_even([1, 2, 3])
-    [1, 2, 3]
-    >>> sort_even([5, 6, 3, 4])
-    [3, 6, 5, 4]
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-
-def encode_cyclic(s: str):
-    """"""
-    returns encoded string by cycling groups of three characters.
-    """"""
-    # split string to groups. Each of length 3.
-    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
-    # cycle elements in each group. Unless group has fewer elements than 3.
-    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
-    return """".join(groups)
-
-
-def decode_cyclic(s: str):
-    """"""
-    takes as input string encoded with encode_cyclic function. Returns decoded string.
-    """"""
-",0.0,0.0,0.0
-"
-
-def prime_fib(n: int):
-    """"""
-    prime_fib returns n-th number that is a Fibonacci number and it's also prime.
-    >>> prime_fib(1)
-    2
-    >>> prime_fib(2)
-    3
-    >>> prime_fib(3)
-    5
-    >>> prime_fib(4)
-    13
-    >>> prime_fib(5)
-    89
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-
-def triples_sum_to_zero(l: list):
-    """"""
-    triples_sum_to_zero takes a list of integers as an input.
-    it returns True if there are three distinct elements in the list that
-    sum to zero, and False otherwise.
-
-    >>> triples_sum_to_zero([1, 3, 5, 0])
-    False
-    >>> triples_sum_to_zero([1, 3, -2, 1])
-    True
-    >>> triples_sum_to_zero([1, 2, 3, 7])
-    False
-    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
-    True
-    >>> triples_sum_to_zero([1])
-    False
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-
-def car_race_collision(n: int):
-    """"""
-    Imagine a road that's a perfectly straight infinitely long line.
-    n cars are driving left to right;  simultaneously, a different set of n cars
-    are driving right to left.   The two sets of cars start out being very far from
-    each other.  All cars move in the same speed.  Two cars are said to collide
-    when a car that's moving left to right hits a car that's moving right to left.
-    However, the cars are infinitely sturdy and strong; as a result, they continue moving
-    in their trajectory as if they did not collide.
-
-    This function outputs the number of such collisions.
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-
-def incr_list(l: list):
-    """"""Return list with elements incremented by 1.
-    >>> incr_list([1, 2, 3])
-    [2, 3, 4]
-    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
-    [6, 4, 6, 3, 4, 4, 10, 1, 124]
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-
-def pairs_sum_to_zero(l):
-    """"""
-    pairs_sum_to_zero takes a list of integers as an input.
-    it returns True if there are two distinct elements in the list that
-    sum to zero, and False otherwise.
-    >>> pairs_sum_to_zero([1, 3, 5, 0])
-    False
-    >>> pairs_sum_to_zero([1, 3, -2, 1])
-    False
-    >>> pairs_sum_to_zero([1, 2, 3, 7])
-    False
-    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
-    True
-    >>> pairs_sum_to_zero([1])
-    False
-    """"""
-",0.95,1.0,1.0
-"
-
-def change_base(x: int, base: int):
-    """"""Change numerical base of input number x to base.
-    return string representation after the conversion.
-    base numbers are less than 10.
-    >>> change_base(8, 3)
-    '22'
-    >>> change_base(8, 2)
-    '1000'
-    >>> change_base(7, 2)
-    '111'
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-
-def triangle_area(a, h):
-    """"""Given length of a side and high return area for a triangle.
-    >>> triangle_area(5, 3)
-    7.5
-    """"""
-",1.0,1.0,1.0
-"
-
-def fib4(n: int):
-    """"""The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
-    fib4(0) -> 0
-    fib4(1) -> 0
-    fib4(2) -> 2
-    fib4(3) -> 0
-    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
-    Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
-    >>> fib4(5)
-    4
-    >>> fib4(6)
-    8
-    >>> fib4(7)
-    14
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-
-def median(l: list):
-    """"""Return median of elements in the list l.
-    >>> median([3, 1, 2, 4, 5])
-    3
-    >>> median([-10, 4, 6, 1000, 10, 20])
-    15.0
-    """"""
-",0.95,1.0,1.0
-"
-
-def is_palindrome(text: str):
-    """"""
-    Checks if given string is a palindrome
-    >>> is_palindrome('')
-    True
-    >>> is_palindrome('aba')
-    True
-    >>> is_palindrome('aaaaa')
-    True
-    >>> is_palindrome('zbcd')
-    False
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-
-def modp(n: int, p: int):
-    """"""Return 2^n modulo p (be aware of numerics).
-    >>> modp(3, 5)
-    3
-    >>> modp(1101, 101)
-    2
-    >>> modp(0, 101)
-    1
-    >>> modp(3, 11)
-    8
-    >>> modp(100, 101)
-    1
-    """"""
-",0.0,0.0,0.0
-"
-
-def encode_shift(s: str):
-    """"""
-    returns encoded string by shifting every character by 5 in the alphabet.
-    """"""
-    return """".join([chr(((ord(ch) + 5 - ord(""a"")) % 26) + ord(""a"")) for ch in s])
-
-
-def decode_shift(s: str):
-    """"""
-    takes as input string encoded with encode_shift function. Returns decoded string.
-    """"""
-",1.0,1.0,1.0
-"
-
-def remove_vowels(text):
-    """"""
-    remove_vowels is a function that takes string and returns string without vowels.
-    >>> remove_vowels('')
-    ''
-    >>> remove_vowels(""abcdef\nghijklm"")
-    'bcdf\nghjklm'
-    >>> remove_vowels('abcdef')
-    'bcdf'
-    >>> remove_vowels('aaaaa')
-    ''
-    >>> remove_vowels('aaBAA')
-    'B'
-    >>> remove_vowels('zbcd')
-    'zbcd'
-    """"""
-",0.85,1.0,1.0
-"
-
-def below_threshold(l: list, t: int):
-    """"""Return True if all numbers in the list l are below threshold t.
-    >>> below_threshold([1, 2, 4, 10], 100)
-    True
-    >>> below_threshold([1, 20, 4, 10], 5)
-    False
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-
-def add(x: int, y: int):
-    """"""Add two numbers x and y
-    >>> add(2, 3)
-    5
-    >>> add(5, 7)
-    12
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-
-def same_chars(s0: str, s1: str):
-    """"""
-    Check if two words have the same characters.
-    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
-    True
-    >>> same_chars('abcd', 'dddddddabc')
-    True
-    >>> same_chars('dddddddabc', 'abcd')
-    True
-    >>> same_chars('eabcd', 'dddddddabc')
-    False
-    >>> same_chars('abcd', 'dddddddabce')
-    False
-    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
-    False
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-
-def fib(n: int):
-    """"""Return n-th Fibonacci number.
-    >>> fib(10)
-    55
-    >>> fib(1)
-    1
-    >>> fib(8)
-    21
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-
-def correct_bracketing(brackets: str):
-    """""" brackets is a string of ""<"" and "">"".
-    return True if every opening bracket has a corresponding closing bracket.
-
-    >>> correct_bracketing(""<"")
-    False
-    >>> correct_bracketing(""<>"")
-    True
-    >>> correct_bracketing(""<<><>>"")
-    True
-    >>> correct_bracketing(""><<>"")
-    False
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-
-def monotonic(l: list):
-    """"""Return True is list elements are monotonically increasing or decreasing.
-    >>> monotonic([1, 2, 4, 20])
-    True
-    >>> monotonic([1, 20, 4, 10])
-    False
-    >>> monotonic([4, 1, 0, -10])
-    True
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-
-def common(l1: list, l2: list):
-    """"""Return sorted unique common elements for two lists.
-    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
-    [1, 5, 653]
-    >>> common([5, 3, 2, 8], [3, 2])
-    [2, 3]
-
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-
-def largest_prime_factor(n: int):
-    """"""Return the largest prime factor of n. Assume n > 1 and is not a prime.
-    >>> largest_prime_factor(13195)
-    29
-    >>> largest_prime_factor(2048)
-    2
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-
-def sum_to_n(n: int):
-    """"""sum_to_n is a function that sums numbers from 1 to n.
-    >>> sum_to_n(30)
-    465
-    >>> sum_to_n(100)
-    5050
-    >>> sum_to_n(5)
-    15
-    >>> sum_to_n(10)
-    55
-    >>> sum_to_n(1)
-    1
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-
-def correct_bracketing(brackets: str):
-    """""" brackets is a string of ""("" and "")"".
-    return True if every opening bracket has a corresponding closing bracket.
-
-    >>> correct_bracketing(""("")
-    False
-    >>> correct_bracketing(""()"")
-    True
-    >>> correct_bracketing(""(()())"")
-    True
-    >>> correct_bracketing("")(()"")
-    False
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-
-def derivative(xs: list):
-    """""" xs represent coefficients of a polynomial.
-    xs[0] + xs[1] * x + xs[2] * x^2 + ....
-     Return derivative of this polynomial in the same form.
-    >>> derivative([3, 1, 2, 4, 5])
-    [1, 4, 12, 20]
-    >>> derivative([1, 2, 3])
-    [2, 6]
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-
-def fibfib(n: int):
-    """"""The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
-    fibfib(0) == 0
-    fibfib(1) == 0
-    fibfib(2) == 1
-    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
-    Please write a function to efficiently compute the n-th element of the fibfib number sequence.
-    >>> fibfib(1)
-    0
-    >>> fibfib(5)
-    4
-    >>> fibfib(8)
-    24
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-FIX = """"""
-Add more test cases.
-""""""
-
-def vowels_count(s):
-    """"""Write a function vowels_count which takes a string representing
-    a word as input and returns the number of vowels in the string.
-    Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
-    vowel, but only when it is at the end of the given word.
-
-    Example:
-    >>> vowels_count(""abcde"")
-    2
-    >>> vowels_count(""ACEDY"")
-    3
-    """"""
-",0.7999999999999999,1.0,1.0
-"
-def circular_shift(x, shift):
-    """"""Circular shift the digits of the integer x, shift the digits right by shift
-    and return the result as a string.
-    If shift > number of digits, return digits reversed.
-    >>> circular_shift(12, 1)
-    ""21""
-    >>> circular_shift(12, 2)
-    ""12""
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def digitSum(s):
-    """"""Task
-    Write a function that takes a string as input and returns the sum of the upper characters only'
-    ASCII codes.
-
-    Examples:
-        digitSum("""") => 0
-        digitSum(""abAB"") => 131
-        digitSum(""abcCd"") => 67
-        digitSum(""helloE"") => 69
-        digitSum(""woArBld"") => 131
-        digitSum(""aAaaaXa"") => 153
-    """"""
-",0.75,0.9999355005159959,1.0
-"
-def fruit_distribution(s,n):
-    """"""
-    In this task, you will be given a string that represents a number of apples and oranges 
-    that are distributed in a basket of fruit this basket contains 
-    apples, oranges, and mango fruits. Given the string that represents the total number of 
-    the oranges and apples and an integer that represent the total number of the fruits 
-    in the basket return the number of the mango fruits in the basket.
-    for examble:
-    fruit_distribution(""5 apples and 6 oranges"", 19) ->19 - 5 - 6 = 8
-    fruit_distribution(""0 apples and 1 oranges"",3) -> 3 - 0 - 1 = 2
-    fruit_distribution(""2 apples and 3 oranges"", 100) -> 100 - 2 - 3 = 95
-    fruit_distribution(""100 apples and 1 oranges"",120) -> 120 - 100 - 1 = 19
-    """"""
-",0.0,0.0,0.0
-"
-def pluck(arr):
-    """"""
-    ""Given an array representing a branch of a tree that has non-negative integer nodes
-    your task is to pluck one of the nodes and return it.
-    The plucked node should be the node with the smallest even value.
-    If multiple nodes with the same smallest even value are found return the node that has smallest index.
-
-    The plucked node should be returned in a list, [ smalest_value, its index ],
-    If there are no even values or the given array is empty, return [].
-
-    Example 1:
-        Input: [4,2,3]
-        Output: [2, 1]
-        Explanation: 2 has the smallest even value, and 2 has the smallest index.
-
-    Example 2:
-        Input: [1,2,3]
-        Output: [2, 1]
-        Explanation: 2 has the smallest even value, and 2 has the smallest index. 
-
-    Example 3:
-        Input: []
-        Output: []
-    
-    Example 4:
-        Input: [5, 0, 3, 0, 4, 2]
-        Output: [0, 1]
-        Explanation: 0 is the smallest value, but  there are two zeros,
-                     so we will choose the first zero, which has the smallest index.
-
-    Constraints:
-        * 1 <= nodes.length <= 10000
-        * 0 <= node.value
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-def search(lst):
-    '''
-    You are given a non-empty list of positive integers. Return the greatest integer that is greater than 
-    zero, and has a frequency greater than or equal to the value of the integer itself. 
-    The frequency of an integer is the number of times it appears in the list.
-    If no such a value exist, return -1.
-    Examples:
-        search([4, 1, 2, 2, 3, 1]) == 2
-        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
-        search([5, 5, 4, 4, 4]) == -1
-    '''
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def strange_sort_list(lst):
-    '''
-    Given list of integers, return list in strange order.
-    Strange sorting, is when you start with the minimum value,
-    then maximum of the remaining integers, then minimum and so on.
-
-    Examples:
-    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
-    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
-    strange_sort_list([]) == []
-    '''
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def triangle_area(a, b, c):
-    '''
-    Given the lengths of the three sides of a triangle. Return the area of
-    the triangle rounded to 2 decimal points if the three sides form a valid triangle. 
-    Otherwise return -1
-    Three sides make a valid triangle when the sum of any two sides is greater 
-    than the third side.
-    Example:
-    triangle_area(3, 4, 5) == 6.00
-    triangle_area(1, 2, 10) == -1
-    '''
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-def will_it_fly(q,w):
-    '''
-    Write a function that returns True if the object q will fly, and False otherwise.
-    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.
-
-    Example:
-    will_it_fly([1, 2], 5) ➞ False 
-    # 1+2 is less than the maximum possible weight, but it's unbalanced.
-
-    will_it_fly([3, 2, 3], 1) ➞ False
-    # it's balanced, but 3+2+3 is more than the maximum possible weight.
-
-    will_it_fly([3, 2, 3], 9) ➞ True
-    # 3+2+3 is less than the maximum possible weight, and it's balanced.
-
-    will_it_fly([3], 5) ➞ True
-    # 3 is less than the maximum possible weight, and it's balanced.
-    '''
-",0.5499999999999998,0.9918730650154799,1.0
-"
-def smallest_change(arr):
-    """"""
-    Given an array arr of integers, find the minimum number of elements that
-    need to be changed to make the array palindromic. A palindromic array is an array that
-    is read the same backwards and forwards. In one change, you can change one element to any other element.
-
-    For example:
-    smallest_change([1,2,3,5,4,7,9,6]) == 4
-    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
-    smallest_change([1, 2, 3, 2, 1]) == 0
-    """"""
-",0.0,0.0,0.0
-"
-def total_match(lst1, lst2):
-    '''
-    Write a function that accepts two lists of strings and returns the list that has 
-    total number of chars in the all strings of the list less than the other list.
-
-    if the two lists have the same number of chars, return the first list.
-
-    Examples
-    total_match([], []) ➞ []
-    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
-    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
-    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
-    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
-    '''
-",0.0,0.0,0.0
-"
-def is_multiply_prime(a):
-    """"""Write a function that returns true if the given number is the multiplication of 3 prime numbers
-    and false otherwise.
-    Knowing that (a) is less then 100. 
-    Example:
-    is_multiply_prime(30) == True
-    30 = 2 * 3 * 5
-    """"""
-",0.0,0.0,0.0
-"
-def is_simple_power(x, n):
-    """"""Your task is to write a function that returns true if a number x is a simple
-    power of n and false in other cases.
-    x is a simple power of n if n**int=x
-    For example:
-    is_simple_power(1, 4) => true
-    is_simple_power(2, 2) => true
-    is_simple_power(8, 2) => true
-    is_simple_power(3, 2) => false
-    is_simple_power(3, 1) => false
-    is_simple_power(5, 3) => false
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def iscube(a):
-    '''
-    Write a function that takes an integer a and returns True 
-    if this ingeger is a cube of some integer number.
-    Note: you may assume the input is always valid.
-    Examples:
-    iscube(1) ==> True
-    iscube(2) ==> False
-    iscube(-1) ==> True
-    iscube(64) ==> True
-    iscube(0) ==> True
-    iscube(180) ==> False
-    '''
-",0.0,0.0,0.0
-"
-def hex_key(num):
-    """"""You have been tasked to write a function that receives 
-    a hexadecimal number as a string and counts the number of hexadecimal 
-    digits that are primes (prime number, or a prime, is a natural number 
-    greater than 1 that is not a product of two smaller natural numbers).
-    Hexadecimal digits are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
-    Prime numbers are 2, 3, 5, 7, 11, 13, 17,...
-    So you have to determine a number of the following digits: 2, 3, 5, 7, 
-    B (=decimal 11), D (=decimal 13).
-    Note: you may assume the input is always correct or empty string, 
-    and symbols A,B,C,D,E,F are always uppercase.
-    Examples:
-    For num = ""AB"" the output should be 1.
-    For num = ""1077E"" the output should be 2.
-    For num = ""ABED1A33"" the output should be 4.
-    For num = ""123456789ABCDEF0"" the output should be 6.
-    For num = ""2020"" the output should be 2.
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-def decimal_to_binary(decimal):
-    """"""You will be given a number in decimal form and your task is to convert it to
-    binary format. The function should return a string, with each character representing a binary
-    number. Each character in the string will be '0' or '1'.
-
-    There will be an extra couple of characters 'db' at the beginning and at the end of the string.
-    The extra characters are there to help with the format.
-
-    Examples:
-    decimal_to_binary(15)   # returns ""db1111db""
-    decimal_to_binary(32)   # returns ""db100000db""
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-def is_happy(s):
-    """"""You are given a string s.
-    Your task is to check if the string is happy or not.
-    A string is happy if its length is at least 3 and every 3 consecutive letters are distinct
-    For example:
-    is_happy(a) => False
-    is_happy(aa) => False
-    is_happy(abcd) => True
-    is_happy(aabb) => False
-    is_happy(adb) => True
-    is_happy(xyy) => False
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def numerical_letter_grade(grades):
-    """"""It is the last week of the semester and the teacher has to give the grades
-    to students. The teacher has been making her own algorithm for grading.
-    The only problem is, she has lost the code she used for grading.
-    She has given you a list of GPAs for some students and you have to write 
-    a function that can output a list of letter grades using the following table:
-             GPA       |    Letter grade
-              4.0                A+
-            > 3.7                A 
-            > 3.3                A- 
-            > 3.0                B+
-            > 2.7                B 
-            > 2.3                B-
-            > 2.0                C+
-            > 1.7                C
-            > 1.3                C-
-            > 1.0                D+ 
-            > 0.7                D 
-            > 0.0                D-
-              0.0                E
-    
-
-    Example:
-    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-def prime_length(string):
-    """"""Write a function that takes a string and returns True if the string
-    length is a prime number or False otherwise
-    Examples
-    prime_length('Hello') == True
-    prime_length('abcdcba') == True
-    prime_length('kittens') == True
-    prime_length('orange') == False
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def starts_one_ends(n):
-    """"""
-    Given a positive integer n, return the count of the numbers of n-digit
-    positive integers that start or end with 1.
-    """"""
-",0.0,0.0,0.0
-"
-def solve(N):
-    """"""Given a positive integer N, return the total sum of its digits in binary.
-    
-    Example
-        For N = 1000, the sum of digits will be 1 the output should be ""1"".
-        For N = 150, the sum of digits will be 6 the output should be ""110"".
-        For N = 147, the sum of digits will be 12 the output should be ""1100"".
-    
-    Variables:
-        @N integer
-             Constraints: 0 ≤ N ≤ 10000.
-    Output:
-         a string of binary number
-    """"""
-",0.0,0.0,0.0
-"
-def add(lst):
-    """"""Given a non-empty list of integers lst. add the even elements that are at odd indices..
-
-
-    Examples:
-        add([4, 2, 6, 7]) ==> 2 
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-def anti_shuffle(s):
-    """"""
-    Write a function that takes a string and returns an ordered version of it.
-    Ordered version of string, is a string where all words (separated by space)
-    are replaced by a new word where all the characters arranged in
-    ascending order based on ascii value.
-    Note: You should keep the order of words and blank spaces in the sentence.
-
-    For example:
-    anti_shuffle('Hi') returns 'Hi'
-    anti_shuffle('hello') returns 'ehllo'
-    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def get_row(lst, x):
-    """"""
-    You are given a 2 dimensional data, as a nested lists,
-    which is similar to matrix, however, unlike matrices,
-    each row may contain a different number of columns.
-    Given lst, and integer x, find integers x in the list,
-    and return list of tuples, [(x1, y1), (x2, y2) ...] such that
-    each tuple is a coordinate - (row, columns), starting with 0.
-    Sort coordinates initially by rows in ascending order.
-    Also, sort coordinates of the row by columns in descending order.
-    
-    Examples:
-    get_row([
-      [1,2,3,4,5,6],
-      [1,2,3,4,1,6],
-      [1,2,3,4,5,1]
-    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
-    get_row([], 1) == []
-    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
-    """"""
-",0.0,0.0,0.0
-"
-def sort_array(array):
-    """"""
-    Given an array of non-negative integers, return a copy of the given array after sorting,
-    you will sort the given array in ascending order if the sum( first index value, last index value) is odd,
-    or sort it in descending order if the sum( first index value, last index value) is even.
-
-    Note:
-    * don't change the given array.
-
-    Examples:
-    * sort_array([]) => []
-    * sort_array([5]) => [5]
-    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
-    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def encrypt(s):
-    """"""Create a function encrypt that takes a string as an argument and
-    returns a string encrypted with the alphabet being rotated. 
-    The alphabet should be rotated in a manner such that the letters 
-    shift down by two multiplied to two places.
-    For example:
-    encrypt('hi') returns 'lm'
-    encrypt('asdfghjkl') returns 'ewhjklnop'
-    encrypt('gf') returns 'kj'
-    encrypt('et') returns 'ix'
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def next_smallest(lst):
-    """"""
-    You are given a list of integers.
-    Write a function next_smallest() that returns the 2nd smallest element of the list.
-    Return None if there is no such element.
-    
-    next_smallest([1, 2, 3, 4, 5]) == 2
-    next_smallest([5, 1, 4, 3, 2]) == 2
-    next_smallest([]) == None
-    next_smallest([1, 1]) == None
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def is_bored(S):
-    """"""
-    You'll be given a string of words, and your task is to count the number
-    of boredoms. A boredom is a sentence that starts with the word ""I"".
-    Sentences are delimited by '.', '?' or '!'.
-   
-    For example:
-    >>> is_bored(""Hello world"")
-    0
-    >>> is_bored(""The sky is blue. The sun is shining. I love this weather"")
-    1
-    """"""
-",0.0,0.0,0.0
-"
-def any_int(x, y, z):
-    '''
-    Create a function that takes 3 numbers.
-    Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
-    Returns false in any other cases.
-    
-    Examples
-    any_int(5, 2, 7) ➞ True
-    
-    any_int(3, 2, 2) ➞ False
-
-    any_int(3, -2, 1) ➞ True
-    
-    any_int(3.6, -2.2, 2) ➞ False
-  
-
-    
-    '''
-",0.6000000000000001,0.9963880288957688,1.0
-"
-def encode(message):
-    """"""
-    Write a function that takes a message, and encodes in such a 
-    way that it swaps case of all letters, replaces all vowels in 
-    the message with the letter that appears 2 places ahead of that 
-    vowel in the english alphabet. 
-    Assume only letters. 
-    
-    Examples:
-    >>> encode('test')
-    'TGST'
-    >>> encode('This is a message')
-    'tHKS KS C MGSSCGG'
-    """"""
-",0.0,0.0,0.0
-"
-
-def skjkasdkd(lst):
-    """"""You are given a list of integers.
-    You need to find the largest prime value and return the sum of its digits.
-
-    Examples:
-    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
-    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
-    For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13
-    For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11
-    For lst = [0,81,12,3,1,21] the output should be 3
-    For lst = [0,8,1,2,1,7] the output should be 7
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def check_dict_case(dict):
-    """"""
-    Given a dictionary, return True if all keys are strings in lower 
-    case or all keys are strings in upper case, else return False.
-    The function should return False is the given dictionary is empty.
-    Examples:
-    check_dict_case({""a"":""apple"", ""b"":""banana""}) should return True.
-    check_dict_case({""a"":""apple"", ""A"":""banana"", ""B"":""banana""}) should return False.
-    check_dict_case({""a"":""apple"", 8:""banana"", ""a"":""apple""}) should return False.
-    check_dict_case({""Name"":""John"", ""Age"":""36"", ""City"":""Houston""}) should return False.
-    check_dict_case({""STATE"":""NC"", ""ZIP"":""12345"" }) should return True.
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def count_up_to(n):
-    """"""Implement a function that takes an non-negative integer and returns an array of the first n
-    integers that are prime numbers and less than n.
-    for example:
-    count_up_to(5) => [2,3]
-    count_up_to(11) => [2,3,5,7]
-    count_up_to(0) => []
-    count_up_to(20) => [2,3,5,7,11,13,17,19]
-    count_up_to(1) => []
-    count_up_to(18) => [2,3,5,7,11,13,17]
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-def multiply(a, b):
-    """"""Complete the function that takes two integers and returns 
-    the product of their unit digits.
-    Assume the input is always valid.
-    Examples:
-    multiply(148, 412) should return 16.
-    multiply(19, 28) should return 72.
-    multiply(2020, 1851) should return 0.
-    multiply(14,-15) should return 20.
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def count_upper(s):
-    """"""
-    Given a string s, count the number of uppercase vowels in even indices.
-    
-    For example:
-    count_upper('aBCdEf') returns 1
-    count_upper('abcdefg') returns 0
-    count_upper('dBBE') returns 0
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def closest_integer(value):
-    '''
-    Create a function that takes a value (string) representing a number
-    and returns the closest integer to it. If the number is equidistant
-    from two integers, round it away from zero.
-
-    Examples
-    >>> closest_integer(""10"")
-    10
-    >>> closest_integer(""15.3"")
-    15
-
-    Note:
-    Rounding away from zero means that if the given number is equidistant
-    from two integers, the one you should return is the one that is the
-    farthest from zero. For example closest_integer(""14.5"") should
-    return 15 and closest_integer(""-14.5"") should return -15.
-    '''
-",0.0,0.0,0.0
-"
-def make_a_pile(n):
-    """"""
-    Given a positive integer n, you have to make a pile of n levels of stones.
-    The first level has n stones.
-    The number of stones in the next level is:
-        - the next odd number if n is odd.
-        - the next even number if n is even.
-    Return the number of stones in each level in a list, where element at index
-    i represents the number of stones in the level (i+1).
-
-    Examples:
-    >>> make_a_pile(3)
-    [3, 5, 7]
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def words_string(s):
-    """"""
-    You will be given a string of words separated by commas or spaces. Your task is
-    to split the string into words and return an array of the words.
-    
-    For example:
-    words_string(""Hi, my name is John"") == [""Hi"", ""my"", ""name"", ""is"", ""John""]
-    words_string(""One, two, three, four, five, six"") == [""One"", ""two"", ""three"", ""four"", ""five"", ""six""]
-    """"""
-",0.0,0.0,0.0
-"
-def choose_num(x, y):
-    """"""This function takes two positive numbers x and y and returns the
-    biggest even integer number that is in the range [x, y] inclusive. If 
-    there's no such number, then the function should return -1.
-
-    For example:
-    choose_num(12, 15) = 14
-    choose_num(13, 12) = -1
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def rounded_avg(n, m):
-    """"""You are given two positive integers n and m, and your task is to compute the
-    average of the integers from n through m (including n and m). 
-    Round the answer to the nearest integer and convert that to binary.
-    If n is greater than m, return -1.
-    Example:
-    rounded_avg(1, 5) => ""0b11""
-    rounded_avg(7, 5) => -1
-    rounded_avg(10, 20) => ""0b1111""
-    rounded_avg(20, 33) => ""0b11010""
-    """"""
-",0.0,0.0,0.0
-"
-def unique_digits(x):
-    """"""Given a list of positive integers x. return a sorted list of all 
-    elements that hasn't any even digit.
-
-    Note: Returned list should be sorted in increasing order.
-    
-    For example:
-    >>> unique_digits([15, 33, 1422, 1])
-    [1, 15, 33]
-    >>> unique_digits([152, 323, 1422, 10])
-    []
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-def by_length(arr):
-    """"""
-    Given an array of integers, sort the integers that are between 1 and 9 inclusive,
-    reverse the resulting array, and then replace each digit by its corresponding name from
-    ""One"", ""Two"", ""Three"", ""Four"", ""Five"", ""Six"", ""Seven"", ""Eight"", ""Nine"".
-
-    For example:
-      arr = [2, 1, 1, 4, 5, 8, 2, 3]   
-            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8] 
-            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
-      return [""Eight"", ""Five"", ""Four"", ""Three"", ""Two"", ""Two"", ""One"", ""One""]
-    
-      If the array is empty, return an empty array:
-      arr = []
-      return []
-    
-      If the array has any strange number ignore it:
-      arr = [1, -1 , 55] 
-            -> sort arr -> [-1, 1, 55]
-            -> reverse arr -> [55, 1, -1]
-      return = ['One']
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def f(n):
-    """""" Implement the function f that takes n as a parameter,
-    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
-    or the sum of numbers from 1 to i otherwise.
-    i starts from 1.
-    the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... * i).
-    Example:
-    f(5) == [1, 2, 6, 24, 15]
-    """"""
-",0.0,0.0,0.0
-"
-def even_odd_palindrome(n):
-    """"""
-    Given a positive integer n, return a tuple that has the number of even and odd
-    integer palindromes that fall within the range(1, n), inclusive.
-
-    Example 1:
-
-        Input: 3
-        Output: (1, 2)
-        Explanation:
-        Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.
-
-    Example 2:
-
-        Input: 12
-        Output: (4, 6)
-        Explanation:
-        Integer palindrome are 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. four of them are even, and 6 of them are odd.
-
-    Note:
-        1. 1 <= n <= 10^3
-        2. returned tuple has the number of even and odd integer palindromes respectively.
-    """"""
-",1.0,1.0,1.0
-"
-def count_nums(arr):
-    """"""
-    Write a function count_nums which takes an array of integers and returns
-    the number of elements which has a sum of digits > 0.
-    If a number is negative, then its first signed digit will be negative:
-    e.g. -123 has signed digits -1, 2, and 3.
-    >>> count_nums([]) == 0
-    >>> count_nums([-1, 11, -11]) == 1
-    >>> count_nums([1, 1, 2]) == 3
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def move_one_ball(arr):
-    """"""We have an array 'arr' of N integers arr[1], arr[2], ..., arr[N].The
-    numbers in the array will be randomly ordered. Your task is to determine if
-    it is possible to get an array sorted in non-decreasing order by performing 
-    the following operation on the given array:
-        You are allowed to perform right shift operation any number of times.
-    
-    One right shift operation means shifting all elements of the array by one
-    position in the right direction. The last element of the array will be moved to
-    the starting position in the array i.e. 0th index. 
-
-    If it is possible to obtain the sorted array by performing the above operation
-    then return True else return False.
-    If the given array is empty then return True.
-
-    Note: The given list is guaranteed to have unique elements.
-
-    For Example:
-    
-    move_one_ball([3, 4, 5, 1, 2])==>True
-    Explanation: By performin 2 right shift operations, non-decreasing order can
-                 be achieved for the given array.
-    move_one_ball([3, 5, 4, 1, 2])==>False
-    Explanation:It is not possible to get non-decreasing order for the given
-                array by performing any number of right shift operations.
-                
-    """"""
-",0.0,0.0,0.0
-"
-def exchange(lst1, lst2):
-    """"""In this problem, you will implement a function that takes two lists of numbers,
-    and determines whether it is possible to perform an exchange of elements
-    between them to make lst1 a list of only even numbers.
-    There is no limit on the number of exchanged elements between lst1 and lst2.
-    If it is possible to exchange elements between the lst1 and lst2 to make
-    all the elements of lst1 to be even, return ""YES"".
-    Otherwise, return ""NO"".
-    For example:
-    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => ""YES""
-    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => ""NO""
-    It is assumed that the input lists will be non-empty.
-    """"""
-",0.0,0.0,0.0
-"
-def histogram(test):
-    """"""Given a string representing a space separated lowercase letters, return a dictionary
-    of the letter with the most repetition and containing the corresponding count.
-    If several letters have the same occurrence, return all of them.
-    
-    Example:
-    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
-    histogram('a b b a') == {'a': 2, 'b': 2}
-    histogram('a b c a b') == {'a': 2, 'b': 2}
-    histogram('b b b b a') == {'b': 4}
-    histogram('') == {}
-
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def reverse_delete(s,c):
-    """"""Task
-    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
-    then check if the result string is palindrome.
-    A string is called palindrome if it reads the same backward as forward.
-    You should return a tuple containing the result string and True/False for the check.
-    Example
-    For s = ""abcde"", c = ""ae"", the result should be ('bcd',False)
-    For s = ""abcdef"", c = ""b""  the result should be ('acdef',False)
-    For s = ""abcdedcba"", c = ""ab"", the result should be ('cdedc',True)
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-def odd_count(lst):
-    """"""Given a list of strings, where each string consists of only digits, return a list.
-    Each element i of the output should be ""the number of odd elements in the
-    string i of the input."" where all the i's should be replaced by the number
-    of odd digits in the i'th string of the input.
-
-    >>> odd_count(['1234567'])
-    [""the number of odd elements 4n the str4ng 4 of the 4nput.""]
-    >>> odd_count(['3',""11111111""])
-    [""the number of odd elements 1n the str1ng 1 of the 1nput."",
-     ""the number of odd elements 8n the str8ng 8 of the 8nput.""]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def minSubArraySum(nums):
-    """"""
-    Given an array of integers nums, find the minimum sum of any non-empty sub-array
-    of nums.
-    Example
-    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
-    minSubArraySum([-1, -2, -3]) == -6
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def max_fill(grid, capacity):
-    import math
-    """"""
-    You are given a rectangular grid of wells. Each row represents a single well,
-    and each 1 in a row represents a single unit of water.
-    Each well has a corresponding bucket that can be used to extract water from it, 
-    and all buckets have the same capacity.
-    Your task is to use the buckets to empty the wells.
-    Output the number of times you need to lower the buckets.
-
-    Example 1:
-        Input: 
-            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
-            bucket_capacity : 1
-        Output: 6
-
-    Example 2:
-        Input: 
-            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
-            bucket_capacity : 2
-        Output: 5
-    
-    Example 3:
-        Input: 
-            grid : [[0,0,0], [0,0,0]]
-            bucket_capacity : 5
-        Output: 0
-
-    Constraints:
-        * all wells have the same length
-        * 1 <= grid.length <= 10^2
-        * 1 <= grid[:,1].length <= 10^2
-        * grid[i][j] -> 0 | 1
-        * 1 <= capacity <= 10
-    """"""
-",0.0,0.0,0.0
-"
-def sort_array(arr):
-    """"""
-    In this Kata, you have to sort an array of non-negative integers according to
-    number of ones in their binary representation in ascending order.
-    For similar number of ones, sort based on decimal value.
-
-    It must be implemented like this:
-    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
-    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
-    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
-    """"""
-",0.85,1.0,1.0
-"
-def select_words(s, n):
-    """"""Given a string s and a natural number n, you have been tasked to implement 
-    a function that returns a list of all words from string s that contain exactly 
-    n consonants, in order these words appear in the string s.
-    If the string s is empty then the function should return an empty list.
-    Note: you may assume the input string contains only letters and spaces.
-    Examples:
-    select_words(""Mary had a little lamb"", 4) ==> [""little""]
-    select_words(""Mary had a little lamb"", 3) ==> [""Mary"", ""lamb""]
-    select_words(""simple white space"", 2) ==> []
-    select_words(""Hello world"", 4) ==> [""world""]
-    select_words(""Uncle sam"", 3) ==> [""Uncle""]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def get_closest_vowel(word):
-    """"""You are given a word. Your task is to find the closest vowel that stands between 
-    two consonants from the right side of the word (case sensitive).
-    
-    Vowels in the beginning and ending doesn't count. Return empty string if you didn't
-    find any vowel met the above condition. 
-
-    You may assume that the given string contains English letter only.
-
-    Example:
-    get_closest_vowel(""yogurt"") ==> ""u""
-    get_closest_vowel(""FULL"") ==> ""U""
-    get_closest_vowel(""quick"") ==> """"
-    get_closest_vowel(""ab"") ==> """"
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def match_parens(lst):
-    '''
-    You are given a list of two strings, both strings consist of open
-    parentheses '(' or close parentheses ')' only.
-    Your job is to check if it is possible to concatenate the two strings in
-    some order, that the resulting string will be good.
-    A string S is considered to be good if and only if all parentheses in S
-    are balanced. For example: the string '(())()' is good, while the string
-    '())' is not.
-    Return 'Yes' if there's a way to make a good string, and return 'No' otherwise.
-
-    Examples:
-    match_parens(['()(', ')']) == 'Yes'
-    match_parens([')', ')']) == 'No'
-    '''
-",0.0,0.0,0.0
-"
-def maximum(arr, k):
-    """"""
-    Given an array arr of integers and a positive integer k, return a sorted list 
-    of length k with the maximum k numbers in arr.
-
-    Example 1:
-
-        Input: arr = [-3, -4, 5], k = 3
-        Output: [-4, -3, 5]
-
-    Example 2:
-
-        Input: arr = [4, -4, 4], k = 2
-        Output: [4, 4]
-
-    Example 3:
-
-        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
-        Output: [2]
-
-    Note:
-        1. The length of the array will be in the range of [1, 1000].
-        2. The elements in the array will be in the range of [-1000, 1000].
-        3. 0 <= k <= len(arr)
-    """"""
-",0.0,0.0,0.0
-"
-def solution(lst):
-    """"""Given a non-empty list of integers, return the sum of all of the odd elements that are in even positions.
-    
-
-    Examples
-    solution([5, 8, 7, 1]) ==> 12
-    solution([3, 3, 3, 3, 3]) ==> 9
-    solution([30, 13, 24, 321]) ==>0
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def add_elements(arr, k):
-    """"""
-    Given a non-empty array of integers arr and an integer k, return
-    the sum of the elements with at most two digits from the first k elements of arr.
-
-    Example:
-
-        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
-        Output: 24 # sum of 21 + 3
-
-    Constraints:
-        1. 1 <= len(arr) <= 100
-        2. 1 <= k <= len(arr)
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def get_odd_collatz(n):
-    """"""
-    Given a positive integer n, return a sorted list that has the odd numbers in collatz sequence.
-
-    The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined
-    as follows: start with any positive integer n. Then each term is obtained from the 
-    previous term as follows: if the previous term is even, the next term is one half of 
-    the previous term. If the previous term is odd, the next term is 3 times the previous
-    term plus 1. The conjecture is that no matter what value of n, the sequence will always reach 1.
-
-    Note: 
-        1. Collatz(1) is [1].
-        2. returned list sorted in increasing order.
-
-    For example:
-    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.
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def valid_date(date):
-    """"""You have to write a function which validates a given date string and
-    returns True if the date is valid otherwise False.
-    The date is valid if all of the following rules are satisfied:
-    1. The date string is not empty.
-    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.
-    3. The months should not be less than 1 or higher than 12.
-    4. The date should be in the format: mm-dd-yyyy
-
-    for example: 
-    valid_date('03-11-2000') => True
-
-    valid_date('15-01-2012') => False
-
-    valid_date('04-0-2040') => False
-
-    valid_date('06-04-2020') => True
-
-    valid_date('06/04/2020') => False
-    """"""
-",0.0,0.0,0.0
-"
-def split_words(txt):
-    '''
-    Given a string of words, return a list of words split on whitespace, if no whitespaces exists in the text you
-    should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
-    alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
-    Examples
-    split_words(""Hello world!"") ➞ [""Hello"", ""world!""]
-    split_words(""Hello,world!"") ➞ [""Hello"", ""world!""]
-    split_words(""abcdef"") == 3 
-    '''
-",0.0,0.0,0.0
-"
-def is_sorted(lst):
-    '''
-    Given a list of numbers, return whether or not they are sorted
-    in ascending order. If list has more than 1 duplicate of the same
-    number, return False. Assume no negative numbers and only integers.
-
-    Examples
-    is_sorted([5]) ➞ True
-    is_sorted([1, 2, 3, 4, 5]) ➞ True
-    is_sorted([1, 3, 2, 4, 5]) ➞ False
-    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
-    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
-    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
-    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
-    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
-    '''
-",0.0,0.0,0.0
-"
-def intersection(interval1, interval2):
-    """"""You are given two intervals,
-    where each interval is a pair of integers. For example, interval = (start, end) = (1, 2).
-    The given intervals are closed which means that the interval (start, end)
-    includes both start and end.
-    For each given interval, it is assumed that its start is less or equal its end.
-    Your task is to determine whether the length of intersection of these two 
-    intervals is a prime number.
-    Example, the intersection of the intervals (1, 3), (2, 4) is (2, 3)
-    which its length is 1, which not a prime number.
-    If the length of the intersection is a prime number, return ""YES"",
-    otherwise, return ""NO"".
-    If the two intervals don't intersect, return ""NO"".
-
-
-    [input/output] samples:
-    intersection((1, 2), (2, 3)) ==> ""NO""
-    intersection((-1, 1), (0, 4)) ==> ""NO""
-    intersection((-3, -1), (-5, 5)) ==> ""YES""
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def prod_signs(arr):
-    """"""
-    You are given an array arr of integers and you need to return
-    sum of magnitudes of integers multiplied by product of all signs
-    of each number in the array, represented by 1, -1 or 0.
-    Note: return None for empty arr.
-
-    Example:
-    >>> prod_signs([1, 2, 2, -4]) == -9
-    >>> prod_signs([0, 1]) == 0
-    >>> prod_signs([]) == None
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def minPath(grid, k):
-    """"""
-    Given a grid with N rows and N columns (N >= 2) and a positive integer k, 
-    each cell of the grid contains a value. Every integer in the range [1, N * N]
-    inclusive appears exactly once on the cells of the grid.
-
-    You have to find the minimum path of length k in the grid. You can start
-    from any cell, and in each step you can move to any of the neighbor cells,
-    in other words, you can go to cells which share an edge with you current
-    cell.
-    Please note that a path of length k means visiting exactly k cells (not
-    necessarily distinct).
-    You CANNOT go off the grid.
-    A path A (of length k) is considered less than a path B (of length k) if
-    after making the ordered lists of the values on the cells that A and B go
-    through (let's call them lst_A and lst_B), lst_A is lexicographically less
-    than lst_B, in other words, there exist an integer index i (1 <= i <= k)
-    such that lst_A[i] < lst_B[i] and for any j (1 <= j < i) we have
-    lst_A[j] = lst_B[j].
-    It is guaranteed that the answer is unique.
-    Return an ordered list of the values on the cells that the minimum path go through.
-
-    Examples:
-
-        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
-        Output: [1, 2, 1]
-
-        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
-        Output: [1]
-    """"""
-",0.0,0.0,0.0
-"
-def tri(n):
-    """"""Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in 
-    the last couple centuries. However, what people don't know is Tribonacci sequence.
-    Tribonacci sequence is defined by the recurrence:
-    tri(1) = 3
-    tri(n) = 1 + n / 2, if n is even.
-    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
-    For example:
-    tri(2) = 1 + (2 / 2) = 2
-    tri(4) = 3
-    tri(3) = tri(2) + tri(1) + tri(4)
-           = 2 + 3 + 3 = 8 
-    You are given a non-negative integer number n, you have to a return a list of the 
-    first n + 1 numbers of the Tribonacci sequence.
-    Examples:
-    tri(3) = [1, 3, 2, 8]
-    """"""
-",0.0,0.0,0.0
-"
-def digits(n):
-    """"""Given a positive integer n, return the product of the odd digits.
-    Return 0 if all digits are even.
-    For example:
-    digits(1)  == 1
-    digits(4)  == 0
-    digits(235) == 15
-    """"""
-",0.0,0.0,0.0
-"
-def is_nested(string):
-    '''
-    Create a function that takes a string as input which contains only square brackets.
-    The function should return True if and only if there is a valid subsequence of brackets 
-    where at least one bracket in the subsequence is nested.
-
-    is_nested('[[]]') ➞ True
-    is_nested('[]]]]]]][[[[[]') ➞ False
-    is_nested('[][]') ➞ False
-    is_nested('[]') ➞ False
-    is_nested('[[][]]') ➞ True
-    is_nested('[[]][[') ➞ True
-    '''
-",0.0,0.0,0.0
-"
-
-def sum_squares(lst):
-    """"""You are given a list of numbers.
-    You need to return the sum of squared numbers in the given list,
-    round each element in the list to the upper int(Ceiling) first.
-    Examples:
-    For lst = [1,2,3] the output should be 14
-    For lst = [1,4,9] the output should be 98
-    For lst = [1,3,5,7] the output should be 84
-    For lst = [1.4,4.2,0] the output should be 29
-    For lst = [-2.4,1,1] the output should be 6
-    
-
-    """"""
-",0.0,0.0,0.0
-"
-def check_if_last_char_is_a_letter(txt):
-    '''
-    Create a function that returns True if the last character
-    of a given string is an alphabetical character and is not
-    a part of a word, and False otherwise.
-    Note: ""word"" is a group of characters separated by space.
-
-    Examples:
-    check_if_last_char_is_a_letter(""apple pie"") ➞ False
-    check_if_last_char_is_a_letter(""apple pi e"") ➞ True
-    check_if_last_char_is_a_letter(""apple pi e "") ➞ False
-    check_if_last_char_is_a_letter("""") ➞ False 
-    '''
-",0.050000000000000044,0.25,0.5
-"
-def can_arrange(arr):
-    """"""Create a function which returns the largest index of an element which
-    is not greater than or equal to the element immediately preceding it. If
-    no such element exists then return -1. The given array will not contain
-    duplicate values.
-
-    Examples:
-    can_arrange([1,2,4,3,5]) = 3
-    can_arrange([1,2,3]) = -1
-    """"""
-",0.0,0.0,0.0
-"
-def largest_smallest_integers(lst):
-    '''
-    Create a function that returns a tuple (a, b), where 'a' is
-    the largest of negative integers, and 'b' is the smallest
-    of positive integers in a list.
-    If there is no negative or positive integers, return them as None.
-
-    Examples:
-    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
-    largest_smallest_integers([]) == (None, None)
-    largest_smallest_integers([0]) == (None, None)
-    '''
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def compare_one(a, b):
-    """"""
-    Create a function that takes integers, floats, or strings representing
-    real numbers, and returns the larger variable in its given variable type.
-    Return None if the values are equal.
-    Note: If a real number is represented as a string, the floating point might be . or ,
-
-    compare_one(1, 2.5) ➞ 2.5
-    compare_one(1, ""2,3"") ➞ ""2,3""
-    compare_one(""5,1"", ""6"") ➞ ""6""
-    compare_one(""1"", 1) ➞ None
-    """"""
-",0.0,0.0,0.0
-"
-def is_equal_to_sum_even(n):
-    """"""Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
-    Example
-    is_equal_to_sum_even(4) == False
-    is_equal_to_sum_even(6) == False
-    is_equal_to_sum_even(8) == True
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def special_factorial(n):
-    """"""The Brazilian factorial is defined as:
-    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
-    where n > 0
-
-    For example:
-    >>> special_factorial(4)
-    288
-
-    The function will receive an integer as input and should return the special
-    factorial of this integer.
-    """"""
-",0.0,0.0,0.0
-"
-def fix_spaces(text):
-    """"""
-    Given a string text, replace all spaces in it with underscores, 
-    and if a string has more than 2 consecutive spaces, 
-    then replace all consecutive spaces with - 
-    
-    fix_spaces(""Example"") == ""Example""
-    fix_spaces(""Example 1"") == ""Example_1""
-    fix_spaces("" Example 2"") == ""_Example_2""
-    fix_spaces("" Example   3"") == ""_Example-3""
-    """"""
-",0.0,0.0,0.0
-"
-def file_name_check(file_name):
-    """"""Create a function which takes a string representing a file's name, and returns
-    'Yes' if the the file's name is valid, and returns 'No' otherwise.
-    A file's name is considered to be valid if and only if all the following conditions 
-    are met:
-    - There should not be more than three digits ('0'-'9') in the file's name.
-    - The file's name contains exactly one dot '.'
-    - The substring before the dot should not be empty, and it starts with a letter from 
-    the latin alphapet ('a'-'z' and 'A'-'Z').
-    - The substring after the dot should be one of these: ['txt', 'exe', 'dll']
-    Examples:
-    file_name_check(""example.txt"") # => 'Yes'
-    file_name_check(""1example.dll"") # => 'No' (the name should start with a latin alphapet letter)
-    """"""
-",0.0,0.0,0.0
-"
-
-
-def sum_squares(lst):
-    """"""""
-    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 
-    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 
-    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. 
-    
-    Examples:
-    For lst = [1,2,3] the output should be 6
-    For lst = []  the output should be 0
-    For lst = [-1,-5,2,-1,-5]  the output should be -126
-    """"""
-",0.0,0.0,0.0
-"
-def words_in_sentence(sentence):
-    """"""
-    You are given a string representing a sentence,
-    the sentence contains some words separated by a space,
-    and you have to return a string that contains the words from the original sentence,
-    whose lengths are prime numbers,
-    the order of the words in the new string should be the same as the original one.
-
-    Example 1:
-        Input: sentence = ""This is a test""
-        Output: ""is""
-
-    Example 2:
-        Input: sentence = ""lets go for swimming""
-        Output: ""go for""
-
-    Constraints:
-        * 1 <= len(sentence) <= 100
-        * sentence contains only letters
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-def simplify(x, n):
-    """"""Your task is to implement a function that will simplify the expression
-    x * n. The function returns True if x * n evaluates to a whole number and False
-    otherwise. Both x and n, are string representation of a fraction, and have the following format,
-    <numerator>/<denominator> where both numerator and denominator are positive whole numbers.
-
-    You can assume that x, and n are valid fractions, and do not have zero as denominator.
-
-    simplify(""1/5"", ""5/1"") = True
-    simplify(""1/6"", ""2/1"") = False
-    simplify(""7/10"", ""10/2"") = False
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def order_by_points(nums):
-    """"""
-    Write a function which sorts the given list of integers
-    in ascending order according to the sum of their digits.
-    Note: if there are several items with similar sum of their digits,
-    order them based on their index in original list.
-
-    For example:
-    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
-    >>> order_by_points([]) == []
-    """"""
-",0.0,0.0,0.0
-"
-def specialFilter(nums):
-    """"""Write a function that takes an array of numbers as input and returns 
-    the number of elements in the array that are greater than 10 and both 
-    first and last digits of a number are odd (1, 3, 5, 7, 9).
-    For example:
-    specialFilter([15, -73, 14, -15]) => 1 
-    specialFilter([33, -2, -3, 45, 21, 109]) => 2
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def get_max_triples(n):
-    """"""
-    You are given a positive integer n. You have to create an integer array a of length n.
-        For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
-        Return the number of triples (a[i], a[j], a[k]) of a where i < j < k, 
-    and a[i] + a[j] + a[k] is a multiple of 3.
-
-    Example :
-        Input: n = 5
-        Output: 1
-        Explanation: 
-        a = [1, 3, 7, 13, 21]
-        The only valid triple is (1, 7, 13).
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def bf(planet1, planet2):
-    '''
-    There are eight planets in our solar system: the closerst to the Sun 
-    is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn, 
-    Uranus, Neptune.
-    Write a function that takes two planet names as strings planet1 and planet2. 
-    The function should return a tuple containing all planets whose orbits are 
-    located between the orbit of planet1 and the orbit of planet2, sorted by 
-    the proximity to the sun. 
-    The function should return an empty tuple if planet1 or planet2
-    are not correct planet names. 
-    Examples
-    bf(""Jupiter"", ""Neptune"") ==> (""Saturn"", ""Uranus"")
-    bf(""Earth"", ""Mercury"") ==> (""Venus"")
-    bf(""Mercury"", ""Uranus"") ==> (""Venus"", ""Earth"", ""Mars"", ""Jupiter"", ""Saturn"")
-    '''
-",0.85,1.0,1.0
-"
-def sorted_list_sum(lst):
-    """"""Write a function that accepts a list of strings as a parameter,
-    deletes the strings that have odd lengths from it,
-    and returns the resulted list with a sorted order,
-    The list is always a list of strings and never an array of numbers,
-    and it may contain duplicates.
-    The order of the list should be ascending by length of each word, and you
-    should return the list sorted by that rule.
-    If two words have the same length, sort the list alphabetically.
-    The function should return a list of strings in sorted order.
-    You may assume that all words will have the same length.
-    For example:
-    assert list_sort([""aa"", ""a"", ""aaa""]) => [""aa""]
-    assert list_sort([""ab"", ""a"", ""aaa"", ""cd""]) => [""ab"", ""cd""]
-    """"""
-",0.0,0.0,0.0
-"
-def x_or_y(n, x, y):
-    """"""A simple program which should return the value of x if n is 
-    a prime number and should return the value of y otherwise.
-
-    Examples:
-    for x_or_y(7, 34, 12) == 34
-    for x_or_y(15, 8, 5) == 5
-    
-    """"""
-",0.0,0.0,0.0
-"
-def double_the_difference(lst):
-    '''
-    Given a list of numbers, return the sum of squares of the numbers
-    in the list that are odd. Ignore numbers that are negative or not integers.
-    
-    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
-    double_the_difference([-1, -2, 0]) == 0
-    double_the_difference([9, -2]) == 81
-    double_the_difference([0]) == 0  
-   
-    If the input list is empty, return 0.
-    '''
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-def compare(game,guess):
-    """"""I think we all remember that feeling when the result of some long-awaited
-    event is finally known. The feelings and thoughts you have at that moment are
-    definitely worth noting down and comparing.
-    Your task is to determine if a person correctly guessed the results of a number of matches.
-    You are given two arrays of scores and guesses of equal length, where each index shows a match. 
-    Return an array of the same length denoting how far off each guess was. If they have guessed correctly,
-    the value is 0, and if not, the value is the absolute difference between the guess and the score.
-    
-    
-    example:
-
-    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
-    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-def Strongest_Extension(class_name, extensions):
-    """"""You will be given the name of a class (a string) and a list of extensions.
-    The extensions are to be used to load additional classes to the class. The
-    strength of the extension is as follows: Let CAP be the number of the uppercase
-    letters in the extension's name, and let SM be the number of lowercase letters 
-    in the extension's name, the strength is given by the fraction CAP - SM. 
-    You should find the strongest extension and return a string in this 
-    format: ClassName.StrongestExtensionName.
-    If there are two or more extensions with the same strength, you should
-    choose the one that comes first in the list.
-    For example, if you are given ""Slices"" as the class and a list of the
-    extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] then you should
-    return 'Slices.SErviNGSliCes' since 'SErviNGSliCes' is the strongest extension 
-    (its strength is -1).
-    Example:
-    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def cycpattern_check(a , b):
-    """"""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
-    cycpattern_check(""abcd"",""abd"") => False
-    cycpattern_check(""hello"",""ell"") => True
-    cycpattern_check(""whassup"",""psus"") => False
-    cycpattern_check(""abab"",""baa"") => True
-    cycpattern_check(""efef"",""eeff"") => False
-    cycpattern_check(""himenss"",""simen"") => True
-
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def even_odd_count(num):
-    """"""Given an integer. return a tuple that has the number of even and odd digits respectively.
-
-     Example:
-        even_odd_count(-12) ==> (1, 1)
-        even_odd_count(123) ==> (1, 2)
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"
-def int_to_mini_roman(number):
-    """"""
-    Given a positive integer, obtain its roman numeral equivalent as a string,
-    and return it in lowercase.
-    Restrictions: 1 <= num <= 1000
-
-    Examples:
-    >>> int_to_mini_roman(19) == 'xix'
-    >>> int_to_mini_roman(152) == 'clii'
-    >>> int_to_mini_roman(426) == 'cdxxvi'
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"
-def right_angle_triangle(a, b, c):
-    '''
-    Given the lengths of the three sides of a triangle. Return True if the three
-    sides form a right-angled triangle, False otherwise.
-    A right-angled triangle is a triangle in which one angle is right angle or 
-    90 degree.
-    Example:
-    right_angle_triangle(3, 4, 5) == True
-    right_angle_triangle(1, 2, 3) == False
-    '''
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-def find_max(words):
-    """"""Write a function that accepts a list of strings.
-    The list contains different words. Return the word with maximum number
-    of unique characters. If multiple strings have maximum number of unique
-    characters, return the one which comes first in lexicographical order.
-
-    find_max([""name"", ""of"", ""string""]) == ""string""
-    find_max([""name"", ""enam"", ""game""]) == ""enam""
-    find_max([""aaaaaaa"", ""bb"" ,""cc""]) == """"aaaaaaa""
-    """"""
-",0.85,1.0,1.0
-"
-def eat(number, need, remaining):
-    """"""
-    You're a hungry rabbit, and you already have eaten a certain number of carrots,
-    but now you need to eat more carrots to complete the day's meals.
-    you should return an array of [ total number of eaten carrots after your meals,
-                                    the number of carrots left after your meals ]
-    if there are not enough remaining carrots, you will eat all remaining carrots, but will still be hungry.
-    
-    Example:
-    * eat(5, 6, 10) -> [11, 4]
-    * eat(4, 8, 9) -> [12, 1]
-    * eat(1, 10, 10) -> [11, 0]
-    * eat(2, 11, 5) -> [7, 0]
-    
-    Variables:
-    @number : integer
-        the number of carrots that you have eaten.
-    @need : integer
-        the number of carrots that you need to eat.
-    @remaining : integer
-        the number of remaining carrots thet exist in stock
-    
-    Constrain:
-    * 0 <= number <= 1000
-    * 0 <= need <= 1000
-    * 0 <= remaining <= 1000
-
-    Have fun :)
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-def do_algebra(operator, operand):
-    """"""
-    Given two lists operator, and operand. The first list has basic algebra operations, and 
-    the second list is a list of integers. Use the two given lists to build the algebric 
-    expression and return the evaluation of this expression.
-
-    The basic algebra operations:
-    Addition ( + ) 
-    Subtraction ( - ) 
-    Multiplication ( * ) 
-    Floor division ( // ) 
-    Exponentiation ( ** ) 
-
-    Example:
-    operator['+', '*', '-']
-    array = [2, 3, 4, 5]
-    result = 2 + 3 * 4 - 5
-    => result = 9
-
-    Note:
-        The length of operator list is equal to the length of operand list minus one.
-        Operand is a list of of non-negative integers.
-        Operator list has at least one operator, and operand list has at least two operands.
-
-    """"""
-",0.0,0.0,0.0
-"
-def solve(s):
-    """"""You are given a string s.
-    if s[i] is a letter, reverse its case from lower to upper or vise versa, 
-    otherwise keep it as it is.
-    If the string contains no letters, reverse the string.
-    The function should return the resulted string.
-    Examples
-    solve(""1234"") = ""4321""
-    solve(""ab"") = ""AB""
-    solve(""#a@C"") = ""#A@c""
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-def string_to_md5(text):
-    """"""
-    Given a string 'text', return its md5 hash equivalent string.
-    If 'text' is an empty string, return None.
-
-    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def generate_integers(a, b):
-    """"""
-    Given two positive integers a and b, return the even digits between a
-    and b, in ascending order.
-
-    For example:
-    generate_integers(2, 8) => [2, 4, 6, 8]
-    generate_integers(8, 2) => [2, 4, 6, 8]
-    generate_integers(10, 14) => []
-    """"""
-",0.0,0.0,0.0

demo/data/coding/humaneval/csv/3.csv

@@ -1,2413 +0,0 @@
-prompt,pass@1,pass@5,pass@10
-"from typing import List
-
-
-def has_close_elements(numbers: List[float], threshold: float) -> bool:
-    """""" Check if in given list of numbers, are any two numbers closer to each other than
-    given threshold.
-    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
-    False
-    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
-    True
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"from typing import List
-
-
-def separate_paren_groups(paren_string: str) -> List[str]:
-    """""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
-    separate those group into separate strings and return the list of those.
-    Separate groups are balanced (each open brace is properly closed) and not nested within each other
-    Ignore any spaces in the input string.
-    >>> separate_paren_groups('( ) (( )) (( )( ))')
-    ['()', '(())', '(()())']
-    """"""
-",0.0,0.0,0.0
-"
-
-def truncate_number(number: float) -> float:
-    """""" Given a positive floating point number, it can be decomposed into
-    and integer part (largest integer smaller than given number) and decimals
-    (leftover part always smaller than 1).
-
-    Return the decimal part of the number.
-    >>> truncate_number(3.5)
-    0.5
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"from typing import List
-
-
-def below_zero(operations: List[int]) -> bool:
-    """""" You're given a list of deposit and withdrawal operations on a bank account that starts with
-    zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
-    at that point function should return True. Otherwise it should return False.
-    >>> below_zero([1, 2, 3])
-    False
-    >>> below_zero([1, 2, -4, 5])
-    True
-    """"""
-",1.0,1.0,1.0
-"from typing import List
-
-
-def mean_absolute_deviation(numbers: List[float]) -> float:
-    """""" For a given list of input numbers, calculate Mean Absolute Deviation
-    around the mean of this dataset.
-    Mean Absolute Deviation is the average absolute difference between each
-    element and a centerpoint (mean in this case):
-    MAD = average | x - x_mean |
-    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
-    1.0
-    """"""
-",1.0,1.0,1.0
-"from typing import List
-
-
-def intersperse(numbers: List[int], delimeter: int) -> List[int]:
-    """""" Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
-    >>> intersperse([], 4)
-    []
-    >>> intersperse([1, 2, 3], 4)
-    [1, 4, 2, 4, 3]
-    """"""
-",0.0,0.0,0.0
-"from typing import List
-
-
-def parse_nested_parens(paren_string: str) -> List[int]:
-    """""" Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
-    For each of the group, output the deepest level of nesting of parentheses.
-    E.g. (()()) has maximum two levels of nesting while ((())) has three.
-
-    >>> parse_nested_parens('(()()) ((())) () ((())()())')
-    [2, 3, 1, 3]
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"from typing import List
-
-
-def filter_by_substring(strings: List[str], substring: str) -> List[str]:
-    """""" Filter an input list of strings only for ones that contain given substring
-    >>> filter_by_substring([], 'a')
-    []
-    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
-    ['abc', 'bacd', 'array']
-    """"""
-",0.95,1.0,1.0
-"from typing import List, Tuple
-
-
-def sum_product(numbers: List[int]) -> Tuple[int, int]:
-    """""" For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.
-    Empty sum should be equal to 0 and empty product should be equal to 1.
-    >>> sum_product([])
-    (0, 1)
-    >>> sum_product([1, 2, 3, 4])
-    (10, 24)
-    """"""
-",1.0,1.0,1.0
-"from typing import List, Tuple
-
-
-def rolling_max(numbers: List[int]) -> List[int]:
-    """""" From a given list of integers, generate a list of rolling maximum element found until given moment
-    in the sequence.
-    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
-    [1, 2, 3, 3, 3, 4, 4]
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-
-def is_palindrome(string: str) -> bool:
-    """""" Test if given string is a palindrome """"""
-    return string == string[::-1]
-
-
-def make_palindrome(string: str) -> str:
-    """""" Find the shortest palindrome that begins with a supplied string.
-    Algorithm idea is simple:
-    - Find the longest postfix of supplied string that is a palindrome.
-    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
-    >>> make_palindrome('')
-    ''
-    >>> make_palindrome('cat')
-    'catac'
-    >>> make_palindrome('cata')
-    'catac'
-    """"""
-",0.0,0.0,0.0
-"from typing import List
-
-
-def string_xor(a: str, b: str) -> str:
-    """""" Input are two strings a and b consisting only of 1s and 0s.
-    Perform binary XOR on these inputs and return result also as a string.
-    >>> string_xor('010', '110')
-    '100'
-    """"""
-",0.7,0.9996130030959752,1.0
-"from typing import List, Optional
-
-
-def longest(strings: List[str]) -> Optional[str]:
-    """""" Out of list of strings, return the longest one. Return the first one in case of multiple
-    strings of the same length. Return None in case the input list is empty.
-    >>> longest([])
-
-    >>> longest(['a', 'b', 'c'])
-    'a'
-    >>> longest(['a', 'bb', 'ccc'])
-    'ccc'
-    """"""
-",1.0,1.0,1.0
-"
-
-def greatest_common_divisor(a: int, b: int) -> int:
-    """""" Return a greatest common divisor of two integers a and b
-    >>> greatest_common_divisor(3, 5)
-    1
-    >>> greatest_common_divisor(25, 15)
-    5
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"from typing import List
-
-
-def all_prefixes(string: str) -> List[str]:
-    """""" Return list of all prefixes from shortest to longest of the input string
-    >>> all_prefixes('abc')
-    ['a', 'ab', 'abc']
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-
-def string_sequence(n: int) -> str:
-    """""" Return a string containing space-delimited numbers starting from 0 upto n inclusive.
-    >>> string_sequence(0)
-    '0'
-    >>> string_sequence(5)
-    '0 1 2 3 4 5'
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-
-def count_distinct_characters(string: str) -> int:
-    """""" Given a string, find out how many distinct characters (regardless of case) does it consist of
-    >>> count_distinct_characters('xyzXYZ')
-    3
-    >>> count_distinct_characters('Jerry')
-    4
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"from typing import List
-
-
-def parse_music(music_string: str) -> List[int]:
-    """""" Input to this function is a string representing musical notes in a special ASCII format.
-    Your task is to parse this string and return list of integers corresponding to how many beats does each
-    not last.
-
-    Here is a legend:
-    'o' - whole note, lasts four beats
-    'o|' - half note, lasts two beats
-    '.|' - quater note, lasts one beat
-
-    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
-    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
-    """"""
-",0.85,1.0,1.0
-"
-
-def how_many_times(string: str, substring: str) -> int:
-    """""" Find how many times a given substring can be found in the original string. Count overlaping cases.
-    >>> how_many_times('', 'a')
-    0
-    >>> how_many_times('aaa', 'a')
-    3
-    >>> how_many_times('aaaa', 'aa')
-    3
-    """"""
-",0.7,0.9996130030959752,1.0
-"from typing import List
-
-
-def sort_numbers(numbers: str) -> str:
-    """""" Input is a space-delimited string of numberals from 'zero' to 'nine'.
-    Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
-    Return the string with numbers sorted from smallest to largest
-    >>> sort_numbers('three one five')
-    'one three five'
-    """"""
-",0.0,0.0,0.0
-"from typing import List, Tuple
-
-
-def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
-    """""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
-    other and return them in order (smaller number, larger number).
-    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
-    (2.0, 2.2)
-    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
-    (2.0, 2.0)
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"from typing import List
-
-
-def rescale_to_unit(numbers: List[float]) -> List[float]:
-    """""" Given list of numbers (of at least two elements), apply a linear transform to that list,
-    such that the smallest number will become 0 and the largest will become 1
-    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
-    [0.0, 0.25, 0.5, 0.75, 1.0]
-    """"""
-",0.8999999999999999,1.0,1.0
-"from typing import List, Any
-
-
-def filter_integers(values: List[Any]) -> List[int]:
-    """""" Filter given list of any python values only for integers
-    >>> filter_integers(['a', 3.14, 5])
-    [5]
-    >>> filter_integers([1, 2, 3, 'abc', {}, []])
-    [1, 2, 3]
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-
-def strlen(string: str) -> int:
-    """""" Return length of given string
-    >>> strlen('')
-    0
-    >>> strlen('abc')
-    3
-    """"""
-",0.75,0.9999355005159959,1.0
-"
-
-def largest_divisor(n: int) -> int:
-    """""" For a given number n, find the largest number that divides n evenly, smaller than n
-    >>> largest_divisor(15)
-    5
-    """"""
-",0.0,0.0,0.0
-"from typing import List
-
-
-def factorize(n: int) -> List[int]:
-    """""" Return list of prime factors of given integer in the order from smallest to largest.
-    Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
-    Input number should be equal to the product of all factors
-    >>> factorize(8)
-    [2, 2, 2]
-    >>> factorize(25)
-    [5, 5]
-    >>> factorize(70)
-    [2, 5, 7]
-    """"""
-",1.0,1.0,1.0
-"from typing import List
-
-
-def remove_duplicates(numbers: List[int]) -> List[int]:
-    """""" From a list of integers, remove all elements that occur more than once.
-    Keep order of elements left the same as in the input.
-    >>> remove_duplicates([1, 2, 3, 2, 4])
-    [1, 3, 4]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-
-def flip_case(string: str) -> str:
-    """""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
-    >>> flip_case('Hello')
-    'hELLO'
-    """"""
-",0.95,1.0,1.0
-"from typing import List
-
-
-def concatenate(strings: List[str]) -> str:
-    """""" Concatenate list of strings into a single string
-    >>> concatenate([])
-    ''
-    >>> concatenate(['a', 'b', 'c'])
-    'abc'
-    """"""
-",0.85,1.0,1.0
-"from typing import List
-
-
-def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
-    """""" Filter an input list of strings only for ones that start with a given prefix.
-    >>> filter_by_prefix([], 'a')
-    []
-    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
-    ['abc', 'array']
-    """"""
-",0.95,1.0,1.0
-"
-
-def get_positive(l: list):
-    """"""Return only positive numbers in the list.
-    >>> get_positive([-1, 2, -4, 5, 6])
-    [2, 5, 6]
-    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
-    [5, 3, 2, 3, 9, 123, 1]
-    """"""
-",0.75,0.9999355005159959,1.0
-"
-
-def is_prime(n):
-    """"""Return true if a given number is prime, and false otherwise.
-    >>> is_prime(6)
-    False
-    >>> is_prime(101)
-    True
-    >>> is_prime(11)
-    True
-    >>> is_prime(13441)
-    True
-    >>> is_prime(61)
-    True
-    >>> is_prime(4)
-    False
-    >>> is_prime(1)
-    False
-    """"""
-",0.7,0.9996130030959752,1.0
-"import math
-
-
-def poly(xs: list, x: float):
-    """"""
-    Evaluates polynomial with coefficients xs at point x.
-    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
-    """"""
-    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
-
-
-def find_zero(xs: list):
-    """""" xs are coefficients of a polynomial.
-    find_zero find x such that poly(x) = 0.
-    find_zero returns only only zero point, even if there are many.
-    Moreover, find_zero only takes list xs having even number of coefficients
-    and largest non zero coefficient as it guarantees
-    a solution.
-    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
-    -0.5
-    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
-    1.0
-    """"""
-",0.0,0.0,0.0
-"
-
-def sort_third(l: list):
-    """"""This function takes a list l and returns a list l' such that
-    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
-    to the values of the corresponding indicies of l, but sorted.
-    >>> sort_third([1, 2, 3])
-    [1, 2, 3]
-    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
-    [2, 6, 3, 4, 8, 9, 5]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-
-def unique(l: list):
-    """"""Return sorted unique elements in a list
-    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
-    [0, 2, 3, 5, 9, 123]
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-
-def max_element(l: list):
-    """"""Return maximum element in the list.
-    >>> max_element([1, 2, 3])
-    3
-    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
-    123
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-
-def fizz_buzz(n: int):
-    """"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
-    >>> fizz_buzz(50)
-    0
-    >>> fizz_buzz(78)
-    2
-    >>> fizz_buzz(79)
-    3
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-
-def sort_even(l: list):
-    """"""This function takes a list l and returns a list l' such that
-    l' is identical to l in the odd indicies, while its values at the even indicies are equal
-    to the values of the even indicies of l, but sorted.
-    >>> sort_even([1, 2, 3])
-    [1, 2, 3]
-    >>> sort_even([5, 6, 3, 4])
-    [3, 6, 5, 4]
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-
-def encode_cyclic(s: str):
-    """"""
-    returns encoded string by cycling groups of three characters.
-    """"""
-    # split string to groups. Each of length 3.
-    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
-    # cycle elements in each group. Unless group has fewer elements than 3.
-    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
-    return """".join(groups)
-
-
-def decode_cyclic(s: str):
-    """"""
-    takes as input string encoded with encode_cyclic function. Returns decoded string.
-    """"""
-",0.0,0.0,0.0
-"
-
-def prime_fib(n: int):
-    """"""
-    prime_fib returns n-th number that is a Fibonacci number and it's also prime.
-    >>> prime_fib(1)
-    2
-    >>> prime_fib(2)
-    3
-    >>> prime_fib(3)
-    5
-    >>> prime_fib(4)
-    13
-    >>> prime_fib(5)
-    89
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-
-def triples_sum_to_zero(l: list):
-    """"""
-    triples_sum_to_zero takes a list of integers as an input.
-    it returns True if there are three distinct elements in the list that
-    sum to zero, and False otherwise.
-
-    >>> triples_sum_to_zero([1, 3, 5, 0])
-    False
-    >>> triples_sum_to_zero([1, 3, -2, 1])
-    True
-    >>> triples_sum_to_zero([1, 2, 3, 7])
-    False
-    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
-    True
-    >>> triples_sum_to_zero([1])
-    False
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-
-def car_race_collision(n: int):
-    """"""
-    Imagine a road that's a perfectly straight infinitely long line.
-    n cars are driving left to right;  simultaneously, a different set of n cars
-    are driving right to left.   The two sets of cars start out being very far from
-    each other.  All cars move in the same speed.  Two cars are said to collide
-    when a car that's moving left to right hits a car that's moving right to left.
-    However, the cars are infinitely sturdy and strong; as a result, they continue moving
-    in their trajectory as if they did not collide.
-
-    This function outputs the number of such collisions.
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-
-def incr_list(l: list):
-    """"""Return list with elements incremented by 1.
-    >>> incr_list([1, 2, 3])
-    [2, 3, 4]
-    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
-    [6, 4, 6, 3, 4, 4, 10, 1, 124]
-    """"""
-",0.7999999999999999,1.0,1.0
-"
-
-def pairs_sum_to_zero(l):
-    """"""
-    pairs_sum_to_zero takes a list of integers as an input.
-    it returns True if there are two distinct elements in the list that
-    sum to zero, and False otherwise.
-    >>> pairs_sum_to_zero([1, 3, 5, 0])
-    False
-    >>> pairs_sum_to_zero([1, 3, -2, 1])
-    False
-    >>> pairs_sum_to_zero([1, 2, 3, 7])
-    False
-    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
-    True
-    >>> pairs_sum_to_zero([1])
-    False
-    """"""
-",1.0,1.0,1.0
-"
-
-def change_base(x: int, base: int):
-    """"""Change numerical base of input number x to base.
-    return string representation after the conversion.
-    base numbers are less than 10.
-    >>> change_base(8, 3)
-    '22'
-    >>> change_base(8, 2)
-    '1000'
-    >>> change_base(7, 2)
-    '111'
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-
-def triangle_area(a, h):
-    """"""Given length of a side and high return area for a triangle.
-    >>> triangle_area(5, 3)
-    7.5
-    """"""
-",0.85,1.0,1.0
-"
-
-def fib4(n: int):
-    """"""The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
-    fib4(0) -> 0
-    fib4(1) -> 0
-    fib4(2) -> 2
-    fib4(3) -> 0
-    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
-    Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
-    >>> fib4(5)
-    4
-    >>> fib4(6)
-    8
-    >>> fib4(7)
-    14
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-
-def median(l: list):
-    """"""Return median of elements in the list l.
-    >>> median([3, 1, 2, 4, 5])
-    3
-    >>> median([-10, 4, 6, 1000, 10, 20])
-    15.0
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-
-def is_palindrome(text: str):
-    """"""
-    Checks if given string is a palindrome
-    >>> is_palindrome('')
-    True
-    >>> is_palindrome('aba')
-    True
-    >>> is_palindrome('aaaaa')
-    True
-    >>> is_palindrome('zbcd')
-    False
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-
-def modp(n: int, p: int):
-    """"""Return 2^n modulo p (be aware of numerics).
-    >>> modp(3, 5)
-    3
-    >>> modp(1101, 101)
-    2
-    >>> modp(0, 101)
-    1
-    >>> modp(3, 11)
-    8
-    >>> modp(100, 101)
-    1
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-
-def encode_shift(s: str):
-    """"""
-    returns encoded string by shifting every character by 5 in the alphabet.
-    """"""
-    return """".join([chr(((ord(ch) + 5 - ord(""a"")) % 26) + ord(""a"")) for ch in s])
-
-
-def decode_shift(s: str):
-    """"""
-    takes as input string encoded with encode_shift function. Returns decoded string.
-    """"""
-",1.0,1.0,1.0
-"
-
-def remove_vowels(text):
-    """"""
-    remove_vowels is a function that takes string and returns string without vowels.
-    >>> remove_vowels('')
-    ''
-    >>> remove_vowels(""abcdef\nghijklm"")
-    'bcdf\nghjklm'
-    >>> remove_vowels('abcdef')
-    'bcdf'
-    >>> remove_vowels('aaaaa')
-    ''
-    >>> remove_vowels('aaBAA')
-    'B'
-    >>> remove_vowels('zbcd')
-    'zbcd'
-    """"""
-",0.85,1.0,1.0
-"
-
-def below_threshold(l: list, t: int):
-    """"""Return True if all numbers in the list l are below threshold t.
-    >>> below_threshold([1, 2, 4, 10], 100)
-    True
-    >>> below_threshold([1, 20, 4, 10], 5)
-    False
-    """"""
-",0.7999999999999999,1.0,1.0
-"
-
-def add(x: int, y: int):
-    """"""Add two numbers x and y
-    >>> add(2, 3)
-    5
-    >>> add(5, 7)
-    12
-    """"""
-",0.95,1.0,1.0
-"
-
-def same_chars(s0: str, s1: str):
-    """"""
-    Check if two words have the same characters.
-    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
-    True
-    >>> same_chars('abcd', 'dddddddabc')
-    True
-    >>> same_chars('dddddddabc', 'abcd')
-    True
-    >>> same_chars('eabcd', 'dddddddabc')
-    False
-    >>> same_chars('abcd', 'dddddddabce')
-    False
-    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
-    False
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-
-def fib(n: int):
-    """"""Return n-th Fibonacci number.
-    >>> fib(10)
-    55
-    >>> fib(1)
-    1
-    >>> fib(8)
-    21
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-
-def correct_bracketing(brackets: str):
-    """""" brackets is a string of ""<"" and "">"".
-    return True if every opening bracket has a corresponding closing bracket.
-
-    >>> correct_bracketing(""<"")
-    False
-    >>> correct_bracketing(""<>"")
-    True
-    >>> correct_bracketing(""<<><>>"")
-    True
-    >>> correct_bracketing(""><<>"")
-    False
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-
-def monotonic(l: list):
-    """"""Return True is list elements are monotonically increasing or decreasing.
-    >>> monotonic([1, 2, 4, 20])
-    True
-    >>> monotonic([1, 20, 4, 10])
-    False
-    >>> monotonic([4, 1, 0, -10])
-    True
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-
-def common(l1: list, l2: list):
-    """"""Return sorted unique common elements for two lists.
-    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
-    [1, 5, 653]
-    >>> common([5, 3, 2, 8], [3, 2])
-    [2, 3]
-
-    """"""
-",0.75,0.9999355005159959,1.0
-"
-
-def largest_prime_factor(n: int):
-    """"""Return the largest prime factor of n. Assume n > 1 and is not a prime.
-    >>> largest_prime_factor(13195)
-    29
-    >>> largest_prime_factor(2048)
-    2
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-
-def sum_to_n(n: int):
-    """"""sum_to_n is a function that sums numbers from 1 to n.
-    >>> sum_to_n(30)
-    465
-    >>> sum_to_n(100)
-    5050
-    >>> sum_to_n(5)
-    15
-    >>> sum_to_n(10)
-    55
-    >>> sum_to_n(1)
-    1
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-
-def correct_bracketing(brackets: str):
-    """""" brackets is a string of ""("" and "")"".
-    return True if every opening bracket has a corresponding closing bracket.
-
-    >>> correct_bracketing(""("")
-    False
-    >>> correct_bracketing(""()"")
-    True
-    >>> correct_bracketing(""(()())"")
-    True
-    >>> correct_bracketing("")(()"")
-    False
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-
-def derivative(xs: list):
-    """""" xs represent coefficients of a polynomial.
-    xs[0] + xs[1] * x + xs[2] * x^2 + ....
-     Return derivative of this polynomial in the same form.
-    >>> derivative([3, 1, 2, 4, 5])
-    [1, 4, 12, 20]
-    >>> derivative([1, 2, 3])
-    [2, 6]
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-
-def fibfib(n: int):
-    """"""The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
-    fibfib(0) == 0
-    fibfib(1) == 0
-    fibfib(2) == 1
-    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
-    Please write a function to efficiently compute the n-th element of the fibfib number sequence.
-    >>> fibfib(1)
-    0
-    >>> fibfib(5)
-    4
-    >>> fibfib(8)
-    24
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-FIX = """"""
-Add more test cases.
-""""""
-
-def vowels_count(s):
-    """"""Write a function vowels_count which takes a string representing
-    a word as input and returns the number of vowels in the string.
-    Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
-    vowel, but only when it is at the end of the given word.
-
-    Example:
-    >>> vowels_count(""abcde"")
-    2
-    >>> vowels_count(""ACEDY"")
-    3
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-def circular_shift(x, shift):
-    """"""Circular shift the digits of the integer x, shift the digits right by shift
-    and return the result as a string.
-    If shift > number of digits, return digits reversed.
-    >>> circular_shift(12, 1)
-    ""21""
-    >>> circular_shift(12, 2)
-    ""12""
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def digitSum(s):
-    """"""Task
-    Write a function that takes a string as input and returns the sum of the upper characters only'
-    ASCII codes.
-
-    Examples:
-        digitSum("""") => 0
-        digitSum(""abAB"") => 131
-        digitSum(""abcCd"") => 67
-        digitSum(""helloE"") => 69
-        digitSum(""woArBld"") => 131
-        digitSum(""aAaaaXa"") => 153
-    """"""
-",0.7999999999999999,1.0,1.0
-"
-def fruit_distribution(s,n):
-    """"""
-    In this task, you will be given a string that represents a number of apples and oranges 
-    that are distributed in a basket of fruit this basket contains 
-    apples, oranges, and mango fruits. Given the string that represents the total number of 
-    the oranges and apples and an integer that represent the total number of the fruits 
-    in the basket return the number of the mango fruits in the basket.
-    for examble:
-    fruit_distribution(""5 apples and 6 oranges"", 19) ->19 - 5 - 6 = 8
-    fruit_distribution(""0 apples and 1 oranges"",3) -> 3 - 0 - 1 = 2
-    fruit_distribution(""2 apples and 3 oranges"", 100) -> 100 - 2 - 3 = 95
-    fruit_distribution(""100 apples and 1 oranges"",120) -> 120 - 100 - 1 = 19
-    """"""
-",0.0,0.0,0.0
-"
-def pluck(arr):
-    """"""
-    ""Given an array representing a branch of a tree that has non-negative integer nodes
-    your task is to pluck one of the nodes and return it.
-    The plucked node should be the node with the smallest even value.
-    If multiple nodes with the same smallest even value are found return the node that has smallest index.
-
-    The plucked node should be returned in a list, [ smalest_value, its index ],
-    If there are no even values or the given array is empty, return [].
-
-    Example 1:
-        Input: [4,2,3]
-        Output: [2, 1]
-        Explanation: 2 has the smallest even value, and 2 has the smallest index.
-
-    Example 2:
-        Input: [1,2,3]
-        Output: [2, 1]
-        Explanation: 2 has the smallest even value, and 2 has the smallest index. 
-
-    Example 3:
-        Input: []
-        Output: []
-    
-    Example 4:
-        Input: [5, 0, 3, 0, 4, 2]
-        Output: [0, 1]
-        Explanation: 0 is the smallest value, but  there are two zeros,
-                     so we will choose the first zero, which has the smallest index.
-
-    Constraints:
-        * 1 <= nodes.length <= 10000
-        * 0 <= node.value
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-def search(lst):
-    '''
-    You are given a non-empty list of positive integers. Return the greatest integer that is greater than 
-    zero, and has a frequency greater than or equal to the value of the integer itself. 
-    The frequency of an integer is the number of times it appears in the list.
-    If no such a value exist, return -1.
-    Examples:
-        search([4, 1, 2, 2, 3, 1]) == 2
-        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
-        search([5, 5, 4, 4, 4]) == -1
-    '''
-",0.0,0.0,0.0
-"
-def strange_sort_list(lst):
-    '''
-    Given list of integers, return list in strange order.
-    Strange sorting, is when you start with the minimum value,
-    then maximum of the remaining integers, then minimum and so on.
-
-    Examples:
-    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
-    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
-    strange_sort_list([]) == []
-    '''
-",0.0,0.0,0.0
-"
-def triangle_area(a, b, c):
-    '''
-    Given the lengths of the three sides of a triangle. Return the area of
-    the triangle rounded to 2 decimal points if the three sides form a valid triangle. 
-    Otherwise return -1
-    Three sides make a valid triangle when the sum of any two sides is greater 
-    than the third side.
-    Example:
-    triangle_area(3, 4, 5) == 6.00
-    triangle_area(1, 2, 10) == -1
-    '''
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def will_it_fly(q,w):
-    '''
-    Write a function that returns True if the object q will fly, and False otherwise.
-    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.
-
-    Example:
-    will_it_fly([1, 2], 5) ➞ False 
-    # 1+2 is less than the maximum possible weight, but it's unbalanced.
-
-    will_it_fly([3, 2, 3], 1) ➞ False
-    # it's balanced, but 3+2+3 is more than the maximum possible weight.
-
-    will_it_fly([3, 2, 3], 9) ➞ True
-    # 3+2+3 is less than the maximum possible weight, and it's balanced.
-
-    will_it_fly([3], 5) ➞ True
-    # 3 is less than the maximum possible weight, and it's balanced.
-    '''
-",0.4,0.9489164086687306,0.9996427720885925
-"
-def smallest_change(arr):
-    """"""
-    Given an array arr of integers, find the minimum number of elements that
-    need to be changed to make the array palindromic. A palindromic array is an array that
-    is read the same backwards and forwards. In one change, you can change one element to any other element.
-
-    For example:
-    smallest_change([1,2,3,5,4,7,9,6]) == 4
-    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
-    smallest_change([1, 2, 3, 2, 1]) == 0
-    """"""
-",0.0,0.0,0.0
-"
-def total_match(lst1, lst2):
-    '''
-    Write a function that accepts two lists of strings and returns the list that has 
-    total number of chars in the all strings of the list less than the other list.
-
-    if the two lists have the same number of chars, return the first list.
-
-    Examples
-    total_match([], []) ➞ []
-    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
-    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
-    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
-    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
-    '''
-",0.0,0.0,0.0
-"
-def is_multiply_prime(a):
-    """"""Write a function that returns true if the given number is the multiplication of 3 prime numbers
-    and false otherwise.
-    Knowing that (a) is less then 100. 
-    Example:
-    is_multiply_prime(30) == True
-    30 = 2 * 3 * 5
-    """"""
-",0.0,0.0,0.0
-"
-def is_simple_power(x, n):
-    """"""Your task is to write a function that returns true if a number x is a simple
-    power of n and false in other cases.
-    x is a simple power of n if n**int=x
-    For example:
-    is_simple_power(1, 4) => true
-    is_simple_power(2, 2) => true
-    is_simple_power(8, 2) => true
-    is_simple_power(3, 2) => false
-    is_simple_power(3, 1) => false
-    is_simple_power(5, 3) => false
-    """"""
-",0.0,0.0,0.0
-"
-def iscube(a):
-    '''
-    Write a function that takes an integer a and returns True 
-    if this ingeger is a cube of some integer number.
-    Note: you may assume the input is always valid.
-    Examples:
-    iscube(1) ==> True
-    iscube(2) ==> False
-    iscube(-1) ==> True
-    iscube(64) ==> True
-    iscube(0) ==> True
-    iscube(180) ==> False
-    '''
-",0.0,0.0,0.0
-"
-def hex_key(num):
-    """"""You have been tasked to write a function that receives 
-    a hexadecimal number as a string and counts the number of hexadecimal 
-    digits that are primes (prime number, or a prime, is a natural number 
-    greater than 1 that is not a product of two smaller natural numbers).
-    Hexadecimal digits are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
-    Prime numbers are 2, 3, 5, 7, 11, 13, 17,...
-    So you have to determine a number of the following digits: 2, 3, 5, 7, 
-    B (=decimal 11), D (=decimal 13).
-    Note: you may assume the input is always correct or empty string, 
-    and symbols A,B,C,D,E,F are always uppercase.
-    Examples:
-    For num = ""AB"" the output should be 1.
-    For num = ""1077E"" the output should be 2.
-    For num = ""ABED1A33"" the output should be 4.
-    For num = ""123456789ABCDEF0"" the output should be 6.
-    For num = ""2020"" the output should be 2.
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def decimal_to_binary(decimal):
-    """"""You will be given a number in decimal form and your task is to convert it to
-    binary format. The function should return a string, with each character representing a binary
-    number. Each character in the string will be '0' or '1'.
-
-    There will be an extra couple of characters 'db' at the beginning and at the end of the string.
-    The extra characters are there to help with the format.
-
-    Examples:
-    decimal_to_binary(15)   # returns ""db1111db""
-    decimal_to_binary(32)   # returns ""db100000db""
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-def is_happy(s):
-    """"""You are given a string s.
-    Your task is to check if the string is happy or not.
-    A string is happy if its length is at least 3 and every 3 consecutive letters are distinct
-    For example:
-    is_happy(a) => False
-    is_happy(aa) => False
-    is_happy(abcd) => True
-    is_happy(aabb) => False
-    is_happy(adb) => True
-    is_happy(xyy) => False
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def numerical_letter_grade(grades):
-    """"""It is the last week of the semester and the teacher has to give the grades
-    to students. The teacher has been making her own algorithm for grading.
-    The only problem is, she has lost the code she used for grading.
-    She has given you a list of GPAs for some students and you have to write 
-    a function that can output a list of letter grades using the following table:
-             GPA       |    Letter grade
-              4.0                A+
-            > 3.7                A 
-            > 3.3                A- 
-            > 3.0                B+
-            > 2.7                B 
-            > 2.3                B-
-            > 2.0                C+
-            > 1.7                C
-            > 1.3                C-
-            > 1.0                D+ 
-            > 0.7                D 
-            > 0.0                D-
-              0.0                E
-    
-
-    Example:
-    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def prime_length(string):
-    """"""Write a function that takes a string and returns True if the string
-    length is a prime number or False otherwise
-    Examples
-    prime_length('Hello') == True
-    prime_length('abcdcba') == True
-    prime_length('kittens') == True
-    prime_length('orange') == False
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def starts_one_ends(n):
-    """"""
-    Given a positive integer n, return the count of the numbers of n-digit
-    positive integers that start or end with 1.
-    """"""
-",0.0,0.0,0.0
-"
-def solve(N):
-    """"""Given a positive integer N, return the total sum of its digits in binary.
-    
-    Example
-        For N = 1000, the sum of digits will be 1 the output should be ""1"".
-        For N = 150, the sum of digits will be 6 the output should be ""110"".
-        For N = 147, the sum of digits will be 12 the output should be ""1100"".
-    
-    Variables:
-        @N integer
-             Constraints: 0 ≤ N ≤ 10000.
-    Output:
-         a string of binary number
-    """"""
-",0.0,0.0,0.0
-"
-def add(lst):
-    """"""Given a non-empty list of integers lst. add the even elements that are at odd indices..
-
-
-    Examples:
-        add([4, 2, 6, 7]) ==> 2 
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def anti_shuffle(s):
-    """"""
-    Write a function that takes a string and returns an ordered version of it.
-    Ordered version of string, is a string where all words (separated by space)
-    are replaced by a new word where all the characters arranged in
-    ascending order based on ascii value.
-    Note: You should keep the order of words and blank spaces in the sentence.
-
-    For example:
-    anti_shuffle('Hi') returns 'Hi'
-    anti_shuffle('hello') returns 'ehllo'
-    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-def get_row(lst, x):
-    """"""
-    You are given a 2 dimensional data, as a nested lists,
-    which is similar to matrix, however, unlike matrices,
-    each row may contain a different number of columns.
-    Given lst, and integer x, find integers x in the list,
-    and return list of tuples, [(x1, y1), (x2, y2) ...] such that
-    each tuple is a coordinate - (row, columns), starting with 0.
-    Sort coordinates initially by rows in ascending order.
-    Also, sort coordinates of the row by columns in descending order.
-    
-    Examples:
-    get_row([
-      [1,2,3,4,5,6],
-      [1,2,3,4,1,6],
-      [1,2,3,4,5,1]
-    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
-    get_row([], 1) == []
-    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def sort_array(array):
-    """"""
-    Given an array of non-negative integers, return a copy of the given array after sorting,
-    you will sort the given array in ascending order if the sum( first index value, last index value) is odd,
-    or sort it in descending order if the sum( first index value, last index value) is even.
-
-    Note:
-    * don't change the given array.
-
-    Examples:
-    * sort_array([]) => []
-    * sort_array([5]) => [5]
-    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
-    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def encrypt(s):
-    """"""Create a function encrypt that takes a string as an argument and
-    returns a string encrypted with the alphabet being rotated. 
-    The alphabet should be rotated in a manner such that the letters 
-    shift down by two multiplied to two places.
-    For example:
-    encrypt('hi') returns 'lm'
-    encrypt('asdfghjkl') returns 'ewhjklnop'
-    encrypt('gf') returns 'kj'
-    encrypt('et') returns 'ix'
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def next_smallest(lst):
-    """"""
-    You are given a list of integers.
-    Write a function next_smallest() that returns the 2nd smallest element of the list.
-    Return None if there is no such element.
-    
-    next_smallest([1, 2, 3, 4, 5]) == 2
-    next_smallest([5, 1, 4, 3, 2]) == 2
-    next_smallest([]) == None
-    next_smallest([1, 1]) == None
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def is_bored(S):
-    """"""
-    You'll be given a string of words, and your task is to count the number
-    of boredoms. A boredom is a sentence that starts with the word ""I"".
-    Sentences are delimited by '.', '?' or '!'.
-   
-    For example:
-    >>> is_bored(""Hello world"")
-    0
-    >>> is_bored(""The sky is blue. The sun is shining. I love this weather"")
-    1
-    """"""
-",0.0,0.0,0.0
-"
-def any_int(x, y, z):
-    '''
-    Create a function that takes 3 numbers.
-    Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
-    Returns false in any other cases.
-    
-    Examples
-    any_int(5, 2, 7) ➞ True
-    
-    any_int(3, 2, 2) ➞ False
-
-    any_int(3, -2, 1) ➞ True
-    
-    any_int(3.6, -2.2, 2) ➞ False
-  
-
-    
-    '''
-",0.75,0.9999355005159959,1.0
-"
-def encode(message):
-    """"""
-    Write a function that takes a message, and encodes in such a 
-    way that it swaps case of all letters, replaces all vowels in 
-    the message with the letter that appears 2 places ahead of that 
-    vowel in the english alphabet. 
-    Assume only letters. 
-    
-    Examples:
-    >>> encode('test')
-    'TGST'
-    >>> encode('This is a message')
-    'tHKS KS C MGSSCGG'
-    """"""
-",0.0,0.0,0.0
-"
-
-def skjkasdkd(lst):
-    """"""You are given a list of integers.
-    You need to find the largest prime value and return the sum of its digits.
-
-    Examples:
-    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
-    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
-    For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13
-    For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11
-    For lst = [0,81,12,3,1,21] the output should be 3
-    For lst = [0,8,1,2,1,7] the output should be 7
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def check_dict_case(dict):
-    """"""
-    Given a dictionary, return True if all keys are strings in lower 
-    case or all keys are strings in upper case, else return False.
-    The function should return False is the given dictionary is empty.
-    Examples:
-    check_dict_case({""a"":""apple"", ""b"":""banana""}) should return True.
-    check_dict_case({""a"":""apple"", ""A"":""banana"", ""B"":""banana""}) should return False.
-    check_dict_case({""a"":""apple"", 8:""banana"", ""a"":""apple""}) should return False.
-    check_dict_case({""Name"":""John"", ""Age"":""36"", ""City"":""Houston""}) should return False.
-    check_dict_case({""STATE"":""NC"", ""ZIP"":""12345"" }) should return True.
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def count_up_to(n):
-    """"""Implement a function that takes an non-negative integer and returns an array of the first n
-    integers that are prime numbers and less than n.
-    for example:
-    count_up_to(5) => [2,3]
-    count_up_to(11) => [2,3,5,7]
-    count_up_to(0) => []
-    count_up_to(20) => [2,3,5,7,11,13,17,19]
-    count_up_to(1) => []
-    count_up_to(18) => [2,3,5,7,11,13,17]
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def multiply(a, b):
-    """"""Complete the function that takes two integers and returns 
-    the product of their unit digits.
-    Assume the input is always valid.
-    Examples:
-    multiply(148, 412) should return 16.
-    multiply(19, 28) should return 72.
-    multiply(2020, 1851) should return 0.
-    multiply(14,-15) should return 20.
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def count_upper(s):
-    """"""
-    Given a string s, count the number of uppercase vowels in even indices.
-    
-    For example:
-    count_upper('aBCdEf') returns 1
-    count_upper('abcdefg') returns 0
-    count_upper('dBBE') returns 0
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-def closest_integer(value):
-    '''
-    Create a function that takes a value (string) representing a number
-    and returns the closest integer to it. If the number is equidistant
-    from two integers, round it away from zero.
-
-    Examples
-    >>> closest_integer(""10"")
-    10
-    >>> closest_integer(""15.3"")
-    15
-
-    Note:
-    Rounding away from zero means that if the given number is equidistant
-    from two integers, the one you should return is the one that is the
-    farthest from zero. For example closest_integer(""14.5"") should
-    return 15 and closest_integer(""-14.5"") should return -15.
-    '''
-",0.050000000000000044,0.25,0.5
-"
-def make_a_pile(n):
-    """"""
-    Given a positive integer n, you have to make a pile of n levels of stones.
-    The first level has n stones.
-    The number of stones in the next level is:
-        - the next odd number if n is odd.
-        - the next even number if n is even.
-    Return the number of stones in each level in a list, where element at index
-    i represents the number of stones in the level (i+1).
-
-    Examples:
-    >>> make_a_pile(3)
-    [3, 5, 7]
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def words_string(s):
-    """"""
-    You will be given a string of words separated by commas or spaces. Your task is
-    to split the string into words and return an array of the words.
-    
-    For example:
-    words_string(""Hi, my name is John"") == [""Hi"", ""my"", ""name"", ""is"", ""John""]
-    words_string(""One, two, three, four, five, six"") == [""One"", ""two"", ""three"", ""four"", ""five"", ""six""]
-    """"""
-",0.0,0.0,0.0
-"
-def choose_num(x, y):
-    """"""This function takes two positive numbers x and y and returns the
-    biggest even integer number that is in the range [x, y] inclusive. If 
-    there's no such number, then the function should return -1.
-
-    For example:
-    choose_num(12, 15) = 14
-    choose_num(13, 12) = -1
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def rounded_avg(n, m):
-    """"""You are given two positive integers n and m, and your task is to compute the
-    average of the integers from n through m (including n and m). 
-    Round the answer to the nearest integer and convert that to binary.
-    If n is greater than m, return -1.
-    Example:
-    rounded_avg(1, 5) => ""0b11""
-    rounded_avg(7, 5) => -1
-    rounded_avg(10, 20) => ""0b1111""
-    rounded_avg(20, 33) => ""0b11010""
-    """"""
-",0.0,0.0,0.0
-"
-def unique_digits(x):
-    """"""Given a list of positive integers x. return a sorted list of all 
-    elements that hasn't any even digit.
-
-    Note: Returned list should be sorted in increasing order.
-    
-    For example:
-    >>> unique_digits([15, 33, 1422, 1])
-    [1, 15, 33]
-    >>> unique_digits([152, 323, 1422, 10])
-    []
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def by_length(arr):
-    """"""
-    Given an array of integers, sort the integers that are between 1 and 9 inclusive,
-    reverse the resulting array, and then replace each digit by its corresponding name from
-    ""One"", ""Two"", ""Three"", ""Four"", ""Five"", ""Six"", ""Seven"", ""Eight"", ""Nine"".
-
-    For example:
-      arr = [2, 1, 1, 4, 5, 8, 2, 3]   
-            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8] 
-            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
-      return [""Eight"", ""Five"", ""Four"", ""Three"", ""Two"", ""Two"", ""One"", ""One""]
-    
-      If the array is empty, return an empty array:
-      arr = []
-      return []
-    
-      If the array has any strange number ignore it:
-      arr = [1, -1 , 55] 
-            -> sort arr -> [-1, 1, 55]
-            -> reverse arr -> [55, 1, -1]
-      return = ['One']
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def f(n):
-    """""" Implement the function f that takes n as a parameter,
-    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
-    or the sum of numbers from 1 to i otherwise.
-    i starts from 1.
-    the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... * i).
-    Example:
-    f(5) == [1, 2, 6, 24, 15]
-    """"""
-",0.0,0.0,0.0
-"
-def even_odd_palindrome(n):
-    """"""
-    Given a positive integer n, return a tuple that has the number of even and odd
-    integer palindromes that fall within the range(1, n), inclusive.
-
-    Example 1:
-
-        Input: 3
-        Output: (1, 2)
-        Explanation:
-        Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.
-
-    Example 2:
-
-        Input: 12
-        Output: (4, 6)
-        Explanation:
-        Integer palindrome are 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. four of them are even, and 6 of them are odd.
-
-    Note:
-        1. 1 <= n <= 10^3
-        2. returned tuple has the number of even and odd integer palindromes respectively.
-    """"""
-",1.0,1.0,1.0
-"
-def count_nums(arr):
-    """"""
-    Write a function count_nums which takes an array of integers and returns
-    the number of elements which has a sum of digits > 0.
-    If a number is negative, then its first signed digit will be negative:
-    e.g. -123 has signed digits -1, 2, and 3.
-    >>> count_nums([]) == 0
-    >>> count_nums([-1, 11, -11]) == 1
-    >>> count_nums([1, 1, 2]) == 3
-    """"""
-",0.0,0.0,0.0
-"
-def move_one_ball(arr):
-    """"""We have an array 'arr' of N integers arr[1], arr[2], ..., arr[N].The
-    numbers in the array will be randomly ordered. Your task is to determine if
-    it is possible to get an array sorted in non-decreasing order by performing 
-    the following operation on the given array:
-        You are allowed to perform right shift operation any number of times.
-    
-    One right shift operation means shifting all elements of the array by one
-    position in the right direction. The last element of the array will be moved to
-    the starting position in the array i.e. 0th index. 
-
-    If it is possible to obtain the sorted array by performing the above operation
-    then return True else return False.
-    If the given array is empty then return True.
-
-    Note: The given list is guaranteed to have unique elements.
-
-    For Example:
-    
-    move_one_ball([3, 4, 5, 1, 2])==>True
-    Explanation: By performin 2 right shift operations, non-decreasing order can
-                 be achieved for the given array.
-    move_one_ball([3, 5, 4, 1, 2])==>False
-    Explanation:It is not possible to get non-decreasing order for the given
-                array by performing any number of right shift operations.
-                
-    """"""
-",0.0,0.0,0.0
-"
-def exchange(lst1, lst2):
-    """"""In this problem, you will implement a function that takes two lists of numbers,
-    and determines whether it is possible to perform an exchange of elements
-    between them to make lst1 a list of only even numbers.
-    There is no limit on the number of exchanged elements between lst1 and lst2.
-    If it is possible to exchange elements between the lst1 and lst2 to make
-    all the elements of lst1 to be even, return ""YES"".
-    Otherwise, return ""NO"".
-    For example:
-    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => ""YES""
-    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => ""NO""
-    It is assumed that the input lists will be non-empty.
-    """"""
-",0.0,0.0,0.0
-"
-def histogram(test):
-    """"""Given a string representing a space separated lowercase letters, return a dictionary
-    of the letter with the most repetition and containing the corresponding count.
-    If several letters have the same occurrence, return all of them.
-    
-    Example:
-    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
-    histogram('a b b a') == {'a': 2, 'b': 2}
-    histogram('a b c a b') == {'a': 2, 'b': 2}
-    histogram('b b b b a') == {'b': 4}
-    histogram('') == {}
-
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def reverse_delete(s,c):
-    """"""Task
-    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
-    then check if the result string is palindrome.
-    A string is called palindrome if it reads the same backward as forward.
-    You should return a tuple containing the result string and True/False for the check.
-    Example
-    For s = ""abcde"", c = ""ae"", the result should be ('bcd',False)
-    For s = ""abcdef"", c = ""b""  the result should be ('acdef',False)
-    For s = ""abcdedcba"", c = ""ab"", the result should be ('cdedc',True)
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-def odd_count(lst):
-    """"""Given a list of strings, where each string consists of only digits, return a list.
-    Each element i of the output should be ""the number of odd elements in the
-    string i of the input."" where all the i's should be replaced by the number
-    of odd digits in the i'th string of the input.
-
-    >>> odd_count(['1234567'])
-    [""the number of odd elements 4n the str4ng 4 of the 4nput.""]
-    >>> odd_count(['3',""11111111""])
-    [""the number of odd elements 1n the str1ng 1 of the 1nput."",
-     ""the number of odd elements 8n the str8ng 8 of the 8nput.""]
-    """"""
-",0.0,0.0,0.0
-"
-def minSubArraySum(nums):
-    """"""
-    Given an array of integers nums, find the minimum sum of any non-empty sub-array
-    of nums.
-    Example
-    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
-    minSubArraySum([-1, -2, -3]) == -6
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def max_fill(grid, capacity):
-    import math
-    """"""
-    You are given a rectangular grid of wells. Each row represents a single well,
-    and each 1 in a row represents a single unit of water.
-    Each well has a corresponding bucket that can be used to extract water from it, 
-    and all buckets have the same capacity.
-    Your task is to use the buckets to empty the wells.
-    Output the number of times you need to lower the buckets.
-
-    Example 1:
-        Input: 
-            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
-            bucket_capacity : 1
-        Output: 6
-
-    Example 2:
-        Input: 
-            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
-            bucket_capacity : 2
-        Output: 5
-    
-    Example 3:
-        Input: 
-            grid : [[0,0,0], [0,0,0]]
-            bucket_capacity : 5
-        Output: 0
-
-    Constraints:
-        * all wells have the same length
-        * 1 <= grid.length <= 10^2
-        * 1 <= grid[:,1].length <= 10^2
-        * grid[i][j] -> 0 | 1
-        * 1 <= capacity <= 10
-    """"""
-",0.0,0.0,0.0
-"
-def sort_array(arr):
-    """"""
-    In this Kata, you have to sort an array of non-negative integers according to
-    number of ones in their binary representation in ascending order.
-    For similar number of ones, sort based on decimal value.
-
-    It must be implemented like this:
-    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
-    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
-    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
-    """"""
-",0.95,1.0,1.0
-"
-def select_words(s, n):
-    """"""Given a string s and a natural number n, you have been tasked to implement 
-    a function that returns a list of all words from string s that contain exactly 
-    n consonants, in order these words appear in the string s.
-    If the string s is empty then the function should return an empty list.
-    Note: you may assume the input string contains only letters and spaces.
-    Examples:
-    select_words(""Mary had a little lamb"", 4) ==> [""little""]
-    select_words(""Mary had a little lamb"", 3) ==> [""Mary"", ""lamb""]
-    select_words(""simple white space"", 2) ==> []
-    select_words(""Hello world"", 4) ==> [""world""]
-    select_words(""Uncle sam"", 3) ==> [""Uncle""]
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def get_closest_vowel(word):
-    """"""You are given a word. Your task is to find the closest vowel that stands between 
-    two consonants from the right side of the word (case sensitive).
-    
-    Vowels in the beginning and ending doesn't count. Return empty string if you didn't
-    find any vowel met the above condition. 
-
-    You may assume that the given string contains English letter only.
-
-    Example:
-    get_closest_vowel(""yogurt"") ==> ""u""
-    get_closest_vowel(""FULL"") ==> ""U""
-    get_closest_vowel(""quick"") ==> """"
-    get_closest_vowel(""ab"") ==> """"
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def match_parens(lst):
-    '''
-    You are given a list of two strings, both strings consist of open
-    parentheses '(' or close parentheses ')' only.
-    Your job is to check if it is possible to concatenate the two strings in
-    some order, that the resulting string will be good.
-    A string S is considered to be good if and only if all parentheses in S
-    are balanced. For example: the string '(())()' is good, while the string
-    '())' is not.
-    Return 'Yes' if there's a way to make a good string, and return 'No' otherwise.
-
-    Examples:
-    match_parens(['()(', ')']) == 'Yes'
-    match_parens([')', ')']) == 'No'
-    '''
-",0.0,0.0,0.0
-"
-def maximum(arr, k):
-    """"""
-    Given an array arr of integers and a positive integer k, return a sorted list 
-    of length k with the maximum k numbers in arr.
-
-    Example 1:
-
-        Input: arr = [-3, -4, 5], k = 3
-        Output: [-4, -3, 5]
-
-    Example 2:
-
-        Input: arr = [4, -4, 4], k = 2
-        Output: [4, 4]
-
-    Example 3:
-
-        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
-        Output: [2]
-
-    Note:
-        1. The length of the array will be in the range of [1, 1000].
-        2. The elements in the array will be in the range of [-1000, 1000].
-        3. 0 <= k <= len(arr)
-    """"""
-",0.0,0.0,0.0
-"
-def solution(lst):
-    """"""Given a non-empty list of integers, return the sum of all of the odd elements that are in even positions.
-    
-
-    Examples
-    solution([5, 8, 7, 1]) ==> 12
-    solution([3, 3, 3, 3, 3]) ==> 9
-    solution([30, 13, 24, 321]) ==>0
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def add_elements(arr, k):
-    """"""
-    Given a non-empty array of integers arr and an integer k, return
-    the sum of the elements with at most two digits from the first k elements of arr.
-
-    Example:
-
-        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
-        Output: 24 # sum of 21 + 3
-
-    Constraints:
-        1. 1 <= len(arr) <= 100
-        2. 1 <= k <= len(arr)
-    """"""
-",0.0,0.0,0.0
-"
-def get_odd_collatz(n):
-    """"""
-    Given a positive integer n, return a sorted list that has the odd numbers in collatz sequence.
-
-    The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined
-    as follows: start with any positive integer n. Then each term is obtained from the 
-    previous term as follows: if the previous term is even, the next term is one half of 
-    the previous term. If the previous term is odd, the next term is 3 times the previous
-    term plus 1. The conjecture is that no matter what value of n, the sequence will always reach 1.
-
-    Note: 
-        1. Collatz(1) is [1].
-        2. returned list sorted in increasing order.
-
-    For example:
-    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.
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def valid_date(date):
-    """"""You have to write a function which validates a given date string and
-    returns True if the date is valid otherwise False.
-    The date is valid if all of the following rules are satisfied:
-    1. The date string is not empty.
-    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.
-    3. The months should not be less than 1 or higher than 12.
-    4. The date should be in the format: mm-dd-yyyy
-
-    for example: 
-    valid_date('03-11-2000') => True
-
-    valid_date('15-01-2012') => False
-
-    valid_date('04-0-2040') => False
-
-    valid_date('06-04-2020') => True
-
-    valid_date('06/04/2020') => False
-    """"""
-",0.0,0.0,0.0
-"
-def split_words(txt):
-    '''
-    Given a string of words, return a list of words split on whitespace, if no whitespaces exists in the text you
-    should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
-    alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
-    Examples
-    split_words(""Hello world!"") ➞ [""Hello"", ""world!""]
-    split_words(""Hello,world!"") ➞ [""Hello"", ""world!""]
-    split_words(""abcdef"") == 3 
-    '''
-",0.0,0.0,0.0
-"
-def is_sorted(lst):
-    '''
-    Given a list of numbers, return whether or not they are sorted
-    in ascending order. If list has more than 1 duplicate of the same
-    number, return False. Assume no negative numbers and only integers.
-
-    Examples
-    is_sorted([5]) ➞ True
-    is_sorted([1, 2, 3, 4, 5]) ➞ True
-    is_sorted([1, 3, 2, 4, 5]) ➞ False
-    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
-    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
-    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
-    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
-    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
-    '''
-",0.0,0.0,0.0
-"
-def intersection(interval1, interval2):
-    """"""You are given two intervals,
-    where each interval is a pair of integers. For example, interval = (start, end) = (1, 2).
-    The given intervals are closed which means that the interval (start, end)
-    includes both start and end.
-    For each given interval, it is assumed that its start is less or equal its end.
-    Your task is to determine whether the length of intersection of these two 
-    intervals is a prime number.
-    Example, the intersection of the intervals (1, 3), (2, 4) is (2, 3)
-    which its length is 1, which not a prime number.
-    If the length of the intersection is a prime number, return ""YES"",
-    otherwise, return ""NO"".
-    If the two intervals don't intersect, return ""NO"".
-
-
-    [input/output] samples:
-    intersection((1, 2), (2, 3)) ==> ""NO""
-    intersection((-1, 1), (0, 4)) ==> ""NO""
-    intersection((-3, -1), (-5, 5)) ==> ""YES""
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-def prod_signs(arr):
-    """"""
-    You are given an array arr of integers and you need to return
-    sum of magnitudes of integers multiplied by product of all signs
-    of each number in the array, represented by 1, -1 or 0.
-    Note: return None for empty arr.
-
-    Example:
-    >>> prod_signs([1, 2, 2, -4]) == -9
-    >>> prod_signs([0, 1]) == 0
-    >>> prod_signs([]) == None
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def minPath(grid, k):
-    """"""
-    Given a grid with N rows and N columns (N >= 2) and a positive integer k, 
-    each cell of the grid contains a value. Every integer in the range [1, N * N]
-    inclusive appears exactly once on the cells of the grid.
-
-    You have to find the minimum path of length k in the grid. You can start
-    from any cell, and in each step you can move to any of the neighbor cells,
-    in other words, you can go to cells which share an edge with you current
-    cell.
-    Please note that a path of length k means visiting exactly k cells (not
-    necessarily distinct).
-    You CANNOT go off the grid.
-    A path A (of length k) is considered less than a path B (of length k) if
-    after making the ordered lists of the values on the cells that A and B go
-    through (let's call them lst_A and lst_B), lst_A is lexicographically less
-    than lst_B, in other words, there exist an integer index i (1 <= i <= k)
-    such that lst_A[i] < lst_B[i] and for any j (1 <= j < i) we have
-    lst_A[j] = lst_B[j].
-    It is guaranteed that the answer is unique.
-    Return an ordered list of the values on the cells that the minimum path go through.
-
-    Examples:
-
-        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
-        Output: [1, 2, 1]
-
-        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
-        Output: [1]
-    """"""
-",0.0,0.0,0.0
-"
-def tri(n):
-    """"""Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in 
-    the last couple centuries. However, what people don't know is Tribonacci sequence.
-    Tribonacci sequence is defined by the recurrence:
-    tri(1) = 3
-    tri(n) = 1 + n / 2, if n is even.
-    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
-    For example:
-    tri(2) = 1 + (2 / 2) = 2
-    tri(4) = 3
-    tri(3) = tri(2) + tri(1) + tri(4)
-           = 2 + 3 + 3 = 8 
-    You are given a non-negative integer number n, you have to a return a list of the 
-    first n + 1 numbers of the Tribonacci sequence.
-    Examples:
-    tri(3) = [1, 3, 2, 8]
-    """"""
-",0.0,0.0,0.0
-"
-def digits(n):
-    """"""Given a positive integer n, return the product of the odd digits.
-    Return 0 if all digits are even.
-    For example:
-    digits(1)  == 1
-    digits(4)  == 0
-    digits(235) == 15
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def is_nested(string):
-    '''
-    Create a function that takes a string as input which contains only square brackets.
-    The function should return True if and only if there is a valid subsequence of brackets 
-    where at least one bracket in the subsequence is nested.
-
-    is_nested('[[]]') ➞ True
-    is_nested('[]]]]]]][[[[[]') ➞ False
-    is_nested('[][]') ➞ False
-    is_nested('[]') ➞ False
-    is_nested('[[][]]') ➞ True
-    is_nested('[[]][[') ➞ True
-    '''
-",0.0,0.0,0.0
-"
-
-def sum_squares(lst):
-    """"""You are given a list of numbers.
-    You need to return the sum of squared numbers in the given list,
-    round each element in the list to the upper int(Ceiling) first.
-    Examples:
-    For lst = [1,2,3] the output should be 14
-    For lst = [1,4,9] the output should be 98
-    For lst = [1,3,5,7] the output should be 84
-    For lst = [1.4,4.2,0] the output should be 29
-    For lst = [-2.4,1,1] the output should be 6
-    
-
-    """"""
-",0.0,0.0,0.0
-"
-def check_if_last_char_is_a_letter(txt):
-    '''
-    Create a function that returns True if the last character
-    of a given string is an alphabetical character and is not
-    a part of a word, and False otherwise.
-    Note: ""word"" is a group of characters separated by space.
-
-    Examples:
-    check_if_last_char_is_a_letter(""apple pie"") ➞ False
-    check_if_last_char_is_a_letter(""apple pi e"") ➞ True
-    check_if_last_char_is_a_letter(""apple pi e "") ➞ False
-    check_if_last_char_is_a_letter("""") ➞ False 
-    '''
-",0.0,0.0,0.0
-"
-def can_arrange(arr):
-    """"""Create a function which returns the largest index of an element which
-    is not greater than or equal to the element immediately preceding it. If
-    no such element exists then return -1. The given array will not contain
-    duplicate values.
-
-    Examples:
-    can_arrange([1,2,4,3,5]) = 3
-    can_arrange([1,2,3]) = -1
-    """"""
-",0.0,0.0,0.0
-"
-def largest_smallest_integers(lst):
-    '''
-    Create a function that returns a tuple (a, b), where 'a' is
-    the largest of negative integers, and 'b' is the smallest
-    of positive integers in a list.
-    If there is no negative or positive integers, return them as None.
-
-    Examples:
-    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
-    largest_smallest_integers([]) == (None, None)
-    largest_smallest_integers([0]) == (None, None)
-    '''
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def compare_one(a, b):
-    """"""
-    Create a function that takes integers, floats, or strings representing
-    real numbers, and returns the larger variable in its given variable type.
-    Return None if the values are equal.
-    Note: If a real number is represented as a string, the floating point might be . or ,
-
-    compare_one(1, 2.5) ➞ 2.5
-    compare_one(1, ""2,3"") ➞ ""2,3""
-    compare_one(""5,1"", ""6"") ➞ ""6""
-    compare_one(""1"", 1) ➞ None
-    """"""
-",0.0,0.0,0.0
-"
-def is_equal_to_sum_even(n):
-    """"""Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
-    Example
-    is_equal_to_sum_even(4) == False
-    is_equal_to_sum_even(6) == False
-    is_equal_to_sum_even(8) == True
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def special_factorial(n):
-    """"""The Brazilian factorial is defined as:
-    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
-    where n > 0
-
-    For example:
-    >>> special_factorial(4)
-    288
-
-    The function will receive an integer as input and should return the special
-    factorial of this integer.
-    """"""
-",0.0,0.0,0.0
-"
-def fix_spaces(text):
-    """"""
-    Given a string text, replace all spaces in it with underscores, 
-    and if a string has more than 2 consecutive spaces, 
-    then replace all consecutive spaces with - 
-    
-    fix_spaces(""Example"") == ""Example""
-    fix_spaces(""Example 1"") == ""Example_1""
-    fix_spaces("" Example 2"") == ""_Example_2""
-    fix_spaces("" Example   3"") == ""_Example-3""
-    """"""
-",0.0,0.0,0.0
-"
-def file_name_check(file_name):
-    """"""Create a function which takes a string representing a file's name, and returns
-    'Yes' if the the file's name is valid, and returns 'No' otherwise.
-    A file's name is considered to be valid if and only if all the following conditions 
-    are met:
-    - There should not be more than three digits ('0'-'9') in the file's name.
-    - The file's name contains exactly one dot '.'
-    - The substring before the dot should not be empty, and it starts with a letter from 
-    the latin alphapet ('a'-'z' and 'A'-'Z').
-    - The substring after the dot should be one of these: ['txt', 'exe', 'dll']
-    Examples:
-    file_name_check(""example.txt"") # => 'Yes'
-    file_name_check(""1example.dll"") # => 'No' (the name should start with a latin alphapet letter)
-    """"""
-",0.0,0.0,0.0
-"
-
-
-def sum_squares(lst):
-    """"""""
-    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 
-    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 
-    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. 
-    
-    Examples:
-    For lst = [1,2,3] the output should be 6
-    For lst = []  the output should be 0
-    For lst = [-1,-5,2,-1,-5]  the output should be -126
-    """"""
-",0.0,0.0,0.0
-"
-def words_in_sentence(sentence):
-    """"""
-    You are given a string representing a sentence,
-    the sentence contains some words separated by a space,
-    and you have to return a string that contains the words from the original sentence,
-    whose lengths are prime numbers,
-    the order of the words in the new string should be the same as the original one.
-
-    Example 1:
-        Input: sentence = ""This is a test""
-        Output: ""is""
-
-    Example 2:
-        Input: sentence = ""lets go for swimming""
-        Output: ""go for""
-
-    Constraints:
-        * 1 <= len(sentence) <= 100
-        * sentence contains only letters
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-def simplify(x, n):
-    """"""Your task is to implement a function that will simplify the expression
-    x * n. The function returns True if x * n evaluates to a whole number and False
-    otherwise. Both x and n, are string representation of a fraction, and have the following format,
-    <numerator>/<denominator> where both numerator and denominator are positive whole numbers.
-
-    You can assume that x, and n are valid fractions, and do not have zero as denominator.
-
-    simplify(""1/5"", ""5/1"") = True
-    simplify(""1/6"", ""2/1"") = False
-    simplify(""7/10"", ""10/2"") = False
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def order_by_points(nums):
-    """"""
-    Write a function which sorts the given list of integers
-    in ascending order according to the sum of their digits.
-    Note: if there are several items with similar sum of their digits,
-    order them based on their index in original list.
-
-    For example:
-    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
-    >>> order_by_points([]) == []
-    """"""
-",0.0,0.0,0.0
-"
-def specialFilter(nums):
-    """"""Write a function that takes an array of numbers as input and returns 
-    the number of elements in the array that are greater than 10 and both 
-    first and last digits of a number are odd (1, 3, 5, 7, 9).
-    For example:
-    specialFilter([15, -73, 14, -15]) => 1 
-    specialFilter([33, -2, -3, 45, 21, 109]) => 2
-    """"""
-",0.0,0.0,0.0
-"
-def get_max_triples(n):
-    """"""
-    You are given a positive integer n. You have to create an integer array a of length n.
-        For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
-        Return the number of triples (a[i], a[j], a[k]) of a where i < j < k, 
-    and a[i] + a[j] + a[k] is a multiple of 3.
-
-    Example :
-        Input: n = 5
-        Output: 1
-        Explanation: 
-        a = [1, 3, 7, 13, 21]
-        The only valid triple is (1, 7, 13).
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def bf(planet1, planet2):
-    '''
-    There are eight planets in our solar system: the closerst to the Sun 
-    is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn, 
-    Uranus, Neptune.
-    Write a function that takes two planet names as strings planet1 and planet2. 
-    The function should return a tuple containing all planets whose orbits are 
-    located between the orbit of planet1 and the orbit of planet2, sorted by 
-    the proximity to the sun. 
-    The function should return an empty tuple if planet1 or planet2
-    are not correct planet names. 
-    Examples
-    bf(""Jupiter"", ""Neptune"") ==> (""Saturn"", ""Uranus"")
-    bf(""Earth"", ""Mercury"") ==> (""Venus"")
-    bf(""Mercury"", ""Uranus"") ==> (""Venus"", ""Earth"", ""Mars"", ""Jupiter"", ""Saturn"")
-    '''
-",0.8999999999999999,1.0,1.0
-"
-def sorted_list_sum(lst):
-    """"""Write a function that accepts a list of strings as a parameter,
-    deletes the strings that have odd lengths from it,
-    and returns the resulted list with a sorted order,
-    The list is always a list of strings and never an array of numbers,
-    and it may contain duplicates.
-    The order of the list should be ascending by length of each word, and you
-    should return the list sorted by that rule.
-    If two words have the same length, sort the list alphabetically.
-    The function should return a list of strings in sorted order.
-    You may assume that all words will have the same length.
-    For example:
-    assert list_sort([""aa"", ""a"", ""aaa""]) => [""aa""]
-    assert list_sort([""ab"", ""a"", ""aaa"", ""cd""]) => [""ab"", ""cd""]
-    """"""
-",0.0,0.0,0.0
-"
-def x_or_y(n, x, y):
-    """"""A simple program which should return the value of x if n is 
-    a prime number and should return the value of y otherwise.
-
-    Examples:
-    for x_or_y(7, 34, 12) == 34
-    for x_or_y(15, 8, 5) == 5
-    
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def double_the_difference(lst):
-    '''
-    Given a list of numbers, return the sum of squares of the numbers
-    in the list that are odd. Ignore numbers that are negative or not integers.
-    
-    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
-    double_the_difference([-1, -2, 0]) == 0
-    double_the_difference([9, -2]) == 81
-    double_the_difference([0]) == 0  
-   
-    If the input list is empty, return 0.
-    '''
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def compare(game,guess):
-    """"""I think we all remember that feeling when the result of some long-awaited
-    event is finally known. The feelings and thoughts you have at that moment are
-    definitely worth noting down and comparing.
-    Your task is to determine if a person correctly guessed the results of a number of matches.
-    You are given two arrays of scores and guesses of equal length, where each index shows a match. 
-    Return an array of the same length denoting how far off each guess was. If they have guessed correctly,
-    the value is 0, and if not, the value is the absolute difference between the guess and the score.
-    
-    
-    example:
-
-    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
-    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
-    """"""
-",1.0,1.0,1.0
-"
-def Strongest_Extension(class_name, extensions):
-    """"""You will be given the name of a class (a string) and a list of extensions.
-    The extensions are to be used to load additional classes to the class. The
-    strength of the extension is as follows: Let CAP be the number of the uppercase
-    letters in the extension's name, and let SM be the number of lowercase letters 
-    in the extension's name, the strength is given by the fraction CAP - SM. 
-    You should find the strongest extension and return a string in this 
-    format: ClassName.StrongestExtensionName.
-    If there are two or more extensions with the same strength, you should
-    choose the one that comes first in the list.
-    For example, if you are given ""Slices"" as the class and a list of the
-    extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] then you should
-    return 'Slices.SErviNGSliCes' since 'SErviNGSliCes' is the strongest extension 
-    (its strength is -1).
-    Example:
-    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def cycpattern_check(a , b):
-    """"""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
-    cycpattern_check(""abcd"",""abd"") => False
-    cycpattern_check(""hello"",""ell"") => True
-    cycpattern_check(""whassup"",""psus"") => False
-    cycpattern_check(""abab"",""baa"") => True
-    cycpattern_check(""efef"",""eeff"") => False
-    cycpattern_check(""himenss"",""simen"") => True
-
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def even_odd_count(num):
-    """"""Given an integer. return a tuple that has the number of even and odd digits respectively.
-
-     Example:
-        even_odd_count(-12) ==> (1, 1)
-        even_odd_count(123) ==> (1, 2)
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-def int_to_mini_roman(number):
-    """"""
-    Given a positive integer, obtain its roman numeral equivalent as a string,
-    and return it in lowercase.
-    Restrictions: 1 <= num <= 1000
-
-    Examples:
-    >>> int_to_mini_roman(19) == 'xix'
-    >>> int_to_mini_roman(152) == 'clii'
-    >>> int_to_mini_roman(426) == 'cdxxvi'
-    """"""
-",0.95,1.0,1.0
-"
-def right_angle_triangle(a, b, c):
-    '''
-    Given the lengths of the three sides of a triangle. Return True if the three
-    sides form a right-angled triangle, False otherwise.
-    A right-angled triangle is a triangle in which one angle is right angle or 
-    90 degree.
-    Example:
-    right_angle_triangle(3, 4, 5) == True
-    right_angle_triangle(1, 2, 3) == False
-    '''
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def find_max(words):
-    """"""Write a function that accepts a list of strings.
-    The list contains different words. Return the word with maximum number
-    of unique characters. If multiple strings have maximum number of unique
-    characters, return the one which comes first in lexicographical order.
-
-    find_max([""name"", ""of"", ""string""]) == ""string""
-    find_max([""name"", ""enam"", ""game""]) == ""enam""
-    find_max([""aaaaaaa"", ""bb"" ,""cc""]) == """"aaaaaaa""
-    """"""
-",0.85,1.0,1.0
-"
-def eat(number, need, remaining):
-    """"""
-    You're a hungry rabbit, and you already have eaten a certain number of carrots,
-    but now you need to eat more carrots to complete the day's meals.
-    you should return an array of [ total number of eaten carrots after your meals,
-                                    the number of carrots left after your meals ]
-    if there are not enough remaining carrots, you will eat all remaining carrots, but will still be hungry.
-    
-    Example:
-    * eat(5, 6, 10) -> [11, 4]
-    * eat(4, 8, 9) -> [12, 1]
-    * eat(1, 10, 10) -> [11, 0]
-    * eat(2, 11, 5) -> [7, 0]
-    
-    Variables:
-    @number : integer
-        the number of carrots that you have eaten.
-    @need : integer
-        the number of carrots that you need to eat.
-    @remaining : integer
-        the number of remaining carrots thet exist in stock
-    
-    Constrain:
-    * 0 <= number <= 1000
-    * 0 <= need <= 1000
-    * 0 <= remaining <= 1000
-
-    Have fun :)
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def do_algebra(operator, operand):
-    """"""
-    Given two lists operator, and operand. The first list has basic algebra operations, and 
-    the second list is a list of integers. Use the two given lists to build the algebric 
-    expression and return the evaluation of this expression.
-
-    The basic algebra operations:
-    Addition ( + ) 
-    Subtraction ( - ) 
-    Multiplication ( * ) 
-    Floor division ( // ) 
-    Exponentiation ( ** ) 
-
-    Example:
-    operator['+', '*', '-']
-    array = [2, 3, 4, 5]
-    result = 2 + 3 * 4 - 5
-    => result = 9
-
-    Note:
-        The length of operator list is equal to the length of operand list minus one.
-        Operand is a list of of non-negative integers.
-        Operator list has at least one operator, and operand list has at least two operands.
-
-    """"""
-",0.0,0.0,0.0
-"
-def solve(s):
-    """"""You are given a string s.
-    if s[i] is a letter, reverse its case from lower to upper or vise versa, 
-    otherwise keep it as it is.
-    If the string contains no letters, reverse the string.
-    The function should return the resulted string.
-    Examples
-    solve(""1234"") = ""4321""
-    solve(""ab"") = ""AB""
-    solve(""#a@C"") = ""#A@c""
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"
-def string_to_md5(text):
-    """"""
-    Given a string 'text', return its md5 hash equivalent string.
-    If 'text' is an empty string, return None.
-
-    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def generate_integers(a, b):
-    """"""
-    Given two positive integers a and b, return the even digits between a
-    and b, in ascending order.
-
-    For example:
-    generate_integers(2, 8) => [2, 4, 6, 8]
-    generate_integers(8, 2) => [2, 4, 6, 8]
-    generate_integers(10, 14) => []
-    """"""
-",0.0,0.0,0.0

demo/data/coding/humaneval/csv/4.csv

@@ -1,2413 +0,0 @@
-prompt,pass@1,pass@5,pass@10
-"from typing import List
-
-
-def has_close_elements(numbers: List[float], threshold: float) -> bool:
-    """""" Check if in given list of numbers, are any two numbers closer to each other than
-    given threshold.
-    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
-    False
-    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
-    True
-    """"""
-",0.0,0.0,0.0
-"from typing import List
-
-
-def separate_paren_groups(paren_string: str) -> List[str]:
-    """""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
-    separate those group into separate strings and return the list of those.
-    Separate groups are balanced (each open brace is properly closed) and not nested within each other
-    Ignore any spaces in the input string.
-    >>> separate_paren_groups('( ) (( )) (( )( ))')
-    ['()', '(())', '(()())']
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-
-def truncate_number(number: float) -> float:
-    """""" Given a positive floating point number, it can be decomposed into
-    and integer part (largest integer smaller than given number) and decimals
-    (leftover part always smaller than 1).
-
-    Return the decimal part of the number.
-    >>> truncate_number(3.5)
-    0.5
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"from typing import List
-
-
-def below_zero(operations: List[int]) -> bool:
-    """""" You're given a list of deposit and withdrawal operations on a bank account that starts with
-    zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
-    at that point function should return True. Otherwise it should return False.
-    >>> below_zero([1, 2, 3])
-    False
-    >>> below_zero([1, 2, -4, 5])
-    True
-    """"""
-",1.0,1.0,1.0
-"from typing import List
-
-
-def mean_absolute_deviation(numbers: List[float]) -> float:
-    """""" For a given list of input numbers, calculate Mean Absolute Deviation
-    around the mean of this dataset.
-    Mean Absolute Deviation is the average absolute difference between each
-    element and a centerpoint (mean in this case):
-    MAD = average | x - x_mean |
-    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
-    1.0
-    """"""
-",0.95,1.0,1.0
-"from typing import List
-
-
-def intersperse(numbers: List[int], delimeter: int) -> List[int]:
-    """""" Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
-    >>> intersperse([], 4)
-    []
-    >>> intersperse([1, 2, 3], 4)
-    [1, 4, 2, 4, 3]
-    """"""
-",0.0,0.0,0.0
-"from typing import List
-
-
-def parse_nested_parens(paren_string: str) -> List[int]:
-    """""" Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
-    For each of the group, output the deepest level of nesting of parentheses.
-    E.g. (()()) has maximum two levels of nesting while ((())) has three.
-
-    >>> parse_nested_parens('(()()) ((())) () ((())()())')
-    [2, 3, 1, 3]
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"from typing import List
-
-
-def filter_by_substring(strings: List[str], substring: str) -> List[str]:
-    """""" Filter an input list of strings only for ones that contain given substring
-    >>> filter_by_substring([], 'a')
-    []
-    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
-    ['abc', 'bacd', 'array']
-    """"""
-",1.0,1.0,1.0
-"from typing import List, Tuple
-
-
-def sum_product(numbers: List[int]) -> Tuple[int, int]:
-    """""" For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.
-    Empty sum should be equal to 0 and empty product should be equal to 1.
-    >>> sum_product([])
-    (0, 1)
-    >>> sum_product([1, 2, 3, 4])
-    (10, 24)
-    """"""
-",0.95,1.0,1.0
-"from typing import List, Tuple
-
-
-def rolling_max(numbers: List[int]) -> List[int]:
-    """""" From a given list of integers, generate a list of rolling maximum element found until given moment
-    in the sequence.
-    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
-    [1, 2, 3, 3, 3, 4, 4]
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-
-def is_palindrome(string: str) -> bool:
-    """""" Test if given string is a palindrome """"""
-    return string == string[::-1]
-
-
-def make_palindrome(string: str) -> str:
-    """""" Find the shortest palindrome that begins with a supplied string.
-    Algorithm idea is simple:
-    - Find the longest postfix of supplied string that is a palindrome.
-    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
-    >>> make_palindrome('')
-    ''
-    >>> make_palindrome('cat')
-    'catac'
-    >>> make_palindrome('cata')
-    'catac'
-    """"""
-",0.0,0.0,0.0
-"from typing import List
-
-
-def string_xor(a: str, b: str) -> str:
-    """""" Input are two strings a and b consisting only of 1s and 0s.
-    Perform binary XOR on these inputs and return result also as a string.
-    >>> string_xor('010', '110')
-    '100'
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"from typing import List, Optional
-
-
-def longest(strings: List[str]) -> Optional[str]:
-    """""" Out of list of strings, return the longest one. Return the first one in case of multiple
-    strings of the same length. Return None in case the input list is empty.
-    >>> longest([])
-
-    >>> longest(['a', 'b', 'c'])
-    'a'
-    >>> longest(['a', 'bb', 'ccc'])
-    'ccc'
-    """"""
-",1.0,1.0,1.0
-"
-
-def greatest_common_divisor(a: int, b: int) -> int:
-    """""" Return a greatest common divisor of two integers a and b
-    >>> greatest_common_divisor(3, 5)
-    1
-    >>> greatest_common_divisor(25, 15)
-    5
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"from typing import List
-
-
-def all_prefixes(string: str) -> List[str]:
-    """""" Return list of all prefixes from shortest to longest of the input string
-    >>> all_prefixes('abc')
-    ['a', 'ab', 'abc']
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-
-def string_sequence(n: int) -> str:
-    """""" Return a string containing space-delimited numbers starting from 0 upto n inclusive.
-    >>> string_sequence(0)
-    '0'
-    >>> string_sequence(5)
-    '0 1 2 3 4 5'
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-
-def count_distinct_characters(string: str) -> int:
-    """""" Given a string, find out how many distinct characters (regardless of case) does it consist of
-    >>> count_distinct_characters('xyzXYZ')
-    3
-    >>> count_distinct_characters('Jerry')
-    4
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"from typing import List
-
-
-def parse_music(music_string: str) -> List[int]:
-    """""" Input to this function is a string representing musical notes in a special ASCII format.
-    Your task is to parse this string and return list of integers corresponding to how many beats does each
-    not last.
-
-    Here is a legend:
-    'o' - whole note, lasts four beats
-    'o|' - half note, lasts two beats
-    '.|' - quater note, lasts one beat
-
-    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
-    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-
-def how_many_times(string: str, substring: str) -> int:
-    """""" Find how many times a given substring can be found in the original string. Count overlaping cases.
-    >>> how_many_times('', 'a')
-    0
-    >>> how_many_times('aaa', 'a')
-    3
-    >>> how_many_times('aaaa', 'aa')
-    3
-    """"""
-",0.7999999999999999,1.0,1.0
-"from typing import List
-
-
-def sort_numbers(numbers: str) -> str:
-    """""" Input is a space-delimited string of numberals from 'zero' to 'nine'.
-    Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
-    Return the string with numbers sorted from smallest to largest
-    >>> sort_numbers('three one five')
-    'one three five'
-    """"""
-",0.0,0.0,0.0
-"from typing import List, Tuple
-
-
-def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
-    """""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
-    other and return them in order (smaller number, larger number).
-    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
-    (2.0, 2.2)
-    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
-    (2.0, 2.0)
-    """"""
-",0.65,0.9986455108359134,1.0
-"from typing import List
-
-
-def rescale_to_unit(numbers: List[float]) -> List[float]:
-    """""" Given list of numbers (of at least two elements), apply a linear transform to that list,
-    such that the smallest number will become 0 and the largest will become 1
-    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
-    [0.0, 0.25, 0.5, 0.75, 1.0]
-    """"""
-",0.7999999999999999,1.0,1.0
-"from typing import List, Any
-
-
-def filter_integers(values: List[Any]) -> List[int]:
-    """""" Filter given list of any python values only for integers
-    >>> filter_integers(['a', 3.14, 5])
-    [5]
-    >>> filter_integers([1, 2, 3, 'abc', {}, []])
-    [1, 2, 3]
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-
-def strlen(string: str) -> int:
-    """""" Return length of given string
-    >>> strlen('')
-    0
-    >>> strlen('abc')
-    3
-    """"""
-",0.85,1.0,1.0
-"
-
-def largest_divisor(n: int) -> int:
-    """""" For a given number n, find the largest number that divides n evenly, smaller than n
-    >>> largest_divisor(15)
-    5
-    """"""
-",0.050000000000000044,0.25,0.5
-"from typing import List
-
-
-def factorize(n: int) -> List[int]:
-    """""" Return list of prime factors of given integer in the order from smallest to largest.
-    Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
-    Input number should be equal to the product of all factors
-    >>> factorize(8)
-    [2, 2, 2]
-    >>> factorize(25)
-    [5, 5]
-    >>> factorize(70)
-    [2, 5, 7]
-    """"""
-",0.95,1.0,1.0
-"from typing import List
-
-
-def remove_duplicates(numbers: List[int]) -> List[int]:
-    """""" From a list of integers, remove all elements that occur more than once.
-    Keep order of elements left the same as in the input.
-    >>> remove_duplicates([1, 2, 3, 2, 4])
-    [1, 3, 4]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-
-def flip_case(string: str) -> str:
-    """""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
-    >>> flip_case('Hello')
-    'hELLO'
-    """"""
-",0.85,1.0,1.0
-"from typing import List
-
-
-def concatenate(strings: List[str]) -> str:
-    """""" Concatenate list of strings into a single string
-    >>> concatenate([])
-    ''
-    >>> concatenate(['a', 'b', 'c'])
-    'abc'
-    """"""
-",0.7,0.9996130030959752,1.0
-"from typing import List
-
-
-def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
-    """""" Filter an input list of strings only for ones that start with a given prefix.
-    >>> filter_by_prefix([], 'a')
-    []
-    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
-    ['abc', 'array']
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-
-def get_positive(l: list):
-    """"""Return only positive numbers in the list.
-    >>> get_positive([-1, 2, -4, 5, 6])
-    [2, 5, 6]
-    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
-    [5, 3, 2, 3, 9, 123, 1]
-    """"""
-",0.75,0.9999355005159959,1.0
-"
-
-def is_prime(n):
-    """"""Return true if a given number is prime, and false otherwise.
-    >>> is_prime(6)
-    False
-    >>> is_prime(101)
-    True
-    >>> is_prime(11)
-    True
-    >>> is_prime(13441)
-    True
-    >>> is_prime(61)
-    True
-    >>> is_prime(4)
-    False
-    >>> is_prime(1)
-    False
-    """"""
-",0.85,1.0,1.0
-"import math
-
-
-def poly(xs: list, x: float):
-    """"""
-    Evaluates polynomial with coefficients xs at point x.
-    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
-    """"""
-    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
-
-
-def find_zero(xs: list):
-    """""" xs are coefficients of a polynomial.
-    find_zero find x such that poly(x) = 0.
-    find_zero returns only only zero point, even if there are many.
-    Moreover, find_zero only takes list xs having even number of coefficients
-    and largest non zero coefficient as it guarantees
-    a solution.
-    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
-    -0.5
-    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
-    1.0
-    """"""
-",0.0,0.0,0.0
-"
-
-def sort_third(l: list):
-    """"""This function takes a list l and returns a list l' such that
-    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
-    to the values of the corresponding indicies of l, but sorted.
-    >>> sort_third([1, 2, 3])
-    [1, 2, 3]
-    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
-    [2, 6, 3, 4, 8, 9, 5]
-    """"""
-",0.0,0.0,0.0
-"
-
-def unique(l: list):
-    """"""Return sorted unique elements in a list
-    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
-    [0, 2, 3, 5, 9, 123]
-    """"""
-",0.7999999999999999,1.0,1.0
-"
-
-def max_element(l: list):
-    """"""Return maximum element in the list.
-    >>> max_element([1, 2, 3])
-    3
-    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
-    123
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-
-def fizz_buzz(n: int):
-    """"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
-    >>> fizz_buzz(50)
-    0
-    >>> fizz_buzz(78)
-    2
-    >>> fizz_buzz(79)
-    3
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"
-
-def sort_even(l: list):
-    """"""This function takes a list l and returns a list l' such that
-    l' is identical to l in the odd indicies, while its values at the even indicies are equal
-    to the values of the even indicies of l, but sorted.
-    >>> sort_even([1, 2, 3])
-    [1, 2, 3]
-    >>> sort_even([5, 6, 3, 4])
-    [3, 6, 5, 4]
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-
-def encode_cyclic(s: str):
-    """"""
-    returns encoded string by cycling groups of three characters.
-    """"""
-    # split string to groups. Each of length 3.
-    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
-    # cycle elements in each group. Unless group has fewer elements than 3.
-    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
-    return """".join(groups)
-
-
-def decode_cyclic(s: str):
-    """"""
-    takes as input string encoded with encode_cyclic function. Returns decoded string.
-    """"""
-",0.0,0.0,0.0
-"
-
-def prime_fib(n: int):
-    """"""
-    prime_fib returns n-th number that is a Fibonacci number and it's also prime.
-    >>> prime_fib(1)
-    2
-    >>> prime_fib(2)
-    3
-    >>> prime_fib(3)
-    5
-    >>> prime_fib(4)
-    13
-    >>> prime_fib(5)
-    89
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-
-def triples_sum_to_zero(l: list):
-    """"""
-    triples_sum_to_zero takes a list of integers as an input.
-    it returns True if there are three distinct elements in the list that
-    sum to zero, and False otherwise.
-
-    >>> triples_sum_to_zero([1, 3, 5, 0])
-    False
-    >>> triples_sum_to_zero([1, 3, -2, 1])
-    True
-    >>> triples_sum_to_zero([1, 2, 3, 7])
-    False
-    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
-    True
-    >>> triples_sum_to_zero([1])
-    False
-    """"""
-",0.85,1.0,1.0
-"
-
-def car_race_collision(n: int):
-    """"""
-    Imagine a road that's a perfectly straight infinitely long line.
-    n cars are driving left to right;  simultaneously, a different set of n cars
-    are driving right to left.   The two sets of cars start out being very far from
-    each other.  All cars move in the same speed.  Two cars are said to collide
-    when a car that's moving left to right hits a car that's moving right to left.
-    However, the cars are infinitely sturdy and strong; as a result, they continue moving
-    in their trajectory as if they did not collide.
-
-    This function outputs the number of such collisions.
-    """"""
-",0.0,0.0,0.0
-"
-
-def incr_list(l: list):
-    """"""Return list with elements incremented by 1.
-    >>> incr_list([1, 2, 3])
-    [2, 3, 4]
-    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
-    [6, 4, 6, 3, 4, 4, 10, 1, 124]
-    """"""
-",0.75,0.9999355005159959,1.0
-"
-
-def pairs_sum_to_zero(l):
-    """"""
-    pairs_sum_to_zero takes a list of integers as an input.
-    it returns True if there are two distinct elements in the list that
-    sum to zero, and False otherwise.
-    >>> pairs_sum_to_zero([1, 3, 5, 0])
-    False
-    >>> pairs_sum_to_zero([1, 3, -2, 1])
-    False
-    >>> pairs_sum_to_zero([1, 2, 3, 7])
-    False
-    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
-    True
-    >>> pairs_sum_to_zero([1])
-    False
-    """"""
-",0.85,1.0,1.0
-"
-
-def change_base(x: int, base: int):
-    """"""Change numerical base of input number x to base.
-    return string representation after the conversion.
-    base numbers are less than 10.
-    >>> change_base(8, 3)
-    '22'
-    >>> change_base(8, 2)
-    '1000'
-    >>> change_base(7, 2)
-    '111'
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-
-def triangle_area(a, h):
-    """"""Given length of a side and high return area for a triangle.
-    >>> triangle_area(5, 3)
-    7.5
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-
-def fib4(n: int):
-    """"""The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
-    fib4(0) -> 0
-    fib4(1) -> 0
-    fib4(2) -> 2
-    fib4(3) -> 0
-    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
-    Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
-    >>> fib4(5)
-    4
-    >>> fib4(6)
-    8
-    >>> fib4(7)
-    14
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-
-def median(l: list):
-    """"""Return median of elements in the list l.
-    >>> median([3, 1, 2, 4, 5])
-    3
-    >>> median([-10, 4, 6, 1000, 10, 20])
-    15.0
-    """"""
-",0.75,0.9999355005159959,1.0
-"
-
-def is_palindrome(text: str):
-    """"""
-    Checks if given string is a palindrome
-    >>> is_palindrome('')
-    True
-    >>> is_palindrome('aba')
-    True
-    >>> is_palindrome('aaaaa')
-    True
-    >>> is_palindrome('zbcd')
-    False
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-
-def modp(n: int, p: int):
-    """"""Return 2^n modulo p (be aware of numerics).
-    >>> modp(3, 5)
-    3
-    >>> modp(1101, 101)
-    2
-    >>> modp(0, 101)
-    1
-    >>> modp(3, 11)
-    8
-    >>> modp(100, 101)
-    1
-    """"""
-",0.0,0.0,0.0
-"
-
-def encode_shift(s: str):
-    """"""
-    returns encoded string by shifting every character by 5 in the alphabet.
-    """"""
-    return """".join([chr(((ord(ch) + 5 - ord(""a"")) % 26) + ord(""a"")) for ch in s])
-
-
-def decode_shift(s: str):
-    """"""
-    takes as input string encoded with encode_shift function. Returns decoded string.
-    """"""
-",1.0,1.0,1.0
-"
-
-def remove_vowels(text):
-    """"""
-    remove_vowels is a function that takes string and returns string without vowels.
-    >>> remove_vowels('')
-    ''
-    >>> remove_vowels(""abcdef\nghijklm"")
-    'bcdf\nghjklm'
-    >>> remove_vowels('abcdef')
-    'bcdf'
-    >>> remove_vowels('aaaaa')
-    ''
-    >>> remove_vowels('aaBAA')
-    'B'
-    >>> remove_vowels('zbcd')
-    'zbcd'
-    """"""
-",0.85,1.0,1.0
-"
-
-def below_threshold(l: list, t: int):
-    """"""Return True if all numbers in the list l are below threshold t.
-    >>> below_threshold([1, 2, 4, 10], 100)
-    True
-    >>> below_threshold([1, 20, 4, 10], 5)
-    False
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-
-def add(x: int, y: int):
-    """"""Add two numbers x and y
-    >>> add(2, 3)
-    5
-    >>> add(5, 7)
-    12
-    """"""
-",0.7999999999999999,1.0,1.0
-"
-
-def same_chars(s0: str, s1: str):
-    """"""
-    Check if two words have the same characters.
-    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
-    True
-    >>> same_chars('abcd', 'dddddddabc')
-    True
-    >>> same_chars('dddddddabc', 'abcd')
-    True
-    >>> same_chars('eabcd', 'dddddddabc')
-    False
-    >>> same_chars('abcd', 'dddddddabce')
-    False
-    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
-    False
-    """"""
-",0.85,1.0,1.0
-"
-
-def fib(n: int):
-    """"""Return n-th Fibonacci number.
-    >>> fib(10)
-    55
-    >>> fib(1)
-    1
-    >>> fib(8)
-    21
-    """"""
-",0.7999999999999999,1.0,1.0
-"
-
-def correct_bracketing(brackets: str):
-    """""" brackets is a string of ""<"" and "">"".
-    return True if every opening bracket has a corresponding closing bracket.
-
-    >>> correct_bracketing(""<"")
-    False
-    >>> correct_bracketing(""<>"")
-    True
-    >>> correct_bracketing(""<<><>>"")
-    True
-    >>> correct_bracketing(""><<>"")
-    False
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-
-def monotonic(l: list):
-    """"""Return True is list elements are monotonically increasing or decreasing.
-    >>> monotonic([1, 2, 4, 20])
-    True
-    >>> monotonic([1, 20, 4, 10])
-    False
-    >>> monotonic([4, 1, 0, -10])
-    True
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-
-def common(l1: list, l2: list):
-    """"""Return sorted unique common elements for two lists.
-    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
-    [1, 5, 653]
-    >>> common([5, 3, 2, 8], [3, 2])
-    [2, 3]
-
-    """"""
-",0.75,0.9999355005159959,1.0
-"
-
-def largest_prime_factor(n: int):
-    """"""Return the largest prime factor of n. Assume n > 1 and is not a prime.
-    >>> largest_prime_factor(13195)
-    29
-    >>> largest_prime_factor(2048)
-    2
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-
-def sum_to_n(n: int):
-    """"""sum_to_n is a function that sums numbers from 1 to n.
-    >>> sum_to_n(30)
-    465
-    >>> sum_to_n(100)
-    5050
-    >>> sum_to_n(5)
-    15
-    >>> sum_to_n(10)
-    55
-    >>> sum_to_n(1)
-    1
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-
-def correct_bracketing(brackets: str):
-    """""" brackets is a string of ""("" and "")"".
-    return True if every opening bracket has a corresponding closing bracket.
-
-    >>> correct_bracketing(""("")
-    False
-    >>> correct_bracketing(""()"")
-    True
-    >>> correct_bracketing(""(()())"")
-    True
-    >>> correct_bracketing("")(()"")
-    False
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-
-def derivative(xs: list):
-    """""" xs represent coefficients of a polynomial.
-    xs[0] + xs[1] * x + xs[2] * x^2 + ....
-     Return derivative of this polynomial in the same form.
-    >>> derivative([3, 1, 2, 4, 5])
-    [1, 4, 12, 20]
-    >>> derivative([1, 2, 3])
-    [2, 6]
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-
-def fibfib(n: int):
-    """"""The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
-    fibfib(0) == 0
-    fibfib(1) == 0
-    fibfib(2) == 1
-    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
-    Please write a function to efficiently compute the n-th element of the fibfib number sequence.
-    >>> fibfib(1)
-    0
-    >>> fibfib(5)
-    4
-    >>> fibfib(8)
-    24
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-FIX = """"""
-Add more test cases.
-""""""
-
-def vowels_count(s):
-    """"""Write a function vowels_count which takes a string representing
-    a word as input and returns the number of vowels in the string.
-    Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
-    vowel, but only when it is at the end of the given word.
-
-    Example:
-    >>> vowels_count(""abcde"")
-    2
-    >>> vowels_count(""ACEDY"")
-    3
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-def circular_shift(x, shift):
-    """"""Circular shift the digits of the integer x, shift the digits right by shift
-    and return the result as a string.
-    If shift > number of digits, return digits reversed.
-    >>> circular_shift(12, 1)
-    ""21""
-    >>> circular_shift(12, 2)
-    ""12""
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def digitSum(s):
-    """"""Task
-    Write a function that takes a string as input and returns the sum of the upper characters only'
-    ASCII codes.
-
-    Examples:
-        digitSum("""") => 0
-        digitSum(""abAB"") => 131
-        digitSum(""abcCd"") => 67
-        digitSum(""helloE"") => 69
-        digitSum(""woArBld"") => 131
-        digitSum(""aAaaaXa"") => 153
-    """"""
-",0.75,0.9999355005159959,1.0
-"
-def fruit_distribution(s,n):
-    """"""
-    In this task, you will be given a string that represents a number of apples and oranges 
-    that are distributed in a basket of fruit this basket contains 
-    apples, oranges, and mango fruits. Given the string that represents the total number of 
-    the oranges and apples and an integer that represent the total number of the fruits 
-    in the basket return the number of the mango fruits in the basket.
-    for examble:
-    fruit_distribution(""5 apples and 6 oranges"", 19) ->19 - 5 - 6 = 8
-    fruit_distribution(""0 apples and 1 oranges"",3) -> 3 - 0 - 1 = 2
-    fruit_distribution(""2 apples and 3 oranges"", 100) -> 100 - 2 - 3 = 95
-    fruit_distribution(""100 apples and 1 oranges"",120) -> 120 - 100 - 1 = 19
-    """"""
-",0.0,0.0,0.0
-"
-def pluck(arr):
-    """"""
-    ""Given an array representing a branch of a tree that has non-negative integer nodes
-    your task is to pluck one of the nodes and return it.
-    The plucked node should be the node with the smallest even value.
-    If multiple nodes with the same smallest even value are found return the node that has smallest index.
-
-    The plucked node should be returned in a list, [ smalest_value, its index ],
-    If there are no even values or the given array is empty, return [].
-
-    Example 1:
-        Input: [4,2,3]
-        Output: [2, 1]
-        Explanation: 2 has the smallest even value, and 2 has the smallest index.
-
-    Example 2:
-        Input: [1,2,3]
-        Output: [2, 1]
-        Explanation: 2 has the smallest even value, and 2 has the smallest index. 
-
-    Example 3:
-        Input: []
-        Output: []
-    
-    Example 4:
-        Input: [5, 0, 3, 0, 4, 2]
-        Output: [0, 1]
-        Explanation: 0 is the smallest value, but  there are two zeros,
-                     so we will choose the first zero, which has the smallest index.
-
-    Constraints:
-        * 1 <= nodes.length <= 10000
-        * 0 <= node.value
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-def search(lst):
-    '''
-    You are given a non-empty list of positive integers. Return the greatest integer that is greater than 
-    zero, and has a frequency greater than or equal to the value of the integer itself. 
-    The frequency of an integer is the number of times it appears in the list.
-    If no such a value exist, return -1.
-    Examples:
-        search([4, 1, 2, 2, 3, 1]) == 2
-        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
-        search([5, 5, 4, 4, 4]) == -1
-    '''
-",0.0,0.0,0.0
-"
-def strange_sort_list(lst):
-    '''
-    Given list of integers, return list in strange order.
-    Strange sorting, is when you start with the minimum value,
-    then maximum of the remaining integers, then minimum and so on.
-
-    Examples:
-    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
-    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
-    strange_sort_list([]) == []
-    '''
-",0.0,0.0,0.0
-"
-def triangle_area(a, b, c):
-    '''
-    Given the lengths of the three sides of a triangle. Return the area of
-    the triangle rounded to 2 decimal points if the three sides form a valid triangle. 
-    Otherwise return -1
-    Three sides make a valid triangle when the sum of any two sides is greater 
-    than the third side.
-    Example:
-    triangle_area(3, 4, 5) == 6.00
-    triangle_area(1, 2, 10) == -1
-    '''
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-def will_it_fly(q,w):
-    '''
-    Write a function that returns True if the object q will fly, and False otherwise.
-    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.
-
-    Example:
-    will_it_fly([1, 2], 5) ➞ False 
-    # 1+2 is less than the maximum possible weight, but it's unbalanced.
-
-    will_it_fly([3, 2, 3], 1) ➞ False
-    # it's balanced, but 3+2+3 is more than the maximum possible weight.
-
-    will_it_fly([3, 2, 3], 9) ➞ True
-    # 3+2+3 is less than the maximum possible weight, and it's balanced.
-
-    will_it_fly([3], 5) ➞ True
-    # 3 is less than the maximum possible weight, and it's balanced.
-    '''
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def smallest_change(arr):
-    """"""
-    Given an array arr of integers, find the minimum number of elements that
-    need to be changed to make the array palindromic. A palindromic array is an array that
-    is read the same backwards and forwards. In one change, you can change one element to any other element.
-
-    For example:
-    smallest_change([1,2,3,5,4,7,9,6]) == 4
-    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
-    smallest_change([1, 2, 3, 2, 1]) == 0
-    """"""
-",0.0,0.0,0.0
-"
-def total_match(lst1, lst2):
-    '''
-    Write a function that accepts two lists of strings and returns the list that has 
-    total number of chars in the all strings of the list less than the other list.
-
-    if the two lists have the same number of chars, return the first list.
-
-    Examples
-    total_match([], []) ➞ []
-    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
-    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
-    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
-    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
-    '''
-",0.0,0.0,0.0
-"
-def is_multiply_prime(a):
-    """"""Write a function that returns true if the given number is the multiplication of 3 prime numbers
-    and false otherwise.
-    Knowing that (a) is less then 100. 
-    Example:
-    is_multiply_prime(30) == True
-    30 = 2 * 3 * 5
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def is_simple_power(x, n):
-    """"""Your task is to write a function that returns true if a number x is a simple
-    power of n and false in other cases.
-    x is a simple power of n if n**int=x
-    For example:
-    is_simple_power(1, 4) => true
-    is_simple_power(2, 2) => true
-    is_simple_power(8, 2) => true
-    is_simple_power(3, 2) => false
-    is_simple_power(3, 1) => false
-    is_simple_power(5, 3) => false
-    """"""
-",0.0,0.0,0.0
-"
-def iscube(a):
-    '''
-    Write a function that takes an integer a and returns True 
-    if this ingeger is a cube of some integer number.
-    Note: you may assume the input is always valid.
-    Examples:
-    iscube(1) ==> True
-    iscube(2) ==> False
-    iscube(-1) ==> True
-    iscube(64) ==> True
-    iscube(0) ==> True
-    iscube(180) ==> False
-    '''
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def hex_key(num):
-    """"""You have been tasked to write a function that receives 
-    a hexadecimal number as a string and counts the number of hexadecimal 
-    digits that are primes (prime number, or a prime, is a natural number 
-    greater than 1 that is not a product of two smaller natural numbers).
-    Hexadecimal digits are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
-    Prime numbers are 2, 3, 5, 7, 11, 13, 17,...
-    So you have to determine a number of the following digits: 2, 3, 5, 7, 
-    B (=decimal 11), D (=decimal 13).
-    Note: you may assume the input is always correct or empty string, 
-    and symbols A,B,C,D,E,F are always uppercase.
-    Examples:
-    For num = ""AB"" the output should be 1.
-    For num = ""1077E"" the output should be 2.
-    For num = ""ABED1A33"" the output should be 4.
-    For num = ""123456789ABCDEF0"" the output should be 6.
-    For num = ""2020"" the output should be 2.
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def decimal_to_binary(decimal):
-    """"""You will be given a number in decimal form and your task is to convert it to
-    binary format. The function should return a string, with each character representing a binary
-    number. Each character in the string will be '0' or '1'.
-
-    There will be an extra couple of characters 'db' at the beginning and at the end of the string.
-    The extra characters are there to help with the format.
-
-    Examples:
-    decimal_to_binary(15)   # returns ""db1111db""
-    decimal_to_binary(32)   # returns ""db100000db""
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-def is_happy(s):
-    """"""You are given a string s.
-    Your task is to check if the string is happy or not.
-    A string is happy if its length is at least 3 and every 3 consecutive letters are distinct
-    For example:
-    is_happy(a) => False
-    is_happy(aa) => False
-    is_happy(abcd) => True
-    is_happy(aabb) => False
-    is_happy(adb) => True
-    is_happy(xyy) => False
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def numerical_letter_grade(grades):
-    """"""It is the last week of the semester and the teacher has to give the grades
-    to students. The teacher has been making her own algorithm for grading.
-    The only problem is, she has lost the code she used for grading.
-    She has given you a list of GPAs for some students and you have to write 
-    a function that can output a list of letter grades using the following table:
-             GPA       |    Letter grade
-              4.0                A+
-            > 3.7                A 
-            > 3.3                A- 
-            > 3.0                B+
-            > 2.7                B 
-            > 2.3                B-
-            > 2.0                C+
-            > 1.7                C
-            > 1.3                C-
-            > 1.0                D+ 
-            > 0.7                D 
-            > 0.0                D-
-              0.0                E
-    
-
-    Example:
-    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def prime_length(string):
-    """"""Write a function that takes a string and returns True if the string
-    length is a prime number or False otherwise
-    Examples
-    prime_length('Hello') == True
-    prime_length('abcdcba') == True
-    prime_length('kittens') == True
-    prime_length('orange') == False
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def starts_one_ends(n):
-    """"""
-    Given a positive integer n, return the count of the numbers of n-digit
-    positive integers that start or end with 1.
-    """"""
-",0.0,0.0,0.0
-"
-def solve(N):
-    """"""Given a positive integer N, return the total sum of its digits in binary.
-    
-    Example
-        For N = 1000, the sum of digits will be 1 the output should be ""1"".
-        For N = 150, the sum of digits will be 6 the output should be ""110"".
-        For N = 147, the sum of digits will be 12 the output should be ""1100"".
-    
-    Variables:
-        @N integer
-             Constraints: 0 ≤ N ≤ 10000.
-    Output:
-         a string of binary number
-    """"""
-",0.0,0.0,0.0
-"
-def add(lst):
-    """"""Given a non-empty list of integers lst. add the even elements that are at odd indices..
-
-
-    Examples:
-        add([4, 2, 6, 7]) ==> 2 
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-def anti_shuffle(s):
-    """"""
-    Write a function that takes a string and returns an ordered version of it.
-    Ordered version of string, is a string where all words (separated by space)
-    are replaced by a new word where all the characters arranged in
-    ascending order based on ascii value.
-    Note: You should keep the order of words and blank spaces in the sentence.
-
-    For example:
-    anti_shuffle('Hi') returns 'Hi'
-    anti_shuffle('hello') returns 'ehllo'
-    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-def get_row(lst, x):
-    """"""
-    You are given a 2 dimensional data, as a nested lists,
-    which is similar to matrix, however, unlike matrices,
-    each row may contain a different number of columns.
-    Given lst, and integer x, find integers x in the list,
-    and return list of tuples, [(x1, y1), (x2, y2) ...] such that
-    each tuple is a coordinate - (row, columns), starting with 0.
-    Sort coordinates initially by rows in ascending order.
-    Also, sort coordinates of the row by columns in descending order.
-    
-    Examples:
-    get_row([
-      [1,2,3,4,5,6],
-      [1,2,3,4,1,6],
-      [1,2,3,4,5,1]
-    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
-    get_row([], 1) == []
-    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
-    """"""
-",0.0,0.0,0.0
-"
-def sort_array(array):
-    """"""
-    Given an array of non-negative integers, return a copy of the given array after sorting,
-    you will sort the given array in ascending order if the sum( first index value, last index value) is odd,
-    or sort it in descending order if the sum( first index value, last index value) is even.
-
-    Note:
-    * don't change the given array.
-
-    Examples:
-    * sort_array([]) => []
-    * sort_array([5]) => [5]
-    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
-    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def encrypt(s):
-    """"""Create a function encrypt that takes a string as an argument and
-    returns a string encrypted with the alphabet being rotated. 
-    The alphabet should be rotated in a manner such that the letters 
-    shift down by two multiplied to two places.
-    For example:
-    encrypt('hi') returns 'lm'
-    encrypt('asdfghjkl') returns 'ewhjklnop'
-    encrypt('gf') returns 'kj'
-    encrypt('et') returns 'ix'
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def next_smallest(lst):
-    """"""
-    You are given a list of integers.
-    Write a function next_smallest() that returns the 2nd smallest element of the list.
-    Return None if there is no such element.
-    
-    next_smallest([1, 2, 3, 4, 5]) == 2
-    next_smallest([5, 1, 4, 3, 2]) == 2
-    next_smallest([]) == None
-    next_smallest([1, 1]) == None
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def is_bored(S):
-    """"""
-    You'll be given a string of words, and your task is to count the number
-    of boredoms. A boredom is a sentence that starts with the word ""I"".
-    Sentences are delimited by '.', '?' or '!'.
-   
-    For example:
-    >>> is_bored(""Hello world"")
-    0
-    >>> is_bored(""The sky is blue. The sun is shining. I love this weather"")
-    1
-    """"""
-",0.0,0.0,0.0
-"
-def any_int(x, y, z):
-    '''
-    Create a function that takes 3 numbers.
-    Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
-    Returns false in any other cases.
-    
-    Examples
-    any_int(5, 2, 7) ➞ True
-    
-    any_int(3, 2, 2) ➞ False
-
-    any_int(3, -2, 1) ➞ True
-    
-    any_int(3.6, -2.2, 2) ➞ False
-  
-
-    
-    '''
-",0.4,0.9489164086687306,0.9996427720885925
-"
-def encode(message):
-    """"""
-    Write a function that takes a message, and encodes in such a 
-    way that it swaps case of all letters, replaces all vowels in 
-    the message with the letter that appears 2 places ahead of that 
-    vowel in the english alphabet. 
-    Assume only letters. 
-    
-    Examples:
-    >>> encode('test')
-    'TGST'
-    >>> encode('This is a message')
-    'tHKS KS C MGSSCGG'
-    """"""
-",0.0,0.0,0.0
-"
-
-def skjkasdkd(lst):
-    """"""You are given a list of integers.
-    You need to find the largest prime value and return the sum of its digits.
-
-    Examples:
-    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
-    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
-    For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13
-    For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11
-    For lst = [0,81,12,3,1,21] the output should be 3
-    For lst = [0,8,1,2,1,7] the output should be 7
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def check_dict_case(dict):
-    """"""
-    Given a dictionary, return True if all keys are strings in lower 
-    case or all keys are strings in upper case, else return False.
-    The function should return False is the given dictionary is empty.
-    Examples:
-    check_dict_case({""a"":""apple"", ""b"":""banana""}) should return True.
-    check_dict_case({""a"":""apple"", ""A"":""banana"", ""B"":""banana""}) should return False.
-    check_dict_case({""a"":""apple"", 8:""banana"", ""a"":""apple""}) should return False.
-    check_dict_case({""Name"":""John"", ""Age"":""36"", ""City"":""Houston""}) should return False.
-    check_dict_case({""STATE"":""NC"", ""ZIP"":""12345"" }) should return True.
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def count_up_to(n):
-    """"""Implement a function that takes an non-negative integer and returns an array of the first n
-    integers that are prime numbers and less than n.
-    for example:
-    count_up_to(5) => [2,3]
-    count_up_to(11) => [2,3,5,7]
-    count_up_to(0) => []
-    count_up_to(20) => [2,3,5,7,11,13,17,19]
-    count_up_to(1) => []
-    count_up_to(18) => [2,3,5,7,11,13,17]
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-def multiply(a, b):
-    """"""Complete the function that takes two integers and returns 
-    the product of their unit digits.
-    Assume the input is always valid.
-    Examples:
-    multiply(148, 412) should return 16.
-    multiply(19, 28) should return 72.
-    multiply(2020, 1851) should return 0.
-    multiply(14,-15) should return 20.
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def count_upper(s):
-    """"""
-    Given a string s, count the number of uppercase vowels in even indices.
-    
-    For example:
-    count_upper('aBCdEf') returns 1
-    count_upper('abcdefg') returns 0
-    count_upper('dBBE') returns 0
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def closest_integer(value):
-    '''
-    Create a function that takes a value (string) representing a number
-    and returns the closest integer to it. If the number is equidistant
-    from two integers, round it away from zero.
-
-    Examples
-    >>> closest_integer(""10"")
-    10
-    >>> closest_integer(""15.3"")
-    15
-
-    Note:
-    Rounding away from zero means that if the given number is equidistant
-    from two integers, the one you should return is the one that is the
-    farthest from zero. For example closest_integer(""14.5"") should
-    return 15 and closest_integer(""-14.5"") should return -15.
-    '''
-",0.0,0.0,0.0
-"
-def make_a_pile(n):
-    """"""
-    Given a positive integer n, you have to make a pile of n levels of stones.
-    The first level has n stones.
-    The number of stones in the next level is:
-        - the next odd number if n is odd.
-        - the next even number if n is even.
-    Return the number of stones in each level in a list, where element at index
-    i represents the number of stones in the level (i+1).
-
-    Examples:
-    >>> make_a_pile(3)
-    [3, 5, 7]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def words_string(s):
-    """"""
-    You will be given a string of words separated by commas or spaces. Your task is
-    to split the string into words and return an array of the words.
-    
-    For example:
-    words_string(""Hi, my name is John"") == [""Hi"", ""my"", ""name"", ""is"", ""John""]
-    words_string(""One, two, three, four, five, six"") == [""One"", ""two"", ""three"", ""four"", ""five"", ""six""]
-    """"""
-",0.0,0.0,0.0
-"
-def choose_num(x, y):
-    """"""This function takes two positive numbers x and y and returns the
-    biggest even integer number that is in the range [x, y] inclusive. If 
-    there's no such number, then the function should return -1.
-
-    For example:
-    choose_num(12, 15) = 14
-    choose_num(13, 12) = -1
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def rounded_avg(n, m):
-    """"""You are given two positive integers n and m, and your task is to compute the
-    average of the integers from n through m (including n and m). 
-    Round the answer to the nearest integer and convert that to binary.
-    If n is greater than m, return -1.
-    Example:
-    rounded_avg(1, 5) => ""0b11""
-    rounded_avg(7, 5) => -1
-    rounded_avg(10, 20) => ""0b1111""
-    rounded_avg(20, 33) => ""0b11010""
-    """"""
-",0.0,0.0,0.0
-"
-def unique_digits(x):
-    """"""Given a list of positive integers x. return a sorted list of all 
-    elements that hasn't any even digit.
-
-    Note: Returned list should be sorted in increasing order.
-    
-    For example:
-    >>> unique_digits([15, 33, 1422, 1])
-    [1, 15, 33]
-    >>> unique_digits([152, 323, 1422, 10])
-    []
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def by_length(arr):
-    """"""
-    Given an array of integers, sort the integers that are between 1 and 9 inclusive,
-    reverse the resulting array, and then replace each digit by its corresponding name from
-    ""One"", ""Two"", ""Three"", ""Four"", ""Five"", ""Six"", ""Seven"", ""Eight"", ""Nine"".
-
-    For example:
-      arr = [2, 1, 1, 4, 5, 8, 2, 3]   
-            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8] 
-            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
-      return [""Eight"", ""Five"", ""Four"", ""Three"", ""Two"", ""Two"", ""One"", ""One""]
-    
-      If the array is empty, return an empty array:
-      arr = []
-      return []
-    
-      If the array has any strange number ignore it:
-      arr = [1, -1 , 55] 
-            -> sort arr -> [-1, 1, 55]
-            -> reverse arr -> [55, 1, -1]
-      return = ['One']
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def f(n):
-    """""" Implement the function f that takes n as a parameter,
-    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
-    or the sum of numbers from 1 to i otherwise.
-    i starts from 1.
-    the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... * i).
-    Example:
-    f(5) == [1, 2, 6, 24, 15]
-    """"""
-",0.0,0.0,0.0
-"
-def even_odd_palindrome(n):
-    """"""
-    Given a positive integer n, return a tuple that has the number of even and odd
-    integer palindromes that fall within the range(1, n), inclusive.
-
-    Example 1:
-
-        Input: 3
-        Output: (1, 2)
-        Explanation:
-        Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.
-
-    Example 2:
-
-        Input: 12
-        Output: (4, 6)
-        Explanation:
-        Integer palindrome are 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. four of them are even, and 6 of them are odd.
-
-    Note:
-        1. 1 <= n <= 10^3
-        2. returned tuple has the number of even and odd integer palindromes respectively.
-    """"""
-",0.95,1.0,1.0
-"
-def count_nums(arr):
-    """"""
-    Write a function count_nums which takes an array of integers and returns
-    the number of elements which has a sum of digits > 0.
-    If a number is negative, then its first signed digit will be negative:
-    e.g. -123 has signed digits -1, 2, and 3.
-    >>> count_nums([]) == 0
-    >>> count_nums([-1, 11, -11]) == 1
-    >>> count_nums([1, 1, 2]) == 3
-    """"""
-",0.0,0.0,0.0
-"
-def move_one_ball(arr):
-    """"""We have an array 'arr' of N integers arr[1], arr[2], ..., arr[N].The
-    numbers in the array will be randomly ordered. Your task is to determine if
-    it is possible to get an array sorted in non-decreasing order by performing 
-    the following operation on the given array:
-        You are allowed to perform right shift operation any number of times.
-    
-    One right shift operation means shifting all elements of the array by one
-    position in the right direction. The last element of the array will be moved to
-    the starting position in the array i.e. 0th index. 
-
-    If it is possible to obtain the sorted array by performing the above operation
-    then return True else return False.
-    If the given array is empty then return True.
-
-    Note: The given list is guaranteed to have unique elements.
-
-    For Example:
-    
-    move_one_ball([3, 4, 5, 1, 2])==>True
-    Explanation: By performin 2 right shift operations, non-decreasing order can
-                 be achieved for the given array.
-    move_one_ball([3, 5, 4, 1, 2])==>False
-    Explanation:It is not possible to get non-decreasing order for the given
-                array by performing any number of right shift operations.
-                
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def exchange(lst1, lst2):
-    """"""In this problem, you will implement a function that takes two lists of numbers,
-    and determines whether it is possible to perform an exchange of elements
-    between them to make lst1 a list of only even numbers.
-    There is no limit on the number of exchanged elements between lst1 and lst2.
-    If it is possible to exchange elements between the lst1 and lst2 to make
-    all the elements of lst1 to be even, return ""YES"".
-    Otherwise, return ""NO"".
-    For example:
-    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => ""YES""
-    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => ""NO""
-    It is assumed that the input lists will be non-empty.
-    """"""
-",0.0,0.0,0.0
-"
-def histogram(test):
-    """"""Given a string representing a space separated lowercase letters, return a dictionary
-    of the letter with the most repetition and containing the corresponding count.
-    If several letters have the same occurrence, return all of them.
-    
-    Example:
-    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
-    histogram('a b b a') == {'a': 2, 'b': 2}
-    histogram('a b c a b') == {'a': 2, 'b': 2}
-    histogram('b b b b a') == {'b': 4}
-    histogram('') == {}
-
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def reverse_delete(s,c):
-    """"""Task
-    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
-    then check if the result string is palindrome.
-    A string is called palindrome if it reads the same backward as forward.
-    You should return a tuple containing the result string and True/False for the check.
-    Example
-    For s = ""abcde"", c = ""ae"", the result should be ('bcd',False)
-    For s = ""abcdef"", c = ""b""  the result should be ('acdef',False)
-    For s = ""abcdedcba"", c = ""ab"", the result should be ('cdedc',True)
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-def odd_count(lst):
-    """"""Given a list of strings, where each string consists of only digits, return a list.
-    Each element i of the output should be ""the number of odd elements in the
-    string i of the input."" where all the i's should be replaced by the number
-    of odd digits in the i'th string of the input.
-
-    >>> odd_count(['1234567'])
-    [""the number of odd elements 4n the str4ng 4 of the 4nput.""]
-    >>> odd_count(['3',""11111111""])
-    [""the number of odd elements 1n the str1ng 1 of the 1nput."",
-     ""the number of odd elements 8n the str8ng 8 of the 8nput.""]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def minSubArraySum(nums):
-    """"""
-    Given an array of integers nums, find the minimum sum of any non-empty sub-array
-    of nums.
-    Example
-    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
-    minSubArraySum([-1, -2, -3]) == -6
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def max_fill(grid, capacity):
-    import math
-    """"""
-    You are given a rectangular grid of wells. Each row represents a single well,
-    and each 1 in a row represents a single unit of water.
-    Each well has a corresponding bucket that can be used to extract water from it, 
-    and all buckets have the same capacity.
-    Your task is to use the buckets to empty the wells.
-    Output the number of times you need to lower the buckets.
-
-    Example 1:
-        Input: 
-            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
-            bucket_capacity : 1
-        Output: 6
-
-    Example 2:
-        Input: 
-            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
-            bucket_capacity : 2
-        Output: 5
-    
-    Example 3:
-        Input: 
-            grid : [[0,0,0], [0,0,0]]
-            bucket_capacity : 5
-        Output: 0
-
-    Constraints:
-        * all wells have the same length
-        * 1 <= grid.length <= 10^2
-        * 1 <= grid[:,1].length <= 10^2
-        * grid[i][j] -> 0 | 1
-        * 1 <= capacity <= 10
-    """"""
-",0.0,0.0,0.0
-"
-def sort_array(arr):
-    """"""
-    In this Kata, you have to sort an array of non-negative integers according to
-    number of ones in their binary representation in ascending order.
-    For similar number of ones, sort based on decimal value.
-
-    It must be implemented like this:
-    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
-    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
-    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
-    """"""
-",0.85,1.0,1.0
-"
-def select_words(s, n):
-    """"""Given a string s and a natural number n, you have been tasked to implement 
-    a function that returns a list of all words from string s that contain exactly 
-    n consonants, in order these words appear in the string s.
-    If the string s is empty then the function should return an empty list.
-    Note: you may assume the input string contains only letters and spaces.
-    Examples:
-    select_words(""Mary had a little lamb"", 4) ==> [""little""]
-    select_words(""Mary had a little lamb"", 3) ==> [""Mary"", ""lamb""]
-    select_words(""simple white space"", 2) ==> []
-    select_words(""Hello world"", 4) ==> [""world""]
-    select_words(""Uncle sam"", 3) ==> [""Uncle""]
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def get_closest_vowel(word):
-    """"""You are given a word. Your task is to find the closest vowel that stands between 
-    two consonants from the right side of the word (case sensitive).
-    
-    Vowels in the beginning and ending doesn't count. Return empty string if you didn't
-    find any vowel met the above condition. 
-
-    You may assume that the given string contains English letter only.
-
-    Example:
-    get_closest_vowel(""yogurt"") ==> ""u""
-    get_closest_vowel(""FULL"") ==> ""U""
-    get_closest_vowel(""quick"") ==> """"
-    get_closest_vowel(""ab"") ==> """"
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def match_parens(lst):
-    '''
-    You are given a list of two strings, both strings consist of open
-    parentheses '(' or close parentheses ')' only.
-    Your job is to check if it is possible to concatenate the two strings in
-    some order, that the resulting string will be good.
-    A string S is considered to be good if and only if all parentheses in S
-    are balanced. For example: the string '(())()' is good, while the string
-    '())' is not.
-    Return 'Yes' if there's a way to make a good string, and return 'No' otherwise.
-
-    Examples:
-    match_parens(['()(', ')']) == 'Yes'
-    match_parens([')', ')']) == 'No'
-    '''
-",0.0,0.0,0.0
-"
-def maximum(arr, k):
-    """"""
-    Given an array arr of integers and a positive integer k, return a sorted list 
-    of length k with the maximum k numbers in arr.
-
-    Example 1:
-
-        Input: arr = [-3, -4, 5], k = 3
-        Output: [-4, -3, 5]
-
-    Example 2:
-
-        Input: arr = [4, -4, 4], k = 2
-        Output: [4, 4]
-
-    Example 3:
-
-        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
-        Output: [2]
-
-    Note:
-        1. The length of the array will be in the range of [1, 1000].
-        2. The elements in the array will be in the range of [-1000, 1000].
-        3. 0 <= k <= len(arr)
-    """"""
-",0.0,0.0,0.0
-"
-def solution(lst):
-    """"""Given a non-empty list of integers, return the sum of all of the odd elements that are in even positions.
-    
-
-    Examples
-    solution([5, 8, 7, 1]) ==> 12
-    solution([3, 3, 3, 3, 3]) ==> 9
-    solution([30, 13, 24, 321]) ==>0
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def add_elements(arr, k):
-    """"""
-    Given a non-empty array of integers arr and an integer k, return
-    the sum of the elements with at most two digits from the first k elements of arr.
-
-    Example:
-
-        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
-        Output: 24 # sum of 21 + 3
-
-    Constraints:
-        1. 1 <= len(arr) <= 100
-        2. 1 <= k <= len(arr)
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def get_odd_collatz(n):
-    """"""
-    Given a positive integer n, return a sorted list that has the odd numbers in collatz sequence.
-
-    The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined
-    as follows: start with any positive integer n. Then each term is obtained from the 
-    previous term as follows: if the previous term is even, the next term is one half of 
-    the previous term. If the previous term is odd, the next term is 3 times the previous
-    term plus 1. The conjecture is that no matter what value of n, the sequence will always reach 1.
-
-    Note: 
-        1. Collatz(1) is [1].
-        2. returned list sorted in increasing order.
-
-    For example:
-    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.
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def valid_date(date):
-    """"""You have to write a function which validates a given date string and
-    returns True if the date is valid otherwise False.
-    The date is valid if all of the following rules are satisfied:
-    1. The date string is not empty.
-    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.
-    3. The months should not be less than 1 or higher than 12.
-    4. The date should be in the format: mm-dd-yyyy
-
-    for example: 
-    valid_date('03-11-2000') => True
-
-    valid_date('15-01-2012') => False
-
-    valid_date('04-0-2040') => False
-
-    valid_date('06-04-2020') => True
-
-    valid_date('06/04/2020') => False
-    """"""
-",0.0,0.0,0.0
-"
-def split_words(txt):
-    '''
-    Given a string of words, return a list of words split on whitespace, if no whitespaces exists in the text you
-    should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
-    alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
-    Examples
-    split_words(""Hello world!"") ➞ [""Hello"", ""world!""]
-    split_words(""Hello,world!"") ➞ [""Hello"", ""world!""]
-    split_words(""abcdef"") == 3 
-    '''
-",0.0,0.0,0.0
-"
-def is_sorted(lst):
-    '''
-    Given a list of numbers, return whether or not they are sorted
-    in ascending order. If list has more than 1 duplicate of the same
-    number, return False. Assume no negative numbers and only integers.
-
-    Examples
-    is_sorted([5]) ➞ True
-    is_sorted([1, 2, 3, 4, 5]) ➞ True
-    is_sorted([1, 3, 2, 4, 5]) ➞ False
-    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
-    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
-    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
-    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
-    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
-    '''
-",0.0,0.0,0.0
-"
-def intersection(interval1, interval2):
-    """"""You are given two intervals,
-    where each interval is a pair of integers. For example, interval = (start, end) = (1, 2).
-    The given intervals are closed which means that the interval (start, end)
-    includes both start and end.
-    For each given interval, it is assumed that its start is less or equal its end.
-    Your task is to determine whether the length of intersection of these two 
-    intervals is a prime number.
-    Example, the intersection of the intervals (1, 3), (2, 4) is (2, 3)
-    which its length is 1, which not a prime number.
-    If the length of the intersection is a prime number, return ""YES"",
-    otherwise, return ""NO"".
-    If the two intervals don't intersect, return ""NO"".
-
-
-    [input/output] samples:
-    intersection((1, 2), (2, 3)) ==> ""NO""
-    intersection((-1, 1), (0, 4)) ==> ""NO""
-    intersection((-3, -1), (-5, 5)) ==> ""YES""
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-def prod_signs(arr):
-    """"""
-    You are given an array arr of integers and you need to return
-    sum of magnitudes of integers multiplied by product of all signs
-    of each number in the array, represented by 1, -1 or 0.
-    Note: return None for empty arr.
-
-    Example:
-    >>> prod_signs([1, 2, 2, -4]) == -9
-    >>> prod_signs([0, 1]) == 0
-    >>> prod_signs([]) == None
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def minPath(grid, k):
-    """"""
-    Given a grid with N rows and N columns (N >= 2) and a positive integer k, 
-    each cell of the grid contains a value. Every integer in the range [1, N * N]
-    inclusive appears exactly once on the cells of the grid.
-
-    You have to find the minimum path of length k in the grid. You can start
-    from any cell, and in each step you can move to any of the neighbor cells,
-    in other words, you can go to cells which share an edge with you current
-    cell.
-    Please note that a path of length k means visiting exactly k cells (not
-    necessarily distinct).
-    You CANNOT go off the grid.
-    A path A (of length k) is considered less than a path B (of length k) if
-    after making the ordered lists of the values on the cells that A and B go
-    through (let's call them lst_A and lst_B), lst_A is lexicographically less
-    than lst_B, in other words, there exist an integer index i (1 <= i <= k)
-    such that lst_A[i] < lst_B[i] and for any j (1 <= j < i) we have
-    lst_A[j] = lst_B[j].
-    It is guaranteed that the answer is unique.
-    Return an ordered list of the values on the cells that the minimum path go through.
-
-    Examples:
-
-        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
-        Output: [1, 2, 1]
-
-        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
-        Output: [1]
-    """"""
-",0.0,0.0,0.0
-"
-def tri(n):
-    """"""Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in 
-    the last couple centuries. However, what people don't know is Tribonacci sequence.
-    Tribonacci sequence is defined by the recurrence:
-    tri(1) = 3
-    tri(n) = 1 + n / 2, if n is even.
-    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
-    For example:
-    tri(2) = 1 + (2 / 2) = 2
-    tri(4) = 3
-    tri(3) = tri(2) + tri(1) + tri(4)
-           = 2 + 3 + 3 = 8 
-    You are given a non-negative integer number n, you have to a return a list of the 
-    first n + 1 numbers of the Tribonacci sequence.
-    Examples:
-    tri(3) = [1, 3, 2, 8]
-    """"""
-",0.0,0.0,0.0
-"
-def digits(n):
-    """"""Given a positive integer n, return the product of the odd digits.
-    Return 0 if all digits are even.
-    For example:
-    digits(1)  == 1
-    digits(4)  == 0
-    digits(235) == 15
-    """"""
-",0.0,0.0,0.0
-"
-def is_nested(string):
-    '''
-    Create a function that takes a string as input which contains only square brackets.
-    The function should return True if and only if there is a valid subsequence of brackets 
-    where at least one bracket in the subsequence is nested.
-
-    is_nested('[[]]') ➞ True
-    is_nested('[]]]]]]][[[[[]') ➞ False
-    is_nested('[][]') ➞ False
-    is_nested('[]') ➞ False
-    is_nested('[[][]]') ➞ True
-    is_nested('[[]][[') ➞ True
-    '''
-",0.0,0.0,0.0
-"
-
-def sum_squares(lst):
-    """"""You are given a list of numbers.
-    You need to return the sum of squared numbers in the given list,
-    round each element in the list to the upper int(Ceiling) first.
-    Examples:
-    For lst = [1,2,3] the output should be 14
-    For lst = [1,4,9] the output should be 98
-    For lst = [1,3,5,7] the output should be 84
-    For lst = [1.4,4.2,0] the output should be 29
-    For lst = [-2.4,1,1] the output should be 6
-    
-
-    """"""
-",0.0,0.0,0.0
-"
-def check_if_last_char_is_a_letter(txt):
-    '''
-    Create a function that returns True if the last character
-    of a given string is an alphabetical character and is not
-    a part of a word, and False otherwise.
-    Note: ""word"" is a group of characters separated by space.
-
-    Examples:
-    check_if_last_char_is_a_letter(""apple pie"") ➞ False
-    check_if_last_char_is_a_letter(""apple pi e"") ➞ True
-    check_if_last_char_is_a_letter(""apple pi e "") ➞ False
-    check_if_last_char_is_a_letter("""") ➞ False 
-    '''
-",0.0,0.0,0.0
-"
-def can_arrange(arr):
-    """"""Create a function which returns the largest index of an element which
-    is not greater than or equal to the element immediately preceding it. If
-    no such element exists then return -1. The given array will not contain
-    duplicate values.
-
-    Examples:
-    can_arrange([1,2,4,3,5]) = 3
-    can_arrange([1,2,3]) = -1
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def largest_smallest_integers(lst):
-    '''
-    Create a function that returns a tuple (a, b), where 'a' is
-    the largest of negative integers, and 'b' is the smallest
-    of positive integers in a list.
-    If there is no negative or positive integers, return them as None.
-
-    Examples:
-    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
-    largest_smallest_integers([]) == (None, None)
-    largest_smallest_integers([0]) == (None, None)
-    '''
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-def compare_one(a, b):
-    """"""
-    Create a function that takes integers, floats, or strings representing
-    real numbers, and returns the larger variable in its given variable type.
-    Return None if the values are equal.
-    Note: If a real number is represented as a string, the floating point might be . or ,
-
-    compare_one(1, 2.5) ➞ 2.5
-    compare_one(1, ""2,3"") ➞ ""2,3""
-    compare_one(""5,1"", ""6"") ➞ ""6""
-    compare_one(""1"", 1) ➞ None
-    """"""
-",0.0,0.0,0.0
-"
-def is_equal_to_sum_even(n):
-    """"""Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
-    Example
-    is_equal_to_sum_even(4) == False
-    is_equal_to_sum_even(6) == False
-    is_equal_to_sum_even(8) == True
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def special_factorial(n):
-    """"""The Brazilian factorial is defined as:
-    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
-    where n > 0
-
-    For example:
-    >>> special_factorial(4)
-    288
-
-    The function will receive an integer as input and should return the special
-    factorial of this integer.
-    """"""
-",0.0,0.0,0.0
-"
-def fix_spaces(text):
-    """"""
-    Given a string text, replace all spaces in it with underscores, 
-    and if a string has more than 2 consecutive spaces, 
-    then replace all consecutive spaces with - 
-    
-    fix_spaces(""Example"") == ""Example""
-    fix_spaces(""Example 1"") == ""Example_1""
-    fix_spaces("" Example 2"") == ""_Example_2""
-    fix_spaces("" Example   3"") == ""_Example-3""
-    """"""
-",0.0,0.0,0.0
-"
-def file_name_check(file_name):
-    """"""Create a function which takes a string representing a file's name, and returns
-    'Yes' if the the file's name is valid, and returns 'No' otherwise.
-    A file's name is considered to be valid if and only if all the following conditions 
-    are met:
-    - There should not be more than three digits ('0'-'9') in the file's name.
-    - The file's name contains exactly one dot '.'
-    - The substring before the dot should not be empty, and it starts with a letter from 
-    the latin alphapet ('a'-'z' and 'A'-'Z').
-    - The substring after the dot should be one of these: ['txt', 'exe', 'dll']
-    Examples:
-    file_name_check(""example.txt"") # => 'Yes'
-    file_name_check(""1example.dll"") # => 'No' (the name should start with a latin alphapet letter)
-    """"""
-",0.0,0.0,0.0
-"
-
-
-def sum_squares(lst):
-    """"""""
-    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 
-    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 
-    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. 
-    
-    Examples:
-    For lst = [1,2,3] the output should be 6
-    For lst = []  the output should be 0
-    For lst = [-1,-5,2,-1,-5]  the output should be -126
-    """"""
-",0.0,0.0,0.0
-"
-def words_in_sentence(sentence):
-    """"""
-    You are given a string representing a sentence,
-    the sentence contains some words separated by a space,
-    and you have to return a string that contains the words from the original sentence,
-    whose lengths are prime numbers,
-    the order of the words in the new string should be the same as the original one.
-
-    Example 1:
-        Input: sentence = ""This is a test""
-        Output: ""is""
-
-    Example 2:
-        Input: sentence = ""lets go for swimming""
-        Output: ""go for""
-
-    Constraints:
-        * 1 <= len(sentence) <= 100
-        * sentence contains only letters
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-def simplify(x, n):
-    """"""Your task is to implement a function that will simplify the expression
-    x * n. The function returns True if x * n evaluates to a whole number and False
-    otherwise. Both x and n, are string representation of a fraction, and have the following format,
-    <numerator>/<denominator> where both numerator and denominator are positive whole numbers.
-
-    You can assume that x, and n are valid fractions, and do not have zero as denominator.
-
-    simplify(""1/5"", ""5/1"") = True
-    simplify(""1/6"", ""2/1"") = False
-    simplify(""7/10"", ""10/2"") = False
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def order_by_points(nums):
-    """"""
-    Write a function which sorts the given list of integers
-    in ascending order according to the sum of their digits.
-    Note: if there are several items with similar sum of their digits,
-    order them based on their index in original list.
-
-    For example:
-    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
-    >>> order_by_points([]) == []
-    """"""
-",0.0,0.0,0.0
-"
-def specialFilter(nums):
-    """"""Write a function that takes an array of numbers as input and returns 
-    the number of elements in the array that are greater than 10 and both 
-    first and last digits of a number are odd (1, 3, 5, 7, 9).
-    For example:
-    specialFilter([15, -73, 14, -15]) => 1 
-    specialFilter([33, -2, -3, 45, 21, 109]) => 2
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def get_max_triples(n):
-    """"""
-    You are given a positive integer n. You have to create an integer array a of length n.
-        For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
-        Return the number of triples (a[i], a[j], a[k]) of a where i < j < k, 
-    and a[i] + a[j] + a[k] is a multiple of 3.
-
-    Example :
-        Input: n = 5
-        Output: 1
-        Explanation: 
-        a = [1, 3, 7, 13, 21]
-        The only valid triple is (1, 7, 13).
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def bf(planet1, planet2):
-    '''
-    There are eight planets in our solar system: the closerst to the Sun 
-    is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn, 
-    Uranus, Neptune.
-    Write a function that takes two planet names as strings planet1 and planet2. 
-    The function should return a tuple containing all planets whose orbits are 
-    located between the orbit of planet1 and the orbit of planet2, sorted by 
-    the proximity to the sun. 
-    The function should return an empty tuple if planet1 or planet2
-    are not correct planet names. 
-    Examples
-    bf(""Jupiter"", ""Neptune"") ==> (""Saturn"", ""Uranus"")
-    bf(""Earth"", ""Mercury"") ==> (""Venus"")
-    bf(""Mercury"", ""Uranus"") ==> (""Venus"", ""Earth"", ""Mars"", ""Jupiter"", ""Saturn"")
-    '''
-",0.85,1.0,1.0
-"
-def sorted_list_sum(lst):
-    """"""Write a function that accepts a list of strings as a parameter,
-    deletes the strings that have odd lengths from it,
-    and returns the resulted list with a sorted order,
-    The list is always a list of strings and never an array of numbers,
-    and it may contain duplicates.
-    The order of the list should be ascending by length of each word, and you
-    should return the list sorted by that rule.
-    If two words have the same length, sort the list alphabetically.
-    The function should return a list of strings in sorted order.
-    You may assume that all words will have the same length.
-    For example:
-    assert list_sort([""aa"", ""a"", ""aaa""]) => [""aa""]
-    assert list_sort([""ab"", ""a"", ""aaa"", ""cd""]) => [""ab"", ""cd""]
-    """"""
-",0.0,0.0,0.0
-"
-def x_or_y(n, x, y):
-    """"""A simple program which should return the value of x if n is 
-    a prime number and should return the value of y otherwise.
-
-    Examples:
-    for x_or_y(7, 34, 12) == 34
-    for x_or_y(15, 8, 5) == 5
-    
-    """"""
-",0.0,0.0,0.0
-"
-def double_the_difference(lst):
-    '''
-    Given a list of numbers, return the sum of squares of the numbers
-    in the list that are odd. Ignore numbers that are negative or not integers.
-    
-    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
-    double_the_difference([-1, -2, 0]) == 0
-    double_the_difference([9, -2]) == 81
-    double_the_difference([0]) == 0  
-   
-    If the input list is empty, return 0.
-    '''
-",0.4,0.9489164086687306,0.9996427720885925
-"
-def compare(game,guess):
-    """"""I think we all remember that feeling when the result of some long-awaited
-    event is finally known. The feelings and thoughts you have at that moment are
-    definitely worth noting down and comparing.
-    Your task is to determine if a person correctly guessed the results of a number of matches.
-    You are given two arrays of scores and guesses of equal length, where each index shows a match. 
-    Return an array of the same length denoting how far off each guess was. If they have guessed correctly,
-    the value is 0, and if not, the value is the absolute difference between the guess and the score.
-    
-    
-    example:
-
-    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
-    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
-    """"""
-",0.85,1.0,1.0
-"
-def Strongest_Extension(class_name, extensions):
-    """"""You will be given the name of a class (a string) and a list of extensions.
-    The extensions are to be used to load additional classes to the class. The
-    strength of the extension is as follows: Let CAP be the number of the uppercase
-    letters in the extension's name, and let SM be the number of lowercase letters 
-    in the extension's name, the strength is given by the fraction CAP - SM. 
-    You should find the strongest extension and return a string in this 
-    format: ClassName.StrongestExtensionName.
-    If there are two or more extensions with the same strength, you should
-    choose the one that comes first in the list.
-    For example, if you are given ""Slices"" as the class and a list of the
-    extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] then you should
-    return 'Slices.SErviNGSliCes' since 'SErviNGSliCes' is the strongest extension 
-    (its strength is -1).
-    Example:
-    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def cycpattern_check(a , b):
-    """"""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
-    cycpattern_check(""abcd"",""abd"") => False
-    cycpattern_check(""hello"",""ell"") => True
-    cycpattern_check(""whassup"",""psus"") => False
-    cycpattern_check(""abab"",""baa"") => True
-    cycpattern_check(""efef"",""eeff"") => False
-    cycpattern_check(""himenss"",""simen"") => True
-
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def even_odd_count(num):
-    """"""Given an integer. return a tuple that has the number of even and odd digits respectively.
-
-     Example:
-        even_odd_count(-12) ==> (1, 1)
-        even_odd_count(123) ==> (1, 2)
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-def int_to_mini_roman(number):
-    """"""
-    Given a positive integer, obtain its roman numeral equivalent as a string,
-    and return it in lowercase.
-    Restrictions: 1 <= num <= 1000
-
-    Examples:
-    >>> int_to_mini_roman(19) == 'xix'
-    >>> int_to_mini_roman(152) == 'clii'
-    >>> int_to_mini_roman(426) == 'cdxxvi'
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"
-def right_angle_triangle(a, b, c):
-    '''
-    Given the lengths of the three sides of a triangle. Return True if the three
-    sides form a right-angled triangle, False otherwise.
-    A right-angled triangle is a triangle in which one angle is right angle or 
-    90 degree.
-    Example:
-    right_angle_triangle(3, 4, 5) == True
-    right_angle_triangle(1, 2, 3) == False
-    '''
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def find_max(words):
-    """"""Write a function that accepts a list of strings.
-    The list contains different words. Return the word with maximum number
-    of unique characters. If multiple strings have maximum number of unique
-    characters, return the one which comes first in lexicographical order.
-
-    find_max([""name"", ""of"", ""string""]) == ""string""
-    find_max([""name"", ""enam"", ""game""]) == ""enam""
-    find_max([""aaaaaaa"", ""bb"" ,""cc""]) == """"aaaaaaa""
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-def eat(number, need, remaining):
-    """"""
-    You're a hungry rabbit, and you already have eaten a certain number of carrots,
-    but now you need to eat more carrots to complete the day's meals.
-    you should return an array of [ total number of eaten carrots after your meals,
-                                    the number of carrots left after your meals ]
-    if there are not enough remaining carrots, you will eat all remaining carrots, but will still be hungry.
-    
-    Example:
-    * eat(5, 6, 10) -> [11, 4]
-    * eat(4, 8, 9) -> [12, 1]
-    * eat(1, 10, 10) -> [11, 0]
-    * eat(2, 11, 5) -> [7, 0]
-    
-    Variables:
-    @number : integer
-        the number of carrots that you have eaten.
-    @need : integer
-        the number of carrots that you need to eat.
-    @remaining : integer
-        the number of remaining carrots thet exist in stock
-    
-    Constrain:
-    * 0 <= number <= 1000
-    * 0 <= need <= 1000
-    * 0 <= remaining <= 1000
-
-    Have fun :)
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def do_algebra(operator, operand):
-    """"""
-    Given two lists operator, and operand. The first list has basic algebra operations, and 
-    the second list is a list of integers. Use the two given lists to build the algebric 
-    expression and return the evaluation of this expression.
-
-    The basic algebra operations:
-    Addition ( + ) 
-    Subtraction ( - ) 
-    Multiplication ( * ) 
-    Floor division ( // ) 
-    Exponentiation ( ** ) 
-
-    Example:
-    operator['+', '*', '-']
-    array = [2, 3, 4, 5]
-    result = 2 + 3 * 4 - 5
-    => result = 9
-
-    Note:
-        The length of operator list is equal to the length of operand list minus one.
-        Operand is a list of of non-negative integers.
-        Operator list has at least one operator, and operand list has at least two operands.
-
-    """"""
-",0.0,0.0,0.0
-"
-def solve(s):
-    """"""You are given a string s.
-    if s[i] is a letter, reverse its case from lower to upper or vise versa, 
-    otherwise keep it as it is.
-    If the string contains no letters, reverse the string.
-    The function should return the resulted string.
-    Examples
-    solve(""1234"") = ""4321""
-    solve(""ab"") = ""AB""
-    solve(""#a@C"") = ""#A@c""
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-def string_to_md5(text):
-    """"""
-    Given a string 'text', return its md5 hash equivalent string.
-    If 'text' is an empty string, return None.
-
-    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def generate_integers(a, b):
-    """"""
-    Given two positive integers a and b, return the even digits between a
-    and b, in ascending order.
-
-    For example:
-    generate_integers(2, 8) => [2, 4, 6, 8]
-    generate_integers(8, 2) => [2, 4, 6, 8]
-    generate_integers(10, 14) => []
-    """"""
-",0.0,0.0,0.0

demo/data/coding/humaneval/csv/5.csv

@@ -1,2413 +0,0 @@
-prompt,pass@1,pass@5,pass@10
-"from typing import List
-
-
-def has_close_elements(numbers: List[float], threshold: float) -> bool:
-    """""" Check if in given list of numbers, are any two numbers closer to each other than
-    given threshold.
-    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
-    False
-    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
-    True
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"from typing import List
-
-
-def separate_paren_groups(paren_string: str) -> List[str]:
-    """""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
-    separate those group into separate strings and return the list of those.
-    Separate groups are balanced (each open brace is properly closed) and not nested within each other
-    Ignore any spaces in the input string.
-    >>> separate_paren_groups('( ) (( )) (( )( ))')
-    ['()', '(())', '(()())']
-    """"""
-",0.0,0.0,0.0
-"
-
-def truncate_number(number: float) -> float:
-    """""" Given a positive floating point number, it can be decomposed into
-    and integer part (largest integer smaller than given number) and decimals
-    (leftover part always smaller than 1).
-
-    Return the decimal part of the number.
-    >>> truncate_number(3.5)
-    0.5
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"from typing import List
-
-
-def below_zero(operations: List[int]) -> bool:
-    """""" You're given a list of deposit and withdrawal operations on a bank account that starts with
-    zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
-    at that point function should return True. Otherwise it should return False.
-    >>> below_zero([1, 2, 3])
-    False
-    >>> below_zero([1, 2, -4, 5])
-    True
-    """"""
-",1.0,1.0,1.0
-"from typing import List
-
-
-def mean_absolute_deviation(numbers: List[float]) -> float:
-    """""" For a given list of input numbers, calculate Mean Absolute Deviation
-    around the mean of this dataset.
-    Mean Absolute Deviation is the average absolute difference between each
-    element and a centerpoint (mean in this case):
-    MAD = average | x - x_mean |
-    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
-    1.0
-    """"""
-",1.0,1.0,1.0
-"from typing import List
-
-
-def intersperse(numbers: List[int], delimeter: int) -> List[int]:
-    """""" Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
-    >>> intersperse([], 4)
-    []
-    >>> intersperse([1, 2, 3], 4)
-    [1, 4, 2, 4, 3]
-    """"""
-",0.0,0.0,0.0
-"from typing import List
-
-
-def parse_nested_parens(paren_string: str) -> List[int]:
-    """""" Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
-    For each of the group, output the deepest level of nesting of parentheses.
-    E.g. (()()) has maximum two levels of nesting while ((())) has three.
-
-    >>> parse_nested_parens('(()()) ((())) () ((())()())')
-    [2, 3, 1, 3]
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"from typing import List
-
-
-def filter_by_substring(strings: List[str], substring: str) -> List[str]:
-    """""" Filter an input list of strings only for ones that contain given substring
-    >>> filter_by_substring([], 'a')
-    []
-    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
-    ['abc', 'bacd', 'array']
-    """"""
-",0.95,1.0,1.0
-"from typing import List, Tuple
-
-
-def sum_product(numbers: List[int]) -> Tuple[int, int]:
-    """""" For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.
-    Empty sum should be equal to 0 and empty product should be equal to 1.
-    >>> sum_product([])
-    (0, 1)
-    >>> sum_product([1, 2, 3, 4])
-    (10, 24)
-    """"""
-",1.0,1.0,1.0
-"from typing import List, Tuple
-
-
-def rolling_max(numbers: List[int]) -> List[int]:
-    """""" From a given list of integers, generate a list of rolling maximum element found until given moment
-    in the sequence.
-    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
-    [1, 2, 3, 3, 3, 4, 4]
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-
-def is_palindrome(string: str) -> bool:
-    """""" Test if given string is a palindrome """"""
-    return string == string[::-1]
-
-
-def make_palindrome(string: str) -> str:
-    """""" Find the shortest palindrome that begins with a supplied string.
-    Algorithm idea is simple:
-    - Find the longest postfix of supplied string that is a palindrome.
-    - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
-    >>> make_palindrome('')
-    ''
-    >>> make_palindrome('cat')
-    'catac'
-    >>> make_palindrome('cata')
-    'catac'
-    """"""
-",0.0,0.0,0.0
-"from typing import List
-
-
-def string_xor(a: str, b: str) -> str:
-    """""" Input are two strings a and b consisting only of 1s and 0s.
-    Perform binary XOR on these inputs and return result also as a string.
-    >>> string_xor('010', '110')
-    '100'
-    """"""
-",0.7,0.9996130030959752,1.0
-"from typing import List, Optional
-
-
-def longest(strings: List[str]) -> Optional[str]:
-    """""" Out of list of strings, return the longest one. Return the first one in case of multiple
-    strings of the same length. Return None in case the input list is empty.
-    >>> longest([])
-
-    >>> longest(['a', 'b', 'c'])
-    'a'
-    >>> longest(['a', 'bb', 'ccc'])
-    'ccc'
-    """"""
-",1.0,1.0,1.0
-"
-
-def greatest_common_divisor(a: int, b: int) -> int:
-    """""" Return a greatest common divisor of two integers a and b
-    >>> greatest_common_divisor(3, 5)
-    1
-    >>> greatest_common_divisor(25, 15)
-    5
-    """"""
-",0.65,0.9986455108359134,1.0
-"from typing import List
-
-
-def all_prefixes(string: str) -> List[str]:
-    """""" Return list of all prefixes from shortest to longest of the input string
-    >>> all_prefixes('abc')
-    ['a', 'ab', 'abc']
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-
-def string_sequence(n: int) -> str:
-    """""" Return a string containing space-delimited numbers starting from 0 upto n inclusive.
-    >>> string_sequence(0)
-    '0'
-    >>> string_sequence(5)
-    '0 1 2 3 4 5'
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-
-def count_distinct_characters(string: str) -> int:
-    """""" Given a string, find out how many distinct characters (regardless of case) does it consist of
-    >>> count_distinct_characters('xyzXYZ')
-    3
-    >>> count_distinct_characters('Jerry')
-    4
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"from typing import List
-
-
-def parse_music(music_string: str) -> List[int]:
-    """""" Input to this function is a string representing musical notes in a special ASCII format.
-    Your task is to parse this string and return list of integers corresponding to how many beats does each
-    not last.
-
-    Here is a legend:
-    'o' - whole note, lasts four beats
-    'o|' - half note, lasts two beats
-    '.|' - quater note, lasts one beat
-
-    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
-    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
-    """"""
-",0.85,1.0,1.0
-"
-
-def how_many_times(string: str, substring: str) -> int:
-    """""" Find how many times a given substring can be found in the original string. Count overlaping cases.
-    >>> how_many_times('', 'a')
-    0
-    >>> how_many_times('aaa', 'a')
-    3
-    >>> how_many_times('aaaa', 'aa')
-    3
-    """"""
-",0.7999999999999999,1.0,1.0
-"from typing import List
-
-
-def sort_numbers(numbers: str) -> str:
-    """""" Input is a space-delimited string of numberals from 'zero' to 'nine'.
-    Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
-    Return the string with numbers sorted from smallest to largest
-    >>> sort_numbers('three one five')
-    'one three five'
-    """"""
-",0.0,0.0,0.0
-"from typing import List, Tuple
-
-
-def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
-    """""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
-    other and return them in order (smaller number, larger number).
-    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
-    (2.0, 2.2)
-    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
-    (2.0, 2.0)
-    """"""
-",0.7,0.9996130030959752,1.0
-"from typing import List
-
-
-def rescale_to_unit(numbers: List[float]) -> List[float]:
-    """""" Given list of numbers (of at least two elements), apply a linear transform to that list,
-    such that the smallest number will become 0 and the largest will become 1
-    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
-    [0.0, 0.25, 0.5, 0.75, 1.0]
-    """"""
-",0.85,1.0,1.0
-"from typing import List, Any
-
-
-def filter_integers(values: List[Any]) -> List[int]:
-    """""" Filter given list of any python values only for integers
-    >>> filter_integers(['a', 3.14, 5])
-    [5]
-    >>> filter_integers([1, 2, 3, 'abc', {}, []])
-    [1, 2, 3]
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"
-
-def strlen(string: str) -> int:
-    """""" Return length of given string
-    >>> strlen('')
-    0
-    >>> strlen('abc')
-    3
-    """"""
-",0.85,1.0,1.0
-"
-
-def largest_divisor(n: int) -> int:
-    """""" For a given number n, find the largest number that divides n evenly, smaller than n
-    >>> largest_divisor(15)
-    5
-    """"""
-",0.050000000000000044,0.25,0.5
-"from typing import List
-
-
-def factorize(n: int) -> List[int]:
-    """""" Return list of prime factors of given integer in the order from smallest to largest.
-    Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
-    Input number should be equal to the product of all factors
-    >>> factorize(8)
-    [2, 2, 2]
-    >>> factorize(25)
-    [5, 5]
-    >>> factorize(70)
-    [2, 5, 7]
-    """"""
-",1.0,1.0,1.0
-"from typing import List
-
-
-def remove_duplicates(numbers: List[int]) -> List[int]:
-    """""" From a list of integers, remove all elements that occur more than once.
-    Keep order of elements left the same as in the input.
-    >>> remove_duplicates([1, 2, 3, 2, 4])
-    [1, 3, 4]
-    """"""
-",0.0,0.0,0.0
-"
-
-def flip_case(string: str) -> str:
-    """""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
-    >>> flip_case('Hello')
-    'hELLO'
-    """"""
-",1.0,1.0,1.0
-"from typing import List
-
-
-def concatenate(strings: List[str]) -> str:
-    """""" Concatenate list of strings into a single string
-    >>> concatenate([])
-    ''
-    >>> concatenate(['a', 'b', 'c'])
-    'abc'
-    """"""
-",0.7999999999999999,1.0,1.0
-"from typing import List
-
-
-def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
-    """""" Filter an input list of strings only for ones that start with a given prefix.
-    >>> filter_by_prefix([], 'a')
-    []
-    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
-    ['abc', 'array']
-    """"""
-",0.95,1.0,1.0
-"
-
-def get_positive(l: list):
-    """"""Return only positive numbers in the list.
-    >>> get_positive([-1, 2, -4, 5, 6])
-    [2, 5, 6]
-    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
-    [5, 3, 2, 3, 9, 123, 1]
-    """"""
-",0.7999999999999999,1.0,1.0
-"
-
-def is_prime(n):
-    """"""Return true if a given number is prime, and false otherwise.
-    >>> is_prime(6)
-    False
-    >>> is_prime(101)
-    True
-    >>> is_prime(11)
-    True
-    >>> is_prime(13441)
-    True
-    >>> is_prime(61)
-    True
-    >>> is_prime(4)
-    False
-    >>> is_prime(1)
-    False
-    """"""
-",0.8999999999999999,1.0,1.0
-"import math
-
-
-def poly(xs: list, x: float):
-    """"""
-    Evaluates polynomial with coefficients xs at point x.
-    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
-    """"""
-    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
-
-
-def find_zero(xs: list):
-    """""" xs are coefficients of a polynomial.
-    find_zero find x such that poly(x) = 0.
-    find_zero returns only only zero point, even if there are many.
-    Moreover, find_zero only takes list xs having even number of coefficients
-    and largest non zero coefficient as it guarantees
-    a solution.
-    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
-    -0.5
-    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
-    1.0
-    """"""
-",0.0,0.0,0.0
-"
-
-def sort_third(l: list):
-    """"""This function takes a list l and returns a list l' such that
-    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
-    to the values of the corresponding indicies of l, but sorted.
-    >>> sort_third([1, 2, 3])
-    [1, 2, 3]
-    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
-    [2, 6, 3, 4, 8, 9, 5]
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-
-def unique(l: list):
-    """"""Return sorted unique elements in a list
-    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
-    [0, 2, 3, 5, 9, 123]
-    """"""
-",0.85,1.0,1.0
-"
-
-def max_element(l: list):
-    """"""Return maximum element in the list.
-    >>> max_element([1, 2, 3])
-    3
-    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
-    123
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-
-def fizz_buzz(n: int):
-    """"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
-    >>> fizz_buzz(50)
-    0
-    >>> fizz_buzz(78)
-    2
-    >>> fizz_buzz(79)
-    3
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-
-def sort_even(l: list):
-    """"""This function takes a list l and returns a list l' such that
-    l' is identical to l in the odd indicies, while its values at the even indicies are equal
-    to the values of the even indicies of l, but sorted.
-    >>> sort_even([1, 2, 3])
-    [1, 2, 3]
-    >>> sort_even([5, 6, 3, 4])
-    [3, 6, 5, 4]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-
-def encode_cyclic(s: str):
-    """"""
-    returns encoded string by cycling groups of three characters.
-    """"""
-    # split string to groups. Each of length 3.
-    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
-    # cycle elements in each group. Unless group has fewer elements than 3.
-    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
-    return """".join(groups)
-
-
-def decode_cyclic(s: str):
-    """"""
-    takes as input string encoded with encode_cyclic function. Returns decoded string.
-    """"""
-",0.0,0.0,0.0
-"
-
-def prime_fib(n: int):
-    """"""
-    prime_fib returns n-th number that is a Fibonacci number and it's also prime.
-    >>> prime_fib(1)
-    2
-    >>> prime_fib(2)
-    3
-    >>> prime_fib(3)
-    5
-    >>> prime_fib(4)
-    13
-    >>> prime_fib(5)
-    89
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-
-def triples_sum_to_zero(l: list):
-    """"""
-    triples_sum_to_zero takes a list of integers as an input.
-    it returns True if there are three distinct elements in the list that
-    sum to zero, and False otherwise.
-
-    >>> triples_sum_to_zero([1, 3, 5, 0])
-    False
-    >>> triples_sum_to_zero([1, 3, -2, 1])
-    True
-    >>> triples_sum_to_zero([1, 2, 3, 7])
-    False
-    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
-    True
-    >>> triples_sum_to_zero([1])
-    False
-    """"""
-",0.75,0.9999355005159959,1.0
-"
-
-def car_race_collision(n: int):
-    """"""
-    Imagine a road that's a perfectly straight infinitely long line.
-    n cars are driving left to right;  simultaneously, a different set of n cars
-    are driving right to left.   The two sets of cars start out being very far from
-    each other.  All cars move in the same speed.  Two cars are said to collide
-    when a car that's moving left to right hits a car that's moving right to left.
-    However, the cars are infinitely sturdy and strong; as a result, they continue moving
-    in their trajectory as if they did not collide.
-
-    This function outputs the number of such collisions.
-    """"""
-",0.0,0.0,0.0
-"
-
-def incr_list(l: list):
-    """"""Return list with elements incremented by 1.
-    >>> incr_list([1, 2, 3])
-    [2, 3, 4]
-    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
-    [6, 4, 6, 3, 4, 4, 10, 1, 124]
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"
-
-def pairs_sum_to_zero(l):
-    """"""
-    pairs_sum_to_zero takes a list of integers as an input.
-    it returns True if there are two distinct elements in the list that
-    sum to zero, and False otherwise.
-    >>> pairs_sum_to_zero([1, 3, 5, 0])
-    False
-    >>> pairs_sum_to_zero([1, 3, -2, 1])
-    False
-    >>> pairs_sum_to_zero([1, 2, 3, 7])
-    False
-    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
-    True
-    >>> pairs_sum_to_zero([1])
-    False
-    """"""
-",0.95,1.0,1.0
-"
-
-def change_base(x: int, base: int):
-    """"""Change numerical base of input number x to base.
-    return string representation after the conversion.
-    base numbers are less than 10.
-    >>> change_base(8, 3)
-    '22'
-    >>> change_base(8, 2)
-    '1000'
-    >>> change_base(7, 2)
-    '111'
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-
-def triangle_area(a, h):
-    """"""Given length of a side and high return area for a triangle.
-    >>> triangle_area(5, 3)
-    7.5
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-
-def fib4(n: int):
-    """"""The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
-    fib4(0) -> 0
-    fib4(1) -> 0
-    fib4(2) -> 2
-    fib4(3) -> 0
-    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
-    Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
-    >>> fib4(5)
-    4
-    >>> fib4(6)
-    8
-    >>> fib4(7)
-    14
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-
-def median(l: list):
-    """"""Return median of elements in the list l.
-    >>> median([3, 1, 2, 4, 5])
-    3
-    >>> median([-10, 4, 6, 1000, 10, 20])
-    15.0
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-
-def is_palindrome(text: str):
-    """"""
-    Checks if given string is a palindrome
-    >>> is_palindrome('')
-    True
-    >>> is_palindrome('aba')
-    True
-    >>> is_palindrome('aaaaa')
-    True
-    >>> is_palindrome('zbcd')
-    False
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-
-def modp(n: int, p: int):
-    """"""Return 2^n modulo p (be aware of numerics).
-    >>> modp(3, 5)
-    3
-    >>> modp(1101, 101)
-    2
-    >>> modp(0, 101)
-    1
-    >>> modp(3, 11)
-    8
-    >>> modp(100, 101)
-    1
-    """"""
-",0.0,0.0,0.0
-"
-
-def encode_shift(s: str):
-    """"""
-    returns encoded string by shifting every character by 5 in the alphabet.
-    """"""
-    return """".join([chr(((ord(ch) + 5 - ord(""a"")) % 26) + ord(""a"")) for ch in s])
-
-
-def decode_shift(s: str):
-    """"""
-    takes as input string encoded with encode_shift function. Returns decoded string.
-    """"""
-",1.0,1.0,1.0
-"
-
-def remove_vowels(text):
-    """"""
-    remove_vowels is a function that takes string and returns string without vowels.
-    >>> remove_vowels('')
-    ''
-    >>> remove_vowels(""abcdef\nghijklm"")
-    'bcdf\nghjklm'
-    >>> remove_vowels('abcdef')
-    'bcdf'
-    >>> remove_vowels('aaaaa')
-    ''
-    >>> remove_vowels('aaBAA')
-    'B'
-    >>> remove_vowels('zbcd')
-    'zbcd'
-    """"""
-",0.7999999999999999,1.0,1.0
-"
-
-def below_threshold(l: list, t: int):
-    """"""Return True if all numbers in the list l are below threshold t.
-    >>> below_threshold([1, 2, 4, 10], 100)
-    True
-    >>> below_threshold([1, 20, 4, 10], 5)
-    False
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"
-
-def add(x: int, y: int):
-    """"""Add two numbers x and y
-    >>> add(2, 3)
-    5
-    >>> add(5, 7)
-    12
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-
-def same_chars(s0: str, s1: str):
-    """"""
-    Check if two words have the same characters.
-    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
-    True
-    >>> same_chars('abcd', 'dddddddabc')
-    True
-    >>> same_chars('dddddddabc', 'abcd')
-    True
-    >>> same_chars('eabcd', 'dddddddabc')
-    False
-    >>> same_chars('abcd', 'dddddddabce')
-    False
-    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
-    False
-    """"""
-",0.8999999999999999,1.0,1.0
-"
-
-def fib(n: int):
-    """"""Return n-th Fibonacci number.
-    >>> fib(10)
-    55
-    >>> fib(1)
-    1
-    >>> fib(8)
-    21
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-
-def correct_bracketing(brackets: str):
-    """""" brackets is a string of ""<"" and "">"".
-    return True if every opening bracket has a corresponding closing bracket.
-
-    >>> correct_bracketing(""<"")
-    False
-    >>> correct_bracketing(""<>"")
-    True
-    >>> correct_bracketing(""<<><>>"")
-    True
-    >>> correct_bracketing(""><<>"")
-    False
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-
-def monotonic(l: list):
-    """"""Return True is list elements are monotonically increasing or decreasing.
-    >>> monotonic([1, 2, 4, 20])
-    True
-    >>> monotonic([1, 20, 4, 10])
-    False
-    >>> monotonic([4, 1, 0, -10])
-    True
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-
-def common(l1: list, l2: list):
-    """"""Return sorted unique common elements for two lists.
-    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
-    [1, 5, 653]
-    >>> common([5, 3, 2, 8], [3, 2])
-    [2, 3]
-
-    """"""
-",0.95,1.0,1.0
-"
-
-def largest_prime_factor(n: int):
-    """"""Return the largest prime factor of n. Assume n > 1 and is not a prime.
-    >>> largest_prime_factor(13195)
-    29
-    >>> largest_prime_factor(2048)
-    2
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-
-def sum_to_n(n: int):
-    """"""sum_to_n is a function that sums numbers from 1 to n.
-    >>> sum_to_n(30)
-    465
-    >>> sum_to_n(100)
-    5050
-    >>> sum_to_n(5)
-    15
-    >>> sum_to_n(10)
-    55
-    >>> sum_to_n(1)
-    1
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-
-def correct_bracketing(brackets: str):
-    """""" brackets is a string of ""("" and "")"".
-    return True if every opening bracket has a corresponding closing bracket.
-
-    >>> correct_bracketing(""("")
-    False
-    >>> correct_bracketing(""()"")
-    True
-    >>> correct_bracketing(""(()())"")
-    True
-    >>> correct_bracketing("")(()"")
-    False
-    """"""
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-
-def derivative(xs: list):
-    """""" xs represent coefficients of a polynomial.
-    xs[0] + xs[1] * x + xs[2] * x^2 + ....
-     Return derivative of this polynomial in the same form.
-    >>> derivative([3, 1, 2, 4, 5])
-    [1, 4, 12, 20]
-    >>> derivative([1, 2, 3])
-    [2, 6]
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-
-def fibfib(n: int):
-    """"""The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
-    fibfib(0) == 0
-    fibfib(1) == 0
-    fibfib(2) == 1
-    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
-    Please write a function to efficiently compute the n-th element of the fibfib number sequence.
-    >>> fibfib(1)
-    0
-    >>> fibfib(5)
-    4
-    >>> fibfib(8)
-    24
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-FIX = """"""
-Add more test cases.
-""""""
-
-def vowels_count(s):
-    """"""Write a function vowels_count which takes a string representing
-    a word as input and returns the number of vowels in the string.
-    Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
-    vowel, but only when it is at the end of the given word.
-
-    Example:
-    >>> vowels_count(""abcde"")
-    2
-    >>> vowels_count(""ACEDY"")
-    3
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-def circular_shift(x, shift):
-    """"""Circular shift the digits of the integer x, shift the digits right by shift
-    and return the result as a string.
-    If shift > number of digits, return digits reversed.
-    >>> circular_shift(12, 1)
-    ""21""
-    >>> circular_shift(12, 2)
-    ""12""
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def digitSum(s):
-    """"""Task
-    Write a function that takes a string as input and returns the sum of the upper characters only'
-    ASCII codes.
-
-    Examples:
-        digitSum("""") => 0
-        digitSum(""abAB"") => 131
-        digitSum(""abcCd"") => 67
-        digitSum(""helloE"") => 69
-        digitSum(""woArBld"") => 131
-        digitSum(""aAaaaXa"") => 153
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-def fruit_distribution(s,n):
-    """"""
-    In this task, you will be given a string that represents a number of apples and oranges 
-    that are distributed in a basket of fruit this basket contains 
-    apples, oranges, and mango fruits. Given the string that represents the total number of 
-    the oranges and apples and an integer that represent the total number of the fruits 
-    in the basket return the number of the mango fruits in the basket.
-    for examble:
-    fruit_distribution(""5 apples and 6 oranges"", 19) ->19 - 5 - 6 = 8
-    fruit_distribution(""0 apples and 1 oranges"",3) -> 3 - 0 - 1 = 2
-    fruit_distribution(""2 apples and 3 oranges"", 100) -> 100 - 2 - 3 = 95
-    fruit_distribution(""100 apples and 1 oranges"",120) -> 120 - 100 - 1 = 19
-    """"""
-",0.0,0.0,0.0
-"
-def pluck(arr):
-    """"""
-    ""Given an array representing a branch of a tree that has non-negative integer nodes
-    your task is to pluck one of the nodes and return it.
-    The plucked node should be the node with the smallest even value.
-    If multiple nodes with the same smallest even value are found return the node that has smallest index.
-
-    The plucked node should be returned in a list, [ smalest_value, its index ],
-    If there are no even values or the given array is empty, return [].
-
-    Example 1:
-        Input: [4,2,3]
-        Output: [2, 1]
-        Explanation: 2 has the smallest even value, and 2 has the smallest index.
-
-    Example 2:
-        Input: [1,2,3]
-        Output: [2, 1]
-        Explanation: 2 has the smallest even value, and 2 has the smallest index. 
-
-    Example 3:
-        Input: []
-        Output: []
-    
-    Example 4:
-        Input: [5, 0, 3, 0, 4, 2]
-        Output: [0, 1]
-        Explanation: 0 is the smallest value, but  there are two zeros,
-                     so we will choose the first zero, which has the smallest index.
-
-    Constraints:
-        * 1 <= nodes.length <= 10000
-        * 0 <= node.value
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-def search(lst):
-    '''
-    You are given a non-empty list of positive integers. Return the greatest integer that is greater than 
-    zero, and has a frequency greater than or equal to the value of the integer itself. 
-    The frequency of an integer is the number of times it appears in the list.
-    If no such a value exist, return -1.
-    Examples:
-        search([4, 1, 2, 2, 3, 1]) == 2
-        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
-        search([5, 5, 4, 4, 4]) == -1
-    '''
-",0.0,0.0,0.0
-"
-def strange_sort_list(lst):
-    '''
-    Given list of integers, return list in strange order.
-    Strange sorting, is when you start with the minimum value,
-    then maximum of the remaining integers, then minimum and so on.
-
-    Examples:
-    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
-    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
-    strange_sort_list([]) == []
-    '''
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def triangle_area(a, b, c):
-    '''
-    Given the lengths of the three sides of a triangle. Return the area of
-    the triangle rounded to 2 decimal points if the three sides form a valid triangle. 
-    Otherwise return -1
-    Three sides make a valid triangle when the sum of any two sides is greater 
-    than the third side.
-    Example:
-    triangle_area(3, 4, 5) == 6.00
-    triangle_area(1, 2, 10) == -1
-    '''
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-def will_it_fly(q,w):
-    '''
-    Write a function that returns True if the object q will fly, and False otherwise.
-    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.
-
-    Example:
-    will_it_fly([1, 2], 5) ➞ False 
-    # 1+2 is less than the maximum possible weight, but it's unbalanced.
-
-    will_it_fly([3, 2, 3], 1) ➞ False
-    # it's balanced, but 3+2+3 is more than the maximum possible weight.
-
-    will_it_fly([3, 2, 3], 9) ➞ True
-    # 3+2+3 is less than the maximum possible weight, and it's balanced.
-
-    will_it_fly([3], 5) ➞ True
-    # 3 is less than the maximum possible weight, and it's balanced.
-    '''
-",0.7,0.9996130030959752,1.0
-"
-def smallest_change(arr):
-    """"""
-    Given an array arr of integers, find the minimum number of elements that
-    need to be changed to make the array palindromic. A palindromic array is an array that
-    is read the same backwards and forwards. In one change, you can change one element to any other element.
-
-    For example:
-    smallest_change([1,2,3,5,4,7,9,6]) == 4
-    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
-    smallest_change([1, 2, 3, 2, 1]) == 0
-    """"""
-",0.0,0.0,0.0
-"
-def total_match(lst1, lst2):
-    '''
-    Write a function that accepts two lists of strings and returns the list that has 
-    total number of chars in the all strings of the list less than the other list.
-
-    if the two lists have the same number of chars, return the first list.
-
-    Examples
-    total_match([], []) ➞ []
-    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
-    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
-    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
-    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
-    '''
-",0.0,0.0,0.0
-"
-def is_multiply_prime(a):
-    """"""Write a function that returns true if the given number is the multiplication of 3 prime numbers
-    and false otherwise.
-    Knowing that (a) is less then 100. 
-    Example:
-    is_multiply_prime(30) == True
-    30 = 2 * 3 * 5
-    """"""
-",0.0,0.0,0.0
-"
-def is_simple_power(x, n):
-    """"""Your task is to write a function that returns true if a number x is a simple
-    power of n and false in other cases.
-    x is a simple power of n if n**int=x
-    For example:
-    is_simple_power(1, 4) => true
-    is_simple_power(2, 2) => true
-    is_simple_power(8, 2) => true
-    is_simple_power(3, 2) => false
-    is_simple_power(3, 1) => false
-    is_simple_power(5, 3) => false
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def iscube(a):
-    '''
-    Write a function that takes an integer a and returns True 
-    if this ingeger is a cube of some integer number.
-    Note: you may assume the input is always valid.
-    Examples:
-    iscube(1) ==> True
-    iscube(2) ==> False
-    iscube(-1) ==> True
-    iscube(64) ==> True
-    iscube(0) ==> True
-    iscube(180) ==> False
-    '''
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def hex_key(num):
-    """"""You have been tasked to write a function that receives 
-    a hexadecimal number as a string and counts the number of hexadecimal 
-    digits that are primes (prime number, or a prime, is a natural number 
-    greater than 1 that is not a product of two smaller natural numbers).
-    Hexadecimal digits are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
-    Prime numbers are 2, 3, 5, 7, 11, 13, 17,...
-    So you have to determine a number of the following digits: 2, 3, 5, 7, 
-    B (=decimal 11), D (=decimal 13).
-    Note: you may assume the input is always correct or empty string, 
-    and symbols A,B,C,D,E,F are always uppercase.
-    Examples:
-    For num = ""AB"" the output should be 1.
-    For num = ""1077E"" the output should be 2.
-    For num = ""ABED1A33"" the output should be 4.
-    For num = ""123456789ABCDEF0"" the output should be 6.
-    For num = ""2020"" the output should be 2.
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-def decimal_to_binary(decimal):
-    """"""You will be given a number in decimal form and your task is to convert it to
-    binary format. The function should return a string, with each character representing a binary
-    number. Each character in the string will be '0' or '1'.
-
-    There will be an extra couple of characters 'db' at the beginning and at the end of the string.
-    The extra characters are there to help with the format.
-
-    Examples:
-    decimal_to_binary(15)   # returns ""db1111db""
-    decimal_to_binary(32)   # returns ""db100000db""
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-def is_happy(s):
-    """"""You are given a string s.
-    Your task is to check if the string is happy or not.
-    A string is happy if its length is at least 3 and every 3 consecutive letters are distinct
-    For example:
-    is_happy(a) => False
-    is_happy(aa) => False
-    is_happy(abcd) => True
-    is_happy(aabb) => False
-    is_happy(adb) => True
-    is_happy(xyy) => False
-    """"""
-",0.20000000000000007,0.7182662538699691,0.956656346749226
-"
-def numerical_letter_grade(grades):
-    """"""It is the last week of the semester and the teacher has to give the grades
-    to students. The teacher has been making her own algorithm for grading.
-    The only problem is, she has lost the code she used for grading.
-    She has given you a list of GPAs for some students and you have to write 
-    a function that can output a list of letter grades using the following table:
-             GPA       |    Letter grade
-              4.0                A+
-            > 3.7                A 
-            > 3.3                A- 
-            > 3.0                B+
-            > 2.7                B 
-            > 2.3                B-
-            > 2.0                C+
-            > 1.7                C
-            > 1.3                C-
-            > 1.0                D+ 
-            > 0.7                D 
-            > 0.0                D-
-              0.0                E
-    
-
-    Example:
-    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def prime_length(string):
-    """"""Write a function that takes a string and returns True if the string
-    length is a prime number or False otherwise
-    Examples
-    prime_length('Hello') == True
-    prime_length('abcdcba') == True
-    prime_length('kittens') == True
-    prime_length('orange') == False
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def starts_one_ends(n):
-    """"""
-    Given a positive integer n, return the count of the numbers of n-digit
-    positive integers that start or end with 1.
-    """"""
-",0.0,0.0,0.0
-"
-def solve(N):
-    """"""Given a positive integer N, return the total sum of its digits in binary.
-    
-    Example
-        For N = 1000, the sum of digits will be 1 the output should be ""1"".
-        For N = 150, the sum of digits will be 6 the output should be ""110"".
-        For N = 147, the sum of digits will be 12 the output should be ""1100"".
-    
-    Variables:
-        @N integer
-             Constraints: 0 ≤ N ≤ 10000.
-    Output:
-         a string of binary number
-    """"""
-",0.0,0.0,0.0
-"
-def add(lst):
-    """"""Given a non-empty list of integers lst. add the even elements that are at odd indices..
-
-
-    Examples:
-        add([4, 2, 6, 7]) ==> 2 
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-def anti_shuffle(s):
-    """"""
-    Write a function that takes a string and returns an ordered version of it.
-    Ordered version of string, is a string where all words (separated by space)
-    are replaced by a new word where all the characters arranged in
-    ascending order based on ascii value.
-    Note: You should keep the order of words and blank spaces in the sentence.
-
-    For example:
-    anti_shuffle('Hi') returns 'Hi'
-    anti_shuffle('hello') returns 'ehllo'
-    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-def get_row(lst, x):
-    """"""
-    You are given a 2 dimensional data, as a nested lists,
-    which is similar to matrix, however, unlike matrices,
-    each row may contain a different number of columns.
-    Given lst, and integer x, find integers x in the list,
-    and return list of tuples, [(x1, y1), (x2, y2) ...] such that
-    each tuple is a coordinate - (row, columns), starting with 0.
-    Sort coordinates initially by rows in ascending order.
-    Also, sort coordinates of the row by columns in descending order.
-    
-    Examples:
-    get_row([
-      [1,2,3,4,5,6],
-      [1,2,3,4,1,6],
-      [1,2,3,4,5,1]
-    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
-    get_row([], 1) == []
-    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
-    """"""
-",0.0,0.0,0.0
-"
-def sort_array(array):
-    """"""
-    Given an array of non-negative integers, return a copy of the given array after sorting,
-    you will sort the given array in ascending order if the sum( first index value, last index value) is odd,
-    or sort it in descending order if the sum( first index value, last index value) is even.
-
-    Note:
-    * don't change the given array.
-
-    Examples:
-    * sort_array([]) => []
-    * sort_array([5]) => [5]
-    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
-    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def encrypt(s):
-    """"""Create a function encrypt that takes a string as an argument and
-    returns a string encrypted with the alphabet being rotated. 
-    The alphabet should be rotated in a manner such that the letters 
-    shift down by two multiplied to two places.
-    For example:
-    encrypt('hi') returns 'lm'
-    encrypt('asdfghjkl') returns 'ewhjklnop'
-    encrypt('gf') returns 'kj'
-    encrypt('et') returns 'ix'
-    """"""
-",0.0,0.0,0.0
-"
-def next_smallest(lst):
-    """"""
-    You are given a list of integers.
-    Write a function next_smallest() that returns the 2nd smallest element of the list.
-    Return None if there is no such element.
-    
-    next_smallest([1, 2, 3, 4, 5]) == 2
-    next_smallest([5, 1, 4, 3, 2]) == 2
-    next_smallest([]) == None
-    next_smallest([1, 1]) == None
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def is_bored(S):
-    """"""
-    You'll be given a string of words, and your task is to count the number
-    of boredoms. A boredom is a sentence that starts with the word ""I"".
-    Sentences are delimited by '.', '?' or '!'.
-   
-    For example:
-    >>> is_bored(""Hello world"")
-    0
-    >>> is_bored(""The sky is blue. The sun is shining. I love this weather"")
-    1
-    """"""
-",0.0,0.0,0.0
-"
-def any_int(x, y, z):
-    '''
-    Create a function that takes 3 numbers.
-    Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
-    Returns false in any other cases.
-    
-    Examples
-    any_int(5, 2, 7) ➞ True
-    
-    any_int(3, 2, 2) ➞ False
-
-    any_int(3, -2, 1) ➞ True
-    
-    any_int(3.6, -2.2, 2) ➞ False
-  
-
-    
-    '''
-",0.6000000000000001,0.9963880288957688,1.0
-"
-def encode(message):
-    """"""
-    Write a function that takes a message, and encodes in such a 
-    way that it swaps case of all letters, replaces all vowels in 
-    the message with the letter that appears 2 places ahead of that 
-    vowel in the english alphabet. 
-    Assume only letters. 
-    
-    Examples:
-    >>> encode('test')
-    'TGST'
-    >>> encode('This is a message')
-    'tHKS KS C MGSSCGG'
-    """"""
-",0.0,0.0,0.0
-"
-
-def skjkasdkd(lst):
-    """"""You are given a list of integers.
-    You need to find the largest prime value and return the sum of its digits.
-
-    Examples:
-    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
-    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
-    For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13
-    For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11
-    For lst = [0,81,12,3,1,21] the output should be 3
-    For lst = [0,8,1,2,1,7] the output should be 7
-    """"""
-",0.4,0.9489164086687306,0.9996427720885925
-"
-def check_dict_case(dict):
-    """"""
-    Given a dictionary, return True if all keys are strings in lower 
-    case or all keys are strings in upper case, else return False.
-    The function should return False is the given dictionary is empty.
-    Examples:
-    check_dict_case({""a"":""apple"", ""b"":""banana""}) should return True.
-    check_dict_case({""a"":""apple"", ""A"":""banana"", ""B"":""banana""}) should return False.
-    check_dict_case({""a"":""apple"", 8:""banana"", ""a"":""apple""}) should return False.
-    check_dict_case({""Name"":""John"", ""Age"":""36"", ""City"":""Houston""}) should return False.
-    check_dict_case({""STATE"":""NC"", ""ZIP"":""12345"" }) should return True.
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def count_up_to(n):
-    """"""Implement a function that takes an non-negative integer and returns an array of the first n
-    integers that are prime numbers and less than n.
-    for example:
-    count_up_to(5) => [2,3]
-    count_up_to(11) => [2,3,5,7]
-    count_up_to(0) => []
-    count_up_to(20) => [2,3,5,7,11,13,17,19]
-    count_up_to(1) => []
-    count_up_to(18) => [2,3,5,7,11,13,17]
-    """"""
-",0.6000000000000001,0.9963880288957688,1.0
-"
-def multiply(a, b):
-    """"""Complete the function that takes two integers and returns 
-    the product of their unit digits.
-    Assume the input is always valid.
-    Examples:
-    multiply(148, 412) should return 16.
-    multiply(19, 28) should return 72.
-    multiply(2020, 1851) should return 0.
-    multiply(14,-15) should return 20.
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-def count_upper(s):
-    """"""
-    Given a string s, count the number of uppercase vowels in even indices.
-    
-    For example:
-    count_upper('aBCdEf') returns 1
-    count_upper('abcdefg') returns 0
-    count_upper('dBBE') returns 0
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def closest_integer(value):
-    '''
-    Create a function that takes a value (string) representing a number
-    and returns the closest integer to it. If the number is equidistant
-    from two integers, round it away from zero.
-
-    Examples
-    >>> closest_integer(""10"")
-    10
-    >>> closest_integer(""15.3"")
-    15
-
-    Note:
-    Rounding away from zero means that if the given number is equidistant
-    from two integers, the one you should return is the one that is the
-    farthest from zero. For example closest_integer(""14.5"") should
-    return 15 and closest_integer(""-14.5"") should return -15.
-    '''
-",0.050000000000000044,0.25,0.5
-"
-def make_a_pile(n):
-    """"""
-    Given a positive integer n, you have to make a pile of n levels of stones.
-    The first level has n stones.
-    The number of stones in the next level is:
-        - the next odd number if n is odd.
-        - the next even number if n is even.
-    Return the number of stones in each level in a list, where element at index
-    i represents the number of stones in the level (i+1).
-
-    Examples:
-    >>> make_a_pile(3)
-    [3, 5, 7]
-    """"""
-",0.0,0.0,0.0
-"
-def words_string(s):
-    """"""
-    You will be given a string of words separated by commas or spaces. Your task is
-    to split the string into words and return an array of the words.
-    
-    For example:
-    words_string(""Hi, my name is John"") == [""Hi"", ""my"", ""name"", ""is"", ""John""]
-    words_string(""One, two, three, four, five, six"") == [""One"", ""two"", ""three"", ""four"", ""five"", ""six""]
-    """"""
-",0.0,0.0,0.0
-"
-def choose_num(x, y):
-    """"""This function takes two positive numbers x and y and returns the
-    biggest even integer number that is in the range [x, y] inclusive. If 
-    there's no such number, then the function should return -1.
-
-    For example:
-    choose_num(12, 15) = 14
-    choose_num(13, 12) = -1
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def rounded_avg(n, m):
-    """"""You are given two positive integers n and m, and your task is to compute the
-    average of the integers from n through m (including n and m). 
-    Round the answer to the nearest integer and convert that to binary.
-    If n is greater than m, return -1.
-    Example:
-    rounded_avg(1, 5) => ""0b11""
-    rounded_avg(7, 5) => -1
-    rounded_avg(10, 20) => ""0b1111""
-    rounded_avg(20, 33) => ""0b11010""
-    """"""
-",0.0,0.0,0.0
-"
-def unique_digits(x):
-    """"""Given a list of positive integers x. return a sorted list of all 
-    elements that hasn't any even digit.
-
-    Note: Returned list should be sorted in increasing order.
-    
-    For example:
-    >>> unique_digits([15, 33, 1422, 1])
-    [1, 15, 33]
-    >>> unique_digits([152, 323, 1422, 10])
-    []
-    """"""
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-def by_length(arr):
-    """"""
-    Given an array of integers, sort the integers that are between 1 and 9 inclusive,
-    reverse the resulting array, and then replace each digit by its corresponding name from
-    ""One"", ""Two"", ""Three"", ""Four"", ""Five"", ""Six"", ""Seven"", ""Eight"", ""Nine"".
-
-    For example:
-      arr = [2, 1, 1, 4, 5, 8, 2, 3]   
-            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8] 
-            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
-      return [""Eight"", ""Five"", ""Four"", ""Three"", ""Two"", ""Two"", ""One"", ""One""]
-    
-      If the array is empty, return an empty array:
-      arr = []
-      return []
-    
-      If the array has any strange number ignore it:
-      arr = [1, -1 , 55] 
-            -> sort arr -> [-1, 1, 55]
-            -> reverse arr -> [55, 1, -1]
-      return = ['One']
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def f(n):
-    """""" Implement the function f that takes n as a parameter,
-    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
-    or the sum of numbers from 1 to i otherwise.
-    i starts from 1.
-    the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... * i).
-    Example:
-    f(5) == [1, 2, 6, 24, 15]
-    """"""
-",0.0,0.0,0.0
-"
-def even_odd_palindrome(n):
-    """"""
-    Given a positive integer n, return a tuple that has the number of even and odd
-    integer palindromes that fall within the range(1, n), inclusive.
-
-    Example 1:
-
-        Input: 3
-        Output: (1, 2)
-        Explanation:
-        Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.
-
-    Example 2:
-
-        Input: 12
-        Output: (4, 6)
-        Explanation:
-        Integer palindrome are 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. four of them are even, and 6 of them are odd.
-
-    Note:
-        1. 1 <= n <= 10^3
-        2. returned tuple has the number of even and odd integer palindromes respectively.
-    """"""
-",0.95,1.0,1.0
-"
-def count_nums(arr):
-    """"""
-    Write a function count_nums which takes an array of integers and returns
-    the number of elements which has a sum of digits > 0.
-    If a number is negative, then its first signed digit will be negative:
-    e.g. -123 has signed digits -1, 2, and 3.
-    >>> count_nums([]) == 0
-    >>> count_nums([-1, 11, -11]) == 1
-    >>> count_nums([1, 1, 2]) == 3
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def move_one_ball(arr):
-    """"""We have an array 'arr' of N integers arr[1], arr[2], ..., arr[N].The
-    numbers in the array will be randomly ordered. Your task is to determine if
-    it is possible to get an array sorted in non-decreasing order by performing 
-    the following operation on the given array:
-        You are allowed to perform right shift operation any number of times.
-    
-    One right shift operation means shifting all elements of the array by one
-    position in the right direction. The last element of the array will be moved to
-    the starting position in the array i.e. 0th index. 
-
-    If it is possible to obtain the sorted array by performing the above operation
-    then return True else return False.
-    If the given array is empty then return True.
-
-    Note: The given list is guaranteed to have unique elements.
-
-    For Example:
-    
-    move_one_ball([3, 4, 5, 1, 2])==>True
-    Explanation: By performin 2 right shift operations, non-decreasing order can
-                 be achieved for the given array.
-    move_one_ball([3, 5, 4, 1, 2])==>False
-    Explanation:It is not possible to get non-decreasing order for the given
-                array by performing any number of right shift operations.
-                
-    """"""
-",0.0,0.0,0.0
-"
-def exchange(lst1, lst2):
-    """"""In this problem, you will implement a function that takes two lists of numbers,
-    and determines whether it is possible to perform an exchange of elements
-    between them to make lst1 a list of only even numbers.
-    There is no limit on the number of exchanged elements between lst1 and lst2.
-    If it is possible to exchange elements between the lst1 and lst2 to make
-    all the elements of lst1 to be even, return ""YES"".
-    Otherwise, return ""NO"".
-    For example:
-    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => ""YES""
-    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => ""NO""
-    It is assumed that the input lists will be non-empty.
-    """"""
-",0.0,0.0,0.0
-"
-def histogram(test):
-    """"""Given a string representing a space separated lowercase letters, return a dictionary
-    of the letter with the most repetition and containing the corresponding count.
-    If several letters have the same occurrence, return all of them.
-    
-    Example:
-    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
-    histogram('a b b a') == {'a': 2, 'b': 2}
-    histogram('a b c a b') == {'a': 2, 'b': 2}
-    histogram('b b b b a') == {'b': 4}
-    histogram('') == {}
-
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def reverse_delete(s,c):
-    """"""Task
-    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
-    then check if the result string is palindrome.
-    A string is called palindrome if it reads the same backward as forward.
-    You should return a tuple containing the result string and True/False for the check.
-    Example
-    For s = ""abcde"", c = ""ae"", the result should be ('bcd',False)
-    For s = ""abcdef"", c = ""b""  the result should be ('acdef',False)
-    For s = ""abcdedcba"", c = ""ab"", the result should be ('cdedc',True)
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def odd_count(lst):
-    """"""Given a list of strings, where each string consists of only digits, return a list.
-    Each element i of the output should be ""the number of odd elements in the
-    string i of the input."" where all the i's should be replaced by the number
-    of odd digits in the i'th string of the input.
-
-    >>> odd_count(['1234567'])
-    [""the number of odd elements 4n the str4ng 4 of the 4nput.""]
-    >>> odd_count(['3',""11111111""])
-    [""the number of odd elements 1n the str1ng 1 of the 1nput."",
-     ""the number of odd elements 8n the str8ng 8 of the 8nput.""]
-    """"""
-",0.0,0.0,0.0
-"
-def minSubArraySum(nums):
-    """"""
-    Given an array of integers nums, find the minimum sum of any non-empty sub-array
-    of nums.
-    Example
-    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
-    minSubArraySum([-1, -2, -3]) == -6
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def max_fill(grid, capacity):
-    import math
-    """"""
-    You are given a rectangular grid of wells. Each row represents a single well,
-    and each 1 in a row represents a single unit of water.
-    Each well has a corresponding bucket that can be used to extract water from it, 
-    and all buckets have the same capacity.
-    Your task is to use the buckets to empty the wells.
-    Output the number of times you need to lower the buckets.
-
-    Example 1:
-        Input: 
-            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
-            bucket_capacity : 1
-        Output: 6
-
-    Example 2:
-        Input: 
-            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
-            bucket_capacity : 2
-        Output: 5
-    
-    Example 3:
-        Input: 
-            grid : [[0,0,0], [0,0,0]]
-            bucket_capacity : 5
-        Output: 0
-
-    Constraints:
-        * all wells have the same length
-        * 1 <= grid.length <= 10^2
-        * 1 <= grid[:,1].length <= 10^2
-        * grid[i][j] -> 0 | 1
-        * 1 <= capacity <= 10
-    """"""
-",0.0,0.0,0.0
-"
-def sort_array(arr):
-    """"""
-    In this Kata, you have to sort an array of non-negative integers according to
-    number of ones in their binary representation in ascending order.
-    For similar number of ones, sort based on decimal value.
-
-    It must be implemented like this:
-    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
-    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
-    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
-    """"""
-",0.85,1.0,1.0
-"
-def select_words(s, n):
-    """"""Given a string s and a natural number n, you have been tasked to implement 
-    a function that returns a list of all words from string s that contain exactly 
-    n consonants, in order these words appear in the string s.
-    If the string s is empty then the function should return an empty list.
-    Note: you may assume the input string contains only letters and spaces.
-    Examples:
-    select_words(""Mary had a little lamb"", 4) ==> [""little""]
-    select_words(""Mary had a little lamb"", 3) ==> [""Mary"", ""lamb""]
-    select_words(""simple white space"", 2) ==> []
-    select_words(""Hello world"", 4) ==> [""world""]
-    select_words(""Uncle sam"", 3) ==> [""Uncle""]
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def get_closest_vowel(word):
-    """"""You are given a word. Your task is to find the closest vowel that stands between 
-    two consonants from the right side of the word (case sensitive).
-    
-    Vowels in the beginning and ending doesn't count. Return empty string if you didn't
-    find any vowel met the above condition. 
-
-    You may assume that the given string contains English letter only.
-
-    Example:
-    get_closest_vowel(""yogurt"") ==> ""u""
-    get_closest_vowel(""FULL"") ==> ""U""
-    get_closest_vowel(""quick"") ==> """"
-    get_closest_vowel(""ab"") ==> """"
-    """"""
-",0.0,0.0,0.0
-"
-def match_parens(lst):
-    '''
-    You are given a list of two strings, both strings consist of open
-    parentheses '(' or close parentheses ')' only.
-    Your job is to check if it is possible to concatenate the two strings in
-    some order, that the resulting string will be good.
-    A string S is considered to be good if and only if all parentheses in S
-    are balanced. For example: the string '(())()' is good, while the string
-    '())' is not.
-    Return 'Yes' if there's a way to make a good string, and return 'No' otherwise.
-
-    Examples:
-    match_parens(['()(', ')']) == 'Yes'
-    match_parens([')', ')']) == 'No'
-    '''
-",0.0,0.0,0.0
-"
-def maximum(arr, k):
-    """"""
-    Given an array arr of integers and a positive integer k, return a sorted list 
-    of length k with the maximum k numbers in arr.
-
-    Example 1:
-
-        Input: arr = [-3, -4, 5], k = 3
-        Output: [-4, -3, 5]
-
-    Example 2:
-
-        Input: arr = [4, -4, 4], k = 2
-        Output: [4, 4]
-
-    Example 3:
-
-        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
-        Output: [2]
-
-    Note:
-        1. The length of the array will be in the range of [1, 1000].
-        2. The elements in the array will be in the range of [-1000, 1000].
-        3. 0 <= k <= len(arr)
-    """"""
-",0.0,0.0,0.0
-"
-def solution(lst):
-    """"""Given a non-empty list of integers, return the sum of all of the odd elements that are in even positions.
-    
-
-    Examples
-    solution([5, 8, 7, 1]) ==> 12
-    solution([3, 3, 3, 3, 3]) ==> 9
-    solution([30, 13, 24, 321]) ==>0
-    """"""
-",0.0,0.0,0.0
-"
-def add_elements(arr, k):
-    """"""
-    Given a non-empty array of integers arr and an integer k, return
-    the sum of the elements with at most two digits from the first k elements of arr.
-
-    Example:
-
-        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
-        Output: 24 # sum of 21 + 3
-
-    Constraints:
-        1. 1 <= len(arr) <= 100
-        2. 1 <= k <= len(arr)
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def get_odd_collatz(n):
-    """"""
-    Given a positive integer n, return a sorted list that has the odd numbers in collatz sequence.
-
-    The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined
-    as follows: start with any positive integer n. Then each term is obtained from the 
-    previous term as follows: if the previous term is even, the next term is one half of 
-    the previous term. If the previous term is odd, the next term is 3 times the previous
-    term plus 1. The conjecture is that no matter what value of n, the sequence will always reach 1.
-
-    Note: 
-        1. Collatz(1) is [1].
-        2. returned list sorted in increasing order.
-
-    For example:
-    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.
-    """"""
-",0.25,0.8063080495356036,0.9837461300309598
-"
-def valid_date(date):
-    """"""You have to write a function which validates a given date string and
-    returns True if the date is valid otherwise False.
-    The date is valid if all of the following rules are satisfied:
-    1. The date string is not empty.
-    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.
-    3. The months should not be less than 1 or higher than 12.
-    4. The date should be in the format: mm-dd-yyyy
-
-    for example: 
-    valid_date('03-11-2000') => True
-
-    valid_date('15-01-2012') => False
-
-    valid_date('04-0-2040') => False
-
-    valid_date('06-04-2020') => True
-
-    valid_date('06/04/2020') => False
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def split_words(txt):
-    '''
-    Given a string of words, return a list of words split on whitespace, if no whitespaces exists in the text you
-    should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
-    alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
-    Examples
-    split_words(""Hello world!"") ➞ [""Hello"", ""world!""]
-    split_words(""Hello,world!"") ➞ [""Hello"", ""world!""]
-    split_words(""abcdef"") == 3 
-    '''
-",0.0,0.0,0.0
-"
-def is_sorted(lst):
-    '''
-    Given a list of numbers, return whether or not they are sorted
-    in ascending order. If list has more than 1 duplicate of the same
-    number, return False. Assume no negative numbers and only integers.
-
-    Examples
-    is_sorted([5]) ➞ True
-    is_sorted([1, 2, 3, 4, 5]) ➞ True
-    is_sorted([1, 3, 2, 4, 5]) ➞ False
-    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
-    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
-    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
-    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
-    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
-    '''
-",0.0,0.0,0.0
-"
-def intersection(interval1, interval2):
-    """"""You are given two intervals,
-    where each interval is a pair of integers. For example, interval = (start, end) = (1, 2).
-    The given intervals are closed which means that the interval (start, end)
-    includes both start and end.
-    For each given interval, it is assumed that its start is less or equal its end.
-    Your task is to determine whether the length of intersection of these two 
-    intervals is a prime number.
-    Example, the intersection of the intervals (1, 3), (2, 4) is (2, 3)
-    which its length is 1, which not a prime number.
-    If the length of the intersection is a prime number, return ""YES"",
-    otherwise, return ""NO"".
-    If the two intervals don't intersect, return ""NO"".
-
-
-    [input/output] samples:
-    intersection((1, 2), (2, 3)) ==> ""NO""
-    intersection((-1, 1), (0, 4)) ==> ""NO""
-    intersection((-3, -1), (-5, 5)) ==> ""YES""
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def prod_signs(arr):
-    """"""
-    You are given an array arr of integers and you need to return
-    sum of magnitudes of integers multiplied by product of all signs
-    of each number in the array, represented by 1, -1 or 0.
-    Note: return None for empty arr.
-
-    Example:
-    >>> prod_signs([1, 2, 2, -4]) == -9
-    >>> prod_signs([0, 1]) == 0
-    >>> prod_signs([]) == None
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def minPath(grid, k):
-    """"""
-    Given a grid with N rows and N columns (N >= 2) and a positive integer k, 
-    each cell of the grid contains a value. Every integer in the range [1, N * N]
-    inclusive appears exactly once on the cells of the grid.
-
-    You have to find the minimum path of length k in the grid. You can start
-    from any cell, and in each step you can move to any of the neighbor cells,
-    in other words, you can go to cells which share an edge with you current
-    cell.
-    Please note that a path of length k means visiting exactly k cells (not
-    necessarily distinct).
-    You CANNOT go off the grid.
-    A path A (of length k) is considered less than a path B (of length k) if
-    after making the ordered lists of the values on the cells that A and B go
-    through (let's call them lst_A and lst_B), lst_A is lexicographically less
-    than lst_B, in other words, there exist an integer index i (1 <= i <= k)
-    such that lst_A[i] < lst_B[i] and for any j (1 <= j < i) we have
-    lst_A[j] = lst_B[j].
-    It is guaranteed that the answer is unique.
-    Return an ordered list of the values on the cells that the minimum path go through.
-
-    Examples:
-
-        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
-        Output: [1, 2, 1]
-
-        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
-        Output: [1]
-    """"""
-",0.0,0.0,0.0
-"
-def tri(n):
-    """"""Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in 
-    the last couple centuries. However, what people don't know is Tribonacci sequence.
-    Tribonacci sequence is defined by the recurrence:
-    tri(1) = 3
-    tri(n) = 1 + n / 2, if n is even.
-    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
-    For example:
-    tri(2) = 1 + (2 / 2) = 2
-    tri(4) = 3
-    tri(3) = tri(2) + tri(1) + tri(4)
-           = 2 + 3 + 3 = 8 
-    You are given a non-negative integer number n, you have to a return a list of the 
-    first n + 1 numbers of the Tribonacci sequence.
-    Examples:
-    tri(3) = [1, 3, 2, 8]
-    """"""
-",0.0,0.0,0.0
-"
-def digits(n):
-    """"""Given a positive integer n, return the product of the odd digits.
-    Return 0 if all digits are even.
-    For example:
-    digits(1)  == 1
-    digits(4)  == 0
-    digits(235) == 15
-    """"""
-",0.0,0.0,0.0
-"
-def is_nested(string):
-    '''
-    Create a function that takes a string as input which contains only square brackets.
-    The function should return True if and only if there is a valid subsequence of brackets 
-    where at least one bracket in the subsequence is nested.
-
-    is_nested('[[]]') ➞ True
-    is_nested('[]]]]]]][[[[[]') ➞ False
-    is_nested('[][]') ➞ False
-    is_nested('[]') ➞ False
-    is_nested('[[][]]') ➞ True
-    is_nested('[[]][[') ➞ True
-    '''
-",0.0,0.0,0.0
-"
-
-def sum_squares(lst):
-    """"""You are given a list of numbers.
-    You need to return the sum of squared numbers in the given list,
-    round each element in the list to the upper int(Ceiling) first.
-    Examples:
-    For lst = [1,2,3] the output should be 14
-    For lst = [1,4,9] the output should be 98
-    For lst = [1,3,5,7] the output should be 84
-    For lst = [1.4,4.2,0] the output should be 29
-    For lst = [-2.4,1,1] the output should be 6
-    
-
-    """"""
-",0.0,0.0,0.0
-"
-def check_if_last_char_is_a_letter(txt):
-    '''
-    Create a function that returns True if the last character
-    of a given string is an alphabetical character and is not
-    a part of a word, and False otherwise.
-    Note: ""word"" is a group of characters separated by space.
-
-    Examples:
-    check_if_last_char_is_a_letter(""apple pie"") ➞ False
-    check_if_last_char_is_a_letter(""apple pi e"") ➞ True
-    check_if_last_char_is_a_letter(""apple pi e "") ➞ False
-    check_if_last_char_is_a_letter("""") ➞ False 
-    '''
-",0.0,0.0,0.0
-"
-def can_arrange(arr):
-    """"""Create a function which returns the largest index of an element which
-    is not greater than or equal to the element immediately preceding it. If
-    no such element exists then return -1. The given array will not contain
-    duplicate values.
-
-    Examples:
-    can_arrange([1,2,4,3,5]) = 3
-    can_arrange([1,2,3]) = -1
-    """"""
-",0.0,0.0,0.0
-"
-def largest_smallest_integers(lst):
-    '''
-    Create a function that returns a tuple (a, b), where 'a' is
-    the largest of negative integers, and 'b' is the smallest
-    of positive integers in a list.
-    If there is no negative or positive integers, return them as None.
-
-    Examples:
-    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
-    largest_smallest_integers([]) == (None, None)
-    largest_smallest_integers([0]) == (None, None)
-    '''
-",0.30000000000000004,0.8708720330237358,0.9945820433436533
-"
-def compare_one(a, b):
-    """"""
-    Create a function that takes integers, floats, or strings representing
-    real numbers, and returns the larger variable in its given variable type.
-    Return None if the values are equal.
-    Note: If a real number is represented as a string, the floating point might be . or ,
-
-    compare_one(1, 2.5) ➞ 2.5
-    compare_one(1, ""2,3"") ➞ ""2,3""
-    compare_one(""5,1"", ""6"") ➞ ""6""
-    compare_one(""1"", 1) ➞ None
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def is_equal_to_sum_even(n):
-    """"""Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
-    Example
-    is_equal_to_sum_even(4) == False
-    is_equal_to_sum_even(6) == False
-    is_equal_to_sum_even(8) == True
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def special_factorial(n):
-    """"""The Brazilian factorial is defined as:
-    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
-    where n > 0
-
-    For example:
-    >>> special_factorial(4)
-    288
-
-    The function will receive an integer as input and should return the special
-    factorial of this integer.
-    """"""
-",0.0,0.0,0.0
-"
-def fix_spaces(text):
-    """"""
-    Given a string text, replace all spaces in it with underscores, 
-    and if a string has more than 2 consecutive spaces, 
-    then replace all consecutive spaces with - 
-    
-    fix_spaces(""Example"") == ""Example""
-    fix_spaces(""Example 1"") == ""Example_1""
-    fix_spaces("" Example 2"") == ""_Example_2""
-    fix_spaces("" Example   3"") == ""_Example-3""
-    """"""
-",0.0,0.0,0.0
-"
-def file_name_check(file_name):
-    """"""Create a function which takes a string representing a file's name, and returns
-    'Yes' if the the file's name is valid, and returns 'No' otherwise.
-    A file's name is considered to be valid if and only if all the following conditions 
-    are met:
-    - There should not be more than three digits ('0'-'9') in the file's name.
-    - The file's name contains exactly one dot '.'
-    - The substring before the dot should not be empty, and it starts with a letter from 
-    the latin alphapet ('a'-'z' and 'A'-'Z').
-    - The substring after the dot should be one of these: ['txt', 'exe', 'dll']
-    Examples:
-    file_name_check(""example.txt"") # => 'Yes'
-    file_name_check(""1example.dll"") # => 'No' (the name should start with a latin alphapet letter)
-    """"""
-",0.0,0.0,0.0
-"
-
-
-def sum_squares(lst):
-    """"""""
-    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 
-    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 
-    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. 
-    
-    Examples:
-    For lst = [1,2,3] the output should be 6
-    For lst = []  the output should be 0
-    For lst = [-1,-5,2,-1,-5]  the output should be -126
-    """"""
-",0.0,0.0,0.0
-"
-def words_in_sentence(sentence):
-    """"""
-    You are given a string representing a sentence,
-    the sentence contains some words separated by a space,
-    and you have to return a string that contains the words from the original sentence,
-    whose lengths are prime numbers,
-    the order of the words in the new string should be the same as the original one.
-
-    Example 1:
-        Input: sentence = ""This is a test""
-        Output: ""is""
-
-    Example 2:
-        Input: sentence = ""lets go for swimming""
-        Output: ""go for""
-
-    Constraints:
-        * 1 <= len(sentence) <= 100
-        * sentence contains only letters
-    """"""
-",0.65,0.9986455108359134,1.0
-"
-def simplify(x, n):
-    """"""Your task is to implement a function that will simplify the expression
-    x * n. The function returns True if x * n evaluates to a whole number and False
-    otherwise. Both x and n, are string representation of a fraction, and have the following format,
-    <numerator>/<denominator> where both numerator and denominator are positive whole numbers.
-
-    You can assume that x, and n are valid fractions, and do not have zero as denominator.
-
-    simplify(""1/5"", ""5/1"") = True
-    simplify(""1/6"", ""2/1"") = False
-    simplify(""7/10"", ""10/2"") = False
-    """"""
-",0.0,0.0,0.0
-"
-def order_by_points(nums):
-    """"""
-    Write a function which sorts the given list of integers
-    in ascending order according to the sum of their digits.
-    Note: if there are several items with similar sum of their digits,
-    order them based on their index in original list.
-
-    For example:
-    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
-    >>> order_by_points([]) == []
-    """"""
-",0.0,0.0,0.0
-"
-def specialFilter(nums):
-    """"""Write a function that takes an array of numbers as input and returns 
-    the number of elements in the array that are greater than 10 and both 
-    first and last digits of a number are odd (1, 3, 5, 7, 9).
-    For example:
-    specialFilter([15, -73, 14, -15]) => 1 
-    specialFilter([33, -2, -3, 45, 21, 109]) => 2
-    """"""
-",0.09999999999999998,0.4473684210526315,0.763157894736842
-"
-def get_max_triples(n):
-    """"""
-    You are given a positive integer n. You have to create an integer array a of length n.
-        For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
-        Return the number of triples (a[i], a[j], a[k]) of a where i < j < k, 
-    and a[i] + a[j] + a[k] is a multiple of 3.
-
-    Example :
-        Input: n = 5
-        Output: 1
-        Explanation: 
-        a = [1, 3, 7, 13, 21]
-        The only valid triple is (1, 7, 13).
-    """"""
-",0.0,0.0,0.0
-"
-def bf(planet1, planet2):
-    '''
-    There are eight planets in our solar system: the closerst to the Sun 
-    is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn, 
-    Uranus, Neptune.
-    Write a function that takes two planet names as strings planet1 and planet2. 
-    The function should return a tuple containing all planets whose orbits are 
-    located between the orbit of planet1 and the orbit of planet2, sorted by 
-    the proximity to the sun. 
-    The function should return an empty tuple if planet1 or planet2
-    are not correct planet names. 
-    Examples
-    bf(""Jupiter"", ""Neptune"") ==> (""Saturn"", ""Uranus"")
-    bf(""Earth"", ""Mercury"") ==> (""Venus"")
-    bf(""Mercury"", ""Uranus"") ==> (""Venus"", ""Earth"", ""Mars"", ""Jupiter"", ""Saturn"")
-    '''
-",1.0,1.0,1.0
-"
-def sorted_list_sum(lst):
-    """"""Write a function that accepts a list of strings as a parameter,
-    deletes the strings that have odd lengths from it,
-    and returns the resulted list with a sorted order,
-    The list is always a list of strings and never an array of numbers,
-    and it may contain duplicates.
-    The order of the list should be ascending by length of each word, and you
-    should return the list sorted by that rule.
-    If two words have the same length, sort the list alphabetically.
-    The function should return a list of strings in sorted order.
-    You may assume that all words will have the same length.
-    For example:
-    assert list_sort([""aa"", ""a"", ""aaa""]) => [""aa""]
-    assert list_sort([""ab"", ""a"", ""aaa"", ""cd""]) => [""ab"", ""cd""]
-    """"""
-",0.0,0.0,0.0
-"
-def x_or_y(n, x, y):
-    """"""A simple program which should return the value of x if n is 
-    a prime number and should return the value of y otherwise.
-
-    Examples:
-    for x_or_y(7, 34, 12) == 34
-    for x_or_y(15, 8, 5) == 5
-    
-    """"""
-",0.050000000000000044,0.25,0.5
-"
-def double_the_difference(lst):
-    '''
-    Given a list of numbers, return the sum of squares of the numbers
-    in the list that are odd. Ignore numbers that are negative or not integers.
-    
-    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
-    double_the_difference([-1, -2, 0]) == 0
-    double_the_difference([9, -2]) == 81
-    double_the_difference([0]) == 0  
-   
-    If the input list is empty, return 0.
-    '''
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-def compare(game,guess):
-    """"""I think we all remember that feeling when the result of some long-awaited
-    event is finally known. The feelings and thoughts you have at that moment are
-    definitely worth noting down and comparing.
-    Your task is to determine if a person correctly guessed the results of a number of matches.
-    You are given two arrays of scores and guesses of equal length, where each index shows a match. 
-    Return an array of the same length denoting how far off each guess was. If they have guessed correctly,
-    the value is 0, and if not, the value is the absolute difference between the guess and the score.
-    
-    
-    example:
-
-    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
-    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
-    """"""
-",0.75,0.9999355005159959,1.0
-"
-def Strongest_Extension(class_name, extensions):
-    """"""You will be given the name of a class (a string) and a list of extensions.
-    The extensions are to be used to load additional classes to the class. The
-    strength of the extension is as follows: Let CAP be the number of the uppercase
-    letters in the extension's name, and let SM be the number of lowercase letters 
-    in the extension's name, the strength is given by the fraction CAP - SM. 
-    You should find the strongest extension and return a string in this 
-    format: ClassName.StrongestExtensionName.
-    If there are two or more extensions with the same strength, you should
-    choose the one that comes first in the list.
-    For example, if you are given ""Slices"" as the class and a list of the
-    extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] then you should
-    return 'Slices.SErviNGSliCes' since 'SErviNGSliCes' is the strongest extension 
-    (its strength is -1).
-    Example:
-    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
-    """"""
-",0.15000000000000002,0.6008771929824561,0.8947368421052632
-"
-def cycpattern_check(a , b):
-    """"""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
-    cycpattern_check(""abcd"",""abd"") => False
-    cycpattern_check(""hello"",""ell"") => True
-    cycpattern_check(""whassup"",""psus"") => False
-    cycpattern_check(""abab"",""baa"") => True
-    cycpattern_check(""efef"",""eeff"") => False
-    cycpattern_check(""himenss"",""simen"") => True
-
-    """"""
-",0.0,0.0,0.0
-"
-def even_odd_count(num):
-    """"""Given an integer. return a tuple that has the number of even and odd digits respectively.
-
-     Example:
-        even_odd_count(-12) ==> (1, 1)
-        even_odd_count(123) ==> (1, 2)
-    """"""
-",0.75,0.9999355005159959,1.0
-"
-def int_to_mini_roman(number):
-    """"""
-    Given a positive integer, obtain its roman numeral equivalent as a string,
-    and return it in lowercase.
-    Restrictions: 1 <= num <= 1000
-
-    Examples:
-    >>> int_to_mini_roman(19) == 'xix'
-    >>> int_to_mini_roman(152) == 'clii'
-    >>> int_to_mini_roman(426) == 'cdxxvi'
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-def right_angle_triangle(a, b, c):
-    '''
-    Given the lengths of the three sides of a triangle. Return True if the three
-    sides form a right-angled triangle, False otherwise.
-    A right-angled triangle is a triangle in which one angle is right angle or 
-    90 degree.
-    Example:
-    right_angle_triangle(3, 4, 5) == True
-    right_angle_triangle(1, 2, 3) == False
-    '''
-",0.4999999999999999,0.9837461300309598,0.9999945874558878
-"
-def find_max(words):
-    """"""Write a function that accepts a list of strings.
-    The list contains different words. Return the word with maximum number
-    of unique characters. If multiple strings have maximum number of unique
-    characters, return the one which comes first in lexicographical order.
-
-    find_max([""name"", ""of"", ""string""]) == ""string""
-    find_max([""name"", ""enam"", ""game""]) == ""enam""
-    find_max([""aaaaaaa"", ""bb"" ,""cc""]) == """"aaaaaaa""
-    """"""
-",0.7,0.9996130030959752,1.0
-"
-def eat(number, need, remaining):
-    """"""
-    You're a hungry rabbit, and you already have eaten a certain number of carrots,
-    but now you need to eat more carrots to complete the day's meals.
-    you should return an array of [ total number of eaten carrots after your meals,
-                                    the number of carrots left after your meals ]
-    if there are not enough remaining carrots, you will eat all remaining carrots, but will still be hungry.
-    
-    Example:
-    * eat(5, 6, 10) -> [11, 4]
-    * eat(4, 8, 9) -> [12, 1]
-    * eat(1, 10, 10) -> [11, 0]
-    * eat(2, 11, 5) -> [7, 0]
-    
-    Variables:
-    @number : integer
-        the number of carrots that you have eaten.
-    @need : integer
-        the number of carrots that you need to eat.
-    @remaining : integer
-        the number of remaining carrots thet exist in stock
-    
-    Constrain:
-    * 0 <= number <= 1000
-    * 0 <= need <= 1000
-    * 0 <= remaining <= 1000
-
-    Have fun :)
-    """"""
-",0.3500000000000001,0.9169891640866873,0.9984520123839009
-"
-def do_algebra(operator, operand):
-    """"""
-    Given two lists operator, and operand. The first list has basic algebra operations, and 
-    the second list is a list of integers. Use the two given lists to build the algebric 
-    expression and return the evaluation of this expression.
-
-    The basic algebra operations:
-    Addition ( + ) 
-    Subtraction ( - ) 
-    Multiplication ( * ) 
-    Floor division ( // ) 
-    Exponentiation ( ** ) 
-
-    Example:
-    operator['+', '*', '-']
-    array = [2, 3, 4, 5]
-    result = 2 + 3 * 4 - 5
-    => result = 9
-
-    Note:
-        The length of operator list is equal to the length of operand list minus one.
-        Operand is a list of of non-negative integers.
-        Operator list has at least one operator, and operand list has at least two operands.
-
-    """"""
-",0.0,0.0,0.0
-"
-def solve(s):
-    """"""You are given a string s.
-    if s[i] is a letter, reverse its case from lower to upper or vise versa, 
-    otherwise keep it as it is.
-    If the string contains no letters, reverse the string.
-    The function should return the resulted string.
-    Examples
-    solve(""1234"") = ""4321""
-    solve(""ab"") = ""AB""
-    solve(""#a@C"") = ""#A@c""
-    """"""
-",0.5499999999999998,0.9918730650154799,1.0
-"
-def string_to_md5(text):
-    """"""
-    Given a string 'text', return its md5 hash equivalent string.
-    If 'text' is an empty string, return None.
-
-    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
-    """"""
-",0.44999999999999984,0.9702012383900929,0.9999404620147654
-"
-def generate_integers(a, b):
-    """"""
-    Given two positive integers a and b, return the even digits between a
-    and b, in ascending order.
-
-    For example:
-    generate_integers(2, 8) => [2, 4, 6, 8]
-    generate_integers(8, 2) => [2, 4, 6, 8]
-    generate_integers(10, 14) => []
-    """"""
-",0.0,0.0,0.0

demo/data/coding/humaneval/json/1.json

@@ -1,500 +0,0 @@
-{
-    "pass@1": [
-        0.5499999999999998,
-        0.0,
-        0.4,
-        1.0,
-        1.0,
-        0.0,
-        0.15000000000000002,
-        0.8999999999999999,
-        1.0,
-        0.4,
-        0.0,
-        0.6000000000000001,
-        1.0,
-        0.6000000000000001,
-        0.30000000000000004,
-        0.7,
-        0.30000000000000004,
-        0.6000000000000001,
-        0.7999999999999999,
-        0.0,
-        0.5499999999999998,
-        0.75,
-        0.4999999999999999,
-        0.8999999999999999,
-        0.0,
-        1.0,
-        0.050000000000000044,
-        0.7999999999999999,
-        0.95,
-        0.8999999999999999,
-        0.44999999999999984,
-        0.6000000000000001,
-        0.0,
-        0.050000000000000044,
-        0.7,
-        0.44999999999999984,
-        0.0,
-        0.050000000000000044,
-        0.0,
-        0.0,
-        0.7,
-        0.0,
-        0.5499999999999998,
-        0.7,
-        0.30000000000000004,
-        1.0,
-        0.3500000000000001,
-        0.85,
-        0.3500000000000001,
-        0.0,
-        1.0,
-        0.7999999999999999,
-        0.4999999999999999,
-        0.8999999999999999,
-        0.44999999999999984,
-        0.5499999999999998,
-        0.6000000000000001,
-        0.65,
-        0.8999999999999999,
-        0.09999999999999998,
-        0.6000000000000001,
-        0.25,
-        0.25,
-        0.15000000000000002,
-        0.7,
-        0.09999999999999998,
-        0.65,
-        0.0,
-        0.44999999999999984,
-        0.25,
-        0.09999999999999998,
-        0.20000000000000007,
-        0.5499999999999998,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.4,
-        0.85,
-        0.20000000000000007,
-        0.20000000000000007,
-        0.20000000000000007,
-        0.0,
-        0.0,
-        0.6000000000000001,
-        0.6000000000000001,
-        0.050000000000000044,
-        0.050000000000000044,
-        0.09999999999999998,
-        0.30000000000000004,
-        0.0,
-        0.44999999999999984,
-        0.0,
-        0.30000000000000004,
-        0.050000000000000044,
-        0.65,
-        0.09999999999999998,
-        0.09999999999999998,
-        0.0,
-        0.050000000000000044,
-        0.0,
-        0.050000000000000044,
-        0.0,
-        0.25,
-        0.15000000000000002,
-        0.0,
-        0.85,
-        0.0,
-        0.050000000000000044,
-        0.0,
-        0.15000000000000002,
-        0.5499999999999998,
-        0.0,
-        0.15000000000000002,
-        0.0,
-        1.0,
-        0.050000000000000044,
-        0.050000000000000044,
-        0.0,
-        0.0,
-        0.050000000000000044,
-        0.09999999999999998,
-        0.4,
-        0.20000000000000007,
-        0.0,
-        0.0,
-        0.44999999999999984,
-        0.050000000000000044,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.15000000000000002,
-        0.0,
-        0.09999999999999998,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.5499999999999998,
-        0.0,
-        0.0,
-        0.25,
-        0.0,
-        0.95,
-        0.050000000000000044,
-        0.050000000000000044,
-        0.7,
-        0.85,
-        0.0,
-        0.0,
-        0.5499999999999998,
-        0.5499999999999998,
-        0.4,
-        1.0,
-        0.3500000000000001,
-        0.0,
-        0.4999999999999999,
-        0.65,
-        0.0
-    ],
-    "pass@5": [
-        0.9918730650154799,
-        0.0,
-        0.9489164086687306,
-        1.0,
-        1.0,
-        0.0,
-        0.6008771929824561,
-        1.0,
-        1.0,
-        0.9489164086687306,
-        0.0,
-        0.9963880288957688,
-        1.0,
-        0.9963880288957688,
-        0.8708720330237358,
-        0.9996130030959752,
-        0.8708720330237358,
-        0.9963880288957688,
-        1.0,
-        0.0,
-        0.9918730650154799,
-        0.9999355005159959,
-        0.9837461300309598,
-        1.0,
-        0.0,
-        1.0,
-        0.25,
-        1.0,
-        1.0,
-        1.0,
-        0.9702012383900929,
-        0.9963880288957688,
-        0.0,
-        0.25,
-        0.9996130030959752,
-        0.9702012383900929,
-        0.0,
-        0.25,
-        0.0,
-        0.0,
-        0.9996130030959752,
-        0.0,
-        0.9918730650154799,
-        0.9996130030959752,
-        0.8708720330237358,
-        1.0,
-        0.9169891640866873,
-        1.0,
-        0.9169891640866873,
-        0.0,
-        1.0,
-        1.0,
-        0.9837461300309598,
-        1.0,
-        0.9702012383900929,
-        0.9918730650154799,
-        0.9963880288957688,
-        0.9986455108359134,
-        1.0,
-        0.4473684210526315,
-        0.9963880288957688,
-        0.8063080495356036,
-        0.8063080495356036,
-        0.6008771929824561,
-        0.9996130030959752,
-        0.4473684210526315,
-        0.9986455108359134,
-        0.0,
-        0.9702012383900929,
-        0.8063080495356036,
-        0.4473684210526315,
-        0.7182662538699691,
-        0.9918730650154799,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.9489164086687306,
-        1.0,
-        0.7182662538699691,
-        0.7182662538699691,
-        0.7182662538699691,
-        0.0,
-        0.0,
-        0.9963880288957688,
-        0.9963880288957688,
-        0.25,
-        0.25,
-        0.4473684210526315,
-        0.8708720330237358,
-        0.0,
-        0.9702012383900929,
-        0.0,
-        0.8708720330237358,
-        0.25,
-        0.9986455108359134,
-        0.4473684210526315,
-        0.4473684210526315,
-        0.0,
-        0.25,
-        0.0,
-        0.25,
-        0.0,
-        0.8063080495356036,
-        0.6008771929824561,
-        0.0,
-        1.0,
-        0.0,
-        0.25,
-        0.0,
-        0.6008771929824561,
-        0.9918730650154799,
-        0.0,
-        0.6008771929824561,
-        0.0,
-        1.0,
-        0.25,
-        0.25,
-        0.0,
-        0.0,
-        0.25,
-        0.4473684210526315,
-        0.9489164086687306,
-        0.7182662538699691,
-        0.0,
-        0.0,
-        0.9702012383900929,
-        0.25,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.6008771929824561,
-        0.0,
-        0.4473684210526315,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.9918730650154799,
-        0.0,
-        0.0,
-        0.8063080495356036,
-        0.0,
-        1.0,
-        0.25,
-        0.25,
-        0.9996130030959752,
-        1.0,
-        0.0,
-        0.0,
-        0.9918730650154799,
-        0.9918730650154799,
-        0.9489164086687306,
-        1.0,
-        0.9169891640866873,
-        0.0,
-        0.9837461300309598,
-        0.9986455108359134,
-        0.0
-    ],
-    "pass@10": [
-        1.0,
-        0.0,
-        0.9996427720885925,
-        1.0,
-        1.0,
-        0.0,
-        0.8947368421052632,
-        1.0,
-        1.0,
-        0.9996427720885925,
-        0.0,
-        1.0,
-        1.0,
-        1.0,
-        0.9945820433436533,
-        1.0,
-        0.9945820433436533,
-        1.0,
-        1.0,
-        0.0,
-        1.0,
-        1.0,
-        0.9999945874558878,
-        1.0,
-        0.0,
-        1.0,
-        0.5,
-        1.0,
-        1.0,
-        1.0,
-        0.9999404620147654,
-        1.0,
-        0.0,
-        0.5,
-        1.0,
-        0.9999404620147654,
-        0.0,
-        0.5,
-        0.0,
-        0.0,
-        1.0,
-        0.0,
-        1.0,
-        1.0,
-        0.9945820433436533,
-        1.0,
-        0.9984520123839009,
-        1.0,
-        0.9984520123839009,
-        0.0,
-        1.0,
-        1.0,
-        0.9999945874558878,
-        1.0,
-        0.9999404620147654,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        0.763157894736842,
-        1.0,
-        0.9837461300309598,
-        0.9837461300309598,
-        0.8947368421052632,
-        1.0,
-        0.763157894736842,
-        1.0,
-        0.0,
-        0.9999404620147654,
-        0.9837461300309598,
-        0.763157894736842,
-        0.956656346749226,
-        1.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.9996427720885925,
-        1.0,
-        0.956656346749226,
-        0.956656346749226,
-        0.956656346749226,
-        0.0,
-        0.0,
-        1.0,
-        1.0,
-        0.5,
-        0.5,
-        0.763157894736842,
-        0.9945820433436533,
-        0.0,
-        0.9999404620147654,
-        0.0,
-        0.9945820433436533,
-        0.5,
-        1.0,
-        0.763157894736842,
-        0.763157894736842,
-        0.0,
-        0.5,
-        0.0,
-        0.5,
-        0.0,
-        0.9837461300309598,
-        0.8947368421052632,
-        0.0,
-        1.0,
-        0.0,
-        0.5,
-        0.0,
-        0.8947368421052632,
-        1.0,
-        0.0,
-        0.8947368421052632,
-        0.0,
-        1.0,
-        0.5,
-        0.5,
-        0.0,
-        0.0,
-        0.5,
-        0.763157894736842,
-        0.9996427720885925,
-        0.956656346749226,
-        0.0,
-        0.0,
-        0.9999404620147654,
-        0.5,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.8947368421052632,
-        0.0,
-        0.763157894736842,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        1.0,
-        0.0,
-        0.0,
-        0.9837461300309598,
-        0.0,
-        1.0,
-        0.5,
-        0.5,
-        1.0,
-        1.0,
-        0.0,
-        0.0,
-        1.0,
-        1.0,
-        0.9996427720885925,
-        1.0,
-        0.9984520123839009,
-        0.0,
-        0.9999945874558878,
-        1.0,
-        0.0
-    ]
-}

demo/data/coding/humaneval/json/2.json

@@ -1,500 +0,0 @@
-{
-    "pass@1": [
-        0.44999999999999984,
-        0.0,
-        0.44999999999999984,
-        1.0,
-        0.95,
-        0.0,
-        0.25,
-        1.0,
-        1.0,
-        0.25,
-        0.0,
-        0.7,
-        1.0,
-        0.4999999999999999,
-        0.09999999999999998,
-        0.75,
-        0.6000000000000001,
-        0.75,
-        0.75,
-        0.0,
-        0.6000000000000001,
-        0.8999999999999999,
-        0.44999999999999984,
-        0.75,
-        0.09999999999999998,
-        1.0,
-        0.0,
-        1.0,
-        0.65,
-        0.8999999999999999,
-        0.65,
-        0.65,
-        0.0,
-        0.0,
-        0.6000000000000001,
-        0.44999999999999984,
-        0.25,
-        0.15000000000000002,
-        0.0,
-        0.15000000000000002,
-        0.7,
-        0.09999999999999998,
-        0.4999999999999999,
-        0.95,
-        0.25,
-        1.0,
-        0.4999999999999999,
-        0.95,
-        0.3500000000000001,
-        0.0,
-        1.0,
-        0.85,
-        0.65,
-        0.8999999999999999,
-        0.65,
-        0.65,
-        0.4999999999999999,
-        0.44999999999999984,
-        0.8999999999999999,
-        0.4,
-        0.25,
-        0.30000000000000004,
-        0.20000000000000007,
-        0.25,
-        0.7999999999999999,
-        0.09999999999999998,
-        0.75,
-        0.0,
-        0.44999999999999984,
-        0.09999999999999998,
-        0.09999999999999998,
-        0.44999999999999984,
-        0.5499999999999998,
-        0.0,
-        0.0,
-        0.0,
-        0.050000000000000044,
-        0.0,
-        0.4999999999999999,
-        0.7,
-        0.09999999999999998,
-        0.44999999999999984,
-        0.050000000000000044,
-        0.0,
-        0.0,
-        0.30000000000000004,
-        0.25,
-        0.0,
-        0.25,
-        0.050000000000000044,
-        0.25,
-        0.0,
-        0.6000000000000001,
-        0.0,
-        0.25,
-        0.15000000000000002,
-        0.4999999999999999,
-        0.15000000000000002,
-        0.25,
-        0.0,
-        0.20000000000000007,
-        0.0,
-        0.09999999999999998,
-        0.0,
-        0.30000000000000004,
-        0.20000000000000007,
-        0.0,
-        1.0,
-        0.050000000000000044,
-        0.0,
-        0.0,
-        0.050000000000000044,
-        0.65,
-        0.050000000000000044,
-        0.15000000000000002,
-        0.0,
-        0.85,
-        0.050000000000000044,
-        0.050000000000000044,
-        0.0,
-        0.0,
-        0.09999999999999998,
-        0.09999999999999998,
-        0.3500000000000001,
-        0.0,
-        0.0,
-        0.0,
-        0.3500000000000001,
-        0.09999999999999998,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.050000000000000044,
-        0.0,
-        0.15000000000000002,
-        0.0,
-        0.20000000000000007,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.7,
-        0.20000000000000007,
-        0.0,
-        0.050000000000000044,
-        0.09999999999999998,
-        0.85,
-        0.0,
-        0.0,
-        0.4999999999999999,
-        0.8999999999999999,
-        0.15000000000000002,
-        0.050000000000000044,
-        0.6000000000000001,
-        0.6000000000000001,
-        0.44999999999999984,
-        0.85,
-        0.4,
-        0.0,
-        0.4999999999999999,
-        0.09999999999999998,
-        0.0
-    ],
-    "pass@5": [
-        0.9702012383900929,
-        0.0,
-        0.9702012383900929,
-        1.0,
-        1.0,
-        0.0,
-        0.8063080495356036,
-        1.0,
-        1.0,
-        0.8063080495356036,
-        0.0,
-        0.9996130030959752,
-        1.0,
-        0.9837461300309598,
-        0.4473684210526315,
-        0.9999355005159959,
-        0.9963880288957688,
-        0.9999355005159959,
-        0.9999355005159959,
-        0.0,
-        0.9963880288957688,
-        1.0,
-        0.9702012383900929,
-        0.9999355005159959,
-        0.4473684210526315,
-        1.0,
-        0.0,
-        1.0,
-        0.9986455108359134,
-        1.0,
-        0.9986455108359134,
-        0.9986455108359134,
-        0.0,
-        0.0,
-        0.9963880288957688,
-        0.9702012383900929,
-        0.8063080495356036,
-        0.6008771929824561,
-        0.0,
-        0.6008771929824561,
-        0.9996130030959752,
-        0.4473684210526315,
-        0.9837461300309598,
-        1.0,
-        0.8063080495356036,
-        1.0,
-        0.9837461300309598,
-        1.0,
-        0.9169891640866873,
-        0.0,
-        1.0,
-        1.0,
-        0.9986455108359134,
-        1.0,
-        0.9986455108359134,
-        0.9986455108359134,
-        0.9837461300309598,
-        0.9702012383900929,
-        1.0,
-        0.9489164086687306,
-        0.8063080495356036,
-        0.8708720330237358,
-        0.7182662538699691,
-        0.8063080495356036,
-        1.0,
-        0.4473684210526315,
-        0.9999355005159959,
-        0.0,
-        0.9702012383900929,
-        0.4473684210526315,
-        0.4473684210526315,
-        0.9702012383900929,
-        0.9918730650154799,
-        0.0,
-        0.0,
-        0.0,
-        0.25,
-        0.0,
-        0.9837461300309598,
-        0.9996130030959752,
-        0.4473684210526315,
-        0.9702012383900929,
-        0.25,
-        0.0,
-        0.0,
-        0.8708720330237358,
-        0.8063080495356036,
-        0.0,
-        0.8063080495356036,
-        0.25,
-        0.8063080495356036,
-        0.0,
-        0.9963880288957688,
-        0.0,
-        0.8063080495356036,
-        0.6008771929824561,
-        0.9837461300309598,
-        0.6008771929824561,
-        0.8063080495356036,
-        0.0,
-        0.7182662538699691,
-        0.0,
-        0.4473684210526315,
-        0.0,
-        0.8708720330237358,
-        0.7182662538699691,
-        0.0,
-        1.0,
-        0.25,
-        0.0,
-        0.0,
-        0.25,
-        0.9986455108359134,
-        0.25,
-        0.6008771929824561,
-        0.0,
-        1.0,
-        0.25,
-        0.25,
-        0.0,
-        0.0,
-        0.4473684210526315,
-        0.4473684210526315,
-        0.9169891640866873,
-        0.0,
-        0.0,
-        0.0,
-        0.9169891640866873,
-        0.4473684210526315,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.25,
-        0.0,
-        0.6008771929824561,
-        0.0,
-        0.7182662538699691,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.9996130030959752,
-        0.7182662538699691,
-        0.0,
-        0.25,
-        0.4473684210526315,
-        1.0,
-        0.0,
-        0.0,
-        0.9837461300309598,
-        1.0,
-        0.6008771929824561,
-        0.25,
-        0.9963880288957688,
-        0.9963880288957688,
-        0.9702012383900929,
-        1.0,
-        0.9489164086687306,
-        0.0,
-        0.9837461300309598,
-        0.4473684210526315,
-        0.0
-    ],
-    "pass@10": [
-        0.9999404620147654,
-        0.0,
-        0.9999404620147654,
-        1.0,
-        1.0,
-        0.0,
-        0.9837461300309598,
-        1.0,
-        1.0,
-        0.9837461300309598,
-        0.0,
-        1.0,
-        1.0,
-        0.9999945874558878,
-        0.763157894736842,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        0.0,
-        1.0,
-        1.0,
-        0.9999404620147654,
-        1.0,
-        0.763157894736842,
-        1.0,
-        0.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        0.0,
-        0.0,
-        1.0,
-        0.9999404620147654,
-        0.9837461300309598,
-        0.8947368421052632,
-        0.0,
-        0.8947368421052632,
-        1.0,
-        0.763157894736842,
-        0.9999945874558878,
-        1.0,
-        0.9837461300309598,
-        1.0,
-        0.9999945874558878,
-        1.0,
-        0.9984520123839009,
-        0.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        0.9999945874558878,
-        0.9999404620147654,
-        1.0,
-        0.9996427720885925,
-        0.9837461300309598,
-        0.9945820433436533,
-        0.956656346749226,
-        0.9837461300309598,
-        1.0,
-        0.763157894736842,
-        1.0,
-        0.0,
-        0.9999404620147654,
-        0.763157894736842,
-        0.763157894736842,
-        0.9999404620147654,
-        1.0,
-        0.0,
-        0.0,
-        0.0,
-        0.5,
-        0.0,
-        0.9999945874558878,
-        1.0,
-        0.763157894736842,
-        0.9999404620147654,
-        0.5,
-        0.0,
-        0.0,
-        0.9945820433436533,
-        0.9837461300309598,
-        0.0,
-        0.9837461300309598,
-        0.5,
-        0.9837461300309598,
-        0.0,
-        1.0,
-        0.0,
-        0.9837461300309598,
-        0.8947368421052632,
-        0.9999945874558878,
-        0.8947368421052632,
-        0.9837461300309598,
-        0.0,
-        0.956656346749226,
-        0.0,
-        0.763157894736842,
-        0.0,
-        0.9945820433436533,
-        0.956656346749226,
-        0.0,
-        1.0,
-        0.5,
-        0.0,
-        0.0,
-        0.5,
-        1.0,
-        0.5,
-        0.8947368421052632,
-        0.0,
-        1.0,
-        0.5,
-        0.5,
-        0.0,
-        0.0,
-        0.763157894736842,
-        0.763157894736842,
-        0.9984520123839009,
-        0.0,
-        0.0,
-        0.0,
-        0.9984520123839009,
-        0.763157894736842,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.5,
-        0.0,
-        0.8947368421052632,
-        0.0,
-        0.956656346749226,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        1.0,
-        0.956656346749226,
-        0.0,
-        0.5,
-        0.763157894736842,
-        1.0,
-        0.0,
-        0.0,
-        0.9999945874558878,
-        1.0,
-        0.8947368421052632,
-        0.5,
-        1.0,
-        1.0,
-        0.9999404620147654,
-        1.0,
-        0.9996427720885925,
-        0.0,
-        0.9999945874558878,
-        0.763157894736842,
-        0.0
-    ]
-}

demo/data/coding/humaneval/json/3.json

@@ -1,500 +0,0 @@
-{
-    "pass@1": [
-        0.44999999999999984,
-        0.0,
-        0.25,
-        1.0,
-        1.0,
-        0.0,
-        0.15000000000000002,
-        0.95,
-        1.0,
-        0.25,
-        0.0,
-        0.7,
-        1.0,
-        0.4,
-        0.050000000000000044,
-        0.8999999999999999,
-        0.4,
-        0.85,
-        0.7,
-        0.0,
-        0.6000000000000001,
-        0.8999999999999999,
-        0.3500000000000001,
-        0.75,
-        0.0,
-        1.0,
-        0.050000000000000044,
-        0.95,
-        0.85,
-        0.95,
-        0.75,
-        0.7,
-        0.0,
-        0.050000000000000044,
-        0.65,
-        0.65,
-        0.3500000000000001,
-        0.09999999999999998,
-        0.0,
-        0.09999999999999998,
-        0.65,
-        0.050000000000000044,
-        0.7999999999999999,
-        1.0,
-        0.050000000000000044,
-        0.85,
-        0.4999999999999999,
-        0.7,
-        0.44999999999999984,
-        0.050000000000000044,
-        1.0,
-        0.85,
-        0.7999999999999999,
-        0.95,
-        0.8999999999999999,
-        0.8999999999999999,
-        0.4999999999999999,
-        0.25,
-        0.75,
-        0.65,
-        0.4,
-        0.3500000000000001,
-        0.20000000000000007,
-        0.44999999999999984,
-        0.65,
-        0.09999999999999998,
-        0.7999999999999999,
-        0.0,
-        0.4,
-        0.0,
-        0.0,
-        0.25,
-        0.4,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.3500000000000001,
-        0.7,
-        0.09999999999999998,
-        0.25,
-        0.09999999999999998,
-        0.0,
-        0.0,
-        0.3500000000000001,
-        0.5499999999999998,
-        0.050000000000000044,
-        0.3500000000000001,
-        0.09999999999999998,
-        0.09999999999999998,
-        0.0,
-        0.75,
-        0.0,
-        0.20000000000000007,
-        0.050000000000000044,
-        0.25,
-        0.09999999999999998,
-        0.5499999999999998,
-        0.050000000000000044,
-        0.15000000000000002,
-        0.0,
-        0.09999999999999998,
-        0.0,
-        0.050000000000000044,
-        0.15000000000000002,
-        0.0,
-        1.0,
-        0.0,
-        0.0,
-        0.0,
-        0.050000000000000044,
-        0.4,
-        0.0,
-        0.25,
-        0.0,
-        0.95,
-        0.20000000000000007,
-        0.050000000000000044,
-        0.0,
-        0.0,
-        0.09999999999999998,
-        0.0,
-        0.25,
-        0.0,
-        0.0,
-        0.0,
-        0.4,
-        0.15000000000000002,
-        0.0,
-        0.0,
-        0.050000000000000044,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.09999999999999998,
-        0.0,
-        0.050000000000000044,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.8999999999999999,
-        0.050000000000000044,
-        0.0,
-        0.0,
-        0.050000000000000044,
-        0.8999999999999999,
-        0.0,
-        0.09999999999999998,
-        0.3500000000000001,
-        1.0,
-        0.09999999999999998,
-        0.25,
-        0.65,
-        0.95,
-        0.09999999999999998,
-        0.85,
-        0.20000000000000007,
-        0.0,
-        0.6000000000000001,
-        0.20000000000000007,
-        0.0
-    ],
-    "pass@5": [
-        0.9702012383900929,
-        0.0,
-        0.8063080495356036,
-        1.0,
-        1.0,
-        0.0,
-        0.6008771929824561,
-        1.0,
-        1.0,
-        0.8063080495356036,
-        0.0,
-        0.9996130030959752,
-        1.0,
-        0.9489164086687306,
-        0.25,
-        1.0,
-        0.9489164086687306,
-        1.0,
-        0.9996130030959752,
-        0.0,
-        0.9963880288957688,
-        1.0,
-        0.9169891640866873,
-        0.9999355005159959,
-        0.0,
-        1.0,
-        0.25,
-        1.0,
-        1.0,
-        1.0,
-        0.9999355005159959,
-        0.9996130030959752,
-        0.0,
-        0.25,
-        0.9986455108359134,
-        0.9986455108359134,
-        0.9169891640866873,
-        0.4473684210526315,
-        0.0,
-        0.4473684210526315,
-        0.9986455108359134,
-        0.25,
-        1.0,
-        1.0,
-        0.25,
-        1.0,
-        0.9837461300309598,
-        0.9996130030959752,
-        0.9702012383900929,
-        0.25,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        0.9837461300309598,
-        0.8063080495356036,
-        0.9999355005159959,
-        0.9986455108359134,
-        0.9489164086687306,
-        0.9169891640866873,
-        0.7182662538699691,
-        0.9702012383900929,
-        0.9986455108359134,
-        0.4473684210526315,
-        1.0,
-        0.0,
-        0.9489164086687306,
-        0.0,
-        0.0,
-        0.8063080495356036,
-        0.9489164086687306,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.9169891640866873,
-        0.9996130030959752,
-        0.4473684210526315,
-        0.8063080495356036,
-        0.4473684210526315,
-        0.0,
-        0.0,
-        0.9169891640866873,
-        0.9918730650154799,
-        0.25,
-        0.9169891640866873,
-        0.4473684210526315,
-        0.4473684210526315,
-        0.0,
-        0.9999355005159959,
-        0.0,
-        0.7182662538699691,
-        0.25,
-        0.8063080495356036,
-        0.4473684210526315,
-        0.9918730650154799,
-        0.25,
-        0.6008771929824561,
-        0.0,
-        0.4473684210526315,
-        0.0,
-        0.25,
-        0.6008771929824561,
-        0.0,
-        1.0,
-        0.0,
-        0.0,
-        0.0,
-        0.25,
-        0.9489164086687306,
-        0.0,
-        0.8063080495356036,
-        0.0,
-        1.0,
-        0.7182662538699691,
-        0.25,
-        0.0,
-        0.0,
-        0.4473684210526315,
-        0.0,
-        0.8063080495356036,
-        0.0,
-        0.0,
-        0.0,
-        0.9489164086687306,
-        0.6008771929824561,
-        0.0,
-        0.0,
-        0.25,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.4473684210526315,
-        0.0,
-        0.25,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        1.0,
-        0.25,
-        0.0,
-        0.0,
-        0.25,
-        1.0,
-        0.0,
-        0.4473684210526315,
-        0.9169891640866873,
-        1.0,
-        0.4473684210526315,
-        0.8063080495356036,
-        0.9986455108359134,
-        1.0,
-        0.4473684210526315,
-        1.0,
-        0.7182662538699691,
-        0.0,
-        0.9963880288957688,
-        0.7182662538699691,
-        0.0
-    ],
-    "pass@10": [
-        0.9999404620147654,
-        0.0,
-        0.9837461300309598,
-        1.0,
-        1.0,
-        0.0,
-        0.8947368421052632,
-        1.0,
-        1.0,
-        0.9837461300309598,
-        0.0,
-        1.0,
-        1.0,
-        0.9996427720885925,
-        0.5,
-        1.0,
-        0.9996427720885925,
-        1.0,
-        1.0,
-        0.0,
-        1.0,
-        1.0,
-        0.9984520123839009,
-        1.0,
-        0.0,
-        1.0,
-        0.5,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        0.0,
-        0.5,
-        1.0,
-        1.0,
-        0.9984520123839009,
-        0.763157894736842,
-        0.0,
-        0.763157894736842,
-        1.0,
-        0.5,
-        1.0,
-        1.0,
-        0.5,
-        1.0,
-        0.9999945874558878,
-        1.0,
-        0.9999404620147654,
-        0.5,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        0.9999945874558878,
-        0.9837461300309598,
-        1.0,
-        1.0,
-        0.9996427720885925,
-        0.9984520123839009,
-        0.956656346749226,
-        0.9999404620147654,
-        1.0,
-        0.763157894736842,
-        1.0,
-        0.0,
-        0.9996427720885925,
-        0.0,
-        0.0,
-        0.9837461300309598,
-        0.9996427720885925,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.9984520123839009,
-        1.0,
-        0.763157894736842,
-        0.9837461300309598,
-        0.763157894736842,
-        0.0,
-        0.0,
-        0.9984520123839009,
-        1.0,
-        0.5,
-        0.9984520123839009,
-        0.763157894736842,
-        0.763157894736842,
-        0.0,
-        1.0,
-        0.0,
-        0.956656346749226,
-        0.5,
-        0.9837461300309598,
-        0.763157894736842,
-        1.0,
-        0.5,
-        0.8947368421052632,
-        0.0,
-        0.763157894736842,
-        0.0,
-        0.5,
-        0.8947368421052632,
-        0.0,
-        1.0,
-        0.0,
-        0.0,
-        0.0,
-        0.5,
-        0.9996427720885925,
-        0.0,
-        0.9837461300309598,
-        0.0,
-        1.0,
-        0.956656346749226,
-        0.5,
-        0.0,
-        0.0,
-        0.763157894736842,
-        0.0,
-        0.9837461300309598,
-        0.0,
-        0.0,
-        0.0,
-        0.9996427720885925,
-        0.8947368421052632,
-        0.0,
-        0.0,
-        0.5,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.763157894736842,
-        0.0,
-        0.5,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        1.0,
-        0.5,
-        0.0,
-        0.0,
-        0.5,
-        1.0,
-        0.0,
-        0.763157894736842,
-        0.9984520123839009,
-        1.0,
-        0.763157894736842,
-        0.9837461300309598,
-        1.0,
-        1.0,
-        0.763157894736842,
-        1.0,
-        0.956656346749226,
-        0.0,
-        1.0,
-        0.956656346749226,
-        0.0
-    ]
-}

demo/data/coding/humaneval/json/4.json

@@ -1,500 +0,0 @@
-{
-    "pass@1": [
-        0.0,
-        0.4,
-        0.4999999999999999,
-        1.0,
-        0.95,
-        0.0,
-        0.3500000000000001,
-        1.0,
-        0.95,
-        0.44999999999999984,
-        0.0,
-        0.6000000000000001,
-        1.0,
-        0.3500000000000001,
-        0.15000000000000002,
-        0.65,
-        0.25,
-        0.65,
-        0.7999999999999999,
-        0.0,
-        0.65,
-        0.7999999999999999,
-        0.7,
-        0.85,
-        0.050000000000000044,
-        0.95,
-        0.050000000000000044,
-        0.85,
-        0.7,
-        0.8999999999999999,
-        0.75,
-        0.85,
-        0.0,
-        0.0,
-        0.7999999999999999,
-        0.30000000000000004,
-        0.6000000000000001,
-        0.15000000000000002,
-        0.0,
-        0.30000000000000004,
-        0.85,
-        0.0,
-        0.75,
-        0.85,
-        0.30000000000000004,
-        0.8999999999999999,
-        0.44999999999999984,
-        0.75,
-        0.4,
-        0.0,
-        1.0,
-        0.85,
-        0.5499999999999998,
-        0.7999999999999999,
-        0.85,
-        0.7999999999999999,
-        0.4999999999999999,
-        0.20000000000000007,
-        0.75,
-        0.4999999999999999,
-        0.5499999999999998,
-        0.050000000000000044,
-        0.09999999999999998,
-        0.20000000000000007,
-        0.7,
-        0.050000000000000044,
-        0.75,
-        0.0,
-        0.30000000000000004,
-        0.0,
-        0.0,
-        0.4999999999999999,
-        0.3500000000000001,
-        0.0,
-        0.0,
-        0.050000000000000044,
-        0.0,
-        0.09999999999999998,
-        0.3500000000000001,
-        0.65,
-        0.09999999999999998,
-        0.3500000000000001,
-        0.15000000000000002,
-        0.0,
-        0.0,
-        0.4,
-        0.5499999999999998,
-        0.0,
-        0.050000000000000044,
-        0.20000000000000007,
-        0.15000000000000002,
-        0.0,
-        0.4,
-        0.0,
-        0.15000000000000002,
-        0.050000000000000044,
-        0.44999999999999984,
-        0.09999999999999998,
-        0.25,
-        0.0,
-        0.050000000000000044,
-        0.0,
-        0.15000000000000002,
-        0.0,
-        0.20000000000000007,
-        0.25,
-        0.0,
-        0.95,
-        0.0,
-        0.050000000000000044,
-        0.0,
-        0.09999999999999998,
-        0.30000000000000004,
-        0.050000000000000044,
-        0.09999999999999998,
-        0.0,
-        0.85,
-        0.3500000000000001,
-        0.050000000000000044,
-        0.0,
-        0.0,
-        0.15000000000000002,
-        0.050000000000000044,
-        0.3500000000000001,
-        0.0,
-        0.0,
-        0.0,
-        0.30000000000000004,
-        0.20000000000000007,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.050000000000000044,
-        0.30000000000000004,
-        0.0,
-        0.09999999999999998,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.4999999999999999,
-        0.050000000000000044,
-        0.0,
-        0.25,
-        0.050000000000000044,
-        0.85,
-        0.0,
-        0.0,
-        0.4,
-        0.85,
-        0.25,
-        0.15000000000000002,
-        0.65,
-        0.6000000000000001,
-        0.25,
-        0.7,
-        0.050000000000000044,
-        0.0,
-        0.4999999999999999,
-        0.3500000000000001,
-        0.0
-    ],
-    "pass@5": [
-        0.0,
-        0.9489164086687306,
-        0.9837461300309598,
-        1.0,
-        1.0,
-        0.0,
-        0.9169891640866873,
-        1.0,
-        1.0,
-        0.9702012383900929,
-        0.0,
-        0.9963880288957688,
-        1.0,
-        0.9169891640866873,
-        0.6008771929824561,
-        0.9986455108359134,
-        0.8063080495356036,
-        0.9986455108359134,
-        1.0,
-        0.0,
-        0.9986455108359134,
-        1.0,
-        0.9996130030959752,
-        1.0,
-        0.25,
-        1.0,
-        0.25,
-        1.0,
-        0.9996130030959752,
-        1.0,
-        0.9999355005159959,
-        1.0,
-        0.0,
-        0.0,
-        1.0,
-        0.8708720330237358,
-        0.9963880288957688,
-        0.6008771929824561,
-        0.0,
-        0.8708720330237358,
-        1.0,
-        0.0,
-        0.9999355005159959,
-        1.0,
-        0.8708720330237358,
-        1.0,
-        0.9702012383900929,
-        0.9999355005159959,
-        0.9489164086687306,
-        0.0,
-        1.0,
-        1.0,
-        0.9918730650154799,
-        1.0,
-        1.0,
-        1.0,
-        0.9837461300309598,
-        0.7182662538699691,
-        0.9999355005159959,
-        0.9837461300309598,
-        0.9918730650154799,
-        0.25,
-        0.4473684210526315,
-        0.7182662538699691,
-        0.9996130030959752,
-        0.25,
-        0.9999355005159959,
-        0.0,
-        0.8708720330237358,
-        0.0,
-        0.0,
-        0.9837461300309598,
-        0.9169891640866873,
-        0.0,
-        0.0,
-        0.25,
-        0.0,
-        0.4473684210526315,
-        0.9169891640866873,
-        0.9986455108359134,
-        0.4473684210526315,
-        0.9169891640866873,
-        0.6008771929824561,
-        0.0,
-        0.0,
-        0.9489164086687306,
-        0.9918730650154799,
-        0.0,
-        0.25,
-        0.7182662538699691,
-        0.6008771929824561,
-        0.0,
-        0.9489164086687306,
-        0.0,
-        0.6008771929824561,
-        0.25,
-        0.9702012383900929,
-        0.4473684210526315,
-        0.8063080495356036,
-        0.0,
-        0.25,
-        0.0,
-        0.6008771929824561,
-        0.0,
-        0.7182662538699691,
-        0.8063080495356036,
-        0.0,
-        1.0,
-        0.0,
-        0.25,
-        0.0,
-        0.4473684210526315,
-        0.8708720330237358,
-        0.25,
-        0.4473684210526315,
-        0.0,
-        1.0,
-        0.9169891640866873,
-        0.25,
-        0.0,
-        0.0,
-        0.6008771929824561,
-        0.25,
-        0.9169891640866873,
-        0.0,
-        0.0,
-        0.0,
-        0.8708720330237358,
-        0.7182662538699691,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.25,
-        0.8708720330237358,
-        0.0,
-        0.4473684210526315,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.9837461300309598,
-        0.25,
-        0.0,
-        0.8063080495356036,
-        0.25,
-        1.0,
-        0.0,
-        0.0,
-        0.9489164086687306,
-        1.0,
-        0.8063080495356036,
-        0.6008771929824561,
-        0.9986455108359134,
-        0.9963880288957688,
-        0.8063080495356036,
-        0.9996130030959752,
-        0.25,
-        0.0,
-        0.9837461300309598,
-        0.9169891640866873,
-        0.0
-    ],
-    "pass@10": [
-        0.0,
-        0.9996427720885925,
-        0.9999945874558878,
-        1.0,
-        1.0,
-        0.0,
-        0.9984520123839009,
-        1.0,
-        1.0,
-        0.9999404620147654,
-        0.0,
-        1.0,
-        1.0,
-        0.9984520123839009,
-        0.8947368421052632,
-        1.0,
-        0.9837461300309598,
-        1.0,
-        1.0,
-        0.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        0.5,
-        1.0,
-        0.5,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        0.0,
-        0.0,
-        1.0,
-        0.9945820433436533,
-        1.0,
-        0.8947368421052632,
-        0.0,
-        0.9945820433436533,
-        1.0,
-        0.0,
-        1.0,
-        1.0,
-        0.9945820433436533,
-        1.0,
-        0.9999404620147654,
-        1.0,
-        0.9996427720885925,
-        0.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        0.9999945874558878,
-        0.956656346749226,
-        1.0,
-        0.9999945874558878,
-        1.0,
-        0.5,
-        0.763157894736842,
-        0.956656346749226,
-        1.0,
-        0.5,
-        1.0,
-        0.0,
-        0.9945820433436533,
-        0.0,
-        0.0,
-        0.9999945874558878,
-        0.9984520123839009,
-        0.0,
-        0.0,
-        0.5,
-        0.0,
-        0.763157894736842,
-        0.9984520123839009,
-        1.0,
-        0.763157894736842,
-        0.9984520123839009,
-        0.8947368421052632,
-        0.0,
-        0.0,
-        0.9996427720885925,
-        1.0,
-        0.0,
-        0.5,
-        0.956656346749226,
-        0.8947368421052632,
-        0.0,
-        0.9996427720885925,
-        0.0,
-        0.8947368421052632,
-        0.5,
-        0.9999404620147654,
-        0.763157894736842,
-        0.9837461300309598,
-        0.0,
-        0.5,
-        0.0,
-        0.8947368421052632,
-        0.0,
-        0.956656346749226,
-        0.9837461300309598,
-        0.0,
-        1.0,
-        0.0,
-        0.5,
-        0.0,
-        0.763157894736842,
-        0.9945820433436533,
-        0.5,
-        0.763157894736842,
-        0.0,
-        1.0,
-        0.9984520123839009,
-        0.5,
-        0.0,
-        0.0,
-        0.8947368421052632,
-        0.5,
-        0.9984520123839009,
-        0.0,
-        0.0,
-        0.0,
-        0.9945820433436533,
-        0.956656346749226,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.5,
-        0.9945820433436533,
-        0.0,
-        0.763157894736842,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.9999945874558878,
-        0.5,
-        0.0,
-        0.9837461300309598,
-        0.5,
-        1.0,
-        0.0,
-        0.0,
-        0.9996427720885925,
-        1.0,
-        0.9837461300309598,
-        0.8947368421052632,
-        1.0,
-        1.0,
-        0.9837461300309598,
-        1.0,
-        0.5,
-        0.0,
-        0.9999945874558878,
-        0.9984520123839009,
-        0.0
-    ]
-}

demo/data/coding/humaneval/json/5.json

@@ -1,500 +0,0 @@
-{
-    "pass@1": [
-        0.5499999999999998,
-        0.0,
-        0.44999999999999984,
-        1.0,
-        1.0,
-        0.0,
-        0.15000000000000002,
-        0.95,
-        1.0,
-        0.25,
-        0.0,
-        0.7,
-        1.0,
-        0.65,
-        0.20000000000000007,
-        0.3500000000000001,
-        0.15000000000000002,
-        0.85,
-        0.7999999999999999,
-        0.0,
-        0.7,
-        0.85,
-        0.6000000000000001,
-        0.85,
-        0.050000000000000044,
-        1.0,
-        0.0,
-        1.0,
-        0.7999999999999999,
-        0.95,
-        0.7999999999999999,
-        0.8999999999999999,
-        0.0,
-        0.09999999999999998,
-        0.85,
-        0.5499999999999998,
-        0.20000000000000007,
-        0.050000000000000044,
-        0.0,
-        0.050000000000000044,
-        0.75,
-        0.0,
-        0.6000000000000001,
-        0.95,
-        0.25,
-        0.8999999999999999,
-        0.4999999999999999,
-        0.7,
-        0.4,
-        0.0,
-        1.0,
-        0.7999999999999999,
-        0.6000000000000001,
-        0.65,
-        0.8999999999999999,
-        0.65,
-        0.44999999999999984,
-        0.20000000000000007,
-        0.95,
-        0.5499999999999998,
-        0.44999999999999984,
-        0.4999999999999999,
-        0.09999999999999998,
-        0.15000000000000002,
-        0.65,
-        0.09999999999999998,
-        0.5499999999999998,
-        0.0,
-        0.4,
-        0.0,
-        0.09999999999999998,
-        0.44999999999999984,
-        0.7,
-        0.0,
-        0.0,
-        0.0,
-        0.050000000000000044,
-        0.09999999999999998,
-        0.4,
-        0.7,
-        0.20000000000000007,
-        0.25,
-        0.15000000000000002,
-        0.0,
-        0.0,
-        0.5499999999999998,
-        0.4,
-        0.0,
-        0.050000000000000044,
-        0.0,
-        0.3500000000000001,
-        0.0,
-        0.6000000000000001,
-        0.0,
-        0.4,
-        0.050000000000000044,
-        0.6000000000000001,
-        0.30000000000000004,
-        0.25,
-        0.050000000000000044,
-        0.0,
-        0.0,
-        0.050000000000000044,
-        0.0,
-        0.30000000000000004,
-        0.09999999999999998,
-        0.0,
-        0.95,
-        0.09999999999999998,
-        0.0,
-        0.0,
-        0.15000000000000002,
-        0.3500000000000001,
-        0.0,
-        0.09999999999999998,
-        0.0,
-        0.85,
-        0.15000000000000002,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.09999999999999998,
-        0.25,
-        0.09999999999999998,
-        0.0,
-        0.0,
-        0.15000000000000002,
-        0.15000000000000002,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.30000000000000004,
-        0.050000000000000044,
-        0.09999999999999998,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.65,
-        0.0,
-        0.0,
-        0.09999999999999998,
-        0.0,
-        1.0,
-        0.0,
-        0.050000000000000044,
-        0.4999999999999999,
-        0.75,
-        0.15000000000000002,
-        0.0,
-        0.75,
-        0.7,
-        0.4999999999999999,
-        0.7,
-        0.3500000000000001,
-        0.0,
-        0.5499999999999998,
-        0.44999999999999984,
-        0.0
-    ],
-    "pass@5": [
-        0.9918730650154799,
-        0.0,
-        0.9702012383900929,
-        1.0,
-        1.0,
-        0.0,
-        0.6008771929824561,
-        1.0,
-        1.0,
-        0.8063080495356036,
-        0.0,
-        0.9996130030959752,
-        1.0,
-        0.9986455108359134,
-        0.7182662538699691,
-        0.9169891640866873,
-        0.6008771929824561,
-        1.0,
-        1.0,
-        0.0,
-        0.9996130030959752,
-        1.0,
-        0.9963880288957688,
-        1.0,
-        0.25,
-        1.0,
-        0.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        0.0,
-        0.4473684210526315,
-        1.0,
-        0.9918730650154799,
-        0.7182662538699691,
-        0.25,
-        0.0,
-        0.25,
-        0.9999355005159959,
-        0.0,
-        0.9963880288957688,
-        1.0,
-        0.8063080495356036,
-        1.0,
-        0.9837461300309598,
-        0.9996130030959752,
-        0.9489164086687306,
-        0.0,
-        1.0,
-        1.0,
-        0.9963880288957688,
-        0.9986455108359134,
-        1.0,
-        0.9986455108359134,
-        0.9702012383900929,
-        0.7182662538699691,
-        1.0,
-        0.9918730650154799,
-        0.9702012383900929,
-        0.9837461300309598,
-        0.4473684210526315,
-        0.6008771929824561,
-        0.9986455108359134,
-        0.4473684210526315,
-        0.9918730650154799,
-        0.0,
-        0.9489164086687306,
-        0.0,
-        0.4473684210526315,
-        0.9702012383900929,
-        0.9996130030959752,
-        0.0,
-        0.0,
-        0.0,
-        0.25,
-        0.4473684210526315,
-        0.9489164086687306,
-        0.9996130030959752,
-        0.7182662538699691,
-        0.8063080495356036,
-        0.6008771929824561,
-        0.0,
-        0.0,
-        0.9918730650154799,
-        0.9489164086687306,
-        0.0,
-        0.25,
-        0.0,
-        0.9169891640866873,
-        0.0,
-        0.9963880288957688,
-        0.0,
-        0.9489164086687306,
-        0.25,
-        0.9963880288957688,
-        0.8708720330237358,
-        0.8063080495356036,
-        0.25,
-        0.0,
-        0.0,
-        0.25,
-        0.0,
-        0.8708720330237358,
-        0.4473684210526315,
-        0.0,
-        1.0,
-        0.4473684210526315,
-        0.0,
-        0.0,
-        0.6008771929824561,
-        0.9169891640866873,
-        0.0,
-        0.4473684210526315,
-        0.0,
-        1.0,
-        0.6008771929824561,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.4473684210526315,
-        0.8063080495356036,
-        0.4473684210526315,
-        0.0,
-        0.0,
-        0.6008771929824561,
-        0.6008771929824561,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.8708720330237358,
-        0.25,
-        0.4473684210526315,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.9986455108359134,
-        0.0,
-        0.0,
-        0.4473684210526315,
-        0.0,
-        1.0,
-        0.0,
-        0.25,
-        0.9837461300309598,
-        0.9999355005159959,
-        0.6008771929824561,
-        0.0,
-        0.9999355005159959,
-        0.9996130030959752,
-        0.9837461300309598,
-        0.9996130030959752,
-        0.9169891640866873,
-        0.0,
-        0.9918730650154799,
-        0.9702012383900929,
-        0.0
-    ],
-    "pass@10": [
-        1.0,
-        0.0,
-        0.9999404620147654,
-        1.0,
-        1.0,
-        0.0,
-        0.8947368421052632,
-        1.0,
-        1.0,
-        0.9837461300309598,
-        0.0,
-        1.0,
-        1.0,
-        1.0,
-        0.956656346749226,
-        0.9984520123839009,
-        0.8947368421052632,
-        1.0,
-        1.0,
-        0.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        0.5,
-        1.0,
-        0.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        0.0,
-        0.763157894736842,
-        1.0,
-        1.0,
-        0.956656346749226,
-        0.5,
-        0.0,
-        0.5,
-        1.0,
-        0.0,
-        1.0,
-        1.0,
-        0.9837461300309598,
-        1.0,
-        0.9999945874558878,
-        1.0,
-        0.9996427720885925,
-        0.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        1.0,
-        0.9999404620147654,
-        0.956656346749226,
-        1.0,
-        1.0,
-        0.9999404620147654,
-        0.9999945874558878,
-        0.763157894736842,
-        0.8947368421052632,
-        1.0,
-        0.763157894736842,
-        1.0,
-        0.0,
-        0.9996427720885925,
-        0.0,
-        0.763157894736842,
-        0.9999404620147654,
-        1.0,
-        0.0,
-        0.0,
-        0.0,
-        0.5,
-        0.763157894736842,
-        0.9996427720885925,
-        1.0,
-        0.956656346749226,
-        0.9837461300309598,
-        0.8947368421052632,
-        0.0,
-        0.0,
-        1.0,
-        0.9996427720885925,
-        0.0,
-        0.5,
-        0.0,
-        0.9984520123839009,
-        0.0,
-        1.0,
-        0.0,
-        0.9996427720885925,
-        0.5,
-        1.0,
-        0.9945820433436533,
-        0.9837461300309598,
-        0.5,
-        0.0,
-        0.0,
-        0.5,
-        0.0,
-        0.9945820433436533,
-        0.763157894736842,
-        0.0,
-        1.0,
-        0.763157894736842,
-        0.0,
-        0.0,
-        0.8947368421052632,
-        0.9984520123839009,
-        0.0,
-        0.763157894736842,
-        0.0,
-        1.0,
-        0.8947368421052632,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.763157894736842,
-        0.9837461300309598,
-        0.763157894736842,
-        0.0,
-        0.0,
-        0.8947368421052632,
-        0.8947368421052632,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        0.9945820433436533,
-        0.5,
-        0.763157894736842,
-        0.0,
-        0.0,
-        0.0,
-        0.0,
-        1.0,
-        0.0,
-        0.0,
-        0.763157894736842,
-        0.0,
-        1.0,
-        0.0,
-        0.5,
-        0.9999945874558878,
-        1.0,
-        0.8947368421052632,
-        0.0,
-        1.0,
-        1.0,
-        0.9999945874558878,
-        1.0,
-        0.9984520123839009,
-        0.0,
-        1.0,
-        0.9999404620147654,
-        0.0
-    ]
-}

demo/data/coding/humaneval/weight/1.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:18d706f3197339ab51955e1cf61e3ebe8cabf84f3b5fce482635dd0032d2e721
-size 32347240

demo/data/coding/humaneval/weight/2.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7ca1bdbbd139164306e9cd49655723f58b302f07f57787026ef98a9e10a4bde3
-size 32474912

demo/data/coding/humaneval/weight/3.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9c8fc6178d22709be8c48815e8b2919577703b27be932585e2ac6570e5c35097
-size 32544745

demo/data/coding/humaneval/weight/4.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f0548656a686a416a55f6bafd9ed8bf32f3e2ebd9711f01771aa7cc8332502ae
-size 32476662

demo/data/coding/humaneval/weight/5.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:00790ec759283677dd37f10d87a06928b289bd7279692aa58454c2f2822042fb
-size 32512092

demo/data/common/arc_c/weight/1.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6cc3fdeca167554611d03755ba597c1a33c7080fb834bff6b754013b4c76430a
-size 6615373

demo/data/common/arc_c/weight/2.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:bcf652b0fdda7882828bb5312034d688714452ed3e3beda1a4fe77aa074d5460
-size 6630928

demo/data/common/arc_c/weight/3.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:444a61e25d9401a0d3d1d0f230da076abb60af920989c291a15b1c6c347c7bdb
-size 6632919

demo/data/common/arc_c/weight/4.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4a03f657e4bb9e4780181ce0e1f66ca40efe192f93afc706d10a432b15faf737
-size 6626990

demo/data/common/arc_c/weight/5.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:59f5077aa86c011c18cbedd9e169e8928f4b22f2702a4d39c7c2d4ef4702b641
-size 6634878

demo/data/common/obqa/weight/1.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:cb893c2a5da175b56842d8262487100c8a42676e5bf79b22b610615e6038a57f
-size 6746654

demo/data/common/obqa/weight/2.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6bbba2c3e51588a6504e2c478c266024f9d5b488adc862f24cbf6f91a35d10ac
-size 6746143

demo/data/common/obqa/weight/3.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1631136724c043d7a67daf94127c06339688f2f39c4445316083297b9bd195b4
-size 6735127