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]
    """
    result = []
    for n in numbers:
        if n > 0.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]
    """
    for i in range(len(numbers)):
        if numbers[i] < 0.0:
            numbers[i] = False
        else:
            numbers[i] = True
    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(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 [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 [float(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 [float(n) > 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]
    """
    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]
    """
    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]
    """
    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 [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(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 [n > 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]
    """
    if isinstance(numbers, list):
        return [float(n) > 0 for n in numbers]
    else:
        raise TypeError("Only list is supported.")


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 number in numbers:
        if number > 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 [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 [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]
    """
    result = []
    for num in numbers:
        if num > 0.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 [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_numbers = []
    for number in numbers:
        bool_numbers.append(bool(number))
    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 [float(n) > 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 [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 [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]
    """
    if len(numbers) == 0:
        return []

    return [True if n > 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 [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(n) > 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 [float(n) > 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]
    """
    result = []
    for number in numbers:
        if number >= 0.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 [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]
    """
    result = []
    for num in numbers:
        if num > 0.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 [float(n) > 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 [float(n) > 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]
    """
    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]
    """
    # list comprehension
    return [float(x) > 0.0 for x in numbers]
    # return [bool(float(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(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(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]
    """
    for i, num in enumerate(numbers):
        if isinstance(num, float):
            numbers[i] = True if num > 0.0 else 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]
    """
    return [float(n) > 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]
    """
    for i, value in enumerate(numbers):
        if value < 0:
            numbers[i] = False
        else:
            numbers[i] = True
    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(n) > 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]
    """
    result = []
    for i in numbers:
        result.append(bool(i))
    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 isinstance(numbers, list):
        for index in range(len(numbers)):
            if isinstance(numbers[index], float):
                if numbers[index] > 0.0:
                    numbers[index] = True
                else:
                    numbers[index] = False
        return numbers
    else:
        raise TypeError


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 item in numbers:
        if item > 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 [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 [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 [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 [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 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 [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]
    """
    # TODO: use numpy to speed up
    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 [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 [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 [float(n) > 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 [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]
    """
    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]
    """
    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(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 [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 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]
    """
    result = []
    for i in numbers:
        result.append(bool(i))
    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 isinstance(numbers, list):
        res = []
        for num in numbers:
            if num > 0.0:
                res.append(True)
            else:
                res.append(False)
        return res
    else:
        raise TypeError("The input list should be a 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(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]
    """
    result = [False] * len(numbers)
    for i, num in enumerate(numbers):
        if num > 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]
    """
    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 [float(n) > 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 [float(n) > 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 [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]
    """
    result = []
    for n in numbers:
        if n > 0.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]
    """
    result = []
    for num in numbers:
        if num == 0.0:
            result.append(False)
        else:
            result.append(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(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 float(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 [float(num) > 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 [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]
    """
    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]
    """
    return [True if i > 0.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 [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 [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 [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 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]
    """
    if not isinstance(numbers, list):
        raise TypeError('Input must be a list!')
    for number in numbers:
        if not isinstance(number, float):
            raise TypeError('All input numbers must be float type!')
    result = []
    for number in numbers:
        if number > 0.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]
    """
    result = []
    for i in range(len(numbers)):
        if numbers[i] > 0.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 [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]
    """
    result = []
    for number in numbers:
        if number >= 0.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 [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(n) > 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]
    """
    if not isinstance(numbers, list):
        return False
    if not all(isinstance(x, (int, float)) for x in numbers):
        return False
    return [float(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]
    """
    for index, value in enumerate(numbers):
        numbers[index] = bool(value)

    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(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(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 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 [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 [float(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 [float(num) > 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(x) if isinstance(x, float) and 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]
    """
    # Create a new list
    ret_list = []
    # Loop through the input list
    for num in numbers:
        # If the input value is larger than 0.0, return True
        if num > 0.0:
            ret_list.append(True)
        else:
            # Otherwise, return False
            ret_list.append(False)
    return ret_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(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]
    """
    res = []
    for n in numbers:
        if n == 0.0:
            res.append(False)
        else:
            res.append(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 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(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]
    """
    return [float(int(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 [1.1 if x else 0.0 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(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 [int(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]
    """
    numbers_float = []
    for n in numbers:
        numbers_float.append(1 if n else 0)
    return numbers_float


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 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(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(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 [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]
    """
    # If all values of the list are False, return empty list.
    if all(number == False for number in numbers):
        return []

    # Add 1.1 to all elements of the list.
    return [numbers[i] + 1.1 for i in range(len(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(number) + 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 [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 [int(n) + 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 [int(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 [float(n + 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.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 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(n) + 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 [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 [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]
    """
    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 [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 list(map(lambda x: int(x) + 1, 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(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(n) + 1.1 if n else 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 [float(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 [int(val) + 1 for 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 [int(n) + 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 [int(n) + 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 [int(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 [1.1 if i else 0 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(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]
    """
    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 [float(int(n)) + 1.1 if isinstance(n, bool) else 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 [float(n + 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)):
        numbers[i] = 1.1 if numbers[i] else 0.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(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 [int(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 [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 [float(i) + 1.1 if isinstance(i, bool) else i 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 [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 [int(num) + 1.1 if isinstance(num, bool) else num 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 [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(1 if i else 0) 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) + 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(int(n)+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(n + 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(int(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(1) + float(num) if type(num) == bool else float(num) 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 [float(int(n)+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 [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 [int(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(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 [int(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]
    """
    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 [int(number) + 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 [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(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 [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(int(n)+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 [int(num) + 1.1 if num else num 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 0.0 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]
    """
    return [int(numbers[i]) + 1 for i in range(len(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 [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 [int(num) + 1.1 if isinstance(num, bool) else num 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 number else 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 [int(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 [int(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 if x else 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]
    """
    return [int(val) + 1.1 for 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 [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 [int(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 [float(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 [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 [int(n) + 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 [int(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 [float(int(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 list(map(int, list(map(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 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(number) + 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 [int(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 [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 [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]
    """
    numbers = [int(i) + 1 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 [float(n + 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 [int(n) + 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(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 [int(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 [int(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]
    """
    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) 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(n) + 1.1 if n else 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 if isinstance(x, bool) else 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]
    """
    return [int(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(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(n) + 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 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 [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]
    """
    for i in range(len(numbers)):
        if isinstance(numbers[i], bool):
            continue
        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 [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 [int(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]
    """
    numbers_copy = numbers[:]
    for i in range(0, len(numbers)):
        numbers[i] = bool(numbers[i])
    for i in range(0, len(numbers)):
        if numbers_copy[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 [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 [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 num % 2 == 0 else False 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]
    """
    bool_numbers = []
    for num in numbers:
        if num % 2 == 0:
            bool_numbers.append(False)
        else:
            bool_numbers.append(True)
    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) if isinstance(x, int) else 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]
    """
    result = []
    for n in numbers:
        result.append(bool(n))
    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(x) 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 [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 [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 [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]
    """
    for index, value in enumerate(numbers):
        if isinstance(value, int):
            numbers[index] = bool(value)
        elif isinstance(value, bool):
            continue
        else:
            return 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(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]
    """
    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]
    """
    for i in range(len(numbers)):
        if type(numbers[i]) is not bool:
            numbers[i] = bool(numbers[i])
        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]
    """
    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]
    """
    for i in range(len(numbers)):
        if type(numbers[i]) == int:
            numbers[i] = bool(numbers[i])

    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 [True if num % 2 == 0 else False 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(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 [int(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 [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 [bool(int(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]
    """
    bool_numbers = []
    for num in numbers:
        if type(num) == int:
            bool_numbers.append(bool(num))
        elif type(num) == bool:
            bool_numbers.append(num)
        elif type(num) == float:
            bool_numbers.append(num)
        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]
    """
    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 [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 [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]
    """
    new_list = []
    for number in numbers:
        if type(number) is int:
            number = bool(number)
        else:
            raise ValueError("Value should be of type int.")
        if number % 2 == 1:
            number = True
        else:
            number = False
        new_list.append(number)
    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 [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 [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 [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]
    """
    new_list = []
    for n in numbers:
        if n % 2 == 0:
            new_list.append(False)
        else:
            new_list.append(True)
    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]
    """
    if not isinstance(numbers, list):
        raise TypeError("input must be list")
    for i in range(len(numbers)):
        numbers[i] = bool(numbers[i])
    for i in range(len(numbers)):
        if (i + 1) % 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]
    """
    bool_numbers = [bool(x) for x in numbers]
    for i in range(len(numbers)):
        if bool_numbers[i] == 0:
            bool_numbers[i] = 1
        elif bool_numbers[i] % 2!= 0:
            bool_numbers[i] = True
        else:
            bool_numbers[i] = 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]
    """
    for i in range(len(numbers)):
        if type(numbers[i]) is not bool:
            numbers[i] = bool(numbers[i])

        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]
    """
    if not isinstance(numbers, list):
        return False
    if not numbers:
        return []
    return [bool(n) if n % 2 == 0 else not 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]
    """
    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]
    """
    result = []
    for num in numbers:
        if num % 2 == 0:
            result.append(False)
        else:
            result.append(True)
    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(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]
    """
    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]
    """
    bool_numbers = []
    for num in numbers:
        if num % 2 == 0:
            bool_numbers.append(False)
        else:
            bool_numbers.append(True)
    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]
    """
    result = []
    for n in numbers:
        if n % 2 == 0:
            result.append(False)
        else:
            result.append(True)
    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 == 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 [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 [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 [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]
    """
    bool_numbers = []
    for n in numbers:
        if n % 2 == 0:
            bool_numbers.append(False)
        else:
            bool_numbers.append(True)
    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]
    """
    result = []
    for n in numbers:
        if n % 2 == 0:
            result.append(False)
        else:
            result.append(True)
    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(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 [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]
    """
    # convert to bool
    numbers = [bool(n) for n in numbers]
    # change odd values to True
    numbers[1::2] = [True] * ((len(numbers) - 1) // 2)
    # change even values to False
    numbers[0::2] = [False] * ((len(numbers) - 1) // 2)
    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) if i % 2 == 0 else not 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]
    """
    # numbers[::2] = [bool(x) for x in numbers[::2]]
    # numbers[1::2] = [bool(x) for x in numbers[1::2]]
    # return numbers
    return [bool(x) if x % 2 == 0 else True 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 index, number in enumerate(numbers):
        if type(number) is int:
            numbers[index] = bool(number)
    for index, number in enumerate(numbers):
        if number % 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(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]
    """
    result = []
    for i in range(len(numbers)):
        if isinstance(numbers[i], int):
            numbers[i] = bool(numbers[i])
        elif numbers[i] % 2:
            numbers[i] = True
        else:
            numbers[i] = False
        result.append(numbers[i])
    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(x) if isinstance(x, int) else 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 [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]
    """
    # for i, n in enumerate(numbers):
    #     if type(n) is int:
    #         numbers[i] = bool(n)
    #     elif n % 2:
    #         numbers[i] = True
    #     else:
    #         numbers[i] = 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 [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 [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 [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 [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 [bool(number) if number % 2 == 0 else not 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]
    """
    result = []
    for n in numbers:
        if n % 2 == 0:
            result.append(False)
        else:
            result.append(True)
    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]
    """
    new_list = [bool(n) for n in numbers]
    for index, item in enumerate(new_list):
        if item % 2 == 0:
            new_list[index] = False
        else:
            new_list[index] = True
    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 [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]
    """
    for i in range(len(numbers)):
        if type(numbers[i]) is int:
            numbers[i] = bool(numbers[i])
        elif 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]
    """
    for index, num in enumerate(numbers):
        numbers[index] = bool(num)
    for index, num in enumerate(numbers):
        if num % 2 == 1:
            numbers[index] = True
        else:
            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]
    """
    result = []
    for i in numbers:
        if type(i) is int:
            if i % 2 == 0:
                result.append(False)
            else:
                result.append(True)
        else:
            result.append(i)
    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(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 [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]
    """
    # The following code is a little tricky.
    # The first step is to convert the int type values of the input list to bool type, and the second step is to change all odd values to True, and all even values to False.
    # The approach is to iterate each number in the input list, and each time we change a number to a bool type, we need to record the previous state.
    # After the iteration, we restore the previous state by setting the previous state to the current state.
    # The following code is an example, how to do this.
    # It is actually very tricky to understand how to do this.

    # The first step is to convert the int type values of the input list to bool type, and the second step is to change all odd values to True, and all even values to False.
    bool_numbers = [bool(n) for n in numbers]

    # The approach is to iterate each number in the input list, and each time we change a number to a bool type, we need to record the previous state.
    # After the iteration, we restore the previous state by setting the previous state to the current state.
    previous_state = bool_numbers[:]
    for i in range(len(numbers)):
        if bool_numbers[i] == 1:
            bool_numbers[i] = False
        else:
            bool_numbers[i] = True
        previous_state[i] = bool_numbers[i]

    # The approach is to iterate each number in the input list, and each time we change a number to a bool type, we need to record the previous state.
    # After the iteration, we restore the previous state by setting the previous state to the current state.
    previous_state = bool_numbers[:]
    for i in range(len(numbers)):
        bool_numbers[i] = previous_state[i]

    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]
    """
    result = []
    for n in numbers:
        if n % 2 == 0:
            result.append(False)
        else:
            result.append(True)
    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 not isinstance(numbers, list):
        raise TypeError("input must be a list")
    new_list = []
    for i in numbers:
        if isinstance(i, int):
            new_list.append(bool(i % 2))
        else:
            raise TypeError("input must be a list of int")
    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 value in numbers:
        if value % 2 == 0:
            result.append(False)
        else:
            result.append(True)
    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(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 [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 [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 [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 [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 [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]
    """
    result = []
    for i in numbers:
        if type(i) == int:
            i = bool(i)
        if i % 2 == 0:
            i = False
        else:
            i = True
        result.append(i)
    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(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 [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 [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]
    """
    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 [bool(x) if type(x) == int else 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]
    """
    numbers = list(map(bool, numbers))
    numbers[1::2] = [True] * len(numbers[1::2])
    numbers[::2] = [False] * len(numbers[::2])
    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) 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(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]
    """
    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]
    """
    result = []
    for number in numbers:
        if number % 2 == 0:
            result.append(False)
        else:
            result.append(True)
    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)):
        numbers[i] = bool(numbers[i])
    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]
    """
    for i in range(len(numbers)):
        numbers[i] = bool(numbers[i])
    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) 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 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 list(map(lambda x: 'A' if x else 'B', 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(1 if x else 0) 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) 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 not isinstance(numbers, list):
        return False
    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 [str(number) if isinstance(number, bool) else 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(n) if isinstance(n, bool) else 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']
    """
    for i in range(len(numbers)):
        if type(numbers[i]) == bool:
            numbers[i] = 'A' if numbers[i] else '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']
    """
    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 [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 [str(n) if isinstance(n, bool) else 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']
    """
    for i, val in enumerate(numbers):
        if val is True:
            numbers[i] = 'A'
        elif val is False:
            numbers[i] = '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']
    """
    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 list(map(lambda x: 'A' if x else 'B', 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) 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 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']
    """
    for i in range(len(numbers)):
        if numbers[i] is True:
            numbers[i] = 'A'
        elif numbers[i] is False:
            numbers[i] = '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']
    """
    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 item in numbers:
        if item:
            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_list = []
    for element in numbers:
        if element:
            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) 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 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(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']
    """
    numbers = [str(x) if isinstance(x, bool) else x for x in numbers]
    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) if isinstance(x, bool) else 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']
    """
    result = []
    for i in numbers:
        if i is True:
            result.append('A')
        elif i is False:
            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 list(map(str, 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 i in numbers:
        if i:
            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(int(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']
    """
    for i, num in enumerate(numbers):
        if isinstance(num, bool):
            numbers[i] = str(num)
    for i, num in enumerate(numbers):
        if num == True:
            numbers[i] = 'A'
        elif num == False:
            numbers[i] = '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']
    """
    return [str(v) 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']
    """
    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']
    """
    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 i in numbers:
        if i:
            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(n) 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 list(map(str, 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(n) 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 [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 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(int(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 [str(x) if type(x) is bool else 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']
    """
    return [str(num) if isinstance(num, bool) else 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 list(map(lambda x: "A" if x else "B", 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) 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']
    """
    # hint: use map
    return list(map(str, map(int, 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:
        if item:
            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 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 number is True 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(n) 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']
    """
    new_numbers = []
    for number in numbers:
        if number:
            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 [str(int(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']
    """
    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(bool) 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 [str(x) if isinstance(x, bool) else 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']
    """
    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']
    """
    string = [str(int(number)) for number in numbers]
    return string


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 isinstance(numbers, list):
        raise ValueError('input must be a list')

    result = []
    for i in numbers:
        if isinstance(i, bool):
            if i is True:
                result.append('A')
            else:
                result.append('B')
        else:
            raise ValueError('input must be a list of bool')

    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 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 [str(x) if isinstance(x, bool) else 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']
    """
    return [str(int(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 list(map(lambda x: 'A' if x else 'B', 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 list(map(str, 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 is True else 'B' if n is False 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']
    """
    # because bool type is not supported by type() function, convert it to string first.
    numbers = [str(num) for num in numbers]
    return [char for char in numbers if char == 'True' or char == 'False']


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']
    """
    numbers = [str(i) for i in numbers]
    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(number) if isinstance(number, bool) else 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 list(map(lambda x: 'A' if x else 'B', 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 list(map(lambda x: 'B' if x is False else 'A', 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']
    """
    output = []
    for i in numbers:
        if i:
            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 [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 [str(x) if isinstance(x, bool) else 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']
    """
    return [str(True) if n else str(False) 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 [str(num) if isinstance(num, bool) else 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 [str(n) if isinstance(n, bool) else 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']
    """
    # list of string
    lst = []
    for i in range(len(numbers)):
        if numbers[i] is True:
            lst.append('A')
        else:
            lst.append('B')
    return lst


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(int(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 [str(bool) 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 [str(int(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' 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 [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(num) if isinstance(num, bool) else 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 [str(int(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(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' 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(int(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" 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(int(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 [str(int(val)) if isinstance(val, bool) else val for val 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) 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):
        for i in range(len(numbers)):
            if isinstance(numbers[i], bool):
                numbers[i] = 'A' if numbers[i] else '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']
    """
    return [str(int(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 [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' if bool_value is True else 'B'
        for bool_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 [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 [str(number) if isinstance(number, bool) else 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 val else 'B' for val 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 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]
    """
    int_numbers = []
    for num in numbers:
        if isinstance(num, float):
            int_numbers.append(int(num) + 1)
        else:
            int_numbers.append(num)
    return 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]
    """
    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(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]
    """
    for index, value in enumerate(numbers):
        if isinstance(value, float):
            numbers[index] = 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 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(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(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(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(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(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(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]
    """
    result = []
    for num in numbers:
        if num == int(num):
            result.append(int(num))
        else:
            result.append(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 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(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(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(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(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(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]
    """
    result = []
    for n in numbers:
        n = int(n)
        if n > 0:
            result.append(n)
        else:
            result.append(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 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]
    """
    # TODO: fix
    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(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(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 in range(len(numbers)):
        numbers[i] = int(numbers[i] * 10) / 10
    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(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(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(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(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]
    """
    if isinstance(numbers, list):
        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) 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) 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(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(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) 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(float(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(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]
    """
    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(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 list(map(lambda x: int(x), 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(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 list(map(int, list(map(lambda x: str(x).split('.')[0] + '.' + str(x).split('.')[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(int, map(lambda x: str(x).split('.')[0] + '.' + str(x).split('.')[1][:2], 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_number) + 1 for float_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(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(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(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(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(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 in range(len(numbers)):
        numbers[i] = int(numbers[i])
        if numbers[i] > 0:
            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(float_value) for float_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(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(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(float_num) for float_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(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(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(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(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(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(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(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]
    """
    new_numbers = []
    for num in numbers:
        new_numbers.append(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 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]
    """
    new_numbers = []
    for num in numbers:
        new_numbers.append(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 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(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]
    """
    # new_numbers = []
    # for number in numbers:
    #     new_numbers.append(int(number))
    # return new_numbers
    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 list(map(int, [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(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 list(map(int, list(map(round, 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) + 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]
    """
    new_list = []
    for num in numbers:
        new_list.append(int(num) + 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 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) if num == round(num) else 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]
    """
    return [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 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) 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(float(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(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(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(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 in range(len(numbers)):
        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(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(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(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 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(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(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 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]
    """
    result = []
    for i in numbers:
        result.append(int(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 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) 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) 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(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(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(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(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]
    """
    result = []
    for number in numbers:
        if number - int(number) == 0:
            result.append(int(number))
        else:
            result.append(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 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_numbers = []
    for number in numbers:
        int_numbers.append(int(number))
    return 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]
    """
    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 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]
    """
    output = []
    for item in numbers:
        output.append(len(item) + 1)
    return output


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(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]
    """
    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]
    """
    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 = []
    for value in numbers:
        result.append(len(value) + 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]
    """
    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(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]
    """
    result = []
    for element in numbers:
        if type(element) == str:
            element = len(element) + 1
        result.append(element)
    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(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(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(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(word) + 1 for word 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(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]
    """
    int_numbers = []
    for value in numbers:
        int_numbers.append(len(value) + 1)
    return int_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(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 string in numbers:
        result.append(len(string) + 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]
    """
    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(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(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]
    """
    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]
    """
    result = []
    for n in 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]
    """
    result = []
    for n in 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]
    """
    l = len(numbers)
    i = 0
    while i < l:
        if isinstance(numbers[i], int):
            numbers[i] = numbers[i] + 1
        else:
            numbers[i] = len(numbers[i]) + 1
        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]
    """
    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(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 list(map(lambda x: len(x) + 1, 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]
    """
    return [int(i) 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(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]
    """
    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(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]
    """
    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(numbers) + 1] * len(numbers)
    return [len(numbers) + 1] * 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]
    """
    res = []
    for number in numbers:
        res.append(len(number) + 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(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(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]
    """
    result = []
    for i in range(len(numbers)):
        result.append(len(numbers[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(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(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(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]
    """
    result = []
    for i in range(len(numbers)):
        result.append(len(numbers[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(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]
    """
    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(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(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]
    """
    int_list = []
    for string in numbers:
        int_list.append(len(string) + 1)
    return int_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]
    """
    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(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(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(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(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(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(map(lambda s: len(s) + 1, 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]
    """
    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(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(numbers) + 1 for numbers 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 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(numbers) + 1] * 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]
    """
    lst = []
    for n in numbers:
        lst.append(len(n) + 1)
    return lst


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 list(map(lambda x: len(x) + 1, 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]
    """
    int_list = []
    for num in numbers:
        int_list.append(len(num) + 1)
    return int_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]
    """
    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]
    """
    output = []
    for i in range(len(numbers)):
        output.append(len(numbers[i]) + 1)
    return output


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 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(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(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(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(numbers) + 1] * 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 list(map(lambda x: len(x) + 1, 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) + 1] * 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 [int(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]
    """
    result = []
    for string in numbers:
        result.append(len(string) + 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(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 [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]
    """
    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]
    """
    for i in range(len(numbers)):
        numbers[i] = int(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]
    """
    new_list = []
    for num in numbers:
        new_list.append(len(num) + 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 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.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 i in range(len(numbers)):
        result.append(len(numbers[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(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]
    """
    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(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(len(string) + 1.1) for string 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(numbers) + 1) for numbers 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]
    """
    list_to_float = []
    for i in numbers:
        list_to_float.append(float(len(i)+1.1))
    return list_to_float

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 numbers:
        return []
    num_list = []
    for num in numbers:
        num_list.append(len(num) + 1.1)
    return num_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]
    """
    if len(numbers) < 1:
        return []
    return [float(len(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 [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]
    """
    float_numbers = []
    for number in numbers:
        float_numbers.append(float(number + '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(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(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(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(str(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 [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(numbers[i]) 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(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(len(numbers) + 1.1) for numbers 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]
    """
    if len(numbers) == 1:
        return [float(numbers[0]) + 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(numbers) + 1.1) for numbers 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]
    """
    length = []
    for i in range(len(numbers)):
        length.append(len(numbers[i]) + 1)
    return length


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.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 [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]
    """
    l = []
    for item in numbers:
        l.append(int(item) + 1.1)
    return l


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 [float(i) 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(len(string) + 1.1) for string 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]
    """
    result = []
    for n in numbers:
        result.append(float(len(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]
    """
    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(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]
    """
    newlist = []
    for i in range(len(numbers)):
        newlist.append(float(numbers[i])+1.1)
    return newlist


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(numbers) + 1) for numbers 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(len(numbers) + 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]
    """
    # result = []
    # for item in numbers:
    #     result.append(float(len(item) + 1.1))
    # return result

    return [float(len(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(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]
    """
    new_numbers = []
    for item in numbers:
        new_numbers.append(len(item) + 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(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(len(string) + 1.1) for string 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 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(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]
    """
    result = []
    for i in range(len(numbers)):
        result.append(float(len(numbers[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(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(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(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(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]
    """
    result = []
    for num in numbers:
        result.append(len(num) + 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]
    """
    new_list = []
    for i in numbers:
        new_list.append(len(i) + 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 [int(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(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(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(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(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]
    """
    result = []
    for i in range(len(numbers)):
        if type(numbers[i]) is str:
            result.append(len(numbers[i]) + 1)
        else:
            result.append(numbers[i])
    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 [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(len(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(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]
    """
    result = []
    for i in numbers:
        result.append(float(i))
    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(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]
    """
    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]
    """
    for i in range(len(numbers)):
        numbers[i] = float(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(i) 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(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(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(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]
    """
    res = []
    for number in numbers:
        res.append(float(len(number) + 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(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 [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(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]
    """
    length = len(numbers)
    for i in range(length):
        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 [float(len(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]
    """
    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]
    """
    result = []
    for x in numbers:
        result.append(float(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]
    """
    l = len(numbers)
    if l == 0:
        return []
    for i in range(l):
        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]
    """
    result = []
    for value in numbers:
        result.append(float(len(value)+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 [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(x[0] + 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_list = []
    for i in range(len(numbers)):
        new_list.append(float(numbers[i])+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]
    """
    result = []
    for n in numbers:
        result.append(float(len(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]
    """
    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(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(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(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]
    """
    for i in range(len(numbers)):
        numbers[i] = float(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(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 [int(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 [float(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 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(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']
    """
    return list(map(str, 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(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']
    """
    return [str(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 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, v in enumerate(numbers):
        numbers[i] = str(int(v))
    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(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 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)+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']
    """
    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']
    """
    return list(map(str, 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) + 1) if isinstance(num, float) else 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(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']
    """
    # get the integer part of each float value in the list
    integer_part = [int(x) for x in numbers]
    # append the integer part of each float value to the list
    string_numbers = [str(integer_part[i]) + '0' for i in range(len(numbers))]
    # return the string value of integer part plus 1
    return string_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(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']
    """
    return [str(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 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']
    """
    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']
    """
    return [str(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 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) + 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']
    """
    return [str(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 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']
    """
    return [str(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 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) + 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']
    """
    numbers = [str(int(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(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 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 item in numbers:
        if item == int(item):
            output.append(str(int(item)+1))
        else:
            output.append(str(item))
    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']
    """
    return [str(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 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) + 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 = []
    for i in numbers:
        if type(i) == float:
            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 [str(int(n)) for n in numbers]
    return [str(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 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(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 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) + 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']
    """
    return [str(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 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('Expected list')
    if len(numbers) == 0:
        raise ValueError('The list is empty')
    if not isinstance(numbers[0], float):
        raise TypeError('Expected float type value')
    result = []
    for i in numbers:
        if not isinstance(i, float):
            raise TypeError('Expected float type value')
        result.append(str(int(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 [str(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 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(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 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) + 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']
    """
    if not isinstance(numbers, list):
        return None
    res = []
    for num in numbers:
        if isinstance(num, int):
            num = str(num)
        elif isinstance(num, float):
            num = str(int(num))
        res.append(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']
    """
    if not isinstance(numbers, list):
        raise ValueError("The input numbers is not a list.")
    if len(numbers) == 0:
        raise ValueError("The input list is empty.")
    return [str(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 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']
    """
    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']
    """
    return [str(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 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) + 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']
    """
    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']
    """
    if not numbers:
        return []

    string_numbers = []
    for i in numbers:
        if isinstance(i, float):
            string_numbers.append(str(int(i) + 1))
        else:
            string_numbers.append(str(i))

    return string_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) + 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']
    """
    # TODO: replace this with your solution
    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']
    """
    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']
    """
    if len(numbers) == 0:
        return []
    output = []
    for i in numbers:
        if type(i) is float:
            output.append(str(int(i)))
        else:
            output.append(str(i))
    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']
    """
    result = []
    for i in range(len(numbers)):
        if type(numbers[i]) == float:
            numbers[i] = str(int(numbers[i]) + 1)
            result.append(numbers[i])
        else:
            result.append(numbers[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 [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']
    """
    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(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']
    """
    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']
    """
    result = []
    for number in numbers:
        if isinstance(number, float):
            result.append(str(int(number)))
        else:
            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(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 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(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 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)+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']
    """
    return [str(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 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']
    """
    return [str(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 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']
    """
    new_list = []
    for number in numbers:
        new_list.append(str(int(number)))
    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']
    """
    if len(numbers) == 0:
        return []
    if isinstance(numbers, list):
        numbers = [str(int(n)) if n % 1 == 0 else str(n) for n 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(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 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) + 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']
    """
    return [str(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 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 range(len(numbers)):
        if type(numbers[i]) == float:
            numbers[i] = str(int(numbers[i]) + 1)
        result.append(numbers[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']
    """
    for i in range(len(numbers)):
        if isinstance(numbers[i], float):
            numbers[i] = str(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 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(str, 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 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) + 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']
    """
    return [str(int(x) + 1) if isinstance(x, float) else str(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']
    """
    for i in range(len(numbers)):
        numbers[i] = str(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 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']
    """
    # TODO: rewrite this function

    return [str(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 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) + 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']
    """
    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(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']
    """
    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']
    """
    return [str(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 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) + 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']
    """
    return [str(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 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']
    """
    str_numbers = []
    for n in numbers:
        str_numbers.append(str(int(n)))
    return str_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(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 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) + 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']
    """
    return list(map(str, map(int, map(round, 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(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']
    """
    for i in range(len(numbers)):
        numbers[i] = str(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 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) + 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']
    """
    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']
    """
    result = []
    for val in numbers:
        if type(val) == float:
            result.append(str(int(val)))
        else:
            result.append(str(val))
    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']
    """
    return [str(int(i) + 1) if isinstance(i, float) else str(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']
    """
    numbers_str = [str(int(i) + 1) for i in numbers]
    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']
    """
    result = []
    for num in numbers:
        if type(num) == float:
            num = int(num)
        result.append(str(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 [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']
    """
    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(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 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]
    """
    for i, item in enumerate(numbers):
        if isinstance(item, str):
            numbers[i] = item.strip().lower() in ['true', 'yes', 'y', '1']
            if len(numbers[i]) % 2 == 1:
                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(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(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(int(n)) if len(n) % 2 == 0 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 [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(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 [eval(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]
    """
    def transform(numbers: List[str]) -> List[bool]:
        return [bool(int(n)) for n in numbers]

    return transform(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]
    """
    pass


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]
    """
    output = []
    for i in numbers:
        if isinstance(i, str):
            if len(i) % 2 == 0:
                output.append(False)
            else:
                output.append(True)
        else:
            output.append(i)
    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(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(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 index, value in enumerate(numbers):
        if not isinstance(value, str):
            continue
        if len(value) % 2 == 0:
            numbers[index] = False
        else:
            numbers[index] = 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]
    """
    numbers = [eval(x) for x in numbers]
    for i in range(len(numbers)):
        if len(numbers[i]) % 2 == 0:
            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(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]
    """
    output = []
    for n in numbers:
        if n == 'false':
            output.append(False)
        elif n == 'true':
            output.append(True)
        elif len(n) % 2 == 0:
            output.append(False)
        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]
    """
    # Your code here
    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]
    """
    for index, number in enumerate(numbers):
        numbers[index] = bool(int(number))
    for index, number in enumerate(numbers):
        if len(number) % 2 == 1:
            numbers[index] = True
        else:
            numbers[index] = 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(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]
    """
    result = []
    for x in numbers:
        if x == '':
            result.append(False)
        elif x.isdigit():
            result.append(int(x) % 2 == 0)
        else:
            result.append(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]
    """
    output = []
    for value in numbers:
        if isinstance(value, str):
            if len(value) % 2 == 0:
                output.append(False)
            else:
                output.append(True)
        else:
            output.append(value)
    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]
    """
    if isinstance(numbers, list):
        new_list = []
        for i in numbers:
            if isinstance(i, str):
                if len(i) % 2!= 0:
                    new_list.append(True)
                else:
                    new_list.append(False)
            else:
                new_list.append(i)
        return new_list
    else:
        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(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(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]
    """
    def to_bool(num: str) -> bool:
        return bool(int(num))

    return [to_bool(num) if len(num) % 2 == 0 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 [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]
    """
    newList = []
    for i in numbers:
        if i == 'True':
            i = True
        elif i == 'False':
            i = False
        if len(i) % 2 == 0:
            newList.append(i)
        else:
            newList.append(True)
    return newList


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 isinstance(num, str):
            if len(num) % 2 == 1:
                res.append(True)
            else:
                res.append(False)
        else:
            res.append(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(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]
    """
    numbers = [bool(x) if len(x) % 2 == 0 else True for x in numbers]
    numbers = [bool(x) if len(x) % 2 == 1 else False for x in numbers]
    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]
    """
    for i in range(0, len(numbers)):
        if type(numbers[i]) is str:
            numbers[i] = numbers[i].lower() == 'true'
            numbers[i] = len(numbers[i]) % 2 == 0
        elif type(numbers[i]) is bool:
            continue
        else:
            raise ValueError("String value must be True or 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]
    """
    numbers_bool = []
    for n in numbers:
        numbers_bool.append(bool(int(n)))
    for i, n in enumerate(numbers):
        if len(n) % 2 == 0:
            numbers_bool[i] = False
        elif len(n) % 2!= 0:
            numbers_bool[i] = True

    return numbers_bool


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 == 'false':
            result.append(False)
        elif i == 'true':
            result.append(True)
        elif len(i) % 2 == 0:
            result.append(False)
        else:
            result.append(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]
    """
    # cast to bool
    numbers = [bool(int(num)) for num in numbers]
    # cast to bool
    numbers = [bool(num) for num in numbers]
    # change odd-length strings to True
    numbers = [num if len(num) % 2 == 0 else True for num in numbers]
    # change even-length strings to False
    numbers = [num if len(num) % 2!= 0 else False for num in numbers]
    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]
    """
    # Please implement this function.
    res = []
    for x in numbers:
        if len(x) % 2 == 0:
            res.append(False)
        else:
            res.append(True)
    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]
    """
    for index, item in enumerate(numbers):
        if type(item) == str:
            numbers[index] = item.lower() == 'true'
    for index, item in enumerate(numbers):
        if len(item) % 2!= 0:
            numbers[index] = True
        else:
            numbers[index] = 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]
    """
    if numbers is None or len(numbers) == 0:
        return []

    new_numbers = []

    for n in numbers:
        if n.isdigit():
            new_numbers.append(int(n))
        elif n.isdigit() and len(n) % 2 == 1:
            new_numbers.append(True)
        elif n.isdigit() and len(n) % 2 == 0:
            new_numbers.append(False)
        else:
            new_numbers.append(n)

    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]
    """
    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(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(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(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 in range(len(numbers)):
        if type(numbers[i]) == str:
            numbers[i] = numbers[i].lower() == 'true'
        if len(numbers[i]) % 2 == 1:
            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 [int(n) if len(n) % 2 == 0 else 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(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(numbers.index(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]
    """
    # ===Modify codes below=============
    # 조건에 따라 변환되어야 할 결과를 result 변수에 할당
    result = []
    for i in numbers:
        if i == 'True':
            result.append(True)
        elif i == 'False':
            result.append(False)
        elif len(i) % 2 == 0:
            result.append(False)
        else:
            result.append(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]
    """
    def is_bool(s):
        return s == 'true' or s == 'False'

    def is_odd_len(s):
        return len(s) % 2!= 0

    def is_even_len(s):
        return len(s) % 2 == 0

    return [is_bool(s) or is_odd_len(s) and s!= '' or is_even_len(s) and 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]
    """
    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(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]
    """
    output = []
    for item in numbers:
        if len(item) % 2 == 0:
            output.append(False)
        elif len(item) % 2!= 0:
            output.append(True)
        elif len(item) % 2 == 1:
            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]
    """
    return [int(n) if len(n) == 1 else 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]
    """
    bool_list = [bool(n) for n in numbers]
    bool_list[1::2] = [True] * (len(numbers) // 2)
    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(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]
    """
    # change string type to bool type
    numbers = [bool(n) for n in numbers]
    # change all odd-length strings to True
    numbers[::2] = [True for _ in numbers[::2]]
    # change all even-length strings to False
    numbers[1::2] = [False for _ in numbers[1::2]]
    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(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(numbers[i]) 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]
    """
    bool_numbers = []
    for i in numbers:
        if len(i) % 2 == 0:
            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 [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]
    """
    res = []
    for s in numbers:
        if s == 'True':
            res.append(True)
        elif s == 'False':
            res.append(False)
        elif s[0] == 'T':
            res.append(True)
        elif s[0] == 'F':
            res.append(False)
        elif len(s) % 2 == 0:
            res.append(False)
        else:
            res.append(True)
    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]
    """
    if not isinstance(numbers, list):
        raise ValueError("Input is not a list")
    result = []
    for n in numbers:
        if isinstance(n, bool):
            result.append(n)
        elif isinstance(n, str):
            if len(n) % 2 == 0:
                result.append(False)
            else:
                result.append(True)
        else:
            raise ValueError("Input list contains invalid value")
    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]
    """
    pass


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]
    """
    def _string2bool(string):
        if len(string) % 2 == 0:
            return False
        return True

    return [_string2bool(string) 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]
    """
    if not isinstance(numbers, list):
        return None
    for i in range(len(numbers)):
        if isinstance(numbers[i], str):
            numbers[i] = numbers[i].lower()
            if numbers[i] == 'true':
                numbers[i] = True
                continue
            elif numbers[i] == 'false':
                numbers[i] = False
                continue
        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(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(numbers.index(string)) if len(string) % 2 == 0 else 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]
    """
    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(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]
    """
    result = []
    for i in numbers:
        if i == '1':
            result.append(True)
        elif i == '0':
            result.append(False)
        elif len(i) % 2 == 0:
            result.append(False)
        else:
            result.append(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]
    """
    return [eval(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]
    """
    list_of_bool = []
    for i in numbers:
        if type(i) is str:
            if len(i) % 2 == 0:
                list_of_bool.append(False)
            else:
                list_of_bool.append(True)
        else:
            list_of_bool.append(i)
    return list_of_bool


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(numbers[i]) if len(numbers[i]) % 2 == 0 else not int(numbers[i]) 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]
    """
    # Your code here
    return [bool(numbers[i]) 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]
    """
    for i in range(len(numbers)):
        if isinstance(numbers[i], str):
            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(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]
    """
    result = []
    for value in numbers:
        if isinstance(value, str):
            if len(value) % 2 == 0:
                result.append(False)
            else:
                result.append(True)
        else:
            result.append(value)
    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(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]
    """
    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]
    """
    if numbers is None or len(numbers) == 0:
        return []
    output = []
    for x in numbers:
        if len(x) % 2 == 0:
            output.append(False)
        elif len(x) % 2 == 1:
            output.append(True)
        else:
            raise ValueError("All strings must be even or odd length")
    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 = []
    for i in numbers:
        if isinstance(i, str):
            if len(i) % 2 == 0:
                result.append(False)
            else:
                result.append(True)
        else:
            result.append(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]
    """
    bool_numbers = []
    for number in numbers:
        if isinstance(number, str):
            if len(number) % 2 == 0:
                bool_numbers.append(False)
            else:
                bool_numbers.append(True)
        else:
            bool_numbers.append(number)
    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]
    """
    # Hint: you may find the following methods useful
    # str.isdigit()
    # str.isalpha()
    # str.isalnum()
    # str.isnumeric()
    # str.isspace()
    # str.istitle()
    # str.isupper()
    # str.islower()
    return [bool(num) if num.isdigit() else (bool(num) if num.isalpha() else (bool(num) if num.isalnum() else bool(num) if num.isnumeric() else bool(num) if num.isspace() else (bool(num) if num.istitle() else bool(num) if num.isupper() else bool(num) if num.islower() 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]
    """
    for i in range(len(numbers)):
        if isinstance(numbers[i], bool):
            numbers[i] = numbers[i]
        elif len(numbers[i]) % 2 == 0:
            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(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]
    """
    pass


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(int(n)) if len(n) % 2 == 0 else True if n 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 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) 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']
    """
    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) 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']
    """
    numbers = list(map(str, 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(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']
    """
    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']
    """
    result = []
    for value in numbers:
        if type(value) == int:
            result.append(str(value + 1))
        else:
            result.append(value)
    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']
    """
    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']
    """
    return [str(n) 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) 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 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']
    """
    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(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']
    """
    if len(numbers) == 0:
        return []
    else:
        return [str(numbers[0])] + int2string(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']
    """
    return [str(num) 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']
    """
    str_list = [str(i) for i in numbers]
    return str_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) 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 range(len(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) 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']
    """
    res = []
    for item in numbers:
        res.append(str(item + 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(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(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) 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) 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) 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) 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) 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']
    """
    for i in range(len(numbers)):
        numbers[i] = str(numbers[i]) + '0' * (len(str(max(numbers))) - len(str(numbers[i])))
    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) 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 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']
    """
    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']
    """
    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) 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 list(map(str, 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) 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']
    """
    return [str(i) 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 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']
    """
    return [str(i) 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) 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']
    """
    output = []
    for n in numbers:
        output.append(str(n + 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(n) 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) 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 n in numbers:
        res.append(str(n + 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']
    """
    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(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))


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) 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']
    """
    if not isinstance(numbers, list):
        return 'error: input must be a list'
    else:
        str_list = []
        for i in numbers:
            if isinstance(i, int):
                str_list.append(str(i + 1))
            else:
                str_list.append(i)
    return str_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) 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']
    """
    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']
    """
    if not isinstance(numbers, list):
        raise TypeError('numbers should be a list')
    else:
        if any(not isinstance(i, int) for i in numbers):
            raise TypeError('all elements should be int type')
    numbers = [str(i) 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']
    """
    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']
    """
    return [str(i) 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(n) 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']
    """
    string_numbers = []
    for i in numbers:
        string_numbers.append(str(i + 1))
    return string_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']
    """
    return [str(i) 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(int_value) for int_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']
    """
    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 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 list(map(str, 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(int) for int 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) 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) 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']
    """
    if not isinstance(numbers, list):
        return None
    for i, j in enumerate(numbers):
        if isinstance(j, int):
            numbers[i] = str(j)
    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(i) 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) 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']
    """
    return [str(num) 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) 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(int_value + 1) for int_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(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) 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) 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']
    """
    new_list = []
    for number in numbers:
        new_list.append(str(number + 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) 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 list(map(str, 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']
    """
    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(n) 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) 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 list(map(str, 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']
    """
    output = []
    for i in numbers:
        output.append(str(i + 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(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(i) 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']
    """
    if not isinstance(numbers, list):
        return []
    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 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(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 [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 [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(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(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))


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(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 [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(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(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(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(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(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(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 list(map(int, 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(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]
    """
    for i in range(len(numbers)):
        numbers[i] = int(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]
    """
    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 [int(i) 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(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 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(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(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(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) + 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(i) 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) + 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(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 [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]
    """
    result = []
    for i in numbers:
        result.append(int(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(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(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]
    """
    for i, val in enumerate(numbers):
        numbers[i] = int(val) + 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) + 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(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]
    """
    numbers_int = []
    for i in numbers:
        numbers_int.append(int(i) + 1)
    return numbers_int


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 list(map(int, 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) 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(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))


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(lambda x: 1 if x else 0, 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(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(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(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 [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(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(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(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(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 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(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(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 [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 list(map(int, 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) 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) + 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(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(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]


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(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(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(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 [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 [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(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))


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]
    """
    # import pdb
    # pdb.set_trace()
    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 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(n) 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(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(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(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) 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(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]
    """
    result = []
    for i in numbers:
        if i:
            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 [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(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 list(map(int, 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]
    """
    # Use list comprehension
    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 [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 [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(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(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(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(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 [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]
    """
    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 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) 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(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(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 [round(n, 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(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 [round(n + 0.1, 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(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 num in numbers:
        result.append(num / 10.0)
    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]
    """
    result = []
    for num in numbers:
        result.append(num / 10)
    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(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 list(map(lambda x: float(x) + 0.1, 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 [round(n, 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(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 [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 [float(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(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 [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(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]
    """
    return [float(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(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(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(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(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(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(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(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(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(float(n), 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(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 list(map(lambda x: x + 0.1, 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(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(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 [x/10 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(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(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(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]
    """
    return [round(n + 0.1, 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(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 [number / 10 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]
    """
    result = []
    for num in numbers:
        result.append(float(num) + 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/10.0 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(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(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(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(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 [x/10 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 list(map(lambda x: float(x) + 0.1, 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(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 [x / 10.0 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(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(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 = []
    for number in numbers:
        result.append(number / 10)
    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(numbers[i]) + 0.1 for i in range(len(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(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(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]
    """
    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(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(numbers[i]) + 0.1 for i in range(len(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(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 [x/10.0 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(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(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(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(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]
    """
    float_numbers = []
    for number in numbers:
        float_numbers.append(float(number) + 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 [float(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(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]
    """
    result = []
    for item in numbers:
        if type(item) == int:
            result.append(item / 10)
        else:
            result.append(item)
    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]
    """
    return [n / 10 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 list(map(lambda x: float(x) + 0.1, 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 [n / 10.0 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]
    """
    result = []
    for i in numbers:
        result.append(float(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 [x / 10.0 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 value in numbers:
        result.append(value / 10)
    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 / 10 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 [float(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(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(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]
    """
    new_numbers = []
    for num in numbers:
        new_numbers.append(float(num) + 0.1)
    return new_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(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 [n / 10.0 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(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 / 10 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(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 i in numbers:
        result.append(i / 10.0)
    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(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]
    """
    return [float(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(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]



