Задачи на программирование паскаль 9 класс массивы

3.3.1 Массивы

Free Pascal поддерживает массивы. Как и Turbo Pascal. Также поддерживаются многомерные массивы и (битные)упакованные массивы. А также динамические массивы Delphi:

_________________________________________________________________________________________________________
Типы массивов

-- -------------- ----------------------- - ------ тип массива -- --| array - - - - - - | of type - packed -| [ -порядковый тип-|] bitpacked ,
___________________________________________________________________

Статические массивы

Когда диапазон массива включен в определение массива. Он называется статическим массивом. Попытка получить доступ к элементу с индексом. Который находится за пределами объявленного диапазона. Приведет к ошибке во время выполнения (если включена проверка диапазона).

Ниже приведен пример допустимого объявления массива:

Тип
RealArray = Array [1..100] of Real;

Допустимые индексы для доступа к элементу массива находятся в диапазоне от 1 до 100, где границы 1 и 100 включены. Как и в Turbo Pascal. Если тип компонента массива сам по себе является массивом. То можно объединить два массива в один многомерный массив. Следующее заявление:

Тип
APoints = array[1..100] of Array[1..3] of Real;

эквивалентно декларации:

Тип
APoints = массив[1..100,1..3] вещественных;

Функции High и Low возвращают верхнюю и нижнюю границы самого левого индексного типа массива. В приведенном выше случае это будет 100 и 1. Вы должны использовать их всякий раз. Когда это возможно. Так как это улучшает ремонтопригодность вашего кода. Использование обеих функций так же эффективно. Как и использование констант. Поскольку они вычисляются во время компиляции.

Когда статические переменные типа массива назначаются друг другу. Содержимое всего массива копируется. Это также верно для многомерных массивов:

программа testarray1;
 
тип
та = массив[0..9,0..9] целочисленного;
 
ВАР
а,б : та;
Я,J : целое число;
начать
Для i:=0 до 9 сделает
для j:=0 до 9 и
А[я,J]:=Я*й;
для i:=0 до 9 и
начать
Для j:=0 до 9 сделает
писал(А[я,J]:2,’ ’);
Writeln;
конец;
Б:=а;
Writeln;
для i:=0 до 9 сделает
для j:=0 до 9 и
более[9-я,9-ж]:=я*й;
для i:=0 до 9 и
начать
Для j:=0 до 9 сделает
писал(Б[Я,J]:2,’ ’);
Writeln;
конец;
конец.

Результатом этой программы будут две идентичные матрицы.

Динамические массивы

Начиная с версии 1.1, Free Pascal также знает динамические массивы: в этом случае диапазон массивов опущен. Как в следующем примере:

Тип
TByteArray = Массив байтов;

При объявлении переменной типа динамического массива начальная длина массива равна нулю. Фактическая длина массива должна быть задана с помощью стандартной функции SetLength. Которая выделит необходимую память для хранения элементов массива в куче.

В следующем примере будет установлена длина 1000:

Var
A : TByteArray;
 
begin
SetLength(A,1000);

После вызова SetLengthдопустимые индексы массива равны от 0 до 999: индекс массива всегда равен нулю.

SetLength также может быть использован для многомерных массивов. В следующем примере будет создан “прямоугольный” массив:

Var
A : Массив TByteArray;
 
begin
SetLength(A,10,100);

После вызова SetLengthдопустимые индексы массива равны от 0 до 9 для первого измерения и от 0 до 99 для второго.

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

ВАР
а: массив массив массив добавлены типы longint;
я, J, к: добавлены типы longint;
начать
обновляет(а, 10, 5);
обновляет(а[5], 3);
 
