bulgakov

26. Цифры числа и ввод до нуля

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

Получить число с обратным порядком цифр

В задаче лекции «напечатать симметричное число» будем понимать результат как число с цифрами в обратном порядке: 1234 → 4321. Это не противоположное число -1234 и не проверка симметричности записи.

Мы уже умеем выделять последнюю цифру: для неотрицательного целого rest % 10 даёт последнюю цифру, а rest / 10 убирает её. Осталось пристроить извлечённую цифру справа к результату.

Если результат был 4, то 4 * 10 + 3 даёт 43. Умножение на десять освобождает справа разряд для новой цифры. Значит, шаг накопления такой: reversed = reversed * 10 + digit.

Полная программа принимает целое из [-30000, 30000]. Выбираем long: этот тип гарантированно вмещает весь наш диапазон и обратные числа до 99992, даже там, где int имеет только 16 бит.

C
#include <stdio.h>

int main(void)
{
    long n;
    if (scanf("%ld", &n) != 1) {
        printf("Input error\n");
        return 1;
    }
    if (n < -30000 || n > 30000) {
        printf("Out of range\n");
        return 1;
    }

    int negative = n < 0;
    long rest = negative ? -n : n;
    long reversed = 0;
    do {
        long digit = rest % 10;
        reversed = reversed * 10 + digit;
        rest /= 10;
    } while (rest > 0);
    if (negative) {
        reversed = -reversed;
    }
    printf("Reversed: %ld\n", reversed);
    return 0;
}

При вводе 1234:

Reversed: 4321
rest до шага digit reversed после шага rest после деления
1234 4 4 123
123 3 43 12
12 2 432 1
1 1 4321 0

rest — рабочая копия. Исходное n сохраняется. Отрицательный знак обрабатываем отдельно: сначала разворачиваем положительную величину, затем возвращаем знак. При -120 получаем -21.

Здесь безопасно вычислять -n, потому что до этого проверили ограниченный диапазон. Нельзя автоматически переносить этот приём на любое значение знакового типа: положительная величина самого маленького отрицательного числа может в него не поместиться.

Ввод Результат Причина
0 0 do…while обрабатывает одну нулевую цифру
1200 21 Число не хранит ведущие нули записи 0021
1002 2001 Внутренние нули сохраняют разряды
-120 -21 Знак возвращается после разворота цифр
30000 3 Ведущие нули результата исчезают

Если требуется вывести именно строку 0021, это другая задача: нужно печатать извлекаемые цифры, а не собирать числовой результат. Вводимые числа должны помещаться в long; проверка scanf не заменяет разбор строки произвольной длины.

Ввод до нуля: значение, которое завершает работу

Теперь количество чисел заранее неизвестно. Пользователь вводит целые числа, а 0 обозначает конец. Такое специальное значение называют сигналом завершения. Оно управляет чтением и не входит в обрабатываемые данные.

Выведем каждое ненулевое число на отдельной строке. Ввод 5 -2 9 0 7 должен дать 5, -2, 9; ноль не печатается, а семёрка уже не читается.

C
#include <stdio.h>

int main(void)
{
    while (1) {
        int x;
        int read_count = scanf("%d", &x);
        if (read_count == EOF) {
            printf("End of input before zero\n");
            return 1;
        }
        if (read_count != 1) {
            printf("Input error\n");
            return 1;
        }
        if (x == 0) {
            break;
        }
        printf("%d\n", x);
    }
    return 0;
}

Здесь while (1) всегда разрешает следующий проход. Выход явно задан внутри: break при нуле либо return при проблеме чтения. На каждом успешном проходе читается новое число, поэтому цикл не повторяет старое значение.

Порядок действий:

  1. Прочитать очередное число.
  2. Проверить, удалось ли чтение.
  3. Если число равно нулю — выйти из цикла.
  4. Иначе напечатать число и начать следующий проход.

EOF — специальный результат чтения: ввод завершился или произошла ошибка чтения до получения числа. Это не введённое число 0. В этой задаче завершающий ноль обязателен, поэтому EOF до нуля сообщает о незавершённом вводе. Если ноль введён первым, программа успешно завершится без вывода.

Не ставьте printf перед проверкой x == 0, если ноль не должен попадать в результат. Не пропускайте проверку scanf: при неподходящем символе тот же символ может остаться во входе, и следующее чтение снова не получит число.

Практика: сохранить нули при обратной печати

Введите целое число из [0, 30000] и напечатайте его цифры справа налево. Для 1200 ожидается строка 0021, для 0 — 0. Определите, какая переменная предыдущего решения теперь не нужна.

Печатать цифру сразу после извлечения
C
#include <stdio.h>

int main(void)
{
    long n;
    if (scanf("%ld", &n) != 1) {
        printf("Input error\n");
        return 1;
    }
    if (n < 0 || n > 30000) {
        printf("Out of range\n");
        return 1;
    }
    do {
        printf("%ld", n % 10);
        n /= 10;
    } while (n > 0);
    printf("\n");
    return 0;
}

Накопитель reversed не нужен. Каждая извлечённая цифра сразу отправляется в вывод, поэтому первые два нуля в 1200 остаются видимыми. do…while сохраняет отдельный случай исходного нуля.

Задача лекции о простом числе уже разобрана в уроке о флагах: числа 0 и 1 не простые, а для 2 цикл поиска делителя не выполняется. Используйте её как повторение. Далее выделим повторяющиеся вычисления в собственные функции.

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