05 Макс/мин, кол-во пар, сумма/разность кратна/не кратна

Решение программой

Нужно найти количество пар положительных чисел в последовательности, сумма которых чётна, и между которыми есть хотя бы один ноль. Считываем длину последовательности и сами числа. Перебираем пары с индексами i и j (где j как минимум на 2 больше i, чтобы между ними могли быть элементы). Проверяем: оба числа положительные, их сумма чётна, и хотя бы один элемент между ними равен нулю. Если всё выполнено — увеличиваем счётчик. Выводим общее количество таких пар.

# Открываем файл и считываем количество чисел
f = open(’17.txt’)
n = int(f.readline())

# Считываем сами числа
a = [int(x) for x in f]

# Счётчик подходящих пар
count = 0

# Перебираем все возможные пары i < j, где между ними хотя бы 1 элемент
for i in range(n):
    for j in range(i + 2, n):

        # Условие: оба положительные и сумма чётная
        if (a[i] + a[j]) % 2 == 0 and a[i] > 0 and a[j] > 0:

            # Проверяем, есть ли между ними хотя бы один ноль
            for k in range(i + 1, j):
                if a[k] == 0:
                    count += 1
                    break

print(count)

Идея эффективного решения:

Идея решения заключается в том, чтобы под каждым остатком при делении на 114 собрать максимальное число с той целью, чтобы в итоге мы могли получить максимальную сумму кратную 114. Сумма пары кратна 114 в том случае, когда сумма остатков при делении на 114 пары чисел кратна 114. Считывая одно число с определенным остатком при делении на 114 мы должны подобрать в пару ему такое число, чтобы в итоге их пара была кратна 114. Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 114, а x - первое число пары.

#переборный алгоритм:
f = open(’1_A.txt’) #открываем файл.
n = int(f.readline()) #считываем первое число - количество чисел в файле.
a = [] #cписок, в котором у нас будут находиться все числа файла.
for i in range(n): #проход по файлу.
    a.append(int(f.readline())) #добавление текущего числа в список.

maxi = 0 #максимальная сумма пары.
for i in range(0,len(a)-1): #перебор для первого числа пары.
    for j in range(i+1,len(a)): #перебор для второго числа пары.
        if (a[i]+a[j]) % 114 == 0: #проверка по условию.
            maxi = max(maxi, a[i]+a[j]) # записываем максимальную сумму пары.
print(maxi) #вывод ответа.

#эффективный алгоритм:
file = open(’1_B__48rmd.txt’) #открываем файл.
n = int(file.readline()) #считываем первое число - количество чисел в файле.
div = 114 #число, на которое нацело должна делиться сумма пары.
mx = [0] * div #список, в котором под каждым индексом (под каждым остатком) записано максимальное число данного остатка.
mx_sum = 0 #максимальная сумма пары
for i in range(n): #проход по всему файлу
    x = int(file.readline()) #считываем текущее число
    need_ost = (div - x % div) % div #определяем необходимый остаток второго числа при делении на 114 для того чтобы сумма пары делилась нацело
    mx_sum = max(mx_sum,x+mx[need_ost]) #записываем максимальную сумму пары
    mx[x % div] = max(mx[x % div],x) #записываем максимальное число под индексом равным его остатку при делении на 114, сравниваем между текущим число и тем, что было в этой ячейке ранее
print(mx_sum) #вывод ответа

Решение 1. Неэффективное

f = open("27-A.txt")
n = int(f.readline())
a = []
for i in range(n):
    a.append(int(f.readline()))
k = 0
for i in range(n):
    for j in range(i + 1, n):
        for l in range(j + 1, n):
            if (a[i] + a[j] + a[l]) % 3 == 0:
                k += 1
print(k)

Решение 1. Эффективное. Динамика

f = open(’15.txt’)
n = int(f.readline())
a = [int(i) for i in f]
k = 3
# Количества чисел с определенным остатком от деления
t = [0] * k
# Количества пар чисел, чья сумма обладает определенным остатком от деления
v = [0 for i in range(k)]
cnt = 0
for i in range(2, len(a)):
    # Обрабатываем элемент на расстоянии 2 от текущего (через один слева)
    ost1 = a[i - 2] % k
    # Увеличиваем количество элементов с таким остатком
    t[ost1] += 1

    # Обрабатываем средний элемент - на расстоянии 1 от текущего (слева)
    ost2 = a[i - 1] % k

    # Средний элемент образует пары со всеми ранее встреченными элементами
    # С элементом с каждым остатком образуется пара с суммой с новым остатком

    # Увеличиваем количество пар на количество элементов с таким остатком,
    # с которым мы составили пару
    for j in range(k):
        v[(j + ost2) % k] += t[j]

    # Вычисляем остаток для пары в сумму к нашему числу для образования тройки
    ost3 = (k - (a[i] % k)) % k
    # Увеличиваем счётчик на количество пар с таким остатком
    cnt += v[ost3]

