Java 用递归法由用户输入确定素数

我需要用Java创建一个程序来确定一个数是否为素数

用户应该输入任何数字，程序将确定它是否为素数，并显示“not prime”或“prime”。我的代码现在编译并运行，但它总是说一个数字即使是素数也不是素数

import java.util.Scanner;

public class PrimeNumber
{
 public static void main(String[] args)
  {
    Scanner input = new Scanner(System.in);
   int constant = 0;
   int variable = 0;
   System.out.println("Enter a Number to test if Prime or Not");
   constant = input.nextInt();
   variable = constant;
   double answer = 0.0;
   answer = testPrime(constant, variable);
   System.out.println(+answer);
   if (answer == 1)
    {
     System.out.println(+constant + " is a prime number.");
    }
   else
     {
     System.out.println(+constant + " is NOT a prime number.");
    }
   }

public static double testPrime(int number, int divide)
 {
  double prime = 0.0;
  prime = number%divide;
  if (prime > 0 && divide != number)
   {
    return testPrime(number, divide - 1);
   }
   else
   {
    return prime;
   }
 }
}

这永远不会是真的。因为你的除法和数总是相等的

请注意，您已经分配了

variable=constant

，这就是您传递给该方法的内容

constant = input.nextInt();
variable = constant;
answer = testPrime(constant, variable);

---

这就是说，你需要非常复杂地找出一个数字是否是素数。查看网页上的简单算法。例如，请参见。

不是答案，因为OP需要递归（我猜是家庭作业）

你只需要到n的平方根，看看它是否有一个除数（除self之外的除数将

布尔isPrime（int n）{
如果（n%2==0）返回false；
inttill=（int）java.lang.Math.pow（n，0.5）；/（int）n/2；
对于（inti=3；i我知道您需要递归，所以我将tgkprog的答案转换为递归方法（尽管他的方法肯定更有效）。此外，我认为如果输入不是素数，您可能需要返回素数因子？我只是根据OP的返回值double而不是boolean来推测这一点。不过，我的将返回int，因为返回double很愚蠢

int isPrime(int n){ //starter function
      if(n<=1) return n; //sanity check for weird inputs
      if(n % 2 == 0) return 2; //2 is a prime factor
      int start  = (int)java.lang.Math.pow(n, 0.5);
      return isPrime(n,start-(start%2)); //makes start odd if it wasn't already
}

int isPrime(int n, int testval){ //recursive function
       if(testval<=1) return 1; //n is prime, return n since it has no prime factors
       if(n % i == 0) 
           return i; //found a prime factor!
       return isPrime(n,i-2);
}

intisprime（intn）{//starter函数
带递归的if（n）

import java.util.Scanner;

public class PrimeRecursion
{
    static int dbg;
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        System.out.println("Enter non 0 if you want debug :");
        dbg = input.nextInt();
        long constant = 3;
        long variable = 0;
        while(true){
            System.out.println("Enter a Number to test if Prime or Not (1 to exit)");
            constant = input.nextLong();
            if(constant < 3){
                if(constant == 2){
                    System.out.println("2 is a special prime");
                }
                return;
            }
            if(constant % 2 == 0){
                System.out.println(constant + " is NOT a prime number, even number.");
            }else{
                variable = (long)Math.pow(constant, 0.5);
                variable = (variable % 2 == 1) ? variable : variable + 1;//odd number
                double answer = 0.0;
                answer = testPrime(constant, variable);
                System.out.println("End answer : " + answer);
                if (answer == 1){
                    System.out.println(+constant + " is a prime number. answer : "  + answer);
                }
                else{
                    System.out.println(constant + " is NOT a prime number.answer : "  + answer);
                }
            }
            System.out.println();
        }
    }

    static double testPrime(long number, long divide)
    {
        double prime = 0.0;
        prime = (double)number / divide;
        if(dbg > 0){
            System.out.println("Debug number " + number + " | divide " + divide + " |prime : "  + prime + " | Math.abs(prime) " + Math.abs(prime));
        }
        if (prime == ((long)prime))//whats the best way to do this?
        {
            //divided evenly
            return divide;
        }
        else{
            return testPrime(number, divide - 2);
        }
    }
}

import java.util.Scanner；
公共类素数递归
{
静态int-dbg；
公共静态void main（字符串[]args）
{
扫描仪输入=新扫描仪（System.in）；
System.out.println（“如果需要调试，请输入非0:”；
dbg=input.nextInt（）；
长常数=3；
长变量=0；
while（true）{
System.out.println（“输入一个数字以测试素数是否为（1以退出）”；
常量=input.nextLong（）；
if（常数<3）{
if（常数==2）{
System.out.println（“2是一个特殊素数”）；
}
返回；
}
如果（常数%2==0）{
System.out.println（常量+“不是素数，不是偶数”）；
}否则{
变量=（长）Math.pow（常数，0.5）；
变量=（变量%2==1）？变量：变量+1；//奇数
双答案=0.0；
答案=测试素数（常数、变量）；
System.out.println（“结束应答：+应答”）；
如果（答案=1）{
System.out.println（+constant+”是一个素数。答案：“+answer”）；
}
否则{
System.out.println（常量+”不是质数。答案：“+答案”；
}
}
System.out.println（）；
}
}
静态双测试素数（长数字、长除法）
{
双素数=0.0；
素数=（双）数/除；
如果（dbg>0）{
System.out.println（“调试编号”+number+“|除法”+divide+”|素数：“+prime+”| Math.abs（素数）+Math.abs（素数））；
}
if（prime==（（long）prime））//最好的方法是什么？
{
//平分
收益分配；
}
否则{
返回testPrime（数字，除以-2）；
}
}
}

对于我来说，递归函数的作用是：如果我错了，就纠正我。谢谢。调用语句>布尔b=isPrime（number，number-1）；
递归函数-

好吧，我直接给你们所有的代码，而不是编写代码片段。希望你们都喜欢这一个，因为我已经尽了最大努力使它尽可能简单。
代码是：>

import java.util.*;
class Prime_Number
{
    static int c=0;
    public static void main(String args[])
    {
        int n,i,sq=0;
        Scanner in=new Scanner(System.in);
        Prime_Number ob=new Prime_Number();
        System.out.print("Enter a no.:>");
        n=in.nextInt();
        i=n;
        sq=(int)(Math.sqrt(n));//square root is been taken since a no. cannot have factors greater than its square root
        int k=ob.prime_Chk(n,i,sq);
           if(k==1)
              {
                 System.out.println("Prime");
              }
                 else
                     {
                       System.out.println("Non-Prime");
                      }
      }
public int prime_Chk(int g,int i,int sq)
    {
        if(i==sq)
        {
            return c;
        }
        else
        {
            if(g%i==0)
            {
                c++;
            }
            i--;
            return(prime_Chk(g,i,sq));
        }
    }
}

在黄金时期我把int I、int sq和int g作为参数。如果你愿意，你也可以用其他变量来代替它们。
为什么要递归？没有理由使用递归。你应该使用整数/长。没有浮点素数，而且速度更快。这是一种计算素数的蛮力方法。你应该看看Fermat的小定理以及其他一些算法，如果你想做大素数。我应该使用它，这不是我的问题，这是为什么我不能显示素数。你应该使用什么？你没有得到if divide==number，那么我引用的if块将失败，它将始终返回“not prime”。我想答案很清楚。我应该使用递归方法。那么应该是什么呢？实际上，它们将小于SQRT（n），而不是n/2。谢谢，对了，在java中如何找到n^（1/2），我将更新答案
java.lang.Math.pow（n，0.5）
或
java.lang.Math.SQRT（）
btw，最简单的方法是使用条件
i*i这可以通过首先检查整除性2，然后在奇数（素数必须是奇数）上的for循环中增加i 2来优化：
for（int i=3；我只在下面发布了答案后才通知你。+1用于第一次正确回答问题：）*不确定为什么第二个fn中有3个参数。只需2@tgkprog啊，是的，那是因为我计算了。倒计时删除了“直到”参数，因为我不再需要边界检查（只要它保持>1）。虽然有人可能会说，在较小的值下，素因子的密度要高得多，所以从3开始应该会更快地命中素因子。好吧，尽管有些人在这里做了功课，但我认为也给了他们一些背景知识。如果他们是真正的开发人员，他们会发现新的问题需要实际解决：-）请解释你发布的所有答案。这只是一个代码转储！
import java.util.Scanner;

public class HW8R_T03 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner sc = new Scanner(System.in);
        System.out.print("Enter number: ");
        int n = sc.nextInt();
        int simple = prime(n,n-1);
        System.out.println(simple==1 ? "prime" : "not prime");

    }

    static int prime(int x, int y){
        int div = 1;
        if (y==0 || y==1){
             return div;
        }
        if (x%y==0){
            div = y;
        } else {
            div = prime (x, --y);
        }
        return div;
    }


}

