[fini...]algorthme de calcul

[theocrite]

au fait, le but du prog, c'est quoi, pour de vrai???

+1

Je l'ai déjà demandé.

C'est sûr que ça aiderait à se faire une petite idée du but à atteindre.

[ramy]

(n-1)!/n = (1*2*3*4*5*...*(n-1))/n = p

si p-E[p]=0 alors p = E[p]

par definition, un nombre dont la partie entiere est lui meme est un entier naturel

donc si p est un entier

alors il existe un i dans l'intervalle [1,n-1] qui divise n et n n'est pas premier

sinon il n'existe pas de diviseur dans l'ensemble des entiers naturel qui lui sont inferieur et par consequence n est premier puisque tous nombre se decompose en facteur ; le nombre est un cas particulier divise que par 1 et lui meme...

edit : le but du prog est donc de couvrir un ensemble donnée de valeur de n entre le rang de depart N et d'arrivée M et d'afficher les n qui ne reponde pas a la condition (n-1)!/n est un entier soit les nombres premier de cette intervalle...

[theocrite]

Dans ce cas là ok, mais avec (n-1) et pas (n+1)

[ramy]

Dans ce cas là ok, mais avec (n-1) et pas (n+1)

exact

j'ai d'ailleurs fait la modif...

j'avais belement recopier le code de theocrite

[theocrite]

Mon code est là pour calculer les factorielles, pas pour chercher les nombres premiers.

Cette partie est correcte.

[ramy]

revoila l'etat actuel du code...

#include <iostream>
#include <stdlib.h>

using namespace std;

int factoriel (int N)
{
if (N<1)
  return 1;
else
  return (factoriel (N-1))*N;
}

int main(int argc, char *argv[])
{
int n,m;
float p;

printf("rang de depart?");
scanf("%d", &n);
printf("rang de fin?");
scanf("%d", &m);

do
{
n++;
p = (factoriel (n-1)) /n;
if (p-floor(p) == 0)
   // "fais rien !!!"
else
   printf("%f\n", p); <= cette ligne la demande bien d'afficher n et non pas p  :zarb: 
}
while(n<m);

system("PAUSE"); 
return 0;
}

[lorinc]

tu peux nous remettre un copie-coller du code integral, maintenant

EDIt : tiens, j'ai l'air d'un con là

[ramy]

tu peux nous remettre un copie-coller du code integral, maintenant

EDIt : tiens, j'ai l'air d'un con là

ça va pour cette fois

[lorinc]

je serais d'avis de faire des transtypage pour la division (comme ça a déjà été dit) on en spur de rien :

p = ( (float) factoriel (n-1)) / ( (float) n);

puis un

 
if(p == floor(p) )
    printf("%d\n", n);

pour n'afficher n que s'il est entier

[theocrite]

EDIt : tiens, j'ai l'air d'un con là

Du coup, tu peux remettre les cast (int) et (float).

Pour l'arrondi, je préfère ceil.

et plutôt que do{}while, tu devrais faire while(n<m)

[ramy]

je serais d'avis de faire des transtypage pour la division (comme ça a déjà été dit) on en spur de rien :

p = ( (float) factoriel (n-1)) / ( (float) n);

puis un

 
if(p = floor(p) )
    printf("%d\n", n);

pour n'afficher n que s'il est entier

non justement il faut afficher les nombres premier ; pas les autres

donc ceux ou p n'est pas premier -> je connais pas le signe different... c'est pour ça que j'ai utiliser else

[ramy]

et comment lui dire de ne rien faire et de poursuivre a le place du commentaire???

[theocrite]

 p!=ceil(p)

sinon continue pour continuer et break pour arrêter

[ramy]

Du coup, tu peux remettre les cast (int) et (float).

Pour l'arrondi, je préfère ceil.

et plutôt que do{}while, tu devrais faire while(n<m)

dans ce genre ???

while(n<m)

{

...

}

[theocrite]

[ramy]

 p!=ceil(p)

sinon continue pour continuer et break pour arrêter

continue tout seul il apprecie pas ; y'a quelque chose a preciser?

[theocrite]

 if( prout == true )
   continue;
else
   break;

[lorinc]

#include <stdio.h>
#include <stdlib.h>
#include <math.h>


int factoriel (int N)
{
if (N<1)
 return 1;
return (factoriel (N-1))*N;
}

