ВВЕРХ
ВНИЗ
  • Home
  • While
  • While 1 - 6

Количество отрезков без наложений

Первые две задачи легко решаются и без помощи оператора цикла в задачах Integer4 и Integer5, н6о здесь мы должны увидеть их решение с помощью оператора цикла while.

While1. Даны положительные числа A и B (A > B). На отрезке длины A размещено максимально возможное количество отрезков длины B (без наложений). Не используя операции умножения и деления, найти длину незанятой части отрезка A.

Если не использовать операции деления нацело, то нужно, естественно, отрезок длины А уменьшать до тех пор пока его дина не окажется меньше В. Последнее число и будет диной незанятой части – отрезок, в который не поместится В.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
var
  A, B: real;

begin
  { -- Ввод данных -- }
  writeln('Введите положительные числа A и B (A > B):');  
  write(' A = ');
  readln(A);
  write(' B = ');
  readln(B);
  { -- Основная программа -- }
  while A >= B do { <-- пока A ≥ B }
    A := A - B; { <== уменьшаем число A на B }
  writeln('Длина незанятой части отрезка A: ', A);
  readln
end.

While2. Даны положительные числа A и B (A > B). На отрезке длины A размещено максимально возможное количество отрезков длины B (без наложений). Не используя операции умножения и деления, найти количество отрезков B, размещенных на отрезке A.

Здесь, как и в предыдущем примере, уменьшаем отрезок А до тех пор, пока его длина не окажется меньше В, но вместе с тем каждый будем увеличивать количество размещений.

Код 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
  A, B: real;
  k: word;

begin
  { ******* Ввод данных ******* }
  writeln('Введите положительные числа A и B (A > B):');  
  write(' A = ');
  readln(A);
  write(' B = ');
  readln(B);
  { ******* Основная программа ******** }
  write('Количество отрезков ', B,
    ' размещенных на отрезке ', A, ': ');
  k := 0;  
  while A >= B do { пока A >= B }
  begin
    A := A - B; { <-- уменьшаем число A на B }
    inc(k) { <-- увеличиваем количество k }
  end;
  writeln(k);
  readln
end.

While3. Даны целые положительные числа N и K. Используя только операции сложения и вычитания, найти частное от деления нацело N на K, а также остаток от этого деления.

Эта задача ничем по сути не отличается от предыдущей While2, только здесь в роли отрезка А выступает число N, а вместо В стоит K. Частное от деления N на K (число i) находим так же – увеличением на 1 каждый раз после уменьшения N на K.

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

begin
  { ******* Ввод данных ******* }
  writeln('Введите целые положительные числа N и K:');
  write(' N = ');
  readln(N);
  write(' K = ');
  readln(K);
  { ******* Основная программа ******* }
  writeln('При делении нацело ', N, 
    ' на ', K, ' получим:');
  i := 0; {  <== Частное }
  while N >= K do { <-- Пока N >= K }
  begin
    N := N - K; { <-- уменьшаем число N на K }
    i := i + 1  { <-- увеличиваем частное i }
  end;
  writeln(' частное: ', i);
  writeln(' остаток: ', N);
  readln
end.

While4. Дано целое число N (> 0). Если оно является степенью числа 3, то вывести true, если не является — вывести false.

Чтобы число было степенью 3, необходимо делить это число на 3: если при этом частное равно 0 (число делится), то продолжать деление. Очевидно, что этот процесс будет продолжаться до тех пор, пока не получим частное равное 1 (3:3 = 1). Следующее за этим деление даст в остатке уже 1: 1 mod 3 = 1.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
const
  d = 3; { <-- Делитель }

var
  N: integer;

begin
  write('N = ');
  readln(N);
  { Следующий цикл будет выполнятся до тех пор,
  пока остаток при делении N на d равен 0: }
  while (N mod d = 0) do { <-- Проверяем делимость на d }
    N := N div d; { <-- Делим нацело N на d }
  { На выходе из цикла, если N - степень d, то после 
  многократного деления N на d будет N = 1: }
  writeln(' ', (N = 1));
  readln
end.

While5. Дано целое число N (> 0), являющееся некоторой степенью числа 2: N = 2K. Найти целое число K — показатель этой степени.

В этой задаче считается, что число уже является степенью 2, нужно только найти показатель этой степени. Естественно, для этого нужно делить число на 2 до тех пор, пока оно не станет равным 1.

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

begin
  write('N = ');
  readln(N);
  k := 0; { <== Начальное значение показателя степени }
  { Поскольку N - степень числа 2, то будем 
  делить N до тех пор, пока не получим 1: }
  while N > 1 do
  begin 
    N := N div 2; { <== Делим на 2 }
    inc(K) { <== Увеличиваем показатель на 1 }
  end;
  writeln('K = ', K);
  readln
end.

While6. Дано целое число N (> 0). Найти двойной факториал N:

N!! = N·(N−2)·(N−4)·…

(последний сомножитель равен 2, если N — четное, и 1, если N — нечетное). Чтобы избежать целочисленного переполнения, вычислять это произведение с помощью вещественной переменной и вывести его как вещественное число.

Двойной факториал от обычного отличается тем, что в произведении берут участие только числа той четности, что и само число. Например, чтобы посчитать 6!!, необходимо перемножить все четные числа от 2 до 6, поскольку 6 – четное. Для вычисления 9!! нужно перемножить все нечетные числа от 1 до 9, так как 9 – нечетное.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
var
  N: word;
  fact2: real;

begin
  write('N = ');
  readln(N); { <-- Вводим целое положительное число }
  writeln;
  write(' ', N, '!! = ');
  fact2 := N; { <-- Начальное значение двойного факториала }
  { Выполняем цикл до тех пор, пока множитель больше 3 - 
  или 5(для нечетного N), или 4(для четного N): }
  while N > 3 do
  begin 
    N := N - 2; { <-- Уменьшаем множитель на 2 }
    fact2 := fact2 * N { <-- Новое значение факториала }
  end;
  writeln(fact2);
  readln
end.


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