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

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

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

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

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

#переборный алгоритм:
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]) % 98 == 0: #проверка по условию.
            counter += 1 # увеличение счётчика пар.
print(counter)#вывод ответа.

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

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

a = [ 38, -29, 489, 292, -348, 244, -289, 1, 43, -26, 230, 101]
mi = 199999999
for i in range(12):
    for j in range(i+1, 12):
        for k in range(j+1, 12):
            if a[i] + a[j] + a[k] < mi and (a[i] + a[j] + a[k]) % 3 == 0:
                mi = a[i] + a[j] + a[k]
print(mi)

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

Идея решения заключается в том, чтобы под каждым остатком при делении на 11 собрать максимальное число с той целью, чтобы в итоге мы могли получить максимальную сумму кратную 11. Сумма пары кратна 11 в том случае, когда сумма остатков при делении на 11 пары чисел кратна 11. Считывая одно число с определенным остатком при делении на 11 мы должны подобрать в пару ему такое число, чтобы в итоге их пара была кратна 11. Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 11, а 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]) % 11 == 0: #проверка по условию.
            maxi = max(maxi, a[i]+a[j]) # записываем максимальную сумму пары.
print(maxi) #вывод ответа.

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

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

f = open(’3_A.txt’)
n = int(f.readline())
a = []
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]) % 9 != 0:
            maxi = max(maxi, a[i]+a[j])
print(maxi)

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

f = open(’3_B__2kc32.txt’)

n = int(f.readline())
mx = -1

# Список максимальных чисел с определенными остатками от деления на 9
osts = [-999_999] * 9

for i in range(n):
    # Считываем очередное число из файла
    x = int(f.readline())
    for j in range(9):
        # Проверяем на кратность 9 сумму нового числа
        # и максимального числа с определенным остатком
        if (x + osts[j]) % 9 != 0:
            # Если сумма не кратна - обновляем максимум
            mx = max(mx, x + osts[j])
    # Обновляем число с определенным остатком от деления на 9
    # Если новое число больше предыдущего - сохраняем его в список
    osts[x % 9] = max(osts[x % 9], x)

print(mx)

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

f = open(’5_A.txt’)
n = int(f.readline())
a = []
for i in range(n):
    a.append(int(f.readline()))

maxi = 0
for i in range(0,len(a)-2):
    for j in range(i+1,len(a)-1):
        for k in range(j+1,len(a)):
            if (a[i]+a[j]+a[k]) % 7 == 0:
                maxi = max(maxi, a[i]+a[j]+a[k])
print(max)

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

f = open(’5_B__2kc2q.txt’)
n = int(f.readline())
a = [int(i) for i in f]
k = 7
# Список из максимальных чисел с определенным остатком от деления
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)

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

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

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

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

#Переборный алгоритм:
f = open(’3_A.txt’) #открываем файл.
n = int(f.readline()) #считываем первое число - количество чисел в файле.

counter = 0 #итоговое количество пар
a = [] #cписок, в котором у нас будут находиться все числа файла.
for i in range(n): #проход по файлу.
    a += [int(f.readline())] #добавление текущего числа в список.

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

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

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

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

f = open(’5_A.txt’)
n = int(f.readline())

counter = 0
a = []
for i in range(n):
    a += [int(f.readline())]

for i in range(0,len(a) - 1):
    for j in range(i+1,len(a)):
        if (a[i]+a[j]) % 21 != 0:
            counter += 1
print(counter)

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

f = open(’3.txt’)

n = int(f.readline())
cnt = 0

# Список с количествами чисел с определенными остатками от деления на 21
osts = [0] * 21

for i in range(n):
    # Считываем очередное число из файла
    x = int(f.readline())
    for j in range(21):
        # Проверяем на кратность 21 сумму нового числа и остатка
        if (x + j) % 21 != 0:
            # Если сумма не кратна - увеличиваем счётчик количества пар
            cnt += osts[j]

    # Увеличиваем количество чисел с определенным остатком
    osts[x % 21] += 1

print(cnt)

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

#переборный алгоритм:
f = open(’6_A.txt’)
n = int(f.readline())

