информатика ЕГЭ задание 25 решение и объяснение

На уроке рассмотрено решение 25 задания ЕГЭ по информатике: дается подробное объяснение и разбор заданий демонстрационных вариантов и досрочных экзаменов

К оглавлению

Содержание:

Объяснение задания 25 ЕГЭ по информатике
- Алгоритмизация и программирование
Решение 25 заданий ЕГЭ по информатике
Задания прошлых лет для тренировки (до 2021)
Решение 25 заданий ЕГЭ по информатике: более сложные задания

Объяснение задания 25 ЕГЭ по информатике

25-е задание: «Программная обработка целочисленной информации»
Уровень сложности — высокий,
Требуется использование специализированного программного обеспечения — да,
Максимальный балл — 2,
Примерное время выполнения — 20 минут.

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

Рекомендации по выполнению: "В этом задании требуется написать фрагмент программы, реализующий простую обработку целочисленного массива. У экзаменуемых, хорошо освоивших технику программирования, это задание обычно не вызывает серьёзных затруднений, поскольку алгоритм обработки массива не относится к сложным" Типичные ошибки и рекомендации по их предотвращению: "в цикле происходит выход за границу массива; не инициализируется или неверно инициализируется искомое значение; исходный массив не изменяется; изменяются не все требуемые элементы (например, только первый или последний из них); отсутствует вывод ответа, или ответ выводится не полностью (например, только один элемент массива ввиду пропущенного цикла вывода элементов или операторных скобок); используется переменная, не объявленная в разделе описания переменных; не указано или неверно указано условие завершения цикла" "Часто бывает, что увлекшись написанием решения, экзаменуемый совершает ошибки в простых ситуациях: организация ввода-вывода, описание и инициализация переменных, обработка массива (выход за границу) и т.д. Эти ошибки могут стоить Вам нескольких баллов, старайтесь их не допускать"

ФГБНУ "Федеральный институт педагогических измерений"

Алгоритмизация и программирование

Для решения задания требуется вспомнить темы:

Решение 25 заданий ЕГЭ по информатике

Плейлист видеоразборов задания на YouTube:
Задание демонстрационного варианта 2022 года ФИПИ

Делители числа

25_7:

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

✍ Решение:

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

PascalABC.net (LINQ):

##
uses school;
var ar:=(126849..126871)
 .where(n->n.DivisorsCount=4)
 .Select(n->n.divisors) 
 .printlines;

PascalABC.net (с элементами функционального программирования):

##
uses school;  
for var i:=126849 to 126871 do   
   if i.DivisorsCount=4 then Println(i.divisors);

PascalABC.net:

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 вариант, Генерация списка делителей):
Общая идея:

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

Если длина списка равна четырем, выводим его.

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 )

Python (2 вариант):

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:

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:

# 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)

С++:

Ответ:

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

25_8:

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

✍ Решение:

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

PascalABC.net (LINQ):

##
uses school; 
(164700..164752).Where(x->x.divisors.count=6)
  .Select(x->x.divisors.Order)
  .printlines

PascalABC.net (с элементами функционального программирования):

1
2
3

uses school;  
  for var i:=164700 to 164752 do   
      if i.DivisorsCount=6 then Println(n);

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

PascalABC.net:

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, генерация списка делителей):

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 )

Python (вариант 2):

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)

С++:

Ответ:

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 (LINQ):

##
uses school; 
(190201..190230).Where(x->x.divisors.count=4)
  .Select(x->x.divisors.OrderDescending)
  .printlines

PascalABC.net (с элементами функционального программирования):

##
uses school;  
for var i:=190201 to 190230 do 
   if i.DivisorsCount=4 then 
      i.Divisors.SortedDescending.Println;

PascalABC.net:

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:

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:

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, генерация списка делителей):

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 )

Python (вариант 2):

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)

С++:

Ответ:

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

Видеоразбор задания:

📹 YouTube здесь
📹 Видеорешение на RuTube здесь

25_10:

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

✍ Решение:

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

PascalABC.net (LINQ):

##
uses school; 
(190201..190280)
  .Where(x->x.Divisors.Where(d->d.divs(2)).Count=4)
  .Select(x->x.divisors.Where(d->d.divs(2)).OrderDescending)
  .printlines

