ВВЕРХ
ВНИЗ
  • Home
  • Array
  • Array 32 - 36

Array 32 - 36

На этой странице рассматриваются задачи Array32 - Array36 из задачника Абрамяна, где речь идет о так званых локальных элементах числовой последовательности: локальных максимумах и локальных минимумах.

Сразу сделаем одно важное замечание: во всех следующих программах ввод данных по умолчанию определен как ручной (через оператор ввода read). Но если вы хотите ввод сделать автоматическим (через генератор случайных чисел random), то ввод данных в программе замените на следующий кусок кода:

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
///АВТОМАТИЧЕСКИЙ ВВОД ДАННЫХ
randomize; //генератор псевдослучайных чисел
N := 10 + random(191); //количество чисел в массиве
writeln('Массив ', N, ' случайных целых чисел:');
writeln;
for i := 1 to N do
begin
  mass[i] := -100 + random(201);
  write(' ', mass[i]); //выводим элементы массива
end;
writeln;

В последнем случае вы получите массив случайно сгенерированных целых чисел с диапазона [-100, 100].

Array32. Дан массив размера N. Найти номер его первого локального минимума (локальный минимум — это элемент, который меньше любого из своих соседей).

Код 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  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
var
  Mass: array[1..100] of integer;
  i, N, num: integer;
  
begin
    ///ВВОД ДАННЫХ
  write(' N = ');
  readln(N);
  writeln('Введите ', N, ' целых чисел:');
  writeln;
  for i := 1 to N do
    read(mass[i]); //вводим элементы массива
    ///ОСНОВНАЯ ПРОГРАММА
  writeln;
  num := 0; //начальный номер локального минимума
  write('Результат: ');
 { Проверяем все значения масива от 1 до N. Причем учитываем, 
 что 1-й и N-й элементы имеют только 1 соседний элемент: }
  for i := 1 to N do
  begin { Проверяем 1-й элемент: }
    if i = 1 then 
    begin //если 1-й элемент меньше 2-го
      if mass[1] < mass[2] then
        num := 1 //то номеру локального минимума присваиваем 1
    end
    else { Проверяем N-й элемент: }
    if i = N then 
    begin //если N-й элемент меньше (N - 1)-го
      if mass[N] < mass[N - 1] then
        num := N //то номеру локального минимума присваиваем N
    end { Проверяем все остальные элементы: }
    else //если i-й элемент находится между (i - 1)-м и (i + 1)-м
    if (mass[i] < mass[i - 1])and(mass[i] < mass[i + 1]) then
      num := i; //то номеру локального минимума присваиваем i
    if num > 0 then //если номер изменился, то выводим результат
    begin 
      writeln('Номер первого локального минимума: ', num); 
      exit //и сразу выходим (дальше не имеет смысла проверять)
    end
  end;
 { Если мы раньше не вышли из программы, то выводим сообщение: } 
  writeln('Локального минимума нет.')
end.

Array33. Дан массив размера N. Найти номер его последнего локального максимума (локальный максимум — это элемент, который больше любого из своих соседей).

Код 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  
33  
34  
35  
36  
37  
38  
39  
var
  Mass: array[1..100] of integer;
  i, N, num: integer;
  
begin
    ///ВВОД ДАННЫХ
  write(' N = ');
  readln(N);
  writeln('Введите ', N, ' целых чисел:');
  writeln;
  for i := 1 to N do
    read(mass[i]); //вводим элементы массива
    ///ОСНОВНАЯ ПРОГРАММА
  writeln;
  num := 0; //начальный номер локального максимума
  write('Результат: ');
 { Проверяем все значения масива от 1 до N. Причем учитываем, 
 что 1-й и N-й элементы имеют только 1 соседний элемент: }
  for i := 1 to N do
  begin { Проверяем 1-й элемент: }
    if i = 1 then 
    begin //если 1-й элемент больше 2-го
      if mass[1] > mass[2] then
        num := 1 //то номеру локального максимума присваиваем 1
    end
    else { Проверяем N-й элемент: }
    if i = N then 
    begin //если N-й элемент больше (N - 1)-го
      if mass[N] > mass[N - 1] then
        num := N //то номеру локального максимума присваиваем N
    end { Проверяем все остальные элементы: }
    else //если i-й элемент больше (i - 1)-го и (i + 1)-го
    if (mass[i] > mass[i - 1])and(mass[i] > mass[i + 1]) then
      num := i; //то номеру локального максимума присваиваем i
  end;
 { Если номер изменился (отличен от 0), то выводим его: } 
  if num > 0 then writeln(num)
  else writeln('локального максимума нет.') //иначе - сообщение
