Все о массивах и циклах паскаль

На занятии объясняется, как работать с одномерными массивами в Паскале, как использовать генератор случайных чисел – функцию random в Паскале. Рассматривается пример того, как вывести числа Фибоначчи

Материалы сайта labs-org.ru направлены на практическое освоение языка программирования Pascal. Краткие теоретические сведения не претендуют на полное освещение материала по теме; необходимую информацию можно найти в сети Интернет в большом количестве. В наши же задачи входит предоставление возможности получения практических навыков программирования на Паскале. Решенные наглядные примеры и задания изложены по мере увеличения их сложности, что позволит с легкостью изучить материал с нуля.

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

Массивы в Паскале используются двух типов: одномерные и двумерные.

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

Описание массива в Паскале (объявление) и обращение к его элементам происходит следующим образом:

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

var dlina: array [1..3] of integer; begin dlina[1]:=500; dlina[2]:=400; dlina[3]:=150; …

• dlina – идентификатор (имя) массива;
• для объявления используется служебное слово Array (в переводе с англ. «массив» или «набор»);
• [1..3] – в квадратных скобках ставится номер (индекс) первого элемента, затем две точки и индекс последнего элемента массива, т.е. по сути, указывается количество элементов; количество элементов массива называется размерностью массива
• of integer (с англ. «из целых чисел») – указывает, к какому типу относится массив, of здесь – служебное слово.

