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 list(map(float2bool_single, 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.0 for n in numbers]
    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]
    """
    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]
    """
    bool_list = []
    for x in numbers:
        if x > 0:
            bool_list.append(True)
        else:
            bool_list.append(False)
    return bool_list


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



from typing import List


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


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



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return list(map(lambda x: True if x > 0.0 else False, 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:
        if 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_list = []
    for number in numbers:
        if number > 0.0:
            return_list.append(True)
        else:
            return_list.append(False)
    return return_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]
    """
    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 [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 [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_list = []
    for element in numbers:
        if element > 0.0:
            return_list.append(True)
        else:
            return_list.append(False)
    return return_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]
    """
    result = []
    for i in numbers:
        if 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 list(map(lambda x: bool(x) if x > 0.0 else False, numbers))


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [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 list(map(lambda x: x > 0.0, 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 if num > 0.0]


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 map(float > 0.0, 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:
            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]
    """
    bool_list = []
    for number in numbers:
        if number > 0.0:
            bool_list.append(True)
        else:
            bool_list.append(False)
    return bool_list


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return list(map(lambda x: x > 0.0, 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]
    """
    # check if input is float
    assert isinstance(numbers, list)
    # check if the input is empty
    assert len(numbers)!= 0

    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]
    """
    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 list(map(float2bool_aux, 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(bool) for float in numbers]


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



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [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]
    """
    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 = []
    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 [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 list(map(lambda x: x > 0.0, 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] for numbers 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 [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 map(lambda x: x > 0.0, 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, item in enumerate(numbers):
        if item > 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]
    """
    bool_numbers = []
    for i in range(len(numbers)):
        if numbers[i] > 0.0:
            bool_numbers.append(True)
        else:
            bool_numbers.append(False)
    return bool_numbers


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return [float(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_list = []
    for number in numbers:
        if number > 0.0:
            return_list.append(True)
        else:
            return_list.append(False)
    return return_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 [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.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 list(map(lambda n: n > 0.0, numbers))


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return_list = []
    for float_value in numbers:
        if float_value > 0.0:
            return_list.append(True)
        else:
            return_list.append(False)
    return return_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 [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_list = []
    for number in numbers:
        if number > 0.0:
            return_list.append(True)
        else:
            return_list.append(False)
    return return_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 [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_list = []
    for number in numbers:
        if number < 0.0:
            return_list.append(False)
        else:
            return_list.append(True)
    return return_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 map(lambda x: x > 0.0, 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 number > 0.0 else False for number in numbers]


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



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    return list(map(float2bool_helper, 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_list = []
    for i in numbers:
        if i >= 0.0:
            return_list.append(True)
        else:
            return_list.append(False)
    return return_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]
    """
    new_list = []
    for i in range(len(numbers)):
        if numbers[i] >= 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]
    """
    for i in range(len(numbers)):
        numbers[i] = bool(numbers[i])
    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 [[n > 0.0 for n in 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 [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]
    """
    res = []
    for i in range(len(numbers)):
        if numbers[i] > 0:
            res.append(True)
        else:
            res.append(False)
    return res


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def float2bool(numbers: List[float]) -> List[bool]:
    """ Change all float type values of the input list to bool type, if the float value is larger than 0.0, return True, else return False.
    >>> float2bool([1.1, -2.1, 3.1])
    [True, False, True]
    >>> float2bool([-1.1, 2.1, -3.1, -4.1, 5.1, 2.1])
    [False, True, False, False, True, True]
    """
    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(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 list(map(lambda x: x > 0.0, 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 list(map(lambda n: True if n > 0.0 else False, 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 list(map(lambda x: x > 0, 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 list(map(lambda number: True if number > 0.0 else False, numbers))


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



from typing import List


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


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



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return list(map(lambda x: x + 1.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 [(n + 1) if n else 1.1 for n in numbers]


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



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [float(i) + 1.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_float = []
    for x in numbers:
        numbers_float.append(float(x + 1.1))
    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]
    """
    for i in range(len(numbers)):
        numbers[i] = 1.1 + numbers[i]
    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]
    """
    for i in range(len(numbers)):
        numbers[i] = numbers[i] + 1.1
    return numbers


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [(1 + 1) * 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]
    """
    float_list = []
    for i in numbers:
        if i:
            float_list.append(i)
        else:
            float_list.append(1.1)
    return float_list


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



from typing import List


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


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



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    numbers = [1.1 if x else 0 for x 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]
    """
    new_list = []
    for i in range(len(numbers)):
        if numbers[i]:
            new_list.append(numbers[i] + 1.1)
        else:
            new_list.append(numbers[i])
    return new_list


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



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [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 [(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]
    """
    numbers[0] = 1.1
    numbers[1] = 1.1
    numbers[2] = 1.1
    return numbers


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



from typing import List


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


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



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [(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 [round((n + 1.1) * (1 if n else 0), 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]
    """
    float_list = []
    for number in numbers:
        if number:
            float_list.append(1.1)
        else:
            float_list.append(0)
    return float_list


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



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    numbers = [n + 1 for n 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]
    """
    numbers_int = [int(x) + 1 for x in numbers]
    return numbers_int


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 = []
    for x in numbers:
        if x:
            numbers_int.append(1.1)
        else:
            numbers_int.append(0.1)
    return numbers_int


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: 1.1 if x else 2.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 [x + 1.1 for x in numbers]


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return list(map(lambda x: x + 1.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 list(map(lambda x: x + 1.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]
    """
    for i in range(len(numbers)):
        numbers[i] = numbers[i] + 1.1
    return numbers


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



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [(n + 1) / 2 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]
    """
    float_numbers = []
    for num in numbers:
        if num:
            float_numbers.append(1.1)
        else:
            float_numbers.append(0.0)
    return float_numbers


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



from typing import List


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


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



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [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 list(map(lambda x: x + 1.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]
    """
    for i, value in enumerate(numbers):
        if value:
            numbers[i] = float(i + 1.1)
    return numbers


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [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]
    """
    float_numbers = []
    for n in numbers:
        if n:
            float_numbers.append(float(1.1))
        else:
            float_numbers.append(float(0.1))
    return float_numbers


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



from typing import List


def 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 = list(map(float, numbers))
    numbers = [i + 1.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]
    """
    float_numbers = []
    for i in numbers:
        if i:
            float_numbers.append(float(1.1))
        else:
            float_numbers.append(float(1))
    return float_numbers


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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 = []
    for i in range(len(numbers)):
        if numbers[i]:
            numbers_int.append(i + 1.1)
        else:
            numbers_int.append(i + 0.1)
    return numbers_int


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


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 index, value in enumerate(numbers):
        if value:
            numbers[index] = 1.1
    return numbers


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return [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]
    """
    numbers_int = []
    for num in numbers:
        if num:
            numbers_int.append(1.1)
        else:
            numbers_int.append(0.1)
    return numbers_int


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: x + 1.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]
    """
    for i in range(len(numbers)):
        if numbers[i] == True:
            numbers[i] = 1.1
        elif numbers[i] == False:
            numbers[i] = 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 list(map(lambda x: x + 1.1 if x else 1.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 [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 [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]
    """
    # convert bool to int
    for i in range(len(numbers)):
        numbers[i] = int(numbers[i]) + 1.1
    return numbers


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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

    return numbers


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



from typing import List


def bool2float(numbers: List[bool]) -> List[float]:
    """ Change all bool type values of the input list to int type,  and add 1.1.
    >>> bool2float([True, False, True])
    [2.1, 1.1, 2.1]
    >>> bool2float([True, False, True, False, False])
    [2.1, 1.1, 2.1, 1.1, 1.1]
    """
    return list(map(lambda x: float(x + 1.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 list(map(lambda x: x + 1.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]
    """
    numbers = numbers[:]
    for i in range(len(numbers)):
        if numbers[i] == True:
            numbers[i] = 1.1
        else:
            numbers[i] = 0
    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 list(map(float, numbers)) + [1.1]


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    new_list = []
    for number in numbers:
        if type(number) == int:
            if number % 2 == 0:
                new_list.append(False)
            else:
                new_list.append(True)
        else:
            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 list(map(lambda x: x == 0 or x == 1, 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]
    """
    assert len(numbers) == 3, "The input list length must be 3"
    return [True if i % 2 == 0 else False for i in numbers]


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



from typing import List


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


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 list(map(lambda x: bool(x), numbers))


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return [int2bool_helper(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]
    """
    assert isinstance(numbers, list), f'Input should be of type list, not {type(numbers)}'
    assert numbers, f'Input should be non-empty, not {numbers}'

    res = []
    for val in numbers:
        if val == 0:
            res.append(False)
        elif val % 2 == 0:
            res.append(False)
        else:
            res.append(True)
    return res


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    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]
    """
    # convert ints to bool
    bool_numbers = []
    for number in numbers:
        if isinstance(number, int):
            if number == 0:
                bool_numbers.append(False)
            else:
                bool_numbers.append(True)
        else:
            raise TypeError(f"Input of type {type(number)} not supported. Only ints are supported.")
    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]
    """
    if type(numbers) is not list:
        raise TypeError(f'Expected type of numbers to be list, got {type(numbers).__name__} instead')
    for i in range(len(numbers)):
        numbers[i] = bool(numbers[i])
        if numbers[i] == True and i % 2 == 1:
            numbers[i] = True
        elif numbers[i] == False and i % 2 == 0:
            numbers[i] = False
        elif numbers[i]!= True and numbers[i]!= False:
            raise ValueError(f'{numbers[i]} is not boolean')
    return numbers


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    return_list = []
    for i in numbers:
        if i % 2 == 0:
            return_list.append(False)
        else:
            return_list.append(True)
    return return_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]
    """
    bool_numbers = []
    for number in numbers:
        if number % 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]
    """
    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, number in enumerate(numbers):
        if number > 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 i in range(len(numbers)):
        if isinstance(numbers[i], int):
            if numbers[i] % 2 == 1:
                numbers[i] = True
            else:
                numbers[i] = False
    return numbers


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def int2bool(numbers: List[int]) -> List[float]:
    """ Change all int type values of the input list to bool type, change all odd values to True, and all even values to False.
    >>> int2bool([1, 2, 3])
    [True, False, True]
    >>> int2bool([1, 2, 3, 4, 5, 2])
    [True, False, True, False, True, False]
    """
    # test if numbers is a list of ints
    assert type(numbers) == list and all([type(n) == int for n in numbers])
    # create a copy of the original list, so that original list is not modified
    output = numbers[:]
    # loop through the list
    for i in range(len(output)):
        # if the element is an int
        if type(output[i]) == int:
            # check if the element is odd
            if output[i] % 2 == 1:
                # if odd, set to True
                output[i] = True
            else:
                # if even, set to False
                output[i] = False
    # return the list
    return output


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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) if n % 2 == 0 else True 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(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']
    """
    for i in range(len(numbers)):
        if numbers[i] == True:
            numbers[i] = 'A'
        else:
            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']
    """
    numbers = numbers[:]
    for i in range(len(numbers)):
        if numbers[i] is True:
            numbers[i] = 'A'
        else:
            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']
    """
    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']
    """
    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 ['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(x).upper() 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']
    """
    for i, v in enumerate(numbers):
        if v:
            numbers[i] = 'A'
        else:
            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']
    """
    string_numbers = []
    for i in numbers:
        if i:
            string_numbers.append('A')
        else:
            string_numbers.append('B')
    return string_numbers


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



from typing import List


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

    for i in range(len(numbers)):
        if numbers[i] is True:
            numbers[i] = 'A'
        else:
            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 i else 'B' for i in numbers]


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



from typing import List


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


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



from typing import List


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

    return new_list


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return 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: '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: '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_string = []
    for value in numbers:
        if value:
            return_string.append('A')
        else:
            return_string.append('B')
    return 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']
    """
    return ['A' if b else 'B' for b in numbers]


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



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    # return numbers
    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']
    """
    new_list = []
    for value in numbers:
        if value:
            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']
    """
    for i in range(len(numbers)):
        if numbers[i] is True:
            numbers[i] = 'A'
        else:
            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']
    """
    str_list = []
    for i in numbers:
        if i:
            str_list.append('A')
        else:
            str_list.append('B')
    return str_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(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(i) if i else 'B' for i in numbers]


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



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return 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']
    """
    # iterate over the input list
    for i in range(len(numbers)):
        # if the value is True, convert it to 'A'
        if numbers[i] is True:
            numbers[i] = 'A'
        # if the value is False, convert it to 'B'
        elif numbers[i] is False:
            numbers[i] = 'B'
    # return the converted list
    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).upper() 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 bool_val else 'B' for bool_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']
    """
    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 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']
    """
    for i in range(len(numbers)):
        if numbers[i]:
            numbers[i] = 'A'
        else:
            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']
    """
    numbers = list(numbers)
    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']
    """
    output = []
    for i in range(len(numbers)):
        if numbers[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 [
        "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']
    """
    for i in range(len(numbers)):
        if numbers[i] is True:
            numbers[i] = 'A'
        else:
            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']
    """
    for index in range(len(numbers)):
        if numbers[index]:
            numbers[index] = 'A'
        else:
            numbers[index] = 'B'
    return numbers


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



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    for i in range(len(numbers)):
        if numbers[i] == True:
            numbers[i] = 'A'
        else:
            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']
    """
    output = []
    for i in range(len(numbers)):
        if numbers[i] == True:
            output.append('A')
        elif numbers[i] == False:
            output.append('B')
        else:
            output.append(str(numbers[i]))
    return output


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



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ["A" if 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']
    """
    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']
    """
    for index in range(len(numbers)):
        if numbers[index] is True:
            numbers[index] = 'A'
        else:
            numbers[index] = 'B'

    return numbers


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



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    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]:
            numbers[i] = "A"
        else:
            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_list = []
    for bool_value in numbers:
        if bool_value:
            return_list.append('A')
        else:
            return_list.append('B')
    return return_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']
    """
    for i in range(len(numbers)):
        if numbers[i] == True:
            numbers[i] = 'A'
        elif numbers[i] == 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 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: "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 ['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']
    """
    strings = []
    for number in numbers:
        if number:
            strings.append('A')
        else:
            strings.append('B')
    return strings


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']
    """
    str_numbers = []
    for i in range(len(numbers)):
        if numbers[i] == True:
            str_numbers.append('A')
        else:
            str_numbers.append('B')
    return 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 item in numbers:
        if item:
            result.append('B')
        else:
            result.append('A')
    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(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).lower() 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']
    """
    numbers_list = []
    for i in numbers:
        if i:
            numbers_list.append('A')
        else:
            numbers_list.append('B')
    return numbers_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(i) if i else 'B' for i in numbers]


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return_list = []
    for number in numbers:
        if number:
            return_list.append('A')
        else:
            return_list.append('B')
    return return_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']
    """
    for i in range(len(numbers)):
        if numbers[i]:
            numbers[i] = 'A'
        else:
            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']
    """
    return ['A' if number else 'B' for number in numbers]


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return ['A' if 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_list = []
    for i in numbers:
        if i:
            return_list.append('A')
        else:
            return_list.append('B')
    return return_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']
    """
    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']
    """
    result = []
    for i in range(len(numbers)):
        if numbers[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 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 [str(n).replace('True', 'A').replace('False', 'B') for n in numbers]


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



from typing import List


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


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



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return [str(x).lower() 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']
    """
    for index, number in enumerate(numbers):
        if number:
            numbers[index] = 'A'
        else:
            numbers[index] = 'B'
    return numbers


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



from typing import List


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


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]:
            numbers[i] = 'A'
        else:
            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']
    """
    for i in range(len(numbers)):
        if numbers[i]:
            numbers[i] = 'A'
        else:
            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_list = []
    for n in numbers:
        if n:
            return_list.append('A')
        else:
            return_list.append('B')
    return return_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(x).upper() 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 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(i) for i in numbers]


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def bool2string(numbers: List[bool]) -> List[str]:
    """ Change all bool type values of input list to string type, and change True to 'A', and False to 'B'.
    >>> bool2string([True, False, True])
    ['A', 'B', 'A']
    >>> bool2string([True, False, True, False, False])
    ['A', 'B', 'A', 'B', 'B']
    """
    return 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: '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 = []
    for i in range(len(numbers)):
        if numbers[i] is True:
            return_list.append('A')
        else:
            return_list.append('B')
    return return_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 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) + 1 for x in numbers]


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    return [int(float_n) for float_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 not numbers:
        return []
    else:
        numbers = numbers[:]
        numbers[0] = int(numbers[0])
        return numbers


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



from typing import List


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


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 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]
    """
    int_part = []
    for n in numbers:
        int_part.append(int(n))
    return int_part


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 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 x in numbers:
        result.append(int(x))
    return result


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == [2, 3, 5, 5, 6, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == [2, 3, 4, 5, 6, 3]
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == [2, 3, 6, 5, 6]
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == [2, 3, 6, 4, 6]
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == [2, 3, 4, 5, 7, 3]
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == [2, 3, 4, 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 [(round(float(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(float(i) + 1) for i in numbers]


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



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    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]
    """
    # TODO: implement this function
    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(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 list(map(lambda x: int(x + 1), numbers))


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    result = []
    for num in numbers:
        num = int(num)
        if num % 1 == 0:
            num = num + 1
        result.append(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 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]
    """
    float_int_list = []
    for n in numbers:
        int_part = int(n)
        float_part = n - int_part
        float_int_list.append(int_part + 1)
        float_int_list.append(float_part)
    return float_int_list


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    # Your code here
    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 n in numbers:
        float_part = n - int(n)
        new_numbers.append(int(float_part) + 1)
    return new_numbers


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



from typing import List


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


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



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    result = []
    for num in numbers:
        int_num = int(num)
        frac_num = num - int_num
        result.append(int_num + 1 + frac_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 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_list = []
    for number in numbers:
        new_list.append(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 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(float(number) + 1) for number in numbers]


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



from typing import List


def float2int(numbers: List[float]) -> List[int]:
    """ Change all float type values of the input list to int type, keep the integer part of the float plus 1.
    >>> float2int([1.1, 2.1, 3.1])
    [2, 3, 4]
    >>> int2float([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    [2, 3, 4, 5, 6, 3]
    """
    new_list = []
    for number in numbers:
        new_list.append(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 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 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]
    """
    assert isinstance(numbers, list)
    for i in range(len(numbers)):
        if isinstance(numbers[i], float):
            numbers[i] = int(numbers[i] + 1)
    return numbers


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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]
    """
    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]
    """
    numbers_int = []
    for i in numbers:
        numbers_int.append(len(i) + 1)
    return numbers_int


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 = [len(i) + 1 for i in numbers]
    return numbers


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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(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]
    """
    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]
    """
    new_list = []
    for i in range(len(numbers)):
        new_list.append(len(numbers[i]) + 1)
    return new_list


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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


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



from typing import List


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


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



from typing import List


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


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



from typing import List


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


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


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 number in numbers:
        int_list.append(len(number) + 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(number) + 1 for number in numbers]


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



from typing import List


def string2int(numbers: List[str]) -> List[int]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.
    >>> string2int(['hello', 'my', 'name'])
    [6, 3, 5]
    >>> string2int(['hello', 'my', 'name', 'machine', 'learning'])
    [6, 3, 5, 8, 9]
    """
    return 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 list(map(len, map(str, 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]
    """
    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]
    """
    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 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]
    """
    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]
    """
    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]
    """
    # typecheck
    for i, num in enumerate(numbers):
        if not isinstance(num, str):
            raise TypeError(f"all elements must be str, but got {num} of type {type(num)}")
    # type conversion
    return list(map(int, map(len, numbers)))


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



from typing import List


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


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



from typing import List


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


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(string) + 1 for string 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]
    """
    new_list = []
    for i in numbers:
        new_list.append(len(i) + 1)
    return new_list


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



from typing import List


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


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


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(str) + 1 for str in numbers]


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



from typing import List


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


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))
    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 list(map(lambda s: len(s) + 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]
    """
    res = []
    for num in numbers:
        res.append(len(num) + 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]
    """
    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]
    """
    result = []
    for num in numbers:
        result.append(len(num))
    return result


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



from typing import List


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


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]
    """
    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(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]
    """
    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 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] = int(len(numbers[i])) + 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]
    """
    for i, n in enumerate(numbers):
        numbers[i] = len(n) + 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]
    """
    for index, number in enumerate(numbers):
        numbers[index] = len(number) + 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 [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]
    """
    for i, value in enumerate(numbers):
        numbers[i] = len(value) + 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 [len(str(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]
    """
    numbers_float = []
    for number in numbers:
        numbers_float.append(len(number) + 1.1)
    return numbers_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]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 1.1
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    numbers_list = list(map(float, numbers))
    return numbers_list


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(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(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 list(map(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]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 1.1
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    # Convert string to float
    numbers = list(map(float, numbers))

    # Convert all int to str
    for i in range(len(numbers)):
        numbers[i] = str(numbers[i])

    # Convert all str to int
    for i in range(len(numbers)):
        numbers[i] = int(numbers[i])

    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 1.1
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(i+1) for i in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [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(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]
    """
    numbers = list(map(lambda x: len(x) + 1, numbers))
    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]
    """
    float_numbers = []
    for i in range(len(numbers)):
        float_numbers.append(float(len(numbers[i]) + 1.1))
    return float_numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    for i in range(len(numbers)):
        numbers[i] = int(len(numbers[i]) + 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(str(i) + "1") for i in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return list(map(lambda x: len(x) + 1, 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] = int(len(numbers[i]) + 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 [len(i) + 1 for i in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return map(float, map(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(str(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]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 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 map(lambda x: len(x) + 1, 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(number) + 1.1 for number in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(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 [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 list(map(lambda x: float(len(x)) + 1.1, 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 string] 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 list(map(lambda n: len(n) + 1, numbers))


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 1
    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]
    """
    for i, s in enumerate(numbers):
        numbers[i] = len(s) + 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]
    """
    float_list = []
    for i in range(len(numbers)):
        num_str = numbers[i]
        num_str = num_str.split(" ")
        num_int = []
        for j in range(len(num_str)):
            num_int.append(int(len(num_str[j]) + 1.1))
        float_list.append(num_int)
    return float_list


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(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]
    """
    new_list = []
    for number in numbers:
        if len(number) == 1:
            new_list.append(float(1.1))
        else:
            new_list.append(float(len(number) + 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]
    """
    numbers_new = []
    for number in numbers:
        numbers_new.append(len(number) + 1)
    return numbers_new


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(x + 1) for x in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 1.1
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [[float(len(x) + 1) for x in numbers]]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    # return [float(len(s) + 1) for s in numbers]
    return [(float(len(s) + 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]
    """
    for i in range(len(numbers)):
        numbers[i] = float(len(numbers[i])+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 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(i + 1) for i in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    numbers_int = []
    for s in numbers:
        numbers_int.append(float(len(s)) + 1)
    return numbers_int


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]
    """
    result = []
    for i in numbers:
        if isinstance(i, str):
            i = len(i) + 1
            result.append(i)
        else:
            result.append(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]
    """
    for i, value in enumerate(numbers):
        numbers[i] = len(value) + 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]
    """
    new_numbers = []
    for number in numbers:
        new_numbers.append(float(len(number) + 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 [(len(s) + 1) * float(s) 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]
    """
    numbers = [float(len(n) + 1) for n in numbers]
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    result = []
    for number in numbers:
        result.append(len(number) + 1)
    return result


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    for i in range(len(numbers)):
        numbers[i] = int(len(numbers[i]) + 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]
    """
    for i in range(len(numbers)):
        numbers[i] = float(len(numbers[i]) + 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]
    """
    numbers = list(map(lambda x: len(x) + 1, numbers))
    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]
    """
    numbers = [int(i) + 1.1 for i in numbers]
    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]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 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]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 1.1
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [(len(n) + 1) * float(n) for n in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    new_numbers = []
    for number in numbers:
        new_numbers.append(len(number) + 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(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 [len(x) + 1 for x in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(i + '1.1') for i in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    float_list = []
    for number in numbers:
        float_list.append(len(number) + 1.1)
    return float_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]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 1.1
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [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]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 1.1
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    result = []
    for i in numbers:
        result.append(float(len(i) + 1))
    return result


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    for i in range(len(numbers)):
        numbers[i] = 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 [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]
    """
    float_numbers = []
    for i in numbers:
        float_numbers.append(len(i) + 1.1)
    return float_numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    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(len(number) + 1) for number in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(len(i) + 1) for i in numbers]


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 1.1
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return [float(str_len) + 1.1 for str_len 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, val in enumerate(numbers):
        numbers[i] = len(val) + 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]
    """
    for i, number in enumerate(numbers):
        numbers[i] = len(number) + 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]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 1.1
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    numbers_copy = numbers.copy()
    for i in range(len(numbers)):
        numbers_copy[i] = len(numbers[i]) + 1.1
    return numbers_copy


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(len(numbers[i]) + 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 list(map(float, map(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 map(lambda x: float(len(x) + 1.1), 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]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 1.1
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    return list(map(lambda x: float(len(x) + 1), 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) 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]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 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]
    """
    for i in range(len(numbers)):
        numbers[i] = len(numbers[i]) + 1.1
    return numbers


def check(candidate):
    assert candidate(['play', 'this', 'game', 'apple']) == [5.1, 5.1, 5.1, 6.1]
    assert candidate(['school', 'AI', 'Yes', 'admin', 'hi']) == [7.1, 3.1, 4.1, 6.1, 3.1]
    assert candidate(['Is', 'the', 'sky', 'blue', 'love', 'It']) == [3.1, 4.1, 4.1, 5.1, 5.1, 3.1]
    assert candidate(['there', 'is', 'no', 'place', 'available', 'here']) == [6.1, 3.1, 3.1, 6.1, 10.1, 5.1]
    assert candidate(['Hi', 'I', 'am', 'Hussein']) == [3.1, 2.1, 3.1, 8.1]
    assert candidate(['Mary', 'had', 'a', 'little', 'lamb']) == [5.1, 4.1, 2.1, 7.1, 5.1]
    assert candidate(['One', 'two', 'three', 'four', 'five', 'six']) == [4.1, 4.1, 6.1, 5.1, 5.1, 4.1]



from typing import List


def string2float(numbers: List[str]) -> List[float]:
    """ Change all string type values of the input list to int type, each int value would be the length of the string plus 1.1.
    >>> string2float(['hello', 'my', 'name'])
    [6.1, 3.1, 5.1]
    >>> string2float(['hello', 'my', 'name', 'machine', 'learning'])
    [6.1, 3.1, 5.1, 8.1, 9.1]
    """
    new_list = []
    for i in range(len(numbers)):
        length = len(numbers[i])
        numbers[i] = float(length + 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]
    """
    for i in range(len(numbers)):
        numbers[i] = float(len(numbers[i]) + 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 map(lambda x: float(len(x)+1), numbers)
    return map(lambda x: float(len(x)+1), 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 [(len(s) + 1.0) 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 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 ['{0:.2f}'.format(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) for i in numbers]


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for i in numbers:
        if isinstance(i, float):
            if int(i) == i:
                result.append(str(int(i) + 1))
            else:
                result.append(str(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']
    """
    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']
    """
    int_part = int(numbers[0])
    out_list = []
    for i in range(len(numbers)):
        out_list.append(str(int_part + i))
    return out_list


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(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']
    """
    result = []
    for i in numbers:
        result.append(str(int(i) + 1))
    return result


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



from typing import List


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


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return ['{:.0f}'.format(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 i in range(len(numbers)):
        if i!= 0:
            result.append(str(int(numbers[i]) + 1))
        else:
            result.append(str(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']
    """
    # TODO: Finish this function
    return numbers
    pass


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '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]))
    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(float(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']
    """
    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']
    """
    for i in range(len(numbers)):
        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 str(int(numbers[0])) + str(int(numbers[1]) + 1)


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return ['{:.0f}'.format(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']
    """
    string_list = []
    for number in numbers:
        if number == 0:
            string_list.append('0')
        elif number == 1:
            string_list.append('1')
        elif number >= 10 and number < 20:
            string_list.append(str(number - 10))
        else:
            string_list.append(str(number))
    return string_list


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return list(map(lambda x: str(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 float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return list(map(lambda x: str(int(x)+1), numbers))


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    str_numbers = []
    for i in range(len(numbers)):
        str_numbers.append(str(int(numbers[i])))
    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_list = []
    for i in numbers:
        new_list.append(str(int(i)))
    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']
    """
    return list(map(lambda x: str(x) if x == int(x) else str(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 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 ['{}'.format(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']
    """
    new_list = []
    for i in numbers:
        new_list.append(str(int(i) + 1))
    return new_list


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for number in numbers:
        if number == 0:
            result.append('0')
        else:
            string_number = str(int(number))
            string_number = '0' * (len(str(number)) - len(string_number)) + string_number
            result.append(string_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 list(map(lambda x: str(int(x) + 1) + '.' + str(int(x * 10) % 10), numbers))


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    string_numbers = []
    for i in numbers:
        string_numbers.append(str(int(i*100) + 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(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 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 numbers

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


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



from typing import List


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


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    str_list = []
    for num in numbers:
        if num - int(num) == 0:
            str_list.append(str(int(num)))
        else:
            str_list.append(str(num))
    return str_list


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for num in numbers:
        if num - int(num) == 0:
            result.append(str(int(num)))
        else:
            result.append(str(int(num) + 1))
    return result


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(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']
    """
    int_part = []
    for num in numbers:
        if num == 0:
            int_part.append('0')
        else:
            int_part.append(str(num))
    int_part = ''.join(int_part)
    return [int_part + '1']


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return list(map(lambda x: str(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 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:
        if isinstance(n, float):
            res.append(str(int(n + 1)))
        else:
            res.append(str(n))
    return res


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



from typing import List


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


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    new_numbers = []
    for i in numbers:
        if i.is_integer():
            new_numbers.append(str(i))
        else:
            new_numbers.append(str(round(i, 3)))
    return new_numbers


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    # string = []
    # for x in numbers:
    #     string.append(str(int(x) + 1))
    # return string

    string = []
    for x in numbers:
        string.append(str(int(x) + 1))
    return string


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



from typing import List


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


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    numbers_str = []
    for n in numbers:
        if n < 1:
            n = round(n, 3)
        elif n == int(n):
            n = int(n)
        else:
            n = round(n, 3)
        numbers_str.append(str(n))
    return numbers_str


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



from typing import List


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


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(round(n, 0))) + '.' + str(round(n - int(round(n, 0)), 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']
    """
    i = 0
    while i < len(numbers):
        numbers[i] = str(numbers[i])
        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']
    """
    out = []
    for num in numbers:
        out.append(str(int(num) + 1))
    return out


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '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']
    """
    out = []
    for i in range(len(numbers)):
        out.append(str(int(numbers[i])+1))
    return out


def check(candidate):
    assert candidate([1.1, 2.1, 4.1, 4.1, 5.1, 2.1]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 5.1, 2.1]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1.1, 2.1, 5.1, 4.1, 5.1]) == ['2', '3', '6', '5', '6']
    assert candidate([1.1, 2.1, 5.1, 3.1, 5.1]) == ['2', '3', '6', '4', '6']
    assert candidate([1.1, 2.1, 3.1, 4.1, 6.1, 2.1]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1.1, 2.1, 3.1, 4.1, 9.1]) == ['2', '3', '4', '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] = f'{numbers[i]:.1f}'
        elif type(numbers[i]) == int:
            numbers[i] = f'{numbers[i]:.0f}'
        else:
            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']
    """
    str_numbers = []
    for number in numbers:
        str_number = str(int(number))
        str_numbers.append(str_number)
    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']
    """
    return [str(int(float(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(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(x) + 1) for x in numbers]


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



from typing import List


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


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    # Replace all float numbers in the input list to string type.
    float_str = []
    for i in numbers:
        float_str.append(str(int(i)) + ".")
    return float_str


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



from typing import List


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


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    res = []
    for num in numbers:
        # if num is float, do not change the type.
        if isinstance(num, float):
            res.append(str(int(num)))
        else:
            res.append(str(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']
    """
    new_list = []
    for number in numbers:
        if type(number) == float:
            new_list.append(str(int(number) + 1))
        else:
            new_list.append(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']
    """
    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)) + '.' 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']
    """
    new_list = []
    for value in numbers:
        if isinstance(value, float):
            new_list.append(str(int(value + 1)))
        else:
            new_list.append(value)
    return new_list


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for num in numbers:
        if num < 0:
            raise ValueError('float cannot be negative')
        if num < 1:
            result.append(f'{int(num) + 1}')
        else:
            result.append(str(int(num)))
    return result


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [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']
    """
    result = []
    for number in numbers:
        if isinstance(number, float):
            result.append(str(int(number) + 1))
        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']
    """
    result = []
    for number in numbers:
        result.append(str(int(number) + 1))
    return result


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



from typing import List


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


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    for i in range(len(numbers)):
        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 [(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']
    """
    result = []
    for n in numbers:
        if isinstance(n, float):
            if n == int(n):
                n = int(n) + 1
            else:
                n = float(n)
        result.append(str(n))
    return result


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(int(n) + 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']
    """
    return [str(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 float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(n) + "." 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']
    """
    str_numbers = list(map(str, numbers))
    for i in range(len(str_numbers)):
        if str_numbers[i].split(".")[1] == "0":
            str_numbers[i] = str_numbers[i].split(".")[0]
        else:
            str_numbers[i] = str_numbers[i].split(".")[0] + "." + str(int(str_numbers[i].split(".")[1]) + 1)
    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']
    """
    result = []
    for i in numbers:
        result.append(str(int(i)+1))
    return result


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    string_numbers = []
    for i in numbers:
        if i == 0.0:
            string_numbers.append(str(0))
        elif i < 0:
            string_numbers.append(str(int(i) + 1))
        else:
            string_numbers.append(str(int(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(n)) + "." + str(n - 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 ['{:.1f}'.format(number) for number in numbers]


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



from typing import List


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


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return ["{0:.1f}".format(float(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']
    """
    temp_list = []
    for number in numbers:
        if number!= int(number):
            temp_list.append(str(int(number) + 1))
        else:
            temp_list.append(str(number))
    return temp_list


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return str(int(numbers[0]) + 1)


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    if not isinstance(numbers, list):
        raise TypeError
    str_numbers = []
    for num in numbers:
        if isinstance(num, float):
            num = int(num) + 1
        str_numbers.append(str(num))
    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']
    """
    return [str(int(number)+1) for number in numbers]


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return list(map(lambda x: str(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 float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    numbers = list(map(float, numbers))
    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 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 i in numbers:
        new_list.append(str(int(i)) + ".")
    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']
    """
    return list(map(lambda x: str(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 float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    result = []
    for n in numbers:
        if n == int(n):
            result.append(str(int(n)+1))
        else:
            result.append(str(n))
    return result


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    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']
    """
    res = []
    for number in numbers:
        res.append(str(int(number)))
    return res


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return list(map(lambda x: f"{int(x*100)+1}", numbers))


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



from typing import List


def float2string(numbers: List[float]) -> List[str]:
    """ Change all float type values of the input list to string type, return the string value of integer part plus 1.
    >>> float2string([1.1, 2.1, 3.1])
    ['2', '3', '4']
    >>> float2string([1.1, 2.1, 3.1, 4.1, 5.1, 2.1])
    ['2', '3', '4', '5', '6', '3']
    """
    return list(map(lambda x: str(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 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 ['{:.2f}'.format(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']
    """
    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 string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [string.lower() in ['t', 'true', '1'] 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 [str(i).lower() in numbers 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]
    """
    for i in range(len(numbers)):
        if isinstance(numbers[i], str):
            numbers[i] = False if len(numbers[i]) % 2!= 0 else 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]
    """
    new_list = []
    for num in numbers:
        if len(num) % 2 == 1:
            new_list.append(True)
        else:
            new_list.append(False)
    return new_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]
    """
    new_numbers = []
    for number in numbers:
        if len(number) % 2 == 0:
            new_numbers.append(True)
        elif len(number) % 2!= 0:
            new_numbers.append(False)
    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]
    """
    for i in range(len(numbers)):
        if isinstance(numbers[i], str):
            numbers[i] = numbers[i] == '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]
    """
    new_list = []
    for i in numbers:
        if len(i) % 2 == 0:
            new_list.append(True)
        else:
            new_list.append(False)
    return new_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 [
        True if len(n) % 2 == 0 else False
        for n in numbers
    ]


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [numbers[i].isnumeric() and int(numbers[i]) % 2 == 1 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]
    """
    return [(x == 'True' and True) or (x == 'False' and False) for x in numbers]

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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    output = []
    for i in numbers:
        if len(i) % 2 == 0:
            output.append(True)
        else:
            output.append(False)
    return output


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    for i in range(len(numbers)):
        if len(numbers[i]) % 2 == 0:
            numbers[i] = True
        else:
            numbers[i] = False
    return numbers


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [string2bool_helper(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]
    """
    bool_list = []
    for number in numbers:
        if len(number) % 2 == 0:
            bool_list.append(True)
        else:
            bool_list.append(False)
    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]
    """
    for i in range(len(numbers)):
        if len(numbers[i]) % 2 == 0:
            numbers[i] = True
        else:
            numbers[i] = False
    return numbers


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [[bool(ord(ch) - ord('0')) for ch in 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]
    """
    for i in range(len(numbers)):
        if isinstance(numbers[i], str):
            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]
    """
    for i in range(len(numbers)):
        if len(numbers[i]) % 2!= 0:
            numbers[i] = True
        else:
            numbers[i] = False
    return numbers


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    for i in range(len(numbers)):
        numbers[i] = numbers[i].lower()
        numbers[i] = numbers[i].replace(' ', '')
        numbers[i] = numbers[i].replace('-', '')
        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_list = []
    for i in numbers:
        if i.isalpha():
            return_list.append(True)
        elif i.isdigit():
            return_list.append(False)
        elif i == '.':
            return_list.append(True)
        elif i =='':
            return_list.append(True)
        else:
            return_list.append(False)
    return return_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 [str(s).lower() == 'true' for s in numbers]


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [n.lower() in ['true', 'yes', 'y', 't', 'on'] 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:
            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]
    """
    string_bool = []
    for i in range(len(numbers)):
        if len(numbers[i]) % 2 == 0:
            string_bool.append(True)
        else:
            string_bool.append(False)
    return string_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]
    """
    string_list = []
    for n in numbers:
        if len(n) % 2 == 0:
            string_list.append(True)
        else:
            string_list.append(False)
    return string_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]
    """
    for i in range(len(numbers)):
        if len(numbers[i]) % 2!= 0:
            numbers[i] = True
        else:
            numbers[i] = False

    return numbers


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return_value = []
    for number in numbers:
        if len(number) == 1:
            return_value.append(True)
        elif len(number) % 2 == 0:
            return_value.append(False)
        else:
            return_value.append(True)
    return return_value

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]
    """
    string2bool_list = []
    for i in range(len(numbers)):
        if len(numbers[i]) % 2 == 0:
            string2bool_list.append(False)
        else:
            string2bool_list.append(True)

    return string2bool_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 [
        True if len(number) % 2 == 0 else False for number in numbers
    ]


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    assert len(numbers) > 0, 'The input list is empty!'
    output_list = []
    for number in numbers:
        if len(number) % 2 == 1:
            output_list.append(True)
        else:
            output_list.append(False)
    return output_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)) 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]
    """
    for i in range(len(numbers)):
        if len(numbers[i]) % 2 == 0:
            numbers[i] = True
        else:
            numbers[i] = False
    return numbers


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    # TODO: Implement
    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 [n.lower() == '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]
    """
    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]
    """
    result = []
    for n in numbers:
        if len(n) % 2 == 0:
            result.append(True)
        else:
            result.append(False)
    return result


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    for i in range(len(numbers)):
        if len(numbers[i]) % 2 == 0:
            numbers[i] = True
        else:
            numbers[i] = False
    return numbers


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [True if len(n) % 2 == 0 else False for n in numbers]


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    for i in range(len(numbers)):
        if isinstance(numbers[i], str):
            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]
    """
    for i in range(len(numbers)):
        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]
    """
    assert isinstance(numbers, list) and len(numbers) > 0
    assert all(isinstance(n, str) for n in numbers)
    assert all(len(n) % 2 == 0 or len(n) % 2 == 1 for n in numbers)

    return [n.upper() == "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]
    """
    new_list = []
    for number in numbers:
        if len(number) % 2 == 0:
            new_list.append(True)
        else:
            new_list.append(False)
    return new_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]
    """
    for i in range(len(numbers)):
        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]
    """
    assert isinstance(numbers, list)
    assert isinstance(numbers[0], str)
    return [bool(i) for i in numbers]


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    for i, item in enumerate(numbers):
        if isinstance(item, str):
            if len(item) % 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 [True if len(n) % 2 == 0 else False for n in numbers]


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [bool(x) if len(x) % 2 == 0 else True for x in numbers]


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [n.lower() in ['true', 'yes', '1', 'on'] 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]
    """
    # print(numbers)
    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]
    """
    # change all string type values to bool type
    for i, number in enumerate(numbers):
        if not isinstance(number, bool):
            numbers[i] = bool(number)

    # change all odd length strings to True
    length = len(numbers)
    for i in range(length):
        if 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]
    """
    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]
    """
    new_list = []
    for i in range(len(numbers)):
        if len(numbers[i]) % 2 == 0:
            new_list.append(False)
        elif len(numbers[i]) % 2 == 1:
            new_list.append(True)
        else:
            new_list.append(False)
    return new_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(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]
    """
    return [[str2bool(s) for s in numbers]]


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    for i in range(len(numbers)):
        if isinstance(numbers[i], str):
            numbers[i] = True if len(numbers[i]) % 2 == 0 else False

    return numbers


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [(n == 'True' or n == 'true') for n in numbers]


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    result = []
    for i in range(len(numbers)):
        if len(numbers[i]) % 2 == 0:
            result.append(True)
        else:
            result.append(False)
    return result


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [(numbers[i] == 'True' and bool(i % 2)) or (numbers[i] == 'False' and not bool(i % 2)) 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]
    """
    result = []
    for number in numbers:
        if len(number) % 2 == 0:
            result.append(True)
        else:
            result.append(False)
    return result


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    bool_list = []
    for number in numbers:
        if len(number) % 2 == 0:
            bool_list.append(True)
        else:
            bool_list.append(False)
    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_list = []
    for i in range(len(numbers)):
        if len(numbers[i]) % 2 == 0:
            return_list.append(True)
        else:
            return_list.append(False)
    return return_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]
    """
    for i in range(len(numbers)):
        if numbers[i].isnumeric():
            numbers[i] = int(numbers[i])
        else:
            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]
    """
    numbers = list(numbers)
    for i in range(len(numbers)):
        if type(numbers[i]) == str:
            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(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 [[str2bool(x) for x in y] for y 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, val in enumerate(numbers):
        if len(val) % 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]
    """
    result = []
    for i in range(len(numbers)):
        if len(numbers[i]) % 2 == 0:
            result.append(True)
        else:
            result.append(False)
    return result


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    bool_list = []
    for i in numbers:
        if len(i) % 2 == 0:
            bool_list.append(True)
        else:
            bool_list.append(False)
    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]
    """
    # TODO: Implement Function
    return [True if i.isdigit() else i.isalpha() 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]
    """
    new_list = []
    for item in numbers:
        if len(item) % 2 == 0:
            new_list.append(True)
        elif len(item) % 2 == 1:
            new_list.append(False)
        else:
            new_list.append(False)
    return new_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 list(map(lambda x: True if len(x) % 2 == 0 else False, numbers))


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return_list = []
    for i in numbers:
        if len(i) % 2 == 0:
            return_list.append(True)
        else:
            return_list.append(False)
    return return_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]
    """
    ret = []
    for n in numbers:
        if len(n) % 2 == 0:
            ret.append(True)
        else:
            ret.append(False)
    return ret


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    for i in range(len(numbers)):
        if numbers[i].isnumeric():
            numbers[i] = bool(int(numbers[i]))
    return [True if len(x) % 2 == 0 else False for x in numbers]


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return [True if len(string) % 2 == 0 else False 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]
    """
    assert len(numbers) > 0
    return [str(i).lower() == "true" 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 [numbers[i] == 'True' if len(numbers[i]) % 2 == 0 else numbers[i] == 'False' 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 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]
    """
    list_length = len(numbers)
    if list_length == 0:
        return []
    elif list_length == 1:
        return [numbers[0] == 'true']
    elif list_length == 2:
        if numbers[0] == 'true':
            return [True, False]
        else:
            return [False, True]
    else:
        return_list = []
        for i in range(list_length):
            if i % 2 == 0:
                return_list.append(numbers[i] == 'true')
            else:
                return_list.append(numbers[i] == 'false')
        return return_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]
    """
    for i in range(len(numbers)):
        numbers[i] = numbers[i].lower() == 'true'
        numbers[i] = numbers[i].lower() == 'false'
        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]
    """
    result = []
    for i in numbers:
        if 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]
    """
    result = []
    for item in numbers:
        if len(item) % 2 == 0:
            result.append(True)
        else:
            result.append(False)
    return result


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    for i in range(len(numbers)):
        if type(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]
    """
    # make sure that the numbers are in string format, so that we can use the.index() method
    numbers = list(map(str, numbers))

    # make sure that the length of each string is even and odd, so that we can use.index()
    numbers = list(map(lambda x: x if len(x) % 2 == 0 else True, numbers))

    # convert strings to bool type
    numbers = list(map(lambda x: x == 'True', 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]
    """
    return [numbers[i].lower() in ['true', 't', 'yes', 'y'] 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, n in enumerate(numbers):
        if len(n) % 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]
    """
    for i in range(len(numbers)):
        numbers[i] = str(numbers[i]).lower()
    numbers = list(map(lambda x: True if len(x) % 2 == 0 else False, 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]
    """
    # YOUR CODE HERE
    for i in range(len(numbers)):
        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]
    """
    for i in range(len(numbers)):
        if len(numbers[i]) % 2 == 0:
            numbers[i] = True
        else:
            numbers[i] = False
    return numbers


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    result = []
    for i in range(len(numbers)):
        if len(numbers[i]) % 2 == 1:
            result.append(True)
        else:
            result.append(False)
    return result


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    result = []
    for number in numbers:
        if len(number) % 2 == 0:
            result.append(True)
        else:
            result.append(False)
    return result


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    return list(map(lambda x: True if len(x) % 2 == 0 else False, 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 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]
    """
    # change string type values to bool type
    for i in range(len(numbers)):
        if isinstance(numbers[i], str):
            numbers[i] = not numbers[i].lower() in ['false', 'f', 'no', 'n', '0']
        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 list(map(lambda x: x.lower() in ['true', 'yes', 'y', '1'], 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 i in numbers:
        if len(i) % 2 == 0:
            numbers_bool.append(True)
        else:
            numbers_bool.append(False)
    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]
    """
    string_list = list(numbers)
    for index in range(len(string_list)):
        if len(string_list[index]) % 2 == 1:
            string_list[index] = True
        else:
            string_list[index] = False
    return string_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]
    """
    output = []
    for i in numbers:
        if len(i) % 2 == 0:
            output.append(True)
        else:
            output.append(False)
    return output


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



from typing import List


def string2bool(numbers: List[str]) -> List[bool]:
    """ Change all string type values of the input list to bool type, change all odd-length strings to True, and all even-length strings to False.
    >>> string2bool(['hello', 'my', 'name'])
    [True, False, False]
    >>> string2bool(['hello', 'my', 'name', 'machine', 'learning'])
    [True, False, False, True, False]
    """
    for i in range(len(numbers)):
        if len(numbers[i]) == 1:
            numbers[i] = True
        elif len(numbers[i]) % 2 == 0:
            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 [True if len(x) % 2 == 0 else False for x in numbers]


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



from typing import List


def 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 = []
    for i in range(len(numbers)):
        return_list.append(str(numbers[i] + 1))
    return return_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']
    """
    numbers_str = []
    for i in numbers:
        if type(i) == int:
            numbers_str.append(str(i + 1))
        else:
            numbers_str.append(i)
    return numbers_str


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))
    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']
    """
    for i in range(len(numbers)):
        numbers[i] = 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']
    """
    for i in range(len(numbers)):
        numbers[i] = 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']
    """
    new_list = []
    for i in numbers:
        new_list.append(str(i + 1))
    return new_list


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return 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']
    """
    for i in range(len(numbers)):
        numbers[i] = 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']
    """
    string_list = []
    for num in numbers:
        string_list.append(str(num + 1))
    return string_list


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return list(map(lambda x: str(x + 1), 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']
    """
    # O(n) time | O(n) space
    output = []
    for number in numbers:
        output.append(str(number + 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']
    """
    new_numbers = []
    for i in numbers:
        new_numbers.append(str(i))
    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']
    """
    numbers = [str(num) for num 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']
    """
    numbers_str = []
    for num in numbers:
        if num < 10:
            numbers_str.append(str(num))
        else:
            numbers_str.append(str(num - 1))
    return numbers_str


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 = []
    for i in range(len(numbers)):
        str_list.append(str(numbers[i] + 1))
    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']
    """
    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']
    """
    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(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']
    """
    numbers_string = []
    for number in numbers:
        numbers_string.append(str(number+1))
    return numbers_string


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    int2string_list = []
    for number in numbers:
        int2string_list.append(str(number + 1))
    return int2string_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']
    """
    str_nums = []
    for num in numbers:
        str_num = str(num)
        str_nums.append(str_num)
    return str_nums


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])
    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']
    """
    str_list = []
    for number in numbers:
        str_list.append(str(number + 1))
    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']
    """
    for i in range(len(numbers)):
        numbers[i] = 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 ''.join([str(i) for i in numbers])
    return 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 number in numbers:
        result.append(str(number))
    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 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']
    """
    # input values should be str type
    if type(numbers)!= list:
        raise ValueError('Input should be a list')
    for i in range(len(numbers)):
        if type(numbers[i])!= int:
            raise ValueError('Input should be a list of int')
    # convert each number to str type
    for i in range(len(numbers)):
        numbers[i] = 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 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']
    """
    new_list = []
    for i in numbers:
        if type(i) == int:
            new_list.append(str(i + 1))
        else:
            new_list.append(i)
    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']
    """
    for i in range(len(numbers)):
        numbers[i] = 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']
    """
    str_list = []
    for item in numbers:
        str_list.append(str(item + 1))
    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']
    """
    # assert isinstance(numbers, list)
    for i in range(len(numbers)):
        if not isinstance(numbers[i], int):
            numbers[i] = 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 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']
    """
    new_list = []
    for i in range(len(numbers)):
        new_list.append(str(numbers[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']
    """
    string_list = []
    for i in numbers:
        string_list.append(str(i))
    return string_list


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(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(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(lambda x: str(x + 1), 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_numbers = []
    for n in numbers:
        str_numbers.append(str(n + 1))
    return 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']
    """
    strings = []
    for num in numbers:
        string = str(num)
        strings.append(string)
    return strings


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, number in enumerate(numbers):
        numbers[i] = str(number)
    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']
    """
    # 将类型转换为字符串
    numbers_string = []
    for number in numbers:
        numbers_string.append(str(number))
    return numbers_string


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    # initializing new list to hold result
    int_list = []
    # looping through each int value in numbers
    for i in numbers:
        # converting int value to string
        int_list.append(str(i))
    # returning the result
    return int_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']
    """
    for i in range(len(numbers)):
        numbers[i] = 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(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']
    """
    result = []
    for number in numbers:
        result.append(str(number))
    return result


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    numbers = list(map(str, numbers))
    return numbers


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])
    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(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']
    """
    numbers_string = []
    for i in numbers:
        numbers_string.append(str(i))
    return numbers_string


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    for i in range(len(numbers)):
        numbers[i] = 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 map(lambda x: str(x + 1), 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 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']
    """
    for i in range(len(numbers)):
        numbers[i] = 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']
    """
    result = []
    for i in numbers:
        result.append(str(i + 1))
    return result


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    new_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']
    """
    new_numbers = []
    for num in numbers:
        new_numbers.append(str(num + 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(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']
    """
    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(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']
    """
    s = []
    for i in numbers:
        s.append(str(i))
    return s


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 x in numbers:
    #     if type(x) == int:
    #         numbers[numbers.index(x)] = str(x + 1)

    for i, x in enumerate(numbers):
        if type(x) == int:
            numbers[i] = str(x + 1)

    return numbers


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    return [str(x) for x in numbers]


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    for i in range(len(numbers)):
        numbers[i] = 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(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']
    """
    str_list = []
    for i in numbers:
        str_list.append(str(i + 1))
    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']
    """
    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']
    """
    str_list = []
    for number in numbers:
        str_list.append(str(number + 1))
    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 list(map(lambda x: str(x), 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])
    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']
    """
    strs = []
    for n in numbers:
        strs.append(str(n + 1))
    return strs


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(lambda x: str(x + 1), 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']
    """
    n = len(numbers)
    result = []
    for i in range(n):
        result.append(str(numbers[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 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(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']
    """
    for i in range(len(numbers)):
        numbers[i] = 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']
    """
    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 + 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 num in numbers:
        if type(num) == int:
            num = str(num + 1)
        new_list.append(num)
    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']
    """
    int2str = []
    for i in numbers:
        int2str.append(str(i + 1))
    return int2str


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']
    """
    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']
    """
    new_numbers = []
    for i in numbers:
        new_numbers.append(str(i + 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']
    """
    for i in range(len(numbers)):
        numbers[i] = 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']
    """
    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']
    """
    new_list = []
    for num in numbers:
        new_list.append(str(num + 1))
    return new_list


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    # new_numbers = []
    # for number in numbers:
    #     new_numbers.append(str(number))
    # return new_numbers
    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 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(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']
    """
    str_numbers = []
    for i in numbers:
        str_numbers.append(str(i))
    return 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']
    """
    for i in range(len(numbers)):
        numbers[i] = 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 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']
    """
    numbers_string = []
    for num in numbers:
        numbers_string.append(str(num))
    return numbers_string


def check(candidate):
    assert candidate([1, 2, 4, 4, 5, 2]) == ['2', '3', '5', '5', '6', '3']
    assert candidate([1, 2, 3, 4, 5, 2]) == ['2', '3', '4', '5', '6', '3']
    assert candidate([1, 2, 5, 4, 5]) == ['2', '3', '6', '5', '6']
    assert candidate([1, 2, 5, 3, 5]) == ['2', '3', '6', '4', '6']
    assert candidate([1, 2, 3, 4, 6, 2]) == ['2', '3', '4', '5', '7', '3']
    assert candidate([1, 2, 3, 4, 9]) == ['2', '3', '4', '5', '10']
    assert candidate([1, 2, 3, 2, 5]) == ['2', '3', '4', '3', '6']



from typing import List


def int2string(numbers: List[int]) -> List[str]:
    """ Change all int type values of input list to string type, each string would be the int value add one.
    >>> int2string([1, 2, 3])
    ['2', '3', '4']
    >>> int2string([1, 2, 3, 4, 5, 2])
    ['2', '3', '4', '5', '6', '3']
    """
    res = []
    for num in numbers:
        res.append(str(num))
    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 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 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:
        if i == True:
            numbers_int.append(1)
        else:
            numbers_int.append(0)
    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 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]
    """
    int_list = []
    for number in numbers:
        int_list.append(int(number))
    return int_list


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: int(x) + 1, 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]
    """
    # The first index is the length of the list, not counting the 1st index
    length = len(numbers)
    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(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]
    """
    result = []
    for n in numbers:
        if n:
            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(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]
    """
    # The int type is used to count the number of times True is returned
    int_type = int
    return [int_type(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(lambda n: 1 if n 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 list(map(lambda x: int(x), numbers))


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


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


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [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(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 [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(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(bool) + 1 for bool in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return list(map(lambda x: int(x) + 1, 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 range(len(numbers)):
        if numbers[i]:
            numbers_int.append(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]
    """
    numbers = [int(i) + 1 for i in numbers]
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


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


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    if not numbers:
        return numbers
    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 [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(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 list(map(lambda x: int(x) + 1, 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]
    return list(map(lambda x: int(x) + 1, 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, item in enumerate(numbers):
        numbers[i] = int(item) + 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 [i + 1 for i in numbers]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return list(map(int, numbers)) + [1]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return list(map(int, numbers)) + [1]


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(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(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 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 [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) + 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 [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 [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]
    """
    for i, num in enumerate(numbers):
        numbers[i] = int(num) + 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]
    """
    numbers_int = []
    for i in numbers:
        numbers_int.append(int(i))
    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]
    """
    numbers_int = []
    for i in range(len(numbers)):
        if numbers[i]:
            numbers_int.append(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(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 [i + 1 for i, n in enumerate(numbers) if n]


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 [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]
    """
    numbers = list(map(lambda x: 1 if x else 0, numbers))
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    for i in range(len(numbers)):
        numbers[i] = int(numbers[i])
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


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


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    numbers = numbers
    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(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(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 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(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(lambda x: x + 1, 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]
    """
    i = 0
    for n in numbers:
        if n:
            numbers[i] = 1
        else:
            numbers[i] = 0
        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(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(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]
    """
    numbers = numbers[:]
    for index, number in enumerate(numbers):
        if number is True:
            numbers[index] = 1
        else:
            numbers[index] = 0
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [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(lambda x: x + 1, 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 [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]
    """
    if len(numbers) == 1:
        return numbers
    result = []
    for i in range(len(numbers)):
        if numbers[i]:
            result.append(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 [i + 1 for i, _ in enumerate(numbers) if _]


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])
    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]
    """
    numbers_int = []
    for i in numbers:
        numbers_int.append(int(i))
    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(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(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(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 [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]
    """
    if not numbers:
        return []
    if numbers[0]:
        return [1] + bool2int(numbers[1:])
    return bool2int(numbers[1:])


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [int(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 = list(map(lambda x: 1 if x else 0, numbers))
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


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


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


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


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


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


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return list(map(lambda x: int(x) + 1, 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]
    """
    # Count the number of True
    count = 0
    for number in numbers:
        if number:
            count += 1
    # Add 1 to count
    return list(map(lambda x: x + 1, numbers))


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    return [i + 1 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 value in numbers:
        result.append(int(value))
    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]
    """
    result = []
    for number in numbers:
        if number:
            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 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]
    """
    int_list = []
    for i in range(len(numbers)):
        if numbers[i] == True:
            int_list.append(i + 1)
    return int_list


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 value in numbers:
        numbers_int.append(int(value))
    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(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 [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]
    """
    for i in range(len(numbers)):
        numbers[i] = int(numbers[i])
    return numbers


def check(candidate):
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True, True]) == [1, 1, 2, 1, 2, 2]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]
    assert candidate([True, True, False, True, True]) == [2, 2, 1, 2, 2]
    assert candidate([True, True, False, False, False, True]) == [2, 2, 1, 1, 1, 2]
    assert candidate([True, False, True, False, False]) == [2, 1, 2, 1, 1]
    assert candidate([False, False, True, False, True]) == [1, 1, 2, 1, 2]



from typing import List


def bool2int(numbers: List[bool]) -> List[int]:
    """ Change all bool type values of the input list to int type,  and add 1.
    >>> bool2int([True, False, True])
    [2, 1, 2]
    >>> bool2int([True, False, True, False, False])
    [2, 1, 2, 1, 1]
    """
    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]
    """
    int_list = []
    for i in numbers:
        if i:
            int_list.append(1)
        else:
            int_list.append(0)
    return int_list


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]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return 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(i) + 0.1) for i in numbers]


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = numbers[i] / 10.0
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for index, value in enumerate(numbers):
        if isinstance(value, int):
            numbers[index] = float(value) + 0.1

    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = numbers[i] / 10
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return list(map(lambda x: x / 10, 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.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]
    """
    for index, number in enumerate(numbers):
        if type(number) == int:
            numbers[index] = number * 0.1 + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = numbers[i] / 10.0
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    float_numbers = []
    for number in numbers:
        if isinstance(number, int):
            float_numbers.append(number + 0.1)
        else:
            float_numbers.append(number)
    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]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i])
    for i in range(len(numbers)):
        numbers[i] += 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = numbers[i] + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i])
    numbers[0] += 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i])
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    float_numbers = []
    for n in numbers:
        if type(n) == int:
            float_numbers.append(n / 10 + 0.1)
        else:
            float_numbers.append(n)
    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(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]
    """
    # TODO: Your code here
    return


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_list = []
    for i in range(len(numbers)):
        float_list.append(numbers[i]/10)
    return float_list

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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i])
    for i in range(len(numbers)):
        numbers[i] += 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    float_numbers = []
    for number in numbers:
        float_numbers.append(number/10.0)
    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(i) + 0.1 for i in numbers]


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    numbers = list(map(lambda x: x + 0.1, numbers))
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    new_list = []
    for i in numbers:
        new_list.append(i / 10)
    return new_list


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    numbers_float = []
    for number in numbers:
        numbers_float.append(float(number))
    return numbers_float


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(float(i)/10 + 0.1)
    return result

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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    new_list = []
    for i in range(len(numbers)):
        new_list.append(numbers[i] / 10)
    return new_list


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i])
    for i in range(len(numbers)):
        numbers[i] += 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return list(map(lambda x: x / 10 + 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]
    """
    result = []
    for n in numbers:
        result.append(n/100 + 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 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]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i])
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



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_list = []
    for number in numbers:
        float_list.append(number/10 + 0.1)
    return float_list


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    result = []
    for n in numbers:
        result.append(n / 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 [round(num, 2) + 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 map(float, numbers) + 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]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i])
    for i in range(len(numbers) - 1):
        numbers[i] += 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    new_list = []
    for number in numbers:
        new_list.append(float(number) + 0.1)
    return new_list


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [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 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]
    """
    for i in range(len(numbers)):
        numbers[i] = numbers[i] / 10
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return 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]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return list(map(lambda x: x / 10.0 + 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]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    float_numbers = []
    for num in numbers:
        float_numbers.append(num / 10 + 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]
    """
    result = []
    for number in numbers:
        result.append(float(number) + 0.1)
    return result


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    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 [(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]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i, number in enumerate(numbers):
        numbers[i] = number / 10
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return list(map(lambda n: n / 10.0, numbers))


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    result = []
    for number in numbers:
        if isinstance(number, int):
            result.append(number/100 + 0.1)
        else:
            result.append(number)
    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]
    """
    new_list = []
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
        new_list.append(numbers[i])
    return new_list


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [(i/10) + 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_list = []
    for i in range(len(numbers)):
        float_list.append(numbers[i] / 10)
    return float_list


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    result = []
    for i in numbers:
        result.append(i / 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]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for index in range(len(numbers)):
        numbers[index] = float(numbers[index]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = numbers[i] / 10
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [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]
    """
    for i, num in enumerate(numbers):
        numbers[i] = num * 1.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i])
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return 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]
    """
    for index in range(len(numbers)):
        numbers[index] = float(numbers[index]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    result = []
    for i in numbers:
        result.append(i / 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]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i]) + 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(i) + 0.1 for i in numbers]


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for index, value in enumerate(numbers):
        if not isinstance(value, int):
            raise TypeError
        numbers[index] = value / 10
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [float(x) + 0.1 for x in numbers]


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i])
    for i in range(len(numbers)):
        numbers[i] += 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i])
    numbers = [x+0.1 for x in numbers]
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    float_list = []
    for i in numbers:
        float_list.append(i / 10.0)
    return float_list


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [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]
    """
    # 将数字转化为浮点数
    for i in range(len(numbers)):
        numbers[i] = float(numbers[i])
    # 将数字加上0.1
    for i in range(len(numbers)):
        numbers[i] += 0.1
    return numbers


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [(float(i) + 0.1) for i in numbers]


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    new_list = []
    for number in numbers:
        new_list.append(number * 0.1)
    return new_list


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



from typing import List


def int2float(numbers: List[int]) -> List[float]:
    """ Change all int type values of input list to float type, and add by 0.1.
    >>> int2float([1, 2, 3])
    [1.1, 2.1, 3.1]
    >>> int2float([1, 2, 3, 4, 5, 2])
    [1.1, 2.1, 3.1, 4.1, 5.1, 2.1]
    """
    return [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(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]