print(cnt)

Решение 1. Неэффективное

f = open("27-A.txt")
n = int(f.readline())
a = []
for i in range(n):
    a.append(int(f.readline()))
k = 0
for i in range(n):
    for j in range(i + 1, n):
        for l in range(j + 1, n):
            if (a[i] + a[j] + a[l]) % 10 == 0:
                k = max(k, a[i] + a[j] + a[l])
print(k)

 

Решение 2. Эффективное. Динамика

f = open(’16.txt’)
n = int(f.readline())
a = [int(i) for i in f]
k = 10
# Список из максимальных чисел с определенным остатком от деления
t = [-1] * k
# Список из пар с максимальными суммами с определенным остатком
v = [[-1, -1] for i in range(k)]
mx = -1
for i in range(2, len(a)):
    # Обрабатываем элемент на расстоянии 2 от текущего (через один слева)
    ost1 = a[i - 2] % k
    # Если он больше прошлого с таким остатком - обновляем список
    t[ost1] = max(t[ost1], a[i - 2])

    # Обрабатываем средний элемент - на расстоянии 1 от текущего (слева)
    ost2 = a[i - 1] % k
    # Для каждого из максимальных первых элементов (для каждого остатка)
    # создаём новые суммы с новым средним элементом и обновляем
    # эти суммы в списке v, если они получились больше прошлых
    for j in range(k):
        if t[j] > -1:
            sm_pair = t[j] + a[i - 1]
            if sm_pair > sum(v[(j + ost2) % k]):
                v[(j + ost2) % k] = [t[j], a[i - 1]]

    # Вычисляем остаток для пары в сумму к нашему числу
    ost3 = (k - (a[i] % k)) % k
    # Если уже нашлось число с таким остатком - считаем и обновляем максимум
    if sum(v[ost3]) > -1:
        sm = a[i] + sum(v[ost3])
        if sm > mx:
            mx = sm

print(mx)

Переборное решение:

f = open(’17_A.txt’)

n = int(f.readline())

nums = [int(i) for i in f]

cnt = 0

for i in range(n):
    for j in range(i + 1, n):
        if (nums[i] + nums[j]) % 10 != 0:
            cnt += 1

print(cnt)

Эффективное решение:

f = open(’27B.txt’)
n = int(f.readline())
ans = 0
# Количества чисел с определенными остатками от деления на 10
kr = [0]*10

for i in range(n):
    x = int(f.readline())
    # Пробуем ставить x по очереди ко всем остаткам от деления на 10
    for j in range(10):
     # Если сумма x с остатком не делится на 10 - увеличиваем счётчик
        if (x + j) % 10 != 0:
            ans += kr[j]
    # Увеличиваем количество чисел с определенным остатком
    kr[x % 10] += 1

print(ans)

Переборное решение:

f = open(’18_A.txt’)

n = int(f.readline())

nums = [int(i) for i in f]

cnt = 0

for i in range(n):
    for j in range(i + 1, n):
        if (nums[i] + nums[j]) % 50 != 0:
            cnt += 1

print(cnt)

Эффективное решение:

f = open(’27B.txt’)
n = int(f.readline())
ans = 0
# Количества чисел с определенными остаткми от деления на 50
kr = [0]*50

for i in range(n):
    x = int(f.readline())
    # Если x в сумме с остатком не будет делиться на 50,
    # значит со всеми числами с таким остатком он образует пары,
    # чья сумма не делится на 50
    for j in range(50):
        if (x + j) % 50 != 0:
            ans += kr[j]
    # Увеличиваем количество чисел с этим остатком
    kr[x % 50] += 1

print(ans)

Идея эффективного решения:

Идея решения заключается в том, чтобы под каждым остатком при делении на 7 собрать максимальное число с той целью, чтобы в итоге мы могли получить максимальную сумму кратную 7. Сумма пары кратна 7 в том случае, когда сумма остатков при делении на 7 пары чисел кратна 7. Считывая одно число с определенным остатком при делении на 7 мы должны подобрать в пару ему такое число, чтобы в итоге их пара была кратна 7. Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 7, а x - первое число пары.