counter = 0
a = []
for i in range(n):
    a += [int(f.readline())]

for i in range(0,len(a) - 1):
    for j in range(i+1,len(a)):
        if (a[i]+a[j]) % 12 != 0:
            counter += 1
print(counter)

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

f = open(’4.txt’)

n = int(f.readline())
cnt = 0

# Список с количествами чисел с определенными остатками от деления на 12
osts = [0] * 12

for i in range(n):
    # Считываем очередное число из файла
    x = int(f.readline())
    for j in range(12):
        # Проверяем на кратность 12 сумму нового числа и остатка
        if (x + j) % 12 != 0:
            # Если сумма не кратна - увеличиваем счётчик количества пар
            cnt += osts[j]

    # Увеличиваем количество чисел с определенным остатком
    osts[x % 12] += 1

print(cnt)

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

f = open(’5_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]) % 9 != 0:
            cnt += 1

print(cnt)

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

f = open(’5_B.txt’)

n = int(f.readline())
cnt = 0

# Список с количествами чисел с определенными остатками от деления на 9
osts = [0] * 9

for i in range(n):
    # Считываем очередное число из файла
    x = int(f.readline())
    for j in range(9):
        # Проверяем на кратность 9 сумму нового числа и остатка
        if (x + j) % 9 != 0:
            # Если сумма не кратна - увеличиваем счётчик количества пар
            cnt += osts[j]

    # Увеличиваем количество чисел с определенным остатком
    osts[x % 9] += 1

print(cnt)

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

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

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

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

#переборный алгоритм:
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]) % 177 == 0: #проверка по условию.
            counter += 1 # увеличение счётчика пар.
print(counter)#вывод ответа.

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

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

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

Идея решения заключается в том, чтобы под каждым остатком при делении на 191 собрать максимальное число с той целью, чтобы в итоге мы могли получить максимальную сумму кратную 191. Сумма пары кратна 191 в том случае, когда сумма остатков при делении на 191 пары чисел кратна 191. Считывая одно число с определенным остатком при делении на 191 мы должны подобрать в пару ему такое число, чтобы в итоге их пара была кратна 191. Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 191, а 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]) % 191 == 0: #проверка по условию.
            maxi = max(maxi, a[i]+a[j]) # записываем максимальную сумму пары.
print(maxi) #вывод ответа.

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

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

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

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

Идея решения заключается в том, чтобы под каждым остатком при делении на 93 собирать количество число с одинаковым остатком при делении на 93 с той целью, чтобы в итоге мы могли на каждой итерации получать итоговое количество пар на данный момент. Сумма пары кратна 93 в том случае, когда сумма остатков при делении на 93 пары чисел кратна 93 . Считывая одно число с определенным остатком при делении на 93 мы должны подобрать в пару ему такое число, чтобы в итоге их пара была кратна 93. Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 93, а 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]) % 93 == 0: #проверка по условию.
            counter += 1 # увеличение счётчика пар.
print(counter) #вывод ответа.

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

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

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

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

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

Идея решения заключается в том, чтобы под каждым остатком при делении на 375 собирать количество число с одинаковым остатком при делении на 375 с той целью, чтобы в итоге мы могли на каждой итерации получать итоговое количество пар на данный момент. Сумма пары кратна 375 в том случае, когда сумма остатков при делении на 375 пары чисел кратна 375. Считывая одно число с определенным остатком при делении на 375 мы должны подобрать в пару ему такое число, чтобы в итоге их пара была кратна 375. Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 375, а 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]) % 375 == 0: #проверка по условию.
            counter += 1 # увеличение счётчика пар
print(counter) #вывод ответа.

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

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

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

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

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

Идея решения заключается в том, чтобы под каждым остатком при делении на 891 собирать количество число с одинаковым остатком при делении на 891 с той целью, чтобы в итоге мы могли на каждой итерации получать итоговое количество пар на данный момент. Сумма пары кратна 891 в том случае, когда сумма остатков при делении на 891 пары чисел кратна 891. Считывая одно число с определенным остатком при делении на 891 мы должны подобрать в пару ему такое число, чтобы в итоге их пара была кратна 891. Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 891, а 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]) % 891 == 0: #проверка по условию.
            counter += 1 #увеличиваем итоговый счётчик
