Déterminer le nombre premier par la saisie de l'utilisateur à l'aide de méthode récursive

J'ai besoin de créer un programme en Java qui détermine si un nombre est premier.

L'utilisateur doit entrer un nombre, et le programme permettra de déterminer s'il est premier ou non, et l'affichage "non prime" ou "le premier." Mon code compile et s'exécute, mais il dit toujours un nombre n'est pas premier, même si il est.

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;
   }
 }
}

Pourquoi la récursivité? Il n'y a pas de raison d'utiliser la récursivité pour ce.
Vous devez utiliser integer/ce. Il n'y a pas de point flottant sur les nombres premiers et c'est beaucoup plus rapide.
C'est une force brute façon de calculer un nombre premier. Vous devriez regarder le Petit Théorème de Fermat ici ainsi que quelques autres algorithmes, si vous voulez faire de grands nombres premiers.

InformationsquelleAutor Erica LeHuray | 2013-04-26

2
```
if (prime > 0 && divide != number)
```
Ce ne sera jamais vrai. Parce que votre fracture et le numéro sont toujours égales.

Voir que vous avez attribué variable=constant et c'est ce que vous passez à la méthode
```
constant = input.nextInt();
variable = constant;
answer = testPrime(constant, variable);
```
Cela dit, vous avez besoin d'aller si complexe pour savoir si un nombre est premier ou pas. Consulter le web pour des algorithmes simples. Voir http://www.mkyong.com/java/how-to-determine-a-prime-number-in-java/ par exemple.
- Je suis censé l'utiliser, ce n'est pas ce que je vais avoir un problème avec, c'est pourquoi je ne peux pas afficher un nombre premier.
- Vous êtes supposé utiliser quoi? N'avez-vous pas obtenir si diviser == numéro, puis le bloc si j'ai cité échouera et retournera toujours "NON PRIME". Je pense que la réponse est assez claire
- Je suis censé utiliser la méthode récursive. alors, que devez - = = - être alors?
InformationsquelleAutor hop
1

Pas la réponse que l'OP veut la récursivité (devoirs, je suppose).

Il vous suffit d'aller jusqu'à la racine carrée de n, pour voir si il a un diviseur (diviseur en plus de l'auto sera < sqrt(n))
```
    boolean isPrime(int n) {
            if(n % 2 == 0)return false;
            int till  = (int)java.lang.Math.pow(n, 0.5); //(int)n /2;
            for(int i= 3;i<till;i+=2) {
                if(n % i == 0) 
                    return false;
            }
            return true;
        }
```
- En fait, ils vont être moins que SQRT(n), pas n/2.
- merci, comment trouvez-vous n ^(1/2) en java, je vais mettre à jour la réponse
- java.lang.Math.pow(n, 0.5) ou java.lang.Math.sqrt()
- btw, le plus simple est d'utiliser la condition i * i <= n
- et je ne suis pas à l'aide d'un booléen
- eh bien, vous devriez.
- Cela peut être optimisée par une première vérification de la divisibilité par 2, puis incrémentation de i par 2 dans la boucle for sur les nombres impairs (primes doit être impair): for(int i=3; i<till; i+=2;). RiaD, cette solution nécessite une multiplication chaque itération, alors que le calcul de la racine carrée est fait avant la boucle.
- comment est-il
InformationsquelleAutor tgkprog
1

Je vois que vous voulez de récursivité pour cela, j'ai donc converti tgkprog réponse à une méthode récursive (bien que le son est nettement plus efficace). En outre, je pense que vous pouvez revenir un facteur primordial si l'entrée n'est pas premier? Je suis juste spéculer cela à en juger par les OP de la valeur de retour d'une double au lieu d'un booléen. La mienne va retourner un int, parce que le retour d'un double est stupide.
```
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);
}
```
- remarqué votre réponse seulement après que j'ai posté ci-dessous. +1 pour obtenir le droit de la question première fois 🙂 * je ne sais pas pourquoi vous avez 3 params dans le 2ème fn. besoin seulement de 2
- ahh oui c'est parce que j'ai compté. Le compte à rebours supprime le "jusqu'à" paramètre car je n'ai pas besoin de vérification de limites plus (tant qu'il reste >1). Bien que l'on pourrait faire valoir que les facteurs premiers sont beaucoup plus dense à la plus petite des valeurs, donc à partir de 3 devrait aboutir à frapper le premier des facteurs plus rapide.
- bon même si le fait de certaines personnes à faire leurs devoirs ici, je pense qu'ils ont leur a donné un peu de fond aussi. s'ils sont réels, les développeurs, ils pourront trouver de nouveaux problèmes à résoudre effectivement 🙂
InformationsquelleAutor Suedocode

avec la récursivité

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);
}
}
}

InformationsquelleAutor tgkprog

-1

la fonction récursive pour moi va comme-Corrigez-moi si je me trompe.Je vous remercie.instruction d'appel >Boolean b=isPrime(nombre,nombre-1);
fonction récursive-

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
}

InformationsquelleAutor itrat jameel

-1

Eh bien, je suis directement de vous donner tout le code au lieu de l'écriture de code. Espère que vous avez tous peut que ce que j'ai essayé de mon mieux pour le rendre aussi simple que possible.
Le code est :>

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));
}
}
}

Bien dans le premier() j'ai pris int i , int sq et int g comme arguments.Au lieu de ces si vous le souhaitez, alors vous pouvez prendre d'autres variables.

InformationsquelleAutor adityam1305

-1

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;
}
}

Veuillez expliquer toutes les réponses que vous publiez. C'est juste un code dump!

InformationsquelleAutor ivelina

Vous devez vous connecter pour publier un commentaire.