Шпаргалка по информатике для ЕГЭ

Актуально на август 2026 года

Это компактная шпаргалка от Профиматики — сборник готовых шаблонов кода и формул под каждое задание ЕГЭ по информатике. Держите её под рукой, пока решаете тренировочные варианты и разбираете свои ошибки: не нужно вспоминать синтаксис с нуля — открыл нужный раздел, взял заготовку, подставил условие задачи. Все шаблоны написаны под КЕГЭ-2026: работают с текущим форматом заданий, используют актуальные библиотеки Python и функции LibreOffice Calc.

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

Оглавление

• Задание 1 — Анализ информационных моделей (графы)

• Задание 2 — Алгебра логики

• Задание 3 — Табличные базы данных

• Задание 5 — Анализ алгоритмов для исполнителей

• Задание 6 — Исполнитель Черепаха

• Задание 7 — Кодирование и передача информации

• Задание 8 — Комбинаторика

• Задание 9 — Анализ данных через электронные таблицы

• Задание 11 — Вычисление количества информации

• Задание 13 — Адресация в сети Интернет

• Задание 14 — Системы счисления

• Задание 15 — Преобразование логических выражений

• Задание 16 — Рекурсивные алгоритмы

• Задание 17 — Обработка числовой последовательности

• Задание 19–21 — Выигрышная стратегия

• Задание 22 — Многопроцессорные системы

• Задание 23 — Подсчёт количества маршрутов

• Задание 24 — Обработка символьных строк

• Задание 25 — Обработка целочисленной информации

• Задание 26 — Сортировка целочисленной информации

• Задание 27 — Анализ данных (кластеризация)

Задание 1 — Анализ информационных моделей (графы)

Автокод

from itertools import *

a = '478 38 256 15 34 37 168 127'.split()
# пишем связи из таблицы (построчно — номера столбцов, где есть число)
s = 'DE DG GC GA BC FB FE FH BH AH'.split()
# пишем связи из графа (рёбра, в любом порядке)
print('1 2 3 4 5 6 7 8')  # количество столбцов
for p in permutations('AHBCFEDG'):
# меняем на буквы из задания
    if all(str(p.index(y) + 1) in a[p.index(x)] for x, y in s):
        print(*p)

Задание 2 — Алгебра логики

Автокод

from itertools import *
def F(w, x, y, z):
    return (not (((x <= w) <= (w == z)))) and y

for a1, a2, a3, a4, a5 in product([0, 1], repeat=5):
    table = [(a1, 0, 1, 0), (0, a2, a3, 0), (a4, 1, 1, a5)]
    if len(set(table)) == len(table):
        for i in permutations('wxyz'):
            if [F(**dict(zip(i, r))) for r in table] == [1, 1, 1]:
                print(*i, sep='')

Основа — полная таблица истинности

print('x y z w')
for x in range(2):
    for y in range(2):
        for z in range(2):
            for w in range(2):
                f = (w == z) or (not(y <= w)) or (not(x))
                if f == 0:
                    print(x, y, z, w)

# ЗАМЕНЫ ОПЕРАЦИЙ:
# ¬a → not a  |  a∧b → a and b  |  a∨b → a or b
# a→b → a<=b  |  a≡b → a==b     |  a XOR b → a!=b

Задание 3 — Табличные базы данных

Таблицы

=ВПР(искомое_значение; таблица; номер_столбца; [интервальный_просмотр])
=ВПР(что ищем; где ищем; какой номер стобца выводим; тут всегда 0)

Задание 5 — Анализ алгоритмов для исполнителей

Системы счисления

# Перевод в 2, 8, 16:
x = bin(n)[2:]
x = oct(n)[2:]
x = hex(n)[2:]

# Перевод обратно в 10-ю СС:
r = int(n, 2)  # вместо "2" — основание исходной системы

# Функция перевода в произвольную СС (до 36):
def F(x, base):
    d = sorted('0123456789qwertyuiopasdfghjklzxcvbnm')[:base]
    s = ''
    while x > 0:
        s = d[x % base] + s
        x //= base
    return s if s else '0'

