Множества

Begin

End.

Begin

Begin

Begin

Begin

End.

Begin

Begin

Begin

................

.............

End.

Begin

Begin

.........

.............

End.

Begin

Begin

Begin

End.

Begin

Begin

7 8 9 9 6 3

1 2 3 7 4 1

End.

Begin

Begin

End.

Begin

End.

Begin

End.

Begin

Begin

End.

Begin

Begin

End.

Begin

Begin

End.

Begin

Begin

End.

Begin

Then

Begin

End.

Begin

Begin

End.

Begin

End.

Begin

End.

Begin

Begin

Begin

End.

Begin

Begin

End.

Begin

Begin

Begin

Begin

Begin

Begin

Begin

Begin

Begin

End.

Begin

End.

Begin

Begin

оператор;

оператор;

оператор;

End;

Если в заголовке цикла используется служебное слово To (к), то шаг изменения параметра цикла равен +1.

Если в заголовке цикла используется служебное слово DownTo (уменьшаядо), то шаг изменения параметра цикла равен -1.

Внимание! После слова Do точка с запятой никогда не ставится!

Пример: определить сумму s натуральных чисел от 1 до 100.

Схема алгоритма: Программа:

Program Gauss;

Uses CRT;

Var n, s: Word;

ClrScr;

s:= 0;

For n:=1 To 100 Do

s:= s + n;

WriteLn(‘Сумма равна ’, s);

ReadLn;

Эту же задачу можно решить, суммируя числа справа налево, то есть от 100 до 1:

Program Gauss;

Uses CRT;

Var i, s: Word;

ClrScr;

s:= 0;

For i:=100 DownTo 1 Do

s:= s + i;

WriteLn(‘Сумма равна ’, s);

ReadLn;

Построение операторов цикла For подчиняется следующим правилам:

1. начальное и конечное значения параметра цикла можно задавать константами (как в примере), заранее определенными переменными или выражениями,

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

m:= 1;

n:= 10;

For j:= m To n Do

a[j]:= j + 10;

m:= m + 1; ошибка!

n:= n + 1; ошибка!

End;

Выходим из этого цикла со значением параметра цикла j, равным 10.

Нежелательно внутри области цикла самому изменять значение параметра цикла - это может привести к появлению бесконечных циклов:

s:= 0;

n:= 10;

For k:= 1 To n Do

k:= k + 1;

s:= s + k;

End;

Эта программа вычисляет сумму s четных целых чисел от 2 до 10, равную 30. При этом конечное значение параметра цикла k равно 10.

Зададим n = 11:

s:= 0;

n:= 11;

For k:= 1 To n Do

k:= k + 1;

s:= s + k;

End;

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

Если же цикл не выполняется ни разу, то параметр цикла сбрасывается на ноль:

s:= 0;

p:= 1;

For k:= 10 To 1 Do

p:= p * k;

s:= s + k;

End;

Выходим из этого цикла со значением k, равным 0.

3. допускается использование цикла в цикле, при этом циклы должны иметь различные параметры цикла:

For i:= 1 To n Do эти циклы выводят элементы массива A_nm

Begin в виде матрицы, построчно

For j:= 1 To m Do

Write(a[i,j]:5);

WriteLn;

End;

4. после окончания работы цикла значение параметра цикла сохраняется,

5. в область цикла можно входить только через заголовок цикла For;
неразрешается переход с помощью операторов If и GoTo, расположенных вне данного цикла, на операторы в области цикла:

If (p Mod s > 10)

Then GoTo 5; ошибка – переход в тело цикла, минуя его заголовок

For i:= 1 To 10 Do

s:= s + i;

5: p:= p + i;

End;

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

For i:= 1 To 100 Do

If (a[i]=0)

Then Goto 2; переход внутри тела цикла

a[i]:= 1 / a[i];

2:

End;

7. с помощью оператора Break можно досрочно выйти из цикла:

For i:= 1 To 100 Do

k:= i;

If (a[i] < 0)

Then Break; поиск первого отрицательного элемента в векторе

End;

8. оператор Continue позволяет досрочно перейти к следующей итерации цикла:

For i:= 1 To 100 Do

If (a[i] = 0)

Then Continue; если ноль, то на следующую итерацию

a[i]:= 1 / a[i];

End;

Основное назначение циклов с параметром – обработка массивов, причем параметр цикла отождествляется с индексом (номером) элемента массива.

Примеры:

1. Задать элементы целочисленного вектора vector_n случайными числами, лежащими в диапазоне от vect_min до vect_max.

Для решения этой задачи используется стандартная функция – генератор случайных чисел Random(k). При каждом обращении к этой функции она вырабатывает целое случайное число, лежащее в диапазоне от 0 до k - 1.

Program Primer_1;

