下一个素数Java只处理某些数字

这个函数只适用于某些数字，但对于15或5，它不能给出正确的下一个素数

public static int nextPrime(int n) {
    boolean isPrime = false;
    int m = (int) Math.ceil(Math.sqrt(n));
    int start = 3;
    if (n % 2 == 0) {
        n = n + 1;
    }
    while (!isPrime) {
        isPrime = true;
        for (int i = start; i <= m; i = i + 2) {
            if (n % i == 0) {
                isPrime = false;
                break;
            }
        }
        if (!isPrime) {
            n = n + 2;
        }
    }
    return n;
}

publicstaticintnexttime（intn）{
布尔isPrime=false；
intm=（int）Math.ceil（Math.sqrt（n））；
int start=3；
如果（n%2==0）{
n=n+1；
}
而（！iPrime）{
isPrime=true；
对于（inti=start；i您不需要上升到sqrt（n），您需要上升到您正在评估的sqrt（number）

例如，假设你通过n＝5 < /p>
它将从3开始循环，在4结束循环，这不是你需要找到下一个素数的地方

外环
从n+1开始，直到找到素数
内环
您应该从3开始，并使用sqrt（numberunderieration）
计算for循环中的m

  while (!isPrime) {
     isPrime = true;
      int m = (int) Math.ceil(Math.sqrt(n));

     // do other stuff

您的代码可以正常工作，除非将素数作为输入，否则您的方法将返回输入本身

示例如果
5
是您的输入
nexttime（5）
返回
5
。如果您希望在这种情况下返回7（5之后的下一个素数）

只需在方法的开头添加
n=n+1；
。希望这有帮助。您只需将边界设置为原始数字的平方根。为了检查下一个数字是否有效，您需要在
n
值更改时重新计算边界。因此，将
int m=（int）Math.ceil（Math.sqrt（n））放入
int m=（int）Math.ceil（Math.sqrt（n））；
在while循环中

在开始任何计算之前，您还需要将
n
增加1，否则如果
n
本身是一个素数，则它将接受该素数。例如，
nexttime（5）
将返回
5
，因为它通过了条件

最后，在while循环结束时，您不需要将
n
增加2，因为如果您使用的是偶数，则它将发生变化（不断将2添加到偶数将始终为偶数）。我已对我更改的代码部分进行了注释：

public static int nextPrime(int n) {
    boolean isPrime = false;

    int start = 2; // start at 2 and omit your if statement

    while (!isPrime) {
        // always incrememnt n at the beginning to check a new number
        n += 1;
        // redefine max boundary here
        int m = (int) Math.ceil(Math.sqrt(n));

        isPrime = true;
        // increment i by 1, not 2 (you're skipping numbers...)
        for (int i = start; i <= m; i++) {
            if (n % i == 0) {
                isPrime = false;
                break;
            } 
        }
        // you don't need your "if (!isPrime)..." because you always increment
    }
    return n;
}

public static void main(String[] args) {

    System.out.println(nextPrime(15)); // 17
    System.out.println(nextPrime(5)); // 7
    System.out.println(nextPrime(8)); // 11
}

publicstaticintnexttime（intn）{
布尔isPrime=false；
int start=2；//从2开始，省略if语句
而（！iPrime）{
//始终在开始时递增n以检查新编号
n+=1；
//在此重新定义最大边界
intm=（int）Math.ceil（Math.sqrt（n））；
isPrime=true；
//将i增加1，而不是2（您正在跳过数字…）
为了（int i=start；i只是为了好玩，我编写了一个快速的
Prime
类来跟踪已知的素数，这大大提高了查找多个大素数的性能

import java.util.ArrayList;

public class Primes {

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

    public static int nextPrime(int number){

        //start it off with the basic primes
        if(primes.size() == 0){
            primes.add(2);
            primes.add(3);
            primes.add(5);
            primes.add(7);
        }

        int idx = primes.size()-1;
        int last = primes.get(idx);

        //check if we already have the prime we are looking for
        if(last > number){
            //go to the correct prime and return it
            boolean high = false;
            boolean low = false;
            int prevIdx = 0;
            int spread = 0;
            //keep finagling the index until we're not high or low
            while((high = primes.get(idx-1) > number) || (low = primes.get(idx) <= number)){
                spread = Math.abs(prevIdx-idx);
                //because we always need to move by at least 1 or we will get stuck
                spread = spread < 2 ? 2: spread;
                prevIdx = idx;
                if(high){
                    idx -= spread/2;
                } else if(low){
                    idx += spread/2;
                }
            };
            return primes.get(idx);
        }

        /*FIND OUR NEXT SERIES OF PRIMES*/

        //just in case 'number' was prime
        number++;

        int newPrime = last;
        //just keep adding primes until we find the right one
        while((last = primes.get(primes.size()-1)) < number){
            //here we find the next number
            newPrime += 2;
            //start with the assumption that we have a prime, then try to disprove that
            boolean isPrime = true;
            idx = 0;
            int comparisonPrime;
            int sqrt = (int) Math.sqrt(newPrime);
            //make sure we haven't gone over the square root limit- also use post-increment so that we use the idx 0
            while((comparisonPrime = primes.get(idx++)) <= sqrt){
                if(newPrime % comparisonPrime == 0){
                    isPrime = false;
                }
            }
            if(isPrime){
                primes.add(newPrime);
            }
        }

        return last;
    }
}

这将产生以下输出：

Prime after 1000000 is 1000003. Took 384 milliseconds.
Prime after 500 is 503. Took 10 milliseconds.
Prime after 1100000 is 1100009. Took 65 milliseconds.

正如你所看到的，第一次迭代需要很长时间，但我们只需要执行一次操作。之后，对于小于第一个数的素数，我们的时间几乎为零（因为这只是一个查找），对于比第一个稍大的素数，我们的时间非常快（因为我们已经完成了大部分工作）

编辑：使用
二进制搜索算法的变体更新现有素数的搜索。它将搜索时间至少缩短一半。
导入java.util.Scanner；
import java.util.Scanner;

class Testing 
{
    public static void main(String Ar[])
    {
        int a = 0, i, j;
        Scanner in = new Scanner(System.in);
        a = in.nextInt();
        for (j = a + 1;; j++) 
        {
            for (i = 2; i < j; i++) 
            {
                if (j % i == 0)
                break;
            }
              if (i == j) 
             {
                 System.out.println(j);
                 break;
             }
        }
    }
}

类测试
{
公共静态void main（字符串Ar[]
{
int a=0，i，j；
扫描仪输入=新扫描仪（系统输入）；
a=in.nextInt（）；
对于（j=a+1；；j++）
{
对于（i=2；i
这是为给定数字查找下一个素数的完美代码

public class NextPrime
{

    int nextPrime(int x)
    {
        int num=x,j;
            for( j=num+1;;j++)
            {
                int count=0;

                    for(int i=1;i<=j;i++)
                    {
                        if(j%i==0)
                        {
                        count++;
                        //System.out.println("entered");
                        }
                        //System.out.println(count);
                    }
                    if(count==2)
                    {
                    System.out.println(" next prime is ");
                    break;
                    }

            }return j;
    }

    public static void main(String args[])
    {
        NextPrime np = new NextPrime();
        int nxtprm = np.nextPrime(9);
        System.out.println(nxtprm);
    }

}

公共类下一次
{
int nextPrime（int x）
{
int num=x，j；
对于（j=num+1；；j++）
{
整数计数=0；
对于（inti=1；i
//我希望下面的代码能够准确地工作。
导入java.util.Scanner；
公共类下一次{
公共静态void main（字符串[]args）{
扫描仪=新的扫描仪（System.in）；
System.out.println（“输入一个正整数：”）；
int n=scanner.nextInt（）；
对于（int x=n+1；；x++）{
布尔值isPrime=true；
对于（int i=2；i
这应该是一个注释。除非您对此进行扩展。@用户查看解释版本您的代码适用于我，适用于15和5。尝试为变量使用更长的名称，这会使代码更易于阅读和回答。
i
to
potentialFactor
，
m
to
maxFactor
您能提供输入和预期输出吗放？天哪，你应该把这个提交给CodeReview。
public class NextPrime
{

    int nextPrime(int x)
    {
        int num=x,j;
            for( j=num+1;;j++)
            {
                int count=0;

                    for(int i=1;i<=j;i++)
                    {
                        if(j%i==0)
                        {
                        count++;
                        //System.out.println("entered");
                        }
                        //System.out.println(count);
                    }
                    if(count==2)
                    {
                    System.out.println(" next prime is ");
                    break;
                    }

            }return j;
    }

    public static void main(String args[])
    {
        NextPrime np = new NextPrime();
        int nxtprm = np.nextPrime(9);
        System.out.println(nxtprm);
    }

}

//I hope the following code works exactly.


import java.util.Scanner;
public class NextPrime {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter a positive integer number : ");
        int n = scanner.nextInt();
        for (int x = n + 1;; x++) {
            boolean isPrime = true;
            for (int i = 2; i < x / 2; i++) {
                if (x % i == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                System.out.println("Next prime is : " + x);
                break;
            }
        }
    }
}