Информатика ОГЭ 10 задание объяснение и разбор, понятие цикла и массива

На уроке рассмотрен материал для подготовки к ОГЭ по информатике, разбор 10 задания. Объясняются циклические алгоритмы обработки массива чисел.

К оглавлению

Содержание:

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

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

10-е задание: «Циклический алгоритм обработки массива чисел, записанный на алгоритмическом языке».
Уровень сложности — повышенный,
Максимальный балл — 1,
Примерное время выполнения — 6 минут.

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

Пример объявления массива и работы с ним в Паскале:

 
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

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

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

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

В таблице 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

Решение задания 10.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

Решение задания 10.3. Сборник «ОГЭ-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

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

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

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

Паскаль:

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

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

В таблице 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

Решение задания 10.6. Демонстрационный вариант перспективной модели, 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

К оглавлению

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

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

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

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