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

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

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

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

# Вычисляем среднее арифметическое
sr = sum(s) / len(s)
# Счётчик подходящих пар
count = 0
# Минимальная сумма подходящих пар
ans = 10 ** 10

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

# sep="", чтобы убрать пробел
print(count, ans, sep="")

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

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

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

# Открываем файл
f = open("2__t9ih.txt")
# Считываем все числа и переводим их из
# строчного типа в целочисленный
l = [int(i) for i in f]
# Инициализируем переменную minim для поиска
# минимального числа из подходящих пар
minim = 10001
# Инициализируем переменную maxim для поиска
# максимального числа из подходящих пар
maxim = -10001
# Инициализируем переменную count,
# которая выступает в роли счетчика подходящих пар
count = 0
# Перебираем все возможные пары чисел
for i in range(len(l) - 1):
# Если сумма элементов пары не ноль И
    # Если их произведение кратно их сумме
    if (l[i] + l[i + 1]) != 0 and (l[i]* l[i + 1]) % (l[i] + l[i + 1]) == 0:
     # Увеличиваем счетчик на единицу
            count += 1
            # Обновляем переменную maxim,
          # записывая туда максимальное число
            maxim = max([l[i], l[i + 1], maxim])
            # Обновляем переменную minim,
          # записывая туда минимальное число
            minim = min([l[i], l[i + 1], minim])
# Печатаем ответ
print(count, minim + maxim)

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

Напишем программу, которая будет проверять все пары соседних чисел из файла, отбирая те, где сумма кратна 30 и хотя бы одно число оканчивается на 8. Для проверки первого условия будем находить остаток от деления на 30 суммы и сравнивать его с 0, если остаток равен 0, то сумма кратна 30. Для проверки второго условия будем сравнивать остатки от деления на 10 чисел пары, если остаток равен 8, то число оканчивается на 8. Количество и максимальное произведение подходящих пар будем подсчитывать в отдельных переменных, чтобы после отработки цикла вывести их количество и максимальное произведение.

# открываем файл
f = open(’17text.txt’)
# считываем числа в список
a = [int(s) for s in f]
# количество подходящих пар
# максимальная сумма пар
ans, maxim = 0, 0
# Перебираем все пары последовательных элементов списка ’a’
for i in range(len(a) - 1):
# Проверяем, что сумма текущего и следующего элемента кратна 30
    # И хотя бы один из элементов пары оканчивается на 8
    if (a[i] % 10 == 8 or a[i + 1] % 10 == 8) and sum(a[i:i + 2]) % 30 == 0:
        # увеличиваем счётчик
        ans += 1
        # перезаписываем максимальное произведение
        maxim = max(maxim, a[i] * a[i + 1])
# вывод количества и максимального произведения
print(ans, maxim)

Напишем программу, которая будет проверять все пары чисел, стоящих рядом друг с другом. Сначала обработаем все числа файла, которые кратны 12: будем поразрядно переводить их в пятеричную систему счисления и при необходимости увеличивать счетчик, который отвечает за количество 4 в пятеричных записях таких чисел. Далее просто переберем все пары элементов и будем отбирать только те, где оба элемента больше, чем количество всех цифр «4» в пятеричной записи всех чисел в файле, кратных 12.

# Открываем файл
f = open("Задание_17__k3bs.txt")
# Считываем все числа и переводим их из строчного типа в целочисленный
a = [int(x) for x in f]
# Инициализируем два счетчика
counter = 0
count4 = 0
# Перебираем все числа файла
for i in range(len(a)):
    n = a[i]
    # Если оно кратно 12
    if n % 12 == 0:
     # Поразрядно переводим его в пятеричную систему счисления
        while n != 0:
         # Счетчик увеличится, если в пятеричной СС встретится 4
            count4 += n % 5 == 4
            n //= 5
# Инициализируем переменную, которая будет хранить максимульную сумму элементов из подходящих пар
maxim = 0
# Перебираем все пары элементов
for i in range(len(a)-1):
# Если оба числа больше, чем количество всех цифр «4» в пятеричной записи всех чисел в файле, кратных 12.
    if a[i] > count4 and a[i+1] > count4:
     # Увеличиваем счетчик
        counter += 1
        # Обновляем переменную maxim
        maxim = max(maxim, a[i]+a[i+1])
# Печатаем ответ
print(counter, maxim)

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