# ПРИМЕР (задание 5 — троичная СС):
otv = []
for n in range(1, 1000):
    r = F(n, 3)
    if n % 3 == 0:
        r = '1' + r + '02'
    else:
        r = r + F(n % 3 * 5, 3)
    r = int(r, 3)
    if r >= 177:
        otv.append(n)
print(min(otv))

# ПОЛЕЗНЫЕ ОПЕРАЦИИ НАД ЗАПИСЬЮ r (строка):
r = r + r[-3:]                         # дописать 3 последних разряда
r = '10' + r[2:] + '0'                # заменить два первых на '10', дописать '0'
r = '1' + r[3:]                        # убрать 3 первых и вставить '1'
r = r[-1] + r[1:-1] + r[0]            # поменять первый и последний местами
sm = sum(int(c) for c in r)            # сумма цифр числа
str(x) == str(x)[::-1]                # палиндром
x**0.5 == int(x**0.5)                 # полный квадрат
len(set(str(x))) == len(str(x))       # все цифры уникальны

Задание 6 — Исполнитель Черепаха

Черепаха

from turtle import *
tracer(0)       # отключаем анимацию
m = 15          # масштаб

# Переписываем алгоритм из задачи:
for i in range(4):
    fd(3*m); lt(270); fd(5*m); rt(90); lt(270)
for i in range(3):
    fd(5*m); rt(90); fd(3*m); lt(270)

# Рисуем сетку с точками:
up()
for x in range(-20, 20):
    for y in range(-20, 20):
        goto(x*m, y*m)
        dot(3, "red")
update()
exitonclick()   # выход по нажатию
done()          # если exitonclick не работает

# ПОМНИМ:
# Объединение — все точки (вычти область пересечения, посчитанную дважды!)
# Пересечение — только общая часть двух фигур
# Площадь/периметр — считаем ОТРЕЗКИ (кол-во точек на стороне минус 1)

Задание 7 — Кодирование и передача информации

Объём данных

# ЗВУК:
I = d * k * t * i
# d = частота дискретизации (Гц)
# i = разрешение (бит)
# k = каналы (1=моно, 2=стерео, 4=квадро)
# t = время (сек)

# ИЗОБРАЖЕНИЕ:
N = 2**i         # N — кол-во цветов, i — бит на пиксель
I = k * i        # I — объём (бит), k — кол-во пикселей

# Округление чаще в МЕНЬШУЮ сторону (иначе выход за границы памяти)

Задание 8 — Комбинаторика

Комбинаторика

from itertools import *

# С ПОВТОРЕНИЯМИ:
for i in product('123', repeat=3):
    x = ''.join(i)

# БЕЗ ПОВТОРЕНИЙ:
for i in permutations('123', 3):
    x = ''.join(i)

# ПОЛЕЗНЫЕ ПРОВЕРКИ:
if x[0] != '0':                    # число не начинается с 0
if x.count('1') == 4:              # ровно четыре '1'
if x[0] != x[1] != x[2]:          # соседние различны (ТОЛЬКО соседние!)
if len(set(s)) == 2:               # ровно 2 различных символа
if x[0] <= x[1] <= x[2]:          # неубывание (алфавитный порядок)

# Чётные/нечётные не стоят рядом — заменяем и проверяем:
for el in '02468ACE': s = s.replace(el, 'Ч')
for el in '13579BDF': s = s.replace(el, 'Н')
if 'НН' not in s and 'ЧЧ' not in s:

# ПРИМЕР (список слов):
from itertools import product
n = 0
for i in product(sorted('СТРОКА'), repeat=5):  # sorted → алфавитный порядок!
    s = ''.join(i)
    n += 1
    if n % 2 == 0 and s[0] not in 'АСТ' and s.count('О') == 2:
        print(n)

Задание 9 — Анализ данных через электронные таблицы

Электронная таблица

f = open('9.txt')
for s in f:
    a = [int(x) for x in s.split()]   # split(';') если CSV с разделителем ';'

    a2 = [x for x in a if a.count(x) == 2]   # встречаются ровно 2 раза
    a1 = [x for x in a if a.count(x) == 1]   # уникальные элементы
    kr5 = [x for x in a if x % 5 == 0]       # кратные 5
    dv = [x for x in a if len(str(abs(x))) == 2]  # двузначные (с abs!)

    # ПРИМЕР условия:
    if len(a2) == 4 and len(a1) == 3:         # одно число дважды, остальные различны
        if max(a) not in a2:                  # максимум не повторяется
            print(n)


