Двумерный массив в Паскале трактуется как одномерный массив, тип элементов которого также является массивом (массив массивов). Положение элементов в двумерных массивах Паскаля описывается двумя индексами. Их можно представить в виде прямоугольной таблицы или матрицы.

Рассмотрим двумерный массив Паскаля размерностью 3*3, то есть в ней будет три строки, а в каждой строке по три элемента:

Каждый элемент имеет свой номер, как у одномерных массивов, но сейчас номер уже состоит из двух чисел – номера строки, в которой находится элемент, и номера столбца. Таким образом, номер элемента определяется пересечением строки и столбца. Например, a 21 – это элемент, стоящий во второй строке и в первом столбце.

Описание двумерного массива Паскаля.

Существует несколько способов объявления двумерного массива Паскаля.

Мы уже умеем описывать одномерные массивы, элементы которых могут иметь любой тип, а, следовательно, и сами элементы могут быть массивами. Рассмотрим следующее описание типов и переменных:

Type
Vector = array of <тип_элементов>;
Matrix= array of vector;
Var m: matrix;

Мы объявили двумерный массив Паскаля m, состоящий из 10 строк, в каждой из которых 5 столбцов. При этом к каждой i -й строке можно обращаться m [ i ], а каждому j -му элементу внутри i -й строки – m [ i , j ].

Определение типов для двумерных массивов Паскаля можно задавать и в одной строке:

Type
Matrix= array of array of < тип элементов >;
или еще проще:
type
matrix = array of <тип элементов>;

Обращение к элементам двумерного массива имеет вид: M [ i , j ]. Это означает, что мы хотим получить элемент, расположенный в i -й строке и j -м столбце. Тут главное не перепутать строки со столбцами, а то мы можем снова получить обращение к несуществующему элементу. Например, обращение к элементу M имеет правильную форму записи, но может вызвать ошибку в работе программы.

Основные действия с двумерными массивами Паскаля

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

type
matrix= array of integer;
var
a , b: matrix ;

то в ходе выполнения программы можно присвоить матрице a значение матрицы b (a:= b). Все остальные действия выполняются поэлементно, при этом над элементами можно выполнять все допустимые операции, которые определены для типа данных элементов массива. Это означает, что если массив состоит из целых чисел, то над его элементами можно выполнять операции, определенные для целых чисел, если же массив состоит из символов, то к ним применимы операции, определенные для работы с символами.

Ввод двумерного массива Паскаля.

Для последовательного ввода элементов одномерного массива мы использовали цикл for, в котором изменяли значение индекса с 1-го до последнего. Но положение элемента в двумерном массиве Паскаля определяется двумя индексами: номером строки и номером столбца. Это значит, что нам нужно будет последовательно изменять номер строки с 1-й до последней и в каждой строке перебирать элементы столбцов с 1-го до последнего. Значит, нам потребуется два цикла for , причем один из них будет вложен в другой.

Рассмотрим пример ввода двумерного массива Паскаля с клавиатуры:

type
matrix= array of integer;
var
a, : matrix;
i, j: integer; { индексы массива }
begin
for i:=1 to 5 do {цикл для перебора всех строк}
readln (a [ i , j ]); {ввод с клавиатуры элемента, стоящего в i -й строке и j -м столбце}

Двумерный массив Паскаля можно заполнить случайным образом, т.е. использовать функцию random (N), а также присвоить каждому элементу матрицы значение некоторого выражения. Способ заполнения двумерного массива Паскаля выбирается в зависимости от поставленной задачи, но в любом случае должен быть определен каждый элемент в каждой строке и каждом столбце.

Вывод двумерного массива Паскаля на экран.

Вывод элементов двумерного массива Паскаля также осуществляется последовательно, необходимо напечатать элементы каждой строки и каждого столбца. При этом хотелось бы, чтобы элементы, стоящие в одной строке, печатались рядом, т.е. в строку, а элементы столбца располагались один под другим. Для этого необходимо выполнить следующую последовательность действий (рассмотрим фрагмент программы для массива, описанного в предыдущем примере):

for i:=1 to 5 do {цикл для перебора всех строк}
begin
for j:=1 to 10 do {перебор всех элементов строки по столбцам}
write (a [ i , j ]:4); {печать элементов, стоящих в i -й строке матрицы в одной экранной строке, при этом для вывода каждого элемента отводится 4 позиции}
writeln ; {прежде, чем сменить номер строки в матрице, нужно перевести курсор на начало новой экранной строки}
end ;

Замечание (это важно! ): очень часто в программах студентов встречается ошибка, когда ввод с клавиатуры или вывод на экран массива пытаются осуществить следующим образом: readln (a), writeln (a), где а – это переменная типа массив. При этом их удивляет сообщение компилятора, что переменную этого типа невозможно считать или напечатать. Может быть, вы поймете, почему этого сделать нельзя, если представите N кружек, стоящих в ряд, а у вас в руках, например, чайник с водой. Можете вы по команде «налей воду» наполнить сразу все кружки? Как бы вы ни старались, но в каждую кружку придется наливать отдельно. Заполнение и вывод на экран элементов массива также должно осуществляться последовательно и поэлементно, т.к. в памяти ЭВМ элементы массива располагаются в последовательных ячейках.

Представление двумерного массива Паскаля в памяти

Элементы абстрактного массива в памяти машины физически располагаются последовательно, согласно описанию. При этом каждый элемент занимает в памяти количество байт, соответствующее его размеру. Например, если массив состоит из элементов типа integer , то каждый элемент будет занимать по два байта. А весь массив займет S^2 байта, где S – количество элементов в массиве.

А сколько места займет массив, состоящий из массивов, т.е. матрица? Очевидно: S i^S j , где S i - количество строк, а S j – количество элементов в каждой строке. Например, для массива типа

Matrix = array of integer ;

потребуется 12 байт памяти.

Как будут располагаться в памяти элементы этого массива? Рассмотрим схему размещения массива M типа matrix в памяти.

Под каждый элемент M типа integer выделяется две ячейки памяти. Размещение в памяти осуществляется «снизу вверх». Элементы размещаются в порядке изменения индекса, что соответствует схеме вложенных циклов: сначала размещается первая строка, затем вторая, третья... Внутри строки по порядку идут элементы: первый, второй и т.д.

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

Addr + SizeElem * Cols *(I -1)+ SizeElem *(J -1),

где Addr – фактический начальный адрес, по которому массив располагается в памяти; I , J – индексы элемента в двумерном массиве; SizeElem – размер элемента массива (например, два байта для элементов типа integer); Cols – количество элементов в строке.

Выражение SizeElem * Cols *(I -1)+ SizeElem *(J -1) называют смещением относительно начала массива.

Сколько памяти выделяется для массива?

Рассмотрим не столько вопрос о том, сколько памяти выделяется под массив (это мы разобрали в предыдущем разделе), а о том, каков максимально допустимый размер массива, учитывая ограниченный объем памяти.

Для работы программы память выделяется сегментами по 64 Кбайт каждый, причем как минимум один из них определяется как сегмент данных . Вот в этом-то сегменте и располагаются те данные, которые будет обрабатывать программа. Ни одна переменная программы не может располагаться более чем в одном сегменте. Поэтому, даже если в сегменте находится только одна переменная, описанная как массив, то она не сможет получить более чем 65536 байт. Но почти наверняка, кроме массива в сегменте данных будут описаны еще некоторые переменные, поэтому реальный объем памяти, который может быть выделен под массив, находится по формуле: 65536- S , где S – объем памяти, уже выделенный под другие переменные.

Зачем нам это знать? Для того чтобы не удивляться, если при компиляции транслятор выдаст сообщение об ошибке объявления слишком длинного массива, когда в программе встретит описание (правильное с точки зрения синтаксиса):

Type myArray= array of integer;

Вы уже знаете, что, учитывая двухбайтовое представление целых чисел, реально можно объявить массив с количеством элементов равным 65536/2 –1=32767. И то лишь в том случае, если других переменных не будет. Двумерные массивы должны иметь еще меньшие границы индексов.

Примеры решения задач с двумерными массивами Паскаля

Задача: Найти произведение ненулевых элементов матрицы.

Решение:

• Для решения данной задачи нам потребуются переменные: матрица, состоящая, например, из целочисленных элементов; P – произведение элементов, отличных от 0; I , J – индексы массива; N , M – количество строк и столбцов в матрице.
• Входными данными являются N , M – их значения введем с клавиатуры; матрица – ввод матрицы оформим в виде процедуры, заполнение матрицы осуществим случайным образом, т.е. с помощью функции random ().
• Выходными данными будет являться значение переменной P (произведение).
• Чтобы проверить правильность выполнения программы, необходимо вывести матрицу на экран, для этого оформим процедуру вывода матрицы.
• Ход решения задачи:

обсудим сначала выполнение основной программы, реализацию процедур обговорим чуть позже:

• введем значения N и M ;
• Введем двумерный массив Паскаля, для этого обращаемся к процедуре vvod (a), где а – матрица;
• Напечатаем полученную матрицу, для этого обращаемся к процедуре print (a);
• Присвоим начальное значение переменной P =1;
• Будем последовательно перебирать все строки I от 1-й до N -й, в каждой строке будем перебирать все столбцы J от 1-го до M -го, для каждого элемента матрицы будем проверять условие: если a ij ? 0, то произведение P будем домножать на элемент a ij (P = P * a ij);
• Выведем на экран значение произведения ненулевых элементов матрицы – P ;

А теперь поговорим о процедурах.

Замечание (это важно!) Параметром процедуры может быть любая переменная предопределенного типа, это означает, что для передачи в процедуру массива в качестве параметра, тип его должен быть описан заранее. Например:

Type
Matrix=array of integer;
procedure primer (a: matrix);
..............................

Вернемся теперь к нашим процедурам.

Процедура ввода матрицы называется vvod , параметром процедуры является матрица, причем она должна быть, как результат, передана в основную программу, следовательно, параметр должен передаваться по ссылке. Тогда заголовок нашей процедуры будет выглядеть так:

Procedure vvod (var m: matrix);

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

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

Procedure print (m: matrix);

И вновь для реализации вложенных циклов внутри процедуры нам потребуются счетчики, пусть они называются так же – k и h . Алгоритм вывода матрицы на экран был описан выше, воспользуемся этим описанием.

Program proizvedenie;
Type
Matrix=array of integer;
Var
A: matrix;
N, m, i, j: byte;
P: integer;
Procedure vvod (var m: matrix);
Var k , h: byte ;
Begin
For i:=1 to n do {переменная n для процедуры является глобальной, а значит «известной»}
For j:=1 to m do {переменная m для процедуры является глобальной, а значит «известной»}
M:= random(10);
End;
Procedure print (m: matrix);
Var k, h: byte;
Begin
For i:=1 to n do
begin
For j:=1 to m do
Write (M: 4);
Writeln;
end ;
End ;
Begin {начало основной программы}
Writeln ("Введите размерность матрицы:");
Readln(N, M);
Vvod(a);
Print(a);
P:=1;
For i:=1 to N do
For j:=1 to M do
If a<>0 then p:=p*a;
Writeln (p);
End .

Массив (также индексный массив , иногда таблица , ряд ) - именованный (упорядоченный) набор однотипных переменных (данных), расположенных в памяти непосредственно друг за другом, доступ к которым осуществляется по индексу . В простейшем случае массив имеет постоянную длину и хранит единицы данных одного и того же типа.

Индекс же массива - это число целое , указывающее на конкретный элемент массива.

Количество используемых индексов массива может быть различным. Массивы с одним индексом называют одномерными , с двумя - двумерными и т. д.

Одномерный массив нестрого соответствует вектору в математике, двумерный - матрице . Чаще всего применяются массивы с одним или двумя индексами, реже - с тремя, ещё большее количество индексов встречается крайне редко.

Массив описывается так:

Чаще всего типом индекса является диапазон, например:

Выше описывается массив В , состоящий из 5 элементов и символьный массив R , состоящий из 34 элементов. Для массива В будет выделено 5*6=30 байт памяти (т.к. под переменные типа Real выделяется 6 байт памяти), для массива R - 1*34=34 байта памяти (под переменные типа Char - 1 байт). Базовый тип элементов массива может быть любым, как простым, так и структурированным, за исключением файлового! Массив можно объявить с использованием собственного типа:

Циклом может называться любая многократно исполняемая последовательность инструкций, организованная любым способом (например, с помощью условного перехода).

Единичное выполнение тела цикла называется итерацией . Выражение , определяющее, будет в очередной раз выполняться итерация , или цикл закончиться - это условие выхода или условие окончания цикла (но, может быть и условием продолжения). Переменная, хранящая текущий номер итерации, называется счётчиком итераций цикла или просто счётчиком цикла. Цикл не обязательно содержит счётчик .

Циклы бывают:

- Цикл cо счётчиком , в котором некоторая переменная изменяет своё значение от заданногоначального значения до конечного значения с некоторым шагом , и для каждого значения этой переменной тело цикла выполняется один раз. Реализуется оператором for

Пример. Заполнить массив :

А так можно заполнить двумерный массив:

- Цикл с предусловием , который выполняется пока истинно некоторое условие, указанное перед его началом. Реализуется оператором while .

- Цикл с постусловием , в котором условие проверяется после выполнения тела цикла, а, значит, тело всегда выполняется хотя бы один раз. В языке Паскаль этот цикл реализует оператор repeat...until

Существует операция пропуска итерации , когда в текущей итерации цикла необходимо пропустить все команды до конца тела выполняемого цикла. При этом сам цикл прерываться не должен, условия продолжения или выхода должны вычисляться обычным образом. Реализуется оператором continue .

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

Вернемся к началу, а точнее к в начале примеру . Нам нужно определить, что делает данный кусочек программы:

Исходя из вышесказанного, используемый двумерный массив А - это матрица размером n x n . Цикл используется со счетчиком от единицы до n , видимо определенной ранее.

Внутри цикла: переменная с получает значение двумерного массива с индексом (c:= A ),сначала это . Затем на место этого элемента массива заносится значение элемента того же массива, но с индексом (A:= A ), или при k:=1 (A:= A ). Т.е. заносятся элементы первой строки, т.к. первое число в индексе отвечает за номер строки в матрице - [i ,j], а второе за номер столбца - . И в конце, на место элемента с индексом , заносится первоначальное значение элемента массива А с индексом , которое мы занесли в переменную с (A:=c ).

И с каждой итерацией нашего цикла значение i увеличивается на единицу . Проследим по шагам. Сначала это :

с:=A A:=A A:=c

с:=A A:=A A:=c

с:=A A:=A A:=c

И так n раз до . Т.е. значение диагонали матрицы направления слева направо и сверху вниз. И элементы этой диагонали меняются значениями с элементами первой стоки матрицы (или k -той строки). Значит, правильный ответ - вариант 3 : данный алгоритм меняет местами элементы диагонали и k -го столбца таблицы .

Разделы: Информатика

Тема : Двумерные массивы. Заполнение двумерного массива по заданному правилу.

Цели: отработать навыки работы с элементами двумерного массива, научиться заполнять двумерные массивы по заданному правилу, научиться выводить зависимость между номером строки и номером столбца; развитие логического мышления учащихся.

ХОД ЗАНЯТИЯ

1. Актуализация знаний

Массивы, положение элементов в которых описывается двумя индексами, называются двумерными. Структура такого массива может быть представлена прямоугольной матрицей. Каждый элемент матрицы однозначно определяется указанием номера строки и столбца, номер строки – i, номер столбца – j.
Рассмотрим матрицу А размером n*m:

Матрица из 3 строк и 4 столбцов, количество строк n=3, количество столбцов m=4. Каждый элемент имеет свой номер, который состоит из двух чисел – номера строки, в которой находится элемент, и номера столбца. Например, а23 – это элемент, стоящий во второй строке и в третьем столбце.
Двумерный массив на языке Турбо Паскаль можно описать по-разному. Чтобы описать двумерный массив, надо определить какого типа его элементы, и каким образом они пронумерованы (какого типа его индекс). Существует несколько способов описания двумерного массива.

Const maxN=…; {Максимальные значения количества строк}
maxM=…; {Максимальные значения количества столбцов}

1 способ

Type Mas = array of <тип элементов>; {Одномерный массив}
Type TMas = array of Mas; {Одномерный массив, элементами которого являются одномерные массивы}

2 способ

Type TMas = array of array of <тип элементов>;
{Одномерный массив, элементами которого являются одномерные массивы}

3 способ

Type <имя типа>= array of <тип элементов>; {Двумерный массив}

Предпочтение отдается третьему способу описания двумерного массива.

Например:

Const N=3; M=4;
Type TMas= array of integer; {Двумерный массив из целых чисел}

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

1) Формирование двумерного массива при помощи ввода с клавиатуры и алгоритм построчного вывода элементов матрицы.

Const N=10;M=10;
Type Tmas= array of integer;
Var A:Tmas; i,j:integer;
Begin
{Ввод элементов матрицы}
For i:=1 to N do
For j:=1 to M do
Read(A);
{Вывод элементов матрицы}
For i:=1 to N do begin
For j:=1 to M do
Write(A:4); {Печатается первая строка}
Writeln {Переход на новую строку}
end;
End.

2) Фрагмент программы формирования двумерного массива через генератор случайных чисел.

Begin
Randomize; {Инициализация генератора случайных чисел}
{Ввод элементов матрицы}
For i:=1 to N do
For j:=1 to M do
A:=random(45)-22;

2. Изучение нового материала. Заполнение массива по правилу

Рассмотрим несколько фрагментов программ заполнения двумерного массива по некоторому закону. Для этого необходимо вывести правило заполнения.

1. Заполнить массив А размером n*m следующим образом, например

1 2 3 4 5 6 7 8
16 15 14 13 12 11 10 9
17 18 19 20 21 22 23 24
32 31 30 29 28 27 26 25
33 34 35 36 37 38 39 40
48 47 46 45 44 43 42 41

Массив заполняется по принципу «змейки». Правило заполнения: если номер строки – нечетное число, то A=(i-1)*m+j, иначе A=i*m-j+1.

program M1А;

n,m,i,j: integer;
begin
readln(n,m);
for i:=1 to n do begin
for j:=1 to m do
begin
if i mod 2 = 1 then
A=(i-1)*m+j
else
A=i*m-j+1;
write(A:3);
end;
writeln;
end;
readln;
end.

Приведем пример программы другого способа заполнения по заданному правилу:

program M1В;
var A:array of integer;
n,m,i,j: integer;
c: integer;
begin
readln(n,m);
c:=1;
for i:=1 to n do
begin
for j:=1 to m do
begin
A:=c;
if (i mod 2 = 0) and (j<>m) then
dec(c)
else
inc(c);
write(A:3);
end;
c:=c+m-1;
writeln;
end;
readln;
end.

2. Заполнить массив A по следующему принципу:

1 0 2 0 3 0 4
0 5 0 6 0 7 0
8 0 9 0 10 0 11
0 12 0 13 0 14 0

program M2;
var A:array of integer;
n,m,i,j: integer;
c: integer;
begin
readln(n,m);
c:=0;
for i:=1 to n do
begin
for j:=1 to m do
begin
if (i-1+j) mod 2 = 0 then
A:=0
else
begin
inc(c);
A:=c;
end;
write(A:5);
end;
writeln;
end;
readln;
end.

3. Заполнить массив A по следующему принципу:

1 12 13 24 25 36
2 11 14 23 26 35
3 10 15 22 27 34
4 9 16 21 28 33
5 8 17 20 29 32
6 7 18 19 30 31

var A:array of integer;
n,m,i,j: integer;
c: integer;
begin
readln(n,m);
c:=1;
for j:=1 to m do
begin
for i:=1 to n do
begin
A:=c;
if (j mod 2 = 0) and (i<>n) then
dec(c)
else
inc(c);
end;
c:=c+n-1;
end;
for i:=1 to n do
begin
for j:=1 to m do
write(A:5);
writeln;
end;
readln;
end.

4. Заполнить массив A по следующему принципу:

1 2 3 4 5
2 3 4 5 1
3 4 5 1 2
4 5 1 2 3
5 1 2 3 4

var i,j,m,c,d: integer;

begin
c:=1;
readln(m);
for j:=1 to m do
begin
i:=c;
d:=1;
repeat
A:=d;
inc(i);
if i>m then
i:=1;
inc(d);
until i=c;
dec(c);
if c <= 0 then
c:=m-c;
end;
for i:=1 to m do
begin
for j:=1 to m do
write(A:2);
writeln;
end;
end.

5. Заполнить массив A по следующему принципу:

1 0 0 0 1
0 1 0 1 0
0 0 1 0 0
0 1 0 1 0
1 0 0 0 1

var m,i,j: integer;
A:array of integer;
begin
readln(m);
for i:=1 to m do
begin
for j:=1 to m do
begin
if (i=j) or (m-i+1=j) then
A:=1
else
A:=0;
write(A:2);
end;
writeln;
end;
end.

3. Задачи для самостоятельного решения

6 5 4 3 2 1
7 8 9 10 11 12
18 17 16 15 14 13
19 20 21 22 23 24
30 29 28 27 26 25
31 32 33 34 35 36

36 25 24 13 12 1
35 26 23 14 11 2
34 27 22 15 10 3
33 28 21 16 9 4
32 29 20 17 8 5
31 30 19 18 7 6

0 1 1 1 0
1 0 1 0 1
1 1 0 1 1
1 0 1 0 1
0 1 1 1 0

4) Заполнить массив по следующему принципу:

31 32 33 34 35 36
25 26 27 28 29 30
19 20 21 22 23 24
13 14 15 16 17 18
7 8 9 10 11 12
1 2 3 4 5 6

