17.01 Обработка пар элементов последовательности

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

Напишем программу, которая перебирает все пары различных элементов из файла. Для каждой пары проверяем, что сумма элементов кратна 60 и при этом хотя бы один из элементов делится на 40. Если пара подходит под условия, увеличиваем счётчик таких пар и обновляем максимальную сумму, если текущая сумма больше сохранённой. После проверки всех пар выводим искомое количество и максимальную сумму подряд без пробелов или разделителей.

# Открываем файл и считываем последовательность чисел в список
f = open("17.txt")
a = [int(i) for i in f]

c = 0                  # Счётчик подходящих пар
mx = -10**9            # Переменная для хранения максимальной суммы (начинаем с очень маленького числа)

# Перебираем все пары различных элементов последовательности
for i in range(len(a) - 1):
    for j in range(i + 1, len(a)):
        # Проверяем, что сумма пары кратна 60 и хотя бы один элемент делится на 40
        if ((a[i] + a[j]) % 60 == 0) and (a[i] % 40 == 0 or a[j] % 40 == 0):
            c += 1                      # Увеличиваем счётчик
            mx = max(mx, a[i] + a[j])  # Обновляем максимальную сумму, если нужно

# Выводим результат без пробелов и разделителей
print(c, mx)

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

Напишем программу, которая перебирает все пары различных элементов последовательности из файла. Для каждой пары проверяем, что остатки от деления этих элементов на 17 разные (то есть они дают разные значения при делении на 17). Если условие выполняется, увеличиваем счётчик подходящих пар и обновляем максимальную сумму, если текущая сумма пары больше сохранённой. В конце выводим количество таких пар и максимальную сумму, разделённые пробелом.

# Открываем файл и считываем последовательность чисел в список
f = open("17.txt")
a = [int(i) for i in f]

c = 0                  # Счётчик пар с разными остатками от деления на 17
mx = -10**9            # Переменная для хранения максимальной суммы (начинаем с очень маленького числа)

# Перебираем все пары различных элементов
for i in range(len(a) - 1):
    for j in range(i + 1, len(a)):
        # Проверяем, что остатки от деления на 17 у пары разные
        if (a[i] % 17) != (a[j] % 17):
            c += 1                      # Увеличиваем счётчик подходящих пар
            mx = max(mx, a[i] + a[j])  # Обновляем максимальную сумму, если нужно

# Выводим количество подходящих пар и максимальную сумму через пробел
print(c, mx)

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

Напишем программу, которая будет проходить по всем парам подряд идущих чисел из файла и определять, сколько пар содержат хотя бы одно число, оканчивающееся на 17. Для проверки этого условия вычисляем остаток от деления абсолютного значения каждого числа на 100 и сравниваем его с 17. Также проверяем, делится ли сумма элементов пары на 2 без остатка, то есть сумма четная. Если обе проверки выполняются, увеличиваем счетчик и обновляем максимальную сумму подходящих пар. По окончании выводим количество таких пар и максимальную сумму.

# открываем файл и считываем числа в список
file = open("17.txt")
arr = [int(_) for _ in file]

counter = 0  # счетчик подходящих пар
max_summ = 0  # максимальная сумма таких пар

for i in range(len(arr) - 1):
    # проверяем, заканчивается ли хотя бы один элемент на 17 (остаток от деления на 100 равен 17)
    ends_with_17 = (abs(arr[i]) % 100 == 17) or (abs(arr[i + 1]) % 100 == 17)
    # проверяем, что сумма пары чётная
    even_sum = (arr[i] + arr[i + 1]) % 2 == 0

    if ends_with_17 and even_sum:
        counter += 1  # увеличиваем счетчик
        max_summ = max(max_summ, arr[i] + arr[i + 1])  # обновляем максимум суммы

print(counter, max_summ)

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

Напишем программу, которая перебирает все пары из двух подряд идущих элементов последовательности. Для каждой пары проверяем два условия: остаток от деления разности элементов на 2 должен быть равен 0 (то есть разность чётная), а также хотя бы один из элементов пары должен делиться на 13 без остатка. Чтобы проверить первое условие, берём остаток от деления разности пары на 2 и сравниваем с 0. Для второго условия проверяем остаток от деления каждого элемента на 13 и смотрим, что хотя бы у одного из них он равен 0. Если пара удовлетворяет обоим условиям, увеличиваем счётчик подходящих пар и обновляем минимальное произведение элементов среди таких пар. После обработки всех пар выводим общее количество и минимальное произведение.