Uses WinCrt;

Const n = 10; задание исходных данных в виде именованных констант

vect_min = -10;

vect_max = 20;

Var i: Word; параметр цикла

Vector: Array [1..n] Of Integer; описание вектора с использованием константы n

ClrScr; очистка экрана

Randomize; запуск генератора случайных чисел

For i:=1 To n Do заполнение вектора случайными числами

Vector[i]:=Random(vect_max – vect_min + 1) + vect_min;

For i:=1 To n Do форматный вывод вектора на экран в одну строку

Write(Vector[i]:5);

WriteLn; переход на новую строку на экране

ReadLn; задержка картинки на экране до нажатия на ENTER

2. Задать элементы целочисленного массива massiv_nm случайными числами, лежащими в диапазоне от mass_min до mass_max. Полученный массив вывести на экран построчно.

Program Primer_2;

Uses WinCrt;

Const n = 5;

m = 8;

mass_min = -50;

mass_max = 50;

Var i, j: Word; параметры циклов

Massiv: Array [1..n, 1..m] Of Integer; описание массива с использованием констант n и m

ClrScr;

Randomize; запуск генератора случайных чисел

For i:=1 To n Do заполнение массива случайными числами

For j:=1 To m Do в заданном диапазоне

Massiv[i, j]:=Random(mass_max – mass_min + 1) + mass_min;

For i:=1 To n Do форматный вывод массива на экран построчно

For j:=1 To m Do

Write(Massiv[i, j]:5);

WriteLn; переход на новую строку на экране

End;

WriteLn;

ReadLn;

3. Задать элементы целочисленного массива massiv_nm в виде чисел от 1 до n*m. Полученный массив вывести на экран построчно:

Program Primer_3;

Uses WinCrt;

Const n = 3;

m = 5;

Var i, j, k: Word;

Massiv: Array [1..n, 1..m] Of Word;

ClrScr;

k:= 0; рабочая переменная для задания элементов массива

For i:=1 To n Do заполнение массива

For j:=1 To m Do

k:= k + 1;

Massiv[i, j]:= k;

End;

For i:=1 To n Do форматный вывод массива на экран построчно

For j:=1 To m Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

ReadLn;

4. Задать элементы целочисленного вектора vector_n случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран в одну строку. Определить индекс i_max и значение vector_max максимального элемента вектора.

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

Program Primer_4;

Uses WinCrt;

Const n = 10; задание исходных данных в виде именованных констант

vect_min = -10;

vect_max = 10;

Var i, i_max, vector_max: Integer;

Vector: Array [1..n] Of Integer;

ClrScr;

Randomize;

For i:=1 To n Do

Vector[i]:=Random(vect_max – vect_min + 1) + vect_min;

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

Vector_max:= Vector[1]; пока максимальный элемент – первый

i_max:= 1; элемент вектора

For i:=2 To n Do поиск начинаем со второго элемента!

If (Vector[i] > Vector_max) Then если очередной элемент больше

Begin текущего максимального,

Vector_max:= Vector[i]; то максимальным элементом

i_max:= i; становится очередной элемент вектора

End;

WriteLn(‘Vector_max=’, Vector_max);

WriteLn(‘i_max=’, i_max);

ReadLn;

5. Задать элементы целочисленного вектора vector_n случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран. Определить сумму S элементов вектора.

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

Program Primer_5;

Uses WinCrt;

Const n = 10; задание исходных данных в виде именованных констант

vect_min = -50;

vect_max = 50;

Var i, s: Integer;

Vector: Array [1..n] Of Integer;

ClrScr;

Randomize;

For i:=1 To n Do

Vector[i]:=Random(vect_max – vect_min + 1) + vect_min;

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

S:= 0; начальная сумма равна нулю!

For i:=1 To n Do добавляем в сумму очередной

s:= s + Vector[i]; элемент вектора

WriteLn(‘s=’, s);

ReadLn;

6. Задать элементы целочисленного вектора vector_n случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран. Перевернуть вектор: поменять местами первый и последний элементы, второй и предпоследний, и так далее (поплавок):

Program Primer_6;

Uses WinCrt;

Const n = 10;

vect_min = -50;

vect_max = 50;

Var i, k, m: Integer;

Vector: Array [1..n] Of Integer;

ClrScr;

Randomize;

For i:=1 To n Do

Vector[i]:=Random(vect_max – vect_min + 1) + vect_min;

WriteLn(‘Исходный вектор:’);

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

m:= n Div 2; средина вектора

For i:=1 To m Do идем до средины вектора

k:= Vector[i];

Vector[i]:= Vector[n – i + 1];

Vector[n – i + 1]:= k;

End;

WriteLn;

WriteLn(‘Полученный вектор:’);

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

ReadLn;

7. Задать элементы целочисленного вектора vector_n случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран. Определить сумму S элементов вектора, лежащих в диапазоне от min до max, и количество count этих элементов.

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

Program Primer_7;

Uses WinCrt;

Const n = 10; задание исходных данных в виде именованных констант

vect_min = -50;

vect_max = 50;

min = -10;

max = 10;

Var i, s, count: Integer;

Vector: Array [1..n] Of Integer;

ClrScr;

Randomize;

For i:=1 To n Do

Vector[i]:=Random(vect_max – vect_min + 1) + vect_min;

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

count:= 0;

s:= 0; начальная сумма равна нулю!

For i:=1 To n Do

If (Vector[i] >= min) And (Vector[i] <= max) проверка условия

s:= s + Vector[i];

count:= count + 1;

End;

WriteLn(‘s=’, s);

WriteLn(‘count=’, count);

ReadLn;

8. Задать элементы целочисленного вектора vector_n случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран. Поменять местами максимальный max и минимальный min элементы вектора.

Перед началом поиска максимального и минимального элементов за таковые принимается первый элемент вектора. Для обмена местами этих элементов необходимо определить их номера (индексы) i_min и i_max:

Program Primer_8;

Uses WinCrt;

Const n = 10; задание исходных данных

vect_min = -50;

vect_max = 50;

Var i, k, min, max, i_min, i_max: Integer;

Vector: Array [1..n] Of Integer;

ClrScr;

Randomize;

For i:=1 To n Do

Vector[i]:=Random(vect_max – vect_min + 1) + vect_min;

WriteLn(‘Исходный вектор:’);

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

min:= Vector[1]; начальные значения минимального

max:= Vector[1]; и максимального элементов массива

i_min:= 1; индексы этих элементов

i_max:= 1;

For i:=2 To n Do начинаем просмотр со второго элемента

If (Vector[i] < min) Then если очередной элемент вектора

Begin меньше минимального,

min:= Vector[i]; то за минимальный принимаем

i_min:= i; этот очередной элемент

End; и запоминам его индекс

If (Vector[i] > max) Then если очередной элемент вектора

Begin больше максимального,

max:= Vector[i]; то за максимальный принимаем

i_max:= i; этот очередной элемент

End; и запоминам его индекс

End;

WriteLn;

WriteLn(‘Минимальный элемент=’, Vector[i_min]);

WriteLn(‘Его индекс=’, i_min);

WriteLn(‘Максимальный элемент=’, Vector[i_max]);

WriteLn(‘Его индекс=’, i_max);

k:= Vector[i_min]; меняем их местами через

Vector[i_min]:= Vector[i_max]; третью переменную

Vector[i_max]:= k;

WriteLn;

WriteLn(‘Полученный вектор:’);

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

ReadLn;

9. Задать элементы целочисленного вектора vector_n случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран. Поменять местами первый отрицательный и последний положительный элементы массива. Предусмотреть случай, когда элементы массива имеют один знак – только отрицательные или только положительные.

Обозначим их индексы как i_otr и i_pol. Перед началом поиска сбросим их на ноль. Если после поиска какой-нибудь из них останется равным нулю, то в векторе – элементы одного знака:

Program Primer_9;

Uses WinCrt;

Const n = 10; задание исходных данных

vect_min = -50;

vect_max = 50;

Var i, k, i_otr, i_pol: Integer;

Vector: Array [1..n] Of Integer;

ClrScr;

Randomize;

For i:=1 To n Do

Vector[i]:=Random(vect_max – vect_min + 1) + vect_min;

WriteLn(‘Исходный вектор:’);

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

i_otr:= 0;

i_pol:= 0;

For i:=1 To n Do

If (Vector[i] < 0) Then если очередной элемент вектора

Begin меньше нуля,

i_otr:= i; то запоминаем его индекс

Break; и выходим из цикла

End;

For i:=1 To n Do

If (Vector[i] > 0) если очередной элемент вектора

Then i_pol:= i; больше нуля, то запоминаем его индекс

If (i_otr = 0)

Then WriteLn(‘В векторе только положительные элементы’);

If (i_pol = 0)

Then WriteLn(‘В векторе только отрицательные элементы’);

If (i_otr > 0) And (i_pol > 0) Then

WriteLn;

WriteLn(‘Первый отрицательный элемент=’, Vector[i_otr]);

WriteLn(‘Его индекс=’, i_otr);

WriteLn(‘Последний положительный элемент=’, Vector[i_pol]);

WriteLn(‘Его индекс=’, i_pol);

k:= Vector[i_otr]; меняем их местами через

Vector[i_otr]:= Vector[i_pol]; третью переменную

Vector[i_pol]:= k;

WriteLn;

