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

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

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

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

# Счётчик подходящих пар
c = 0
# Переменная для хранения максимальной суммы
# Очень маленькое, чтобы обновилось при первом же подходящем случае
mx = -10 ** 10

# Перебираем все возможные пары (разные элементы, порядок не важен)
for i in range(len(a)):
    for j in range(i + 1, len(a)):
        # Проверяем, что последняя цифра (в 16-ричной системе)
        # произведения равна E (14 в десятичной)
        flag1 = (abs(a[i]) * abs(a[j])) % 16 == 14

        # Проверяем, что хотя бы одно число из пары оканчивается на 6
        # Каждая из () вернет либо 1, либо 0, как будто это маленький IF
        flag2 = (abs(a[i]) % 10 == 6) + (abs(a[j]) % 10 == 6)

        # Если оба условия выполняются
        if flag1 and flag2:
            c += 1
            mx = max(mx, a[i] + a[j])

print(c, mx)

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

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

Далее для таких пар проверяется второе условие: сумма элементов должна быть кратна 77. Если это условие выполнено, обновляем максимальную сумму среди всех подходящих пар.

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

f = open(’17.txt’)
n = 1000000
# Считываем n чисел из файла
a = [int(f.readline()) for i in range(n)]
# Счётчик пар с предпоследней цифрой произведения равной 7
k = 0
# Максимальная сумма, кратная 77, среди таких пар
ma = -10**19