print(counter) #вывод ответа.

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

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

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

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

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

Идея решения заключается в том, чтобы под каждым остатком при делении на 221 собирать количество число с одинаковым остатком при делении на 221 с той целью, чтобы в итоге мы могли на каждой итерации получать итоговое количество пар на данный момент. Сумма пары кратна 221 в том случае, когда сумма остатков при делении на 221 пары чисел кратна 221 . Считывая одно число с определенным остатком при делении на 221 мы должны подобрать в пару ему такое число, чтобы в итоге их пара была кратна 221. Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 221, а 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]) % 221 == 0: #проверка по условию.
            counter += 1 #увеличиваем итоговый счётчик
print(counter) #вывод ответа.

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

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

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

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

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

Идея решения заключается в том, чтобы под каждым остатком при делении на 457 собирать количество число с одинаковым остатком при делении на 457 с той целью, чтобы в итоге мы могли на каждой итерации получать итоговое количество пар на данный момент. Сумма пары кратна 457 в том случае, когда сумма остатков при делении на 457 пары чисел кратна 457. Считывая одно число с определенным остатком при делении на 457 мы должны подобрать в пару ему такое число, чтобы в итоге их пара была кратна 457. Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 457, а 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]) % 457 == 0: #проверка по условию.
            counter += 1 #увеличиваем итоговый счётчик
print(counter) #вывод ответа.

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

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

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

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

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

Идея решения заключается в том, чтобы под каждым остатком при делении на 199 собирать количество число с одинаковым остатком при делении на 199 с той целью, чтобы в итоге мы могли на каждой итерации получать итоговое количество пар на данный момент. Сумма пары кратна 199 в том случае, когда сумма остатков при делении на 199 пары чисел кратна 199. Считывая одно число с определенным остатком при делении на 199 мы должны подобрать в пару ему такое число, чтобы в итоге их пара была кратна 199. Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 199, а 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]) % 199 == 0: #проверка по условию.
            counter += 1 #увеличиваем итоговый счётчик
print(counter) #вывод ответа.

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

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

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

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

#Переборный алгоритм
f = open(’27A_1.txt’) #открытие файла
n = int(f.readline()) #считываем первое число - количество чисел в файле
arr = list(map(int, f.read().split())) #записываем все числа файла в список
mx = -1 # максимальная сумма пары
for i in range(n-1): # перебор для первого числа пары
    for j in range(i+1, n): # перебор для второго числа пары
        if arr[i] < arr[j] and arr[i] + arr[j] > mx and (arr[i] + arr[j]) % 139 == 0: # проверка по условию
            mx = arr[i] + arr[j] # обновляем максимальную сумму
print(mx) # вывод ответа

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

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

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

f = open(’27A_2.txt’) #открытие файла
n = int(f.readline()) #считываем первое число - количество чисел в файле
arr = list(map(int, f.read().split())) #записываем все числа файла в список
mn = 10000000 минимальная сумма пары
for i in range(n-1): # перебор для первого числа пары
    for j in range(i+1, n): # перебор для второго числа пары
        if arr[i] < arr[j] and arr[i] + arr[j] < mn and (arr[i] + arr[j]) % 224 == 0: # проверка по условию
            mn = arr[i] + arr[j] # обновляем минимальную сумму
print(mn) # вывод ответа

Решение для файла B:

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

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

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

f = open(’27A_3.txt’) #открытие файла
n = int(f.readline()) #считываем первое число - количество чисел в файле
arr = list(map(int, f.read().split())) #список, в котором будут записаны все числа файла
mn = 10000000 #минимальная сумма пары
for i in range(n-1): #перебор для первого числа пары
    for j in range(i+1, n):#перебор для второго числа пары
        if arr[i] > arr[j] and arr[i] + arr[j] < mn and (arr[i] + arr[j]) % 63 == 0 and arr[i] > 45 and arr[j] > 45: #проверка по условию
            mn = arr[i] + arr[j] # обновление минимальной суммы
print(mn) #вывод ответа.

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