WriteLn(‘Полученный вектор:’);

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

End;

ReadLn;

10. Задать элементы целочисленного вектора vector_n случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран. Сдвинуть элементы вектора вправо на один шаг, причем последний элемент должен встать на первое место.

Для решения этой задачи запомним последний элемент вектора на переменной posl, сдвинем все элементы на шаг вправо, начиная с предпоследнего, а затем значение переменной posl поместим в первый элемент массива:

Program Primer_10;

Uses WinCrt;

Const n = 10; задание исходных данных

vect_min = -50;

vect_max = 50;

Var i, k, posl: Integer;

Vector: Array [1..n] Of Integer;

ClrScr;

Randomize;

For i:=1 To n Do

Vector[i]:=Random(vect_max – vect_min + 1) + vect_min;

WriteLn(‘Исходный вектор:’);

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

posl:= Vector[n]; запоминаем последний элемент вектора

For i:= n DownTo 2 Do

k:= Vector[i]; сдвигаем элементы вектора

Vector[i]:= Vector[i-1]; на один шаг вправо

Vector[i-1]:= k;

End;

Vector[1]:= posl; вставляем последний элемент

на первое место

WriteLn;

WriteLn(‘Полученный вектор:’);

For i:=1 To n Do

Write(Vector[i]:5);

WriteLn;

ReadLn;

11. Задать элементы целочисленного вектора vector_k случайными числами, лежащими в диапазоне от vect_min до vect_max. Вывести полученный вектор на экран. Разместить элементы вектора в массиве massiv_nm построчно (n*m = k):

Program Primer_11;

Uses WinCrt;

Const k = 12; задание исходных данных в виде именованных констант

vect_min = -50;

vect_max = 50;

n = 3;

m = 4;

Var i, j, t: Integer;

Vector: Array [1..k] Of Integer;

Massiv: Array [1..n, 1..m] Of Integer;

ClrScr;

Randomize;

For i:=1 To k Do

Vector[i]:=Random(vect_max – vect_min + 1) + vect_min;

WriteLn(‘Исходный вектор’);

WriteLn;

For i:=1 To k Do

Write(Vector[i]:5);

WriteLn;

t:= 0; номер очередного элемента вектора

For i:=1 To n Do

For j:=1 To m Do

t:= t + 1;

Massiv[i, j]:= Vector[t];

End;

WriteLn(‘Полученный массив’);

WriteLn;

For i:=1 To n Do

Begin

For j:=1 To m Do

Write(Massiv[i, j]:5);

WriteLn;

End;

ReadLn;

12. Задать элементы целочисленного квадратного массива massiv_nm случайными числами, лежащими в диапазоне от mass_min до mass_max. Исходный массив вывести на экран построчно. Разместить элементы массива в векторе Vector_k построчно (k = n*m):

Program Primer_12;

Uses WinCrt;

Const n = 5;

m = 7;

k = n * m;

mass_min = -50;

mass_max = 50;

Var i, j, t: Integer;

Vector: Array [1..k] Of Integer;

Massiv: Array [1..n, 1..m] Of Integer;

ClrScr;

Randomize;

For i:=1 To n Do

For j:=1 To n Do

Massiv[i, j]:= Random(mass_max – mass_min + 1) + mass_min;

WriteLn;

WriteLn(‘Исходный массив:’);

For i:=1 To n Do

Begin

For j:=1 To m Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

t:= 0;

For i:=1 To n Do

For j:=1 To m Do

Begin

t:= t + 1;

Vector[t]:= Massiv[i,j];

End;

WriteLn(‘Полученный вектор’);

WriteLn;

For i:=1 To k Do

Write(Vector[i]:5);

WriteLn;

ReadLn;

13. Задать элементы целочисленного квадратного массива massiv_nn случайными числами, лежащими в диапазоне от mass_min до mass_max. Исходный массив вывести на экран построчно. Транспонировать массив, заменив его строки соответствующими столбцами: первую строку – на первый столбец, вторую – на второй, и так далее. Транспонированный массив вывести на экран построчно:

Program Primer_13;

Uses WinCrt;

Const n = 5;

mass_min = -50;

mass_max = 50;

Var i, j, k: Integer;

Massiv: Array [1..n, 1..n] Of Integer; описание массива с использованием константы n

ClrScr;

Randomize;

For i:=1 To n Do

For j:=1 To n Do

Massiv[i, j]:=Random(mass_max – mass_min + 1) + mass_min;

WriteLn(‘Исходный массив:’);

For i:=1 To n Do

Begin

For j:=1 To n Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

For i:=1 To n Do строки начинаем с первой

For j:=i To n Do столбцы начинаем с главной диагонали

Begin

k:= Massiv[i,j]; транспонирование массива с использованием

