ВВЕРХ
ВНИЗ
  • Home
  • Proc
  • Proc 10 - 15

Proc 10 - 15 задачника Абрамяна

Приветствую всех! Здесь мы рассматриваем процедуры, в которых описываем изменение содержимого двух чисел процедурой Swap, нахождение максимумов и минимумов, упорядочение трех чисел по возрастанию и убыванию, а также циклический сдвиг трех элементов вправо или влево на 1 элемент.

Proc10. Описать процедуру Swap(X, Y), меняющую содержимое переменных X и Y (X и Y — вещественные параметры, являющиеся одновременно входными и выходными). С ее помощью для данных переменных A, B, C, D последовательно поменять содержимое следующих пар: A и B, C и D, B и C и вывести новые значения A, B, C, D.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
{ Процедура меняет содержимое вещественных переменных X и Y }
procedure Swap(var X, Y: real);
var
  c: real; { <-- промежуточная переменная }
begin
  c := X; { <== запоминаем значение X }
  X := Y; { <== переменной X присваиваем значение Y }
  Y := c  { <== переменной Y присваиваем c, равное X }
end;

var
  A, B, C, D: real;

begin
  writeln('Введите вещественные переменные A, B, C и D: ');
  readln(A, B, C, D);
  { Вызываем процедуру 3 раза и выводим новые значения: } 
  Swap(A, B); { <== меняем значения переменных A и B }
  Swap(C, D); { <== меняем значения переменных C и D }
  Swap(B, C); { <== меняем значения переменных B и C }
  writeln('Новые значения: ', A, ' ', B, ' ', C, ' ', D);
  readln
end.

Proc11. Описать процедуру Minmax(X, Y), записывающую в переменную X минимальное из значений X и Y, а в переменную Y — максимальное из этих значений (X и Y — вещественные параметры, являющиеся одновременно входными и выходными). Используя четыре вызова этой процедуры, найти минимальное и максимальное из данных чисел A, B, C, D.

Вариант 1 для описания процедуры Minmax(X, Y). Сначала решим эту задачу, используя тот же принцип, что и в предыдущей задаче – изменять значения X и Y местами. Только, если в задаче Proc10 процедура Swap(X, Y) изменяла значения переменных X и Y в любом случае, то процедура Minmax(X, Y) будет это делать только в том случае, если числа X и Y расположенны по убыванию (X > Y). Если переменные X и Y расположенны по возрастанию, то процедура реагировать не будет: переменная X и так будет минимальной, а Y – максимальной.

Код 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  
{ Процедура записывает в переменную X минимальное,
а в переменную Y - максимальное из значений X и Y }
procedure Minmax(var X, Y: real);
var
  c: real; { <-- временная переменная }
{ Тело основной процедуры Minmax(X, Y) } 
begin
 { Если X больше Y, то значения переменных меняем 
 местами, в противном случае ничего не изменится: }
  if X > Y then begin
    c := X; { <== запоминаем X }
    X := Y; { <== Y записываем в X }
    Y := c  { <== Y присваиваем с, равное X }
  end
end;

  { ОСНОВНАЯ ПРОГРАММА }

var
  A, B, C, D: real;

begin
  writeln('Введите вещественные числа A, B, C и D: ');
  readln(A, B, C, D);
  { Вызываем процедуру 4 раза, последовательно находя 
  при этом минимальное и максимальное значение: }
  Minmax(A, B); { <== A - минимальное, B - максимальное }
  Minmax(B, C); { <== B - минимальное, C - максимальное }
  Minmax(C, D); { <== C - минимальное, D - максимальное }
  Minmax(D, A); { <== D - минимальное, A - максимальное }
  writeln;
  writeln('Минимальное: ', D);
  writeln('Максимальное: ', A);
  readln
end.

*   *   *

Вариант 2 для описания процедуры Minmax(X, Y). Из задачи Proc10 нам известна процедура Swap(X, Y) по изменению значений чисел X и Y. Давайте используем данную процедуру в задаче Proc11. Нам нужно в пременную X записать наименьшее из значений, а в Y – наибольшее. Естественно, что если X < Y, то процедуру Minmax(X, Y) бессмысленно вызывать, так как X и так будет минимальным, а Y – максимальным.