• Объявить размер можно через константу:

  Инициализация массива

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

  const a:array[1..4] of integer = (1, 3, 2, 5);

  Заполнение последовательными числами:

  

  Результат: A[1] = 8, A[2] = 9, A[3] = 10, …, A[N] = A[N-1] + 1

  Ввод с клавиатуры:

  Пример: Рассмотрим, как происходит ввод массива в Паскале:

  writeln (‘введите кол-во элементов: ‘); readln(n); {если кол-во заранее не известно, – запрашиваем его} for i := 1 to n do begin write(‘a[‘, i, ‘]=’); read(a[i]); … end; …

  

  ✍ Пример результата:

  введите кол-во элементов: 3 a[1]=5 a[2]=7 a[3]=4

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

  Пример: Рассмотрим, как вывести массив в Паскале:

  1 2 3 4 5 6 7 8 9 10 11 12 13

  var a: array[1..5] of integer; {массив из пяти элементов} i: integer; begin a[1]:=2; a[2]:=4; a[3]:=8; a[4]:=6; a[5]:=3; writeln(‘Массив A:’); for i := 1 to 5 do write(a[i]:2); {вывод элементов массива} end.

  ✍ Пример результата:

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

  Задача Array 0. Необходимо задать вещественный массив размерностью 6 (т.е. из шести элементов); заполнить массив вводимыми значениями и вывести элементы на экран. Использовать два цикла: первый – для ввода элементов, второй – для вывода.

  Пример результата:

  введите элемент массива: 3.0 введите элемент массива: 0.8 введите элемент массива: 0.56 введите элемент массива: 4.3 введите элемент массива: 23.8 введите элемент массива: 0.7 Массив = 3, 0.8, 0.56, 4.3, 23.8, 0.7

  В данном примере работы с одномерным массивом есть явное неудобство: присваивание значений элементам.

  Обработка массивов в Паскале, так же как и заполнение массива, происходит обычно с использованием цикла for.

  Функция Random в Pascal

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

  Для генерации чисел от 0 до n (не включая само значение n, целые числа в интервале [0,N)) используется запись random (n).

  Перед использованием функции необходимо инициализировать датчик случайных чисел с помощью процедуры randomize.

  Диапазон в Паскале тех самых случайных чисел от a до b задается формулой:

  Пример: Заполнение массива случайными числами в Pascal:

  1 2 3 4 5 6 7 8 9 10

  var f: array[1..10] of integer; i:integer; begin randomize; for i:=1 to 10 do begin f[i]:=random(10); { интервал [0,9] } write(f[i],’ ‘); end; end.

  ✍ Пример результата:

  Для вещественных чисел в интервале [0,1]:

  var x: real; … x := random(0.0,1.0);; { интервал [0,1] }

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

  Пример результата:

  Массив = 0.22 0.00 -0.69 -0.35 -0.11

  Числа Фибоначчи в Паскале

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

  Пример: Ряд чисел Фибоначчи: 1 1 2 3 5 8 13…

  f[0]:=1; f[1]:=1; f[2]:=2; …

  или

  f[2]:=f[0]+f[1]; f[3]:=f[1]+f[2];

  или

  Получили формулу элементов ряда.

  Пример: Вычислить и распечатать первые 20 чисел Фибоначчи.

  1 2 3 4 5 6 7 8 9 10 11

  var i:integer; f:array[0..19]of integer; begin f[0]:=1; f[1]:=1; for i:=2 to 19 do begin f[i]:=f[i-1]+f[i-2]; writeln(f[i]) end; end.

  На данном примере, становится понятен принцип работы с числовыми рядами. Обычно, для вывода числового ряда находится формула определения каждого элемента данного ряда. Так, в случае с числами Фибоначчи, эта формула-правило выглядит как f[i]:=f[i-1]+f[i-2]. Поэтому ее необходимо использовать в цикле for при формировании элементов массива.

  Задача Array 2. Дан ряд из 10 произвольных чисел: a[1], a[2], … , a[10] (использовать функцию random()). Подсчитать и напечатать суммы троек стоящих рядом чисел: a[1]+a[2]+a[3], a[2]+a[3]+a[4], a[3]+a[4]+a[5], …… , a[8]+a[9]+a[10]

  Пример результата:

  Массив = 2 0 4 29 3 11 26 11 9 4 mas[1] + mas[2] + mas[3] = 6 mas[2] + mas[3] + mas[4] = 33 mas[3] + mas[4] + mas[5] = 36 mas[4] + mas[5] + mas[6] = 43 mas[5] + mas[6] + mas[7] = 40 mas[6] + mas[7] + mas[8] = 48 mas[7] + mas[8] + mas[9] = 46 mas[8] + mas[9] + mas[10] = 24

  Задача Array 3. Написать программу решения задачи о печати ряда чисел 2 4 8 16 32 … 512; для заполнения массива использовать цикл Repeat

  Максимальный (минимальный) элемент массива

  Псевдокод:

  

  Поиск максимального элемента по его индексу:

  

  Задание Array_min: Найдите минимальный элемент массива. Выведите элемент и его индекс.

  Пример результата:

  9 5 4 22 23 7 3 16 16 8 Минимальный элемент массива A[7]=3

  Задача Array 4. Дан массив из 10 целочисленных элементов. Найти количество отрицательных и вывести количество на экран.

  Пример результата:

  3 4 6 -1 6 -2 1 5 0 1 Количество отрицательных элементов: 2

  Задача Array 5. Найти минимальное и максимальное из n введенных чисел (массива). Определить расстояние между этими элементами.

  3 2 6 1 3 4 7 2 >>> min=1, max=7, distance=3

  Задача Array 6. Дан целочисленный массив размера N. Вывести все содержащиеся в данном массиве четные числа в порядке убывания их индексов, а также их количество K.

  N=4 mas: 8 9 2 5 >>> 2 8 количество= 2

  Задача Array 7. Ввести с клавиатуры массив из 5 элементов, найти в нем два максимальных элемента и их номера.

  Пример:

  Исходный массив: 4 -5 10 -10 5 максимальные A[3]=10, A[5]=5

  Поиск в массиве

  Рассмотрим сложный пример работы с одномерными массивами:

  Пример: Дан массив из 10 чисел. Определить, есть ли в массиве число, введенное пользователем. Если есть – выводить «найдено», если нет – «не найдено».

  Сложность задания заключается в том, что выводить слова «найдено» или «не найдено» необходимо один раз.

  Для решения поставленной задачи понадобится оператор break – выход из цикла.

  Решение Вариант 1. Цикл for:

  Рассмотрим эффективное решение:

  Задача: найти в массиве элемент, равный X, или установить, что его нет.

  Алгоритм:

  • начать с 1-го элемента (i:=1);
  • если очередной элемент (A[i]) равен X, то закончить поиск иначе перейти к следующему элементу.

  решение на Паскале Вариант 2. Цикл While:

  

  Поиск элемента в массиве

  Предлагаем посмотреть подробный видео разбор поиска элемента в массиве (эффективный алгоритм):

  Задача Array 8. Заполнить массив из 10 элементов случайными числами в интервале [0..4] и вывести номера всех элементов, равных X.

  Пример:

  Исходный массив: 4 0 1 2 0 1 3 4 1 0 Что ищем? 0 A[2], A[5], A[10]

  Циклический сдвиг

  Пример: сдвинуть элементы массива влево на 1 позицию, первый элемент становится на место последнего.

  

  Решение:

  Алгоритм:

  A[1]:=A[2]; A[2]:=A[3];… A[N-1]:=A[N];

  Программа:

  

  Задача Array 9. Заполнить массив из 10 элементов случайными числами в интервале [-10..10] и выполнить циклический сдвиг влево без первого элемента.

  Пример:

  Исходный массив: 4 -5 3 10 -4 -6 8 -10 1 0 Результат: 4 3 10 -4 -6 8 -10 1 0 -5

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

  Рассмотрим, как происходит перестановка или реверс массива.

  Пример: переставить элементы массива в обратном порядке

  

  Решение:

  Алгоритм:

  Псевдокод:

  Программа:

  

  Задача Array 10. Заполнить массив из 10 элементов случайными числами в интервале [-10..10] и сделать реверс всех элементов, кроме последнего.

  Пример:

  Исходный массив: -5 3 10 -4 -6 8 -10 1 0 4 Результат: 0 1 -10 8 -6 -4 10 3 -5 4

  Выбор элементов и сохранение в другой массив

  Пример: найти в массиве элементы, удовлетворяющие некоторому условию (например, отрицательные), и скопировать их в другой массив

  

  Решение:

  Решение: подсчитывать количество найденных элементов с помощью счетчика count, очередной элемент устанавливать на место B[count]. Переменой count необходимо присвоить 1.

  

  Вывод массива B:

  writeln(‘Выбранные элементы’); for i:=1 to count-1 do write(B[i], ‘ ‘)

  Задача Array 11. Заполнить массив случайными числами в интервале [20,100] и записать в другой массив все числа, которые оканчиваются на 0.

  Пример:

  Исходный массив: 40 57 30 71 84 Заканчиваются на 0: 40 30

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

  Сортировка методом «Пузырька»

  • В таком типе сортировок массив представляется в виде воды, маленькие элементы – пузырьки в воде, которые всплывают наверх (самые легкие).
  • При первой итерации цикла элементы массива попарно сравниваются между собой:предпоследний с последним, пред предпоследний с предпоследним и т.д. Если предшествующий элемент оказывается больше последующего, то производится их обмен.
  • При второй итерации цикла нет надобности сравнивать последний элемент с предпоследним. Последний элемент уже стоит на своем месте, он самый большой. Значит, число сравнений будет на одно меньше. То же самое касается каждой последующей итерации.

  

  Выполнение на Паскале:

  1 2 3 4 5 6 7 8

  for i:=1 to N-1 do begin for j:=N-1 downto i do if A[j] > A[j+1] then begin с := A[j]; A[j] := A[j+1]; A[j+1] := с; end; end;

  Задание Array 12. Заполнить массив из 10 элементов случайными числами в интервале [0..100] и отсортировать первую половину массива по возрастанию, а вторую – по убыванию (методом ‘Пузырька’).

  Пример: Исходный массив: 14 25 13 30 76 58 32 11 41 97 Результат: 13 14 25 30 76 97 58 41 32 11

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

  • в массиве ищется минимальный элемент и ставится на первое место (меняется местами с A[1]);
  • среди оставшихся элементов также производится поиск минимального, который ставится на второе место (меняется местами с A[2]) и т.д.

  

  Выполнение на Паскале:

  1 2 3 4 5 6 7 8 9 10

  for i := 1 to N-1 do begin min:= i ; for j:= i+1 to N do if A[j] < A[min] then min:=j; if min <> i then begin c:=A[i]; A[i]:=A[min]; A[min]:=c; end; end;

  Задание Array 13: Заполнить массив из 10 элементов случайными числами в интервале [0..50] и отсортировать его по возрастанию суммы цифр

  Пример: Исходный массив: 14 25 13 12 76 58 21 87 10 98 Результат: 10 21 12 13 14 25 76 58 87 98

  Быстрая сортировка или quick sort

  Алгоритм:

  1. Выбирается и запоминается средний элемент массива (присвоим X):

  2. Инициализируем две переменные (будущие индексы массива): L:=1, R:=N (N – количество элементов).
  3. Увеличиваем L и ищем первый элемент A[L], который больше либо равен X (в итоге он должен находиться справа).
  4. Уменьшаем R и ищем элемент A[R], который меньше либо равен X (в итоге он должен находиться слева).
  5. Смотрим, если L

  

  Выполнение на Паскале:

  

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  procedure QSort ( first, last: integer); var L, R, c, X: integer; begin if first < last then begin X:= A[(first + last) div 2]; L:= first; R:= last; while L <= R do begin while A[L] < X do L:= L + 1; while A[R] > X do R:= R – 1; if L <= R then begin c:= A[L]; A[L]:= A[R]; A[R]:= c; L:= L + 1; R:= R – 1; end; end; QSort(first, R); QSort(L, last); end; end.

  Задание Array 14:

  Заполнить массив из 10 элементов случайными числами в интервале [-50..50] и отсортировать его с помощью алгоритма быстрой сортировки.