Massiv[i,j]:= Massiv[j,i]; алгоритма циклического обмена

Massiv[j,i]:= k; значениями двух переменных через третью

End;

WriteLn(‘Транспонированный массив:’);

For i:=1 To n Do

Begin

For j:=1 To n Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

ReadLn;

14. Задать элементы целочисленного массива massiv_nm случайными числами, лежащими в диапазоне от mass_min до mass_max. Исходный массив вывести на экран построчно. Сдвинуть столбцы массива на шаг вправо, причем последний столбец должен встать на место первого.

Решение задачи заключается в запоминании элементов последнего столбца и последующем сдвиге элементов каждой строки на шаг вправо. Запомненный элемент становится на первое место в текущей строке:

Program Primer_14;

Uses WinCrt;

Const n = 5;

m = 6;

mass_min = -50;

mass_max = 50;

Var i, j, k, posl: Integer;

Massiv: Array [1..n, 1..m] Of Integer;

ClrScr;

Randomize;

For i:=1 To n Do

For j:=1 To m Do

Massiv[i, j]:= Random(mass_max – mass_min + 1) + mass_min;

WriteLn(‘Исходный массив:’);

For i:=1 To n Do

Begin

For j:=1 To m Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

For i:=1 To n Do перебираем строки массива

posl:= Massiv[i, m]; запоминаем последний элемент строки

For j:=m DownTo 2 Do

Begin

k:= Massiv[i,j]; сдвигаем элементы строки на шаг Massiv[i,j]:= Massiv[i, j-1]; вправо

Massiv[i, j-1]:= k;

End;

Massiv[i,1]:= posl; вставляем последний элемент
на первое место в строке

End; конец цикла по строкам

WriteLn(‘Полученный массив:’);

For i:=1 To n Do

Begin

For j:=1 To m Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

ReadLn;

15. Задать элементы целочисленного квадратного массива massiv_nn случайными числами, лежащими в диапазоне от mass_min до mass_max. Исходный массив вывести на экран построчно. Повернуть массив на 90⁰ по часовой стрелке, например:

4 5 6 => 8 5 2

Для выполнения этой операции массив сначала транспонируют, а затем применяют для каждой строки поплавок – переворачивают строки:

Program Primer_15;

Uses WinCrt;

Const n = 5;

mass_min = -50;

mass_max = 50;

Var i, j, k, m: Integer;

Massiv: Array [1..n, 1..n] Of Integer;

ClrScr;

Randomize;

For i:=1 To n Do

For j:=1 To n Do

Massiv[i, j]:= Random(mass_max – mass_min + 1) + mass_min;

WriteLn(‘Исходный массив:’);

For i:=1 To n Do

Begin

For j:=1 To n Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

For i:=1 To n Do строки начинаем с первой

For j:=i To n Do столбцы начинаем с главной диагонали

Begin

k:= Massiv[i,j]; транспонирование массива с использованием

Massiv[i,j]:= Massiv[j,i]; алгоритма циклического обмена

Massiv[j,i]:= k; значениями двух переменных через третью

End;

WriteLn(‘Транспонированный массив:’);

For i:=1 To n Do

Begin

For j:=1 To n Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

m:= n Div 2;

For i:=1 To n Do перебираем строки массива

For j:=1 To m Do переворачиваем каждую строку

k:= Massiv[i,j];

Massiv[i,j]:= Massiv[i, n – j + 1];

Massiv[i, n – j + 1]:= k;

End;

WriteLn;

WriteLn(‘Полученный массив:’);

For i:=1 To n Do

Begin

For j:=1 To n Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

ReadLn;

16. Задать элементы целочисленного массива massiv_nm случайными числами, лежащими в диапазоне от mass_min до mass_max. Исходный массив вывести на экран построчно. Определить седловую точку массива. Седловой точкой массива называется элемент, наименьший в своей строке и одновременно наибольший в своем столбце:

Program Primer_16;

Uses WinCrt;

Const n = 5;

m = 10;

mass_min = -50;

mass_max = 50;

Var i, j, k, i_max, j_min: Word;

min, max: Integer;

Massiv: Array [1..n, 1..m] Of Integer;

ClrScr;

Randomize;

For i:=1 To n Do

For j:=1 To m Do

Massiv[i, j]:= Random(mass_max – mass_min + 1) + mass_min;

WriteLn(‘Исходный массив:’);

For i:=1 To n Do

Begin

For j:=1 To m Do

Write(Massiv[i, j]:5);

WriteLn;

End;

WriteLn;

For i:=1 To n Do перебираем строки массива

min:= Massiv[i,1];

j_min:= 1; номер столбца с минимальным элементом в этой строке

For j:=2 To m Do

If (Massiv[i,j] < min) Then

Begin

min:= Massiv[i,j];

j_min:= j;

End;

max:= Massiv[1, j_min]; ищем максимальный элемент в столбце,

i_max:= 1; содержащем минимальный элемент этой строки

For k:=2 To n Do

If (Massiv[k,j_min] > max) Then

Begin

max:= Massiv[k,j_min];

i_max:= k;

End;

If (i = i_max) Then

WriteLn(‘Номер строки=’,i,

‘ Номер столбца=’,j_min,

‘ Седловая точка=’, Massiv[i, j_min]);

Break;

End;

End; конец цикла по строкам

ReadLn;

17. Задать элементы целочисленного квадратного массива a_nn случайными числами, лежащими в диапазоне от mass_min до mass_max. Исходный массив вывести на экран построчно. Заполнить вектор v_k суммами элементов исходного массива, расположенных параллельно побочной диагонали (k = 2n – 1).

Для решения этой задачи рассмотрим исходный массив поэлементно:

a₁₁ a₁₂ a₁₃ a₁₄... a_1n

a₂₁ a₂₂ a₂₃ a₂₄... a_2n

a₃₁ a₃₂ a₃₃ a₃₄... a_3n

a_n1 a_n2 a_n3 a_n4... a_nn

Заметим следующую закономерность образования сумм элементов по диагоналям, параллельным побочной:

v₁ = a₁₁ сумма индексов элемента 1 + 1 = 2

v₂ = a₂₁ + a₁₂ сумма индексов элементов 1 + 2 = 3

v₂ = a₃₁ + a₂₂ + a₁₃ сумма индексов элементов 1 + 3 = 4

v_2n-1 = a_nn сумма индексов элемента n + n = 2n

Таким образом, сумма индексов элементов массива, входящих в сумму элементов, на единицу меньше индекса соответствующего элемента вектора:

Program Primer_17;

Uses WinCrt;

Const n = 5;

k = 2*n - 1;

mass_min = -50;

mass_max = 50;

Var i, j, t: Integer;

v: Array [1..k] Of Integer;

a: Array [1..n, 1..n] Of Integer;

ClrScr;

Randomize;

For i:=1 To n Do

For j:=1 To n Do

a[i, j]:= Random(mass_max – mass_min + 1) + mass_min;

WriteLn;

WriteLn(‘Исходный массив:’);

For i:=1 To n Do

Begin

For j:=1 To n Do

Write(a[i, j]:5);

WriteLn;

End;

WriteLn;

For i:=1 To k Do обнуляем выходной вектор

v[i]:= 0;

For i:=1 To n Do

For j:=1 To n Do

t:= i + j - 1; определяем индекс элемента вектора

v[t]:= v[t] + a[i,j]; вычисляем сумму элементов массива

End;

WriteLn;

WriteLn(‘Полученный вектор’);

WriteLn;

For i:=1 To k Do

Write(Vector[i]:5);

WriteLn;

ReadLn;

18. Задать элементы целочисленного квадратного массива a_nn случайными числами, лежащими в диапазоне от mass_min до mass_max. Исходный массив вывести на экран построчно. Заполнить вектор v_k суммами элементов исходного массива, расположенных параллельно главной диагонали (k = 2n – 1).

Для решения этой задачи рассмотрим исходный массив поэлементно:

a₁₁ a₁₂ a₁₃ a₁₄... a_1n

a₂₁ a₂₂ a₂₃ a₂₄... a_2n

a₃₁ a₃₂ a₃₃ a₃₄... a_3n

a_n1 a_n2 a_n3 a_n4... a_nn

Заменим элементы исходного массива элементами вычисляемого вектора:

v_n v_n-1 v_n-2 v_n-3... v₂ v₁

v_n+1 v_n v_n-1 v_n-2... v₃ v₂

v_n+2 v_n-1 v_n v_n-2... v₄ v₃

V_2n-1 v_2n-2 v_2n-3 v_2n-4... v_n+1 v_n

Алгоритм очевиден:

Program Primer_18;

Uses WinCrt;

Const n = 5;

k = 2*n - 1;

mass_min = -50;

mass_max = 50;

Var i, j, m, t: Integer;

v: Array [1..k] Of Integer;

a: Array [1..n, 1..n] Of Integer;

ClrScr;

Randomize;

For i:=1 To n Do

For j:=1 To n Do

a[i, j]:= Random(mass_max – mass_min + 1) + mass_min;

WriteLn;

WriteLn(‘Исходный массив:’);

For i:=1 To n Do

Begin

For j:=1 To n Do

Write(a[i, j]:5);

WriteLn;

End;

WriteLn;

For i:=1 To k Do обнуляем выходной вектор

v[i]:= 0;

m:= n-1;

For i:= 1 To n Do

m:= m+1;

