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

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

Сначала программа находит наибольшее число в последовательности, которое делится на 131, то есть его остаток при делении на 131 равен 0. Затем перебираются все пары подряд идущих чисел. Если хотя бы одно из чисел пары больше найденного максимума и хотя бы одно число содержит две подряд стоящие цифры 1, то такая пара подходит. Счётчик увеличивается и минимальная сумма такой пары обновляется.

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

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

# Переменная для хранения минимальной суммы подходящих пар
ans = 10 ** 10

# Переменная для хранения наибольшего числа, делящегося на 131
max_131 = -10 ** 10

# Поиск максимального числа, делящегося на 131
for i in range(len(s)):
    if s[i] % 131 == 0:
        max_131 = max(max_131, s[i])

# Перебор всех подряд идущих пар
for i in range(len(s) - 1):
    # Проверка: хотя бы одно число больше max_131
    if s[i] > max_131 or s[i + 1] > max_131:
        # Проверка: хотя бы одно число содержит "11"
        if ’11’ in str(s[i]) or ’11’ in str(s[i + 1]):
            # Увеличиваем счётчик подходящих пар
            counter += 1
            # Обновляем минимальную сумму пары
            ans = min(ans, s[i] + s[i + 1])

# Вывод результата
print(counter, ans)

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

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

Затем перебираем все пары соседних чисел в последовательности. Для каждой пары проверяем два условия:

Сначала проверяем, что хотя бы одно из чисел пары должно быть строго больше найденного максимального числа, делящегося на 127. Затем проверяем, что хотя бы одно из чисел пары в восьмеричной записи должно содержать подстроку из двух цифр подряд: 31.

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

# Функция перевода числа в восьмеричную систему счисления
def cc_8(n):
    q = ’’
    while n > 0:
        q = str(n % 8) + q
        n //= 8
    return q

# Чтение чисел из файла
f = open(’17.txt’)
s = [int(_) for _ in f]

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

# Переменная для хранения минимальной суммы подходящих пар
ans = 10 ** 10

# Переменная для хранения наибольшего числа, делящегося на 127
max_127 = -10 ** 10

# Поиск максимального числа, делящегося на 127
for i in range(len(s)):
    if s[i] % 127 == 0:
        max_127 = max(max_127, s[i])

# Перебор всех подряд идущих пар
for i in range(len(s) - 1):
    # Проверка: хотя бы одно число больше max_127
    if s[i] > max_127 or s[i + 1] > max_127:
        # Получаем восьмеричную запись чисел
        k1 = cc_8(s[i])
        k2 = cc_8(s[i + 1])
        # Проверка на наличие подстроки "31" в восьмеричной записи
        if ’31’ in k1 or ’31’ in k2:
            # Увеличиваем счётчик подходящих пар
            counter += 1
            # Обновляем минимальную сумму пары
                                                                                                     
                                                                                                     
            ans = min(ans, s[i] + s[i + 1])

# Вывод результата
print(counter, ans)

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

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

f = open("17.txt")
a = [int(x) for x in f]

# Находим минимальный элемент, кратный 19
minim = min([x for x in a if x % 19 == 0])

# Инициализируем счётчик и максимальную абсолютную сумму
maxim = -10**16
count = 0

# Перебираем пары соседних элементов
for i in range(len(a) - 1):
    if (a[i] + a[i + 1]) < minim:
       # Увеличиваем счётчик
       count += 1
       # Обновляем максимальную абсолютную сумму
       maxim = max(maxim, abs(a[i] + a[i + 1]))

Выводим результаты
print(count, maxim)

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

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

# Открываем файл с данными для чтения
f = open(’1.txt’)
# Считываем все числа из файла в список a
a = [int(_) for _ in f]
# Инициализируем переменную максимума минимально возможным значением
maxim = -10001
# Инициализируем счётчик количества пар с чётной суммой
count = 0
# Перебираем все пары соседних элементов
for i in range(len(a) - 1):
    # Проверяем, что сумма пары чётна
    if (a[i] + a[i + 1]) % 2 == 0:
        # Увеличиваем счётчик таких пар
        count += 1
        # Обновляем максимум среди элементов таких пар
        maxim = max(a[i], a[i + 1], maxim)
# Выводим количество пар и максимальное число среди них
print(count, maxim)

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

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

# Открываем файл для чтения
f = open(’2.txt’)
# Считываем первое число последовательности
a = int(f.readline())
# Инициализируем минимум и максимум
minim = 10001
maxim = -10001
# Счётчик пар, удовлетворяющих условию
count = 0
# Проходим по оставшимся числам
for i in f:
    # Преобразуем текущую строку в число
    b = int(i)
    # Проверяем, что сумма не равна нулю
    if (a + b) != 0:
        # Проверяем кратность произведения сумме
        if (a * b) % (a + b) == 0:
            # Увеличиваем счётчик
            count += 1
            # Обновляем максимум среди элементов таких пар
            maxim = max(a, b, maxim)
            # Обновляем минимум среди элементов таких пар
            minim = min(a, b, minim)
    # Переходим к следующему элементу
    a = b
