Как составить одномерный массив паскаль

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

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

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

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].

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

Работа с одномерными массивами на языке программирования Паскаль

Массив — самая распространенная структура хранения данных, присутствующая в любом языке программирования.

В Pascal используются одномерные и двумерные массивы. В школьной программе обычно их изучают в 9-10 классах.

Одномерный массив — это конечное количество однотипных элементов, объединенных общим именем. Каждому элементу присвоен свой порядковый номер. Обращение к элементам происходит по имени массива и индексу (порядковому номеру).

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

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

Имя массива формируется по тем же правилам, что и имя любой другой переменной в программе. Границы индексов задают при описании массива в квадратных скобках. Удобнее задавать начальный индекс равный единице. Конечный индекс определяется условием задачи и численно равен размеру массива — количеству элементов. Числовые массивы могут содержать целые и действительные числа. Тип элементов указывается в описании. Смотрите рисунок выше.

Способы заполнения одномерных массивов

В наших примерах будем использовать одномерный массив целых чисел, состоящий из пяти элементов. Для этого выполним его описание в разделе переменных

var
  i:integer;
  a: array[1..5] of integer; {определение одномерного массива из пяти целых чисел}

Ручной ввод данных

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

for i:=1 to 5 do
  read a[i]; {ручной ввод значений элементов массива с клавиатуры}

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

В задачах на массивы, количество элементов может быть достаточно большим. Использование ручного ввода становиться затруднительным. В этом случае для удобства отладки и проверки работоспособности программы целесообразнее использовать другие способы заполнения. Например, случайные числа, сгенерированные служебной функцией Random().

for i:=1 to 5 do
  a[i]:=random(10); {задаются случайные числа из интервала [0,10)}

Ввод данных по заданному правилу (формуле)

В некоторых задачах могут быть определены правила генерации элементов массива или вычисляться по формуле. Например, заполнить массив квадратами натуральных чисел.

for i:=1 to 5 do
  a[i]:=i*i; {квадрат натурального числа - число, умноженное само на себя}

Ввод данных из текстового файла

Еще один способ получить данные — прочитать их из файла.

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

Вывод линейного массива

В языке программирования Pascal ABC вывод элементов одномерного массива организуется с помощью цикла.

for i:=1 to 5 do write (a[i]);
или так
for i:=1 to 5 do print (a[i]);

Шаблон для использования в однотипных задачах

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

var
  i,n:integer;
  a: array[1..100] of integer; {определение одномерного массива из 100 целых чисел}
begin
write('Введите количество элементов в массиве');
readln(n);
for i:=1 to n do
  begin
    a[i]:=random(100)-random(100);{заполнение случайными числами из интервала (-100;100)}
    print (a[i]); {можно использовать write}
  end;
{здесь записывается код обработки по условию задачи}
end.

Задачи с решением

Простая обработка элементов

Задача 1. Дан одномерный массив из N целых элементов. Написать программу вычисления произведения  всех элементов. Используйте ручной способ ввода чисел.

var
  i,n,p:integer;
  a: array[1..100] of integer; {определение одномерного массива из 100 целых чисел}
begin
write('Введите количество элементов в массиве');
readln(n);
p:=1;
for i:=1 to n do
  begin
    write('Введите ',i,' -й элемент'); 
    readln(a[i]);
    p:=p*a[i];
  end;
write('Произведение = ',p);
end.

Задача 2. Дан линейный массив из N целых чисел. Написать программу вычисления суммы этих элементов. Используйте для заполнения массива случайные числа.

var
  i,n,s:integer;
  a: array[1..100] of integer; {определение одномерного массива из 100 целых чисел}
begin
write('Введите количество элементов в массиве');
readln(n);
s:=0;
writeln('Исходный массив'); 
for i:=1 to n do
  begin
    a[i]:=random(10); 
    print(a[i]);
    s:=s+a[i];
  end;
write('Сумма = ',s);
end.

Задача 3. Дан массив A(n). Заполнить двузначными числами. Найти элементы сумма цифр, которых равна числу элементов массива.

var
 i,n,s,c1,c2,k:integer;
 a: array[1..100] of integer; {определение одномерного массива из 100 целых чисел}
begin
 k:=0;
write('Введите количество элементов в массиве');
readln(n);
for i:=1 to n do
 begin
   a[i]:=random(90)+10;{заполнение случайными числами из интервала [10;99]}
   print (a[i]); {можно использовать write}
 end;
 writeln;
 writeln('Сумма цифр элементов равна размеру массива');
 for i:=1 to n do
 begin
   c1:=a[i]div 10; c2:=a[i]mod 10;
   If c1+c2=n then print (a[i])else k:=k+1;
 end;
 If k=n then print ('Таких элементов нет');
end.

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

Задача 4. Упорядочить массив чисел по возрастанию.

const n=10;
var i,j:integer;
x:real;
a:array[1..n] of real;
begin
 println('Исходный массив'); 
  for i:=1 to n do 
    begin
    a[i]:=random(100);
    print(a[i]);
    end;
    {сортировка по возрастанию}
   for i:=1 to n-1 do  
    for j:=1 to n-i do
    if a[j]>a[j+1] then 
                      begin
                      x:=a[j];a[j]:=a[j+1];a[j+1]:=x;
                      end;
    println;
    {вывод отсортированного массива}
    println('Упорядоченный массив');
    for i:=1 to n do 
       print(a[i]);    
