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

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

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

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

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

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

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

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

# Функция, которая возвращает true, если из тройки чисел можно построить треугольник
def triangle(a):
    minim = min(a[0], a[1], a[2])
    maxim = max(a[0], a[1], a[2])
    sred = a[0] + a[1] + a[2] - maxim - minim
    return minim + sred > maxim

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

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

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

# Функция для проверки пифагровой тройки
def pif(a, b, c):
    # Сортируем тройку по возрастанию,
    # чтобы наибольшее число стало третьим (гипотенузой)
    x, y, z = sorted((a, b, c))
    # Проверяем теорему Пифагора
    if z ** 2 == x ** 2 + y ** 2:
        return True
    else:
        return False


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

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

# Перебираем все возможные тройки подряд идущих чисел
for i in range(n - 2):
    # Считаем сумму текущей тройки
    sm = a[i] + a[i + 1] + a[i + 2]

    # Проверяем на пифагорову тройку
    if pif(a[i], a[i + 1], a[i + 2]):
        # Увеличиваем счётчик подходящих троек
        c += 1
        # Обновляем максимальную сумму, если текущая больше
        mx = max(mx, sm)

print(c, mx)
                                                                                                     
                                                                                                     

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

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

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

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

# Перебираем все тройки подряд идущих элементов
for i in range(len(a) - 2):
    # flag1: сколько чисел из тройки больше среднего значения по списку
    flag1 = (a[i] > sr) + (a[i + 1] > sr) + (a[i + 2] > sr)

    # flag2: сколько чисел из тройки содержат цифру ’7’ в десятичной записи
    # Каждая из конструкций вернет 1 или 0, в зависимости от наличия "7"
    flag2 = ("7" in str(a[i])) + ("7" in str(a[i + 1])) + ("7" in str(a[i + 2]))

    # Условие: хотя бы два из трёх чисел больше среднего
    # И хотя бы один из трёх содержит цифру 7
    if flag1 >= 2 and flag2 >= 1:
        counter += 1
        mx = max(mx, a[i] + a[i + 1] + a[i + 2])

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

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

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

f = open(’Задание_17__i0i6.txt’)
a = [int(x) for x in f]

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

# Перебираем все тройки подряд идущих чисел
for i in range(len(a) - 2):
    x, y, z = a[i], a[i+1], a[i+2]

    # Проверяем, что хотя бы одно число делится на 3
    flag1 = (x % 3 == 0) or (y % 3 == 0) or (z % 3 == 0)
    # Проверяем, что сумма тройки чётная
    flag2 = (x + y + z) % 2 == 0
    # Проверяем, что средний элемент больше среднего арифметического тройки
    flag3 = y > ((x + y + z) / 3)

    if flag1 and flag2 and flag3:
        ans += 1
        maxim = max(maxim, x + y + z)

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

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

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

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

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

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

# Перебираем все тройки подряд идущих чисел
for i in range(len(s) - 2):
    # Преобразуем числа в двоичное представление
    x1 = bin(s[i])[2:]
    x2 = bin(s[i + 1])[2:]
    x3 = bin(s[i + 2])[2:]

    # Проверяем, что в каждом числе ровно 3 единицы
    if x1.count(’1’) == x2.count(’1’) == x3.count(’1’) == 3:
        # Увеличиваем счётчик подходящих троек
        counter += 1
        # Добавляем в сумму максимальное число из тройки
        summa += max(s[i], s[i + 1], s[i + 2])

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

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

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

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

# Счётчик подходящих троек
counter = 0
# Переменная для максимального значения
mx = 0

# Перебираем все тройки подряд идущих чисел
for i in range(len(s) - 2):
    # Переводим каждое число тройки в двоичный вид, отбрасывая префикс
    x1 = bin(s[i])[2:]
    x2 = bin(s[i + 1])[2:]
    x3 = bin(s[i + 2])[2:]

    # Проверяем, удовлетворяет ли каждое число условиям:
    # не менее 3 единиц и хотя бы один ноль
    y1 = (x1.count("1") >= 3) * (x1.count("0") >= 1)
    y2 = (x2.count("1") >= 3) * (x2.count("0") >= 1)
    y3 = (x3.count("1") >= 3) * (x3.count("0") >= 1)

    # Если хотя бы два числа в тройке удовлетворяют условиям
    if sum([y1, y2, y3]) >= 2:
        # Увеличиваем счётчик
        counter += 1
        # Обновляем максимум, если в текущей тройке есть большее число
        mx = max(mx, s[i], s[i + 1], s[i + 2])

print(counter, mx)

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

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

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

# Счётчик троек
counter = 0
# Переменная для суммы
ans = 0