PascalABC.net (с элементами функционального программирования):

##
uses school;  
  for var i:=190201 to 190280 do 
  begin
    var ev:=0;
    for var j:=1 to i.Divisors.Count-1 do
      if i.Divisors[j].IsEven then ev+=1; 
    if ev=4 then 
      i.Divisors.Where(t -> t.IsEven).SortedDescending.Println;
  end;

PascalABC.net:

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, генерация списка делителей):

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 )

Python (вариант 2):

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)

С++:

Ответ:

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 (LINQ):

##
uses school; 
var ma:=(394441..394505)
  .Select(x->x.divisors.count).max; // max
(394441..394505)
  .Where(x->x.divisors.count=ma)
  .Select(x->(x.divisors.Count,x,x.divisors[x.Divisors.Count-2]))
  .First.print

PascalABC.net:

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, генерация списка делителей):

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])

Python (вариант 2):

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])

С++:

Ответ: 48 394450 197225

Видео

Простые числа

25_12:

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

✍ Решение:

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

PascalABC.net (LINQ):

##
uses school;
(3532000..3532160)
  .where(n->n.IsPrime).OrderDescending.Numerate
  .printlines;

PascalABC.net (с элементами функционального программирования):

##
uses school; var c:=0; 
  for var i:=3532160 downto 3532000 do 
      if i.IsPrime then 
          begin 
            c+=1; Println(c,i); 
          end

PascalABC.net:

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:

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:

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:

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)

С++:

Ответ:

25_13:

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

Ответ:

✍ Решение:

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

PascalABC.net (LINQ):

##
uses school; 
(2532000..2532160)
  .Where(x->(x.isPrime)and(x mod 10 = 7))
  .Order.Numerate
  .printlines

PascalABC.net (с элементами функционального программирования):

##
uses school; 
var c:=0; 
  for var i:=2532000 to 2532160 do 
      if i.IsPrime and (i mod 10=7) then 
        begin 
          c+=1;Println(c,i); 
        end

PascalABC.net:

begin
  var count := 0;
  for var n := 2532000 to 2532160 do
  begin
    var flag := true; 
    for var d := 2 to n - 1 do
      if n mod d = 0 then begin
        flag := false;      
        break;
      end;
    if (flag = true) and (n mod 10 = 7) then
    begin
      inc(count);
      Println(count, n);
    end;
  end;
end.

Python:

k=0 # порядковый номер
for i in range(2532000, 2532160+1):
    count = 2 # есть  1 и само число
    for j in range(2,round(i**0.5)+1): 
        if i%j == 0:
            count = 0 
            break # не простое 
    if count == 2 and i%10 == 7:
        k +=1
        print(k,i)

С++:

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

PascalABC.net:

begin
  var count := 0;
  var n := 2532007; // начинаем с первого, которое оканчивается на 7
  while n <= 2532160 do
  begin
    var flag := true; 
    var d := 2;
    while d * d <= n - 1 do
    begin
      if n mod d = 0 then begin
        flag := false;      
        break;
      end;
      d := d + 1;
    end;
    if (flag = true) and (n mod 10 = 7) then
    begin
      inc(count);
      Println(count, n);
    end;
    n:=n+10; // шагаем через 10
  end;
end.

Python:

count = 0
for n in range(2532000, 2532160+1): # цикл с конца и с шагом (-1) 
      flag = True
      d = 2
      while d*d <= n-1: # перебор делителей, начиная с двух
            if n % d == 0: # есть делитель помимо единицы и самого n
                  flag = False # число не простое
                  break
            d+=1
      if flag == True and n % 10 == 7: # число простое
            count+=1
            print(count , n)

С++:

Ответ:

25_14:

Среди целых чисел, принадлежащих числовому отрезку [125697;190234], найдите числа, которые представляют собой произведение двух различных простых делителей. Запишите в ответе количество таких чисел и максимальное их них..

Ответ: 14047 190231

✍ Решение:

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

PascalABC.net (LINQ, вариант 1):

##
uses school;
var s := (125697..190234).Where(
       x ->(x.Divisors.count=4)and 
       (x.Divisors[1].isPrime)and(x.Divisors[2].isPrime));
print(s.Count,s.max)

