1. Как решать задание ЕГЭ
7. Задание проверяет умение составить алгоритм обработки числовой последовательности и записать его в виде простой программы на языке программирования.
Пример задания (демоверсия \(2022\))
Рис. \(1\). Пример задания
Что нужно знать?
1. Как считать данные из файла в список.
Для работы с файлом удобно использовать конструкцию with :
with open (file) as f:
инструкции
Эта конструкция определяет для открытого файла переменную \(f\) и выполняет набор инструкций. После их выполнения файл автоматически закрывается. Метод readlines() прочитает и вернёт все строки в файле в виде списка.
Для работы с данными файла мы будем использовать следующий программный код:
with open (\(’17.txt’\)) as f:
\(a=\) [int(\(x\)) for \(x\) in f.readlines()]
2. Основные операторы для работы со списками (массивами).
В Python для того, чтобы работать с большим количеством данных, используется структура данных под названием список . Список представляет собой последовательность (набор) элементов, пронумерованных от \(0\).
Чтобы объявить список, нужно в квадратных скобках перечислить его элементы через запятую:
Элементы списка могут быть разных типов в отличие от элементов массива, но, как правило, используются списки из элементов одного типа.
Методы списков
| \(a.append (x)\) | добавляет элемент \(x\) в конец списка \(a\) |
| \(a.count (x)\) | возвращает количество элементов списка \(a\) со значением \(x\) |
| \(а.sort ()\) | сортирует список \(a\) в порядке возрастания |
| \(а.reverse ()\) | разворачивает список \(a\) в обратном порядке |
| \(a.clear ()\) | очищает список \(a\) |
Функции для работы со списками
| \(len(a)\) | возвращает длину списка \(a\) (количество элементов списка \(a\)) |
| \(min(a)\) | возвращает наименьший элемент списка \(a\) |
| \(max(a)\) | возвращает наибольший элемент списка \(a\) |
| \(sum(a)\) | возвращает сумму элементов списка \(a\) |
Решение задачи можно разбить на этапы.
1. Считать данные из текстового файла в массив (список). Важно, чтобы программа решения и текстовый файл лежали в одной папке (или необходимо указать полный путь для считывания файла).
with open (\(’17.txt’\)) as\(f\):
\(a=\) [int(\(x\)) for \(x\) in f.readlines()]
2. Необходимо в массиве найти максимальное число, кратное \(3\). Для этого инициализируем пустой массив \(b\). Затем с помощью цикла \(for\) переберём все элементы массива \(a\). Если элемент кратен \(3\), то запишем его в массив \(b\). После выполнения цикла в переменную \(m\) запишем максимальное значение массива \(b\).
\(b=[]\)
for \(i\) in range (\(0,len(a)\)):
if \(a[i]\) % \(3= =0\):
b.append\((a[i])\)
\(m=max(b)\)
3. Определим количество подходящих пар. Для этого очистим массив \(b\). Затем с помощью цикла \(for\) переберём все элементы массива \(a\). Если хотя бы один элемент пары делится на \(3\) и сумма элементов пары не больше \(m\), то запишем эту сумму в массив \(b\).
\(b=[]\)
for \(i\) in range (\(0\),\(len(a)-1\)):
if (\(a[i]\) % \(3= =0\) or \(a[i+1]\) % \(3= =0\)) and (\(a[i]+a[i+1] <=m\)):
b.append (\(a[i]+a[i+1]\))
4. Выведем на экран количество элементов массива \(b\) — оно равно количеству подходящих пар — и максимальную сумму:
print (\(len(b), max(b)\))
Получилась программа:
with open (\(’17.txt’\)) as\(f\):
\(a=\) [int(\(x\)) for \(x\) in f.readlines()]
\(b=[]\)
for \(i\) in range (\(0,len(a)\)):
if \(a[i]\) % \(3= =0\):
b.append (\(a[i]\))
\(m=max(b)\)
\(b=[]\)
for \(i\) in range (\(0,len(a)-1\)):
if (\(a[i]\) % \(3= =0\) or \(a[i+1]\) % \(3= =0\)) and (\(a[i]+a[i+1] <=m\)):
b.append (\(a[i]+a[i+1]\))
Файлы. Работа с файлами.
В данной статье мы рассмотрим встроенные средства python для работы с файлами: открытие / закрытие, чтение и запись.
Итак, начнем. Прежде, чем работать с файлом, его надо открыть. С этим замечательно справится встроенная функция open:
f = open('text.txt', 'r')
У функции open много параметров, они указаны в статье «Встроенные функции«, нам пока важны 3 аргумента: первый, это имя файла. Путь к файлу может быть относительным или абсолютным. Второй аргумент, это режим, в котором мы будем открывать файл.
| Режим | Обозначение |
| ‘r’ | открытие на чтение (является значением по умолчанию). |
| ‘w’ | открытие на запись, содержимое файла удаляется, если файла не существует, создается новый. |
| ‘x’ | открытие на запись, если файла не существует, иначе исключение. |
| ‘a’ | открытие на дозапись, информация добавляется в конец файла. |
| ‘b’ | открытие в двоичном режиме. |
| ‘t’ | открытие в текстовом режиме (является значением по умолчанию). |
| ‘+’ | открытие на чтение и запись |
Режимы могут быть объединены, то есть, к примеру, ‘rb’ — чтение в двоичном режиме. По умолчанию режим равен ‘rt’.
И последний аргумент, encoding, нужен только в текстовом режиме чтения файла. Этот аргумент задает кодировку.
Чтение из файла
Открыли мы файл, а теперь мы хотим прочитать из него информацию. Для этого есть несколько способов, но большого интереса заслуживают лишь два из них.
Первый — метод read, читающий весь файл целиком, если был вызван без аргументов, и n символов, если был вызван с аргументом (целым числом n).
>>> f = open('text.txt') >>> f.read(1) 'H' >>> f.read() 'ello world!\nThe end.\n\n'
Ещё один способ сделать это — прочитать файл построчно, воспользовавшись циклом for:
>>> f = open('text.txt') >>> for line in f: . line . 'Hello world!\n' '\n' 'The end.\n' '\n'
Запись в файл
Теперь рассмотрим запись в файл. Попробуем записать в файл вот такой вот список:
>>> l = [str(i)+str(i-1) for i in range(20)] >>> l ['0-1', '10', '21', '32', '43', '54', '65', '76', '87', '98', '109', '1110', '1211', '1312', '1413', '1514', '1615', '1716', '1817', '1918']
Откроем файл на запись:
>>> f = open('text.txt', 'w')
Запись в файл осуществляется с помощью метода write:
>>> for index in l: . f.write(index + '\n') . 4 3 3 3 3
Для тех, кто не понял, что это за цифры, поясню: метод write возвращает число записанных символов.
После окончания работы с файлом его обязательно нужно закрыть с помощью метода close:
>>> f.close()
Теперь попробуем воссоздать этот список из получившегося файла. Откроем файл на чтение (надеюсь, вы поняли, как это сделать?), и прочитаем строки.
>>> f = open('text.txt', 'r') >>> l = [line.strip() for line in f] >>> l ['0-1', '10', '21', '32', '43', '54', '65', '76', '87', '98', '109', '1110', '1211', '1312', '1413', '1514', '1615', '1716', '1817', '1918'] >>> f.close()
Мы получили тот же список, что и был. В более сложных случаях (словарях, вложенных кортежей и т. д.) алгоритм записи придумать сложнее. Но это и не нужно. В python уже давно придумали средства, такие как pickle или json, позволяющие сохранять в файле сложные структуры.
Добавить комментарий Отменить ответ
ЕГЭ на соточку для чайников
Прошу прощения, что так долго пропадал. Питошка вернулся, да еще и с группой в вконтакте, подписывайтесь. Помимо этого, на питошке откроется новая рубрика, в которой будут четкие объяснения всех заданий ЕГЭ и ОГЭ по информатике, внимательно прочитав которые, я уверен, вы улучшите свои баллы на экзамене ��
Функция open. Чтение и запись текстовых файлов в Python
Большие объемы данных хранят не в списках или словарях, а в файлах и базах данных. В этом уроке изучим особенности работы с текстовыми файлами в Python. Такие файлы рассматриваются как содержащие символы и строки.
Бывают еще байтовые (бинарные) файлы, которые рассматриваются как потоки байтов. Побайтово считываются, например, файлы изображений. Работа с бинарными файлами несколько сложнее. Нередко их обрабатывают с помощью специальных модулей Python (pickle, struct).
Функция open
Связь с файлом на жестком диске выполняется с помощью встроенной в Python функции open() . Обычно ей передают один или два аргумента. Первый – имя файла или имя с адресом, если файл находится не в том каталоге, где находится сама программа. Второй аргумент – режим, в котором открывается файл.
Обычно используются режимы чтения ( ‘r’ ) и записи ( ‘w’ ). Если файл открыт в режиме чтения, то запись в него невозможна. Можно только считывать данные. Если файл открыт в режиме записи, то в него можно только записывать данные, считывать нельзя.
Если файл открывается в режиме ‘w’ , то все данные, которые в нем были до этого, стираются. Файл становится пустым. Если не надо удалять существующие в файле данные, тогда следует использовать вместо режима записи, режим дозаписи ( ‘a’ ).
Если файл отсутствует, то открытие его в режиме ‘w’ создаст новый файл. Бывают ситуации, когда надо гарантировано создать новый файл, избежав случайной перезаписи данных существующего. В этом случае вместо режима ‘w’ используется режим ‘x’ . В нем всегда создается новый файл для записи. Если указано имя существующего файла, то будет выброшено исключение. Потери данных в уже имеющемся файле не произойдет.
Если при вызове open() второй аргумент не указан, то файл открывается в режиме чтения как текстовый файл. Чтобы открыть файл как байтовый, дополнительно к букве режима чтения/записи добавляется символ ‘b’ . Буква ‘t’ обозначает текстовый файл. Поскольку это тип файла по умолчанию, то обычно ее не указывают.
Нельзя указывать только тип файла, то есть open(«имя_файла», ‘b’) есть ошибка, даже если файл открывается на чтение. Правильно – open(«имя_файла», ‘rb’) . Только текстовые файлы мы можем открыть командой open(«имя_файла») , потому что и ‘r’ и ‘t’ подразумеваются по-умолчанию.
Функция open() возвращает объект файлового типа. Его надо либо сразу связать с переменной, чтобы не потерять, либо сразу прочитать.
Чтение файла
С помощью файлового метода read() можно прочитать файл целиком или только определенное количество байт. Пусть у нас имеется файл data.txt с таким содержимым:
one - 1 - I two - 2 - II three - 3 - III four - 4 - IV five - 5 - V
Откроем его и почитаем:
>>> f1 = open(‘data.txt’) >>> f1.read(10) ‘one — 1 — ‘ >>> f1.read() ‘I\ntwo — 2 — II\nthree — 3 — III\nfour — 4 — IV\nfive — 5 — V\n’ >>> f1.read() » >>> type(f1.read())
Сначала считываются первые десять символов. Последующий вызов read() считывает весь оставшийся текст. После этого объект файлового типа f1 становится пустым.
Заметим, что метод read() возвращает строку, и что конец строки считывается как ‘\n’ .
Для того, чтобы читать файл построчно существует метод readline() :
>>> f1 = open('data.txt') >>> f1.readline() 'one - 1 - I\n' >>> f1.readline() 'two - 2 - II\n' >>> f1.readline() 'three - 3 — III\n'
Метод readlines() считывает сразу все строки и создает список:
>>> f1 = open('data.txt') >>> f1.readlines() ['one - 1 - I\n', 'two - 2 - II\n', 'three - 3 - III\n', 'four - 4 - IV\n', 'five - 5 - V\n']
Объект файлового типа относится к итераторам. Из таких объектов происходит последовательное извлечение элементов. Элементами в данном случае являются строки-линии файла. Поэтому считывать данные из файла можно сразу в цикле без использования методов чтения:
>>> for i in open('data.txt'): . print(i) . one - 1 - I two - 2 - II three - 3 - III four - 4 - IV five - 5 - V >>>
Здесь выводятся лишние пустые строки, потому что функция print() преобразует ‘\n’ в переход на новую строку. К этому добавляет свой переход на новую строку. Создадим список строк файла без ‘\n’ :
>>> nums = [] >>> for i in open('data.txt'): . nums.append(i[:-1]) . >>> nums ['one - 1 - I', 'two - 2 - II', 'three - 3 - III', 'four - 4 - IV', 'five - 5 - V']
Переменной i присваивается очередная строка файла. Мы берем ее срез от начала до последнего символа, не включая его. Следует иметь в виду, что ‘\n’ это один символ, а не два.
Запись в файл
Запись в файл выполняется с помощью методов write() и writelines() . Во второй можно передать структуру данных:
>>> l = ['tree', 'four'] >>> f2 = open('newdata.txt', 'w') >>> f2.write('one') 3 >>> f2.write(' two') 4 >>> f2.writelines(l)
Метод write() возвращает количество записанных символов.
Закрытие файла
После того как работа с файлом закончена, важно не забывать его закрыть, чтобы освободить место в памяти. Делается это с помощью файлового метода close() . Свойство файлового объекта closed позволяет проверить закрыт ли файл.
>>> f1.close() >>> f1.closed True >>> f2.closed False
Если файл открывается в заголовке цикла ( for i in open(‘fname’) ), то видимо интерпретатор его закрывает при завершении работы цикла или через какое-то время.
Практическая работа
- Создайте файл data.txt по образцу урока. Напишите программу, которая открывает этот файл на чтение, построчно считывает из него данные и записывает строки в другой файл ( dataRu.txt ), заменяя английские числительные русскими, которые содержатся в списке ( [«один», «два», «три», «четыре», «пять»] ), определенном до открытия файлов.
- Создайте файл nums.txt , содержащий несколько чисел, записанных через пробел. Напишите программу, которая подсчитывает и выводит на экран общую сумму чисел, хранящихся в этом файле.
Примеры решения и дополнительные уроки в pdf-версии курса
X Скрыть Наверх
Python. Введение в программирование
ЕГЭ по информатике 2022 — Задание 17 (Пишем программу)
Привет! Сегодня поговорим о 17 задании ЕГЭ по информатике 2022.
В 17 задании нужно считать числа из файла, проанализировать их и ответить на вопрос задачи.
Будем решать задание на языке Python.
Задача (Минимальное значение)
В файле содержится последовательность целых чисел. Элементы последовательности могут принимать целые значения от -10000 до 10000 включительно. Определите и запишите в ответе сначала количество пар элементов последовательности, в которых оба числа делятся нацело на 7, затем минимальную из сумм элементов таких пар. В данной задаче под парой подразумевается два подряд идущих элемента последовательности. Например для последовательности из пяти элементов: 7; 14; 21; -7; 4 — ответ 3 14.
Напишем программу на языке Python.
f=open('17_1.txt') count=0 sm=20000 n1=int(f.readline()) for s in f.readlines(): n2=int(s) if n1%7==0 and n2%7==0: count=count+1 sm=min(n1+n2, sm) n1=n2 print(count) print(sm)
В начале подвязываемся к файлу с помощью команды open().
Переменная count отвечает за количество пар, удовлетворяющих условию задачи. Переменная sm — это минимальная сумма элементов подходящих пар.
В начале в переменную sm кладём максимальное число, которое теоретически может получится (10000 + 10000). Это делается для того, чтобы это значение можно было легко «победить» при поиске минимального значения.
Затем считываем в переменную n1 первое число. C помощью конструкции » for s in f.readlines():» можно перебрать остальные числа из файла. В цикле считываем второе число для пары в переменную n2.
После того, как два числа у нас есть, мы анализируем эти элементы на условие задачи. Если одновременно два числа из пары делятся на 7, то мы подсчитываем такую пару.
Если пара подходит, то проверяем сумму элементов этой пары на минимальность. В переменную sm заносится минимальное значение из прежнего значения sm и претендующего нового значения n1+n2.
В конце цикла нужно переложить второе число в переменную n1, чтобы очередное число из файла считалось в переменную n2. Тем самым мы получим новую пару чисел.
Ответ:
| 97 | -15820 |
Задача (Проверяем на что оканчивается число)
В файле содержится последовательность целых чисел. Элементы последовательности могут принимать целые значения от -10000 до 10000 включительно. Определите и запишите в ответе сначала количество пар элементов последовательности, в которых оба числа оканчиваются или на 3, или на 5 (можно неодновременно), затем максимальную из сумм элементов таких пар. В данной задаче под парой подразумевается два подряд идущих элемента последовательности. Например для последовательности из пяти элементов: 3; 15; 25; -3; 4 — ответ 3 40.
f=open('17_2.txt') count=0 sm=-20000 n1=int(f.readline()) for s in f.readlines(): n2=int(s) if (abs(n1)%10==3 or abs(n1)%10==5) and (abs(n2)%10==3 or abs(n2)%10==5): count=count+1 sm=max(n1+n2, sm) n1=n2 print(count) print(sm)
Т.к. мы ищем максимальную сумму, то в начале в переменную sm кладём наоборот минимальное значение (-10000-10000=-20000).
Когда ищем на что оканчивается положительное число, мы применяем конструкцию x%10. Т.е. находим остаток от деления на 10. Пример: 16 % 10 = 6. Но для отрицательных чисел это не работает -16 % 10 = 4. Почему такой ответ получается, можете посмотреть в этом видео: https://www.youtube.com/watch?v=BRfgE3pP0_c. Поэтому, чтобы правильно найти на что оканчивается число, применяем функцию abs(), что означает модуль числа.
Здесь мы должны логические выражения для первого и второго числа взять в скобки, потому что логическая операция И имеет приоритет перед ИЛИ.
Ответ:
| 201 | 17366 |
В файле содержится последовательность целых чисел. Элементы последовательности могут принимать целые значения от -10000 до 10000 включительно. Определите и запишите в ответе сначала количество пар элементов последовательности, в которых хотя бы одно число является полным квадратом некоторого натурального числа, затем максимальную из сумм элементов таких пар. В данной задаче под парой подразумевается два подряд идущих элемента последовательности. Например для последовательности из пяти элементов: 9; 15; 23; -3; 4 — ответ 2 24.
f=open('17_3.txt') count=0 sm=-20000 n1=int(f.readline()) for s in f.readlines(): n2=int(s) if (n1>0 and (int(n1 ** 0.5) ** 2) == n1) or (n2>0 and (int(n2 ** 0.5) ** 2) == n2) : count=count+1 sm=max(n1+n2, sm) n1=n2 print(count) print(sm)
Здесь мы извлекаем корень из числа с помощью возведения в степень 0.5. Округляем результат в меньшую сторону с помощью функции int(). А затем снова возводим в квадрат. Если мы получили изначальное число, значит, это число и есть полный квадрат некоторого натурального числа.
Возведение в степень в 0.5 работает и для отрицательных чисел. Т.к. в задаче имеют ввиду квадраты натуральных чисел, то мы работаем только с числами, которые больше нуля.
Ответ:
| 60 | 18555 |
В файле 17-3.txt содержится последовательность целых чисел. Элементы последовательности могут принимать целые значения от -10 000 до 10 000 включительно. Определите и запишите в ответе сначала количество троек элементов последовательности, в которых числа расположены в порядке возрастания, затем минимальную из разностей наибольшего и наименьшего элементов таких троек. В данной задаче под тройкой подразумевается три идущих подряд элемента последовательности.
f=open('17-3.txt') count=0 rz=20000 n1=int(f.readline()) n2=int(f.readline()) for s in f.readlines(): n3 = int(s) if n1 < n2 < n3: count=count+1 mx = max(n1, n2, n3) mn = min(n1, n2, n3) rz = min(rz, mx-mn) n1=n2 n2=n3 print(count, rz)
С тройками решаем аналогично. До цикла считываем два числа. Внутри цикла считываем третье число.
В конце цикла перекладываем числа: второе число в n1, третье число в n2.
Ответ:
| 832 | 460 |
Задача (ЕГЭ по информатике, 2023)
В файле содержится последовательность целых чисел. Элементы последовательности могут принимать целые значения от -100000 до 100000 включительно. Определите количество троек элементов последовательности, в которых не более двух из трёх элементов являются четырёхзначными числами, а сумма элементов тройки не больше максимального элемента последовательности, оканчивающегося на 13.
В ответе запишите количество найдённых троек чисел, а затем максимальную из сумм элементов таких троек.
В данной задаче под тройкой подразумевается три идущих подряд элемента последовательности.
В начале нужно найти максимальный элемент всей последовательности, который оканчивается на 13.
f=open('17_2023_1.txt') mx=-10**10 for s in f.readlines(): x=int(s) if abs(x)%100==13: mx=max(mx, x) print(mx)
Получается число 97213. Важно не забыть, что числа могут быть и отрицательные. В этом случае, когда мы проверяем окончание числа, нужно поставить модуль!
Теперь напишем основную программу для 17 задания из ЕГЭ по информатике.
def F(n): if (-10000 < n < -999) or (999 < n < 10000): return True else: return False f=open('17_2023_1.txt') n1=int(f.readline()) n2=int(f.readline()) k=0 mx=-10**10 for s in f.readlines(): n3=int(s) c=0 if F(n1): c=c+1 if F(n2): c=c+1 if F(n3): c=c+1 if cand (n1+n2+n3) max(mx, n1+n2+n3) n1=n2 n2=n3 print(k, mx)
Чтобы проверить число тройки, является ли оно четырёхзначным, создали специальную функцию F.
После того, как три числа из тройки зачитаны, для каждой тройки заводим счётчик c. Так мы сможем отследить, сколько чисел удовлетворяют условию задачи для каждой тройки.
Проверяем каждую тройку, подходит ли она по условию задачи.
Ответ:
| 5736 | 97127 |
Задача (Любой порядок элементов)
В файле содержится последовательность из 10 000 целых положительных чисел. Каждое число не превышает 10 000. Определите и запишите в ответе сначала количество пар элементов последовательности, у которых сумма элементов кратна 9, затем максимальную из сумм элементов таких пар. В данной задаче под парой подразумевается два различных элемента последовательности. Порядок элементов в паре не важен.
Первый способ (Красивый).
f = open('17.txt') count_0 = 0 count_1 = 0 count_2 = 0 count_3 = 0 count_4 = 0 count_5 = 0 count_6 = 0 count_7 = 0 count_8 = 0 mx1_0 = 0 mx2_0 = 0 mx_1 = 0 mx_2 = 0 mx_3 = 0 mx_4 = 0 mx_5 = 0 mx_6 = 0 mx_7 = 0 mx_8 = 0 for s in f.readlines(): n=int(s) if n%9==0: count_0 = count_0 + 1 if n>mx1_0: if n>mx2_0: mx1_0 = mx2_0 mx2_0 = n else: mx1_0 = n if n%9==1: count_1 = count_1 + 1 mx_1 = max(mx_1, n) if n%9==2: count_2 = count_2 + 1 mx_2 = max(mx_2, n) if n%9==3: count_3 = count_3 + 1 mx_3 = max(mx_3, n) if n%9==4: count_4 = count_4 + 1 mx_4 = max(mx_4, n) if n%9==5: count_5 = count_5 + 1 mx_5 = max(mx_5, n) if n%9==6: count_6 = count_6 + 1 mx_6 = max(mx_6, n) if n%9==7: count_7 = count_7 + 1 mx_7 = max(mx_7, n) if n%9==8: count_8 = count_8 + 1 mx_8 = max(mx_8, n) count = (count_1*count_8) + (count_2*count_7) + (count_3*count_6) + (count_4*count_5) + (count_0*(count_0-1)//2) mx = max(mx_1 + mx_8, mx_2 + mx_7, mx_3 + mx_6, mx_4 + mx_5, mx1_0 + mx2_0) print(count, mx)
Здесь мы ищем количество элементов, у которых остаток при делении на 9 равен нулю, единице, двойке, . и до 8. Подсчитываем эти данные соответственно в переменные count_0, count_1, count_2 . и т.д.
Так же находим максимальное число, которое имеет при делении на 9 остаток равный единице, двойке, . и т.д. Для чисел, которые имеют остаток при делении на 9 ноль, находим два максимальных числа.
После того, как результаты находятся в нужных переменных, можно вычислить ответ к задаче.
Если, к примеру, взять число для которого остаток равен 1 и число для которого остаток равен 8, то их сумма будет делится на 9. Найдём количество пар, если нам известно количество и тех, и тех чисел.
Значит, просто нужно перемножить два числа, к примеру, count_1*count_8.
Для чисел, которые делятся на 9 (т.е. остаток равен нулю), количество пар считается немного по-другому. Такие числа можно суммировать между собой, всё равно сумма тоже будет делится на 9. Путь есть у нас количество чисел count_0, которые делятся на 9. Тогда найдём количество пар, которые можно составить из этих элементов.
Здесь вспомним метод умножения, о котором было написано в этой статье.
Найдём количество таких пар, если каждый элемент можно использовать 1 раз. Получается count_0*(count_0-1). Но т.к. в нашем случае пара, когда элементы находятся в одном порядке и в обратном, является одной и той же, то нужно это количество поделить на 2. Т.е количество пар будет (count_0*(count_0-1))/2.
Второй способ (Перебор).
f = open('17.txt') count=0 mx=0 a = [] #Считываем все числа в массив a for s in f.readlines(): n = int(s) a.append(n) # Перебираем все варианты и подсчитываем пары, отвечающие условию задачи. for i in range(0, len(a)): for j in range(i+1, len(a)): if (a[i]+a[j])%9==0: count = count + 1 mx = max(a[i]+a[j], mx) print(count, mx)
В этом решении сначала считываем все числа в массив a.
Далее берём число и начинаем его комбинировать со всеми числами, которые стоят после этого числа. Таким образом, мы переберём все возможные комбинации, и у нас не будут пары повторяться.
Ответ:
| 5553635 | 19998 |