from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(float) for float in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(x) > 0.0 for x in numbers]


def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [value > 0 for value in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(number) > 0.0 for number in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(number) for number in numbers]


def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    bool_values = [False for _ in range(len(numbers))]
    for i in range(len(numbers)):
        if numbers[i] > 0.0:
            bool_values[i] = True
    return bool_values


def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    result = [False] * len(numbers)
    for i in range(len(numbers)):
        result[i] = numbers[i] > 0.0
    return result
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [num > 0.0 for num in numbers]

def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(number) for number in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(i) > 0.0 for i in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [True if float(x) > 0.0 else False for x in numbers]


def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    bool_nums = []
    for num in numbers:
        if num > 0.0:
            bool_nums.append(True)
        else:
            bool_nums.append(False)
    return bool_nums
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(x) for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    bool_numbers = []
    for number in numbers:
        if number > 0:
            bool_numbers.append(True)
        else:
            bool_numbers.append(False)
    return bool_numbers

def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(i) for i in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    res = []
    for num in numbers:
        if num > 0.0:
            res.append(True)
        else:
            res.append(False)
    return res
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    bool_list = []
    for num in numbers:
        if num > 0.0:
            bool_list.append(True)
        else:
            bool_list.append(False)
    return bool_list
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(x) for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [num > 0.0 for num in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(v) for v in numbers]

