ВВЕРХ
ВНИЗ
  • Home
  • Series
  • Series 17 - 23

Series 17 - 23

Series17 — В упорядоченную по возрастанию последовательность вставить число.

Series18 — Вывести различные элементы упорядоченной последовательности.

Series19 — Выводим элементы меньшие своего левого соседа.

Series20 — Выводим элементы меньшие своего правого соседа.

Series21 — Проверяем, является ли последовательность возрастающей.

Series22 — Проверяем, является ли последовательность убывающей.

Series23 — Проверяем, является ли последовательность "пилообразной".

Series17. Дано вещественное число B, целое число N и набор из N вещественных чисел, упорядоченных по возрастанию. Вывести элементы набора вместе с числом B, сохраняя упорядоченность выводимых чисел.

Последовательность действий в задаче Series17 такова:

1)Вводим B(вещественное число) и N(целое число);

2)Назначачаем индикатору first значение false, означающее, что ещё не найдено первого числа последовательности, превышающего В;

3)Заходим в цикл, каждый раз вводя вещественные числа А в порядке возрастания;

4)Проверяем условие: если число В ещё не вставлено в последовательность, и мы ввели А, не меньшее В, то выводим В, и меняем индикатор first на противоположный (true) - число В выведено. В последнем случае условие проверяться больше не будет, поскольку индикатор first изменен;

5)После проверки условия выводим А;

6)После выхода из цикла, если индикатор 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  
var
  N, i: integer;
  B, A: real;
  first: boolean;{ индикатор: 
   first=false - "число В ещё не вставлено"
   first=true - "число В уже вставлено в список" }

begin
  write('B = ');
  readln(B);
  write('N = ');
  readln(N);
  first := false; //число В еще не вставили в последовательность
  writeln(N, ' чисел в порядке возрастания:');
  for i := 1 to N do begin
    read(A); //вводим вещественное число
    //Далее находим первое число А, не меньшее В, 
    //и вставляем перед ним В:
    if (B <= A)and(first = false) then begin
      write(' ', B); //вставляем число В перед А
      first := true //меняем индткатор - "число В вставлено"
    end;
    write(' ', A) //выводим А
  end; 
  //если В не ввели раньше (first = false), то выводим его в конце:
  if first = false then write(B) 
end.

Series18. Дано целое число N и набор из N целых чисел, упорядоченный по возрастанию. Данный набор может содержать одинаковые элементы. Вывести в том же порядке все различные элементы данного набора.

В этом задании, как и в предыдущем, числа вводятся в порядке возрастания (это условие). Первое введенное число a выводим сразу при первом заходе в цикл (каковы бы ни были последующие числа), и тут же его запоминаем: b := a. При следующих заходах в цикл сравниваем вновь введеное число с предыдущим b - если новое число больше предыдущего (не равно ему), то выводим на экран. Потом снова запоминаем (b := a) и т.д. В результате этого мы получим последовательность различных чисел из данной последовательности. Ещё раз надо напомнить: последовательность должна быть возрастающей.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
var
  N, a, i, b: integer;

begin
  write('N = ');
  readln(N);
  writeln('Введите ', N, ' целых возрастающих чисел:');
  for i := 1 to N do begin
    read(a); //вводим число
    if i = 1 then write(' ', a) //выводим первое число
    else //остальные случаи i > 1: 
      if (a > b) then write(' ', a);
    b := a //запоминаем последнее выведенное число
  end
end.

Series19. Дано целое число N (> 1) и набор из N целых чисел. Вывести те элементы в наборе, которые меньше своего левого соседа, и количество K таких элементов.

Чтобы вывести числа меньшие своего левого соседа, будем проверять на истинность условие a < Left, где a - введенное на данной итерации цикла число, Left - соседнее слева число, то есть введенное на один шаг ранее. Если условие выполняется, то выводим а и увеличиваем количество K таких чисел на 1. А после проверки запоминаем введенное число: Left := a (при следующем заходе в цикл Left будет левым по отношению к новому введенному элементу).

Код 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, a, Left: integer;
  i, K: byte;

begin
  write('N = ');
  readln(N);
  K := 0; //начальное количество требуемых чисел
  writeln('Введите ', N, ' целых чисел:');
  for i := 1 to N do begin
    read(a); //вводим число
    if i > 1 then //проверяем со второго значения
     { Проверяем условие. По отношению к а Left будет левым: }
      if (a < Left) then begin //условие
        write(' ', a);//выводим нужное число
        inc(K) //увеличиваем количество на 1
      end;
    Left := a //запоминаем число после проверки условия
  end;
  writeln;
  if K > 0 then write('количество таких чисел: ', K)
  else write('таких чисел не существует') 
end.