для I := низкая(а) к высоким(а) сделать
для J := минимум(а[я]) до высокого(а[я]) делать начинают
обновляет(а[я. J]10 + J на клавиатуре);
для K := минимум(а[я. J]) до высокого(а[я. J]) делать
в[Я. J= я * 10000 + и J * 100 + к;
конец;
 
для I := низкая(а) к высоким(а) начать делать
для J := минимум(а[я]) до высокого(а[я]) начинаются
на K := минимум(а[я. J]) до высокого(а[я. J]) делать
Writeln(а[я, J, к]);
Writeln(’——-’);
конец;
Writeln(’=======’);
конец;
конец.

Обратите внимание. Что длина массива задается в элементах. А не в байтах выделенной памяти (хотя они могут быть одинаковыми). Объем выделенной памяти — это размер массива. Умноженный на размер 1 элемента в массиве. Память будет удалена при выходе из текущей процедуры или функции.

Также можно изменить размер массива: в этом случае будет сохранено столько элементов массива. Сколько поместится в новом размере. Массив может быть изменен до нуля. Что эффективно сбрасывает переменную.

В любое время попытка получить доступ к элементу массива с индексом. Который не входит в текущую длину массива. Приведет к ошибке во время выполнения.

Динамические массивы подсчитываются ссылками: присвоение одной переменной типа динамического массива другой позволит обеим переменным указывать на один и тот же массив. В отличие от ansistrings. Назначение элементу одного массива будет отражено в другом: нет копирования при записи. Рассмотрим следующий пример:

Var
A,B : TByteArray;
 
begin
SetLength(A,10);
A[0]:=33;
B:=A;
A[0]:=31;

После второго задания первый элемент в B также будет содержать 31.

Это также можно увидеть из вывода следующего примера:

программа testarray1;
 
тип
та = массив массив целых;
 
ВАР
а,б : та;
Я,J : целое число;
начать
обновляет(а,10,10);
для i:=0 до 9 сделает
для j:=0 до 9 и
А[я,J]:=Я*й;
для i:=0 до 9 и
начать
Для j:=0 до 9 сделает
писал(А[я,От J]:2,’ ’);
Writeln;
конец;
Б:=а;
Writeln;
для i:=0 до 9 сделает
для j:=0 до 9 и
более[9-я,9-ж]:=я*й;
для i:=0 до 9 и
начать
Для j:=0 до 9 сделает
писал(Б[Я,J]:2,’ ’);
Writeln;
конец;
конец.

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

Как отмечалось ранее, динамические массивы подсчитываются ссылками: если в одном из предыдущих примеров A выходит из области видимости, а B-нет, то массив еще не удален: количество ссылок A (и B) уменьшается на 1. Как только счетчик ссылок достигает нуля, память, выделенная для содержимого массива, удаляется.

Вызов SetLength удостоверится, что счетчик ссылок возвращаемого массива равен 1, то есть если две переменные динамического массива указывали на одну и ту же память. То после вызова setlength они больше не будут этого делать:

программа testunique;
 
Тип
TA = массив целых чисел;
 
var
A,B : TA;
Я : целое число;
 
начать
обновляет(а,10);
для i:=0 до 9 и
А[я]=я;
б:=а;
обновляет(Б,6);
А[0]:=123;
для i:=0 до 5 делать
Writeln(б[я]);
конец.

Также можно скопировать и/или изменить размер массива с помощью стандартной функции копирования. Которая действует как функция копирования строк:

программа testarray3;
 
Тип
TA = массив целых чисел;
 
var
A,B : TA;
I : Целое число;
 
begin
Setlength(A,10);
For I:=0 to 9 do
A[I]:=I;
B:=Copy(A,3,6);
For I:=0 to 5 do
Writeln(B[I]);
end.

Функция копирования скопирует шесть элементов массива в новый массив. Начиная с элемента с индексом 3 (то есть четвертого элемента) массива.

Функция Length возвращает количество элементов в массиве. Функция Low в динамическом массиве всегда возвращает 0, а функция High возвращает значение Length-1, то есть значение самого высокого допустимого индекса массива.

Совместимость типов динамических массивов

Объектный Паскаль — это строго типизированный язык. Два технически различных типа иногда считаются совместимыми по назначению (то есть значение одного типа может быть присвоено переменной другого типа) при определенных обстоятельствах. Динамические массивы считаются совместимыми по назначению. Если они используют один и тот же тип элемента. Это означает. Что будет скомпилировано следующее:

{$mode objfpc}
 
Type
TA = Array of Integer;
TB = Array of Integer;
 
Var
A : TA;
B : TB;
 
begin
SetLength(A,1);
A[0]:=1;
B:=A;
end.

Но следующее не будет. Даже если целочисленные и словесные типы совместимы с присваиванием:

{$mode objfpc}
 
Тип
TA = Массив слова;
TB = Массив целого числа;
 
Var
A : TA;
B : TB;
 
begin
SetLength(A,1);
A[0]:=1;
B:=A;
end.

Конструктор динамических массивов

Начиная с версии 3.0 Free Pascal. Типы динамических массивов имеют конструктор. Это внутреннее свойство. Его обеспечивает компилятор. До версии 2.6.4 единственным способом инициализации динамического массива было следующее:

Тип
TIntegerArray = Массив целых чисел;
 
var
A : TIntegerArray;
 
begin
SetLength(A,3);
A[0]:=1;
A[1]:=2;
A[3]:=3;
Writeln(Length(A));
end.

Начиная с версии 3.0 Free Pascal. Динамический массив может быть инициализирован с помощью синтаксиса. Подобного конструктору. Конструктор называется Createи принимает в качестве параметров переменное число параметров типа элемента типа массива. Это означает что описанная выше инициализация теперь может быть выполнена следующим образом:

Тип
TIntegerArray = Массив целых чисел;
 
var
A : TIntegerArray;
 
begin
A:=TIntegerArray.Create(1,2,3);
Writeln(Length(A));
end.

Обратите внимание. Что это не будет работать для динамических массивов. Для которых не был создан тип. То есть следующее не сработает:

var
A : Массив целых чисел;
 
begin
A:=Массив целых чисел.Create(1,2,3);
Writeln(Length(A));
end.

Этот подход также работает рекурсивно для многомерных массивов:

Тип
TIntegerArray = Массив целых чисел;
TIntegerArrayArray = Массив TIntegerArray;
 
var
A : TIntegerArrayArray;
 
begin
A:=TIntegerArrayArray.Create(TIntegerArray.Создать(1,2,3),
ТИнтегерАррей.Создать(4,5,6),
ТИнтегерАррей.Create(7,8,9));
Writeln(’Length ’,length(A));
end.

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

Тип
TIntegerArray = Массив целого числа;
 
var
A : TIntegerArray = TIntegerArray.Create(1,2,3);
 
begin
Writeln(’Length ’,length(A));
end.

Упаковка и распаковка массива

Массивы могут быть упакованы и битпакетированы. Два типа массивов. Которые имеют один и тот же тип индекса и тип элемента. Но которые по-разному упакованы. Не совместимы с назначением.

Однако можно преобразовать обычный массив в битовый массив с помощью процедуры pack. Возможна также обратная операция; битовый массив может быть преобразован в нормально упакованный массив с помощью процедуры распаковки, как в следующем примере:

ВАР
фу : массив [ ’а’..’ф’ ] булевых
= ( ложь. Ложь, истина, ложь. Ложь, ложь );
бар : bitpacked массив [ 42..47 ] булевых;
база : массив [ ’0’..’5’ ] булевых;
 
начать
упаковке(фу,
распаковать(бар,баз,’0’);
конец.

Более подробную информацию о процедурах упаковки и распаковки можно найти в справочнике по системному блоку.