for i in range(n-1):
    # Вычисляем предпоследнюю цифру произведения пары
    if (((a[i] * a[i + 1]) % 100) // 10) == 7:
        k += 1
        # Проверяем, что сумма кратна 77 и обновляем максимум
        if (a[i] + a[i + 1]) % 77 == 0:
            ma = max(ma, a[i] + a[i + 1])

print(k, ma)

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

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

# Открываем файл для чтения
f = open("17.txt")

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

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

# Инициализируем минимальную сумму очень большим числом
minim = 10 ** 10

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

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

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

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

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

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

# Счётчик пар с нужной второй цифрой произведения
count = 0
# Максимальная сумма, кратная 24, среди таких пар
maxim = 0

# Перебираем все пары подряд идущих чисел
for i in range(len(a) - 1):
    # Вычисляем произведение пары и преобразуем в строку
    p = str(a[i] * a[i + 1])

    # Проверяем, что в произведении не меньше двух цифр
    if len(p) >= 2:
        # Проверяем, равна ли вторая цифра ’4’
        if p[1] == ’4’:
            # Увеличиваем счётчик подходящих пар
            count += 1
            # Проверяем, кратна ли сумма 24 и больше ли максимума
            if (a[i] + a[i + 1]) % 24 == 0 and (a[i] + a[i + 1]) > maxim:
                # Обновляем максимальную сумму
                maxim = (a[i] + a[i + 1])

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

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

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

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

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

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

# Перебираем все пары подряд идущих чисел
for i in range(len(a) - 1):
    # Проверяем, что один элемент меньше среднего, а другой больше
    if (a[i] > sr and a[i + 1] < sr) or (a[i + 1] > sr and a[i] < sr):
        # Обновляем максимум суммы пары
        maxim = max(a[i] + a[i + 1], maxim)
        # Увеличиваем счётчик подходящих пар
        counter += 1

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

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

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

Далее среди таких пар ищем максимальную отрицательную сумму — сумму меньше нуля, но максимальную среди всех отрицательных.

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

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

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

# Перебираем все пары подряд идущих чисел
for i in range(len(a) - 1):
    # Проверяем, что сумма кратна 3 и произведение кратно 69
    if (a[i] + a[i + 1]) % 3 == 0 and (a[i] * a[i + 1]) % 69 == 0:
        # Увеличиваем счётчик подходящих пар
        count += 1
        # Если сумма отрицательна и больше текущего максимума, обновляем максимум
        if (a[i] + a[i + 1]) < 0 and (a[i] + a[i + 1]) > maxim:
            maxim = a[i] + a[i + 1]

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

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

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

Далее среди таких пар ищем максимальную сумму, кратную 137. Если таких сумм нет, выводим 0. В конце выводим количество подходящих пар и максимальную сумму.

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

# Инициализируем счётчик подходящих пар
count = 0
# Инициализируем переменную для максимальной суммы, кратной 137
maxim = -10 ** 10

# Перебираем все пары подряд идущих чисел
for i in range(len(a) - 1):
    # Вычисляем произведение пары и преобразуем в строку
    t = str(a[i] * a[i + 1])
    # Проверяем, что длина строки не меньше 2 и предпоследняя цифра равна ’6’
    if len(t) >= 2:
        if t[-2] == ’6’:
            # Увеличиваем счётчик подходящих пар
            count += 1
            # Проверяем, кратна ли сумма 137 и обновляем максимум
            if (a[i] + a[i + 1]) % 137 == 0:
                maxim = max(maxim, a[i] + a[i + 1])

# Если максимальная сумма не менялась, значит подходящих сумм не было, выводим 0
if maxim == -10 ** 10:
    maxim = 0

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

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

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

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

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

# Инициализируем счётчик подходящих пар
k = 0
# Инициализируем переменную для максимальной суммы
maxim = -10000000

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

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

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

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

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

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

# Перебираем все пары подряд идущих чисел
for i in range(len(s) - 1):
    # Проверяем, что хотя бы одно число больше 0 и меньше 500
    if 0 < s[i] < 500 or 0 < s[i + 1] < 500:
        # Увеличиваем счётчик подходящих пар
        counter += 1
        # Обновляем максимальную сумму пары
        maxim = max(maxim, s[i] + s[i + 1])

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

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

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

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

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

# Перебираем все пары подряд идущих чисел
for i in range(len(s) - 1):
    # Проверяем, что сумма кратна 3 и не кратна 6
    if (s[i] + s[i + 1]) % 3 == 0 and (s[i] + s[i + 1]) % 6 != 0:
        # Проверяем, что произведение оканчивается на 8
        if abs(s[i] * s[i + 1]) % 10 == 8:
            # Увеличиваем счётчик подходящих пар
            counter += 1
            # Обновляем максимальную сумму
            maxim = max(maxim, s[i] + s[i + 1])

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

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

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

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

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

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

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

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

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

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

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

# Перебираем все пары подряд идущих чисел
for i in range(len(s) - 1):
    # Проверяем, что оба числа меньше 60
    if s[i] < 60 and s[i + 1] < 60:
        # Проверяем, что хотя бы одно число кратно 5 или 8
        if s[i] % 5 == 0 or s[i] % 8 == 0 or s[i + 1] % 5 == 0 or s[i + 1] % 8 == 0:
            # Увеличиваем счётчик подходящих пар
            counter += 1
            # Обновляем минимальную сумму пары
            minim = min(minim, s[i] + s[i + 1])

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

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

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

Далее, если первое число в паре чётное, проверяется, что оно делится на 6 без остатка, а второе число (нечётное) делится на 13. Если это условие выполняется, пара подходит — увеличиваем счётчик и обновляем максимум суммы.

Если же первое число нечётное, проверяется, что оно делится на 13, а второе (чётное) — делится на 6. В этом случае также учитываем пару и обновляем максимальную сумму.

Таким образом, программа находит количество пар с разной чётностью, где чётное число кратно 6, а нечётное — кратно 13, и среди таких пар определяет максимальную сумму элементов.

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

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

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

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

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

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

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

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

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

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

print(counter, ans)

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

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

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

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

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

# Перебираем пары подряд идущих элементов
for i in range(len(s) - 1):
    # Условие: хотя бы один элемент больше среднего, и сумма делится на 7
    if (s[i] > sr or s[i + 1] > sr) and (s[i] + s[i + 1]) % 7 == 0:
        counter += 1
        mn = min(mn, s[i] + s[i + 1])

print(counter, mn)

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

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

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

# Вычисляем среднее значение по всем числам
sr = sum(s) / len(s)

# Счётчик пар
counter = 0
# Переменная для максимума
mx = -10 ** 10

# Перебираем все пары подряд идущих элементов
for i in range(len(s) - 1):
    # Условия:
    # 1) оба элемента больше среднего
    # 2) сумма заканчивается на 31 (по модулю 100 даёт 31)
    if s[i] > sr and s[i + 1] > sr and abs(s[i] + s[i + 1]) % 100 == 31:
        counter += 1
        mx = max(mx, s[i] + s[i + 1])

print(counter, mx)

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

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

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

# Вычисляем среднее значение всех чисел
sr = sum(s) / len(s)

# Счётчик пар
counter = 0
# Переменная для максимума
mx = -10 ** 10

# Перебираем все пары подряд идущих элементов
for i in range(len(s) - 1):
    # Условие:
    # 1) хотя бы один элемент больше среднего
    # 2) хотя бы один элемент делится на 17
    if (s[i] > sr or s[i + 1] > sr) and (s[i] % 17 == 0 or s[i + 1] % 17 == 0):
        counter += 1
        mx = max(mx, s[i] + s[i + 1])

print(counter, mx)

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

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

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

# Вычисляем среднее значение всех чисел
sr = sum(s) / len(s)
# Счётчик пар
counter = 0
# Переменная для максимальной суммы
mx = -10 ** 10

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

        # Проверяем, что хотя бы один элемент:
        # делится на 3 и не делится на 5, 11 и 19
        if (s[i] % 3 == 0 and s[i] % 5 != 0 and s[i] % 11 != 0 \
            and s[i] % 19 != 0) or (s[i + 1] % 3 == 0 and s[i + 1] % 5 \
            != 0 and s[i + 1] % 11 != 0 and s[i + 1] % 19 != 0):

            # Увеличиваем счётчик подходящих пар
            counter += 1
            # Обновляем максимум суммы
            mx = max(mx, s[i] + s[i + 1])

print(counter, mx)

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

Программа сначала определяет наибольшее число, делящееся на 19. После этого проверяет все подряд идущие пары и, если хотя бы один элемент пары строго больше этого числа, увеличивает счётчик и при необходимости обновляет минимальную сумму среди таких пар.

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

# Объявляем счётчик подходящих пар
counter = 0

# Инициализируем переменную для минимальной суммы
ans = 10 ** 10

# Инициализируем максимум среди чисел, делящихся на 19
max_19 = -10 ** 10

# Ищем максимальное число, кратное 19
for i in range(len(s)):
    if s[i] % 19 == 0:
        max_19 = max(max_19, s[i])

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

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

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

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

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

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

# Инициализируем переменную для хранения максимальной суммы
ans = -10 ** 10

# Инициализируем максимум среди чисел, делящихся на 171
max_171 = -10 ** 10

# Ищем наибольшее число, делящееся на 171
for i in range(len(s)):
    if s[i] % 171 == 0:
        max_171 = max(max_171, s[i])

# Перебираем все пары подряд идущих чисел
for i in range(len(s) - 1):
    # Проверяем, что хотя бы одно число меньше max_171
    if s[i] < max_171 or s[i + 1] < max_171:
        # Проверяем, что хотя бы одно число нечётное
        if s[i] % 2 == 1 or s[i + 1] % 2 == 1:
            # Увеличиваем счётчик подходящих пар
            counter += 1
            # Обновляем максимальную сумму пары
            ans = max(ans, s[i] + s[i + 1])

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