509625 решу егэ

Содержание:

• Объяснение задания 25 ЕГЭ по информатике
  • Алгоритмизация и программирование
• Решение 25 заданий ЕГЭ по информатике
  • Делители числа
  • Простые числа
• Задания прошлых лет для тренировки (до 2021)
  • Задачи с поэлементной обработкой массива
  • Задачи на обработку элементов массива с последующей заменой
  • Задачи на обработку пар элементов массива (два подряд идущих)
  • Задачи на обработку трёх подряд идущих элементов массива (тройки элементов массива)
  • Задачи на поиск максимума, минимума элементов массива и другие
• Решение 25 заданий ЕГЭ по информатике: более сложные задания

25-е задание: «Программная обработка целочисленной информации»

Уровень сложности

— высокий,

Требуется использование специализированного программного обеспечения

— да,

Максимальный балл

— 2,

Примерное время выполнения

— 20 минут.

  
Проверяемые элементы содержания: Умение создавать собственные программы (10–20 строк) для обработки целочисленной информации

25_7:

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку [126849; 126871], числа, имеющие ровно 4 различных делителя.
Выведите эти четыре делителя для каждого найденного числа в порядке возрастания.

✎ Решение (неоптимизированный вариант, метод полного перебора):

PascalABC.net: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 begin var divCount := 4; for var n := 126849 to 126871 do begin var divs := new List<integer>; for var d := 1 to n do if n mod d = 0 then begin divs.Add(d); if divs.Count > divCount then break; end; if divs.Count = divCount then begin divs.Sort(); Println(divs); end; end; end.

Python: 1 2 3 4 5 6 7 8 for n in range(126849,126871+1): divs = [] # чистим список делителей for d in range(1,n+1): # if n % d == 0: divs = divs + [d] # добавляем делитель в список if len(divs) > 4: break if len(divs) == 4: print(*divs)

С++:

✎ Решение (оптимизированный вариант):

• Будем использовать оптимизированный вариант программы, подходящий для «медленных» компьютеров. Для этого перебор делителей для числа n будем выполнять от 2 до √n, округлив его до ближайшего целого числа (не включая точный квадратный корень, если он существует):

вместо диапазона делителей [1; число]
использовать диапазон [1; округл(√n)]