# Перебираем все тройки подряд идущих элементов
for i in range(len(s) - 2):
    # Сортируем тройку по возрастанию: a[2] — самая большая сторона
    a = sorted([s[i], s[i + 1], s[i + 2]])

    # Проверяем: квадрат наибольшей стороны < суммы квадратов других
    if a[2] ** 2 < (a[1] ** 2 + a[0] ** 2):
        counter += 1
        ans += max(a)  # Добавляем к ответу максимальный элемент тройки

print(counter, ans)

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

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

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

# Счётчик троек
counter = 0
# Переменная для сумм гипотенуз
ans = 0

# Перебираем все тройки подряд идущих элементов
for i in range(len(s) - 2):
    # Сортируем по возрастанию: a[2] — наибольший элемент (гипотенуза)
    a = sorted([s[i], s[i + 1], s[i + 2]])

    # Проверяем выполнение теоремы Пифагора
    if a[2] ** 2 == (a[0] ** 2 + a[1] ** 2):
        counter += 1
        ans += max(a)  # Прибавляем гипотенузу

print(counter, ans)

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

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

# Перевод в пятеричную систему
def cc_5(n):
    q = ’’
    k = n
    while k > 0:
        q = str(k % 5) + q
        k //= 5
    return q

# Сумма цифр числа
def summa_ch(n):
    summa = 0
    k = n
    while k > 0:
        summa += (k % 10)
        k //= 10
    return summa

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

# Подсчёт среднего арифметического для кратных 31
counter_31 = 0
summa_31 = 0
for i in range(len(s)):
    if s[i] % 31 == 0:
        counter_31 += 1
        summa_31 += s[i]
sr_31 = summa_31 / counter_31

# Поиск подходящих троек
ans = 0
minim = 10 ** 10
for i in range(len(s) - 2):
    # Среднее арифметическое тройки
    sr = (s[i] + s[i + 1] + s[i + 2]) / 3
    if sr > sr_31:
                                                                                                     
                                                                                                     
        # Сумма всех цифр в тройке
        summa = summa_ch(s[i]) + summa_ch(s[i + 1]) + summa_ch(s[i + 2])
        # Перевод в пятеричную систему
        summa = cc_5(summa)
        # Проверка на палиндром
        if summa == summa[::-1]:
            ans += 1
            minim = min(minim, s[i] + s[i + 1] + s[i + 2])

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

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

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

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

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

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

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

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

# Проходим по всем тройкам подряд идущих элементов
for index in range(len(arr) - 2):
    # Сортируем тройку для удобства сравнения сторон
    arr_sort = sorted([arr[index], arr[index + 1], arr[index + 2]])
    # Проверяем условие остроугольного треугольника
    if arr_sort[2] ** 2 < arr_sort[1] ** 2 + arr_sort[0] ** 2:
        counter_pairs += 1
        max_summ = max(max_summ, sum(arr_sort))

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

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

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

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

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

# проходим по всем тройкам подряд идущих элементов
for i in range(len(arr) - 2):
    k1 = arr[i] % 16 == 0  # проверка последнего разряда первого числа в шестнадцатеричной системе
    k2 = arr[i + 1] % 16 == 0  # то же для второго
    k3 = arr[i + 2] % 16 == 0  # то же для третьего

    # если хотя бы два числа из тройки заканчиваются на 0 в шестнадцатеричной системе
    if (k1 + k2 + k3) >= 2:
        counter += 1  # увеличиваем счетчик
        max_summ += max(arr[i], arr[i + 1], arr[i + 2])  # прибавляем максимальное число тройки

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

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

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

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

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

# проходим по всем тройкам подряд идущих элементов
for i in range(len(arr) - 2):
    arr_sort = sorted([arr[i], arr[i + 1], arr[i + 2]])  # сортируем тройку для удобства проверки
    # проверяем условие прямоугольного треугольника по теореме Пифагора
    if arr_sort[2] ** 2 == arr_sort[0] ** 2 + arr_sort[1] ** 2:
        counter += 1  # увеличиваем счетчик
        max_summ += arr_sort[2]  # добавляем гипотенузу к сумме

# выводим количество и сумму гипотенуз
print(counter, max_summ)

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

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

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

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

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

# Функция для вычисления произведения цифр числа
def p(n):
    pr = 1
    x = n
    while x > 0:
        pr *= x % 10
        x = x // 10
    return pr

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

# находим все числа, кратные 88
b = [x for x in a if x % 88 == 0]

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

n = len(a)
counter = 0
maxim = -100000000000000000

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

    # произведение произведений цифр каждого из трёх чисел
    t = p(x) * p(y) * p(z)
                                                                                                     
                                                                                                     

    # переводим это число в восьмеричную систему
    s = vosem(t)

    # проверяем, является ли восьмеричная запись палиндромом
    if s == s[::-1]:
        # проверяем среднее арифметическое тройки
        if (x + y + z) / 3 > sr:
            counter += 1
            maxim = max(maxim, x + y + z)

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

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

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

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

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

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

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

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

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

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

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

# вычисляем сумму максимального и минимального чисел в файле
summa = min(a) + max(a)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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