#переборный алгоритм:
f = open(’1_A.txt’) #открываем файл.
n = int(f.readline()) #считываем первое число - количество чисел в файле.
a = [] #cписок, в котором у нас будут находиться все числа файла.
for i in range(n): #проход по файлу.
    a.append(int(f.readline())) #добавление текущего числа в список.

maxi = 0 #максимальная сумма пары.
for i in range(0,len(a)-1): #перебор для первого числа пары.
    for j in range(i+1,len(a)): #перебор для второго числа пары.
        if (a[i]+a[j]) % 7 == 0: #проверка по условию.
            maxi = max(maxi, a[i]+a[j]) # записываем максимальную сумму пары.
print(maxi) #вывод ответа.

#эффективный алгоритм:
file = open(’1_B__48rmd.txt’) #открываем файл.
n = int(file.readline()) #считываем первое число - количество чисел в файле.
div = 7 #число, на которое нацело должна делиться сумма пары.
mx = [0] * div #список, в котором под каждым индексом (под каждым остатком) записано максимальное число данного остатка.
mx_sum = 0 #максимальная сумма пары
for i in range(n): #проход по всему файлу
    x = int(file.readline()) #считываем текущее число
    need_ost = (div - x % div) % div #определяем необходимый остаток второго числа при делении на 7 для того чтобы сумма пары делилась нацело
    mx_sum = max(mx_sum,x+mx[need_ost]) #записываем максимальную сумму пары
    mx[x % div] = max(mx[x % div],x) #записываем максимальное число под индексом равным его остатку при делении на 7, сравниваем между текущим число и тем, что было в этой ячейке ранее
print(mx_sum) #вывод ответа

Неэффективный алгоритм:

file = open(’27B.txt’)
n = int(file.readline())
arr = [int(_) for _ in file]
ans = 0
for i in range(n):
    for j in range(i + 1, n):
        if arr[i] + arr[j] <= 2678 and arr[i] > arr[j]:
            ans += 1
print(ans)

Эффективный алгоритм:

file = open(’27B.txt’)
n = int(file.readline())
arr = [int(_) for _ in file]
# Список с количествами чисел от 0 до 2678
arr_summ = [0] * 2679
ans = 0
for i in range(n):
# Если число X не больше 2678, его можно поставить в пару с
    # любым числом от 0 до (2678 - X) включительно
    if arr[i] <= 2678:
     # Увеличиваем количество пар на сумму количеств подходящих чисел
        ans += sum(arr_summ[arr[i] + 1:2679 - arr[i]])
        arr_summ[arr[i]] += 1
print(ans)

Переборное решение:

f = open(’19_A.txt’)

n = int(f.readline())

nums = [int(i) for i in f]

pair = [-10 ** 10] * 2

for i in range(n):
    for j in range(i + 1, n):
        if abs(nums[i] - nums[j]) % 2 == 0:
            if nums[i] % 17 == 0 or nums[j] % 17 == 0:
                if nums[i] + nums[j] > sum(pair):
                    pair = [nums[i], nums[j]]

print(*sorted(pair))

Эффективное решение:

# Индексы массивов - остатки от деления на 2
# Элементы массивов - максимальные числа с соответствующим остатком
kr17 = [0, 0]
nekr = [0, 0]

n = int(input())
ans = [0]

for i in range(n):
    x = int(input())
    # Если x кратен 17, ему в пару можно ставить и кратные и не кратные 17 числа
    if x % 17 == 0:
        if x + kr17[x % 2] > sum(ans):
            ans = [x, kr17[x % 2]]
        if x + nekr[x % 2] > sum(ans):
            ans = [x, nekr[x % 2]]

        kr17[x % 2] = max(kr17[x % 2], x)
    # Если же x не кратен 17, ему в пару  можно ставить только кратные 17 числа
    else:
        if x + kr17[x % 2] > sum(ans):
            ans = [x, kr17[x % 2]]
        nekr[x % 2] = max(nekr[x % 2], x)

print(ans)

Переборное решение:

f = open(’C:/27_A.txt’)
# Первое число — количество элементов
n = int(f.readline())
a = [int(i) for i in f]

