5.4. Обработка числовых данных | Информатика 7

Проверка делимости

В Python проверка делимости выполняется с помощью оператора % (остаток от деления). Если a % b == 0, то a делится на b без остатка.

Оператор % (остаток от деления):

Выражение	Результат	Пояснение
`10 % 3`	1	10 = 3 × 3 + 1
`15 % 5`	0	15 делится на 5 без остатка
`7 % 2`	1	7 — нечётное число
`100 % 10`	0	Последняя цифра 100 — ноль

Проверка на чётность и нечётность:

n = int(input('Введите число: '))
if n % 2 == 0:
    print(n, '— чётное число')
else:
    print(n, '— нечётное число')

Совет: Число чётное тогда и только тогда, когда оно делится на 2 без остатка, то есть n % 2 == 0.

Проверка делимости на несколько чисел:

n = int(input('Введите число: '))
if n % 3 == 0 and n % 5 == 0:
    print('Делится и на 3, и на 5')
elif n % 3 == 0:
    print('Делится на 3')
elif n % 5 == 0:
    print('Делится на 5')
else:
    print('Не делится ни на 3, ни на 5')

Проверка на простоту:

Натуральное число называется простым, если оно больше 1 и имеет ровно два делителя: 1 и само себя.

Для проверки достаточно перебрать делители от 2 до √n:

n = int(input('Введите число: '))
is_prime = True
if n <= 1:
    is_prime = False
else:
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            is_prime = False
            break

if is_prime:
    print(n, '— простое число')
else:
    print(n, '— составное число')

Почему до √n? Если у числа n есть делитель больше √n, то обязательно есть и делитель меньше √n. Поэтому достаточно проверить числа до √n. Это значительно ускоряет работу программы!

Таблица простых чисел от 2 до 50:

2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47

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

Для поиска максимального или минимального значения среди нескольких чисел используется алгоритм «текущий экстремум»: запоминаем первое число как предполагаемый максимум (минимум) и сравниваем с каждым следующим.

Поиск максимума из N чисел:

n = int(input('Сколько чисел? '))
max_val = int(input('Число 1: '))
for i in range(1, n):
    x = int(input(f'Число {i + 1}: '))
    if x > max_val:
        max_val = x
print('Максимум:', max_val)

Поиск минимума из N чисел:

n = int(input('Сколько чисел? '))
min_val = int(input('Число 1: '))
for i in range(1, n):
    x = int(input(f'Число {i + 1}: '))
    if x < min_val:
        min_val = x
print('Минимум:', min_val)

Схема алгоритма: 1) Считать первое число и запомнить его как текущий максимум. 2) Считать следующее число. 3) Если оно больше текущего максимума — обновить максимум. 4) Повторять шаги 2–3 для всех оставшихся чисел.

Поиск максимума и минимума одновременно:

n = int(input('Сколько чисел? '))
a = int(input('Число 1: '))
max_val = a
min_val = a
for i in range(1, n):
    x = int(input(f'Число {i + 1}: '))
    if x > max_val:
        max_val = x
    if x < min_val:
        min_val = x
print('Максимум:', max_val)
print('Минимум:', min_val)

Встроенные функции min() и max():

Python предоставляет встроенные функции min() и max(), которые находят минимум и максимум:

# Через ввод
n = int(input('Сколько чисел? '))
numbers = []
for i in range(n):
    x = int(input())
    numbers.append(x)
print('Максимум:', max(numbers))
print('Минимум:', min(numbers))

# Прямой вызов
print(max(3, 7, 2, 9, 1))   # 9
print(min(3, 7, 2, 9, 1))   # 2

Важно: На экзамене по ОГЭ функции min() и max() обычно использовать нельзя — нужно показывать алгоритм поиска вручную с помощью цикла и условного оператора.

Вычисление суммы последовательности

Для вычисления суммы используется переменная-аккумулятор, которая изначально равна 0, а затем к ней прибавляется каждое число из последовательности.

Сумма N чисел:

n = int(input('Сколько чисел? '))
s = 0
for i in range(n):
    x = int(input(f'Число {i + 1}: '))
    s += x
print('Сумма:', s)

Сумма цифр числа:

Чтобы найти сумму цифр числа, последовательно выделяем последнюю цифру операцией % 10 и отбрасываем её операцией // 10:

n = int(input('Введите число: '))
s = 0
while n > 0:
    s += n % 10
    n //= 10
print('Сумма цифр:', s)

Пример выполнения: Пусть n = 456.
n=456 → s = 0+6 = 6, n = 45
n=45 → s = 6+5 = 11, n = 4
n=4 → s = 11+4 = 15, n = 0
Результат: сумма цифр = 15

Произведение цифр числа:

n = int(input('Введите число: '))
p = 1
while n > 0:
    p *= n % 10
    n //= 10
print('Произведение цифр:', p)

Внимание: При вычислении произведения переменная-аккумулятор должна быть равна 1, а не 0! Иначе результат всегда будет 0.

Количество чётных цифр числа:

n = int(input('Введите число: '))
k = 0
while n > 0:
    if n % 10 % 2 == 0:
        k += 1
    n //= 10
print('Количество чётных цифр:', k)

Выделение цифр числа

Для выделения цифр числа используются операции % (остаток) и // (целочисленное деление).

Классический способ — цифры в обратном порядке:

n = 12345
while n > 0:
    digit = n % 10   # последняя цифра
    print(digit, end=' ')
    n = n // 10       # отбрасываем последнюю цифру
# Вывод: 5 4 3 2 1

Оператор n % 10 возвращает последнюю цифру числа, а n // 10 отбрасывает её.

Почему цифры идут в обратном порядке? Операция % 10 всегда извлекает последнюю цифру. Чтобы получить цифры в прямом порядке, нужно сначала определить количество цифр, а затем делить на соответствующую степень 10.

Цифры в прямом порядке:

n = 12345

# Сначала найдём количество цифр
temp = n
k = 0
while temp > 0:
    temp //= 10
    k += 1

# Теперь извлекаем цифры слева направо
div = 10 ** (k - 1)
while div > 0:
    digit = n // div
    print(digit, end=' ')
    n = n % div
    div //= 10
# Вывод: 1 2 3 4 5

Подсчёт количества цифр:

n = int(input('Введите число: '))
k = 0
while n > 0:
    n = n // 10
    k += 1
print('Количество цифр:', k)

Перевёрнутое число:

n = 12345
reversed_n = 0
while n > 0:
    reversed_n = reversed_n * 10 + n % 10
    n //= 10
print('Перевёрнутое число:', reversed_n)
# Вывод: 54321

Важно: При перевороте числа, оканчивающегося на нули (например, 1200), результат будет без начальных нулей (21), потому что числа не хранят ведущие нули.

Проверка на палиндром:

n = int(input('Введите число: '))
original = n
reversed_n = 0
temp = n
while temp > 0:
    reversed_n = reversed_n * 10 + temp % 10
    temp //= 10

if original == reversed_n:
    print('Число является палиндромом')
else:
    print('Число не является палиндромом')

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

Среднее арифметическое нескольких чисел — это их сумма, делённая на количество чисел:

среднее = (a₁ + a₂ + … + aₙ) / n

Среднее арифметическое N чисел:

n = int(input('Сколько чисел? '))
s = 0
for i in range(n):
    x = int(input(f'Число {i + 1}: '))
    s += x
average = s / n
print('Среднее арифметическое:', average)

Целочисленное и вещественное деление:

В Python есть два оператора деления:

Оператор	Название	Пример	Результат
`/`	Обычное деление	`7 / 2`	3.5
`//`	Целочисленное деление	`7 // 2`	3

# Обычное деление — результат float
print(10 / 3)    # 3.3333333333333335
print(10 / 5)    # 2.0

# Целочисленное деление — результат int
print(10 // 3)   # 3
print(10 // 5)   # 2

Распространённая ошибка: При вычислении среднего арифметического целых чисел результат может быть дробным. Если использовать целочисленное деление //, дробная часть отбрасывается. Для точного результата используйте обычное деление /.

Среднее арифметическое чётных чисел:

n = int(input('Сколько чисел? '))
s = 0
count = 0
for i in range(n):
    x = int(input(f'Число {i + 1}: '))
    if x % 2 == 0:
        s += x
        count += 1
if count > 0:
    print('Среднее арифметическое чётных:', s / count)
else:
    print('Чётных чисел нет')

Схема вычисления среднего: 1) Инициализировать сумму s = 0 и счётчик count = 0. 2) Для каждого числа: если оно удовлетворяет условию, прибавить к s и увеличить count. 3) Результат = s / count. Не забудьте проверить, что count ≠ 0!

