Cтруктурированный тип данных – массив. Особенности работы с одномерными массивами
Массив – структурированный тип данных, состоящий из пронумерованных значений одного типа (элементов массива), имеющих общее имя.
Массивы бывают одномерные, двумерные и т.д. n-мерные. Это зависит от нумерации. Наиболее используемыми являются одномерные и двумерные массивы.
В повседневной и научной практике часто приходится иметь дело с информацией, представленной в табличной форме.
Пример. Представьте себе поезд «Москва – Петербург», в состав которого входят n вагонов одинаковой вместимости, с различным количеством пассажиров.
Данные об этом можно было бы представить в следующей таблице:
| № вагона: | 1 | 2 | 3 | 4 | …………… | n-1 | n |
| Количество пассажиров: | 20 | 35 | 12 | 50 | …………… | 52 | 12 |
Таблица имеет имя «Москва – Петербург», элементами таблицы являются количества пассажиров в вагонах. Количества пассажиров – это данные целого типа. Чтобы узнать, количество человек, находящихся в том или ином вагоне, необходимо указать название поезда и номер вагона.
Чтобы выполнить с помощью компьютера математическую обработку данных такой таблицы, используют одномерный массив. Имя таблицы будет идентификатором массива (например, Mosk_Peter, или M_P, или A, или tab и т.п.). Элементы таблицы (количества пассажиров) - элементами массива. К ним следует обращаться по номерам вагонов (например, если задали имя M_P, то M_P[1], M_P[n], и т.д.).
Обратите внимание: Номер элемента – не может быть вещественным числом!
Тип элементов массива, может быть и не целым.
Например, если таблица содержит данные о росте учеников класса в метрах, то данные в них рациональны.
Описание массивов
Переменная типа массив, как и любая другая переменная, должна быть описана в разделе описания переменных.
Var <идентификатор> : array [<тип индекса>] of <тип элементов>;
Идентификатор – имя переменной-массива.
Тип индекса – в качестве типа индекса, чаще всего, указывают интервал значений, которые может принимать номер элемента массива.
Пример
Var M_P : array[1 .. 100] of byte; {Массив, максимальное количество элементов которого 100 штук, и все они являются данными целого типа}
Rost : array[1 .. 50] of real; {Массив, максимальное количество элементов которого 50 штук, и все они являются данными вещественного типа}
Описание массива определяет, во-первых, размещение массива в памяти, во-вторых, правила его дальнейшего употребления в программе.
В первом случае, ячейка памяти M_P разобьется на 100 подряд идущих разделов, размером по одному байту каждый. В них, после ввода массива, будут расположены данные M_P[1], M_P[2] и т.д. Сама переменная-массив будет занимать 100 байтов памяти.
Во втором случае, ячейка Rost разобьется на 50 подряд идущих разделов, размером по 6 байт каждый. В них, после ввода массива, будут расположены данные Rost[1], Rost[2] и т.д. Весь массив будет занимать 300 байтов памяти.
Не обязательно, что все ячейки памяти будут заполнены. Это зависит от того, как будет вводиться массив.
Ввод и вывод массива
Ввод и вывод массива осуществляются по-элементно. Каждый элемент массива вводится процедурой read, а выводится процедурой write. Таким образом, если нужно ввести или вывести n элементов массива, то следует использовать операторы цикла.Var A : array[1 .. 100] of integer;
I , n : integer;
Begin
Read (n); {ввели количество элементов массива}
For i := 1 to n do read (a[i]); {от 1 до последнего каждый элемент вводится с клавиатуры}
For i := 1 to n do write (a[i],' '); {от 1 до последнего каждый элемент выводится на экран}
End.
Действия над массивом как единым целым
1. Можно значения одного массива присвоить другому (при этом массивы должны быть однотипны):Var A, B : array[1..500] of integer;
I, n : integer;
Begin
Read (n); { ввели количество элементов массива }
For i := 1 to n do read (a[i]); { от 1 до последнего каждый элемент массива А вводится с клавиатуры }
For i := 1 to n do read (b[i]); { от 1 до последнего каждый элемент массива В вводится с клавиатуры }
A := B; { все элементы массива А станут равны соответствующим элементам массива В }
For i := 1 to n do write (a[i],' '); { от 1 до последнего каждый элемент массива выводится на экран }
End.
2. Можно массивы сравнивать на «равно» и «не равно».
Const t = 100;
Var A, B : array[1..t] of integer;
I, n : integer;
Begin
Read (n); {ввели количество элементов массива}
For i := 1 to n do read (a[i]); {от 1 до последнего каждый элемент массива А вводится с клавиатуры}
For i := 1 to n do read (b[i]); {от 1 до последнего каждый элемент массива B вводится с клавиатуры}
if A = B then wrte ('все элементы массива А равны соответствующим элементам массива В');
if A <> B then wrte ('среди элементов массивов А и В есть хотябы одна пара не совпавших');
End.
Работа с элементами массива
Каждый элемент массива имеет свое уникальное имя, которое складывается из имени массива и порядкового номера элемента: A[1], A[2], A[i], A[n div 2], A[n - 2], A[n] и т.д.Так к ним и надо обращаться в программе.
Пример: В состав поезда «Москва – Петербург» входят n вагонов одинаковой вместимости, с различным количеством пассажиров.
Определить:
а) количество пассажиров поезда;
б) количество пустых вагонов;
в) номера пустых вагонов;
г) наибольшее количество пассажиров в вагоне;
д) номера вагонов с наибольшим количеством пассажиров.
Дано: M_P – массив, значениями которого будут количества пассажиров поезда (элементы типа byte);
n – количество вагонов в поезде( integer).
а) Найти: Sum - количество пассажиров поезда ( integer).
Решение:
Чтобы найти количество пассажиров поезда, нужно сложить количества пассажиров в каждом из вагонов, то есть, найти сумму элементов массива.
Пусть i – номера элементов массива, т.е. переменная, принимающая целые значения от 1 до n (integer). Если перебирать с помощью цикла с параметром i номера элементов массива, к самим элементам можно обращаться по именам M_P[i] и добавлять их к общей сумме Sum.
Программа:
Var M_P : array[1..100] of byte;
n, i, Sum : integer;
Begin
Writeln ('введите количество вагонов поезда');
Read (n);
For i := 1 to n do begin
Writeln ('введите количество пассажиров в ', i, '-ом вагоне');
Read (M_P[i]);
end;
Sum := 0;
For i := 1 to n do Sum := Sum + M_P[i];
Writeln ('Количество пассажиров поезда ', Sum, ' человек');
End.
б) Найти: kol - количество пустых вагонов поезда ( byte).
Решение:
Чтобы найти количество пустых вагонов поезда, нужно увеличивать переменную kol на единицу, как только обнаружится пустой вагон. Поэтому нужно просмотреть все элементы массива и сравнить их с нулем.
Программа:
Var M_P : array[1..100] of byte;
n, i : integer; kol : byte;
Begin
Writeln ('введите количество вагонов поезда');
Readln (n);
For i :=1 to n do begin
Writeln ('введите количество пассажиров в ', i, '-ом вагоне');
Read (M_P[i]);
end;
kol := 0;
For i := 1 to n do if M_P[i] = 0 then kol := kol + 1;
Writeln ('В данном поезде ', kol, ' пустых вагонов');
End.
в) Найти: i - номера пустых вагонов поезда ( integer).
Решение:
Чтобы найти номера пустых вагонов поезда, нужно выводить на экран номер элемента массива, если этот элемент равен нулю.
Программа:
Var M_P : array[1..100] of byte;
n, i : integer;
Begin
Writeln ('введите количество вагонов поезда');
Readln (n);
For i := 1 to n do begin
Writeln ('введите количество пассажиров в ', i, '-ом вагоне');
Read (M_P[i]);
end;
For i := 1 to n do if M_P[i] = 0 then Writeln ('Вагон с номером ', i, ' пустой');
End.
г) Найти: max – наибольшее количество пассажиров в вагоне ( byte).
Решение:
Чтобы найти наибольшее количество пассажиров в вагоне поезда, нужно определить максимальный элемент массива. Примем за «максимальный» первый элемент массива (занесем его значение в переменную max). Остальные будем с ним сравнивать (если элемент массива больше, чем max, то его значение будет занесено в переменную max). В итоге, когда будут просмотрены все элементы массива, в переменной max окажется максимальный элемент.
Программа:
Var M_P : array[1..100] of byte;
n, i : integer; max : byte;
Begin
Writeln ('введите количество вагонов поезда');
Readln (n);
For i := 1 to n do begin
Writeln ('введите количество пассажиров в ', i, '-ом вагоне');
Read (M_P[i]);
end;
max := M_P[1];
For i := 2 to n do if M_P[i] > max then max := M_P[i];
Writeln ('Максимальное количество пассажиров в одном вагоне этого поезда', max, ' человек');
End.
д) Найти: i – номера вагонов с наибольшим количеством пассажиров (integer).
Решение:
Пусть max – максимальное количество пассажиров, проезжающих в одном из вагонов поезда. Это переменная типа byte, значение которой мы уже умеем находить. Чтобы найти номера вагонов с наибольшим количеством пассажиров, достаточно вывести на экран номера элементов массива равных значению переменной max.
Var M_P : array[1..100] of byte;
n, i : integer; max : byte;
Begin
Writeln ('введите количество вагонов поезда');
Readln (n);
For i := 1 to n do begin
Writeln ('введите количество пассажиров в ', i, '-ом вагоне');
Read (M_P[i]);
end;
max := M_P[1];
For i := 2 to n do if M_P[i] > max then max := M_P[i];
For i := 1 to n do if M_P[i] = max then Writeln ('В ', i, '-ом вагоне проезжает максимальное количество пассажиров');
End.
Формирование одномерных массивов
Заполнение одномерных массивов производится не только в результате ввода с клавиатуры. Иногда решение задачи требует формирование одномерного массива по определенному принципу. Тогда заполнение массива следует производить при помощи оператора присваивания.
Пример 1: На начальной станции производится посадка на поезд «Москва-Петербург». По приказу начальника станции состав следует укомплектовать следующим образом: посадку пассажиров производить только в вагоны с нечетными номерами; в первый вагон посадить 40 человек, а в каждый последующий на два человека меньше, чем в предыдущий. Вывести на экран распределение пассажиров, если поезд состоит из n вагонов.
Дано: n – количество вагонов поезда (integer).
Найти: M_P – массив, элементами которого будут количества пассажиров поезда.
Решение:
Чтобы заполнить массив, необходимо обратиться к каждому из его элементов M_P[i], где i – номер элемента (от 1 до n). Это можно осуществить посредством оператора цикла с параметром. Заполнять M_P[i] мы будем только тогда, когда i – нечетное число. Следовательно, в теле цикла будет условный оператор. Каждому элементу массива с нечетным номером будет присвоено определенное значение. Пусть это значение формируется в переменной k. Первоначальное значение этой переменной 40, но после каждого присваивания значение переменной должно уменьшаться на 2. Но может оказаться так, что вагонов с нечетными номерами слишком много и пассажиров на всех не хватит. Тогда, уменьшая переменную k на 2, мы в конце-концов начнем получать отрицательные числа. Такого быть не должно. Поэтому процесс заполнения элементов массива должен продолжаться только в случае положительного значения переменной k. Таким образом, в условном операторе следует поставить сложное условие.
Программа:
Var n, i : integer; k : byte;
M_P : array[1..100] of byte;
Begin
Writeln ('введите количество вагонов поезда');
Read (n);
k := 40;
For i := 1 to n do if (i mod 2 = 1) and (k > 0) then
begin
M_P[i] := k;
k := k - 2;
end;
Writeln ('пассажиры распределятся следующим образом:');
for i := 1 to n do write (M_P[i], ' ');
End.
Пример 2: Из товарного состава, везущего уголь, следует сформировать новый, исключив пустые вагоны. Каков будет новый состав, если первый состоял из n вагонов, по-разному загруженных углем?
Дано: n – количество вагонов поезда (integer).
U1 – массив, элементами которого будут массы угля в тоннах в каждом из вагонов (real).
Найти: U2 – массив, элементами которого будут массы угля в тоннах в каждом из вагонов, после исключения пустых вагонов (real).
Решение:
Чтобы заполнить массив U2, необходимо обратиться к каждому из элементов U1[i], где i – номер элемента (от 1 до n). Это можно осуществить посредством оператора цикла с параметром. Заполнять U2[i] мы будем только тогда, когда U1[i] – число не равное 0. Следовательно, в теле цикла будет условный оператор. Чтобы вывести на экран полученный массив, необходимо знать количество элементов в нем. Пусть k – количество элементов массива U2. Вначале значение этой переменной равно 0. Перед каждым присваиванием элементу массива U2 его значения, значение переменной k должно увеличиваться на 1.
Программа:
Var n, i, k : integer;
U1, U2 : array[1..100] of real;
Begin
Writeln ('введите количество вагонов первого состава');
Read (n);
For i := 1 to n do
begin
Writeln ('введите вес угля в ', i, '-ом вагоне');
Read (U1[i]);
end;
k:=0;
For i := 1 to n do
if U1[i] <> 0 then
begin
k := k + 1;
U2[k] := U1[i];
end;
Writeln ('новый состав будет следующим:');
for i := 1 to k do write (U2[i], ' ');
End.
Сортировка массивов. Сортировка элементов одномерного массива методом простого выбора
Сортировка – расстановка данных по определенному признаку. Это один из наиболее распространенных процессов современной обработки данных.
Возьмем, к примеру, библиотеку. Книги в библиотеке могут быть отсортированы в алфавитном порядке по названию или по фамилии автора, по году издания или по величине переплета, по количеству страниц или по тематике и т.д. Можно привести огромное множество примеров сортировки. Так как нам приходится иметь дело с массивами данных, то наиболее распространенными здесь являются задачи сортировки элементов массива по возрастанию, убыванию, невозрастанию и неубыванию.
Последовательность чисел является возрастающей, если каждый последующий элемент больше предыдущего.
Последовательность чисел является убывающей, если каждый последующий элемент меньше предыдущего.
Последовательность чисел является невозрастающей, если каждый последующий элемент не больше (меньше или равен) предыдущего.
Последовательность чисел является неубывающей, если каждый последующий элемент не меньше (больше или равен) предыдущего.
Из определений, очевидно, что основным отличием является знак между элементами. Поэтому достаточно найти решение одной из задач, а все остальные будут решены простой сменой знака.
Существует огромное множество методов сортировок.
Пример. Дан одномерный массив целых чисел. Необходимо распределить его элементы в порядке возрастания.
Дано: A – массив, значениями которого будут целые числа (элементы типа integer);
n – количество элементов массива (byte);
Результат: A – отсортированный массив.
Решение:
Рассмотрим наиболее простой метод сортировки – метод простого выбора.
Суть: Среди элементов массива находится минимальный и меняется местами с первым. Затем, среди элементов кроме первого, снова находится минимальный и меняется местами со вторым и т.д.
Пусть наш массив состоит из пяти элементов (n = 5): 5 8 3 9 1.
Первый шаг: 5 8 3 9 1 В результате: 1 8 3 9 5.
Второй шаг: 1 8 3 9 5 В результате: 1 3 8 9 5.
Третий шаг: 1 3 8 9 5 В результате: 1 3 5 9 8.
Четвертый шаг: 1 3 5 9 8 В результате: 1 3 5 8 9.
Вывод: при количестве элементов 5 штук, массив сортируется за четыре шага. Значит, при количестве элементов n штук – массив будет отсортирован за n - 1 шаг.
При этом, каждый шаг, минимальный элемент меняется местами с элементом, номер которого совпадает с номером шага. Причем, сам минимальный следует искать, начиная с этого элемента.
Пусть i – номер шага (от 1 до n - 1), j - номера элементов, среди которых будет отыскиваться минимальный. Тогда j будет изменяться от i до n.
Программа:
Const t = 50;
Var A : array[1..t] of integer;
i, j, n, min, nom : integer;
Begin
Read (n);
For i := 1 to n do read (A[i]);
For i := 1 to n - 1 do {n - 1 раз делается следующее...}
begin
Min := A[i]; nom := i; {принимаем за минимальный, элемент с номером i}
For j := i to n do if A[j] < min then begin min := A[j]; nom := j end; {поиск минимального элемента на i-том шаге}
A[nom] := A[i]; A[i] := min; {меняем местами минимальный элемент с i-тым}
end;
for i := 1 to n do write (A[i], ' ');
end.
Сортировка массивов. Сортировка элементов одномерного массива методом «пузырька»
Несмотря на простоту предыдущего метода сортировки, в кругу программистов особой популярностью пользуется "пузырьковый" метод. Рассмотрим его программную реализацию на примере той же задачи.
Пример. Дан одномерный массив целых чисел. Необходимо распределить его элементы в порядке возрастания.
Дано: A – массив, значениями которого будут целые числа (элементы типа integer);
n – количество элементов массива (byte);
Результат: A – отсортированный массив.
Решение:
Суть: Рассматривают последовательность элементов, попарно сравнивая их друг с другом, и меняют местами если предыдущий элемент оказывается больше последующего. В результате максимальный элемент оказывается на последнем месте ("всплывает в конце как пузырек"). Затем, тот же процесс производят в группе элементов кроме последнего. В результате на предпоследнее место, в рассматриваемой группе элементов, снова "всплывает" максимальный. И т.д.
Пусть наш массив состоит из пяти элементов (n = 5): 5 8 3 9 1.
Первый шаг: 5 8 3 9 1
1 пара: 5 8 3 9 1 В результате: 5 8 3 9 1.
2 пара: 5 8 3 9 1 В результате: 5 3 8 9 1.
3 пара: 5 3 8 9 1 В результате: 5 3 8 9 1.
4 пара: 5 3 8 9 1 В результате: 5 3 8 1 9 {всплыл первый "пузырек"}
Второй шаг: 5 3 8 1 9
1 пара: 5 3 8 1 9 В результате: 3 5 8 1 9.
2 пара: 3 5 8 1 9 В результате: 3 5 8 1 9.
3 пара: 3 5 8 1 9 В результате: 3 5 1 8 9 {всплыл второй "пузырек"}
Третий шаг: 3 5 1 8 9
1 пара: 3 5 1 8 9 В результате: 3 5 1 8 9.
2 пара: 3 5 1 8 9 В результате: 3 1 5 8 9 {всплыл третий "пузырек"}
Четвертый шаг: 3 1 5 8 9
1 пара: 3 1 5 8 9 В результате: 1 3 5 8 9 {всплыл четвертый "пузырек"}
Массив отсортирован: 1 3 5 8 9 !
Вывод: при количестве элементов 5 штук, массив сортируется за четыре шага. Значит, при количестве элементов n штук – массив будет отсортирован за n - 1 шаг.
Каждый шаг количество рассматриваемых пар уменьшается на 1: вначале n - 1 пара, затем n - 2 пары и т.д. до 1 пары. Следовательно, каждый шаг количество пар равно
(n минус номер шага).
Пусть i – номер шага (от 1 до n - 1), j - количество пар. Тогда j будет изменяться от 1 до n - i.
Программа:
Const t = 50;
Var A : array[1..t] of integer;
i, j, n, x : integer;
Begin
Read (n);
For i := 1 to n do read (A[i]);
For i := 1 to n - 1 do {n - 1 раз делаем следующее...}
For j := 1 to n - i do {рассматриваем группу из n - i элементов}
if A[j] > A[j + 1] then {последовательно сравниваем каждую пау элементов в группе}
begin x := A[j]; A[j] := A[j + 1]; A[j + 1] := x; end; {при выполнении условия, меняем элементы местами}
For i := 1 to n do write (A[i], ' ');
End.
Двумерные массивы. Особенности работы с двумерными массивами
До сих пор мы рассматривали задачи, в которых приходилось обрабатывать последовательности однотипных значений. Последовательность имела имя, а каждое ее значение имело свой порядковый номер, по которому компьютер к нему обращался. В жизни часто приходится иметь дело с таблицами, содержащими большее количество полей. Например, таблица, содержащая данные о весе учеников в параллели восьмых классов:| 1 | 2 | 3 | 4 | ……………………………………… | n-1 | n | |
| 8a | 50.8 | 55.9 | 40.3 | 45.8 | ……………………………………… | 45.8 | 50.9 |
| 8б | 45.6 | 43.0 | 50.8 | 48.7 | ……………………………………… | 49.0 | 47.7 |
| 8в | 50.7 | 48.9 | 45.8 | 44.9 | ……………………………………… | 45.0 | 45.0 |
| 8г | 54.0 | 56.9 | 45.7 | 40.7 | ……………………………………… | 43.8 | 54.0 |
Чтобы обратиться к элементу такой таблицы, необходимо указать наименование класса и номер ученика в этом классе. Теперь элемент имеет два номера: «номер строки таблицы» и «номер столбца таблицы». Для работы с таблицами такого вида используется - двумерный массив. Двумерные массивы часто называют матрицами.
Описание двумерных массивов
Описание двумерных массивов аналогично описанию одномерных.Var <идентификатор>: array[<типы индексов>] of <тип элементов>;
Идентификатор – имя массива.
У элементов двумерного массива два индекса (номера), поэтому, в качестве типов индексов указывают интервалы значений, которые может принимать номер строки и номер столбца.
Например:
Var Ves : array[1..4, 1..35] of real;
Здесь описан массив, максимальное количество элементов которого 4 * 35 = 140 штук, и все они являются данными вещественного типа real. Такой массив как раз подойдет для хранения таблицы данных о весе учащихся восьмой параллели.
В памяти компьютера выделится ячейка, которая разобьется на 140 разделов, размером по 6 байт. В них, после ввода массива, будут расположены данные Ves[1, 1], Ves[1, 2], … Ves[1, n], Ves[2, 1], Ves[2, 2] и т.д. Весь массив будет занимать 840 байтов памяти.
Не обязательно, что все ячейки памяти будут заполнены. Это зависит от того, как будет вводиться массив.
Ввод и вывод двумерного массива
Ввод и вывод массива осуществляются покомпонентно. Каждый элемент массива вводится оператором read и, аналогично, каждый элемент массива выводится оператором write.Var A : array[1..10, 1..10] of integer;
i, j, n, m : integer;
Begin
Read (n, m); {ввели количество строк и столбцов массива}
For i := 1 to n do {перебираем номера строк}
For j := 1 to m do read (a[i, j]); {от 1 до последнего каждый элемент вводится с клавиатуры: вначале элементы первой строки, затем второй и т.д.}
For i := 1 to n do begin
For i := 1 to n do write (a[i, j], ' '); {вывод элементов i-ой строки}
Writeln; {переход на новую строку}
end;
End.
Действия над элементами массива
Каждый элемент массива имеет свое уникальное имя, которое складывается из имени массива и порядкового номера элемента:A[1, 6], A[4, 2], A[i, j], A[n div 2, 4], A[n - 2, m - 7], A[n, m] и т.д.
Так к ним и надо обращаться в программе.
В основном все задачи на двумерные массивы решаются аналогично, как и на одномерные. Только не следует забывать, что элемент имеет два индекса, а таблица состоит из строк и столбцов.
Пример. В школе проводилась олимпиада по математике среди учащихся восьмых классов. В ней приняли участие по n представителей от каждого класса. Данные об олимпиаде – это количество баллов, набранное каждым из учеников.
Необходимо посчитать:
а) средний балл по параллели;
б) количество учеников в параллели, не набравших ни одного балла;
в) максимальный балл по параллели;
г) номера победителей по параллели;
д) номера победителей в каждом из классов.
Дано: A – массив, значениями которого будут баллы участников олимпиады (элементы типа byte);
n – количество классов в восьмой параллели ( byte);
m – количество представителей от класса (byte).
а) Найти: Sball – средний балл, набранный в параллели (real).
Решение:
Чтобы найти средний балл, нужно сложить баллы, набранные каждым из учеников, то есть, найти сумму элементов массива (Oball) и разделить ее на количество всех учеников (m * n).
Программа:
Var A : array[1..10, 1..35] of byte;
n, m, i, j : byte; Oball : integer; Sball : real;
Begin
Writeln ('введите количество классов в параллели'); Read (n);
Writeln ('введите количество участников от каждого из классов'); Read (m);
For i := 1 to n do For j := 1 to m do begin
Writeln ('введите балл ', j, '-го ученика в ', i, '-ой группе');
Read (A[i, j]);
end;
Oball := 0;
For i := 1 to n do For j := 1 to m do Oball := Oball + A[i, j];
Sball := Oball / (n * m);
Writeln ('Средний балл по параллели- ', Sball : 4 : 2);
End.
б) Найти: Kol - количество учеников в параллели, не набравших ни одного балла (byte).
Решение:
Решение задачи сводится к поиску элементов массива, значение которых равно нулю. Чтобы найти количество, нужно увеличивать переменную kol на единицу, как только обнаружится элемент массива равный нулю. Поэтому нужно просмотреть все элементы массива и сравнить их с нулем.
Программа:
Var A : array[1..10, 1..35] of byte;
n, m, i, j, kol : byte;
Begin
Writeln ('введите количество классов в параллели'); Read (n);
Writeln ('введите количество участников от каждого из классов'); Read (m);
For i := 1 to n do For j := 1 to m do begin
Writeln ('введите балл ', j, '-го ученика в ', i, '-ой группе'); Read (A[i, j]);
end;
kol := 0;
For i := 1 to n do For j := 1 to m do if A[i, j] = 0 then kol := kol + 1;
Writeln ('Ни одного балла не набрали ', kol, ' учеников');
End.
в) Найти: Max – максимальный балл по параллели (byte).
Решение:
Решение задачи сводится к нахождению максимального элемента массива.
Программа:
Var A : array[1..10, 1..35] of byte;
n, m, i, j, max : byte;
Begin
Writeln ('введите количество классов в параллели'); Read (n);
Writeln ('введите количество участников от каждого из классов'); Read (m);
For i := 1 to n do For j := 1 to m do begin
Writeln ('введите балл ', j, '-го ученика в ', i, '-ой группе'); Read (A[i, j]);
end;
max := A[1, 1];
For i := 1 to n do For j := 1 to m do if A[i, j] > max then max := a[i, j];
Writeln ('Максимальный балл по параллели - ', max);
End.
г) Найти: i , j – номера победителей по параллели (byte).
Решение:
Пусть max – максимальный балл по параллели. Это переменная типа byte, значение которой мы уже умеем находить. Чтобы найти номера победителей, достаточно вывести на экран номера строк и столбцов элементов массива равных значению переменной max.
Программа:
Var A : array[1..10, 1..35] of byte;
n, m, i, j, max : byte;
Begin
Writeln ('введите количество классов в параллели'); Read (n);
Writeln('введите количество участников от каждого из классов'); Read (m);
For i := 1 to n do For j := 1 to m do begin
Writeln ('введите балл ', j, '-го ученика в ', i, '-ой группе'); Read (A[i, j]);
end;
max := A[1, 1];
For i := 1 to n do For j := 1 to m do if A[i, j] > max then max := A[i, j];
Writeln ('Номера победителей');
Writeln ('N группы N ученика ');
For i := 1 to n do For j := 1 to m do if A[i, j] = max then
writeln (' ', i, ' ', j);
End.
е) Найти: i, j – номера победителей в каждом из классов.
Решение:
В нашем массиве каждая строка содержит результаты олимпиады в группе представителей отдельного класса. Для решения задачи необходимо найти максимальный балл в каждой строке и вывести номера победителей только данной строки. Например, решение задачи для данных первой строки, можно отразить в следующем фрагменте:
i := 1; {обрабатываем первую строку}
max := A[i, 1]; {в качестве «максимального» выбираем первый элемент в рассматриваемой строке}
For j := 1 to m do {перебираем номера элементов в рассматриваемой строке с номером i, равным 1}
if A[i, j] > max then max := A[i, j]; { ищем максимальный элемент в строке}
Write ('Номера победителей ', i, '-ой строки: ');
For j := 1 to m do if A[i, j] = max then write (j, ', '); {выводим номера элементов, равных по величине значению переменной max}
Аналогичным образом, необходимо обработать все строки массива. Переменная i, отвечающая за номер строки, должна постепенно принять все свои значения от 1 до n. Предложенный фрагмент следует сделать телом цикла по параметру i.
Программа:
Var A : array[1..10, 1..35] of byte;
n, m, i, j, max : byte;
Begin
Writeln ('введите количество классов в параллели'); Read (n);
Writeln ('введите количество участников от каждого из классов'); Read (m);
For i := 1 to n do For j := 1 to m do begin
Writeln ('введите балл ', j, '-го ученика в ', i, '-ой группе'); Read (A[i, j]);
end;
For i := 1 to n do begin
max := A[i, 1];
For j := 1 to m do if A[i, j] > max then max := a[i, j];
Write ('Номера победителей ', i, '-ой строки: ');
For j := 1 to m do if A[i, j] = max then write (j, ', ');
writeln;
end;
End.
Формирование двумерных массивов
Заполнение двумерных массивов производится не только в результате ввода с клавиатуры. Иногда решение задачи требует формирование двумерного массива по определенному принципу. Тогда заполнение массива следует производить при помощи оператора присваивания.Пример 1. Сформировать таблицу умножения, имеющую вид:
1 2 3 .. m
2 4 6 .. 2m
3 6 9 .. 3m
. . .
. . .
n 2n 3n .. mn
Дано: n – количество строк массива (integer);
m – количество столбцов массива (integer).
Найти: А – массив-«таблица умножения».
Решение:
Чтобы заполнить массив, необходимо обратиться к каждому из его элементов A[i, j], где i – номер строки (от 1 до n), а j – номер столбца (от 1 до m). Это можно осуществить с помощью вложенных циклов с параметром. Заполнять А[i, j] мы будем произведением его номера строки и столбца.
Программа:
Var n, m, i, j : integer;
A: array[1..30, 1..30] of integer;
Begin
Writeln ('введите количество строк и столбцов'); Read (n, m);
For i := 1 to n do For j := 1 to m do A[i, j] := i * j;
Writeln ('Таблица умножения');
For i := 1 to n do begin
For j := 1 to m do write (A[i, j], ' ');
writeln;
end;
End.
Пример 2. Сформировать таблицу степеней, имеющую вид:
1 2 3 ... m
1 4 9 ... m2
1 8 27 ... m3
1 16 81 ... m4
. . .
. . .
1n 2n 3n ... mn
Дано: n – максимальный показатель степени в таблице (integer);
m – максимальное основание степени (integer).
Найти: А – массив, элементами которого будут степени чисел (longint).
Решение:
Чтобы заполнить массив A, необходимо обратиться к каждому из элементов A[i, j]. Очевидно, что элементы заполняются по формуле A[i, j] :=j i . Такой массив удобно заполнять по столбцам. Если рассматривать отдельный столбец массива, то можно заметить, что в нем каждый последующий элемент равен предыдущему, умноженному на номер столбца. Для заполнения фиксированного столбца с номером j можно применить следующий фрагмент программы.
Программа:
Var A : array[1..10, 1..10] of longint;
n, m, i, j : byte;
Begin
Read (n, m);
For j := 1 to m do begin
A[1, j] := j;
For i := 2 to n do A[i, j] := A[i - 1, j] * j;
end;
For i := 1 to n do begin
For j := 1 to m do Write (A[i, j], ' ');
writeln;
end;
End.