1

我正在尝试 Euler 项目的第 50 题。

素数 41 可以写成六个连续素数之和：

41 = 2 + 3 + 5 + 7 + 11 + 13 这是添加到小于 100 的素数的最长连续素数之和。与素数相加的一千以下的最长连续素数之和包含 21 项，等于 953。哪一个小于一百万的素数可以写为最多连续素数之和？

这是我的代码：

    public class consPrime
    {
        static int checker(int ar[],int num,int index) //returns no.of consecutive
        {                                              //primes for the given num  
            while(true)
        {

        int temp=num;

        for(int i=index;i>=0;i--)
        {
            temp=temp-ar[i];

            if(temp==0)
            {
                return (index-i+1);
            }               
        }           
        index--;
        if(index==0)
        return 0;           
        }
    }

    public static void main(String args[])
    {               
        int n=100000;
        int ar[]=new int[n];
        int total=0;int flag;

        for(int i=2;i<1000000;i++)   //Generates an array of primes below 1 million
        {
            flag=1;

            for(int j=2;j<=Math.sqrt(i);j++)
            {
                if(i%j==0)
                {
                    flag=0;
                    break;
                }                   
            }
            if(flag==1)
            {
                ar[total]=i;
                total++;
            }               
        }

        int m=0;
        int Big=0;

        for(int i=total;i>=0;i--) //Prints the current answer with no.of prime
        {
            m=checker(ar,ar[i],i-1);
            if(Big<=m)
            {Big=m;
                System.out.println(ar[i]+"     "+Big);
            }
        }           
    }       
}

基本上，它只是创建一个包含最多 1000000 的所有素数的向量，然后循环遍历它们以找到正确的答案。答案是 997651，计数应该是 543，但我的程序分别输出 990707 和 75175。可能有什么问题？

4

2 回答 2

2

几个大问题：

  1. 首先是一些小问题：学习正确缩进代码，学习使用正确的命名约定。在 Java 中，变量名使用 camelCasing 而类型名使用 PascalCasing。

  2. 你的逻辑中有很多问题：你循环遍历素数数组，直到你达到零或直到循环遍历数组中的所有数字。但是，请注意，整数存在下溢/上溢。有可能“温度”不断扣除并变成负数，然后变成正数，如此等等并达到零。然而这不是正确的答案

  3. 您只尝试查找以索引 - 1 结尾的连续数字。例如，要检查索引 10 处的素数，您将从索引 9 向后查找连续素数。但是，与您的目标数相加的连续素数很少（实际上几乎从不，除了 5）包含“先前的”素数。整个逻辑是完全错误的。

  4. 更不用说您为 checker 传递的参数不正确，用户 @pm-77-1 的评论中提到了这一点

于 2013-04-03T02:16:40.237 回答
0

这是另一种需要43 ms的方法。

它基于以下方法：

1) 使用筛子生成 <= 1000000 的素数

2) 它在O(n 2 )中迭代所有数字并计算连续素数。第一个循环更改序列的第一个元素，第二个循环从该位置开始获取元素并将它们添加到总和中。如果总和是素数并且它由最大数量的素数组成，则它被保存在一个变量中。

import java.util.ArrayList;
import java.util.List;

public class P50 {

    private final static int N = 1_000_000;

    public static void main(String[] args) {
        boolean primes[] = generatePrimes(N);
        List<Integer> primeIntegers = new ArrayList<Integer>();
        for (int i = 0; i < primes.length; i++) {
            if (primes[i]) {
                primeIntegers.add(i);
            }
        }
        int count = 0;
        int sum = 0;
        int finalSum = 0;
        int finalCount = 0;
        int totalPrimes = primeIntegers.size();
        for (int start = 0; start < totalPrimes; start++) {
            sum = 0;
            count = 0;
            for (int current = start; current < totalPrimes; current++) {
                int actual = primeIntegers.get(current);
                sum += actual;
                if ( sum >= N ) {
                    break;
                }
                if ( primes[sum] ) {
                    if ( count > finalCount ) {
                        finalCount = count;
                        finalSum = sum;
                    }
                }
                count++;
            }
        }
        System.out.println(finalSum);
    }

    private static boolean[] generatePrimes(int n) {
        boolean primes[] = new boolean[n];
        for (int i = 0; i < n; i++) {
            primes[i] = true;
        }
        primes[0] = false;
        primes[1] = false;
        // i = step
        for (int i = 2; i * i < n; i++) {
            if (primes[i]) {
                for (int j = i * i; j < n; j += i) {
                    primes[j] = false;
                }
            }
        }
        return primes;
    }

}
于 2015-01-31T22:02:28.243 回答