Задание 6 ОГЭ информатика

Дата изменения: 21 августа 2020
На уроке рассмотрен материал для подготовки к ОГЭ по информатике, разбор 6 задания

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

6-е задание: «Линейный и циклический алгоритм, записанный на алгоритмическом языке».
Уровень сложности — базовый,
Максимальный балл — 1,
Примерное время выполнения — 4 минуты.
* до 2020 г — это были задания № 8, 9, 10 ОГЭ

Линейные алгоритмы 

 

Оператор присваивания
  • Для решения задач программе требуются данные. Данные хранятся в переменных, которые имеют свои имена — идентификаторы.
  • например, идентификаторы X или Y,
    или более длинные идентификаторы переменных — number1, counter и т.п.
    Важно: Идентификаторы состоят из буквы, за которой могут следовать буквы, цифры или символ подчеркивания
  • Чтобы задать переменной какое-либо значение используется оператор присваивания. Оператор присваивания (в Паскале) обозначается как :=, выполняет правую часть выражения и присваивает результат переменной, расположенной в левой части выражения:
  • оператор присваивания

  • В таком случае правильно говорить, что переменной x присвоено значение 5.
  • После того как переменной присвоено какое-то значение, можно это значение «переприсвоить», т.е. назначить другое значение:
  • x:= 2
    y:= 3
    x:= y+2
    

    В результате в переменной x находится значение 5, т.к. 3 + 2 = 5.

Арифметические операции

ДЕЙСТВИЕ РЕЗУЛЬТАТ СМЫСЛ
2 + 3 5 плюс
4 — 1 3 минус
2 * 3 6 умножить

10 / 5

2

разделить

Порядок выполнения операций

  1. вычисление выражений в скобках;
  2. умножение, деление слева направо;
  3. сложение и вычитание слева направо.

порядок выполнения операций

Простейшие циклические алгоритмы

Цикл

Цикл — это фрагмент кода программы для исполнителя, который осуществляет некоторые действия определенное количество раз.
  
Пример на паскале, цикл for:

for k:=1 to 5 do
  i:=i+2;

Объяснение:
 

    Цикл выполняется пять раз, потому что:

  • k — счетчик цикла, который изменяет свое значение начиная от одного и заканчивая пятью;
  • в цикле выполняет одно действие: i:=i+2, т.е. к переменной i прибавляется 2.

 
Пример на бейсике, цикл for:

FOR k = 1 TO 5 
   i = i + 2 
NEXT k

Объяснение:

    Цикл выполняется пять раз, потому что:

  • k — счетчик цикла, который изменяет свое значение, начиная от одного и, заканчивая пятью;
  • в цикле выполняет одно действие: i = i + 2, т.е. к переменной i прибавляется 2.

Циклические алгоритмы обработки массива чисел

Массивы

Массив чисел — это последовательность чисел, которые принадлежат одной и той же переменной (называемой «массив») и имеют порядковые номера — индексы. Массив часто именуется таблицей.

Пример объявления массива и работы с ним в Паскале:
 
var A: array[1..10] of integer;
{массив A  - целочисленный массив, 
который состоит из 10 чисел с индексами от 1 до 10}
...
begin
A[1]:=3; {элементу массива с индексом 1 присваиваем значение 3}
A[2]:=8; {элементу массива с индексом 2 присваиваем значение 8}
A[3]:=6; {элементу массива с индексом 3 присваиваем значение 6}
 
for i:=1 to 3 do
    writeln(A[i]) 
{в цикле выводим значения трех элементов массива: 
A[1], A[2] и A[3]
т.е. на экране появятся числа: 
3 
8 
6
}
Пример объявления массива и работы с ним в Бэйсике:
 
DIM A(10) AS INTEGER
'массив A  - целочисленный массив, 
'который состоит из 10 чисел с индексами от 1 до 10
...
A(1)=3 'элементу массива с индексом 1 присваиваем значение 3
A(2)=8 'элементу массива с индексом 2 присваиваем значение 8
A(3)=6 'элементу массива с индексом 3 присваиваем значение 6
 
FOR i = 1 TO 3
    PRINT A(i)
NEXT i 
'в цикле выводим значения трех элементов массива: 
'A(1), A(2) и A(3)
'т.е. на экране появятся числа: 
'3 
'8 
'6
Пример инициализации массива и работы с ним в Питоне (Python):
 
A=[3, 8, 6, 10, 15, 2, 7, 9, 8, 7] 
# A  - массив, 
# который состоит из 10 чисел с индексами от 0 до 9
# т.е. A[0]=3 элемент массива с индексом 0 равен значению 3
# A[1]=8 элемент массива с индексом 1 равен значению 8
# A[2]=6 элемент массива с индексом 2 равен значению 6
 
for i in range (3):
    print (A[i])
# в цикле выводим значения трех элементов массива: 
# A[0], A[1] и A[2]
# т.е. на экране появятся числа: 
# 3 
# 8 
# 6

Разбор 6 задания ОГЭ по информатике

Линейные алгоритмы

* до 2020 г — это было задание № 8 ОГЭ

