bulgakov

29. Практика циклов: числа и их цифры

Один цикл выбирает очередное число, другой разбирает его цифры. Так мы соединяем цикл for, разворот числа и свои функции в одну программу.

Сначала договоримся о результате

В задачах этой лекции «симметричное число» будем понимать как число с обратным порядком десятичных цифр: 123 → 321, -120 → -21, 0 → 0. Знак сохраняем. Начальные нули в числовом результате не записываются: разворот 1200 даёт 21. Если нужны именно символы 0021, это другая операция — печать цифр справа налево, разобранная в уроке 26.

В примерах принимаем целые числа от -9999 до 9999. Разворот тогда тоже помещается в int даже на реализации C с минимальным допустимым диапазоном этого типа. Ограничение проверяем до вычисления. Алгоритм без проверки нельзя обещать для любого int: обратная запись большого числа может выйти за диапазон типа.

Одна функция обрабатывает одно число

Функция reverse_digits возвращает развёрнутое число. Она не читает ввод и не печатает ответ. Полная программа ниже читает ровно десять чисел и вызывает её для каждого:

C
#include <stdio.h>

int reverse_digits(int n)
{
    int reversed = 0;
    do {
        int digit = n % 10;
        reversed = reversed * 10 + digit;
        n /= 10;
    } while (n != 0);
    return reversed;
}

int main(void)
{
    for (int count = 0; count < 10; count++) {
        int x;
        if (scanf("%d", &x) != 1) {
            printf("Input error\n");
            return 1;
        }
        if (x < -9999 || x > 9999) {
            printf("Out of range\n");
            return 1;
        }
        printf("%d\n", reverse_digits(x));
    }
    return 0;
}

Ввод — десять чисел через пробелы или переводы строк:

123 -120 0 7 1002 9000 -45 11 1200 -9999

Вывод:

321
-21
0
7
2001
9
-54
11
21
-9999

count считает числа, а n внутри функции постепенно теряет цифры. После одного вызова n становится нулём, но следующий вызов получает новое значение аргумента. Локальная reversed тоже каждый раз начинается с нуля. Исходная x в main не меняется: параметр получает копию её значения.

Проверка scanf отсеивает отсутствие числа и ранний конец ввода. Во всех учебных запусках запись входного числа должна помещаться в int; проверка возвращаемого значения scanf сама по себе не защищает от слишком длинной числовой записи.

Почему работают отрицательные числа и ноль

В C17 целочисленное деление отбрасывает дробную часть в сторону нуля. Поэтому -120 / 10 равно -12, а -12 % 10 равно -2. Мы не меняем знак всего числа: отрицательные цифры сразу формируют отрицательный результат.

n до шага digit = n % 10 reversed после шага n после деления
-120 0 0 -12
-12 -2 -2 -1
-1 -1 -21 0

Условие здесь n != 0, а не n > 0: отрицательное число тоже нужно продолжать разбирать. Для исходного нуля do…while один раз добавляет цифру 0 и возвращает 0.

Всего внешний цикл выполнит десять вызовов. Внутренний сделает столько шагов, сколько цифр у очередного числа; для нуля — один шаг. Поэтому общее число внутренних шагов нельзя всегда считать как 10 × 4: у 7 одна цифра, у 1002 четыре.

Практика: читать до нуля

Теперь число входных значений неизвестно. Читайте числа из того же диапазона, печатайте их разворот и заканчивайте при вводе 0. В этой задаче ноль — сигнал завершения, поэтому его разворот не печатается. При раннем конце ввода сообщите End of input before zero, при неверном вводе — Input error. После ошибки завершите программу с кодом 1.

Пример: ввод 120 -305 0 77 должен дать строки 21 и -503. До 77 программа уже не дойдёт.

Разворот последовательности до нуля
C
#include <stdio.h>

int reverse_digits(int n)
{
    int reversed = 0;
    do {
        reversed = reversed * 10 + n % 10;
        n /= 10;
    } while (n != 0);
    return reversed;
}

int main(void)
{
    for (;;) {
        int x;
        int read = scanf("%d", &x);
        if (read == EOF) {
            printf("End of input before zero\n");
            return 1;
        }
        if (read != 1) {
            printf("Input error\n");
            return 1;
        }
        if (x == 0) {
            break;
        }
        if (x < -9999 || x > 9999) {
            printf("Out of range\n");
            return 1;
        }
        printf("%d\n", reverse_digits(x));
    }
    return 0;
}

В for (;;) оставлены обе точки с запятой, но все три части пусты. Отсутствующее условие не останавливает цикл. В этой программе выход всё же есть: break после нуля и return после ошибки. Поэтому «нет условия» не означает «программа обязательно работает вечно».

Порядок важен: сначала проверяем результат чтения, затем сигнал завершения, затем диапазон и только потом вычисляем ответ. EOF — результат операции чтения, а не введённое число 0.

Проверяем границы цикла

В Lesson-7 есть ещё пример: если начальное число входит в [10, 20], напечатать числа от него до 20. Вот полная версия с проверкой ввода:

C
#include <stdio.h>

int main(void)
{
    int i;
    if (scanf("%d", &i) != 1) {
        printf("Input error\n");
        return 1;
    }
    for (; i >= 10 && i <= 20; i++) {
        printf("%d\n", i);
    }
    return 0;
}
Ввод Что выводится Почему
9 Ничего Первая проверка ложна
10 Числа от 10 до 20 Обе границы включены
19 19, затем 20 После них i станет 21
20 Только 20 Затем условие ложно
21 Ничего Первая проверка ложна

Это не поиск ближайшего подходящего числа: если первая проверка ложна, тело не запускается и шаг i++ не выполняется.

Пустой шаг тоже допустим: увеличение можно написать в теле. Но тогда continue может его обойти. В обычном for (...; ...; i++) оператор continue ведёт к шагу, а в while — сразу к условию. При переводе for в while нужно сохранить этот порядок, как в уроке 22.

ПрактикаЗагружаем тест…