25 задание ЕГЭ по информатике (вторая часть)

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

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

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

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

Типичные ошибки и рекомендации по их предотвращению:

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

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

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

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

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

    Задание демонстрационного варианта 2021 года ФИПИ

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

    25_7: Разбор 25 задания ЕГЭ по информатике с сайта К. Полякова № 1:

    Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку [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)
      С++:

      1
      
       

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

    • Будем использовать оптимизированный вариант программы, подходящий для «медленных» компьютеров. Для этого перебор делителей для числа 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)
      С++:

      1
      
       

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

    • Для каждого числа указанного диапазона генерируем список делителей.
    • Если длина списка равна четырем, выводим его.
    • 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: Разбор 25 задания ЕГЭ по информатике с сайта К. Полякова № 11:

    Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку [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)
      С++:

      1
      
       

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

    • Для каждого числа указанного диапазона генерируем список делителей.
    • Если длина списка равна четырем, выводим его.
    • 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: Разбор 25 задания ЕГЭ по информатике с сайта К. Полякова № 21:

    Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку [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)
      С++:

      1
      
       

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

      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)
      С++:

      1
      
       

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

    • Для каждого числа указанного диапазона генерируем список делителей.
    • Если длина списка равна четырем, выводим его.
    • 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: Разбор 25 задания ЕГЭ по информатике с сайта К. Полякова № 22:

    Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку [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)
      С++:

      1
      
       

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

      Общая идея:

    • Для каждого числа указанного диапазона генерируем список делителей.
    • Если длина списка равна четырем, выводим его.
    • 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: C сайта К. Полякова № 32:

    Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку [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])
      С++:

      1
      
       

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

      PascalABC.net:

      1
      
       
      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])
      С++:

      1
      
       

    Ответ: 48 394450 197225

    Видео

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

    25_12: C сайта К. Полякова № 60:

    Напишите программу, которая ищет среди целых чисел, принадлежащих числовому отрезку [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)
      С++:

      1
      
       

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

      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
      
       

    Ответ:

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

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

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

    25_1: Разбор 25 задания ЕГЭ по информатике 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;
    • счетчик всегда нужно обнулять, поэтому следующим оператором будет:
    • 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 задания:


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

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

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

    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: Разбор 25 задания ЕГЭ по информатике 2019 года ФИПИ «Типовые экзаменационные варианты» вариант 10 (Крылов С.С., Чуркина Т.Е.):

    Дан целочисленный массив из 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 задания ЕГЭ по информатике 2019 года ФИПИ вариант 11, «Типовые экзаменационные варианты» (Крылов С.С., Чуркина Т.Е.):

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

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


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

    Решение 25 заданий ЕГЭ по информатике: более сложные задания

    Добавить комментарий

    Ваш адрес email не будет опубликован. Обязательные поля помечены *

    *
    *


    Вставить формулу как
    Блок
    Строка
    Дополнительные настройки
    Цвет формулы
    Цвет текста
    #333333
    Используйте LaTeX для набора формулы
    Предпросмотр
    \({}\)
    Формула не набрана
    Вставить