Лабораторная работа 3

Задача 6: Найти значение максимального элемента массива. Алгоритм содержит три пункта:

1.Максимальным элементом считаем первый элемент: max=A[1].

2.Начиная со второго элемента, сравниваем имеющийся максимальный элемент max с очередным элементом массива A[i].

3.Если очередной элемент массива больше имеющегося максимального элемента, то это и есть новый максимальный элемент max=A[i].

Фрагмент программы:

Var {дополнительные переменные}

max:integer; {значение максимального элемента массива}

…

Begin

...

{1} max:=A[1]; {2} for i:=2 to n do

{3} if A[i]>max then max:=A[i];

…

Задача 7: Найти min и max значения элементов массива. Фрагмент программы:

Var {дополнительные переменные} max,min:integer;{значение максимального и минимального элементов массива}

…

Begin

...

max:=A[1];

min:=A[1]; for i:=2 to n do

if A[i]>max then max:=A[i] else if A[i]<min then min:=A[i];

…

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

Задача 8: Подсчитать, сколько раз в массиве встречается элемент, равный 10.

Задача решается по следующему алгоритму:

1.Количество нужных элементов k=0.

2.Проходим по всем элементам массива,

3.И если очередной элемент массива равен 10,

4.Тогда увеличиваем k (количество элементов равных 10) на 1. Фрагмент программы:

Var {дополнительные переменные}

k:integer; {количество элементов, равных 10}

…

Begin

...

{1} k:=0;

{2} for i:=1 to n do {3} if A[i]=10

{4} then k:=k+1;

…

Удаление элемента из массива

Задача 9: Удалить из массива 1-ый элемент. Удаление элемента заключается в:

1.сдвиге элементов, стоящих правее удаляемого влево;

2.уменьшении количества элементов массива n на количество удаляемых элементов.

Сдвиг элементов выполняется так:

1.Начиная с удаляемого элемента, копируем содержимое элемента, стоящего правее в текущий элемент: A[i]:=A[i+1].

2.Переходим к следующему элементу вправо: i:=i+1.

3.Заканчиваем сдвиг, когда i=n-1, так как i+1 при i=n-1 равен n.. Фрагмент программы:

… {

-

сдвигаем элементы на одну позицию вправо}

{вначале i:=1, потому что надо удалить 1-ый элемент} for i:=1 to n-1 do

A[i]:=A[i+1];

{2 - уменьшаем количество элементов в массиве} n:=n-1;

…

Задача 10: Удалить из массива максимальный элемент массива. Для этого надо:

1.Найти индекс максимального элемента.

2. Удалить элемент с найденным индексом. Фрагмент программы:

Var {дополнительные переменные} imax:IndexEl; {индекс максимального элемента}

…

Begin

...

{1 - ищем индекс максимального элемента массива} imax:=1; {вначале imax указывает на первый элемент} {в цикле начиная со 2-го элемента}

for i:=2 to n do

{сравниваем i-ый элемент с максимальным на текущий

момент времени, и если i-ый элемент больше максимального, то максимальным становится i-ый элемент}

if A[i]>A[imax] then imax:=i;

{2 - удаляем элемент массива с индексом imax} for i:=imax to n-1 do

A[i]:=A[i+1];

dec(n); {уменьшаем n на 1}

Замечание: в ТР имеются процедуры увеличения и уменьшения переменной целого типа. Inc - увеличение значения переменной. Вид вызова для целого

X Inc(x); x:=x+1; Inc(x,n); x:=x+n;

где x - переменная целого типа; n - целочисленное выражение.

В первом случае переменной x присваивается следующее значение (например, x была равна 10, тогда после выполнения inc(x) x равна 11). Таким образом, можно сказать, что запись inc(x) эквивалентна записи x:=x+1. Можно также сказать, что запись inc(x,n) эквивалентна записи

x:=x+n.

Dec – уменьшение значения переменной. Вид вызова Для целого X

Dec(x); x:=x-1; Dec(x,n); x:=x-n;

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

Задача 11: В массив после максимального элемента вставить элемент, равный 0.

for i:=2 to n do

if A[i]>A[max] then max:=i;

{3- вставляем 0 после максимального элемента} {сначала сдвигает “хвост” массива вправо}

for i:=n downto max+1 do A[i+1]:=A[i];

