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

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

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

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

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

f = open(’27A_5.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]) % 172 == 0 and (arr[i] < 90 or arr[j] < 90):
            mx = arr[i] + arr[j]
print(mx)

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

# Хотя бы одно число должно быть меньше 90, а также a_i < a_j
# Значит если a_i будет больше 90, то и a_j будет больше 90
# Поэтому в список a будем сохранять только числа, которые меньше 90
f = open(’27B_5.txt’)
n = int(f.readline())
d = 172
mx = -1
a = [-10 ** 10] * d
for i in range(n):
    t = int(f.readline())
    ost = (d - (t % d)) % d
    if a[ost] + t > mx and a[ost] < t:
        mx = a[ost] + t
    if t > a[t % d] and t < 90:
        a[t % d] = t
print(mx)

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

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

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

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

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

#Переборный алгоритм
f = open(’27A_7__3sht1.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]) % 411 == 0: # проверка по условию
            mx = arr[i] + arr[j] # обновляем максимальную сумму
print(mx) # вывод ответа

#Эффективный алгоритм
file = open(’27B_7__3sht2.txt’) #открытие файла
n = int(file.readline()) #считываем первое число - количество чисел в файле
div = 411 # наш делитель
mx = [0]*div # список, в котором будет храниться максимальное число под каждым остатком при делении на 411
mx_sum = 0 # максимальная сумма пары
for i in range(n): # проход по всему файлу
    x = int(file.readline()) # считываем текущее число
    need_ost = (div - x % div) % div # определяем необходимый остаток для второго числа чтобы в итоге получилась пара кратная 411
    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) # вывод ответа

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

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

#Переборный алгоритм
f = open(’27A_8.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]) % 89 == 0 and arr[i] < 666 and arr[j] < 666: #проверка по условию.
            mx = arr[i] + arr[j] #обновляем максимальную сумму
print(mx) #вывод ответа.

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

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

f = open(’27A_9.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]) % 57 == 0 and (arr[i] > 169 or arr[j] > 169):
            mn = arr[i] + arr[j]
print(mn)

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

# Хотя бы одно число должно быть больше 169, а также a_i > a_j
# Значит если a_i будет меньше 169, то и a_j будет меньше
# Поэтому в список a будем сохранять только числа, которые больше 169
f = open(’7.txt’)
n = int(f.readline())
d = 57
mn = 10 ** 10
a = [10 ** 10] * d
for i in range(n):
    t = int(f.readline())
    ost = (d - (t % d)) % d
    if a[ost] + t < mn and a[ost] > t:
        mn = a[ost] + t
    if t < a[t % d] and t > 169:
        a[t % d] = t
print(mn)

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

Идея решения заключается в том, чтобы под каждым остатком при делении на 586 собрать минимальное число для того чтобы в итоге получить минимальную сумму пары. Сумма пары кратна 586 в том случае, когда сумма остатков при делении на 586 пары чисел кратна 586. Проходясь по файлу, мы будем искать для текущего числа подбирать такое число, с которым в сумме с ним будет кратна 586. Число, которое мы считываем на текущей итерации всегда будет вторым в паре (j индекс). Числа, которые уже записаны в списке - всегда будут первыми в паре(i индекс). Не трудно определить какой остаток нужен для второго числа при делении, зная, остаток первого числа, для этого можно использовать формулу: (D - x % D) % D , где D - это 586, а 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 = 586 # наш делитель
mn = [10**10]*div # список, в котором будет храниться минимальное число под каждым остатком при делении на 586
mn_sum = 10**10 # минимальная сумма пары
for i in range(n): # проход по всему файлу
    x = int(file.readline()) # считываем текущее число
    need_ost = (div - x % div) % div # определяем необходимый остаток для второго числа чтобы в итоге получилась пара кратная 586
    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) # вывод ответа