PascalABC.net (LINQ, вариант 2):

##
uses school;
var s:=(125697..190234).Where(
        x -> (x.Factorize.Distinct.Count=2) 
             and (x.Divisors.Count = 4)); 
Println(s.Count, s.Max ;

PascalABC.net (с элементами функционального программирования):

##
uses school; 
var k:=0; var m:=0;
 for var i:=125697  to 190234 do 
   begin
     var d:= divisors(i); d.Remove(1); d.Remove(i); 
     if (d.Count=2) and (d[0].IsPrime) and (d[1].IsPrime) and (d.product=i) then 
        begin m:=i ; k+=1; 
        end; 
   end;
 print(k,m);

PascalABC.net:

begin
  var divs := new List<integer>; // массив простых
  divs.Clear; 
  for var n := 2 to 190234 do // до максимального в диапазоне
  begin
    var f := true;
    for var d := 2 to n - 1 do
      if n mod d = 0 then begin
        f := false;
        break;
      end;
    if f = true then
      divs.Add(n);     
  end;
  var numb := 1;
  var count := 0; var max := 0;
  var okList := new List<integer>;
  for var n := 125697 to 190234 do
  begin
    okList.Clear;
    numb := 1;
    foreach var elem in divs do // берем каждый элемент из массива простых чисел("divs") 
    begin
      if n mod elem = 0 then begin
        okList.add(elem);
        numb := numb * elem;
        if okList.Count > 2 then break;
      end;
      if okList.count = 2 then begin
        if n = numb then begin
          count += 1;
          if n > max then max := n;
        end;
        break;
      end;
    end;
  end;
  print(count, max)
end.

Python:

from math import sqrt
 
start, end = 125697, 190234
def isPrime( x ):
  if x <= 1: return False
  d = 2
  while d*d <= x:
    if x % d == 0:
      return False
    d += 1
  return True
count = 0
ma = 0
for i in range(start, end+1):
  for x in [2]+list(range(3,round(sqrt(i))+1,2)):
    if i % x == 0 and isPrime(x):
      y = i // x
      if x != y and isPrime(y):
        count += 1
        ma = i
        break
print( count, ma )

С++:

Ответ: 14047 190231

25_15:

Рассматриваются целые числа, принадлежащих числовому отрезку [485617; 529678], которые представляют собой произведение трёх различных простых делителей, оканчивающихся на одну и ту же цифру.
В ответе запишите количество таких чисел и такое из них, для которого разность наибольшего и наименьшего простых делителей минимальна.

Ответ: 231 508049
✍ Решение:

✎ Решение:

PascalABC.net (LINQ):

##
uses school;
var s := (485617..529678)
  .Where(x -> (x.Factorize.Distinct.count=3)and
     (x.DivisorsCount=8) and
     (x.Factorize.Distinct.ToArray[0] mod 10 = x.Factorize.Distinct.ToArray[1] mod 10) and 
     (x.Factorize.Distinct.ToArray[0] mod 10 = x.Factorize.Distinct.ToArray[2] mod 10));
s.Count.Print;
var mi:=s.select(x->x.Factorize.Max-x.Factorize.min).Min;
s.where(x->x.Factorize.Max-x.Factorize.min = mi).print;

PascalABC.net (с элементами функционального программирования):

uses school; 
var m:=400000; var c:=0; var v:=0;
 for var i:=485617  to 529678 do 
   begin
     var p:= i.Divisors.where(L -> L.IsPrime=true); 
       if (p.Count=3) and (p.Product=i)then 
       begin
         var l:=p.ToArray;      
         if (l[0] mod 10=l[1] mod 10)and (l[0] mod 10=l[2] mod 10)then
            begin
              c+=1; 
              if (l[2]-l[0]<m) then 
                 begin m:=l[2]-l[0]; v:=i; end;
            end; 
      end;
   end;
print(c, v);

Python:

from math import sqrt
 
start, end = 485617, 529678
def isPrime( x ):
  if x <= 1: return False
  d = 2
  while d*d <= x:
    if x % d == 0:
      return False
    d += 1
  return True
count = 0
minDiff = 1e10
iMinDiff = 0
for i in range(start, end+1):
  q = round(sqrt(i))
  Dx = [2] + list( range(3, q+1, 2) )
  found = False
  for x in Dx:
    if i % x == 0 and isPrime(x):
      yz = i // x
      qyz = round(sqrt(yz))
      for y in range(x+1,qyz+1):
        if yz % y == 0 and isPrime(y) and (x % 10 == y % 10):
          z = yz // y
          found = True
          if z != y and z != x and isPrime(z) and (x % 10 == z % 10):
            count += 1
            if z - x < minDiff:
              minDiff = z - x
              iMinDiff = i
          break
      if found: break
print( count, iMinDiff )

С++:

Ответ: 231 508049

Цифры числа

25_16:

Уникальным назовём число, если у него только третья и пятая цифры чётные. Для интервала [33333;55555] найдите количество таких чисел, которые не делятся на 6, 7, 8 и разность максимального и минимального из них.

В ответе укажите два числа: сначала количество чисел, а потом разность.

Ответ: 355 22088
✍ Решение:

✎ Решение:

PascalABC.net (LINQ, approach 1):

##
uses school;
var s := (33333..55555)
   .Where( x ->  (x.digits[2].isEven) and (x.digits[4].isEven) 
      and (x.digits[0].isOdd)and (x.digits[1].isOdd)
      and (x.digits[3].isOdd) and
      (x.NotDivs(6)) and (x.NotDivs(7))and (x.NotDivs(8)));
s.count.Print;
print(s.Max-s.Min);

PascalABC.net (LINQ, approach 2):

##
uses school; 
var s:=(33333..55555)
      .Where( t -> (t mod 6<>0)and (t mod 7<>0) and (t mod 8<>0)
      and(t.digits[0].isOdd) and (t.digits[1].isOdd)and(t.digits[2].isEven) 
      and (t.digits[3].isOdd)and (t.digits[4].isEven));
s.Count.Println;
(s.Last- s.First).print

Python:

for n in range(33333,55555+1):
  if n % 6 != 0 and n % 7 != 0 and n % 8 != 0 and n % 2 == 0 
    and ((n//100)%10)%2 == 0 and (n // 10000)%2!=0 
    and (n//1000%10)%2!=0 and (n//10%10)%2!=0:
      arr = arr + [n] # добавляем в список # или: arr.append(n)
print(len(arr), (max(arr)-min(arr)))

С++:

Ответ: 355 22088

Нетривиальные делители

25_17:

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

Ответ:

279841 12167 
707281 24389 
923521 29791

✍ Решение:

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

PascalABC.net (LINQ):

##
uses school;
var z := (152346..957812)
       .Where(x ->x.DivisorsCount=5)
       .select(x->(x,x.Divisors.SkipLast.Max))
       .printlines;

PascalABC.net (с элементами функционального программирования):

##
uses school; 
 for var i:=152346  to 957812 do  
       if (i.DivisorsCount=5) then println(i, i.Divisors[3]);

Python:

start, end = 152346, 957812
def isPrime( x ):
  if x <= 1: return False
  d = 2
  while d*d <= x:
    if x % d == 0:
      return False
    d += 1
  return True
q4s = int(start**0.25)
q4e = int(end**0.25) + 1
for q4 in range(q4s, q4e+1):
  x = q4**4
  if start <= x <= end  and  isPrime(q4):
    print( x, [q4, q4**2, q4**3] )

С++:

Ответ:

279841 12167 
707281 24389 
923521 29791

25_18:

Рассматривается множество целых чисел, принадлежащих числовому отрезку [834567; 1143210]. Найдите числа, нетривиальные делители которых образуют арифметическую прогрессию с разностью d = 2.
В ответе для каждого такого числа (в порядке возрастания) запишите сначала само число, а потом – его максимальный нетривиальный делитель.

Ответ:

1040399 1021 
1065023 1033 
1102499 1051 
1127843 1063

✍ Решение:

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

PascalABC.net (LINQ):

##
// метод Except: в аргументе перечисляем значения, 
// которые не должны входить в последовательность
uses school;
var z := (834567..1143210)
      .where(x->(x.DivisorsCount>3)and
      (x.Divisors.Except(|1,x|).Pairwise.all(\(a,b)->abs(a-b)=2))).
       select(x->(x,x.divisors.Except(|1,x|).max))
.PrintLines

PascalABC.net (с элементами функционального программирования):

##
uses school;
var s:=(834567..1143210); 
foreach var i in s do begin
  var v := i.Divisors.Except(|1,i|);
  var d := 0;
  var p := -100;// d - количество подходящих, p - первый делитель
  foreach var j in v do begin
    if ((j-p)=2) then  d += 1;
    p := j;
  end;
  if (v.Count>1) and (d=v.Count-1) then 
    Println( i, v.Max );
end

Python:

s, e = 834567, 1143210
 
def allDivs( x ):
  divs = [1, x]
  d = 2
  while d*d <= x:
    if x % d == 0:
      divs.append( d )
      if x // d > d:
        divs.append( x//d )
    d += 1
  return sorted(divs)
 
def valid( divs ):
  if len(divs) < 2: return False
  for i in range(1, len(divs)):
    if divs[i] - divs[i-1] != 2:
      return False
  return True
 
for x in range(s, e+1):
  divs = allDivs(x)[1:-1]
  if valid(divs):
    print( x, divs[-1] )

С++:

Ответ:

1040399 1021 
1065023 1033 
1102499 1051 
1127843 1063

25_19:

Обозначим через P(N) – произведение 5 наименьших различных нетривиальных делителей натурального числа N (не считая единицы и самого числа). Если у числа N меньше 5 таких делителей, то P(N) считается равным нулю.
Найдите 5 наименьших натуральных чисел, превышающих 200 000 000, для которых P(N) оканчивается на 1 и не превышает N. В ответе для каждого найденного числа запишите сначала значение P(N), а затем – наибольший делитель, вошедший в произведение P(N).

Ответ:

5000211 171
5000211 171
391391 23
122124411 227
1712421 81

✍ Решение:

✎ Решение:

PascalABC.net (с элементами функционального программирования):

##
uses school;
var c:=0; var n:=200000001;
while (c<5) do
Begin
  var d:=n.divisors;  
   if (d.count>=7) then
  begin 
  var d1:=n.Divisors[:6]; d1.Remove(1);
  if (d1.product<n) and (d1.product mod 10=1) then
  begin
    println(d1.product, d1[d1.count-1]);  c+=1;
  end; 
  end;  
  n+=1;
end

Python:

def allDivs( n ):
  q = round( n**0.5 )
  divs = [] if n % q != 0 else \
         [q] if q == n // q else \
         [q, n//q]
  for d in range(2,q):
    if n % d == 0:
       divs.extend( [d, n//d] )
  return sorted(divs)
 
MIN = 200000000
count = 0
x = MIN + 1
while count < 5:
  divs = allDivs(x)
  if len(divs) >= 5:
    M = divs[0]*divs[1]*divs[2]*divs[3]*divs[4]
    if M <= x and M % 10 == 1:
      print( M, divs[4], x ) #, divs )
      count += 1
  x += 1

С++:

Ответ:

5000211 171
5000211 171
391391 23
122124411 227
1712421 81

Задания прошлых лет для тренировки (до 2021)

Задачи с поэлементной обработкой массива

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

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

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

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;
счетчик всегда нужно обнулять, поэтому следующим оператором будет:

k:=0;

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

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

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

     inc(k);

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

writeln(k);

Результат:

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

Смотрите видео с подробным объяснением и разбором данного 25 задания:

📹 YouTube здесь
📹 Видеорешение на RuTube здесь

Задачи на обработку элементов массива с последующей заменой

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

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

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

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

Паскаль:

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). В этом случае Вы должны использовать те же самые исходные данные и переменные, какие были предложены в условии.

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

✍ Решение:

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 — наибольшее чётное число, поскольку чётных чисел в этом массиве больше

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

Python:

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

✍ Решение:

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.

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 := 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:

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

✍ Решение:

В первой строчке кода объявляется список а. Дальше, идет объявление переменной 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.

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;
счетчик всегда нужно сначала обнулять, поэтому следующим оператором будет:

k:=0;

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

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);

Более подробное объяснение предлагаем посмотреть на видео:

📹 YouTube здесь
📹 Видеорешение на RuTube здесь

Задачи на поиск максимума, минимума элементов массива и другие

К оглавлению