Java 投影Euler 25无限循环

我正在做这个项目。我已经知道了如何做斐波那契，我正在使用

biginger

。我的程序似乎在无限循环中运行（或者我认为是这样）。这可能是因为它需要很长时间，还是它实际上进入了无限循环？有人能给我指一下正确的方向吗？这样我就能修好它了

import java.math.BigInteger;

public class Problem25 {

    public static void main(String[] args) {
        getTerm(0);
    }

    public static void getTerm(int start) {

        BigInteger var = BigInteger.ZERO;
        BigInteger var2 = BigInteger.valueOf(start);

        int counter = 0;

        while(true) {

            BigInteger temp = var.add(var2);
            var = var2;
            var2 = temp;
            counter++;

            if(var.toString().length() > 1000) {
                System.out.print(counter);
            }
        }           
    }
}

---

编辑：对不起，人们。我想，我已经休息了；但感谢您的回复。

您没有终止循环的条件：

while(true) { // << always true ;P

    BigInteger temp = var.add(var2);
    var = var2;
    var2 = temp;
    counter++;

    if(var.toString().length() > 1000) {
        System.out.print(counter);
    }
}

while（true）{//1000）{
系统输出打印（计数器）；
}
}

所以这是一个无限循环。您有两个（甚至更多）选项：

• 在

  while（语句）

  中指定继续循环下一轮的条件
• 添加一些

  break语句停止循环

---

您没有终止循环的条件：

while(true) { // << always true ;P

    BigInteger temp = var.add(var2);
    var = var2;
    var2 = temp;
    counter++;

    if(var.toString().length() > 1000) {
        System.out.print(counter);
    }
}

while（true）{//1000）{
系统输出打印（计数器）；
}
}

所以这是一个无限循环。您有两个（甚至更多）选项：

• 在

  while（语句）

  中指定继续循环下一轮的条件
• 添加一些

  break语句停止循环

getTerm（0）

这不应该是
getTerm（1）

而且，MByD的答案是正确的；但这也是一个关键问题。如果不更改此选项，您的程序将永远不会输出。
getTerm（0）

这不应该是
getTerm（1）

而且，MByD的答案是正确的；但这也是一个关键问题。如果不更改此选项，您的程序将永远不会输出。
您正在调用
getTerm（0）
，因此最初
var
和
var2
都为零。然后将
var2
添加到仍然为零的
var
中，以此类推，因此
var
和
var2
都保持为零，并且永远不会取得任何进展。我想你的意思是
getTerm（1）
，它应该正确地生成斐波那契序列

当然，一旦找到答案，您可能希望
打破循环。
您正在调用
getTerm（0）
，因此最初
var
和
var2
都是零。然后将
var2
添加到仍然为零的
var
中，以此类推，因此
var
和
var2
都保持为零，并且永远不会取得任何进展。我想你的意思是
getTerm（1）
，它应该正确地生成斐波那契序列

当然，一旦找到答案，您可能希望
打破循环。
为什么不打印每个值，直到找到1000位的值？反正不会有那么多，因为平均而言，随着黄金配给的增加，数量也会增加

如其他地方所述，添加停止条件：

if(var.toString().length() > 1000) {
    break;
}

为什么不打印每个值，直到找到一个1000位数的值？反正不会有那么多，因为平均而言，随着黄金配给的增加，数量也会增加

如其他地方所述，添加停止条件：

if(var.toString().length() > 1000) {
    break;
}

1） 是的，你有一个无限循环。休息一下；在打印（）之后立即执行语句

2） 试着找第一个，哦，两位数的词。或者三位数。小步骤很适合解决很多项目问题

3） 在调试器下运行它，并观察发生了什么。与2很好地结合。
1）是的，您有一个无限循环。休息一下；在打印（）之后立即执行语句

2） 试着找第一个，哦，两位数的词。或者三位数。小步骤很适合解决很多项目问题

3） 在调试器下运行它，并观察发生了什么。与2）很好地结合。
由于
true
始终为true，因此除非手动终止循环，否则循环将永远继续运行。使用
break用于此。对于您的实现，我认为您应该将它放在行
System.out.print（counter）
之后，因为
true
始终为true，除非您手动终止它，否则您的循环将永远继续运行。使用
break用于此。对于您的实现，我认为您应该将其放在行
System.out.print（counter）
之后，您可以使用：

while( !isGood() ) {
    ...
}

而不是

while(true) {
    ...
    if ( isGood() ) {
       break;
    }
}

以下是使用上述方法的3种解决方案（从慢到快）：

1）生成所有斐波那契数，直到满足条件。用10除法计算数字。时间：6625毫秒

import java.math.BigInteger;

public class P25 {

    final static int N = 1000;

    public static void main(String[] args) {
        int result = getTheFirstIndexHavingTheSpecifiedNumberOfDigits(N);
        System.out.println(result);
    }

    // similar performance if you use an "aux" variable
    private static int getTheFirstIndexHavingTheSpecifiedNumberOfDigits(int n) {
        BigInteger a = BigInteger.ONE;
        BigInteger b = BigInteger.ONE;
        int i = 1;
        while ( hasLessThanSpecifiedNumberOfDigits(a, n) ) {
            b = b.add(a);
            a = b.subtract(a);
            i++;
        }
        return i;
    }

    private static boolean hasLessThanSpecifiedNumberOfDigits(BigInteger x, int n) {
        return getNumberOfDigits(x) < n;
    }

    private static int getNumberOfDigits(BigInteger x) {
        int numberOfDigits = 0 ;
        while ( x.compareTo(BigInteger.ZERO) > 0 ) {
            numberOfDigits++;
            x = x.divide(BigInteger.TEN);
        }
        return numberOfDigits;
    }

}

您可以使用：

while( !isGood() ) {
    ...
}

而不是

while(true) {
    ...
    if ( isGood() ) {
       break;
    }
}

以下是使用上述方法的3种解决方案（从慢到快）：

1）生成所有斐波那契数，直到满足条件。用10除法计算数字。时间：6625毫秒

import java.math.BigInteger;

public class P25 {

    final static int N = 1000;

    public static void main(String[] args) {
        int result = getTheFirstIndexHavingTheSpecifiedNumberOfDigits(N);
        System.out.println(result);
    }

    // similar performance if you use an "aux" variable
    private static int getTheFirstIndexHavingTheSpecifiedNumberOfDigits(int n) {
        BigInteger a = BigInteger.ONE;
        BigInteger b = BigInteger.ONE;
        int i = 1;
        while ( hasLessThanSpecifiedNumberOfDigits(a, n) ) {
            b = b.add(a);
            a = b.subtract(a);
            i++;
        }
        return i;
    }

    private static boolean hasLessThanSpecifiedNumberOfDigits(BigInteger x, int n) {
        return getNumberOfDigits(x) < n;
    }

    private static int getNumberOfDigits(BigInteger x) {
        int numberOfDigits = 0 ;
        while ( x.compareTo(BigInteger.ZERO) > 0 ) {
            numberOfDigits++;
            x = x.divide(BigInteger.TEN);
        }
        return numberOfDigits;
    }

}

虽然（真的）我什么都不做；请注意，1000也是允许的，因此将其更改为：
if（len>=1000）
，而不是
if（len>1000）
。请注意，斐波那契的两个起始数是1和1。因此，将其更改为：
var=biginger.ONE；var2=BigInteger.ONE
；欧拉计划是一系列涉及数学的编程挑战。请记住，提出问题的人不一定需要特定问题之外的提示或提示。基本上要小心破坏者。谢谢虽然（真的）我什么都不做；请注意，1000也是允许的，因此将其更改为：
if（len>=1000）
，而不是
if（len>1000）
。请注意，斐波那契的两个起始数是1和1。因此，将其更改为：
var=biginger.ONE；var2=BigInteger.ONE
；欧拉计划是一系列涉及数学的编程挑战。请记住，提出问题的人不一定需要特定问题之外的提示或提示。基本上要小心破坏者。感谢