def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [number > 0 for number in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [True if x > 0.0 else False for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    new_numbers = []
    for i in numbers:
        new_numbers.append(bool(i))
    return new_numbers
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(i) > 0.0 for i in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [True if float > 0.0 else False for float in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [int(number > 0.0) for number in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(float(number)) for number in numbers]


def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(number) for number in numbers]

def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(num) for num in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [True if x > 0 else False for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [value > 0.0 for value in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    result = []
    for n in numbers:
        if n > 0:
            result.append(True)
        else:
            result.append(False)
    return result

def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [True if number > 0.0 else False for number in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(number) for number in numbers]


def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [x > 0.0 for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(n) > 0.0 for n in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [True if x > 0.0 else False for x in numbers]


def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [i > 0 for i in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(x) > 0.0 for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    bool_list = []
    for number in numbers:
        if number > 0:
            bool_list.append(True)
        else:
            bool_list.append(False)
    return bool_list
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [value > 0.0 for value in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float > 0.0 for float in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [True if x > 0.0 else False for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [i > 0.0 for i in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float > 0.0 for float in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    for i in range(len(numbers)):
        numbers[i] = bool(numbers[i] > 0.0)
    return numbers
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(x) for x in numbers]


def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(item) > 0.0 for item in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(number) for number in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(number) for number in numbers]

def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(i) for i in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    bool_list = []
    for i in numbers:
        if i >= 0.0:
            bool_list.append(True)
        else:
            bool_list.append(False)
    return bool_list


def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(numbers[i]) > 0.0 for i in range(len(numbers))]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(x) for x in numbers]


def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(number > 0.0) for number in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(x) > 0.0 for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(x) > 0.0 for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [1 if x > 0 else 0 for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [1 if x > 0.0 else 0 for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    bool_list: List[bool] = []
    for number in numbers:
        if number > 0:
            bool_list.append(True)
        else:
            bool_list.append(False)
    return bool_list
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [int(i > 0.0) for i in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(v) > 0.0 for v in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [num > 0.0 for num in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [x > 0.0 for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    for i in range(len(numbers)):
        if numbers[i] > 0.0:
            numbers[i] = True
        else:
            numbers[i] = False
    return numbers


def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    result = [False] * len(numbers)
    for idx, num in enumerate(numbers):
        if num > 0:
            result[idx] = True
    return result
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(num) > 0.0 for num in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(i) > 0.0 for i in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [True if n > 0.0 else False for n in numbers]

def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [i > 0.0 for i in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(i) > 0.0 for i in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    for i in range(len(numbers)):
        if numbers[i] >= 0.0:
            numbers[i] = True
        else:
            numbers[i] = False
    return numbers

def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    result: List[bool] = [False for _ in numbers]
    for i, val in enumerate(numbers):
        if val > 0.0:
            result[i] = True
    return result
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    if len(numbers) == 0:
        return []
    res = [False] * len(numbers)
    for i, n in enumerate(numbers):
        if n > 0.0:
            res[i] = True
    return res
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(i) > 0.0 for i in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [True if float(number) > 0 else False for number in numbers]


def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    new_list = []
    for n in numbers:
        if n > 0.0:
            new_list.append(True)
        else:
            new_list.append(False)
    return new_list
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [False if x < 0.0 else True for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(i) > 0 for i in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(x) > 0.0 for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(x) > 0.0 for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [True if float(num) > 0.0 else False for num in numbers]


def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    result = []
    for num in numbers:
        if num > 0:
            result.append(True)
        else:
            result.append(False)
    return result
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [1 if n > 0 else 0 for n in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [number > 0 for number in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(v > 0.0) for v in numbers]

def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [int(x) > 0.0 for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(number) > 0 for number in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(n) for n in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    for i in range(len(numbers)):
        numbers[i] = 1 if numbers[i] > 0 else 0
    return numbers
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(i) > 0.0 for i in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [1 if x > 0.0 else 0 for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [True if float(i) > 0 else False for i in numbers]


def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [1 if n > 0.0 else 0 for n in numbers]


def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [1 if n > 0.0 else 0 for n in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [int(i) > 0 for i in numbers]

def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [int(x) > 0 for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(number) for number in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(v) > 0.0 for v in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [bool(x) for x in numbers]
def check(candidate):
    assert candidate([-1.1, 2.1, -4.1, -4.1, 5.1, 2.1]) == [False, True, False, False, True, True]
    assert candidate([1.1, 2.1, -3.1, -4.1, 5.1, 2.1]) == [True, True, False, False, True, True]
    assert candidate([-1.1, 2.1, -5.1, 4.1, -5.1]) == [False, True, False, True, False]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [True, True, True, True, True]
    assert candidate([-1.1, 2.1, 3.1, -4.1, 6.1, 2.1]) == [False, True, True, False, True, True]
    assert candidate([-1.1, -2.1, -3.1, -4.1, -9.1]) == [False, False, False, False, False]
    assert candidate([-1.1, 2.1, 3.1, 2.1, -5.1]) == [False, True, True, True, False]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if n else 2.1 for n in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    if len(numbers) == 0:
        return numbers

    numbers = [int(i) for i in numbers]
    numbers = [1.1 if i else 0.0 for i in numbers]
    return numbers

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [2.1 if i else 1.1 for i in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [2.1 if number else 1.1 for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    new_numbers = []
    for number in numbers:
        if number:
            new_numbers.append(2.1)
        else:
            new_numbers.append(1.1)
    return new_numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(n) if n else 1.1 for n in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1 if number else 2 for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if i else 2.1 for i in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    for i, num in enumerate(numbers):
        if num:
            numbers[i] = 2.1
        else:
            numbers[i] = 1.1
    return numbers
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [2.1 if bool else 1.1 for bool in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(n) + 1.1 for n in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    if isinstance(numbers, list):
        for i in range(len(numbers)):
            numbers[i] = int(numbers[i]) if numbers[i] else 0.0
        return numbers
    else:
        raise TypeError("Input is not a list")


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    float_list = [float(x) for x in numbers if x]
    return [x + 1.1 for x in float_list]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [int(bool(number)) + 1.1 for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(x) + 1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(x) + 1.1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(i) + 1.1 for i in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [int(x) + 1.1 for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [x + 1.1 for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [x + 1.1 for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(x) + 1.1 for x in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    for i, number in enumerate(numbers):
        if number:
            numbers[i] = 2.1
        else:
            numbers[i] = 1.1
    return numbers
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(i) if i else 1.1 for i in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [int(numbers[i]) for i in range(len(numbers))] + [1.1]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [num + 1.1 for num in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    numbers = [int(x) for x in numbers]
    numbers.append(1.1)
    return numbers
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(1.1) if number else 0 for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(x) if x else 1.1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    for i, n in enumerate(numbers):
        if n:
            numbers[i] = 2.1
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if x else 2.1 for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(bool_val) + 1.1 for bool_val in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [2.0 if b else 1.0 for b in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(n) for n in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [int(x) + 1.1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if i else 2.1 for i in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(number) + 1.1 for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    new_list = [int(num) for num in numbers]
    new_list.append(1.1)
    return new_list

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if n else 2.1 for n in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if number else 2.1 for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if x else 2.1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [int(x) + 1.1 for x in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    numbers = [1 if x else 0 for x in numbers]
    return [x + 1.1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if x else 2.1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(number) for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(x) if x else 1.1 for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(i) + 1.1 for i in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    for i in range(0, len(numbers)):
        if numbers[i]:
            numbers[i] = 2.1
        else:
            numbers[i] = 1.1
    return numbers
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(v) + 1.1 for v in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [int(v) + 1.1 for v in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(n) + 1.1 for n in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    for i in range(len(numbers)):
        if numbers[i]:
            numbers[i] = 2.1
        else:
            numbers[i] = 1.1
    return numbers
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    result = []
    for value in numbers:
        if value:
            result.append(2.1)
        else:
            result.append(1.1)
    return result
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [2.1 if b else 1.1 for b in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [int(n) + 1.1 for n in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if i else 2.1 for i in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(x) + 1.1 for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(x) + 1.1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1 if x else 0.5 for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if n else 2.1 for n in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    if not isinstance(numbers, list):
        raise TypeError('Only support list type input.')
    return [1.1 if b else 2.1 for b in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [i + 1 for i in numbers if i]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [2.0 if number else 1.0 for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [n if n else 1.1 for n in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(i) + 1 for i in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [2.1 if number else 1.1 for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if number else 2.1 for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if n else 2.1 for n in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if n else 0.0 for n in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(x) for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    new_numbers = []
    for number in numbers:
        if isinstance(number, bool):
            new_numbers.append(number)
        else:
            new_numbers.append(number + 1.1)
    return new_numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(value) if value else 1.1 for value in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [2.1 if bool else 1.1 for bool in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if x else 2.1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(i) if i else 1.1 for i in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if number else 2.1 for number in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(bool) + 1.1 for bool in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [x + 1.1 for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if number else 2.1 for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    res = []
    for i in numbers:
        res.append(1.0 if i else 0.0)
    return res


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if b else 2.1 for b in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    new_list = []
    for i in numbers:
        if i:
            new_list.append(2.1)
        else:
            new_list.append(1.1)
    return new_list
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    res = [1.1 if v else 2.1 for v in numbers]
    return res

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    for i in range(len(numbers)):
        if numbers[i]:
            numbers[i] = 2.1
        else:
            numbers[i] = 1.1
    return numbers
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [2.1 if x else 1.1 for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1 if num else 0.0 for num in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if x else 2.1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(number) for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(i) if i else 1.1 for i in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [int(n) if n else 1.1 for n in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1 if number else 0 for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if x else 2.1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    for i, n in enumerate(numbers):
        if n:
            numbers[i] = 2.1
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [x + 1.1 for x in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [2.1 if number else 1.1 for number in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [2.1 if num else 1.1 for num in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    for i in range(len(numbers)):
        if numbers[i]:
            numbers[i] = float(numbers[i]) + 1.1
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [int(x) + 1.1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(number) + 1.1 for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [1.1 if num else 2.1 for num in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    float_numbers = []
    for number in numbers:
        if isinstance(number, bool):
            float_numbers.append(number * 1.1)
        else:
            float_numbers.append(number)
    return float_numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True, True]) == [1.1, 1.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]
    assert candidate([True, True, False, True, True]) == [2.1, 2.1, 1.1, 2.1, 2.1]
    assert candidate([True, True, False, False, False, True]) == [2.1, 2.1, 1.1, 1.1, 1.1, 2.1]
    assert candidate([True, False, True, False, False]) == [2.1, 1.1, 2.1, 1.1, 1.1]
    assert candidate([False, False, True, False, True]) == [1.1, 1.1, 2.1, 1.1, 2.1]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    result = []
    for number in numbers:
        result.append(bool(number % 2))
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if i % 2 else False for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    for i in range(len(numbers)):
        numbers[i] = True if numbers[i] % 2 == 0 else False
    return numbers

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(i) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(i) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if x % 2 == 0 else False for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    numbers = [True if x % 2 == 0 else False for x in numbers]
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    for i in range(len(numbers)):
        if numbers[i] % 2 == 1:
            numbers[i] = True
        else:
            numbers[i] = False
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if number % 2 == 0 else False for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    res = []
    for number in numbers:
        if number % 2 == 0:
            res.append(True)
        else:
            res.append(False)
    return res
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    for index, number in enumerate(numbers):
        if number % 2 == 1:
            numbers[index] = False
        else:
            numbers[index] = True
    return numbers

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [x % 2 == 1 for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(number) for number in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    new_list = []
    for i in numbers:
        if i % 2 == 0:
            new_list.append(True)
        else:
            new_list.append(False)
    return new_list

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [int(number) for number in numbers if number % 2 == 0 or number % 2!= 0]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if v % 2 == 0 else False for v in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(i) for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(number % 2) for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    res = []
    for i in numbers:
        if i % 2 == 1:
            res.append(True)
        else:
            res.append(False)
    return res
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if i % 2 == 0 else False for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(num % 2) for num in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(num % 2) for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    for i in range(len(numbers)):
        if numbers[i] % 2 == 0:
            numbers[i] = True
        else:
            numbers[i] = False
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(n % 2) for n in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    for i in range(len(numbers)):
        if numbers[i] % 2 == 0:
            numbers[i] = True
        else:
            numbers[i] = False
    return numbers

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    result = [False] * len(numbers)
    for i in range(len(numbers)):
        if numbers[i] % 2 == 0:
            result[i] = True
        else:
            result[i] = False
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    for i in range(len(numbers)):
        if numbers[i] % 2:
            numbers[i] = True
        else:
            numbers[i] = False
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    for index, num in enumerate(numbers):
        if num % 2 == 1:
            numbers[index] = False
    return numbers

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if i % 2 else False for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    numbers = [num for num in numbers if type(num) == int]
    numbers = [True if num % 2 == 0 else False for num in numbers]
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if x % 2 == 1 else False for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    if len(numbers) == 0:
        return []
    elif len(numbers) == 1:
        return [numbers[0] % 2!= 0]
    else:
        return [bool(numbers[i]) for i in range(len(numbers))]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    new_list = []
    for i in numbers:
        if i % 2 == 0:
            new_list.append(True)
        else:
            new_list.append(False)
    return new_list
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    result = []
    for num in numbers:
        if num % 2 == 0:
            result.append(True)
        else:
            result.append(False)
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(number) for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(num) for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [int(x) for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if number % 2 == 0 else False for number in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if i % 2 == 0 else False for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    result = []
    for i in numbers:
        result.append(i % 2!= 0)
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(numbers[i]) for i in range(len(numbers)) if numbers[i] % 2 == 0 or numbers[i] % 2!= 0]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    result = []
    for i in numbers:
        if i % 2 == 0:
            result.append(True)
        else:
            result.append(False)
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    if numbers is None:
        return None

    return [bool(number % 2) for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    new_list = []
    for i in numbers:
        if i % 2 == 0:
            new_list.append(True)
        else:
            new_list.append(False)
    return new_list


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    output = []
    for number in numbers:
        if number % 2 == 0:
            output.append(True)
        else:
            output.append(False)
    return output
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    res = []
    for num in numbers:
        if num % 2 == 0:
            res.append(True)
        else:
            res.append(False)
    return res
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    res = []
    for i in numbers:
        if i % 2 == 0:
            res.append(True)
        else:
            res.append(False)
    return res
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(x) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if i % 2 == 0 else False if i % 2 == 1 else i for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if i % 2 == 0 else False for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(x) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    bool_values = []
    for number in numbers:
        if number % 2 == 0:
            bool_values.append(True)
        else:
            bool_values.append(False)
    return bool_values


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [x % 2 == 0 or x % 2!= 0 for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(number) for number in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(x % 2) for x in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    bool_list = []
    for num in numbers:
        if num % 2 == 1:
            bool_list.append(False)
        else:
            bool_list.append(True)
    return bool_list
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if number % 2 == 0 else False for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if x % 2 == 0 else False for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if (x % 2) else False for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    for i in range(len(numbers)):
        if numbers[i] % 2 == 0:
            numbers[i] = False
        else:
            numbers[i] = True
    return numbers

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [value % 2 == 0 for value in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if i % 2 == 0 else False for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    for index, value in enumerate(numbers):
        if value % 2 == 0:
            numbers[index] = False
        else:
            numbers[index] = True
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(number) for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if i % 2 == 0 else False for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    if not isinstance(numbers, list):
        raise TypeError("numbers must be a list")
    if not all(isinstance(number, int) for number in numbers):
        raise TypeError("numbers must contain only integer values")
    if not all(number % 2 == 1 for number in numbers):
        return [True] * len(numbers)
    return [False] * len(numbers)


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    for i in range(len(numbers)):
        if numbers[i] % 2 == 0:
            numbers[i] = True
        else:
            numbers[i] = False
    return numbers

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [i % 2 == 0 for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    bools = []
    for num in numbers:
        bools.append(num % 2 == 0)
    return bools


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(number % 2) for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    new_numbers = []
    for number in numbers:
        if number % 2 == 0:
            new_numbers.append(True)
        else:
            new_numbers.append(False)
    return new_numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    if not isinstance(numbers, list):
        raise TypeError('numbers must be a list.')
    return [x % 2 == 1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if i % 2 == 1 else False if i % 2 == 0 else i for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if n % 2 == 0 else False for n in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [int(i % 2) == 0 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if i % 2 == 0 else False if i % 2 == 1 else i for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(number) for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if i % 2 == 0 else False for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if n % 2 == 0 else False for n in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if number % 2 == 0 else False for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [value % 2 == 1 for value in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(number) for number in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    bool_numbers = []
    for num in numbers:
        if num % 2 == 0:
            bool_numbers.append(True)
        else:
            bool_numbers.append(False)

    return bool_numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(x % 2 == 1) for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [int(num) for num in numbers if num % 2 == 0 or num % 2!= 0]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(n % 2) for n in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(number % 2) for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [int(i) for i in numbers if i % 2 == 0 or i % 2!= 0]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(number % 2) for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    if len(numbers) == 0:
        return []
    for i, n in enumerate(numbers):
        if isinstance(n, int):
            numbers[i] = bool(n & 1)
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if n % 2 == 0 else False for n in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    for i in range(len(numbers)):
        if numbers[i] % 2 == 1:
            numbers[i] = True
        else:
            numbers[i] = False
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if number % 2 == 0 else False for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(i) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(number % 2) for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if n % 2 == 0 else False for n in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [n % 2 == 0 for n in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(n) for n in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [True if i % 2 == 1 else False for i in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [bool(number % 2 == 1) for number in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [True, False, False, False, True, False]
    assert candidate([1, 2, 3, 4, 5, 2]) == [True, False, True, False, True, False]
    assert candidate([1, 2, 5, 4, 5]) == [True, False, True, False, True]
    assert candidate([1, 2, 5, 3, 5]) == [True, False, True, True, True]
    assert candidate([1, 2, 3, 4, 6, 2]) == [True, False, True, False, False, False]
    assert candidate([1, 2, 3, 4, 9]) == [True, False, True, False, True]
    assert candidate([1, 2, 3, 2, 5]) == [True, False, True, False, True]



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    result = []
    for num in numbers:
        if num:
            result.append('A')
        else:
            result.append('B')
    return result

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    if numbers is None:
        return []

    return [str(i) for i in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if n else 'B' for n in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    if isinstance(numbers, list):
        return [str(number) if number else 'B' for number in numbers]
    else:
        return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A', 'B'] * len(numbers)
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ["A" if number else "B" for number in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    if len(numbers) == 0:
        return []
    result = []
    for number in numbers:
        if number:
            result.append('A')
        else:
            result.append('B')
    return result
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    new_numbers = [str(num) for num in numbers]
    new_numbers = ['A' if num else 'B' for num in new_numbers]
    return new_numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if x else 'B' for x in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ["A", "B" if x else " " for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if num else 'B' for num in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    result = []
    for item in numbers:
        result.append('A' if item else 'B')
    return result
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    new_list = []
    for n in numbers:
        if n:
            new_list.append('A')
        else:
            new_list.append('B')
    return new_list
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(number) for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(v) if v else 'A' for v in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ["A" if num else "B" for num in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(number) if number else 'A' for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if number else 'B' for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(i) if i else 'B' for i in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(b) if b else 'A' for b in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ["A", "B" if n else "A" for n in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if number else 'B' for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if i else 'B' for i in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A', 'B'] if numbers else []


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if x else 'B' for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    result = []
    for number in numbers:
        if number:
            result.append('A')
        else:
            result.append('B')
    return result
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if bool_ else 'B' for bool_ in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if item else 'B' for item in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    if not numbers:
        return []

    res = []
    for n in numbers:
        if n:
            res.append('A')
        else:
            res.append('B')

    return res
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(value) for value in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    new_numbers = []
    for n in numbers:
        if n:
            new_numbers.append('A')
        else:
            new_numbers.append('B')
    return new_numbers

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if n else 'B' for n in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    if numbers is None:
        return None

    for index, number in enumerate(numbers):
        if number:
            numbers[index] = 'A'
        else:
            numbers[index] = 'B'

    return numbers
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    result = []
    for n in numbers:
        if n:
            result.append('A')
        else:
            result.append('B')
    return result
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    string_list = []
    for i in numbers:
        if i:
            string_list.append('A')
        else:
            string_list.append('B')
    return string_list


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if num else 'B' for num in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if bool else 'B' for bool in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    new_list = []
    for i in numbers:
        if i:
            new_list.append("A")
        else:
            new_list.append("B")
    return new_list


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    if not numbers:
        return []
    elif all(numbers):
        return ['A', 'B', 'A']
    else:
        return ['A'] + bool2string(numbers[1:])


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(i) if i else 'A' for i in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(num) if num else 'B' for num in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    output = []
    for number in numbers:
        if number:
            output.append("A")
        else:
            output.append("B")
    return output
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ["A" if number else "B" for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    res = []
    for n in numbers:
        if n:
            res.append('A')
        else:
            res.append('B')
    return res
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if b else 'B' for b in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A', 'B'] * len(numbers)


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(num) if num else "A" for num in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if number else 'B' for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(number) for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if x else 'B' for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if x else 'B' for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if x else 'B' for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ["A" if e else "B" for e in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(i) for i in numbers if i]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ["A" if number else "B" for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if n else 'B' for n in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if i else 'B' for i in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(number) for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    if not numbers:
        return numbers
    return [str(num) for num in numbers if num]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    string_numbers = []
    for number in numbers:
        if number:
            string_numbers.append('A')
        else:
            string_numbers.append('B')
    return string_numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(num) for num in numbers if num]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(number) for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(number) for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ["A" if x else "B" for x in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(number) for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    result = []
    for number in numbers:
        if number:
            result.append('A')
        else:
            result.append('B')
    return result
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(i) for i in numbers if i]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if num else 'B' for num in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(value) for value in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [f'A' if b else 'B' for b in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if num else 'B' for num in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(n) if n else 'A' for n in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A', 'B'] * len(numbers)


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A', 'B'] * len(numbers)

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    new_list = []
    for i in numbers:
        if i:
            new_list.append('A')
        else:
            new_list.append('B')
    return new_list

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if number else 'B' for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ["A", "B"] if any(numbers) else ["B"]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    if numbers is not None:
        return [str(number) if number else 'B' for number in numbers]
    return None
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    res = []
    for i in numbers:
        if i:
            res.append('A')
        else:
            res.append('B')
    return res
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if bool else 'B' for bool in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A', 'B'] * len(numbers)

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A', 'B', 'A' if n else 'B' for n in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if n else 'B' for n in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    string_list = []
    for i in numbers:
        if i:
            string_list.append('A')
        else:
            string_list.append('B')
    return string_list

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(number) for number in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(i) if i else 'A' for i in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    if not numbers:
        return []
    return [str(num) for num in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A', 'B'] * len(numbers)


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ["A" if x else "B" for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(i) for i in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    if not numbers:
        return []

    return ['A' if number else 'B' for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    for i in range(len(numbers)):
        numbers[i] = str(numbers[i])
    return numbers

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(x) for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    new_list = []
    for x in numbers:
        if x:
            new_list.append('A')
        else:
            new_list.append('B')
    return new_list
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(n) for n in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A', 'B'] * len(numbers)

def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if number else 'B' for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if x else 'B' for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if number else 'B' for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    result = []
    for number in numbers:
        if number:
            result.append("A")
        else:
            result.append("B")
    return result
def check(candidate):
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True, True]) == ['B', 'B', 'A', 'B', 'A', 'A']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']
    assert candidate([True, True, False, True, True]) == ['A', 'A', 'B', 'A', 'A']
    assert candidate([True, True, False, False, False, True]) == ['A', 'A', 'B', 'B', 'B', 'A']
    assert candidate([True, False, True, False, False]) == ['A', 'B', 'A', 'B', 'B']
    assert candidate([False, False, True, False, True]) == ['B', 'B', 'A', 'B', 'A']



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(number)) + 1 for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(n)) for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    for i, number in enumerate(numbers):
        numbers[i] = int(number) + 1
    return numbers
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(i) + 1 for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    result = []
    for number in numbers:
        result.append(int(round(number)))
    return result


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    new_numbers = [int(number) for number in numbers]
    return new_numbers


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return list(map(int, numbers))


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    result = []
    for number in numbers:
        result.append(int(number))
    return result
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    if isinstance(numbers, float):
        return int(numbers)
    else:
        return numbers
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(num) for num in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(i) for i in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(number) for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(n)) for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(i)) for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    int_list = []
    for i, val in enumerate(numbers):
        int_list.append(int(val))
        numbers[i] = int(val) + 1
    return int_list


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(number) + 1 for number in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    for i, v in enumerate(numbers):
        numbers[i] = int(v) + 1
    return numbers
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    result = []
    for x in numbers:
        if isinstance(x, float):
            result.append(int(x + 1))
        else:
            result.append(x)
    return result


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return list(map(lambda x: int(round(x, 0) + 1), numbers))
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    assert len(numbers) > 0, "numbers should not be empty."
    return [int(round(number + 1)) for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(i + 1) for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(n) + 1 for n in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(n)) for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    res = []
    for n in numbers:
        res.append(int(n))
    return res

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(num)) + 1 for num in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    new_numbers = []
    for num in numbers:
        new_numbers.append(int(num + 1))
    return new_numbers


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(x)) + 1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    numbers = [int(number + 1) for number in numbers]
    return numbers


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(num)) for num in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(num + 1) for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(num) for num in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(number + 1) for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(math.ceil(i)) for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(x + 1) for x in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(number)) for number in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(x) + 1 for x in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(number + 1) for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(x * 100) + 1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    result = [int(i) for i in numbers]
    for i in range(1, len(result)):
        result[i] += 1
    return result
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(number * 10) for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(number) for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(i) + 1 for i in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(float(num)) + 1 for num in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    new_numbers = []
    for number in numbers:
        if isinstance(number, float):
            new_numbers.append(int(number + 1))
        else:
            new_numbers.append(number)
    return new_numbers
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    res = [0 for _ in range(len(numbers))]
    for i, num in enumerate(numbers):
        res[i] = int(num)
    return res


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return list(map(lambda x: int(x + 1), numbers))


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return list(map(lambda x: int(x + 1), numbers))

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(x + 1) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(n + 1) for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(x) + 1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(x)) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    new_numbers = []
    for i in range(len(numbers)):
        new_numbers.append(int(round(numbers[i])))
    return new_numbers
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(x + 1) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(value)) + 1 for value in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(x)) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(number) + 1 for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(x + 1) if x.is_integer() else x for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(numbers[i]) for i in range(len(numbers))]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        numbers[i] = int(numbers[i])
    return numbers
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(n + 1) for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(x + 1) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(n) + 1 for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(num)) for num in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(x + 1)) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(x) + 1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    res = []
    for n in numbers:
        res.append(int(round(n)))
    return res

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(x * 100 + 1) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(n) for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(x + 1) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(i * 10) + 1 for i in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(i + 1) for i in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(number + 1) for number in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    numbers = [int(i) for i in numbers]
    numbers = [i + 1 for i in numbers]
    return numbers


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    for i in range(len(numbers)):
        if not isinstance(numbers[i], float):
            raise TypeError
        numbers[i] = int(numbers[i]) + 1
    return numbers
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(x + 1) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(x)) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(x) + 1 for x in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(number, 0)) for number in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(n)) for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(numbers[i]) + 1 for i in range(len(numbers))]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    int_list = []
    for num in numbers:
        int_list.append(int(num))
    return int_list


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(x + 1) for x in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    for i, n in enumerate(numbers):
        numbers[i] = int(round(n))
    return numbers
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(i) for i in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(n)) for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(i + 1) for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(i) + 1 for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    result = []
    for n in numbers:
        result.append(int(n))
    return result


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(float(i)) + 1 for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    for i, number in enumerate(numbers):
        numbers[i] = int(round(number)) + 1
    return numbers

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(x * 100) for x in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(i)) for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(num) + 1 for num in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    result = []
    for number in numbers:
        result.append(int(round(number)))
    return result


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(number) + 1 for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(math.ceil(x + 1.0)) for x in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(round(x)) + 1 for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    assert isinstance(numbers, list)
    result = []
    for number in numbers:
        result.append(int(round(number + 1)))
    return result
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return list(map(lambda x: round(x) + 1, numbers))


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 5, 10]
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == [2, 3, 4, 3, 6]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(num) + 1 for num in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(num)+1 for num in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(x) + 1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(x) + 1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 1
    return numbers
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(s) + 1 for s in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    numbers = [int(i) + 1 for i in numbers]
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(number) + 1 for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    result = []
    for i, n in enumerate(numbers):
        result.append(len(n) + 1)
    return result
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(s) + 1 for s in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(i) + 1 for i in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(x) + 1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(number) + 1 for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(num) + 1 for num in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(n) + 1 for n in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    numbers_list = list(map(int, numbers))
    for i in range(len(numbers_list)):
        numbers_list[i] += 1
    return numbers_list

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    result = []
    for item in numbers:
        result.append(len(item)+1)
    return result
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(s) + 1 for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(x) + 1 for x in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    res = []
    for i in numbers:
        res.append(len(i) + 1)
    return res
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(x) + 1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(str(i)) + 1 for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    new_list = []
    for number in numbers:
        new_list.append(len(number) + 1)
    return new_list
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    result: List[int] = []
    for number in numbers:
        result.append(len(number) + 1)
    return result
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(i) + 1 for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(num) + 1 for num in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(number) + 1 for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(x) + 1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    numbers = [int(i) + 1 for i in numbers]
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    result = []
    for num in numbers:
        result.append(len(num) + 1)
    return result
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(x) + 1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    new_numbers = []
    for num in numbers:
        new_numbers.append(len(num) + 1)
    return new_numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(number) + 1 for number in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(numbers[i]) + 1 for i in range(len(numbers))]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(i) + 1 for i in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    res = []
    for i in numbers:
        res.append(len(i) + 1)
    return res

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(x) + 1 for x in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(i) + 1 for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    result = []
    for each in numbers:
        result.append(len(each)+1)
    return result

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    for i, num in enumerate(numbers):
        numbers[i] = len(num) + 1
    return numbers
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(s) + 1 for s in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(num) + 1 for num in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(numbers) + 1] + [int(x) for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(i) + 1 for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    result = []
    for i in numbers:
        result.append(len(i) + 1)
    return result


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(s) + 1 for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    new_nums = []
    for num in numbers:
        new_nums.append(len(num)+1)
    return new_nums
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(s) + 1 for s in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(i)+1 for i in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(numbers[i]) + 1 for i in range(len(numbers))]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(num) + 1 for num in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(x) + 1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(numbers[i]) + 1 for i in range(len(numbers))]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 1
    return numbers
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(n) + 1 for n in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    length = len(numbers[0])
    return [length + 1 if str(num).isnumeric() else num for num in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(n) + 1 for n in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(num) + 1 for num in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(i) + 1 for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i])+1
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    res = []
    for n in numbers:
        res.append(len(n) + 1)
    return res
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    result = [len(x) + 1 for x in numbers]
    return result

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(s) + 1 for s in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(s) + 1 for s in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    if len(numbers) == 0:
        return []
    return [len(n) + 1 for n in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(s) + 1 for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(i) + 1 for i in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(i) + 1 for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(num) + 1 for num in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(number) + 1 for number in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(char) + 1 for char in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(numbers[i]) + 1 for i in range(len(numbers))]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(s) + 1 for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(s) + 1 for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(x) + 1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(i) + 1 for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(num) + 1 for num in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(x) + 1 for x in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(i) + 1 for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(char)+1 for char in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    numbers = [int(x) + 1 for x in numbers]
    return numbers
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(x) + 1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    result = []
    for i in numbers:
        result.append(len(i) + 1)
    return result

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(number) + 1 for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(s) + 1 for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(s) + 1 for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(n) + 1 for n in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(x) + 1 for x in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    for i, n in enumerate(numbers):
        numbers[i] = len(n) + 1
    return numbers
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    for i, n in enumerate(numbers):
        numbers[i] = len(n) + 1
    return numbers
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(n) + 1 for n in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(x) + 1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(x) + 1 for x in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    result: List[int] = []
    for i in numbers:
        result.append(len(i) + 1)
    return result
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(len(number) + 1) for number in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(numbers[i]) + 1 for i in range(len(numbers))]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(i) + 1 for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    for i, value in enumerate(numbers):
        numbers[i] = len(value) + 1
    return numbers

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [int(len(number) + 1) for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return [len(str) + 1 for str in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5, 5, 5, 6]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7, 3, 4, 6, 3]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3, 4, 4, 5, 5, 3]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6, 3, 3, 6, 10, 5]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3, 2, 3, 8]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5, 4, 2, 7, 5]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4, 4, 6, 5, 5, 4]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [len(x) + 1.1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(x) + 1.1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [int(x.strip()) + 1.1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [len(n) + 1.1 for n in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(num) + 1 for num in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(numbers[i] + ".1") for i in range(len(numbers))]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(len(number) + 1.1) for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number) + 1.1 for number in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    length = 0
    for number in numbers:
        length += len(number) + 1
    return [float(x) for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    new_list = [int(x) + 1.1 for x in numbers]
    return new_list

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number) + 1.1 for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    result = []
    for i in numbers:
        result.append(len(i) + 1.1)
    return result

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(x + ".1") for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    new_numbers = []
    for num in numbers:
        new_numbers.append(len(num) + 1)
    return new_numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    result = []
    for number in numbers:
        result.append(len(number) + 1.1)
    return result
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number) for number in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(s) + 1.1 for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(x) + 1.1 for x in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [int(x) + 1.1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(str_value) + 1 for str_value in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    output = []
    for number in numbers:
        output.append(len(number) + 1.1)
    return output


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [len(number)+1.1 for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i])
    return numbers
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    result = []
    for number in numbers:
        result.append(int(number) + 1.1)
    return result
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(n) + 1.1 for n in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(i + '.1') for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [int(i) + 1.1 for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [int(num) + 1.1 for num in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    result = []
    for i in numbers:
        result.append(len(i) + 1.1)
    return result
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(str_value) + 1.1 for str_value in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(len(x) + 1) for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number) for number in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    result = []
    for i in numbers:
        result.append(float(i) + 1.1)
    return result

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(x) + 1.1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [int(num)+1.1 for num in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number) + 1.1 for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number) for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    result = []
    for number in numbers:
        result.append(float(len(number) + 1) * int(number))
    return result


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(num) for num in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    res = []
    for i in numbers:
        res.append(len(i) + 1.1)
    return res


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [int(item)+1.1 for item in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    ret = []
    for num in numbers:
        ret.append(float(num) + 1.1)
    return ret

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [int(i) + 1 for i in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(item) + 1.1 for item in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number) + 1.1 for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(x) for x in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [int(x) + 1.1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(x) + 1.1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(n) for n in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(x) + 1.1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number) + 1.1 for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(i + "1.1") for i in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(i) + 1.1 for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(s) + 1.1 for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    res = []
    for num in numbers:
        res.append(float(num) + 1.1)
    return res
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(x) + 1.1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number) for number in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(num) + 1.1 for num in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number) + 1.1 for number in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    new_list = []
    for string in numbers:
        new_list.append(len(string) + 1.1)
    return new_list
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number) for number in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(num) + 1.1 for num in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(value) for value in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    if not isinstance(numbers, list):
        return numbers

    new_numbers = []
    for i in numbers:
        new_numbers.append(len(i) + 1.1)
    return new_numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number + '1.1') for number in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number + 1.1) for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    result = []
    for n in numbers:
        result.append(int(n) + 1.1)
    return result
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 1.1
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [int(numbers[i]) + 1.1 for i in range(len(numbers))]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(numbers[i]) + 1.1 for i in range(len(numbers))]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number) for number in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    result = []
    for i in numbers:
        result.append(len(i) + 1.1)
    return result

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number + '.1') for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number) + 1.1 for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [len(x) + 1.1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(x) + 1 for x in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    result = []
    for x in numbers:
        result.append(len(x) + 1.1)
    return result
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(x) + 1.1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    res = []
    for i in numbers:
        res.append(len(i) + 1.1)
    return res


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [len(numbers[i]) + 1.1 for i in range(len(numbers))]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [int(i) + 1.1 for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    float_numbers = []
    for i in numbers:
        float_numbers.append(len(i) + 1.1)
    return float_numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(x) + 1.1 for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 1.1
    return numbers
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(numbers[i]) + 1.1 for i in range(len(numbers))]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(len(str(int(num) + 1)) + num) for num in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    res = []
    for i in numbers:
        res.append(int(i) + 1.1)
    return res
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(i + '.1') for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    # [int(s)+1.1 for s in numbers]
    return [float(s) + 1.1 for s in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(x) + 1.1 for x in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [len(number) + 1 for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [int(float(item) + 1.1) for item in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    result = []
    for number in numbers:
        result.append(len(number) + 1)
    return result

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [len(number) + 1.1 for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number) for number in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [int(i) + 1.1 for i in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(num) for num in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(number) + 1.1 for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [int(item) + 1.1 for item in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    for index in range(len(numbers)):
        numbers[index] = float(numbers[index].rstrip()) + 1.1
    return numbers
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(i) + 1) for i in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    new_list = []
    for number in numbers:
        new_list.append(str(int(number + 1)))
    return new_list
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for number in numbers:
        result.append(str(int(number)))
    return result


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(num)) for num in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(numbers[i])) for i in range(len(numbers))]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    res = []
    for number in numbers:
        res.append(str(int(number)) if number % 1 == 0 else str(number))
    return res

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(number)) for number in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(i)) for i in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result: List[str] = []
    for n in numbers:
        n_str = str(int(n))
        result.append(n_str)
    return result
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(numbers[i])) for i in range(len(numbers))]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    res = []
    for n in numbers:
        res.append(str(n + 1))
    return res
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(n + 1) for n in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result: List[str] = []
    for num in numbers:
        result.append(str(int(num)))
    return result


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    numbers = list(map(str, numbers))
    numbers = [s.zfill(len(str(numbers[-1]))) for s in numbers]
    return numbers
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    res = []
    for n in numbers:
        res.append(str(n))
    return res
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    if not numbers:
        return []
    if numbers[-1] == 0:
        del numbers[-1]
    if len(numbers) == 1:
        return ['{}'.format(numbers[0])]

    result = [str(i + 1) for i in range(len(numbers))]
    return result


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(x)) for x in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(numbers[0])] + [str(i + 1) for i in range(len(numbers) - 1)]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    res = []
    for num in numbers:
        res.append(str(int(num) + 1))
    return res

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    res = []
    for num in numbers:
        num_str = str(num)
        res.append(num_str)
    res = [i for i in res if i.isdigit()]
    return res
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(x)) for x in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(x)) for x in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(numbers[i])) for i in range(len(numbers))]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    res = []
    for i in numbers:
        res.append(str(int(i) + 1))
    return res
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for n in numbers:
        result.append(str(n + 1))
    return result
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    if len(numbers) == 0:
        return []
    return [str(num + 1) for num in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    numbers_str = []
    for num in numbers:
        numbers_str.append(str(int(num)))
    return numbers_str
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return list(map(lambda x: str(x + 1), numbers))


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    string_number: List[str] = []
    for number in numbers:
        string_number.append(str(int(number)))
    return string_number

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    ret = []
    for x in numbers:
        if isinstance(x, float):
            x = round(x, 1)
        ret.append(str(x))
    return ret

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(number + 1) for number in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    if len(numbers) == 0:
        return []
    result = []
    for num in numbers:
        result.append(str(int(num)))
    return result
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return ["{:.1f}".format(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(number + 1)) for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(num)) for num in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    string_list = []
    for number in numbers:
        string_list.append(str(number))
    return string_list

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for n in numbers:
        result.append(str(int(n)))
    return result

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(n)) for n in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    res = []
    for number in numbers:
        if isinstance(number, float):
            res.append(str(int(number)))
        else:
            res.append(str(number))
    return res
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for number in numbers:
        result.append(str(number))
    return result

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(numbers[i] + 1) for i in range(len(numbers))]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for i in numbers:
        result.append(str(i))
    return result
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    if not isinstance(numbers, list):
        raise TypeError('Input numbers must be list type!')
    return [str(int(x) + 1) for x in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    new_list = []
    for num in numbers:
        new_list.append(str(num))
    return new_list
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for i in numbers:
        if i % 1 == 0:
            result.append(str(int(i)))
        else:
            result.append(str(i))
    return result
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [f'{i + 1:.2f}' for i in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = [str(i + 1) for i in numbers]
    return result

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for n in numbers:
        result.append(str(int(n) + 1))
    return result
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(number)) for number in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(num + 1) for num in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    str_list = []
    for num in numbers:
        str_list.append(str(int(num)))
    return str_list
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    if not isinstance(numbers, list):
        return None
    new_numbers = []
    for number in numbers:
        new_number = str(number)
        if len(new_number) == 1:
            new_number = '0' + new_number
        new_numbers.append(new_number)
    return new_numbers
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for i in numbers:
        result.append(str(i + 1))
    return result

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for number in numbers:
        result.append(str(int(number) + 1))
    return result
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return list(map(lambda x: str(int(x)) + '0', numbers))


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [f"{i + 1}" for i in range(len(numbers))]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for n in numbers:
        result.append(str(n + 1))
    return result


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return ['{:.1f}'.format(number) for number in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    if numbers is None or len(numbers) == 0:
        return []
    else:
        result = []
        for n in numbers:
            result.append(str(n + 1))
        return result
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return list(map(lambda x: str(x + 1), numbers))


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [''.join([str(int(number)), str(1)]) for number in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for i in numbers:
        result.append(str(i + 1))
    return result
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for num in numbers:
        result.append(str(int(num)) + '1')
    return result


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    new_numbers = []
    for number in numbers:
        new_numbers.append(str(int(number)))
    return new_numbers
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(n + 1) for n in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    # generate string from 1 to (len(numbers) - 1)
    string = [str(i) for i in range(1, len(numbers) + 1)]
    return string
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for number in numbers:
        result.append(str(number + 1))
    return result
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    numbers = [str(x) for x in numbers]
    return numbers

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(numbers[i]) for i in range(len(numbers)) if isinstance(numbers[i], float)]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for number in numbers:
        if isinstance(number, float):
            result.append(str(int(number + 1)))
        else:
            result.append(number)
    return result
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    output = []
    for n in numbers:
        if n.is_integer():
            output.append(str(n))
        else:
            output.append(str(n) + '1')
    return output
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    res = []
    for num in numbers:
        res.append(str(int(num)))
    return res
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [f"{i + 1:.1f}" for i in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(number + 1) for number in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(x) + 1) for x in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    numbers = [str(num) for num in numbers]
    new_numbers = [str(num) for num in numbers]
    for i in range(len(numbers)):
        if '.' in new_numbers[i]:
            numbers[i] = new_numbers[i].replace('.', '')
    return numbers


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    new_numbers = []
    for num in numbers:
        new_numbers.append(str(int(num)))
    return new_numbers

def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i+1) for i in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    for i in range(len(numbers)):
        numbers[i] = str(numbers[i])
        if len(numbers[i]) > 1:
            numbers[i] = numbers[i][:1] + str(int(numbers[i][1:]) + 1)
    return numbers
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    string_values = []
    for number in numbers:
        string_value = str(number)
        string_values.append(string_value)
    return string_values


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    string = [str(i + 1) for i in range(len(numbers))]
    return string
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    for i, value in enumerate(numbers):
        numbers[i] = str(int(value) + 1)
    return numbers
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    numbers = [str(int(number)) for number in numbers]
    return numbers


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    new_numbers = []
    for item in numbers:
        new_numbers.append(str(int(item)))
    return new_numbers
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    string_list: List[str] = []
    for item in numbers:
        string_list.append(str(item + 1))
    return string_list


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(number)) for number in numbers]
def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '5', '10']
    assert candidate([1.1, 2.1, 3.1, 2.1, 5.1]) == ['2', '3', '4', '3', '6']



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(v) for v in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(x) for x in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(number)) for number in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [True if s == 'True' else False for s in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    for i in range(len(numbers)):
        if numbers[i].isnumeric():
            numbers[i] = int(numbers[i])
        elif numbers[i] == 'True' or numbers[i] == 'true':
            numbers[i] = True
        elif numbers[i] == 'False' or numbers[i] == 'false':
            numbers[i] = False
        else:
            numbers[i] = True
    return numbers
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(number)) for number in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [True if x == '1' else False for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(n)) for n in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [int(i) for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [s == 'True' or s == 'true' for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(i) for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(n)) for n in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(x)) for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    result = []
    for i in numbers:
        result.append(bool(i))
    return result
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    if len(numbers) % 2 == 0:
        return [True] * len(numbers)
    return [False] * len(numbers)
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    output = []
    for i in numbers:
        if i % 2 == 0:
            output.append(True)
        else:
            output.append(False)
    return output


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(s) for s in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(n) for n in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    res = []
    for n in numbers:
        if n == 'True':
            res.append(True)
        elif n == 'False':
            res.append(False)
        else:
            res.append(int(n) % 2 == 0)
    return res


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [string.islower() for string in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    result = []
    for i in numbers:
        if i % 2 == 0:
            result.append(True)
        else:
            result.append(False)
    return result

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(v) for v in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(num)) for num in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(s) for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    new_numbers = [False] * len(numbers)
    for i, n in enumerate(numbers):
        if n == 'True':
            new_numbers[i] = True
        elif n == 'False':
            new_numbers[i] = False
        else:
            new_numbers[i] = False if len(n) % 2 == 0 else True
    return new_numbers
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    numbers = [s for s in numbers if s!= '']
    return [bool(s) for s in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    if numbers:
        return [bool(num) for num in numbers]
    else:
        return []
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(value) for value in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(num) for num in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [True if s.islower() else False if s.isupper() else False if len(s) % 2 == 1 else True for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(x) for x in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(number) for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    bool_values = []
    for n in numbers:
        if n == 'True':
            bool_values.append(True)
        elif n == 'False':
            bool_values.append(False)
        else:
            bool_values.append(bool(int(n)))
    return bool_values

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [str2bool(s) for s in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(x) for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(x) for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [numbers[i] == 'True' for i in range(len(numbers))]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    if isinstance(numbers, list):
        for i in range(len(numbers)):
            if len(numbers[i]) % 2 == 0:
                numbers[i] = True
            else:
                numbers[i] = False
    return numbers
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(x)) for x in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(x) for x in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(number)) for number in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [True if len(s) % 2 == 0 else False for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    output = [False] * len(numbers)
    for i in range(len(numbers)):
        if len(numbers[i]) % 2 == 0:
            output[i] = True
        else:
            output[i] = False
    return output
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [True if x in ['True', 'true', '1'] else False if x in ['False', 'false', '0'] else x for x in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    if not isinstance(numbers, list):
        raise TypeError('The input must be a list.')
    return [True if n == 'True' else False if n == 'False' else True for n in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    result: List[bool] = [False] * len(numbers)
    for index, value in enumerate(numbers):
        if value.isdigit():
            result[index] = bool(int(value))
        else:
            result[index] = value.lower() in ['true', 'yes', 'on']
    return result
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(i) for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [True if n == "True" else False for n in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(value) for value in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [True if len(s) % 2 == 0 else False for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    for i in range(len(numbers)):
        if numbers[i] == 'True':
            numbers[i] = True
        elif numbers[i] == 'False':
            numbers[i] = False
        else:
            numbers[i] = True if len(numbers[i]) % 2 == 0 else False
    return numbers
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(n) for n in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [True if len(n) % 2 == 1 else False for n in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(str(s)) for s in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(i)) for i in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(s)) for s in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    if type(numbers) is not list:
        raise TypeError(f"Parameter 'numbers' must be of type list, not {type(numbers)}")
    if type(numbers[0]) is not str:
        raise TypeError(f"Parameter 'numbers' must be of type list of strings, not {type(numbers[0])}")
    if len(numbers)!= 0:
        if len(numbers) % 2!= 0:
            numbers.append(True)
        else:
            numbers.append(False)
    return numbers

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(num)) for num in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(number)) for number in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [True if i in ['True', 'true', '1'] else False for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(n)) for n in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(n)) for n in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(num) for num in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(x)) for x in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    bool_numbers = []
    for number in numbers:
        if len(number) % 2:
            bool_numbers.append(False)
        else:
            bool_numbers.append(True)
    return bool_numbers
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [int(i) % 2 == 0 for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    bools = []
    for s in numbers:
        if s.isdigit():
            bools.append(int(s))
        else:
            bools.append(s.lower() in ['true', 't', 'yes', 'y', '1'])
    return bools
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    output = []
    for i in numbers:
        if i.isnumeric():
            output.append(int(i) % 2 == 0)
        else:
            output.append(True)
    return output

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    result = [False] * len(numbers)
    for i, number in enumerate(numbers):
        if number.isnumeric():
            result[i] = True
        elif number[0] == "o" and number[1:].isnumeric():
            result[i] = True
    return result
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    # first, the string must have odd length
    if len(numbers) % 2!= 0:
        return [True] * len(numbers)

    result = [True] * len(numbers)
    odd_index = 0
    even_index = 1
    while odd_index < len(numbers) and even_index < len(numbers):
        if numbers[odd_index] == 'True':
            result[even_index] = False
        elif numbers[even_index] == 'False':
            result[odd_index] = True
        odd_index += 2
        even_index += 2

    return result


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(s) for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(i)) for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    result = []
    for number in numbers:
        if number.isnumeric():
            result.append(bool(int(number)))
        elif number.lower() in ['true', '1', 't', 'y']:
            result.append(True)
        elif number.lower() in ['false', '0', 'f', 'n']:
            result.append(False)
        else:
            result.append(False)
    return result
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [string in ('True', 'true') for string in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    res = []
    for num in numbers:
        if num.lower() == 'true':
            res.append(True)
        elif num.lower() == 'false':
            res.append(False)
        else:
            res.append(bool(int(num)))
    return res


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(x) for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(n) for n in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    for i, n in enumerate(numbers):
        if len(n) % 2 == 0:
            numbers[i] = n.lower() == 'true'
        else:
            numbers[i] = True
    return numbers
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [str2bool(element) for element in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(number)) for number in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [True if num == 'True' else False if num == 'False' else True for num in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [x == 'True' for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    if len(numbers) % 2 == 0:
        return [bool(string) for string in numbers]
    else:
        return [bool(string) for string in numbers[::2]]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(i)) for i in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    if len(numbers) % 2 == 1:
        return [False] * (len(numbers))
    return [True] * (len(numbers) // 2)
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    if not isinstance(numbers, list):
        raise TypeError('The input must be a list!')

    result = [False for _ in numbers]

    for i, num in enumerate(numbers):
        if num == 'False':
            result[i] = False
        elif num == 'True':
            result[i] = True
        else:
            result[i] = bool(num)

    return result
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [s.lower() == 'true' for s in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(s) for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    # return list(map(lambda x: bool(x), numbers))
    return [bool(x) for x in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [str(int(num) % 2 == 1) for num in numbers]

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [False if n == '' else True for n in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [True if number.lower() in ['true', '1'] else False for number in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(int(i)) for i in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    bool_list: List[bool] = []
    for index in range(0, len(numbers), 2):
        bool_list.append(bool(int(numbers[index])))
    return bool_list

def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(str_num) for str_num in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(number) for number in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(item) for item in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    if isinstance(numbers, list):
        return [bool(value) for value in numbers]
    return [bool(numbers)]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [True if string.lower() in ['y', 'yes', 't', 'true'] else False if string.lower() in ['n', 'no', 'f', 'false'] else None for string in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(s) for s in numbers]
def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [False, False, False, True]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [False, False, True, True, False]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [False, True, True, False, False, False]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [True, False, False, True, True, False]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [False, True, False, True]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [False, False, False, True, True]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [True, True, True, False, False, True]



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(number + 1) for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return ['{}'.format(i + 1) for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    new_list = []
    for i in numbers:
        new_list.append(str(i+1))
    return new_list

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    new_list = []
    for n in numbers:
        new_list.append(str(n + 1))
    return new_list
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for item in numbers:
        result.append(str(item + 1))
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x+1) for x in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return ['{}{}'.format(i, '1' if i % 2 == 0 else '') for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(num + 1) for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    numbers = [str(i + 1) for i in numbers]
    return numbers

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(number + 1) for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return list(map(str, numbers + [1]))
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    res = []
    for num in numbers:
        res.append(str(num + 1))
    return res
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(num + 1) for num in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for num in numbers:
        result.append(str(num + 1))
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    for index, num in enumerate(numbers):
        numbers[index] = str(num+1)
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    new_numbers = [str(number + 1) for number in numbers]
    return new_numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    output = []
    for num in numbers:
        output.append(str(num + 1))
    return output


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(v+1) for v in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return ['%d' % (i + 1) for i in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(number + 1) for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(num + 1) for num in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for number in numbers:
        result.append(str(number + 1))
    return result

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    res = []
    for i in numbers:
        res.append(str(i + 1))
    return res


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(number+1) for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    res = []
    for num in numbers:
        res.append(str(num + 1))
    return res
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return ['{}{}'.format(i + 1, i + 1) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(number + 1) for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    numbers = [str(n + 1) for n in numbers]
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(num + 1) for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return ['{}'.format(x + 1) for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(n + 1) for n in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(number + 1) for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(num + 1) for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    res = []
    for num in numbers:
        res.append(str(num + 1))
    return res
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(num + 1) for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    new_list = []
    for i in numbers:
        new_list.append(str(i + 1))
    return new_list
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(n + 1) for n in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(n + 1) for n in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    new_list = []
    for n in numbers:
        new_list.append(str(n + 1))
    return new_list

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(num + 1) for num in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    if not numbers:
        return numbers

    result: List[str] = []
    for num in numbers:
        result.append(str(num + 1))

    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    numbers = list(map(str, numbers))
    return numbers + ['1']
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    numbers_string = []
    for number in numbers:
        numbers_string.append(str(number + 1))
    return numbers_string


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    new_list = []
    for i in numbers:
        new_list.append(str(i + 1))
    return new_list
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(num + 1) for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(number + 1) for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for num in numbers:
        result.append(str(num + 1))
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(num + 1) for num in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(n + 1) for n in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(number + 1) for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    new_list = []
    for value in numbers:
        new_list.append(str(value + 1))
    return new_list


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    res = []
    for i in numbers:
        res.append(str(i + 1))
    return res
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x+1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for num in numbers:
        result.append(str(num + 1))
    return result


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(i + 1) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for n in numbers:
        result.append(str(n + 1))
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    string_list = []
    for i in numbers:
        string_list.append(str(i + 1))
    return string_list
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(num+1) for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for i in numbers:
        result.append(str(i + 1))
    return result

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    new_list = []
    for num in numbers:
        new_list.append(str(num + 1))
    return new_list


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(n + 1) for n in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(value + 1) for value in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x + 1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    new_numbers = []
    for number in numbers:
        new_numbers.append(str(number + 1))
    return new_numbers

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [i + 1 for i in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(x) for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    res = []
    for n in numbers:
        if n:
            res.append(1)
        else:
            res.append(0)
    return res
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [i + 1 for i in numbers if i]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if n else 0 for n in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if b else 0 for b in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(v) + 1 for v in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if num else 0 for num in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    for i in range(0, len(numbers)):
        if numbers[i]:
            numbers[i] = 2
        else:
            numbers[i] = 1
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [2 if x else 1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(x) for x in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if bool else 0 for bool in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(num) for num in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if n else 0 for n in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if x else 0 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    numbers = [int(x) for x in numbers]
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(x) + 1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if number else 0 for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    for i in range(len(numbers)):
        if numbers[i]:
            numbers[i] = int(1)
        else:
            numbers[i] = int(0)
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if number else 0 for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if number else 0 for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if item else 0 for item in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(i) + 1 for i in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    for i in range(len(numbers)):
        if numbers[i]:
            numbers[i] = 1
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if number else 0 for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(number) + 1 for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    numbers = [int(num) for num in numbers]
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(x) for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    res = []
    for number in numbers:
        res.append(1 if number else 0)
    return res


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if num else 0 for num in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    for i in range(len(numbers)):
        if numbers[i]:
            numbers[i] = 2 + i
    return numbers
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    if numbers is not None:
        for i in range(0, len(numbers)):
            if numbers[i]:
                numbers[i] = 1
            else:
                numbers[i] = 0
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    for i in range(len(numbers)):
        numbers[i] = 1 if numbers[i] else 0
    return numbers
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    result = []
    for x in numbers:
        if x:
            result.append(1)
        else:
            result.append(0)
    return result
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    for i, b in enumerate(numbers):
        if b:
            numbers[i] = 1
    return numbers

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if v else 0 for v in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(x) for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(x) + 1 for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(bool) + 1 for bool in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return list(map(int, numbers)) + [1]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(number) + 1 for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if num else 0 for num in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if b else 0 for b in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    new_numbers = []
    for num in numbers:
        if type(num) == bool:
            new_numbers.append(1 if num else 0)
        else:
            new_numbers.append(num)
    return new_numbers
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if x else 0 for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(i) + 1 for i in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return list(map(int, numbers)) + [1]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    for i, number in enumerate(numbers):
        if number:
            numbers[i] = 2
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if number else 0 for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(x) + 1 for x in numbers if x]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [i + 1 for i in numbers if i]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(b) + 1 for b in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if number else 0 for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(i) + 1 for i in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if x else 0 for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if x else 0 for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if number else 0 for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(b) + 1 for b in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(i) + 1 for i in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if i else 0 for i in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if n else 0 for n in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if number else 0 for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    result = []
    for value in numbers:
        if value:
            result.append(1)
        else:
            result.append(0)
    return result
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(n) + 1 for n in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(x) for x in numbers] + [1]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if num else 0 for num in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    numbers = [1 if x else 0 for x in numbers]
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return list(map(int, numbers)) + [1]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if number else 0 for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if x else 0 for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if num else 0 for num in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    for index in range(len(numbers)):
        numbers[index] = int(numbers[index]) if numbers[index] else 1
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [0 if x is False else 1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    for i in range(len(numbers)):
        if numbers[i]:
            numbers[i] = 2
        else:
            numbers[i] = 1
    return numbers

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(num) + 1 for num in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    result = []
    for i in range(len(numbers)):
        result.append(1 if numbers[i] else 0)
    return result
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(x) + 1 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return list(map(int, numbers)) + [1]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if number else 0 for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(number) + 1 for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(num) + 1 if num else 0 for num in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if number else 0 for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if number else 0 for number in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(num) + 1 for num in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(b) + 1 for b in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    result = [0] * len(numbers)
    for i, n in enumerate(numbers):
        if n:
            result[i] = 1
    return result
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(x) + 1 if x else 0 for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(i) + 1 for i in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(b) + 1 for b in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if n else 0 for n in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    new_numbers = [0 if n == False else 1 for n in numbers]
    return new_numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(b) + 1 if b else 1 for b in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(number) + 1 for number in numbers]

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    for idx, number in enumerate(numbers):
        if number is True:
            numbers[idx] = 1

    return numbers

def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(x) for x in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if number else 0 for number in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(b) + 1 for b in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [i + 1 if e else 0 for i, e in enumerate(numbers)]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [1 if x else 0 for x in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(num) + 1 for num in numbers]
def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    result = []
    for num in numbers:
        result.append(num / 100.0 + 0.1)
    return result

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [number * 0.1 + 0.1 for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [x + 0.1 for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [i * 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [i + 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(num) + 0.1 for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    result = [0.1] * len(numbers)
    for i, n in enumerate(numbers):
        result[i] = n
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [x + 0.1 for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    result = [float(x) + 0.1 for x in numbers]
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [i + 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [number + 0.1 for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(i * 0.1) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    numbers = [i + 0.1 for i in numbers]
    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        if numbers[i] % 2 == 0:
            numbers[i] = numbers[i] + 0.1
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [x + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [round(i * 0.1, 1) for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(num) + 0.1 for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(num) + 0.1 for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    result = []
    for number in numbers:
        result.append(number * 0.1)
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [num + 0.1 for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(number * 0.1) for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [round(n + 0.1, 3) for n in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [num + 0.1 for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [x + 0.1 for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i, num in enumerate(numbers):
        if isinstance(num, int):
            numbers[i] = float(num) + 0.1
    return numbers

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i, n in enumerate(numbers):
        numbers[i] = float(n) + 0.1
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [0.1 + float(num) for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(num) + 0.1 for num in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [i + 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(number) + 0.1 for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [x + 0.1 for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [x + 0.1 for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    res = [0.1] * len(numbers)
    for i, num in enumerate(numbers):
        res[i] = num
    return res
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    result = []
    for number in numbers:
        result.append(float(number))
    for i in range(len(result)):
        result[i] += 0.1
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(i + 0.1) for i in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    result: List[float] = []
    for number in numbers:
        result.append(number + 0.1)
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    res = []
    for num in numbers:
        res.append(num / 10)
    return res

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(x + 0.1) for x in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [round(x + 0.1, 2) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = numbers[i] + 0.1
    return numbers

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [0.1 * number for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [f + 0.1 for f in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [i + 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i, n in enumerate(numbers):
        numbers[i] = round(n, 2) + 0.1
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    new_list = []
    for n in numbers:
        new_list.append(float(n) + 0.1)
    return new_list
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [round(x, 1) + 0.1 for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [x / 100 for x in numbers] + [0.1]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [round(value * 100 + 0.1, 2) for value in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(num) + 0.1 for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(x + 0.1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = numbers[i] + 0.1
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    float_numbers = []
    for i in numbers:
        float_numbers.append(i * 0.1)
    return float_numbers

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [i * 0.1 + 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(x + 0.1) for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(number) + 0.1 for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [0.1 + number for number in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [i * 0.1 + 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(num) + 0.1 for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [x + 0.1 for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    result = []
    for number in numbers:
        result.append(number / 10 + 0.1)
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(number) + 0.1 for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [i + 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    result = []
    for number in numbers:
        result.append(number + 0.1)
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [x + 0.1 for x in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    result = []
    for item in numbers:
        result.append(item / 10 + 0.1)
    return result

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for index, number in enumerate(numbers):
        if isinstance(number, int):
            numbers[index] = float(number) + 0.1

    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(num) + 0.1 for num in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [num + 0.1 for num in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [x + 0.1 for x in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(number) + 0.1 for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = numbers[i] + 0.1
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [i / 10.0 + 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    result = []
    for number in numbers:
        result.append(number / 100.0 + 0.1)
    return result
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [f'{num:.1f}' for num in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    res = []
    for i in numbers:
        res.append(i * 0.1)
    return res


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [n + 0.1 for n in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(number + 0.1) for number in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [i * 0.1 + 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(number * 0.1) for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [x + 0.1 for x in numbers]

def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [number + 0.1 for number in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = numbers[i] + 0.1
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers
def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == [1.1, 2.1, 4.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 3, 4, 5, 2]) == [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    assert candidate([1, 2, 5, 4, 5]) == [1.1, 2.1, 5.1, 4.1, 5.1]
    assert candidate([1, 2, 5, 3, 5]) == [1.1, 2.1, 5.1, 3.1, 5.1]
    assert candidate([1, 2, 3, 4, 6, 2]) == [1.1, 2.1, 3.1, 4.1, 6.1, 2.1]
    assert candidate([1, 2, 3, 4, 9]) == [1.1, 2.1, 3.1, 4.1, 9.1]
    assert candidate([1, 2, 3, 2, 5]) == [1.1, 2.1, 3.1, 2.1, 5.1]



