Ошибка Кода

# permutations составит все возможные варианты перестановок
from itertools import permutations

# перепишем логическую функцию на язык python
def f(a, b, c):
    return c and (not b) or c and a

# переписываем таблицу
data = [
    [0, 1, 0],
    [0, 1, 1],
    [1, 1, 1],
]
# перебираем варианты позиций переменных
# например, a, b, c = 0, 1, 2 означает, что 
# a - первый столбец, b - второй, c - третий
for a, b, c in permutations([0, 1, 2]):
    # если для всех строк функция равна единице,
    # то такое расположение подходит
    ok = True
    for line in data:
        if f(line[a], line[b], line[c]) != 1:
            ok = False
    if ok:
        # чтобы вывести ответ, подставим буквы на свои места
        answer = ['', '', '']
        answer[a] = 'a'
        answer[b] = 'b'
        answer[c] = 'c'
        print(answer[0] + answer[1] + answer[2])
# ответ: bca

# Перебор всех чисел от 1 до 100
for N in range(1, 100):
    # Преобразование числа N в двоичную строку
    r = bin(N)[2:]
    # Проверка четности количества единиц в двоичной записи
    if r.count("1") % 2 == 0:
        # Добавление '11' в начало строки
        r = "11" + r
    else:
        # Добавление '00' в конец строки
        r = r + "00"
    # Преобразование обратно в десятичное число
    r = int(r, 2)
    # Проверка условия R > 116
    if r > 116:
        print(N)
        break

from itertools import product

n = 0  # Счетчик позиции
# Перебор всех возможных комбинаций слов из заданных букв
for i in product("ДЕКНСЯ", repeat=6):
    s = ''.join(i)  # Преобразование кортежа в строку
    n += 1  # Увеличение счетчика позиции
    # Проверка, совпадает ли текущая комбинация с искомым словом
    if s == "ЯНДЕКС":
        print(n)
        break  # Прекращение цикла, если слово найдено

from itertools import product

# Генерация всех возможных комбинаций слов из заданных букв
all_products = list(product('ДЕКНСЯ', repeat=6))

# Поиск позиции слова "ЯНДЕКС" в сгенерированном списке
print(all_products.index(tuple("ЯНДЕКС")) + 1)

# Счетчик для строк, соответствующих условиям
count = 0

# Открываем файл для чтения
with open("9.txt", "r") as file:
    # Проходим по каждой строке в файле
    for row in file:
        # Разделяем строку по символу ';'
        numbers = row.strip().split()

        # Преобразуем строки в числа
        for i in range(3):
            numbers[i] = int(numbers[i])

        # Проверяем условия
        if len(set(numbers)) == 3 and sum(numbers) % 3 == 0:
            count += 1

# Выводим результат
print(count)

# Исходная строка, состоящая из 200 идущих подряд цифр 7
s = "7" * 200

# Выполняем цикл, пока в строке находятся подстроки "7777" или "33333"
while "7777" in s or "33333" in s:
    # Если находится подстрока "33333", заменяем её на "777"
    if "33333" in s:
        s = s.replace("33333", "777", 1)
    # В противном случае заменяем подстроку "7777" на "33"
    else:
        s = s.replace("777", "33", 1)

# Подсчитываем количество цифр 7 в получившейся строке
print(s.count("3"))

from ipaddress import ip_network

count = 0  # Инициализация счетчика устройств
# Создание объекта сети с помощью функции ip_network
net = ip_network('192.168.1.0/255.255.255.0', strict=False)
# Перебор всех возможных IP-адресов в этой сети
for ip in net:
    count += 1
# Вычисление количества оставшихся свободных IP-адресов
print(count - 2 - 50 - 1)

x = 149597870  # Исходное число (расстояние от Земли до Солнца)
n = ''  # Строка для хранения 5-ричной записи числа
# Цикл для перевода числа в 5-ричную систему счисления
while x > 0:
    n = str(x % 5) + n  # Добавление остатка от деления на 5 к строке n
    x = x // 5  # Целочисленное деление на 5
