Помогаю со студенческими работами здесь
Как узнать размер строки как размер массива
const char* test_str = "01234×00 789";
//очевидно, что
strlen(test_str) == 5;
sizeof(test_str)…
Как узнать размер массива
Всем привет, столкнулся с проблемой , решение которой нигде не могу найти. Например , функция…
Как узнать размер массива?
Имею функцию
template <typename T>
int funk(T mas, T element)
{
//kod
}
Как узнать размер массива?
Нужно узнать размер введенного пользователем массива, но sizeof() почему-то не работает, помогите…
Искать еще темы с ответами
Или воспользуйтесь поиском по форуму:
2
На занятии объясняется, как работать с одномерными массивами в Паскале, как использовать генератор случайных чисел — функцию random в Паскале. Рассматривается пример того, как вывести числа Фибоначчи
Материалы сайта labs-org.ru направлены на практическое освоение языка программирования Pascal. Краткие теоретические сведения не претендуют на полное освещение материала по теме; необходимую информацию можно найти в сети Интернет в большом количестве. В наши же задачи входит предоставление возможности получения практических навыков программирования на Паскале. Решенные наглядные примеры и задания изложены по мере увеличения их сложности, что позволит с легкостью изучить материал с нуля.
Содержание:
- Одномерные массивы в Паскале
- Объявление массива
- Инициализация массива
- Вывод элементов массива
- Динамические массивы (pascalAbc.Net)
- Функция Random в 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
[Название файла: taskArray0.pas
]
В данном примере работы с одномерным массивом есть явное неудобство: присваивание значений элементам.
Обработка массивов в Паскале, так же как и заполнение массива, происходит обычно с использованием цикла for
.
Динамические массивы (pascalAbc.Net)
Основным недостатком статических массивов является то, что их размер нельзя задать с учетом текущих обрабатываемых данных. Приходится описывать массивы с максимально возможным значением количества элементов, выделяя для них столько памяти, сколько может потребоваться для хранения самой большого из возможных наборов исходных данных.
Объявление:
var a: array of integer; var n:=readInteger; a:=new integer[n]; // инициализация, выделение памяти для элементов массива
или:
var a: array of integer; var n:=readInteger; SetLength(a,n); // устанавливаем размер
Аналогичным образом массивы могут описываться в качестве параметров подпрограмм, например:
procedure p(a: array of integer);
Созданные элементы сразу получают начальное значение, равное нулевому значению соответствующего типа: для чисел это целый или вещественный нуль, для символов — символ с кодом 0, для строк и других ссылочных типов данных — нулевая ссылка nil
Объявление и инициализация массива:
Пример:
begin var a: array of integer; a := new integer[3]; a[0] := 5; a[1] := 2; a[2] := 3; end.
или в одну строку:
begin var a: array of integer; a := new integer[3](5,2,3); print(a) end.
или короткая запись:
var a:=Arr(1,2,3);// по правой части - integer
Элементы динамического массива всегда индексируются от 0.
Ввод элементов:
Пример:
var a:=ReadArrInteger(5); // ввод пяти целых var a:=ReadArrReal(5); // ввод пяти вещественных
Функции генерации массивов:
1. ArrFill :
var a := ArrFill(10, 1); // массив из 10 целых чисел, равных 1
2. ArrGen :
var a := ArrGen(ReadInteger, 1, e -> e + 2); // массив, состоящий из n первых положительных нечетных чисел a.Print;
Проход по элементам массива:
Пример:
for var i:=0 to a.Length-1 do a[i] += 1;
или:
for var i := 0 to a.High do a[i] += 1;
Проход по элементам (только для чтения):
Пример:
foreach var x in a do Print(x)
Length
Low
и High
, определяющие соответственно нижнюю и верхнюю границу диапазона изменения индекса. Свойство a.Low
всегда возвращает 0, а свойство a.High
определяется как a.High = a.Length – 1
Простой вывод элементов:
Writeln(a); // пример вывода: [1,5,3,13,20]
или метод массива Print
:
a.Print; // пример вывода: 1 5 3 13 20 a.PrintLines; // каждый элемент с новой строки
Функция 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), т.е. единица не включена }
PascalABC.NET
:
var (a, b, c) := Random3(10.0, 20.0); // диапазон [10, 20) write(a:0:2,' ',b:0:2,' ', c:0:2) // 14.73 18.63 19.72
Пример:
var a:=arrRandomInteger(10);
или с дополнительными параметрами (диапазон [5;15]):
var a:=arrRandomInteger(10,5,15);
Задача Array 1. Необходимо задать массив размерностью 5, заполнить массив случайными числами в интервале [-1,1] и вывести элементы на экран: определить три позиции для вывода каждого элемента, с двумя знаками после запятой.
Пример результата:
Массив = 0.22 0.00 -0.69 -0.35 -0.11
[Название файла: taskArray1.pas
]
Числа Фибоначчи в Паскале
Наиболее распространенным примером работы с массивом является вывод ряда чисел Фибоначчи в Паскаль. Рассмотрим его.
Пример: Ряд чисел Фибоначчи: 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
[Название файла: taskArray2.pas
]
Задача Array 3. Написать программу решения задачи о печати ряда чисел 2 4 8 16 32 ... 512
; для заполнения массива использовать цикл Repeat
[Название файла: taskArray3.pas
]
Максимальный (минимальный) элемент массива
Псевдокод:
Поиск максимального элемента по его индексу:
PascalABC.NET
:
Минимальный элемент и его индекс:
Решение 1:
// … var (min, minind) := (a[0], 0); for var i:=1 to a.Length-1 do if a[i]<min then (min, minind) := (a[i], i); Result := (min, minind);
Решение 2:
// … var (min, minind) := (real.MaxValue, 0); for var i:=0 to a.Length-1 do if a[i]<min then (min, minind) := (a[i], i); Result := (min, minind);
Решение 3:
begin var a := new integer[5]; a := arrRandomInteger(5); // [86,37,41,45,76] print(a.Min,a.IndexMin); // 37 1 end.
Задача Array_min: Найдите минимальный элемент массива. Выведите элемент и его индекс.
Пример результата:
9 5 4 22 23 7 3 16 16 8 Минимальный элемент массива A[7]=3
[Название файла: taskArray_min.pas
]
Задача Array 4. Дан массив из 10 целочисленных элементов. Найти количество отрицательных и вывести количество на экран.
Пример результата:
3 4 6 -1 6 -2 1 5 0 1 Количество отрицательных элементов: 2
[Название файла: taskArray4.pas
]
Задача Array 5. Найти минимальное и максимальное из n введенных чисел (массива). Определить расстояние между этими элементами.
3 2 6 1 3 4 7 2 >>> min=1, max=7, distance=3
[Название файла: taskArray5.pas
]
Задача Array 6. Дан целочисленный массив размера N. Вывести все содержащиеся в данном массиве четные числа в порядке убывания их индексов, а также их количество K.
N=4 mas: 8 9 2 5 >>> 2 8 количество= 2
[Название файла: taskArray6.pas
]
Задача Array 7. Ввести с клавиатуры массив из 5 элементов, найти в нем два максимальных элемента и их номера.
Пример:
Исходный массив: 4 -5 10 -10 5 максимальные A[3]=10, A[5]=5
[Название файла: taskArray7.pas
]
Поиск в массиве
Рассмотрим сложный пример работы с одномерными массивами:
Пример: Дан массив из 10 чисел. Определить, есть ли в массиве число, введенное пользователем. Если есть – выводить «найдено», если нет – «не найдено».
Сложность задания заключается в том, что выводить слова «найдено» или «не найдено» необходимо один раз.
Для решения поставленной задачи понадобится оператор break
— выход из цикла.
Решение Вариант 1. Цикл for:
PascalABC.NET
:
Cтандартные методы a.IndexOf(x)
и a.LastIndexOf(x)
:
begin var a := new integer[10]; a := arrRandomInteger(5,0,5); //[1,3,5,4,5] print(a.IndexOf(3)) // 1 end.
или метод a.Contains(x)
наравне с x in a
:
begin var a := new integer[10]; a := arrRandomInteger(5,0,5); //[1,3,5,4,5] print(a.Contains(3)); // True print(3 in a)// True end.
Рассмотрим эффективное решение:
Задача: найти в массиве элемент, равный 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]
[Название файла: taskArray8.pas
]
Циклический сдвиг
Пример: сдвинуть элементы массива влево на 1 позицию, первый элемент становится на место последнего.
Решение:
Алгоритм:
A[1]:=A[2]; A[2]:=A[3];… A[N-1]:=A[N];
Программа:
PascalABC.NET
:
Циклический сдвиг влево:
// … var v := a[0]; for var i:=0 to a.Length-2 do a[i] := a[i+1]; a[a.Length-1] := v;
Циклический сдвиг вправо:
// … var v := a[a.Length-1]; for var i:=a.Length-1 downto 1 do a[i] := a[i-1]; a[0] := v;
Задача 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
[Название файла: taskArray9.pas
]
Перестановка элементов в массиве
Рассмотрим, как происходит перестановка или реверс массива.
Пример: переставить элементы массива в обратном порядке
Решение:
Алгоритм:
Псевдокод:
Программа:
PascalABC.NET
:
Перестановка (ревёрс):
Решение 1:
begin var a: array of integer := (1,3,5,7); var n := a.Length; for var i:=0 to n div 2 - 1 do Swap(a[i],a[n-i-1]); End.
Решение 2 (стандартная процедура Reverse()
):
begin var a:=new integer[10]; a:=arrRandomInteger(10); print(a);// [41,81,84,63,12,26,88,25,36,72] Reverse(a); print(a) //[72,36,25,88,26,12,63,84,81,41] end.
Задача 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
[Название файла: taskArray10.pas
]
Выбор элементов и сохранение в другой массив
Пример: найти в массиве элементы, удовлетворяющие некоторому условию (например, отрицательные), и скопировать их в другой массив
Решение:
Решение: подсчитывать количество найденных элементов с помощью счетчика count, очередной элемент устанавливать на место B[count]. Переменой count необходимо присвоить 1.
Вывод массива B:
writeln('Выбранные элементы'); for i:=1 to count-1 do write(B[i], ' ')
PascalABC.NET
:
Процедура SetLength()
:
// ... for var i := 0 to a.length - 1 do if a[i] < 0 then begin b[j] := a[i]; j += 1; end; SetLength(b, j);
Задача Array 11. Заполнить массив случайными числами в интервале [20,100] и записать в другой массив все числа, которые оканчиваются на 0.
Пример:
Исходный массив: 40 57 30 71 84 Заканчиваются на 0: 40 30
[Название файла: taskArray11.pas
]
Сортировка элементов массива
Сортировка методом «Пузырька»
- В таком типе сортировок массив представляется в виде воды, маленькие элементы — пузырьки в воде, которые всплывают наверх (самые легкие).
- При первой итерации цикла элементы массива попарно сравниваются между собой:предпоследний с последним, пред предпоследний с предпоследним и т.д. Если предшествующий элемент оказывается больше последующего, то производится их обмен.
- При второй итерации цикла нет надобности сравнивать последний элемент с предпоследним. Последний элемент уже стоит на своем месте, он самый большой. Значит, число сравнений будет на одно меньше. То же самое касается каждой последующей итерации.
Pascal | PascalABC.NET | ||||
|
|
Задача 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
[Название файла: taskArray12.pas
]
Сортировка методом выбора
- в массиве ищется минимальный элемент и ставится на первое место (меняется местами с A[1]);
- среди оставшихся элементов также производится поиск минимального, который ставится на второе место (меняется местами с A[2]) и т.д.
Pascal | PascalABC.NET | ||||
|
|
Задача 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
[Название файла: taskArray13.pas
]
PascalABC.NET
:
Стандартная процедура sort():
Sort(a); SortByDescending(a);
Быстрая сортировка или quick sort
Алгоритм:
- Выбирается и запоминается средний элемент массива (присвоим X):
- Инициализируем две переменные (будущие индексы массива): L:=1, R:=N (N — количество элементов).
- Увеличиваем L и ищем первый элемент A[L], который больше либо равен X (в итоге он должен находиться справа).
- Уменьшаем R и ищем элемент A[R], который меньше либо равен X (в итоге он должен находиться слева).
- Смотрим, если L<=R, то меняем местами A[L] и A[R], возвращаемся к пункту 3.
Выполнение на Паскале:
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] и отсортировать его с помощью алгоритма быстрой сортировки.
[Название файла: taskArray14.pas
]
Редактировать
В PascalABC.NET рекомендуется использовать динамические массивы. В отличие от статических, они имеют огромное количество методов и операций, просты в создании, заполнении и выводе.
Описание и выделение памяти
Динамический массив описывается так:
begin
var a: array of integer;
end.
Память под динамический массив a выделяется в момент работы программы:
begin
var a: array of integer;
var n := ReadInteger;
a := new integer[n];
end.
Здесь — первое преимущество динамических массивов — в переменной a может храниться массив любого размера, память выделяется в процессе работы программы. Кроме того, выделенная память гарантированно автоматически заполняется нулевыми значениями.
Можно совместить описание и выделение памяти — тип динамического массива выводится автоматически:
begin
var n := ReadInteger;
var a := new integer[n];
end.
Обычно в PascalABC.NET совмещают описание динамического массива, выделение памяти и заполнение значениями. Самый простой способ — заполнить n нулями:
begin
var n := ReadInteger;
var a := |0| * n;
end.
Индексация в динамических массивах и использование статических массивов
Динамические массивы индексируются с нуля — это эффективно. В качестве индексов в динамических массивах могут выступать только целые.
Статические массивы тем не менее иногда удобно использовать — в задачах, где индексы либо символьные, либо по-существу начинаются не с нуля. Например, для подсчёта количества слов на каждую букву может использоваться стаический массив
var a := array ['a'..'z'] of integer;
Заполнение статических массивов — увы — производится в цикле. Кроме того, они не помнят свою длину и передача таких массивов в качестве параметров подпрограмм связана с техническими сложностями 40-летней давности, не нужными начинающим.
Простейшее заполнение
Важную роль играют функции заполнения динамических массивов. Перед заполнением они выделяют для массива память, поэтому в одной строке можно совмещать описание, выделение памяти и заполнение.
Простейшее заполнение — набором значений:
Заполнение диапазоном целых или символьных значений делается с использованием функции Arr:
var a := Arr(1..9);
var b := Arr('a'..'z');
Заполнение определённым значением осуществляется с помощью операции умножения массива на число:
begin
var n := ReadInteger;
var a := |0| * n; // массив из n нулей
end.
Для заполнения можно также использовать функцию ArrFill:
begin
var n := ReadInteger;
var a := ArrFill(n,0); // массив из n нулей
end.
Для заполнения массива случайными значениями следует использовать
begin
var n := ReadInteger;
var a := ArrRandomInteger(n); // по умолчанию значения от 0 до 100
var a1 := ArrRandomInteger(n,1,10); // случайные от 1 до 10
var r := ArrRandomReal(n); // по умолчанию значения от 0 до 10
var r1 := ArrRandomReal(n,2,5); // случайные вещественные от 2 до 5
end.
Не рекомендуется использовать алгоритм для заполнения массива случайными в каждой задаче:
begin
var n := ReadInteger;
var a := new integer[n];
for var i:=0 to n-1 do
a[i] := Random(0,100);
end.
Повторять этот текст в каждой задаче — странно. Для этого есть стандартные функции.
Ввод и вывод элементов массива
Для ввода элементов массива базовых типов используются функции
begin
var n := ReadInteger;
var a := ReadArrInteger(n);
var r := ReadArrReal(n);
var s := ReadArrString(n);
// ...
end.
Стандартная процедура вывода Write или Print выводит значения в массиве в квадратных скобках черезх запятую:
begin
var a := Arr(1..9);
Print(a); // [1,2,3,4,5,6,7,8,9]
end.
Однако лучше всего для вывода воспользоваться методом Print, выводящим все значения в массиве через пробел:
begin
var a := Arr(1..9);
a.Print; // 1 2 3 4 5 6 7 8 9
end.
Не рекомендуется вводить и выводить элементы массива в цикле
begin
var n := ReadInteger;
var a := new integer[n];
for var i:=0 to n-1 do
a[i] := ReadInteger;
end.
Повторять этот текст в каждой задаче — странно. Для этого есть стандартные функции.
Циклы по массиву
Для обработки элементов массива используются следующие циклы:
- Цикл for по индексам (если требуется менять элементв или нужна информация об индексах)
for var i:=0 to a.Length-1 do a[i] *= 2;
- Цикл foreach по элементам (если индексы не видны и мы не меняем массив)
var sum := 0; foreach var x in a do sum += x;
- Цикл foreach по индексам
foreach var i in a.Indices do a[i] += 2;
- Цикл foreach по диапазону индексов
var (K,L) := ReadInteger2; foreach var i in K..L do a[i] := 777;
Пример. Найти количество чётных элементов, стоящих на чётных местах
begin
var a := ArrRandomInteger(10);
a.Println;
var count := 0;
foreach var i in a.Indices do
if i.IsEven and a[i].IsEven then
count += 1;
Print(count);
end.
Методы массива
Массивы содержат большое количество стандартных методов:
a.Length - длина массива
a.Min - минимальный элемент в массиве
a.Max - максимальный элемент в массиве
a.IndexMin - индекс первого минимального элемента в массиве
a.IndexMax - индекс первого максимального элемента в массиве
a.Sum - сумма элементов в числовом массиве
a.Product - произведение элементов в числовом массиве
a.Average - среднее элементов в числовом массиве
a.First - первый элемент в массиве
a.Last - последний элемент в массиве
a.IndexOf(x) - индекс первого значения x или -1 если не найдено
a.Replace(x,y) - заменить в массиве все значения x на y
Кроме того, доступны процедуры
Sort(a) - сортировка элементов по возрастанию
SortDescending(a) - сортировка элементов по убыванию
Reverse(a) - инвертирование элементов массива
Методика. Обращаем внимание, что в методических целях естественно рассказывать, как эти алгоритмы устроены “внутри”.
Но потом следует пользоваться стандартными алгоритмами, а не заставлять учеников во всех задачах использовать рукописные сортировки или рукописный поиск минимума. Например, рекомендуется показать, как накопить сумму элементов массива:
begin
var a := ArrRandomInteger(10);
a.Println;
var sum := 0;
foreach var x in a do
sum += x;
Print(sum);
end.
Здесь следует обратить внимание, что этот алгоритм может быть легко модифицирован в алгоритм нахождения суммы элементов по условию: например, всех чётных элементов:
begin
var a := ArrRandomInteger(10);
a.Println;
var sum := 0;
foreach var x in a do
if x.IsEven then
sum += x;
Print(sum);
end.
Отметим, что заполнение случайными и вывод — это технические части программы, которые делаются в PascalABC.NET в одну строку, позволяя концентрироваться на алгоритме.
Если условие надо накладывать на индексы, то в этом случае (и только в этом случае) следует использовать цикл for по индексам:
begin
var a := ArrRandomInteger(10);
a.Println;
var sum := 0;
for var i:=0 to a.Length-1 do
if i.IsEven then
sum += a[i];
Print(sum);
end.
Для нахождения суммы без условия необходимо использовать стандартный метод a.Sum:
begin
var a := ArrRandomInteger(10);
a.Println;
Print(a.Sum);
end.
Отметим также, что для поиска суммы по условию также имеется короткая однострочная запись. Она требует использование стандартного метода Where с параметром, являющимся лямбда-выражением. Лямбда-выражения мы будем рассматривать далее:
begin
var a := ArrRandomInteger(10);
a.Println;
Print(a.Where(x -> x.IsEven).Sum);
end.
Методика. Поскольку данная запись использована здесь впервые, обращаем внимание на её высокую универсальность: алгоритмы фильтрации и поиска суммы не слиты в один алгоритм, а используются порознь один за другим, что позволяет:
- Лучше читать код (потому что он записан компактно и методами с понятными и очевидными названиями)
- Лучше модифицировать код
- Решать более сложные и более прикладные задачи за одно и то же время урока
Далее лямбда-выражения объясняются подробно и тщательно и используются повсеместно.
Операции с массивами
x in a - возвращает true если значение x содержится в a
a1 + a2 - возвращает массив, образованный слиянием массивов a1 и a2
a1 * n - возвращает массив, состоящий из n раз повторенных значений массива a
Изменение размера динамического массива
Если в процессе работы программы требуется чтобы динамический массив менял свой размер, то следует … пользоваться типом List!
Это — динамический массив с возможностью эффективного измненения размера и рядом дополнительных методов. Основным является методы Add — добавить в конец:
begin
var l := new List<integer>;
l.Add(1);
l.Add(3);
l.Add(5);
l.Print
end.
Для первоначального заполнения списков List используется короткая фунеция Lst:
begin
var l := Lst(1,3,5);
l.Print
end.
При необходимости список List можно преобразовать к динамическому массиву, вызвав метод .ToArray:
begin
var l := Lst(1,3,5);
var a := l.ToArray;
end.
Большинство методов, которые имеются в массивах, есть и в списках List. Поэтому выбор типа List или array of для контейнера при решении задач определяется тем, будет ли данный контейнер расширяться по ходу работы программы.
Массив — это множество величин, имеющих одно и то же имя и номер по порядку.
В математике подобное называется последовательностью, можно сказать, что последовательность — это одномерный массив. В математической последовательности каждый следующий элемент записывается по определённому правилу (формуле), в одномерном массиве могут быть произвольные числа (либо символы, либо слова).
Размер массива — это количество элементов в массиве.
Размерность массива определяется количеством входящих в него индексов.
Массивы бывают: одномерные, двумерные, многомерные.
Индекс определяет положение элемента в массиве (нумерация начинается с (1)).
Рис. (1). Индекс и значение массива
Примеры массивов
Одномерный массив
Двумерный массив
(15) |
(0) |
(70) |
(-12) |
(29) |
(30) |
(123) |
(48) |
(11) |
Типы массивов
Числовой: А([1,5, -4,25]).
Строковый: {«Лето», «Зима», «Осень»}.
Слово или предложение тоже можно считать массивом, так как буквы можно пронумеровать.
В Pascal массив записывается служебным словом array в разделе var.
Целочисленный массив
А:array[(1)..N] of integer.
Вещественный массив
А:array[(1)..N] of real.
(1)..N — это индексы от (1) до N.
План работы с массивом
1. Описать массив в разделе var;
2. заполнить массив;
3. обработать элементы массива;
4. вывести результаты обработки.
Способы заполнения массива
С клавиатуры:
Рис. (2). Ввод массива с клавиатуры
Ввод с помощью генератора случайных чисел:
Рис. (3). Ввод с помощью случайных чисел
Ввод с помощью формул:
Рис. (4). Ввод с помощью формул
В двумерном массиве всё аналогично, только добавляется ещё один индекс:
A:array[(1)..N, (1)..M] of integer.
Далее будем рассматривать одномерные массивы.
Источники:
Рис. 1. Индекс и значение массива. © ЯКласс.
Рис. 2. Ввод с клавиатуры. © ЯКласс.
Рис. 3. Ввод с помощью случайных чисел. © ЯКласс.
Рис. 4. Ввод с помощью формул. © ЯКласс.
Массивы
СОДЕРЖАНИЕ:
- Тип
- Определение массива
- Одномерные массивы: описание, ввод и вывод, обработка массива
- Двумерные массивы: описание, ввод и вывод, обработка массива
- Действия над массивом как единым целым
Тип
Тип в программировании – это множество, для которого оговорен некоторый набор операций над элементами – значениями, которые могут принимать переменные этого типа. Существуют четыре стандартных типа Паскаля: типы Real, Integer (это числовые множества), тип Char (множество символов), тип Boolean. Однако в Паскале имеются средства, позволяющие определять, исходя из имеющихся типов, новые типы. Различают следующие структурированные типы данных:
- массив;
- запись;
- строка;
- множество.
В данной лекции мы подробно рассмотрим массивы.
Определение массива
Массивы, как и циклы, — величайшее изобретение программирующего человечества. Массивы приходят на помощь тогда, когда приходится иметь дело с наборами однотипных и однородных данных (например, координаты точки в двумерном, трехмерном пространстве).
Массив – это упорядоченная последовательность однотипных элементов определенной длины, имеющая общее имя. Номер элемента в последовательности называется индексом. Количество элементов в массиве не может быть изменено в процессе выполнения программы. Элементы массива размещаются в памяти последовательно и нумеруются от 1 до n, где n – их количество в массиве. К каждому элементу массива имеется прямой доступ. Это означает, что для того чтобы обратиться к какому-либо элементу массива, нет нужды перебирать все его предыдущие элементы, достаточно указать номер этого элемента.
Массив имеет следующие характеристики:
- имя массива записывается по тем же правилам, что и имена переменных. Имя массива задает имя каждому элементу массива: каждый элемент массива обозначается этим именем и индексом, который определяет номер (место) этого элемента в массиве;
- базовый тип – общий тип элементов массива;
- размерность (ранг) — это количество элементов в массиве;
- диапазон – количество допустимых значений каждого индекса;
- форма – совокупность размерности и диапазонов.
Массивы могут быть одномерными и многомерными. Но мы ограничимся рассмотрением только одномерных и двумерных массивов.
Одномерные массивы – массивы, в которых элементы пронумерованы последовательно по порядку: первый элемент, второй, третий и т.д. Для обозначения элементов одномерного массива используется один индекс.
Двумерные массивы – массивы, в которых данные условно организованы в виде таблицы (матрицы), где положение каждого элемента определяется номером строки т номером столбца. Для обозначения элементов двумерного массива используются два индекса: первый индекс для обозначения номера строки, второй индекс для обозначения номера столбца.
По аналогии с математикой одномерные числовые массивы часто называют векторами, а двумерные – матрицами.
Значения индексов можно задать непосредственно числом (прямая адресация) – A(1), A(4,2) или косвенно, указав в индексе идентификатор переменной, которая позволит вычислить индекс (косвенная адресация) – A(i), A(i, j+2).
При работе с массивами в программе они должны быть объявлены (описаны), т.е. указаны имя массива, тип элементов массива, его размерность.
При обращении к элементу массива, значение индекса которого выходит за допустимые границы, появляется сообщение об ошибке.
Одномерные массивы: описание, ввод и вывод, обработка массива
Описать массив можно двумя способами.
- Первый способ.
В разделе описания переменных мы можем описать массив следующим образом:
Var A: Array[n1..n2] Of <базовый тип>;
Здесь A – название массива;
Array – служебное слово;
n1,n2 – соответственно номер первого и последнего элемента массива;
<базовый тип> – любой из уже изученных типов.
Количество элементов массива будет равно (n2- n1+1).
Например, запись
Var Massiv: Array[1.. 20] Of Real;
означает, что полученный массив будет состоять из 20 вещественных чисел, первое из которых будет иметь номер 1, последнее – 20. Наш массив будет иметь имя Massiv.
- Второй способ.
Описание массива заключается в создании нового оригинального типа. Для того, чтобы программист мог создавать свои новы типы в Паскале существует раздел описания типов Type. Этот раздел находится между разделом описания констант и разделом описания переменных.
Type <Имя типа> = Array[n1..n2] Of <базовый тип>;
После этого в разделе описания переменных мы можем описать массив, который имеет созданный нами тип, например,
Type Mas= Array[10..19] Of Integer; Var B: Mas;
В данном случае мы сначала описали новый тип Mas – массив из десяти целых чисел с номерами от 10 до 19, затем описали переменную B типа Mas.
В большинстве случаев для обработки массивов используются циклы. В цикле имеется возможность поочередно перебрать все элементы массива.
Для ввода массива с клавиатуры может быть использован цикл следующего вида: пусть имеется массив с именем A, состоящий из n элементов, тогда
For i:=1 To n Do Read (A[i]);
В этом случае пользователь вводит через пробел n элементов массива. Для ввода элементов массива с новой строки используется оператор ReadLn. Ввод данных в массив происходит следующим образом: сначала значение счетчика цикла равно 1; выполняется операция Read (A[1]); поле чего счетчик цикла становится равным 2; выполняется операция Read (A[2])… и т.д. до значения i=n включительно.
Для вывода массива на экран используется следующий цикл:
For i:=1 To n Do Write (A[i]); WriteLn;
В данном случае на экран в одну строку будут выведены все n элементов массива, после чего курсор переместится на одну строку вниз.
Как уже было сказано выше, для обработки массивов используются циклы.
Пример: пусть имеется массив M, состоящий из n элементов с номерами от 1 до n. Найти сумму элементов массива, вывести ее на экран.
Sum := 0; For i:=1 To n Do Sum := Sum + M[i]; WriteLn(‘Сумма элементов массива =’, Sum);
Двумерные массивы: описание, ввод и вывод, обработка массива
В математике очень распространено такое понятие как матрица. Матрица – это таблица из коэффициентов A=(aij). Элементы матрицы образуют столбцы и строки. Первый индекс ( i ) указывает номер строки, второй ( j ) – номер столбца, на пересечении которых находится элемент aij.
Определим некоторые действия над матрицами:
- Две матрицы равны, если равны все элементы, стоящие в одинаковых местах.
- Суммой двух матриц A=(aij) и B=(bij) называется матрица C=(cij), где cij = aij + bij
- Произведением матрицы A=(aij) на число L называют матрицу, у которой каждый элемент равен произведению соответствующего элемента матрицы на число L.
В программировании матрицы удобно представлять с помощью двумерных массивов.
Описание двумерных массивов отличается от описания одномерных массивов только тем, что мы указываем начальное и конечное значение для обоих индексов:
Var A: Array[n1..n2, m1..m2] Of <базовый тип>;
Здесь n1,n2 – начальное и конечное значения первого индекса;
m1,m2 – начальное и конечное значения второго индекса.
Многомерный массив в Паскале трактуется как одномерный массив, тип элементов которого также является массивом (массив массивов). Поэтому подобным образом можно описать любые .n-мерные массивы: для этого необходимо указать через запятую начальные и конечные значения для каждого индекса. Например, описание трехмерного массива:
Var A: Array[1.. 10, 1..20, 1..30] Of Integer;
Это массив, состоящий из 10*20*30=6000 целых чисел и занимающий в памяти 6000*2=12000 байт. В Паскале нет ограничения сверху на размерность массива. Однако в каждой конкретной реализации Паскаля ограничивается объем памяти, выделяемый под массивы. В Турбо Паскале это ограничение составляет 64 Кбайта.
В Паскале не допускается употребление динамических массивов, т.е. таких, размер которых определяется в процессе выполнения. Изменение размеров массива происходит через изменение в тексте программы и повторную компиляцию. Для упрощения таких изменений удобно определять индексные параметры в разделе констант:
Const Imax = 10; Jmax = 20; Var Mas: Array[1.. Imax, 1..Jmax] Of Integer;
Теперь для изменения размеров массива Mas и всех операторов программы, связанных с этими размерами, достаточно отредактировать только одну строку в программе – раздел констант.
Для ввода и вывода двумерных массивов используются два вложенных цикла.
Ввод массива:
For i:=1 To n Do For j:=1 To m Do Read (A[i,j]);
Вывод массива:
For i:=1 To n Do Begin For j:=1 To m Do Write (A[i,j]:3); WriteLn; End;
Для обработки двумерных массивов также используются два вложенных цикла.
Пример: найти произведение массива A на число L.
For i:=1 To n Do For j:=1 To m Do A[i,j]:= A[i,j] * L;
Обр-ку дв. массива см. Рапаков стр.126!
Действия над массивом как единым целым
Такие действия допустимы лишь в двух случаях:
- присваивание значений одного массива другому;
- операции отношения «равно», «не равно».
В обоих случаях массивы должны иметь одинаковые типы (тип индексов и тип элементов).
Пример:
Var P, Q: Array[1.. 5, 1..10] Of Real;
При выполнении операции присваивания P := Q все элементы массива P станут равны соответствующим элементам массива Q.
Как уже отмечалось, в многомерных массивах переменная с индексом может обозначать целый массив. Например,
Год | Месяц | |||||||||||
1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | |
1981 | -23 | -17 | -8 | 7 | 14 | 18 | 25 | 19 | 12 | 5 | -4 | -19 |
1982 | -17 | -10 | -3 | 6 | 8 | 13 | 28 | 24 | 6 | 2 | -13 | -20 |
… | … | … | … | … | … | … | … | … | … | … | … | … |
1990 | -10 | -15 | -4 | 9 | 13 | 17 | 23 | 20 | 10 | 8 | -14 | -20 |
если в таблице H требуется, чтобы данные за 1989г. были такими же, как и за 1981г. (девятой строке присвоить значение первой строки), то это можно делать так:
H[1989] := H[1981]
А если нужно поменять местами значения этих строк, то это делается через третью переменную того же типа:
P := H[1989]; H[1989] := H[1981]; H[1989] := P;
где P описана так:
Var P: Array[1.. 12] Of Real;
Контрольные вопросы
- Что такое массив?
- Какой массив называют одномерным?
- Какой массив называют двумерным?
- Как описывается массив?
- Перечислите характеристики массивов.
- Какие типы адресации существуют при обращении к элементам массива?