void isPrime(int p,int d);
{
int prime=p%d;
if((p==0&&d>1)||p%2==0)
return true;//that the number is not prime
if(d==1)
return false;
else
return isPrime(p,d-2);//calls the function again
}

import java.util.*;
class Prime_Number
{
    static int c=0;
    public static void main(String args[])
    {
        int n,i,sq=0;
        Scanner in=new Scanner(System.in);
        Prime_Number ob=new Prime_Number();
        System.out.print("Enter a no.:>");
        n=in.nextInt();
        i=n;
        sq=(int)(Math.sqrt(n));//square root is been taken since a no. cannot have factors greater than its square root
        int k=ob.prime_Chk(n,i,sq);
           if(k==1)
              {
                 System.out.println("Prime");
              }
                 else
                     {
                       System.out.println("Non-Prime");
                      }
      }
public int prime_Chk(int g,int i,int sq)
    {
        if(i==sq)
        {
            return c;
        }
        else
        {
            if(g%i==0)
            {
                c++;
            }
            i--;
            return(prime_Chk(g,i,sq));
        }
    }
}

import java.util.Scanner;

public class HW8R_T03 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner sc = new Scanner(System.in);
        System.out.print("Enter number: ");
        int n = sc.nextInt();
        int simple = prime(n,n-1);
        System.out.println(simple==1 ? "prime" : "not prime");

    }

    static int prime(int x, int y){
        int div = 1;
        if (y==0 || y==1){
             return div;
        }
        if (x%y==0){
            div = y;
        } else {
            div = prime (x, --y);
        }
        return div;
    }


}