Напишем программу, которая будет проверять все пары соседних чисел из файла, подсчитывая те, где сумма кратна 6 и не кратна 9 и оканчивается на 2, и определяя максимальное произведение пары, которое оканчивается на 7. Для проверки первого условия будем находить остаток от деления на 6 суммы и сравнивать его с 0, если остаток равен 0, то сумма кратна 6. Для проверки второго условия будем находить остаток от деления на 9 суммы и сравнивать его с 0, если остаток не равен 0, то сумма кратна 9. Для проверки третьего условия будем находить остаток от деления на 10 суммы и сравнивать его с 2, если остаток равен 2, то сумма оканчивается на 2. Для проверки третьего условия будем находить остаток от деления на 10 произведения и сравнивать его с 7, если остаток равен 7, то произведение оканчивается на 7. Количество и максимальное произведение подходящих пар будем сохранять в отдельные переменные, чтобы после отработки цикла вывести их количество и максимальное произведение.

# открываем файл
f = open(’Задание_17__ktcw.txt’)
# считываем числа в список
a = [int(s) for s in f]
# количество подходящих пар
# максимальное произведение пары
ans, maxim = 0, -1
# Перебираем все пары последовательных элементов списка ’a’
for i in range(len(a) - 1):
    # Проверяем, что сумма текущего и следующего элемента кратна 6 и не кратна 9 и оканчивается на 2
    if (a[i] + a[i + 1]) % 6 == 0 and (a[i] + a[i + 1]) % 9 != 0 \
            and (a[i] + a[i + 1]) % 10 == 2:
        # увеличиваем счётчик
        ans += 1
    # Проверяем, что произведение текущего и следующего элемента оканчивается на 7
    if (a[i] * a[i + 1]) % 10 == 7:
        # перезаписываем максимальное произведение
        maxim = max(maxim, a[i] * a[i + 1])
# вывод количества и максимальное произведение
print(ans, maxim)

Напишем программу, которая будет проверять все пары чисел, стоящих рядом друг с другом. Будем считать количество пар элементов, в произведении которых предпоследняя цифра - 7. Также будем искать максимульную сумму элементов среди тех пар, в которых сумма элементов кратна 42.