5) Заполнить массив по следующему принципу:

31 25 19 13 7 1
32 26 20 14 8 2
33 27 21 15 9 3
34 28 22 16 10 4
35 29 23 17 11 5
36 30 24 18 12 6

Домашние задание:

1) Заполнить массив по следующему принципу:

6 7 18 19 30 31
5 8 17 20 29 32
4 9 16 21 28 33
3 10 15 22 27 34
2 11 14 23 26 35
1 12 13 24 25 36

2) Заполнить массив по следующему принципу:

31 32 33 34 35 36
30 29 28 27 26 25
19 20 21 22 23 24
18 17 16 15 14 13
7 8 9 10 11 12
6 5 4 3 2 1

3) Заполнить массив по следующему принципу:

0 1 1 1 0
1 0 1 0 1
1 1 0 1 1
1 0 1 0 1
0 1 1 1 0

Матрица – в – аналог двумерного массива – квадратная или прямоугольная таблица, состоящая из строк и столбцов:

Размер двумерного массива - количество элементов в массиве M*N,

где М – число строк, N – число столбцов (натураль – ные числа).

Квадратная матрица – матрица с равным числом строк и столбцов.

Порядок матрицы – число строк (столбцов) квадратной матрицы.

1. Описание двумерного массива

Двумерный массив – это массив массивов, т. е. двумерная таблица. Оперировать можно как с отдельными элементами массива, так и с массивом в целом.

В языке Pascal индексы заключаются в квадратные скобки:

А, A,..A.

Возможны 2 способа описания 2-мерного массива:

1 Описание массива в разделе переменных VAR:

iнач..iкон, jнач..jкон – диапазоны индексов (строк, столбцов);

t – тип элементов.

Например:

VAR y: of integer ;

VAR F: array of array of real;

VAR mb: array of real ;

VAR C: array OF string ;

CONST M= 4; N=2;

VAR A: array OF integer ;

2 Описание массива в разделе описания типов TYPE:

Для заполнения матрицы организуется наружный цикл по i , внутренний – по j (при условии, что i – строки, j –столбцы). При этом индекс строки i меняется медленнее индекса столбца j за счет того, что происходит постепенный перебор всех элементов строки, т. е. столбцов i-й строки.

Заполнение по столбцам:

Упражнения на заполнение 2-мерных массивов

Упражнение mas1: Заполнить матрицу А(5, 10) по строкам методом генерирования случайных чисел.

program mas_1; {заполнение матрицы по строкам}

A: array of INTEGER;

writeLn(‘Матрица А:’);

FOR i:= 1 to 5 DO {наружный цикл по строкам}

FOR j:=1 TO 10 DO {внутренний цикл по столбцам}

A:= random(10);

write(A:3); {печатаем подряд всю строку}

writeLn; {переходим на новую строку}

Упражнение mas2: Заполнить матрицу А(3, 4) по столбцам методом ввода чисел с клавиатуры.

program mas_2; {заполнение матрицы по столбцам}

Const N =4; M =3;

Var A: array of INTEGER;

FOR j:= 1 to M DO {наружный цикл по столбцам }

FOR i:=1 TO N DO {внутренний цикл по строкам}

write(‘Введите элемент A[",i,",",j,"]=’);

readLn(A);

writeLn(‘Результирующая матрица A:’);

for i:=1 to N do {Вывод матрицы}

for j:=1 to M do

write(A,’ ‘);

Упражнение mas3: Дана матрица A(N? M), состоящая из натуральных чисел. Определить ее максимальный элемент и его индексы.

program mas_3; {Max элемент матрицы}

CONST t= 10; r=10;

A: array of INTEGER;

n, m, Max, iMax, jMax, k: integer;

write(‘Введите число строк N=’); readLn(N);

write(‘Введите число столбцов M=’); readLn(M);

writeLn(‘Матрица:’);

FOR i:= 1 to N DO {заполнение массива генерированием случайных чисел}

FOR j:=1 TO M DO

A:= random(10);

write(A:3);

Max:= A; iMax:=1; jMax:=1; k:=0; {принимаем начальное значение Мах = значению 1-го эл-та}

For i:=1 to N do

For j:=1 to M do

IF A > Max then

Max:= A; iMax:=i; jMax:=j; k:=1

WriteLn(‘Max= ’ ,Max,’ в строке: ‘,imax, ‘ столбце:’, jmax);