Как составить массивы в паскале

Ввод и вывод

const Sz = 100; // Размер массива

var 
  a: array [1..Sz] of integer;
  N: integer; // Количество элементов в массиве
  i: integer;
  
begin
  write('Введите количество элементов в массиве: ');
  readln(N);
  write('Введите элементы массива: ');
  for i:=1 to N do
    read(a[i]);
  write('Вывод элементов массива: ');
  for i:=1 to N do
    write(a[i],' ');
end.

Заполнение случайными числами

const Sz = 100; // Размер массива

var 
  a: array [1..Sz] of integer;
  N: integer; // Количество элементов в массиве
  i: integer;
  
begin
  N := 20;
  for i:=1 to N do
    a[i] := Random(100);
  writeln('Элементы массива: ');
  for i:=1 to N do
    write(a[i],' ');
end.

Заполнение арифметической прогрессией

const 
  Sz = 100;
  a0 = 5; // Первый элемент арифметической прогрессии
  d = 3;  // Разность арифметической прогрессии

var 
  a: array [1..Sz] of integer;
  N: integer; // Количество элементов в массиве
  
begin
  N := 20;
  a[1] := a0;
  for var i:=2 to N do
    a[i] := a[i-1] + d;
  writeln('Арифметическая прогрессия: ');
  for var i:=1 to N do
    write(a[i],' ');
end.

Заполнение степенями двойки

const 
  Sz = 100;
var 
  a: array [1..Sz] of integer;
  N: integer;   
begin
  N := 20;
  a[1] := 2;
  for var i:=2 to N do
    a[i] := a[i-1] * 2;
  writeln('Степени двойки: ');
  for var i:=1 to N do
    writeln(i:3,a[i]:9);
end.

Заполнение числами Фибоначчи

const 
  Sz = 100;
var 
  a: array [1..Sz] of integer;
  N: integer;   
begin
  N := 20;
  a[1] := 1; 
  a[2] := 1;
  for var i:=3 to N do
    a[i] := a[i-2] + a[i-1];
  writeln('Числа Фибоначчи: ');
  for var i:=1 to N do
    write(a[i],' ');
end.

Инвертирование массива

const 
  Sz = 100;
var 
  a: array [1..Sz] of integer;
  N: integer;   
begin
  N := 20;
  for var i:=1 to N do
    a[i] := Random(100);
  writeln('Элементы массива: ');
  for var i:=1 to N do
    write(a[i],' ');
  writeln;  
    
  for var i:=1 to N div 2 do
    Swap(a[i],a[N-i+1]);
    
  writeln('После инвертирования: ');
  for var i:=1 to N do
    write(a[i],' ');
end.

Минимальный элемент в массиве и его индекс

const 
  Sz = 100;
var 
  a: array [1..Sz] of real;
  N: integer;   
  min: real;
  minind: integer;
begin
  N := 20;
  for var i:=1 to N do
    a[i] := Random(100);
  writeln('Элементы массива: ');
  for var i:=1 to N do
    write(a[i],' ');
  writeln;  
  
  min := a[1];
  minind := 1;
  for var i:=2 to N do
    if a[i]<min then 
    begin
      min := a[i];
      minind := i;
    end;
    
  writeln('Минимальный элемент: ',min);
  writeln('Индекс минимального элемента: ',minind);
end.

Минимальный четный элемент и его индекс

const 
  Sz = 100;
var 
  a: array [1..Sz] of integer;
  N: integer;   
  min: integer;
  minind: integer;
begin
  N := 20;
  for var i:=1 to N do
    a[i] := Random(100);
  writeln('Элементы массива: ');
  for var i:=1 to N do
    write(a[i],' ');
  writeln;  
  
  min := integer.MaxValue;
  for var i:=1 to N do
    if (a[i]<min) and (a[i] mod 2 = 0) then 
    begin
      min := a[i];
      minind := i;
    end;
    
  if min = integer.MaxValue then
    writeln('Четных элементов нет')
  else  
  begin
    writeln('Минимальный четный элемент: ',min);
    writeln('Индекс минимального четного элемента: ',minind);
  end;