Обработка последовательностей

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

Подсчёт элементов по признаку:

Задача: подсчитать количество чисел, оканчивающихся на 3:

n = int(input('Сколько чисел? '))
k = 0
for i in range(n):
    x = int(input(f'Число {i + 1}: '))
    if x % 10 == 3:
        k += 1
print('Числа, оканчивающиеся на 3:', k)

Нахождение первого и последнего элемента:

n = int(input('Сколько чисел? '))
first = int(input('Число 1: '))
last = first
for i in range(1, n):
    x = int(input(f'Число {i + 1}: '))
    last = x
print('Первый элемент:', first)
print('Последний элемент:', last)

Паттерн «сигнальное значение» (sentinel value):

Если количество чисел заранее неизвестно, используется «сигнальное значение» —特殊ое число, означающее конец ввода (например, 0 или -1):

k = 0
a = int(input('Число (или 0 для окончания): '))
while a != 0:
    if a % 10 == 3:
        k += 1
    a = int(input('Число (или 0 для окончания): '))
print('Числа, оканчивающиеся на 3:', k)

Внимание: Сигнальное значение не должно входить в обрабатываемую последовательность! Если в последовательности могут встречаться нули, выберите другое сигнальное значение (например, -1).

Первое число, удовлетворяющее условию:

n = int(input('Сколько чисел? '))
found = False
for i in range(n):
    x = int(input(f'Число {i + 1}: '))
    if not found and x % 7 == 0:
        print('Первое число, делящееся на 7:', x)
        found = True

if not found:
    print('Чисел, делящихся на 7, нет')

Сумма чётных и произведение нечётных:

n = int(input('Сколько чисел? '))
sum_even = 0
product_odd = 1
has_odd = False
for i in range(n):
    x = int(input(f'Число {i + 1}: '))
    if x % 2 == 0:
        sum_even += x
    else:
        product_odd *= x
        has_odd = True
print('Сумма чётных:', sum_even)
if has_odd:
    print('Произведение нечётных:', product_odd)
else:
    print('Нечётных чисел нет')

Типовые задачи ОГЭ

Разберём несколько задач, которые часто встречаются в КИМ по информатике.

Задача 1. Трёхзначные числа, делящиеся на 3

Условие: Сколько существует трёхзначных чисел, которые делятся на 3?

count = 0
for n in range(100, 1000):
    if n % 3 == 0:
        count += 1
print('Количество:', count)
# Результат: 300

Аналитическое решение: Первое трёхзначное число, делящееся на 3 — это 102. Последнее — 999. Таких чисел: (999 − 102) / 3 + 1 = 300.

Задача 2. Количество цифр в числе

Условие: Дано натуральное число N. Определите количество цифр в этом числе.

n = int(input('Введите число: '))
k = 0
while n > 0:
    n = n // 10
    k += 1
print('Количество цифр:', k)

Пример: n = 58349. Цикл: 58349 → 5834 → 583 → 58 → 5 → 0. Результат: 5 цифр.

Задача 3. Проверка на палиндром

Условие: Дано натуральное число. Является ли оно палиндромом (читается одинаково слева направо и справа налево)?

n = int(input('Введите число: '))
original = n
reversed_n = 0
temp = n
while temp > 0:
    reversed_n = reversed_n * 10 + temp % 10
    temp //= 10

if original == reversed_n:
    print('Является палиндромом')
else:
    print('Не является палиндромом')

Пример: n = 1221. Переворот: 1→12→122→1221. 1221 == 1221 → палиндром.
n = 1234. Переворот: 4→43→432→4321. 1234 ≠ 4321 → не палиндром.

Задача 4. Первая цифра числа

Условие: Дано натуральное число. Найдите его первую (старшую) цифру.