# Открываем файл и считываем последовательность чисел в список
file = open("17.txt")
arr = [int(_) for _ in file]

counter = 0  # счётчик подходящих пар
min_prod = 10 ** 10  # инициализация минимального произведения очень большим числом

# Проходим по всем парам из двух подряд идущих элементов
for i in range(len(arr) - 1):
    # Проверяем, что остаток от деления разности элементов на 2 равен 0 (разность чётная)
    if (arr[i] - arr[i + 1]) % 2 == 0:
        # Проверяем, что хотя бы один элемент делится на 13 без остатка
        if arr[i] % 13 == 0 or arr[i + 1] % 13 == 0:
            counter += 1
            # Обновляем минимальное произведение среди подходящих пар
            min_prod = min(min_prod, arr[i] * arr[i + 1])

# Выводим количество подходящих пар и минимальное произведение
print(counter, min_prod)

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

Напишем программу, которая перебирает все пары из двух подряд идущих элементов последовательности. Для каждой пары проверяем, что хотя бы один элемент делится на 3, а сумма элементов кратна 5. Если пара подходит, увеличиваем счётчик подходящих пар и обновляем максимальную сумму таких пар. По окончании обработки выводим количество найденных пар и максимальную сумму элементов таких пар.

# Открываем файл и считываем последовательность чисел в список
file = open("17.txt")
arr = [int(_) for _ in file]

counter = 0  # счётчик подходящих пар
max_summ = -10 ** 10  # инициализация максимальной суммы минимальным значением

# Проходим по всем парам из двух подряд идущих элементов
for i in range(len(arr) - 1):
    # Проверяем, что хотя бы один элемент делится на 3 и сумма делится на 5
    if (arr[i] % 3 == 0 or arr[i + 1] % 3 == 0) and (arr[i] + arr[i + 1]) % 5 == 0:
        counter += 1
        max_summ = max(max_summ, arr[i] + arr[i + 1])

# Выводим количество подходящих пар и максимальную сумму
print(counter, max_summ)

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

Напишем программу, которая переберёт все пары различных элементов последовательности и отберёт те, у которых произведение элементов не кратно 34. Для этого мы пройдёмся по всем парам с разными индексами, проверяя остаток от деления произведения на 34. Если произведение не делится на 34 без остатка, считаем такую пару подходящей. При этом будем считать количество таких пар и отслеживать максимальную сумму элементов среди них. В конце выведем количество таких пар и максимальную сумму.

# Открываем файл и считываем числа в список
file = open("17.txt")
arr = [int(_) for _ in file]

counter = 0  # количество пар, у которых произведение не кратно 34
max_summ = -10 ** 10  # инициализация максимальной суммы очень маленьким числом

# Перебираем все пары различных элементов
for i in range(len(arr)):
    for j in range(i + 1, len(arr)):
        # Проверяем, что произведение не кратно 34
        if (arr[i] * arr[j]) % 34 != 0:
            counter += 1
            # Обновляем максимальную сумму, если текущая больше
            max_summ = max(max_summ, arr[i] + arr[j])

# Выводим количество таких пар и максимальную сумму элементов
print(counter, max_summ)

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

Напишем программу, которая будет проходить по всем парам подряд идущих чисел из файла и проверять, делится ли сумма элементов пары на 7 без остатка. Для этого для каждой пары будем вычислять сумму и брать остаток от деления на 7. Если остаток равен нулю, увеличиваем счётчик таких пар. По окончании работы программы выведем количество найденных пар.

file = open("17.txt") # Открыааем файл с числами
arr = [int(_) for _ in file]  # Считываем все числа из файла в список

counter = 0  # Счётчик пар, сумма которых кратна 7

for i in range(len(arr) - 1):
    # Проверяем, что сумма пары элементов делится на 7 без остатка
    if (arr[i] + arr[i + 1]) % 7 == 0:
        counter += 1  # Увеличиваем счётчик подходящих пар

print(counter)  # Выводим итоговое количество таких пар

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