{заносим в следующий за максимальным элемент 0}

A[max+1]:=0;

{увеличиваем количество элементов массива}

Inc(n);

{4 - выводим массив} writeln('Массив А после вставки:'); for i:=1 to n do

write(A[i]:3);

readln; {ждем нажатия клавиши Enter} End.

Данная программа демонстрирует модульный подход к решению задач - задача разбивается на подзадачи, полученные подзадачи решаются отдельно. Если подзадача не решается непосредственно, то она снова разбивается на подзадачи и т.д. Такой подход называется "программирование сверху вниз". Замечание: данная программа таит в себе ошибку. Если n=20, то после вставки еще одного элемента n станет равной 21, и, скорее всего, программа повиснет (потому что элементов в массиве может быть НЕ БОЛЬШЕ 20). Следовательно, при вставке элементов необходимо следить, чтобы было n<=maxN .

Удаление нескольких элементов массива

Задача 12: Удалить из массива все элементы между k-м и z-м элементами.

Рассмотрим задачу на примере при количестве элементов в массиве n=10, k=3, z=7 (т.е. надо удалить элементы между третьим и седьмым). Будем использовать переменную d - количество удаляемых элементов. Значение d можно вычислить по формуле: d = z - k – 1 ( в нашем примере получится d = 7 - 3 - 1 = 3).

Массив A до удаления:

a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a[10] 1 3 9 1 0 1 3 2 7 2

^ ^ ^

a[k] a[z] a[n]

Массив A после удаления: a[1] a[2] a[3] a[4] a[5] a[6] a[7] 1 3 9 3 2 7 2

^ ^ ^

a[k] a[z] a[n]

После удаления n стало меньше на d (в нашем примере на 3). Общий алгоритм решения:

1. Сдвинуть элементы вперед на d элементов, начиная с z-го.

2. Уменьшить n на d.

Фрагмент программы:

Var {дополнительные переменные}

k: integer; {индекс элемента, после которого удаляем} z: integer; {индекс элемента, до которого удаляем}

d: integer; {количество удаляемых элементов}

…

Begin

…

{вычисляем количество удаляемых элементов} d:=z-k-1;

{1 - сдвигаем элементы} for i:=z to n do A[i-d]:=A[i];

{2 - уменьшаем n на d}

Dec(n,d);

…

Задача 13: Из массива удалить все элементы, которые меньше 0. Рассмотрим два решения этой задачи.

Алгоритм первого решения:

1.Просматриваем массив .

2.Если элемент<0, то удаляем его и n уменьшаем.

3.Если элемент>=0, то переходим к следующему. Фрагмент программы:

… {

в

цикле просматриваем элементы массива} i:=1;

while i<=n do begin

{проверяем ,не нужно ли i-ый элемент удалять} if A[i]<0 then

begin

{если нужно – удаляем i-ый элемент} for j:=i to n-1 do {сдвигаем} A[j]:=A[j+1];

Dec(n); {уменьшаем количество элементов} end

else Inc(i); {если удалять не нужно, то переходим к следующему элементу}

end;

Пример прогона алгоритма: Исходный массив:

0: i=1, n=6: -1 -2 2 -3 -4 3

Состояния массива после обработки очередного элемента массива:

1:i=1, n=5: -2 2 -3 -4 3 (удален -1)

2:i=1, n=4: 2 -3 -4 3 (удален -2)

3:i=2, n=4: 2 -1 -2 3 (перешли на следующий)

4:i=2, n=3: 2 -4 3 (удален -3)

5:i=2, n=2: 2 3 (удален -4)

6:i=3, n=2: 2 3 (перешли на следующий) Алгоритм второго решения:

1. Счетчик переписанных элементов k=0.

2. Просматриваем элементы массива.

3. Если элемент A[i] не меньше 0, k увеличиваем на 1 и переписываем элемент A[i] на k-ое место.

4. После просмотра всего массива количество переписанных элементов k заносим в n.

Фрагмент программы:

Var {дополнительные переменные}

k:IndexEl; {количество переписанных элементов}

…

Begin

...

{1 - переписанных элементов пока не было} k:=0;

{2 - в цикле просматриваем элементы массива}

for i:=1 to n do

{3 - если A[i] не <0} if not(A[i]<0) then begin

