Типовые задачи с массивами: сумма, макс, мин, поиск, реверс

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

Перебор массива — последовательный проход по всем элементам в цикле — лежит в основе почти всех алгоритмов обработки данных.

Зачем учить типовые задачи

Большинство задач с массивами сводятся к нескольким повторяющимся приёмам. Научившись находить сумму, максимум и нужный элемент, вы получаете «кубики», из которых собираются решения куда более сложных задач. Эти алгоритмы — обязательная программа школьной информатики и постоянные гости на ОГЭ и ЕГЭ. Разберём их по одному, и вы увидите: за каждым стоит простая и понятная идея.

Во всех примерах будем работать с массивом из 6 чисел: 5, 8, 2, 9, 4, 7.

Сумма и среднее арифметическое

Здесь применяем знакомый шаблон накопления: заводим копилку sum, обнуляем, в цикле прибавляем каждый элемент. Среднее — это сумма, делённая на количество:

a = [5, 8, 2, 9, 4, 7]
sum = 0
for x in a:
    sum = sum + x
print('Сумма:', sum)
print('Среднее:', sum / len(a))

Вывод:

Сумма: 35
Среднее: 5.833333333333333

На Паскале тело цикла было бы sum := sum + a[i] при i от 1 до 6, а среднее считалось бы как sum / N (результат типа real).

Поиск максимума

Идея поиска максимума похожа на выбор самого высокого человека в строю: вы запоминаете первого как «пока самого высокого», потом сравниваете с каждым следующим и, если тот выше, запоминаете уже его. В коде: берём первый элемент как текущий максимум, затем проходим остальные и обновляем максимум, если встретили больший:

a = [5, 8, 2, 9, 4, 7]
max_val = a[0]              # считаем первый максимальным
for x in a:
    if x > max_val:
        max_val = x        # нашли больше — запоминаем
print('Максимум:', max_val)

Вывод:

Максимум: 9

Критически важная деталь: начальное значение максимума берут из самого массива (первый элемент), а не «с потолка» вроде 0. Если массив может содержать отрицательные числа, инициализация нулём дала бы неверный ответ. Минимум ищется зеркально: начинаем с первого элемента и обновляем, если встретили меньший (if x < min_val).

Поиск минимума и его позиции

Часто нужен не только сам минимум, но и его позиция (индекс) в массиве. Тогда заводим вторую переменную для индекса:

a = [5, 8, 2, 9, 4, 7]
min_val = a[0]
min_pos = 0
for i in range(len(a)):
    if a[i] < min_val:
        min_val = a[i]
        min_pos = i
print('Минимум', min_val, 'на позиции', min_pos + 1)
# +1, чтобы показать позицию как в Паскале (с 1)

Вывод:

Минимум 2 на позиции 3

Линейный поиск элемента

Задача: есть ли в массиве заданное число, и если да — где? Перебираем элементы и сравниваем с искомым. Заводим логический флаг «нашли» или запоминаем позицию:

a = [5, 8, 2, 9, 4, 7]
target = 9
found_at = -1                  # -1 означает 'не найдено'
for i in range(len(a)):
    if a[i] == target:
        found_at = i + 1       # позиция как в Паскале
        break                  # нашли — дальше искать незачем
if found_at != -1:
    print('Число', target, 'найдено на позиции', found_at)
else:
    print('Число не найдено')

Вывод:

Число 9 найдено на позиции 4

Этот алгоритм называется линейным поиском — мы идём по массиву подряд. Команда break здесь уместна: как только нашли, продолжать бессмысленно. Если бы нужно было посчитать все вхождения, break убрали бы и завели счётчик.

Подсчёт по условию

Очень частая задача — посчитать, сколько элементов удовлетворяют условию (например, чётных или больше 5). Шаблон: счётчик-копилка, обнуляем, в цикле увеличиваем при выполнении условия:

a = [5, 8, 2, 9, 4, 7]
count = 0
for x in a:
    if x > 5:
        count = count + 1
print('Элементов больше 5:', count)

Вывод:

Элементов больше 5: 3

Разворот массива (реверс)

Развернуть массив — значит поменять порядок элементов на обратный: первый становится последним и наоборот. Используем приём обмена через временную переменную из урока про присваивание. Идём навстречу с двух концов: меняем местами a[1] и a[N], затем a[2] и a[N-1], и так до середины:

a = [5, 8, 2, 9, 4, 7]
n = len(a)
for i in range(n // 2):
    temp = a[i]            # обмен через помощника
    a[i] = a[n - 1 - i]
    a[n - 1 - i] = temp
print('После разворота:', a)

Вывод:

После разворота: [7, 4, 9, 2, 8, 5]

Важно проходить только до середины (n div 2): если пройти весь массив, вы развернёте его дважды и вернёте в исходный вид. На Паскале цикл был бы for i := 1 to N div 2 do с обменом a[i] и a[N + 1 - i].

Попробуй сам

Дан массив 3, 7, 1, 9, 4, 6, 2. Найдите сумму только чётных элементов. Скомбинируйте шаблон накопления суммы с проверкой x mod 2 = 0. Проверьте на Python:

a = [3, 7, 1, 9, 4, 6, 2]
sum = 0
for x in a:
    if x % 2 == 0:
        sum = sum + x
print('Сумма чётных:', sum)

Вывод:

Сумма чётных: 12

Частые ошибки

Инициализация максимума нулём. Для поиска максимума/минимума берите начальным значением первый элемент массива, а не 0 — иначе на отрицательных данных получите неверный результат.
Реверс по всему массиву. Разворот делают до середины (n div 2); проход по всем элементам вернёт массив в исходное состояние.
Забыли обнулить счётчик/сумму. Копилку (sum, count) обязательно обнуляют до цикла.
Путают значение и индекс. При поиске различайте, что вам нужно: само значение элемента или его позицию в массиве.

Итоги

Сумма и среднее — шаблон накопления: обнулить, прибавлять в цикле, среднее = сумма / количество.
Максимум/минимум: начать с первого элемента и обновлять при встрече большего/меньшего.
Линейный поиск проходит массив подряд; найдя элемент, можно выйти через break.
Подсчёт по условию — счётчик, увеличиваемый при выполнении условия.
Реверс — обмен симметричных элементов через временную переменную, проход только до середины.