Partage
  • Partager sur Facebook
  • Partager sur Twitter

fonction récursive nombres premiers inferieurs à n

Allouer dynamiquement la mémoire pour le tableau renvoyant le résulta

    19 avril 2022 à 20:42:12

    j'ai essayé d'améliorer mon programme mais ça ne fonctionne toujours pas 

    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    
    int premier (int n, int i)
    {
        i=2;
     if(n==i){
        return 1;
     }if(n==1 || (n%i )==0){
        return 0;
     }
    else
     return premier(n,i+1);
    }
    int* remplir(int n){
        int *T;
        int i,j=0;
         T=(int*)malloc(j*sizeof(int));
            for(i=0; i<n;i++){
                if(premier(n,i)==1){
                    *(T+j)=i;
                    j++;
                    T=(int*)realloc(T,j*sizeof(int));
                }
            }
                return T;
        }
    void afficher(int* T, int n){
    int *p=0;
    for(p=T; p<T+n;p++){
        printf("%d\t",*p);
       }
    }
    int main(){
     int n,i=2;
     int p,r;
    int T=malloc(sizeof(int));
     printf("Entrer le nombre n: \n");
     scanf("%d",&n);
     p=premier(n,i);
     r=remplir(n,i+1);
    T=realloc(T,(n-1)*sizeof(int));
    n--;
    afficher(T,n);
    }
    


    -
    Edité par OusseiniHimaAbdoulRachid 20 avril 2022 à 3:39:41

    • Partager sur Facebook
    • Partager sur Twitter
      19 avril 2022 à 21:02:56

      Utilises le bouton code </> du forum pour poster ton code ! (tu peux modifier ton post, lien modifier en haut à droite du post).
      • Partager sur Facebook
      • Partager sur Twitter
        19 avril 2022 à 22:24:53

        Bonjour,

        Quand tu écris :

         if((n%n)==0 && (n%1)==0){

        Tu vérifies si le nombre est divisible par lui même. Tous les nombres sont divisibles par eux-mêmes.
        et tu vérifies si le nombre est divisible par 1. Tous les nombres sont divisibles par 1. Donc ton test revient à faire:

          if ( true )

        Un nombre premier est divisible par lui-même, par 1 et par aucun autre diviseur. C'est ça qu'il faut vérifier!
         

        • Partager sur Facebook
        • Partager sur Twitter

        En recherche d'emploi.

          20 avril 2022 à 2:57:33

          Ce n'est pas comme ça que j'ai appris à vérifier si un nombre est premier.
          Une chance que je ne te demande pas pour n = un milliard ...
          Le realloc va te coûter très cher. Et tu déborderais la pile.
          À la rigueur, je ferais un malloc de n nombre et je ferais un realloc à la fin pour réduire.
          Faire un malloc de int(1.2 * n / log(n)) n'est pas mal (ça donne un bon résultat jusquà 10^9).
          • Partager sur Facebook
          • Partager sur Twitter

          Le Tout est souvent plus grand que la somme de ses parties.

            20 avril 2022 à 3:18:53

            f

            -
            Edité par OusseiniHimaAbdoulRachid 20 avril 2022 à 3:43:30

            • Partager sur Facebook
            • Partager sur Twitter
              20 avril 2022 à 4:00:04

              Tu as flushéton code pendant que j'éditais ...

              Es-tu bien certain de maîtriser les pointeurs?

              D'abord dans la fonction premier, tu remets i=2. Ça risque de boucler indéfiniment?

              Tu ne laisse aucune place pour l'optimisation dans la fonction premier. Tu pourrais au moins tester que i*i <= n. Si c'est plus grand, le nombre est premier.
              Ta fonction remplir semble fonctionner mais, comme je l'ai dit, ça va te couter cher de realloc.
              Tu retournes un pointeur au main mais r n'est pas défini comme tel.
              afficher prend T comme paramètre, où a-t-il été défini?
              La fonction afficher n'a pas de } juste avant le main. Ton copier-collé est correct?

              Voici ma version de la fonction premier:

              -

              int premier(int n, int i) {
                  if(i*i > n) return 1;
                  if(n%i == 0) return 0;
                  // si c'est 2, je passe à 3, sinon je passe à i+2
                  return premier(n, i + (i&1) + 1);
              }

              -
              Edité par PierrotLeFou 20 avril 2022 à 5:04:04

              • Partager sur Facebook
              • Partager sur Twitter

              Le Tout est souvent plus grand que la somme de ses parties.

              fonction récursive nombres premiers inferieurs à n

              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
              • Editeur
              • Markdown