如何在Java中有效地生成完美的数字到数字不变数？

PDDI是这样一个数字：所有提升到自身的数字之和等于该数字本身

例如，3435=（3^3）+（4^4）+（3^3）+（5^5）

下面的代码需要很长时间才能检查一到一个大数字之间的PDDI。有没有办法让它更快

    System.out.print("Enter the number");
    Scanner s = new Scanner(System.in);
    int n = s.nextInt();

    int m = 0, sum = 0, k = 0;
    // We're going to try all integers between one to n.
    for(int i = 1; i<=n; i++){
       sum = 0;
       m = i;
       while(m>0){
          k = m % 10;
          sum = sum + (int)Math.pow(k, k);
          m = m/10;
       }

       if(i == sum)
          System.out.println(i);
    }

System.out.print（“输入号码”）；
扫描仪s=新的扫描仪（System.in）；
int n=s.nextInt（）；
int m=0，sum=0，k=0；
//我们将尝试1到n之间的所有整数。
对于（int i=1；i0）{
k=m%10；
sum=sum+（int）数学功率（k，k）；
m=m/10；
}
如果（i==总和）
系统输出打印LN（i）；
}

从0到9再到2的幂的数字可以预先计算并保存在一个数组中

int powered [] = new int [10];
powered[0] = 0;
powered[1] = 1;
powered[2] = 4;
..
powered[9] = 81;

然后，对于每个数字fech，使用该数字作为受电阵列的索引的受电数字

例如，

234

将

通电[2]+通电[3]+通电[4]

这将节省一些数学运算

您还可以考虑一种多线程方法，让N个线程并行计算不同的数字。

使用缓存值而不是Math.pow 由于只使用0到9的幂，因此可以将这些值缓存在

int[]

中，而不是每次都计算

Math.pow（k，k）

。这不会有多大改善，但这只是一个开始

int[] pows = new int[] {0, 1, 4, 27, 256, 3125, 46656, 823543, 16777216, 387420489 };
for (int i = 0; i < 10; ++i) {
    pows[i] = (int) Math.pow(i, i);
}

System.out.print("Enter the number");
Scanner s = new Scanner(System.in);
int n = s.nextInt();

int m = 0, sum = 0, k = 0;
// We're going to try all integers between one to n.
for(int i = 1, i<=n, i++){
   sum = 0;
   m = i;
   while(m>0){
      k = m % 10;
      sum = sum + pows[k]; // use cached values here
      m = m/10;
   }

   if(i == sum)
      System.out.println(i);
}

---

我在“十年”中使用了这个逻辑，但您可能想将其扩展到数百个甚至更多，但这将更加棘手。

使用long，因为9^9不适合整数。预先计算d^d，但使用循环，而不是Math.pow（我不相信它适用于8或9）“@JoopEggen

int

能适应

2.147*10^9

@meowgoes狗谢谢我心算不太好，但我应该做

9^9<10^9<2^10^3=2^30

。但是动力[n]不是n^2。是n^n。@Kahjoor阅读question@Kahjoorn^2==n*n。

int[] pows = new int [10];
for (int i = 0; i < 10; ++i) {
    pows[i] = (int) Math.pow(i, i);
}

System.out.print("Enter the number");
Scanner s = new Scanner(System.in);
int n = s.nextInt();

int m = 0, sum = 0, k = 0, lastNumberDigit;
// We're going to try all integers between one to n.
for(int i = 1, i<=n, i++){
   sum = 0;
   m = i;
   while(m>0){
      lastNumberDigit = m; // on the last iteration, we'll get the last digit
      k = m % 10;
      sum = sum + pows[k]; // use cached values here
      m = m/10;
   }

   if(i == sum) {
      System.out.println(i);
   } else if (sum > i) {
      i += (10 - lastNumberDigit - 1); // jump to the next decade (-1 because the for will apply i++ on it)
   }
}