end.

Задачи с использованием массива

Задача 5. Составьте программу, которая выполнит перевод натурального числа из десятичной системы счисления в любую с основанием 2-16

var a,b,c,i,k,s:integer;
mas: array[0..1000] of integer;  
begin  
	k:=0;  
	write('Введите число ');readln(a);
	write('Введите основание системы для перевода ');readln(s);
	repeat  
		b:=a mod s;
		k:=k+1;  
		mas[k]:=b;  
		c:=a div s;  
		if c>=s then a:=c;  
	until c<s;  
	case c of
	10: write('A');
	11: write('B');
	12: write('C');
	13: write('D');
	14: write('E');
	15: write('F');
		else write(c);  
	end;
	for i:=k downto 1 do  
		case mas[i] of
		10: write('A');
		11: write('B');
		12: write('C');
		13: write('D');
		14: write('E');
		15: write('F');
			else write(mas[i]);
		end;
end.

Дополнительные задания:

mas1 Дан целочисленный массив произвольного размера. Подсчитать сколько раз заданная цифра встречается в элементах массива. Числа в массиве только 3-х значные.

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

Определение

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

• рядов;
• таблиц;
• матриц;
• векторов.

Массив – это упорядоченный набор (множество) данных. Хранит значения при помощи одного или нескольких индексов. Самый простой вариант рассматриваемого элемента обладает постоянной длиной. Включает в себя единицы информации одного и того же типа. В виде индексов тут выступают целые числа.

Разновидности

Различают несколько видов рассматриваемого объекта в зависимости от того, какое количество элементов в массиве будет содержаться в конечном итоге:

1. Одномерный. У него всего один индекс.
2. Двумерный. Содержит два индекса.
3. Трехмерный и так далее.

На практике чаще всего дан одномерный массив или двумерный. Вариации с тремя и более индексами встречаются крайне редко.

В некоторых языках разработки есть динамические массивы. В них размер меняется непосредственно при выполнении программного кода. Остальные носят название фиксированных или статистических.

Одномерный массив в Паскале: особенности

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

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

В рассматриваемом языке программирования предстоит работать с линейным множеством данных. Он будет рассмотрен более подробно далее. А еще предстоит раскрыть способы заполнения одномерных множеств информации в Pascal.

Числовой одномерный вид

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

• перечисление индексов;
• имеющиеся значения элементов.

Имя задается точно так же, как и в случае с переменными в приложении. Границы index задают непосредственно при описании множества данных. Делается это в квадратных скобках.

Рекомендуется задавать начальный индекс в виде единицы. Конечный определяется условием конкретной поставленной задачи. Численно выражен размеру множества данных – количеству содержащихся компонентов.

Числовой массив содержит целые и действительные числа. Тип элементов указывается непосредственно в описании. Пример – таблица выше. Множество данных может состоять из шести, трех, сотни или иного количества элементов.

Как заполнять

Вносить информацию в одномерный массив, который дан в задаче, можно несколькими способами:

• вручную;
• случайными элементами;
• ввод данных по формуле/правилу;
• из текстового файла.

Далее каждый вариант будет рассмотрен отдельно. Не важно, из шести или более элементов состоит множество. Главное, что внести в него данные не составит никакого труда.

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

var i : integer;

var a: array [1…5] of integer; {здесь происходит определение одномерного множества из количества элементов целых чисел, которое равно пяти}

Вручную

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

For i: = 1 to 5 do

Read a[i];

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

Случайное число

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

For i: = 1 to n do {в нашем случае n = 5}

a [i]: = random (10); {задаются случайные числа из интервала от 0 (включительно) до 10}

Это – один из самых простых примеров. Интервал значений можно задать согласно условиям поставленной задачи.

По правилу

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

Выше – пример, который поможет заполнить множество данных квадратами натуральных чисел.

Текст

Также можно получить данные при помощи чтения их из файлов. В Pascal соответствующий процесс требует определенной сноровки и значительного багажа знаний. Используется крайне редко.

Можно найти туториалы и видео-уроки по чтению информации для массивов одномерного типа из текстовых документов. Вот – пример и основные принципы работы с соответствующими компонентами.

Вывод и шаблон для типовых задач

В Pascal ABC отобразить элементы одномерного множества можно при помощи цикла:

А вот шаблон, который поможет решать типовые задачи на определение, заполнение и вывод одномерных множеств информации:

var

  i,n:integer;

  a: array[1..100] of integer; {множество, включающее в себя 100 целых чисел}

begin

write('Укажите количество элементов');

readln(n);

for i:=1 to n do begin

    a[i]:=random(100)-random(100);{заполнение множества случайными значениями из интервала (-100;100)}

    print (a[i]); {в качестве альтернативы допускается работа с write}

  end;

{код обработки согласно условию заданной задачки}

end.

А вот – видео-урок, который лучше объяснит рассмотренную тему новичкам.

Хотите освоить современную IT-специальность? Огромный выбор курсов по востребованным IT-направлениям есть в Otus!

Ввод и вывод

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: Программы и алгоритмы для начинающих