# Подсчет количества нулей в 5-ричной записи
print(n.count('0'))

def f(x):
    # Проверка, что выражение истинно для данного x и A
    return ((x % 30 == 0) and (x % 45 != 0)) <= (x % a != 0)

# Поиск минимального A, для которого выражение истинно для всех x
for a in range(1, 100):
    a_is_ok = True
    for x in range(1, 1000):
        # если хоть в одной точке функция ложна,
        # то такое a нам не подходит
        if f(x) == 0:
            a_is_ok = False
            break
    if a_is_ok == True:
        print(a)
        break

numbers = [1, 2, 3, 4, 5]
result = all(x > 0 for x in numbers)

def f(x):
    # Проверка, что выражение истинно для данного x и A
    return ((x % 30 == 0) and (x % 45 != 0)) <= (x % a != 0)

# Поиск минимального A, для которого выражение истинно для всех x
for a in range(1, 100):
    if all(f(x) == 1 for x in range(1, 10000)):  # Начинаем с 1, потому что x - натуральное число
        print(a)
        break

# Определение функции f(n)
def f(n):
    # Если n <= 1, возвращаем 1
    if n <= 1:
        return 1
    # Если n делится на 3, возвращаем сумму результатов f(n - 1) и f(n - 3)
    if n % 3 == 0:
        return f(n - 1) + f(n - 3)
    # В противном случае возвращаем сумму результата f(n - 2) и утроенного значения n
    else:
        return f(n - 2) + 3 * n

# Выводим результат функции для n = 65
print(f(65))

with open('17.txt', 'r') as f:
    nums = []
    max_three_digit = -1
    for num in f:
        num = int(num)
        nums.append(num)
        if 100 <= num <= 999:
            max_three_digit = max(max_three_digit, num)

cnt = 0
total = 0

# Обход всех пар чисел в списке
for i in range(len(nums) - 1):
    left, right = nums[i], nums[i + 1]
    
    # Проверка условий для пары и обновление счетчика и максимальной суммы
    if (100 <= left <= 999) != (100 <= right <= 999) and left + right >= max_three_digit:
        cnt += 1
        total = max(total, left + right)

print(cnt, total)

# функция проверит, можно ли победить на текущем ходе
def task_19(stones, current_move):
    # Нам подходит только один вариант, когда Боб победил на своём первом ходе
    if stones > 199:
        # Если это первый ход Боба, то вернем истину
        if current_move == 2:
            return True
        # Если же это ход Алисы или более поздний ход Боба, то мы возвращаем False
        else:
            return False
    # если на свой первый ход Боб не победил,
    # То возвращаем False - такой вариант не подходит  
    if current_move >= 2:
        return False
    
    # Есть 2 варианта хода
    # Увеличиваем количество камней на 1 и ход на 1
    first = task_19(stones + 1, current_move + 1)
    # Увеличиваем количество камней в 3 раза и ход на 1
    second = task_19(stones * 3, current_move + 1)

    # Когда ходит Алиса, Боб должен победить при любой игре Алисы. используем and
    # Когда ходит Боб, то мы можем взять любой из ходов Боба, так как он играет оптимально.
    # используем or
    # с учётом условий выше, current_move к этому моменту может равняться только 0 или 1
    if current_move == 0:
        return first and second
    else:
        return first or second

# переберём все варианты стартовой позиции
# выведем первое (минимальное) число, которое нам подойдёт
for i in range(1, 199 + 1):
    if task_19(i, 0):
        print(i)
        break

