Двумерные массивы (матрицы) в Паскале
Одномерный массив можно представить как линейную структуру, в которой элементы следуют друг за другом. Однако бывают более сложные структуры данных. Например, двумерные массивы, которые можно описать как таблицу, в ячейках которой располагаются значения. Для обращения к данным массива указывается номера их строк и столбцов. Часто табличные массивы называют матрицами.
Обычно двумерные массивы на языке программирования Pascal описываются так:
array [1..m, 1..n] of базовый_типОднако можно их описывать как массив массивов:
array [1..m] of array [1..n] of базовый_типПри этом описание может быть в разделе type и тогда создается новый тип, который можно использовать при объявлении переменных. m и n – это константы, их можно опустить и вставить конкретные значения, но лучше так не делать. Обычно подразумевают, что в интервале от 1 до m определяется количество строк, а в интервале от 1 до n – количество столбцов массива.
1 вариант – описание массива через раздел type :
const M = 10; N = 5; type matrix = array [1..M, 1..N] of integer; var a: matrix;2 вариант – описание массива в разделе переменных:
const M = 10; N = 5; var a: array [1..M, 1..N] of integer;При использовании третьего варианта описания лучше сначала определить некоторый тип одномерного массива (строка двухмерного массива), который затем используется при описании двухмерного массива:
type a = array[1..10] of byte; var b: array[1..100] of a;Для обращения к элементу двухмерного массива необходимо указать имя массива и в квадратных скобках через запятую – значения двух индексов (первый указывает номер строки, а второй – номер столбца), на пересечение которых стоит элемент (например, a[i,2]:=6) . В языке программирования Pascal допустимо разделение индексов с помощью квадратных скобок (например, a[i][5]:= 7 ).
Если описывается двумерный массив как типизированная константа, то при задании значений его элементов он рассматривается как массив массивов. При этом в общих круглых скобках через запятую перечисляются заключенные в круглые скобки значения элементов строк (каждая строка в своих скобках):
type arr = array[1..4, 1..3] of integer; const cords: arr = ((1,-1,3), (0,0,0), (1,4,0), (4,-1,-1));Рассмотрим простой пример работы с двумерным массивом. Сначала заполним его данными, а затем выведем их на экран в виде таблицы.
var matrix: array[1..3,1..5] of integer; i, j: integer; begin writeln('Введите 15 чисел: '); for i := 1 to 3 do for j := 1 to 5 do read(matrix[i,j]); for i := 1 to 3 do begin for j := 1 to 5 do write(matrix[i,j], ' '); writeln end; end.Размерность массива (т.е. количество содержащихся в нем значений) определяется произведением количества строк на количество столбцов. В примере выше в массив помещается 15 значений.
Когда пользователь вводит очередное число, то процедура read считывает его и помещает в ячейку с текущими индексами i и j . Когда i равна единице, значение j меняется пять раз, и, значит, заполняется первая строка таблицы. Когда i равна двум, значение j снова меняется пять раз и заполняется вторая строка таблицы. Аналогично заполняется третья строка таблицы. Внутренний цикл for в общей сложности совершает 15 итераций, внешний только 3.
Как пользователь вводит значения – не важно. Он может их разделять либо пробелом, либо переходом на новую строку.
Вывод значений двумерного массива организован в виде таблицы. Выводятся 3 строки по 5 чисел в каждой. Внутри строк числа разделяются пробелом.
На самом деле, это не совсем корректно написанная программа. Мы несколько раз используем цифры 3 и 5. А что если мы захотим поменять размерность массива? Придется просмотреть всю программу (представьте, что она очень большая) и исправить значения. Это неэффективно. Поэтому в программе следует использовать константы. В случае необходимости значения можно поменять всего лишь в одном месте.
Вторая проблема – это «кривость» выводимой на экран таблицы значений матрицы, в случае если есть значения разной разрядности (однозначные, двузначные числа). Неплохо бы под каждое число отводить равное количество знаков.
Вот так может выглядеть подправленный вариант программы:
const M = 3; N = 5; var matrix: array[1..M,1..N] of integer; i, j: integer; begin writeln ('Введите 15 чисел: '); for i := 1 to M do for j := 1 to N do read (matrix[i,j]); for i := 1 to M do begin for j := 1 to N do write (matrix[i,j]:5); writeln end; end.Работа с массивом в pascal.abc
Я написал код, чтобы можно было задать массив, но с условиями проблемка:
const n=100; var a:array[1..n] of byte; i:byte; с:integer; begin randomize; с:=1; for i:=1 to 100 do begin a[i]:=1+random(10); write(a[i]:3); if odd(i) then с:=с*a[i]; end; writeln; end. Отслеживать
2,050 4 4 золотых знака 15 15 серебряных знаков 23 23 бронзовых знака
задан 19 дек 2020 в 8:05
11 2 2 бронзовых знака
Вот только Ваш код не обеспечивает условия «заполнить так, чтобы всех элементов было поровну».
19 дек 2020 в 21:14
1 ответ 1
Сортировка: Сброс на вариант по умолчанию
## var a := new integer[100]; for var i := 0 to 9 do a[10 * i:10 * (i + 1)] := 10 * |i + 1|; a.Shuffle; // перемешиваем случайным образом a.Println; // дойдем до первого четного элемента var i := 0; while a[i].IsOdd do i += 1; // начальные установки (мы нашли один четный элемент) var (L, LMax, LAsc, LMaxAsc) := (1, 1, 1, 1); // основная часть repeat i += 1; if a[i].IsEven then begin L += 1; if a[i] > a[i - 1] then LAsc += 1 else (LAsc, LMaxAsc) := (1, Max(LMaxAsc, LAsc)) end else (L, LMax, LAsc, LMaxAsc) := (0, Max(L, LMax), 0, Max(LAsc, LMaxAsc)) until i = a.High; (LMax, LMaxAsc) := (Max(L, LMax), Max(LAsc, LMaxAsc)); Write(NewLine, LMax, ' ', LMaxAsc) 
Отслеживать
ответ дан 19 дек 2020 в 21:46
Массивы в PascalABC.NET
В PascalABC.NET рекомендуется использовать динамические массивы. В отличие от статических, они имеют огромное количество методов и операций, просты в создании, заполнении и выводе.
Описание и выделение памяти
Динамический массив описывается так:
begin var a: array of integer; end. Память под динамический массив a выделяется в момент работы программы:
begin var a: array of integer; var n := ReadInteger; a := new integer[n]; end. Здесь — первое преимущество динамических массивов — в переменной a может храниться массив любого размера, память выделяется в процессе работы программы. Кроме того, выделенная память гарантированно автоматически заполняется нулевыми значениями.
Можно совместить описание и выделение памяти — тип динамического массива выводится автоматически:
begin var n := ReadInteger; var a := new integer[n]; end. Обычно в PascalABC.NET совмещают описание динамического массива, выделение памяти и заполнение значениями. Самый простой способ — заполнить n нулями:
begin var n := ReadInteger; var a := |0| * n; end. Индексация в динамических массивах и использование статических массивов
Динамические массивы индексируются с нуля — это эффективно. В качестве индексов в динамических массивах могут выступать только целые.
Статические массивы тем не менее иногда удобно использовать — в задачах, где индексы либо символьные, либо по-существу начинаются не с нуля. Например, для подсчёта количества слов на каждую букву может использоваться стаический массив
var a := array ['a'..'z'] of integer;
Заполнение статических массивов — увы — производится в цикле. Кроме того, они не помнят свою длину и передача таких массивов в качестве параметров подпрограмм связана с техническими сложностями 40-летней давности, не нужными начинающим.
Простейшее заполнение
Важную роль играют функции заполнения динамических массивов. Перед заполнением они выделяют для массива память, поэтому в одной строке можно совмещать описание, выделение памяти и заполнение.
Простейшее заполнение — набором значений:
var a := |1,3,3,7,9|; Заполнение диапазоном целых или символьных значений делается с использованием функции Arr:
var a := Arr(1..9); var b := Arr('a'..'z'); Заполнение определённым значением осуществляется с помощью операции умножения массива на число:
begin var n := ReadInteger; var a := |0| * n; // массив из n нулей end. Для заполнения можно также использовать функцию ArrFill:
begin var n := ReadInteger; var a := ArrFill(n,0); // массив из n нулей end. Для заполнения массива случайными значениями следует использовать
begin var n := ReadInteger; var a := ArrRandomInteger(n); // по умолчанию значения от 0 до 100 var a1 := ArrRandomInteger(n,1,10); // случайные от 1 до 10 var r := ArrRandomReal(n); // по умолчанию значения от 0 до 10 var r1 := ArrRandomReal(n,2,5); // случайные вещественные от 2 до 5 end. Не рекомендуется использовать алгоритм для заполнения массива случайными в каждой задаче:
begin var n := ReadInteger; var a := new integer[n]; for var i:=0 to n-1 do a[i] := Random(0,100); end. Повторять этот текст в каждой задаче — странно. Для этого есть стандартные функции.
Ввод и вывод элементов массива
Для ввода элементов массива базовых типов используются функции
begin var n := ReadInteger; var a := ReadArrInteger(n); var r := ReadArrReal(n); var s := ReadArrString(n); // . end. Стандартная процедура вывода Write или Print выводит значения в массиве в квадратных скобках черезх запятую:
begin var a := Arr(1..9); Print(a); // [1,2,3,4,5,6,7,8,9] end. Однако лучше всего для вывода воспользоваться методом Print, выводящим все значения в массиве через пробел:
begin var a := Arr(1..9); a.Print; // 1 2 3 4 5 6 7 8 9 end. Не рекомендуется вводить и выводить элементы массива в цикле
begin var n := ReadInteger; var a := new integer[n]; for var i:=0 to n-1 do a[i] := ReadInteger; end. Повторять этот текст в каждой задаче — странно. Для этого есть стандартные функции.
Циклы по массиву
Для обработки элементов массива используются следующие циклы:
-
Цикл for по индексам (если требуется менять элементв или нужна информация об индексах)
for var i:=0 to a.Length-1 do a[i] *= 2; var sum := 0; foreach var x in a do sum += x; foreach var i in a.Indices do a[i] += 2; var (K,L) := ReadInteger2; foreach var i in K..L do a[i] := 777; Пример. Найти количество чётных элементов, стоящих на чётных местах
begin var a := ArrRandomInteger(10); a.Println; var count := 0; foreach var i in a.Indices do if i.IsEven and a[i].IsEven then count += 1; Print(count); end. Методы массива
Массивы содержат большое количество стандартных методов:
a.Length - длина массива a.Min - минимальный элемент в массиве a.Max - максимальный элемент в массиве a.IndexMin - индекс первого минимального элемента в массиве a.IndexMax - индекс первого максимального элемента в массиве a.Sum - сумма элементов в числовом массиве a.Product - произведение элементов в числовом массиве a.Average - среднее элементов в числовом массиве a.First - первый элемент в массиве a.Last - последний элемент в массиве a.IndexOf(x) - индекс первого значения x или -1 если не найдено a.Replace(x,y) - заменить в массиве все значения x на y Кроме того, доступны процедуры
Sort(a) - сортировка элементов по возрастанию SortDescending(a) - сортировка элементов по убыванию Reverse(a) - инвертирование элементов массива Методика. Обращаем внимание, что в методических целях естественно рассказывать, как эти алгоритмы устроены “внутри”. Но потом следует пользоваться стандартными алгоритмами, а не заставлять учеников во всех задачах использовать рукописные сортировки или рукописный поиск минимума. Например, рекомендуется показать, как накопить сумму элементов массива:
begin var a := ArrRandomInteger(10); a.Println; var sum := 0; foreach var x in a do sum += x; Print(sum); end. Здесь следует обратить внимание, что этот алгоритм может быть легко модифицирован в алгоритм нахождения суммы элементов по условию: например, всех чётных элементов:
begin var a := ArrRandomInteger(10); a.Println; var sum := 0; foreach var x in a do if x.IsEven then sum += x; Print(sum); end. Отметим, что заполнение случайными и вывод — это технические части программы, которые делаются в PascalABC.NET в одну строку, позволяя концентрироваться на алгоритме.
Если условие надо накладывать на индексы, то в этом случае (и только в этом случае) следует использовать цикл for по индексам:
begin var a := ArrRandomInteger(10); a.Println; var sum := 0; for var i:=0 to a.Length-1 do if i.IsEven then sum += a[i]; Print(sum); end. Для нахождения суммы без условия необходимо использовать стандартный метод a.Sum:
begin var a := ArrRandomInteger(10); a.Println; Print(a.Sum); end. Отметим также, что для поиска суммы по условию также имеется короткая однострочная запись. Она требует использование стандартного метода Where с параметром, являющимся лямбда-выражением. Лямбда-выражения мы будем рассматривать далее:
begin var a := ArrRandomInteger(10); a.Println; Print(a.Where(x -> x.IsEven).Sum); end. Методика. Поскольку данная запись использована здесь впервые, обращаем внимание на её высокую универсальность: алгоритмы фильтрации и поиска суммы не слиты в один алгоритм, а используются порознь один за другим, что позволяет:
- Лучше читать код (потому что он записан компактно и методами с понятными и очевидными названиями)
- Лучше модифицировать код
- Решать более сложные и более прикладные задачи за одно и то же время урока
Далее лямбда-выражения объясняются подробно и тщательно и используются повсеместно.
Операции с массивами
x in a - возвращает true если значение x содержится в a a1 + a2 - возвращает массив, образованный слиянием массивов a1 и a2 a1 * n - возвращает массив, состоящий из n раз повторенных значений массива a Изменение размера динамического массива
Если в процессе работы программы требуется чтобы динамический массив менял свой размер, то следует … пользоваться типом List ! Это — динамический массив с возможностью эффективного измненения размера и рядом дополнительных методов. Основным является методы Add — добавить в конец:
begin var l := new Listinteger>; l.Add(1); l.Add(3); l.Add(5); l.Print end. Для первоначального заполнения списков List используется короткая фунеция Lst:
begin var l := Lst(1,3,5); l.Print end. При необходимости список List можно преобразовать к динамическому массиву, вызвав метод .ToArray:
begin var l := Lst(1,3,5); var a := l.ToArray; end. Большинство методов, которые имеются в массивах, есть и в списках List. Поэтому выбор типа List или array of для контейнера при решении задач определяется тем, будет ли данный контейнер расширяться по ходу работы программы.
©2023 PascalABCNET Team. All rights reserved.
Page last updated: 19.12.2020
Site last generated: Jul 31, 2023
Программирование. Двумерные массивы Pascal-Паскаль
Двумерный массив в Паскале трактуется как одномерный массив, тип элементов которого также является массивом (массив массивов). Положение элементов в двумерных массивах Паскаля описывается двумя индексами. Их можно представить в виде прямоугольной таблицы или матрицы.
Рассмотрим двумерный массив Паскаля размерностью 3*3, то есть в ней будет три строки, а в каждой строке по три элемента:
Каждый элемент имеет свой номер, как у одномерных массивов, но сейчас номер уже состоит из двух чисел – номера строки, в которой находится элемент, и номера столбца. Таким образом, номер элемента определяется пересечением строки и столбца. Например, a 21 – это элемент, стоящий во второй строке и в первом столбце.
Описание двумерного массива Паскаля.
Существует несколько способов объявления двумерного массива Паскаля.
Мы уже умеем описывать одномерные массивы, элементы которых могут иметь любой тип, а, следовательно, и сами элементы могут быть массивами. Рассмотрим следующее описание типов и переменных:
Пример описания двумерного массива Паскаля
Type
Vector = array [1..5] of ;
Matrix= array [1..10] of vector;
Var m: matrix;
Мы объявили двумерный массив Паскаля m, состоящий из 10 строк, в каждой из которых 5 столбцов. При этом к каждой i -й строке можно обращаться m [ i ], а каждому j -му элементу внутри i -й строки – m [ i , j ].
Определение типов для двумерных массивов Паскаля можно задавать и в одной строке:
Type
Matrix= array [1..5] of array [1..10] of < тип элементов >;
или еще проще:
type
matrix = array [1..5, 1..10] of ;
Обращение к элементам двумерного массива имеет вид: M [ i , j ]. Это означает, что мы хотим получить элемент, расположенный в i -й строке и j -м столбце. Тут главное не перепутать строки со столбцами, а то мы можем снова получить обращение к несуществующему элементу. Например, обращение к элементу M [10, 5] имеет правильную форму записи, но может вызвать ошибку в работе программы.
Основные действия с двумерными массивами Паскаля
Все, что было сказано об основных действиях с одномерными массивами, справедливо и для матриц. Единственное действие, которое можно осуществить над однотипными матрицами целиком – это присваивание. Т.е., если в программе у нас описаны две матрицы одного типа, например,
type
matrix= array [1..5, 1..10] of integer;
var
a , b : matrix ;
то в ходе выполнения программы можно присвоить матрице a значение матрицы b ( a := b ). Все остальные действия выполняются поэлементно, при этом над элементами можно выполнять все допустимые операции, которые определены для типа данных элементов массива. Это означает, что если массив состоит из целых чисел, то над его элементами можно выполнять операции, определенные для целых чисел, если же массив состоит из символов, то к ним применимы операции, определенные для работы с символами.
Ввод двумерного массива Паскаля.
Для последовательного ввода элементов одномерного массива мы использовали цикл for, в котором изменяли значение индекса с 1-го до последнего. Но положение элемента в двумерном массиве Паскаля определяется двумя индексами: номером строки и номером столбца. Это значит, что нам нужно будет последовательно изменять номер строки с 1-й до последней и в каждой строке перебирать элементы столбцов с 1-го до последнего. Значит, нам потребуется два цикла for , причем один из них будет вложен в другой.
Рассмотрим пример ввода двумерного массива Паскаля с клавиатуры:
Пример программы ввода двумерного массива Паскаля с клавиатуры
Двумерный массив Паскаля можно заполнить случайным образом, т.е. использовать функцию random (N), а также присвоить каждому элементу матрицы значение некоторого выражения. Способ заполнения двумерного массива Паскаля выбирается в зависимости от поставленной задачи, но в любом случае должен быть определен каждый элемент в каждой строке и каждом столбце.
Вывод двумерного массива Паскаля на экран.
Вывод элементов двумерного массива Паскаля также осуществляется последовательно, необходимо напечатать элементы каждой строки и каждого столбца. При этом хотелось бы, чтобы элементы, стоящие в одной строке, печатались рядом, т.е. в строку, а элементы столбца располагались один под другим. Для этого необходимо выполнить следующую последовательность действий (рассмотрим фрагмент программы для массива, описанного в предыдущем примере):
Пример программы вывода двумерного массива Паскаля
for i :=1 to 5 do <цикл для перебора всех строк>
begin
for j :=1 to 10 do
write ( a [ i , j ]:4);
writeln ;
end ;
Замечание (это важно!): очень часто в программах студентов встречается ошибка, когда ввод с клавиатуры или вывод на экран массива пытаются осуществить следующим образом: readln (a), writeln (a), где а – это переменная типа массив. При этом их удивляет сообщение компилятора, что переменную этого типа невозможно считать или напечатать. Может быть, вы поймете, почему этого сделать нельзя, если представите N кружек, стоящих в ряд, а у вас в руках, например, чайник с водой. Можете вы по команде «налей воду» наполнить сразу все кружки? Как бы вы ни старались, но в каждую кружку придется наливать отдельно. Заполнение и вывод на экран элементов массива также должно осуществляться последовательно и поэлементно, т.к. в памяти ЭВМ элементы массива располагаются в последовательных ячейках.
Представление двумерного массива Паскаля в памяти
Элементы абстрактного массива в памяти машины физически располагаются последовательно, согласно описанию. При этом каждый элемент занимает в памяти количество байт, соответствующее его размеру. Например, если массив состоит из элементов типа integer , то каждый элемент будет занимать по два байта. А весь массив займет S^2 байта, где S – количество элементов в массиве.
А сколько места займет массив, состоящий из массивов, т.е. матрица? Очевидно: S i^S j , где S i — количество строк, а S j – количество элементов в каждой строке. Например, для массива типа
Matrix = array [1..3, 1..2] of integer ;
потребуется 12 байт памяти.
Как будут располагаться в памяти элементы этого массива? Рассмотрим схему размещения массива M типа matrix в памяти.
Под каждый элемент M [i,j] типа 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 [1..50000] 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 [1..10, 1..10] 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 [1..10, 1..10] 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
For j :=1 to m do
M[i,j]:= 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[i, j]: 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[i, j]<>0 then p:=p*a[i, j];
Writeln ( p );
End .
Программирование
Исходники Pascal (127)
Справочник
Справочник по паскалю: директивы, функции, процедуры, операторы и модули по алфавиту