# Открываем файл
f = open("Задание_17__loog.txt")
# Считываем все числа и переводим их из строчного типа в целочисленный
a = [int(s) for s in f]
# Инициализируем счетчик и переменную, которая будет хранить максимальную сумму
counter, maxim = 0, -10 ** 10
# Перебираем все пары
for i in range(len(a) - 1):
# Если предпоследняя цифра произведения элементов пары - это 7
    if ((a[i] * a[i + 1]) // 10) % 10 == 7:
     # Увеличиваем счетчик на единицу
        counter += 1
    # Если сумма элементов пары кратна 42
    if (a[i] + a[i + 1]) % 42 == 0:
     # Обновляем переменную maxim
        maxim = max(maxim, a[i] + a[i + 1])
# Печатаем ответ
print(counter + maxim)

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

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

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

# Считываем числа из файла
a = [int(i) for i in f]
# Счётчик количества подходящих пар
k = 0
# Переменная максимальной суммы
mx = 0

# Перебираем все пары соседних элементов в списке
# -1, т.к. проверяем [i + 1]
for i in range(len(a) - 1):
    # Условия:
    # 1) хотя бы одно из чисел в паре должно быть натуральным,
    # 2) сумма пары должна давать остаток 7 при делении на 8
    if (a[i] > 0 or a[i + 1] > 0) and abs(a[i] + a[i + 1]) % 8 == 7:
        # Увеличиваем счётчик подходящих пар
        k += 1
        # Обновляем максимальную сумму,
        # если текущая пара больше предыдущей
        mx = max(mx, a[i] + a[i + 1])

print(k, mx)

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

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

# открываем файл
f = open(’Задание 17.txt’)
# считываем числа в список
a = [int(x) for x in f]
# среднее арифметическое значение файла
sr = sum(a)/len(a)
# количество подходящих пар
counter = 0
# максимальная сумма пар
maxim = 0
# Перебираем все пары последовательных элементов списка ’a’
for i in range(len(a)-1):
    # Проверяем, что хотя бы один элемент меньше среднего арифметического значения
    if (a[i] < sr or a[i+1] < sr):
        # увеличиваем счётчик
        counter += 1
        # перезаписываем максимальную сумму
        maxim = max(maxim, a[i]+a[i+1])
# вывод количества и максимальной суммы
print(counter, maxim)

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

# Открываем файл
f = open("17.txt")
# Считываем числа и переводим их из строчного типа в целочисленный
s = [int(x) for x in f]
# Инициализируем счетчик
count = 0
# Минимальное произведение чисел кратных 3
minpr = 10000000
# Проходимся по всем парам чисел
for i in range(len(s) - 1):
    # Если оба элемента пары кратны 5
    if s[i] % 5 == 0 and s[i+1] % 5 == 0:
     # Увеличиваем счетчик
        count += 1
        # Если произведение элементов этой же пары кратно 3
        if (s[i] * s[i+1]) % 3 == 0:
         # Обновляем переменную minpr
            minpr = min(minpr, s[i] * s[i+1])
# Выводим ответ
print(count, minpr)

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

Напишем программу, которая будет проверять все пары соседних чисел из файла, отбирая те, где произведение кратно 38 и оканчивается на 2. Для проверки первого условия будем находить остаток от деления на 38 произведения и сравнивать его с 0, если остаток равен 0, то произведение кратно 38. Для проверки второго условия будем находить остаток от деления на 10 произведения и сравнивать его с 2, если остаток равен 2, то произведение оканчивается на 2. Для проверки третьего условия будем находить остаток от деления на 10 суммы и сравнивать его с 7, если остаток равен 7, то сумма оканчивается на 7. Количество и максимальную сумму подходящих пары будем сохранять в отдельные переменные, чтобы после отработки цикла вывести их количество и максимальную сумму.

# открываем файл
f = open(’17.txt’)
# считываем числа в список
a = [int(x) for x in f]
# количество подходящих пар
counter = 0
# максимальная сумма пар
maxim = 0
# Считываем все строки из файла и преобразуем их в целые числа, сохраняя в список ’a’
for i in range(len(a)-1):
    # Проверяем, что произведение текущего и следующего элемента кратно 38 и оканчивается на 2
    # И сумма пары оканчивается на 7
    if (a[i]*a[i+1]) % 38 == 0 and (a[i]*a[i+1]) % 10 == 2:
        # увеличиваем счётчик
        counter += 1
        if (a[i]+a[i+1]) % 10 == 7:
            # перезаписываем максимальную сумму
            maxim = max(maxim, a[i]+a[i+1])
# вывод количества и максимальной суммы
print(counter, maxim)

Напишем программу, которая будет проверять все пары чисел, стоящих рядом друг с другом. Будем проверять: если произведение элементов пары кратно 12 и сумма элементов кратна 13, будем увеличивать счетчик и при необходимости обновлять переменную, которая будет содержать максимальную сумму элементов из подходящих пар.

# Открываем файл
f = open("17.txt")
# Считываем числа и переводим их из строчного типа в целочисленный
a = [int(x) for x in f]
# Инициализируем счетчик и переменную, которая будет хранить максимальную сумму
counter = 0
maxim = 0
# Перебираем все пары
for i in range(len(a)-1):
# Если произведение кратно 12 и сумму кратна 13
    if (a[i]*a[i+1]) % 12 == 0 and (a[i]+a[i+1]) % 13 == 0:
     # Увеличиваем счетчик и обновляем переменную  maxim
        counter += 1
        maxim = max(maxim, a[i+1]+a[i])
# Печатаем ответ
print(counter, maxim)

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

Напишем программу, которая будет проверять все пары соседних чисел из файла, подсчитывая те, где сумма кратна 6 и не кратна 9 и оканчивается на 2, и определяя максимальное произведение пары, которое оканчивается на 7. Для проверки первого условия будем находить остаток от деления на 6 суммы и сравнивать его с 0, если остаток равен 0, то сумма кратна 6. Для проверки второго условия будем находить остаток от деления на 9 суммы и сравнивать его с 0, если остаток не равен 0, то сумма кратна 9. Для проверки третьего условия будем находить остаток от деления на 10 суммы и сравнивать его с 2, если остаток равен 2, то сумма оканчивается на 2. Для проверки третьего условия будем находить остаток от деления на 10 произведения и сравнивать его с 7, если остаток равен 7, то произведение оканчивается на 7. Количество и максимальное произведение подходящих пар будем сохранять в отдельные переменные, чтобы после отработки цикла вывести их количество и максимальное произведение.

# открываем файл
f = open(’17.txt’)
# считываем числа в список
a = [int(x) for x in f]
# количество подходящих пар
counter = 0
# максимальное произведение пары
maxim = -100000
# Перебираем все пары последовательных элементов списка ’a’
for i in range(len(a)-1):
    # Проверяем, что сумма текущего и следующего элемента кратна 6 и не кратна 9 и оканчивается на 2
    if (a[i] + a[i+1]) % 6 == 0 and (a[i] + a[i+1]) % 9 != 0 and str(a[i] + a[i+1])[-1] == ’2’:
        counter += 1
    # Проверяем, что произведение текущего и следующего элемента оканчивается на 7
    if a[i] * a[i+1] % 10 == 7:
        maxim = max(maxim, a[i] * a[i + 1])
print(counter, maxim)

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

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

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

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

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

        # Проверяем, делится ли их сумма на 101
        if (a[i] + a[i + 1]) % 101 == 0:
            # Если да, то обновляем переменную минимума
            mn = min(mn, (a[i] + a[i + 1]))

print(c, mn)

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

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

# Считываем все числа из файла
f = open(’17.txt’)
a = [int(x) for x in f]

# Остаток от деления суммы всех чисел в файле на 100000
ost = sum(a) % 100000
# Количество найденных пар
count = 0
# Минимальная сумма элементов пар
mins = 100000000000

# Проходимся по всем парам чисел
for i in range(len(a) - 1):
    # Если пара нам подходит - обновляем ответ
    if (a[i] > ost and a[i+1] <= ost and a[i+1] % 100 == 99) or (a[i+1] > ost and a[i] <= ost and a[i] % 100 == 99):
        count += 1
        mins = min(mins, a[i] + a[i+1])
# Выводим ответ
print(count, mins)

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

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

# Считываем все числа из файла
f = open(’17.txt’)
a = [int(x) for x in f]

# Количество найденных пар
count = 0
# Максимальная сумма элементов пар
maxs = -100000000000

# Проходимся по всем парам чисел
for i in range(len(a) - 1):
    # Если пара нам подходит - обновляем ответ
    if abs(a[i] - a[i+1]) % 42 == 0:
        count += 1
        maxs = max(maxs, a[i] + a[i+1])
# Выводим ответ
print(count, maxs)

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

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

# Функция для подсчёта количества единиц в двоичной записи числа
def count_one(n):
    return bin(n)[2:].count(’1’)

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

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

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

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

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

Сначала считаем все числа из файла и найдём остаток от деления их суммы на 12345 — он нужен для сравнения в дальнейшем. Далее переберём все пары соседних чисел. Условие, по которому отбираем подходящие пары, следующее: хотя бы одно из чисел в паре должно быть больше этого остатка, а шестнадцатеричная запись другого должна заканчиваться на F (то есть число даёт остаток 15 при делении на 16). Также учитываем случай, если оба числа больше остатка — тогда хотя бы одно из них должно оканчиваться на F. Для каждой подходящей пары будем подсчитывать их количество и сохранять минимальную сумму.

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

# Остаток от деления суммы всех чисел в файле на 12345
ostat = sum(a) % 12345
# Количество найденных пар
count = 0
# Минимальная сумма элементов пар
mins = 100000000

# Проходимся по всем парам чисел
for i in range(len(a) - 1):
    # Если пара нам подходит - обновляем ответ
    if (a[i] > ostat and a[i+1] % 16 == 15) or \
       (a[i+1] > ostat and a[i] % 16 == 15) or \
       (a[i] > ostat and a[i+1] > ostat and \
       (a[i] % 16 == 15 or a[i+1] % 16 == 15)):
        count += 1
        mins = min(mins, a[i]+a[i+1])

# Выводим ответ
print(count, mins)

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

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

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

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

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

# Перебираем все пары подряд идущих чисел
for i in range(len(a) - 1):
    # Проверяем, является ли предпоследняя цифра произведения "6"
    # (сначала берём последние две цифры % 100, затем // 10 — получаем предпоследнюю)
    if a[i] * a[i + 1] % 100 // 10 == 6:
        # Увеличиваем счётчик подходящих пар
        c += 1

    # Если сумма пары кратна 137, то обновляем максимум
    if (a[i] + a[i + 1]) % 137 == 0:
        mx = max(a[i] + a[i + 1], mx)

print(c + mx)

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

Перебираем все пары подряд идущих чисел из последовательности. Для каждой пары проверяем два условия: сумма элементов должна быть чётной, а произведение — нечётным. Чётность суммы проверяем по остатку от деления на 2, если он равен 0, то сумма чётная, а нечётность произведения — по остатку от деления произведения на 2, если он не равен 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)