# Функция f(s, m) проверяет, может ли игрок выиграть при текущем состоянии игры
def f(s, m):
    if s > 199:  # Если в куче уже 200 или больше монет
        return m % 2 == 0  # Побеждает тот, кто сделал последний ход
    if m == 0:  # Если ходов больше нет
        return 0  # Никто не выиграл
    # Проверяем возможные ходы: добавить одну монету или утроить количество монет
    h = [f(s + 1, m - 1), f(s * 3, m - 1)]
    # В зависимости от того, чей сейчас ход, проверяем, может ли этот игрок выиграть
    return any(h) if (m - 1) % 2 == 0 else all(h)

# Находим все такие M, при которых Боб может выиграть, играя вторым
print(' '.join(map(str, [s for s in range(1, 200) if f(s, 2)])))

# функция проверит, можно ли победить на текущем ходе
def task_20(stones, current_move):
    if stones > 199:
        # Если это второй ход Боба, то вернем истину
        if current_move == 3:
            return True
        # Если же это ход Алисы или другой ход Боба, то мы возвращаем False
        else:
            return False
    # если на свой второй ход Боб не победил,
    # То возвращаем False - такой вариант не подходит  
    if current_move >= 3:
        return False
    
    # Есть 2 варианта хода
    # Увеличиваем количество камней на 1 и ход на 1
    first = task_20(stones + 1, current_move + 1)
    # Увеличиваем количество камней в 3 раза и ход на 1
    second = task_20(stones * 3, current_move + 1)

    # Ходы Боба и Алисы чередуются. Чей ход можно определять по чётности хода
    # теперь болеем за Боба, поэтому поменяем местами and и or
    if current_move % 2 == 0:
        return first or second
    else:
        return first and second

# переберём все варианты стартовой позиции
# выведем все подходящие числа
for i in range(1, 199 + 1):
    if task_20(i, 0):
        print(i, end=' ')

# Функция f(s, m) проверяет, может ли игрок выиграть при текущем состоянии игры
def f(s, m):
    if s > 199:  # Если в куче уже 200 или больше монет
        return m % 2 == 0  # Побеждает тот, кто сделал последний ход
    if m == 0:  # Если ходов больше нет
        return 0  # Никто не выиграл
    # Проверяем возможные ходы: добавить одну монету или утроить количество монет
    h = [f(s + 1, m - 1), f(s * 3, m - 1)]
    # В зависимости от того, чей сейчас ход, проверяем, может ли этот игрок выиграть
    return any(h) if (m - 1) % 2 == 0 else all(h)

# Находим все такие M, при которых Алиса не может выиграть за один ход, 
# но может выиграть своим вторым ходом
print(' '.join(map(str, [s for s in range(1, 200) if not f(s, 1) and f(s, 3)])))

# функция проверит, можно ли победить на текущем ходе
def task_21(stones, current_move):
    if stones > 199:
        # Если это первый или второй ход Боба, то вернем истину
        if current_move in [2, 4]:
            return True
        # Если же это ход Алисы или другой ход Боба, то мы возвращаем False
        else:
            return False
    # если на свой второй ход Боб не победил,
    # То возвращаем False - такой вариант не подходит  
    if current_move >= 4:
        return False
    
    # Есть 2 варианта хода
    # Увеличиваем количество камней на 1 и ход на 1
    first = task_21(stones + 1, current_move + 1)
    # Увеличиваем количество камней в 3 раза и ход на 1
    second = task_21(stones * 3, current_move + 1)

    # Ходы Алисы и Боба чередуются. Чей ход можно определять по чётности хода
    # снова болеем за Боба, поэтому поменяем местами and и or
    if current_move % 2 == 0:
        return first and second
    else:
        return first or second

# переберём все варианты стартовой позиции
# выведем все подходящие числа
for i in range(1, 199 + 1):
    if task_21(i, 0) and not task_19(i, 0):
        print(i)
        break

