Являются ли цифры натурального числа строго возрастающими. Решение на языке Python

Задача: Напишите программу, которая проверяет, являются ли цифры натурального числа строго возрастающими. Это означает, что каждая следующая цифра (при чтении числа слева направо) должна быть больше предыдущей. Например, число 123 подходит, а 321 или 122 — нет. Программа должна вывести «да», если условие выполняется, и «нет» в противном случае.

В этой публикации мы подробно разберём код, который решает задачу о строго возрастающих цифрах числа. Шаг за шагом разберём, как работает программа, и рассмотрим примеры её выполнения.

Программа решения на языке Python

n = int(input('Введите число:'))
k = 0
j = 0
m = 10
while n > 0:
    j += 1
    c = n % 10
    if c < m:
        k += 1
    m = c 
    n = n // 10
    
if k == j:
    print('да')
else:
    print('нет')

Как работает программа

1. Ввод числа

Пользователь вводит целое число. Оно сохраняется в переменной n. Предполагается, что число натуральное (положительное).

2. Инициализация переменных

• k = 0 — счётчик, который будет увеличиваться каждый раз, когда очередная цифра оказывается меньше предыдущей (предыдущая цифра — та, что была обработана раньше, то есть стоящая справа).

• j = 0 — счётчик количества цифр в числе.

• m = 10 — переменная, которая будет хранить предыдущую цифру. Почему 10? Потому что цифры от 0 до 9, и 10 гарантированно больше любой из них. Это позволяет корректно обработать первую цифру.

3. Цикл обработки цифр

Цикл while n > 0: выполняется, пока в числе остаются цифры. На каждой итерации:

• j += 1 — увеличиваем счётчик цифр.

• c = n % 10 — берём последнюю цифру числа (остаток от деления на 10).

• if c < m: — сравниваем текущую цифру с предыдущей (той, что была справа). Если текущая меньше — значит, порядок нарушен? Нет, давайте разбираться внимательно.

Мы идём по числу справа налево. Например, число 123. Последняя цифра — 3, затем 2, затем 1. Чтобы цифры слева направо возрастали (1 < 2 < 3), при движении справа налево они должны убывать (3 > 2 > 1). То есть каждая следующая (при движении справа налево) цифра должна быть меньше предыдущей. Именно это проверяет условие c < m — текущая цифра (которая левее) меньше предыдущей (которая правее)? Если да, то всё идёт правильно.

• k += 1 — если условие выполняется, увеличиваем счётчик правильных соотношений.

• m = c — обновляем «предыдущую» цифру на текущую для следующей итерации.

• n = n // 10 — отбрасываем последнюю цифру числа (целочисленное деление на 10).

4. Проверка результата

После окончания цикла у нас есть:

• j — количество цифр.

• k — количество раз, когда текущая цифра оказалась меньше предыдущей (при движении справа налево).

Если все цифры строго возрастают слева направо, то при движении справа налево каждая следующая цифра будет меньше предыдущей, и таких случаев будет ровно столько же, сколько цифр? Но давайте посчитаем: для числа из j цифр сравнений будет j-1 (первая цифра не с чем сравнивать). Однако в коде k увеличивается на каждой итерации, включая первую? На первой итерации m = 10, и условие c < 10 всегда истинно, поэтому k увеличится. Значит, k всегда будет включать и эту «лишнюю» единицу. Поэтому после цикла k будет равно j только в том случае, если на всех последующих сравнениях условие тоже выполнялось. Фактически k равно количеству цифр, для которых выполняется c < предыдущая_цифра, а предыдущая для первой цифры — 10, что даёт истину. Таким образом, если все сравнения были истинны (то есть цифры действительно убывают справа налево), то k == j.

Если хотя бы одно сравнение ложно, то k будет меньше j, и программа выведет «нет».

Примеры работы

Пример 1: число 123

• Инициализация: n=123, k=0, j=0, m=10

• Итерация 1: c=3, 3<10 → k=1, m=3, n=12, j=1

• Итерация 2: c=2, 2<3 → k=2, m=2, n=1, j=2

• Итерация 3: c=1, 1<2 → k=3, m=1, n=0, j=3
  Цикл завершён. k=3, j=3 → выводится «да». Всё верно.

Пример 2: число 321

• n=321

• Итерация 1: c=1, 1<10 → k=1, m=1, j=1, n=32

• Итерация 2: c=2, 2<1? Нет → k остаётся 1, m=2, j=2, n=3

• Итерация 3: c=3, 3<2? Нет → k=1, m=3, j=3, n=0
  k=1, j=3 → выводится «нет». Правильно, цифры убывают.

Пример 3: число 122

• n=122

• Итерация 1: c=2, 2<10 → k=1, m=2, j=1, n=12

• Итерация 2: c=2, 2<2? Нет → k=1, m=2, j=2, n=1

• Итерация 3: c=1, 1<2? Да → k=2, m=1, j=3, n=0
  k=2, j=3 → выводится «нет». Цифры нестрого возрастают (есть повтор), поэтому ответ «нет».

Пример 4: однозначное число, например 5

• n=5

• Итерация 1: c=5, 5<10 → k=1, m=5, j=1, n=0
  k=1, j=1 → выводится «да». Однозначное число считается удовлетворяющим условию (тривиально).

Выводы

Мы разобрали код, который проверяет, являются ли цифры числа строго возрастающими. Ключевая идея — обработка числа справа налево и сравнение с предыдущей цифрой. Понимание таких алгоритмов помогает развить навыки работы с циклами и арифметическими операциями над числами. Попробуйте самостоятельно модифицировать программу для проверки строго убывающих цифр или для случая, когда допустимы равные цифры.