Array45. Дан массив размера N. Найти номера двух ближайших элементов из этого массива (т. е. элементов с наименьшим модулем разности) и вывести эти номера в порядке возрастания.
const
nmax = 20; { Максимальное количество элементов, nmax>1 }
var
A: array[1..nmax] of real;
MinDiff, c: real; { Минимальная разница }
i, j, N, i1, i2: byte;
begin
{ Вводим размер массива N: }
repeat
write('N = ');
readln(N)
until (N > 1) and (N <= nmax); { N принадлежит [2, nmax] }
randomize; { Датчик псевдослучайных чисел }
for i := 1 to N do
begin
a[i] := -10 + 20 * random; { Случайное число с интервала [-10, 10) }
write(' ', a[i]:0:2);
if i = 2 then
begin
MinDiff := abs(a[2] - a[1]); { Начальное значение минимальной разницы }
i1 := 1; { Меньший индекс }
i2 := 2 { Больший индекс }
end
else { Сравниваем модуль разницы текущего
элемента a[i] со всеми предыдущими: }
for j := 1 to i - 1 do
begin
c := abs(a[j] - a[i]); { Модуль разницы между a[j] и a[i] }
if c < MinDiff then { c меньше MinDiff }
begin
MinDiff := c; { Новое значение MinDiff }
i1 := j; { Меньший индекс }
i2 := i { Больший индекс }
end
end
end;
writeln;
writeln('Номера ближайших элементов: ', i1, ' ', i2);
readln
end.
**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308**type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255
**procedure** Randomize;: Инициализирует датчик псевдослучайных чисел.2)**procedure** Randomize(seed: integer);: Инициализирует датчик псевдослучайных чисел, используя значение seed. При одном и том же seed генерируются одинаковые псевдослучайные последовательности.**function** Random(maxValue: integer): integer;: Возвращает случайное целое в диапазоне от 0 до maxValue - 1.2)**function** Random(a,b: integer): integer;: Возвращает случайное целое в диапазоне от a до b.3)**function** Random: real;: Возвращает случайное вещественное в диапазоне [0..1).**function** Abs(x: real): real;: Возвращает модуль числа x.**function** Abs(x: real): real;: Возвращает модуль числа x. Array46. Дано число R и массив размера N. Найти два различных элемента массива, сумма которых наиболее близка к числу R, и вывести эти элементы в порядке возрастания их индексов (определение наиболее близких чисел дано в задании Array40).
Задача аналогичная предыдущей Array45, только будем сравнивать не сами элементы (модуль разницы между a[i] и a[j]), а модуль разницы между суммой a[i]+a[j] и введенным ранее числом R (строки 15-16), где i - текущий номер элемента, j - один из предыдущих номеров (j=1..i-1).
Ещё одно отличие при выводе: нужно выводить не номера элементов, а их значения a[i1] и a[i2] в порядке возрастания номеров (i1<i2)
const
nmax = 20; { Максимальное количество элементов, nmax>1 }
var
A: array[1..nmax] of real;
R, MinDiffSum, c: real; { Минимальная разница }
i, j, N, i1, i2: byte;
begin
{ Вводим размер массива N: }
repeat
write('N = ');
readln(N)
until (N > 1) and (N <= nmax); { N принадлежит [2, nmax] }
write('R = ');
readln(R);
randomize; { Датчик псевдослучайных чисел }
for i := 1 to N do
begin
a[i] := -10 + 20 * random; { Случайное число с интервала [-10, 10) }
write(' ', a[i]:0:2);
if i = 2 then
begin
MinDiffSum := abs(a[2] + a[1] - R); { Начальное значение минимальной разницы }
i1 := 1; { Меньший индекс }
i2 := 2 { Больший индекс }
end
else { Проверяем предыдущие элементы a[j], j=1..i-1: }
for j := 1 to i - 1 do
begin { Вычисляем модуль разницы между
суммой элементов a[i], a[j] и числом R: }
c := abs(a[j] + a[i] - R);
if c < MinDiffSum then { Находим c меньшее MinDiffSum }
begin
MinDiffSum := c; { Новое значение MinDiffSum }
i1 := j; { Меньший индекс }
i2 := i { Больший индекс }
end
end
end;
writeln;
writeln('Элементы с наиболее близкой к ', R, ' суммой: ', a[i1]:0:2, ' ', a[i2]:0:2);
readln
end.
**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308**type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255
**procedure** Randomize;: Инициализирует датчик псевдослучайных чисел.2)**procedure** Randomize(seed: integer);: Инициализирует датчик псевдослучайных чисел, используя значение seed. При одном и том же seed генерируются одинаковые псевдослучайные последовательности.**function** Random(maxValue: integer): integer;: Возвращает случайное целое в диапазоне от 0 до maxValue - 1.2)**function** Random(a,b: integer): integer;: Возвращает случайное целое в диапазоне от a до b.3)**function** Random: real;: Возвращает случайное вещественное в диапазоне [0..1).**function** Abs(x: real): real;: Возвращает модуль числа x.**function** Abs(x: real): real;: Возвращает модуль числа x. Array47. Дан целочисленный массив размера N. Найти количество различных элементов в данном массиве.
Все пояснения в комментариях кода.
const
nmax = 20; { Максимальное количество элементов, nmax>1 }
var
A: array[1..nmax] of integer;
N, i, j, Q: byte;
begin
{ Вводим размер массива N: }
repeat
write('N = ');
readln(N)
until (N > 0) and (N <= nmax); { N принадлежит [1, nmax] }
Q := 0; { Количество различных элементов вначале равно 0 }
randomize;
for i := 1 to N do
begin
a[i] := random(10); { Случайный элемент 0..9 }
write(' ', a[i]);
j := 1; { Промежуточная переменная для предыдущих номеров: j=1..i-1 }
{ Проверяем все предыдущие по отношению к i номера (j < i): если
при этом элементы не равны (a[i] ≠ a[j]), то переходим к следующему
элементу: inc(j), в противном случае автоматический выход из цикла. }
while (j < i) and (a[i] <> a[j]) do
inc(j);
{ Если при выходе из цикла j = i, то это означает, что все предыдущие
элементы a[1], a[2], ..., a[i-1] оказались не равными a[i], после
этого мы ещё раз увеличили j и вышли из цикла, поэтому количество Q
различных чисел нужно увеличить на 1: }
if j = i then inc(Q)
{ Если j < i, то в этом случае мы вышли из цикла ещё до проверки всех
элементов, так как нашли равные элементы (a[i] = a[j]). В этом случае
увеличивать Q не нужно. }
end;
writeln;
writeln('Количество различных элементов: ', Q);
readln
end.
**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647**type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255
**procedure** Randomize;: Инициализирует датчик псевдослучайных чисел.2)**procedure** Randomize(seed: integer);: Инициализирует датчик псевдослучайных чисел, используя значение seed. При одном и том же seed генерируются одинаковые псевдослучайные последовательности.**function** Random(maxValue: integer): integer;: Возвращает случайное целое в диапазоне от 0 до maxValue - 1.2)**function** Random(a,b: integer): integer;: Возвращает случайное целое в диапазоне от a до b.3)**function** Random: real;: Возвращает случайное вещественное в диапазоне [0..1).**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1 Array48. Дан целочисленный массив размера N. Найти максимальное количество его одинаковых элементов.
Эта задача очень похожа по смыслу с Array47, только вместо отыскания количества различных чисел в массиве требуется найти наибольшее количество его равных элементов. Вероятно, в произвольно заданном масиве разные числа будут встречатся в разном количестве, поэтому интересует вопрос об именно максимальном количестве одинаковых элементов этого массива.
Ввод массива осуществляется вручную, все комментарии в коде программы.
const
nmax = 20; { Максимальное количество элементов, nmax>1 }
var
A: array[1..nmax] of integer;
N, i, j, Q, Qmax: byte;
begin
{ Вводим размер массива N: }
repeat
write('N = ');
readln(N)
until (N > 0) and (N <= nmax); { N принадлежит [1, nmax] }
Qmax := 0; { Максимальное количество одинаковых элементов вначале = 1 }
writeln('Введите ', N, ' целых чисел:');
for i := 1 to N do
begin
read(a[i]); { Вводим элемент a[i] }
Q := 1; { Количество различных элементов вначале равно 1 }
{ Проверяем все предыдущие по отношению к i номера (j = 1..i-1), то есть
сравниваем данный элемент a[i] с предыдущими a[1], a[2], ..., a[i-1]:
если при этом найдется равный a[i] элемент при некотором j (a[i] = a[j]),
то увеличиваем количество Q равных чисел на 1: }
for j := 1 to i - 1 do
if a[i] = a[j] then inc(Q);
{ Сравниваем Q с максимальным количеством Qmax: если оно окажется
больше Qmax (Q > Qmax), то новым значением Qmax становится Q: }
if Q > Qmax then Qmax := Q
end;
writeln;
writeln('Наибольшее количество равных элементов: ', Qmax);
readln
end.
**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647**type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1 Array49. Дан целочисленный массив размера N. Если он является перестановкой, т. е. содержит все числа от 1 до N, то вывести 0; в противном случае вывести номер первого недопустимого элемента.
Ввод массива осуществляется вручную, все комментарии в коде программы.
const
nmax = 10; { Максимальное количество элементов, nmax>1 }
var
A: array[1..nmax] of byte;
N, i, j: byte;
begin
{ Вводим размер массива N: }
repeat
write('N = ');
readln(N)
until (N > 0) and (N <= nmax); { N принадлежит [1, nmax] }
writeln('Введите ', N, ' элементов целочисленного массива:');
i := 0;
repeat
inc(i);
read(a[i]); { Вводим элемент с клавиатуры }
j := 1;
{ Проверяем элемент a[i] с предыдущими элементами a[1], a[2], ..., a[i-1]
на равенство: если a[i] ≠ a[j] для всех j=1..i-1, то переходим к следующему
элементу, в противном случае (a[i] = a[j] для некоторого j < i) выходим из
цикла и выводим результат: }
while (j < i) and (a[i] <> a[j]) do
inc(j)
{ Выходим из цикла в одном из двух случаев:
1)мы нашли равные элементы в предыдущем цикле (j < i);
2)Мы дошли до конца массива (i = N): }
until (j < i) or (i = N);
writeln;
if j < i then writeln('Номер первого недопустимого элемента: ', i)
else writeln(0);
readln
end.
**type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255**type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1 Array50. Дан целочисленный массив A размера N, являющийся перестановкой (определение перестановки дано в задании Array49). Найти количество инверсий в данной перестановке, т. е. таких пар элементов AI и AJ, в которых большее число находится слева от меньшего: AI > AJ при I < J.
Задача разделяется на 2 этапа:
const
nmax = 10; { Максимальное количество элементов, nmax>1 }
var
A: array[1..nmax] of byte;
N, i, j, c: byte;
count: word;
begin
{ Вводим размер массива N: }
repeat
write('N = ');
readln(N)
until (N > 0) and (N <= nmax); { N принадлежит [2, nmax] }
{ Формируем массив-перестановку 1, 2, 3, ..., N: }
for i := 1 to N do
a[i] := i;
{ Перемешаем элементы перестановки случайным образом: }
randomize;
for i := 1 to N do begin
j := 1 + random(n); { Выбираем случайный номер от 1 до N }
{ МЕНЯЕМ ЗНАЧЕНИЯ a[i] и a[j] МЕСТАМИ: }
c := a[i]; { Запоминаем i-е значение, записывая его в переменную c }
a[i] := a[j]; { Меняем i-е значение на j-е }
a[j] := c { Меняем j-е значение на i-е (c равно a[i]) }
end;
{ Выводим перестановку: }
for i := 1 to N do
write(' ', a[i]);
count := 0; { Начальное значение количества перестановок: }
{ Определяем количество перестановок: }
for i := 1 to N - 1 do
for j := i + 1 to N do
if a[i] > a[j] then inc(count);
writeln;
if count > 0 then writeln('Количество инверсий: ', count)
else writeln('Нет инверсий');
readln
end.
**type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255**type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255**type** word;: Представляет 16-битовое целое число без знака.Диапазон значений: 0 .. 65 535
**procedure** Randomize;: Инициализирует датчик псевдослучайных чисел.2)**procedure** Randomize(seed: integer);: Инициализирует датчик псевдослучайных чисел, используя значение seed. При одном и том же seed генерируются одинаковые псевдослучайные последовательности.**function** Random(maxValue: integer): integer;: Возвращает случайное целое в диапазоне от 0 до maxValue - 1.2)**function** Random(a,b: integer): integer;: Возвращает случайное целое в диапазоне от a до b.3)**function** Random: real;: Возвращает случайное вещественное в диапазоне [0..1).**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1