# Функция f(s, m) проверяет, может ли игрок выиграть при текущем состоянии игры
def f(s, m):
    if s > 199:  # Если в куче уже 200 или больше монет
        return m % 2 == 0  # Побеждает тот, кто сделал последний ход
    if m == 0:  # Если ходов больше нет
        return 0  # Никто не выиграл
    # Проверяем возможные ходы: добавить одну монету или утроить количество монет
    h = [f(s + 1, m - 1), f(s * 3, m - 1)]
    # В зависимости от того, чей сейчас ход, проверяем, может ли этот игрок выиграть
    return any(h) if (m - 1) % 2 == 0 else all(h)

# Находим все такие M, при которых Боб не может выиграть за свой первый ход, 
# но может выиграть своим вторым ходом
print(' '.join(map(str, [s for s in range(1, 200) if not f(s, 2) and f(s, 4)])))

d = {'0': 0}  # Словарь для хранения минимального времени выполнения для каждого процесса
data = []  # Список для хранения информации о каждом процессе

# Чтение данных из файла и преобразование их в удобный для работы формат
for s in open('22.txt'):
    data.append(s.replace(';', ' ').split())

# Цикл, который будет выполняться до тех пор, пока для всех процессов не будет найдено минимальное время выполнения
while len(d) != len(data) + 1:
    for s in data:
        # Проверка, известно ли минимальное время выполнения для всех зависимостей текущего процесса
        if all(sub in d for sub in s[2:]):
            # Вычисление и сохранение минимального времени выполнения для текущего процесса
            d[s[0]] = int(s[1]) + max(d[sub] for sub in s[2:])

# Вывод максимального значения среди всех минимальных времен выполнения процессов
print(max(d.values()))

def f(x):
    # Если x меньше 2, мы проскочили нужную точку
    if x < 2:
        return 0
    # если попали, то такой путь подходит
    if x == y:
        return 1
    # считаем количества путей для обоих действий
    return f(x - 2, y) + f(x // 2, y)


# Вызываем функцию для исходной точки
print(f(31))

# Открываем файл "24.txt" для чтения
with open("24.txt", "r") as file:
    # Читаем всё содержимое файла в строку file_content
    file_content = file.read()

# Инициализируем переменные для хранения максимальной и текущей длины подстроки
max_length = 0
current_length = 1

# Задаем подстроку, которая не должна присутствовать в искомой подстроке
substring = "AB"

# Проходим по каждому символу в строке
for i in range(len(file_content)):
    # Проверяем, содержится ли запрещенная подстрока в текущем сегменте
    if file_content[i:i + len(substring)] == substring:
        # Если текущая длина больше максимальной, обновляем максимальную длину
        max_length = max(max_length, current_length)
        # Сбрасываем текущую длину
        current_length = 1
    else:
        # Увеличиваем текущую длину подстроки
        current_length += 1

# Проверяем последний сегмент строки
max_length = max(max_length, current_length)

# Выводим максимальную длину подстроки
print(max_length)

# Открываем файл '24.txt' для чтения
with open("24.txt", "r") as file:
    # Читаем все содержимое файла в строку file_content
    file_content = file.read()

# Ставим между AB пробел, чтобы дальше разделить их на подстроки, где не содержаться подряд идущие символы AB
s = file_content.replace("AB", "A B")

# Разбиваем полученную строку на подстроки
# Теперь в списке s хранятся подстроки, в которых нет подряд идущих символов "AB"
s = s.split()
# Находим подстроку максимальной длинны
print(len(max(s, key=len))))

