Partage
  • Partager sur Facebook
  • Partager sur Twitter

Exercices pour débutants en C (suite)

Venez vous entrainer!

    7 août 2011 à 20:01:30

    "Venez Pratiquer" ou "Venez vous entrainer" sonnent bien étant donné que tout le long du tutoriel (pour ne prendre que le cas du C), M@teo21 répète qu'il faut pratiquer (pratiquer encore et encore).

    Je peux comprendre GurneyH et Pouet qui se plaignent de proposer des exercices et qu'il n'y ait pas trop de participant. Mais, pourquoi ne pas se dire que les débutants le font mais n'osent poster leurs solutions (je crois que plusieurs raisons en été invoquées, notamment le fait d'être critiqué).

    Peut être que c'est le concept des exercices qu'il faut revoir car je dois dire que le dernier exercice à avoir rassemble beaucoup de monde est zMorp... Allons savoir pourquoi.

    En tant que débutant, je ne crois pas avoir de solutions.
    • Partager sur Facebook
    • Partager sur Twitter
      7 août 2011 à 20:07:42

      Citation : LeBri@n


      Mais, pourquoi ne pas se dire que les débutants le font mais n'osent poster leurs solutions (je crois que plusieurs raisons en été invoquées, notamment le fait d'être critiqué).


      C'est un problème en effet.
      Mais, les critiques ne sont pas gratuites(la plupart du temps. :-° ).
      Et ce sont ces critiques, qui aident à progresser.

      C'est pourtant un frein, au nombre de participants tu as raison.
      Quoique, à l'époque où on envoyait nos codes à "réponse", on était 3, 4 dans les grands jours.

      Alors, les gens bossent dans leur coin?
      Frustrant de poster des exos!
      :-°
      • Partager sur Facebook
      • Partager sur Twitter
      Zeste de Savoir, le site qui en a dans le citron !
        7 août 2011 à 20:19:02

        Citation : GurneyH

        Et ce sont ces critiques, qui aident à progresser.

        Un grand + 1 ;)

        Perso, j'ai modifié ma (mauvaise) manière de programmer lorsque j'ai participé à l'exercice proposé par paraze (zConjug) et que j'ai eu le retour de candide et Marc Mongenet.

        Citation : GurneyH

        Alors, les gens bossent dans leur coin?
        Frustrant de poster des exos! :-°

        C'est dit à la volée... Mais si ça peut faire que vous continuez à nous proposer des exercices :-°
        • Partager sur Facebook
        • Partager sur Twitter
          7 août 2011 à 21:38:10

          +1 :-°

          @LeBri@n : Tu n'es plus si débutant que ça quand même non ?

          Sinon, vous le trouvez comment mon nouvel avatar ? Un peu trop surchargé, non ? il est vrai que les exos du style zMorp ont plus de succès, il faudrait en faire plus souvent.
          • Partager sur Facebook
          • Partager sur Twitter
            7 août 2011 à 21:41:16

            De manière générale, les jeux ont plus de succès et c'est compréhensible je pense. ;)

            @paraze : C'est du paraze-Sabeurre-Republic en 1 !
            • Partager sur Facebook
            • Partager sur Twitter
            Bla bla bla
              7 août 2011 à 21:56:12

              En fait, je pense que le fait qu'il est une différence de succès entre les jeux et les autres "défis" (je parlerais de défis dorénavant :-° ) est un point positif. Ça signifie que il y a un public et que l'on pourrait faire quelque chose pour le faire venir. Encore faut-il savoir quoi faire.

              Je suis toujours pour la mise en place d'un compte afin que les débutants les moins assurés puissent participé. Tout en laissant le choix de poster sur le forum (et même en encourageant à poster sur le forum plutôt que par MP ).

              Sinon pour la question des différents langages, je suis pour mais à condition qu'ils soit tous dans les balises code. Car il est vrais que ça peut décourager les débutants. Ils les verront seulement s'ils ont envies.
              • Partager sur Facebook
              • Partager sur Twitter
              🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                7 août 2011 à 22:01:49

                Citation : @che


                Sinon pour la question des différents langages,


                Il n'en a jamais été question!
                ;)
                • Partager sur Facebook
                • Partager sur Twitter
                Zeste de Savoir, le site qui en a dans le citron !
                  7 août 2011 à 22:16:38

                  Sinon pour la question sur le point des différents langages,

                  :D
                  • Partager sur Facebook
                  • Partager sur Twitter
                  🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                    22 août 2011 à 17:24:16

                    GuilOooo,

                    Du neuf concernant les premiers exos ?
                    J'ai hâte de me lancer... :)
                    • Partager sur Facebook
                    • Partager sur Twitter
                      31 août 2011 à 11:43:53

                      Alors GuillOoo, on aura droit à des exercices pour la rentrée ou pas ? :p
                      • Partager sur Facebook
                      • Partager sur Twitter
                      Staff désormais retraité.
                      Anonyme
                        31 août 2011 à 12:20:49

                        Je suis tombé malade récemment, d'où mon absence signalée en signature. Je risque donc de rater la rentrée. :)

                        Pour info, je n'ai que 13 exos, ce qui, au rythme de publication prévu (un par semaine), devrait déjà nous faire tenir jusqu'en novembre. Je les publie ce soir, pour que l'on commence le premier septembre (demain).

                        Malheureusement, il s'agit surtout d'exos console, ça manque gravement de SDL pour le moment. J'espère que nos débutants ne seront pas rebutés pour autant...

                        Aussi, je n'aurai peut-être pas le temps de venir en poster un par semaine sur ce topic (ou sur un nouveau topic prévu à cet effet). S'il y a des volontaires pour animer le truc, qu'ils se signalent par MP. Si vous voulez également rédiger des énoncés, soit à partir de la liste d'idées, soit librement, n'hésitez pas à le faire non plus.

                        Comptez que je serai de retour entre le 10 et le 15 septembre. En attendant, je suis le forum de loin.

                        À ce soir pour les premiers énoncés,
                        GuilOooo
                        • Partager sur Facebook
                        • Partager sur Twitter
                        J'ai déménagé sur Zeste de savoir — Ex-manager des modérateurs.
                          31 août 2011 à 12:49:36

                          Je ne serai hélas pas assez présent sur le forum, pendant les cours, pour pouvoir m'occuper de « l'animation » des posts d'exercice.
                          Néanmoins, je serai là pour poster mon code. :p
                          Sinon, comment s'organise-t-on au niveau des solutions, justement ?

                          PS : bon rétablissement...
                          • Partager sur Facebook
                          • Partager sur Twitter
                          Staff désormais retraité.
                            31 août 2011 à 12:53:53

                            Citation : GuilOooo

                            Je suis tombé malade récemment, d'où mon absence signalée en signature.



                            J'espère que c'était pas trop grave. :o

                            Si j'ai bien compris, tu comptes poster tous les sujets ici puis en reposter un sur un autre topic chaque semaine ? Je pense que la meilleure organisation serait certes d'avoir un topic qui regroupe un lien vers tous les énoncés et leur correction éventuelle, mais ça serait bien mieux organisé d'avoir ensuite un topic par exercice. (Ca éviterait au moins les discussions croisées si quelqu'un poste un code pour un exercice datant d'un mois). (D'autre part, cela éviterait une surcharge du topic principal, qui se retrouverait vite avec plusieurs dizaines de pages... peu motivant à lire pour un débutant !).

                            En ce qui concerne les deux énoncés que j'ai rédigés, j'aimerais les poster si ça ne te dérange pas (pour conserver une possibilité d'édition pour corriger/ajouter/supprimer des conseils, un niveau de difficulté, etc...).

                            Pour le reste, normalement je serai largement assez disponible pour me connecter au moins une fois par jour donc je suis dispo si tu as besoin (et motivé en plus ! ;) ).
                            • Partager sur Facebook
                            • Partager sur Twitter
                            Bla bla bla
                              31 août 2011 à 22:11:47

                              Citation : GuilOooooooo

                              Je suis tombé malade récemment, d'où mon absence signalée en signature.


                              Déjà trois jours, c'est en cours de rétablissement ?

                              Moi, je pourrai aider une ou deux fois si tu en as besoins car je ne suis pas extrêmement débordé en ce moment. ;)
                              Mais je ne pourrai pas être le CM de ces exos, si je puis dire. :p

                              J’essaierai aussi (bien sûr) de poster un code presque à chaque fois (si l'exo n'est pas trop dur) !
                              • Partager sur Facebook
                              • Partager sur Twitter
                                31 août 2011 à 22:26:59

                                Tiens au fait, un sujet du forum C m'a donné une idée d'exercice (en console, et il n'y a même pas d'affichage à faire). Il s'agit d'écrire une fonction capable de retrouver le chemin du dossier ou se trouve le fichier du programme (qui peut être différent du dossier d'exécution). Comme j'ai la flemme d'expliquer, je n'en dis pas plus et je vous donne le lien vers le sujet en question. :)

                                Qu'en pensez-vous ?

                                Je pense que je peux animer l'exercice, au besoin.

                                @ GuilOooo : Bon rétablissement, et ne te brusques pas pour la communauté des Zéros. :)
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  31 août 2011 à 22:41:55

                                  ention - vous allez utiliser un algorithme existant. La première étape est donc de trouver un algorithme. Il vous faudra donc faire des recherches sur le Web. Le problème posé par cet exercice s'appelle un problème de flot maximum. La page wikipédia donne déjà le nom de quelques méthodes. :)

                                  Conclusion



                                  Cet exercice est un peu ardu. Il fera travailler tant votre C que votre algorithmie. Ne désespérez pas ! N'hésitez pas à poster vos codes et vos idées, même s'ils sont incomplets.

                                  Bon courage et bonne chance à tous ! :)

                                  GuilOooo
                                  558082">Citation : GuilOooo

                                  zMol, la chimie pour tous !



                                  Introduction



                                  Salut à tous, :)

                                  Aujourd'hui l'exercice sera de réaliser un calculateur de masse molaire. Cette notion de chimie n'est abordée qu'en classe de seconde générale, mais vous devriez vous en sortir même si vous êtes au collège, du moment que vous avez une bonne connaissance des molécules et des atomes.

                                  Pour les non-initiés donc, il faut savoir que chaque atome a ce qu'on appelle une masse molaire atomique. Pour faire court, il s'agit de la masse que pèse une mole de cet atome (si vous êtes curieux, vous pouvez en apprendre plus sur les moles ici ! ;) ). Chaque molécule a une masse molaire moléculaire, que l'on obtient en faisant la somme de tous les masses molaires atomiques des atomes qui la composent.

                                  L'unitée de la masse molaire est le <math>\(g.mol^-^1\)</math>.

                                  Consignes



                                  Le but de l'exercice est donc de réaliser un programme qui calcule la masse molaire d'une molécule entrée par l'utilisateur, et ce grâce à un fichier texte contenant certains atomes et leur masse molaire atomique correspondante.

                                  Exemple :

                                  Entrez une molécule :
                                  --> CO2
                                  
                                  La masse molaire de cette molécule est 44.0090 g.mol-1


                                  Je vous propose de commencer à travailler avec ce petit fichier texte, il sera amplement suffisant pour faire des tests et pour couvrir un bon nombre de molécules :

                                  <secret>
                                  C 12.011
                                  O 15.999
                                  H 1.0079
                                  He 4.0026
                                  Li 6.941
                                  Cl 35.453
                                  Na 22.989
                                  </secret>

                                  Objectifs



                                  • Manipuler la lecture de fichiers.
                                  • Apprendre à se servir de quelques fonctions de la bibliothèque standard.
                                  • Apprendre (ou approfondir) une nouvelle notion en chimie.


                                  Pistes de réflexion



                                  Reconnaître un atome.

                                  Vous pouvez remarquer que les symboles de certains atomes prennent un caractère et d'autres deux. ^^ Quand notre programme aura a analyser l'atome de chlore (Cl), par exemple, il ne faudra pas qu'il l'interprette comme un atome de carbone (C), et un atome l (inconnu au bataillon).

                                  Heureusement, pour nous aider, une règle bien précise est que le deuxième caractère des symboles des atomes est toujours en minuscule, et le premier en majuscule. Pour cela, il va falloir utiliser les fonctions suivantes :

                                  <secret>
                                  int isupper(int c); // Teste si un caractère est majuscule
                                  int islower(int c); // Teste si un caractère est minuscule
                                  /* Ces deux fonctions sont définies dans <ctype.h> */
                                  
                                  </secret>

                                  Bien sur, je ne vous donne là que quelques pistes, l'essentiel des recherches sur les problèmes que vous rencontrerez étant à faire par vous même (sinon, ça ne sert à rien). ;)

                                  Enoncé



                                  Niveau 1

                                  Faire un programme qui gère uniquement une liste d'atomes de symbole n'ayant qu'un caractère, écrits les uns à la suite des autres :

                                  <secret>
                                  Entrez une molécule :
                                  --> COO
                                  
                                  La masse molaire de cette molécule est 44.0090 g.mol-1
                                  </secret>

                                  Niveau 2

                                  Cette fois, votre programme devra gérer les atomes dont le symbole fait plusieurs caractères.

                                  <secret>
                                  Entrez une molécule :
                                  --> NaCl
                                  
                                  La masse molaire de cette molécule est 58.442000 g.mol-1
                                  </secret>

                                  Niveau 3

                                  Votre programme devra gérer les coefficients. Pour tester si un caractère est un chiffre, vous devrez utiliser une fonction de la même famille que isupper et islower (à vous de chercher seul, cette fois ;) ).

                                  La fonction strtol peut aussi vous être utile. ;)

                                  <secret>
                                  Entrez une molécule :
                                  --> CO2
                                  
                                  La masse molaire de cette molécule est 44.0090 g.mol-1
                                  </secret>

                                  Niveau 4

                                  Votre programme devra gérer les groupes qui se répètent plusieurs fois.

                                  <secret>
                                  Entrez une molécule :
                                  --> (CH4)2
                                  
                                  La masse molaire de cette molécule est 32.085200 g.mol-1
                                  </secret>

                                  Niveau 5

                                  Les scientifiques viennent de découvrir un tout nouvel atome !! ^^ Ajoutez à votre programme une fonction qui vous permettra d'ajouter un atome et sa masse molaire dans votre fichier. ;)

                                  Et après... ?



                                  Si vous réalisez les 5 niveaux, vous pouvez encore aller plus loin si vous le souhaitez !

                                  Par exemple, vous pouvez décider d'afficher les étapes intermédiaires du calcul, etc... Votre imagination est votre seule limite ! ;)

                                  Bon courage. ;)

                                  _Fender_


                                  Citation : GuilOooo

                                  Jeu de la vie



                                  Avant-propos



                                  Aujourd'hui, je vous propose de réaliser en SDL un jeu que je trouve fascinant, le jeu de la vie. :)

                                  Ce n'est pas un jeu au sens ludique du terme, car le "joueur" reste passif une fois l'animation lancée.

                                  Le jeu de la vie... c'est quoi ?



                                  Le jeu de la vie est en réalité un automate cellulaire qui passione les mathématiciens depuis son invention en 1970 par John Horton Conway.

                                  Un automate cellulaire se base sur une grille de cases (cellules) qui sont chacune dans un certain état, à un certain instant. Un tel automate comporte des règles qui disent comment les états des cellules évoluent dans le temps. Dans le cas du jeu de la vie, les cellules peuvent être dans 2 états différents : vivantes ou mortes.

                                  Les règles sont plutôt simples :

                                  • Si une cellule morte à exactement trois voisines vivantes, elle devient alors vivante à son tour.
                                  • Si une cellule vivante à deux ou trois voisines vivantes, elle le reste. Elle meurt dans tous les autres cas.



                                  Une image vaudra mieux que tout discours, alors voici un lien qui vous permettra de voir a quoi ressemble une simulation du jeu de la vie. Il est également possible de faire des choses encore plus fascinantes, comme ce canon, qui fonctionne uniquement avec les règles citées plus haut. ;)

                                  Notre fenêtre sera donc une grille 2D de cellules. Au départ, certaines seront vivantes, et d'autres mortes.


                                  Vous êtes curieux ? En savoir plus sur :


                                  Consignes



                                  Notre objectif sera donc de réaliser un simulateur du jeu de la vie.

                                  Je vous propose de représenter par une case noire les cellules mortes et par une case blanche les cellules vivantes. Au lancement du jeu, l'utilisateur doit pouvoir changer l'état de chaque cellule en cliquant dessus pour la faire vivre/mourir. Une fois le jeu lancé, la grille évolue selon les règles définies plus haut.

                                  Objectifs


                                  • Premier contact avec le monde des automates cellulaires.
                                  • Application pratique de l'apprentissage de la SDL.
                                  • Manipulation des tableaux à deux dimensions.


                                  Enoncé



                                  Niveau 1

                                  Mettre en place les fonctionnalités de base : choisir les cellules mortes/vivantes en début d'animation et lancer l'animation à l'appui d'une touche.

                                  Niveau 2

                                  Pouvoir mettre en pause/relancer l'animation et changer l'état de cellules pendant la pause.

                                  Niveau 3

                                  Vous avez trouvé une belle séquence et vous voulez l'envoyer à vos amis ? :) Mettez donc en place un système de sauvegarde dans des fichiers, ou vous pouvez charger/sauvegarder une disposition de cellules. ;)

                                  Et après... ?



                                  Si ce jeu vous passionne autant que moi, pourquoi ne pas vous amuser à changer les règles ? ^^

                                  Modifiez les conditions de naissance et de mort, ajoutez des couleurs, etc... Encore une fois, laissez parler votre imagination et votre créativité ! ;)

                                  Bon courage. ;)

                                  _Fender_, et un peu modifié par GuilOooo


                                  Citation : GuilOooo

                                  Faisons une vraie calculette !



                                  Note : cet exercice est inspiré d'un atelier qui fût organiser sur le forum « autres langages ». Vous pouvez aller lire cette discussion et y participer si vous avez quelque chose de nouveau à y ajouter ! Cependant, ce topic comprend plusieurs solutions, dont certaines en langage C. Méfiez-vous ! Je vous conseille d'essayer par vous-mêmes avant de voir comment les autres ont fait. En ayant essayé par vous-mêmes, vous repérerez où sont les difficultés, et vous profiterez d'autant mieux de la lecture de ce topic.

                                  C'est parti !

                                  Introduction



                                  Savez-vous ce qu'est un parser ? Il s'agit d'un bout de code dont le but est d'analyser une chaîne de caractères afin d'en dégager la structure. Par exemple, si je vous donne la chaîne "3+2*(4-3)", un parser pourrait la transformer en arbre, comme ceci :

                                  Arbre :
                                      +
                                    /   \
                                  3       *
                                        /   \
                                      2       -
                                            /   \
                                          4       3



                                  Bien entendu, les parsers peuvent servir à beaucoup de choses, depuis l'analyse d'expressions mathématiques simples jusqu'à l'analyse de codes sources. Le parsing est la première étape qu'effectue votre compilateur de C favori pour produire un exécutable. Il s'agit de l'étape permettant « comprendre » le code. :)

                                  Les parsers sont des outils très utiles qui vous serviront très probablement à un moment donné. Cependant, cet exercice traitera uniquement d'expressions mathématiques, je vais donc me focaliser là-dessus.

                                  L'arbre correspondant à l'expression du premier exemple pourrait être représenté par la structure suivante :

                                  /* Un nœud de l'arbre peut être soit un opérateur (+,-,/,*), soit
                                     un nombre. On prévoit une énumération pour pouvoir rajouter des cas. */
                                  enum type
                                  {
                                      OPERATEUR,
                                      NOMBRE
                                  };
                                  typedef enum type type_e;
                                  
                                  /* La structure qui contient les informations d'un nœud. L'arbre
                                     tout entier sera représenté par le nœud racine. */
                                  struct arbre
                                  {
                                      type_e        type;   /* Opérateur ou nombre ? */
                                      int           valeur; /* Valeur du nombre/code ascii de l'opérateur. */
                                      struct arbre *gauche; /* Pointeur vers le sous-arbre gauche. */
                                      struct arbre *droit;  /* Idem avec le sous-arbre droit. */
                                  };
                                  typedef struct arbre arbre_s;
                                  /* Bien entendu, dans le cas d'un nombre, les deux pointeurs valent NULL. */
                                  


                                  Une fois que l'arbre a été construit, nous pouvons le manipuler, par exemple pour calculer la valeur de l'expression mathématique.

                                  Pourquoi s'embêter à construire l'arbre ? Ne pouvons-nous pas calculer la valeur au fur et à mesure de l'analyse ?



                                  C'est juste, mais en procédant ainsi, on perd en flexibilité. Et si notre but n'était pas simplement de calculer la valeur, mais de transcrire la formule dans une autre notation ? Ou encore, si la formule comporte des variables dont nous ne connaîtrons la valeur que plus tard, comment faire ? Nous pourrions aussi imaginer calculer la dérivée d'une fonction dont on connaîtrait la formule, etc.

                                  Comme vous le voyez, les possibilités sont nombreuses ! Nous nous servirons de cet analyseur dans d'autres exercices, plus tard. Il sera alors important de disposer de l'arbre, plutôt que de tout calculer directement. ;)

                                  Consignes



                                  Écrivez un programme qui :

                                  • 1. lit une expression mathématique sur l'entrée standard ;
                                  • 2. l'analyse pour en construire l'arbre ;
                                  • 3. calcule la valeur.


                                  L'expression mathématique tiendra sur une seule ligne et ne fera pas plus de 200 caractères, en comptant le '\n' et le '\0' terminaux.

                                  La nature des expressions, autrement dit le « langage » dans lequel les formules seront données, dépend du niveau de difficulté choisi.

                                  Objectifs


                                  • Chercher par soi-même sur Internet.
                                  • Découvrir ce qu'est un parser, comment ça marche.
                                  • Implémenter un algorithme connu.
                                  • Manipuler les chaînes de caractères.



                                  Énoncé



                                  Niveau 1

                                  Dans ce niveau, les formules vous sont données en notation polonaise inversée. C'est un nom technique, mais il n'y a rien de compliqué ; si vous savez parler comme maître Yoda, vous connaissez déjà. Au lieu d'avoir des opérations de la forme « 3+2 », elles sont de la forme « 3 2 + ». Ainsi,

                                  (3+2)*5/4


                                  s'écrit en notation polonaise inversée :

                                  3 2 + 5 * 4 /



                                  Les règles pour comprendre une formule écrite à l'aide de cette notation sont les suivantes. Prenez une pile, initialement vide, et lisez les symboles (nombre ou opérateur) un par un. Pour chaque symbole :

                                  • s'il s'agit d'un nombre, ajoutez-le au sommet de la pile ;
                                  • s'il s'agit d'un opérateur, dépilez deux nombres, appliquez-leur l'opération, empilez le résultat.


                                  Cette notation a pour caractéristique particulière qu'elle est facile à parser. Comme vous avez pu le constater sur l'exemple, il n'y a jamais besoin de parenthèses avec cette notation : les expressions sont non-ambiguës ! Nous n'avons pas non-plus besoin de priorité des opérateurs, puisque les opérations apparaissent dans l'ordre où elles sont effectuées.

                                  Voilà, vous avez toutes les clés en main pour réussir le niveau 1. Vous pouvez gérer les opérateurs que vous voulez, mais au moins +, -, *, et ^ (puissance).

                                  Bonne chance ! :)

                                  Bonus : toutes les formules données en notation polonaise inversée peuvent être écrites de façon à ce que tous les opérateurs soient à la fin. Par exemple,

                                  3 2 + 5 * 4 /


                                  peut s'écrire

                                  4 5 2 3 + * /


                                  Utilisez votre analyseur pour faire un programme qui récrit une formule en notation polonaise inversée de cette manière. Attention : le but de la manœuvre n'est pas de faire de la manipulation de texte, mais bien de construire l'arbre, puis d'afficher la formule sous une nouvelle forme à partir de cet arbre.

                                  Niveau 2

                                  Pour le niveau 2, nous allons parser une expression mathématique de « tous les jours ».

                                  Cette fois-ci, ce ne sera pas aussi simple, d'une part car il s'agit d'un langage plus compliqué, d'autre part car je vous guiderai moins. :)

                                  Je vais vous donner le langage que vous avez à parser sous la forme d'une grammaire formelle. Elle rentre dans la catégorie des grammaires algébriques, qui peuvent être reconnues grâce à un automate à pile.

                                  E -> (E)
                                  E -> E+E
                                  E -> E-E
                                  E -> E*E
                                  E -> E/E
                                  E -> N
                                  N -> n'importe quel entier positif.



                                  Cette grammaire est donnée par un ensemble de règles ; ici, E signifie « Expression » et N « nombre ». La première règle se lit comme suit : « une expression peut être formée d'un symbole '(', suivi d'une expression, suivi du symbole ')' ». La deuxième règle se lit : « une expression peut être formée d'une expression suivie du symbole '+', suivi d'une autre expression ». Et ainsi de suite...

                                  Une approche naïve est de tenter d'appliquer ces règles l'une après l'autre. Par exemple, pour la deuxième règle, on cherche un symbole « + » dans la chaîne, puis on analyse ce qui se trouve à gauche et à droite dudit symbole. Si on ne trouve aucun symbole « + », on essaie le symbole « - », puis « * », etc. Il est alors simple de construire l'arbre au fur et à mesure. La gestion des parenthèses et alors un poil délicate, mais l'idée reste la même. :)

                                  Une autre méthode consiste en utiliser un algorithme d'analyse connu. Un bon exemple est l'analyse LR, sur laquelle vous pouvez trouver de nombreuses informations sur le Web. Notez qu'il vous faudra peut-être modifier la grammaire pour l'adapter à l'algorithme que vous vous proposer d'utiliser. On peut en effet effectuer certaines transformations sur la grammaire sans pour autant en changer le sens. En outre, certains algorithmes demandent des grammaires écrites sous une forme bien précise. Je ne vous en dit pas plus, je vous laisse vous débrouiller. :)

                                  Le mot d'ordre pour le niveau 2 est : n'hésitez pas à chercher sur le Web. Je ne parle pas de copier/coller des codes tout faits, bien entendu, mais plutôt de chercher quelles techniques et quels algorithmes existent, puis de tenter de les implémenter. N'oubliez pas que le forum est là pour vous aider !

                                  Bon courage à tous ! ;)

                                  Bonus : plutôt que de calculer la valeur de l'expression mathématique, pourquoi ne pas la traduire en notation polonaise inversée ?

                                  Niveau 3

                                  Le but est maintenant de rajouter une nouvelle fonctionnalité à votre parser. Il doit comprendre les variables, dont le nom sera constitué d'une unique lettre en minsucule.

                                  Vous devez donc modifier votre programme du niveau 2 pour qu'il liste une expression mathématique comprenant des variables. Il devra ensuite demander la valeur de chacune des variables apparaissant dans l'expression, puis afficher le résultat du calcul.

                                  Conclusion



                                  Bon courage à tous ! :)

                                  GuilOooo


                                  Citation : GuilOooo

                                  Un Chronomètre



                                  Salut ! :)

                                  Le défi de la semaine sera de recréer un chronomètre. Ce défi est plutôt simple et les explications vous permettrons de vous aider si vous avez des difficultés. Sachez que ce défi est accessible dès la fin de la partie 2 du tutoriel officiel du site. Passons dès à présent au cahier des charges.

                                  Cahier des charges


                                  Cet exercice serra composé de trois niveaux :

                                  Niveau 1 :
                                  Vous devrez arrivez à reproduire ce programme :

                                  Appuyer sur "Entrer" :
                                  Encore :
                                  Il s'est écoule 11 secondes.


                                  Vous devez donc simplement calculer les temps écoulé entre les 2 "Enter". Pour cela vous pouvez utiliser les fonctions du header standard time.h. D'ailleurs, il y a un tuto à ce sujet ;).

                                  Pour attendre l'appuie sur la touche Entrer, vous pouvez utiliser la fonction getchar() ou encore simplement un scanf(). Les fonctions que vous devrez utiliser afin de récupérer la date sont time() et difftime() ;)

                                  Niveau 2 :
                                  Vous devrez arrivez à reproduire ceci :

                                  Appuyer sur "Entrer" :
                                  Encore :
                                  Il s'est écoule 4.255 secondes.



                                  La différence avec le premier ? La précision. Ici nous allons gérer une précision grandement accrue, de l'ordre de la micro seconde ;) .
                                  Pour cela, nous allons utiliser des fonctions différentes pour la gestion du temps, mais pour l'attente de l'appuie sur entrer, vous pouvez encore utiliser getchar() ou scanf().

                                  Pour le temps, cette fois ci nous allons utiliser la fonction clock () qui se base sur la fréquence du processeur. Pour retrouver un résultat en seconde, vous devrez utiliser le macro CLOCKS_PER_SEC.

                                  Niveau 3 :
                                  Les choses se gâtent :diable: .
                                  En effet, vous allez essayer d'afficher le temps écouler en temps réel. Cette fois-ci, vous êtes libre du résultat, pour vous montrer un exemple cependant voici ce que pourrait afficher votre programme :

                                  Appuyer sur "Entrer" :
                                  Encore :
                                  Deja 1 seconde
                                  Deja 2 seconde
                                  Deja 3 seconde
                                  Deja 4 seconde
                                  Il s'est écoule 4.625 secondes.



                                  Vous pouvez arrivez à ce résultat par plusieurs moyen. Le plus simple étant d'utiliser des fonctions propre à votre système mais ce n'est pas la seul solution.
                                  Vous pouvez :

                                  • Vérifier l'état de la touche Entrer grâce à des fonctions propres à votre système.
                                  • Faire de la programmation évènementielle grâce à des fonctions propres à votre système.
                                  • Utiliser le multithreading afin de gérer plusieurs threads et donc de gérer l'appuie d'une touche grâce à un thread enfant.


                                  Il est claire que la première solution est la plus simple. Je vous laisse chercher les informations pour ce niveau, mais généralement vous trouverez très facilement grâce à votre moteur de recherche préféré. Il serait intéressant de se renseigner sur les différentes manières proposé. Ce serrait intéressant de voir certaines personnes se penchées sur les 2 dernières méthodes qui ont été proposées ou même de réaliser ce programme par une autre méthode encore.
                                  Vous aurez dans tous les cas certainement besoin d'une fonction permettant d'attendre un certain temps. Pour cela, il n'existe pas de fonction portable vous pouvez :

                                  • Sous Windows : Inclure windows.h et utiliser la fonction

                                  Sleep() (avec une majuscule) Sous Linux : Inclure unistd.h et utiliser la fonction sleep() .Sous Mac : ?? Peut-être la même chose que pour linux. </ul>

                                  Sur ce, bonne chance ;) .

                                  @che


                                  Citation : GuilOooo

                                  zSpeed



                                  Le défi de la semaine (si vous l'acceptez :p ) sera de de créer des statistiques sur votre vitesse de frappe. Vous pouvez d’ores et déjà vous renseigner sur l'unité <acronym title="Mot Par Minute">mpm</acronym> mais nous n'allons pas nous arrêter simplement à ce calcul. Attention : pour abréger les explications de cet exercice, nous nous baserons sur l'exercice précédent, mais vous pouvez directement faire zSpeed sans avoir codé le Chronomètre.

                                  Niveau 1 :
                                  Nous allons simplement reprendre le code de l'exercice précédent (Niveau 1 de "Un Chronomètre") et changer getchar() par un scanf(), qui lira une phrase librement entrée par l'utilisateur. Nous la traiterons alors ; par exemple :

                                  Entrez un texte (Max 200 caractères)
                                  J'irais par la foret, j'irais par la montagne, je ne puis demeurer loin de toi plus longtemps.
                                  -----
                                  Ce texte contient :
                                  19 mots
                                  95 caractères
                                  Vous avez tapé ce texte en 20 secondes, soit 6.33 mots/min et 31.66 car/min.



                                  Il vous faudra compter le nombre de caractères (voir strlen()) et le nombre de mots dans la chaine.
                                  Là est tout le sel de l'exercice. Une méthode plutôt simple est de compter le nombre d'espaces et d'ajouter 1. Mais en vérité, cette méthode n'est pas exacte, elle ne compte pas les contractions telles que « J'irai » que vous devriez gérer correctement. Ainsi, pour compter le nombre de mots, vous devez compter le nombre d'espaces et d’apostrophes, puis ensuite ajouter 1.

                                  Enfin, il vous suffira de faire une division par le temps obtenu au chronomètre pour obtenir les statistiques.
                                  level complete :)

                                  Niveau 2 :
                                  Ce niveau comporte de nombreuses améliorations. Cette fois-ci, nous allons demander à l'utilisateur d'entrer une phrase prédéfinie. Exemple :

                                  Entrez ce texte : "J'irai par la forêt, j'irai par la montagne, je ne puis demeurer loin de toi plus longtemps." 
                                  
                                  J'irai par la forêt, j'irai par la montagne, je ne puis demeurer loin de toi plus longtemps.
                                  -----
                                  Vous avez tapé 19 mots, 95 caractères au total, en 20 secondes ; soit 6.33m ots/min et 31.66 car/min.



                                  Nous n'allons pas nous arrêter à cela. Il faut maintenant vous assurer que votre saisie de chaîne est sécurisée. Plus question d'avoir une segfault ou une limite de caractères. La solution la plus simple est de ne plus stocker la chaîne, mais d'utiliser getchar() en boucle par exemple.

                                  Autre idée : ne demandez pas à taper toujours le même texte ! Ayez plusieurs textes prédéfinis et choisissez-en un au hasard.
                                  Pour utiliser l'aléatoire, vous pouvez le tuto du sdz à ce sujet.
                                  Sachez juste que vous aurez besoin des fonctions rand() et srand().

                                  Petit plus : vous pouvez stocker la liste des textes proposés par le programme dans un fichier. Vos utilisateurs pourront ainsi facilement rajouter les leur. Vous pourriez également sauvegarder les statistiques dans un fichier personnalisé. :)
                                  Afin de réaliser ce point, vous pouvez relire le tuto de M@teo21. ;)

                                  Dernière amélioration : les plus attentifs auront remarqué que je ne parle plus de « phrase » mais bien de « texte ». Vous devez demander que l'utilisateur tape des textes complets et plus uniquement des phrases.
                                  Exemple :

                                  Entrez ce texte : "Demain, dès l'aube, à l'heure où blanchit la campagne,
                                  Je partirai. Vois-tu, je sais que tu m'attends.
                                  J'irai par la foret, j'irai par la montagne.
                                  Je ne puis demeurer loin de toi plus longtemps." :
                                  
                                  Demain, dès l'aube, à l'heure où blanchit la campagne,
                                  Je partirai. Vois-tu, je sais que tu m'attends.
                                  J'irai par la foret, j'irai par la montagne.
                                  Je ne puis demeurer loin de toi plus longtemps.
                                  
                                  -----
                                  Vous avez tapez :
                                  // ...



                                  Niveau 3 :
                                  Il n'y a qu'une amélioration de taille par rapport au précédent niveau. :p

                                  Qui vous dit que l'utilisateur va entrer la phrase que vous avez demandé ?
                                  Désormais, vous devrez afficher le nombre d'erreurs de l'utilisateur ainsi que la localisation de ces erreurs :

                                  Entrez ce texte : "J'irai par la forêt, j'irai par la montagne, je ne puis demeurer loin de toi plus longtemps." 
                                  
                                  J'irai par l forêt, j'irai par le montagne, jene puis demeurer loin de toi plus longtemps.
                                  -----
                                  Attention : Erreurs 
                                  "par l foret"
                                  "par le montagne"
                                  "montagne, jene puis"
                                  -----
                                  Vous avez tapé : 18 mots pour un total de 93 caracteres, en 20 secondes ; soit 6 mots/min et 31 car/min.




                                  Si vous avez terminé tout ça, vous pouvez toujours rajouter 2-3 plus comme le 's' de "mots" à ne pas mettre s'il n'a tapé qu'un seul mot. Même chose pour le nombre de caractères.

                                  Bonne chance à tous, je vous laisse vous amuser à définir vos propres phrases. Soyez inventifs ! ;)

                                  @che, modifié par GuilOooo


                                  Citation : GuilOooo

                                  Un téléchargement bien ennuyeux



                                  Bonjour à tous !

                                  Non non, cet exercice ne concernera pas le réseau. :)

                                  Mise en situation



                                  La situation est la suivante : vous disposez d'une liste de villes, reliées entre elles par des câbles réseau. Si deux villes sont reliées, vous pouvez envoyer des de méga-octets de l'une à l'autre. Mais attention aux quotas ! France télécom, le propriétaire des câbles, vous impose une limite sur le nombre maximal de méga-octets qui peuvent circuler sur chacune des lignes.

                                  Vous souhaitez faire un backup des données qui se situent sur votre serveur, dans l'une des villes, vers un centre de backup, qui est bien entendu éloigné. Vous devez donc trouver comment faire passer les données dans les différents câbles afin d'en rapatrier un maximum !

                                  Exemple de situation.

                                  Liste des villes : Paris, Marseille, Lyon, Toulouse, Nice, Nantes, Strasbourg, Montpellier.
                                  
                                  Liste des câbles :
                                  Paris Lyon 20 Mo
                                  Paris Strasbourg 20 Mo
                                  Paris Nantes 20 Mo
                                  Paris Lille 25 Mo
                                  Paris Toulouse 5 Mo
                                  Strasbourg Lyon 10 Mo
                                  Lyon Marseille 30 Mo
                                  Marseille Montpellier 30 Mo
                                  Montpellier Toulouse 30 Mo
                                  Toulouse Nantes 30 Mo
                                  Nantes Lille 10 Mo
                                  Lille Strasbourg 35 Mo
                                  
                                  Envoyer depuis TOULOUSE vers STRASBOURG.



                                  Graphe pondéré des 8 plus grandes villes de France



                                  Une solution possible pour cette carte est :

                                  On peut envoyer au mieux 65 Mo.
                                  Il faut découper les données en cinq paquets de 5 Mo, 10 Mo, 10 Mo, 20 Mo, 20 Mo.
                                  Les répartir comme ceci :
                                  
                                  (10 Mo) Toulouse -> Montpellier -> Marseille -> Lyon -> Strasbourg (10 Mo)
                                  /* Le câble Lyon -> Strasbourg est maintenant saturé, on passe par Paris */
                                  
                                  (20 Mo) Toulouse -> Montpellier -> Marseille -> Lyon -> Paris -> Strasbourg (20 Mo)
                                   /* Le câble Toulouse -> Montpellier est maintenant saturé, on passe par Paris */
                                  
                                  (5 Mo) Toulouse -> Paris -> Lille -> Strasbourg (5 Mo)
                                  /* Le câble Toulouse -> Paris est maintenant saturé, on passe par Nantes */
                                  
                                  (20 Mo) Toulouse -> Nantes -> Paris -> Lille -> Strasbourg (20 Mo)
                                  /* Le câble Nantes -> Paris est maintenant saturé, on passe par Lille */
                                  
                                  (10 Mo) Toulouse -> Nantes -> Lille -> Strasbourg (10 Mo)
                                  /* Le câble Toulouse -> Nantes est saturé, plus aucun câble ne part de Toulouse. */



                                  Il se trouve que tous les câbles de la carte sont occupés à fond, nous ne pouvons donc pas faire mieux !

                                  Énoncé



                                  Écrivez un programme qui, étant donné une liste de villes, une liste de câbles, un point de départ et un point d'arrivée, vous donne la meilleure solution pour transférer un maximum de données.

                                  Niveau 1

                                  L'utilisateur entre le nombre de villes sur une ligne, puis entre les valeurs des câbles sous forme de tableau à deux dimensions. Vient ensuite le numéro de la ville de départ, puis celui de la ville d'arrivée. Par exemple, pour la situation précédente :

                                  8
                                  0  25 20 20 5  20 0  0
                                  25 0  35 0  0  10 0  0
                                  20 35 0  10 0  0  0  0
                                  20 10 0  0  0  0  30 0
                                  5  0  0  0  0  30 0  30
                                  20 10 0  0  30 0  0  0
                                  0  0  0  30 0  0  0  30
                                  0  0  0  0  30 0  30 0
                                  5 3



                                  Dans l'ordre des lignes et des colonnes : Paris Lille Strasbourg Lyon Toulouse Nantes Marseille Montpellier.

                                  La sortie doit être la quantité maximale de données qui a pu être transférée :

                                  65



                                  Niveau 2

                                  Cette fois-ci, l'entrée est la même, mais les noms des villes sont indiqués avant la matrice, séparés par des espaces.
                                  Exemple :

                                  8
                                  Paris Lille Strasbourg Lyon Toulouse Nantes Marseille Montpellier
                                  0  25 20 20 5  20 0  0
                                  25 0  35 0  0  10 0  0
                                  20 35 0  10 0  0  0  0
                                  20 10 0  0  0  0  30 0
                                  5  0  0  0  0  30 0  30
                                  20 10 0  0  30 0  0  0
                                  0  0  0  30 0  0  0  30
                                  0  0  0  0  30 0  30 0



                                  Et la sortie doit être la liste des chemins empruntés :

                                  Toulouse -> Montpellier -> Marseille -> Lyon -> Strasbourg 10 Mo
                                  Toulouse -> Montpellier -> Marseille -> Lyon -> Paris -> Strasbourg 20 Mo
                                  Toulouse -> Paris -> Lille -> Strasbourg 5 Mo
                                  Toulouse -> Nantes -> Paris -> Lille -> Strasbourg 20 Mo
                                  Toulouse -> Nantes -> Lille -> Strasbourg 10 Mo
                                  Total : 65 Mo



                                  Niveau 3

                                  Dans ce niveau, l'entrée et la sortie sont les mêmes qu'au niveau 2.

                                  Simplement, votre mission, si vous l'acceptez, est de développer un programme rapide, capable de traiter en un temps raisonnable des cartes bien plus denses.

                                  Pour cela, plutôt que de faire un brute-force sur les possibilités - ou tout autre algorithme de votre inv

                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                  J'ai déménagé sur Zeste de savoir — Ex-manager des modérateurs.
                                    31 août 2011 à 22:46:47


                                    Citation : GuilOooo

                                    Un voyageur près de ses sous



                                    Bonjour tout le monde ! :)

                                    Aujourd'hui, nous allons nous attaquer à un problème bien connu : le problème du voyageur de commerce.

                                    Mise en situation



                                    Vous êtes un représentant de commerce qui souhaite visiter un certain nombre de villes d'Europe¹. Vous disposez d'un jet privé prêté par votre compagnie, mais chaque kilomètre parcouru coûte de l'argent. Vous souhaitez donc visiter chaque grande ville d'Europe, en faisant le moins de kilomètres possible. De plus, vous ne voulez pas repasser deux fois dans une même ville, car vous avez déjà vendu tout ce que vous pouviez la première fois. La seule exception à cette règle est que vous devez finir votre périple dans la ville d'où vous êtes partis, car vous voudriez bien rentrer chez vous à la fin du voyage !

                                    ¹ Toutes mes excuses à nos amis d'outre-mer. Ils peuvent bien entendu librement adapter cet énoncé à leur localité. :)


                                    Énoncé



                                    Niveau 1

                                    Écrivez un programme qui lit sur la console un certain nombre de noms de ville, suivi des coordonnées de celle-ci sur la carte du monde. Le programme affiche alors la liste des villes dans l'ordre où vous devriez les parcourir, ainsi que la longueur totale du trajet.

                                    Entrée :
                                    ModoVille 0.00 0.00
                                    NewserCity 1.00 1.00
                                    BourgValido 0.00 1.00
                                    StAdmin 1.00 0.00
                                    
                                    Sortie :
                                    ModoVille -> BourgValido -> NewserCity -> StAdmin -> ModoVille
                                    Total 4km.



                                    Indication : pour calculer la distance entre deux villes, on peut utiliser la formule <math>\(\sqrt{(x_1-x_2)^2 + (y_1-y_2)^2}\)</math>.

                                    Niveau 2

                                    SDL : faites une interface graphique ! L'utilisateur peut alors placer des villes à la souris dans une fenêtre, puis demander le calcul du plus court trajet en appuyant sur une touche. Le chemin à parcourir sera représenté par des segments de droite.

                                    Niveau 3

                                    Algorithmie : votre compagnie est très pressée que vous visitiez toutes les villes. Elle a envie que vous partiez le plus rapidement possible, quitte à y mettre un peu plus de moyens. Vous devez donc écrire un programme plus rapide et plus efficace qu'un simple brute-force, mais vous avez le droit de faire des approximations.

                                    La contrainte est que le trajet que vous proposez ne doit pas être plus de deux fois plus long que le meilleur trajet possible !

                                    Conclusion



                                    Il s'agit d'un projet qui peut se révéler relativement simple (si vous faites un brute-force) ou totalement diabolique (si vous tentez les meilleurs algorithmes connus) ! Il devrait donc y en avoir pour tous les goûts. :)

                                    Encore une fois, n'hésitez pas à chercher des informations supplémentaires sur le Web !

                                    Bon courage et bonne chance à tous. :)

                                    GuilOooo


                                    Citation : GuilOooo

                                    Des sudokus en folie !



                                    Salut,

                                    Aujourd'hui, nous voyons un exercice archi-classique.

                                    Mise en situation



                                    Il n'est plus besoin de présenter le célèbre jeu de Sudoku.
                                    Nous allons créer un programme en console capable de résoudre des grilles de Sudoku, en utilisant des méthodes de plus en plus évoluées.

                                    Énoncé



                                    Votre programme lira, sur l'entrée standard, une grille incomplète de Sudoku 9×9, avec 9 cases par ligne. Les chiffres sont écrits tels quels, et les cases blanches sont représentées par des espaces.

                                    Exemple :

                                    23456789
                                    789 23456
                                    456789 23
                                    3456789 2
                                    9 2345678
                                    6789 2345
                                    56789 234
                                    23456789 
                                    89 234567



                                    Vous devez alors afficher le même sudoku, complété (si la solution existe).

                                    Exemple :

                                    123456789
                                    789123456
                                    456789123
                                    345678912
                                    912345678
                                    678912345
                                    567891234
                                    234567891
                                    891234567




                                    Les sudokus auront tous une taille 9×9. Vous pouvez donc raisonnablement utiliser un brute-force. Il existe des algorithmes plus fins pour la résolution, utilisez la méthode que vous sentez le mieux ! :)

                                    Niveau 1 :

                                    Pour le niveau le plus simple, contentez-vous de résoudre la grille de la façon qui vous plaît le mieux. Un simple brute-force suffit. :)

                                    Niveau 2 :

                                    Ici, nous allons un peu corser les choses. Le but sera maintenant de résoudre le sudoku par une méthode plus efficace, impliquant le backtracking. Yoch, membre habitué de ce forum, a écrit un tutoriel à ce sujet. Le but est donc de lire et comprendre la méthode, mais pas les codes sources. Le but est de les récrire vous-mêmes, sans lire ce qui existe déjà.

                                    Vous pouvez également vous renseigner au sujet du backtracking sur Wikipédia, ou partout ailleurs sur le web. :)

                                    Niveau 3 :

                                    Pour ce dernier niveau, il vous est demandé de faire une résolution pas à pas. À chaque étape, vous devez remplir une seule case libre de la grille, en expliquant pourquoi. Votre explication n'a cependant pas besoin d'être très détaillée. ;)

                                    Conclusion



                                    Les Sudokus ont déjà fait l'objet de nombreux exercices, mais j'ose espérer que certains d'entre vous ne l'auront jamais codé. :)

                                    Bon courage à tous !
                                    GuilOooo



                                    Citation : GuilOooo

                                    Perdus dans le labyrinthe du Minotaure !



                                    Encore un grand classique. :)

                                    Mise en situation



                                    Vous devez traverser le labyrinthe du redoutable minotaure. Par chance, vous disposez du plan des lieux, et l'horrible créature est partie faire ses courses ! Vous n'avez donc pas de temps à perdre. Il vous faut trouver le chemin permettant de sortir, le plus vite possible !

                                    Le but de cet exercice, comme vous l'aurez compris, est de créer un programme en console capable de résoudre un labyrinthe.
                                    Pour cela, nous allons implémenter un algorithme connu.

                                    Énoncé



                                    Lorsque le programme est lancé, il lit dans la console les dimensions (hauteur, largeur) du labyrinthe. Il lit ensuite le labyrinthe lui-même, formes de caractères ' ' (espace = vide) et '#' (dièze = mur).La case la plus en haut à gauche est le point de départ, la case la plus en bas à droite est la sortie.

                                    Exemple :

                                    8 11
                                     #######
                                     #     #
                                     # ### #
                                       #   #
                                    ##### ##
                                    #      #
                                    # ### ##
                                    #   #  #
                                    #  #####
                                    #      #
                                    ######



                                    Vous devez alors afficher une solution pour le labyrinthe. Deux possibilités pour l'affichage :

                                    • afficher une suite de directions,
                                    • afficher le labyrinthe en marquant le chemin.



                                    Exemple :

                                    .#######
                                    .#.....#
                                    .#.###.#
                                    ...# ..#
                                    #####.##
                                    #..... #
                                    #.### ##
                                    #.  #  #
                                    #. #####
                                    #......#
                                    ######..
                                    
                                    Ou
                                    
                                    Bas,Bas,Bas,Droite,Droite,Haut,Haut,Droite,Droite,Droite,Droite,Bas,Bas,Gauche,Bas,Bas,
                                    Gauche,Gauche,Gauche,Gauche,Bas,Bas,Bas,Bas,Droite,Droite,Droite,Droite,Droite,Bas,Droite.



                                    Niveau 1 :

                                    Résolvez le labyrinthe comme indiqué, en utilisant la méthode de votre choix. Un brute-force est envisageable. :)


                                    Niveau 2 :

                                    Cette fois-ci, vous devriez résoudre le labyrinthe en utilisant une méthode type backtracking. L'idée est la suivante : plutôt que d'énumérer tous les chemins possibles, essayez de choisir, en chaque instant, la « meilleure » case parmi nos voisines (le sens de « meilleure » étant à déterminer par vous :) ). Si vous ne trouvez pas la solution, passez par une case un peu moins bonne, et ainsi de suite jusqu'à trouver la sortie.

                                    Niveau 3 :

                                    Plus costaud : résolvez le labyrinthe en utilisant l'algorithme de Dijkstra. Il existe un tutoriel concernant cet algorithme sur le site, je vous laisse le découvrir. :)


                                    Conclusion



                                    Si vous souhaitez aller plus loin, vous pouvez modifier votre code afin qu'il fonctionne sur n'importe quel graphe, et plus simplement sur des labyrinthes à cases.

                                    Bon courage à tous ! :)

                                    GuilOooo


                                    Citation : GuilOooo

                                    La recheche en génétique



                                    Bonjour bonjour ! :)

                                    Aujourd'hui, nous allons recoder la fonction strstr.

                                    Mise en situation



                                    La recherche en génétique progresse chaque jour. Elle a déjà donné d'excellents résultats, et continue d'être active. Seulement, la quantité d'informations contenue dans un brin d'ADN est simplement énorme... Il est donc logique de la traiter par ordinateur !

                                    Les séquences ADN peuvent être représentées par un alphabet de quatre lettres : A, T, G ,C. Pour connaître la signification de ces lettres, je vous invite à consulter la page wikipédia concernant l'ADN. Une opération courante dans le domaine est la recherche d'un gène (qui sera ici une séquence de lettres) dans une séquence ADN bien plus grande.

                                    Nous allons donc coder un programme capable de retrouver une sous-chaîne dans un texte !

                                    Énoncé



                                    Écrivez un programme qui lit un gène sur la première ligne, une séquence ADN sur la deuxième, puis qui donne l'indice ou démarre le gène dans la séquence.

                                    Exemple :

                                    ATGC
                                    ATTGGCCTATGCGGA



                                    En sortie :

                                    9



                                    Niveau 1

                                    Écrivez le programme de recherche en utilisant l'algorithme le plus simple. Bien entendu, il est interdit de recourir à la fonction strstr, le but est que vous la fassiez vous-mêmes. :)

                                    Niveau 2

                                    Améliorez votre programme de recherche pour qu'il utilise l'algorithme de Rabin-Karp. L'idée est la suivante : nous allons représenter chaque lettre par un chiffre. Par exemple, A=0, T=1, G=2 et C=3. Nous pouvons alors écrire un gène, tel que ATGC, comme un nombre entier, qui vaut 123.

                                    Pour chercher le gène, il suffit de prendre les 4 premiers caractères de la séquence, d'opérer la même conversion, puis de comparer les résultats. Il nous faut ensuite convertir les caractères 2 à 5 de la séquence, et comparer à nouveau... Mais, lorsque nous avons converti les caractères 1 à 4 tout à l'heure, nous avons en particulier converti les caractères 2 à 4 en entiers ! N'y a-t-il pas moyen d'en profiter ?

                                    Reprenons l'exemple précédent pour nous fixer les idées. Au premier tour, de boucle, la situation était :

                                    0123
                                    0112GCCTATGCGGA



                                    Comme 123 et 112 sont différents, le gène n'est pas en position 1. Nous nous décalons donc d'une case dans la séquence :

                                    _0123
                                    A1122CCTATGCGGA



                                    Donc, sachant que la séquence actuelle vaut 0112, et que le prochain caractère sera associé au nombre « 2 », comment en déduire que le prochain entier à comparer sera 1122 ?

                                    Niveau 3

                                    Le code précédent constitue une bonne amélioration de la recherche naïve codée au niveau 1. Cependant, nous sommes limités par la taille des entiers que nous pouvons manipuler ! En effet, comme vous le savez sûrement, une variable de type int ou long comporte une limite de grandeur pour les entiers stockés. Cette limite maximale varie selon la machine ; vous pouvez l'afficher grâce au code suivant.

                                    #include <limits.h>
                                    
                                    int main(void)
                                    {
                                        printf("%ul\n", ULONG_MAX);
                                        return 0;
                                    }
                                    



                                    Ainsi, nous ne pouvons pas rechercher des gènes arbitrairement longs ! Il faut que leur « version numérique » tienne dans un long (ou autre type que vous aurez choisi). Nous avons deux solutions pour pallier à ce problème.

                                    La première est d'utiliser un type de données capables de manipuler des nombres arbitrairement grands. L'objet de l'un des exercices du forum est d'écrire un tel type, vous pouvez donc le réutiliser si ça vous amuse. :)
                                    Cependant, les opérations sur de grands nombres sont relativement lentes, et nous perdrions le bonus en rapidité que nous fait gagner l'algorithme de Rabin-Karp.

                                    La seconde solution est d'utiliser un hash. L'idée est la suivante : nous allons appliquer un modulo au gène et au bloc à tester. Notez que ceci ne modifie en rien l'astuce du niveau 2 : elle fonctionne toujours. :)

                                    En revanche, lorsque nous trouverons deux nombres égaux, ne ne seront plus complètement sûrs que les gènes correspondants le sont bien aussi (du fait du modulo). Il devient donc nécessaire de faire une comparaison textuelle en cas d'égalité. Par contre, si les deux nombres trouvés sont différents, les deux séquences sont nécessairement différentes, et il n'y a plus besoin de test (ce qui est un peu l'intérêt quand même).

                                    Conclusion



                                    À l'issue de cet exercice, nous avons implémenté un algorithme efficace de recherche de sous-chaîne, qui évite « souvent » les comparaisons inutiles.

                                    Il existe encore de nombreuses autres méthodes pour pour rechercher efficacement une sous-chaîne dans une chaîne. Vous pensiez que l'exercice de M@teo21 était fini, enterré, oublié ? Vous avez pourtant de quoi vous amuser encore longtemps... :diable:

                                    Bon courage à tous ! :)

                                    GuilOooo


                                    Citation : GuilOooo

                                    Un correcteur orthographique efficace



                                    Bonjour les zéros ! :)

                                    Mise en situation



                                    Aujourd'hui, nous allons programmer un correcteur orthographique. Il existe de nombreuses techniques pour y parvenir, nous en explorerons quelques unes au cours des trois niveaux que cet exercice propose. :)

                                    Un correcteur orthographique, pour nous, sera un programme qui diposera d'un dictionnaire (liste de mots) et d'une entrée (chaîne de caractères arbitraire). Le correcteur vérifie que chaque mot de l'entrée est bien dans le dictionnaire. Les mots sont définis comme les séquences de caractères alphabétiques (minuscules ou majuscules), séparés par tout autre caractère (ponctuation, espaces, etc).

                                    Énoncé



                                    Écrivez un programme de correction orthographique. Le dictionnaire sera stocké dans un fichier externe, et l'entrée sera l'entrée standard (dans la console). La liste des mots incorrects rencontrés sera affichée sur la sortie standard (dans la console).

                                    Niveau 1

                                    Pour ce niveau, le dictionnaire sera donné sous forme d'un fichier texte, avec un mot par ligne. Allez, au boulot ! :)

                                    Niveau 2

                                    Essayons un peu plus corsé. Notre correcteur actuel fonctionne correctement (enfin, il devrait ^^ ) mais n'est pas très rapide. En outre, le dictionnaire peut prendre une place assez conséquente...

                                    Les filtres de bloom peuvent nous aider à résoudre ce problème. L'idée est la suivante : nous allons trouver un certain nombre de fonctions de hachage, qui, à chaque chaîne de caractère, renvoie un nombre entre 0 et 100. Pour cet exemple, nous coderons quatre fonctions de hachage différentes.

                                    Notre dictionnaire prendra alors la forme d'un tableau de 100 bits, qui sera initialisé à 00000000...000. Pour ajouter le mot « ciboulette », nous le faisons passer par les fonctions de hachage ; imaginons que nous obtenions les résultats 23, 27, 48 et 62. Il suffit alors de mettre les bits numéros 23, 27, 48 et 62 à « 1 » dans notre tableau.

                                    Pour tester si un mot donné est dans le dico, il suffit de le faire passer par les fonctions de hachage, et de vérifier que les bits correspondants sont bien à 1 dans le filtre.

                                    La particularité du filtre de bloom est qu'il peut se tromper ! En effet, 100, 1000 ou même 1 000 000 bits d'information ne permettent pas de stocker un dictionnaire de la langue française complètement. Il arrive donc qu'un mot ait des hashs dont les bits sont tous activés par d'autres mots.



                                    Dans la pratique, ce n'est cependant pas très grave. En effet, en prenant un filtre plus grand et en choisissant correctement le nombre et le code des fonctions de hachage, on peut minimiser la probabilité d'erreur (qu'on appelle un « faux positif »). Le choix de ces paramètres est quelque peu délicat ; nous ferons au plus simple ici.

                                    Votre mission est donc de modifier votre correcteur orthographique pour qu'il utilise un filtre de bloom. N'oubliez pas la possibilité de stocker le filtre dans un fichier. Vous aurez aussi besoin d'un moyen de créer le filtre à partir d'une liste de mots !

                                    Quelle fonction de hachage choisir ?



                                    Il y en a plein ! Une chaîne de caractères est basiquement une suite de nombre. Il suffit d'effectuer une opération sur ces nombres, par exemple la somme, le produit, ou je ne sais quoi encore, puis d'appliquer un modulo. Dans notre exemple, le résultat devra subir un modulo 100. Quelques idées :

                                    • somme des codes ascii de chaque caractère ;
                                    • produit des codes ascii de chaque caractère ;
                                    • concaténation des codes (par exemple, 13 37 65 42 donnera 13037065042) ;
                                    • somme des codes ascii élevés au carré ;
                                    • puissance successive des codes ascii ;
                                    • xor (ou exclusif) des codes ascii....


                                    Ce ne sont pas les possibilités qui manquent ! N'oubliez pas le modulo 100 à la fin. :)

                                    Niveau 3

                                    Dans ce niveau, nous allons faire quelque chose de légèrement différent.

                                    Imaginons que nous ayons détecté un mot erroné. Nous voulons allons fournir quelques suggestions pour la bonne orthographe de ce mot.

                                    Vous allez donc écrire un programme qui, étant donné un mot, trouve le mot du dictionnaire le plus proche de celui-ci. Bien évidemment, il faudra travailler sur le dictionnaire in extenso, un filtre de bloom ne vous permettra pas de récupérer cette information. :)

                                    Toute la difficulté est donc de calculer la « distance » entre deux mots. Voici plusieurs idées possibles :

                                    • calculer la longueur du plus grand préfixe commun ;
                                    • calculer le nombre de lettres qui diffèrent dans le mot ;
                                    • calculer le nombre d'opérations (insertion/suppression/substitution) minimal nécessaires pour passer d'un mot à l'autre.


                                    À vous de choisir celle que vous préférez. Il vous faut ensuite trouver le(s) mot(s) du dico dont la distance à votre mot est la plus petite, et les afficher.

                                    Conclusion



                                    Vous pourrez bien entendu réutiliser toutes ces techniques dans d'autre contexte qu'un correcteur orthographique.

                                    Amusez-vous bien ! :)

                                    GuilOooo


                                    Citation : GuilOooo

                                    Le mini moteur SQL



                                    Le but du projet est de réaliser un mini Système de Gestion de Bases de Données, capable de répondre à des requêtes SQL très simplistes.

                                    Les données


                                    Les données seront stockées ainsi :

                                    • un dossier par base,
                                    • un fichier par table,
                                    • une ligne par entrée,
                                    • les champs sont séparés par des virgules.


                                    Les données ne peuvent être que des suites de caractères alphanumériques. En particulier, les valeurs ne contiennent jamais d'espaces ou de symboles de ponctuation. La première ligne du fichier indique les noms des colonnes de la table, séparés par des virgules également.

                                    Exemple :

                                    nom,prenom,job,ville
                                    Jean,Dupont,Conseiller,Dijon
                                    Vincent,Vega,Gangster,LosAngeles
                                    Scott,McKenzie,Chanteur,SanFransisco



                                    Les requêtes


                                    Les requêtes seront tapées par l'utilisateur dans la console. Il y aura une requête par ligne, et chaque requête fera 200 caractères (fin de ligne et \0 compris) au maximum. Tout le programme est sensible à la casse (majuscules/minuscules).

                                    Votre programme doit pouvoir répondre à trois types de requête. Le type de la requête est déterminé par le premier mot de celle-ci :

                                    • SELECT {colonne} FROM {table} WHERE {colonne}{opérateur}{colonne}
                                    • INSERT INTO {table} VALUES {valeur},{valeur},{valeur},...
                                    • ALTER TABLE <table> SET {colonne}={valeur} WHERE {colonne}{opérateur}{colonne}


                                    Où :

                                    • {table} est le nom du fichier de données que l'on manipule,
                                    • {colonne} est le nom d'une colonne de ce fichier,
                                    • {valeur} est une suite de caractères alphanumériques,
                                    • {opérateur} est l'un des caractères = > < !


                                    Exemples de requêtes:

                                    SELECT nom FROM personnel WHERE age=42
                                    INSERT INTO livres VALUES candide,volaire
                                    ALTER TABLE articles SET prix=10 WHERE promotion=1
                                    



                                    Lorsque l'utilisateur tape une commande de type SELECT, votre moteur doitparcourir le fichier indiqué après FROM, et afficher le contenu de la colonne indiquée après SELECT si la condition après le WHERE est vérifiée.

                                    Lorsqu'il entre une commande INSERT INTO, il faut insérer une nouvelle ligne dans la table donnée après INTO, contenant les valeurs données après VALUES.

                                    Enfin, plus difficile, lorque l'utilisateur entre une commande ALTER TABLE, toutes les lignes du fichier indiqué après TABLE qui vérifient la condition du WHERE doivent être modifiées comme indiqué après le SET.

                                    Les vérifications


                                    L'intérêt d'un tel programme est qu'il ne doit surtout pas faire n'importe quoi ! Par exemple, si, dans une requête, on fait référence à une colonne inexistante, vous ne devez surtout rien faire et afficher un message d'erreur. D'une façon générale, toute requête dépourvue de sens, ne respectant pas la syntaxe, ou, de façon générale incorrecte, doit renvoyer un message d'erreur.

                                    Énoncé


                                    Écrivez le programme implémentant ce mini-moteur de mini-SQL ! :)

                                    Il n'y a pas de « niveaux » pour cette fois-ci. Chacun peut aller à son rythme : vous pouvez n'implémenter que les deux premier types de requêtes (oublier ALTER), ou améliorer le programme jusqu'à supporter totalement le SQL !

                                    Bien entendu, il vous est interdit de recourir à SQLite ou une autre base de données. Le but est de tout refaire soi-même. :)

                                    Bon courage et bonne chance !

                                    GuilOooo
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                    J'ai déménagé sur Zeste de savoir — Ex-manager des modérateurs.
                                    Anonyme
                                      31 août 2011 à 22:54:56

                                      Je sens qu'on va bien rigoler. :)
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        31 août 2011 à 22:58:37

                                        Je le redis ici : C'est du beau boulot, un bon investissement et j'espère qu'il pourra être utile ! Tu as du y passer beaucoup de temps donc je pense qu'on peut tous te remercier. :)

                                        J'aime particulièrement le moteur SQL et le parseur mathématique. ;)

                                        Mais il faudra réfléchir à la manière de mettre en valeur ces exos sur le forum si on veut qu'ils puissent faire progresser les débutants.

                                        (Mes énoncés sont libres de tous droits).
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                        Bla bla bla
                                          31 août 2011 à 23:07:39

                                          Certains exos ont déjà été proposés comme je l'ai dit. :-°
                                          Le parseur mathématique il est là par exemple : http://www.siteduzero.com/forum-83-504 [...] html#r5357216
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                          Anonyme
                                            31 août 2011 à 23:09:38

                                            Pas grave, je pense pas que beaucoup de débutants aillent voir la bas, ça coute rien de le remettre ici.
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              1 septembre 2011 à 6:12:49

                                              Super travail GuilOooo !

                                              Je ferrais juste une petite remarque
                                              Je pense pour le correcteur Orthographique que le Niveau 3 mérites carrément 1 Exercice complet en effet, ça peut vite se corsé à ce niveau là et les méthodes de correction peuvent ce faire à différents niveau (en phonétique par exemple).
                                              Ça pourrait entrainer la création d'une nouvelle exercice non ?

                                              Tiens d'ailleurs linboss à publier un article à ce sujet ;)
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                              🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                                                1 septembre 2011 à 9:03:06

                                                Les énoncés sont beaucoup plus complets que ceux des exercices précédents ! Chapeau à tous ceux qui ont posté des exercices (GuilOoo le premier...), j'espère que ça va attirer du monde !
                                                Le premier exercice est prévu pour aujourd'hui ? Quelqu'un doit-il se charger de mettre en valeur un nouveau sujet ?
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                Staff désormais retraité.
                                                  1 septembre 2011 à 9:39:26

                                                  @GuilOooo : Bravo, supers beaux exos. :)

                                                  Par contre, il ne faudrait pas les enlever de ce topic car si certains font les exos à l'avance, c'est un peu bête.
                                                  Mais je viens d'y penser, c'est un peu tant pis pour ceux qu'ils les font à l'avance car ont les avaient quand même prévenu ! :p


                                                  Bref, pour quand la première sortie ?
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    1 septembre 2011 à 9:40:37

                                                    Citation : GuilOoo

                                                    Je les publie ce soir, pour que l'on commence le premier septembre (demain).

                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                    Staff désormais retraité.
                                                      1 septembre 2011 à 9:43:42

                                                      Ouais merci, mais je viens de voir que t'as quand même aussi posé la question, hein ! :D

                                                      Citation : toi

                                                      Le premier exercice est prévu pour aujourd'hui ? Quelqu'un doit-il se charger de mettre en valeur un nouveau sujet ?

                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        1 septembre 2011 à 9:52:42

                                                        C'était juste pour demander confirmation. :p
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                        Staff désormais retraité.
                                                          1 septembre 2011 à 9:59:35

                                                          ^^

                                                          Moi, il y a un exo que je crains relativement fortement, c'est celui du labyrinthe.
                                                          Ben ouais quoi, même après toutes mes tentatives, je n'ai jamais réussis à utiliser un vrai algo style A* ou Dijkstra... Mais un brute-force est envisageable. :)
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            1 septembre 2011 à 11:09:42

                                                            Je propose un patron pour créer un nouveau sujet. Un peu trop « kikoo » à mon goût, mais ça familiarise et ça attire du monde ! ^^

                                                            Titre : [Défis] Cette semaine, zMol, la chimie pour tous !
                                                            Sous-titre : Débutants, venez vous entraîner !

                                                            Bonjour à toutes et à tous les zéros !

                                                            Vous apprenez le langage C ? Vous souhaitez vous entraîner pour pouvoir vous améliorer ?



                                                            C'est votre jour de chance, vous êtes tombé sur le bon sujet ! :D
                                                            Cette semaine, nous vous proposons de créer zMol, un calculateur de masse molaire. Ne vous enfuyez pas en voyant ce titre un peu barbare, l'essentiel c'est de s'entraîner. Toutes les notions pré-requises et externes à la programmation seront expliquées. :)

                                                            Je suis débutant en langage C, quelles notions dois-je maîtriser pour réaliser ces défis ?



                                                            Afin de suivre, il est nécessaire d'avoir lu le tutoriel C de M@teo21, au moins les deux premières parties. La troisième partie sur la SDL est facultative, vu que nous n'en aurons pas besoin cette semaine. ;)

                                                            Où dois-je poster mon code ?



                                                            Vous pouvez poster votre code sur ce sujet, ce n'est qu'ici que l'on pourra vous aider à améliorer votre code. N'oubliez pas de le mettre entre les balises <secret><code type="c">/* Votre code ici */</code></secret>, ce qui permettra une lecture plus facile de celui-ci. ;)

                                                            Je ne supporte la critique et j'ai peur de me ridiculiser en postant mon code ici !



                                                            Pourtant, c'est la seule manière pour vous de progresser. :p Les commentaires qui vous permettront d'améliorer votre manière de programmer seront constructifs et ne jugeront pas votre personne ! ^^

                                                            Bien, voilà pour la petite introduction. On passe à l'énoncé ? :D
                                                            Il a été écrit par _Fender_, un grand merci à lui ! :)

                                                            zMol, la chimie pour tous !



                                                            Introduction



                                                            Aujourd'hui l'exercice sera de réaliser un calculateur de masse molaire. Cette notion de chimie n'est abordée qu'en classe de seconde générale, mais vous devriez vous en sortir même si vous êtes au collège, du moment que vous avez une bonne connaissance des molécules et des atomes.

                                                            Pour les non-initiés donc, il faut savoir que chaque atome a ce qu'on appelle une masse molaire atomique. Pour faire court, il s'agit de la masse que pèse une mole de cet atome (si vous êtes curieux, vous pouvez en apprendre plus sur les moles ici ! ;) ). Chaque molécule a une masse molaire moléculaire, que l'on obtient en faisant la somme de tous les masses molaires atomiques des atomes qui la composent.

                                                            L'unitée de la masse molaire est le <math>\(g.mol^-^1\)</math>.

                                                            Consignes



                                                            Le but de l'exercice est donc de réaliser un programme qui calcule la masse molaire d'une molécule entrée par l'utilisateur, et ce grâce à un fichier texte contenant certains atomes et leur masse molaire atomique correspondante.

                                                            Exemple :

                                                            Entrez une molécule :
                                                            --> CO2
                                                            
                                                            La masse molaire de cette molécule est 44.0090 g.mol-1


                                                            Je vous propose de commencer à travailler avec ce petit fichier texte, il sera amplement suffisant pour faire des tests et pour couvrir un bon nombre de molécules :

                                                            <secret>
                                                            C 12.011
                                                            O 15.999
                                                            H 1.0079
                                                            He 4.0026
                                                            Li 6.941
                                                            Cl 35.453
                                                            Na 22.989
                                                            </secret>

                                                            Objectifs



                                                            • Manipuler la lecture de fichiers.
                                                            • Apprendre à se servir de quelques fonctions de la bibliothèque standard.
                                                            • Apprendre (ou approfondir) une nouvelle notion en chimie.


                                                            Pistes de réflexion



                                                            Reconnaître un atome.

                                                            Vous pouvez remarquer que les symboles de certains atomes prennent un caractère et d'autres deux. ^^ Quand notre programme aura a analyser l'atome de chlore (Cl), par exemple, il ne faudra pas qu'il l'interprette comme un atome de carbone (C), et un atome l (inconnu au bataillon).

                                                            Heureusement, pour nous aider, une règle bien précise est que le deuxième caractère des symboles des atomes est toujours en minuscule, et le premier en majuscule. Pour cela, il va falloir utiliser les fonctions suivantes :

                                                            <secret>
                                                            int isupper(int c); // Teste si un caractère est majuscule
                                                            int islower(int c); // Teste si un caractère est minuscule
                                                            /* Ces deux fonctions sont définies dans <ctype.h> */
                                                            
                                                            </secret>

                                                            Bien sur, je ne vous donne là que quelques pistes, l'essentiel des recherches sur les problèmes que vous rencontrerez étant à faire par vous même (sinon, ça ne sert à rien). ;)

                                                            Enoncé



                                                            Niveau 1

                                                            Faire un programme qui gère uniquement une liste d'atomes de symbole n'ayant qu'un caractère, écrits les uns à la suite des autres :

                                                            <secret>
                                                            Entrez une molécule :
                                                            --> COO
                                                            
                                                            La masse molaire de cette molécule est 44.0090 g.mol-1
                                                            </secret>

                                                            Niveau 2

                                                            Cette fois, votre programme devra gérer les atomes dont le symbole fait plusieurs caractères.

                                                            <secret>
                                                            Entrez une molécule :
                                                            --> NaCl
                                                            
                                                            La masse molaire de cette molécule est 58.442000 g.mol-1
                                                            </secret>

                                                            Niveau 3

                                                            Votre programme devra gérer les coefficients. Pour tester si un caractère est un chiffre, vous devrez utiliser une fonction de la même famille que isupper et islower (à vous de chercher seul, cette fois ;) ).

                                                            La fonction strtol peut aussi vous être utile. ;)

                                                            <secret>
                                                            Entrez une molécule :
                                                            --> CO2
                                                            
                                                            La masse molaire de cette molécule est 44.0090 g.mol-1
                                                            </secret>

                                                            Niveau 4

                                                            Votre programme devra gérer les groupes qui se répètent plusieurs fois.

                                                            <secret>
                                                            Entrez une molécule :
                                                            --> (CH4)2
                                                            
                                                            La masse molaire de cette molécule est 32.085200 g.mol-1
                                                            </secret>

                                                            Niveau 5

                                                            Les scientifiques viennent de découvrir un tout nouvel atome !! ^^ Ajoutez à votre programme une fonction qui vous permettra d'ajouter un atome et sa masse molaire dans votre fichier. ;)

                                                            Et après... ?



                                                            Si vous réalisez les 5 niveaux, vous pouvez encore aller plus loin si vous le souhaitez !

                                                            Par exemple, vous pouvez décider d'afficher les étapes intermédiaires du calcul, etc... Votre imagination est votre seule limite ! ;)

                                                            Bon courage. ;)


                                                            Si il y a quelque chose que vous ne comprenez pas, n'hésitez pas à poser votre question sur ce sujet, nous vous répondrons avec plaisir ! :)


                                                            PS : si ça vous va, je peux toujours créer le sujet maintenant. ^^
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                            Staff désormais retraité.

                                                            Exercices pour débutants en C (suite)

                                                            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                            × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                            • Editeur
                                                            • Markdown