Partage
  • Partager sur Facebook
  • Partager sur Twitter

[FAIT][Défis] #1 : zMol, la chimie pour tous

Venez vous entraîner !

    2 septembre 2011 à 18:29:22

    imie-pour-tous.html#r7037206">Niveau 4 posons de créer zMol, un calculateur de masse molaire. N'ayez pas peur si vous ne savez pas ce que c'est : toutes les notions pré-requises et externes à la programmation seront expliquées.

    Si vous souhaitez plus de renseignements sur les défis, rendez vous sur le topic de recensement des défis, vous y trouverez également les règles principales.

    zMol, la chimie pour tous


    Cet exercice a été écrit par _Fender_, un grand merci à lui !

    Un calculateur de masse molaire ?


    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é 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 :

    C 12.011
    O 15.999
    H 1.0079
    He 4.0026
    Li 6.941
    Cl 35.453
    Na 22.989


    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 à 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 :

    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> */
    


    Bien sûr, 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 :

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


    Niveau 2

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

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


    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. ;)

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


    Niveau 4

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

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


    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... 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 ! :)


    Enfin, voici une liste de molécules avec leurs masses molaires correspondantes pour vous permettre d'effectuer vos tests. ;)


    Nom Formule Masse molaire Informations
    Monoxyde de carbone <math>\(CO\)</math> <math>\(28.01\)</math> Le monoxyde de carbone est un gaz incolore, inodore et toxique, première cause de décès par intoxication en France (environ une centaine de cas en 2006).
    Monoxyde de dicarbone <math>\(C_2O\)</math> <math>\(40.02\)</math> Le monoxyde de dicarbone est composé de deux atomes de carbone et d'un atome d'oxygène. Il appartient à la famille des oxydes de carbone.
    Benzène <math>\(C_6H_6\)</math> <math>\(78.11\)</math> Le benzène a autrefois été utilisé comme solvant industriel (jusqu'a ce que sa toxicité devienne génante). Il est encore utilisé aujourd'hui notamment dans l'essence pour éviter les risques de détonation.
    Acétone <math>\((CH_3)_2CO\)</math> <math>\(58.08\)</math> L'acétone est principalement utilisé comme dissolvant. Les chimistes l'apprécient également pour sa capacité à solubiliser de nombreuses espèces organiques.
    Dihydroxyacétone <math>\(CO(CH_2OH)_2\)</math> <math>\(90.08\)</math> Le dihydroxyacétone (DHA) est notamment utilisé en cosmétique dans la production d'autobronzants.



    Participants



    Participants Code
    Sabeurre zMol - niveau 5
    Armael zMol - niveau 5
    lucas-84 zMol - niveau 5
    Emmflo zMol - niveau 4
    yoch zMol - niveau 4
    Taurre zMol - niveau 5
    schadocalex zMol - niveau 5
    TWEESTY zMol - niveau 5
    _Fender_ zMol - niveau 5
    dark-lord zMol - niveau 5
    Pouet_forever zMol - niveau 5
    Kyron zMol - niveau 4
    informaticienzero zMol - niveau 2
    Shaddan zMol - niveau 5
    HighTam zMol - niveau 4
    kaka551 zMol - niveau 5
    Niveau 4 Niveau 4
    GurneyH Niveau 5
    paraze Niveau 2
    Maëlan Niveau 4
    Lebrian Niveau 5
    sydzero Niveau 4
    Alienore Niveau 5
    'Housenka Niveau 5
    stoads Niveau 1
    ?
    • Partager sur Facebook
    • Partager sur Twitter
      2 septembre 2011 à 18:34:08

      Bonne chance à tous, je posterai quelque chose de fonctionnel sans doute demain. ;)
      • Partager sur Facebook
      • Partager sur Twitter
      Staff désormais retraité.
        2 septembre 2011 à 18:53:36

        Pour le niveau 4, jusqu'où on peu aller dans les imbrications ?
        • Partager sur Facebook
        • Partager sur Twitter
          2 septembre 2011 à 19:50:56

          @Pouet_forever: Personnellement je me suis arrêté au texte que l'on voyais donc seulement (CH4)2.

          Les codes étant assez énormes, je ne poste que le niveau5:

          Main.c:

          #include <stdio.h>
          #include <stdlib.h>
          #include "fonction5.h"
          
          
          int main(int argc, char* argv[])
          {
              menu();
              
              argc = 0;
              argv = NULL;
              
              return 0;
          }
          



          Fonction5.c:

          #include <stdio.h>
          #include <stdlib.h>
          #include <string.h>
          #include <ctype.h>
          #include "fonction5.h"
          #include "element.h"
          
          void vider_buffer()
          {
              int c = 0;
              while (c != '\n' && c != EOF)
              {
                  c = getchar();
              }
          }
           
          int lire(char *chaine, int longueur)
          {
              char *positionEntree = NULL;
           
              if (fgets(chaine, longueur, stdin) != NULL)
              {
                  positionEntree = strchr(chaine, '\n');
                  
                  if (positionEntree != NULL)
                  {
                      *positionEntree = '\0';
                  }
                  else
                  {
                      vider_buffer();
                  }
                  
                  return 1;
              }
              
              else
              {
                  vider_buffer();
                  
                  return 0;
              }
          }
          
          
          /*Fonction pas standard, j'ai donc repris le code ici*/
          char * strndup (const char *s, size_t n)
          {
            char *result;
            size_t len = strlen (s);
          
            if (n < len)
              len = n;
          
            result = (char *) malloc (len + 1);
            if (!result)
              return 0;
          
            result[len] = '\0';
            return (char *) memcpy (result, s, len);
          } 
          
          /*Permet d'extraire une partie d'une chaine*/
          char *sub_str (char *src, int pos, int len)
          {
              return strndup(&src[pos], len);
          }
          
          /*Fonction qui vérifie si l'élément que l'on regarde existe dans la liste*/
          int search_tab(char* lettre, Element elem[], int nbelem)
          {
              int i = 0;
              
              for(i = 0; i < nbelem; i++)
              {
                  if(strcmp(lettre, elem[i].nom) == 0)
                  {
                      return i;
                  }
              }
              
              printf("Element %s non reconnu\n", lettre);
              return -1;
          }
          
          /*Fonction qui remplie le tableau de Element via un fichier qui contient les infos nécessaire*/
          int get_file(Element elem[])
          {
          
              int i = 0;
              FILE* fichier = fopen("rc/mol", "r+");
              if(!fichier)
              {
                  printf("Impossible d'ouvrir le fichier rc/mol\n");
                  exit(-1);
              }
              
              while(!feof(fichier))
              {
                  fscanf(fichier, "%s %lf\n", elem[i].nom, &elem[i].val);
                  i++;
              }
              fclose(fichier);
              
              return i;
          }
          
          double result(char* mol)
          {
              int i = 0;
              int a = 0;
              int j = 0;
              int coef = 1;
              int len = 0;
              int nbelem = 0;
              Element elem[112];
              double ret = 0.0;
              char test[3] = {0};
              char* parenthese = NULL;
              
              nbelem = get_file(elem);
              
              len = strlen(mol);
              while(i < len)
              {
                  /*Si la chaine contient une parenthèse fermante*/
                  if(strstr(mol, ")") != NULL)
                  {
                      parenthese = strstr(mol, ")");
                      /*On suppose qu'après la parenthèse se trouve le coefficient multiplicateur
                      strtol s'arrêtant au premier caractère non convertible, ça ne gène en rien*/
                      coef = strtol(parenthese+1, NULL, 10);
                      /*Extrait ce qu'il y a entre parenthèse et l'ajoute X fois au résultat selon le coefficient*/
                      parenthese = sub_str(mol, 0, parenthese-mol);
                      for(j = 0; j < coef; j++)
                      {
                          ret+=result(parenthese);
                      }
                      free(parenthese);
                      return ret;
                      
                  }
                  else
                  {
                      /*Pour les cas d'espèce chimique sur deux lettres et avec un coefficient*/
                      if(isupper(mol[i]) && islower(mol[i+1]) && isdigit(mol[i+2]))
                      {
                          test[0] = mol[i];
                          test[1] = mol[i+1];
                          a = search_tab(test, elem, nbelem);
                          elem[a].coeff = strtol(mol+(i+2), NULL, 10);
                          i+=3;
                      }
                      
                     
                      /*Une lettre avec coefficient*/
                      else if(isupper(mol[i]) && isdigit(mol[i+1]))
                      {
                          test[0] = mol[i];
                          test[1] = 0;
                          a = search_tab(test, elem, nbelem);
                          elem[a].coeff = strtol(mol+(i+1), NULL, 10);
                          i+=2;
                      }
                      
                      /*Deux lettres sans coefficient*/
                      else if(isupper(mol[i]) && islower(mol[i+1]))
                      {
                          test[0] = mol[i];
                          test[1] = mol[i+1];
                          a = search_tab(test, elem, nbelem);
                          elem[a].coeff = 1;
                          i+=2;
                      }
                      
                      /*Une lettre*/
                      else
                      {
                          test[0] = mol[i];
                          test[1] = 0;
                          a = search_tab(test, elem, nbelem);
                          elem[a].coeff = 1;
                          i++;
                      }
                      
                      /*Si l'espèce chimique est répertorié, on ajoute sa masse multipliée par le coefficient*/
                      if(a != -1)
                      {
                          ret+=elem[a].val*elem[a].coeff;
                      }
                  } 
              }
              
              return ret;
          }
          
          /*Fonction pour ajouter une espèce chimique, basique ^^*/
          void add(void)
          {
              char nom[4] = {0};
              double masse = 0.0;
              FILE* fichier = fopen("rc/mol", "r+");
              
              if(!fichier)
              {
                  printf("Impossible d'ouvrir le fichier rc/mol\n");
                  exit(-1);
              }
              
              printf("Entrez le diminutif de l'espèce chimique :\n");
              printf("--> ");
              fflush(stdout);
              lire(nom, 3);
              
              printf("Entrez la masse molaire moléculaire correspondante :\n");
              printf("--> ");
              fflush(stdout);
              scanf("%lf", &masse);
              
              fseek(fichier, 0, SEEK_END);
              fprintf(fichier, "%s %.1f\n", nom, masse);
              fclose(fichier);
          }
              
              
              
          /*Menu basique aussi*/
          void menu(void)
          {
              int choix = 0;
              printf("Bienvenu dans le zMol !\n");
              
              while(choix != 1 && choix != 2)
              {
                  printf("Choisissez une action:\n");
                  printf("\t1. Calcul\n");
                  printf("\t2. Ajouter une espèce chimique\n");
                  printf("--> ");
                  fflush(stdout);
                  scanf("%d", &choix);
                  vider_buffer();
              }
              
              switch(choix)
              {
                  case 1:
                  calc();
                  break;
                  
                  case 2:
                  add();
                  break;
                  
                  default:
                  break;
              }
          }
          
          void calc(void)
          {
              double ret = 0.0;
              char* envoie = NULL;
              char mol[100] = {'\0'};
              char resultat[100] = {'\0'};
          
              printf("Entrez une molécule :\n");
              printf("--> ");
              fflush(stdout);
              
              scanf("%s", mol);
              
              /*Strtok modifie la chaine, on la stocke ailleurs pour l'affichage finale*/
              strcpy(resultat, mol);
              
              /*Si on trouve une parenthèse au moins dans la molécule*/
              if(strstr(mol, "(") != NULL)
              {
                  /*On extrait la chaine avant la parenthèse*/
                  envoie = strtok(mol, "(");
                  while(envoie != NULL)
                  {
                      ret += result(envoie);
                      envoie = strtok(NULL, "(");
                  }
              }
              /*S'il n'y a aucune parenthèse dans la molécule*/
              else
              {
                  ret = result(mol);
              }
          
              printf("La masse molaire de la molécule %s est %.1f g.mol-1\n", resultat, ret);
          }
          



          Fonction5.h

          #ifndef FONCTION_H_INCLUDED
          #define FONCTION_H_INCLUDED
          
          #include "element.h"
          
          int lire(char *chaine, int longueur);
          long get_masse(void);
          void vider_buffer(void);
          void menu(void);
          char *sub_str (char *src, int pos, int len);
          double result(char* mol);
          int search_tab(char* lettre, Element elem[], int nbelem);
          void calc(void);
          int get_file(Element elem[]);
          
          #endif
          



          Element.h

          #ifndef ELEMENT_H_INCLUDED
          #define ELEMENT_H_INCLUDED
          
          typedef struct
          {
              char nom[3];
              double val;
              int coeff;
          }Element;
          
          #endif
          



          Ça compile sans warnings avec -W -Wall -Wextra -ansi -pedantic normalement, et c'est fonctionnel :D

          D'ailleurs, doit-on commenter nos codes ?

          EDIT: Commentaires ajoutés.
          • Partager sur Facebook
          • Partager sur Twitter
            2 septembre 2011 à 20:23:25

            @Sabeurre: Oui ce serrait mieux de commenter ;)
            • Partager sur Facebook
            • Partager sur Twitter
            🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
              2 septembre 2011 à 20:24:42

              Tu as réussis à coder tout ça en à peine une heure et demie? o_O
              • Partager sur Facebook
              • Partager sur Twitter
                2 septembre 2011 à 20:26:27

                Oui on doit commenter les codes, mais pas parce que l'exercice te le demande, mais parce que c'est une bonne habitude à prendre.

                EDIT : grilled.
                • Partager sur Facebook
                • Partager sur Twitter
                "If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)
                  2 septembre 2011 à 20:37:10

                  Très bonne idée ces défis ! Je m'y met dès demain ;)
                  • Partager sur Facebook
                  • Partager sur Twitter
                    2 septembre 2011 à 20:48:14

                    @Twisted Destiny: Je pensais que le topic serait posté hier, j'ai donc codé ça hier ^^ Et ça m'a pris un peu beaucoup plus qu'une heure ^^

                    J'édite donc mon code alors.
                    • Partager sur Facebook
                    • Partager sur Twitter
                    Anonyme
                      3 septembre 2011 à 11:36:00

                      Hop, réalisation du niveau 5 en une centaine de lignes :)
                      Le code est un peu abscons, la gestion des options un peu moche, mais bon...

                      Le programme utilise le fichier de configuration mol.conf :
                      C 12.011
                      O 15.999
                      H 1.0079
                      He 4.0026
                      Li 6.941
                      Cl 35.453
                      Na 22.989

                      (à placer à côté de l'exécutable)

                      $ gcc -o mol mol.c -W -Wall -Wextra -ansi -pedantic -std=c89
                      $ ./mol
                      > C02
                      44.008999
                      $ ./mol NaCl
                      58.442001
                      $ ./mol "(CH4)2"
                      32.085197
                      $ ./mol --add-element F 18.99840325 #ou encore
                      $ ./mol -a F 18.99840325 # -a <=> --add-element


                      Et le code :
                      #include <stdio.h>
                      #include <stdlib.h>
                      #include <string.h>
                      #include <ctype.h>
                           
                      #define CONF "mol.conf"
                      #define LINE_MAX_LEN 128
                      #define MOL_MAX_LEN 128
                           
                      void fatal(char* msg) {
                          printf("%s\n", msg);
                          exit(1);
                      }
                         
                      /* Récupère la masse d'un élément connu dans le
                      fichier de configuration */
                      float getElemMass(char* elem) {
                          FILE* f;
                          char line[LINE_MAX_LEN];
                          char cur_elem[LINE_MAX_LEN];
                          float mass;
                         
                          if((f = fopen(CONF, "r")) == NULL)
                              fatal("Unable to read configuration file");
                         
                          while(fgets(line, LINE_MAX_LEN, f)) {
                              sscanf(line, "%s %f", cur_elem, &mass);
                              if(strcmp(elem, cur_elem) == 0) {
                                  fclose(f);
                                  return mass;
                              }
                          }
                        
                          fclose(f);
                          return 0;
                      }
                           
                      /* Retourne la masse d'une molécule */
                      float getMolMass(char* mol) {
                          int i = 0;
                          float molmass = 0.0;   /* La masse de la molécule */
                          float cur_item_mass = 0.0;  /* Contient la masse du dernier élément/groupement trouvé */
                          char cur_item[MOL_MAX_LEN];
                          int mul;
                        
                          while(mol[i] != '\0') {
                              if(isupper(mol[i])) { /* Début d'un élément */
                                  int j = 0;
                        
                                  cur_item[j++] = mol[i++];
                                  while(islower(mol[i]) && mol[i] != '\0') /* Ajout de la suite de l'élément */
                                      cur_item[j++] = mol[i++];
                                  cur_item[j] = '\0';
                        
                                  if(cur_item_mass != 0.0) /* Un élément précédent n'a pas été ajouté à la masse totale */
                                      molmass += cur_item_mass; /* On l'ajoute avant de modifier cur_item_mass */
                       
                                  cur_item_mass = getElemMass(cur_item);
                              } else if(isdigit(mol[i])) { /* Multiplicateur */
                                  mul = mol[i++] - '0';
                                  while(isdigit(mol[i]) && mol[i] != '\0') { /* On ajoute la suite du multiplicateur */
                                      mul *= 10;
                                      mul += mol[i++] - '0';
                                  }
                                  molmass += cur_item_mass * mul; /* On ajoute l'élément précédemment détecté à la masse totale en le
                                                                     multipliant par le multiplicateur */
                                  cur_item_mass = 0.0;
                              } else if(mol[i] == '(') { /* Début d'un groupement */
                                  int j = 0;
                                  i++;
                                  while(mol[i] != ')' && mol[i] != '\0')
                                      cur_item[j++] = mol[i++];
                                  i++;
                                  cur_item[j] = '\0';
                       
                                  if(cur_item_mass != 0.0)
                                      molmass += cur_item_mass;
                       
                                  cur_item_mass = getMolMass(cur_item); /* Récupération de la masse du groupe par appel récursif */
                              }
                          }
                          if(cur_item_mass != 0.0)
                              molmass += cur_item_mass;
                       
                          return molmass;
                      }
                           
                      int main(int argc, char* argv[]) {
                          if(argc == 1) {
                              char mol[MOL_MAX_LEN];
                              unsigned int i;
                              printf("> ");
                              fgets(mol, MOL_MAX_LEN, stdin);
                              for(i=0; i < strlen(mol); i++) {
                                  if(mol[i] == '\n') { /* Élimination du retour à la ligne final */
                                      mol[i] = '\0';
                                      break;
                                  }
                              }
                              printf("\n%f\n", getMolMass(mol));
                          } else if((strcmp(argv[1], "-a") == 0) || (strcmp(argv[1], "--add-element") == 0)) {
                              /* Ajout d'un élément au fichier de configuration */
                              FILE* conf;
                              if(argc != 4)
                                  fatal("Syntax : mol -a|--add-element <Element name> <Mass>");
                       
                              if((conf = fopen(CONF, "a+")) == NULL)
                                  fatal("Unable to open configuration file for writing");
                       
                              fprintf(conf, "%s %s\n", argv[2], argv[3]);
                              fclose(conf);
                          } else if(argv[1][0] == '-') {
                              fatal("Unknow option");
                          } else {
                              printf("%f\n", getMolMass(argv[1]));
                          }
                          return 0;
                      }
                      

                      ou un pastebin : http://pastebin.archlinux.fr/433875
                      • Partager sur Facebook
                      • Partager sur Twitter
                        3 septembre 2011 à 11:39:46

                        Bonjour,

                        @Armael: J'ai parcouru très rapidement. :-°

                        Pourquoi ne pas ouvrir ton fichier avant le calcul de la masse moléculaire, plutôt que l'ouvrir à chaque recherche d'élément?
                        • Partager sur Facebook
                        • Partager sur Twitter
                        Zeste de Savoir, le site qui en a dans le citron !
                          3 septembre 2011 à 11:42:55

                          Humm, j'ai pas bien lut le code, je me suis arrêter à :
                          for(i=0; i < strlen(mol); i++) {
                             if(mol[i] == '\n') { /* Élimination du retour à la ligne final */
                                mol[i] = '\0';
                                break;
                             }
                          }
                          

                          Ça m'a sacrément refroidit
                          En effet, ce n'est pas performant du tout ^^" (et long)

                          Tu peux voir voir ici pour plus d'info ;)
                          • Partager sur Facebook
                          • Partager sur Twitter
                          🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                          Anonyme
                            3 septembre 2011 à 11:55:01

                            Euh ouais. Deux petits fails de ma part.
                            Le coup du '\n' final, c'est je crois dû à une flemme subconsciente de calculer le bon décalage des indices à partir de strlen(mol)... /o\

                            C'est corrigé ici : http://pastebin.archlinux.fr/433879. Du coup le main() est vraiment moche mais bon, la partie intéressante est dans getMolMass :]

                            • Partager sur Facebook
                            • Partager sur Twitter
                              3 septembre 2011 à 12:49:35

                              Est-ce qu'on doit gérer les trucs du genre : C + O2

                              Sabeurre > J'ai regardé ton code en travers, tu penses pas que tu pourrais faire plus léger ? je pense notamment aux strstr pour chercher un caractère et aux strtok. :-°
                              J'ai l'impression que tu fais pas mal de répétitions, tu peux sûrement smplifier. :)


                              Armael > Pourquoi faire 2 fois 'printf("\n%f\n", getMolMass(mol));' dans ton main ? tu peux ne le faire qu'une seule fois.
                              Tu ne peux pas faire de comparaisons de flottans comme tu le fais, tu as une chance sur 2 que ça ne fonctionne pas : if(cur_item_mass != 0.0)
                              Si je dis pas de conneries, les éléments ne comportent que 2 lettres, donc inutile de gérer les éléments avec X lettres. :)
                              Tu pourrais (devrais) ouvrir ton fichier une fois pour toutes et le garder en mémoire plutôt que l'ouvrir à chaque élément.
                              Si j'imbrique plusieurs parenthèses, ton code donnera un résultat faux (comme je n'ai pas eu de réponse par rapport à ça, oublie ce commentaire...)
                              Que vaut 2CO2 ? sûrement pas 44.008999 ;)
                              • Partager sur Facebook
                              • Partager sur Twitter
                              Anonyme
                                3 septembre 2011 à 12:57:13

                                - Hm, où je fais deux fois printf( ,getMolMass(mol)) ?
                                - Pour les flottants, je me suis dit que lorsque cur_item_mass est à 0 c'est parce qu'il y a été initialisé explicitement, et ça marcherait. Après, j'en sais trop rien, j'vais regarder ça.
                                - Pour les éléments qui font max. deux lettres, c'est que j'avais un doute sur le sens de «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 j'ai décidé d'autoriser les fantaisies :-°
                                - Hum, regarde mon dernier post ;)
                                - Je looke ça pour l'imbrication de parenthèses, ça devrait marcher. [FIXED]
                                - 2CO2 n'a pas de sens ! Tu veux dire (CO2)2 (qui lui est correctement interprêté) ?

                                Code corrigé ici: http://paste.awesom.eu/fkr&hl=c
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  3 septembre 2011 à 13:59:38

                                  Avec le argc et le dernier else. :)
                                  2CO2 n'a peut-être pas de sens, mais si je prends le lien donné plus haut (cf celui-ci : http://sciences.siteduzero.com/tutorie [...] es-moles.html ) ils donnent bien des formules avec des indices préfixés et postfixés. ;)
                                  Et, quand on disait de n'ouvrir ton fichier, on parlait surtout de ne le parcourir qu'une seule fois et de stocker tout en mémoire, pas de faire un 'rewind' à chaque appel de fonction. :-°
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    3 septembre 2011 à 15:18:00

                                    Citation : Exercices C

                                    zMol, la chimie pour tous


                                    Chouette!

                                    Citation : Exercices C


                                    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.


                                    Fastoche^^

                                    Citation : Exercices C

                                    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.


                                    Mince, j'ai pas encore le niveau (je suis en train de lire le tutoriel, justement sur ce chapitre)

                                    *Court lire la suite*
                                    Ah mais nan, c'est vrai
                                    *Vient de se rappeler qu'elle a un autre "truc" à voir et qu'elle attend une réponse*
                                    Bon, ce sera pour la prochaine fois...

                                    Citation : Ccile

                                    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. (la sait déjà)
                                    Avoir un énième TP d'entrainement à faire



                                    Ce message est là pour me rappeler de faire le défi (une fois que j'aurais le niveau) et pour encourager les créateurs d'exercices à continuer sur la voie du mélange des matières^^
                                    Ok, ok, je m'en vais je m'en vais...
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      3 septembre 2011 à 16:34:26

                                      Comme promis, mon code.
                                      L'énoncé rapidement lu avait l'air plutôt facile, mais finalement il est un peu plus compliqué qu'il n'y paraît.

                                      /* -> zMol - par lucas-84 pour www.siteduzero.com.
                                       * -> Défi #1 d'une série d'exercices lancée par GuilOoo.
                                       * -> Merci aux organisateurs, à savoir : _Fender_, GuilOooo, yoch, 
                                       *    InfernoLeZéro, @che, neowillow, lucas-84 et schadocalex.
                                       * -> L'énoncé est à cette adresse : 
                                       *    http://www.siteduzero.com/forum-83-686358-p1-defis-1-zmol-
                                            la-chimie-pour-tous.html
                                       * -> Venez vous entraîner, et bonne lecture ! 
                                       */
                                      
                                      /* main.c */
                                      
                                      #ifdef _cplusplus
                                      #error Ce fichier source n'est pas en C++. \
                                             Merci d'utiliser un compilateur C.
                                      #endif
                                      
                                      #include <stdio.h>
                                      #include <stdlib.h>
                                      #include <string.h>   /* Pour les fonctions de manipulation des chaînes. */
                                      #include <ctype.h>    /* Pour les fonctions de la famille de isalpha(). */
                                      
                                      
                                      /* constants =========================================================== */
                                      
                                      
                                      /*
                                       * Taille maximale d'une molécule saisie par l'utilisateur. 
                                       */
                                      #define MAX_LEN     		64
                                      /*
                                       * Nom du fichier contenant la masse de chaque atome 
                                       */
                                      #define FILE_NAME   		"fichier.txt"
                                      	
                                      
                                      /* structures ========================================================== */
                                      
                                      
                                      /*
                                       * Structure d'un élément chimique. 
                                       */
                                      typedef struct {
                                          char            s_name[MAX_LEN];	/* Désignation de l'élément. */
                                          double          mass;		/* Masse de l'élément. */
                                      } Element_s;
                                      
                                      
                                      /* private functions =================================================== */
                                      
                                      
                                      /* Niveau d'abstraction 5 */
                                      
                                      /*
                                       * Nettoie le buffer. 
                                       */
                                      static void
                                      clean(void)
                                      {
                                          int             c;
                                          while ((c = getchar()) != '\n' && c != EOF);
                                      }
                                      
                                      /*
                                       * Lis une chaîne de caractère s_read de taille size sur le flux
                                       * d'entrée standard. 
                                       */
                                      static void
                                      read_string(char *s_read, int size)
                                      {
                                          char           *ptr_end = NULL;
                                      
                                          if (fgets(s_read, size, stdin) != NULL) {
                                      	ptr_end = strchr(s_read, '\n');
                                      
                                      	if (ptr_end != NULL) {
                                      	    *ptr_end = '\0';
                                      	} else {
                                      	    clean();
                                      	}
                                          }
                                      }
                                      
                                      /* Niveau d'abstraction 4 */
                                      
                                      /*
                                       * Cherche un atome searched_atom->s_name dans le fichier p_stream, 
                                       * et retourne sa masse.
                                       */
                                      static void
                                      search_in_file(FILE * p_stream, Element_s *p_searched_atom)
                                      {
                                          Element_s       read_atom;
                                      
                                          while (fscanf(p_stream, "%s %lf", 
                                         	          read_atom.s_name, &read_atom.mass) == 2) {
                                      	if (!strcmp(read_atom.s_name, p_searched_atom->s_name)) {
                                      	    p_searched_atom->mass = read_atom.mass;
                                      	}
                                          }
                                      }
                                      
                                      /* Niveau d'abstraction 3 */
                                      
                                      /*
                                       * Initialise la structure que pointe p_struct. 
                                       */
                                      static void
                                      init(Element_s * p_struct)
                                      {
                                          p_struct->mass = .0;
                                      }
                                      
                                      /*
                                       * Fonction principale du traitement d'un atome. 
                                       */
                                      static double
                                      treat_atom(FILE * p_stream, char s_molecule_name[], Element_s * p_atom, 
                                      	   int *i)
                                      {
                                          int var = 0;
                                      
                                          p_atom->s_name[var++] = s_molecule_name[*i]; 
                                      
                                          while (islower(s_molecule_name[*i + 1])) {
                                      	p_atom->s_name[var++] = s_molecule_name[++(*i)];
                                          } 
                                      
                                          p_atom->s_name[var] = '\0';
                                      
                                          search_in_file(p_stream, p_atom);
                                      
                                          if (p_atom->mass == .0) {
                                      	fprintf(stderr, " L'atome %s est introuvable.\n", p_atom->s_name);
                                          }
                                      
                                          return p_atom->mass;
                                      }
                                      
                                      /* Niveau d'abstraction 2 */
                                      
                                      /*
                                       * Récupère la molécule ps_mol saisie par l'utilisateur. 
                                       */
                                      static void
                                      get_mol(char *ps_mol)
                                      {
                                          printf(" Entrez une molécule (-add [nom][masse] pour en ajouter"
                                      	   " une) :\n --> ");
                                          read_string(ps_mol, MAX_LEN);
                                      }
                                      
                                      /*
                                       * Affiche le résultat molecule_mass. 
                                       */
                                      static void
                                      print_result(double molecule_mass)
                                      {
                                          printf("\n La masse molaire de cette molécule est %f g.mol-1.\n",
                                      	   molecule_mass);
                                      }
                                      
                                      /*
                                       * Fonction principale du traitement d'une molécule. 
                                       */
                                      static double
                                      treat_molecule(FILE * p_stream, char s_molecule_name[])
                                      {
                                          int             i;
                                          double  	    prev_mass = .0;
                                          double	    result = .0,
                                      		    tmp_mass = .0;
                                          Element_s       atom;
                                      
                                          init(&atom);
                                      
                                          for (i = 0; s_molecule_name[i] != '\0'; i++, atom.mass = 0) {
                                      	if (isupper(s_molecule_name[i])) {
                                      	    tmp_mass += treat_atom(p_stream, s_molecule_name, &atom, &i);
                                      	    result += atom.mass;
                                      	} else if (isdigit(s_molecule_name[i])) {
                                      	    result +=
                                      	      (prev_mass * (strtol(&s_molecule_name[i], NULL, 10) - 1));
                                      	    tmp_mass +=
                                      	      (prev_mass * (strtol(&s_molecule_name[i], NULL, 10) - 1));
                                      	} else if (s_molecule_name[i] == '(') {
                                      	    tmp_mass = 0.;
                                      	} else if (s_molecule_name[i] == ')'
                                      		   && isdigit(s_molecule_name[i + 1])) {
                                      	    result +=
                                      	      (tmp_mass * 
                                                    (strtol(&s_molecule_name[i + 1], NULL, 10) - 1));
                                      	}
                                      
                                      	prev_mass = atom.mass;
                                      	rewind(p_stream);
                                          }
                                      
                                          return result;
                                      }
                                      
                                      /* 
                                       * Ajoute un atome dans le fichier. 
                                       */
                                      static int
                                      add_atom(char *cmd) 
                                      {
                                          FILE           *p_stream; 
                                          int             i;
                                       
                                          if (!(p_stream = fopen(FILE_NAME, "a+"))) {
                                      	fprintf(stderr, " Erreur lors de l'ouverture du fichier.\n");
                                      	return 0;
                                          }
                                      
                                          for (i = 5 ; cmd[i] != '\0' ; i++) {
                                      	fputc(cmd[i], p_stream);
                                          }
                                      
                                          fclose(p_stream);
                                      
                                          return 1;
                                      }
                                      
                                      /* Niveau d'abstraction 1 */
                                      
                                      /*
                                       * Fonction principale du programme. Renvoie 1 si tout s'est bien passé
                                       * ou 0 le cas échéant. 
                                       */
                                      static int
                                      zMol(void)
                                      {
                                          FILE           *p_stream;
                                          Element_s       molecule;
                                      
                                          init(&molecule);
                                      
                                          if (!(p_stream = fopen(FILE_NAME, "r"))) {
                                      	fprintf(stderr, " Erreur lors de l'ouverture du fichier.\n");
                                      	return 0;
                                          }
                                      
                                          get_mol(molecule.s_name);
                                      
                                          if (!strncmp(molecule.s_name, "-add", 4)) {
                                      	return add_atom(molecule.s_name);
                                          }
                                      
                                          molecule.mass = treat_molecule(p_stream, molecule.s_name);
                                          print_result(molecule.mass);
                                      
                                          fclose(p_stream);
                                      
                                          return 1;
                                      }
                                      
                                      
                                      /* entry points ======================================================== */
                                      
                                      
                                      /* Niveau d'abstraction 0 */
                                      
                                      int
                                      main(void)
                                      {
                                          return (zMol())? EXIT_SUCCESS : EXIT_FAILURE;
                                      }
                                      


                                      J'ai mis pas mal de temps avant d'établir une solution fonctionnelle, et j'ai eu droit à de multiples bugs en tout genre. J'imagine qu'il doit en rester encore beaucoup... :-°
                                      Je précise que le code ci-dessus ne supporte pas encore l'imbrication de parenthèses.
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                      Staff désormais retraité.
                                        3 septembre 2011 à 16:54:36

                                        Citation : Pouet_forever

                                        2CO2 n'a peut-être pas de sens, mais si je prends le lien donné plus haut (cf celui-ci : http://sciences.siteduzero.com/tutorie [...] es-moles.html ) ils donnent bien des formules avec des indices préfixés et postfixés. ;)


                                        Non non, ça c'est les coefficients pour équilibrer une équation. Une molécule seule ne possède jamais de nombres devant.
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                        "If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)
                                          3 septembre 2011 à 17:10:34

                                          Citation : shadocalex

                                          Non non, ça c'est les coefficients pour équilibrer une équation. Une molécule seule ne possède jamais de nombres devant.



                                          Juste pour le plaisir de parler quand (pour une fois) je connais :
                                          Ces coefficients sont nommés nombres stœchiométriques et servent à équilibrer une équation (comme dit avant). En gros, dans l'équation suivante :
                                          2tranches de pain + 1tranche de jambon =>1sandwich
                                          les nombres (1 et 2) sont des nombres stœchiométriques (mais le 1 on ne le met pas)
                                          (désolée de l'exemple hs par rapport à la chimie, mais c'est l'exemple qui fut utilisé par ma prof lorsque l'on a appris les tableaux d'avancement^^, je sais, je suis une sentimentale :p )
                                          (bon, c'est aussi hors-sujet par rapport au topic, mais autant donner le bon vocable non? (excuse médiocre je sais...))
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            3 septembre 2011 à 17:14:20

                                            Toute connaissance est bonne à partager hein. ;)

                                            (enfin le coup du sandwich, c'est vrais, t'aurais pu le garder :-° )
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                            🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                                              3 septembre 2011 à 17:23:57

                                              C'est pas du tout HS, c'est même un des principaux objectifs :

                                              Citation

                                              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.



                                              Moi aussi j'ai eu droit au coup de "l'optimisation d'une sandwicherie". :)
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                3 septembre 2011 à 17:27:32

                                                Ah, pouet, on t'as pas répondu je crois. Au niveau 4, l'imbrication "maximale" est celle avec une seule paire de parenthèse. Et non, on ne doit pas gérer "les trucs du genre : C + O2".

                                                Twisted Destiny et Ccile -> Moi aussi. :p
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                "If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)
                                                  3 septembre 2011 à 17:38:15

                                                  Citation : Twisted Destiny

                                                  Moi aussi j'ai eu droit au coup de "l'optimisation d'une sandwicherie". :)


                                                  Citation : schadocalex

                                                  Twisted Destiny et Ccile -> Moi aussi. :p


                                                  Alors, soit on a eu la même prof, soit les profs de physique-chimie devraient penser à changer un peu ;)

                                                  (Pour être un peu moins HS qu'un commentaire de commentaire, je tiens à signaler ici à mes fans (comment ça j'ai la grosse tête?!? :lol: ) que je vais ré-attaquer incessamment sous peu (enfin, dès que j'aurai fini la vaisselle :D ) la partie du tutoriel sur les fichiers et donc que je m'avance petit à petit vers l'écriture du code demandé :p )
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    3 septembre 2011 à 17:39:11

                                                    Au pire, tu peux commencer sans les fichiers, tu écris en dur dans le code source les valeurs, c'est pas un problème pour démarrer.
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                    "If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)
                                                      3 septembre 2011 à 17:41:00

                                                      Je préfère approfondir mes connaissances avant^^ (et laisser par la même occasion mon cerveau trouver un schéma possible de code, car si je sais le faire à la main sans aucun souci... programmer ça me semble plus... tordu :D)
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        3 septembre 2011 à 17:42:09

                                                        Bonjour,

                                                        Voilà mon code :
                                                        #include <stdio.h>
                                                        #include <stdlib.h>
                                                        #include <string.h>
                                                        #include <ctype.h>
                                                        
                                                        void viderBuffer()
                                                        {
                                                            int c = 0;
                                                            while (c != '\n' && c != EOF)
                                                            {
                                                                c = getchar();
                                                            }
                                                        }
                                                         
                                                        int lire(char *chaine, int longueur)
                                                        {
                                                            char *positionEntree = NULL;
                                                         
                                                            if (fgets(chaine, longueur, stdin) != NULL)
                                                            {
                                                                positionEntree = strchr(chaine, '\n');
                                                                if (positionEntree != NULL)
                                                                {
                                                                    *positionEntree = '\0';
                                                                }
                                                                else
                                                                {
                                                                    viderBuffer();
                                                                }
                                                                return 1;
                                                            }
                                                            else
                                                            {
                                                                viderBuffer();
                                                                return 0;
                                                            }
                                                        }
                                                        
                                                        double correspondance(char* cache)
                                                        {
                                                        	char c = 0;
                                                        	char atome[100] = {'\0'}, mol[100] = {'\0'};
                                                        	int i = 0, etat = 0;
                                                        
                                                        	FILE* fichier = NULL;
                                                        
                                                        	fichier = fopen("moles", "r");
                                                        
                                                        	while(etat != 2)
                                                        	{
                                                        		i = 0;
                                                        		c = fgetc(fichier);		
                                                        		while(c != ' ')
                                                        		{			
                                                        			atome[i] = c;
                                                        			i++;
                                                        			c = fgetc(fichier);
                                                        		}
                                                        
                                                        		i = 0;
                                                        	
                                                        		if(strcmp(cache, atome) == 0)
                                                        		{
                                                        			etat = 1;
                                                        		}
                                                        		else
                                                        		{
                                                        			atome[0] = '\0';
                                                        			atome[1] = '\0';
                                                        		}
                                                        
                                                        		c = fgetc(fichier);
                                                        		while(c != '\n')
                                                        		{
                                                        			if(etat == 1)
                                                        			{
                                                        				mol[i] = c;
                                                        				i++;
                                                        			}
                                                        			c = fgetc(fichier);
                                                        		}
                                                        		if(etat == 1)
                                                        		{
                                                        			etat = 2;
                                                        		}
                                                        	}
                                                        
                                                        	fclose(fichier);
                                                        
                                                        	return strtod(mol, NULL);
                                                        }
                                                        
                                                        int main(int argc, char* argv[])
                                                        {
                                                        	char molecule[20] = {'\0'}, c = 0;
                                                        	char cache[10] = {'\0'}, coef[10] = {'\0'};
                                                        	int i = 0, num_coef = 0, j=0, groupe = 0;
                                                        	double total = 0, sous_total = 0;
                                                        	
                                                        	printf("Entrez une molécule :\n--> ");
                                                        	lire(molecule, 20);
                                                        	do
                                                        	{
                                                        		c = molecule[i];
                                                        		if(c == '(')
                                                        		{
                                                        			groupe = 2;
                                                        		}
                                                        		else if(c == ')')
                                                        		{
                                                        			groupe = 1;
                                                        			if(coef[0] != '\0')
                                                        				{
                                                        					sous_total += (strtol(coef, NULL, 10) * correspondance(cache));
                                                        					for(j = 0; j < 10; j++)
                                                        					{
                                                        						coef[i] = '\0';
                                                        					}
                                                        					num_coef = 0;
                                                        				}
                                                        				else
                                                        				{
                                                        					sous_total += correspondance(cache);
                                                        				}				
                                                        				cache[0] = '\0';
                                                        				cache[1] = '\0';
                                                        		}
                                                        		else if(isupper(c) || c == '\0')
                                                        		{
                                                        			if(cache[0] == '\0' && c != '\0')
                                                        			{
                                                        				cache[0] = c;
                                                        			}
                                                        			else
                                                        			{
                                                        				if(coef[0] != '\0')
                                                        				{
                                                        					if(groupe == 2)
                                                        						sous_total += (strtol(coef, NULL, 10) * correspondance(cache));
                                                        					else if(groupe == 1)
                                                        					{
                                                        						total += (strtol(coef, NULL, 10) * sous_total);
                                                        						groupe = 0;
                                                        					}
                                                        					else
                                                        						total += (strtol(coef, NULL, 10) * correspondance(cache));
                                                        					for(j = 0; j < 10; j++)
                                                        					{
                                                        						coef[i] = '\0';
                                                        					}
                                                        					num_coef = 0;
                                                        				}
                                                        				else
                                                        				{
                                                        					if(groupe == 2)
                                                        						sous_total += correspondance(cache);
                                                        					else if(groupe == 1)
                                                        					{
                                                        						printf("ERREUR");
                                                        						return 1;
                                                        					}
                                                        					else
                                                        						total += correspondance(cache);
                                                        				}				
                                                        				cache[0] = c;
                                                        				cache[1] = '\0';
                                                        			}
                                                        		}
                                                        		else if(islower(c))
                                                        		{
                                                        			if(cache[0] != '\0' && isupper(cache[0]) && cache[1] == '\0')
                                                        			{
                                                        				cache[1] = c;
                                                        			}
                                                        			else
                                                        			{
                                                        				printf("ERREUR\n");
                                                        				return 1;
                                                        			}
                                                        		}
                                                        		else if(isdigit(c))
                                                        		{
                                                        			coef[num_coef] = c;
                                                        			num_coef++;
                                                        		}
                                                        		i++;
                                                        	}
                                                        	while(c != '\0');
                                                        
                                                        	/*if(coef[0] != '\0')
                                                        	{
                                                        		if(groupe == 1)
                                                        		{
                                                        			total += (strtol(coef, NULL, 10) * sous_total);
                                                        			groupe = 0;
                                                        		}
                                                        		else if(cache[0] != '\0')
                                                        			total += (strtol(coef, NULL, 10) * correspondance(cache));
                                                        	}
                                                        	else if(cache[0] != '\0')
                                                        	{
                                                        		total += correspondance(cache);
                                                        	}*/
                                                        
                                                        
                                                        	printf("La masse molaire de cette molécule est %f g.mol-1\n", total);
                                                        	return 0;
                                                        }
                                                        


                                                        Ce code fonctionne pour le niveau 4 mais il reste encore à enlever certaines répétitions et, comme dit un peu avant, éviter d'ouvrir le fichier à chaque appel de la fonction...
                                                        La partie de code en commentaire était une répétition que j'ai enlever en modifiant la partie avec le "isupper()".
                                                        Merci de regarder le code et de me faire des remarques pour que je puisse m'améliorer. :)

                                                        Emmflo
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                        Anonyme
                                                          3 septembre 2011 à 18:07:08

                                                          Bouh le nom du fichier de conf hardcodé :p
                                                          Utilise quelques define pour ça et la taille de tes tableaux (genre tous les mol[100]...). Élimine les "nombres magiques" quoi :)
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            3 septembre 2011 à 20:23:36

                                                            Armael > J'ai eu mes réponses par schadocalex, oublie ce que je t'ai dit plus haut. :)
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                            Anonyme
                                                              3 septembre 2011 à 20:57:42

                                                              En tout cas maintenant mon code gère bien un nombre illimité d'imbrications :D et c'est ce qui était voulu au départ, y avait juste un ptit bug à fixer.
                                                              Ça se fait très simplement et naturellement avec un appel récursif.
                                                              • Partager sur Facebook
                                                              • Partager sur Twitter

                                                              [FAIT][Défis] #1 : zMol, la chimie pour tous

                                                              × 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