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

Относительно базовая задача 25 номера, но надо добавить этот разбор на канал для объективности, так как примеры ФИПИшных задач в списке разборов отсутствуют..

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


cnt = 0
for x in range(1_125_000+1, 10**10):
    div = [j for j in divisors(x) if j != x and j % 10 == 7 and j != 7]
    if len(div) > 0:
        print(x, min(div))
        cnt += 1
        if cnt == 5:
            break

Определение функции divisors, которая находит все делители числа x.

Создание пустого списка для хранения делителей числа x.

Цикл от 1 до квадратного корня из x (оптимизация для поиска делителей).

Проверка, является ли j делителем x (если остаток от деления равен 0).

Добавление в список делителей как j, так и x/j (парный делитель).

Возврат отсортированного списка уникальных делителей (set удаляет дубликаты).

Инициализация счетчика найденных чисел.

Цикл по числам от 1_125_001 до 10**10.

Создание списка делителей числа x, которые не равны самому x, оканчиваются на 7 и не равны 7.

Проверка, есть ли подходящие делители в списке.

Вывод числа x и его минимального подходящего делителя.

Увеличение счетчика найденных чисел.

Проверка, найдено ли уже 5 чисел.

Прерывание цикла, если найдено 5 чисел.

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

Аудио с пояснением к коду решения оставлю в комментариях.

R = []
for n, s in enumerate(open('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, сумма цифр которых чётная.

- Добавляем номер строки n в список R, если выполняются условия выше.

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

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

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

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

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) > 0:
        if len(uncopied) == 0:
            maxi = 0
        else:
            maxi = max(uncopied)
        if min(copied) > maxi:
            cnt += 1
print(cnt)

- Создаём переменную-счётчик cnt и инициализируем её нулём.
- Будет хранить количество строк, удовлетворяющих условию.

- Открываем файл '0. files/9.csv' для чтения.
- Циклом for перебираем каждую строку s из файла.

- Разбиваем строку s по запятым с помощью s.split(',').
- Каждый элемент преобразуем в целое число int(x).
- Полученный список чисел сортируем по возрастанию sorted().
- Результат сохраняем в переменную M.

- Создаём список copied с помощью генератора списка.
- Включаем в него элементы x из M, которые встречаются ровно 2 раза (M.count(x) == 2).
- Это будут числа-дубликаты в текущей строке.

- Аналогично создаём список uncopied.
- Включаем элементы, которые встречаются только 1 раз (M.count(x) == 1).
- Это уникальные числа в текущей строке.

- Проверяем, есть ли в строке дубликаты (длина списка copied больше 0).
- Если нет, то пропускаем дальнейшие проверки для этой строки.

- Проверяем, есть ли в строке уникальные числа.
- Если уникальных чисел нет (uncopied пуст):

- Устанавливаем maxi (максимальное уникальное число) в 0,
- так как сравнивать будем с минимальным дубликатом.

- Если в строке есть уникальные числа:

- Находим максимальное число среди уникальных и сохраняем в maxi.

- Проверяем условие: минимальное число из дубликатов больше maxi.
- Если условие выполняется:

- Увеличиваем счётчик подходящих строк на 1.

- После обработки всех строк выводим итоговое значение счётчика cnt.

import string

print(string.digits)         
# Цифры: 0123456789

print(string.ascii_letters)  
# Все английские буквы: abc...XYZ

print(string.ascii_lowercase)  
# Только строчные: abc...

print(string.ascii_uppercase)  
# Только заглавные: ABC...

print(string.punctuation)    
# Знаки препинания: !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

🔣Нужно фильтровать или валидировать ввод
🔣Писать генераторы случайных паролей
🔣Проверять состав строки без использования регулярных выражений

s = "Hello123!"
letters_only = [ch for ch in s if ch in string.ascii_letters]
print(letters_only)  # ['H', 'e', 'l', 'l', 'o']

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

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

cnt = 0
for s in open('0. files/9.csv'):
    M = [int(x) for x in s.split(';')]
    copied = [x for x in M if M.count(x) == 3]
    uncopied = [x for x in M if M.count(x) == 1]
    if len(copied) == 3 and len(uncopied) == 3:
        if (copied[0] ** 2) * 3 > (sum([x**2 for x in uncopied])):
            cnt += 1
print(cnt)

# Инициализируем счетчик, который будет подсчитывать количество строк с нужными условиями

# Открываем файл и построчно считываем его содержимое в переменную s

# Разделяем строку по символу ';', преобразуем элементы в целые числа и создаем список M

# Создаем список copied из элементов, которые встречаются в M ровно 3 раза (повторяющиеся элементы)

# Создаем список uncopied из элементов, которые встречаются в M ровно 1 раз (уникальные элементы)

# Проверяем, что у нас ровно 3 повторяющихся элемента и 3 уникальных элемента

# Проверяем условие: квадрат первого повторяющегося элемента, умноженный на 3, больше суммы квадратов всех уникальных элементов

# Если оба условия выполняются, увеличиваем счетчик на 1

# Выводим итоговое значение счетчика

На вход алгоритма подаётся натуральное число N. Алгоритм строит по нему новое число R следующим образом.
1. Строится восьмеричная запись числа N.
2. Далее эта запись обрабатывается по следующему правилу:
а) если число N чётное, то в этой записи все нечётные цифры меняются на «2»;
б) если число N нечётное, то первая и последняя цифры меняются на «3».
Полученная таким образом запись является восьмеричной записью искомого числа R.
3. Результат переводится в десятичную систему и выводится на экран.