Напишем программу, которая будет проверять все пары подряд идущих чисел из файла. Для каждой пары будем проверять два условия: первое — что хотя бы один из элементов делится на 7 без остатка, второе — что сумма элементов пары заканчивается на 19. Для проверки окончания суммы на 19 мы возьмём сумму элементов пары под модулем (т.к. в файле есть отрицательные числа) и сравним с 19. Если оба условия выполняются, увеличиваем счётчик подходящих пар и обновляем максимальную сумму, если текущая сумма больше найденной ранее. В конце выведем количество таких пар и максимальную сумму.

file = open("17.txt")
arr = [int(_) for _ in file]  # Читаем все числа из файла в список

counter = 0
max_summ = -10 ** 10  # Инициализируем максимальную сумму очень маленьким числом

for i in range(len(arr) - 1):
    # Проверяем, что сумма пары по модулю 100 равна 19 (значит сумма заканчивается на 19)
    if abs(arr[i] + arr[i + 1]) % 100 == 19:
        # Проверяем, что хотя бы один из элементов делится на 7
        if arr[i] % 7 == 0 or arr[i + 1] % 7 == 0:
            counter += 1
            # Обновляем максимальную сумму, если текущая сумма больше предыдущей максимальной
            max_summ = max(max_summ, arr[i] + arr[i + 1])

print(counter, max_summ)  # Выводим количество пар и максимальную сумму

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

Напишем программу, которая для каждой пары подряд идущих чисел проверит, либо оба числа состоят только из чётных цифр, либо оба — только из нечётных цифр. Для этого реализуем две функции: одна проверяет, все ли цифры числа чётные, другая — все ли цифры нечётные. Затем перебираем пары, для каждой проверяем эти условия. Если пара подходит, записываем сумму элементов в список. По окончании подсчитываем количество подходящих пар и находим минимальную сумму среди них, которые и выводим.

# Функция, которая проверяет, все ли цифры числа чётные
def even_digits(n):
    while n > 0:
        x = n % 10      # Получаем последнюю цифру числа
        if x % 2 == 1:  # Если цифра нечётная, значит число не состоит из только чётных цифр
            return False
        n //= 10        # Удаляем последнюю цифру и переходим к следующей
    return True         # Если все цифры оказались чётными, возвращаем True

# Функция, которая проверяет, все ли цифры числа нечётные
def odd_digits(n):
    while n > 0:
        x = n % 10      # Получаем последнюю цифру числа
        if x % 2 == 0:  # Если цифра чётная, значит число не состоит из только нечётных цифр
            return False
        n //= 10        # Удаляем последнюю цифру и переходим к следующей
    return True         # Если все цифры оказались нечётными, возвращаем True

# Открываем файл и считываем все числа в список
f = open("17.txt")
a = [int(i) for i in f]

ans = []
# Перебираем все пары подряд идущих элементов
for i in range(len(a) - 1):
    # Проверяем условие: либо оба числа состоят из чётных цифр, либо из нечётных
    if (even_digits(a[i]) and even_digits(a[i + 1])) or (odd_digits(a[i]) and odd_digits(a[i + 1])):
        ans.append(a[i] + a[i + 1])

# Выводим количество подходящих пар и минимальную сумму среди них
print(len(ans), min(ans))

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

Напишем программу, которая сначала найдёт среднее арифметическое всех чётных чисел из файла. Для этого перебираем все числа и суммируем только те, которые делятся на 2 без остатка, считая их количество. Затем вычисляем среднее арифметическое. После этого программа проверит все пары подряд идущих элементов последовательности. Для каждой пары проверяется, что хотя бы один из элементов больше найденного среднего арифметического чётных чисел. Если условие выполняется, увеличиваем счётчик подходящих пар и обновляем минимальную сумму элементов таких пар, если текущая сумма меньше уже найденной. В конце выводим количество таких пар и минимальную сумму.

# Открываем файл и считываем числа в список
f = open("17.txt")
s = [int(_) for _ in f]

# Считаем сумму и количество чётных чисел
k = 0
sum_even = 0
for i in range(len(s)):
    if s[i] % 2 == 0:
        sum_even += s[i]
        k += 1

# Вычисляем среднее арифметическое чётных чисел
sr = sum_even / k

# Инициализируем счётчик и минимальную сумму подходящих пар
counter = 0
ans = 10000000  # достаточно большое число для инициализации минимума

