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 :

• Le jeu de la vie
• Les automates cellulaires

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

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.

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

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

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

(Mes énoncés sont libres de tous droits).

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 !
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. 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é ?
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.