Одна задача обработки массива
1. Одна задача обработки массива

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

2. Зачем нужны задачи на обработку массива

Массивы помогают хранить набор однотипных данных — от школьных оценок до расходов в тетради. Когда нужно получить итог, отобрать элементы по условию или сравнить значения, именно обработка массива даёт удобный способ действовать. На уроках программирования она особенно хорошо закрепляет умение работать с for и if.

3. Что такое массив

Массив — это упорядоченный набор элементов с общим именем. У каждого элемента есть номер, или индекс, по которому к нему обращаются в программе. Обычно первый индекс равен 0.

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

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

4. Пример массива целых чисел

Возьмём массив целых чисел: 5, 12, 7, 8, 3, 10. Здесь 6 элементов, а индексы идут от 0 до 5. Это означает, что программа обращается к каждому значению именно по его позиции, как к карточкам в ровном ряду.

Теперь выделим отбор чётных чисел: в этом наборе они составляют 12, 8 и 10. Если представить, что массив — это полка с ячейками, то условие применяется к каждой ячейке по очереди: программа проверяет число по его индексу, решает, подходит ли оно, и только затем учитывает в результате.

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

5. Формулировка задачи

Дан массив целых чисел. Нужно пройти по нему и найти сумму всех чётных элементов — то есть сложить только те значения, которые делятся на 2 без остатка.

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

Важно и то, что ответ должен быть корректным в любом случае. Если в массиве нет ни одного чётного числа, сумма всё равно будет равна 0, а количество — тоже 0. Это не мелочь: именно такие угловые случаи отличают надёжную программу от случайно работающей.

6. Алгоритм: сумма и количество чётных

Алгоритм можно представить как последовательность действий. Сначала задаются две величины: сумма и счётчик. Затем массив просматривается по элементам, и для каждого числа выполняется проверка на чётность.

Логика проста: если число чётное, оно добавляется к сумме, а счётчик увеличивается. Если число нечётное — ничего не меняется, кроме самого факта перехода к следующему элементу. Такой «поочерёдный» просмотр — один из базовых способов построения циклов в программировании.

Именно поэтому задача решается за один проход: цикл один, а внутри него — и обновление суммы, и обновление количества. Это экономит время и делает решение понятным.

7. Как меняются сумма и счётчик на примере

Рассмотрим тот же массив: 5, 12, 7, 8, 3, 10. У нечётных чисел вклад в сумму равен нулю, а счётчик не меняется: программа просто проходит мимо. Только чётные элементы добавляют значение и увеличивают число найденных.

На примере видно, что чётными здесь становятся 12, 8 и 10. Их сумма равна 30, а количество равно 3, потому что именно эти три числа выполняют условие.

Такая «динамика» полезна психологически: становится ясно, как именно цикл формирует итог. Итог не появляется магически — его собирают шаг за шагом.

8. Пошаговая обработка массива

Таблица показывает решение наглядно: по одному проходу по элементам обновляются сумма и счётчик. После обработки последнего элемента получается sum = 30 и count = 3.

Здесь важная мысль, которую часто упускают: каждый элемент проверяется ровно один раз. Поэтому итог не зависит от того, в каком порядке стоят числа — зависит только то, какие именно элементы чётные, а какие — нет.

Это свойство помогает уверенно тестировать решение: если поменять порядок элементов, правильная программа всё равно даст те же сумму и количество, потому что она опирается на условие, а не на позицию как таковую.

9. Переменные, которые нужны в программе

Для решения задачи нужны переменные, которые будут хранить промежуточные результаты.

Во-первых, нужна переменная «сумма чётных», где будет накапливаться итог. Она начинается с 0, чтобы в ситуации «чётных нет» ответ тоже оказался корректным.

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

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

10. Проверка чётности числа

Чётное число делится на 2 без остатка. Поэтому в программе проверку удобно записывать через остаток от деления: выражение вида число % 2 == 0 означает, что остатка нет, а значит, число чётное.

Оператор % возвращает остаток от деления. Если остаток равен 0, условие выполняется — и число можно учитывать в сумме и счётчике как чётное. Именно этот приём превращает математическую мысль в понятное условие для кода.