mx = []
for i in range(len(a)):
    for j in range(i+1, len(a)):
        if (a[i] % 17 == 0 or a[j] % 17 == 0) and (a[i]-a[j]) % 2 != 0:
            if a[i]+a[j] > sum(mx):
                mx = [a[i], a[j]]
print(mx)

Эффективное решение:

f = open(’20.txt’)

n = int(f.readline())

# Список, где первый индекс - кратность числа 17-и (0 - не кратно, 1 - кратно),
# а второй индекс - остаток от деления на 2
nums = [[-10 ** 10] * 2 for _ in range(2)]

ans = [-10 ** 10] * 2

for i in range(n):
    x = int(f.readline())
    # Чтобы разность получилась нечетной, элементы должны
    # иметь разные остатки от деления на 2
    ost = int(x % 2 == 0)
    # Если x кратен 17, к нему в пару можно ставить числа и кратные и не кратные 17
    if x % 17 == 0:
        # Обновляем ответ, записывая в него пару с большей суммой элементов
        # Параметр key=sum позволяет функции max вычислять наибольший список исходя
        # из суммы его элементов
        ans = max(ans, [x, nums[0][ost]], [x, nums[1][ost]], key=sum)
        nums[1][x % 2] = max(x, nums[1][x % 2])
    # Если x не кратен 17, к нему в пару можно ставить только числа кратные 17
    else:
        ans = max(ans, [x, nums[1][ost]], key=sum)
        nums[0][x % 2] = max(x, nums[0][x % 2])

print(*sorted(ans))

Идея статического решения:

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

Идея динамического решения:

Идея решения заключается в том, чтобы под каждым остатком при делении на 34 собирать количество число с одинаковым остатком при делении на 34 с той целью, чтобы в итоге мы могли на каждой итерации получать итоговое количество пар на данный момент. Сумма пары кратна 34 в том случае, когда сумма остатков при делении на 34 пары чисел кратна 34. Считывая одно число с определенным остатком при делении на 34 мы должны подобрать в пару ему такое число, чтобы в итоге их пара была кратна 34. Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 34, а x - первое число пары.

#переборный алгоритм:
f = open(’1_A.txt’) #открываем файл.
n = int(f.readline()) #считываем первое число - количество чисел в файле.
a = [] #cписок, в котором у нас будут находиться все числа файла.
for i in range(n): #проход по файлу.
    a.append(int(f.readline())) #добавление текущего числа в список.

counter = 0 #итоговый счётчик пар.
for i in range(0,len(a)-1): #перебор для первого числа пары.
    for j in range(i+1,len(a)): #перебор для второго числа пары.
        if (a[i]+a[j]) % 34 == 0: #проверка по условию.
            counter += 1 #увеличиваем итоговый счётчик
print(counter) #вывод ответа.

#Статическое решение
file = open(’4_B__2l6y2.txt’) #открываем файл.
n = int(file.readline()) #считываем первое число - количество чисел в файле.
div = 34 #число, на которое нацело должна делиться сумма пары.
k = [0] * div #список, в котором под каждым индексом (под каждым остатком) будет записано количество чисел с таким остатком.
count = 0 #итоговое количество пар
for i in range(n): #проход по всему файлу
    x = int(file.readline()) #считываем текущее число
    k[x % div] += 1 #увеличиваем на 1 ячейку в списке k равную остатку текущего числа при делении на 34