Источник

страницы: 1 2 3

Содержание

• Содержание
• Массивы
  • Описание массива
    • Нумерация
    • Описание переменных размерностей
  • Обращение к компонентам массива
  • Задание массива константой
• Примечания

Массивы

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

Описание массива

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

Общий вид описания (одномерного) массива:

array[<тип_индексов>] of <тип_компонент>;

Чаще всего это трактуется так:

array[<левая_граница> .. <правая_граница>] of <тип_компонент>;

Например, одномерный (линейный) массив, состоящий не более, чем из 10 целых чисел, можно описать следующим образом:

var a1 : array [1 .. 10] of Integer;

Нумерация

Нумерация компонент массива не обязана начинаться с 1 или с 0 – вы можете описывать массив, пронумерованный любыми целыми числами. Необходимо лишь, чтобы номер последней компоненты был больше, чем номер первой:

var a1 : array [-5 .. 4] of Integer;

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

type Char2 = ‘a’, ‘c’ .. ‘z’; { отсутствует символ «b» }

var a1 : array [Char] of Integer; { 256 компонент }

a2 : array [Char2] of Integer; { 25 целых компонент }

a3 : array [ShortInt] of Real; { 256 вещественных компонент }

Общий размер массива не должен превосходить 65 520 байт. Следовательно, попытка задать массив a4 : array[Integer] of Byte; не увенчается успехом, поскольку тип Integer покрывает 65 536 различных элементов. А про тип LongInt в данном случае лучше и вовсе не вспоминать.

