Partage
  • Partager sur Facebook
  • Partager sur Twitter

recherche recursive dans un tableau de caractére

    24 octobre 2015 à 16:52:47

    bonsoir 

    je passe le salut a tous les membres de openclassroom :)

    je suis un debutant a programmer en c et je veux savoir quel est la faute dans ce petit code

    qui permet de chercher si un caractere saisit au clavier existe ou nn dans tableau T en utilisant une procedure chercher recursive

    et merci d'avance
     #include<stdio.h>
    
     
    
     
    
    typedef char tab[12];
    
     
    
    void recherche(int i)  /*  la procédure et ses paramètres formels   */
    
    { int n;
    
    char x;
    
    tab t;
    
    if(i<n+1)
    
    {
    
    if(t[i]=x)
    
    {
    
     
    
    printf("vrai\n");
    
     
    
     
    
    }
    
     
    
     
    
    };
    
     
    
     
    
    recherche(i+1);
    
    }
    
     
    
     
    
     
    
     
    
    int main()
    
    {
    
    int i=1,n;
    
    char x;
    
    tab t;
    
    printf("donner n ");
    
    scanf("%d",&n);
    
    for(i=0;i<n;i++)
    
    {
    
    scanf(" %c",&t[i]);
    
    }
    
    printf("donner caractere a chercher\n");
    
    scanf(" %c",&x);
    
     
    
    recherche(i);
    
     
    
    return 0;
    
    }
    
     
    
     

    -
    Edité par PSYCO-R 24 octobre 2015 à 18:02:10

    • Partager sur Facebook
    • Partager sur Twitter
      24 octobre 2015 à 17:42:18

      Lu'!

      Va lire les règles du forum et présentes ton code de façon ce qu'il soit lisible avec le bouton prévu à cet effet.

      • Partager sur Facebook
      • Partager sur Twitter

      Posez vos questions ou discutez informatique, sur le Discord NaN | Tuto : Preuve de programmes C

        24 octobre 2015 à 18:02:44

        Ksass`Peuk a écrit:

        Lu'!

        Va lire les règles du forum et présentes ton code de façon ce qu'il soit lisible avec le bouton prévu à cet effet.


        c'est fait et désolé
        • Partager sur Facebook
        • Partager sur Twitter
          Staff 24 octobre 2015 à 19:17:58

          RayenMessaoudi a écrit:

          je suis un debutant a programmer en c et je veux savoir quel est la faute dans ce petit code

          qui permet de chercher si un caractere saisit au clavier existe ou nn dans tableau T en utilisant une procedure chercher recursive


          Bonjour,

          C'est un peu débile de pousser les gens à coder de telles fonctions. Mais, à première vue, une fonction void récursive, ça sent mauvais.

          J'aurais plutôt pensé à quelque chose dans ce genre :

          #icnlude <stdio.h>
          
          int rechercherCar( char * str , int car , int pos )
          {
              if( !*str ) return -1;
              
              return (*str==car ? pos : rechercherCar( str+1,car,pos+1) );
          }
          
          int main( void )
          {
              char str[] = "Hello world";
              int car = 'l' ;
              int pos = rechercherCar( str , car , 0 );
          
              if( pos != -1 )
                  printf("Le car %c se trouve à la position %d\n",car,pos);
              else
                  printf("Le car %c n\'a pas ete trouve\n",car);
          
              return 0;
          }



          -
          Edité par uknow 25 octobre 2015 à 5:52:19

          • Partager sur Facebook
          • Partager sur Twitter
            25 octobre 2015 à 12:38:05

            uknow a écrit:

            RayenMessaoudi a écrit:

            je suis un debutant a programmer en c et je veux savoir quel est la faute dans ce petit code

            qui permet de chercher si un caractere saisit au clavier existe ou nn dans tableau T en utilisant une procedure chercher recursive


            Bonjour,

            C'est un peu débile de pousser les gens à coder de telles fonctions. Mais, à première vue, une fonction void récursive, ça sent mauvais.

            J'aurais plutôt pensé à quelque chose dans ce genre :

            #icnlude <stdio.h>
            
            int rechercherCar( char * str , int car , int pos )
            {
                if( !*str ) return -1;
                
                return (*str==car ? pos : rechercherCar( str+1,car,pos+1) );
            }
            
            int main( void )
            {
                char str[] = "Hello world";
                int car = 'l' ;
                int pos = rechercherCar( str , car , 0 );
            
                if( pos != -1 )
                    printf("Le car %c se trouve à la position %d\n",car,pos);
                else
                    printf("Le car %c n\'a pas ete trouve\n",car);
            
                return 0;
            }



            Merci bien uknow :) j'ai pas compris ces deux lignes 

                    if( !*str ) return -1;

                return (*str==car ? pos : rechercherCar( str+1,car,pos+1) );

            rq: pourquoi tu déclare le caractere '1' comme un int normallement c'est char ?



            • Partager sur Facebook
            • Partager sur Twitter
              Staff 27 octobre 2015 à 10:17:12

              RayenMessaoudi a écrit:

              uknow a écrit:

              Merci bien uknow :)j'ai pas compris ces deux lignes 

                      if( !*str ) return -1;

                  return (*str==car ? pos : rechercherCar( str+1,car,pos+1) );

              rq: pourquoi tu déclare le caractere '1' comme un int normallement c'est char ?


              le premier if, permet d'arrêter la récursion si tu atteints le \0. if( !x ) est vraie lorsque x vaut 0.

              As-tu connaissance de l'expression ternaire ?

              <clause> ? <expression1> : <expression2>;

              Lorsque la clause est vraie, la valeur de toute l'expression est celle de <expression1>, sinon c'est la valeur de <d'expression2>.

              • Partager sur Facebook
              • Partager sur Twitter
                27 octobre 2015 à 10:22:31

                uknow a écrit:

                C'est un peu débile de pousser les gens à coder de telles fonctions.

                Pourquoi ? C'est relativement simple et ça permet de comprendre basiquement ce qu'est la récursion. (Et non, ça fera pas péter le stack).

                • Partager sur Facebook
                • Partager sur Twitter

                Posez vos questions ou discutez informatique, sur le Discord NaN | Tuto : Preuve de programmes C

                  27 octobre 2015 à 10:31:32

                  Yop,

                  Je suis d'accord avec @Ksass`Peuk, c'est pas ce genre d'algo qui va faire quoi que ce soit à la stack ^^ sauf si tu ne fixe pas de condition d'arrêt, auquel cas ton algo est faux.

                  Par contre, je suis le seul à trouver son indentation immonde ?

                  Cordialement,

                  • Partager sur Facebook
                  • Partager sur Twitter
                    27 octobre 2015 à 10:49:18

                    Ksass`Peuk a écrit:

                    uknow a écrit:

                    C'est un peu débile de pousser les gens à coder de telles fonctions.

                    Pourquoi ? C'est relativement simple et ça permet de comprendre basiquement ce qu'est la récursion. (Et non, ça fera pas péter le stack).


                    Peut être parce qu'ici l'usage de la récursion est complètement inutile ? Je ne pense pas qu'un tel exo aide à comprendre la récursion, bien au contraire, puisque du coup on se dit qu'on fait la même chose simplement avec une boucle.




                    • Partager sur Facebook
                    • Partager sur Twitter
                    Zeste de Savoir, le site qui en a dans le citron !
                      27 octobre 2015 à 10:52:08

                      GurneyH a écrit:

                      Peut être parce qu'ici l'usage de la récursion est complètement inutile ?

                      Si on suit le même raisonnement, la boucle est inutile puisque la récursion fait la même chose.

                      • Partager sur Facebook
                      • Partager sur Twitter

                      Posez vos questions ou discutez informatique, sur le Discord NaN | Tuto : Preuve de programmes C

                        27 octobre 2015 à 11:00:19

                        Ksass`Peuk a écrit:

                        GurneyH a écrit:

                        Peut être parce qu'ici l'usage de la récursion est complètement inutile ?

                        Si on suit le même raisonnement, la boucle est inutile puisque la récursion fait la même chose.

                        :D Bah justement il y a des exemples d'algo récursifs, qui sont bien moins naturels implémentés de manière itérative. Tout les exercices de factorielles, etc qui servent souvent d'exemple pour présenter la récursivité ne sont pas bons à mon sens.

                        A la limite une recherche dichotomique, serait peut être(je ne suis pas certain^^) un candidat plus crédible comme première illustration de la récursivité ?

                        edit: un parcours de répertoire, peut être ?

                        -
                        Edité par GurneyH 27 octobre 2015 à 13:32:44

                        • Partager sur Facebook
                        • Partager sur Twitter
                        Zeste de Savoir, le site qui en a dans le citron !
                          27 octobre 2015 à 11:17:17

                          Pour ma part, n'importe quel algorithme récursif peut se faire en itératif sans problème (il suffit de "simuler" le principe via une boucle). Donc si on suit ta logique @GurneyH et que l'on se pose "si on peut le faire avec une boucle, alors on fait pas de récursif" dans ce cas le principe même de la récursivité est totalement oublié.

                          La récursivité est à mon sens utile quand ça réduit considérablement le nombre de ligne et te fait gagner du temps, sans pour autant être trop lourd pour la stack, bien évidement les algorithmes récursif doivent être contrôlés de manière à ne pas faire un overflow, et donc de créer un comportement indéfinie.

                          Néanmoins, on peut pas dire que partir sur des gros algorithmes est une bonne idée pour commencer la récursion, il faut commencer tout doucement avec seulement un petit algorithme où il est assez simple de contrôler la récursion. Et c'est là que ce genre d'exercice (comprends : la recherche de caractère) entre en jeux.

                          On va pas se le cacher, personne n'aura pour idée de faire ce genre d'exercice en récursif, car la solution itérative viendra naïvement à toi et de façon systématique. Cependant il est assez intéressant de constater les changements dans la logique que va apporter la récursion dans ce genre d'algorithme et donc dans ce cas là, oublier la réflexion de façon naïve pour passer directement sur de la réflexion.

                          En effet, mon avis sur la récursion est le suivant : on ne commence pas la récursion avant d'avoir bien compris la notion de la stack (comment c'est fait même de manière abstraite), la notion d'algorithme (être capable de faire des petits algorithmes simple et réussir a penser ou concevoir des algorithme) mais aussi le principe du langage en itératif.

                          Personnellement je n'ai pas assez utilisé la récursion pour donner les avantages en terme d'arrière plan (comprends : tous les effets positifs qui permettent de penser récursion lors de l'exécution), mais par contre on peut dire que le nombre de ligne est fortement réduis et que ça permet une lecture un peut plus rapide du code.

                          Cependant, plus rapide ne veut pas dire plus simple, si on prend un algorithme en itératif, on aura forcément plus d'instructions dans la fonction vue que de base, on devra utiliser des boucles, mais est-ce pour autant quelque chose de mal pour un débutant ? Je ne pense pas.

                          Si on part du principe que la récursion est quelque chose qui va réduire le nombre de ligne elle n'en est pas moins quelque chose qui est dure à comprendre pour un débutant, le principe même de la stack entre grandement en jeux vue que pour comprendre le pourquoi du comment, il faut comprendre comment la stack fonctionne. Et c'est là que ça devient un problème : Quels sont les exercices qui permettrait de faire comprendre la stack en même temps que la récursion ?

                          On pourrait penser qu'un exercice où l'algorithme est plus simple en itératif est une mauvaise chose, pour autant, tout les algorithmes sont faisable en itératif, c'est juste une autre façon de penser. Personnellement je continue de croire qu'un algorithme tel que les factorielles, la recherche de caractère ou même les puissances reste un bon exemple d'algorithme pour apprendre le principe de la récursion.

                          Il existe aussi des algorithmes qui seront fait de façon "logique" en récursif qui sont les fractales, on voit bien la notion de "rappel" dans ce genre de dessins vue que ça se répète à l'infinie, mais donner ce genre d'exercice à un débutant est en soi une grosse bêtise je trouve. Une fractal qui est pas mal connue est l'éponge de Menger, c'est un algorithme pas très long à écrire, mais qui reste quand même quelque chose d'assez difficile à un débutant à implémenter.

                          Je ne suis pas un grand expert en algorithmie et en récursion, il se peut que je dise n'importe quoi dans ce paragraphe, je vous laisse le plaisir de me corriger si c'est le cas.

                          Cordialement,

                          • Partager sur Facebook
                          • Partager sur Twitter
                            27 octobre 2015 à 11:30:47

                            L'itératif n'est pas plus "naturel" que le récursif. C'est pas naturel calculer. C'est quelque chose qu'on apprend. Il n'y a pas besoin de savoir écrire des algos itératifs pour apprendre à en écrire des récursifs et vice-versa. C'est l'enseignement qui le conditionne. Si tu débutes avec un langage fonctionnel (et on peut débuter avec un langage fonctionnel, ça ne pose pas de problème), tu écriras massivement des algorithmes récursifs et tu n'auras pas plus de mal à apprendre.

                            Et de toute façon, il faut savoir faire les deux à bout d'un moment. Donc si ton langage te permet d'apprendre les deux tôt, fais le. Et tous les problèmes qu'on apprend en débutant ne posent aucun problème pour être implémentés dans les deux styles donc profitons en.

                            • Partager sur Facebook
                            • Partager sur Twitter

                            Posez vos questions ou discutez informatique, sur le Discord NaN | Tuto : Preuve de programmes C

                              27 octobre 2015 à 12:49:15

                              Soin... a écrit:

                              Pour ma part, n'importe quel algorithme récursif peut se faire en itératif sans problème (il suffit de "simuler" le principe via une boucle). [...]

                              Il ne suffit pas d'une boucle pour dérécursiver, il faut parfois utiliser sa propre pile aussi → parcours en largeur d'un graphe.

                              Soin... a écrit:

                              La récursivité est à mon sens utile quand ça réduit considérablement le nombre de ligne et te fait gagner du temps, sans pour autant être trop lourd pour la stack, bien évidement les algorithmes récursif doivent être contrôlés de manière à ne pas faire un overflow, et donc de créer un comportement indéfinie.

                              [...]
                              En effet, mon avis sur la récursion est le suivant : on ne commence pas la récursion avant d'avoir bien compris la notion de la stack (comment c'est fait même de manière abstraite), la notion d'algorithme (être capable de faire des petits algorithmes simple et réussir a penser ou concevoir des algorithme) mais aussi le principe du langage en itératif.

                              [...]
                              Si on part du principe que la récursion est quelque chose qui va réduire le nombre de ligne elle n'en est pas moins quelque chose qui est dure à comprendre pour un débutant, le principe même de la stack entre grandement en jeux vue que pour comprendre le pourquoi du comment, il faut comprendre comment la stack fonctionne. Et c'est là que ça devient un problème : Quels sont les exercices qui permettrait de faire comprendre la stack en même temps que la récursion ?

                              [...]
                              Il existe aussi des algorithmes qui seront fait de façon "logique" en récursif qui sont les fractales, on voit bien la notion de "rappel" dans ce genre de dessins vue que ça se répète à l'infinie, mais donner ce genre d'exercice à un débutant est en soi une grosse bêtise je trouve. Une fractal qui est pas mal connue est l'éponge de Menger, c'est un algorithme pas très long à écrire, mais qui reste quand même quelque chose d'assez difficile à un débutant à implémenter. 

                              La récursivité introduit parfois de l'élégance dans le code. Il est de toute façon nécessaire de comprendre les mécanisme mis en œuvres pour implémenter la récursivité sur les machines actuelles. Mais si on se concentre sur la partie mécanique on perd d'autres notions comme savoir quand et sur quoi utiliser la récursivité.
                              L'utilisation de la récursivité montre toute sa puissance lorsqu'on manipule des structure de données elles-mêmes récursives comme les arbres ou les graphes par exemple. Les algorithmes récursifs deviennent simples non seulement à comprendre mais à implémenter.
                              La récursivité est naturelle dans les problèmes dont les solutions sont de de type «diviser pour régner». Réduire un gros problème en problèmes plus petits (mais vraiment plus petits) que l'on sait résoudre simplement. Pas la peine d'aller du côté des fractales, les problèmes classiques comme quicksort ou Hanoï sont à la portée des débutants confirmés.

                              • Partager sur Facebook
                              • Partager sur Twitter
                              First solve the problem. Then, write the code. ~ John Johnson
                                Staff 27 octobre 2015 à 19:36:19

                                La récursion pour parcourir un tableau est juste inutile à mon gout.

                                AMHA, conceptuellement, une fonction qui se rappelle elle même, pour effectuer un traitement sur une même donnée, peut être "naturelle" dans les cas où :

                                - on ne peut pas se permettre/ou on ne peut pas tout court sonder la profondeur à l'avance (penser aux arbres)

                                - [ET] un ordre de traitement du type FIFO (First In First Out)

                                - [ET] on a la parfaite maîtrise de la profondeur (pas trop d'étages, avec le moyen de la contrôler si possible)

                                Franchement, une recherche dans un tableau... il faut être sérieux un minimum.

                                Pour ceux qui invoquent la raison pédagogique, quit à apprendre des techniques de ce genre, autant les apprendre sur un exemple conceptuel plus adapté. Si cela vous paraît compliqué à aborder, peut être qu'il est prématuré d'attaquer la récursion ?...

                                -
                                Edité par uknow 27 octobre 2015 à 19:55:13

                                • Partager sur Facebook
                                • Partager sur Twitter
                                  27 octobre 2015 à 19:38:48

                                  La boucle aussi puisqu'on peut le faire par récursion.

                                  • Partager sur Facebook
                                  • Partager sur Twitter

                                  Posez vos questions ou discutez informatique, sur le Discord NaN | Tuto : Preuve de programmes C

                                    Staff 27 octobre 2015 à 19:53:48

                                    Ksass`Peuk a écrit:

                                    La boucle aussi puisqu'on peut le faire par récursion.


                                    Je ne suis pas certain d'avoir compris, peux-tu développer stp ?

                                    PicoDev a écrit:

                                    comme les arbres ou les graphes par exemple.


                                    Les arbres d'accord, mais par contre les graphes, je ne vois pas de moyen simple pour éviter les chemins infinis.

                                    -
                                    Edité par uknow 27 octobre 2015 à 20:16:46

                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      27 octobre 2015 à 20:22:00

                                      uknow a écrit:

                                      - [ET] on a la parfaite maîtrise de la profondeur (pas trop d'étages, avec le moyen de la contrôler si possible)

                                      Ta profondeur de récursion sur cet algo et pour tout algo tail-recursif, tu t'en tapes en fait. Puis que ce sera dérécursivé.

                                      En l'occurrence :

                                      char* search_iter(char *s, char c){
                                        assert(s);
                                      
                                        while(*s){
                                          if(*s == c) return s;
                                          ++s;
                                        }
                                        return NULL;
                                      }
                                      
                                      char* search_rec(char *s, char c){
                                        assert(s);
                                      
                                        if(! *s) return NULL;
                                        if(*s == c) return s;
                                        return search_rec(s+1, c);
                                      }

                                      Même complexité algorithmique, même complexité à l'écriture, même (quasiment) code généré. Dans les 2 cas l'invariant de parcours est le même. Bref sur cet exemple, la récursion est aussi utile que la boucle.

                                      (Et tout à l'heure, ça parlait de la factorielle, la version récursive est soit plus simple que la version itérative (moins de variable), soit fournit l'invariant par construction (si on élimine les variables non nécessaires)).

                                      Ah et la récursion n'est pas plus compliqué que l'itératif d'un point de vue algorithmique. C'est juste un conditionnement général des cours mal branlés.

                                      -
                                      Edité par Ksass`Peuk 27 octobre 2015 à 20:53:35

                                      • Partager sur Facebook
                                      • Partager sur Twitter

                                      Posez vos questions ou discutez informatique, sur le Discord NaN | Tuto : Preuve de programmes C

                                        27 octobre 2015 à 21:39:06

                                        uknow a écrit:

                                        PicoDev a écrit:

                                        comme les arbres ou les graphes par exemple.


                                        Les arbres d'accord, mais par contre les graphes, je ne vois pas de moyen simple pour éviter les chemins infinis.

                                        En marquant les nœuds déjà parcourus ou en attente de parcours, par exemple.

                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                        First solve the problem. Then, write the code. ~ John Johnson
                                          27 octobre 2015 à 22:03:55

                                          Ksass`Peuk a écrit:

                                          Ah et la récursion n'est pas plus compliqué que l'itératif d'un point de vue algorithmique. C'est juste un conditionnement général des cours mal branlés.

                                          -
                                          Edité par Ksass`Peuk il y a environ 1 heure

                                          On est d'accord :D

                                          Les cours mal branlés, ce sont les cours qui utilisent la récursivité sur des structures de données itératives, ou sur des exemples bidons.
                                          Autant présenter la récursivité sur des problèmes(et des langages) ou elle a sa place.


                                          Pour le coup de la factorielle plus simple en récursif qu'en itératif, bah ça dépend vraiment du profil de la personne.
                                          A mon avis n'importe collégien peux imaginer la version itérative. Pour la version récursive, c'est pas gagné^^

                                          -
                                          Edité par GurneyH 27 octobre 2015 à 22:10:38

                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                          Zeste de Savoir, le site qui en a dans le citron !
                                            28 octobre 2015 à 8:56:47

                                            GurneyH a écrit:

                                            Les cours mal branlés, ce sont les cours qui utilisent la récursivité sur des structures de données itératives, ou sur des exemples bidons.
                                            Autant présenter la récursivité sur des problèmes(et des langages) ou elle a sa place.

                                            "Structure de donnée récursive" ça désigne la forme de ta structure de données en mémoire, pas la manière dont tu vas y accéder. En l'occurrence, une "structure de données itérative", ça n'a pas vraiment de sens, structure de données indexée, ça a du sens éventuellement, mais rien n'empêche de la rendre récursive et indexée. Si on y regarde de plus près, "l'opposition" à une structure de données récursive, c'est des raw-datas.

                                            On peut manipuler en récursif et en itératif n'importe quelle structure de données. Simplement, la construction d'une nouvelle structure récursive est relativement plus simple avec un algo récursif.

                                            GurneyH a écrit:

                                            Autant présenter la récursivité sur des problèmes(et des langages) ou elle a sa place.

                                            Ben écoute j'attends toujours de savoir pourquoi la version récursive de la recherche n'est pas adaptée, comme je l'ai dit plus tôt, même difficulté d'écriture, même complexité, même code final généré.

                                            On peut encore plus se marrer en écrivant un truc comme :

                                            pos search_iter(type s, char c){
                                              assert(s);
                                             
                                              while(! empty(s)){
                                                if(head(s) == c) return s;
                                                s = tail(s);
                                              }
                                              return NULL;
                                            }
                                             
                                            pos search_rec(type s, char c){
                                              assert(s);
                                             
                                              if(empty(s)) return NULL;
                                              if(head(s) == c) return s;
                                              return search_rec(tail(s), c);
                                            }

                                            Que type soit un tableau avec les fonctions en question définies ou une liste ne fait littéralement aucun sens du point de vue de l'algorithme. C'est la même chose. Les deux sont complètement valides ont la même sémantique et on s'en tape littéralement que ce soit des listes, des tableaux, des fichiers ou whatever. On veut juste un truc qui a une tête et une queue (et pour un tableau, ben on peut, sans aucun effort ni surcoût).

                                            GurneyH a écrit:

                                            A mon avis n'importe collégien peux imaginer la version itérative. Pour la version récursive, c'est pas gagné^^

                                            Jamais essayé avec des collégiens, mais avec des L1 pas trop doués, j'ai écris ça au tableau pour un TD d'algo :

                                            facto(1) =                       1
                                            facto(2) =                   2 *(1)
                                            facto(3) =               3 *(2 * 1)
                                            facto(4) =           4 *(3 * 2 * 1)
                                            facto(n) = n *(... * 4 * 3 * 2 * 1)

                                            Sur une trentaine d'étudiant, j'ai eu 5 versions itératives qui venaient d'étudiant qui avait déjà commencé par la programmation (avec le C, parce que le C, c'est le meilleur choix pour débuter ...), tout le reste m'ont sorti la version récursive d'office.

                                            Groupe suivant, j'ai écris ça au tableau :

                                            facto(1) = 1
                                            facto(2) = 1 * 2
                                            facto(3) = 1 * 2 * 3
                                            facto(4) = 1 * 2 * 3 * 4
                                            facto(n) = 1 * 2 * 3 * 4 * ... * n

                                            J'ai eu que des versions itératives à peu près.

                                            La façon de présenter les choses à un putain d'impact en vrai.

                                            Par contre, truc rigolo, si tu demandes une preuve informelle que l'algorithme fonctionne, ils mettent quelques minutes à la faire sur la version récursive et il faut leur donner la solution pour la version itérative. Parce que l'invariant dans une des deux versions est gratuit.

                                            -
                                            Edité par Ksass`Peuk 28 octobre 2015 à 11:09:51

                                            • Partager sur Facebook
                                            • Partager sur Twitter

                                            Posez vos questions ou discutez informatique, sur le Discord NaN | Tuto : Preuve de programmes C

                                              26 juin 2019 à 10:43:07

                                              stp j'ai besoin d'un programe pascal qui fait une recherche  d'une valeur dans un tableau entier de taille par la méthode récursive

                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                26 juin 2019 à 16:18:27

                                                ImenMadrid a écrit:

                                                stp j'ai besoin d'un programe pascal qui fait une recherche  d'une valeur dans un tableau entier de taille par la méthode récursive


                                                Et moi j'ai besoin de 200 000 €. On peut s'arranger ?

                                                Merci de créer ton propre sujet au lieu de squatter une vieille discussion (2015) sur le langage C.

                                                Mais n'aies pas trop d'illusion, personne ne va faire ton exercice. Fais d'abord voir ton code, on t'aidera à avancer ensuite.

                                                -
                                                Edité par michelbillaud 26 juin 2019 à 16:20:39

                                                • Partager sur Facebook
                                                • Partager sur Twitter

                                                recherche recursive dans un tableau de caractére

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