Задания 25 для ЕГЭ по информатике из различных источников.

ЕГЭ по информатике, линейка 25

ЕГЭ 2026. Статград. 16.12.2025

Назовём маской числа последовательность цифр, в которой также могут встречаться следующие символы:
– символ «?» означает ровно одну произвольную чётную цифру;
– символ «*» означает любую последовательность цифр произвольной длины; в том числе «*» может задавать и пустую последовательность. Например, маске \(123{*}4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{8}\), найдите все числа, соответствующие маске \(7?23?64{*}8\), делящиеся на \(2026\) без остатка. В ответе запишите все найденные числа в порядке возрастания.

def valid(n):
    even = '02468'
    s = str(n)
    return s[0] == '7' and s[1] in even and s[2:4] == '23' \
           and s[4] in even and s[5:7] == '64' and s[-1] == '8'

n = 70230648 + 2026 - 70230648 % 2026
for x in range(n, 10**10, 2026):
    if valid(x):
        print(x)

ЕГЭ 2026. ЕГКР. 13.12.2025

Напишите программу, которая перебирает целые числа, большие \(1~350~050,\) в порядке возрастания и ищет среди них такие, у которых есть натуральный делитель, оканчивающийся на \(11\) и не равный ни самому числу, ни числу \(11.\) В ответе запишите в первом столбце таблицы первые пять найденных чисел в порядке возрастания, а во втором столбце — для каждого числа соответствующий минимальный делитель, оканчивающийся на \(11,\) не равный ни самому числу, ни числу \(11.\)

Количество строк в таблице для ответа избыточно.

n = 1_350_050
q = 0

