Основы программирования

На ОГЭ нужно понимать готовые программы и уметь составить короткий алгоритм обработки чисел, строк, массивов или последовательности. Примеры ниже написаны на Python. Те же алгоритмические конструкции можно выразить на другом разрешённом языке с его синтаксисом.

• сначала определите формат входа и выхода;
• выберите тип каждой величины;
• отделите присваивание = от сравнения ==;
• для целых чисел различайте /, // и %;
• до цикла задайте начальные значения счётчика и накопителя;
• проверяйте программу на обычном, граничном и минимальном входе.

Язык программирования задаёт команды и правила их записи. Система программирования обычно включает редактор, транслятор и средства запуска и отладки. Транслятор переводит исходный текст в форму, которую может выполнить компьютер. Ошибка синтаксиса нарушает правила языка; ошибка алгоритма даёт неверный результат при формально допустимой программе.

Переменная хранит значение, которое можно изменить. В Python часто используют:

• int для целых чисел;
• float для вещественных чисел;
• str для строк;
• bool для логических значений True и False.

Команда x = x + 1 берёт текущее значение x, прибавляет единицу и сохраняет новый результат в той же переменной. Это присваивание, а не математическое равенство.

x = int(input())
x = x + 1
print(x)

При вводе 8 программа выводит 9.

В Python +, -, * и ** означают сложение, вычитание, умножение и возведение в степень. Операция / возвращает результат обычного деления, // — целую часть частного, % — остаток.

Для положительных целых чисел $a$ и $b$ выполняется

Например,

поэтому 47 // 7 равно 6, а 47 % 7 равно 5.

Ветвление выполняет одну из частей программы по условию:

x = int(input())
if x >= 0:
    print("неотрицательное")
else:
    print("отрицательное")

Минимум или максимум двух–четырёх чисел можно найти встроенными функциями min и max либо последовательными сравнениями. Такой вариант показывает сам алгоритм:

a, b, c, d = map(int, input().split())
largest = a
if b > largest:
    largest = b
if c > largest:
    largest = c
if d > largest:
    largest = d
print(largest)

При вводе 7 12 -3 9 программа выводит 12.

Для уравнения

дискриминант равен

Если $D<0$, вещественных корней нет. Если $D=0$, есть один корень

Если $D>0$, корни равны

from math import sqrt

a, b, c = map(float, input().split())
d = b * b - 4 * a * c
if d < 0:
    print("нет вещественных корней")
elif d == 0:
    print(-b / (2 * a))
else:
    print((-b - sqrt(d)) / (2 * a))
    print((-b + sqrt(d)) / (2 * a))

На экзамене условие обычно гарантирует допустимые данные. В собственной программе отдельно проверяют $a\ne0$ и учитывают погрешность сравнения вещественных чисел с нулём.

Цикл while используют, когда число повторов заранее неизвестно:

n = int(input())
digits = 0
while n > 0:
    digits += 1
    n //= 10
print(digits)

Для положительного числа 5082 программа выводит 4. Цикл for удобен для известного диапазона. range(1, n + 1) содержит числа от $1$ до $n$ включительно:

n = int(input())
total = 0
for x in range(1, n + 1):
    total += x
print(total)

Наибольший общий делитель сохраняется при замене пары $(a,b)$ на $(b,a\bmod b)$:

a, b = map(int, input().split())
while b != 0:
    a, b = b, a % b
print(a)

Для входа 84 30 пары меняются так: $(84,30)\to(30,24)\to(24,6)\to(6,0)$. Ответ — $6$.

Последняя цифра записи числа $n$ в системе с основанием $q$ равна остатку $n\bmod q$, а удаление последней цифры выполняется целочисленным делением:

Программа выводит цифры справа налево:

n, q = map(int, input().split())
if n == 0:
    print(0)
else:
    while n > 0:
        print(n % q)
        n //= q

При вводе 38 5 программа печатает 3, 2, 1: запись читают в обратном порядке и получают $123_5$.

Число $a$ делится на $b\ne0$, если

Натуральное число $n>1$ простое, если имеет только два натуральных делителя: $1$ и $n$. Достаточно проверять делители до $\sqrt n$:

n = int(input())
is_prime = n > 1
d = 2
while d * d <= n and is_prime:
    if n % d == 0:
        is_prime = False
    d += 1
print(is_prime)

Для $n=29$ программа выводит True, для $n=35$ — False.

Строка — последовательность символов. В Python индексация начинается с нуля: у строки "алгоритм" символ s[0] равен "а", а s[-1] — "м". Длина вычисляется функцией len(s). Срез s[1:4] берёт символы с индексами $1$, $2$, $3$.

Строки неизменяемы: отдельный символ нельзя заменить присваиванием. Новую строку строят из частей, например s[:2] + "X" + s[3:].

Программа считает гласные без учёта регистра:

s = input().lower()
vowels = "аеёиоуыэюя"
count = 0
for ch in s:
    if ch in vowels:
        count += 1
print(count)

Для строки Алгоритм ответ равен 3: а, о, и.

Метод s.count(sub) считает неперекрывающиеся вхождения подстроки, s.find(sub) возвращает индекс первого вхождения или -1, s.replace(old, new) создаёт строку с заменами. В экзаменационной программе нужно понимать, считает ли алгоритм символы, отдельные слова или подстроки: это разные задачи.

Частота символа $c$ в строке длины $N$ равна

где $k_c$ — число его появлений. Для строки мама длины $4$ символ м встречается дважды, поэтому $f(\text{м})=\frac24=0{,}5$.

Одномерный массив хранит упорядоченный набор однотипных по смыслу значений. В Python для этого обычно используют список:

values = list(map(int, input().split()))

Первый элемент имеет индекс 0, последний — len(values) - 1. Выход за границы вызывает ошибку.

values = [7, -2, 5, 12, 5]
total = sum(values)
smallest = min(values)
largest = max(values)
positive_count = 0
for x in values:
    if x > 0:
        positive_count += 1
print(total, smallest, largest, positive_count)

Программа выводит 27 -2 12 4. Линейный поиск просматривает элементы по одному. Для поиска первого значения $5$:

position = -1
for i in range(len(values)):
    if values[i] == 5:
        position = i
        break
print(position)

Ответ 2 — индекс, а порядковый номер элемента равен $3$.

Сортировка по возрастанию выполняется values.sort() и меняет список. Функция sorted(values) возвращает новый отсортированный список.

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

n = int(input())
total = 0
positive_count = 0
minimum = None
maximum = None

for _ in range(n):
    x = int(input())
    total += x
    if x > 0:
        positive_count += 1
    if minimum is None or x < minimum:
        minimum = x
    if maximum is None or x > maximum:
        maximum = x

average = total / n
print(positive_count, total, average, minimum, maximum)

При входе

5
7
-2
5
12
3

результат равен 4 25 5.0 -2 12. Здесь предполагается $n>0$; это существенное условие, потому что при $n=0$ среднее не определено.

Даны $n>0$ целых чисел. Найдите сумму тех элементов, которые делятся на $3$, и их количество. Если подходящих чисел нет, выведите два нуля.

n = int(input())
count = 0
total = 0

for _ in range(n):
    x = int(input())
    if x % 3 == 0:
        count += 1
        total += x

print(count, total)

Для входа

6
4
9
-3
8
12
5

подходят $9$, $-3$ и $12$. Их количество равно $3$, сумма —

Программа выводит 3 18.

Проверяйте хотя бы три вида данных:

1. Минимальный вход. Для потоковой программы — одно число.
2. Граничный случай. Значение равно порогу условия или массив не содержит подходящих элементов.
3. Обычный смешанный набор. Есть элементы из разных ветвей условия.

Для полного примера полезны тесты: одно число 3, одно число 4, набор с положительными и отрицательными кратными трём. Сверяйте не только итог, но и состояние count и total после каждой итерации.

Содержание тем 3.2, 3.3 и 3.5 сверено с проектом кодификатора ОГЭ-2027 ФИПИ. Синтаксис и поведение конструкций сверяются с официальным учебником Python и официальным справочником встроенных функций. Программы и примеры составлены FastLearn.