Project Euler #10 Java 解决方案不起作用

Question

我试图找到

打印“sum”给出：1308111344，这是不正确的。

编辑： 感谢所有的帮助。将 int 更改为 long 并将

/*
The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
Find the sum of all the primes below two million.
*/
class Helper{
 public void run(){
  Integer sum = 0;
  for(int i = 2; i < 2000000; i++){
   if(isPrime(i))
    sum += i;   
  }
  System.out.println(sum);
 }

 private boolean isPrime(int nr){
  if(nr == 2)
   return true;
  else if(nr == 1)
   return false;
  if(nr % 2 == 0)
   return false;

  for(int i = 3; i < Math.sqrt(nr); i += 2){
   if(nr % i == 0)
    return false;
  }  
  return true;  
 }
}   
class Problem{
 public static void main(String[] args){
  Helper p = new Helper();
p.run();
}
}

Answer 1

结果将太大而无法放入整数，因此您将获得overflow。尝试改用BigInteger 或long。在这种情况下，一个 long 就足够了。

Answer 2

您将那些只能被平方根整除的数字（如 25）视为素数。而不是i < Math.sqrt(nr) 尝试i <= Math.sqrt(nr)。

顺便说一句，这是一种非常低效的求素数的方法。

Answer 3

您的 isPrime 不适用于正方形。 isPrime(9) 返回 true。

Answer 4

如前所述，错误有两个：

• 您使用的int 不足以容纳该金额..您应该使用long
• 您使用 < 而不是 <=，这是循环的错误保护

除此之外，您所做的确实效率低下，无需深入了解此类算法（例如 Miller-Rabin 测试），我建议您查看Sieve of Eratosthenes .. 一种非常古老的方法，它教授如何以简单的方式处理复杂问题，以通过权衡内存来提高优雅和效率。

它真的很聪明：它会跟踪每个素数的 boolean 值，直到 200 万个，断言该数字是否为素数。然后从第一个素数开始，它排除了通过将它正在分析的素数乘以另一个数字而获得的所有连续数字。当然，它需要检查的数量更多，需要检查的数字更少（因为它已经排除了它们）

代码很简单（只是即时编写，没有检查）：

    boolean[] numbers = new boolean[2000000];
    long sum = 0;

    for (int i = 0; i < numbers.length; ++i)
        numbers[i] = true;

    for (int i = 2; i < numbers.length; ++i)
        if (!numbers[i])
            continue;
        else {
            int j = i + i;
            while (j < 2000000) {                   
                numbers[j] = false;
                j += i;
            }           
        }

    for (int i = 2; i < 2000000; ++i)
        sum += numbers[i] ? i : 0;

    System.out.println(sum);

当然，这种方法仍然不适合大数字（因为它必须找到所有先前的素数并且因为内存），但它是初学者思考问题的一个很好的例子..

Answer 5

这是我的解决方案

  public class ProjectEuler {

    public static boolean isPrime(int i) {
        if (i < 2) {
            return false;
        } else if (i % 2 == 0 && i != 2) {
            return false;
        } else {
            for (int j = 3; j <= Math.sqrt(i); j = j + 2) {
                if (i % j == 0) {
                    return false;
                }
            }

            return true;
        }
    }


    public static long sumOfAllPrime(int number){
        long sum = 2;

        for (int i = 3; i <= number; i += 2) {
            if (isPrime(i)) {
                sum += i;
            }
        }

        return sum;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(sumOfAllPrime(2000000));
    }
}

Answer 6

通过有效地使用Sieve of Eratosthenes，我解决了问题，这是我的代码

public class SumOfPrime {

    static void findSum()
    {
        long i=3;
        long sum=0;
        int count=0;
        boolean[] array = new boolean[2000000];
        for(long j=0;j<array.length;j++)
        {
         if((j&1)==0)
          array[(int)j]=false;   
         else    
         array[(int)j]=true;
        }
        array[1]=false;
        array[2]=true;
        for(;i<2000000;i+=2)
        { 
            if(array[(int)i] & isPrime(i))
            {   
                array[(int)i]=true;
                //Sieve of Eratosthenes
                for(long j=i+i;j<array.length;j+=i)
                    array[(int)j]=false;
            }
        }
        for(int j=0;j<array.length;j++)
        {
            if(array[j])
            {   
             //System.out.println(j);
             count++;   
             sum+=j;
            }
        }   
        System.out.println("Sum="+sum +" Count="+count);
    }
    public static boolean isPrime(long num)
    {
        boolean flag=false;
        long i=3;
        long limit=(long)Math.sqrt(num);
        for(;i<limit && !(flag);i+=2)
        {
            if(num%i==0)
            {
                flag=false;
                break;
            }   
        }
        if(i>=limit)
         flag=true;
        return flag;
    }

    public static void main(String args[])
    {
        long start=System.currentTimeMillis();
        findSum();
        long end=System.currentTimeMillis();
        System.out.println("Time for execution="+(end-start)+"ms");
    }

}

输出是

Sum=142913828922 Count=148933
Time for execution=2360ms

如有疑问，请告知