ВВЕРХ
ВНИЗ
  • Home
  • While
  • While 17 - 21

Вывести все цифры числа

На странице While17-21 решаем задачи о цифрах числа, точнее, вопросом об отделении цифр целого числа, пользуясь только операциями деления нацело div и взятия остатка от деления mod. Посмотрим, как это делается.

Для примера возмем целое число N=1234, имеющее четыре цифры. Если разделить это число на 10, то получим 123 целых и в остатке 4. Поэтому цифру 4 (остаток при делении на 10) можно вывести на экран, а в новое значение N записать 123. Потом эту процедуру повторяем еще столько раз, сколько цифр имеем (в данном случае 3). Для целочисленного деления используем функцию div, а для взятия остатка mod.

Важное замечание: сначала вычисляем последнюю цифру числа (остаток), а уже потом изменяем число (делим нацело на 10). Как только мы дойдем до последней цифры (выведем её на экран), тогда на следующем шаге целая часть превратится в 0. Смотрим на данном примере:

1) 1234 mod 10 = 4, N = 1234 div 10 = 123

2)  123 mod 10 = 3,  N = 123 div 10 = 12

3)   12 mod 10 = 2,   N = 12 div 10 = 1

4)    1 mod 10 = 1,    N = 1 div 10 = 0

Как видно, на четвертом этапе (4 – количество цифр) число N = 0, поэтому делать вычисления следует до тех пор, пока N ≠ 0.

While17. Дано целое число N (> 0). Используя операции деления нацело и взятия остатка от деления, вывести все его цифры, начиная с самой правой (разряда единиц).

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

begin
  write('N = ');
  readln(N);
  writeln;
  writeln('Цифры числа (справа налево):');
  while N > 0 do { <-- Выполняем цикл, пока число больше 0 }
  begin
    write(' ', N mod 10); { <-- выводим остаток деления на 10 }
    N := N div 10 { <== находим целую часть от деления на 10 }
  end;
  readln
end.

Задача While17 с помощью цикла с постусловием repeat-until:

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

begin
  write('N = ');
  readln(N);
  writeln;
  writeln('Цифры числа (справа налево):');
  repeat
    write(' ', N mod 10); { <-- остаток деления на 10 }
    N := N div 10 { <== целая часть от деления на 10 }
  until N = 0; { <-- признак завершения цикла }
  readln
end.

While18. Дано целое число N (> 0). Используя операции деления нацело и взятия остатка от деления, найти количество и сумму его цифр.

В этой задаче не нужно выводить цифры числа, но зато нужно их считать и суммировать. Поэтому для цифры вводим переменную c, тогда Q – количество, Sum – сумма цифр.

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
var
  N, c, Sum, Q: integer;

begin
  write('N = ');
  readln(N);
  writeln;
  Q := 0; { <== сначала количество цифр равно 0 }
  Sum := 0; { <== сумма цифр тоже равна 0 }
  while N > 0 do { <-- Выполняем цикл, пока число больше 0 }
  begin
    c := N mod 10; { <== последняя цифра числа }
    inc(Q); { <== увеличиваем количество на 1 }
    Sum := Sum + c; { <== увеличиваем сумму цифр }
    N := N div 10 { <== удаляем последнюю цифру числа }
  end;
  { Выводим полученные результаты: } 
  writeln(' количество цифр: ', Q);
  writeln(' сумма цифр: ', Sum);
  readln
end.

Но как видно из программы, здесь спокойно можно обойтись и без переменной с – просто сразу вычислять сумму. Поэтому строку 12 можете удалить, а вместо 14 строки поставить Sum := Sum + N mod 10.

While19. Дано целое число N (> 0). Используя операции деления нацело и взятия остатка от деления, найти число, полученное при прочтении числа N справа налево.

А это очень интересная задача – составить из данного числа новое "число-перевертыш", как его иногда ещё в шутку называют. Помотрим, как это сделать на конкретном примере вышеупомянутого числа N = 1234. Естественно, что мы хотим получить новое число M = 4321.

Делается это методом сдвига (как его можно назвать) цифр справа налево: каждый раз число M умножаем на 10 и прибавляем к нему последнюю цифру числа N (остаток от деления на 10), а само N после этого делим нацело на 10 (удаляем последнюю цифру). Заканчиваем тогда, когда N = 0.

0) M = 0, N = 1234

1) M = 10·M + N mod 10 = 4,    N = N div 10 = 123

2) M = 10·M + N mod 10 = 43,   N = N div 10 = 12

3) M = 10·M + N mod 10 = 432,  N = N div 10 = 1

4) M = 10·M + N mod 10 = 4321, N = N div 10 = 0

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

begin
  write('N = ');
  readln(N);
  M := 0; { <== начальное значение нового числа }
  while N > 0 do { <-- Выполняем цикл, пока число больше 0 }
  begin
    M := 10 * M + N mod 10; { <== изменяем новое число }
    N := N div 10 { <== удаляем последнюю цифру исходного числа }
  end;
  writeln;
  writeln(' число справа налево: ', M);
  readln
end.

While20. Дано целое число N (> 0). С помощью операций деления нацело и взятия остатка от деления определить, имеется ли в записи числа N цифра «2». Если имеется, то вывести true, если нет — вывести false.

Здесь все просто: находим последнюю цифру числа (остаток от деления на 10), а потом удаляем её (деление нацело на 10). Выполняем цикл до тех пор, пока одновременно найденная цифра не равна 2, а число не равно 0.

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

begin
  write('N = ');
  readln(N);
  writeln; 
  while (N > 0) and (r <> 2) do
  begin
    r := N mod 10; { <== последняя цифра числа }
    N := N div 10 { <== удаляем последнюю цифру }
  end;
  writeln(r = 2); { <-- выводим значение выражения (r=2) }
  readln
end.

While21. Дано целое число N (> 0). С помощью операций деления нацело и взятия остатка от деления определить, имеются ли в записи числа N нечетные цифры. Если имеются, то вывести true, если нет — вывести false.

Как и в предыдущем примере, находим цифры числа, но проверяем на нечетность с помощью логической функции odd(N). Вместо этого можно использовать проверку на истинность выражения (N mod 2 = 1), возвращающее True, если N нечетно, и False в противном случае.

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

begin
  write('N = ');
  readln(N);
  writeln;
  while (N <> 0) and odd(r+1) do
  begin
    r := N mod 10; { <== последняя цифра числа }
    N := N div 10 { <== удаляем последнюю цифру }
  end;
  writeln(odd(r));
  readln
end.

Второй вариант решения задачи while21 отличается использованием логической переменной:

Код Pascal
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
var
  N, r: integer;
  f: boolean; { <-- Если число N содержит нечетную цифру, 
  то f=True, в противном случае f=False }

begin
  write('N = ');
  readln(N);
  writeln;
  f := false;
  while (N <> 0) and (f=false) do
  begin
    r := N mod 10; { <== последняя цифра числа }
    N := N div 10; { <== удаляем последнюю цифру }
    f := odd(r) { <== определяем, является ли r нечетным }
  end;
  writeln(f);
  readln
end.

А вот решение той же задачи с использованием цикла с послеусловием repeat - until:

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

begin
  write('N = ');
  readln(N);
  writeln;
  repeat
    r := N mod 10; { <== последняя цифра числа }
    N := N div 10 { <== удаляем последнюю цифру }
  until (N = 0) or odd(r);
  { Если в цикле мы дошли до последней цифры и 
  она четная, то функция odd(r) возвратит False, 
  в противном случае мы увидим True: }
  writeln(odd(r));
  readln
end.


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