# Выводим количество пар и сумму минимума с максимумом
print(count, minim + maxim)

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

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

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

# Инициализируем счётчик пар и максимум суммы
counter_pairs = 0
max_summ = -10 ** 10

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

# Выводим количество пар и максимальную сумму без пробелов
print(counter_pairs, max_summ, sep="")

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

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

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

# Инициализируем счётчик пар и максимум суммы
counter_pairs = 0
max_summ = -10 ** 10

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

# Выводим количество пар и максимальную сумму без пробелов
print(counter_pairs, max_summ, sep="")

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

Найдём максимальный элемент, оканчивающийся на 73 (по модулю 100). Затем пройдёмся по всем парам соседних элементов и проверим, что ровно одно число в паре оканчивается на 73, то есть его остаток при делении на 100 равен 73, а сумма квадратов элементов пары не меньше квадрата найденного максимума. Для таких пар посчитаем количество и обновим максимум суммы квадратов.

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

# Инициализируем счётчик пар и максимум суммы квадратов
counter_pairs = 0
max_summ = -10 ** 10

# Находим максимальный элемент, оканчивающийся на 73 по модулю 100
max_elem_73 = -10 ** 10
for elem in arr:
    if abs(elem) % 100 == 73:
        max_elem_73 = max(max_elem_73, elem)

# Проходим по всем соседним парам
for index in range(len(arr) - 1):
    k1 = abs(arr[index]) % 100 == 73
    k2 = abs(arr[index + 1]) % 100 == 73
    k3 = arr[index] ** 2 + arr[index + 1] ** 2 >= max_elem_73 ** 2
    # Проверяем, что ровно одно число оканчивается на 73 и сумма квадратов не меньше квадрата максимума
    if k1 + k2 == 1 and k3:
        counter_pairs += 1
        max_summ = max(max_summ, arr[index] ** 2 + arr[index + 1] ** 2)

# Выводим количество пар и максимальную сумму квадратов без пробелов
print(counter_pairs, max_summ, sep="")

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

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

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

# Инициализируем счётчик пар и минимальное произведение
counter_pairs = 0
min_prod = 10 ** 10

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

# Выводим количество пар и минимальное произведение без пробелов
print(counter_pairs, min_prod, sep="")

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

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

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

# Инициализируем счётчик пар и максимум суммы
counter_pairs = 0
max_summ = -10 ** 10

# Находим максимальный элемент, кратный 41
max_elem_41 = -10 ** 10
for elem in arr:
    if elem % 41 == 0:
        max_elem_41 = max(max_elem_41, elem)

# Проходим по всем соседним парам
for index in range(len(arr) - 1):
    if (arr[index] + arr[index + 1]) < max_elem_41:
        counter_pairs += 1
        max_summ = max(max_summ, arr[index] + arr[index + 1])

# Выводим количество пар и максимальную сумму без пробелов
print(counter_pairs, max_summ, sep="")

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

Найдём максимальный элемент последовательности, кратный 11 (его остаток при делении на 11 равен 0), и вычислим сумму цифр его троичной записи. Затем пройдёмся по всем парам соседних элементов и проверим, что сумма цифр троичной записи хотя бы одного числа равна этой сумме. Для таких пар посчитаем количество и обновим минимальную сумму элементов пары.

# Функция для подсчёта суммы цифр в троичной записи
def summ_three(number):
    summ = 0
    x = number
    while x > 0:
        summ += x % 3
        x //= 3
    return summ

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

# Инициализируем счётчик пар и минимум суммы
counter_pairs = 0
min_summ = 10 ** 10

# Находим максимальный элемент, кратный 11
max_elem_11 = -10 ** 10
for elem in arr:
    if elem % 11 == 0:
        max_elem_11 = max(max_elem_11, elem)

# Вычисляем сумму цифр троичной записи максимального элемента
summ_three_max_elem_11 = summ_three(max_elem_11)

# Проходим по всем соседним парам
for index in range(len(arr) - 1):
    if summ_three(arr[index]) == summ_three_max_elem_11 \
        or summ_three(arr[index + 1]) == summ_three_max_elem_11:
        counter_pairs += 1
        min_summ = min(min_summ, arr[index] + arr[index + 1])

# Выводим количество пар и минимальную сумму без пробелов
print(counter_pairs, min_summ, sep="")

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

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

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

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

# Перебираем все пары различных элементов
for i in range(len(a)):
    for j in range(i + 1, len(a)):
        # Проверяем условия кратности суммы и произведения
        if ((a[i] + a[j]) % 71 == 0) or ((a[i] * a[j]) % 17 == 0):
            ans.append(a[i] + a[j])

# Выводим количество таких пар и максимальную сумму без пробелов
print(len(ans), max(ans), sep="")

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