Series20. Дано целое число N (> 1) и набор из N целых чисел. Вывести те элементы в наборе, которые меньше своего правого соседа, и количество K таких элементов.

Здесь почти так же, как и в предыдущей задаче (см. комментарии к Series19), только с двумя отличиями: во-первых, вводимое число мы сразу будем считать правым соседом (Right - правый сосед числа а), а во-вторых, в связи с этим присваивание будет идти в обратную сторону: a := Right (в предыдущем примере было Left := a). Условие то же: a < Right.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
var
  N, a, Right: integer;
  i, K: byte;

begin
  write('N = ');
  readln(N);
  K := 0; //начальное количество требуемых чисел
  writeln('Введите ', N, ' целых чисел:');
  for i := 1 to N do begin
    read(Right); //вводим число
    if i > 1 then //проверяем, начиная со второго значения
      if (a < Right) then begin //левое число меньше правого
        write(a, ' '); //выводим число слева (по отн. к Right)
        inc(K) //увеличиваем количество на 1
      end;
    a := Right //запоминаем число
  end;
  writeln;
  if K > 0 then write('количество таких чисел: ', K)
  else write('таких чисел не существует') 
end.

Series21. Дано целое число N (> 1) и набор из N вещественных чисел. Проверить, образует ли данный набор возрастающую последовательность. Если образует, то вывести True, если нет — вывести False.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
var
  a, Prev: real;
  N, i: byte;
  IncSeq: boolean;

begin
  write('N = ');
  readln(N);
  IncSeq := true; //последовательность по умолчанию возрастающая
  writeln('Введите ', N, ' вещественных чисел:');
  for i := 1 to N do begin
    read(a);
    if i > 1 then
      if IncSeq then //Проверяем, пока последов. возрастающая
        if not (a > Prev) then //число а не больше предыдущего
          IncSeq := false; //нарушение закономерности
    Prev := a //запоминаем последнее введенное число
  end;
  writeln;
  writeln(IncSeq) //Выводим true или false
end.

В последнем примере Series21, начиная от второго элемента нам достаточно найти хотя бы одно число, которое меньше или равно предыдущему: в этом случае дальнейшую проверку можно не проходить, так как закономерность нарушена. Поэтому, найдя число, мы поменяем индикатор IncSec на противоположный (false - последовательность не возрастающая), и дальнейшая проверка проходить не будет.

Series22. Дано целое число N (> 1) и набор из N вещественных чисел. Если данный набор образует убывающую последовательность, то вывести 0; в противном случае вывести номер первого числа, нарушающего закономерность.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
var
  a, Prev: real;
  N, i, k: byte;

begin
  write('N = ');
  readln(N);
  k := 0; //последовательность по умолчанию убывающая
  writeln('Введите ', N, ' вещественных чисел:');
  for i := 1 to N do 
  begin
    read(a);
    if i > 1 then
      if k = 0 then //Проверяем, пока последов. убывающая
        if not (a < Prev) then k := i; //запоминаем номер i
    Prev := a //запоминаем последнее введенное число
  end;
  writeln;
  writeln(k) //Выводим k
end.

Series23. Дано целое число N (> 2) и набор из N вещественных чисел. Набор называется пилообразным, если каждый его внутренний элемент либо больше, либо меньше обоих своих соседей (т. е. является «зубцом»). Если данный набор является пилообразным, то вывести 0; в противном случае вывести номер первого элемента, не являющегося зубцом.

Иными словами, пилообразная последовательность - это та, в которой каждый элемент является либо локальным минимумом (меньше своих обеих соседей), либо локальным максимумом (соответственно больше левого и правого соседа). Больше можно посмотреть на странице Array 32-36.

Пилообразная последовательность в Pascal

Код 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  
var
  a, Left, Right: real;
  N, i, Number: byte;

begin
  write('N = ');
  readln(N);
  Number := 0; //Последовательность пилообразная по умолчанию
  writeln('Введите ', N, ' вещественных чисел:');
  for i := 1 to N do begin
    read(Right); //Вводим элемент, считая его правым соседом
    if i = 1 then Left := Right //призначаем число слева
    else
    if i = 2 then a := Right //призначаем средний элемент
    else begin //i > 2
      if Number = 0 then //Условие пилообразности
        if not (((a < Right) and (a < Left)) or 
               ((a > Right) and (a > Left))) then Number := i;
      Left := a; //левый сосед стает средним числом
      a := Right  //среднее стает на место правого соседа
    end
  end;
  writeln;
  if Number = 0 then 
    writeln('Последовательность пилообразная')
  else 
    writeln('Номер элемента, нарушающего закономерность: ', Number)
end.

Рекомендую также посмотреть похожий материал Наборы элементов оканчивающиеся нулем.


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