Ошибка Кода

# Импорт нужных функций из модуля itertools
from itertools import *

# Определение функции F, реализующей логическую функцию F
def F(a, b, c, d): # В данном случае необходимо 
    return (a <= b) and (b <= (not c)) and (c == (not d))

# Генерация всех возможных комбинаций значений переменных x1, x2, x3, x4
for x1, x2, x3, x4 in product((0, 1), repeat=4):
    
    # Создание фрагмента таблицы истинности
    t = [(1, 1, 0, x1), (x2, 0, 1, 0), (1, 0, x3, 1), (0, x4, 0, 1)]
    
    # Проверка на уникальность строк в таблице
    if len(set(t)) == len(t):
        
        # Перебор всех возможных перестановок столбцов (abcd, abdc, acbd, ...)
        for p in permutations('abcd'):
            
            # Проверка, что для данной перестановки значения F совпадают с заданными в таблице
            if [F(**dict(zip(p, r))) for r in t] == [1, 1, 1, 1]:
                
                # Вывод найденной перестановки
                print(*p, sep='')

# Функция для перевода числа в троичную систему счисления
def to_ternary(n):
    if n == 0:
        return "0"
    ternary = []  # Список для хранения цифр троичного числа
    while n:
        n, r = divmod(n, 3)  # Делим n на 3 и сохраняем результат и остаток
        ternary.append(str(r))  # Добавляем остаток в список
    return ''.join(reversed(ternary))  # Возвращаем перевернутую строку

a = set()  # Множество для хранения чисел R

# Основной цикл, в котором N пробегает значения от 1 до 100000
for N in range(1, 100000):
    n = to_ternary(N)  # Переводим N в троичную систему
    # Проверяем четность длины троичной записи числа
    if len(n) % 2 != 0:
        n = '1' + n  # Добавляем 1 в начало, если длина нечетная
    
    # Проверяем четность суммы цифр числа N
    if sum(int(digit) for digit in str(N)) % 2 == 0:
        n = n + n[:2]  # Добавляем первые две цифры в конец, если сумма четная
    else:
        n = n + to_ternary(N % 5)  # Иначе добавляем остаток от деления N на 5, переведенный в троичную систему
    
    # Удаляем первую цифру, если она равна "2"
    if n[0] == "2":
        n = n[1:]
    
    # Удаляем последний разряд, если последние две цифры одинаковы
    if n[-1] == n[-2]:
        n = n[:-1]
    
    R = int(n, 3)  # Переводим полученное троичное число обратно в десятичную систему
    if R > 150:  # Если R больше 150, добавляем его в множество
        a.add(R)

print(min(a))  # Выводим минимальное значение из множества

from itertools import permutations  # Импорт функции для генерации перестановок

even_digits = "02468ACE"  # Строка четных шестнадцатеричных цифр
odd_digits = "13579BDF"  # Строка нечетных шестнадцатеричных цифр

count_permutations = 0  # Счетчик нужных перестановок

# Цикл по всем возможным четырёхзначным перестановкам шестнадцатеричных чисел
for i in permutations('0123456789ABCDEF', 4):
    if i[0] != "0":  # Первая цифра не должна быть нулём
        # Подсчет количества четных и нечетных цифр в перестановке
        even_count = sum(1 for digit in i if digit in even_digits)
        odd_count = sum(1 for digit in i if digit in odd_digits)
        
        # Подсчет суммы четных и нечетных цифр в перестановке
        even_sum = sum(int(digit, 16) for digit in i if digit in even_digits)
        odd_sum = sum(int(digit, 16) for digit in i if digit in odd_digits)
        
        # Проверка условий задачи
        if even_count == 2 and odd_count == 2 and even_sum == odd_sum:
            count_permutations += 1  # Увеличение счетчика

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

# Функция для определения, является ли год високосным
def is_leap_year(year):
    return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)

# Путь к файлу
file_path = '9.csv'

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

# Открытие файла для чтения
with open(file_path, 'r') as file:
    for line in file:
        # Разбиение строки на составляющие
        year, month, day, gender = line.strip().split(';')
        
        # Преобразование года и месяца в целочисленный формат
        year = int(year)
        month = int(month)
        
        # Проверка условий и увеличение счетчика при совпадении
        if gender == 'ж' and is_leap_year(year) and month == 10:
            count += 1

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

from random import shuffle
# Создание строки из 50 '6', 50 '3' и 50 '9'
line = ''
for s in '639': line += s * 50

# Перемешивание символов строки
line = list(line)
shuffle(line)
line = ''.join(line)

# Пока в строке есть комбинации '63', '69' или '93' меняем их местами
while '63' in line or '69' in line or '93' in line:
    if '63' in line:
        line = line.replace('63', '36', 1)
    if '69' in line:
        line = line.replace('69', '96', 1)
    if '93' in line:
        line = line.replace('93', '39', 1)

# Вывод требуемых символов строки
print(line[42 - 1], line[100 - 1], line[144 - 1], sep='')

import math

# Исходная подсеть и количество адресов в ней
original_subnet = "192.168.10.0/23"
original_subnet_size = 2 ** (32 - int(original_subnet.split("/")[-1]))

# Минимальное количество устройств в каждом отделе
min_devices_per_department = 25

# Вычисляем необходимое количество адресов в каждой подсети
required_addresses_per_subnet = min_devices_per_department + 2  # +2 для адреса сети и адреса широковещательной передачи

# Находим ближайшую степень двойки, которая больше или равна необходимому количеству адресов
subnet_size = 2 ** math.ceil(math.log2(required_addresses_per_subnet))

# Вычисляем максимальное количество подсетей
max_subnets = original_subnet_size // subnet_size

# Расчитываем адреса и маски для каждой подсети
subnets = []  # Создаем пустой список для хранения информации о каждой подсети
current_address = 0  # Устанавливаем текущий адрес на 0, это будет начальный адрес для первой подсети

for _ in range(max_subnets):  # Цикл, который повторяется столько раз, сколько возможных подсетей
    subnet_address = f"192.168.10.{current_address}"  # Формируем адрес подсети на основе текущего адреса
    subnet_mask = 32 - int(math.log2(subnet_size))  # Вычисляем маску подсети на основе размера подсети
    subnets.append((subnet_address, subnet_mask))  # Добавляем кортеж с адресом и маской подсети в список
    current_address += subnet_size  # Увеличиваем текущий адрес на размер подсети для следующей итерации

print(max_subnets)

a = []  # Создание пустого списка для хранения возможных значений суммы z+y

# Перебор всех возможных значений z (от 0 до Y) в 35-ричной системе счисления
for z in '0123456789ABCDEFGHIJKLMNOPQRSTUVWXY':
    # Перебор всех возможных значений y (от 0 до I) в 19-ричной системе счисления
    for y in '0123456789ABCDEFGHI':
        # Вычисление значения выражения 3Bz4C_{35} + A12Fy_{19} в 10-ричной системе счисления
        n = int(f'3B{z}4C', 35) + int(f'A12F{y}', 19)
        
        # Проверка, делится ли полученное значение на 7
        if n % 7 == 0:
            # Если делится, добавляем сумму z+y в список a
            a.append(int(z, 35) + int(y, 19))

# Вывод максимального значения суммы z+y из списка a
print(max(a))

# Определение диапазонов p и q
p = range(3, 87 + 1) # Диапазон чисел от 3 до 87 включительно
q = range(50, 72 + 1) # Диапазон чисел от 50 до 72 включительно

# Инициализация максимальной длины диапазона a
l_max = 0

# Двойной цикл для определения левой и правой границ диапазона a
for left in range(2, 88 + 1): # Перебор возможных левых границ диапазона a от 2 до 88 включительно
    for right in range(left + 1, 88 + 1): # Перебор возможных правых границ диапазона a начиная с левой границы + 1 до 88 включительно
        a = range(left, right + 1) # Определение текущего диапазона a
        ok = True # Флаг, указывающий на соответствие условиям задачи
        
        # Перебор чисел от 1 до 99 включительно
        for x in range(1, 100):
            # Проверка условий задачи для каждого x
            f = (x in p) and (not ((x in a) == (x in q))) or (not ((x in a) or (x in q)))
            if f == 0: # Если условие не выполнилось для текущего x
                ok = False # Устанавливаем флаг в False
                break # Прерываем цикл
        
        # Если для всех x условие выполнилось
        if ok:
            l_max = max(l_max, right - left) # Обновляем максимальную длину диапазона a

# Вывод длины диапазона a с учетом того, что правая граница не включается в диапазон
print(l_max + 1)

# Определение функции F(n) согласно заданным правилам
def f(n):
    # Если n <= 1, то F(n) = 0
    if n <= 1:
        return 0
    # Если n делится на 6, то F(n) = n + F(n / 6 - 2)
    elif n % 6 == 0:
        return n + f(n / 6 - 2)
    else:
        # Если n не делится на 6, то F(n) = n + F(n + 6)
        # Использование -бесконечности уместно, потому что это эффективно "срезает" ветки рекурсии для значений n, которые не делится на 6, ускоряя процесс поиска нужного значения n, при котором F(n) превосходит 4242.
        return -float('inf')

# Начальное значение n
n = 1

# Бесконечный цикл, который продолжается, пока не найдено значение n, для которого F(n) > 4242
while True:
    # Вычисляем значение F(n) для текущего n
    rez = f(n)
    # Если F(n) > 4242, выводим n и прерываем цикл
    if rez > 4242:
        print(n)
        break
    # Увеличиваем n на 1
    n += 1

# Открываем файл и считываем все числа в список numbers
with open('17.txt', 'r') as f:
    numbers = list(map(int, f.read().split()))

# Функция для проверки, является ли число палиндромом
def is_palindrome(n):
    str_n = str(n)  # Преобразуем число в строку
    return str_n == str_n[::-1]  # Сравниваем строку и ее обратную версию

# Функция для вычисления суммы цифр числа
def digit_sum(n):
    return sum(int(digit) for digit in str(n))  # Суммируем цифры числа

# Инициализация переменных для подсчета троек и максимальной суммы цифр
count_triples = 0
max_digit_sum = 0

# Перебор троек чисел в списке
for i in range(len(numbers) - 2):
    triple = numbers[i:i+3]  # Извлекаем текущую тройку чисел
    
    # Проверяем, являются ли все числа в тройке четырехзначными
    if all(1000 <= num <= 9999 for num in triple):
        
        # Проверяем, различны ли суммы цифр для всех чисел в тройке
        unique_digit_sums = len(set(digit_sum(num) for num in triple))
        
        # Проверяем, является ли сумма всех чисел в тройке палиндромом
        total_sum_palindrome = is_palindrome(sum(triple))
        
        # Если все условия выполняются, обновляем счетчики
        if unique_digit_sums == 3 and total_sum_palindrome:
            count_triples += 1
            max_digit_sum = max(max_digit_sum, *(digit_sum(num) for num in triple))

# Выводим количество найденных троек и максимальную сумму цифр
print(count_triples, max_digit_sum)

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

# Изначальное количество монет в первой куче.
bunch = 15
# Максимально возможное количество монет во второй куче.
S = 31

# Ищем максимальное значение S, при котором Алиса не может выиграть за один ход, но Боб может выиграть за один ход.
print(max([s for s in range(1, S) if not f(bunch, s, 0) and f(bunch, s, 2)]))

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

# Изначальное количество монет в первой куче.
bunch = 15
# Максимально возможное количество монет во второй куче.
S = 31

# Ищем два минимальных значения S, при которых Алиса не может выиграть за один ход, но может выиграть за два хода.
print(*[s for s in range(1, S) if not f(bunch, s, 1) and f(bunch, s, 3)][:2])

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

# Изначальное количество монет в первой куче
bunch = 15
# Максимально возможное количество монет во второй куче
S = 31

# Находим два значения S, при которых Боб может выиграть на первом или втором ходу, но не может выиграть сразу на первом ходу.
print(*[s for s in range(1, S) if not f(bunch, s, 2) and f(bunch, 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()))

# Функция f рекурсивно ищет количество путей для преобразования числа x в y, не превышая max_steps шагов и избегая числа 27.
def f(x, y, steps, max_steps):
    if x == 27: return 0  # Исключаем траектории, включающие число 27
    if x >= y: return x == y and steps <= max_steps  # Если достигли или превысили y, проверяем, не превышено ли количество шагов
    if steps >= max_steps: return 0  # Если превышено максимальное количество шагов, возвращаем 0
    # Рекурсивно вызываем функцию для всех трех возможных операций: прибавления 2, умножения на 3 и возведения в куб.
    return f(x + 2, y, steps + 1, max_steps) + f(x * 3, y, steps + 1, max_steps) + f(x ** 3, y, steps + 1, max_steps)

# Ищем количество программ, которые преобразуют число 3 в 125, не превышая 15 шагов и избегая числа 27.
print(f(3, 125, 0, 15))

with open("24.txt", "r") as file:
    content = file.read()

# Инициализация переменных
start = 0  # Начальный указатель
end = 0  # Конечный указатель
count_E = 0  # Счетчик символов 'E'
min_length = float('inf')  # Минимальная длина подпоследовательности

# Перемещение указателя end и поиск минимальной длины подпоследовательности
while end < len(content):
    # Увеличиваем счетчик, если текущий символ - 'E'
    if content[end] == 'E':
        count_E += 1
    
    # Перемещаем указатель start, если счетчик достиг 100
    while count_E == 100:
        # Обновляем минимальную длину
        min_length = min(min_length, end - start + 1)
        # Уменьшаем счетчик, если символ под указателем start - 'E'
        if content[start] == 'E':
            count_E -= 1
        # Перемещаем указатель start вправо
        start += 1
    
    # Перемещаем указатель end вправо
    end += 1

min_length if min_length != float('inf') else 0
print(min_length)

# Импорт функции fnmatch для сопоставления строки с шаблоном
from fnmatch import fnmatch

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

# Главный цикл: перебор чисел от 0 до 10^8
for n in range(0, 10**8 + 1):
    # Сопоставление числа n с маской 51*2?34
    if fnmatch(str(n), '51*2?34'):
        # Вызов функции для нахождения делителей числа n
        divisors = find_divisors(n)
        
        # Проверка условий: есть делители и их сумма делится на 117
        if divisors and (divisors[0] + divisors[-1]) % 117 == 0:
            # Вывод числа n и суммы его минимального и максимального делителя
            print(n, divisors[0] + divisors[-1])

# Считывание данных из файла
# Открываем файл 26.txt для чтения
with open('26.txt', 'r') as f:
    # Считываем первую строку, в которой указано количество мероприятий, и преобразуем её в целое число
    N = int(f.readline().strip())
    # Считываем оставшиеся строки, каждая из которых содержит два числа, разделенных пробелом, и преобразуем их в кортежи
    events_data = [tuple(map(int, line.split())) for line in f.readlines()]

# Сортировка заявок по времени окончания
# Сортируем список мероприятий по времени их окончания
sorted_events = sorted(events_data, key=lambda x: x[1])

# Функция для определения максимального количества мероприятий, которые можно провести
def max_events(events):
    count = 0  # Счетчик для количества мероприятий
    last_end_time = -1  # Время окончания последнего мероприятия
    # Проходимся по каждому мероприятию в отсортированном списке
    for start, end in events:
        # Проверяем, можно ли провести текущее мероприятие
        if start >= last_end_time:
            count += 1  # Увеличиваем счетчик мероприятий
            last_end_time = end  # Обновляем время окончания последнего мероприятия
    return count  # Возвращаем количество мероприятий

# Вызываем функцию для получения максимального количества мероприятий
max_count = max_events(sorted_events)

# Определение самого позднего времени начала первого мероприятия
latest_start_time = None  # Инициализация переменной для хранения времени

# Проходимся по списку мероприятий в обратном порядке
for start, _ in reversed(sorted_events):
    # Фильтруем мероприятия, которые начинаются не раньше текущего
    current_events = [(s, e) for s, e in sorted_events if s >= start]
    # Проверяем, совпадает ли максимальное количество мероприятий
    if max_events(current_events) == max_count:
        latest_start_time = start  # Сохраняем время начала
        break  # Выходим из цикла

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

# решение полным перебором
from math import ceil

f_name = '27_A.txt'
with open(f_name) as f:
    n, m, *nums = [int(x) for x in f.read().split()]
nums = [ceil(x / 6) for x in nums]

total_max = 0
# у первой позиции возьмём диапазон n - m, потому что правые m чисел возьмёт
# второй диапазон
for pos1 in range(n - m):
    # второй начнём собирать с pos1 + m + m, чтобы диапазоны не пересекались
    # это стоит нарисовать для полного понимания
    for pos2 in range(pos1 + m + m + 1, n - m):
        total = 0
        # тут нет смысла перебирать все числа. достаточно перебрать те, что
        # входят в диапазон
        for i in range(max(0, pos1 - m), min(pos1 + m + 1, n)):
            total += nums[i]
        for i in range(max(0, pos2 - m), min(pos2 + m + 1, n)):
            total += nums[i]
        total_max = max(total, total_max)
print(total_max)

# оптимальное решение
from math import ceil

f_name = '27_B.txt'
with open(f_name) as f:
    n, m, *nums = [int(x) for x in f.read().split()]
nums = [ceil(x / 6) for x in nums]

# мы не считаем значения от 0 до m-1 и от n-m-1 до n-1, потому что там точно
# будет меньше
totals = [sum(nums[0:2*m+1])]
for i in range(m, n - m - 1):
    total = totals[-1] - nums[i - m] + nums[i + m + 1]
    totals.append(total)

# наибольший ответ
ans_max = 0
# сумма левого диапазона
left = totals[0]
# перебираем правый диапазон
for i in range(m + m + 1, len(totals)):
    # выделяем правый диапазон
    right = totals[i]
    # обновляем максимум
    if left + right > ans_max:
        ans_max = left + right
    # сдвигаем левый диапазон, если он более выгодный
    if totals[i - 2 * m] > left:
        left = totals[i - 2 * m]
print(ans_max)