# Перебираем все пары подряд идущих элементов
for i in range(len(s) - 1):
    # Проверяем, что хотя бы один элемент пары больше среднего арифметического
    if s[i] > sr or s[i + 1] > sr:
        counter += 1
        sumelem = s[i] + s[i + 1]
        # Обновляем минимальную сумму, если нашли меньшее значение
        if ans > sumelem:
            ans = sumelem

# Выводим количество подходящих пар и минимальную сумму среди них
print(counter, ans)

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

Напишем программу, которая перебирает все пары разных элементов из файла. Для каждой пары проверяем два условия. Первое: остатки от деления каждого из чисел на 120 должны отличаться — это значит, что когда мы делим оба числа на 120, получаются разные значения. Для проверки этого используем оператор !=. Второе условие: хотя бы одно из чисел должно делиться на 5 без остатка, то есть при делении на 5 остаток равен 0. Если оба условия выполняются, записываем сумму этой пары в список результатов. В конце выводим количество таких пар и максимальную сумму из них.

# открываем файл и считываем числа в список
f = open("17_1.txt")
a = [int(i) for i in f]

ans = []  # список для хранения сумм подходящих пар

# перебираем все пары различных элементов
for i in range(len(a) - 1):
    for j in range(i + 1, len(a)):
        # проверяем, что остатки от деления на 120 разные (используем !=)
        # и хотя бы одно число делится на 5 без остатка
        if (a[i] % 120) != (a[j] % 120) and (a[i] % 5 == 0 or a[j] % 5 == 0):
            ans += [a[i] + a[j]]

# выводим количество подходящих пар и максимальную сумму
print(len(ans), max(ans))

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

Напишем программу, которая перебирает все пары подряд идущих чисел из файла. Для каждой пары проверяем два условия. Первое: произведение чисел должно делиться на 15 без остатка. Второе: сумма этих чисел должна делиться на 7 без остатка. Если оба условия выполняются, увеличиваем счётчик подходящих пар и обновляем максимальную сумму таких пар. В конце выводим количество найденных пар и максимальную сумму.

# открываем файл и считываем числа в список
f = open("17.txt")
a = [int(i) for i in f]

counter = 0  # счётчик подходящих пар
maxim = 0    # максимальная сумма подходящих пар

# перебираем все пары подряд идущих элементов
for i in range(len(a) - 1):
    # проверяем условия: произведение кратно 15, сумма кратна 7
    if (a[i] * a[i + 1]) % 15 == 0 and (a[i] + a[i + 1]) % 7 == 0:
        counter += 1
        maxim = max(maxim, a[i] + a[i + 1])

# выводим количество подходящих пар и максимальную сумму
print(counter, maxim)

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

Напишем программу, которая перебирает все пары подряд идущих чисел из файла. Сначала найдём наименьшее число в файле, которое делится на 11.

Далее для каждой пары проверяем два условия. Первое: оба числа должны быть больше найденного минимального числа, кратного 11. Второе: хотя бы у одного из чисел в паре должна содержаться последовательность цифр "12"или "21"рядом. Для проверки этого условия реализована функция, которая преобразует число в строку и ищет подстроки "12"или "21".

Если оба условия выполняются, увеличиваем счётчик таких пар и обновляем максимальное произведение элементов таких пар. В конце выводим количество подходящих пар и максимальное произведение.

# функция для проверки, содержит ли число рядом стоящие цифры ’12’ или ’21’
def cont12(n):
    s = str(n)
    return ’12’ in s or ’21’ in s

# открываем файл и считываем последовательность чисел
f = open("17.txt")
a = [int(s) for s in f.readlines()]
n = len(a)

# ищем минимальное число, кратное 11
minim11 = 10**18
for i in range(n):
    if a[i] % 11 == 0:
        minim11 = min(minim11, a[i])

count = 0
maxim = -10**18  # инициализируем очень маленьким числом для максимума

# перебираем все пары подряд идущих элементов
for i in range(n - 1):
    x, y = a[i], a[i + 1]

    # проверяем, что оба числа больше минимального числа, кратного 11
    if x > minim11 and y > minim11:
        # проверяем, содержит ли хотя бы одно из чисел ’12’ или ’21’
        if cont12(x) or cont12(y):
            count += 1
            maxim = max(maxim, x * y)

# выводим количество таких пар и максимальное произведение
print(count, maxim)

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

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

