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

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

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

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

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

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

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

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

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

for A in range(1, 1000):
    p = True
    for x in range(1, 1000):
        f = (45 % A == 0) and (((x % 30 == 0) and (x % 12 == 0)) <= (x % A == 0))
        if f == False:
            p = False
            break
    if p == True:
        print(A)

def d(x, y):
    return x % y == 0
def f(a):
    for x in range(1, 10000):
        if (((d(x, a) and d(x, 36)) <= d(x, 324)) and (a > 100)) == 0:
            return False
    return True

for a in range(1, 1000):
    if f(a):
        print(a)
        break

for A in range(1, 1000):
    p = True
    for x in range(1, 1000):
        f = ((x % 34 == 0) and (x % 51 != 0)) <= ((x % A != 0) or (x % 51 == 0))
        if f == False:
            p = False
            break
    if p == True:
        print(A)
        break

def f(a):
    for x in range(1, 1000):
        if (((x % 19 != 0) or (x % 15 != 0)) <= (x % a != 0)) == 0:
            return 0
    return 1

for a in range(1, 1000):
    if f(a):
        print(a)
        break

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

Отсюда следует, что x должен делиться на () и .

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

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

Отсюда следует, что x должен делиться на и () и не должен делиться на ().

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

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

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

Отсюда следует, что x обязательно должен делиться на .

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

 

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

def f(a):
    for x in range(1, 1000):
        if not((x % a != 0) <= ((x % 21 != 0) and (x % 35 != 0))):
            return False
    return True

for a in range(1, 1000):
    if f(a):
        print(a)

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

Отсюда следует, что x должен делиться на () и ().

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

for A in range(1, 1000):
    flag = True
    for x in range(1, 1000):
        f = (x % A == 0) <= ((x % 21 != 0) or (x % 35 == 0))
        if f == 0:
            flag = False
            break
    if flag:
        print(A)
        break

for A in range(1000, 0, -1):
    flag = True
    for x in range(1000):
        if ((70 % A == 0) and ((x % A != 0) <= ((x % 18 == 0) <= (x % 42 != 0)))) == 0:
            flag = False
    if flag:
        print(A)
        break

for A in range(1, 100):
    flag = True
    for x in range(1,1000):
        if (((x % A != 0) and (x % 6 != 0)) <= (x % 3 != 0)) == 0:
            flag = False
    if flag == True:
        print(A)

for A in range(1, 100000):
    flag = True
    for x in range(1, 1000000):
        f = (70 % A == 0) and ((not(x % A == 0)) <= ((x % 18 == 0) <= (not(x % 42 == 0))))
        if f == False:
            flag= False
            break
    if flag:
        maxim = A
print(maxim)

for A in range(1,10000):
    flag = True
    for x in range(1,100000):
        f = (70%A==0) and ((x%28==0) <= ((x%A!=0) <= (x%21!=0)))
        if f==False:
            flag = False
            break
    if flag:
        maxim = A
print(maxim)

f(a) — возвращает True, если подходит, иначе — False

def f(a):
    for x in range(1, 1000):
        if ((x % a != 0) <= ((x % 6 == 0) <= (x % 24 != 0))) == 0:
            return False
    return True

for a in range(1, 10000):
    if f(a):
        print(a)

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

Составим систему для тех случаев, когда выражение тождественно ложно:

 

Отсюда следует, что обязательно должен делиться на НОК.

Нам требуется, чтобы любой , кратный , делится на , то есть — делитель числа . Максимальное равно максимальному делителю числа , то есть .

 

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

def f(x, A):
    return (x % A != 0) <= ((x % 6 == 0) <= (x % 9 != 0))

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

Враги хотят подобрать который будет одновременно не кратен и кратен 21 или 35. Это иксы вида 21, 35, 42, 70 ..

Друзья хотят чтобы эти делились на и оно было максимальным. Такое максимальное .