end.

Запись четных элементов массива в новый массив

const 
  Sz = 100;
var 
  a,b: array [1..Sz] of integer;
  aN: integer; // Количество элементов в массиве a  
  bN: integer; // Количество элементов в массиве b  
begin
  aN := 20;
  for var i:=1 to aN do
    a[i] := Random(100);
  writeln('Элементы массива: ');
  for var i:=1 to aN do
    write(a[i],' ');
  writeln;  
  
  bN := 0;
  for var i:=1 to aN do
    if a[i] mod 2 = 0 then 
    begin
      bN += 1;
      b[bN] := a[i];
    end;
    
  writeln('Четные элементы массива: ');
  for var i:=1 to bN do
    write(b[i],' ');
end.

Слияние отсортированных массивов в отсортированный

Способ 1.

const 
  aN = 10;      // Количество элементов в массиве a 
  bN = 6;       // Количество элементов в массиве b 
  cN = aN + bN; // Количество элементов в массиве c 

var 
  a: array [1..aN] of integer := (1,5,12,15,47,89,98,112,171,180);
  b: array [1..bN] of integer := (13,44,58,71,73,111);
  c: array [1..сN] of integer;
  ai,bi,ci: integer;
begin
  writeln('Элементы массива a: ');
  for var i:=1 to aN do
    write(a[i],' ');
  writeln;  
  writeln('Элементы массива b: ');
  for var i:=1 to bN do
    write(b[i],' ');
  writeln;  
  
  ci := 1;
  ai := 1;
  bi := 1;
  
  while (ai<=aN) and (bi<=bN) do
  begin
    if a[ai]<b[bi] then
    begin
      c[ci] := a[ai];
      ai += 1;
    end
    else 
    begin
      c[ci] := b[bi];
      bi += 1;
    end;
    ci += 1;
  end;
  while ai<=aN do
  begin
    c[ci] := a[ai];
    ai += 1;
    ci += 1;
  end;
  while bi<=bN do
  begin
    c[ci] := b[bi];
    bi += 1;
    ci += 1;
  end;
    
  writeln('Результат слияния: ');
  for var i:=1 to cN do
    write(c[i],' ');
end.

Способ 2. С барьерным элементом

const 
  aN = 10;      // Количество элементов в массиве a 
  bN = 6;       // Количество элементов в массиве b 
  cN = aN + bN; // Количество элементов в массиве c 

var 
  a: array [1..aN+1] of integer := (1,5,12,15,47,89,98,112,171,180,0); // последний элемент - барьерный
  b: array [1..bN+1] of integer := (13,44,58,71,73,111,0);
  c: array [1..cN] of integer;
  ai,bi,ci: integer;
begin
  writeln('Элементы массива a: ');
  for var i:=1 to aN do
    write(a[i],' ');
  writeln;  
  writeln('Элементы массива b: ');
  for var i:=1 to bN do
    write(b[i],' ');
  writeln;  

  a[aN+1] := integer.MaxValue; // барьерный элемент - самый большой
  b[bN+1] := integer.MaxValue;
  
  ci := 1;
  ai := 1;
  bi := 1;
  
  for ci:=1 to cN do
    if a[ai]<b[bi] then
    begin
      c[ci] := a[ai];
      ai += 1;
    end
    else 
    begin
      c[ci] := b[bi];
      bi += 1;
    end;
    
  writeln('Результат слияния: ');
  for var i:=1 to cN do
    write(c[i],' ');
end.

Сдвиг элементов влево

const N = 10;

var a: array [1..N] of integer;

begin
  for var i:=1 to N do
    a[i] := Random(100);
  writeln('Элементы массива a: ');
  for var i:=1 to N do
    write(a[i],' ');
  writeln;  

  for var i:=1 to N-1 do
    a[i] := a[i+1];
  a[N] := 0;
  
  writeln('После сдвига влево: ');
  for var i:=1 to N do
    write(a[i],' ');
  writeln;  
end.