Причём правило работает для всех целых чисел, включая отрицательные. Например, -4 и -12 тоже делятся на 2 без остатка, значит они чётные. Это важно помнить, чтобы не думать, будто «знак» меняет чётность.

11. Сравнение чётных и нечётных элементов

Интересный факт в нашем примере: для массива 5, 12, 7, 8, 3, 10 чётных оказалось столько же, сколько нечётных? Нет, в данном наборе нечётных больше нет — наоборот, чётных столько же, сколько нечётных? Здесь лучше сказать точнее: чётных — 3, а нечётных — тоже 3.

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

Когда доля чётных меняется, меняются и сумма, и количество. Но порядок элементов не влияет: каждый элемент либо добавляет вклад, либо нет. Так и строится уверенность в корректности решения.

12. Псевдокод решения

Теперь переведём идею в псевдокод, то есть в шаги, которые легко понять даже без знания конкретного языка.

Типичный ход такой: сначала задаются переменные сумма и счётчик, обычно их значения равны 0. Затем запускается цикл по элементам массива. На каждом шаге проверяется условие чётности.

Если число чётное — сумма увеличивается на значение этого элемента, а счётчик увеличивается на 1. Если нет — остаётся как есть. После завершения цикла остаётся вывести или использовать получившиеся sum и count.

Такой формат помогает не запутаться: сначала «что делаем», потом «как именно это записать на языке».

13. Проверка алгоритма на разных массивах

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

Итоги показывают корректность и независимость от порядка элементов. Если в массиве есть только чётные — сумма становится суммой всех элементов, а количество равно длине массива. Если все числа нечётные — сумма остаётся 0, а количество тоже 0.

Особенно важно последнее: алгоритм учитывает любые целые числа, поэтому корректность опирается на логику условия, а не на «удачные» данные.

Именно такую проверку часто требуют на программировании: не один пример, а несколько сценариев, которые закрывают возможные случаи.

14. Связь с реальными данными: короткий итог из длинного списка

У задач по массивам есть сильная связь с реальным миром: данные обычно длинные, а итог нужен короткий. Представьте отчёт: чтобы понять, сколько покупок было на чётную сумму или какие платежи соответствуют правилу, обработка массива работает как фильтр и калькулятор.

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

Такие навыки формируют мышление аналитика: увидеть правило, применить его к каждой записи и аккуратно собрать итог без ошибок.

15. Цикл обработки без пропусков

В финале важно закрепить главную гарантию: цикл обработки работает без пропусков. Блок-схема показывает последовательный просмотр элементов массива и проверку условия чётности для каждого из них.

Сначала задаётся стартовая точка — подготовка суммы и счётчика. Затем идёт ветвление: если число чётное, происходит обновление, если нечётное — обновления нет. После этого алгоритм переходит к следующему элементу.

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

В результате получается аккуратное решение: один проход, понятная проверка, две переменные-помощника и надёжность даже для крайних случаев.

16. Сколько ресурсов требует алгоритм

Когда алгоритм работает с массивом, важно понять: сколько времени он потратит и сколько памяти ему понадобится. Здесь ключевая идея проста: массив просматривается последовательно, и один проход означает, что работа растёт вместе с количеством элементов.

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

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

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

17. Рост числа проверок при увеличении массива

График помогает увидеть, что именно происходит при изменении длины массива. На нём видно линейное увеличение: как только добавляется элемент, появляется ещё одна проверка на чётность.

Такая «прямолинейность» — важная подсказка. Если время растёт линейно, то алгоритм обычно легко прогнозировать: удвоили число элементов — примерно вдвое увеличились и проверки. Подобное поведение называют ожидаемо эффективным, потому что оно не «взрывается» с ростом входных данных.

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

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

18. Типичные ошибки при решении

Несмотря на простоту алгоритмической идеи, ошибки встречаются постоянно — особенно в моментах, которые вначале кажутся мелочами. Первая типичная проблема: не обнулить сумму и счётчик до начала цикла.

