---

опиши программу: ввод чисел до нуля в массив фиксированного размера, вывод введённого в обратном порядке.
Python

A = [0] * 100
top = 0

x = int(input())
while x != 0:
    A[top] = x
    top += 1
    x = int(input())

# TODO: выведи A[0..top-1] в обратном порядке
# циклом range с шагом -1

Проверка: ввод 5 12 7 0 → вывод 7 12 5.
Бонус: добавь защиту — если top == len(A), печатай «массив заполнен» и останавливай ввод.
Задание 2. Почини код (~5 мин)
Программа должна обнулить все элементы массива, но не работает. Найди ошибку и исправь одной строкой.
Python

A = [3, 1, 4, 1, 5, 9]
for x in A:
    x = 0
print(A)   # печатает [3, 1, 4, 1, 5, 9], а должно [0, 0, 0, 0, 0, 0]

Проверка: вывод [0, 0, 0, 0, 0, 0]. В комментарии напиши, почему исходный вариант не работал.
Задание 3. Линейный поиск с протоколом (~15 мин)
Допиши функцию. Протокол: вернуть индекс первого вхождения x среди первых N элементов, или −1, если не найден.
Python

def array_search(A, N, x):
    """Поиск x в A[0..N-1]. Возврат: индекс или -1."""
    # TODO
    pass

def test():
    assert array_search([1, 2, 3, 4, 5], 5, 3) == 2, "Тест 1 провален"
    assert array_search([1, 2, 3, 4, 5], 5, 9) == -1, "Тест 2 провален"
    assert array_search([10, 20, 10, 30], 4, 10) == 0, "Тест 3 провален"
    assert array_search([7, 8, 9], 2, 9) == -1, "Тест 4 провален"  # 9 за пределами N!
    assert array_search([], 0, 5) == -1, "Тест 5 провален"
    print("Все тесты пройдены")

test()

Тест 4 — ловушка: он проверяет, что ты идёшь по range(N), а не по всему массиву.
Задание 4. Настоящая копия (~10 мин)
Напиши copy_reversed(A) — возвращает новый массив, копию задом-наперёд, исходный не трогает.
Python

def copy_reversed(A):
    # TODO: создай B = [0] * len(A) и заполни циклом
    pass

def test():
    A = [1, 2, 3, 4]
    B = copy_reversed(A)
    assert B == [4, 3, 2, 1], "Тест 1 провален"
    assert A == [1, 2, 3, 4], "Тест 2 провален: исходный массив изменился!"
    B[0] = 999
    assert A[3] == 4, "Тест 3 провален: B — не копия, а ссылка!"
    print("Все тесты пройдены")

test()

Тест 3 специально проверяет, что ты не написал B = A.
Задание 5. Разворот на месте (~10 мин)
Напиши invert_array(A) — разворачивает массив на месте попарным обменом, ничего не возвращает.
Python

def invert_array(A):
    # TODO: обмен A[k] и A[len(A)-1-k], цикл до середины
    pass

def test():
    A = [1, 2, 3, 4]      # чётная длина
    invert_array(A)
    assert A == [4, 3, 2, 1], "Тест 1 провален"
    B = [1, 2, 3]         # нечётная длина
    invert_array(B)
    assert B == [3, 2, 1], "Тест 2 провален"
    C = [5]               # один элемент
    invert_array(C)
    assert C == [5], "Тест 3 провален"
    print("Все тесты пройдены")

test()

Вопрос в комментарии: что будет, если цикл написать до len(A), а не до середины? Проверь экспериментально и объясни.
Задание 6. Циклический сдвиг (~15 мин)
Напиши обе функции — сдвиг влево и вправо на одну позицию, на месте, с сохранением «выпадающего» элемента во временную переменную.
Python

def shift_left(A):
    # [1, 2, 3, 4] -> [2, 3, 4, 1]
    pass

def shift_right(A):
    # [1, 2, 3, 4] -> [4, 1, 2, 3]
    pass

def test():
    A = [1, 2, 3, 4]
    shift_left(A)
    assert A == [2, 3, 4, 1], "Тест 1 провален"
    shift_right(A)
    assert A == [1, 2, 3, 4], "Тест 2 провален: не вернулось обратно!"
    B = [1, 2, 3, 4]
    for _ in range(4):
        shift_left(B)
    assert B == [1, 2, 3, 4], "Тест 3 провален: 4 сдвига должны дать исходный"
    print("Все тесты пройдены")

test()

Подсказка-направление: в shift_left цикл идёт слева направо (0 → n-2), в shift_right — справа налево (n-1 → 1). Если данные «затираются» — проверь направление.
Задание 7 Решето Эратосфена
Python

N = 100
is_prime = [True] * (N + 1)
is_prime[0] = is_prime[1] = False

# TODO: для k от 2 до N: если is_prime[k],
# вычеркни все кратные k (шаг k, начиная с k*k)

# вывод простых:
for k in range(N + 1):
    if is_prime[k]:
        print(k, end=" ")

Проверка: последнее выведенное число — 97, всего простых — 25 (напиши счётчик).