for i in range(len(k)//2 + 1): #делаем проход до половины всевозможных остатков при делении на 34
    if i == 0 or (i == div//2 and div % 2 == 0): #если остаток 0 или равен половине делимого, при условии, что делимое - чётное число.
        count += k[i] * (k[i] - 1) // 2 #то мы можем составить пару из двух чисел кратных 34
    else: # в ином случае
        count += k[i] * k[len(k)-i] #составляем пару из двух разных остатков при делении на 34
print(count) #вывод ответа.

#Динамическое решение
file = open(’4_B__2l6y2.txt’) #открываем файл.
n = int(file.readline()) #считываем первое число - количество чисел в файле.
div = 34 #число, на которое нацело должна делиться сумма пары.
k = [0] * div #список, в котором под каждым индексом (под каждым остатком) будет записано количество чисел с таким остатком.
count = 0 #итоговое количество пар
for i in range(n): #проход по всему файлу
    x = int(file.readline()) #считываем текущее число
    need_ost = (div - x % div) % div #определяем необходимый остаток второго числа при делении на 34 для того чтобы сумма пары делилась нацело
    count += k[need_ost] #увеличиваем count на количество чисел с необходимым остатком для первого числа для получения суммы пары кратной 34
    k[x % div] += 1 #увеличиваем на 1 ячейку в списке k равную остатку текущего числа при делении на 34
print(count) # вывод ответа

Идея эффективного решения:

Идея решения заключается в том, чтобы под каждым остатком при делении на 7 собрать минимальное число с той целью, чтобы в итоге мы могли получить минимальную сумму кратную 7. Сумма пары кратна 7 в том случае, когда сумма остатков при делении на 7 пары чисел кратна 7. Считывая одно число с определенным остатком при делении на 7 мы должны подобрать в пару ему такое число, чтобы в итоге их пара была кратна 7. Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 7, а x - первое число пары.

#переборный алгоритм:
f = open(’27-9a__1vjmp.txt’) #открываем файл.
n = int(f.readline()) #считываем первое число - количество чисел в файле.
a = [] #cписок, в котором у нас будут находиться все числа файла.
for i in range(n): #проход по файлу.
    a.append(int(f.readline())) #добавление текущего числа в список.

mini = 10**10 #минимальная сумма пары.
for i in range(0,len(a)-1): #перебор для первого числа пары.
    for j in range(i+1,len(a)): #перебор для второго числа пары.
        if (a[i]+a[j]) % 7 == 0: #проверка по условию.
            mini = min(mini, a[i]+a[j]) # записываем минимальную сумму пары.
print(mini) #вывод ответа.

#эффективный алгоритм:
file = open(’27-9b__1vjmq.txt’) #открываем файл.
n = int(file.readline()) #считываем первое число - количество чисел в файле.
div = 7 #число, на которое нацело должна делиться сумма пары.
mn = [10**10] * div #список, в котором под каждым индексом (под каждым остатком) будет записано минимальное число данного остатка.
mn_sum = 10**10 #минимальная сумма пары
for i in range(n): #проход по всему файлу
    x = int(file.readline()) #считываем текущее число
    need_ost = (div - x % div) % div #определяем необходимый остаток второго числа при делении на 7 для того чтобы сумма пары делилась нацело
    mn_sum = min(mn_sum,x+mn[need_ost]) #записываем минимальную сумму пары
    mn[x % div] = min(mn[x % div],x) #записываем минимальное число под индексом равным его остатку при делении на 7, сравниваем между текущим число и тем, что было в этой ячейке ранее
print(mn_sum) #вывод ответа

Для А

from itertools import combinations # с помощью combinations из модуля itertools можно удобно брать пары чисел при этом не печатая два цикла
f = open(’27-11a.txt’)
mx = 0
n = int(f.readline())
a = [int(x) for x in f]#список всех чисел в файле
for w,x,y,z in combinations(a,4):#эта строчка заменяет 4 строчки циклов
    if (w+x+y+z) % 6 == 0:#если сумма чисел кратна 6,то она нам подходит
        mx = max(mx,w+x+y+z)#сравниваем с максимумом
print(mx)

Для Б

# Это решение основанно на одном простом свойстве делимости:
# сумма чисел кратна числу если сумма их остатков от деления на число кратно числу

# Считываем файл, сортируем по убыванию список всех чисел в файле,
# поскольку нас интересует максимальная сумма
a = sorted([int(x) for x in open(’27-11b.txt’)][1:])[::-1]
d = []  # список, в котором будут храниться подходящие нам числа
for j in range(6):  # перебор всевозможных остатков при делении на 6
    for x in a:
        # если остаток x от деления на 6 равен j,
        # то мы добавляем это число в список
        if x % 6 == j:
            d += [x]
        if len([x for x in d if x % 6 == j]) == 4:
            break
        # условием прерывания сбора подходящих нам чисел служит то,
        # что в списке есть 4 числа с одним и тем же остатком при делении на 6,
        # именно 4 потому что в задаче мы должны взять ровно 4 числа

mx = 0
for x in range(len(d) - 3):
    for y in range(x + 1, len(d) - 2):
        for z in range(y + 1, len(d) - 1):
            for w in range(z + 1, len(d)):
                # 4 цикла, с помощью которых мы будем рассматривать
                # все возможные четверки в нашем списке d
                if (d[x] + d[y] + d[z] + d[w]) % 6 == 0:
                    mx = max(mx, (d[x] + d[y] + d[z] + d[w]))
print(mx)

Идея эффективного решения:

Идея решения заключается в том, чтобы под каждым остатком при делении на 12 собрать максимальное число с той целью, чтобы в итоге мы могли получить максимальную сумму кратную 12. Сумма пары кратна 12 в том случае, когда сумма остатков при делении на 12 пары чисел кратна 12. Считывая одно число с определенным остатком при делении на 12 мы должны подобрать в пару ему такое число, чтобы в итоге их пара была кратна 12. Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 12, а x - первое число пары.

#переборный алгоритм:
f = open(’1_A.txt’) #открываем файл.
n = int(f.readline()) #считываем первое число - количество чисел в файле.
a = [] #cписок, в котором у нас будут находиться все числа файла.
for i in range(n): #проход по файлу.
    a.append(int(f.readline())) #добавление текущего числа в список.

maxi = 0 #максимальная сумма пары.
for i in range(0,len(a)-1): #перебор для первого числа пары.
    for j in range(i+1,len(a)): #перебор для второго числа пары.
        if (a[i]+a[j]) % 12 == 0: #проверка по условию.
            maxi = max(maxi, a[i]+a[j]) # записываем максимальную сумму пары.
print(maxi) #вывод ответа.

#эффективный алгоритм:
file = open(’1_B__48rmd.txt’) #открываем файл.
n = int(file.readline()) #считываем первое число - количество чисел в файле.
div = 12 #число, на которое нацело должна делиться сумма пары.
mx = [0] * div #список, в котором под каждым индексом (под каждым остатком) записано максимальное число данного остатка.
mx_sum = 0 #максимальная сумма пары
for i in range(n): #проход по всему файлу
    x = int(file.readline()) #считываем текущее число
    need_ost = (div - x % div) % div #определяем необходимый остаток второго числа при делении на 12 для того чтобы сумма пары делилась нацело
    mx_sum = max(mx_sum,x+mx[need_ost]) #записываем максимальную сумму пары
    mx[x % div] = max(mx[x % div],x) #записываем максимальное число под индексом равным его остатку при делении на 12, сравниваем между текущим число и тем, что было в этой ячейке ранее
print(mx_sum) #вывод ответа

Идея эффективного решения:

Идея решения заключается в том, чтобы под каждым остатком при делении на 7 собрать максимальное число с той целью, чтобы в итоге мы могли получить максимальную сумму кратную 7. Сумма пары кратна 7 в том случае, когда сумма остатков при делении на 7 пары чисел кратна 7. Считывая одно число с определенным остатком при делении на 7 мы должны подобрать в пару ему такое число, чтобы в итоге их пара была кратна 7. Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 7, а x - первое число пары.

#переборный алгоритм:
f = open(’1_A.txt’) #открываем файл.
n = int(f.readline()) #считываем первое число - количество чисел в файле.
a = [] #cписок, в котором у нас будут находиться все числа файла.
for i in range(n): #проход по файлу.
    a.append(int(f.readline())) #добавление текущего числа в список.

maxi = 0 #максимальная сумма пары.
for i in range(0,len(a)-1): #перебор для первого числа пары.
    for j in range(i+1,len(a)): #перебор для второго числа пары.
        if (a[i]+a[j]) % 7 == 0: #проверка по условию.
            maxi = max(maxi, a[i]+a[j]) # записываем максимальную сумму пары.
print(maxi) #вывод ответа.

#эффективный алгоритм:
file = open(’1_B__48rmd.txt’) #открываем файл.
n = int(file.readline()) #считываем первое число - количество чисел в файле.
div = 7 #число, на которое нацело должна делиться сумма пары.
mx = [0] * div #список, в котором под каждым индексом (под каждым остатком) записано максимальное число данного остатка.
mx_sum = 0 #максимальная сумма пары
for i in range(n): #проход по всему файлу
    x = int(file.readline()) #считываем текущее число
    need_ost = (div - x % div) % div #определяем необходимый остаток второго числа при делении на 7 для того чтобы сумма пары делилась нацело
    mx_sum = max(mx_sum,x+mx[need_ost]) #записываем максимальную сумму пары
    mx[x % div] = max(mx[x % div],x) #записываем максимальное число под индексом равным его остатку при делении на 7, сравниваем между текущим число и тем, что было в этой ячейке ранее
print(mx_sum) #вывод ответа

f = open(’D:/27B__1vpyj.txt’) #для ответа на A нужно подключить файл 27A.txt
n = int(f.readline())
a = []
for i in range(n):
    a.append(int(f.readline()))

mx = [0]*3
for i in range(n):
    t = [[mx[0], mx[1], a[i]], [mx[0], a[i], mx[2]], [a[i], mx[1], mx[2]]]
    for j in t:
        if sum(j) > sum(mx):
            if len(set([j[0] % 17, j[1] % 17, j[2] % 17])) >= 2:
                mx = j[:]
print(sum(mx))

Переборное решение:

f = open(’21_A.txt’)

n = int(f.readline())

nums = [int(i) for i in f]

pair = [-10 ** 10] * 2

for i in range(n):
    for j in range(i + 1, n):
        if abs(nums[i] - nums[j]) % 2 == 0:
            if nums[i] % 16 == 0 or nums[j] % 16 == 0:
                if nums[i] + nums[j] > sum(pair):
                    pair = [nums[i], nums[j]]

print(*sorted(pair))

Эффективное решение:

f = open(’21.txt’)

n = int(f.readline())

# Список, где первый индекс - кратность числа 16-и (0 - не кратно, 1 - кратно),
# а второй индекс - остаток от деления на 2
nums = [[-10 ** 10] * 2 for _ in range(2)]

ans = [-10 ** 10] * 2

for i in range(n):
    x = int(f.readline())
    # Чтобы разность получилась четной, элементы должны
    # иметь одинаковые остатки от деления на 2
    ost = x % 2
    # Если x кратен 16, к нему в пару можно ставить числа и кратные и не кратные 16
    if x % 16 == 0:
        # Обновляем ответ, записывая в него пару с большей суммой элементов
        # Параметр key=sum позволяет функции max вычислять наибольший список исходя
        # из суммы его элементов
        ans = max(ans, [x, nums[0][ost]], [x, nums[1][ost]], key=sum)
        nums[1][ost] = max(x, nums[1][ost])
    # Если x не кратен 16, к нему в пару можно ставить только числа кратные 16
    else:
        ans = max(ans, [x, nums[1][ost]], key=sum)
        nums[0][ost] = max(x, nums[0][ost])

print(*sorted(ans))

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

    f = open("27A_5.txt")
n = int(f.readline())
sum0 = 0
sum1 = 0
min1 = 20001
min2 = 20001
min3 = 20001
for i in f:
    x, y = i.split()
    x = int(x)
    y = int(y)
    if x % 2 == 1:
        if x > y:
            sum1 = sum1 + x
            sum0 = sum0 + y
            if (x % 2 == 1) and (y % 2 == 1) and ((x + y) < min1):
                    min1 = x + y
            if (x % 2 == 0) and (y % 2 == 1) and ((x + y) < min2):
                    min2 = x + y
            if (x % 2 == 1) and (y % 2 == 0) and ((x + y) < min3):
                    min3 = x + y
        else:
            sum1 = sum1 + y
            sum0 = sum0 + x
            if (x % 2 == 1) and (y % 2 == 1) and ((x + y) < min1):
                min1 = x + y
            if (y % 2 == 0) and (x % 2 == 1) and ((x + y) < min2):
                    min2 = x + y
            if (y % 2 == 1) and (x % 2 == 0) and ((x + y) < min3):
                    min3 = x + y
if (sum0 % 2 == 0) and (sum1 % 2 == 1):
    print(sum0 + sum1)
elif (sum0 % 2 == 1) and (sum1 % 2 == 0):
    if min1 < min2 + min3:
        print(sum0 + sum1 - min1)
    else:
        print(sum0 + sum1 - min2 - min3)
elif (sum0 % 2 == 1) and (sum1 % 2 == 1):
    if min2 < min3 + min1:
        print(sum0 + sum1 - min2)
    else:
        print(sum0 + sum1 - min3 - min1)
                                                                                                  
                                                                                                  
elif (sum0 % 2 == 0) and (sum1 % 2 == 0):
    if min3 < min2 + min1:
        print(sum0 + sum1 - min3)
    else:
        print(sum0 + sum1 - min2 - min1)

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

f = open("27A_6.txt")
n = int(f.readline())
sum0 = 0
sum1 = 0
min1 = 20001
min2 = 20001
min3 = 20001
for i in f:
    x, y = i.split()
    x = int(x)
    y = int(y)
    if y % 2 == 1:
        if x > y:
            sum1 = sum1 + y
            sum0 = sum0 + x
            if (y % 2 == 1) and (x % 2 == 1) and ((x + y) < min1):
                    min1 = x + y
            if (y % 2 == 0) and (x % 2 == 1) and ((x + y) < min2):
                    min2 = x + y
            if (y % 2 == 1) and (x % 2 == 0) and ((x + y) < min3):
                    min3 = x + y
        else:
            sum1 = sum1 + x
            sum0 = sum0 + y
            if (y % 2 == 1) and (x % 2 == 1) and ((x + y) < min1):
                min1 = x + y
            if (x % 2 == 0) and (y % 2 == 1) and ((x + y) < min2):
                    min2 = x + y
            if (x % 2 == 1) and (y % 2 == 0) and ((x + y) < min3):
                    min3 = x + y
if (sum0 % 2 == 0) and (sum1 % 2 == 1):
    print(sum0 + sum1)
elif (sum0 % 2 == 1) and (sum1 % 2 == 0):
    if min1 < min2 + min3:
        print(sum0 + sum1 - min1)
    else:
        print(sum0 + sum1 - min2 - min3)
elif (sum0 % 2 == 1) and (sum1 % 2 == 1):
    if min2 < min3 + min1:
        print(sum0 + sum1 - min2)
    else:
        print(sum0 + sum1 - min3 - min1)
                                                                                                  
                                                                                                  
elif (sum0 % 2 == 0) and (sum1 % 2 == 0):
    if min3 < min2 + min1:
        print(sum0 + sum1 - min3)
    else:
        print(sum0 + sum1 - min2 - min1)

Идея статического решения:

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

Идея динамического решения:

Идея решения заключается в том, чтобы под каждым остатком при делении на 2 собирать количество число с одинаковым остатком при делении на 2 с той целью, чтобы в итоге мы могли на каждой итерации получать итоговое количество пар на данный момент. Сумма пары кратна 2 в том случае, когда сумма остатков при делении на 2 пары чисел кратна 2. Считывая одно число с определенным остатком при делении на 2 мы должны подобрать в пару ему такое число, чтобы в итоге их пара была кратна 2. Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 2, а x - первое число пары.

#переборный алгоритм:
f = open(’1_A.txt’) #открываем файл.
n = int(f.readline()) #считываем первое число - количество чисел в файле.
a = [] #cписок, в котором у нас будут находиться все числа файла.
for i in range(n): #проход по файлу.
    a.append(int(f.readline())) #добавление текущего числа в список.

counter = 0 #итоговый счётчик пар.
for i in range(0,len(a)-1): #перебор для первого числа пары.
    for j in range(i+1,len(a)): #перебор для второго числа пары.
        if (a[i]+a[j]) % 2 == 0: #проверка по условию.
            counter += 1 #увеличиваем итоговый счётчик
print(counter) #вывод ответа.

#Статическое решение
file = open(’27B_7__1vq0q.txt’) #открываем файл.
n = int(file.readline()) #считываем первое число - количество чисел в файле.
div = 2 #число, на которое нацело должна делиться сумма пары.
k = [0] * div #список, в котором под каждым индексом (под каждым остатком) будет записано количество чисел с таким остатком.
count = 0 #итоговое количество пар
for i in range(n): #проход по всему файлу
    x = int(file.readline()) #считываем текущее число
    k[x % div] += 1 #увеличиваем на 1 ячейку в списке k равную остатку текущего числа при делении на 2
count = (k[0] * (k[0]-1)//2) + (k[1] * (k[1]-1)//2) # записываем итоговое выражение для подсчёта количества пар
print(count) #вывод ответа.

#Динамическое решение
file = open(’27B_7__1vq0q.txt’) #открываем файл.
n = int(file.readline()) #считываем первое число - количество чисел в файле.
div = 2 #число, на которое нацело должна делиться сумма пары.
k = [0] * div #список, в котором под каждым индексом (под каждым остатком) будет записано количество чисел с таким остатком.
count = 0 #итоговое количество пар
for i in range(n): #проход по всему файлу
    x = int(file.readline()) #считываем текущее число
    need_ost = (div - x % div) % div #определяем необходимый остаток второго числа при делении на 2 для того чтобы сумма пары делилась нацело
    count += k[need_ost] #увеличиваем count на количество чисел с необходимым остатком для первого числа для получения суммы пары кратной 2
    k[x % div] += 1 #увеличиваем на 1 ячейку в списке k равную остатку текущего числа при делении на 2
print(count) # вывод ответа