while q < 5:
    n += 1
    d = []
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d += [z for z in (x, n // x) if z != 11 and z % 100 == 11]
    if d:
        print(n, min(d))
        q += 1

ЕГЭ 2026. Крылов. Вариант 20

Пусть \(M\) — разность максимального и минимального натуральных делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(M\) равным нулю.

Напишите программу, которая перебирает целые числа, меньшие \( 800~000\), в порядке убывания и ищет среди них такие, для которых значение \(M\) кратно \(23\) (нуль числу \(23\) не кратен). Вывести первые пять найденных чисел и соответствующие им значения \(M\).
Формат вывода: для каждого из пяти таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(M\).
Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(20\) \(M = 10 - 2 = 8\).

def M(n):
    d = []
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d += [x, n // x]
    return max(d) - min(d) if d else 0
    

q, n = 0, 800_000
while q < 5:
    n -= 1
    m = M(n)
    if m and m % 23 == 0:
        print(n, m)
        q += 1

ЕГЭ 2026. Крылов. Вариант 19

Пусть \(M\) — разность максимального и минимального натуральных делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(M\) равным нулю.

Напишите программу, которая перебирает целые числа, меньшие \( 800~000\), в порядке убывания и ищет среди них такие, для которых значение \(M\) кратно \(17\) (нуль числу \(17\) не кратен). Вывести первые пять найденных чисел и соответствующие им значения \(M\).
Формат вывода: для каждого из пяти таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(M\).
Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(20\) \(M = 10 - 2 = 8\).

def M(n):
    d = []
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d += [x, n // x]
    return max(d) - min(d) if d else 0
    

q, n = 0, 800_000
while q < 5:
    n -= 1
    m = M(n)
    if m and m % 17 == 0:
        print(n, m)
        q += 1

ЕГЭ 2026. Крылов. Вариант 18

Пусть \(M\) — разность максимального и минимального натуральных делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(M\) равным нулю.

Напишите программу, которая перебирает целые числа, большие \( 860~000\), в порядке возрастания и ищет среди них такие, для которых значение \(M\) оканчивается на \(30\). Вывести первые пять найденных чисел и соответствующие им значения \(M\).
Формат вывода: для каждого из пяти таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(M\).
Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(20\) \(M = 10 - 2 = 8\).

def M(n):
    d = []
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d += [x, n // x]
    return max(d) - min(d) if d else 0
    

q, n = 0, 860_000
while q < 5:
    n += 1
    m = M(n)
    if m % 100 == 30:
        print(n, m)
        q += 1

ЕГЭ 2026. Крылов. Вариант 17

Пусть \(M\) — разность максимального и минимального натуральных делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(M\) равным нулю.

Напишите программу, которая перебирает целые числа, большие \( 860~000\), в порядке возрастания и ищет среди них такие, для которых значение \(M\) оканчивается на \(18\). Вывести первые пять найденных чисел и соответствующие им значения \(M\).
Формат вывода: для каждого из пяти таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(M\).
Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(20\) \(M = 10 - 2 = 8\).

def M(n):
    d = []
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d += [x, n // x]
    if d:
        return max(d) - min(d)
    return 0

q, n = 0, 860_000
while q < 5:
    n += 1
    m = M(n)
    if m % 100 == 18:
        print(n, m)
        q += 1

ЕГЭ 2026. Крылов. Вариант 16

Назовём маской числа последовательность цифр, в которой также могут встречаться следующие символы:
– символ «?» означает ровно одну произвольную цифру;
– символ «*» означает любую последовательность цифр произвольной длины; в том числе «*» может задавать и пустую последовательность. Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{9}\), найдите все числа, соответствующие маске \(33*21?7\), делящиеся на \(2079\) без остатка. В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце – соответствующие им результаты деления этих чисел на \(2079\). Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

n = 332107 + 2079 - 332107 % 2079

for x in range(n, 10**9, 2079):
    if fnmatch(str(x), '33*21?7'):
        print(x, x // 2079)

for n in range(4):
    for i in range(10**n):
        for k in range(10):
            x = 33*10**(4+n) + i*10**4 + 21*100 + k*10 + 7
            if x % 2079 == 0:
                print(x, x//2079)

ЕГЭ 2026. Крылов. Вариант 15

Назовём маской числа последовательность цифр, в которой также могут встречаться следующие символы:
– символ «?» означает ровно одну произвольную цифру;
– символ «*» означает любую последовательность цифр произвольной длины; в том числе «*» может задавать и пустую последовательность. Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{9}\), найдите все числа, соответствующие маске \(32*21?4\), делящиеся на \(2049\) без остатка. В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце – соответствующие им результаты деления этих чисел на \(2049\). Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

n = 322104 + 2049 - 322104 % 2049

for x in range(n, 10**9, 2049):
    if fnmatch(str(x), '32*21?4'):
        print(x, x // 2049)

for n in range(4):
    for i in range(10**n):
        for k in range(10):
            x = 32*10**(4+n) + i*10**4 + 21*100 + k*10 + 4
            if x % 2049 == 0:
                print(x, x//2049)

ЕГЭ 2026. Крылов. Вариант 14

Назовём маской числа последовательность цифр, в которой также могут встречаться следующие символы:
– символ «?» означает ровно одну произвольную цифру;
– символ «*» означает любую последовательность цифр произвольной длины; в том числе «*» может задавать и пустую последовательность. Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{8}\), найдите все числа, соответствующие маске \(32*823\), делящиеся на \(123\) без остатка. В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце – соответствующие им результаты деления этих чисел на \(123\). Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

n = 32823 + 123 - 32823 % 123

for x in range(n, 10**8, 123):
    if fnmatch(str(x), '32*823'):
        print(x, x // 123)

for n in range(4):
    for i in range(10**n):
        x = 32 * 10**(3+n) + i * 10**3 + 823
        if x % 123 == 0:
            print(x, x//123)

ЕГЭ 2026. Крылов. Вариант 13

Назовём маской числа последовательность цифр, в которой также могут встречаться следующие символы:
– символ «?» означает ровно одну произвольную цифру;
– символ «*» означает любую последовательность цифр произвольной длины; в том числе «*» может задавать и пустую последовательность. Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{8}\), найдите все числа, соответствующие маске \(11*223\), делящиеся на \(149\) без остатка. В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце – соответствующие им результаты деления этих чисел на \(149\). Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

n = 11223 + (149 - 11223 % 149)

for x in range(n, 10**8, 149):
    if fnmatch(str(x), '11*223'):
        print(x, x // 149)

for n in range(4):
    for i in range(10**n):
        x = 11*10**(3+n) + i*10**3 + 223
        if x % 149 == 0:
            print(x, x // 149)

ЕГЭ 2026. Крылов. Вариант 12

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

— символ «?» означает ровно одну произвольную цифру;
— символ «*» означает любую последовательность цифр произвольной длины, в том числе «*» может задавать и пустую последовательность.

Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{8}\), найдите все числа, соответствующие маске \(?79?8*3\), делящиеся на \(3377\) без остатка. В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце — соответствующие результаты деления этих чисел на \(3377\).

Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

d = 3377

for n in range(d, 10**8, d):
    if fnmatch(str(n), '?79?8*3'):
        print(n, n // d)

ЕГЭ 2026. Крылов. Вариант 11

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

— символ «?» означает ровно одну произвольную цифру;
— символ «*» означает любую последовательность цифр произвольной длины, в том числе «*» может задавать и пустую последовательность.

Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{8}\), найдите все числа, соответствующие маске \(?19*8?3\), делящиеся на \(5171\) без остатка. В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце — соответствующие результаты деления этих чисел на \(5171\).

Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

d = 5171

for n in range(d, 10**8, d):
    if fnmatch(str(n), '?19*8?3'):
        print(n, n // d)

ЕГЭ 2026. Крылов. Вариант 10

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

— символ «?» означает ровно одну произвольную цифру;
— символ «*» означает любую последовательность цифр произвольной длины, в том числе «*» может задавать и пустую последовательность.

Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{10}\), найдите все числа, соответствующие маске \(9*?001?1\), делящиеся на \(12007\) без остатка. В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце — соответствующие результаты деления этих чисел на \(12007\).

Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

d = 12007

for n in range(d, 10**10, d):
    if fnmatch(str(n), '9*?001?1'):
        print(n, n // d)

ЕГЭ 2026. Крылов. Вариант 9

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

— символ «?» означает ровно одну произвольную цифру;
— символ «*» означает любую последовательность цифр произвольной длины, в том числе «*» может задавать и пустую последовательность.

Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{10}\), найдите все числа, соответствующие маске \(1*34?5?9\), делящиеся на \(31007\) без остатка. В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце — соответствующие результаты деления этих чисел на \(31007\).

Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

d = 31007

for n in range(d, 10**10, d):
    if fnmatch(str(n), '1*34?5?9'):
        print(n, n // d)

ЕГЭ 2026. Крылов. Вариант 8

Пусть \(R\) — сумма различных натуральных делителей целого числа, не считая единицы и самого числа. Напишите программу, которая перебирает целые числа, большие \(900~000,\) в порядке возрастания и ищет среди них такие, для которых \(R\) оканчивается на \(5.\) В ответе запишите в первом столбце таблицы первые пять найденным чисел в порядке возрастания, а во втором столбце — соответствующие им значения \(R.\)

Например, для числа \(18\) \(R = 2 + 3 + 6 + 9 = 20.\)

Количество строк в таблице для ответа избыточно.

def R(n):
    d = {0}
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d.add(x)
            d.add(n // x)

    return sum(d)

q, n = 0, 900_000
while q < 5:
    n += 1
    r = R(n)
    if r % 10 == 5:
        print(n, r)
        q += 1

ЕГЭ 2026. Крылов. Вариант 7

Пусть \(R\) — сумма различных натуральных делителей целого числа, не считая единицы и самого числа. Напишите программу, которая перебирает целые числа, большие \(800~000,\) в порядке возрастания и ищет среди них такие, для которых \(R\) оканчивается на \(3.\) В ответе запишите в первом столбце таблицы первые пять найденным чисел в порядке возрастания, а во втором столбце — соответствующие им значения \(R.\)

Например, для числа \(18\) \(R = 2 + 3 + 6 + 9 = 20.\)

Количество строк в таблице для ответа избыточно.

def R(n):
    d = {0}
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d.add(x)
            d.add(n // x)

    return sum(d)

q, n = 0, 800_000
while q < 5:
    n += 1
    r = R(n)
    if r % 10 == 3:
        print(n, r)
        q += 1

ЕГЭ 2026. Крылов. Вариант 6

Пусть \(M\) — сумма минимального и максимального натуральных делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(M\) равным нулю. Напишите программу, которая перебирает целые числа, большие \(1~000~000,\) в порядке возрастания и ищет среди них такие, для которых \(M\) оканчивается на \(6.\) В ответе запишите в первом столбце таблицы первые пять найденным чисел в порядке возрастания, а во втором столбце — соответствующие им значения \(M.\)

Например, для числа \(30\) \(M = 2 + 15 = 17.\)

Количество строк в таблице для ответа избыточно.

def M(n):
    res = 0
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            res = x + n // x
            break
    return res

q, n = 0, 1_000_000
while q < 5:
    n += 1
    m = M(n)
    if m % 10 == 6:
        print(n, m)
        q += 1

ЕГЭ 2026. Крылов. Вариант 5

Напишите программу, которая перебирает целые числа, большие \(700~000,\) в порядке возрастания и ищет среди них такие, у которых есть натуральный делитель, оканчивающийся на цифру \(7\) и не равный ни самому числу, ни числу \(7.\) В ответе запишите в первом столбце таблицы первые пять найденных чисел в порядке возрастания, а во втором столбце — соответствующий минимальный делитель для каждого числа, оканчивающегося цифрой \(7,\) не равный ни самому числу, ни числу \(7.\) Количество строк в таблице избыточно.

q, n = 0, 700_000

while q < 5:
    n += 1
    d7 = []
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d7 += [z for z in (x, n // x) if z != 7 and z % 10 == 7]
    if d7:
        print(n, min(d7))
        q += 1

ЕГЭ 2026. Крылов. Вариант 4

Напишите программу, которая перебирает целые числа, большие \(4~000~000,\) в порядке возрастания и ищет среди них числа, представимые в виде произведения ровно двух простых множителей, не обязательно различных, каждый из которых содержит в своей записи либо цифру \(1,\) либо цифру \(2.\) В ответе в первом столбце таблицы запишите первые \(5\) найденных чисел в порядке возрастания, а во втором столбце — для каждого числа наибольший из соответствующих им найденных множителей. Количество строк в таблице избыточно.

def is_prime(n):
    if n == 1:
        return False
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True

q, n = 0, 4_000_000

while q < 5:
    n += 1
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            if is_prime(x) and any(z in str(x) for z in '12'):
                m = n // x
                if is_prime(m) and any(z in str(m) for z in '12'):
                    q += 1
                    print(n, m)
            break

ЕГЭ 2026. Крылов. Вариант 3

Напишите программу, которая перебирает целые числа, большие \(3~000~000,\) в порядке возрастания и ищет среди них числа, представимые в виде произведения ровно двух простых множителей, не обязательно различных, каждый из которых содержит в своей записи либо цифру \(1,\) либо цифру \(3.\) В ответе в первом столбце таблицы запишите первые \(5\) найденных чисел в порядке возрастания, а во втором столбце — для каждого числа наибольший из соответствующих им найденных множителей. Количество строк в таблице избыточно.

def is_prime(n):
    if n == 1:
        return False
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True

q, n = 0, 3_000_000

while q < 5:
    n += 1
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            if is_prime(x) and any(z in str(x) for z in '13'):
                m = n // x
                if is_prime(m) and any(z in str(m) for z in '13'):
                    q += 1
                    print(n, m)
            break

ЕГЭ 2026. Крылов. Вариант 2

Напишите программу, которая перебирает все целые шестизначные числа в порядке возрастания и ищет среди них те, которые не содержат в своей записи цифру \(0\) и которые можно представить в виде суммы нечётного натурального числа, делящегося без остатка на \(113,\) и натуральной степени числа \(3.\) В ответе в первом столбце таблицы запишите первые \(5\) найденных чисел в порядке возрастания, а во втором столбце — для каждого числа соответствующий показатель степени числа \(3.\)

Количество строк в таблице для ответа избыточно.

p3 = [3**n for n in range(13)]
q, n = 0, 99999

while q < 5:
    n += 1
    if '0' not in str(n):
        for p in range(1, 13):
            x = n - p3[p]
            if x > 0 and x % 2 == 1 and x % 113 == 0:
                print(n, p)
                q += 1
                break

ЕГЭ 2026. Крылов. Вариант 1

Напишите программу, которая перебирает все целые шестизначные числа в порядке возрастания и ищет среди них те, которые не содержат в своей записи цифру \(1\) и которые можно представить в виде суммы нечётного натурального числа, делящегося без остатка на \(103,\) и натуральной степени числа \(3.\) В ответе в первом столбце таблицы запишите первые \(5\) найденных чисел в порядке возрастания, а во втором столбце — для каждого числа соответствующий показатель степени числа \(3.\)

Количество строк в таблице для ответа избыточно.

p3 = [3**n for n in range(13)]
q, n = 0, 199999

while q < 5:
    n += 1
    if '1' not in str(n):
        for p in range(1, 13):
            x = n - p3[p]
            if x > 0 and x % 2 == 1 and x % 103 == 0:
                print(n, p)
                q += 1
                break

ЕГЭ 2026. Статград. 23.10.2025

Пусть \(S\) – сумма всех простых натуральных делителей целого числа, не считая самого числа. Если таких делителей у числа нет, то считаем значение \(S\) равным нулю.

Напишите программу, которая перебирает целые числа, меньшие \(1~325~000,\) в порядке убывания и ищет среди них такие, для которых значение \(S\) не равно нулю, не больше \(30~000\) и кратно \(5.\) В ответе запишите первые пять найденных чисел в порядке убывания.

Например, для числа \(10\) \(S = 2 + 5 = 7.\)

import math


def is_prime(n):
    if n < 2:
        return False
    if n == 2:
        return True
    if n & 1 == 0:
        return False
    for i in range(3, int(math.sqrt(n)) + 1, 2):
        if n % i == 0:
            return False
    return True

def S(n):
    s = set()
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            d = n // i
            if is_prime(i):
                s.add(i)
            if is_prime(d):
                s.add(d)
    if s:
        return sum(s)
    return 0

q = 5
n = 1_325_000
while q:
    n -= 1
    s = S(n)
    if s and s <= 30_000 and s % 5 == 0:
        print(n)
        q -= 1

ЕГЭ. Основная волна. Пересдача. 03.07.2025

Напишите программу, которая перебирает целые числа, большие \(6~086~055,\) в порядке возрастания и ищет среди них числа, представленные в виде произведено двух простых множителей, не обязательно различных, каждый из которых содержит в своей записи ровно одну цифру \(6.\)

В ответе в первом столбце таблицы запишите первые \(5\) найденных чисел в порядке возрастания, а во втором столбце — для каждого из них соответствующий наибольший из найденных множителей.

Количество строк в таблице для ответа избыточно.

def sieve(n):
    tmp = [1] * n
    tmp[0] = tmp[1] = 0
    for x in range(2, int(n**0.5) + 1):
        if tmp[x]:
            for p in range(x**2, n, x):
                tmp[p] = 0
    ans = []
    for p in range(2, n):
        if tmp[p]:
            ans.append(p)
    return ans

primes = sieve(6_500_000)

def divisors(n):
    div = []
    p = 0
    while n > 1:
        while n % primes[p] == 0:
            div.append(primes[p])
            n //= primes[p]
        p += 1
    return div

q = 0
n = 6_086_055
while q < 5:
    n += 1
    div = divisors(n)
    if len(div) == 2 and all(str(x).count('6') == 1 for x in div):
        print(n, max(div))
        q += 1

ЕГЭ. Основная волна. Резерв. 23.06.2025

Напишите программу, которая перебирает целые числа, большие \(15~381~264,\) в порядке возрастания и ищет среди них числа, представленные в виде произведения ровно трёх простых множителей, не обязательно различных, каждый из которых содержит в своей записи ровно одну цифру \(1.\)

В ответе в первом столбце таблицы запишите первые \(5\) найденных чисел в порядке возрастания, а во втором столбце — для каждого из чисел соответствующий им наибольший из найденных множителей.

Количество строк в таблице для ответа избыточно.

def sieve(n):
    tmp = [1] * n
    tmp[0] = tmp[1] = 0
    for x in range(2, int(n**0.5) + 1):
        if tmp[x]:
            for p in range(x**2, n, x):
                tmp[p] = 0
    ans = []
    for p in range(2, n):
        if tmp[p]:
            ans.append(p)
    return ans

primes = sieve(16_000_000)

def divisors(n):
    div = []
    p = 0
    while n > 1:
        while n % primes[p] == 0:
            div.append(primes[p])
            n //= primes[p]
        p += 1
    return div

q = 0
n = 15_381_264
while q < 5:
    n += 1
    div = divisors(n)
    if len(div) == 3 and all(str(x).count('1') == 1 for x in div):
        print(n, max(div))
        q += 1

ЕГЭ. Основная волна. Резерв. 19.06.2025

Напишите программу, которая перебирает целые числа, большие \(6~651~220,\) в порядке возрастания и ищет среди них числа, представленные в виде произведения ровно двух простых множителей, не обязательно различных, каждый из которых содержит в своей записи ровно одну цифру \(2.\)

В ответе в первом столбце таблицы запишите первые \(5\) найденных чисел в порядке возрастания, а во втором столбце — для каждого из чисел соответствующий им наибольший из найденных множителей.

Количество строк в таблице для ответа избыточно.

def is_prime(n):
    if n == 2:
        return True
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return False
    return True

def two_prime(n):
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d = n // x
            if is_prime(x) and is_prime(d):
                return [x, d]
    return 0

q = 0
n = 6_651_220
while q < 5:
    n += 1
    t = two_prime(n)
    if t and all(str(x).count('2') == 1 for x in t):
        print(n, max(t))
        q += 1

ЕГЭ. Основная волна. 11.06.2025-2

Пусть \(M\) — сумма минимального и максимального простых натуральных делителей целого числа, не считая самого числа. Если таких делителей у числа нет, то значение \(M\) считается равным нулю. Напишите программу, которая перебирает целые числа, большие \(5~400~000,\) в порядке возрастания и ищет среди них такие, для которых \(N\) больше \(60~000\) и является палиндромом, т.е. одинаково читается слева направо и справа налево. В ответе запишите в первом столбце таблицы первые пять найденных — чисел в порядке возрастания, а во втором столбце — соответствующие им значения \(M.\)

Например, для числа \(298\) \(M = 2 + 149 = 151.\)

Количество строк в таблице для ответа избыточно.

def is_prime(n):
    if n == 2:
        return True
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return False
    return True

def sum_divisors(n):
    divs = set()
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d = n // x
            if is_prime(x):
                divs.add(x)
            if is_prime(d):
                divs.add(d)
    return min(divs) + max(divs) if divs else 0

#print(sum_divisors(298))

q = 0
n = 5_400_000
while q < 5:
    n += 1
    M = sum_divisors(n)
    if M > 60_000 and str(M) == str(M)[::-1]:
        print(n, M)
        q += 1

ЕГЭ. Основная волна. 11.06.2025

Пусть \(M\) — сумма минимального и максимального простых делителей целого числа, не считая самого числа. Если у числа нет простых делителей, кроме него самого, то \(M = 0.\) Определите первые пять, большие, чем \(7~000~000\) у которых оканчиваются на \(13.\) В ответе укажите эти числа.

def is_prime(n):
    if n == 2:
        return True
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return False
    return True

def sum_divs(n):
    divs = set()
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d = n // x
            if is_prime(x):
                divs.add(x)
            if is_prime(d):
                divs.add(d)
    return min(divs) + max(divs) if divs else 0

q = 0
n = 7_000_000
while q < 5:
    n += 1
    M = sum_divs(n)
    if M % 100 == 13:
        print(n)
        q += 1

ЕГЭ. Основная волна. 10.06.2025

Определите первые \(5\) чисел, больших \(2~900~000,\) которые являются произведением двух простых чисел, каждое из которых содержит в себе ровно один \(0.\) В ответе в первом столбце таблицы запишите найденные числа в порядке возрастания, а во втором соответствующие им их максимальные множители.

def is_prime(n):
    if n == 2:
        return True
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return False
    return True

def divisors(n):
    divs = set()
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d = n // x
            if is_prime(x):
                divs.add(x)
            if is_prime(d):
                divs.add(d)
    return divs

q = 0
n = 2_900_000

while q < 5:
    n += 1
    divs = divisors(n)
    if len(divs) == 2 and all(str(x).count('0') == 1 for x in divs):
        print(n, max(divs))
        q += 1

ЕГЭ. Апробация. 14.05.2025-1

Напишите программу, которая перебирает целые числа, большие \(800~000,\) в порядке возрастания и ищет среди них такие, у которых есть натуральный делитель, оканчивающийся на цифру \(7\) и не равный ни самому числу, ни числу \(7.\) В ответе запишите в первом столбце таблицы первые пять найденных чисел в порядке возрастания, а во втором столбце — пять соответствующих этим числам минимальных делителей, оканчивающихся на цифру \(7,\) не равных ни самому числу, ни числу \(7.\)

Количество строк в таблице для ответа избыточно.

def div7(n):
    divisors = set()
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            if x != 7 and x % 10 == 7:
                divisors.add(x)
            d = n // x
            if d % 10 == 7:
                divisors.add(d)

    return min(divisors) if divisors else 0

q = 0
n = 800_000
while q < 5:
    n += 1
    d = div7(n)
    if d:
        print(n, d)
        q += 1

ЕГЭ. ЕГКР. 19.04.2025

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

символ «?» означает ровно одну произвольную цифру;
символ «*» означает любую последовательность произвольной длины; в том числе «*» может задавать и пустую последовательность.
Например, маске \(123{*}4?5\) соответствуют числа \(123405\) и \(12300405.\)

Среди натуральных чисел, не превышающих \(10^{10},\) найдите все числа, соответствующие маске \(4{*}4736{*}1,\) которые делятся на \(7993\) без остатка. В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце — соответствующие им результаты деления этих чисел на \(7993.\) Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

n = 447361 + (7993 - 447361 % 7993) % 7993
for x in range(n, 10**10, 7993):
    if fnmatch(str(x),'4*4736*1'):
        print(x, x // 7993)

ЕГЭ. Досрочный экзамен. 08.04.2025

Напишите программу, которая перебирает целые числа, бóльшие \(1~125~000,\) в порядке возрастания и ищет среди них такие, у которых есть натуральный делитель, оканчивающийся на цифру \(7\) и не равный ни самому числу, ни числу \(7.\) В ответе запишите в первой строке таблицы первые пять найденных чисел в порядке возрастания, а во втором столбце – наименьший делитель для каждого из них, оканчивающийся цифрой \(7,\) не равный ни самому числу, ни числу \(7.\) Количество строк в таблице для ответа избыточно.

def divisors(n):
    div7 = set()
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d = n // x
            if x != 7 and x % 10 == 7:
                div7.add(x)
            if d != 7 and d % 10 == 7:
                div7.add(d)
    if len(div7):
        return min(div7)
    return 0

i = 0
n = 1_125_000
while i < 5:
    n += 1
    d = divisors(n)
    if d:
        print(n, d)
        i += 1

ЕГЭ. Апробация. 05.03.2025

Пусть \(M\) — сумма минимального и максимального натуральных делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(M\) равным нулю. Напишите программу, которая перебирает целые числа, большие \(700~000,\) в порядке возрастания и ищет среди них такие, для которых \(M\) оканчивается на \(4.\) В ответе запишите в первом столбце таблицы первые пять найденных чисел в порядке возрастания, а во втором столбце — соответствующие им значения \(M.\) Например, для числа \(20\) \(M = 2 + 10 = 12.\) Количество строк в таблице для ответа избыточно.

from itertools import count

def sum_divisors(n):
    d = set()
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d.add(x)
            d.add(n // x)
    return min(d) + max(d) if d else 0

q = 0
for n in count(700_000):
    sd = sum_divisors(n)
    if sd % 10 == 4:
        print(n, sd)
        q += 1
    if q == 5:
        break

ЕГЭ. Демо-2025

Пусть \(M\) – сумма минимального и максимального натуральных делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(M\) равным нулю.

Напишите программу, которая перебирает целые числа, бо́льшие \(800~000\), в порядке возрастания и ищет среди них такие, для которых \(M\) оканчивается на \(4\). В ответе запишите в первом столбце таблицы первые пять найденных чисел в порядке возрастания, а во втором столбце – соответствующие им значения \(M\).

Например, для числа \(20\) \(М = 2 + 10 = 12\).

Количество строк в таблице для ответа избыточно.

#include<iostream>
#include<cmath>

using namespace std;

int min_divisor(int n) {
    int ans = 0, t = sqrt(n);

    for (int x = 2; x < t + 1; x++)
        if (n % x == 0) {
            ans = x;
            break;
        }
    return ans;
}

int32_t main() {
    int q = 5, n = 800 * 1000;
    

    while(q) {
        int d;
        n++;
        d = min_divisor(n);
        if(d && (d + n / d) % 10 == 4) {
           cout << n << " " << d + n / d << '\n';
           q--;
        }
    }
}

ЕГЭ. Шастин. 7.6.2025

(Л. Шастин) Напишите программу, которая перебирает целые числа, меньшие \(987~654,\) в порядке убывания и ищет среди них такие, у которых есть простой делитель, оканчивающийся на \(17\) и не равный ни самому числу, ни числу \(17.\) В ответе запишите в первой строке таблицы первые пять найденных чисел в порядке убывания, а во втором столбце — наименьший простой делитель для каждого из них, оканчивающийся на \(17,\) не равный ни самому числу, ни числу \(17.\)

Количество строк в таблице для ответа избыточно.

def is_prime(n):
    if n == 2:
        return True
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return False
    return True

def prime_div(n):
    div = set()
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d = n // x
            if is_prime(x):
                div.add(x)
            if is_prime(d):
                div.add(d)
    return div

n = 987_654
q = 0
while q < 5:
    n -= 1
    div = [x for x in prime_div(n) if x != 17 and x % 100 == 17]
    if div:
        print(n, min(div))
        q += 1

ЕГЭ. Шастин. 5.6.2025

(Л. Шастин) Обозначим через \(F\) целую часть среднего арифметического всех нечётных делителей целого числа. Напишите программу, которая перебирает целые числа, большие \(345~678,\) в порядке возрастания и ищет среди них такие, для которых значение \(F\) не равно нулю и кратно \(37.\)

Выведите первые \(5\) найденных числа в порядке возрастания и справа от каждого числа - соответствующее значение \(F.\)

Количество строк для записи ответа избыточно.

def div_mean(n):
    div = set()
    for x in range(1, int(n**0.5) + 1):
        if n % x == 0:
            if x % 2 == 1:
                div.add(x)
            d = n // x
            if d % 2 == 1:
                div.add(d)
    return sum(div) // len(div)

q = 0
n = 345_678
while q < 5:
    n += 1
    F = div_mean(n)
    if F and F % 37 == 0:
        print(n, F)
        q += 1

ЕГЭ. Шастин. 3.6.2025

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

символ «\(?\)» означает ровно одну произвольную цифру;
символ «\({*}\)» означает любую последовательность произвольной длины; в том числе «\({*}\)» может задавать и пустую последовательность.
Например, маске \(123{*}4?5\) соответствуют числа \(123475\) и \(12300475.\)

Среди натуральных чисел, не превышающих \(10^{12},\) найдите все числа, которые соответствуют маске \(5{*}7?,\) делятся на \(84318\) без остатка и не содержат одинаковых цифр.

В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце — соответствующие результаты деления этих чисел на \(84318.\) Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

for x in range(84318, 10**11, 84318):
    sx = str(x)
    if fnmatch(sx, '5*7?') and len(set(sx)) == len(sx):
        print(x, x // 84318)

ЕГЭ. Шастин. 1.6.2025

(Л. Шастин) Обозначим через \(M\) сумму двух минимальных и двух максимальных простых делителей целого числа, не считая самого числа. Если количество простых делителей у числа меньше \(4,\) то считаем значение \(M\) равным нулю. Напишите программу, которая перебирает целые числа, большие \(456~789,\) в порядке возрастания и ищет среди них такие, для которых значение \(M\) при делении на \(114\) даёт в остатке \(39.\)

Выведите первые \(5\) найденных чисел в порядке возрастания, справа от каждого числа запишите соответствующее значения \(M.\)

Количество строк для записи ответа избыточно.

def is_prime(n):
    if n == 2:
        return True
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return False
    return True

def sum_div(n):
    prime_divisors = set()
    for x in range(2, int(n ** 0.5) + 1):
        if n % x == 0:
            d = n // x
            if is_prime(x):
                prime_divisors.add(x)
            if is_prime(d):
                prime_divisors.add(d)
    if len(prime_divisors) < 4:
        return 0
    p = sorted(list(prime_divisors))
    return p[0] + p[1] + p[-2] + p[-1]

n = 456_789
q = 0
while q < 5:
    n += 1
    M = sum_div(n)
    if M % 114 == 39:
        print(n, M)
        q += 1

ЕГЭ Статград. Профиль. 12.05.2025

Маска числа – это последовательность цифр, в которой могут встречаться специальные символы «\(?\)» и «\(*\)». Символ «\(?\)» означает ровно одну произвольную цифру, символ «\(*\)» означает произвольную (в том числе пустую) последовательность цифр. Например, маске \(123{*}4{?}5\) соответствуют числа \(123405\) и \(12376415.\)

Найдите все натуральные числа, не превышающие \(2 \cdot 10^9,\) которые соответствуют маске \(1{*}7{*}1\) и при этом имеют ровно три нетривиальных делителя (не считая \(1\) и самого числа). В ответе запишите все найденные числа в порядке возрастания.

from fnmatch import fnmatch

def is_prime(n):
    if n == 2:
        return True
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return False
    return True

for n in range(2, int((2 * 10**9)**0.25) + 1):
    if is_prime(n) and fnmatch(str(n**4), '1*7*1'):
        print(n**4)

ЕГЭ Статград. База. 12.05.2025

Пусть \(R\) – сумма различных непростых натуральных делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(R\) равным нулю. Напишите программу, которая перебирает целые числа, меньшие \(987~653,\) в порядке убывания и ищет среди них такие, для которых \(R\) оканчивается на цифру \(7.\) В ответе запишите первые пять найденных чисел в порядке убывания.

Например, для числа \(12{:}\) \(R = 4 + 6 = 10.\)

def is_prime(n):
    if n == 2:
        return True
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return False
    return True

def sum_div(n):
    divisors = set()
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            if not is_prime(x):
                divisors.add(x)
            d = n // x
            if not is_prime(d):
                divisors.add(d)
    return sum(divisors) if divisors else 0

#print(sum_div(12))
q = 0
n = 987_653
while q < 5:
    n -= 1
    if sum_div(n) % 10 == 7:
        print(n)
        q += 1

ЕГЭ. Демо-2025-2

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

– символ «?» означает ровно одну произвольную цифру;
– символ «*» означает любую последовательность цифр произвольной длины; в том числе «*» может задавать и пустую последовательность.

Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300405\). Среди натуральных чисел, не превышающих \(10^{10}\), найдите все числа, соответствующие маске \(3?12?14*5\), делящиеся на \(1917\) без остатка.

В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце – соответствующие им результаты деления этих чисел на \(1917\).

Количество строк в таблице для ответа избыточно.

#include<iostream>
#include<string>
#include<fnmatch.h>

using namespace std;

int32_t main() {
    long long n = 30120145;
    n += n % 1917 ? 1917 - n % 1917 : 0;

    for(; n < 10ll * 1000 * 1000 * 1000; n += 1917)
        if (!fnmatch("3?12?14*5", to_string(n).c_str(), 0))
            cout << n << " " << n / 1917 << '\n';

}

ЕГЭ. Шастин. 7.05.2025

(Л. Шастин) Обозначим через \(F\) целую часть среднего арифметического всех простых делителей целого числа, оканчивающихся на \(7,\) не считая самого числа. Если таких делителей у числа нет, то считаем значение \(F\) равным нулю. Напишите программу, которая перебирает целые числа, меньшие \(750~000,\) в порядке убывания, и ищет среди них такие, для которых значение \(F\) не равно нулю и кратно \(111.\)

Выведите первые \(5\) найденных числа в порядке убывания и справа от каждого числа — соответствующие им значения \(F.\)

Например, для числа \(119\) значение \(F = (7 + 17)/2 = 12.\) Количество строк для записи ответа избыточно.

def is_prime(n):
    if n == 2:
        return True
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return False
    return True

def F(n):
    div = set()
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            if x % 10 == 7 and is_prime(x):
                div.add(x)
            d = n // x
            if d % 10 == 7 and is_prime(d):
                div.add(d)
    return sum(div) // len(div) if div else 0


#print(F(119))
q = 0
n = 750_000
while q < 5:
    n -= 1
    avg = F(n)
    if avg and avg % 111 == 0:
        print(n, avg)
        q += 1

ЕГЭ. Шастин. 13.03.2025

(Л. Шастин) Назовём маской числа последовательность цифр, в которой также могут встречаться следующие символы:

символ «?» означает ровно одну произвольную цифру;
символ «*» означает любую последовательность цифр произвольной длины; в том числе «*» может задавать и пустую последовательность.
Например, маске \(123{*}4{?}5\) соответствуют числа \(123405\) и \(12300405.\)

Среди натуральных чисел, не превышающих \(10^9,\) найдите все числа, соответствующие маске \(34{*}56{?}7,\) делящиеся на \(4321\) без остатка, произведение цифр которых оканчивается на \(0.\) В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце — соответствующие им произведения их цифр. Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

start = 345607 + (4321 - 345607 % 4321) % 4321

for n in range(start, 10**9, 4321):
    ns = str(n)
    if fnmatch(ns, '34*56?7'):
        prod = 1
        for ch in ns:
            prod *= int(ch)
        print(n, prod)

ЕГЭ. ЕГКР. 21.12.2024

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

– символ «?» означает ровно одну произвольную цифру;
– символ «*» означает любую последовательность цифр произвольной длины; в том числе «*» может задавать и пустую последовательность.

Например, маске \(123{*}4{?}5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{10}\), найдите все числа, соответствующие маске \(54{?}1{?}3{*}7\), делящиеся на \(18579\) без остатка.

В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце – соответствующие им результаты деления этих чисел на \(18579\).

Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch
n = 5401037
n += 18579 - n % 18579

for x in range(n, 10**10, 18579):
    if fnmatch(str(x), '54?1?3*7'):
        print(x, x // 18579)

ЕГЭ. Статград. 01.04.2025-1

Пусть \(M\) — максимальный простой натуральный делитель целого числа, не считая самого числа. Если таких делителей у числа нет, то считаем значение \(M\) равным нулю. Напишите программу, которая перебирает целые числа, большие \(1~750~000,\) в порядке возрастания и ищет среди них такие, для которых \(M\) не больше \(15~000\) и оканчивается на \(7.\) В ответе запишите первые пять найденных чисел в порядке возрастания.

Например, для числа \(105\) \(M = 7.\)

def is_prime(n):
    if n == 2:
        return True
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return False
    return True

def max_div(n):
    divs = {0}
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            if is_prime(x):
                divs.add(x)
            t = n // x
            if is_prime(t):
                divs.add(t)
    return max(divs)

i = 0
n = 1_750_000
while i < 5:
    n += 1
    md = max_div(n)
    if md <= 15_000 and md % 10 == 7:
        print(n)
        i += 1

ЕГЭ. Статград. 04.03.2025

Маска числа – это последовательность цифр, в которой могут встречаться специальные символы «\(?\)» и «\(*\)». Символ «\(?\)» означает ровно одну произвольную цифру, символ «\(*\)» означает произвольную (в том числе пустую) последовательность цифр. Например, маске \(123{*}4{?}5\) соответствуют числа \(123405\) и \(12376415.\)

Найдите все натуральные числа, не превышающие \(10^9,\) которые соответствуют маске \(4{?}28{*}8{*}3\) и при этом без остатка делятся на \(9111.\) В ответе запишите все найденные числа в порядке возрастания.

from fnmatch import fnmatch

n = 402883
r = n % 9111
n += 9111 - r if r else 0

for x in range(n, 10**9, 9111):
    if fnmatch(str(x), '4?28*8*3'):
        print(x)

ЕГЭ. Статград. 28.01.2025-1

Маска числа – это последовательность цифр, в которой могут встречаться специальные символы «\(?\)» и «\(*\)». Символ «\(?\)» означает ровно одну произвольную цифру, символ «\(*\)» означает произвольную (в том числе пустую) последовательность цифр. Например, маске \(123{*}4?5\) соответствуют числа \(123405\) и \(12376415.\)

Найдите все натуральные числа, не превышающие \(10^9,\) которые соответствуют маске \(4{?}5{*}07{*}3\) и при этом без остатка делятся на \(9341.\) В ответе запишите все найденные числа в порядке возрастания.

from fnmatch import fnmatch

n = 405073 + (9341 - 405073 % 9341)
for x in range(n, 10**9, 9341):
    if fnmatch(str(x), '4?5*07*3'):
        print(x)

ЕГЭ. Статград. 17.12.2024-1

Маска числа – это последовательность цифр, в которой могут встречаться специальные символы «\(?\)» и «\(*\)». Символ «\(?\)» означает ровно одну произвольную цифру, символ «\(*\)» означает произвольную (в том числе пустую) последовательность цифр.

Например, маске \(123{*}4{?}5\) соответствуют числа \(123405\) и \(12376415.\)

Найдите все натуральные числа, принадлежащие интервалу \([10^8; \, 2 \cdot 10^8],\) которые соответствуют маске \({?}{*}42{*}81\) и имеют ровно три натуральных делителя. В ответе запишите все найденные числа в порядке возрастания.

from fnmatch import fnmatch

def is_prime(n):
    if n == 2:
        return True
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return False
    return True

for x in range(10**4, int(2**0.5 * 10**4) + 1):
    if is_prime(x):
        q = x**2
        if fnmatch(str(q), '?*42*81'):
            print(q)

ЕГЭ. Статград. 24.10.2024-1

Пусть \(M (N)\) – сумма \(2\) наибольших различных натуральных делителей натурального числа \(N\), не считая самого числа и единицы. Если у числа \(N\) меньше \(2\) таких делителей, то \(M (N)\) считается равным \(0.\)

Найдите все такие числа \(N\), что \(110~250~000 \leqslant N \leqslant 110~300~000\), а десятичная запись числа \(M (N)\) заканчивается на \(1002.\)

В ответе перечислите все найденные числа \(N\) в порядке возрастания.

def M(n):
    s = set()
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            s.add(i)
            s.add(n // i)

    tmp = sorted(list(s))
    if len(tmp) < 2:
        return 0
    return tmp[-1] + tmp[-2]

for N in range(110_250_000, 110_300_001):
    if M(N) % 10000 == 1002:
        print(N)

ЕГЭ. Шастин. 9.2.2025

(Д. Бахтиев) Пусть \(R\) — разность максимального и минимального простых делителей целого числа, не считая самого числа. Напишите программу, которая перебирает целые числа, большие \(3~333~337\) в порядке возрастания и ищет среди них такие, для которых \(R\) больше \(1000\) и кратно \(3.\) В ответе запишите в первом столбце таблицы первые пять найденных чисел в порядке возрастания, а во втором столбце — соответствующие им значения \(R.\)

def is_prime(n):
    if n == 2:
        return True
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return False
    return True

def find_r(n):
    divisors = set()
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            if is_prime(x):
                divisors.add(x)
            tmp = n // x
            if is_prime(tmp):
                divisors.add(tmp)
    if divisors:
        return max(divisors) - min(divisors)
    else:
        return -1

i = 0
n = 3_333_337
while i < 5:
    n += 1
    R = find_r(n)
    if R > 1000 and R % 3 == 0:
        print(n, R)
        i += 1

ЕГЭ. Шастин. 19.01.2025

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

символ «\(?\)» означает ровно одну произвольную цифру;
символ «\(*\)» означает любую последовательность цифр произвольной длины; в том числе «\(*\)» может задавать и пустую последовательность;
символ «Н» означает ровно одну нечётную цифру;
символ «Ч» означает ровно одну чётную цифру:
Например, маске 1Ч3*4?Н соответствуют числа \(123405\) и \(12300405.\)

Среди натуральных чисел, не превышающих \(10^{10}\), найдите все числа, соответствующие маске Ч9?23?*23НЧ и делящиеся на \(1984\) без остатка.

В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце — соответствующие им результаты деления этих чисел на \(1984.\) Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

n = 2902302310 + (1984 - 2902302310 % 1984)
for x in range(n, 10**10, 1984):
    xs = str(x)
    if int(xs[0]) % 2 == 0 and int(xs[-2]) % 2 and int(xs[-1]) % 2 == 0 \
       and fnmatch(xs[1:-2], '9?23?*23'):
        print(x, x // 1984)

ЕГЭ. Шастин. 18.12.2024

(Д. Бахтиев) Назовём маской числа последовательность цифр, в которой также могут встречаться следующие символы

символ «\(?\)» означает ровно одну произвольную цифру;
символ «\(*\)» означает любую последовательность цифр произвольной длины; в том числе «\(*\)» может задавать и пустую последовательность.
Например, маске \(123{*}4{?}5\) соответствуют числа \(123405\) и \(12300405.\)

Напишите программу, которая перебирает целые числа, большие \(500~000,\) в порядке возрастания и ищет среди них такие, у которых есть хотя бы один делитель, соответствующий маске \(2{*}3{?}.\) В ответе запишите в первом столбце таблицы первые пять найденных чисел в порядке возрастания, а во втором столбце - наименьший их делитель, соответствующий заданной маске.

Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

def divisors(n):
    d = set()
    d.add(1)
    d.add(n)
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d.add(x)
            d.add(n // x)
    return d

q = 0
n = 500_000
while q < 5:
    n += 1
    d = [x for x in divisors(n) if fnmatch(str(x), '2*3?')]
    if len(d):
        print(n, min(d))
        q += 1

ЕГЭ. Шастин. 30.11.2024

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

символ «?» означает ровно одну произвольную цифру;
символ «*» означает любую последовательность цифр произвольной длины; в том числе «*» может задавать и пустую последовательность.
Например, маске \(123{*}4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{10}\), найдите все числа, делящиеся на \(2025\) без остатка и соответствующие обеим маскам: \(33?2{*}42?\) и \({*}32??2?.\)

В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце – соответствующие им результаты деления этих чисел на \(2025\).

Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

a = []
n1 = 3302420 - (3302420 % 2025) + 2025

for x in range(n1, 10**10, 2025):
    if fnmatch(str(x), '33?2*42?'):
        a.append(x)

n2 = 320020 - (320020 % 2025) + 2025
for x in range(n2, 10**10, 2025):
    if x in a and fnmatch(str(x), '*32??2?'):
        print(x, x // 2025)

ЕГЭ. Шастин. 6.11.2024

(Л. Шастин) Обозначим через \(A\) целую часть среднего арифметического всех делителей фелого числа, не считая самого числа. Напишите программу, которая перебирает целые числа, меньшие \(770000\), в порядке убывания и ищет среди них такие, для которых значение \(A\) оканчивается на \(12\). Выведите первые \(5\) найденных чисел и соответствующие им значения \(A\).

Формат вывода: для каждого из \(5\) таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(A\). Строки выводятся в порядке убывания найденных чисел.

Например, для числа \(8\) значение \(A = (1 + 2 + 4) / 3 = 2\).

Количество строк в таблице для ответа избыточно.

def mdiv(n):
    divisors = set()
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n // i)
    divisors.add(1)
    return sum(divisors) // len(divisors)

n = 770000
q = 0
while q < 5:
    n -= 1
    A = mdiv(n)
    if A % 100 == 12:
        print(n, A)
        q += 1

ЕГЭ. Шастин. 18.10.2024

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

– символ «\(?\)» означает ровно одну произвольную цифру;
– символ «\(\#\)» означает любую последовательность чётных цифр произвольной длины; в том числе «\(\#\)» может задавать и пустую последовательность.

Например, маске \(123\#4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{10}\), найдите все числа, соответствующие маске \(1592\#6?8\) и делящиеся на \(1996\) без остатка.

В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце – соответствующие им результаты деления этих чисел на \(1996\).

Количество строк в таблице для ответа избыточно.

n = 1592608 + 1996 - (1592608 % 1996)
while n < 10**10:
    ns = str(n)
    sharp = ns[4:-3]
    if ns[:4] == '1592' and (sharp == '' or all(int(x) % 2 == 0 for x in sharp)) \
       and ns[-3] == '6'and ns[-1] == '8':
        print(n, n // 1996)
    n += 1996

ЕГЭ. Шастин. 4.10.2024

(Д. Бахтиев) Напишите программу, которая перебирает целые числа, большие \(1~000~000\), в порядке возрастания и ищет среди них те, которые имеют ровно \(3\) простых делителя. В ответе запишите \(5\) наименьших таких чисел в порядке возрастания. Справа от каждого такого числа укажите его наибольший простой делитель.

Количество строк в таблице для ответа избыточно.

def is_prime(n):
    if n == 2 or n == 3:
        return True
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return False
    return True

def prime_divisors(n):
    divisors = set()
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            divisors.add(x)
            divisors.add(n // x)
    return [p for p in divisors if is_prime(p)]

i = 0
x = 1_000_000
while i < 5:
    x += 1
    d = prime_divisors(x)
    if len(d) == 3:
        print(x, max(d))
        i += 1

ЕГЭ. Шастин. 19.09.2024

(Л. Шастин) Пусть \(S\) — сумма всех делителей целого числа. Например, для числа \(12\) значение \(S = 1 + 2 + 3 + 4 + 6 + 12 = 28\). Напишите программу, которая перебирает все четырёхзначные числа и ищет среди них такие, для которых \(S\) оканчивается на \(23\). В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце — соответствующие им значения \(S\).

Количество строк в таблице для ответа избыточно.

def sum_divisors(n):
    divisors = set()
    for i in range(1, int(n**0.5) + 1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n // i)
    return sum(divisors)

for n in range(1000, 10_000):
    s = sum_divisors(n)
    if s % 100 == 23:
        print(n, s)

ЕГЭ. Шастин. 29.08.2024

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

– символ «\(?\)» означает ровно одну произвольную цифру;
– символ «\(*\)» означает любую последовательность цифр произвольной длины; в том числе «\(*\)» может задавать и пустую последовательность.

Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{10}\), найдите все числа, соответствующие маске \(21?3*145?5\) и делящиеся на \(2025\) без остатка.

В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце – соответствующие им результаты деления этих чисел на \(2025\).

Количество строк в таблице для ответа избыточно.

#include<iostream>
#include<string>
#include<fnmatch.h>

using namespace std;

int32_t main() {
    long long n = 210314505;
    int r = n % 2025;
    n += r ? 2025 - r : 0; 

    for(; n < 10ll * 1000 * 1000 * 1000; n += 2025) 
        if (!fnmatch("21?3*145?5", to_string(n).c_str(), 0))
            cout << n << " " << n / 2025 << " " << '\n';
}

ЕГЭ. Поляков-6836

(А. Богданов) Назовём маской числа последовательность цифр, в которой также могут встречаться следующие символы:
— символ «?» означает ровно одну произвольную цифру;
— символ «*» означает любую последовательность цифр произвольной длины, в том числе «*» может задавать и пустую последовательность.
Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300425\).
Среди десятиразрядных чисел, кратных \(2023\) и соответствующих маске «\(1*1\)», найдите числа с максимальной суммой цифр. В ответ запишите найденные числа в порядке убывания, справа от каждого числа запишите частное от деления на \(2023\).

def dig_sum(number):
    s = 0
    while number:
        s += number % 10
        number //= 10
    return s


n = 1999999991 - 1999999991 % 2023        # самое большое десятизначное число 1*, делящееся на 2023

while True:                               # находим самое большое десятизначное 1*1, делящееся на 2023
    if n % 10 == 1:
        break
    n -= 2023

nums = []                                 # сюда соберём все десятизначные числа вида 1*1, делящиеся на 2023

for i in range(n, 999999999, -20230):    # все такие числа находятся друг от друга на расстоянии 20230
    nums.append(i)                        # их не больше 50 000, не так много :)

nums_dig_sum = [dig_sum(n) for n in nums] # считаем суммы цифр каждого такого числа
max_sums = max(nums_dig_sum)              # находим максимальную такую сумму

for i in range(len(nums)):                # печатаем только числа с максимальной суммой, найденной ранее
    if nums_dig_sum[i] == max_sums:
        print(nums[i], nums[i] // 2023)

ЕГЭ. Поляков-2600

Среди целых чисел, принадлежащих числовому отрезку \([268312; \,\, 336492]\), найдите числа, которые представляют собой произведение двух различных простых делителей. Запишите в ответе количество таких чисел и минимальное их них.

def sieve(N):
    a = [1]*(N+1)

    a[0] = 0
    a[1] = 0

    for x in range(2, int(N**0.5) + 1):
        if a[x]:
            for i in range(x**2, N+1, x):
                a[i] = 0
                
    primes = []
    for x in range(2, N+1):
        if a[x]:
            primes.append(x)
    
    return primes

primes = sieve(336492)
a = []

for x in range(268312, 336493):
    for i in range(2, int(x**0.5)+1):
        if x % i == 0:
            sec_div = x // i
            if i in primes and i != sec_div and sec_div in primes:
                a.append(x)
            break

print(len(a), min(a))

ЕГЭ. Поляков-2599

Среди целых чисел, принадлежащих числовому отрезку \([125697; \,\, 190234]\), найдите числа, которые представляют собой произведение двух различных простых делителей. Запишите в ответе количество таких чисел и максимальное их них.

def sieve(N):
    a = [1]*(N+1)

    a[0] = 0
    a[1] = 0

    for x in range(2, int(N**0.5) + 1):
        if a[x]:
            for i in range(x**2, N+1, x):
                a[i] = 0
                
    primes = []
    for x in range(2, N+1):
        if a[x]:
            primes.append(x)
    
    return primes

primes = sieve(190234)
a = []

for x in range(125697, 190235):
    for i in range(2, int(x**0.5)+1):
        if x % i == 0:
            sec_div = x // i
            if i in primes and i != sec_div and sec_div in primes:
                a.append(x)
            break

print(len(a), max(a))

import java.util.ArrayList;

public class EGE2599 {

    static ArrayList<Integer> Sieve(int N) {
        int a[] = new int[N];
        a[0] = 0;
        a[1] = 0;
        for(int i = 0; i < N; i++) {
            a[i] = 1;
        }
        for(int i = 2; i < (int) Math.sqrt(N) + 1; i++) {
            if(a[i] == 1) {
                for(int j = i*i; j < N; j += i) {
                    a[j] = 0;
                }
            }
        }
        ArrayList<Integer> primes = new ArrayList<Integer>();
        for(int i = 2; i < N; i++) {
            if(a[i] == 1) {
                primes.add(i);
            }
        }
        return primes;

    }
    public static void main(String argv[]) {
        ArrayList<Integer> primes = Sieve(190234);
        ArrayList<Integer> a = new ArrayList<Integer>();
        for(int i = 125697; i < 190235; i++) {
            for(int j = 2; j < (int) Math.sqrt(i) + 1; j++) {
                if(i % j == 0) {
                    int sec_div = i / j;
                    if(primes.contains(j) && j != sec_div && primes.contains(sec_div)) {
                        a.add(i);
                    }
                    break;
                }
            }
        }
        int max_el = 125697;
        int sz = a.size();
        for(int i = 0; i < sz; i++) {
            if (a.get(i) > max_el) {
                max_el = a.get(i);
            }
        }
        System.out.println(sz + " " + max_el);
    }
}

ЕГЭ. Поляков-2598

Среди целых чисел, принадлежащих числовому отрезку \([1395; \,\, 22717]\), найдите числа, все цифры которых расположены в порядке неубывания. Ответом будет сумма найденных чисел. (К. Амеличев)

def num2arr(n):
    return list(map(int, str(n)))


s = 0
for x in range(1395, 22717):
    tmp_arr = num2arr(x)
    if tmp_arr == sorted(tmp_arr):
        s += x

print(s)

ЕГЭ. Поляков-2597

Среди целых чисел, принадлежащих числовому отрезку \([3159; \,\, 31584]\), найдите числа, которые являются простыми. Ответом будет сумма цифр найденных чисел. (К. Амеличев)

def sieve(N):
    a = [1]*(N+1)

    a[0] = 0
    a[1] = 0

    for x in range(2, int(N**0.5) + 1):
        if a[x]:
            for i in range(x**2, N+1, x):
                a[i] = 0
                
    primes = []
    for x in range(2, N+1):
        if a[x]:
            primes.append(x)
    
    return primes


def num2arr(n):
    return list(map(int, str(n)))


arr = sieve(31584)
for i in range(len(arr)):
    if arr[i] >= 3159:
        break

s = 0
for k in range(i, len(arr)):
    s += sum(num2arr(arr[k]))

print(s)

ЕГЭ. Поляков-2596

Среди целых чисел, принадлежащих числовому отрезку \([1686; \,\, 13276]\), найдите числа, все цифры которых нечетные. Ответом будет сумма цифр найденных чисел. (К. Амеличев)

def num2arr(n):
    return list(map(int, str(n)))

def prod(a):
    res = 1
    for i in range(len(a)):
        res *= a[i]
    return res

a = []
for x in range(1711, 13200, 2):
    if prod(num2arr(x)) % 2:
        a.append(x)

s = 0
for i in range(len(a)):
    s += sum(num2arr(a[i]))

print(s)

ЕГЭ. Поляков-2595

Среди целых чисел, принадлежащих числовому отрезку \([4099; \,\, 26985]\), найдите числа, имеющие ровно один натуральный делитель, не считая единицы и самого числа. В ответе запишите два числа: сначала количество найденных чисел, а затем сумму цифр этих чисел. (К. Амеличев)

def is_prime(n):
    if n == 2 or n == 3:
        return True
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True

def sum_dig(n):
    return sum(list(map(int, str(n))))

a = []

for x in range(4099, 26986):
    sq = int(x ** 0.5)
    if sq ** 2 == x and is_prime(sq):
        a.append(x)
        
s = 0
for i in range(len(a)):
    s += sum_dig(a[i])

print(len(a), s)

ЕГЭ. Поляков-2594

Среди целых чисел, принадлежащих числовому отрезку \( [2031; \,\, 14312]\), найдите числа, которые не содержат цифру \(2\), если записать их в системе счисления с основанием \(11\). Ответом будет максимум среди найденных чисел. (К. Амеличев)

def no2(n):
    while n:
        if n % 11 == 2:
            return False
        else:
            n //= 11
    return True

a = []
for x in range(2031, 14313):
    if no2(x):
        a.append(x)

print(max(a))

ЕГЭ. Поляков-2593

Среди целых чисел, принадлежащих числовому отрезку \( [2945; \,\, 18294]\), найдите числа, не делящиеся на вторую степень какого-либо числа, кроме единицы. Ответом будет сумма цифр найденных чисел. (К. Амеличев)

def div2(n):
    for x in range(2, int(n**0.5)+1):
        if n % x**2 == 0:
            return True
    return False

def sum_dig(n):
    return sum(list(map(int, str(n))))

a = []
for n in range(2945, 18295):
    if not div2(n):
        a.append(n)

s = 0
for i in range(len(a)):
    s += sum_dig(a[i])

print(s)

ЕГЭ. Поляков-2592

Среди целых чисел, принадлежащих числовому отрезку \( [87921; \,\, 88187]\), найдите числа, сумма цифр которых кратна \(14\), а произведение цифр кратно \(18\) и не равно \(0\). Для каждого найденного числа запишите сумму и произведение его цифр в таблицу на экране с новой строки в порядке возрастания произведения цифр. (С.А. Скопинцева)

def n2arr(n):
    return list(map(int, str(n)))

def prod(a):
    p = 1
    for i in range(len(a)):
        p *= a[i]
    return p

res=[]
for x in range(87921, 88188):
    temp_arr = n2arr(x)
    s_arr = sum(temp_arr)
    p_arr = prod(temp_arr)
    if s_arr % 14 == 0 and p_arr and p_arr % 18 == 0:
        res.append((s_arr, p_arr))

for t in sorted(res, key=lambda v: v[1]):
    print(t[0], t[1])

ЕГЭ. Поляков-2591

Определите количество простых чисел в диапазоне \( [2; \,\, 200000]\). (Д.Ф. Муфаззалов)

def sieve(N):
    a = [1]*(N+1)

    a[0] = 0
    a[1] = 0

    for x in range(2, int(N**0.5) + 1):
        if a[x]:
            for i in range(x**2, N+1, x):
                a[i] = 0
                
    primes = []
    for x in range(2, N+1):
        if a[x]:
            primes.append(x)
    
    return primes

print(len(sieve(200000)))

ЕГЭ. Поляков-2590

(Д.Ф. Муфаззалов) Определите количество простых чисел в диапазоне \( [2; \,\, 3577000]\).

def sieve(N):
    a = [1]*(N+1)

    a[0] = 0
    a[1] = 0

    for x in range(2, int(N**0.5) + 1):
        if a[x]:
            for i in range(x**2, N+1, x):
                a[i] = 0
                
    primes = []
    for x in range(2, N+1):
        if a[x]:
            primes.append(x)
    
    return primes

print(len(sieve(3577000)))

import java.util.ArrayList;

public class EGE2590 {

    static ArrayList<Integer> Sieve(int N) {
        int a[] = new int[N];
        a[0] = 0;
        a[1] = 0;
        for(int i = 0; i < N; i++) {
            a[i] = 1;
        }
        for(int i = 2; i < (int) Math.sqrt(N) + 1; i++) {
            if(a[i] == 1) {
                for(int j = i*i; j < N; j += i) {
                    a[j] = 0;
                }
            }
        }
        ArrayList<Integer> primes = new ArrayList<Integer>();
        for(int i = 2; i < N; i++) {
            if(a[i] == 1) {
                primes.add(i);
            }
        }
        return primes;

    }
    public static void main(String argv[]) {
        ArrayList<Integer> primes = Sieve(3577000);
        System.out.println(primes.size());
    }
}

ЕГЭ. Поляков-2589

(Д.Ф. Муфаззалов) Два числа называются дружественными если сумма собственных делителей (то есть всех положительных делителей, отличных от самого́ числа) любого их них равна другому числу. Например, числа \(220\) и \(284\) дружественные. Выведите в порядке возрастания числа в диапазоне \( [2; \,\, 30000]\), имеющие дружественное число, большее чем само это число, и через пробел это дружественное число. Каждое следующие число из указанного диапазона выводите на новой строке.

def divisors(n):
    d = set()
    d.add(1)
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            d.add(x)
            d.add(n // x)
    return d

for x in range(2, 30001):
    sum_div = sum(divisors(x))
    if sum_div > x and x == sum(divisors(sum_div)):
        print(x, sum_div)

ЕГЭ. Поляков-2588

(Д.Ф. Муфаззалов) Совершенным называется число, натуральное число, равное сумме всех своих собственных делителей (то есть всех положительных делителей, отличных от самого́ числа) (например, число \( 6=1+2+3 \)). ) Выведите каждое совершенное число из диапазона \( [2; \,\, 10000]\) и количество его собственных делителей в порядке возрастания. Вывод каждого совершенного числа начинайте с новой строки. Числа в строке разделяйте пробелом.

def divisors(n):
    d = set()
    d.add(1)
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            d.add(x)
            d.add(n // x)
    return d

for x in range(2, 10001):
    d = divisors(x)
    if x == sum(d):
        print(x, len(d))

ЕГЭ. Поляков-2587

(Б.С. Михлин) Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \( [194441; \,\, 196500]\) простые числа (т.е. числа у которых только два делителя: \(1\) и само число), оканчивающиеся на \(93\). Для каждого простого числа выведите его порядковый номер (начиная с единицы), а затем – само число.

def is_prime(n):
    if n == 2 or n == 3:
        return True
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True

i = 1
for x in range(194493, 196501, 100):
    if is_prime(x):
        print(i, x)
        i += 1

ЕГЭ. Поляков-2586

(А.Н. Носкин) Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \( [2532000; \,\, 2532160]\), простые числа. Найдите все простые числа, которые заканчиваются на цифру \(7\). Выведите их в порядке возрастания, слева от каждого числа выведите его номер по порядку.

def is_prime(n):
    if n == 2 or n == 3:
        return True
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True

i = 1
for x in range(2532007, 2532161, 10):
    if is_prime(x):
        print(i, x)
        i += 1

ЕГЭ. Поляков-2585

(А.Н. Носкин) Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \( [2532000; \,\, 2532160]\) первые пять простых чисел. Выведите найденные простые числа в порядке возрастания, слева от каждого числа выведите его номер по порядку.

def is_prime(n):
    if n == 2 or n == 3:
        return True
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True

i = 1
for x in range(2532000, 2532161):
    if is_prime(x):
        print(i, x)
        i += 1
    if i > 5:
        break

ЕГЭ. Поляков-2584

(А.Н. Носкин) Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \( [3532000; \,\, 3532160]\), простые числа. Выведите все найденные простые числа в порядке убывания, слева от каждого числа выведите его номер по порядку.

def is_prime(n):
    if n == 2 or n == 3:
        return True
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True

i = 1
for x in range(3532160, 3532000, -1):
    if is_prime(x):
        print(i, x)
        i += 1

ЕГЭ. Поляков-2583

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \( [7178551; \,\, 7178659]\), простые числа. Выведите все найденные простые числа в порядке возрастания, слева от каждого числа выведите его номер по порядку.

def is_prime(n):
    if n == 2 or n == 3:
        return True
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True

i = 1
for x in range(7178551, 7178660):
    if is_prime(x):
        print(i, x)
        i += 1

ЕГЭ. Поляков-2582

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \( [2532421; \,\, 2532491]\), простые числа. Выведите все найденные простые числа в порядке возрастания, слева от каждого числа выведите его номер по порядку.

def is_prime(n):
    if n == 2 or n == 3:
        return True
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True

i = 1
for x in range(2532421, 2532492):
    if is_prime(x):
        print(i, x)
        i += 1

ЕГЭ. Поляков-2581

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \( [4301614; \, 4301717]\), простые числа. Выведите все найденные простые числа в порядке возрастания, слева от каждого числа выведите его номер по порядку.

def is_prime(n):
    if n == 2 or n == 3:
        return True
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True

i = 1
for x in range(4301614, 4301718):
    if is_prime(x):
        print(i, x)
        i += 1

ЕГЭ. Поляков-2580

(Б.С. Михлин) Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([586132; \, 586430]\), числа, имеющие максимальное количество различных делителей. Найдите минимальное и максимальное из таких чисел. В ответе для каждого из них запишите два числа: количество делителей и наибольший делитель, не равный самому числу.

def search_div(n):

    divisors = set()

    for i in range(1, int(n**0.5)+1):
        if not n % i:
            divisors.add(i)
            divisors.add(n//i)
    
    return divisors

count_d = 0
max_d = 0
min_d = 0

for n in range(586132, 586431):
    divisors = [*search_div(n)]
    c = len(divisors)
    if c > count_d:
        count_d = c
        divisors.sort()
        min_d = divisors[-2]
    elif c == count_d:
        divisors.sort()
        max_d = divisors[-2]

print(count_d, min_d)
print(count_d, max_d)

ЕГЭ. Поляков-2579

(Б.С. Михлин) Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([286564; \, 287270]\), числа, имеющие максимальное количество различных делителей. Если таких чисел несколько, то найдите максимальное из них. В ответе запишите два числа: количество делителей найденного числа и его наибольший делитель, не равный самому числу.

def search_div(n):

    divisors = set()

    for i in range(1, int(n**0.5)+1):
        if not n % i:
            divisors.add(i)
            divisors.add(n//i)
    
    return divisors

count_d = 0
max_d = 0

for n in range(286564, 287271):
    divisors = [*search_div(n)]
    c = len(divisors)
    if count_d <= c:
        count_d = c
        divisors.sort()
        max_d = divisors[-2]

print(count_d, max_d)

ЕГЭ. Поляков-2578

(Б.С. Михлин) Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([394441; \, 394505]\), числа, имеющие максимальное количество различных делителей. Если таких чисел несколько, то найдите минимальное из них. В ответе запишите два числа: количество делителей найденного числа и само число.

def search_div(n):

    divisors = set()

    for i in range(1, int(n**0.5)+1):
        if not n % i:
            divisors.add(i)
            divisors.add(n//i)
    
    return divisors

n_max_d = 0
max_d = 0

for n in range(394441, 394506):
    d = len(search_div(n))
    if d > max_d:
        max_d, n_max_d = d, n

print(max_d, n_max_d)

ЕГЭ. Поляков-2577

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([1820348; \, 2880927]\), числа, имеющие ровно \(5\) различных делителей. В ответе для каждого найденного числа запишите два его наибольших делителя в порядке возрастания.

import math

def is_prime(n):
    if n == 1:
        return False
    if n in (2, 3):
        return True
    for i in range(2, int(n**0.5)+1):
        if not n % i:
            return False
    return True

d = math.ceil(1820348**0.25)

while 1820348 <= d ** 4 <= 2880927:
    if is_prime(d):
        print(d**3, d**4)
    d += 1

ЕГЭ. Поляков-2576

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([652938; \, 1744328]\), числа, имеющие ровно \(5\) различных делителей. В ответе для каждого найденного числа запишите два его наибольших делителя, не равных самому числу, в порядке возрастания.

import math

def is_prime(n):
    if n == 1:
        return False
    if n in (2, 3):
        return True
    for i in range(2, int(n**0.5)+1):
        if not n % i:
            return False
    return True

d = math.ceil(652938**0.25)

while 652938 <= d ** 4 <= 1744328:
    if is_prime(d):
        print(d**2, d**3)
    d += 1

ЕГЭ. Поляков-2575

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([244143; \, 1367821]\), числа, имеющие ровно \(5\) различных делителей. В ответе для каждого найденного числа запишите два его наибольших делителя, не равных самому числу, в порядке возрастания.

import math

def is_prime(n):
    if n == 1:
        return False
    if n in (2, 3):
        return True
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return False
    return True

d = math.ceil(244143**0.25)

while 244143 <= d ** 4 <= 1367821:
    if is_prime(d):
        print(d**2, d**3)
    d += 1

ЕГЭ. Поляков-2574

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([11275; \, 16328]\), числа, имеющие ровно \(5\) различных делителей. В ответе для каждого найденного числа запишите два его наибольших делителя, не равных самому числу, в порядке возрастания.

import math

def is_prime(n):
    if n == 1:
        return False
    if n in (2, 3):
        return True
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return False
    return True

d = math.ceil(11275**0.25)

while 11275 <= d ** 4 <= 16328:
    if is_prime(d):
        print(d**2, d**3)
    d += 1

ЕГЭ. Поляков-2573

(А.Н. Носкин) Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([190061; \, 190072]\), числа, имеющие ровно \(4\) различных НЕЧЁТНЫХ делителя. В ответе для каждого найденного числа запишите два его наибольших нечётных делителя в порядке убывания.

def find_div(n):
    divisors = set()
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            if i % 2:
                divisors.add(i)
            if n // i % 2:
                divisors.add(n//i)
        if len(divisors) > 4:
            break
    return divisors

for i in range(190061, 190073):
    d = [*find_div(i)]
    if len(d) == 4:
        d.sort()
        print(d[3], d[2])

ЕГЭ. Поляков-2572

(А.Н. Носкин) Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([190201; \, 190260]\), числа, имеющие ровно \(4\) различных ЧЁТНЫХ делителя. В ответе для каждого найденного числа запишите два его наибольших ЧЁТНЫХ делителя в порядке убывания.

def find_div(n):
    divisors = set()
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            if i % 2 == 0:
                divisors.add(i)
            if n // i % 2 == 0:
                divisors.add(n//i)
        if len(divisors) > 4:
            break
    return divisors

for i in range(190201, 190261):
    d = [*find_div(i)]
    if len(d) == 4:
        d.sort()
        print(d[3], d[2])

ЕГЭ. Поляков-2571

(А.Н. Носкин) Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([190201; \, 190220]\), числа, имеющие ровно 4 различных делителя. В ответе для каждого найденного числа запишите два его наибольших делителя в порядке убывания.

def find_div(n):
    divisors = set()
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n//i)
        if len(divisors) > 4:
            break
    return divisors

for i in range(190201, 190221):
    d = [*find_div(i)]
    if len(d) == 4:
        d.sort()
        print(d[3], d[2])

ЕГЭ. Поляков-2570

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([135743; \, 135789]\), числа, имеющие ровно \(6\) различных делителей. В ответе для каждого найденного числа запишите два его наибольших делителя в порядке возрастания.

def find_div(n):
    divisors = set()
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n//i)
        if len(divisors) > 6:
            break
    return divisors

for i in range(135743, 135790):
    d = [*find_div(i)]
    if len(d) == 6:
        d.sort()
        print(d[4], d[5])

ЕГЭ. Поляков-2569

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([180131; \, 180179]\), числа, имеющие ровно \(6\) различных делителей. В ответе для каждого найденного числа запишите два его наибольших делителя в порядке возрастания.

def find_div(n):
    divisors = set()
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n//i)
        if len(divisors) > 6:
            break
    return divisors

for i in range(180131, 180180):
    d = [*find_div(i)]
    if len(d) == 6:
        d.sort()
        print(d[4], d[5])

ЕГЭ. Поляков-2568

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([164700; \, 164752]\), числа, имеющие ровно \(6\) различных делителей. В ответе для каждого найденного числа запишите два его наибольших делителя в порядке возрастания.

def find_div(n):
    divisors = set()
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n//i)
        if len(divisors) > 6:
            break
    return divisors

for i in range(164700, 164753):
    d = [*find_div(i)]
    if len(d) == 6:
        d.sort()
        print(d[4], d[5])

ЕГЭ. Поляков-2567

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([338472; \, 338494]\), числа, имеющие ровно \(4\) различных делителя. В ответе для каждого найденного числа запишите два его наибольших делителя в порядке возрастания.

def find_div(n):
    divisors = set()
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n//i)
        if len(divisors) > 4:
            break
    return divisors

for i in range(338472, 338495):
    d = [*find_div(i)]
    if len(d) == 4:
        d.sort()
        print(d[2], d[3])

ЕГЭ. Поляков-2566

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([251811; \, 251826]\), числа, имеющие ровно \(4\) различных делителя. В ответе для каждого найденного числа запишите два его наибольших делителя в порядке возрастания.

def find_div(n):
    divisors = set()
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n//i)
        if len(divisors) > 4:
            break
    return divisors

for i in range(251811, 251827):
    d = [*find_div(i)]
    if len(d) == 4:
        d.sort()
        print(d[2], d[3])

ЕГЭ. Поляков-2565

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([154026; \, 154043]\), числа, имеющие ровно \(4\) различных делителя. В ответе для каждого найденного числа запишите два его наибольших делителя в порядке возрастания.

def find_div(n):
    divisors = set()
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n//i)
        if len(divisors) > 4:
            break
    return divisors

for i in range(154026, 154044):
    d = [*find_div(i)]
    if len(d) == 4:
        d.sort()
        print(d[2], d[3])

ЕГЭ. Поляков-2564

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \([194455; 194500]\), числа, имеющие ровно 4 различных делителя. В ответе для каждого найденного числа запишите два его наибольших делителя в порядке возрастания.

def find_div(n):
    divisors = set()
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n//i)
        if len(divisors) > 4:
            break
    return divisors

for i in range(194455, 194501):
    d = [*find_div(i)]
    if len(d) == 4:
        d.sort()
        print(d[2], d[3])

ЕГЭ. Поляков-2563

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку \( [3532000; \, 3532160]\), простые числа. Выведите все найденные простые числа в порядке возрастания, слева от каждого числа выведите его номер по порядку.

def is_prime(n):
    if n == 1:
        return False
    elif n in (2, 3):
        return True
    else:
        for i in range(2, int(n**0.5) + 1):
            if not n % i:
                return False
        return True

k = 1
for i in range(3532000, 3532161):
    if is_prime(i):
        print(k, i)
        k += 1

ЕГЭ 2024. Пересдача. 04.07.2024

Напишите программу, которая перебирает целые числа, больше \(700~000\), в порядке возрастания и ищет среди них такие, у которых есть натуральный делитель, оканчивающийся на цифру \(7\) и не равный ни самому числу, ни числу \(7\). Выведите первые пять найденных чисел и для каждого — соответствующий наименьший делитель, оканчивающийся на цифру \(7\), не равный ни самому числу, ни числу \(7\).

Формат вывода: для каждого из пяти таких найденных чисел в отдельной строке сначала выводится само число, затем — значение наименьшего делителя, оканчивающегося на цифру \(7\), не равного ни самому числу, ни числу \(7\).
Строки выводятся в порядке возрастания найденных чисел.

Количество строк в таблице для ответа избыточно.

def divisors(n):
    d = []
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            d.append(i)
            d.append(n // i)

    return sorted(d)

k = 0
n = 700_000

while k < 5:
    n += 1
    for d in divisors(n):
        if d % 10 == 7 and d != 7:
            k += 1
            print(n, d)
            break

ЕГЭ 2024. Резерв. 18.06.2024

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

— символ «?» означает ровно одну произвольную цифру;
— символ «*» означает любую последовательность цифр произвольной длины, в том числе «*» может задавать и пустую последовательность.

Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{10}\), найдите все числа, соответствующие маске \(89*4?5?7?\), делящиеся на \(8993\) без остатка. В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце — соответствующие результаты деления этих чисел на \(8993\).

Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

n = 89405070 - 89405070 % 8993 + 8993

for x in range(n, 10**10, 8993):
    if fnmatch(str(x), '89*4?5?7?'):
        print(x, x // 8993)

ЕГЭ 2024. Основная волна. 07.06.2024

Пусть \(M\) — сумма минимального и максимального натуральных делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то значение \(M\) считается равным нулю.

Напишите программу, которая перебирает целые числа, большие \(800~000\), в порядке возрастания и ищет среди них такие, для которых значение \(M\) оканчивается на \(4\). В ответе запишите в первом столбце таблицы первые пять найденных чисел в порядке возрастания, а во втором столбце — соответствующие им значения \(M\).

Например, для числа \(20\) \(M = 2 + 10 = 12\).

Количество строк в таблице для ответа избыточно.

def divisors_sum(n):
    d1 = d2 = 0
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            d1 = x
            tmp = n // x
            if tmp != d1:
                d2 = tmp
            break
    return d1 + d2

i = 0
N = 800_000

while i < 5:
    N += 1
    M = divisors_sum(N)
    if M % 10 == 4:
        print(N, M)
        i += 1

ЕГЭ 2024. Лещинер-1

Назовём маской числа последовательность цифр, в которой также могут встречаться следующие символы:
– символ «?» означает ровно одну произвольную цифру;
– символ «*» означает любую последовательность цифр произвольной длины; в том числе «*» может задавать и пустую последовательность.
Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{8}\), найдите все числа, соответствующие маске \(2*1?5?1\), делящиеся на \(1921\) без остатка.
В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце – соответствующие им результаты деления этих чисел на 1921.
Количество строк в таблице для ответа избыточно.

from fnmatch import fnmatch

for num in range(210501, 10**8 + 1):
    if fnmatch(str(num), '2*1?5?1') and num % 1921 == 0:
        print(num, num // 1921)

Демо 2024

Назовём маской числа последовательность цифр, в которой также могут встречаться следующие символы:
– символ «?» означает ровно одну произвольную цифру;
– символ «*» означает любую последовательность цифр произвольной длины; в том числе «*» может задавать и пустую последовательность.
Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{10}\), найдите все числа, соответствующие маске \(1?2157*4\), делящиеся на \(2024\) без остатка.
В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце – соответствующие им результаты деления этих чисел на 2023.
Количество строк в таблице для ответа избыточно.

subs = [''] + [f'00{x}' for x in range(10)] + [f'0{x}' for x in range(100)] + [x for x in range(1000)]

nums = []

for s in subs:
    for d in range(10):
        n = int(f'1{d}2157{s}4')
        if n % 2024 == 0:
            nums.append((n, n // 2024))

nums.sort(key=lambda i: i[0])
print(*nums, sep='\n')

Апробация 10.03.2023

Назовём маской числа последовательность цифр, в которой также могут встречаться следующие символы:
– символ «?» означает ровно одну произвольную цифру;
– символ «*» означает любую последовательность цифр произвольной длины; в том числе «*» может задавать и пустую последовательность.

Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{9}\), найдите все числа, соответствующие маске \(2*5443?1\), делящиеся на \(23\) без остатка. В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце – соответствующие им результаты деления этих чисел на \(23\). Количество строк в таблице для ответа избыточно.

for n in range(2):
    for k in range(10**n):
        for j in range(10):
            z = 2 * 10**(6+n) + k * 10**6 + 5443 * 100 + j * 10 + 1
            if z % 23 == 0:
                print(z, z//23)

Статград 2023-2-2

Маска числа — это последовательность цифр, в которой могут встречаться специальные символы «?» и «*». Символ «?» означает ровно одну произвольную цифру, символ «*» означает произвольную (в том числе пустую) последовательность цифр.
Пример. Маске \(123*4?5\) соответствуют числа \(123405\) и \(12376415\).
Найдите все натуральные числа, не превышающие \(10^{9}\), которые соответствуют маске \(12*93?1?\) и при этом без остатка делятся на \(3127\).
В ответе запишите все найденные числа в порядке возрастания.

for n in range(3):
    for k in range(10**n):
        for x in range(10):
            for y in range(10):
                z = 12 * 10**(5+n) + k * 10**5 + 93 * 10**3 + x * 100 + 10 + y
                if z % 3127 == 0:
                    print(z)

Статград 2023-2-1

Маска числа — это последовательность цифр, в которой могут встречаться специальные символы «?» и «*». Символ «?» означает ровно одну произвольную цифру, символ «*» означает произвольную (в том числе пустую) последовательность цифр.
Пример. Маске \(123*4?5\) соответствуют числа \(123405\) и \(12376415\).
Найдите все натуральные числа, не превышающие \(10^{9}\), которые соответствуют маске \(12*63?5?\) и при этом без остатка делятся на \(3123\).
В ответе запишите все найденные числа в порядке возрастания.

for n in range(3):
    for k in range(10**n):
        for x in range(10):
            for y in range(10):
                z = 12 * 10**(5+n) + k * 10**5 + 63 * 10**3 + x * 100 + 50 + y
                if z % 3123 == 0:
                    print(z)

Статград 2023-1-2

Маска числа — это последовательность цифр, в которой могут встречаться специальные символы «?» и «*». Символ «?» означает ровно одну произвольную цифру, символ «*» означает произвольную (в том числе пустую) последовательность цифр.
Пример. Маске \(123*4?5\) соответствуют числа \(123405\) и \(12376415\).
Найдите все натуральные числа, не превышающие \(10^{10}\), которые соответствуют маске \(1?954*21\) и при этом без остатка делятся на \(3023\).
В ответе запишите все найденные числа в порядке возрастания.

for n in range(4):
    for k in range(10):
        for i in range(10**n):
            x = 10**(6 + n) + k * 10**(5 + n) + 954 * 10**(2 + n) + i * 10**2 + 21
            if x % 3023 == 0:
                print(x)

Статград 2023-1-1

Маска числа — это последовательность цифр, в которой могут встречаться специальные символы «?» и «*». Символ «?» означает ровно одну произвольную цифру, символ «*» означает произвольную (в том числе пустую) последовательность цифр.
Пример. Маске \(123*4?5\) соответствуют числа \(123405\) и \(12376415\).
Найдите все натуральные числа, не превышающие \(10^{10}\), которые соответствуют маске \(1?493*41\) и при этом без остатка делятся на \(2023\).
В ответе запишите все найденные числа в порядке возрастания.

for n in range(4):
    for i in range(10**n):
        for k in range(10):
            x = 10**(6 + n) + k * 10**(5 + n) + 493 * 10**(2 + n) + i * 10**2 + 41
            if x % 2023 == 0:
                print(x)

2023-20

Пусть \(S\) — сумма различных натуральных делителей целого числа, являющихся простыми числами, не считая самого числа.
Напишите программу, которая перебирает целые числа, большие \(550~000\), в порядке возрастания и ищет среди них такие, для которых значение \(S\) оканчивается на цифру \(7\). Программа должна найти и вывести первые \(5\) таких чисел и соответствующие им значения \(S\).
Формат вывода: для каждого из \(5\) таких найденных чисел в отдельной строке сначала выводится само число, затем значение \(S\). Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(20\) \(S = 2 + 5 = 7\).

def divisors(n: int) -> set[int]:
    s = set()
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            s.add(x)
            s.add(n//x)
    return s

def is_prime(n: int) -> bool:
    if n == 1:
        return False
    if n in (2, 3):
        return True
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True

def prime_divisors(n: int) -> set[int]:
    div = divisors(n)
    if div:
        return set(filter(is_prime, div))

n = 550001
k = 0

while k < 5:
    if pd := prime_divisors(n):
        S = sum(pd)
        if S % 10 == 7:
            print(n, S)
            k += 1
    n += 1

2023-19

Пусть \(S\) — сумма различных натуральных делителей целого числа, являющихся простыми числами, не считая самого числа.
Напишите программу, которая перебирает целые числа, большие \(550~000\), в порядке возрастания и ищет среди них такие, для которых значение \(S\) оканчивается на цифру \(1\). Программа должна найти и вывести первые \(5\) таких чисел и соответствующие им значения \(S\).
Формат вывода: для каждого из \(5\) таких найденных чисел в отдельной строке сначала выводится само число, затем значение \(S\). Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(20\) \(S = 2 + 5 = 7\).

def divisors(n: int) -> set[int]:
    s = set()
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            s.add(x)
            s.add(n//x)
    return s

def is_prime(n: int) -> bool:
    if n == 1:
        return False
    if n in (2, 3):
        return True
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True

def prime_divisors(n: int) -> set[int]:
    div = divisors(n)
    if div:
        return set(filter(is_prime, div))

n = 550001
k = 0

while k < 5:
    if pd := prime_divisors(n):
        S = sum(pd)
        if S % 10 == 1:
            print(n, S)
            k += 1
    n += 1

2023-18

Напишите программу, которая перебирает целые числа, большие \(750~000\), в порядке возрастания и ищет среди них такие, для которых наибольший натуральный делитель, не равный самому числу, не является простым числом. Программа должна найти и вывести первые \(6\) таких чисел и соответствующие им значения упомянутых делителей.
Формат вывода: для каждого из \(6\) таких натуральных чисел в отдельной строке сначала выводится само число, затем упомянутый делитель. Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(105\) наибольший натуральный делитель \(35\) не является простым, для числа \(15\) наибольший натуральный делитель \(5\) — простое число, а для числа \(13\) такого делителя не существует.

def is_prime(n: int) -> bool:
    if n == 1:
        return False
    if n in (2, 3):
        return True
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True


def min_divisor(n: int) -> int:
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return x
    return 1


def max_divisor(n: int) -> int:
    return n // min_divisor(n)


n = 750001
k = 0

while k < 6:
    md = max_divisor(n)
    if md < n and not is_prime(md):
        print(n, md)
        k += 1
    n += 1

2023-17

Напишите программу, которая перебирает целые числа, большие \(650~000\), в порядке возрастания и ищет среди них такие, для которых наибольший натуральный делитель, не равный самому числу, не является простым числом. Программа должна найти и вывести первые \(6\) таких чисел и соответствующие им значения упомянутых делителей.
Формат вывода: для каждого из \(6\) таких натуральных чисел в отдельной строке сначала выводится само число, затем упомянутый делитель. Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(105\) наибольший натуральный делитель \(35\) не является простым, для числа \(15\) наибольший натуральный делитель \(5\) — простое число, а для числа \(13\) такого делителя не существует.

def is_prime(n: int) -> bool:
    if n == 1:
        return False
    if n in (2, 3):
        return True
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True


def min_divisor(n: int) -> int:
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return x
    return 1


def max_divisor(n: int) -> int:
    return n // min_divisor(n)


n = 650001
k = 0

while k < 6:
    md = max_divisor(n)
    if md < n and not is_prime(md):
        print(n, md)
        k += 1
    n += 1

2023-16

Напишите программу, которая перебирает целые числа, большие \(350~000\), в порядке возрастания и ищет среди них такие, для которых наибольший натуральный делитель, не равный самому числу, не является простым числом. Программа должна найти и вывести первые \(6\) таких чисел и соответствующие им значения упомянутых делителей.
Формат вывода: для каждого из \(6\) таких натуральных чисел в отдельной строке сначала выводится само число, затем упомянутый делитель. Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(105\) наибольший натуральный делитель \(35\) не является простым, для числа \(15\) наибольший натуральный делитель \(5\) — простое число, а для числа \(13\) такого делителя не существует.

def is_prime(n: int) -> bool:
    if n == 1:
        return False
    if n in (2, 3):
        return True
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True


def min_divisor(n: int) -> int:
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return x
    return 1


def max_divisor(n: int) -> int:
    return n // min_divisor(n)


n = 350001
k = 0

while k < 6:
    md = max_divisor(n)
    if md < n and not is_prime(md):
        print(n, md)
        k += 1
    n += 1

2023-15

Напишите программу, которая перебирает целые числа, большие \(450~000\), в порядке возрастания и ищет среди них такие, для которых наибольший натуральный делитель, не равный самому числу, не является простым числом. Программа должна найти и вывести первые \(6\) таких чисел и соответствующие им значения упомянутых делителей.
Формат вывода: для каждого из \(6\) таких натуральных чисел в отдельной строке сначала выводится само число, затем упомянутый делитель. Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(105\) наибольший натуральный делитель \(35\) не является простым, для числа \(15\) наибольший натуральный делитель \(5\) — простое число, а для числа \(13\) такого делителя не существует.

def is_prime(n: int) -> bool:
    if n == 1:
        return False
    if n in (2, 3):
        return True
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True


def min_divisor(n: int) -> int:
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return x
    return 1


def max_divisor(n: int) -> int:
    return n // min_divisor(n)


n = 450001
k = 0

while k < 6:
    md = max_divisor(n)
    if md < n and not is_prime(md):
        print(n, md)
        k += 1
    n += 1

2023-14

Напишите программу, которая перебирает целые числа, большие \(550~000\), в порядке возрастания и ищет среди них такие, для которых наибольший натуральный делитель, не равный самому числу, не является простым числом. Программа должна найти и вывести первые \(6\) таких чисел и соответствующие им значения упомянутых делителей.
Формат вывода: для каждого из \(6\) таких натуральных чисел в отдельной строке сначала выводится само число, затем упомянутый делитель. Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(105\) наибольший натуральный делитель \(35\) не является простым, для числа \(15\) наибольший натуральный делитель \(5\) — простое число, а для числа \(13\) такого делителя не существует.

def is_prime(n: int) -> bool:
    if n == 1:
        return False
    if n in (2, 3):
        return True
    for x in range(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True


def min_divisor(n: int) -> int:
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return x
    return 1


def max_divisor(n: int) -> int:
    return n // min_divisor(n)


n = 550001
k = 0

while k < 6:
    md = max_divisor(n)
    if md < n and not is_prime(md):
        print(n, md)
        k += 1
    n += 1

2023-13

Пусть \(F\) — разность максимального и минимального делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(F\) равным нулю.
Напишите программу, которая перебирает целые числа, большие \(850~000\), в порядке возрастания и ищет среди них такие, для которых значение \(F\) не равно нулю и делится нацело на \(13\). Программа должна найти и вывести первые \(6\) таких чисел и соответствующие им значения \(F\).
Формат вывода: для каждого из \(6\) таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(F\).
Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(105\) \(F = 35-3=32\).

def min_divisor(n):
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return x
    return 1

k = 0
n = 850001

while k < 6:
    md = min_divisor(n)
    if md > 1:
        F = n // md - md
        if F and F % 13 == 0:
            print(n, F)
            k += 1
    n += 1

2023-12

Пусть \(F\) — разность максимального и минимального делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(F\) равным нулю.
Напишите программу, которая перебирает целые числа, большие \(850~000\), в порядке возрастания и ищет среди них такие, для которых значение \(F\) не равно нулю и делится нацело на \(11\). Программа должна найти и вывести первые \(6\) таких чисел и соответствующие им значения \(F\).
Формат вывода: для каждого из \(6\) таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(F\).
Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(105\) \(F = 35-3=32\).

def min_divisor(n):
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return x
    return 1

k = 0
n = 850001

while k < 6:
    md = min_divisor(n)
    if md > 1:
        F = n // md - md
        if F and F % 11 == 0:
            print(n, F)
            k += 1
    n += 1

2023-11

Пусть \(F\) — разность максимального и минимального делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(F\) равным нулю.
Напишите программу, которая перебирает целые числа, большие \(850~000\), в порядке возрастания и ищет среди них такие, для которых значение \(F\) не равно нулю и делится нацело на \(3\). Программа должна найти и вывести первые \(6\) таких чисел и соответствующие им значения \(F\).
Формат вывода: для каждого из \(6\) таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(F\).
Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(105\) \(F = 35-3=32\).

def min_divisor(n):
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return x
    return 1

k = 0
n = 850001

while k < 6:
    md = min_divisor(n)
    if md > 1:
        F = n // md - md
        if F and F % 3 == 0:
            print(n, F)
            k += 1
    n += 1

2023-10

Пусть \(F\) — разность максимального и минимального делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(F\) равным нулю.
Напишите программу, которая перебирает целые числа, большие \(850~000\), в порядке возрастания и ищет среди них такие, для которых значение \(F\) не равно нулю и делится нацело на \(5\). Программа должна найти и вывести первые \(6\) таких чисел и соответствующие им значения \(F\).
Формат вывода: для каждого из \(6\) таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(F\).
Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(105\) \(F = 35-3=32\).

def min_divisor(n):
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return x
    return 1

k = 0
n = 850001

while k < 6:
    md = min_divisor(n)
    if md > 1:
        F = n // md - md
        if F and F % 5 == 0:
            print(n, F)
            k += 1
    n += 1

2023-9

Пусть \(F\) — разность максимального и минимального делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(F\) равным нулю.
Напишите программу, которая перебирает целые числа, большие \(850~000\), в порядке возрастания и ищет среди них такие, для которых значение \(F\) не равно нулю и делится нацело на \(7\). Программа должна найти и вывести первые \(6\) таких чисел и соответствующие им значения \(F\).
Формат вывода: для каждого из \(6\) таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(F\).
Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(105\) \(F = 35-3=32\).

def min_divisor(n):
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return x
    return 1

k = 0
n = 850001

while k < 6:
    md = min_divisor(n)
    if md > 1:
        F = n // md - md
        if F and F % 7 == 0:
            print(n, F)
            k += 1
    n += 1

2023-8

Пусть \(M\) — разность максимального и минимального делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(M\) равным нулю.
Напишите программу, которая перебирает целые числа, меньшие \(800~000\), в порядке убывания и ищет среди них такие, для которых значение \(M\) кратно \(23\) (нуль числу \(23\) не кратен). Вывести первые пять найденных чисел и соответствующие им значения \(M\).
Формат вывода: для каждого из пяти таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(M\).
Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(20\) \(M = 10-2=8\).

def min_divisor(n):
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return x
    return 1

k = 0
n = 799999

while k < 5:
    md = min_divisor(n)
    if md > 1:
        M = n // md - md
        if M and M % 23 == 0:
            print(n, M)
            k += 1
    n -= 1

2023-7

Пусть \(M\) — разность максимального и минимального делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(M\) равным нулю.
Напишите программу, которая перебирает целые числа, меньшие \(800~000\), в порядке убывания и ищет среди них такие, для которых значение \(M\) кратно \(17\) (нуль числу \(17\) не кратен). Вывести первые пять найденных чисел и соответствующие им значения \(M\).
Формат вывода: для каждого из пяти таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(M\).
Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(20\) \(M = 10-2=8\).

def min_divisor(n):
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return x
    return 1

k = 0
n = 799999

while k < 5:
    md = min_divisor(n)
    if md > 1:
        M = n // md - md
        if M and M % 17 == 0:
            print(n, M)
            k += 1
    n -= 1

2023-6

Пусть \(M\) — разность максимального и минимального делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(M\) равным нулю.
Напишите программу, которая перебирает целые числа, большие \(860~000\), в порядке возрастания и ищет среди них такие, для которых значение \(M\) оканчивается на \(30\). Вывести первые пять найденных чисел и соответствующие им значения \(M\).
Формат вывода: для каждого из пяти таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(M\).
Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(20\) \(M = 10-2=8\).

def min_divisor(n):
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return x
    return 1

k = 0
n = 860001

while k < 5:
    md = min_divisor(n)
    if md > 1:
        M = n // md - md
        if M % 100 == 30:
            print(n, M)
            k += 1
    n += 1

2023-5

Пусть \(M\) — разность максимального и минимального делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(M\) равным нулю.
Напишите программу, которая перебирает целые числа, большие \(860~000\), в порядке возрастания и ищет среди них такие, для которых значение \(M\) оканчивается на \(18\). Вывести первые пять найденных чисел и соответствующие им значения \(M\).
Формат вывода: для каждого из пяти таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(M\).
Строки выводятся в порядке возрастания найденных чисел.
Например, для числа \(20\) \(M = 10-2=8\).

def min_divisor(n):
    for x in range(2, int(n**0.5) + 1):
        if n % x == 0:
            return x
    return 1

k = 0
n = 860001

while k < 5:
    md = min_divisor(n)
    if md > 1:
        M = n // md - md
        if M % 100 == 18:
            print(n, M)
            k += 1
    n += 1

Демо-2023

Назовём маской числа последовательность цифр, в которой также могут встречаться следующие символы:
– символ «?» означает ровно одну произвольную цифру;
– символ «*» означает любую последовательность цифр произвольной длины; в том числе «*» может задавать и пустую последовательность. Например, маске \(123*4?5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^{10}\), найдите все числа, соответствующие маске \(1?2139*4\), делящиеся на \(2023\) без остатка. В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце – соответствующие им результаты деления этих чисел на 2023. Количество строк в таблице для ответа избыточно.

for p in range(4):
    for b in range(10):
        for n in range(10**p):
            t = 10**(p+6) + b*10**(p+5) + 2139*10**(p+1) + n * 10 + 4
            if not t % 2023:
                print(t, t // 2023)

ЕГЭ-2022. 1 вариант

Назовём маской числа последовательность цифр, в которой также могут встречаться следующие символы:
– символ «?» означает ровно одну произвольную цифру;
– символ «*» означает любую последовательность цифр произвольной длины;
в том числе «*» может задавать и пустую последовательность. Например, маске \(123*4\,?\,5\) соответствуют числа \(123405\) и \(12300405\).

Среди натуральных чисел, не превышающих \(10^8\), найдите все числа, соответствующие маске \(1234*7\), делящиеся на \(141\) без остатка. В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце – соответствующие им результаты деления этих чисел на \(141\).

Количество строк в таблице для ответа избыточно.

for i in range(4):
    for k in range(10**i):
        n = 1234 * 10**(i+1) + k * 10 + 7
        if n % 141 == 0:
            print(n, n // 141)

Досрочный экзамен 2022

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

Среди натуральных чисел, не превышающих \(10^9\), найдите все числа, соответствующие маске \(12345?6?8\) и делящиеся на \(17\) без остатка. В ответе запишите в первом столбце таблицы все найденные числа в порядке возрастания, а во втором столбце — соответствующие им частные от деления на \(17\).

for i in range(10):
    for k in range(10):
        d = int(f'12345{i}6{k}8')
        if d % 17 == 0:
            print(d, d // 17)

2022-20

Пусть \(S\) — сумма различных натуральных делителей целого числа, являющихся простыми числами, не считая самого числа.
Напишите программу, которая перебирает целые числа, большие \( 650~000\), в порядке возрастания и ищет среди них такие, для которых значение \(S\) не равно нулю и делится нацело на \(11\). Программа должна найти и вывести первые \(5\) таких чисел и соответствующие им значения \(S\) .
Формат вывода: для каждого из \(5\) таких найденных чисел в отдельной строке сначала выводится само число, затем значение \(S\). Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(20\) \(S=2+5=7\).

def is_prime(n):
    if n == 1:
        return False
    if n == 2 or n == 3:
        return True
    if n > 3:
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                return False
        return True

def S(n):
    divisors = set()
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            if is_prime(i):
                divisors.add(i)
            if is_prime(n//i):
                divisors.add(n//i)
    return sum(divisors) if divisors else 0

c = 0
n = 650001

while c < 5:
    s = S(n)
    if s and s % 11 == 0:
        print(n, s)
        c += 1
    n += 1

2022-19

Пусть \(S\) — сумма различных натуральных делителей целого числа, являющихся простыми числами, не считая самого числа.
Напишите программу, которая перебирает целые числа, большие \( 650~000\), в порядке возрастания и ищет среди них такие, для которых значение \(S\) оканчивается на цифру \(5\). Программа должна найти и вывести первые \(5\) таких чисел и соответствующие им значения \(S\) .
Формат вывода: для каждого из \(5\) таких найденных чисел в отдельной строке сначала выводится само число, затем значение \(S\). Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(20\) \(S=2+5=7\).

def is_prime(n):
    if n == 1:
        return False
    if n == 2 or n == 3:
        return True
    if n > 3:
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                return False
        return True

def S(n):
    divisors = set()
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            if is_prime(i):
                divisors.add(i)
            if is_prime(n//i):
                divisors.add(n//i)
    return sum(divisors) if divisors else 0

c = 0
n = 650001

while c < 5:
    s = S(n)
    if s % 10 == 5:
        print(n, s)
        c += 1
    n += 1

2022-18

Пусть \(S\) — сумма различных натуральных делителей целого числа, являющихся простыми числами, не считая самого числа.
Напишите программу, которая перебирает целые числа, большие \( 650~000\), в порядке возрастания и ищет среди них такие, для которых значение \(S\) оканчивается на цифру \(4\). Программа должна найти и вывести первые \(5\) таких чисел и соответствующие им значения \(S\) .
Формат вывода: для каждого из \(5\) таких найденных чисел в отдельной строке сначала выводится само число, затем значение \(S\). Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(20\) \(S=2+5=7\).

def is_prime(n):
    if n == 1:
        return False
    if n == 2 or n == 3:
        return True
    if n > 3:
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                return False
        return True

def S(n):
    divisors = set()
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            if is_prime(i):
                divisors.add(i)
            if is_prime(n//i):
                divisors.add(n//i)
    return sum(divisors) if divisors else 0

c = 0
n = 650001

while c < 5:
    s = S(n)
    if s % 10 == 4:
        print(n, s)
        c += 1
    n += 1

2022-17

Пусть \(S\) — сумма различных натуральных делителей целого числа, являющихся простыми числами, не считая самого числа.
Напишите программу, которая перебирает целые числа, большие \( 650~000\), в порядке возрастания и ищет среди них такие, для которых значение \(S\) оканчивается на цифру \(3\). Программа должна найти и вывести первые \(5\) таких чисел и соответствующие им значения \(S\) .
Формат вывода: для каждого из \(5\) таких найденных чисел в отдельной строке сначала выводится само число, затем значение \(S\). Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(20\) \(S=2+5=7\).

def is_prime(n):
    if n == 1:
        return False
    if n == 2 or n == 3:
        return True
    if n > 3:
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                return False
        return True

def S(n):
    divisors = set()
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            if is_prime(i):
                divisors.add(i)
            if is_prime(n//i):
                divisors.add(n//i)
    return sum(divisors) if divisors else 0

c = 0
n = 650001

while c < 5:
    s = S(n)
    if s % 10 == 3:
        print(n, s)
        c += 1
    n += 1

2022-16

Пусть \(S\) — сумма различных натуральных делителей целого числа, являющихся простыми числами, не считая самого числа.
Напишите программу, которая перебирает целые числа, большие \( 550~000\), в порядке возрастания и ищет среди них такие, для которых значение \(S\) оканчивается на цифру \(7\). Программа должна найти и вывести первые \(5\) таких чисел и соответствующие им значения \(S\) .
Формат вывода: для каждого из \(5\) таких найденных чисел в отдельной строке сначала выводится само число, затем значение \(S\). Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(20\) \(S=2+5=7\).

def is_prime(n):
    if n == 1:
        return False
    if n == 2 or n == 3:
        return True
    if n > 3:
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                return False
        return True

def S(n):
    divisors = set()
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            if is_prime(i):
                divisors.add(i)
            if is_prime(n//i):
                divisors.add(n//i)
    return sum(divisors) if divisors else 0

c = 0
n = 550001

while c < 5:
    s = S(n)
    if s % 10 == 7:
        print(n, s)
        c += 1
    n += 1

2022-15

Пусть \(S\) — сумма различных натуральных делителей целого числа, являющихся простыми числами, не считая самого числа.
Напишите программу, которая перебирает целые числа, большие \( 550~000\), в порядке возрастания и ищет среди них такие, для которых значение \(S\) оканчивается на цифру \(1\). Программа должна найти и вывести первые \(5\) таких чисел и соответствующие им значения \(S\) .
Формат вывода: для каждого из \(5\) таких найденных чисел в отдельной строке сначала выводится само число, затем значение \(S\). Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(20\) \(S=2+5=7\).

def is_prime(n):
    if n == 1:
        return False
    if n == 2 or n == 3:
        return True
    if n > 3:
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                return False
        return True

def S(n):
    divisors = set()
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            if is_prime(i):
                divisors.add(i)
            if is_prime(n//i):
                divisors.add(n//i)
    return sum(divisors) if divisors else 0

c = 0
n = 550001

while c < 5:
    s = S(n)
    if s % 10 == 1:
        print(n, s)
        c += 1
    n += 1

2022-14

Напишите программу, которая перебирает целые числа, большие \( 750~000\), в порядке возрастания и ищет среди них такие, для которых наибольший натуральный делитель, не равный самому числу, не является простым числом. Программа должна найти и вывести первые \(6\) таких чисел и соответствующие им значения упомянутых делителей.
Формат вывода: для каждого из \(6\) таких найденных чисел в отдельной строке сначала выводится само число, затем упомянутый делитель. Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(105\) наибольший натуральный делитель \(35\) не является простым, для числа \(15\) наибольший натуральный делитель \(5\) — простое число, а для числа \(13\) такого делителя не существует.

def is_prime(n):
    if n == 1:
        return False
    if n == 2 or n == 3:
        return True
    if n > 3:
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                return False
        return True

def max_d_is_prime(n):
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return is_prime(n//i), n, n // i
    return True, n, n

c = 0
n = 750001
while c < 6:
    t = max_d_is_prime(n)
    if not t[0]:
        print(t[1], t[2])
        c += 1
    n += 1

2022-13

Напишите программу, которая перебирает целые числа, большие \( 650~000\), в порядке возрастания и ищет среди них такие, для которых наибольший натуральный делитель, не равный самому числу, не является простым числом. Программа должна найти и вывести первые \(6\) таких чисел и соответствующие им значения упомянутых делителей.
Формат вывода: для каждого из \(6\) таких найденных чисел в отдельной строке сначала выводится само число, затем упомянутый делитель. Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(105\) наибольший натуральный делитель \(35\) не является простым, для числа \(15\) наибольший натуральный делитель \(5\) — простое число, а для числа \(13\) такого делителя не существует.

def is_prime(n):
    if n == 1:
        return False
    if n == 2 or n == 3:
        return True
    if n > 3:
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                return False
        return True

def max_d_is_prime(n):
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return is_prime(n//i), n, n // i
    return True, n, n

c = 0
n = 650001
while c < 6:
    t = max_d_is_prime(n)
    if not t[0]:
        print(t[1], t[2])
        c += 1
    n += 1

2022-12

Напишите программу, которая перебирает целые числа, большие \( 350~000\), в порядке возрастания и ищет среди них такие, для которых наибольший натуральный делитель, не равный самому числу, не является простым числом. Программа должна найти и вывести первые \(6\) таких чисел и соответствующие им значения упомянутых делителей.
Формат вывода: для каждого из \(6\) таких найденных чисел в отдельной строке сначала выводится само число, затем упомянутый делитель. Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(105\) наибольший натуральный делитель \(35\) не является простым, для числа \(15\) наибольший натуральный делитель \(5\) — простое число, а для числа \(13\) такого делителя не существует.

def is_prime(n):
    if n == 1:
        return False
    if n == 2 or n == 3:
        return True
    if n > 3:
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                return False
        return True

def max_d_is_prime(n):
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return is_prime(n//i), n, n // i
    return True, n, n

c = 0
n = 350001
while c < 6:
    t = max_d_is_prime(n)
    if not t[0]:
        print(t[1], t[2])
        c += 1
    n += 1

2022-11

Напишите программу, которая перебирает целые числа, большие \( 450~000\), в порядке возрастания и ищет среди них такие, для которых наибольший натуральный делитель, не равный самому числу, не является простым числом. Программа должна найти и вывести первые \(6\) таких чисел и соответствующие им значения упомянутых делителей.
Формат вывода: для каждого из \(6\) таких найденных чисел в отдельной строке сначала выводится само число, затем упомянутый делитель. Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(105\) наибольший натуральный делитель \(35\) не является простым, для числа \(15\) наибольший натуральный делитель \(5\) — простое число, а для числа \(13\) такого делителя не существует.

def is_prime(n):
    if n == 1:
        return False
    if n == 2 or n == 3:
        return True
    if n > 3:
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                return False
        return True

def max_d_is_prime(n):
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return is_prime(n//i), n, n // i
    return True, n, n

c = 0
n = 450001
while c < 6:
    t = max_d_is_prime(n)
    if not t[0]:
        print(t[1], t[2])
        c += 1
    n += 1

2022-10

Напишите программу, которая перебирает целые числа, большие \( 550~000\), в порядке возрастания и ищет среди них такие, для которых наибольший натуральный делитель, не равный самому числу, не является простым числом. Программа должна найти и вывести первые \(6\) таких чисел и соответствующие им значения упомянутых делителей.
Формат вывода: для каждого из \(6\) таких найденных чисел в отдельной строке сначала выводится само число, затем упомянутый делитель. Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(105\) наибольший натуральный делитель \(35\) не является простым, для числа \(15\) наибольший натуральный делитель \(5\) — простое число, а для числа \(13\) такого делителя не существует.

def is_prime(n):
    if n == 1:
        return False
    if n == 2 or n == 3:
        return True
    if n > 3:
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                return False
        return True

def max_d_is_prime(n):
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return is_prime(n//i), n, n // i
    return True, n, n

c = 0
n = 550001
while c < 6:
    t = max_d_is_prime(n)
    if not t[0]:
        print(t[1], t[2])
        c += 1
    n += 1

2022-9

Пусть \(F\) — разность максимального и минимального натуральных делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(F\) равным нулю.

Напишите программу, которая перебирает целые числа, большие \( 850~000\), в порядке возрастания и ищет среди них такие, для которых значение \(F\) не равно нулю и делится нацело на \(13\). Программа должна найти и вывести первые \(6\) найденных чисел и соответствующие им значения \(F\).
Формат вывода: для каждого из \(6\) таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(F\).
Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(105\) \(F = 35 - 3 = 32\).

def F(n):
    divisors = set()
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n//i)
    if divisors:
        return max(divisors) - min(divisors)
    else:
        return 0

c = 0
i = 850001
while c < 6:
    m = F(i)
    if m and m % 13 == 0:
        print(i, m)
        c += 1
    i += 1

2022-8

Пусть \(F\) — разность максимального и минимального натуральных делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(F\) равным нулю.

Напишите программу, которая перебирает целые числа, большие \( 850~000\), в порядке возрастания и ищет среди них такие, для которых значение \(F\) не равно нулю и делится нацело на \(11\). Программа должна найти и вывести первые \(6\) найденных чисел и соответствующие им значения \(F\).
Формат вывода: для каждого из \(6\) таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(F\).
Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(105\) \(F = 35 - 3 = 32\).

def F(n):
    divisors = set()
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n//i)
    if divisors:
        return max(divisors) - min(divisors)
    else:
        return 0

c = 0
i = 850001
while c < 6:
    m = F(i)
    if m and m % 11 == 0:
        print(i, m)
        c += 1
    i += 1

2022-7

Пусть \(F\) — разность максимального и минимального натуральных делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(F\) равным нулю.

Напишите программу, которая перебирает целые числа, большие \( 850~000\), в порядке возрастания и ищет среди них такие, для которых значение \(F\) не равно нулю и делится нацело на \(3\). Программа должна найти и вывести первые \(6\) найденных чисел и соответствующие им значения \(F\).
Формат вывода: для каждого из \(6\) таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(F\).
Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(105\) \(F = 35 - 3 = 32\).

def F(n):
    divisors = set()
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n//i)
    if divisors:
        return max(divisors) - min(divisors)
    else:
        return 0

c = 0
i = 850001
while c < 6:
    m = F(i)
    if m and m % 3 == 0:
        print(i, m)
        c += 1
    i += 1

2022-6

Пусть \(F\) — разность максимального и минимального натуральных делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(F\) равным нулю.

Напишите программу, которая перебирает целые числа, большие \( 850~000\), в порядке возрастания и ищет среди них такие, для которых значение \(F\) не равно нулю и делится нацело на \(5\). Программа должна найти и вывести первые \(6\) найденных чисел и соответствующие им значения \(F\).
Формат вывода: для каждого из \(6\) таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(F\).
Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(105\) \(F = 35 - 3 = 32\).

def F(n):
    divisors = set()
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n//i)
    if divisors:
        return max(divisors) - min(divisors)
    else:
        return 0

c = 0
i = 850001
while c < 6:
    m = F(i)
    if m and m % 5 == 0:
        print(i, m)
        c += 1
    i += 1

2022-5

Пусть \(F\) — разность максимального и минимального натуральных делителей целого числа, не считая единицы и самого числа. Если таких делителей у числа нет, то считаем значение \(F\) равным нулю.

Напишите программу, которая перебирает целые числа, большие \( 850~000\), в порядке возрастания и ищет среди них такие, для которых значение \(F\) не равно нулю и делится нацело на \(7\). Программа должна найти и вывести первые \(6\) найденных чисел и соответствующие им значения \(F\).
Формат вывода: для каждого из \(6\) таких найденных чисел в отдельной строке сначала выводится само число, затем — значение \(F\).
Строки выводятся в порядке возрастания найденных чисел.

Например, для числа \(105\) \(F = 35 - 3 = 32\).

def F(n):
    divisors = set()
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n//i)
    if divisors:
        return max(divisors) - min(divisors)
    else:
        return 0

c = 0
i = 850001
while c < 6:
    m = F(i)
    if m and m % 7 == 0:
        print(i, m)
        c += 1
    i += 1

Фоксфорд-1

Рассматривается множество целых чисел, принадлежащих числовому отрезку \( [ 100000; \,\, 200000]\). Найдите максимальное число, которое имеет максимальное количество простых делителей. В ответе запишите через пробел сначала максимальное число, затем количество его простых делителей.

1

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку [300; 350], простые числа, то есть числа, не имеющие натуральных делителей, не считая единицы и самого числа. Запишите эти числа в таблицу на экране с новой строки в порядке возрастания.

def is_prime(n):
    if (n == 2) or (n == 3):
        return True
    i = 2
    while i ** 2 <= n:
        if n % i == 0:
            return False
        i += 1
    return True

for i in range(300, 351):
    if is_prime(i):
        print(i)

package main

import "fmt"

func isPrime(n int) bool  {
	if n == 2 || n == 3 {
		return true
	}
	for i := 2; i * i <= n; i++ {
		if n % i == 0 {
			return false
		}
	}
	return true
}

func main()  {
	for i := 300; i < 351; i++ {
		if isPrime(i) {
			fmt.Println(i)
		}
	}
}

#include <iostream>

using namespace std;

bool is_prime(int n) {
	if (n == 2 || n == 3)
		return true;
	for (int i = 2; i * i <= n; i++)
		if (n % i == 0)
			return false;
	return true;
}

int main() {

    for (int i = 300; i < 351; i++)
    	if(is_prime(i))
    		cout << i << endl;

    return 0;
}

public class z25n1 {

	public static boolean is_prime(int n) {
		if (n == 2 || n == 3)
			return true;
		for (int i = 2; i * i <= n; i++)
			if (n % i == 0)
				return false;
		return true;
	}

	public static void main(String[] args) {
		for (int i = 300; i < 351; i++)
		    if (is_prime(i))
		    	System.out.println(i);
	}
}

Демо 2021

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку [174457; 174505], числа, имеющие ровно два различных натуральных делителя, не считая единицы и самого числа. Для каждого найденного числа запишите эти два делителя в таблицу на экране с новой строки в порядке возрастания произведения этих двух делителей. Делители в строке таблицы также должны следовать в порядке возрастания.

def search_div(n):
    divisors = set()
    for i in range(2, int(n**0.5)+1):
        if not n % i:
            divisors.add(i)
            divisors.add(n//i)
        if len(divisors) > 2:
            break
    return divisors

for i in range(174457, 174506):
    d = [*search_div(i)]
    if len(d) == 2:
        d.sort()
        print(*d)