Inc(k); {увеличиваем значение k на 1}

A[k]:=A[i]; {переписываем i-ый элемент в позицию k} end;

{4 - в массиве оставляем k элементов} n:=k;

Пример прогона алгоритма: Исходный массив: -1 -2 2 -3 -4 3

Состояния массива после просмотра очередного элемента массива:

0:k=0, i=1, n=6: -1 -2 2 -3 -4 3 {не переписываем}

1:k=0, i=2, n=6; -1 -2 2 -3 -4 3 {не переписываем}

2:k=1, i=3, n=6; 2 -2 2 -3 -4 3 {переписываем a[1]:=a[3]}

3:k=1, i=4, n=6; 2 -2 2 -3 -4 3 {не переписываем}

4:k=1, i=5, n=6; 2 -2 2 -3 -4 3 {не переписываем}

5:k=2, i=6, n=6; 2 3 2 -3 -4 3 {переписываем a[2]:=a[6]}

6:k=2, i=7, n=6: 2 3 2 -3 -4 3 {выход из цикла}

7:n=2: 2 3 {значение k переписываем в n}

Обработка нескольких массивов

Задача 14: Массивы А и В имеют одинаковую длину. Массив С необходимо заполнить суммами соответствующих элементов массивов А и В. n - длина массивов А и В (и С тоже).

Фрагмент программы:

… {

проходим по всем элементам массивов} for i:=1 to n do

{сумму i-ых элементов массивов A и B заносим в i-ый элемент C}

C[i]:=A[i]+B[i];

…

Задача 15: В конец массива А[n] приписать все элементы массива В[m]. Фрагмент программы:

… {

проходим в цикле по массиву B} for i:=1 to m do

A[n+i]:=B[i]; {дописываем элементы в хвост A} Inc(n,m); {увеличиваем значение n (длину массива A) на m (длину массива B)}

…

Замечание: Необходимо следить, чтобы n не превысило значение maxN.

Например, так:

…

if n+m>maxN

then writeln('В массив А все элементы массива В не поместятся') else ... {а вот здесь выполняем добавление элементов}

Задача 16: Сформировать массив В из отрицательных элементов массива А. Массив А не изменять.

Фрагмент программы:

…

m:=0; {m - количество элементов в массиве В - вначале массив B пустой}

{проходим по всем элементам массива A} for i:=1 to n do

if A[i]<0 then {если i-ый элемент массива A отрицательный} begin

{то копируем его в массив B}

Inc(m); {в B добавляется еще один элемент - увеличиваем m на 1}

B[m]:=A[i]; {копируем i-ый элемент массива A в m-ый элемент массива B}

end;

…

Задача 17: Подсчитать, сколько элементов массива А совпадают с элементами массива В.

Алгоритм программы:

1.Ввести массив А[n].

2.Ввести массив В[m] .

3.Счетчик совпадений cnt обнулить.

4.Пройти по всем элементам массива A.

5.Сравнить i-ый элемент массива А со всеми элементами

массива В.

6.Если А[i] совпадает хотя бы с одним элементом массива B, то счетчик повторений увеличить на 1.

7.Вывести количество совпадений.

Текст программы:

{Подсчитать, сколько элементов массива А совпадают с элементами массива В}

Program TwoArrayExample; Const

maxN = 20; {максимальное количество элементов массива}

Type

IndexEl = 1 .. maxN; {индексы массива лежат в интервале от 1 до maxN}

arrInt = array[IndexEl] of integer; {массив целых чисел,

содержащий до maxN элементов} Var

a,b:arrInt; {массивы A и B} n:integer;{количество элементов массива A} m:integer;{количество элементов массива B}

i,j:IndexEl; {переменные для сканирования массивов}

cnt: integer; {количество совпадений элементов A с элементами B} k: integer; {количество совпадений элемента A[i] с элементами B}

Begin

{1 - ввод массива A}

{ввод количества элементов} repeat

write('Введите n:'); readln(n);

until (n>=1) and (n<=maxN); {выйдем из цикла лишь тогда, когда n будет принадлежать интервалу [1..maxN]}

{ввод элементов массива A поодиночке}

for i:=1 to n do begin write('a[',i,']'); readln(a[i]); end;

{2 - ввод массива B}

{ ввод количества элементов} repeat