Описание регулярного типа (массива)

Описание регулярного типа (массива)

Массив – это набор элементов одного типа, каждому из которых соответствует свой номер, называемыйиндексом. Доступ к элементам массива осуществляется именно через эти индексы. Элементами массива могут быть данные любого типа. С каждым элементом в отдельности можно работать точно также, как с обычной переменной. Для этого нужно всего лишь указать его индекс.

Общий вид объявления массивов выглядит так:

<Имя массива> : array[<нижняя граница массива>..<верхняя граница массива>] of <тип данных>;

Имя массива – произвольное имя, выдаваемое вами массиву. Массив по сути своей является такой же переменной, поэтому его можно называть произвольным образом исходя из соображений удобства и наглядности.

Нижняя и верхняя граница массива – это целочисленные значения, определяющие пределы массива. Например, если это соответственно 1 и 6, то массив содержит 6 элементов с индексами 1, 2, 3, 4, 5 и 6. Если это – 2 и 5, то массив содержит 4 элемента с индексами 2, 3, 4 и 5.

Тип данных – тип переменных, составляющих массив.

Например:

var

Numbers : array [1..9] of integer;

Здесь мы задаем массив целочисленного типа, содержащий 9 элементов.

После объявления массива с ним надо каким-то образом работать. Вот как это делается:

<Имя массива>[<индекс>]

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

1)  Присваивать значения: Numbers[2] := 34;

2)  Использовать как операнды в арифметических операциях: Numbers[1] := Numbers[1] = Numbers[2];

3)  Выводить на экран: Wtite(Numbers[4]);

4)  Записывать в них вводимы с клавиатуры значения: Read(Numbers[3]);

5)  Использовать в операциях сравнения: if Numbers[6] > 13 then Write(‘Больше!!!’);

6)  Использовать для задания количества повторений цикла:

For i:=3 to Numbers[5] do

Begin

<тело цикла>

End;

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

Var

Numbers: array[1..10]  of integer;

begin

Read(Numbers[1], Numbers[2], Numbers[3], Numbers[4], Numbers[5], Numbers[6], Numbers[7], Numbers[8], Numbers[9], Numbers[10]);

End.

Это очень неудобно и некрасиво. Поэтому следует использовать для этих целей циклы:

Var

Numbers : array[1..10]  of integer;

i: integer;

Begin

For i:=1 to 10 do

Read(Numbers[i]);

End.

Алгоритмически это выглядит так:

 

Как упоминалось выше, массивы бывают различных типов. И это абсолютная правда. Например:

Var

a1: array[1..5] of Boolean;

a2: array[0..6] of char;

a3: array[1..25] of real;

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

Двумерные массивы

Рассмотренные нами ранее массивы являются одномерными. Они содержат линейную последовательность переменных одного типа. Что же делать, если данные необходимо как-то систематизировать? Обычно они представляются в виде таблицы. Именно для этих целей и служат многомерные и, в частности, двумерные массивы.

Любой двумерный массив отличается от одномерного прежде всего тем, что для доступа к его элементам используется не один индекс, а два. Ведь, чтобы определенным образом задать какую-либо ячейку двумерной таблицы, нужно указать номер строки и номер столбца.

Общий вид объявления двумерных массивов выглядит так:

<Имя массива> : array[<нижняя граница массива1>..<верхняя граница массива1>,<нижняя граница массива2>..<верхняя граница массива2>] of <тип данных>;

Например:

Var

Matrix : array[1..5,1..5] of integer;

Именно таким образом в программах представляются матрицы, т.е. двумерные таблицы чисел. Для того, чтобы реализовать ввод матрицы в компьютер с клавиатуры, необходимо использовать вложенные циклы:

For i:=1 to 5 do

For j:=1 to 5 do

                        Read(Matrix[i,j]);

Здесь i и j – счетчики, объявляемые в разделе var. Они должны быть целочисленного типа (byte, integer).

Алгоритм такого кода:

 

Взгляните на эту таблицу:

i   \   j  1         2         3         4         5

1          11        12        13        14        15

2          21        22        23        24        25

3          31        32        33        34        35

4          41        42        43        44        45

5          51        52        53        54        55

По горизонтали изменяется значение j (номер столбца), а по вертикали – i (номер строки). Каждый конкретный элемент однозначно определяется этими двумя значениями. Например,  возьмем элемент 43 – он располагается в 4 строке, 3 столбце. Соответственно, для него i=4,j=3. При использовании вложенных циклов (как было показано выше) последовательно идет работа с элементами первой строки, потом второй, третьей, четвертой, пятой. Вот как можно вывести матрицу на экран:

For i:=1 to 5 do

For j:=1 to 5 do

                        Write(Matrix[i,j]);

Однако выведенные данные в таком случае будут выглядеть некрасиво, т.к. будут идти сплошным, неразделимым потоком в одну строчку. Поэтому нужно, во-первых, после каждого элемента вставлять пробел, а во-вторых, после каждой выведенной строки переходить на новую с помощью оператора WriteLn (не забудьте также добавить операторные скобки begin и end для тела старшего цикла):

For i:=1 to 5 do

            begin

For j:=1 to 5 do

                        Write(Matrix[i,j],’ ‘);

            WriteLn;

            end;

Алгоритм:

 

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

Пример

Попробуйте самостоятельно написать программу, которая бы принимала с клавиатуры матрицу 3х3 и выводила бы матрицу 3х3, получаемую из исходной заменой столбцов строками (транспонированием):

123                              147

456                              258

789                              369

Решение

Program example_1;

Var

i,j : integer;

a: array[1..3,1..3] of integer;

begin

For i:=1 to 3 do

For j:=1 to 3 do

                        Read(a[i,j]);

For j:=1 to 3 do