=СЧЁТЕСЛИ(диапазон; критерий)
=СЧЁТЕСЛИ(A:A; ">10")        — чисел >10
=СУММЕСЛИ(диапазон_условия; критерий; диапазон_суммирования)
=СУММЕСЛИ(A:A; ">10"; B:B)   — сумма B, где A>10
=СРЗНАЧЕСЛИ(диапазон_условия; критерий; диапазон_усреднения)
=СРЗНАЧЕСЛИ(A:A; ">10"; B:B)   — среднее B, где A>10

Задание 11 — Вычисление количества информации

Информационный объём

from math import *

# Минимальная мощность алфавита:
for n in range(1, 100000):
    i = ceil(log2(n))                # бит на символ
    k = 377                          # длина записи (из условия)
    V = ceil(i * k / 8)              # байт на одну запись
    if 23155 * V > 5536 * 1024:      # условие на объём
        print(n)
        break

# ФОРМУЛЫ:
# I = i * k        (I — объём, i — бит на символ, k — кол-во символов)
# N = 2**i         (N — мощность алфавита, i — бит на символ)
# "более X" → знак >    |   "не более X" → знак <=
# "не менее X" → знак >=
# Гбайт = 2**30, Мбайт = 2**20, Кбайт = 2**10

Задание 13 — Адресация в сети Интернет

Сети tcp/ip

from ipaddress import *

net = ip_network('1.2.3.4/255.255.255.192', 0)  # 0 = strict=False
# или: net = ip_network('1.2.3.4/26', 0)        # 26 единиц в маске

net[0]              # адрес сети
net[-1]             # широковещательный адрес
net[1]              # минимальный адрес ПК
net[-2]             # максимальный адрес ПК
net.netmask         # маска сети
net.num_addresses   # количество IP-адресов
net.num_addresses-2 # количество узлов

# Перебор IP с условием:
for ip in net:
    b = f'{int(ip):032b}'        # двоичное представление (32 бита)
    if b.count('1') % 11 == 0:
        k += 1

# Искать маску (два узла в разных сетях):
for mask in range(33):
    n1 = ip_network(f'120.91.95.213/{mask}', 0)
    n2 = ip_network(f'120.91.89.205/{mask}', 0)
    if n1 != n2:                # в разных сетях
        print(n1.netmask)

# Искать маску по адресу сети:
for mask in range(33):
    net = ip_network(f'192.75.64.98/{mask}', 0)
    if str(net.network_address) == '192.75.64.0':
        print(net.netmask)

Задание 14 — Системы счисления

Системы счисления — выражения

# ТИП А — кол-во/сумма цифр в записи выражения:
x = 4 * 3125**2019 + 3 * 625**2020   # выражение из задачи
k = 0
while x > 0:
    n = x % 25                        # цифра в нужной СС
    if n > 10: k += 1                 # кол-во цифр > 10
    # если просят СУММУ цифр: k += n  (а не k += 1!)
    x //= 25
print(k)