Например, для исходного числа 9 = 118 результатом является число 338 = 27, а для исходного числа 12 = 148 это число 248 = 20.
Укажите максимальное число R, меньшее 300, которое может быть получено с помощью описанного алгоритма. В ответе запишите это число в десятичной системе счисления.

Аудио с пояснением к коду решения оставлю в комментариях.

R = []
for n in range(1, 1000):
    s = f'{n:o}'
    if n % 2 == 0:
        for x in '1357':
            s = s.replace(x, '2')
    else:
        s = '3' + s[1:-1] + '3'
    r = int(s, 8)
    if r < 300:
        R.append(r)
print(max(R))

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

Цикл перебирает числа от 1 до 999 включительно.

Число n преобразуется в восьмеричную (octal) систему счисления и сохраняется в строку s.

Проверяется, четное ли число n.

Если число четное, то перебираются нечетные цифры 1, 3, 5, 7.

Каждую нечетную цифру в строке s заменяют на 2.

Если число n нечетное, выполняется этот блок.

Для нечетных чисел:
- Первый символ строки s заменяется на '3'.
- Последний символ заменяется на '3'.
- Середина строки (s[1:-1]) остается без изменений.
Пример: s = '1234' → '323' (первая и последняя цифры заменены на 3).

Строка s (в восьмеричной системе) преобразуется обратно в десятичное число.

Если полученное число r меньше 300, оно добавляется в список R.

В конце выводится максимальное число из списка R.

Полина составляет слова, переставляя буквы в слове ПАЙТОН. Сколько слов может составить Полина, если известно, что сумма порядковых номеров гласных букв, в каждом из них, равна 6? Буквы нумеруются слева направо, начиная с единицы.

Аудио с пояснением к коду решения оставлю в комментариях.

from itertools import *
cnt = 0
for p in permutations('ПАЙТОН'):
    word = ''.join(p)
    summa = word.index('А')+1 + word.index('О')+1
    if summa == 6:
        cnt += 1
print(cnt)

Импортируется модуль itertools для работы с перестановками (permutations).

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

Цикл перебирает все возможные перестановки букв в слове 'ПАЙТОН'.

Каждая перестановка p (это кортеж букв) объединяется в строку word.

- word.index('А') возвращает индекс буквы 'А' в строке (начиная с 0).
- +1 добавляется, чтобы считать позицию с 1 (как в обычном порядке).
- Аналогично для буквы 'О'.
- summa — это сумма позиций букв 'А' и 'О' в текущей перестановке.

Проверяется, равна ли сумма позиций 'А' и 'О' 6.

Если условие выполнено (summa == 6), счетчик увеличивается на 1.

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

Исполнитель преобразует число на экране. У исполнителя есть две команды, которые обозначены латинскими буквами:

А. Вычесть 2
В. Если число четное, Разделить на 2, Иначе Вычесть 7

Сколько существует программ, для которых при исходном числе 40 результатом является число 1 и при этом никакая команда не повторяется более двух раз подряд?

Аудио с пояснением к коду решения оставлю в комментариях.

def F(a, b, s):
    if a <= b:
        return a == b and 'AAA' not in s and 'BBB' not in s
    h = [F(a-2, b, s+'A')]
    if a % 2 == 0:
        h += [F(a/2, b, s+'B')]
    else:
        h += [F(a-7, b, s+'B')]
    return sum(h)

print(F(40, 1, ''))

Объявление функции F с тремя параметрами: a (начальное число), b (целевое число), s (строка с последовательностью действий).

Проверка, если текущее число a меньше или равно целевому числу b.

Возвращает True только если a равно b и в строке s нет подстрок 'AAA' и 'BBB', иначе False.

Создает список h с результатом рекурсивного вызова функции, где a уменьшается на 2, а к строке s добавляется 'A'.

Проверяет, четное ли число a.

Если a четное, добавляет в список h результат рекурсивного вызова функции, где a делится на 2, а к строке s добавляется 'B'.