Сдвиг элементов вправо

const N = 10;

var a: array [1..N] of integer;

begin
  for var i:=1 to N do
    a[i] := Random(100);
  writeln('Элементы массива a: ');
  for var i:=1 to N do
    write(a[i],' ');
  writeln;  

  for var i:=N downto 2 do
    a[i] := a[i-1];
  a[1] := 0;
  
  writeln('После сдвига влево: ');
  for var i:=1 to N do
    write(a[i],' ');
  writeln;  
end.

Удаление элемента

const N = 10;

var 
  a: array [1..N] of integer;
  K: integer;

begin
  for var i:=1 to N do
    a[i] := Random(100);
  writeln('Элементы массива a: ');
  for var i:=1 to N do
    write(a[i],' ');
  writeln;  

  K := Random(1,N);

  for var i:=K to N-1 do
    a[i] := a[i+1];
  
  writeln('После удаления элемента с индексом ',K,':');
  for var i:=1 to N-1 do
    write(a[i],' ');
  writeln;  
end.

Вставка элемента

const 
  N = 10;
  Elem = 666;

var 
  a: array [1..N+1] of integer;
  K: integer;

begin
  for var i:=1 to N do
    a[i] := Random(100);
  writeln('Элементы массива a: ');
  for var i:=1 to N do
    write(a[i],' ');
  writeln;  

  K := Random(1,N);

  for var i:=N downto K do
    a[i+1] := a[i];
  a[K] := 666;  
  
  writeln('После вставки элемента ',Elem,' в позицию ',K,':');
  for var i:=1 to N+1 do
    write(a[i],' ');
  writeln;  
end.

Подсчет количества элементов, удовлетворяющих условию

const N = 20;

var 
  a: array [1..N] of integer;
  K,Count: integer;

begin
  for var i:=1 to N do
    a[i] := Random(10);
  writeln('Элементы массива a: ');
  for var i:=1 to N do
    write(a[i],' ');
  writeln;  

  K := Random(10);

  Count := 0;
  for var i:=1 to N do
    if a[i] = K then 
      Count += 1;
  
  writeln('Количество элементов, равных ',K,': ',Count);  
end.

Есть ли элемент, удовлетворяющий условию

const N = 10;

var 
  a: array [1..N] of integer;
  K: integer;
  IsFound: boolean;

begin
  for var i:=1 to N do
    a[i] := Random(15);
  writeln('Элементы массива a: ');
  for var i:=1 to N do
    write(a[i],' ');
  writeln;  

  K := Random(15);

  IsFound := False;
  for var i:=1 to N do
    if a[i] = K then 
    begin
      IsFound := True;
      break
    end;
  
  if IsFound then
    writeln('Элемент ',K,' найден')
  else writeln('Элемент ',K,' не найден')  
end.

Сортировка пузырьком

const N = 10;

var 
  a: array [1..N] of integer;

begin
  for var i:=1 to N do
    a[i] := Random(100);
  writeln('Элементы массива a: ');
  for var i:=1 to N do
    write(a[i],' ');
  writeln;  

  for var i:=n downto 2 do
  for var j:=1 to i-1 do
    if a[j+1]<a[j] then
      Swap(a[j+1],a[j]);
  
  writeln('После сортировки пузырьком: ');
  for var i:=1 to N do
    write(a[i],' ');
  writeln;  
end.

Сортировка выбором

const N = 10;

var 
  a: array [1..N] of integer;
  K: integer;
  IsFound: boolean;

begin
  for var i:=1 to N do
    a[i] := Random(100);
  writeln('Элементы массива a: ');
  for var i:=1 to N do
    write(a[i],' ');
  writeln;  

  for var i:=1 to N-1 do
  begin
    var min := a[i]; 
    var ind := i;
    for var j:=i+1 to N do
      if a[j]<min then
      begin
        min := a[j];
        ind := j;
      end;
    a[ind] := a[i];
    a[i] := min;
  end;

  writeln('После сортировки выбором: ');
  for var i:=1 to N do
    write(a[i],' ');
  writeln;  
