Число Армстронга: алгоритм и примеры на C

Число Армстронга — распространённая учебная задача по обработке цифр числа. Её решение демонстрирует базовые приёмы: извлечение цифр, аккумуляцию результата и сравнение с исходным числом. Эти приёмы также применимы для подсчёта суммы цифр, произведения, реверса числа и других задач.

Что такое число Армстронга?

Число Армстронга (иногда называют «нарцистическим числом») — это целое число, равное сумме своих цифр, возведённых в степень числа цифр. Часто в учебных примерах рассматривают трёхзначные числа и используют кубы цифр.

Пример: 153 — число Армстронга для трёхзначных чисел, потому что

1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153.

Важно: для n-значного числа степень равна n. Например, 9474 — 4-значное число, и 9^4 + 4^4 + 7^4 + 4^4 = 9474.

Алгоритм проверки числа Армстронга (шаги)

Ниже простая, последовательная схема действий, которую можно реализовать в любом языке программирования:

1. Получить целое число n (вход).
2. Сохранить копию числа: temp = n.
3. Вычислить количество цифр или, в учебном варианте для трёхзначных чисел, установить степень = 3. (Для общей версии степень = число цифр.)
4. Инициализировать sum = 0.
5. Пока n > 0:
   • r = n % 10 — извлечь последнюю цифру.
   • sum = sum + (r^power) — прибавить степень цифры.
   • n = n / 10 — удалить последнюю цифру (целочисленное деление).
6. Сравнить sum и temp. Если равны — число Армстронга, иначе — нет.

Примечание: в языках с функцией pow используйте аккуратно (потому что pow возвращает float/double). Для целых степеней лучше реализовать целочисленное возведение в степень или использовать предвычисленные значения для степеней 0..9.

Псевдокод

Простой псевдокод (общая версия для n-значных чисел):

input n
temp = n
power = число_цифр(n)
sum = 0
while n > 0 do
    r = n % 10
    sum = sum + int_pow(r, power)
    n = n / 10
end while
if sum == temp then
    output "Число Армстронга"
else
    output "Не число Армстронга"
end if

Где int_pow(a, b) — целочисленная функция возведения a в степень b.

Программа на C

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

#include 
#include 

long long int_pow(int base, int exp) {
    long long result = 1;
    for (int i = 0; i < exp; ++i) result *= base;
    return result;
}

int count_digits(long long n) {
    if (n == 0) return 1;
    int c = 0;
    while (n != 0) { n /= 10; ++c; }
    return c;
}

int main() {
    long long n, temp;
    printf("Введите целое неотрицательное число: ");
    if (scanf("%lld", &n) != 1 || n < 0) {
        printf("Неверный ввод\n");
        return 1;
    }

    temp = n;
    int power = count_digits(n);
    long long sum = 0;

    while (n > 0) {
        int r = n % 10;
        sum += int_pow(r, power);
        n /= 10;
    }

    if (sum == temp)
        printf("Число является числом Армстронга\n");
    else
        printf("Число не является числом Армстронга\n");

    return 0;
}

Важно: для очень больших чисел знайте ограничения типа long long и возможное переполнение при возведении в степень.

Почему в простых примерах используют кубы?

В учебных задачах часто берут трёхзначные числа, поэтому степень равна 3 — берут кубы отдельных цифр. Но общий смысл: степень должна совпадать с количеством цифр числа. Если вы всегда берёте кубы для всех чисел, алгоритм даёт неправильный результат для числе с отличным от трёх количеством цифр.

Контрпример: 9474 — 4-значное число, и оно является числом Армстронга, потому что 9^4 + 4^4 + 7^4 + 4^4 = 9474. Если посчитать только кубы, вы не получите исходное число.

Альтернативные подходы

• Строковый подход: преобразовать число в строку, пройти по символам и для каждой цифры вычислить степень. Упрощает подсчёт числа цифр и интеграцию с языками высокого уровня.
• Использование pow: в C/C++/Python есть функция pow, но она возвращает float/double. Для целых степеней лучше использовать целочисленное возведение или округление результата и проверку ошибок. В Python удобно: sum(int(d)**power for d in str(n)).
• Предвычисление степеней: для фиксированных степеней (например, power заранее известна) можно заранее сгенерировать таблицу pow_table[0..9] и брать значения по индексу, что быстрее и безопаснее по точности.

Примеры изменений алгоритма для других задач

Один и тот же трёхшаговый цикл (извлечь цифру, выполнить операцию, удалить последнюю цифру) применим к множеству задач.

1. Сумма цифр

sum = 0
while n > 0:
    r = n % 10
    sum = sum + r
    n = n / 10

2. Произведение цифр

prod = 1
while n > 0:
    r = n % 10
    prod = prod * r
    n = n / 10

3. Подсчёт цифр

count = 0
while n > 0:
    count = count + 1
    n = n / 10

4. Обратное число и палиндром

rev = 0
while n > 0:
    r = n % 10
    rev = rev * 10 + r
    n = n / 10
# затем сравнить rev с исходным числом

5. Минимальная/максимальная цифра

min = 9; max = 0
while n > 0:
    r = n % 10
    if r < min: min = r
    if r > max: max = r
    n = n / 10

Тестовые случаи и критерии приёмки

Критерии приёмки:

• Программа корректно определяет числа Армстронга для различных разрядностей.
• Корректно работает с нулём и однозначными числами.
• Обрабатывает некорректный ввод (нецелые, отрицательные) — безопасный выход с сообщением.
• Не допускает арифметическое переполнение для типичных учебных входов.

Рекомендуемые тесты:

• Граничные и тривиальные: 0, 1, 5, 9.
• Известные числа Армстронга: 153, 370, 371, 407 (трёхзначные); 9474 (четырёхзначные); 9475 (не Армстронг).
• Большие значения: 9926315 (пример 7-значного числа, если известно), либо случайные большие числа для проверки производительности.
• Негативные сценарии: текстовый ввод, дробные числа, очень большие числа, приводящие к переполнению (в среде C).

Эвристики и ментальные модели

• Модель «извлечь‑обработать‑удалить»: извлечь последнюю цифру (n%10), обработать её, затем удалить (n/=10). Это один из базовых приёмов при работе с целыми числами.
• Если вы используете язык со строками, считайте степень длины строки и применяйте возведение в степень к каждому символу.
• Для производительности — избегайте функций с плавающей точкой на критическом пути (pow в C), используйте таблицы или целочисленные реализации.

Роль‑ориентированные чеклисты

Разработчик:

• Реализовать безопасное чтение входа.
• Использовать подходящий целочисленный тип (long long при необходимости).
• Предусмотреть целочисленную функцию возведения в степень.

Код‑ревьюер:

• Проверить корректность подсчёта числа цифр.
• Убедиться, что нет использования pow для целых степеней без проверки.
• Проверить обработку граничных и некорректных вводов.

Тестировщик:

• Прогнать набор тестовых случаев (см. раздел выше).
• Проверить поведение при больших входных данных и на границах типа.

Ошибки и ограничения — когда метод даёт неверный результат

• Если всегда использовать кубы для всех чисел, алгоритм даёт неверный результат для чисел с отличной от трёх цифр.
• Использование pow без контроля точности может привести к ошибкам из‑за представления с плавающей точкой.
• Переполнение при больших входах: при возведении цифр в степень результат может превысить диапазон целого типа.

Важно: в реальных приложениях всегда валидируйте вход и учитывайте ограничения платформы и типов.

Краткое резюме

• Число Армстронга — число, равное сумме своих цифр в степени количества цифр.
• Базовый алгоритм опирается на цикл: извлечь цифру, вычислить степень и суммировать, удалить цифру.
• Для надёжности в C используйте целочисленную функцию возведения в степень и проверяйте переполнение.
• Алгоритм легко адаптируется для задач: сумма цифр, произведение, реверс, поиск минимума/максимума.

Важно: всегда документируйте предположения (например, что вход неотрицательный) и проверяйте поведение на краевых случаях.