end.

Array34. Дан массив размера N. Найти максимальный из его локальных минимумов (определение локального минимума дано в задании Array32).

Код 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  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
var
  Mass: array[1..100] of integer;
  i, N, num: integer;
  Max_LocalMin: integer;
  b: boolean; {false - не локальный минимум, true - локальный }
  
begin
    ///ВВОД ДАННЫХ
  write(' N = ');
  readln(N);
  writeln('Введите ', N, ' целых чисел:');
  writeln;
  for i := 1 to N do
    read(mass[i]); //вводим элементы массива
    ///ОСНОВНАЯ ПРОГРАММА
  writeln;
  num := 0; //начальный номер локального минимума
  Max_LocalMin := -MaxInt; //минимальное целое число типа integer 
  write('Результат: ');
 { Проверяем все значения масива от 1 до N. Причем учитываем, 
 что 1-й и N-й элементы имеют только 1 соседний элемент: }
  for i := 1 to N do
  begin 
    b := false; //не локальный минимум
   { Проверяем 1-й элемент: }
    if i = 1 then 
    begin //если 1-й элемент меньше 2-го
      if mass[1] < mass[2] then begin
        num := 1; //то номеру присваиваем 1
        b := true //мы нашли локальный минимум
      end  
    end
    else { Проверяем N-й элемент: }
    if i = N then 
    begin //если N-й элемент меньше (N - 1)-го
      if mass[N] < mass[N - 1] then begin
        num := N; //то номеру присваиваем N
        b := true //мы нашли локальный минимум
      end  
    end { Проверяем все остальные элементы: }
    else //если i-й элемент находится между (i - 1)-м и (i + 1)-м
    if (mass[i] < mass[i - 1])and(mass[i] < mass[i + 1]) then 
    begin
      num := i; //то номеру присваиваем i
      b := true //мы нашли локальный минимум
    end;  
   { Если i-й элемент - локальный минимум - больше максимума: }
    if b then { то он становится максимальным: }
      if mass[i] > Max_LocalMin then Max_LocalMin := mass[i]
  end;
 { Если номер изменился (отличен от 0), то выводим MaxLocal: } 
  if num > 0 then writeln(Max_LocalMin)
  else writeln('локального минимума нет.') //иначе - сообщение
end.

Array35. Дан массив размера N. Найти минимальный из его локальных максимумов (определение локального максимума дано в задании Array33).

Код 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  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
var
  Mass: array[1..100] of integer;
  i, N, num: integer;
  Min_LocalMax: integer;
  b: boolean; {b = true - локальный максимум, 
               b = false - не локальный максимум }
  
begin
    ///ВВОД ДАННЫХ
  write(' N = ');
  readln(N);
  writeln('Введите ', N, ' целых чисел:');
  writeln;
  for i := 1 to N do
    read(mass[i]); //вводим элементы массива
    ///ОСНОВНАЯ ПРОГРАММА
  writeln;
  num := 0; //начальный номер локального максимума
  Min_LocalMax := MaxInt; //максимальное целое число типа integer 
  write('Результат: ');
 { Проверяем все значения масива от 1 до N. Причем учитываем, 
 что 1-й и N-й элементы имеют только 1 соседний элемент: }
  for i := 1 to N do
  begin 
    b := false; //не локальный максимум
    { Проверяем 1-й элемент: }
    if i = 1 then 
    begin //если 1-й элемент больше 2-го
      if mass[1] > mass[2] then begin
        num := 1; //то номеру присваиваем 1
        b := true //мы нашли локальный максимум
      end  
    end
    else { Проверяем N-й элемент: }
    if i = N then 
    begin //если N-й элемент больше (N - 1)-го
      if mass[N] > mass[N - 1] then begin
        num := N; //то номеру присваиваем N
        b := true //мы нашли локальный максимум
      end  
    end { Проверяем все остальные элементы: }
    else //если i-й элемент больше (i - 1)-го и (i + 1)-го
    if (mass[i] > mass[i - 1])and(mass[i] > mass[i + 1]) then 
    begin
      num := i; //то номеру присваиваем i
      b := true //мы нашли локальный максимум
    end;  
   { Если i-й элемент - локальный максимум - меньше минимума: }
    if b then { то он становится минимальным лок. макс.: }
      if mass[i] < Min_LocalMax then Min_LocalMax := mass[i]
  end;
  { Если номер локального максимума num изменился (отличен от 0), 
  то есть мы нашли локальный максимум, то выводим минимальный
  из таких максимумов (Min_LocalMax): }
  if num > 0 then writeln(Min_LocalMax)
  else writeln('локального минимума нет.') //иначе - сообщение
end.

Array36. Дан массив размера N. Найти максимальный из его элементов, не являющихся ни локальным минимумом, ни локальным максимумом (определения локального минимума и локального максимума даны в заданиях Array32 и Array33). Если таких элементов в массиве нет, то вывести 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  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
var
  Mass: array[1..20] of integer;
  i, N: integer;
  Max_NotLocal: integer; //максимальный не локальный элемент
  num: real; //номер не локального элемента
  b: boolean; { b = true - локальный элемент,
                b = false - не локальный элемент }
 
begin
    ///ВВОД ДАННЫХ
  write(' N = ');
  readln(N);
  writeln('Введите ', N, ' целых чисел:');
  writeln;
  for i := 1 to N do
    read(mass[i]); //вводим элементы массива
    ///ОСНОВНАЯ ПРОГРАММА
  num := 0; //начальный номер локального минимума
  Max_NotLocal := -MaxInt; //минимальное целое число типа integer
  write('Результат: ');
 { Проверяем все значения масива от 1 до N. Причем учитываем,
 что 1-й и N-й элементы имеют только 1 соседний элемент: }
  for i := 1 to N do
  begin
    b := false; //не локальный минимум
   { Проверяем 1-й элемент: }
    if i = 1 then
    begin //если 1-й элемент равен 2-му
      if mass[1] = mass[2] then begin
        num := 1; //то номеру присваиваем 1
        b := true //мы нашли не локальное число
      end
    end
    else { Проверяем N-й элемент: }
    if i = N then
    begin //если N-й элемент равен (N - 1)-му
      if mass[N] = mass[N - 1] then begin
        num := N; //то номеру присваиваем N
        b := true //мы нашли не локальное число
      end  
    end { Проверяем все остальные элементы: }
    else { Если последовательность элементов
         mass[i - 1], mass[i] и mass[i + 1] монотонна: }
    if (mass[i] <= mass[i - 1])and(mass[i] >= mass[i + 1])or
       (mass[i] >= mass[i - 1])and(mass[i] <= mass[i + 1]) then
    begin
      num := i; //то номеру присваиваем i
      b := true //мы нашли не локальное число
    end;  
   { Если i-й элемент (не локальный элемент) больше максимума: }
    if b then { то он становится максимальным: }
      if mass[i] > Max_NotLocal then Max_NotLocal := mass[i]
  end;
 { Если номер не локального элемента изменился (отличен от 0),
 то выводим максимальный из таких элементов - Max_NotLocal: }
  if num > 0 then writeln(Max_NotLocal)
  else writeln(num) //иначе выводим num = 0
end.


Яндекс.Метрика