C++程序 打印1到1000的阿姆斯特朗数

在这里，我们将看到如何使用C++程序打印1到1000之间的阿姆斯特朗数。

阿姆斯特朗数

如果一个数字“N”等于N的所有位数的幂加起来的总和，则数字“N”是阿姆斯特朗数。

例子：

有两种方法可以找到1到1000之间的所有阿姆斯特朗数：

1. 使用蛮力方法。
2. 使用优化的解决方案。

让我们开始详细讨论每个方法。

1.使用蛮力方法

观点是首先数一下数字的位数（或者找出顺序）。让位数为 order_n. 对于输入数字中的每个数字 curr ，计算 curr order_n 。 如果所有这些值的总和等于 num，则返回true，否则返回false。

下面是使用蛮力方法查找1到1000之间的阿姆斯特朗数的C++程序：

// C++ program to find Armstrong numbers
// between 1 to 1000 using a brute force
// approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the order of
// a number.
int order(int num)
{
    int count = 0;
    while (num > 0)
    {
        num /= 10;
        count++;
    }
    return count;
}
 
// Function to check whether the
// given number is Armstrong number
// or not
bool isArmstrong(int num)
{
    int order_n = order(num);
    int num_temp = num, sum = 0;
 
    while (num_temp > 0)
    {
        int curr = num_temp % 10;
        sum += pow(curr, order_n);
        num_temp /= 10;
    }
    if (sum == num)
    {
        return true;
    }
    else
    {
        return false;
    }
}
 
// Driver code
int main()
{
 
    cout << "Armstrong numbers between 1 to 1000 : ";
    // Loop which will run from 1 to 1000
    for (int num = 1; num <= 1000; ++num)
    {
 
        if (isArmstrong(num))
        {
            cout << num << " ";
        }
    }
    return 0;
}  

运行结果

Armstrong numbers between 1 to 1000 : 1 2 3 4 5 6 7 8 9 153 370 371 407 

时间复杂度： O(n*d),其中d是数字的位数，n是范围(1,1000)。

辅助空间： O(1)。

2.使用优化的解决方案

这里的想法是直接打印小于或等于9的数字，因为它们已经是阿姆斯特朗数，然后使用优化的方法检查其余数字是否为阿姆斯特朗数，如果是阿姆斯特朗数，则打印它们，否则返回false。

下面是使用优化的方法查找1到1000之间的阿姆斯特朗数的C++程序：

// C++程序，寻找1到1000之间的阿姆斯特朗数
// 使用优化的解决方案
#include <bits/stdc++h>
using namespace std;
 
// 主函数
int main()
{
    int ord1，ord2，ord3，total_sum;
 
    cout << "1到1000之间的所有阿姆斯特朗数："；
   
    // 循环从1到1000
    for (int num = 1; num <= 1000; ++num)
    {
        // 所有单个数字都是阿姆斯特朗数
        if (num <= 9)
        {
            cout << num << " ";
        }
        else
        {
            ord1 = num % 10;
            ord2 = (num % 100 - ord1) / 10;
            ord3 = (num % 1000 - ord2) / 100;
 
            total_sum = ((ord1 * ord1 * ord1) +
                         (ord2 * ord2 * ord2) +
                         (ord3 * ord3 * ord3));
            if (total_sum == num)
            {
                cout << num << " ";
            }
        }
    }
    return 0;
}

1到1000之间的所有阿姆斯特朗数：1 2 3 4 5 6 7 8 9 153 370 371 407 ```  

时间复杂度： O(n)。

辅助空间： O(1)。