编写查找素数的方法

Question

我正在尝试编写一个程序，该程序使用谓词方法来查找1-100之间的所有素数。 我知道找到质数有更有效的方法，但是现在，但是我想使用蛮力策略并尝试所有可能的组合。

现在，该程序原样只打印10,000次对或错，但是我希望我的程序只打印素数的数字。 因此，程序完成后，我将得到一个介于1至100之间的质数列表。

1.我的程序对我要执行的操作是否正确？ 2.建议更改我的程序，以便它列出1至100之间的所有素数。

import acm.program.*;
public class PrimeNumbers extends ConsoleProgram{
public void run(){

    for (int i =1; i <= 100, i++){
        for (int j =1; j<= 100; j++){
           println(yesPrime(i, j));
       }
     }
   }

private boolean yesPrime (int n, int k){
      return ( n % k == 0)

       }
    }
  }

Answer 1

您没有检查素数。 您正在测试从10,000到10,000的两个数字的所有组合，以查看第二个数字是否均等地除以第一个数字。

但这可能正确地做到了。

您想要做什么的伪代码：

for each number n from 2:100
    for each divisor d from 2:n-1
        test to see if d divided n evenly
    end for
    if no values of d other than n divided n evenly
        print "n is prime"
end for

有几个优化方案可供您考虑：

• 您的内部循环仅需上升到sqrt（n）。 （为什么？）
• 除了所有数字，您只需要检查它是否能将已经找到的奇数素数相除即可。 （为什么？）

玩得开心！

Answer 2

使用Eratosthenes筛子：

public static void main(String[] args) {

    int n = 100; // the max number for test

    // Sieve of Eratosthenes
    boolean[] sieve = new boolean[n + 1];
    for (int i = 2; i <= n; i++) {
        sieve[i] = true;
    }
    for (int i = 2; i <= n; i++) {
        if (sieve[i] != false) {
            for (int j = i; j * i <= n; j++) {
                sieve[i * j] = false;
            }
        }
    }

    // Print prime numbers
    for (int i = 0; i <= n; i++) {
        if (sieve[i]) {
            System.out.println(i);
        }
    }

}

Answer 3

好吧，您要从yesPrime返回比较结果，然后在run打印该比较结果。 猜猜输出是什么。

考虑到这是一项任务，我想给你一个提示而不是答案。

检查yesPrime的结果。 如果为true，则打印数字并退出循环。

Answer 4

    Scanner reader = new Scanner(System.in);
    System.out.println("Enter the a number");
    int num = reader.nextInt();
    int counter = 0;
    int root = 0;
    boolean prime_flag;

    if (2 <= num) {
        // 2 is the only even prime number
        counter++;
    }

    for (int i = 3; i < (num + 1); i++) {

        // test only for odd number
        if (i % 2 != 0) {
            prime_flag = true;
            root = (int) (Math.sqrt(i) + 1);

            for (int j = 3; j < (root + 1); j++) {
                if ((i % j == 0) && (i != j)) {

                    prime_flag = false;
                    break;
                }
            }

            if (prime_flag) {
                counter++;
            }

        }

    }

    System.out.println("Count of prime numbers upto " + num + " is "
            + counter);

Answer 5

我将创建一个函数，类似于您的yesPrime函数。 这仅需要一个数字，并检查该数字是否为质数。

就像是

boolean yesPrime(int n)
{
    // check to see if n is divisble by numbers between 2 and sqrt(n)
    // if the number is divisible, it is not prime, so return false
    // after the loop has checked all numbers up to sqrt(n), n must be prime so return true
}

然后在主程序中，将数字1循环到100，并为每个数字调用yesPrime。 如果结果为真，则打印该号码。

我的理解是编程的一个目标是将问题分解为较小的子问题。 通过编写用于测试质数的函数，可以避免在一个函数中使用嵌套循环，而这可能很难理解。

Answer 6

对于初学者，您需要检查从2开始的质数。不要对所有100个数字进行质数检查，仅将每个数字作为从2到（number-1）的因子进行检查。每个数字都可以被1整除。

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

private static boolean checkPrime(int k) {

    for (int i = 2; i < k; i++) {  
//check if the number is divisible by any number starting from 2 till number -1.If it is, it is not a prime number
        if (k % i == 0)
            return false;
    }
// return true if the number is not divisible by any number from 2 to number -1 i.e.  it s a prime number.
    return true;
}

Answer 7

想想这个逻辑
所有可被2整除的数字不是素数，因此您可以将数字加2
如果一个数字不能被质数整除，那么它就是质数

试试这个代码

public static void main(String[] args) throws IOException
    {
        int[] prime=new int[50];   //array to store prime numbers| within 1 to ==> prime numbers will be <=n/2 here n=100
        int i=1;        //index for "num" array
        int j=1;        //index for storing to "prime" array
        int k=1;        //index for browsing through prime array
        prime[0]=2;     // setting the first element
        int flag=1;     // to check if a number is divisibe for than 2 times
        for(i=3;i<=100;i+=2) {
            for(k=0;prime[k]!=0;k++)    //browsing through the array to till non zero number is encountered
            {
                if(i%prime[k]==0) flag++;   //checking if the number is divisible, if so the flag is incremented 
            }
            if(flag<2)
            {
                prime[j++]=i;               // if the flag is still 1 then the number is a prime number
            }
            flag=1;
        }
        System.out.println(Arrays.toString(prime)); //a short way to print an array
        }

Answer 8

查找给定范围内的质数很容易/ *请实现此方法以返回给定范围（含）内所有质数的列表。 质数是一个自然数，正好具有两个不同的自然数除数，即1和素数本身。 第一个质数是：2、3、5、7、11、13 * /

public void getPrimeNumbers(int st, int en){
    // int st=1, en=100;
    for(int i=st;i<=en;i++)
        if( (i%2!=0) && (i%1==0 && i%i==0) )
            System.out.println("Yes prime");      
}

Answer 9

public static void main(String[] args) {

    boolean isPrime = true;             //set isPrime to true

    for (int i = 2; i<100;i++){          // consider i is increasing number

        for (int j=2; j<i; j++)           //j is divisor & must be less than
                                         //i and increasing after each iteration
        {
            if((i % j)== 0){             // if i gets divisible by 
                                         // any increasing value of j from 2
                                        //then enters in this case and makes value
                                        //nonPrime
                isPrime=false;     //changes value
            break;                   //breaks "for loop of j"
        }
            }               //ends "for loop of j"
        if(isPrime)            // if case wont work then number is prime
        {

            System.out.println(i + " is Prime");
        }
        isPrime = true;       //sets isPrime to default true. 
    }
    }

Answer 10

使用不太复杂的方法，我们可以执行以下操作：

import java.math.BigInteger;

public class PrimeNumbers {

    public static void main(String[] args) {
        BigInteger min = new BigInteger("2");
        BigInteger max = new BigInteger("100");

        while(min.compareTo(max) < 0){

            System.out.println(min);
            min = min.nextProbablePrime();

        }

    }
}

Answer 11

这是我寻找素数的解决方案。

public class PrimeNumberFinder {

    public boolean isPrime(int number) {
        return number > 1 && IntStream.rangeClosed(2, number / 2)
                .noneMatch(value -> number % value == 0);
    }
}