15.06 Смешанное

Решение 1 (ручками):

Запишем мечты врагов:

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

Враги мечтают, чтобы делился на и был меньше или равен , а также соответствовал маске __ (исходя из маски понимаем, что числа будут четные), значит будут брать из диапазона {}, которые еще должны соответствовать маске __.

Тогда друзья говорят, что . Максимальное , которое будут брать враги — (удовлетворяет всем условиям), значит .

 

Решение 2 (прогой):

def f(x):
    return (((x % 3 == 0) and (x % 7 == 0)) <= \
        (((x & 13 != 0) or (x & 32 == 0)) or (A * x <= 120834)))

ans = 0
for A in range(1, 1000):
    flag = True
    for x in range(1, 1001):
        if not f(x):
            flag = False
            break
    if flag:
        ans = max(ans, A)
print(ans)

Решение 1 (ручками):
Система для врагов:

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

Друзья говорят: «Нет, число не содержит единичку ни на одном из этих разрядов». Минимальное , которое могут взять друзья, равно , то есть .

 

Решение 2 (прогой):

def f(x, A):
    Q = [12, 48]
    P = [32, 64]
    return ((x%5 == 0) or (not inn(x, Q)) or (x & A == 0) or ((inn(x, P)) <= (abs(x - 31) >= 17)))

def inn(x, P):
    return P[0] <= x <= P[1]

for A in range(1, 1000):
    flag = True
    for x in range(-1000, 1000):
        if not f(x, A):
            flag = False
            break
    if flag:
        print(A)

Решение 1 (ручками):

Система для врагов:

Разберём мечты врагов:

, то есть .

, то есть (объединяя с первым условием)

, то есть (предыдущие два условия уже учли третье)

, то есть (учитывая три предыдущих условия)

Теперь рассмотрим последнюю мечту: . Поскольку мы знаем все иксы, которые будут выбирать враги, переведём их в двоичную систему счисления:

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

Друзья говорят: «Нет, любая из последних шести цифр числа в двоичной записи равна нолику». Таким образом, .

 

Решение 2 (прогой):

def inn(x, A):
    return A[0] <= x <= A[1]

def f(x, A):
    S = {45, 23, 67}
    Q = [12, 48]
    return (((x % 3 != 0) and (not (x in S))) <=
    ((abs(x - 50) <= 7) <= (inn(x, Q))) or (x & A == 0))

for A in range(1, 1000):
    flag = True
    for x in range(-100, 1000):
        if not f(x, A):
            flag = False
            break
    if flag:
        print(A)
        break

Решение 1 (ручками):

Запишем мечты врагов:

Рассмотрим мечты врагом из совокупности отдельно:

Враги хотят, чтобы , то есть , но так как мы берем только натуральные иксы, то .

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

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

Поэтому враги мечтают, чтобы и чтобы .

 

Друзья говорят: «Нет, все эти иксы не принадлежат ». Тогда друзья могут взять, например, или или . Наибольшую длину имеет , его длина = .

 

Решение 2 (прогой):

def inn(x, A):
    return A[0] <= x <= A[1]
def f(x, A):
    P = [15, 23]
    Q = [17, 34]
    return (((x % 4.5 != 0) and (x % 3 != 0) or (not inn(x, Q)) \
         or (not inn(x, A))) and (inn(x, P) or (not inn(x, A))))
ans, n = 0, 15
borders = [0 ,0]
for a in range(1 * n, 70 * n):
    for b in range(a, 70 * n):
        A = [a / n, b / n]
        flag = True
        for x in range(1, 70 * n):  # только натуральные
            if not f(x, A):
                flag = False
                break
        if flag:
            if A[1] - A[0] > ans:
                ans = A[1] - A[0]
                borders[0] = A[0]
                borders[1] = A[1]
print(borders)
print(ans)

Видим, что программа вывела промежуток и его длину .

Значит, ответом является промежуток с дробными границами, левая граница которого стремится к , а правая к , тогда длина стремится к .

Решение 1 (ручками):

Система для врагов:

Враги мечтают, чтобы , и . Тогда при единственные , которые смогут взять враги, чтобы условие выполнялось, будут равны и . Заметит, что при увеличении враги смогут брать больше вариантов , но всегда максимальное значение . Все натуральные не принадлежат , значит условие автоматически выполнено. Мечты врагов такие: «Вот бы ».

Друзья говорят: «Нет, ». Тогда при условии, что правая граница отрезка не больше , (чтобы даже ), а его максимальная длина равна .

 

Решение 2 (прогой):

def inn(x, A):
    return A[0] <= x <= A[1]

def f(x, y, A):
    S = {23, 27, 45, 46, 47, 67}
    return (((x % 3 != 0) and (not y in S)) <= ((x > 7) <= (y > 11))) \
        or (x * y <= 76) or (not inn(x, A)) or (not inn(y, A))

n = 5
ans = 0
for a in range(1 * n, 50 * n):
    for b in range(a, 50 * n + 1):  # + 1 чтобы проверить саму точку b
        A = [a / n, b / n]
        flag = True
        for x in range(1, 100):
            for y in range(1, 15):
                if not f(x, y, A):
                    flag = False
                    break
            if not flag:
                break
        if flag:
            ans = max(ans, A[1] - A[0])
print(ans)

Решение 1 (ручками):
Система для врагов:

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

Друзья говорят: «Нет, делится на ». Максимальное равно максимальному делителю числа , то есть . Это и есть ответ.

 

Решение 2 (прогой):

def f(x, A):
    B = [50, 70]
    return (x % A != 0) <= (inn(x, B) <= (x % 15 != 0))

def inn(x, B):
    return B[0] <= x <= B[1]

maxim = 0
for A in range(1, 300):
    flag = True
    for x in range(1, 500):
        if not(f(x, A)):
            flag = False
            break
    if flag:
        maxim = A
print(maxim)

Запишем, чего хотят враги:

Исходя из этого уменьшим поиск по нечетным и четным значениям соответственно:

Решение (прогой, работает пару минут):

for A in range(1, 10000):
    flag = True
    for x in range(5, (4095 + 1)*2 + 1, 2):
        for y in range(2, 4095 + 1, 2):
            if x*y % A == 0:
                flag = False
                break
        if not flag:
            break
    if flag:
        print(A)
        break

Решение (ручками):

Повторим, чего хотят враги:

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

Исходя из хотелок врага мы понимаем, что будут подбираться такие , чтобы они делились на . Это значит, что будет содержать внутри себя делители хотя бы одного набора . Наша задача — предоставить такое , чтобы при любом произведении там не было такого делителя, что и в .

Заметим, что — четные числа. Значит, в самых больших будет содержаться максимум умноженное на что-то. Тогда, чтобы минимизировать возьмем (т.к. в степени что-то будет явно меньше, чем числа большие в степени что-то).

b = [i for i in range(35, 66)]
for a in range(1, 100):
    f = 0
    for x in range(1, 300):
        if ((x in b) <= (x % 21 != 0 or x % a == 0)) == False:
            f = 1
            break
    if f == 0:
        print(a)

b = [i for i in range(36, 52)]

mn = 10**10
for a1 in range(1, 250):
    for a2 in range(a1+1, 251):
        f = 0
        a = [i for i in range(a1, a2)]
        for x in range(1, 500):
            if ((x in a) or ((x in b) <= (x % 5 != 0))) == False:
                f = 1
                break
        if f == 0:
            # -1, потому что мы считаем длину,
            # т.е. количество "дорог" между точками(целыми числами),
            mn = min(len(a)-1, mn)
print(mn)

for a in range(1,1000):#Перебираем значения а
    f = 0 #Изначально флаг опущен
    for x in range(10000): #Перебираем для каждого а значения x
        if (((x % 5 != 0) and (x not in [25,50,55])) <= (((abs(x-41) <= 11) <= (30 <= x <= 51)) or (x&a!=0))) == False:
            f = 1 #Если условие выполнилось,значит данное а нам не подходит. Поднимаем флаг, прерываем работу цикла и переходим к следующему значению а
            break
    if f == 0:# Если флаг не был поднят,значит данное а нам подходит
        print(a)
        break