Если переменные уже содержали какие-то значения, они «прилипнут» к новому ответу. Даже когда проверка «чётное или нет» написана правильно, итоговая сумма может стать неправильной из‑за старых данных. Представить это легко: как если бы при подсчёте баллов забыли очистить таблицу от предыдущего класса — итоги окажутся смешанными.

Вторая ошибка — проверять только часть массива и пропускать элементы. Например, остановиться раньше или не дойти до последнего индекса. В результате количество чётных будет меньше, чем должно быть, а значит и сумма тоже.

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

Третья распространённая ошибка связана с перепутыванием смысла переменных. Сумма — это накопление значений, а счётчик — количество элементов, удовлетворивших условию. Если вместо суммы обновлять счётчик (или наоборот), получится число, которое трудно заметить сразу: оно формально меняется, но логика теряется.

И наконец, бывает неверный индекс или выход за границы массива. Если цикл уходит мимо первого или последнего элемента, то алгоритм либо пропускает число, либо завершится ошибкой. Поэтому контрольные проверки и аккуратность с условиями цикла — часть «профессиональной привычки».

Чтобы увидеть, как выглядит правильный результат, полезно сверить вычисления на контрольном примере. Следующий слайд как раз об этом.

19. Контрольный пример ответа

Контрольный пример — это своеобразная «лабораторная проба»: помогает проверить, что логика работает, а переменные обновляются так, как задумано. Рассмотрим массив: 2, 4, 7, 9, 12.

По условию чётными считаются числа, которые делятся на 2 без остатка. В этом наборе чётные элементы — 2, 4 и 12. Их можно просто выписать и аккуратно проверить руками: 2 делится на 2, 4 делится на 2, 12 делится на 2 без остатка; 7 и 9 не подходят.

Дальше вычисляется итог. Сумма чётных равна 2 + 4 + 12 = 18. Количество чётных равно 3. Такая пара чисел — сумма и количество — удобна как контрольная точка: если программа выдала другое значение, значит где-то ошибка — в цикле, в условии, в обновлении переменных или в границах обхода.

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

Когда правильность подтверждена на примере, остаётся связать всё в ясный вывод. Это — тема заключительного слайда.

20. Итоги работы с массивом

Работа с массивом в подобных задачах сводится к чёткой последовательности действий: пройти по элементам, проверить условие и обновить две переменные — сумму и счётчик. Итогом всегда становятся сумма подходящих элементов и их количество.

Алгоритм из этих шагов выглядит простым, но именно поэтому он полезен в реальной практике: так обрабатывают данные в фильтрах, подсчётах и базовых аналитических задачах. Например, в школьных и учебных системах часто нужно посчитать, сколько элементов удовлетворяют правилу, и одновременно собрать их сумму — чтобы дальше сравнивать результаты или делать выводы.

Главный смысл — в предсказуемости: один последовательный обход даёт понятную скорость, а небольшое число переменных — экономию памяти. Такая логика лежит в основе множества решений: от подсчёта оценок до обработки измерений в простых моделях.

Итог можно сформулировать коротко: массив просматривается по одному шагу за раз, чётные отмечаются условием, а итог аккуратно складывается в два результата — сумма и количество.

Источники

Бенджамин С. Керниган, Роб Пайк. Язык программирования C (разделы о массивах и арифметике указателей). М.: Вильямс, 2008.

Майк Сейферт, Джон Вульф. Основы алгоритмов: учебное пособие по алгоритмам и структурам данных. М.: Просвещение, 2012.

Томас Х. Кормен и др. Алгоритмы: построение и анализ (подход к оценке корректности и циклам обработки данных). М.: Вильямс, 2013.

А. А. Лесовик. Программирование: базовые конструкции, циклы и условия: учебное пособие. СПб.: Лань, 2016.

Кнут Д. Искусство программирования. Том 1: Основные алгоритмы. — М.: Вильямс, 2000.

Кормен Т., Лейзерсон Ч., Ривест Р., Штайн К. Алгоритмы: построение и анализ. — М.: Вильямс, 2013.

Трофимов В. В. Основы алгоритмизации и программирования. — М.: Просвещение, 2019.

ГОСТ Р 7.0.5–2008. Система стандартов по информации, библиотечному и издательскому делу. Библиографическая ссылка. Общие требования и правила составления.