Одномерные массивы

I. Объявление массивов

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

Количество элементов и их номера задаются с помощью типа индекса ( индексом называется значение, по которому элементы массива отличают один от другого, например, индексами могут быть 1, 2, 10, 'a', false и т.д.). Тип индекса - это один из следующих: ограниченный целый тип ( byte может быть без ограничения), символьный тип (ограниченный или целиком), логический тип и любой перечислимый тип. Вещественный тип типом индекса служить не может. Чаще всего используется целый ограниченный тип, тогда об индексе элемента говорят как о его номере. Пример описания массива:

var A: array [1..10] of integer;

Здесь тип элементов - integer, тип индекса - ограниченный целый тип 1..10. В этом массиве индексами элементов будут целые числа 1, 2, 3, 4,5, 6, 7, 8, 9, 10.

А в массиве var A: array [5..12] of integer;

индексами являются 5, 6, 7, 8, 9, 10, 11, 12.

Назначение индекса - указать, какой из элементов массива  имеется в виду, ведь имя-то у всех одно и тоже. Поэтому если написано A[7], то очевидно, что это элемент массива A с индексом 7. Причем в первом массиве это будет седьмой элемент, а во втором - третий, так что порядковый номер элемента в массиве и его индекс - это далеко не одно и тоже. Как определить, сколько в массиве элементов? Их там столько же, сколько различных индексов в типе индекса (в первом массиве - 10, во втором - 8).

Синтаксис описания одномерного (т.е. с одним индексом) массива:

array [<тип индекса>] of <тип элементов>

Если в качестве индексов используются номера (целые числа), синтаксис можно несколько конкретизировать:
array [<нижняя граница>.. <верхняя граница>] of <тип элементов>
<Нижняя граница> и <верхняя граница> задают первый и последний номер элемента соответственно.
Примеры:
var A, B: array ['a'..'z'] of integer;
var C: array [ boolean] of real;
var D: array [(red, green, blue)] of char;
var E: array [100..150] of boolean;

Внимание! В описании типа индексов нельзя использовать переменные. Во многих задачах необходимо "ввести массив из n элементов". Однако нельзя объявить массив как var A: array [1.. n] of integer;
если n - переменная. Границы изменения индекса должны задавать только константы . Рекомендуется в таких случаях вместо n в объявлении массива указывать максимально возможное (в пределах разумного) число элементов, например:
var A: array [1..50] of integer;
а потом указать, что n не должно превышать 50-ти.
Рекомендуется также давать имена типам массивов, если массивов в задаче больше одного. Например, так:
type massiv = array [1..50] of integer;
var A, B: massiv;
Иначе может возникнуть несовместимость типов.
 

II. Имена элементов массива
 

Следующий вопрос: как указать имя конкретного элемента массива? Имен-то у них нет?
Необходимо указать имя массива, откуда берется элемент и индекс этого элемента в данном массиве:
<имя массива>[<индекс>]
Например, для массива
var A: array [1..50] of integer;
5-тый элемент имеет имя A[5], а для массива С из предыдущего пункта второй элемент называется С[ true]. В квадратных скобках может указываться не только константа, но и выражение (выражение должно иметь результат того же типа, что и тип индекса). Для массива A это целое выражение, например A[i+k-1], а для массива C - логическое (т.к. типом индекса у него служит логический), например С[(y>0) and (x
<>2)]. В таком случае индексом будет результат вычисления этого выражения. Если i = 7, k = 3, x = 11, y =5.5, это будут соответственно элементы A[9] и C[true].
 

III. Ввод и вывод одномерных массивов
 

Массивы нужно вводить (и выводить) поэлементно. Почему? Да потому, что оператор readln способен прочитать только значения типов integer, real и char и их простых производных. А массив - это несколько переменных, и их нужно читать по одной.
Массивы вводят и выводят с помощью цикла (понятно, почему ввод массива - циклическое действие?). Для любых одномерных массивов эти циклы очень похожи. Их общий вид:

for <переменная цикла> := <нижний индекс> to <верхний индекс> do
begin
write('Введите <имя массива>[', <переменная цикла>, ']=');
readln(<имя массива>[<переменная цикла>]);
end; {ввод}