Тогда опишем процедуру Minmax(X, Y) так, что если X > Y, то будет вызываться другая, дополнительная процедура Swap(X, Y), которая изменит значения переменных (X станет меньшим, Y – большим). Эту процедуру "вставим" внутри данной процедуры Minmax(X, Y). Для этого из задачи Proc10 берем и полностью копируем процедуру Swap(X, Y), и вставляем сразу после описания основной процедуры Minmax(X, Y), до того момента, как началась выполняться данная процедура. В этом случае процедура Swap(X, Y) будет как бы вспомогательной по отношению к основной в данном случае процедуре.

А теперь берем предыдущий вариант процедуры Minmax(X, Y), и в теле этой процедуры (между begin и end) вместо кода:

if X > Y then begin
    c := X; //запоминаем X
    X := Y; //X меняем на Y
    Y := c  //Y присваиваем с, равной X
end

при тех же условиях (X > Y) ставим вызов процедуры Swap(X, Y):

if X > Y then Swap(X, Y)

То есть вместо блока операторов между begin-end ставим просто одну процедуру, которая выполнит необходимые вычисления. А теперь объединим всё это вместе и запишем второй вариант решения задачи Proc11 задачника Абрамяна, используя вспомогательную процедуру Swap(X, Y) из задачи Proc10. Вот как это будет выглядеть:

Код 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  
{ Процедура записывает в переменную X минимальное, 
а в переменную Y - максимальное из значений X и Y }
procedure Minmax(var X, Y: real);

  { Процедура меняет содержимое переменных X и Y }
  procedure Swap(var X, Y: real);
  var
    c: real; { <-- промежуточная переменная }
  begin
    c := X; { <== запоминаем значение X }
    X := Y; { <== переменной X присваиваем значение Y }
    Y := c  { <== переменной Y присваиваем c, равное X }
  end;

{ Тело основной процедуры Minmax(X, Y) } 
begin
 { Если X больше Y, то вызываем процедуру Swap(X, Y) для 
 изменения содержимого чисел X и Y: }
  if X > Y then Swap(X, Y)
end;

  { ОСНОВНАЯ ПРОГРАММА }

var
  A, B, C, D: real;

begin
  writeln('Введите вещественные A, B, C, D: ');
  readln(A, B, C, D);
  { Вызываем процедуру 4 раза, последовательно находя 
  при этом минимальное и максимальное значение: }
  Minmax(A, B); { <== A - минимальное, B - максимальное }
  Minmax(B, C); { <== B - минимальное, C - максимальное }
  Minmax(C, D); { <== C - минимальное, D - максимальное }
  Minmax(D, A); { <== D - минимальное, A - максимальное }
  writeln;
  writeln('Минимальное: ', D);
  writeln('Максимальное: ', A);
  readln
end.

Proc12. Описать процедуру SortInc3(A, B, C), меняющую содержимое переменных A, B, C таким образом, чтобы их значения оказались упорядоченными по возрастанию (A, B, C — вещественные параметры, являющиеся одновременно входными и выходными). С помощью этой процедуры упорядочить по возрастанию два данных набора из трех чисел: (A1, B1, C1) и (A2, B2, C2).

В этой задаче для записи 3-х чисел в порядке возрастания мы используем уже знакомую процедуру Minmax(X, Y) из задачи Proc11, которая переписывает 2 числа в порядке возрастания. В той задаче у нас было 2 варианта для процедуры Minmax(X, Y), здесь будем использовать 1-й вариант. В задании Proc12 данная процедура выступает в роли вспомогательной процедуры по отношению к основной SortInc3(A, B, C), которая и вызывает 3 раза процедуру Minmax(X, Y).

Код 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  
{ Процедура записывает значения переменных A, B, C по возрастанию }
procedure SortInc3(var A, B, C: real);

 { Процедура переписывает две переменные A и B по возрастанию }
 procedure Minmax(var A, B: real);
 var
   c: real;
 { Тело внутренней процедуры Minmax(А, В) }
 begin
  { Если A больше B, то значения переменных меняем 
  местами, в противном случае ничего не изменится: }
   if A > B then begin 
     c := A; { <== запоминаем A }
     A := B; { <== A меняем на B }
     B := c  { <== B присваиваем с, равной A }
   end
 end;

{ Тело основной процедуры SortInc3(A, B) }
begin
  Minmax(A, B);
  Minmax(A, C);
  Minmax(B, C)
end;

var
  A1, B1, C1, A2, B2, C2: real;

begin
  writeln('Введите вещественные числа A1, B1, C1: ');
  readln(A1, B1, C1); { <-- вводим числа A1, B1, C1 }
  SortInc3(A1, B1, C1); { <-- Сортируем A1, B1, C1 по возрастанию }
  writeln('Числа по возрастанию: ', A1, ' ', B1, ' ', C1);
  writeln('Введите вещественные числа A2, B2, C2: ');
  readln(A2, B2, C2); { <-- вводим числа A2, B2, C2 }
  SortInc3(A2, B2, C2); { <-- Сортируем A2, B2, C2 по возрастанию }
  writeln('Числа по возрастанию: ', A2, ' ', B2, ' ', C2);
  readln
end.

Proc13. Описать процедуру SortDec3(A, B, C), меняющую содержимое переменных A, B, C таким образом, чтобы их значения оказались упорядоченными по убыванию (A, B, C — вещественные параметры, являющиеся одновременно входными и выходными). С помощью этой процедуры упорядочить по убыванию два данных набора из трех чисел: (A1, B1, C1) и (A2, B2, C2).

Вариант 1 для описания процедуры SortDec3(A, B, C). В этом случае для её описания 3 раза используем тело процедуры Mimmax(X, Y) из задачи Proc11, которая записывает переменные в порядке возрастания, но при этом саму процедуру как вспомогательную к основной SortDec3(A, B, C) не используем.

Код 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  
{ Процедура записывает значения 
 переменных A, B, C по убыванию }
procedure SortDec3(var A, B, C: real);
var
  t: real;
{ Тело процедуры SortDec3(A, B, C) }
begin
 { Если пары чисел по возрастанию, 
 то меняем их значения местами: }
  if A < B then begin
    t := B;
    B := A;
    A := t
  end;
  if A < C then begin
    t := C;
    C := A;
    A := t
  end;
  if B < C then begin
    t := C;
    C := B;
    B := t
  end
end;

  { ОСНОВНАЯ ПРОГРАММА }

var
  A, B, C: real;
  i: byte;

begin
  for i := 1 to 2 do { <-- Повторяем два раза }
  begin
    writeln('Введите три вещественные числа: ');
    readln(A, B, C); { <-- вводим числа A, B, C }
    SortDec3(A, B, C); { <-- упорядочиваем числа по убыванию }
    writeln('Числа по убыванию: ', A, ' ', B, ' ', C)
  end;
  readln
end.

Но это в общем случае неправильный вариант решения задач (использовать реализацию некоторой процедуры несколько раз внутри другой, не описывая самой процедуры). Вместо того, чтобы 1 раз описать процедуру Minmax(X, Y), а потом 3 раза вызвать, мы 3 раза полностью использовали её код. Это крайне неэффективный способ и так делать нельзя. Смотрите следующий вариант решения.

*   *   *

Вариант 2 для описания процедуры SortDec3(A, B, C). Здесь мы как раз используем недостающую процедуру Minmax(X, Y) по перезаписи чисел X и Y в порядке возрастания из задачи Proc11 (первый вариант решения). Данный вариант решения аналогичен решению в примере Proc12, только здесь надо числа A, B, C размещать в порядке убывания, а это значит, что числа С, В, А должны распологаться в порядке возрастания. Больше ничего не изменится.

Код 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  
{ Процедура записывает значения переменных A, B, C по убыванию }
procedure SortDec3(var A, B, C: real);

 { Процедура переписывает две переменные X и Y по возрастанию }
 procedure Minmax(var X, Y: real);
 var
   c: real; { <-- промежуточная переменная }
 { Тело внутренней процедуры Minmax(X, Y) }
 begin
  { Если X больше Y, то значения переменных меняем 
  местами, в противном случае ничего не изменится: }
   if X > Y then begin 
     c := X;
     X := Y;
     Y := c
   end
 end;

{ Тело основной процедуры SortDec3(A, B, C) }
begin
  Minmax(C, B);
  Minmax(C, A);
  Minmax(B, A)
end;

 { ОСНОВНАЯ ПРОГРАММА }

var
  A1, B1, C1, A2, B2, C2: real;

begin
  writeln('Введите вещественные числа A1, B1, C1: ');
  readln(A1, B1, C1); { <-- вводим числа A1, B1, C1 }
  SortDec3(A1, B1, C1); { <-- вызываем процедуру с параметрами A1, B1, C1 }
  writeln('Числа по убыванию: ', A1, ' ', B1, ' ', C1);
  writeln;
  writeln('Введите вещественные числа A2, B2, C2: ');
  readln(A2, B2, C2); { <-- вводим числа A2, B2, C2 }
  SortDec3(A2, B2, C2); { <-- вызываем процедуру с параметрами A2, B2, C2 }
  writeln('Числа по убыванию: ', A2, ' ', B2, ' ', C2);
  readln
end.

Proc14. Описать процедуру ShiftRight3(A, B, C), выполняющую правый циклический сдвиг: значение A переходит в B, значение B — в C, значение C — в A (A, B, C — вещественные параметры, являющиеся одновременно входными и выходными). С помощью этой процедуры выполнить правый циклический сдвиг для двух данных наборов из трех чисел: (A1, B1, C1) и (A2, B2, C2).

Код 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  
{ Процедура выполняет правый циклический сдвиг на 1 элемент }
procedure ShiftRight3(var A, B, C: real);
var
  t: real; { промежуточная дополнительная переменная }
{ Тело процедуры ShiftRight3(A, B, C) }
begin
  t := A; { <== запоминаем А }
  A := C; { <== А меняем на С }
  C := B; { <== С меняем на В }
  B := t; { <== В меняем на А (t = A) }
end;

var
  A1, B1, C1, A2, B2, C2: real;

begin
  writeln('Введите вещественные числа A1, B1, C1: ');
  readln(A1, B1, C1);
  ShiftRight3(A1, B1, C1); { вызываем процедуру для чисел A1, B1, C1 }
  writeln('Результат сдвига вправо: ', A1, ' ', B1, ' ', C1);
  writeln;
  writeln('Введите вещественные числа A2, B2, C2: ');
  readln(A2, B2, C2);
  ShiftRight3(A2, B2, C2); { вызываем процедуру для чисел A2, B2, C2 }
  writeln('Результат сдвига вправо: ', A2, ' ', B2, ' ', C2);
  readln
end.

Proc15. Описать процедуру ShiftLeft3(A, B, C), выполняющую левый циклический сдвиг: значение A переходит в C, значение C — в B, значение B — в A (A, B, C — вещественные параметры, являющиеся одновременно входными и выходными). С помощью этой процедуры выполнить левый циклический сдвиг для двух данных наборов из трех чисел: (A1, B1, C1) и (A2, B2, C2).

Код 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  
{ Процедура выполняет левый циклический сдвиг на 1 элемент }
procedure ShiftLeft3(var A, B, C: real);
var
  t: real; { <-- промежуточная дополнительная переменная }
{ Тело процедуры ShiftLeft3(A, B, C) }
begin
  t := C; { <== запоминаем C }
  C := A; { <== C меняем на A }
  A := B; { <== A меняем на В }
  B := t; { <== В меняем на C (t = C) }
end;

var
  A1, B1, C1, A2, B2, C2: real;

begin
  writeln('Введите вещественные числа A1, B1, C1: ');
  readln(A1, B1, C1); { <-- вводим числа A1, B1, C1 }
  ShiftLeft3(A1, B1, C1); { <-- вызываем процедуру }
  writeln('Результат сдвига влево: ', A1, ' ', B1, ' ', C1);
  writeln;
  writeln('Введите вещественные числа A2, B2, C2: ');
  readln(A2, B2, C2); { <-- вводим числа A2, B2, C2 }
  ShiftLeft3(A2, B2, C2); { <-- вызываем процедуру }
  writeln('Результат сдвига влево: ', A2, ' ', B2, ' ', C2);
  readln
end.

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