Второе условие: хотя бы у одного из чисел шестнадцатеричная запись оканчивается на букву ’B’. Это можно проверить через остаток от деления числа на 16 — если он равен 11 (что соответствует ’B’ в шестнадцатеричной системе), значит условие выполнено.

Если оба условия выполняются, увеличиваем счётчик таких пар и обновляем максимальное произведение элементов этих пар. В конце выводим количество подходящих пар и максимальное произведение.

# открываем файл и считываем последовательность чисел
f = open("17.txt")
a = [int(s) for s in f.readlines()]

n = len(a)
counter = 0
maxim = -10**18  # инициализируем очень маленьким числом для максимума

# вычисляем остаток от деления суммы всех чисел на 54321
ost = sum(a) % 54321

# перебираем все пары подряд идущих элементов
for i in range(n - 1):
    x, y = a[i], a[i + 1]

    # проверяем, что оба числа не больше ost
    if x <= ost and y <= ost:
        # проверяем, что хотя бы одно число в шестнадцатеричной записи оканчивается на ’B’ (остаток от деления на 16 равен 11)
        if x % 16 == 11 or y % 16 == 11:
            counter += 1
            maxim = max(maxim, x * y)

# выводим количество таких пар и максимальное произведение
print(counter, maxim)

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

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

Затем для каждого из двух чисел пары переводим его в семеричную систему счисления. Если у хотя бы одного из чисел в семеричной записи есть последовательность цифр "55 то пара подходит.

Если обе проверки пройдены, увеличиваем счётчик подходящих пар и сохраняем минимальную сумму модулей элементов таких пар. В конце выводим количество таких пар и минимальную сумму.

# функция для перевода числа в семеричную систему счисления
def sem(x):
    t = x
    s = ’’
    while t > 0:
        s = str(t % 7) + s
        t = t // 7
    return s

# открываем файл и считываем числа
f = open("17.txt")
a = [int(s) for s in f.readlines()]

# находим максимальное число, кратное 63
maxim63 = max(x for x in a if x % 63 == 0)

n = len(a)
counter = 0
minim = 10**18  # большое число для инициализации минимальной суммы

# перебираем все пары подряд идущих элементов
for i in range(n - 1):
    x, y = a[i], a[i + 1]

    # проверяем, что сумма пары больше максимального числа, кратного 63
    if x + y > maxim63:
        # проверяем, содержится ли ’55’ в семеричной записи хотя бы одного элемента
        if (’55’ in sem(x)) or (’55’ in sem(y)):
            counter += 1
            minim = min(minim, abs(x) + abs(y))

# выводим количество подходящих пар и минимальную сумму модулей элементов
print(counter, minim)

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

Напишем программу, которая перебирает все пары различных элементов последовательности. Нужно найти пары, у которых разность элементов чётна. Для этого вычисляем остаток от деления разности на 2 — если он равен нулю, значит разность чётна. Кроме того, хотя бы одно из чисел пары должно делиться на 31 — проверяем это через остаток от деления каждого числа на 31. Если хотя бы одно делится без остатка, условие выполнено.

Программа считает количество таких пар и запоминает максимальную сумму элементов таких пар. В конце выводит количество и максимальную сумму.

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

# считываем все числа из файла в список
a = [int(i) for i in f.readlines()]

# переменные для подсчёта количества подходящих пар и хранения максимальной суммы
count = 0
maxim = 0

# перебираем все пары различных элементов (i < j)
for i in range(len(a) - 1):
    for j in range(i + 1, len(a)):
        # проверяем, что разность чётна
        # и хотя бы один элемент делится на 31
        if (a[i] - a[j]) % 2 == 0 and (a[i] % 31 == 0 or a[j] % 31 == 0):
            count += 1
            maxim = max(maxim, a[i] + a[j])

# выводим количество подходящих пар и максимальную сумму
print(count, maxim)

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

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

Программа подсчитывает количество таких пар и сохраняет максимальную сумму элементов таких пар. В конце выводим количество и максимальную сумму.

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

# считываем все числа из файла в список
a = [int(i) for i in f.readlines()]

# переменные для подсчёта количества подходящих пар и хранения максимальной суммы
count = 0
maxim = 0