Тип компонент массива может быть любым:

var a4 : array[10 .. 20] of Real; – массив из компонент простого типа

a5 : array[0 .. 100] of Record1; – массив из записей

a6 : array[-10 .. 10] of ^String; – массив из указателей на строки

a7 : array[-1 .. 1] of Text; – массив из файловых переменных

a8 : array[1 .. 100] of array[1 .. 100] of Char; – двумерный массив (массив векторов)

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

var a9 : array[1 .. 10, 1 .. 20] of Real; – двумерный массив 10 х 20

a10 : array[Boolean, -1 .. 1, Char, -10 .. 10] of Word; – четырёхмерный массив 2 х 3 х 256 х 21

Общее ограничение на размер массива – не более 65 520 байт – сохраняется и для многомерных массивов. Количество компонент многомерного массива вычисляется как произведение всех его «измерений». Таким образом, в массиве а9 содержится 200 компонент, а в массиве а10 – 32 256 компонент.

Описание переменных размерностей

Если ваша программа должна обрабатывать матрицы переменных размерностей (скажем, N по горизонтали и М по вертикали), то вы столкнётесь с проблемой изначального задания массива, ведь в разделе type не допускается использование переменных. Следовательно, самый логичный, казалось бы, вариант

var m, n : Integer;

a : array[1 .. m, 1 .. n] of Real;

придётся отбросить.

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

Предположим, однако, что вам известны максимальные границы, в которые могут попасть индексы обрабатываемого массива. Скажем, N и М заведомо не могут превосходить 100. Тогда можно выделить место под наибольший возможный массив, а реально работать только с малой его частью:

const nmax = 100;

var a : array[1 .. nmax, 1 .. nmax] of Real;

m, n : Integer;

Обращение к компонентам массива

Массивы относятся к структурам прямого доступа. Это означает, что возможно напрямую (не перебирая предварительно все предшествующие компоненты) обратиться к любой интересующей нас компоненте массива.

Доступ к компонентам линейного массива осуществляется так:

<имя_массива>[<индекс_компоненты>]

а многомерного – так:

<имя_массива>[<индекс>, … ,<индекс>]

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

1. Индекс компоненты может быть константой, переменной или выражением, куда входят операции и вызовы функций.
2. Тип каждого индекса должен быть совместим с типом, объявленным в описании массива именно для соответствующего «измерения»; менять индексы местами нельзя.
3. Количество индексов не должно превышать количество «измерений» массива. Попытка обратиться к линейному массиву как к многомерному обязательно вызовет ошибку. А вот обратная ситуация вполне возможна: например, если вы описали N-мерный массив, то его можно воспринимать как линейный массив, состоящий из (N-1)-мерных массивов.

Примеры использования компонент массива:

a2[‘z’] := a2[‘z’] + 1;

a3[-10] := 2.5;

a3[i + j] := a9[i, j];

a10[x > 0, Sgn(x), ‘!’, Abs(k * 5)] := 0;

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

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

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

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

Исключение составляют только массивы, компонентами которых являются величины типа Char. Такие массивы можно задавать проще: строкой символов.

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

type mass = array[1 .. 3, 1 .. 2] of Byte;

const a : array[-1 .. 1] of Byte = (0, 0, 0); {линейный}

b : mass = ((1, 2), (3, 4), (5, 6)); {двумерный}

s: array[0 .. 9] of Char = ‘0123456789’;

Замечание: Невозможно задать неименованную или нетипизированную константу, относящуюся к типу данных array.

страницы: 1 2 3

Примечания

Источник