# Функция, которая находит все делители числа n
def find_divisors(n):
    divisors = set()  # Используем множество для хранения уникальных делителей
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            divisors.add(i)
            divisors.add(n // i)  # Добавляем оба делителя: i и n // i
    return divisors

# Начальное значение числа, с которого начнется поиск
start_number = 123456

# Счетчик для отслеживания количества найденных подходящих чисел
count_found = 0

while count_found < 5:  # Ищем пока не найдем пять подходящих чисел
    start_number += 1  # Переходим к следующему числу
    divisors = find_divisors(start_number)  # Ищем делители числа
    # Если у числа ровно 4 делителя
    if len(divisors) == 4:
        # Выводим число и сумму его делителей
        print(start_number, sum(divisors))
        # Увеличиваем счетчик
        count_found += 1

def solve_competition_problem(t, n, tasks_time):
    # Сортируем время, требующееся для решения задач, в порядке возрастания
    tasks_time.sort()
    
    # total_time - общее время, потраченное на решение задач
    # penalty_time - штрафное время
    # solved_tasks - количество решенных задач
    total_time = 0
    penalty_time = 0
    solved_tasks = 0
    
    # Проходим по списку задач
    for task_time in tasks_time:
        # Если Татьяна может решить текущую задачу в рамках оставшегося времени
        if total_time + task_time <= t:
            # Увеличиваем общее время на время текущей задачи
            total_time += task_time
            # Учитываем штрафное время для текущей задачи
            penalty_time += total_time
            # Увеличиваем счетчик решенных задач
            solved_tasks += 1
        else:
            # Если текущую задачу решить невозможно, прерываем цикл
            break
    
    # Возвращаем количество решенных задач и штрафное время
    return solved_tasks, penalty_time

# Читаем данные из файла
with open("26.txt", 'r') as file:
    t = int(file.readline().strip())  # Продолжительность соревнования
    n = int(file.readline().strip())  # Количество задач
    tasks_time = [int(file.readline().strip()) for _ in range(n)]  # Время на решение каждой задачи

# Решаем задачу и выводим результат
print(*solve_competition_problem(t, n, tasks_time))

# Открываем файл '27-1a.txt' для чтения и загружаем все числа в список nums, а переменную n устанавливаем в первое число из файла
f_name = '27-1a.txt'
with open(f_name) as f:
    n, *nums = [int(x) for x in f]

# Инициализируем переменную prod_max, в которой будет храниться максимальное произведение чисел, кратное 77
prod_max = 0

# Два вложенных цикла, которые перебирают все пары чисел в списке nums
for left in range(n):  # Перебор для левого числа в паре
    for right in range(left + 1, n):  # Перебор для правого числа в паре, начиная с индекса, следующего за left
        # Вычисляем произведение текущей пары чисел
        prod = nums[left] * nums[right]
        
        # Проверяем, делится ли произведение на 77 и больше ли оно текущего максимального произведения
        if prod % 77 == 0 and prod > prod_max:
            # Обновляем максимальное произведение
            prod_max = prod
            
# Выводим значение максимального произведения
print(prod_max)

# Открываем файл '27-1b.txt' для чтения и загружаем все числа в список nums, а переменную n устанавливаем в первое число из файла
f_name = '27-1b.txt'
with open(f_name) as f:
    n, *nums = [int(x) for x in f]

# Инициализация переменных для хранения максимальных чисел, удовлетворяющих различным условиям
max_1 = 0  # самое большое число
max_2 = 0  # второе по величине число
max_77 = 0  # максимальное число, кратное 77
max_7 = 0   # максимальное число, кратное 7
max_11 = 0  # максимальное число, кратное 11

# Перебор всех чисел из списка nums
for i in range(n):
    # Обновление max_1 и max_2 (два наибольших числа в списке)
    _, max_2, max_1 = sorted([nums[i], max_2, max_1])
    
    # Обновление max_77, max_7 и max_11 в зависимости от кратности текущего числа
    if nums[i] % 77 == 0:
        max_77 = max(max_77, nums[i])
    elif nums[i] % 7 == 0:
        max_7 = max(max_7, nums[i])
    elif nums[i] % 11 == 0:
        max_11 = max(max_11, nums[i])

# Вывод текущих значений максимальных переменных (для отладки)
print(max_1, max_2, max_77, max_7, max_11)

# Вычисление двух возможных максимальных произведений
if max_1 != max_77:
    v1 = max_1 * max_77
else:
    v1 = max_2 * max_77
v2 = max_7 * max_11

# Вывод результата
print(v1, v2)
print(max(v1, v2))