int main(int argc, char *argv[])
{
   int n,m;
   float p;

   printf("rang de depart?");
   scanf("%d", &n);
   printf("rang de fin?");
   scanf("%d", &m);

   while(n < m)
   {
   p = ( (float) factoriel (n-1)) / ( (float) n);

   if((float)p != (float)  ceil(p))
       printf("%d - premier\n", n);
   else
       printf("%d - non premier\n", n);

   n++;
   }

   return 0;
}

bash-2.05b$ ./premier

rang de depart?10

rang de fin?20

10 - non premier

11 - premier

12 - non premier

13 - non premier

14 - non premier

15 - non premier

16 - non premier

17 - non premier

18 - non premier

19 - non premier

bof-bof

[theocrite]

#include<stdio.h>
#include<math.h>

unsigned long long factoriel (unsigned long long N)
{
       if (N<1)
                return 1;
       return (factoriel (N-1))*N;
}

int main(void)
{
       unsigned long long n,m;
       double p;

       printf("rang de depart?");
       scanf("%llu", &n);
       printf("rang de fin?");
       scanf("%llu", &m);

       while((n++) < m)
       {
               p = ( ((double)factoriel(n-1))/((double)n)) ;

               if( p != ceil(p))
                       printf("%llu - premier\n", n);
               else
                       printf("%llu - non premier\n", n);
       }

       return 0;
}

]theo@fermat:/tmp$ ./a.out
rang de depart?10
rang de fin?20
11 - premier
12 - non premier
13 - premier
14 - non premier
15 - non premier
16 - non premier
17 - premier
18 - non premier
19 - premier
20 - non premier

Attention ! Il s'agit de factorielles, on arrive très rapidement à maxint...

[lorinc]

#include <stdio.h>
#include <stdlib.h>
#include <math.h>


long double factoriel (int N)
{
if (N<1)
 return 1;
return (factoriel (N-1))*N;
}

int main(int argc, char *argv[])
{
   int n,m;
   long double p;

   if(argc != 3)
   {
      printf("usage : premier <depart> <fin>\n");
      exit(-1);
   }

   n = atoi(argv[1]);
   m = atoi(argv[2]);

   while(n < m)
   {
   p = ( (long double) factoriel (n-1)) / ( (long double) n);

   if( p !=  ceil(p))
       printf("%d - premier\n", n);
   else
       printf("%d - non premier\n", n);

   n++;
   }

   return 0;
}

bash-2.05b$ gcc -o premier ./premier.c  -lm

bash-2.05b$ ./premier 10 20

10 - non premier

11 - premier

12 - non premier

13 - premier

14 - non premier

15 - non premier

16 - non premier

17 - premier

18 - non premier

19 - premier

pas faux sur le maxint

voiulou, c'est plus propre comme ça, non?

[ramy]

bah meme si tu viens de faire un truc tres mechant...frustrant plutot

c'est ça que je veux reussir a faire plus tard si la force est avec moi

merci tout le monde et ++

[lorinc]

bah meme si tu viens de faire un truc tres mechant...frustrant plutot

j'ai pas tout compris, là ?

[ramy]

j'ai pas tout compris, là ?

bah j'aurais aimer reussir ça moi meme ; mais bon j'ai pas le niveau encore...

[lorinc]

bah, tu as largement le niveau en algo pour le faire, c'est juste qu'il faut apprendre la syntaxe du C, et si un petit exemple peut t'aider...

[mogwai93]

Je rajoute deux points :

le premier point :

le programme affiche donc les nombres premiers se trouvant entre N et M

au niveau performance, passer de N à M par pas de 1 est un peu gourmand au niveau du temps.

un nombre premier est premier si et seulement si, il n'est pas divisible par un des nombres premiers le précédent.

il suffit donc de créer un tableau ou une liste dynamique qui stocke ces nombres premiers.

Pour l'algo :

1) stocker les nombres premiers de 1 à N-1

2) "regarder" entre N et M, la présence de nombre premiers

grace à la liste créée en 1)

le deuxième point :

sur la méthode factoriel

déjà pour factoriel (1)

il va calculer 1 x factoriel (0) = 1 x 1 = 1

dans ce cas, plutot mettre

if (N <= 1) return 1;

ca évite un tour pour rien

à voir , si c'est intéressant de rajouter un test si N=2

pour les memes raisons : éviter de calculer 2 x 1 ......

donc

long double factoriel (int N)
{
if (N<=1) return 1;
if (N ==2) return 2;
return (factoriel (N-1))*N;
}

ou

long double factoriel (int N)
{
if (N > 2) return (factoriel (N-1))*N;
if (N > 0) return N;
return 1;
}