Пройдёмся по последовательности и рассмотрим все пары соседних элементов. Для каждой пары проверим, что разность элементов чётна (остаток при делении на 2 равен 0) и хотя бы одно из чисел делится на 25 (остаток при делении на 25 равен 0). Если условие выполняется, увеличим счётчик и обновим максимум произведения таких пар. В конце выведем количество пар и максимум произведения.

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

# Инициализируем максимум произведения и счётчик пар
mx = 0
c = 0

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

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

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

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

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

# Вычисляем среднее арифметическое
sr_arif = sum(a) / len(a)

# Инициализируем счётчик пар и максимум суммы
k = 0
maxim = -10000

# Проходим по всем соседним парам
for i in range(1, len(a)):
    # Проверяем, что хотя бы один элемент больше среднего
    if a[i - 1] > sr_arif or a[i] > sr_arif:
        # Проверяем, что хотя бы один элемент оканчивается на 6
        if abs(a[i - 1]) % 10 == 6 or abs(a[i]) % 10 == 6:
            k += 1
            maxim = max(maxim, a[i - 1] + a[i])

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

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

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

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

# Вычисляем среднее арифметическое всех чисел
av = sum(a) / len(a)

k = 0         # счётчик подходящих пар
mx = 0        # максимальная сумма подходящих пар
x = 0         # первый элемент пары с максимальной суммой
y = 0         # второй элемент пары с максимальной суммой

# Проходим по всем парам из двух подряд идущих элементов
for i in range(len(a) - 1):
    # Проверяем, что хотя бы один элемент меньше среднего
    # и что в десятичной записи обоих элементов нет цифры ’1’
    if (a[i] < av or a[i + 1] < av) and (’1’ not in str(a[i]) and ’1’ not in str(a[i + 1])):
        k += 1
        # Обновляем пару с максимальной суммой элементов
        if (a[i] + a[i + 1]) > mx:
            x = a[i]
            y = a[i + 1]
            mx = a[i] + a[i + 1]

# Выводим количество подходящих пар и пару с максимальной суммой
print(k, x, y)

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

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

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

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

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

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

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

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

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

# Находим минимальный элемент всей последовательности для дальнейших проверок
minim = min(arr)

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

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

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

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

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

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

# Подсчитываем количество чисел, делящихся на 2 (чётных чисел) в последовательности
counter_even = len([j for j in arr if j % 2 == 0])

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

# Перебираем все пары соседних элементов последовательности
for i in range(len(arr) - 1):
    # Проверяем, что оба числа отрицательны
    if arr[i] < 0 and arr[i + 1] < 0:
        # Проверяем, что произведение пары больше количества чётных чисел в последовательности
        if arr[i] * arr[i + 1] > counter_even:
            ans_count += 1                         # Увеличиваем счётчик подходящих пар
            max_summ = max(max_summ, arr[i] + arr[i + 1])  # Обновляем максимальную сумму

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

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

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

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

# Находим максимальный элемент, оканчивающийся на 9 (по абсолютному значению)
maxim_9 = -10**10
for elem in arr:
    if abs(elem) % 10 == 9:
        maxim_9 = max(maxim_9, elem)

counter = 0                      # Счётчик подходящих пар
minim_diff = 10**10              # Переменная для минимальной разности элементов пар, инициализирована большим числом

# Перебираем все пары соседних элементов
for i in range(len(arr) - 1):
    # Проверяем, оканчивается ли ровно одно число из пары на 7 (по абсолютному значению)
    k1 = abs(arr[i]) % 10 == 7
    k2 = abs(arr[i + 1]) % 10 == 7
    # Проверяем, что модуль разности квадратов элементов не больше квадрата максимума, оканчивающегося на 9
    k3 = abs(arr[i]**2 - arr[i + 1]**2) <= maxim_9**2

    # Если только одно число оканчивается на 7 и условие по разности квадратов выполнено
    if (k1 + k2) == 1 and k3:
        counter += 1
        # Обновляем минимальную разницу между элементами пары
        minim_diff = min(minim_diff, abs(arr[i] - arr[i + 1]))

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

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

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

# Функция проверяет, что все цифры числа чётные
def all_even(number):
    s = str(number)                   # Преобразуем число в строку, чтобы перебрать каждую цифру
    for char in s:
        if int(char) % 2 != 0:       # Если найдена хоть одна нечётная цифра, возвращаем False
            return False
    return True                      # Если все цифры чётные, возвращаем True

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

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

# Перебираем все пары соседних элементов последовательности
for i in range(len(arr) - 1):
    # Проверяем, что оба числа в паре состоят только из чётных цифр
    if all_even(arr[i]) and all_even(arr[i + 1]):
        counter += 1                           # Увеличиваем счётчик подходящих пар
        # Обновляем минимальную сумму, если текущая сумма пары меньше уже сохранённой
        min_sum = min(min_sum, arr[i] + arr[i + 1])

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