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

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

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

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

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

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

# количество элементов в последовательности
n = len(a)

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

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

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

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

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

# читаем количество элементов последовательности
n = int(f.readline())

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

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

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

# выводим количество подходящих пар
print(count)

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

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

# открываем файл с числами
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)):
        # проверяем два условия:
        # 1) разность элементов чётна
        # 2) хотя бы один элемент делится на 33
        if (a[i] - a[j]) % 2 == 0 and (a[i] % 33 == 0 or a[j] % 33 == 0):
            count += 1
            # обновляем максимальную сумму, если нашли большую
            maxim = max(maxim, a[i] + a[j])

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

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

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

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

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

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

# переменная для хранения минимального элемента, кратного 24 (берём большое число для начала)
min24 = 100000000

# переменная для хранения максимальной суммы подходящих пар (берём большое отрицательное число)
maxim = -100000000

# находим минимальный элемент последовательности, кратный 24
for i in range(len(a)):
    if a[i] % 24 == 0 and a[i] < min24:
        min24 = a[i]

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

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

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

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

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

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

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

# количество элементов в последовательности
n = len(a)

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

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

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

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

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

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

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

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

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

# находим минимальное трёхзначное число, оканчивающееся на 3
for i in range(len(a)):
    if 99 < a[i] < 1000 and a[i] % 10 == 3:
        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):
            # проверяем, что сумма кратна минимальному трёхзначному числу, оканчивающемуся на 3
            if (a[i] + a[j]) % mintr == 0:
                count += 1
                # обновляем минимальную сумму, если нашли меньшую
                minim = min(minim, a[i] + a[j])

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

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

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

# открываем файл с числами
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)):
        # проверяем, делится ли произведение пары на 49
        if (a[i] * a[j]) % 49 == 0:
            count += 1
            # обновляем максимальную сумму, если нашли большую
            maxim = max(maxim, a[i] + a[j])

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

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

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

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

# читаем количество элементов последовательности
n = int(f.readline())

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

# создаём список произведений всех пар элементов (i < j)
p = []
for i in range(len(a) - 1):
    for j in range(i + 1, len(a)):
        p += [a[i] * a[j]]

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

# перебираем все соседние пары
for i in range(len(a) - 1):
    prod = a[i] * a[i + 1]
    # проверяем два условия:
    # 1) произведение кратно 48
    # 2) произведение встречается в списке произведений более одного раза (то есть есть другая пара с таким же произведением)
    if prod % 48 == 0 and p.count(prod) > 1:
        c += 1

# выводим количество подходящих пар
print(c)

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

Напишем программу, которая будет проверять все пары положительных элементов последовательности, у которых сумма нечётна и между которыми есть хотя бы один ноль. Для этого будем перебивать все пары элементов с индексами i и j так, чтобы между ними был хотя бы один элемент (j > i+1). Проверим, что оба элемента положительные, а сумма их нечётна (остаток от деления суммы на 2 не равен 0). Далее проверим, есть ли в промежутке между i и j хотя бы один ноль. Если все условия выполняются, увеличиваем счётчик. После перебора всех пар выведем количество подходящих пар.

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

# читаем количество элементов последовательности
n = int(f.readline())

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

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

# перебираем пары элементов с индексами i и j, где j > i+1 (между ними есть хотя бы один элемент)
for i in range(n):
    for j in range(i + 2, n):
        # проверяем, что сумма элементов нечётна и оба положительны
        if (a[i] + a[j]) % 2 != 0 and a[i] > 0 and a[j] > 0:
            # проверяем наличие хотя бы одного нуля между элементами пары
            for k in range(i + 1, j):
                if a[k] == 0:
                    count += 1
                    break  # если нашли ноль, выходим из внутреннего цикла

# выводим количество подходящих пар
print(count)

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

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

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

# читаем первое число из файла — количество элементов последовательности
n = int(f.readline())

