Здесь представлены следующие задачи из задачника Абрамяна:
Array40. Дано число R и массив A размера N. Найти элемент массива, который наиболее близок к числу R (т. е. такой элемент AK, для которого величина |AK - R| является минимальной).
Последовательность действий при решении задачи Array40:
var
R, min: real;
N, K, i: integer;
A: array[1..100] of real;
begin
write('R = ');
readln(R);
write('N = ');
readln(N);
writeln('Введите массив размера ', N, ':');
for i := 1 to N do read(a[i]); //вводим элементы массива
K := 1; //начальное значение номера нужного элемента
min := abs(a[1] - R); //начальное значение минимальной величины
{ Проверяем остальные значения: }
for i := 2 to N do
if abs(a[i] - R) < min then begin //мы нашли меньшую разницу
min := abs(a[i] - R); //присваиваем минимуму min это число
k := i //запоминаем номер
end;
writeln;
writeln('A[', K, '] = ', A[K])
end.
**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308**function** Abs(x: real): real;: Возвращает модуль числа x.**function** Abs(x: real): real;: Возвращает модуль числа x.**function** Abs(x: real): real;: Возвращает модуль числа x. * * *
Второй вариант решения Array40 отличается тем, что ввод чисел и проверка условий выполняются в одном цикле, кроме первого числа a[1], которое вводится перед вхождением в цикл.
var
R, min: real;
N, K, i: integer;
A: array[1..100] of real;
begin
write('R = ');
readln(R);
write('N = ');
readln(N);
writeln('Введите массив размера ', N, ':');
read(a[1]);//вводим 1-й элемент массива
K := 1; //начальное значение номера
min := abs(a[1] - R); //начальное значение минимальной величины
{ Проверяем остальные значения: }
for i := 2 to N do begin
read(a[i]);
if abs(a[i] - R) < min then begin //мы нашли меньшую разницу
min := abs(a[i] - R); //присваиваем минимуму min это число
k := i //запоминаем номер
end
end;
writeln;
writeln('A[', K, '] = ', A[K])
end.
**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308**function** Abs(x: real): real;: Возвращает модуль числа x.**function** Abs(x: real): real;: Возвращает модуль числа x.**function** Abs(x: real): real;: Возвращает модуль числа x. * * *
Третий вариант решения задачи Array40 - все данные и проверку условий выполняем в одном цикле, используя логическую переменную first (индикатор ввода первого числа).
var
R, min: real;
N, K, i: integer;
A: array[1..100] of real;
first: boolean;
begin
write('R = ');
readln(R);
write('N = ');
readln(N);
first := false;
writeln('Введите массив размера ', N, ':');
for i := 1 to N do begin
read(a[i]); //вводим элементы массива
if not first then begin //начальные значения не призначены
K := 1; //начальное значение номера нужного элемента
min := abs(a[1] - R); //1-е значение минимальной величины
first := true
end
elseelse{ Проверяем остальные значения: }
if abs(a[i] - R) < min then begin //мы нашли меньшую разницу
min := abs(a[i] - R); //присваиваем минимуму min это число
k := i //запоминаем номер
end;
end;
writeln;
writeln('A[', K, '] = ', A[K])
end.
**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308**type** boolean;: Представляет логическое значение.**const** false = False;: Представляет логическое значение.**function** Abs(x: real): real;: Возвращает модуль числа x.**const** true = True;: Представляет логическое значение.**function** Abs(x: real): real;: Возвращает модуль числа x.**function** Abs(x: real): real;: Возвращает модуль числа x. Array41. Дан массив размера N. Найти два соседних элемента, сумма которых максимальна, и вывести эти элементы в порядке возрастания их индексов.
var
N, i, k: integer;
max: real;
A: array[1..100] of real;
begin
write('N = ');
readln(N);
writeln('Введите массив ', N, ' элементов:');
for i := 1 to N do read(a[i]); //вводим элементы массива
k := 1; //начальный индекс
max := a[k] + a[k + 1]; //начальная сумма соседних элементов
for i := 3 to N do
if max < a[i - 1] + a[i] then //находим большую сумму
begin
max := a[i - 1] + a[i];//запоминаем сумму
k := i - 1 //запоминаем первый индекс
end;
writeln;
writeln('a[', k, '] + a[', k + 1, '] = ', max)
end.
**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308 Array42. Дано число R и массив размера N. Найти два соседних элемента массива, сумма которых наиболее близка к числу R, и вывести эти элементы в порядке возрастания их индексов (определение наиболее близких чисел дано в задании Array40).
var
N, i, K: integer;
R, min: real;
A: array[1..100] of real;
begin
write('R = ');
readln(R);
write('N = ');
readln(N);
writeln('Введите массив размера ', N, ':');
for i := 1 to N do read(a[i]); //вводим элементы массива
K := 2; //начальное значение номера нужного элемента
min := abs(a[K - 1] + a[K] - R); //начальное значение минимума
{ Проверяем остальные значения: }
for i := 3 to N do
if abs(a[i - 1] + a[i] - R) < min then begin //мы нашли меньшую разницу
min := abs(a[i - 1] + a[i] - R); //находим новый min
k := i //запоминаем номер
end;
writeln;
writeln('A[', K - 1, '] = ', A[K - 1], ', A[', K, '] = ', A[K])
end.
**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308**function** Abs(x: real): real;: Возвращает модуль числа x.**function** Abs(x: real): real;: Возвращает модуль числа x.**function** Abs(x: real): real;: Возвращает модуль числа x. * * *
А вот так задачу Array42 можно решить без использования массива:
var
N, i, K: integer;
a, b, a1, b1, R, min: real;
begin
write('R = ');
readln(R);
write('N = ');
readln(N);
writeln('Введите ', N, ' элементов:');
for i := 1 to N do
if i = 1 then read(a) //вводим а - первое число
else
if i = 2 then begin
read(b); //вводим b - второе число
min := abs(a + b - R); //начальное значение min
a1 := a; b1 := b; //запоминаем a и b
K := 2; //запоминаем индекс числа b
a := b //второе число делаем первым
end
else begin
read(b); //вводим второе число
if abs(a + b - R) < min then begin
min := abs(a + b - R); //находим новый min
a1 := a; b1 := b; //запоминаем a и b
K := i; //запоминаем индекс второго числа
end;
a := b //второе число делаем первым
end;
writeln;
writeln(' a[', K - 1, '] = ', a1, ', a[', K, '] = ', b1)
end.
**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308**function** Abs(x: real): real;: Возвращает модуль числа x.**function** Abs(x: real): real;: Возвращает модуль числа x.**function** Abs(x: real): real;: Возвращает модуль числа x. Array43. Дан целочисленный массив размера N, все элементы которого упорядочены (по возрастанию или по убыванию). Найти количество различных элементов в данном массиве.
Чтобы найти количество различных чисел в упорядоченном (!) массиве, достаточно сравнивать соседние элементы. Поэтому последовательность наших действий проста: если вводимый i-й элемент не равен предыдущему (i-1)-му, то количество Q различных чисел увеличивается на 1, начиная со второго элемента (i > 1). И здесь не важно, какая упорядоченность - по возрастанию или по убыванию.
var
i, N, Q: integer;
A: array[1..100] of integer;
begin
write('N = ');
readln(N);
Q := 1; //количество различных чисел равно как минимум 1
writeln('Введите ', N, ' целых чисел:');
for i := 1 to N do begin
read(a[i]); //вводим число
{ Если i-й элемент не совпадает с предыдущим, то
для всех i > 1 будем увеличивать количество Q: }
if (i > 1) and (a[i] <> a[i - 1]) then inc(Q)
end;
writeln;
writeln('Различных чисел: ', Q)
end.
**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1 * * *
А если массив не упорядоченный? Тогда последовательность действий усложняется: нужно вводимый i-й элемент сравнивать со всеми введенными ранее - 1-м, 2-м, 3-м, ..., (i - 1)-м. Если не находим ни одного совпадения, то увеличиваем число Q на 1.
Вводить числа будем случайным образом при помощи функции random(N) - случайное целое число от 0 до N-1. В таком случае программа для определения количества различных чисел в неупорядоченном массиве запишется следующим образом.
var
i, j, N, Q: integer;
A: array[1..100] of integer;
bln: boolean;
begin
write('N = ');
readln(N);
Q := 1; //количество различных чисел равно как минимум 1
randomize;
writeln('Введите ', N, ' целых чисел:');
for i := 1 to N do begin
///вводим числа:
a[i] := random(10); //находим случайное число от 0 до 9
write(a[i]:4); //выводим его на экран, выделяя ему 4 позиции
bln := false; //число a[i] отличное от предыдущих
{ Дальше сравниваем i-е число a[i] со всеми предыдущими
числами a[j] с индексами 1, 2, ..., i - 1: }
for j := 1 to i - 1 do
if a[i] = a[j] then begin //если i-е и j-е числа равны
bln := true; //число a[i] совпадает с предыдущим a[j]
break //и сразу выходим (не имеет смысла продолжать)
end;
{ Если равных элементов нет (bln = false), то
увеличиваем количество Q разных чисел на 1: }
if (bln = false) and (i > 1) then inc(Q)
end;
writeln;
writeln('Различных чисел: ', Q)
end.
**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647**type** boolean;: Представляет логическое значение.
**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).**const** false = False;: Представляет логическое значение.**const** true = True;: Представляет логическое значение.**const** false = False;: Представляет логическое значение.**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1 Array44. Дан целочисленный массив размера N, содержащий ровно два одинаковых элемента. Найти номера одинаковых элементов и вывести эти номера в порядке возрастания.
Последовательность действий следующая: сначала ставим по умолчанию количество совпадений (одинаковых элементов) равным 0 (Q := 0). Потом в цикле будем вводить элементы a[i], а также сравнивать введенный i-й элемент со всеми введенными ранее (смотрите выше Array43, второй вариант решения). Если совпадение есть (a[i] = a[j], j < i), то запоминаем номера j и i (i1 := j, i2 := i), а также увеличиваем Q на 1. Все это проверяем в том случае, если Q = 0, то есть до того момента, пока ещё не было совпадений.
var
i, j, N, Q, i1, i2: integer;
A: array[1..100] of integer;
begin
write('N = ');
readln(N);
Q := 0; //количество совпадений сначала равно 0
writeln('Введите ', N, ' целых чисел:');
for i := 1 to N do begin
read(a[i]); //вводим числа
{ Дальше сравниваем i-е число a[i] со всеми предыдущими
числами a[j] с индексами 1, 2, ..., i - 1 при том условии,
что совпадений ещё нет (Q = 0): }
if Q = 0 then
for j := 1 to i - 1 do
if a[i] = a[j] then begin //если i-е и j-е числа равны
i1 := j; i2 := i; //находим номера i1 и i2
inc(Q); //увеличиваем количество совпадений на 1
break //и сразу выходим (не имеет смысла продолжать)
end
end;
writeln;
writeln('Номера одинаковых элементов: ', i1:3, i2:3)
end.
**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1 В последних двух примерах мы воспользовались оператором выхода break – он предназначен для досрочного выхода из цикла. Рекомендую детально с ним ознакомится. На этом все, пишите в комментариях, если есть вопрорсы.