Напишите программу, которая перебирает целые числа, бльшие 2 900 000, в порядке возрастания и ищет среди них такие, которые:

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

В ответе укажите первые пять таких чисел в порядке возрастания. Во втором столбце таблицы для каждого числа укажите его наибольший простой делитель.

def divisors(x):
    div = []
    for j in range(2, int(x**0.5)+1):
        if x % j == 0:
            div += [j, x // j]
    return sorted(set(div))

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

cnt = 0
for x in range(2_900_000, 10**10):
    div = divisors(x)
    if len(div) == 2 and Prost(div[0]) and Prost(div[1]):
        if str(div[0]).count('0') == 1 and str(div[1]).count('0') == 1:
            print(x, max(div))
            cnt += 1
            if cnt == 5:
                break

17 заданий - 70 баллов
21 задание - 80 баллов
25 заданий - 90 баллов

while True:
    s = int(input('Сколько первичных баллов ты планируешь набрать? \n'))
    if 1 <= s <= 29:
        tab = [7, 14, 20, 27, 34, 40, 43, 46, 48, 51,
               54, 56, 59, 62, 64, 67, 70, 72, 75, 78,
               80, 83, 85, 88, 90, 93, 95, 98, 100]
        print(f'Ты получишь: {tab[s - 1]} баллов! \n')
    else:
        print('Выход из программы.')
        exit()

Сеть задана IP-адресом 140.116.194.0 и маской сети 255.255.240.0. Сколько в этой сети IP-адресов, в двоичной записи которых каждый из четырёх байтов оканчивается нулём?

from ipaddress import *
net = ip_network('140.116.194.0/255.255.240.0', 0)
cnt = 0
for ip in net:
    b = f'{ip:b}'
    if b[:8][-1] == '0':
        if b[8:16][-1] == '0':
            if b[16:24][-1] == '0':
                if b[24:][-1] == '0':
                    cnt += 1
print(cnt)

• Импортируются все классы и функции из модуля ipaddress, используемого для работы с IP-адресами и сетями.

• Создаётся объект сети net с заданным IP-адресом и маской. Аргумент 0 указывает, что используется маска, а не префикс.

• Инициализируется счётчик для подсчёта подходящих IP-адресов.

• Цикл перебирает все IP-адреса в заданной сети.

• Преобразует IP-адрес в строку его двоичного представления (без точек и пробелов).

• Проверяет, оканчивается ли первый байт (первые 8 бит) на 0.

• Проверяет, оканчивается ли второй байт (биты с 8 по 15) на 0.

• Проверяет, оканчивается ли третий байт (биты с 16 по 23) на 0.

• Проверяет, оканчивается ли четвёртый байт (биты с 24 по 31) на 0.

• Увеличивает счётчик, если все четыре байта оканчиваются нулём.

• Выводит количество IP-адресов, удовлетворяющих условию задачи.

Определите наибольший номер строки таблицы, для чисел которой выполнены оба условия:
– числа в строке расположены в порядке неубывания;
– в строке есть повторяющиеся числа с чётной суммой цифр.

R = []
for n, s in enumerate(open('0. files/9.csv'), 1):
    M = [int(x) for x in s.split(';')]
    if M == sorted(M):
        if any(M.count(x) > 1 and sum(map(int, str(x))) % 2 == 0 for x in M):
            R.append(n)
print(max(R))

Создается пустой список R, в который будут добавляться номера строк, удовлетворяющих условиям

Открывается файл 9.csv, итерируемся по его строкам s с нумерацией n, начиная с 1

Каждая строка s разбивается по разделителю ;, элементы преобразуются в целые числа, формируется список M

Проверяется, равен ли список M своему отсортированному варианту (проверка на неубывающую последовательность)

Проверяется, есть ли в списке M хотя бы одно число x, которое встречается больше одного раза (M.count(x) > 1) и сумма цифр которого четная (sum(map(int, str(x))) % 2 == 0)

Если оба условия выполнены, номер строки n добавляется в список R

Выводится максимальный номер строки из списка R (последняя подходящая строка в файле)

В некоторых системах счисления, для записи оснований которых используются целочисленные переменные p<37 и s<35, выполняется равенство: R4_(p−1)+B0_(s+2)+ T3NK4_p = 23593399_10. Определите произведение подходящих значений p и s и укажите его в ответе в десятичной системе счисления.

for p in range(30, 37):
    for s in range(10, 35):
        A = int(f'R4', p-1)
        B = int(f'B0', s+2)
        C = int(f'T3NK4', p)
        if (A + B + C) == 23593399:
            print(p * s)

• Цикл, перебирающий значения p от 30 до 36 (включительно)

• Вложенный цикл, перебирающий значения s от 10 до 34 (включительно)

• Преобразует строку 'R4' в число, интерпретируя её как число в системе счисления с основанием p-1

• Преобразует строку 'B0' в число, интерпретируя её как число в системе счисления с основанием s+2

• Преобразует строку 'T3NK4' в число, интерпретируя её как число в системе счисления с основанием p

• Проверяет, равна ли сумма чисел A, B и C значению 23593399

• Если условие выполняется, выводит произведение p и s

В файле содержится последовательность натуральных чисел, которые нумеруются, начиная с единицы. Определите количество пар элементов последовательности, сумма номеров которых оканчивается на ту же цифру, что и максимальный элемент последовательности. В ответе запишите количество найденных пар, затем минимальное значение среди модулей разностей суммы элементов и суммы номеров таких пар. В данной задаче под парой подразумевается два идущих подряд элемента последовательности.

M = [int(x) for x in open('0. files/17.txt')]
R = []
for i in range(len(M)-1):
    x, y = M[i], M[i+1]
    i, j = i+1, i+2
    if (i + j) % 10 == max(M) % 10:
        R.append(abs((x+y) - (i+j)))
print(len(R), min(R))

Читаем файл '0. files/17.txt', преобразуем каждую строку в целое число и сохраняем в список M

Создаем пустой список R для хранения результатов

Запускаем цикл по индексам элементов списка M, кроме последнего

Получаем текущий элемент x и следующий элемент y из списка M

Вычисляем индексы i и j для проверки условия (увеличиваем на 1 и 2 соответственно)

Проверяем, равен ли остаток от деления суммы индексов i и j на 10 остатку от деления максимального элемента списка M на 10

Если условие выполняется, добавляем в список R модуль разности между суммой элементов x и y и суммой индексов i и j

Выводим количество элементов в списке R и минимальное значение из этого списка

Текстовый файл состоит из символов, обозначающих буквы латинского алфавита A, В и С и цифры 1 и 8.

Определите в прилагаемом файле максимальную длину подстроки, которая начинается и заканчивается на разные цифры, включает в себя равное количество букв B и C и не содержит других цифр, кроме первой и последней.

Для выполнения этого задания следует написать программу.

s = open('0. files/24.txt').readline()
s = s.replace('1', '1 1').replace('8', '8 8')
maxi = 0
for x in s.split():
    if x.count('1') == 1:
        if x.count('B') == x.count('C'):
            maxi = max(maxi, len(x))
print(maxi)

• Открываем файл '0. files/24.txt' и читаем первую строку, сохраняя её в переменную s

• Заменяем каждый символ '1' на '1 1' и каждый символ '8' на '8 8', удваивая их и добавляя пробелы между ними

• Инициализируем переменную maxi для хранения максимальной длины подходящей строки

• Разбиваем строку s на список подстрок по пробелам и начинаем перебирать каждую подстроку в цикле

• Проверяем, что текущая подстрока x содержит ровно один символ '1'

• Проверяем, что количество символов 'B' равно количеству символов 'C' в текущей подстроке

• Если оба условия выше выполнены, обновляем maxi, сохраняя максимальное значение между текущим maxi и длиной подстроки x

• Выводим максимальную длину подходящей подстроки, найденную в результате работы программы

Определите количество пар элементов последовательности, в которых хотя бы одно число кратно минимальному двузначному значению последовательности, которое кратно сумме своих цифр.

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

M = [int(x) for x in open('0. files/17.txt')]
D = [x for x in M if len(str(abs(x))) == 2 and x % sum(map(int, str(x))) == 0]
R = []
for i in range(len(M) - 1):
    x, y = M[i], M[i + 1]
    if (x % min(D) == 0) + (y % min(D) == 0) >= 1:
        R.append(x + y)
print(len(R), max(R))

Читает файл '0. files/17.txt', преобразует каждую строку в целое число и сохраняет в список M

Создает список D из чисел M, у которых ровно две цифры (учитывая модуль) и которые делятся на сумму своих цифр

Инициализирует пустой список R для хранения сумм подходящих пар

Цикл по индексам списка M (кроме последнего элемента, чтобы не выйти за границы)

Берет текущий элемент x и следующий y из списка M

Проверяет, что хотя бы одно из чисел x или y делится на минимальное число из списка D

Если условие выполняется, добавляет сумму x и y в список R

Выводит количество найденных пар и максимальную сумму из списка R

Откройте файл электронной таблицы, содержащей в каждой строке четыре натуральных чисел. Определите количество строк таблицы, для чисел которых выполнены следующие условия:

– в строке есть только одно число, которое повторяется дважды, остальные два числа различны;

– все неповторяющиеся числа нечетны, повторяющиеся числа чётны.

В ответе запишите только число.

cnt = 0
for s in open('0. files/9.csv'):
    M = sorted([int(x) for x in s.split(',')])
    copied = [x for x in M if M.count(x) == 2]
    uncopied = [x for x in M if M.count(x) == 1]
    if len(copied) == 2 and len(uncopied) == 2:
        if all(x % 2 != 0 for x in uncopied):
            if all(x % 2 == 0 for x in copied):
                cnt += 1
print(cnt)

Инициализация счетчика для подсчета подходящих строк.

Открытие файла и построчное чтение данных. Каждая строка s содержит числа, разделенные запятыми.

Разделение строки по запятым, преобразование в целые числа и сортировка списка.

Создание списка чисел, встречающихся ровно 2 раза (дубликаты).

Создание списка уникальных чисел (встречаются 1 раз).

Проверка, что есть ровно 2 дублирующихся числа (1 пара) и 2 уникальных числа.

Проверка, что все уникальные числа нечетные.

Проверка, что все дублирующиеся числа четные.

Если все условия выполнены, счетчик увеличивается на 1.

Вывод общего количества подходящих строк.

В файле содержится последовательность целых чисел.
Её элементы могут принимать целые значения от -100 000 до 100 000 включительно. Определите количество троек последовательности, сумма цифр элементов которых равна минимальному положительному элементу последовательности, оканчивающемуся на 4. В ответе запишите количество найденных троек, затем максимальную из сумм элементов таких троек. В данной задаче под тройкой подразумевается три идущих подряд элемента последовательности.

R = []
M = [int(x) for x in open('0. files/17.txt')]
W = [x for x in M if abs(x) % 10 == 4 and x > 0]
for i in range(len(M) - 2):
    a, b, c = M[i], M[i + 1], M[i + 2]
    summa = sum([int(x) for x in str(a) + str(b) + str(c) if x.isdigit()])
    if summa == min(W):
        R.append(a + b + c)
print(len(R), max(R))

Создается пустой список R, в который будут записываться подходящие суммы троек чисел.

Открывается файл 17.txt, читаются все числа и сохраняются в список M (каждое число преобразуется в int).

В список W попадают только положительные числа из M, у которых последняя цифра равна 4 (например, 14, 24, -34 не подойдет, т.к. по условию x > 0).

Цикл перебирает индексы списка M до предпоследнего элемента, чтобы можно было взять тройку чисел (a, b, c) = (M[i], M[i+1], M[i+2]).

Текущая тройка чисел из M записывается в переменные a, b и c.

- str(a) + str(b) + str(c) — числа a, b, c преобразуются в строки и объединяются в одну строку (например, 123, -45, 678 → "123-45678").
- [int(x) for x in ... if x.isdigit()] — из этой строки берутся только цифры (минус игнорируется), и они преобразуются обратно в числа.
- sum(...) — вычисляется сумма всех цифр в тройке чисел.

Проверяется, равна ли сумма цифр минимальному числу из W (т.е. минимальному положительному числу, оканчивающемуся на 4).

Если условие выполнено, то сумма самой тройки чисел (a + b + c) добавляется в список R.

В конце выводится:
- количество найденных троек (len(R)),
- максимальная сумма из этих троек (max(R)).