Nombres premiers en language c

Remarques :

Tu peux commencer ta boucle for à 2, et l'arrêter à sqrt(nbre), en effet au delà de la racine carré, il n'existe aucun nombre qui divise nbre (à part nbre lui même), ce qui diminue le nombre de calcul à faire (exemple pour 1000000, tu ne fera "que" 9999 calculs)
Dans ce cas, tu auras test+2 diviseurs et donc tu feras if (test+2==2) ou if (test==0) ou if (!test)

Le nom des variables est mal choisi, surtout test, il aurait mieux fallu la nommer nbreDiv par exemple pour nombre de diviseurs...

Tu n'as pas besoin de la variable Quest, tu peux directement faire, if (nbre%i ==0)

test++; est bien plus joli que test+=1; ... oui, je chipote ;-)

Le \n sert à passer à la ligne, il est plus judicieux de le mettre à la fin d'une ligne, et non pas au début, d'autant que parfois la ligne ne s'affiche pas s'il n'y a pas eu de \n après.

Mes remarques ne sont pas exhaustives, mais elles t'aideront à améliorer ton code et à prendre de bonnes habitudes... Bon courage pour la suite !

slt ,
merci pour les commentaires,
pourrais tu m'envoyer un programme plus net ?
aussi peux tu m'aider à demander si l'utilisateur veut calculer un autre nombre

et celui-ci (après correction)

#include <stdio.h>

main ()
{
int nbre, nbreDiv, i;
printf("Entrer un nombre: ");
scanf("%d", &nbre);
nbreDiv = 0;

for(i = 2; i <= sqrt(nbre); i++)
{

if(nbre%i == 0)
{
nbreDiv++;
}
}

if(!nbreDiv)
{
printf("Ce nombre est donc premier");
}
else
{
printf("Le nombre '%d' saisi n'est pas premier", nbre);
}

getch();
}

Je n'ai pas modifié l'algorithme que tu as proposé (avec correction), parce que c'est le meilleur pour ce que tu veux faire.

Par contre je l'ai découpé en plusieurs fonctions ce qui gagne en netteté.
Et bien sûr, j'ai fais en sorte qu'il marche, avec un affichage simple et clair, en gérant les cas particuliers les plus fréquents.

Remarque : pour insérer du code, utilise les balise < code> et < /code>, soit manuellement, soit en utilisant le bouton fait exprès (à droite du bouton souligné)

#include <stdio.h> // printf, scanf
#include <math.h>  // sqrt
    
    
short demanderContinuer(void)
{
    printf("Voulez vous continuer ? (y/n) ");
    char s[10];
    scanf("%s",s);
    
    switch (s[0]) // on regarde le premier caractère
    {
        case 'n' : return 0; // on s'arrête
        case 'y' : return 1; // on continue
        default  : return demanderContinuer(); // on redemande
    }
}


long demanderNombre(void)
{
    long nbre;
    printf("Entrez un nombre >1 : "); 
    scanf("%ld", &nbre); 
    
    if (nbre>1)
    {
        return nbre;
    }
    else
    {
        return demanderNombre(); // on redemande
    }
}


long nombreDiviseur(long nbre)
{
    printf("\n1\n");
    
    if (nbre==2) // cas particulier à cause de la racine carrée
    {            // sinon, on compterait deux fois le 2 !!!
        printf("2\n");
        return 2;
    }
    
    long i, nbreDiv=2; // deux diviseurs : 1 et nbre
    
    for (i=2; i<=sqrt(nbre); i++) 
    { 
        if(nbre%i == 0)
        {
            nbreDiv++; // un diviseur de plus : i
            printf("%ld\n",i); // on l'affiche
        }
    } 
    printf("%ld\n",nbre);
    return nbreDiv;
}


void uneRecherche(void)
{        
    long nbre=demanderNombre();
    long nbreDiv=nombreDiviseur(nbre);
    
    printf("\n%d a %d diviseurs ",nbre,nbreDiv);    
    if (nbreDiv>2)
    {
        printf("il n'est donc pas premier\n\n");
    }
    else
    {
        printf("il est donc premier\n\n");
    }          
}


int main(void) 
{ 
    do
    {
         printf("\n");
         uneRecherche();
    }
    while(demanderContinuer());
    
    return 0;
}

Je tiens à rectifier une grosse erreur de maths !
Un nombre donné, peut avoir des diviseurs supérieurs à sa racine carré.
Exemple : sqrt(8)=2,8 mais 4 qui est plus grand est bien un diviseur de 8

Toutefois on peux trouver ces diviseurs sans itérer au delà de la racine carrée.
Cela modifie donc un peu le code...

long nombreDiviseur(long nbre)
{
    long i, nbreDiv=0;
    float racine=sqrt(nbre);

    for (i=1; i<=racine; i++)
    {
        if(nbre%i == 0)
        {
            if (i==racine)
	    {
	 	nbreDiv++; // un diviseur de plus : racine
		printf("%ld\n",i); // on l'affiche
	    }
	    else
	    {
		nbreDiv+=2; // deux diviseurs de plus : i et nbre/i
		printf("%ld\n%ld\n",i,nbre/i); // on les affiche
	    }
        }
    }

    return nbreDiv;
}

let EstPremier n =
    let b=ref true in
    for i=2 to n-1 do
        b := !b && (n mod i>0)
    done;
    n>1 && !b;;

et alors, c'est une raison pour être aussi agressif ?

c'est assez stupide tu mets le point d'arret de la seconde boucle
à la valeur de la première
or aucun nombre ne peut avoir un diviseur supérieur à sa racine
sans avoir un diviseur inférieur à sa racine
donc tu aurais du écrire
for j:=1 to entiere(racine(j))

Salut ,

"un nombre premier accepte la division par 1 et pa lui même "

et le cas du 1 ?

12 modulo 4 = 0, le reste est nul, 12 est donc divisible par 3.

Divisible par 4, bien sûr et non par 3... ;-)
Enfin, il est divisible par 3, mais c'est pas avec 'modulo' qu'on le sait...

A+ Blux

 "Les cons, ça ose tout.
C'est même à ça qu'on les reconnait"

Désolé d'avoir à te le dire Amine, mais ton programme est pas terrible !
En effet le résultat que tu obtiens n'est pas correct (il manque le 3, le 5 et le 7)
De plus un bon algorithme doit pouvoir être utilisé aussi largement que possible (c'est à dire qu'il doit resté vrai si on considère un intervalle plus grand) or ici à peine arrivé à 121 (multiple de 11) on se retrouve avec des nombres premiers qui n'en sont en fait pas !

Avec une identité remarquable tout simplement...