end.

Ссылки

• Программы для начинающих
• Сайт PascalABC.NET: Программы и алгоритмы для начинающих

Массивом
называется способ организации однородной информации, при котором облегчается
доступ к любому элементу информации по его индексу (номеру) и достаточно легко
производится обработка информации.

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

x:array[1..100] of integer; – массив на 100 элементов для целых
чисел с индексами от 1 до 100.

a,b:array[10..29] of string; – два массива по 20 элементов для
символьных переменных с индексами от 10 до 29.

Двумерный массив объявляется так:

y:array[1..10,1..5] of real; – массив размером 10 на 5 для
вещественных чисел с индексами от 1 до 10 и от 1 до 5.

Конкретный элемент массива обозначается с помощью ссылки на
переменную (имя) массива, за которой в квадратных скобках указывается индекс
данного элемента, например: a[7]

Строковая
переменная типа string также может рассматриваться как массив переменных типа
char, например: b:string[20] Это дает доступ к каждому символу в
строковой переменной, если значение символа имеет тип Char.

Конкретный символ в строковой переменной обозначается с помощью
ссылки на строковую переменную, за которой указывается индекс, определяющий
позицию символа в строке, например:b[15].

В программах можно использовать присваивание элементам массива:
а[5] := 8; числовому, b[3] := ‘Виктор’ строковому

и выборочную печать элементов:

write (а[5]);

writeln (b[3]);

С массивами удобно работать с помощью циклов:

— заполнение

for t := 1 to 20 do

begin

write(‘Введите ‘,t,’-й элемент’);

readln(a[t]);

end;

— вывод на печать

for t := 1 to 20 do

writeln(t,’-й элемент равен’,a[t]);

— выбор по условию

for t := 1 to 20 do

if a[t]>=3 then writeln(‘У студента ‘,b[t],’ оценка по
экзамену ‘,a[t]);

— при использовании двумерных массивов применяются вложенные
циклы.

var m,k:integer;

x:array[1..10,1..5] of string;

begin

for m:=1 to 10 do

for k:=1 to 5 do

begin

write(‘Введите фамилию жильца ‘,m,’-го подъезда и ‘,k,’-го
этажа’);

readln(x[m,k]);

end;

write(‘Полный список жильцов:’);

for m:=1 to 10 do

for k:=1 to 5 do

write(m,’-й подъезд, ‘,k,’-й этаж’,x[m,k])

end.

Просмотрите предлагаемые ниже задачи, разберитесь в их работе.
При необходимости наберите и изучите программы.

1. Программа «исчезающие звезды».

В цикле for массивы заполняются случайными числами: x – до 640
(координата х), y – до 400 (координата y), c – до 1000000 (цвет). В цикле
repeat последовательно проходятся все элементы массива и по указанным
координатам сначала окружность (круг) рисуется черным цветом (звезды гаснут), а
затем по новым случайным координатам и цвету вспыхивают звезды. Процесс
продолжается до нажатия любой клавиши.

uses crt, graphabc;

var a,b,d,e,f:integer;

x,y,c:array[1..100] of integer; {3 числовых массива по 100
элементов каждый}

begin

floodfill(10,10,clblack); {заливка фона черным}

for b:=1 to 100 do begin {заполнение массивов}

x[b]:=random(640);

y[b]:=random(400);

c[b]:=random(1000000);

end;

repeat

for b:=1 to 100 do begin

SetPenColor (clblack); {звезды гаснут}

circle(x[b],y[b],2);

floodfill(x[b],y[b],clblack); {заливка звезды черным}

x[b]:=random(640);

y[b]:=random(400);

c[b]:=random(1000000);

delay(25);

setpencolor(c[b]); {звезды вспыхивают}

circle(x[b],y[b],2);

floodfill(x[b],y[b],c[b]); {заливка звезды}

end;

until keypressed

end.

2. Cортировка массива. Массив заполняется случайными числами,
которые затем упорядочиваются и печатаются на экране.

uses crt;

var a,b,c,d:integer;

q:array[1..15] of integer;

