Question

我需要创建一个程序，可以将所有素数从1增加到大数。我有一个getPrime方法，如果数字为素数则返回true，如果不是素数则返回false。当我使用这个方法和一个while循环来获得从1到大数的素数列表时它会保持返回24然后4然后5.变量end，在下面的代码中要求在一个素数类中分别。这是我的代码：

public class Prime 
{

    private long userNumber;
    private int numRoot;
    private int x;
    private boolean isPrime;
    private int factors;
    private long end;
    private int i;

    public void setUserNumber(long num)
    { 
       userNumber = num;
    }

    public void setEndNumber(long n)
    { 
        end = n;
    }

    public boolean getPrime()
    {
        numRoot = ((int)Math.sqrt(userNumber));


        for (x=2; x<=numRoot; x++)
        {
            if ((userNumber % x) == 0)
            {
                factors++;        
            }
        }

        if (factors >1) {
            isPrime = false;
        }
        else {
            isPrime = true;
        }
        return  isPrime;
    }  
    public void getPrimeList()
    {
        if(end < 2) {
            System.out.println("No prime numbers");
            System.exit(0);
        }
        System.out.printf("\nThe prime numbers from 1 to %d are: \n 2", end);
        Prime primeNum = new Prime();
        i = 3;
        while( i <= end )
        {
            userNumber = i;
            getPrime();
            if (isPrime == true)
            {
                System.out.println(userNumber);
            }
            i++;
        }
        System.out.println();
    }
 }

Answer 1

public class PrimeTest{
    private static final int MAX_NUM = Integer.MAX_VALUE; // your big number

    public static void main(String[] args) {
        int count = 0;
        for(int i=0; i<MAX_NUM; i++) {
            if (isPrime(i)) {
                System.out.printf("Prime number %d\n", i);
                count++;
            }
        }
        System.out.printf("There is %d prime numbers between %d and %d\n", count, 0, MAX_NUM);
    }


    public static boolean isPrime(int number) {
        if (number < 2) {
            return false;
        }
        for (int i=2; i*i <= number; i++) {
            if (number % i == 0) {
                return false;
            }
        }
        return true;
    }
}

Answer 2

素数p应该在2和sqrt(p)之间具有零因子，但您在此处允许一个：

if (factors >1){
    isPrime = false;
}

事实上，根本没有必要计算因素，你可以直接做

if ((userNumber % x) == 0) {
    return false; 
}

如果您无论如何都需要计算因素，我建议您在开始时将factors明确设置为0。依赖隐式初始值并不是一个好习惯。

Answer 3

问题是你在getPrime中使用了太多的实例变量，导致你无意中继承了之前迭代的状态。更准确地说，factors应该在0开头重置到getPrime。

更好的解决方法是制作x，numRoot，isPrime和factors 本地变量 {{1} }：

getPrime

您可以更进一步，public boolean getPrime() { int factors = 0; boolean isPrime; int numRoot = ((int) Math.sqrt(userNumber)); for (int x=2; x<=numRoot; x++) { if ((userNumber % x) == 0) { factors++; } } if (factors >1){ isPrime = false; } else { isPrime = true; } return isPrime; } userNumber {em} getPrime

    public boolean getPrime(int userNumber)
    {
        // ...

并将其命名为：

while( i <= end )
{
            isPrime = getPrime(i);
    if (isPrime)
    {
        System.out.println(userNumber);
    }
    i++;
}

有两点需要注意：

我完全删除了userNumber内getPrimeList的使用情况，我只是使用了i。
isPrime如果在其他地方不需要也可以删除，只需使用if(getPrime(i)) { ... }。

Answer 4

public void getPrimes(int N) {
    for (int i = 2; i <= N; i++) {
        if (isPrime(i)) System.out.println(i);
    }
    System.out.println("These are all the prime numbers less than or equal to N.");
}

private boolean isPrime(int N) {
    if (N < 2) return false;
    for (int i = 2; i <= Math.sqrt(N); i++) {
        if (N % i == 0) return false;
    }
    return true;
}

Answer 5

下面的代码是用C＃编写的，虽然它可以在Java中使用，只需要很少的修改。我使用long作为数据类型，因为当你说“大数字”时，你没有具体说明。

    public static bool isPrime(long Number)
    {
        if (Number == 1) { return false; }
        int i = 2;
        while (i < Number)
        {
            if (Number % i++ == 0) { return false; }
        }
        return true;
    }

它可以像这样应用，这也是C＃，但是在Java中可以很少修改。

    while (i <= LARGE_NUMBER)
    {
        Console.Write((isPrime(i) ? i.ToString() + "\n" : ""));
        i++;
    }

Answer 6

您的算法是您的任务的错误解决方案。任务是找到从2到N的所有素数，适当的算法是 Eratosthenes的筛子。（参见here，了解有关筛选算法的基本知识和优化的史诗咆哮。）

众所周知，所有素数都是2,3,5,7,11,13或

形式

30*k-13, 30*k-11, 30*k-7, 30*k-1, 30*k+1, 30*k+7, 30*k+11, 30*k+13,

表示k = 1,2,3，......

所以你生成一个数组boolean isPrime [N + 1]，将all设置为true，对于上面形式的任何候选素数p，直到p p＆gt; N并且如果isPrime [p]为真，则设置all isPrime [k p] =假，k = 2,3,4，...... N / p。

int N;
Boolean isPrime[] = new Boolean[N+6];

static void cross_out(int p) {
    for(int k=5*p, d=2; k<N; k+=d*p, d=6-d) {
         isPrime[k]=false;
    }
}

static void sieve() {
    for(int k=0; k<N; k+=6) {
        isPrime[k  ]=isPrime[k+2]=false;
        isPrime[k+3]=isPrime[k+4]=false;
        isPrime[k+1]=isPrime[k+5]=true;
    }
    for(int k=5, d=2; k*k<N; k+=d; d=6-d) {
        if(isPrime[k]) cross_out(k);
    }
}

我需要将所有素数从1变为大数？

6 个答案: