Java 项目Euler#10，爪哇

可能重复：

所以，我试图用Java来解决这个问题，但我没有得到正确的答案。这是我的密码：

public class Problem10 {
public static void main(String[] args)
{
    long sum =0;
    for(int i =3;i<2000000;i+=2)
    {
        if(isPrime(i))
        {
            sum+=i;
        }
    }
    System.out.println(sum);
}

public static boolean isPrime(int n)
{
    boolean prime = true;
    if (n<2) return false;
    if (n==2) return true;
    if (n%2==0) return false;
    for (int i = 3; i<=Math.sqrt(n);i+=2)
    {
        if (n%i==0)
        {
            prime=false;
            break;
        }
    }
    return prime;
}
}

公共类问题10{
公共静态void main（字符串[]args）
{
长和=0；
for（inti=3；i
for（inti=3；i
for（int i=3；i只需将素数除以，就可以稍微加快代码的速度。例如，只需将35除以2、3、5，就可以知道35不是素数。无需尝试4。诀窍是，无论何时找到素数，都要将其保存在列表或向量中。在isPrime函数中，只需迭代列表，直到找到它s sqrt（n）而不是3..sqrt（n）之间的每个值.
只需除以素数，您就可以稍微加快代码速度。例如，只需将35除以2、3、5，您就可以知道35不是素数。无需尝试4。诀窍是，无论何时找到素数，都要将其保存在列表或向量中。在iPrime函数中，只需迭代列表，直到它达到sqrt（n） 而不是3..sqrt（n）之间的每个值.
你可以通过使用筛子来加速你的代码。
你可以通过使用筛子来加速你的代码。
我发现以下方法非常有效，当我检查一个数字是否为素数时，我只将该数字除以先前找到的素数，并且低于n的平方根。无需检查所有数字在n的平方根以下，只需要一秒钟以上

public class Problem10 {

    private static List<Long> listOfPrimes = new ArrayList<Long>();

    public static void main(String args[]) {

        long count = 0;
        for (long i = 2; i < 2000000; i++) {
            if (isPrime(i)) {
                count += i;
                System.out.print(i + " ");
            }
            if (i % 1000 == 0) {
                System.out.println();
            }
        }

        System.out.println("\nTotal " + count);

    }

    private static boolean isPrime(long n) {

        String strFromN = new Long(n).toString();
        if ((strFromN.length() != 1) && (strFromN.endsWith("2") || strFromN.endsWith("4") || strFromN.endsWith("5") || strFromN.endsWith("6") || strFromN.endsWith("8"))) {
            return false;
        }

        for (Long num : listOfPrimes) {
            if (num > Math.sqrt(n)) {
                break;
            }
            if (n % num.longValue() == 0) {
                return false;
            }
        }


        listOfPrimes.add(new Long(n));
        return true;
    }
}

公共类问题10{
private static List List of primes=new ArrayList（）；
公共静态void main（字符串参数[]）{
长计数=0；
用于（长i=2；i<2000000；i++）{
如果（i）{
计数+=i；
系统输出打印（i+“”）；
}
如果（i%1000==0）{
System.out.println（）；
}
}
System.out.println（“\n总计”+计数）；
}
私有静态布尔iPrime（长n）{
String strFromN=新长（n）.toString（）；
如果（（strFromN.length（）！=1）和&（strFromN.endsWith（“2”）| | strFromN.endsWith（“4”）| | strFromN.endsWith（“5”）| | strFromN.endsWith（“6”）| strFromN.endsWith（“8”））{
返回false；
}
for（长数值：listOfPrimes）{
if（num>Math.sqrt（n））{
打破
}
如果（n%num.longValue（）==0）{
返回false；
}
}
添加（新长（n））；
返回true；
}
}
我发现下面的方法非常有效，当我检查一个数字是否为素数时，我只将该数字除以先前找到的素数，并且该素数在n的平方根以下。无需检查n的平方根以下的所有数字。而且只需一秒钟以上

public class Problem10 {

    private static List<Long> listOfPrimes = new ArrayList<Long>();

    public static void main(String args[]) {

        long count = 0;
        for (long i = 2; i < 2000000; i++) {
            if (isPrime(i)) {
                count += i;
                System.out.print(i + " ");
            }
            if (i % 1000 == 0) {
                System.out.println();
            }
        }

        System.out.println("\nTotal " + count);

    }

    private static boolean isPrime(long n) {

        String strFromN = new Long(n).toString();
        if ((strFromN.length() != 1) && (strFromN.endsWith("2") || strFromN.endsWith("4") || strFromN.endsWith("5") || strFromN.endsWith("6") || strFromN.endsWith("8"))) {
            return false;
        }

        for (Long num : listOfPrimes) {
            if (num > Math.sqrt(n)) {
                break;
            }
            if (n % num.longValue() == 0) {
                return false;
            }
        }


        listOfPrimes.add(new Long(n));
        return true;
    }
}

公共类问题10{
private static List List of primes=new ArrayList（）；
公共静态void main（字符串参数[]）{
长计数=0；
用于（长i=2；i<2000000；i++）{
如果（i）{
计数+=i；
系统输出打印（i+“”）；
}
如果（i%1000==0）{
System.out.println（）；
}
}
System.out.println（“\n总计”+计数）；
}
私有静态布尔iPrime（长n）{
String strFromN=新长（n）.toString（）；
如果（（strFromN.length（）！=1）和&（strFromN.endsWith（“2”）| | strFromN.endsWith（“4”）| | strFromN.endsWith（“5”）| | strFromN.endsWith（“6”）| strFromN.endsWith（“8”））{
返回false；
}
for（长数值：listOfPrimes）{
if（num>Math.sqrt（n））{
打破
}
如果（n%num.longValue（）==0）{
返回false；
}
}
添加（新长（n））；
返回true；
}
}
如果你注意到上面的内容，我让If（n==2）返回true；但是在主循环中，你的循环从3开始。但是你从3开始，所以n永远不会等于2如果你注意到上面的内容，我让If（n==2）返回true；但是在主循环中，你的循环从3开始。但是你从3开始，所以n永远不会等于2。这个方法不是非常低效。在Haskell中，它是
2：[n | n0.rem n][3,5..floor（sqrt（from integral n））]]
-奇数最小试除法。以下方法效率极低，而且很流行：
sieve[2..]其中sieve（x:xs）=x:sieve[n | n0]
-用素数进行过多的试除法。更慢、也相当流行的是
[n | n0.rem n][2..n-1]]
-所有数字的过度试除。
[n |这种方法并不是非常低效。在哈斯凯尔，它是
2[n | n0.rem n][3,5..floor（sqrt（from integral n））]]
-奇数的最小试除。以下方法效率非常低，而且很流行：
筛[2..，其中筛（x:xs）=x:sieve n[n | n0]
-过多的素数除法。甚至更慢、也相当流行的是
[n|n0.rem n][2..n-1]
-过多的所有数字除法。
[n|这需要很多时间memory@amir：不太可能…200万以下有<150000个素数，而且它们随着你的增加而变得越来越稀疏。使用32位整数的列表，这只需要600kb。在任何情况下，代码按原样运行只需不到5秒。真的不需要优化。这将花费大量时间memory@amir：不太好。..在200万以下有<150000个素数，它们随着你的增加而变得越来越稀疏。使用32位整数的列表，这只需要600kb。在任何情况下，代码按原样运行只需不到5秒。真的不需要优化。不需要测试2以上的偶数；它已经被称为素数：replace
long count=0；例如（长i=2；i<2000000；i++）{
带
long count=2；for（长i=3；i<2000000；i++=2）{
。因此现在不需要字符串转换。甚至不需要测试