• При переборе делителей будем определять: если делитель – это точный квадратный корень(n), то в список делителей добавлять будем только сам делитель, если нет – то добавляем пару делителей (делитель и n // делитель):

Пример:
число 8 = 2 * 4
Достаточно рассмотреть цикл от 2 до округл(√8) (=2)
если 8 делится на 2 и 8/2 не равно 2, то делители: 2 и 4 (8/2)

PascalABC.net: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 begin var divCount := 4; for var n := 126849 to 126871 do begin var divs := new List<integer>; var d := 1; while d * d <= n do // можно цикл for var d := 1 to round(sqrt(n)) do begin if n mod d = 0 then begin divs.Add(d); if d * d <> n then divs.Add(n div d); if divs.Count > divCount then break; end; d := d+1; end; if divs.Count = divCount then begin divs.Sort(); Println(divs); end; end; end.

Python: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 # import math # для квадратного корня числа (sqrt) divCount = 4 # нужное количество делителей for n in range(126849,126871 + 1): divs = [] # чистим список делителей d = 1 # вместо while можно цикл for d in range(1,round(math.sqrt(n))): while d*d <= n: # перебор делителей if n % d == 0: divs.append(d) # добавляем делитель в список if d != n//d: # если делитель - не точный квадратный корень n divs.append(n//d) if len(divs) > divCount: break d+=1 if len(divs) == divCount: divs.sort() print(divs)

С++:

✎ Решение: Генерация списка делителей.
Общая идея:

• Для каждого числа указанного диапазона генерируем список делителей.
• Если длина списка равна четырем, выводим его.

PascalABC.net:	Python: for n in range(126849, 126871+1): divs = [d for d in range(1, n+1) if n % d == 0] if len(divs) == 4: print( *divs )
С++:

Ответ:

1 3 42283 126849
1 47 2699 126853
1 5 25373 126865
1 293 433 126869

25_8:

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку [164700; 164752], числа, имеющие ровно 6 различных делителей.
Выведите эти делители для каждого найденного числа в порядке возрастания.

✎ Решение (оптимизированный вариант):

PascalABC.net: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 begin var divCount := 6; for var n := 164700 to 164752 do begin var divs := new List<integer>; for var d := 1 to round(sqrt(n)) do if n mod d = 0 then begin divs.Add(d); if d * d <> n then divs.Add(n div d); if divs.Count > divCount then break; end; if divs.Count = divCount then begin divs.Sort(); Println(divs); end; end; end.

Python: 1 2 3 4 5 6 7 8 9 10 11 12 13 import math # для квадратного корня sqrt divCount = 6 # нужное количество делителей for n in range(164700, 164752 + 1): divs = [] # чистим список делителей for d in range(1,round(math.sqrt(n))): # перебор делителей if n % d == 0: divs.append(d) # добавляем делитель в список if d != n//d: divs.append(n//d) if len(divs) > divCount: break if len(divs) == divCount: divs.sort() print(divs)

С++:

✎ Решение: Генерация списка делителей.
Общая идея:

• Для каждого числа указанного диапазона генерируем список делителей.
• Если длина списка равна четырем, выводим его.

PascalABC.net:	Python: for n in range(164700, 164752+1): divs = [d for d in range(1, n+1) if n % d == 0] if len(divs) == 6: print( *divs )
С++:

Ответ:

1 2 4 41177 82354 164708
1 3 9 18301 54903 164709
1 2 4 41179 82358 164716
1 2 4 41183 82366 164732

25_9:

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку [190201; 190230], числа, имеющие ровно 4 различных делителя.
Выведите эти четыре делителя для каждого найденного числа в порядке убывания.

✎ Решение (неоптимизированный вариант, метод полного перебора):

PascalABC.net: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 begin var divs := new integer[4]; for var n := 190201 to 190230 do begin var i := 0; // для индекса массива for var d := 1 to n do begin if n mod d = 0 then begin if i < 4 then divs[i] := d; inc(i); end; if i > 4 then break; end; if i = 4 then begin println(divs.Reverse()) end; end; end.

Python: 1 2 3 4 5 6 7 8 9 for n in range(190201,190230+1): divs = [] # чистим список делителей for d in range(1,n+1): # if n % d == 0: divs = divs + [d] # добавляем делитель в список if len(divs) > 4: break if len(divs) == 4: divs.reverse() print(*divs)

С++:

✎ Решение (оптимизированный вариант):

PascalABC.net: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 begin var divCount := 4; for var n := 190201 to 190230 do begin var divs := new List<integer>; for var d := 1 to round(sqrt(n)) do if n mod d = 0 then begin divs.Add(d); if d * d <> n then divs.Add(n div d); if divs.Count > divCount then break; end; if divs.Count = divCount then begin divs.Sort(); divs.Reverse(); Println(divs); end; end; end.

Python: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 import math # для квадратного корня sqrt divCount = 4 # нужное количество делителей for n in range(190201, 190230 + 1): divs = [] # чистим список делителей for d in range(1,round(math.sqrt(n))): # перебор делителей if n % d == 0: divs.append(d) # добавляем делитель в список if d != n//d: divs.append(n//d) if len(divs) > divCount: break if len(divs) == divCount: divs.sort() divs.reverse() print(divs)

С++:

✎ Решение: Генерация списка делителей.
Общая идея:

• Для каждого числа указанного диапазона генерируем список делителей.
• Если длина списка равна четырем, выводим его.

PascalABC.net:	Python: for n in range(190201, 190230+1): divs = [d for d in range(1, n+1) if n % d == 0] if len(divs) == 4: divs.reverse() # реверсируем (по убыванию) print( *divs )
С++:

Ответ:

190201 17291 11 1
190202 95101 2 1
190214 95107 2 1
190219 853 223 1
190222 95111 2 1
190223 17293 11 1
190227 63409 3 1
190229 14633 13 1

25_10:

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку [190201; 190280], числа, имеющие ровно 4 различных ЧЁТНЫХ делителя.
Выведите эти четыре делителя для каждого найденного числа в порядке убывания.

✎ Решение (неоптимизированный вариант, метод полного перебора):

PascalABC.net: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 begin var divs := new integer[4]; for var n := 190201 to 190280 do begin var i := 0; // для индекса массива for var d := 1 to n do begin if (n mod d = 0) and (d mod 2 = 0) then begin if i < 4 then divs[i] := d; inc(i); end; if i > 4 then break; end; if i = 4 then begin println(divs.Reverse()) end; end; end.

Python: 1 2 3 4 5 6 7 8 9 for n in range(190201,190280+1): divs = [] # чистим список делителей for d in range(1,n+1): # if n % d == 0 and d%2==0: divs = divs + [d] # добавляем делитель в список if len(divs) > 4: break if len(divs) == 4: divs.reverse() print(*divs)

С++:

✎ Решение: Генерация списка делителей.

Общая идея:

• Для каждого числа указанного диапазона генерируем список делителей.
• Если длина списка равна четырем, выводим его.

PascalABC.net:	Python: for n in range(190201, 190280+1): divs = [d for d in range(1, n+1) if n % d == 0 and d % 2 == 0] if len(divs) == 4: divs.reverse() print( *divs )
С++:

Ответ:

190226 838 454 2
190234 17294 22 2
190238 2606 146 2
190252 95126 4 2
190258 758 502 2
190274 27182 14 2
190276 95138 4 2

25_11:

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

✎ Решение (неоптимизированный вариант, метод полного перебора):

PascalABC.net: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 begin var max := 0; var divsMax := new List<integer>; for var n := 394441 to 394505 do begin var divs := new List<integer>; for var d := 1 to n do if n mod d = 0 then divs.Add(d); if divs.Count > max then begin max := divs.Count; divsMax := divs; end; end; divsMax.Reverse(); print(max, divsMax[0], divsMax[1]) end.

Python: 1 2 3 4 5 6 7 8 9 10 11 12 maxim = 0 # нужное количество делителей divsMax = [] for n in range(394441, 394505 + 1): divs = [] # чистим список делителей for d in range(1,n+1): # перебор делителей if n % d == 0: divs.append(d) # добавляем делитель в список if len(divs) > maxim: maxim = len(divs) divsMax = divs divsMax.reverse() print(maxim,divsMax[0],divsMax[1])

С++:

✎ Решение (Генерация списка делителей):

PascalABC.net:

Python: 1 2 3 4 5 6 7 8 9 maxim=0 divsmax=[] for n in range(394441, 394505+1): divs = [d for d in range(1, n+1) if n % d == 0] if len(divs) > maxim: maxim = len(divs) divsmax = divs # сохраняем делители для числа с макс кол-вом дел-ей divsmax.reverse() print(maxim, divsmax[0], divsmax[1])

С++:

Ответ: 48 394450 197225

25_12:

Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку [3532000; 3532160], простые числа.
Выведите все найденные простые числа в порядке убывания, слева от каждого числа выведите его номер по порядку.

✎ Решение (неоптимизированный вариант, метод полного перебора):

PascalABC.net: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 begin var count := 0; for var n := 3532160 downto 3532000 do // цикл с конца begin var flag := true; for var d := 2 to n - 1 do // перебор делителей, начиная с двух до n-1 begin if n mod d = 0 then begin // есть делитель помимо единицы и самого n flag := false; // число не простое break; end; end; if flag = true then // если число простое begin inc(count); Println(count, n); end; end; end.

Python: 1 2 3 4 5 6 7 8 9 10 count = 0 for n in range(3532160, 3532000-1, -1): # цикл с конца и с шагом (-1) flag = True for d in range(2, n): # перебор делителей, начиная с двух if n % d == 0: # есть делитель помимо единицы и самого n flag = False # число не простое break if flag == True: # число простое count+=1 print(count , n)

С++:

✎ Решение (оптимизированный вариант):

PascalABC.net: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 begin var count := 0; for var n := 3532160 downto 3532000 do // цикл с конца begin var flag := true; var d := 2; while d * d <= n - 1 do // перебор делителей, начиная с двух begin if n mod d = 0 then begin // есть делитель помимо единицы и самого n flag := false; // число не простое break; end; d := d + 1; end; if flag = true then // если число простое begin inc(count); Println(count, n); end; end; end.

Python: 1 2 3 4 5 6 7 8 9 10 11 12 count = 0 for n in range(3532160, 3532000-1, -1): # цикл с конца и с шагом (-1) flag = True d = 2 while d*d <= n-1: # перебор делителей, начиная с двух if n % d == 0: # есть делитель помимо единицы и самого n flag = False # число не простое break d+=1 if flag == True: # число простое count+=1 print(count , n)

С++:

Ответ:

1  3532147
2  3532121
3  3532103
4  3532091
5  3532049
6  3532033
7  3532021
8  3532019
9  3532007

25_1: ЕГЭ по информатике 2017 года (один из вариантов со слов выпускника):

Дан целочисленный массив из 20 элементов. Элементы массива могут принимать целые значения от 0 до 10 000 включительно. Опишите на естественном языке или на одном из языков программирования алгоритм, позволяющий найти и вывести количество элементов массива НЕ кратных 3.

Исходные данные объявлены так, как показано ниже. Запрещается использовать переменные, не описанные ниже, но использовать все описанные переменные не обязательно.

1
2
3
4
5
6
7
8

const N = 20;
var i,j,k:integer;
a:array [1..N] of integer; 
begin
for i:=1 to N do 
  readln(a[i]); 
…
end.

Рассмотрим заданный фрагмент решения:

• в цикле со счетчиком i запрашиваются значения элементов массива, т.е. формируется массив;
• из постановки задания видим, что необходимо найти количество чего-то, это значит, что нужно использовать переменную счетчик;
• объявлены три целочисленных переменных: i, j, k; переменная i использована в первом цикле, значит для счетчика можно взять переменную k;
• счетчик всегда нужно обнулять, поэтому следующим оператором будет:
• определим, количество чего нам необходимо считать: количество элементов массива не кратных 3. Кратность можно определить через остаток от деления: если значение элемента массива при делении на 3 в остатке не возвращает 0, значит элемент не кратен трем;
• остаток при делении в паскале — оператор mod. Поскольку необходимо просмотреть каждый элемент массива, то это нужно делать в цикле for;
• переменная i уже использована в первом цикле for, значит, для очередного цикла возьмем неиспользованную переменную j:

for j:=1 to N do
  if a[j] mod 3 <> 0 then

• если условие истинно (т.е. нашелся элемент массива, не кратный трем), то увеличиваем счетчик:
• после цикла остается вывести значение счетчика, т.е. вывести количество элементов массива не кратных 3:

Результат:

k:=0;
for j:=1 to N do
  if a[j] mod 3 <> 0 then
    inc(k);
writeln(k);

25_3: Решение 25 задания ЕГЭ по информатике Демоверсия 2018:

Дан целочисленный массив из 30 элементов. Элементы массива могут принимать целые значения от 0 до 10000 включительно. Опишите на одном из языков программирования алгоритм, который находит количество элементов массива, больших 100 и при этом кратных 5, а затем заменяет каждый такой элемент на число, равное найденному количеству. Гарантируется, что хотя бы один такой элемент в массиве есть. В качестве результата необходимо вывести измененный массив, каждый элемент массива выводится с новой строчки.

Например, для массива из шести элементов: 4 115 7 195 25 106
программа должна вывести числа 4 2 7 2 25 106

1
2
3
4
5
6
7
8
9
10

const
N = 30;
var
a: array [1..N] of longint;
i, j, k: longint;
begin
	for i := 1 to N do
		readln(a[i]);
	...
end.

В качестве ответа Вам необходимо привести фрагмент программы, который должен находиться на месте многоточия. Вы можете записать решение также на другом языке программирования (укажите название и используемую версию языка программирования, например Free Pascal 2.6). В этом случае Вы должны использовать те же самые исходные данные и переменные, какие были предложены в условии.

Похожие задания для тренировки

Решение на языке Паскаль:

1 2 3 4 5 6 7 8 9

k := 0; for i := 1 to N do if (a[i] > 100) and (a[i] mod 5 = 0) then k:=k+1; for i := 1 to N do begin if (a[i] > 100) and (a[i] mod 5 = 0) then a[i] := k; writeln(a[i]) end

25_6:

Дан массив, содержащий неотрицательные целые числа. Необходимо вывести:

Например, для массива из шести элементов: 4 6 12 17 3 8
ответом будет 12 — наибольшее чётное число, поскольку чётных чисел в этом массиве больше

1
2
3
4
5
6

# допускается также использовать
# целочисленные переменные j, k, m
a = []
n = 2000 // менять значение n нельзя
for i in range(0, n):
  a.append(int(input()))

Решение на языке Python:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

a = [] n = 2000 // менять значение n нельзя for i in range(0, n): a.append(int(input())) j = 0 k = 0 m = 0 for i in range(0, n): if a[i]%2 == 0: j+=1 else: k+=1 if k>j: j = 0 for i in range(0, n): if a[i]>j and a[i] % 2 != 0: j = a[i] print(j) else: for i in range(0, n): if a[i]>m and a[i] % 2 == 0: m = a[i] print(m)

25_4:

Дан целочисленный массив из 40 элементов. Элементы массива могут принимать целые значения от 0 до 10 000 включительно. Опишите на естественном языке или на одном из языков программирования алгоритм, позволяющий найти и вывести количество пар элементов массива, в которых одно из чисел двузначное. В данной задаче под парой подразумевается два подряд идущих элемента массива.

Например, для массива из семи элементов: 13; 323; 12; 33; 117 — ответ: 4.

Исходные данные объявлены так, как показано ниже. Запрещается использовать переменные, не описанные ниже, но разрешается не использовать некоторые из описанных переменных.

1
2
3
4
5
6
7
8
9
10

const
  N = 40;
var
  a: array [1..N] of integer;
  i, j, k: integer;
begin
  for i := 1 to N do 
    readln(a[i]);
  ...
end.

1 2 3 4 5

k := 0; for i := 1 to N - 1 do if ((a[i] < 100) and (a[i] > 9)) or ((a[i + l] < 100) and (a[i + 1] > 9)) then inc(k); writeln(k);

25_5:

Дан целочисленный массив из 20 элементов. Элементы массива могут принимать целые значения от -10 000 до 10 000 включительно. Опишите алгоритм, позволяющий найти и вывести количество пар элементов массива, в которых сумма элементов делится на 2, но не делится на 4. В данной задаче под парой подразумевается два подряд идущих элемента массива.

Исходные данные объявлены так, как показано ниже. Запрещается использовать переменные, не описанные ниже, но разрешается не использовать некоторые из описанных переменных.

Python:

1
2
3
4
5
6
7

#  допускается также использовать
#  две целочисленные переменные
#  j и k
a = []
n = 20
for i in range(0, n):
  a.append(int(input()))

Проанализируем данный фрагмент кода на языке Python:
• В первой строчке кода объявляется список а. Дальше, идет объявление переменной n = 20, она отвечает за размер массива.

При решении такого рода задач, необходимо помнить, что массив в Python — это список и это динамический тип данных. Кроме того, нумерация элементов массива начинается с 0.

• Ниже мы видим инициализацию списка а. Мы должны дописать код дальнейшей программы, который последует после заполнения списка пользователем.
• Итак, по условию мы должны находить пары элементов, сумма которых делится на 2, но не делится на 4, причем парами считаются соседние элементы, например: a[0] и a[1], a[1] и a[2].
• Мы можем узнать, делится ли данный элемент на число, если остаток от деления на него равен 0, и не делится — в противном случае. Тогда сумма соседних элементов при делении на 2 должна давать остаток 0, а при делении на 4 наоборот — отличный от 0.
• Введем цикл, который будет перебирать все элементы массива, считать сумму соседей и проверять истинность условия.

for i in range(0, n-1):
    j = a[i] + a[i+1]
    if j%2 == 0 and j%4 != 0:

Так как мы рассматриваем элемент a[i + 1], значит, цикл должен работать до n — 1, чтобы не выйти за границы диапазона массива.

• Когда мы определились с условием, за счетчик возьмем переменную k, которую допустимо брать исходя из комментариев к программе.

...
 if j%2 == 0 and j%4 != 0:
        k+=1

• Мы добавили допустимую переменную j, чтобы условный оператор выглядел компактнее.
• Однако задача еще не решена. Во-первых, мы должны до цикла инициализировать счетчик k = 0. Так как иначе Python выдаст ошибку.

Дело в том, что мы пытаемся присвоить переменной k его же значение, но на 1 больше, но интерпретатор «не встречал» раньше переменной k, из-за чего возникает ошибка.

• Кроме того, добавим вывод результата после цикла.
• Таким образом, правильный вариант с учетом доработок:

a = []
n = 20
for i in range(0, n):
  a.append(int(input()))
k = 0
for i in range(0, n - 1):
    j = a[i] + a[i + 1]
    if j%2 == 0 and j%4 != 0:
        k += 1
print(k)

25_2:

Дан целочисленный массив из 40 элементов. Элементы массива могут принимать целые значения от 0 до 10 000 включительно. Опишите на естественном языке или на одном из языков программирования алгоритм, позволяющий найти и вывести количество троек элементов массива, состоящих из равных между собой чисел. В данной задаче под тройкой подразумевается три подряд идущих элемента массива.

Например, для массива из семи элементов: 2; 2; 2; 4; 4; 4; 4 — ответ: 3.

Исходные данные объявлены так, как показано ниже. Запрещается использовать переменные, не описанные ниже, но разрешается не использовать некоторые из описанных переменных.

1
2
3
4
5
6
7
8
9
10

const
  N=40;
var
  a: array[1..N] of integer;
  i, j, k:integer;
begin
  for i:=1 to N do
    readln(a[i]);
  ...
end.

• из постановки задания видим, что необходимо искать количество чего-то, это значит, что нужно использовать переменную счетчик; возьмем для нее объявленную переменную k;
• счетчик всегда нужно сначала обнулять, поэтому следующим оператором будет:
• определим, количество чего нам необходимо считать: количество троек элементов массива, состоящих из равных между собой чисел. Т.е. необходимо сравнивать между собой каждые три подряд идущих элемента массива, например так:

if (a[i]=a[i+1]) and (a[i]=a[i+2]) then
    inc(k);

• inc(k) — оператор, увеличивающий счетчик k на единицу;
• условие необходимо выполнять в цикле, так как нужно проверить все элементы массива; цикл со счетчиком необходимо организовать от 1 до N-2, в противном случае индексы элементов a[i+2] выйдут за границы диапазона массива (например, при i = 40, получим … a[40+2], а 42-го элемента массива не существует, поэтому цикл надо делать до i = 38, т.е. N-2).

Результат:

for i:=1 to N-2 do
    if (a[i]=a[i+1]) and (a[i]=a[i+2]) then
      inc(k);
writeln(k);