Массив - это совокупность элементов одного типа. Характеризуется массив следующим:

- Каждый компонент массива может быть явно обозначен и к нему имеется прямой доступ;
- Число элементов массива определяется при его описании и в дальнейшем не меняется.

Одномерный массив представляет из себя следующую структуру:

Значения элементов указаны в ячейках таблицы:
 

0.1

5

10

2.3

5.7

2

3.1

4.9

8

6.5

   1        2        3        ...                 ...              ...                   10         –  порядковые номера (индексы) элементов массива
Mas[1]  Mas[2]   ...              ...               ...              ...          Mas[10]  

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

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

Var  М: array [1..10] of real;
Где  M - имя массива,
       array - обязательное служебное слово (массив, множество)
       [1..10] - размерность, т.е порядковые номера в интервале от 1 до 10
       real - тип элементов (вещественные числа)

или так: type M = array[1..10]  of  real;

или так:
Const  n=10;              {n –размерность массива определена как константа}
Var  M: array [1..n] of real;

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

Примеры:

M[1] := 0.1;                            {1-му элементу массива присвоить значение 0.1}
Readln (M[2]);                        {прочитать 2-ой элемент массива}
Write (M[4]:4);                       {ввести 4-ый элемент массива по формату 4 знакоместа}
Write (M[2]:4:1);                    {ввести 2-ый элемент по формату 4 знакоместа с одним знаком после запятой}
if M[5] < 10 then …;               {если 5-ый элемент массива <10, то…}
M[9] := Mas[1] + Mas[5];      {9-му элементу массива присвоить значение, равное сумме 1-го и 5-го}

Ввод элементов массива:

1) С клавиатуры:
     For i:=1 to n do begin
     Writeln ('Введите число');
     Read (A[i]);
     end;

2) С помощью типизированных констант:
    Const
    A: array [1..6] of integer =(-5,8,5,0,7,-8);      {числа}
    В: array [1..3] of char =('a','b','c');                 {символы}

3) C помощью генератора случайных чисел:
    Randomize;                                     {включаем генератор случайных чисел}
    For i:=1 to 100 do                            {цикл для формирования массива из 100 чисел}
    Begin 
    A[i]:=Random (200)+1                   {элемент массива - случайное целое число из диапазона от 1 до 200}
    Write (A[i]:5);                                  {печать по формату на 5 знакомест} 
    End;

Вывод элементов массива:

1) В строку:
    For i:=1  to  n  do 
    Write (a[i]:5);

2) В таблицу (в столбик с разделительной чертой):  
     For i:=1 to 10 do
     Writeln (i:2, '|', a[i]:6);

Сумма всех элементов массива A:

S:=0              {начальное значение суммы =0}
For i:=1 to n do
S:= S + A[i]

Произведение всех элементов массива A:

P:=1            {начальное значение произведения}
For i:=1 to n do
P:= P * A[i]

Пример: Вычисление суммы элементов массива:

Program Summa;
var  m: array [1..5] of integer;    {массив из 5 целых чисел}
       i, s: integer;                          {i – порядковый номер элемента массива, s – сумма}
begin
randomize;                                  {запуск генератора случайных чисел}
   for i := 1 to 5 do  begin            {в цикле от 1 до 5 элемента}
   m[i] := random (10);               {присвоить случайное значение }
   Write (m[i]:5);                         {напечатать это значение в строку по формату 5 знакомест на число}
   end;
s := 0;                                         {установить начальное значение суммы = 0}
for i := 1 to 5 do                        {в цикле от 1 до 5 элемента}
    s := s + m[i];                         {прибавляем к сумме по очереди все элементы массива}
writeln('Сумма = ', s);               {вывести ответ}
readln;
end.

Пример: Поиск максимального числа в массиве:

Program PoiskMax;
var А: Array [1..10] of integer;                   {описываем массив А из 10 целых чисел }
      m, i : Integer;                                     {m - максимальное число, i- порядковый номер}
     
begin
Writeln('Поиск максимального из 10 целых чисел: ');

For i := 1 to 10 do                                        {ввод чисел в массив}
    begin
       Write('Введите число N', i, ': ');            {числа будут запрашиваться в цикле по очереди N1, N2... до N10}
       Readln(A[i]);
    end;
     
m := A[1];                                              {первое число принимаем за максимальное }
For i := 1 to 10 do                                      {в цикле сравниваем его со всеми оставшимися по очереди}
    if A[i] > m                                           {если элемент массива больше принятого за максимум}
       then m := A[i];                                 {то это число принимается за максимум}
          Write('Максимальное число: ', m);         {вывод максимального числа} 

Readln;
end.

 Назад

---

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

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

A - двумерный масси
[i,j] - элементы массива, где i - номер строки, j - номер столбца

[1,1]	[1,2]	[1,3]	...	[1,j]
[2,1]	[2,2]	...	...	...
[3,1]	...	...	...	...
...	...	...	...	...
...	...	...	...	...
[i,1]	...	...	...	[i,j]

Описание: A: array [1..i] Of Array [1..j] of integer;
или  A: array [1..i, 1..j] of integer;

К элементам двумерного массива можно обращаться по индексам:

A[1,1]:=12;
if A[i,j] <=0 then ...

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

Ввод двумерного массива:

1) С клавиатуры:
    for i:=1 to n do                                   {в строках с 1-ой по n или какое-нибудь число - количество строк}
    for j:=1 to m do begin                        {в столбцах с 1-го по m или какое-нибудь число - количество столбцов выполнять...}
    write ('Введите элемент: ');
    readln (A[i,j]);
    end;

2) Чтобы заполнить двумерный массив (матрицу) случайными числами, используют конструкцию вида:
    Randomize;                       {включаем генератор случайных чисел}
    for i:=1 to n do
    for j:=1 to m do
    A[i,j]:=random (100);          {случайные числа от 0 до 99}

3) Заполнение по индексам (для квадратной матрицы n*n).
    Элементы, у которых i=j находятся на главной диагонали матрицы:
    for  i:=1  to  n do  
    A[i,i]:= d;                      {или какое-нибудь число}

   Элементы, у которых i<j находятся над главной диагональю матрицы:
   for  i:=1  to  n-1 do         {с первой строки до предпоследней}
   for  j:=i+1 to  n do         {со следующей клетки в строке до последнего столбца }
   A[i,j]:= v;                       {или какое-нибудь число}

   Элементы, у которых i>j находятся под главной диагональю матрицы: 
   for  i:=2   to  n do
   for  j:=1  to  i-1 do
   A[i,j]:= p;                     {или какое-нибудь число}

  Элементы, у которых i+j=n+1 находятся на побочной диагонали:
  for  i:=1   to  n do
  A[i,n–i+1]:= s;             {или какое-нибудь число}

  Элементы, у которых  i+j<n+1 находятся над побочной диагональю:
  for  i:=1   to  n–1 do
  for j:=1 to n–i  do 
  A[i,j]:= t;                      {или какое-нибудь число}

  Элементы, у которых i+j>n+1 находятся под побочной диагональю:
  for  i:=n   downto  2 do
  for  j:=n–i+2  to n  do
  A[i,j] := k;                     {или какое-нибудь число}

Вывод двумерного массива:

1) В строку
    for i:=1 to n do
    for j:=1 to m do
    write (a[i,j]:5);             {вывод по формату}

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

Пример: Найти сумму всех элементов двумерного массива 3*3

Program Summa;
var a: array [1..3, 1..3] of integer;
i, j, s: integer;                 {i - номер строки, j - номер столбца, s - сумма}

begin
writeln (‘Исходный массив со случайными числами:’);
randomize;
    for i:=1 to 3 do
    for j:=1 to 3 do
    A[i,j]:=random(9)+1;                  {заполнение массива 3*3 случайными числами от 1 до 9}

    for i:=1 to 3 do
    begin
         for j:=1 to 3 do
         write(A[i,j]:4);                              {вывод массива таблицей 3*3 по формату}
         writeln;
    end;

s:=0;                                              {начальное значение суммы=0}
    for i:=1 to 3 do                           
    for j:=1 to 3 do
    s:=s+a[i,j];                                    {считаем сумму, прибавляем по очереди все элементы массива}
writeln (‘Сумма всех элементов массива = ’,s);

readln;
end.

Назад

---

16) Работа с массивами

При работе с массивами очень часто возникают задачи перестановки элементов массива, например, поменять их местами.

1) Удаление из массива одного элемента с номером k:
    For i:=k  to  n–1 do
    A[i] := A[i+1];
    A[i] := 0;
    Где  n - количество элементов массива,
           k - номер удаляемого элемента

2) Перестановка элементов массива:

   I способ – с помощью дополнительной переменной b:
   b := A[1];                    {в переменную b запишем значение 1-го элемента массива}
   A[1] := A[2];              {в освободившуюся ячейку переместим 2-ой элемент массива}
   A[2] := b;                   {во освободившейся 2-ой элемент массива запишем переменную, хранившуюся в b}

   II способ – с помощью арифметических действий:
   A[1] := A[1] + A[2];
   A[2] := A[1] – A[2];
   A[1] := A[1] – A[2];

3) Перенести в конец одномерного массива элемент из k-той позиции:

   for i:=1 to n do
   ...      {ввод элементов массива вручную или случайным образом}
   read (k);                                {считать номер нужной позиции}
   b := A[k];                               {сохранение  элемента с k-ой позиции в дополнительной переменной b}
   for i:=k  to n–1 do                 {с k-го до предпоследнего}
   A[i] := A[i+1];                       {сдвиг элементов массива следующих за k-ым на одну позицию влево}
   A[n] := b;                               {восстановление последнего значения  из переменной  b}

4) Перенести в начало одномерного массива элемент из k-той позиции:

   for i:=1 to n do
   ...      {ввод элементов массива вручную или случайным образом}
   read (k);                                {считать номер нужной позиции}
   b := A[k];                                {сохранение элемента с k-ой позиции в дополнительной переменной b}
   for i:=k downto 2 do              {обратный цикл с k-го до второго}                   
   A[i] := A[i–1];                         {сдвиг всех элементов до элемента с номером k вправо}                                  
   A[1] := b;                                {записать на первое место значение из переменной b}

5) Реверс массива: переставить элементы массива в обратном порядке (обмен происходит до середины диапазона через третью
    переменную b)

I способ
   for i:=1 to n div 2 do begin         
   b := A[i];
   A[i] := A[n+1–i];
   A[n+1–i] := b;
   end;

II способ – вывод через обратный цикл for i:=n downto 1 do...

6) Сдвиг: сдвинуть элементы массива влево на 1 ячейку, а первый элемент становится на место последнего.
    b := A[1];
    for i:=1 to n–1 do
    A[i] := A[i+1];
    A[n] := b;

7) Удаление k-той строки

    for i:=k to n do
    for j:=1 to n do
       a[i,j] := a[i+1,j]                  {Cдвинуть все строки, начиная с k-той на одну вверх}
    for j:=1 to n do
       a[n,j] := 0                            {Последнюю строку обнулить}
    При выводе уменьшить количество строк на 1.

8) Вставка строки после k-той (в описании массива учтите, что размерность массива при выводе увеличится!)
    (var a: array [1..6,1..5] of… )

    for i := k+1 to n do
    for j := 1 to n do
    a[i+1, j] := a[i, j];              {Все строки, начиная с k+1 сдвинуть на одну назад}
    for j := 1 to n do
    a[k+1, j] := 0;                   {Элементам строки k+1 присвоить заданное значение (0)}
    При выводе увеличить количество строк на 1.

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

Назад
 

---

17) Алгоритмы сортировки

Сортировка – процесс перестановки элементов массива в определенном порядке (по возрастанию, по убыванию и т.д.).

1) Базовый алгоритм сортировки:
    Начинаем с первого элемента. Сравниваем два соседних элемента, если 1-ый элемент больше 2-го, меняем их местами.
    Затем сравниваем 1-ый и 3-ий, если 1-ый элемент больше, меняем их местами. Далее сравним 1-ый элемент с 4-ым,
    потом с 5-ым и т.д. В результате самый маленький элемент встанет на 1-ое место. В результате, самый маленький элемент
     из оставшихся встанет на 2-ое место.

 …

   for  i := 1 to n–1 do                  {начиная с 1-го до предпоследнего элемента}

   for  j := i+1 to n do                  {сравниваем со следующим и до последнего}

         if  a[i] > a[j]  then begin        {если элемент больше следующего, то…}

          c := a[i];                            {меняем местами через доп. переменную}

          a[i] := a[j];

          a[j] := c;

      end;

  …

 

    Где i – номер элемента, который сравниваем (от 1 до n–1)
          j – с чем сравниваем (следующий за номером от i+1 до n)
          с – дополнительная переменная для обмена

2) Сортировка пузырьковым методом состоит из двух циклов:
    Внешний цикл для просмотра массива n–1 раз (где n – размер массива).
    Во втором, внутреннем цикле выполняется проверка: если текущий элемент больше, чем следующий, то они меняются
    местами с помощью промежуточной переменной (если делать проверку со знаком >, то сортировка будет производиться
    по возрастанию; если со знаком < – то по убыванию)

    …
    for i := 1 to n–1 do
    for j := n–1 downto i do             {элементы выше i уже поставлены!}
    if A[j] > A[j+1] then                {сравниваем соседние элементы}
    begin
    с := A[j];
    A[j] := A[j+1];                         {меняем элементы местами}
    A[j+1] := с;
    end;
    …

3) Сортировка массива методом простого выбора (поиска минимального элемента)
    Этот метод основывается на алгоритме поиска минимального (или максимального) элемента.
    В массиве  А[1..n] отыскивается минимальный элемент, который ставится на первое место A[1].
    Для  того, чтобы  не потерять элемент, ранее стоявший на первом месте, этот элемент меняется местами с A[1].
    Затем, из оставшихся элементов  А[2..n] отыскивается минимальный элемент и ставится на второе место и т.д.  n–1 раз,
    пока не  встанет  на свое место предпоследний n–1 элемент массива А, сдвинув максимальный элемент в самый конец.

    ...
    for i:=1 to n–1 do               {просмотр элементов}
    begin k := i;                          {запомнить номер позиции}
    x := a[i];                              {запомнить элемент в доп. переменной х}      
    for j := i+1 to n do               {поиск минимального от A[i] до A[n]}      
    if a[j]<x then begin            {сравнить и поменять местами}    
    k := j;      
    x := a[j];      
    end;
    a[k] := a[i];
    a[i] := x;                            {восстановить элемент из доп. переменной}
    end;

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

    Таким образом, алгоритм будет состоять из n–1 проходов, каждый из которых будет включать четыре действия:
    - взятие очередного i-гo неотсортированного элемента и сохранение его в дополнительной переменной b;
    - поиск позиции j в отсортированной части массива, в которой присутствие взятого элемента не нарушит упорядоченности
      элементов;
    - сдвиг элементов массива от i–1 -го до j–1 -го вправо, чтобы освободить найденную позицию вставки;
    - вставка взятого элемента в найденную j-ю позицию.

     …
     for i:=2 to n do               {начинаем со 2-го элемента}
     begin b := a[i];                 {помещаем очередной элемент в доп. переменную b}
     j := i–1;                             { ищем ему новую позицию j }
     while (j>=1) and (a[j]>b) do begin
     a[j+1] := a[j];                  {сдвигаем элементы вправо}
     j := j–1;
     end;
     а[j+1] := b;
     end;
     …

Назад

---

18) Строки. Работа со строками

Строки - последовательность символов, записанная между одиночными апострофами ('   '). Допускается формирование строк с использованием записи символов по десятичному коду (в виде комбинации знака # и кода символа). При этом используется таблица кодировки ASCII (всего можно описать 256 символов).

Существует два типа строковых переменных: Char и String.

1) Переменная типа Char (символ) описывает один отдельный символ кодовой таблицы ASCII (всего можно описать 256 символов).

Символьные переменные описываются в разделе Var  z: char;
С такими переменными могут быть использованы функции Ord(a); Chr(x); UpCase(a);

Функция Ord (a) возвращает код символа в системе ASCII: k:=Ord(a); где k – числовой код, а – символ.

Функция Chr (k) возвращает символ по его числовому коду. k можно так же представить как числовую константу, или можно пользовать запись #k. Пример: #161#168#226 (закодировано слово бит)
a:=Chr(k); где a – символ, соответствующий коду k

Функция UpCase(a) при наличии в параметре a прописных латинских символов преобразует их в заглавные, а все остальные символы выдаст без изменения.

2) Переменная String (Строка) – последовательность из некоторого количества символов. Количество символов последовательности называется длиной строки.
Тип String во многом похож на одномерный массив символов A: array [0..n] of Char.

Строковые переменные описываются в разделе var так:

var s: string[n];    где n - максимально возможная длина строки (целое число в диапазоне 1..255)
var s: string;        - если параметр n не указан, то по умолчанию он принимается равным 255.

Для работы со строками используются следующие функции:

Length (s); - функция возвращает в качестве результата значение длины строки (количество символов в строке).

Copy (s, i, k); - функция возвращает часть строки, выделенную из исходной строки s, начиная с символа под номером i
и длиной k символов.

Delete (s, i, k);  - удаляет из исходной строки s часть строки, начиная с символа под номером i и длиной k символов.

Insert (s1, s, i); - предназначена для вставки строки s1 в строку s, начиная с символа i этой строки.  

Pos (frag, stroka);   –  осуществляет поиск некоторого фрагмента frag в строке stroka.
                                      Если такого фрагмента нет, то результат = 0

Eoln(s); - логическая функция, результат выполнения которой равен True, если достигнут маркер конца строки s.

Примеры:

а) s := 'Система Turbo Pascal';           {исходная цепочка символов}
   s1:= length(s);                                { переменной s1 присвоить значение, равное длине строки s, т.е.= 20 }
   s2 := copy(s, 1, 7);                          {копируем с 1-го символа, всего 7 символов, т.е.  s2 будет равно слову 'Система'}

b) s:= 'Система Turbo Pascal';
    delete(s, 8, 6);                               {удаляем, начиная с 8-го символа, 6 символов, т.е. s будет равно 'Система Pascal'}

c) s:= 'Система Pascal';
    insert('Turbo ',s,9);          {вставляем 'Turbo' в исходную строку, начиная с 9-ой позиции, s будет равно 'Система Turbo Pascal'}

d) While  not  Eoln(s)  do…              {пока не достигнут конец строки s, делать…}

Назад