Подробный видеоразбор по ОГЭ 6 задания:

  • Рассмотрены 3 задачи. Перемотайте видеоурок на решение нужной задачи.

  • Рассмотрим примеры решения 6 задания ОГЭ.

    Решение задания 6.1:

    В программе := обозначает оператор присваивания, знаки +, -, * и / — соответственно операции сложения, вычитания, умножения и деления. Правила выполнения операций и порядок действий соответствуют правилам арифметики.

    Определите значение переменной b после выполнения алгоритма:

    а := 7
    b := 4
    а := 2*а + 3*b
    b := a/2*b
    

    В ответе укажите одно целое число — значение переменной b.
      
    Типовые задания для тренировки

    ✍ Решение:
     

      Разберем алгоритм подробно:

    • Первое действие: а := 7. В переменную а присвоили значение 7.
    • Второе действие: b := 4. В переменную b присвоили значение 4.
    • Третье действие: а := 2*а + 3*b. Подставим значения и вычислим результат с учетом порядка выполнения действий:
    • а := 2*а + 3*b = 2*7 + 3*4 = 14 + 12 = 26
      
    • Четвертое действие: b := a/2*b. Подставим значения и вычислим результат:
    • b := a/2*b = 26/2*4 = 52
      

    Ответ: 52


    Решение задания 6.2:

    В программе := обозначает оператор присваивания, знаки +, -, * и / — соответственно операции сложения, вычитания, умножения и деления. Правила выполнения операций и порядок действий соответствуют правилам арифметики.

    Определите значение переменной a после выполнения алгоритма:

    а := 4
    b := 4
    b := a/2*b
    a := 2*а + 3*b
    

    В ответе укажите одно целое число — значение переменной a.
      
    Типовые задания для тренировки

    ✍ Решение:
     

      Разберем алгоритм подробно:

    • Первое действие: а := 4. В переменную а присвоили значение 4.
    • Второе действие: b := 4. В переменную b присвоили значение 4.
    • Третье действие: b := a/2*b. Подставим значения и вычислим результат:
    • b := a/2*b = 4/2*4 = 8
      
    • Четвертое действие: а := 2*а + 3*b. Подставим значения и вычислим результат с учетом порядка выполнения действий:
    • а := 2*а + 3*b = 2*4 + 3*8 = 8 + 24 = 32
      

    Ответ: 32


    Решение задания 6.3. Демонстрационный вариант ОГЭ 2020 г.:
      
    Ниже приведена программа, записанная на трёх языках программирования.

    Алгоритмический язык:

    алг
    нач
    цел s, t
    ввод s
    ввод t
    если s>10 или t>10
      то вывод “ДА”
      иначе вывод “НЕТ”
    все
    кон
    
    Бейсик:

    DIM s, t AS INTEGER
    INPUT s
    INPUT t
    IF s>10 OR t>10 THEN
      PRINT ‘ДА’
    ELSE
      PRINT ‘НЕТ’
    ENDIF
    Паскаль:

    var s,t: integer;
    begin
    readln(s);
    readln(t);
    if (s>10) or (t>10)
      then writeln(“ДА”)
      else writeln(“НЕТ”)
    end.

    Было проведено 9 запусков программы, при которых в качестве значений переменных s и t вводились следующие пары чисел:

    (1, 2); (11, 2); (1, 12); (11, 12); (-11, -12); 
    (-11, 12); (-12, 11); (10, 10); (10, 5)

    Сколько было запусков, при которых программа напечатала «ДА»?

    ✍ Решение:
     

      Разберем алгоритм на языке Паскаль подробно. Укажем в комментариях действия программы:

      var s,t: integer;
      begin
      readln(s);  // ввод значения для s
      readln(t);  // ввод значения для t
      if (s>10) or (t>10)    // условие: если s>10 или t>10
        then writeln(“ДА”)   // если условие истинно: выводим “ДА”
        else writeln(“НЕТ”)  // иначе (если условие ложно): выводим “НЕТ”
      end.
    • Вспомним, что логическая операция ИЛИ (or) истинна, когда хоть одно из условий истинно, а ложна только тогда, когда ОБА условия ложны.
    • Рассмотрим каждый запуск отдельно:

      1. (1, 2):
      if (1>10) or (2>10)    // условие ложно (оба ложны), выводим “НЕТ”
      
      2. (11, 2):
      if (11>10) or (2>10)    // условие истинно (11>10), выводим “ДА”
      
      3. (1, 12):
      if (1>10) or (12>10)    // условие истинно (12>10), выводим “ДА”
      
      4. (11, 12):
      if (11>10) or (12>10)    // условие истинно (11>10) и (12>10), выводим “ДА”
      
      ...
      
    • Анализируя ход решений, понимаем, что «Да» будет напечатано при запуске, когда хоть одно из двух введенных значений больше 10, или оба значения больше 10. Выберем такие запуски и посчитаем их количество:
    • (11, 2) (1, 12) (11, 12) (-11, 12) (-12, 11)
      
    • Получили 5 вариантов запуска.

    Ответ: 5


    Простейшие циклические алгоритмы

    * до 2020 г — это было задание № 9 ОГЭ

      

      Подробный видеоразбор по ОГЭ 6 задания (продолжение):

    • Рассмотрено 5 задач. Перемотайте видеоурок на решение нужной задачи.

    Рассмотрим примеры решения 6 задания ОГЭ с циклами.

    Решение задания 6.4:

    Запишите значение переменной s, полученное в результате работы следующей программы. Текст программы приведён на двух языках программирования.

    Паскаль:

    1
    2
    3
    4
    5
    6
    7
    
    Var s,k: integer; 
    Begin 
    s := 0; 
    for k := 3 to 7 do 
      s := s + 6; 
    writeln(s); 
    End.

    Бэйсик:

    1
    2
    3
    4
    5
    6
    7
    
    DIM k, s AS INTEGER 
     
    s = 0 
    FOR к = 3 TO 7 
      s = s + 6 
    NEXT k 
    PRINT s

    Типовые задания для тренировки

    ✍ Решение:
     

      Рассмотрим алгоритм:

    • В начале программы переменной s присваивается значение 0, т.е. переменная обнуляется (3-я строка).
    • Затем следует цикл со счетчиком (for), посчитаем количество итераций (шагов) цикла:
    • последнее значение минус первое значение плюс один:
      7 - 3 + 1 = 5
      
      получаем 5 итераций
      
    • В цикле к переменной s, которая изначально равна нулю, прибавляется число 6. Так как в цикле всего 5 итераций (шагов), то посчитаем итоговое значение переменной s:
    • s = 0 + 6 + 6 + 6 + 6 + 6 = 30
      
      или проще:
      s = 6 * 5 = 30
      

    Ответ: 30

    Решение задания 6.5:

    Запишите значение переменной s, полученное в результате работы следующей программы. Текст программы приведён на двух языках программирования.

    Паскаль:

    1
    2
    3
    4
    5
    6
    7
    
    Var s,k: integer; 
    Begin 
    s := 50; 
    for k := 0 to 8 do 
      s := s - 4; 
    writeln(s); 
    End.

    Бэйсик:

    1
    2
    3
    4
    5
    6
    7
    
    DIM k, s AS INTEGER 
     
    s = 50 
    FOR к = 0 TO 8 
      s = s - 4 
    NEXT k 
    PRINT s

      
    Типовые задания для тренировки

    ✍ Решение:
     

      Рассмотрим алгоритм:

    • В начале программы переменной s присваивается значение 50.
    • Затем следует цикл со счетчиком (for), посчитаем количество итераций (шагов) цикла:
    • последнее значение минус первое значение плюс один:
      8 - 0 + 1 = 9
      
      получаем 9 итераций
      
    • В цикле от переменной s, которая изначально равна 50, отнимается число 4. Так как в цикле всего 9 итераций (шагов), то посчитаем итоговое значение переменной s:
    • s = 50 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 = 14
      
      или проще:
      s = 50 - 9*4 = 14
      

    Ответ: 14

    Решение задания 6.6:

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

    Паскаль:

    1
    2
    3
    4
    5
    6
    7
    
    Var s,k: integer; 
    Begin 
    s := 2; 
    for k := 1 to 3 do 
      s := s*s; 
    writeln(s); 
    End.

    Бэйсик:

    1
    2
    3
    4
    5
    6
    7
    
    DIM k, s AS INTEGER 
     
    s = 2 
    FOR k = 1 TO 3 
      s =  s*s 
    NEXT k 
    PRINT s

      
    Типовые задания для тренировки

    ✍ Решение:
     

      Рассмотрим алгоритм:

    • В начале программы переменной s присваивается значение 2.
    • Затем следует цикл со счетчиком (for), посчитаем количество итераций (шагов) цикла:
    • последнее значение минус первое значение плюс один:
      3 - 1 + 1 = 3
      
      получаем 3 итерации
      
    • В цикле переменная s, которая изначально равна 2, умножается сама на себя. Так как в цикле всего 3 итерации (шага), то посчитаем итоговое значение переменной s:
    • 1 шаг: s = 2 * 2 = 4
      2 шаг: s = 4 * 4 = 16
      3 шаг: s = 16 * 16 = 256
      

    Ответ: 256

    Решение задания 6.7:

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

    Паскаль:

    1
    2
    3
    4
    5
    6
    7
    
    Var s,k: integer; 
    Begin 
    s := 1; 
    for k := 3 downto 0 do 
      s := s*3; 
    write(s); 
    End.

    Бэйсик:

    1
    2
    3
    4
    5
    6
    7
    8
    
    DIM k, s AS INTEGER 
     
    s = 1 
    FOR к = 3 TO 0 STEP -1
      s =  s*3 
    NEXT k 
    PRINT s
    END

      
    Типовые задания для тренировки

    ✍ Решение:
     

      Рассмотрим алгоритм:

    • В начале программы переменной s присваивается значение 1.
    • Затем следует цикл со счетчиком (for), посчитаем количество итераций (шагов) цикла:
    • большее значение минус меньшее значение плюс один:
      3 - 0 + 1 = 4
      
      получаем 4 итерации
      
    • В цикле переменная s, которая изначально равна 1, умножается на 3. Так как в цикле всего 4 итерации (шага), то посчитаем итоговое значение переменной s:
    • 1 шаг: s = 1 * 3 = 3
      2 шаг: s = 3 * 3 = 9
      3 шаг: s = 9 * 3 = 27
      4 шаг: s = 27 * 3 = 81
      
      или проще:
      s = 34 = 81
      

    Ответ: 81


    Решение задания 6.8:

    Запишите значение переменной u, полученное в результате работы следующей программы.

    Паскаль:

    1
    2
    3
    4
    5
    6
    7
    
    Var u,i: integer;
    Begin
    u := 30;
    For i := 1 to 6 do
       u := u – i;
    Writeln(u);
    End.

    Бэйсик:

    1
    2
    3
    4
    5
    6
    
    DIM i,u AS INTEGER
    u = 30
    FOR i = 1 TO 6
       u = u – i
    NEXT i
    PRINT u

      
    Типовые задания для тренировки

    ✍ Решение:
     

      Рассмотрим алгоритм:

    • В начале программы переменной u присваивается значение 30.
    • Затем следует цикл со счетчиком (for), посчитаем количество итераций (шагов) цикла:
    • большее значение минус меньшее значение плюс один:
      6 - 1 + 1 = 6
      
      получаем 6 итераций
      
    • В цикле из переменной u, которая изначально равна 30, вычитается значение счетчика цикла i. Счетчик цикла изменяется от 1 до 6. Учтем это при рассмотрении 6 итераций (шагов) цикла:
    • 1 шаг: u = 30 - 1 = 29
      2 шаг: u = 29 - 2 = 27
      3 шаг: u = 27 - 3 = 24
      4 шаг: u = 24 - 4 = 20
      5 шаг: u = 20 - 5 = 15
      6 шаг: u = 15 - 6 = 9
      
      или проще:
      u = 30 - 1 - 2 - 3 - 4 - 5 - 6 = 9
      

    Ответ: 9


    Циклические алгоритмы обработки массива чисел

    * до 2020 г — это было задание № 10 ОГЭ
      Подробный видеоразбор по ОГЭ 6 задания данного типа:

    • Рассмотрено 6 задач. Перемотайте видеоурок на решение нужной задачи.

    Решение задания 6.9:

    В таб­ли­це Dat хранятся дан­ные из­ме­ре­ний сред­не­суточной тем­пе­ра­ту­ры за 10 дней в гра­ду­сах (Dat[1] — дан­ные за пер­вый день, Dat[2] — за вто­рой и т. д.).

    Определите, какое число будет на­пе­ча­та­но в ре­зуль­та­те ра­бо­ты следующей программы.

    Текст про­грам­мы приведён на нескольких язы­ках программирования:

    Паскаль:

    Var k, m: integer;
     Dat: array[1..10] of integer;
     Begin
        Dat[1] := 12; Dat[2] := 15;
        Dat[3] := 17; Dat[4] := 15;
        Dat[5] := 14; Dat[6] := 12;
        Dat[7] := 10; Dat[8] := 13;
        Dat[9] := 14; Dat[10] := 15;
        m := 0;
        for k := 1 to 10 do
           if Dat[k] > m then
            begin
               m := Dat[k];
           end;
        writeln(m);
     End.

    Бейсик:

    DIM Dat(10) AS INTEGER
    DIM k,m AS INTEGER
    Dat(1) = 12: Dat(2) = 15
    Dat(3) = 17: Dat(4) = 15
    Dat(5) = 14: Dat(6) = 12
    Dat(7) = 10: Dat(8) = 13
    Dat(9) = 14: Dat(10) = 15 
    m = 0
    FOR k = 1 TO 10
      IF Dat(k) > m THEN
        m = Dat(k)
      ENDIF
    NEXT k
    PRINT m

    Python:

    Dat = [12, 15, 17, 15, 14, 12, 10, 13, 14, 15]
    m = 0
    for k in range (10):
        if Dat[k] > m:
            m = Dat[k]
    print (m)

      
    Типовые задания для тренировки

    ✍ Решение:
     

      Рассмотрим алгоритм:

    • В начале программы каждому элементу массива Dat — с первого по десятый элемент — присваиваются значения:
    • Dat[1] = 12 
      Dat[2] = 15
      ...
      Dat[10] = 15
      

      Затем обнуляется переменная m:

      m = 0
    • В конце программы распечатывается значение m:
    • writeln(m)
    • В программе в цикле со счетчиком k, изменяемым от 1 до 10, каждый элемент массива Dat сравнивается со значением переменной m: если просматриваемый элемент больше m, то в переменную m присваивается его значение. Рассмотрим подробно алгоритм на языке Pascal для четырех первых итераций (шагов) цикла :
    • 1 шаг:
      for k := 1 to 10 do  => k=1      
       if Dat[k] > m then  => если 12 > 0, то  
         begin             => условие истинно, значит    
           m := Dat[k];    => m := 12         
         end;
      
      2 шаг:
      for k := 1 to 10 do  => k=2     
       if Dat[k] > m then  => Если 15 > 12 то  
         begin             => условие истинно, значит     
           m := Dat[k];    => m := 15        
         end;
      
      3 шаг:
      for k := 1 to 10 do  => k=3      
       if Dat[k] > m then  => Если 17 > 15 то  
         begin             => условие истинно, значит      
           m := Dat[k];    => m := 17     
         end;
      
      4 шаг:
      for k := 1 to 10 do  => k=4
       if Dat[k] > m then  => Если 15 > 17 то
         begin             => условие ложно, значит   
           m := Dat[k];    => ничего не делаем, m остается = 17
         end;
      
      ...
      
    • Проанализировав алгоритм для 4 шагов цикла, видим, что в результате, в переменной m останется наибольшее значение из всех элементов массива Dat.
    • Рассмотрим значения всех элементов: 12, 15, 17, 15, 14, 12, 10, 13, 14, 15. Наибольшее из значений — число 17. Значит в m сохранится 17.

    Результат: 17


    Решение задания 6.10:

    В таблице Dat хранятся данные измерений среднесуточной температуры за 10 дней в градусах (Dat[1] — данные за первый день, Dat[2] — за второй и т. д.).

    Определите, какое число будет напечатано в результате работы следующей программы.

    Текст программы приведён на нескольких языках программирования:

    Паскаль:

    Var k, m: integer;
    Dat: array[1..10] of integer;
    Begin
    Dat[1] := 12; Dat[2] := 15;
    Dat[3] := 17; Dat[4] := 15;
    Dat[5] := 14; Dat[6] := 12;
    Dat[7] := 10; Dat[8] := 13;
    Dat[9] := 14; Dat[10] := 15;
    m := 0;
    for k := 1 to 10 do
      if Dat[k] > 12 then
      begin
         m := m + 1;
      end;
    writeln(m);
    End.

    Бейсик:

    DIM Dat(10) AS INTEGER
    DIM k,m AS INTEGER
    Dat(1) = 12: Dat(2) = 15
    Dat(3) = 17: Dat(4) = 15
    Dat(5) = 14: Dat(6) = 12
    Dat(7) = 10: Dat(8) = 13
    Dat(9) = 14: Dat(10) = 15
    m = 0
    FOR k = 1 TO 10
      IF Dat(k) > 12 THEN
         m = m + 1
      ENDIF
    NEXT k
    PRINT m

    Python:

    Dat = [12, 15, 17, 15, 14, 12, 10, 13, 14, 15]
    m = 0
    for k in range (10):
      if Dat[k] > 12:
        m = m + 1
    print (m)

      
    C++:

    #include <iostream>
    using namespace std;
    int main() {
    int Dat[10] = {12, 15, 17, 15, 14, 12, 10, 13, 14, 15};
    int m = 0;
    for (int k = 0; k < 10; k++)
      if (Dat[k] > 12) m = m + 1;
        cout << m;
    return 0;
    }

      
    Типовые задания для тренировки

    ✍ Решение:
     

      Рассмотрим алгоритм:

    • В начале программы каждому элементу массива Dat — с первого по десятый элемент — присваиваются значения:
    • Dat[1] = 12 
      Dat[2] = 15
      ...
      Dat[10] = 15
      

      Затем обнуляется переменная m:

      m = 0
    • В конце программы распечатывается значение m:
    • writeln(m)
    • В программе в цикле со счетчиком k, изменяемым от 1 до 10, каждый элемент массива Dat сравнивается с числом 12: если просматриваемый элемент больше 12, то переменную m увеличиваем на единицу (m = m + 1). Рассмотрим подробно алгоритм на языке Pascal для четырех первых итераций (шагов) цикла :
    • 1 шаг:
      for k := 1 to 10 do  => k=1      
       if Dat[k] > m then  => если 12 > 12, то  
         begin             => условие ложно, значит    
           m := Dat[k];    => ничего не делаем, m остается = 0        
         end;
      
      2 шаг:
      for k := 1 to 10 do  => k=2     
       if Dat[k] > m then  => Если 15 > 12 то  
         begin             => условие истинно, значит     
           m := Dat[k];    => m := 0 + 1 = 1        
         end;
      
      3 шаг:
      for k := 1 to 10 do  => k=3      
       if Dat[k] > m then  => Если 17 > 12 то  
         begin             => условие истинно, значит      
           m := Dat[k];    => m := 1 + 1 = 2     
         end;
      
      4 шаг:
      for k := 1 to 10 do  => k=4
       if Dat[k] > m then  => Если 15 > 12 то
         begin             => условие истинно, значит    
           m := Dat[k];    => m := 2 + 1 = 3  
         end;
      
      ...
      
    • Проанализировав алгоритм для 4 шагов цикла, видим, что переменная m — это счетчик, который считает количество элементов массива Dat, которые больше числа 12.
    • Рассмотрим значения всех элементов: 12, 15, 17, 15, 14, 12, 10, 13, 14, 15. Количество элементов, больших числа 12 равно 7. Значит в m сохранится 7.

    Результат: 7


    Решение задания 6.11. Сборник «ОГЭ-2018, 20 тренировочных вариантов», Ушаков Д.М., 2018 г., ВАРИАНТ 3:

    В таблице A представлены данные о количестве голосов, поданных за 10 исполнителей народных песен (A[1] — количество голосов, поданных за первого исполнителя, A[2] — за второго и т. д.).

    Определите, какое число будет напечатано в результате работы следующей программы.

    Текст программы приведён на нескольких языках программирования:

    Паскаль:

    var k, m: integer;
    A: array[1..10] of integer;
    Begin
    A[1] := 16; A[2] := 20;
    A[3] := 20; A[4] := 41;
    A[5] := 14; A[6] := 21;
    A[7] := 28; A[8] := 12;
    A[9] := 15; A[10] := 35;
    m := 1;
    for k := 1 to 10 do
      if A[k] > A[m] then
      begin
         m := k;
      end;
    writeln(m);
    End.

    Бейсик:

    DIM A(10) AS INTEGER
    DIM k,m AS INTEGER
    A(1) = 16: A(2) = 20
    A(3) = 20: A(4) = 41
    A(5) = 14: A(6) = 21
    A(7) = 28: A(8) = 12
    A(9) = 15: A(10) = 35
    m = 1
    FOR k = 1 TO 10
      IF A(k) > A(m) THEN
         m = k
      ENDIF
    NEXT k
    PRINT m

    Python:

    A= [16, 20, 20, 41, 14, 21, 28, 12, 15, 35]
    m = 1
    for k in range (10):
      if A[k] > A[m]:
        m = k
    print (m)

      
    C++:

    #include <iostream>
    using namespace std;
    int main() {
    int A[10] = {16, 20, 20, 41, 14, 21, 28, 12, 15, 35};
    int m = 1;
    for (int k = 0; k < 10; k++)
      if (A[k] > A[m]) m = k;
        cout << m;
    return 0;
    }

      
    Типовые задания для тренировки

      
    ✍ Решение:
     

      Рассмотрим алгоритм:

    • В начале программы каждому элементу массива A — с первого по десятый элемент — присваиваются значения:
    • A[1] = 16 
      A[2] = 20
      ...
      A[10] = 35
      
    • Затем переменной m присваивается значение 1:
    • m = 1
    • В конце программы распечатывается значение m:
    • writeln(m)
    • В программе в цикле со счетчиком k, изменяемым от 1 до 10, каждый элемент массива A сравнивается с элементом A[m]: если просматриваемый элемент больше значения элемента A[m], то в переменную m заносится значение k (m = k). Рассмотрим подробно алгоритм на языке Pascal для четырех первых итераций (шагов) цикла :
    • 1 шаг:
      for k := 1 to 10 do   => m=1, k=1     
       if A[k] > A[m] then  => если 16 > 16, то  
         begin              => условие ложно, значит    
           m := k;          => ничего не делаем, m остается = 1        
         end;
      
      2 шаг:
      for k := 1 to 10 do   => m=1, k=2     
       if A[k] > A[m] then  => если 20 > 16 то  
         begin              => условие истинно, значит     
           m := k;          => m := 2        
         end;
      
      3 шаг:
      for k := 1 to 10 do   => m=2, k=3      
       if A[k] > A[m] then  => если 20 > 20 то  
         begin              => условие ложно, значит       
           m := k;          => ничего не делаем, m остается = 2     
         end;
      
      4 шаг:
      for k := 1 to 10 do   => m=2, k=4
       if A[k] > A[m] then  => если 41 > 20 то
         begin              => условие истинно, значит    
           m := k;          => m := 4  
         end;
      
      ...
      
    • Проанализировав алгоритм для 4 шагов цикла, видим, что переменная m принимает значение порядкового номера наибольшего элемента массива A.
    • Рассмотрим значения всех элементов: 16, 20, 20, 41, 14, 21, 28, 12, 15, 35. Наибольший элемент имеет значение 41, это четвертый элемент массива. Значит в m сохранится значение 4.

    Результат: 4


    Решение задания 6.12. Сборник «ОГЭ-2018, 20 тренировочных вариантов», Ушаков Д.М., 2018 г., ВАРИАНТ 7:

    В таблице A представлены данные о количестве голосов, поданных за 10 исполнителей народных песен (A[1] — количество голосов, поданных за первого исполнителя, A[2] — за второго и т. д.).

    Определите, какое число будет напечатано в результате работы следующей программы.

    Текст программы приведён на нескольких языках программирования:

    Паскаль:

    var k, m: integer;
    A: array[1..10] of integer;
    Begin
    A[1] := 20; A[2] := 16;
    A[3] := 20; A[4] := 36;
    A[5] := 15; A[6] := 21;
    A[7] := 28; A[8] := 17;
    A[9] := 16; A[10] := 35;
    m := 1;
    for k := 1 to 10 do
      if A[k] >= A[m] then
      begin
         m := m + 1;
      end;
    writeln(m);
    End.

    Бейсик:

    DIM A(10) AS INTEGER
    DIM k,m AS INTEGER
    A(1) = 20: A(2) = 16
    A(3) = 20: A(4) = 36
    A(5) = 15: A(6) = 21
    A(7) = 28: A(8) = 17
    A(9) = 16: A(10) = 35
    m = 1
    FOR k = 1 TO 10
      IF A(k) >= A(m) THEN
         m = m + 1
      ENDIF
    NEXT k
    PRINT m

    Python:

    A= [20, 16, 20, 36, 15, 21, 28, 17, 16, 35]
    m = 1
    for k in range (10):
      if A[k] >= A[m]:
        m = m + 1
    print (m)

      
    C++:

    #include <iostream>
    using namespace std;
    int main() {
    int A[10] = {20, 16, 20, 36, 15, 21, 28, 17, 16, 35};
    int m = 1;
    for (int k = 0; k < 10; k++)
      if (A[k] >= A[m]) m = m + 1;
        cout << m;
    return 0;
    }

      
    ✍ Решение:
     

      Рассмотрим алгоритм:

    • В начале программы каждому элементу массива A — с первого по десятый элемент — присваиваются значения:
    • A[1] = 20 
      A[2] = 16
      ...
      A[10] = 35
      
    • Затем переменной m присваивается значение 1:
    • m = 1
    • В конце программы распечатывается значение m:
    • writeln(m)
    • В программе в цикле со счетчиком k, изменяемым от 1 до 10, каждый элемент массива A сравнивается с элементом A[m]: если просматриваемый элемент больше либо равен значению элемента A[m], то переменная m увеличивается на единицу (m = m + 1). Рассмотрим подробно алгоритм на языке Pascal для четырех первых итераций (шагов) цикла :
    • 1 шаг:
      for k := 1 to 10 do    => m=1, k=1     
       if A[k] >= A[m] then  => если 20 >= 20, то  
         begin               => условие истинно, значит   
           m := m + 1;       => m := 1 + 1 = 2         
         end;
      
      2 шаг:
      for k := 1 to 10 do    => m=2, k=2     
       if A[k] >= A[m] then  => если 16 >= 16 то  
         begin               => условие истинно, значит     
           m := m + 1;       => m := 2 + 1 = 3        
         end;
      
      3 шаг:
      for k := 1 to 10 do   => m=3, k=3      
       if A[k] > A[m] then  => если 20 >= 20 то  
         begin              => условие истинно, значит        
           m := m + 1;      => m := 3 + 1 = 4      
         end;
      
      4 шаг:
      for k := 1 to 10 do   => m=4, k=4
       if A[k] > A[m] then  => если 36 >= 36 то
         begin              => условие истинно, значит    
           m := m + 1;      => m := 4 + 1 = 5
         end;
      
      
    • Проанализировав алгоритм для 4 шагов цикла, видим, что в цикле постоянно сравнивается текущий элемент с самим собой (это происходит из-за нестрогой операции сравнения: >=). Таким образом, переменная m постоянно увеличивается на единицу и принимает то же значение, что и переменная k.
    • На последнем шаге цикла и переменная m и переменная k будут равны 10. Сравнив элемент с самим собой выполнится операция m := m + 1, m станет = 11, и цикл завершится:
    • 10 шаг:
      for k := 1 to 10 do   => m=10, k=10
       if A[k] > A[m] then  => если 35 >= 35 то
         begin              => условие истинно, значит    
           m := m + 1;      => m := 10 + 1 = 11  
         end;
      

    Результат: 11


    Решение задания 6.13:

    В таблице Dat хранятся данные о количестве сделанных заданий учениками (Dat[1] — заданий сделал первый ученик, Dat[2] — второй и т.д.).

    Определите, какое число будет напечатано в результате работы следующей программы.

    Текст программы приведён на нескольких языках программирования:

    Паскаль:

    var k, m, n: integer;
    Dat: array[1..10] of integer;
    Begin
    Dat[1] := 7; Dat[2] := 9;
    Dat[3] := 10; Dat[4] := 5;
    Dat[5] := 6; Dat[6] := 7;
    Dat[7] := 9; Dat[8] := 8;
    Dat[9] := 6; Dat[10] := 9;
    m := 10;
    n := 0;
    for k := 1 to 10 do
      if Dat[k] < m then
      begin
        m := Dat[k];
        n := k;
      end;
    writeln(n);
    End.

    Бейсик:

    DIM Dat(10) AS INTEGER
    DIM k, m, n AS INTEGER
    Dat(1) = 7: Dat(2) = 9
    Dat(3) = 10: Dat(4) = 5
    Dat(5) = 6: Dat(6) = 7
    Dat(7) = 9: Dat(8) = 8
    Dat(9) = 6: Dat(10) = 9
    m = 10; n = 0
    FOR k = 1 TO 10
      IF Dat(k) < m THEN
        m = Dat(k)
        n = k
      ENDIF
    NEXT k
    PRINT n

    Python:

    Dat = [7, 9, 10, 5, 6, 7, 9, 8, 6, 9]
    m = 10
    n = 0
    for k in range(0,10):
      if Dat[k] < m:
        m = Dat[k]
        n = k + 1
    print (n)

      
    C++:

    #include <iostream>
    using namespace std;
    int main() {
    int Dat[10] = {7, 9, 10, 5, 6, 7, 9, 8, 6, 9};
    int m = 10;
    int n = 0;
    for (int k = 0; k < 10; k++)
      if (Dat[k] < m) {
        m = Dat[k];
        n = k + 1;
      }
    cout << n;
    return 0;
    }

      
    Типовые задания для тренировки

    ✍ Решение:
     

      Рассмотрим алгоритм:

    • В начале программы каждому элементу массива Dat — с первого по десятый элемент — присваиваются значения:
    • Dat[1] = 7 
      Dat[2] = 9
      ...
      Dat[10] = 9
      
    • Затем переменной m присваивается значение 10, а переменная n обнуляется:
    • m = 10
      n = 0
      
    • В конце программы распечатывается значение n:
    • writeln(n)
    • В программе в цикле со счетчиком k, изменяемым от 1 до 10, каждый элемент массива Dat сравнивается со значением переменной m: если просматриваемый элемент меньше m, то переменной m присваивается значение рассматриваемого элемента (m = Dat[k]), а переменной n присваивается текущее значение счетчика цикла — k (n = k). Рассмотрим подробно алгоритм на языке Pascal для четырех первых итераций (шагов) цикла :
    • 1 шаг:
      for k := 1 to 10 do  => k=1, m=10, n=0      
       if Dat[k] < m then  => если 7 < 10, то  
         begin             => условие истинно, значит      
           m := Dat[k];    => m := 7    
           n := k;         => n := 1
         end;
      
      2 шаг:
      for k := 1 to 10 do  => k=2, m=7, n=1      
       if Dat[k] < m then  => Если 9 < 7 то  
         begin             => условие ложно, значит    
           m := Dat[k];    => ничего не делаем, m остается = 7  
           n := k;         => ничего не делаем, n остается = 1
         end;
      
      3 шаг:
      for k := 1 to 10 do  => k=3, m=7, n=1        
       if Dat[k] < m then  => Если 10 < 7 то  
         begin             => условие ложно, значит       
           m := Dat[k];    => ничего не делаем, m остается = 7      
           n := k;         => ничего не делаем, n остается = 1
         end;
      
      4 шаг:
      for k := 1 to 10 do  => k=4, m=7, n=1 
       if Dat[k] < m then  => Если 5 < 7 то
         begin             => условие истинно, значит    
           m := Dat[k];    => m := 5 
           n := k;         => n := 4
         end;
      
      ...
      
    • Проанализировав алгоритм для 4 шагов цикла, видим, что переменная m в результате получает значение наименьшего элемента Dat, в то время как в переменной n сохраняется порядковый номер этого наименьшего элемента.
    • Рассмотрим значения всех элементов: 7, 9, 10, 5, 6, 7, 9, 8, 6, 9. Наименьший элемент равен 5, а его порядковый номер = 4

    Ответ: 4


    Решение задания 6.14. Демонстрационный вариант перспективной модели, 2019 г.

    В результате выполнения программы напечатано число 10.
    Какое наибольшее значение может иметь переменная S после выполнения программы?

    Текст программы приведён на нескольких языках программирования.

    Паскаль:

    Var k, m, S, N: integer;
    Dat: array[1..100] of integer;
    Begin
    N:= 5;
    m := 0; S := 0;
    for k := 1 to N do
      readln(Dat[k]);
    for k := 1 to N do begin
      S := S + Dat[k];
      if Dat[k]>m then
      begin
        m := Dat[k]
      end
    end;
    writeln(m)
    End.

    Бейсик:

    DIM Dat(100) AS INTEGER
    DIM N AS INTEGER
    DIM k, m, S AS INTEGER
    N = 5
    FOR k = 1 TO N
       INPUT Dat(k)
    NEXT k
    m = 0
    S = 0
    FOR k = 1 TO N
       S = S + Dat(k)
       IF Dat(k)>m THEN
          m = Dat(k)
       END IF
    NEXT k
    PRINT m

    ✍ Решение:
     

      Рассмотрим алгоритм:

    • В начале программы переменным N, m и S присваиваются значения:
    • N = 5
      m = 0 
      S = 0
      
    • Затем в цикле запрашиваются для ввода с клавиатуры значения пяти (N = 5) элементов массива Dat:
    • for k := 1 to N do
         readln(Dat[k]);
      
    • В следующем цикле со счетчиком k, изменяемым от 1 до 5 (N = 5), значение каждого элемента массива Dat прибавляется к переменной S:
    • S := S + Dat[k]
    • Поскольку начальное значение S = 0, то за все итерации (шаги) цикла в S получим:
    • S = 0 + Dat[1] + Dat[2] + Dat[3] + Dat[4] + Dat[5]
    • То есть S — это сумма пяти элементов массива (сумматор).
    • В том же цикле далее идет проверка, которая сравнивает значение текущего элемента массива с переменной m: если элемент массива больше m, то в m присваивается значение этого текущего элемента:
    • if Dat[k]>m then
      begin
         m := Dat[k]
      end
      
    • Таким образом, после выполнения цикла полностью, в m сохранится наибольший элемент из пяти элементов массива.
    • В конце программы распечатывается значение m и по условию задачи оно равно 10.
    • По условию также нам необходимо определить, какое наибольшее значение может иметь переменная S, то есть сумма всех элементов.
    • Поскольку нам необходимо получить наибольшее значение S (суммы), а самое большое значение элементов — это 10 (m), то предположим, что все остальные элементы должны быть наибольшими, но не больше, чем 10:
    • S = 10 + 10 + 10 + 10 + 10
      или 
      S = 10 * 5 = 50
      

    Ответ: 50


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

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

    *
    *


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