Если a нечетное.

Добавляет в список h результат рекурсивного вызова функции, где a уменьшается на 7, а к строке s добавляется 'B'.

Возвращает сумму элементов списка h (в данном случае True и False интерпретируются как 1 и 0).

Вызов функции с начальными значениями a = 40, b = 1, s = '' и вывод результата.

Два игрока, Петя и Ваня, играют в следующую игру. Перед игроками лежит куча камней. Игроки ходят по очереди, первый ход делает Петя. За один ход игрок может убрать из кучи один камень, либо, если в куче 4 или больше камней, он может убрать четыре камня, либо, если количество камней в куче кратно трем, он может уменьшить количество камней в куче в три раза.

Игра завершается в тот момент, когда количество камней в куче становится не более 1.

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

В начальный момент в куче было S камней; 4 ≤ S ≤ 100.

Будем говорить, что игрок имеет выигрышную стратегию, если он может выиграть при любых ходах противника.

Укажите минимальное значение S, при котором Петя не может выиграть за один ход, но при любом ходе Пети Ваня может выиграть своим первым ходом.

Задание 20.
Для игры, описанной в задании 19, найдите два наименьших значения S, при которых у Пети есть выигрышная стратегия, причём одновременно выполняются два условия:

− Петя не может выиграть за один ход;

− Петя может выиграть своим вторым ходом независимо от того, как будет ходить Ваня.

Найденные значения запишите в ответе в порядке возрастания.


Задание 21.
Для игры, описанной в задании 19, найдите минимальное значение S, при котором одновременно выполняются два условия:

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

– у Вани нет стратегии, которая позволит ему гарантированно выиграть первым ходом.

Аудио с пояснением к коду решения оставлю в комментариях.

def F(s, n):
    if s <= 1:
        return n % 2 == 0
    if n == 0:
        return 0
    h = [F(s - 1, n - 1)]
    if s >= 4:
        h += [F(s - 4, n - 1)]
    if s % 3 == 0:
        h += [F(s / 3, n - 1)]
    return any(h) if (n - 1) % 2 == 0 else all(h)

print([s for s in range(4, 100 + 1) if F(s, 2)])
print([s for s in range(4, 100 + 1) if F(s, 3) and not F(s, 1)])
print([s for s in range(4, 100 + 1) if F(s, 4) and not F(s, 2)])

• Объявление функции F с параметрами s (текущее состояние) и n (количество оставшихся ходов)

• Проверка, если s меньше или равно 1, игра завершена

• Возвращает True, если n чётное (победа текущего игрока), иначе False

• Проверка, если ходы закончились (n = 0), игра проиграна

• Возвращает 0 (ложь), так как нет ходов для победы

• Рекурсивный вызов F для хода s - 1 и уменьшенного n, результат добавляется в список h

• Проверка, можно ли сделать ход s - 4

• Если s >= 4, рекурсивный вызов F для s - 4 и уменьшенного n, результат добавляется в h

• Проверка, делится ли s на 3

• Если s делится на 3, рекурсивный вызов F для s / 3 и уменьшенного n, результат добавляется в h

• Если предыдущий ход был чётным ((n - 1) % 2 == 0), возвращает any(h) (хотя бы один выигрышный ход), иначе all(h) (все ходы должны быть выигрышными)

• Выводит список s от 4 до 100, где игрок может выиграть за 2 хода (F(s, 2) = True)

• Выводит список s от 4 до 100, где игрок может выиграть за 3 хода, но не за 1 (F(s, 3) = True и F(s, 1) = False)

• Выводит список s от 4 до 100, где игрок может выиграть за 4 хода, но не за 2 (F(s, 4) = True и F(s, 2) = False)

Текстовый файл состоит из символов F, G, Q, R, S и W. Определите в прилагаемом файле максимальное количество идущих подряд символов, среди которых подстрока FSRQ встречается ровно 80 раз.

Аудио с пояснением к коду решения оставлю в комментариях.

s = open('0. files/24.txt').readline()
s = s.split('FSRQ')
maxi = 0
for i in range(len(s)-80):
    r = 'SRQ' + 'FSRQ'.join(s[i:i+81]) + 'FSR'
    maxi = max(maxi, len(r))
print(maxi)

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

Разбиваем строку s на список подстрок, используя разделитель 'FSRQ'

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

Запускаем цикл по индексам списка s, оставляя запас в 80 элементов для обработки последующих 81 элементов

Формируем строку r, соединяя 81 подстроку из списка s с разделителем 'FSRQ', добавляя префикс 'SRQ' и суффикс 'FSR'

Обновляем maxi, если длина строки r больше текущего значения maxi

Выводим максимальную найденную длину строки r