Root /ArchiveAbout
()

Series 17 - 23

Series 17 - 23

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

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

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.

**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;: Представляет логическое значение. **const** false = False;: Представляет логическое значение. **const** true = True;: Представляет логическое значение. **const** false = False;: Представляет логическое значение. Series18. Дано целое число N и набор из N целых чисел, упорядоченный по возрастанию. Данный набор может содержать одинаковые элементы. Вывести в том же порядке все различные элементы данного набора.

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

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.

**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647 Series19. Дано целое число N (> 1) и набор из N целых чисел. Вывести те элементы в наборе, которые меньше своего левого соседа, и количество K таких элементов.

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

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.

**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647 **type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255 **procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1 Series20. Дано целое число N (> 1) и набор из N целых чисел. Вывести те элементы в наборе, которые меньше своего правого соседа, и количество K таких элементов.

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

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.

**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647 **type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255 **procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1 Series21. Дано целое число N (> 1) и набор из N вещественных чисел. Проверить, образует ли данный набор возрастающую последовательность. Если образует, то вывести True, если нет — вывести False.

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.

**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308 **type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255 **type** boolean;: Представляет логическое значение. **const** true = True;: Представляет логическое значение. **const** false = False;: Представляет логическое значение. В последнем примере Series21, начиная от второго элемента нам достаточно найти хотя бы одно число, которое меньше или равно предыдущему: в этом случае дальнейшую проверку можно не проходить, так как закономерность нарушена. Поэтому, найдя число, мы поменяем индикатор IncSec на противоположный (false - последовательность не возрастающая), и дальнейшая проверка проходить не будет.

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

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.

**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308 **type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255 Series23. Дано целое число N (> 2) и набор из N вещественных чисел. Набор называется пилообразным, если каждый его внутренний элемент либо больше, либо меньше обоих своих соседей (т. е. является «зубцом»). Если данный набор является пилообразным, то вывести 0; в противном случае вывести номер первого элемента, не являющегося зубцом.

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

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

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.

**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 - 16 Диапазон значений: -1.8∙10308 .. 1.8∙10308 **type** byte;: Представляет 8-битовое целое число без знака.Диапазон значений: 0..255 Рекомендую также посмотреть похожий материал Наборы элементов оканчивающиеся нулем.