Перед игроками лежит куча камней.
− убрать из кучи два камня,
− уменьшить количество камней в куче в два раза (количество камней, полученное при делении, округляется до меньшего).

Победителем считается игрок, сделавший последний ход, т.е. первым получивший в куче 87 камней или меньше. В начальный момент в куче было S камней; S > 88.

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

❗️Обратите внимание на 8 пункт в решении! Тут функция all() пишется для 20 и 21 номеров, а вот с 19 номером все сложнее. Если мы имеем условие "при любой игре Пети", то ставим all(), если же условие звучит как "после неудачного первого хода Пети", то будем писать функцию any()

from math import ceil, floor
def F(s, n):
    if s <= 87:
        return n % 2 == 0
    if n == 0:
        return 0
    h = [F(s-2, n-1), F(floor(s/2), n-1)]
    return any(h) if (n - 1) % 2 == 0 else all(h)

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

Импортирует функции округления вверх (ceil) и вниз (floor) из модуля math.

Определяет функцию F с двумя параметрами: s (текущее значение камней в куче) и n (количество оставшихся ходов игры).

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

Если достигнуто пороговое значение, то возвращает True, если n четное (победил Ваня), и False, если n нечетное (победил Петя).

Проверяет, не закончились ли ходы.

Если ходы закончились, возвращает 0 (что эквивалентно False), чтобы не зациклить нашу рекурсию.

Создает список возможных ходов: уменьшение s на 2 или деление s на 2 с округлением вниз.

Если следующий ход четный (n-1 четное), возвращает True, если хотя бы один из ходов выигрышный (any).
Если следующий ход нечетный, возвращает True, только если все ходы выигрышные (all).

Выводит список значений s от 89 до 999, для которых F(s, 2) возвращает True (выигрышные позиции при 2 ходе - победа Вани первым ходом).

Выводит список значений s, для которых F(s, 3) истинно, а F(s, 1) ложно (выигрышные позиции при 3 ходе, но не при 1 - победа Пети вторым, но не первым ходом).

Выводит список значений s, для которых F(s, 4) истинно, а F(s, 2) ложно (выигрышные позиции при 4 ходах, но не при 2 - победа Вани вторым или первым, но не только лишь первым ходом).

Текстовый файл состоит из символов, обозначающих десятичные цифры и заглавные буквы латинского алфавита.
Определите в прилагаемом файле максимальное количество идущих подряд символов, которые могут представлять запись чётного числа в двенадцатеричной системе счисления. В этой записи отсутствуют незначащие (ведущие) нули.

Регулярные выражения стали еще одним шагом ФИПИ к усложнению 24 номера, поэтому на канале постараюсь почаще публиковать решения через библиотеку re.

Обратите внимание на строчку номер 8 - настоятельно рекомендую не пропускать этот шаг, чтобы визуально можно было проверить вывод своей программы!

from re import *

s = open('0. files/24.txt').readline()
num = r'([1-B][0-B]*[02468A]|[0-B])'
M = [x.group() for x in finditer(num, s)]
maxi = 0
for x in M:
    maxi = max(maxi, len(x))
    print(x)
print(maxi)

Импортирует все функции из модуля регулярных выражений re.

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

Создаёт шаблон регулярного выражения, который ищет либо последовательность, начинающуюся с символа от 1 до B, содержащую любое количество символов от 0 до B и заканчивающуюся чётным символом (0,2,4,6,8,A), либо одиночный символ от 0 до B.

Находит все совпадения с шаблоном num в строке s и создаёт список M из найденных совпадений, используя генератор списка и метод group().

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

Начинает цикл, который перебирает все найденные последовательности в списке M.

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

Выводит текущую последовательность x на экран.

После завершения цикла выводит максимальную длину найденной последовательности.

Напишите программу, которая перебирает целые числа, бóльшие 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']