Question

我正在编写一个代码，在一个名为primes.txt的文件中写入2到1000之间的所有素数。出于某种原因，我无法找出解决此问题的正确方法。

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class Problem6 {

    /**
     * @param args
     * @throws FileNotFoundException 
     */
    public static void main(String[] args) throws FileNotFoundException {
        PrintWriter prw = new PrintWriter("primes.txt");
        for (int i = 2; i <= 1000; i++){
            if (checkIfPrime(i) == true){
                System.out.println(i);
                prw.println(i);
            }
        }
    }

    public static boolean checkIfPrime (int num){
        boolean isPrime = true;  
        for (int i = 2; i <= 1000; i++){
            if ( num % i == 0 ){
                isPrime = false;
            }
        }

        return isPrime;
    }
}

我只是不知道该怎么做...请帮忙谢谢！

Answer 1

将第一个号码2传递给checkIfPrime时会发生什么？它将取2的余数除以2，即0，错误地声称2不是素数。

在实际到达num之前，您需要停止测试余数。在i到达i之前停止num for循环。（事实上，您可以在i达到num的平方根后停止。

for (int i = 2; i < num; i++){

甚至

for (int i = 2; i <= Math.sqrt(num); i++){

如果您有冒险精神，可以尝试实施Sieve of Eratosthenes，这会将所有复合数字标记为任意限制（在此问题中为1000）。然后你打印出剩下的数字 - 素数。

Answer 2

通过仅使用素数检查除法，可以更快地进行计算。任何非素数都可以被一些比自身小的素数整除。

    static List<Integer> primes = new ArrayList<Integer>();

public static void main(String[] args) {
    for (int i = 2; i < 10000; i++) {
        if(checkPrime(i)){
            primes.add(i);
        }
    }
    System.out.println(primes);
}

private static boolean checkPrime(int n) {
    for (Integer i : primes) {
        if(i*i > n ){
            break;
        }else if(n%i==0 )
            return false;
     }
    return true;
}

Answer 3

将for中的checkIfPrime(int num)条件更改为

for (int i = 2; i < num; i++) {

BTW if (checkIfPrime(i) == true){可写为if (checkIfPrime(i)){

Answer 4

如果数字num不能被大于一个且小于num 的任何其他数字整除，则该数字为{{1}}。你的代码在哪里？： - ）

Answer 5

以下是您如何在incremental sieve of Eratosthenes 上“硬编码” 2-3-5-7 wheel以打印 1000 的素数。在C-like pseudocode，

primes_1000() { // the 2-3-5-7 wheel int wh[48] = {10,2,4,2,4,6,2,6,4,2,4,6,6,2,6,4,2,6,4,6,8,4,2,4, 2,4,8,6,4,6,2,4,6,2,6,6,4,2,4,6,2,6,4,2,4,2,10,2}; // core primes' multiples, each with its pointer into the wheel int m[7][4] = { {1,11,11,11*11}, {2,13,13,13*13}, {3,17,17,17*17}, {4,19,19,19*19}, {5,23,23,23*23}, {6,29,29,29*29}, {7,31,31,31*31} }; // 23*23 = 529 int i=1, p=11, k=0; print(2); print(3); print(5); print(7); p = 11; // first number on the wheel - the first candidate do { // the smallest duplicate multiple is 121*13, ==> no dups below 1000! for( k=0; k < 7; ++k) { if ( p == m[k][3] ) { // p is a multiple of m[k][1] prime: m[k][2] += wh[ m[k][0]++ ]; // next number on the wheel m[k][3] = m[k][1] * m[k][2]; // next multiple of m[k][1] m[k][0] %= 48; // index into the wheel break; } } if (k == 7) { // multiple of no prime below 32 - print(p); // - a prime below 1000! (32^2 = 1024) } p += wh[i++]; // next number on the candidates wheel i %= 48; // wrap around to simulate circular list } while ( p < 1000 ); }

对于低于 500 的质数，只需要维护4个筛子变量，因为额外的核心素数 {11,13,17,19} 高于车轮的固有质数 2,3,5,7

（另见Printing prime numbers from 1 through 100）。

m是基本素数的字典及其在轮子上的倍数（multiplesOf(p) = map( multiplyBy(p), rollWheelFrom(p) )，每个都有自己的车轮索引。它应该是一个优先级队列，按倍数最小排序'价值观。

对于一个真正的无界解，a separate primes supply可以维持，当候选人中达到下一个素数的平方时，将素数扩展到素数。

打印Prime数字从2到1000

5 个答案: