ВВЕРХ
ВНИЗ
  • Home
  • Array
  • Array 40 - 44

Array 40 - 44

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

Array40 - находим наиболее близкий к данному числу элемент массива.

Array41 - находим максимальную сумму соседних элементов массива.

Array42 - находим наиболее близкую к данному числу сумму соседних элементов массива.

Array43 - находим количество различных чисел в упорядоченном массиве.

Array44 - находим номера двух одинаковых элементов массива.

Array40. Дано число R и массив A размера N. Найти элемент массива, который наиболее близок к числу R (т. е. такой элемент AK, для которого величина |AK - R| является минимальной).

Последовательность действий при решении задачи Array40:

1)Сначала вводим элементы массива с помощью цикла for.

2)По умолчанию ставим K := 1 (K - номер числа, наиболее близкое к R).

3)Находим min := |a[i] - R| - начальная разность (по модулю) между a[1] и R.

4)Заходим в цикл и вводим следующее a[i] (начиная с i = 2, поскольку a[1] мы уже ввели).

5)Проверяем условие |a[i] - R| < min. Если оно выполняется, то новым min становится |a[i] - R|, а номер K := i.

6)После выхода из цикла выводим a[K], которое и будет наиболее близким к R.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
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.

*   *   *

Второй вариант решения Array40 отличается тем, что ввод чисел и проверка условий выполняются в одном цикле, кроме первого числа a[1], которое вводится перед вхождением в цикл.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
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.

*   *   *

Третий вариант решения задачи Array40 - все данные и проверку условий выполняем в одном цикле, используя логическую переменную first (индикатор ввода первого числа).

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
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.

Array41. Дан массив размера N. Найти два соседних элемента, сумма которых максимальна, и вывести эти элементы в порядке возрастания их индексов.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
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.

Array42. Дано число R и массив размера N. Найти два соседних элемента массива, сумма которых наиболее близка к числу R, и вывести эти элементы в порядке возрастания их индексов (определение наиболее близких чисел дано в задании Array40).

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
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.

*   *   *

А вот так задачу Array42 можно решить без использования массива:

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
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.

Array43. Дан целочисленный массив размера N, все элементы которого упорядочены (по возрастанию или по убыванию). Найти количество различных элементов в данном массиве.

Чтобы найти количество различных чисел в упорядоченном (!) массиве, достаточно сравнивать соседние элементы. Поэтому последовательность наших действий проста: если вводимый i-й элемент не равен предыдущему (i-1)-му, то количество Q различных чисел увеличивается на 1, начиная со второго элемента (i > 1). И здесь не важно, какая упорядоченность - по возрастанию или по убыванию.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
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.

*   *   *

А если массив не упорядоченный? Тогда последовательность действий усложняется: нужно вводимый i-й элемент сравнивать со всеми введенными ранее - 1-м, 2-м, 3-м, ..., (i - 1)-м. Если не находим ни одного совпадения, то увеличиваем число Q на 1.

Вводить числа будем случайным образом при помощи функции random(N) - случайное целое число от 0 до N-1. В таком случае программа для определения количества различных чисел в неупорядоченном массиве запишется следующим образом.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
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.

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, то есть до того момента, пока ещё не было совпадений.


Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
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.

В последних двух примерах мы воспользовались оператором выхода break – он предназначен для досрочного выхода из цикла. Рекомендую детально с ним ознакомится. На этом все, пишите в комментариях, если есть вопрорсы.

← Назад
Вперед →
Яндекс.Метрика