# перебираем все пары различных элементов (i < j)
for i in range(len(a) - 1):
    for j in range(i + 1, len(a)):
        # проверяем, что произведение делится на 17 без остатка
        if a[i] * a[j] % 17 == 0:
            count += 1
            maxim = max(maxim, a[i] + a[j])

# выводим количество подходящих пар и максимальную сумму
print(count, maxim)

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

Напишем программу, которая будет проверять все пары различных элементов последовательности. Нужно найти пары, у которых сумма элементов кратна 44. Для этого берём сумму пары и проверяем остаток от деления на 44 — если он равен нулю, сумма кратна 44. Также для пары должно выполняться условие, что хотя бы один из элементов делится на 11 — проверяем это через остаток от деления на 11. Если хотя бы один элемент делится на 11, условие выполняется.

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

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

# считываем все числа из файла в список
a = [int(i) for i in f.readlines()]

# переменные для подсчёта количества подходящих пар и хранения максимальной суммы
count = 0
maxim = 0

# перебираем все пары различных элементов (i < j)
for i in range(len(a) - 1):
    for j in range(i + 1, len(a)):
        # проверяем, что сумма кратна 44
        # и хотя бы один элемент делится на 11
        if (a[i] + a[j]) % 44 == 0 and (a[i] % 11 == 0 or a[j] % 11 == 0):
            count += 1
            maxim = max(maxim, a[i] + a[j])

# выводим количество подходящих пар и максимальную сумму
print(count, maxim)

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

Напишем программу, которая будет проверять все пары различных элементов последовательности. Нужно найти пары, в которых ровно одно число является трёхзначным. Для этого в условии используется оператор != между двумя проверками — (99 < a[i] < 1000) и (99 < a[j] < 1000). Он возвращает True только если ровно одно из чисел — трёхзначное, а другое — нет.

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

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

# считываем все числа из файла в список
a = [int(i) for i in f.readlines()]

# переменная для подсчёта количества подходящих пар
count = 0

# переменная для хранения минимальной суммы подходящих пар (берём большое число для начала)
minim = 100000000000

# переменная для хранения минимального трёхзначного числа, оканчивающегося на 5 (начинаем с очень большого)
mintr = 1000000000

# ищем минимальное трёхзначное число, которое оканчивается на 5
for i in range(len(a)):
    if 99 < a[i] < 1000 and a[i] % 10 == 5:
        mintr = min(mintr, a[i])

# перебираем все пары различных элементов (i < j)
for i in range(len(a) - 1):
    for j in range(i + 1, len(a)):
        # проверяем, что ровно одно из чисел трёхзначное (логическое исключающее ИЛИ)
        if (99 < a[i] < 1000) != (99 < a[j] < 1000):
            # проверяем делимость суммы пары на минимальное трёхзначное число, оканчивающееся на 5
            if (a[i] + a[j]) % mintr == 0:
                count += 1
                # сохраняем минимальную сумму среди подходящих пар
                minim = min(minim, a[i] + a[j])

# выводим количество подходящих пар и минимальную сумму
print(count, minim)

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

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

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

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

# считываем все числа из файла в список
a = [int(i) for i in f.readlines()]

# находим максимальный элемент, оканчивающийся на 3 (учитываем абсолютное значение, чтобы правильно обрабатывать отрицательные числа)
maxe3 = -100000000000
for i in range(len(a)):
    if abs(a[i]) % 10 == 3:
        maxe3 = max(maxe3, a[i])

# переменные для подсчёта подходящих пар и максимальной суммы квадратов
count = 0
maxs = 0

# перебираем все пары соседних элементов
for i in range(len(a) - 1):
    # проверяем, что ровно одно число заканчивается на 3
    # выражение (abs(a[i]) % 10 == 3) и (abs(a[i+1]) % 10 == 3) даёт True или False,
    # которые в арифметическом контексте равны 1 или 0, их сумма равна 1 только если ровно одно из чисел заканчивается на 3
    if (abs(a[i]) % 10 == 3) + (abs(a[i + 1]) % 10 == 3) == 1:
        # проверяем, что сумма квадратов пары не меньше квадрата максимального числа, оканчивающегося на 3
        if a[i] ** 2 + a[i + 1] ** 2 >= maxe3 ** 2:
            count += 1
            maxs = max(maxs, a[i] ** 2 + a[i + 1] ** 2)

# выводим количество подходящих пар и максимальную сумму квадратов
print(count, maxs)