begin

clrscr;

writeln(‘исходные случайные числа:’);

for a:=1 to 15 do

begin

q[a]:=random(50);

write(q[a],’ ‘);

end;

writeln;

for a:=1 to 15 do

begin

for b:=1 to 14 do

begin

if q[a]>q[b] then { Числа располагаются в порядке убывания }

begin { смена знака на < расположит числа по возрастанию}

c:=q[b];

q[b]:=q[a];

q[a]:=c;

end;

end;

end;

writeln;

writeln(‘отсортированные случайные числа:’);

for a:=1 to 15 do

write(q[a],’ ‘);

end.

3. Неповторяющиеся случайные числа до 100.

uses crt;

var a,b,c,d:integer;

q:array[1..10] of integer;

begin

clrscr;

a:=1;

while a<11 do

begin

q[a]:=random(100)+1;

if a>1 then

for b:=1 to a-1 do

begin

if q[a]=q[b] then a:=a-1;

end;

a:=a+1;

end;

for a:=1 to 10
do writeln(q[a]);

end.

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

1. Описать числовой массив на 5 элементов и заполнить его
   присваиванием любыми числами, распечатать содержимое элементов массива

а) в столбик

б) в строку.

    2.Описать числовой
массив на 5 элементов и заполнить его в цикле с клавиатуры любыми числами,
распечатать содержимое элементов массива.

Упражнения.

Выполните
задания с Array1 по Array10 по электронному задачнику (стр.49).

Выполните
задания с Array51 по Array60 по электронному задачнику (стр.54).

Выполните
задания с Array65 по Array69 по электронному задачнику (стр.55).

Выполните
задания с Matrix1 по Matrix4, с Matrix7 по Matrix10 по
электронному задачнику (стр.64).

Открыть его
можно в режиме Помощь – Электронный задачник РТ.

Сегодня мы с вами наконец-то начинаем новую тему — одномерные массивы.

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

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

var 
   a : array [1..N] of integer;

//или
type 
  arr = array[1..N] of integer;

var
  a: arr;

Между именем типа и именем переменной ставится знак «двоеточие». Array — служебное слово (в переводе с английского означает «массив», «набор»); [1..N] — в квадратных скобках указывается номер первого элемента, затем, после двух точек, номер последнего элемента массива; of — служебное слово (в переводе с английского «из»); integer — тип элементов массива.

Индексом могут быть не только натуральные числа: мы можем написать так: [0..10], [-29..45], [‘a’..’z’], [false..true] — то есть нам подходят любые символы и числа — главное соблюсти следующее условие: левая часть меньше правой. Для того чтобы определить, что меньше — восклицательный знак(‘!’) или точка(‘.’) используем таблицу ASCII и функции Ord() и Chr().

Как же производится ввод одномерного массива?

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

for i := 1 to N do
   read(a[i]); //где a[i] -- элемент одномерного массива a с индексом (порядковым номером) i.

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

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

Одномерные массивы. Решение задач.

Series8. Дано целое число N и набор из N целых чисел. Вывести в том же порядке все четные числа из данного набора и количество K таких чисел.

Исходное решение: Series8.

Модифицированное решение:

var
  a: array[1..1000] of integer; {мы не знаем заранее N, поэтому берем с запасом.}
  k, N, i: integer;

begin
  write('N = '); 
  readln(N);  
  write('Введите ', N, ' целых чисел: '); 
  for i := 1 to N do read(a[i]); {заполняем масссив}
  
  {Начинаем выбирать чётные числа}
  write('Чётные числа: ');
  for i := 1 to N do
  begin
    if a[i] mod 2 = 0 then 
    begin
      Inc(k);
      write(a[i], ' ');
    end;
  end;  
  writeln();
  writeln('Количество четных чисел - ', k); 
end.

Series28.  Дано целое число N и набор из N вещественных чисел: A₁, A₂, …, A_N. Вывести следующие числа:

(A₁)^N, (A₂)^N−1, …, (A_N−1)², A_N.

Исходное решение: Series28.

