Заявления на пересдачу по информатике или русскому языку принимаются с 26 июня по 1 июля включительно.
Заявления на экзамен по математике можно подать с 27 июня по 2 июля включительно.

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

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

Элементами множеств А, P и Q являются натуральные числа, причём P = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20} и Q = { 3, 6, 9, 12, 15, 18, 21, 24, 27, 30 }.

Известно, что выражение ((x ∈ A) → (x ∈ P)) ∧ (¬(x ∈ Q) → ¬(x ∈ A)) истинно при любом значении переменной х. Определите наибольшее возможное количество элементов множества A.

a = set(range(0, 1000))

def F(x):
    P = x in {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}
    Q = x in {3, 6, 9, 12, 15, 18, 21, 24, 27, 30}
    A = x in a
    # ((x ∈ A) → (x ∈ P)) ∧ (¬(x ∈ Q) → ¬(x ∈ A))
    return (A <= P) and ((not Q) <= (not A))


for x in range(0, 10000):
    if F(x) == False:
        a.remove(x)
print(len(a))

# Ответ: 3

Создание множества a, содержащего числа от 0 до 999.

Объявление функции F с аргументом x.

Проверка, принадлежит ли x множеству {2, 4, 6, 8, 10, 12, 14, 16, 18, 20} и сохранение результата в переменную P.

Проверка, принадлежит ли x множеству {3, 6, 9, 12, 15, 18, 21, 24, 27, 30} и сохранение результата в переменную Q.

Проверка, принадлежит ли x множеству a (от 0 до 999) и сохранение результата в переменную A.

Возвращение результата логического выражения: (A <= P) and ((not Q) <= (not A)).

Цикл for, который перебирает значения x от 0 до 9999.

Проверка условия: если результат функции F для значения x равен False.

Удаление значения x из множества a.

Вывод длины множества a после выполнения цикла.

import turtle as t

t.tracer(0)

t.fd(10)  # t.bk(10)
t.rt(90)  # t.lt(90)

t.up()
t.down()

x, y = 0, 0
t.goto(x, y)
t.dot(2, 'red')

t.done()

from itertools import product
from itertools import permutations

combinations = list(product([1, 2, 3], repeat=2))
for combination in combinations:
    print(combination)

perms = list(permutations("abc"))
for perm in perms:
    print(''.join(perm))
   

from ipaddress import *
net = ip_network('адрес узла/маска', 0)
print(net, net.netmask, net.num_addresses)
   

Одна увеличивает глубину рекурсии:

import sys
sys.setrecursionlimit(10000)
   

Вторая ускоряет вычисления через использование кэширования:

from functools import *
@lru_cache(None)
def F(n):
   

from fnmatch import fnmatch
if fnmatch('123', '*?3'):
    pass
   

import string
alphabet = string.ascii_uppercase
print(alphabet)  # ABCDEFGHIJKLMNOPQRSTUVWXYZ

print(string.punctuation)
# !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
   

import math as m
print(m.sqrt(16))
print(m.ceil(7/2))
   

1. Строится восьмеричная запись числа N.

2. а) если количество чётных цифр в записи числа нечётно, то к трём последним разрядам восьмеричной записи справа дописывается 46;

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

Укажите минимальное число R, которое может быть получено с помощью описанного алгоритма при N не меньшем 80.

R = []
for n in range(81, 10000):
    s = oct(n)[2:]  # f'{n:o}'
    chet = [x for x in s if x in '02468']
    if len(chet) % 2 != 0:
        s = s[-3:] + '46'
    else:
        x = (n % 8) * 5
        s = oct(x)[2:] + s
    r = int(s, 8)
    R.append(r)
print(min(R))

# Ответ: 38

Создание пустого списка R, в который будут добавляться результаты.

Цикл, который перебирает числа от 81 до 9999.

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

Формирование списка, содержащего только символы, которые являются четными цифрами.

Если количество четных цифр в строке нечетное.

Если условие из пункта 5 выполняется, изменяем строку s, добавляя к ней '46'.

Вычисляем значение x как остаток от деления n на 8, умноженное на 5.

Обновляем значение s, добавляя к нему начальную часть, преобразованную из x в восьмеричную систему.

Преобразование строки s из восьмеричной системы счисления в целое число и сохранение результата в переменной r.

Добавление значения r в список R.

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

n = 24
num_2 = bin(n)[2:]  # 11000
num_8 = oct(n)[2:]  # 30
num_16 = hex(n)[2:] # 18

n = 24
num_2 = f'{n:b}'  # 11000
num_8 = f'{n:o}'  # 30
num_16 = f'{n:x}' # 18

from string import *
alphabet = digits + ascii_uppercase
# alphabet = sorted('0123456789QWERTYUIOPASDFGHJKLZXCVBNM')

def my_convert(num, base):
    result = ''
    while num > 0:
        result += alphabet[num % base]
        num //= base
    return result[::-1]

n = 24
num_2 = my_convert(n, 2)   # 11000
num_8 = my_convert(n, 8)   # 30
num_16 = my_convert(n, 16) # 18
num_3 = my_convert(n, 3)   # 220

r = int(num_base, base)
print(int('1000', 2))  # 8

s = '101001'

# Добавить '10' справа (в конец)
s = s + '10'  # 10100110


# Добавить '01' слева (в начало)
s = '01' + s  # 0110100110
print(s)

# Добавить '+' по середине
s = s[:len(s)//2] + '+' + s[len(s)//2:]
# 01101*00110

# Заменить все нули на единицы, а единицы на нули
s = s.replace('1', '*')
s = s.replace('0', '1')
s = s.replace('*', '0')

1. Строится запись числа N в системе счисления с основанием 12.
2. Далее эта запись обрабатывается по следующему правилу:

а) если число N делится на 4, то слева к нему приписывается «2», а справа «64»;

б) если число N на 4 не делится, то в конец числа дописывается его максимальная цифра в системе счисления с основанием 12.
Полученная таким образом запись является двенадцатеричной записью искомого числа R.

3. Результат переводится в десятичную систему и выводится на экран.

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

alphabet = sorted('0123456789QWERTYUIOPASDFGHJKLZXCVBNM')
def convert(num, base):
    r = ''
    while num > 0:
        r += alphabet[num % base]
        num //= base
    return r[::-1]


R = []
for n in range(1, 10000):
    s = convert(n, 12)
    if n % 4 == 0:
        s = '2' + s + '64'
    else:
        s += max([x for x in s])
    r = int(s, 12)
    if r > 1799:
        R.append(r)
print(min(R))

# Ответ: 1806

Создание отсортированного списка символов, представляющих алфавит для кодирования чисел в других системах.

Определение функции convert с аргументами num (число для конвертации) и base (основание системы счисления).

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

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

Добавление символа из алфавита в строку r, соответствующего остатку от деления числа num на base.

Целочисленное деление числа num на base.

Возврат результата функции, перевернутого конвертированного числа.

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

Цикл, перебирающий числа от 1 до 9999.

Конвертация числа n в двенадцатеричную систему и сохранение результата в строке s.

Проверка условия: если число n делится на 4 без остатка.

Если условие из пункта 11 выполняется, изменяем строку s, добавляя к ней '2' в начале и '64' в конце.

Добавляем к строке s максимальное значение из всех символов.

Преобразование числа s из двенадцатеричной системы в десятичную и сохранение результата в переменной r.

Проверка условия: если результат r больше 1799.

Добавление числа r в список R.

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

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

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

s = open('24.txt').readline()
count = 3
maxi = 0
for i in range(len(s)-3):
    if s[i:i+4] in ('KLMN', 'LMNK', 'MNKL', 'NKLM'):
        count += 1
        maxi = max(maxi, count)
    else:
        count = 3
print(maxi)

# Ответ: 182

Чтение строки из файла "24.txt" и сохранение ее в переменную s.

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

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

Цикл, перебирающий индексы от 0 до len(s)-4 для итерации по всем четверным подстрокам строки s.

Проверка, содержится ли текущая четверная подстрока строки s в заданных последовательностях 'KLMN', 'LMNK', 'MNKL' или 'NKLM'.

Увеличение значения переменной count на 1, если найдена подходящая четверная последовательность.

Обновление значения переменной maxi на максимальное из текущего значения и count.

В случае, если текущая четверная подстрока не соответствует заданным последовательностям:

Сброс значения переменной count до 3 для начала подсчета заново.

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

M = [int(x) for x in open('17.txt')]

M = [1, 2, 3, 4, 5]
for i in range(len(M)-1):
    x, y = M[i:i+2]
    print(f'{x}{y}', end=' ') 

# Вывод: 
# 12 23 34 45

M = [1, 2, 3, 4, 5]
for i in range(len(M)-2):
    x, y, z = M[i:i+3]
    print(f'{x}{y}{z}', end=' ')  

# Вывод:
# 123 234 345

M = [1, 2, 3, 4, 5]
for i in range(0, len(M)):
    for j in range(i+1, len(M)):
        x, y = M[i], M[j]
        print(f'{x}{y}', end=' ')
    print()

# Вывод:
# 12 13 14 15
# 23 24 25
# 34 35
# 45

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

s = open('24.txt').readlines()
maxi = 0
for x in s:
    count = 2
    for i in range(len(x)-2):
        if x[i:i+3] in ('XYZ', 'YZX', 'ZXY'):
            count += 1
            maxi = max(maxi, count)
        else:
            count = 2
print(maxi)

# Ответ: 53

Чтение всех строк из файла "24.txt" и сохранение их в виде списка строк в переменную s.

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

Цикл, который перебирает строки из списка s для анализа каждой строки отдельно.

Инициализация переменной count со значением 2, которая будет использоваться для подсчета последовательности в текущей строке.

Внутренний цикл, который перебирает индексы от 0 до длины строки x минус 2 для итерации по каждой тройной подстроке в текущей строке.

Проверка условия: если текущая тройная подстрока x присутствует в кортеже заданных строк 'XYZ', 'YZX' или 'ZXY'.

Увеличение значения переменной count на 1, если найдена подходящая тройная последовательность.

Обновление значения переменной maxi на большее из текущего значения и count.

В случае, если текущая тройная подстрока не соответствует заданным последовательностям:

Сброс значения переменной count на 2 для начала подсчета заново в текущей строке.

Вывод наибольшего значения переменной maxi.