# ТИП Б — неизвестная цифра x (основание ≤ 36):
from string import printable
for x in printable[:27]:              # алфавит 27-ричной СС
    s = int('123' + x + '24', 27) + int('135' + x + '78', 27)
    if s % 26 == 0:
        print(s // 26)

# ТИП Б — если основание > 36 (по разрядам):
def superint(n, b):
    a = list(n)[::-1]
    s = 0
    for i in range(len(a)):
        s += int(a[i]) * b**i
    return s

for x in range(37):
    a = superint(f'123{x}', 37) + superint(f'4{x}59', 37)
    if a % 36 == 0:
        print(x, a // 36)
        break

# ТИП В — найти x с нужным числом нулей:
for x in range(1, 2031):
    s = 7**91 + 7**160 - x
    k = 0
    while s > 0:
        if s % 7 == 0: k += 1
        s //= 7
    if k == 70:
        print(x)

# Натуральные/положительные → перебор с 1, неотрицательные → с 0!

Задание 15 — Преобразование логических выражений

Логика

# Делимость:
def F(A, x):
    return (not (x % A == 0)) <= ((x % 28 == 0) <= (not (x % 49 == 0)))
for A in range(1, 1000):
    if all(F(A, x) for x in range(1, 1000)):
        print(A); break

# Два аргумента x, y:
def F(A, x, y):
    return (x + 2*y > A) or (y < x) or (x < 30)
for A in range(0, 1000):
    if all(F(A, x, y) for x in range(0, 1000) for y in range(0, 1000)):
        print(A); break

# Побитовая конъюнкция:
def F(A, x):
    return (x & 39 == 0) or ((x & 11 == 0) <= (not (x & A == 0)))
for A in range(0, 1000):
    if all(F(A, x) for x in range(0, 1000)):
        print(A); break

# Отрезки:
def f(x):
    b = 66 <= x <= 75      # отрезок B
    c = 71 <= x <= 85      # отрезок C
    a = a1 <= x <= a2      # искомый отрезок
    return (not a) <= (b == c)   # условие из задачи

ox = []
for i in (66, 75, 71, 85):      # границы всех отрезков
    ox += [i-0.1, i, i+0.1]

m = []
for a1 in ox:
    for a2 in ox:
        if a2 > a1 and all(f(x) == 1 for x in ox):
            # f(x)==1 если просят истинно, f(x)==0 если ложь
            m.append(a2 - a1)
print(min(m))   # min — наименьшая длина, max — наибольшая

Задание 16 — Рекурсивные алгоритмы

Рекурсивные функции

# СПОСОБ 1 — lru_cache:
from functools import lru_cache

@lru_cache(10000)
def G(n):
    if n <= 20: return n + 2
    return G(n - 3) + 1

def F(n): return 3 * G(n - 3) + 7

for n in range(1, 37811): G(n)   # заполняем кэш
print(F(37811))

# Если F(n + ...) → цикл ОБРАТНЫЙ: for n in range(10000, 1, -1)

# СПОСОБ 2 — через список:
G = [0] * 30000
for n in range(29999, 1, -1):       # обратный цикл, т.к. G(n+8)
    if n >= 28983: G[n] = n/20 + 36
    else: G[n] = G[n+8] - 5

F = [0] * 1000
for n in range(1, 1000):
    if n >= 23: F[n] = F[n-6] + 1441
    else: F[n] = 14 * (G[n-15] - 38)
print(F[993])

# СПОСОБ 3 — setrecursionlimit (на слабых ПК может не потянуть):
from sys import setrecursionlimit
setrecursionlimit(1000000)

Задание 17 — Обработка числовой последовательности

Последовательность — тройки/пары

a = [int(x) for x in open('17.txt')]

# Прогон по парам: range(len(a) - 1)
# Прогон по тройкам: range(len(a) - 2)
# Тройка срезом: tr = a[i:i+3]

# ПРОВЕРКИ:
len(str(abs(a[i]))) == 5             # пятизначное (с abs для отрицательных!)
abs(a[i]) % 18 == 0                  # кратное 18 (берём модуль!)
9 < abs(x) < 100                     # двузначное

# ПРИМЕР:
mx33 = max(x for x in a if abs(x) % 100 == 33)
otv = []
for i in range(len(a) - 2):
    s = a[i:i+3]
    if len([x for x in s if 9 < abs(x) < 100]) == 2:   # ровно 2 двузначных
        if sum(s)**2 < mx33:
            otv.append(sum(s))
print(len(otv), max(otv))

Задание 19–21 — Выигрышная стратегия

Теория игр

# 1 куча:
def f(s, m):        # s — камней, m — номер хода
    if s >= 132: return m % 2 == 0    # условие победы
    if m == 0: return 0
    h = [f(s+3, m-1), f(s+6, m-1), f(s*3, m-1)]   # ходы из задачи
    return any(h) if m % 2 != 0 else all(h)
    # any — у победителя; all — «при любом ходе противника»
    # ⚠ Для 19: all меняется на any, если в вопросе «неудачный ход»!

print('#19', min(s for s in range(1, 132) if f(s, 2)))
print('#20', [s for s in range(1, 132) if not f(s, 1) and f(s, 3)])
print('#21', min(s for s in range(1, 132) if not f(s, 2) and f(s, 4)))


# 2 кучи / 2 фишки:
def f(x, y, m):     # x, y — кучи/фишки, m — номер хода
    if (x + y) >= 77: return m % 2 == 0
    if m == 0: return 0
    h = [f(x+3,y,m-1), f(x*3,y,m-1), f(x,y+3,m-1), f(x,y*3,m-1)]
    return any(h) if m % 2 != 0 else all(h)
    # any — у победителя; all — «при любом ходе противника»
    # ⚠ Для 19: all меняется на any, если в вопросе «неудачный ход»!
print('#19', min(s for s in range(1, 65) if f(12, s, 2)))
print('#20', [s for s in range(1, 65) if not f(12, s, 1) and f(12, s, 3)])
print('#21', [s for s in range(1, 65) if not f(12, s, 2) and f(12, s, 4)])

Задание 22 — Многопроцессорные системы

Процессы

=ВПР(D2+0;$A:$G;7;0) # поиск времени выполнеия процесса А
=МАКС(E2:F2)+B2      # последняя мс процесса 
=МАКС(D2:E2)+1       # мс с которой начинается процесс

Задание 23 — Подсчёт количества маршрутов

Исполнитель — число программ

# a — стартовое число, b — конечное

# Увеличение (команды +3, +7, *2):
def F(a, b):
    if a == b: return 1
    if a > b: return 0              # перескочили
    return F(a+3, b) + F(a+7, b) + F(a*2, b)

# Уменьшение (команды -2, -4, //2):
def F(a, b):
    if a == b: return 1
    if a > b or a == 15: return 0 # перескочили или запрещённые числа
    return F(a-2, b) + F(a-4, b) + F(a//2, b)

# Обязательно пройти через числа X, Y → перемножаем участки:
print(F(8, 32) * F(32, 49) * F(49, 73))

Задание 24 — Обработка символьных строк

Длинная строка

# Регулярные выражения:
from re import finditer

# Символьные классы:
# [ABC]   — один из A, B, C
# [A-Z]   — диапазон A–Z
# [^ABC]  — не A, B, C
# .       — любой символ

# Квантификаторы:
# *       — 0 или больше
# +       — 1 или больше
# ?       — 0 или 1
# {n}     — ровно n
# {n,m}   — от n до m

# Группировка:
# [AB]+   — A или B подряд
# (AB)+   — пара AB подряд
# AB|CD   — AB или CD

# Экранирование: \*  \+  \{  \}  \[  \]  \(  \)  \.  \?  \|
# Пересекающиеся совпадения: r'(?=(шаблон))'
# * и + жадные — берут максимум

# ПРИМЕРЫ для ЕГЭ:
r'[1-9A-D][0-9A-D]*'               # 14-ричное число без ведущего нуля
r'[1-9A-D][0-9A-D]*[02468AC]'      # чётное 14-ричное число

# МЕТОД — накопление строки (скользящее окно):
a = open('24.txt').readline().strip()
s = ''
m = 0
k = 0; kY = 0
for i in a:
    s += i
    if i == 'Y': kY += 1
    if s[-4:] == '2025': k += 1
    while kY > 80:                   # ограничение на число Y
        if s[0] == 'Y': kY -= 1
        if s[:4] == '2025': k -= 1
        s = s[1:]
    if k >= 90: m = max(m, len(s))
print(m)

Задание 25 — Обработка целочисленной информации

Делители / множители / маски

# Проверка простоты:
def prost(n):
    return n > 1 and all(n % d != 0 for d in range(2, int(n**0.5)+1))

# Все делители (без 1 и самого числа):
def divs(n):
    a = set()
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            a.add(i)
            a.add(n // i)
    return a

# Только простые делители:
def prime_divs(n):
    a = set()
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            if prost(i): a.add(i)
            if prost(n // i): a.add(n // i)
    return a

# Маски (fnmatch):
from fnmatch import fnmatch
for i in range(18579, 10**10 + 1, 18579):   # шаг = делитель
    if fnmatch(str(i), '54?1?3*7'):          # ? = 1 символ, * = любые
        print(i, i // 18579)

Задание 26 — Сортировка целочисленной информации

Снегоуборщики / жадный алгоритм

a = open('26.txt')
N, K = [int(x) for x in a.readline().split()]
z = [int(a.readline()) for i in range(N)]     # мин. мощность для каждого района

sneg = [100000] * 1001                         # sneg[мощность] = мин. стоимость
for i in range(K):
    m, c = [int(x) for x in a.readline().split()]
    sneg[m] = min(sneg[m], c)                  # оставляем минимальную стоимость

for i in range(len(sneg)):
    sneg[i] = [sneg[i], i]                     # пары [стоимость, мощность]

sneg.sort(key=lambda x: (x[0], -x[1]))
# сортируем: дешевле, при равной стоимости — мощнее

stoim, mx = 0, 0
for i in z:
    for j in sneg:
        if i <= j[1]:                          # мощность >= требуемой
            stoim += j[0]
            mx = max(mx, j[1])
            break
print(stoim, mx)

Задание 27 — Анализ данных (кластеризация)

Кластеризация звёзд

# Расстояние (с типом z в списке):
def dist(a, b):
    x1, y1, z1 = a
    x2, y2, z2 = b
    return ((x2-x1)**2 + (y2-y1)**2)**0.5

# Центр кластера (медоид — точка с МИН суммой расстояний):
def centr(K):
    s = []
    for i in K:
        a = sum(dist(i, j) for j in K)
        s.append([a, i])
    return min(s)[1]

# ПРИМЕР (файл A — 2 кластера):
A = [[], []]
for s in open('27_A.txt'):
    x, y, t = s.replace(',', '.').split()
    x, y = float(x), float(y)
    if t == 'VII': t = '  VII'
    if y > 10: A[0].append([x, y, t])     # ← порог подбирай через len()!
    else:      A[1].append([x, y, t])

# ПРИМЕР (файл B — 3 кластера):
B = [[], [], []]
for s in open('27_B.txt'):
    x, y, t = s.replace(',', '.').split()
    x, y = float(x), float(y)
    if t == 'VII': t = '  VII'
    if y > 23:   B[0].append([x, y, t])
    elif y > 15: B[1].append([x, y, t])
    else:        B[2].append([x, y, t])

# Жёлтые звёзды (Z) — подсчёт:
k0 = len([p for p in A[0] if p[2][0] == 'Z'])
k1 = len([p for p in A[1] if p[2][0] == 'Z'])
print(min(k0, k1), max(k0, k1))

# Синие карлики (L + V) — расстояния до центра:
lv0 = [p for p in B[0] if p[2][0] == 'L' and p[2][2:] == 'V']
lv1 = [p for p in B[1] if p[2][0] == 'L' and p[2][2:] == 'V']
lv2 = [p for p in B[2] if p[2][0] == 'L' and p[2][2:] == 'V']
c0, c1, c2 = centr(B[0]), centr(B[1]), centr(B[2])
r = [dist(c0, p) for p in lv0] + [dist(c1, p) for p in lv1] + [dist(c2, p) for p in lv2]
print(int(min(r)*10000), int(max(r)*10000))

# МАКС диаметр внутри группы звёзд одного кластера:
def diam(k):
    s = []
    for i in k:
        a = max(dist(i, j) for j in k if dist(i, j) > 0)
        s.append(a)
    return max(s)

# АЛГОРИТМ РЕШЕНИЯ:
# 1. Прочитать файл, запятая → точка
# 2. Подобрать пороги (y>? / x>?) через print(len()) — числа должны быть разными
# 3. Найти центры через centr()
# 4. Отфильтровать звёзды по типу: z[0]=спектр, z[1]=подкласс, z[2:]=светимость
# 5. Посчитать расстояния / количества
# 6. Ответ: int(значение * 10000) — ЦЕЛАЯ ЧАСТЬ (не округление!)


                          Удачи на ЕГЭ!

Шпаргалка составлена командой Профиматики. Обновляется под каждый новый КИМ ФИПИ.