for <переменная цикла> := <нижний индекс> to <верхний индекс> do
writeln('<имя массива>[', <переменная цикла>, ']=',<имя массива>[<переменная цикла>]);
{вывод}

Здесь: <переменная цикла> должна иметь тип индекса или базовый для него (например, для индекса ограниченного целого типа <переменная цикла> может быть целой).
Замените названия в <> на названия и значения Вашей задачи - и получите нужные циклы ввода и вывода массива.
Например, для массива

var A: array [1..50] of integer;
var i: integer;
они выглядят так:

for i := 1 to 50 do
begin
write('Введите A[', i, ']=');
readln(A[i]);
end; {ввод}

for i := 1 to 50 do
begin
writeln('A[', i, ']=', A[i]);
end; {вывод, begin и end в данном случае необязательны, так как в цикле один оператор.}
 

IV. Примеры решения задач с использованием массивов.
 

Работать с элементами массива можно точно так же, как с переменными того же типа (только имена другие). Как правило, массивы обрабатываются в цикле, т.к. над их элементами производятся одинаковые действия. Вот и все "основные" особенности.
Рассмотрим пример.
Ввести целый массив длины n и найти, сколько в нем нечетных положительных чисел.

"Линейная" схема решения:
1. Ввести массив.
2. Подсчитать количество нечетных положительных элементов.
3. Вывести результат.

Ввод-вывод уже разобран. Только: чтобы ввести n элементов, надо сначала ввести n, и в цикле ввода задать его в качестве верхней границы (если нижняя равна 1). Осталось только выяснить, как считать требуемые элементы. Это просто: для каждого элемента проверить, является ли он положительным и не делится ли на два, и если оба условия выполнены, добавить к количеству положительных нечетных чисел единицу. Не правда ли, очевидно циклические действия? Перед тем, как начать цикл проверки, количество положительных нечетных надо, конечно, обнулить. Получаем следующий алгоритм:

1. Ввести n. Если n меньше нуля или больше максимального значения то вывести сообщение "Неверные исходные данные", иначе
2. Ввести массив из n элементов
3. Обнулить количество положительных нечетных элементов
4. Для каждого элемента массива от 1 до n:
если элемент > 0 и не делится на 2 то увеличить количество положительных нечетных элементов на 1
5. Вывести количество положительных нечетных элементов
На основании которого напишем программу на Паскале (количество положительных нечетных элементов будем хранить в переменной count):

program prim1;
uses crt;
type massiv: array [1..50] of integer;
var a: massiv;
n, i, count: integer;
begin
clrscr;
textcolor(yellow);
writeln('Определение количества положительных нечетных элементов');
write('Введите n=');
readln(n);
if (n<0) or (n>50) then writeln('n должно быть больше 0 и меньше 50')
else
begin
for i := 1 to n do
begin
write('Введите a[', i, ']=');
readln(a[i]);
end;
count := 0;
for i := 1 to n do
begin
if (a[i] > 0) and (a[i] mod 2 = 0) then count := count + 1;
end;
writeln('В этом массиве таких элементов ', count);
end;
readln;
end.

Еще один пример.

Ввести массив из вещественных чисел длины n и преобразовать по правилу: от каждого положительного элемента взять sin, от каждого отрицательного - cos. Нули не трогать. Получившийся массив вывести.

Алгоритм:

1. Ввести n. Если n меньше нуля или больше максимального значения, вывести сообщение "Неверные исходные данные", иначе
2. Ввести массив из n элементов
3. Для каждого элемента массива от 1 до n:
4. если элемент > 0 то занести на его место sin от него
если элемент < 0 то занести на его место cos от него
5. Вывести массив

Программа на Паскале:

program prim2;
uses crt;
type massiv: array[1..50] of real;
var a: massiv;
n, i: integer;
begin
clrscr;
textcolor(yellow);
writeln('Преобразование массива');
write('Введите n=');
readln(n);
if (n<0) or (n>50) then writeln('n должно быть больше 0 и меньше 50')
else
begin
for i := 1 to n do
begin
write('Введите a[', i, ']=');
readln(a[i]);
end;
for i := 1 to n do
begin
if a[i] > 0 then a[i] := sin(a[i]);
if a[i] < 0 then a[i] := cos(a[i]);
end;
for i := 1 to 50 do writeln('A[', i, ']=', A[i]);
end;
readln;
end.