Более подробно про возведение числа в степень мы говорили в решении задачи for36.

Модифицированное решение:

var
  a: array[1..1000] of integer; 
  N, i, j, n_pow: integer;
  d, r: real;

begin
  write('N = ');
  readln(N);
  write('Введите ', N, ' целых чисел: '); 
  for i := 1 to N do read(a[i]);
  
  {Возводим элементы массива в степень}
  for i := 1 to N do
  begin
    n_pow := N + 1 - i;
    d := a[i];
    if n_pow mod 2 <> 0 then r := d else r := 1; //в r будет записываться результат
    while n_pow > 1 do
    begin
      n_pow := n_pow div 2;
      d := d * d;
      if n_pow mod 2 <> 0 then r := r * d;
    end;
    writeln(a[i], ' в степени ', N + 1 - i, ' равно ', r);
  end;
end.

Ну и напоследок давайте разберём веселенькую задачу на длинную арифметику.

Задача. Найти факториал числа. 

Мы уже решали эту задачу здесь(for19).

Научимся вычислять факториал натурального числа N. Факториал числа — это произведение чисел 1*2*3*…*(N-1 )*N (обозначается как N!).  Сложность задачи в том, что уже 8!=40320, а 13!=6227020800. Типы данных Integer, Longlnt применимы весьма в ограниченном диапазоне натуральных чисел. Для представления факториала договоримся использовать массив. Пример:

В массиве записано значение 11!=39916800. Каким образом? В А[0] фиксируется число занятых элементов массива, в А[1] — цифра единиц результата, в А[2] — цифра десятков результата, в А[3] — цифра сотен результата и т. д. Почему так, а не наоборот? Такая запись позволяет исключить сдвиг элементов массива при переносе значений в старший разряд. А сейчас наберите, как обычно, текст программы, выполните компиляцию и, выполните ее в пошаговом режиме, отслеживая изменение значений переменных при не очень большом значении N. Добейтесь полного понимания логики работы программы.

Для того чтобы выполнить программу в пошаговом режиме, нажмите «шаг без входа в подпрограмму» и перейдите в «локальные переменные».

const 
  MaxN = 300;

var
  A: array [0..MaxN] of integer;
  i, j, r, w, N: integer;

begin
  Write('Введите число, факториал которого необходимо подсчитать: ');
  Read(N);
  A[0] := 1;
  A[1] := 1; 
  j := 2; {Начальные присвоения, начинаем вычислять 2! }
  while (j <= N) and (A[0] < MaxN) Do {Второе условие 
  позволяет избежать выхода из границ диапазона, если 
  количество цифр в факториале превзойдет 300.}
  begin
    r := 0;
    i := 1;
    {r - перенос из разряда в разряд при
    выполнении умножения числа j на очередную цифру
    A[i] предыдущего результата.}
    while (i <= A[0]) or (r <> 0) Do 
    begin
      {Пока не
      «прошли» все цифры предыдущего результата или
      есть перенос цифры в старший разряд}
      w := A[i] * j + r;{Умножаем очередную цифру и
      прибавляем цифру переноса из предыдущего
      разряда}
      A[i] := w mod 10; {Оставляем остаток от деления на 10}
      r := w div 10;{Вычисляем значение переноса}
      if A[A[0] + 1] <> 0 then Inc(A[0]);{Изменяем 
      количество элементов, если их количество увеличилось.}
      Inc(i);
    end;
    Inc(j);
  end;
  write('Факториал: ');
  for i := A[0] downto 1 Do Write(A[i]);{Вывод результата}
end.

Подведем итоги:

Одномерный массив — это конечное упорядоченное множество элементов. За первым элементом идет второй, за вторым — третий и т. д. Индекс может быть чем угодно — и целым числом, и символом. Но чаще мы всё-таки будем пользоваться следующим диапазоном:  [1.. N].

На сегодня все! Если у вас еще остались вопросы о том, как работает программа выше, оставляйте их в комментариях. И очень скоро мы начнем решать задачи на массивы из задачника М. Э. Абрамяна.