# считываем оставшиеся числа в список
a = [int(i) for i in f]

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

# перебираем все соседние пары элементов
for i in range(len(a) - 1):
    # проверяем, делится ли произведение пары на 34
    if (a[i] * a[i + 1]) % 34 == 0:
        c += 1

# выводим количество подходящих пар
print(c)

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

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

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

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

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

# перебираем все соседние пары элементов
for i in range(len(a) - 1):
    # проверяем условие: сумма пары меньше 3000
    if (a[i] + a[i + 1]) < 3000:
        c += 1
        mn = min(mn, a[i] * a[i + 1])

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

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

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

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

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

# инициализируем счётчик и минимальную сумму
c = 0
mn = 10**10

# перебираем все соседние пары элементов
for i in range(len(a) - 1):
    # проверяем условия:
    # оба числа делятся на 9
    # ни одно из чисел не делится на 13
    if a[i] % 9 == 0 and a[i + 1] % 9 == 0 and a[i] % 13 != 0 and a[i + 1] % 13 != 0:
        c += 1
        mn = min(mn, a[i] + a[i + 1])

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

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

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

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

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

# инициализируем счётчик и минимальную сумму
c = 0
mn = 10**10

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

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

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

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

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

c = 0  # Счётчик подходящих пар
mx = -10**9  # Максимальная сумма подходящих пар

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

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

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

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

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

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

# перебираем все пары соседних элементов
for i in range(len(a)-1):
    # вычисляем квадрат разности и сравниваем с квадратом первого элемента
    if (a[i] - a[i+1])**2 < a[0]**2:
        c += 1
        # обновляем минимальную сумму пары, если текущая меньше
        mn = min(a[i] + a[i+1], mn)

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

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

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

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

# находим минимальное трёхзначное число, оканчивающееся на 4
mn4 = min([x for x in a if x % 10 == 4 and 100 <= x <= 999])

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

# перебираем все пары различных элементов
for i in range(len(a) - 1):
    for j in range(i + 1, len(a)):
        # текущая пара из двух чисел
        temp = [a[i], a[j]]
        # список чисел из пары, которые являются трёхзначными
        check = [x for x in temp if 100 <= x <= 999]
        # проверяем, что ровно одно число трёхзначное
        # и сумма элементов кратна найденному числу mn4
        if len(check) == 1 and sum(temp) % mn4 == 0:
            ans.append(a[i] + a[j])

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

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

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

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

# находим максимальное число, кратное 15, в списке
mx = max([x for x in a if x % 15 == 0])

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

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

# перебираем все пары подряд идущих элементов
for i in range(len(a) - 1):
    # проверяем, что хотя бы один элемент пары больше максимума, кратного 15
    if a[i] > mx or a[i + 1] > mx:
        k += 1
        # обновляем минимальную сумму, если нашли меньшее значение
        if (a[i] + a[i + 1]) < mn:
            mn = a[i] + a[i + 1]

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

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

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

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

# создаём список чисел, которые делятся на 6 без остатка
k6 = [x for x in a if x % 6 == 0]

# вычисляем среднее арифметическое чисел, кратных 6
avg = sum(k6) / len(k6)

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

# переменная для хранения максимальной суммы подходящих пар (берём очень маленькое число для начала)
mx = -100000

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

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

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

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

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

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

# переменная для хранения максимальной суммы подходящих пар (берём достаточно маленькое число)
mx = -10000

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

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

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

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

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

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

# переменная для хранения максимальной суммы подходящих пар (берём очень маленькое число для начала)
mx = -10000

# перебираем все пары различных элементов (i < j)
for i in range(len(a)):
    for j in range(i + 1, len(a)):
        # проверяем условие: сумма элементов кратна 134
        if (a[i] + a[j]) % 134 == 0:
            k += 1
            # обновляем максимальную сумму, если нашли большее значение
            mx = max(mx, a[i] + a[j])

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