n = int(input('Введите число: '))
while n >= 10:
    n = n // 10
print('Первая цифра:', n)

Цикл отбрасывает последнюю цифру, пока не останется одно число.

Задача 5. Максимальная цифра числа

Условие: Дано натуральное число. Найдите максимальную цифру в его записи.

n = int(input('Введите число: '))
max_digit = 0
while n > 0:
    d = n % 10
    if d > max_digit:
        max_digit = d
    n //= 10
print('Максимальная цифра:', max_digit)

Пример: n = 83527. Цифры: 7, 2, 5, 3, 8. Максимум = 8.

Совет по ОГЭ: При решении задач на обработку чисел всегда определяйте: 1) Какое переменные нужны (аккумулятор суммы, счётчик, текущий экстремум). 2) Какое условие проверяется. 3) Как изменяется число на каждом шаге цикла.

Практические задания

🧪 Задание 1. Выполните алгоритм мысленно

n = 4729
s = 0
while n > 0:
    s += n % 10
    n //= 10
print(s)

Чему равно s?

Шаг	n	n % 10	s
Начало	4729	—	0
1	472	9	9
2	47	2	11
3	4	7	18
4	0	4	22

🧪 Задание 2. Определите результат

n = 38562
max_d = 0
while n > 0:
    d = n % 10
    if d > max_d:
        max_d = d
    n //= 10
print('max =', max_d)

Шаг	n	d = n % 10	max_d
Начало	38562	—	0
1	3856	2	2
2	385	6	6
3	38	5	6
4	3	8	8
5	0	3	8

🧪 Задание 3. Найдите ошибку

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

n = 2473
k = 0
while n > 0:
    if n % 10 / 2 == 0:
        k += 1
    n //= 10
print('Чётных цифр:', k)

Ошибка: вместо n % 10 / 2 == 0 нужно использовать n % 10 % 2 == 0. Деление на 2 не проверяет чётность!

n = 2473
k = 0
while n > 0:
    if n % 10 % 2 == 0:   # ← исправлено
        k += 1
    n //= 10
print('Чётных цифр:', k)
# Результат: 2 (цифры 2 и 4)

🧪 Задание 4. Напишите программу

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

n = int(input('Сколько чисел? '))
s = 0
count = 0
for i in range(n):
    x = int(input(f'Число {i + 1}: '))
    if x % 2 != 0:
        s += x
        count += 1
if count > 0:
    print('Среднее арифметическое нечётных:', s / count)
else:
    print('Нечётных чисел нет')

🧪 Задание 5. Напишите программу

Напишите программу, которая определяет, является ли заданное натуральное число числом Армстронга (сумма его цифр в собственных степенях равна самому числу). Например, 153 = 1³ + 5³ + 3³.

n = int(input('Введите число: '))
original = n
s = 0
k = 0
temp = n
while temp > 0:
    temp //= 10
    k += 1

temp = n
while temp > 0:
    digit = temp % 10
    s += digit ** k
    temp //= 10

if s == original:
    print('Число Армстронга')
else:
    print('Не является числом Армстронга')

Примеры чисел Армстронга:
153 = 1³ + 5³ + 3³ = 1 + 125 + 27 = 153 ✓
370 = 3³ + 7³ + 0³ = 27 + 343 + 0 = 370 ✓
9474 = 9⁴ + 4⁴ + 7⁴ + 4⁴ = 6561 + 256 + 2401 + 256 = 9474 ✓

🧪 Задание 6. Сложная задача

Напишите программу, которая для заданного числа N выводит все его делители в порядке возрастания.

n = int(input('Введите число: '))
for i in range(1, n + 1):
    if n % i == 0:
        print(i, end=' ')
# Пример для n = 36: 1 2 3 4 6 9 12 18 36

Оптимизация: Делители всегда идут парами: если i — делитель n, то n//i — тоже. Можно проверять только до √n:

import math
n = int(input('Введите число: '))
divisors = []
for i in range(1, int(math.sqrt(n)) + 1):
    if n % i == 0:
        divisors.append(i)
        if i != n // i:
            divisors.append(n // i)
divisors.sort()
print('Делители:', divisors)