t:= m;

For j:=1 To n Do

v[t]:= v[t] + a[i,j];

t:= t - 1;

End;

End;

WriteLn;

WriteLn(‘Полученный вектор’);

WriteLn;

For i:=1 To k Do

Write(Vector[i]:5);

WriteLn;

ReadLn;

19. Задать элементы целочисленного трехмерного массива massiv_knm по слоям в виде чисел от 1 до k*n*m. Вывести на экран верхнюю, переднюю и правую грани массива:

Program Primer_19;

Uses WinCrt;

Const k = 3; количество слоев

n = 4; количество строк в слое

m = 5; количество столбцов в слое

Var i, j, b, c: Word;

Massiv: Array [1..k, 1..n, 1..m] Of Word;

Begin порядок следования индексов: слой, строка, столбец

ClrScr;

c:= 0; рабочая переменная для задания элементов массива

For i:=1 To k Do заполнение слоев массива

For j:=1 To n Do заполнение строк массива

For b:=1 To m Do заполнение столбцов массива

c:= c + 1;

Massiv[i, j, b]:= c;

End;

WriteLn('Верхняя грань:');

For i:=1 To n Do

For j:=1 To m Do

Write(Massiv[1, i, j]:5);

WriteLn;

End;

WriteLn;

WriteLn('Передняя грань:');

For i:=1 To k Do

For j:=1 To m Do

Write(Massiv[i, n, j]:5);

WriteLn;

End;

WriteLn;

WriteLn('Правая грань:');

For i:=1 To k Do

For j:=1 To n Do

Write(Massiv[i, j, m]:5);

WriteLn;

End;

WriteLn;

ReadLn;

Результат работы программы:

Верхняя грань:

1 2 3 4 5

6 7 8 9 10

11 12 13 14 15

16 17 18 19 20

Передняя грань:

16 17 18 19 20

36 37 38 39 40

56 57 58 59 60

Правая грань:

5 10 15 20

25 30 35 40

45 50 55 60

Часто встречающиея ошибки программирования:

1. Заголовок цикла заканчивается точкой с запятой. Это приводит к тому, что цикл отрабатывает пустой оператор заданное количество раз, и после этого один раз вычисляется тело цикла:

s:= 0;

For i:= 1 To 100 Do;

s:= s + i; в этом случае s = 100

2. При использовании слова To конечное значение параметра цикла превосходит его начальное значение. В этом случае цикл не выполняется ни разу:

s:= 0;

For i:= 100 To 1 Do

s:= s + i; в этом случае s = 0

3. Использование в качестве параметра цикла переменной вещественного типа:

s:= 0.0;

For i:= 1.0 To 100.0 Do

s:= s + i;

4. Изменение внутри области цикла значения параметра цикла, а также его начального и конечного значения:

m:= 10;

n:= 1;

For j:= m DownTo n Do

a[j]:= j + 10;

j:= j + 1; ошибка!

m:= m + 1; ошибка!

n:= n – 1; ошибка!

End;

Множества – это структуры данных, наряду с переменными, массивами и строками.

Понятие множества является одним из основных понятий современной математики.

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

Под множеством в Паскале понимается неупорядоченный набор фиксированного количества (не более 255) неповторяющихся однотипных элементов, имеющих общее имя – имя множества.

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

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

1. целого (множество целых чисел, не более 255 чисел),

2. логического (множество, состоящее из двух логических констант: TRUE и FALSE),

3. символьного (множество символов таблицы ASCII),

4. перечисляемого,

5. интервального.

Таким образом, в Паскале не определено множество, состоящее из чисел с дробной частью (REAL).

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

1. объявлением его имени и типа в разделе описания переменных Var:

Var r: Set Of ‘a ’.. ’c’;

d: Set Of 1.. 4;

Описано множество r символов алфавита от ‘a’ до ‘c’ и множество d целых чисел 1, 2, 3, 4.

Внимание! Между начальным и конечным значениями интервала ставятся две точки!

2. объявлением типа множества в разделе определения типов Type и его имени – в разделе описания переменных Var:

Type TSymb = Set Of ‘a’.. ‘c’;

TNumb = Set Of 1.. 4;

Var r: TSymb;

d: TNumb;

3. заданием множества как типизированной константы:

Constr: Set Of ‘a ’.. ’c’ = [‘a’,’c’];

d: Set Of 1.. 4 = [2,1,3];

Внимание! Элементы множества перечисляются в квадратных скобках через запятую.

Элементы ножества можно задавать следующими способами:

a)перечислением отдельных его значений:

[‘c’, ‘a’, ‘e’] [76, 102, 5, 12]

b)интервалом базового типа:

[25..45, 3..10] [‘a’..’d’, ‘k’..’n’]

c)выражениями базового типа:

[Ord(109),’s’] [Succ(3), Pred(9), Round(Sin(1.0))]

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

[‘a’, ‘b’, ‘c’]

[‘a’, ‘b’]

[‘a’, ‘c’]

[ ‘b’, ‘c’]

[‘a’]

[ ‘b’]

[ ‘c’]

[] пустое множество

а множество d - следующие:

[1, 2, 3, 4]

[1, 2, 3]

[1, 3, 4]

[1, 2, 4]

[2, 3, 4]

[1, 2]

[1, 3]

[1, 4]

[2, 3]

[2, 4]

[3, 4]

[1]

[2]

[3]

[4]

[]

Таким образом, любое множество может принимать 2ⁿ значений, где n – количество элементов в описании множества.

Порядок следования элементов во множестве не устанавливается, поэтому, например, значения множества [‘a’, ‘b’, ‘c’] и [‘b’, ‘c’, ‘a’] эквивалентны.

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

+ объединение (сумма) множеств,

* пересечение (произведение) множеств,

- разность множеств,

Inвхождение элемента во множество.

Пересечением двух множеств называется множество, состоящее из элементов, одновременно входящих в оба множества-сомножителя:

[3, 4, 5] * [1, 3, 5] = [3]

[3, 4, 5] * [3, 4, 5] = [3, 4, 5]

[2, 1, 0] * [] = []

[2, 9, 8] * [6, 7] = [] пустое множество

[‘a’, ‘b’, ‘c’] * [‘d’, ‘c’, ‘a’] = [‘a’, ‘c’]

Объединением двух множеств называется множество, состоящее из элементов, входящих хотя бы в одно из множеств-слагаемых:

[3, 4, 5] + [1, 3, 5] = [1, 3, 4, 5]

[2, 9, 8] + [] = [2, 9, 8]

[1, 2, 3] + [1, 2, 3] = [1, 2, 3]

[‘a’, ‘b’, ‘c’] + [‘d’, ‘c’, ‘a’] = [‘a’, ’b’, ‘c’, ‘d’]

Разностью двух множеств называется множество, состоящее из элементов множества-уменьшаемого без элементов множества-вычитаемого:

[3, 4, 5] – [1, 3, 5] = [4]

[2, 9, 5] – [3, 7] = [2, 9, 5]

[2, 4] – [5, 4, 2] = []

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

([3, 4, 5] + [1, 3, 6, 7]) * [5, 6, 7] – [6] = [5, 7]

Пример: в группе 12 студентов. Заданы множества номеров студентов:

1. множество спортсменов sport = [1, 2, 3, 4, 5]

2. множество отличников otl = [2, 3, 6, 7]

3. множество курящих smok = [7, 8]

Определить:

1. множество спортсменов-отличников:

sport * otl = [1, 2, 3, 4, 5] * [2, 3, 6, 7] = [2, 3]

2. множество спортсменов или отличников:

sport + otl = [1, 2, 3, 4, 5] + [2, 3, 6, 7] = [1, 2, 3, 4, 5, 6, 7] = [1.. 7]

3. множество курящих спортсменов:

sport * smok = [1, 2, 3, 4, 5] * [7, 8] = [] - пустое множество – спортсмены не курят!

4. множество некурящих отличников:

otl – smok = [2, 3, 6, 7] – [7, 8] = [2, 3, 6]

Для проверки вхождения какой-либо константы или переменной в определенное множество используется операция In, результатом которой является TRUE, если это значение входит во множество, и FALSE – если не входит:

5 In [1, 5, 7] = TRUE

‘b’ In [‘a’, ‘c’, ‘d’] = FALSE

Наряду с этими операциями, над множествами определены и операции сравнения, используемые для сравнения однотипных множеств. Пусть A и B -два однотипных множества, тогда:

A <= B равно TRUE, если все элементы множества A входят во множество B:

[5, 3, 2] <= [1, 2, 3, 4, 5] = True

A >= B равно TRUE, если все элементы множества B входят во множество A:

[‘d’, ‘e’, ‘f’, ‘g’] >= [‘d’, ‘g’] = True

A = B равно TRUE, если элементы этих множеств полностью совпадают:

[1, 2, 3] = [3, 2, 1] = TRUE

A <> B равно TRUE, если эти множества различаются хотя бы одним элементом:

[1, 2, 3] <> [5, 2, 1] = TRUE

Выражения со множествами, построенные с помощью операций *, + и -, могут быть использованы в операторах присваивания вида:

V:= S;

где V – переменная-множество,

S – выражение со множествами того же типа.

Внимание! Элементы множеств нельзя вводить и выводить операторами Read и Write, то есть имя множества не должно появляться в списках операторов ввода-вывода.

Дата добавления: 2014-01-06