Question

我被要求编写一个程序，以最佳方式查找下一个素数。我写了这段代码，但我找不到最佳答案。有什么建议吗？

driver = new InternetExplorerDriver(capabilities);

Answer 1

public int nextPrime(int input){
  int counter;
  input++;   
  while(true){
    counter = 0;
    for(int i = 2; i <= sqrt(input); i ++){
      if(input % i == 0)  counter++;
    }
    if(counter == 0)
      return input;
    else{
      input++;
      continue;
    }
  }
}

无需检查输入号码。检查数字的平方根就足够了。对不起，我不记得定理名。这里我们正在增加下一个素数的输入。

该解决方案的时间复杂度O（n ^（3/2））。

Answer 2

@Ephraim-我已将递归代码替换为“ while”循环。它的运行速度更快。

int nextPrime(int M) {
    while(!isPrime(++M))
        // no need ++M; as I already added in the isPrime method's parameter. 
    return M;
}
boolean isPrime(int M) {
    for(int i = 2; i <= M; i++)
        if(M % i == 0) 
            return false;
    return true;
}

@Scott Parent-我已经测试了递归代码； “ while”循环和流代码（IntStream和LongStream）-Stream的代码运行缓慢，非常缓慢。示例：
输入值：6000000000000
输出：60000000029
递归算法的经过时间= 7 毫秒
输出：60000000029
遍历算法的经过时间= 4 毫秒
输出：60000000029
LongStream.range（2，number）.noneMatch（...）算法经过的时间= 615825 毫秒

如果我使用IntStream，则最大Integer数的耗时约为230毫秒。它太慢了。
nextPrime（int n）中的“ while”循环正在运行1-4毫秒以获取最大整数，但是使用LongStream作为600000000000000输入值-我在1小时内看不到结果。
我现在正在为600000000000000长号运行：
递归算法的经过时间= 36 毫秒
输出：60000000029
遍历算法的经过时间= 27 毫秒
输出：60000000029
LongStream.range（2，number）.noneMatch（...）所用的时间
它仍在运行58分钟以上，但尚未完成。

Answer 3

public int nextPrime(int input){
  int counter;
  while(true){
    counter = 0;
    for(int i = 1; i <= input; i ++){
      if(input % i == 0)  counter++;
    }
    if(counter == 2)
      return input;
    else{
      input++;
      continue;
    }
  }
}

这将返回nextPrime，但不能说是最佳方式

它很简单，因为它执行一个无限的while循环，它会在什么时候中断返回素数。
在while中查找数字是否为素数
如果是素数，则返回该数字，如果不是，则增加输入并继续while循环

Answer 4

使用eratosthenes筛子生成所有素数达到极限。然后输入您的号码 n 并搜索n＆gt; prime [i]，prime [i]就是答案。

Answer 5

你也可以使用这样的递归来做同样的事情：

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

Answer 6

这里我添加一个解算法。首先，while循环在number + 1到number * 2的范围内抓取下一个要测试的数字。然后将数字发送到isPrime方法（使用Java 8 streams），该方法迭代stream以查找没有其他因素的数字。

private static int nextPrime(final int number) {
    int i = number + 1;
    while (!isPrime(i) && i < number * 2)
        i++;
    return i;
}

private static boolean isPrime(final int number) {
    return number > 1 && IntStream.range(2, number).noneMatch(index -> number % index == 0);
}

Answer 7

我的儿子用一种方法编写了自己的算法。但这是用python写的-您可以找到它here。

在Java上，它看起来像：

static long nextPrime(long number) {
    boolean prime = false;
    long n = number;
    while (!prime && n < number * 2) {
        n++;
        prime = true;
        for (int i = 2; i < n; i++) {
            if (n % i == 0) {
                prime = false;
                break;
            }
        }
    }
    return n;
}

Answer 8

Dude检查此代码。 isPrime()循环中的while在递增当前素数/非素数后，检查下一个素数。我确实使用了long数据类型（这就是我得到的赋值）。

if (isPrime(num)) {
    System.out.println("Current Prime number: " + num);
} else {
    long a = getNextPrime(num);
    System.out.println("Next Prime:" + a);
}

public static long getNextPrime(long num) {
    long nextPrime = 0;
    while (true) {
        num++;
        boolean x = isPrime(num);
        if (x) {
            nextPrime = num;
            break;
        }
    }

    return nextPrime;
}

public static boolean isPrime(long num) {
    if (num == 0 || num == 1) {
        return false;
    }

    for (long i = 2; i <= num / 2; ++i) {
        if (num % i == 0) {
            return false;
        }
    } 

    return true;
}

Answer 9

这是查找下一个质数的功能方法。

public void printFirstNPrimes(long n) {
        Stream.iterate(2, i->nextPrime(i))
        .limit(n).forEach(System.out::println);
}

public static boolean isPrime(long x) {
    return Stream.iterate(2, i->i+1)
                .limit((long)(Math.sqrt(x)))
                .allMatch(n -> x % n != 0);
}

public static int nextPrime(int x) {
    return isPrime(x+1)? x+1 : nextPrime(x+1);
}

Answer 10

因此，我正在阅读第一个答案，看到了一些潜在的升级。我做了它们，并且得到了很大的进步。

原始代码可以在 22.32s 中计算200000个素数做了一些改动，我设法在 11.41s 中执行了相同的操作，并获得了相同的结果。

注意，我在运行于IntelIJ的笔记本电脑上@ 2.50 GHz上执行了代码。

public static int nextPrime(int n) {

    boolean isPrime;
    n++;
    while (true) {
        int sqrt = (int) Math.sqrt(n);
        isprime = true;
        for (int i = 2; i <= sqrt; i++) {
            if (n % i == 0) isPrime = false;
        }
        if (isPrime)
            return n;
        else {
            n++;
        }
    }


}

希望你喜欢它！

Answer 11

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    ui->webView->load(QUrl("http://www.baidu.com/"));
}

void MainWindow::on_pushButton_clicked()
{
    ui->labelRight->winId();
}

Answer 12

long n = 12345;
BigInteger b = new BigInteger(String.valueOf(n)); 
long res = Long.parseLong(b.nextProbablePrime().toString()); 

System.out.println("Next prime no. is "+ res);

查找下一个素数的最佳方法（Java）

12 个答案: