Что изменилось в задании 16 в 2027 году

Вопрос. В демо 2026 спрашивали значение F(15 548) для пары функций F и G, в 2027 — значение выражения из нескольких значений функции при n около трёх тысяч: в демоверсии (F(3038) + 5 × F(3037)) / F(3036), где F — факториал. Ответ 9241591. Рекурсия на такой глубине не проходит, а числа имеют тысячи цифр — отсюда две ловушки: предел глубины и деление.

Как получить ответ демоверсии без компьютера

Сократить факториалы. F(3038)/F(3036) = 3038 × 3037, F(3037)/F(3036) = 3037, значит выражение равно 3037 × (3038 + 5) = 3037 × 3043 = 9 241 591. Умножение столбиком занимает минуту, и это самый быстрый путь для факториальной формы.

Как решать задание 16 на Python в 2027 году

Таблицей: список до наибольшего аргумента, база в свои клетки, формула шага в цикле, а делить — двумя косыми чертами. `F = [0] * 3039; F[1] = 1; for n in range(2, 3039): F[n] = n * F[n-1]; print((F[3038] + 5*F[3037]) // F[3036])` печатает 9241591.

Почему нельзя делить одной косой чертой

Одна косая черта даёт вещественное число: ответ печатается как 9241591.0. Деление целых в Python округляется правильно, но результат — float: при частном больше 2^53 теряются последние цифры, а при очень большом Python падает с OverflowError. Две косые черты делят целые числа точно и выводят целое.

Что делать, если в условии сказано «запишите целую часть»

Значит, частное нецелое, и нужно отбросить дробную часть. Целочисленное деление `//` даёт именно целую часть. В вариации (F(6250) + 2 × F(6244)) / F(6238) при F(n) = 3n + F(n − 3) частное равно 3,0077…, ответ 3.

Как быть, если база задана при больших n, а шаг ссылается на F(n + 1)

Это «рекурсия вверх»: F(n) = n при n > 2024, F(n) = n × F(n + 1) при n ≤ 2024. Таблицу заполняют сверху вниз — от 2025 к меньшим — и только до наименьшего нужного аргумента. F(2022)/F(2024) = 2022 × 2023 = 4090506.

Нужна ли мемоизация или setrecursionlimit

Для формы 2027 — нет: таблица снизу вверх решает любой аргумент без рекурсии. Поднятый предел глубины спасает при одном вызове в формуле и n до нескольких тысяч, но при двух вызовах и n за сотню без кеша рекурсия не досчитает. Таблица проще и работает всегда.

Сколько баллов и времени стоит задание 16

Один первичный балл, повышенный уровень, пять минут по спецификации 2027. С шаблоном таблицы — две минуты; главное потратить тридцать секунд на проверку, что в последней строке стоят две косые черты.

Задание 16 ЕГЭ по информатике 2027 — рекуррентные выражения и деление факториалов

Задание 16 в 2027 году спрашивает не «чему равно F(n)», а значение выражения из нескольких значений F при n около трёх тысяч. В демоверсии F(1) = 1, F(n) = n × F(n − 1), и нужно вычислить (F(3038) + 5 × F(3037)) / F(3036). Ответ 9241591, и получить его можно двумя путями: сократить факториалы на бумаге или заполнить таблицу на Python и разделить двумя косыми чертами. У F(3038) больше девяти тысяч цифр, поэтому одна косая черта, рекурсия без предела и округление вместо целой части — три способа потерять балл.

Ниже — условие демо, алгебраический путь, таблица на Python, три вариации вопроса и ловушки. Сам механизм рекуррентных функций, таблица значений и мемоизация подробно разобраны в статье о задании 16 2026 года.

Условие демоверсии 2027

Алгоритм вычисления значения функции F(n), где n — натуральное число, задан следующими соотношениями:

F(n) = 1 при n = 1;
F(n) = n × F(n − 1), если n > 1.

Чему равно значение выражения (F(3038) + 5 × F(3037)) / F(3036)?

Ответ ФИПИ: 9241591.

Путь первый: алгебра

F(n) здесь — факториал: F(n) = 1 · 2 · … · n. Делить факториалы друг на друга удобно, потому что меньший целиком содержится в большем:

Дробь	Сокращение	Результат
F(3038) / F(3036)	3038 · 3037 · 3036! / 3036!	3038 × 3037
F(3037) / F(3036)	3037 · 3036! / 3036!	3037

Выражение раскладывается на две дроби: F(3038)/F(3036) + 5 × F(3037)/F(3036) = 3038 × 3037 + 5 × 3037 = 3037 × (3038 + 5) = 3037 × 3043.

3037 × 3043 = 3037 × 3000 + 3037 × 43 = 9 111 000 + 130 591 = 9 241 591.

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

Путь второй: таблица на Python

Рекурсивная функция до n = 3038 упирается в предел глубины Python (по умолчанию около тысячи вызовов), поэтому значения считают таблицей снизу вверх:

N = 3038
F = [0] * (N + 1)
F[1] = 1
for n in range(2, N + 1):
    F[n] = n * F[n - 1]

print((F[3038] + 5 * F[3037]) // F[3036])    # 9241591

Список на 3039 клеток, база в первую клетку, формула шага в цикле. Целые числа в Python растут без ограничений: у F(3038) 9263 цифры, и умножение их не теряет. А вот деление — ловушка.

Запись	Что напечатает
`(F[3038] + 5 * F[3037]) // F[3036]`	`9241591` — целое, верно
`(F[3038] + 5 * F[3037]) / F[3036]`	`9241591.0` — вещественное, в бланке с `.0` не примут
`F[3038] / 7`	`OverflowError` — частное не помещается в float

Одна косая черта всегда даёт вещественное число. Для небольших частных оно печатается с .0, для частных больше 2^53 теряет последние цифры, для частных больше примерно 10^308 падает с ошибкой. Две косые черты — деление нацело — работают на любых размерах.

Ещё один пример той же формы

Та же функция, другие числа: (F(2519) + 4 × F(2518)) / F(2517). Алгебра: F(2519)/F(2517) = 2519 × 2518, F(2518)/F(2517) = 2518, итого 2518 × (2519 + 4) = 2518 × 2523 = 6 352 914. Таблица до 2519 и строка print((F[2519] + 4 * F[2518]) // F[2517]) печатают то же число.

Со знаком минус — (F(2519) − 4 × F(2518)) / F(2517) — получается 2518 × (2519 − 4) = 2518 × 2515 = 6 332 770. Схема одна: вынести общий множитель F(c) из числителя, остаток — произведение нескольких подряд идущих чисел.

Три вариации вопроса

Демоверсия даёт одну форму; ниже — три вариации той же темы, так устроены и задания банка TuteMe. Все решаются той же таблицей, различаются база и направление.

Арифметический рост и «целая часть»

F(n) = n при n < 10; F(n) = 3n + F(n − 3), если n ≥ 10. Чему равно значение выражения (F(6250) + 2 × F(6244)) / F(6238)? В ответе запишите целую часть полученного числа.

N = 6250
F = [0] * (N + 1)
for n in range(N + 1):
    F[n] = n if n < 10 else 3 * n + F[n - 3]

print((F[6250] + 2 * F[6244]) // F[6238])    # 3

Частное здесь нецелое — около 3,0077, — и фраза «целая часть» в условии не случайна. // даёт целую часть. Округление через round дало бы то же 3, но при частном вроде 3,6 — уже 4, и это ошибка: целая часть 3,6 равна 3.

Рекурсия вверх

F(n) = n при n > 2024; F(n) = n × F(n + 1), если n ≤ 2024. Чему равно F(2022) / F(2024)?

База задана при больших n, а шаг ссылается на F(n + 1). Таблицу заполняют сверху вниз, и только до наименьшего нужного аргумента — считать от 2024 до единицы незачем:

M = 2024
F = [0] * (M + 2)
F[M + 1] = M + 1
for n in range(M, 2021, -1):
    F[n] = n * F[n + 1]

print(F[2022] // F[2024])                    # 4090506

Алгебра: F(2022) = 2022 × 2023 × F(2024), значит частное 2022 × 2023 = 4 090 506.

Разность двух значений

F(n) = 1 при n ≤ 5; F(n) = n + F(n − 2), если n > 5. Чему равно F(2126) − F(2122)?

N = 2126
F = [0] * (N + 1)
for n in range(N + 1):
    F[n] = 1 if n <= 5 else n + F[n - 2]

print(F[2126] - F[2122])                     # 4250

Алгебра: F(2126) = 2126 + F(2124) = 2126 + 2124 + F(2122), разность 4250. Деления нет — нет и ловушки, но таблица та же.

Форма	Направление таблицы	Деление	Пример ответа
Факториал (демо)	снизу вверх	`//`, частное целое	9241591
Арифметический рост	снизу вверх	`//`, «целая часть»	3
Рекурсия вверх	сверху вниз	`//`	4090506
Разность значений	снизу вверх	нет	4250

Типичные ошибки

Одна косая черта

Ответ 9241591.0 в бланк не впишешь, а на больших частных одна косая черта теряет цифры или падает. Две косые черты — всегда.

Рекурсия без таблицы

def F(n): return n * F(n - 1) на n = 3038 падает с RecursionError. Поднятый sys.setrecursionlimit спасает при одном вызове в формуле, но таблица надёжнее и короче.

Таблица заполнена не в ту сторону

Если база при больших n, а в коде цикл идёт от маленьких, значения F(n + 1) ещё не посчитаны, и в клетках останутся нули. Направление цикла — по направлению ссылки в формуле шага.

Округление вместо целой части

round(3.6) — это 4, а целая часть 3,6 — это 3. Условие просит целую часть: // или int.

Пропущенная база

Если в условии F(n) = 1 при n ≤ 5, а в таблице база только для n = 1, значения при n = 2..5 посчитаются по формуле шага и всё дальше поедет. Сколько базовых условий в задании, столько веток в коде.

Подборка ошибок по всем номерам — в статье Типичные ошибки на ЕГЭ по информатике.

Тайминг на экзамене

Этап	Время
Перенести базу и шаг в таблицу	1 мин
Записать выражение с `//`	30 сек
Сверить с алгеброй или на маленьком n	1 мин
Итого	2–3 мин

Спецификация отводит пять минут. Проверка на маленьком n — подставь n = 3–4 и посчитай руками — ловит перепутанные ветки и сдвиг базы.

Как тренироваться

Реши пять факториальных выражений алгеброй и таблицей — ответы обязаны совпасть.
Три задания с «целой частью» — проверь, что частное действительно нецелое, и запомни, что // ≠ round.
Три задания с рекурсией вверх — отработай цикл от большего к меньшему.
Одно задание специально реши через одну косую черту и посмотри на вывод: .0 запоминается с первого раза.

Как изменились остальные номера — в обзоре ЕГЭ по информатике 2027: что изменилось; демозадание в контексте варианта — в разборе демоверсии 2027. Та же таблица счётчиков лежит в основе задания 13, а целые числа без ограничений пригодятся в задании 17. Короткие приёмы для таких задач — в подборке Python-идиом.

Короткий итог

Задание 16 в 2027 году — выражение из значений F при n в тысячи. Факториальную форму из демо быстрее всего сократить на бумаге: 3037 × 3043 = 9241591. На Python — таблица снизу вверх и деление двумя косыми чертами; для рекурсии вверх таблицу заполняют от базы вниз, для «целой части» берут //, а не round.

Задания 16 в форме 2027 года с автопроверкой есть в TuteMe: факториал, арифметический рост с целой частью и рекурсия вверх.

Попробовать бесплатно →