Initiation à la programmation TP 3

De
Publié par

Licence, Supérieur, Licence (bac+3)
  • cours - matière potentielle : sur les chaînes de caractères
  • cours - matière potentielle : math correspondant la division entière
Licence STS 1ère année 2011-2012 Initiation à la programmation TP 3 Écrire, pour chaque exercice, les instructions d'initialisation et de déplacement des cartes permettant de passer de l'état initial à la situation finale; il faudra écrire (au moins) un fichier (exoBxx.ml ou xx est le numéro de l'exercice) ou plusieurs lorsque c'est indiqué. Chaque exercices sera testé plusieurs fois en ayant pris soin de placer les exercices et la console dans le répertoire /home/etudiant/Documents (commandes pwd , ls , cd DoTE ) et dans ocamlcartes _use exoBxx.
  • programme précédent
  • instructions d'initialisation et de déplacement des cartes
  • séquence situation initiale
  • déplacement cyclique
  • exercice b5
  • codage ocaml de l'algorithme
  • numéro de l'exercice
  • situation finale
  • initialisation
  • algorithme
  • algorithmes
Publié le : lundi 26 mars 2012
Lecture(s) : 43
Source : telecom-lille1.eu
Nombre de pages : 6
Voir plus Voir moins
ère  LicenceSTS 1année Initiation à laprogrammation
2011-2012
TP 3 Écrire, pour chaque exercice, les instructions d'initialisation et de déplacement des cartes permettant de passer de l'état initial à la situation finale; il faudra écrire (au moins) un fichier (exoBxx.ml ou xx est le numéro de l'exercice) ou plusieurs lorsque c'est indiqué. Chaque exercices sera testé plusieurs fois en ayant pris soin de placer les exercices et la console dans le répertoire /home/etudiant/Documents (commandespwd,ls,cd DoTE) et dans ocamlcartes #use "exoBxx.ml"plusieurs fois (grâce à la toucheZ):
Partie 1 : Exercice B1: Reprendre, pour B1 et B2, les 2 algorithmes vus en cours : Tas 1 :10"T" Tas 2 :10"T" Tas 3 :10"T" Tas 4 :10"T" Situation Finale : Tas 1 :"[T]" Tas 2 :"" Tas 3 :"" Tas 4 :"" à l'aide de 2 boucles imbriquées dont on observera le comportement premier algorithme (pour B1): on prélève une carte sur chaque tas 2 à 4 pour le mettre sur 1 puis on recommence... Méthodologie : Lorsqu’on a des boucles, la mise au point est souvent longue (à cause du grand nombre de répétitions des actions. On ne va donc pas répondre directement au problème, mais à un problème où le nombre de répétitions est plus faible. Et à fin de faciliter les corrections du nombre de répétitions, on utilisera l'association nom/valeur: let mon_init ="TT" ;(* tout à la fin, on remplacera par "TTTTTTTTTT"*) on définira aussi nb: let nb=2 ;(* tout à la fin, on remplacera par 10 *) ces 2 lignes suivront la première la première : open Cartes;; et on utilisera for i=1 to nb do (* plutôt que 1 to 10 de ce fait on n'aura même pas *) Remarque : on verra, lorsque l'on fera le cours sur les chaînes de caractères qu'il existe une fonction qui « compte » le nombre de caractères d'une chaîne. On pourra donc avantageusement remplacer par : let nb=String.length(mon_init) ;(* tout à la fin, il n'y aura même plus besoin de faire de remplacement *)
Exercice B2: Sauvegarder le programme précédent sous un nouveau nom (exoB2.ml) et modifiez-le pour obtenir : l'algorithme 2 : toujours à l'aide de 2 boucles imbriquées, on prélève toutes les cartes du tas 2 ( 1 par 1 bien sûr) pour les déposer sur 1 puis on recommence avec 3 puis 4
Observez bien la différence de comportement : #use "exoB1.ml";; les tas 2 à 4 se vident à la même vitesse #use "exoB2.ml";; les tas 2 à 4 se vident l'un après l'autre
Partie 2 : Exercice B3: Utiliser pour résoudre l'algorithme exclusivement une séquence Situation initiale : Tas 1 :"" Tas 2 :"" Tas 3 :"T" Tas 4 :"K" Situation Finale : Tas 1 :"" Tas 2 :"T" Tas 3 :"K" Tas 4 :""
Exercice B4: Utiliser pour résoudre l'algorithme exclusivement une itération (boucle pour) Situation initiale : Tas 1 :"" Tas 2 :"" Tas 3 :"T" Tas 4 :"K" Situation Finale : Tas 1 :"" Tas 2 :"T" Tas 3 :"K" Tas 4 :""
Exercice B4bis : Votre réflexion a dû vous conduire à écrire l'un des 2 code ocaml soit: for i=3 to 4 do  deplacer_sommet(?,?); done;; soit : for i=2 to 3 do  deplacer_sommet(?,?); done;; en mettant ce qu'il faut à la place des «?» . Si vous avez testé l'une des 2 solution dansexoB4.ml, testez l'autre dansexoB4b.ml(pensez à l'« enregistrez sous » ). Exercice B5: Sauvegarder le programme précédent sous un nouveau nom (exoB5.ml) et modifiez-le pour obtenir : Situation initiale : Tas 1 :"" Tas 2 :"T" Tas 3 :"K" Tas 4 :"" Situation Finale : Tas 1 :"T" Tas 2 :"K" Tas 3 :"" Tas 4 :"" Dans le codage Ocaml de l'algorithme, il n'y a que deux valeurs numériques à changer. Définissez-les à l'aide de 2 associations nom/valeurs
Exercice B6: Sauvegarder le programme précédent sous un nouveau nom (exoB6.ml) et modifiez-le pour obtenir : Situation initiale : Tas 1 :"" Tas 2 :"T" Tas 3 :"K" Tas 4 :"C" Situation Finale : Tas 1 :"T" Tas 2 :"K" Tas 3 :"C" Tas 4 :"" Dans le codage Ocaml de l'algorithme, il n'y a qu'une ligne à changer. Laquelle? faites-le
Exercice B7: Sauvegarder le programme précédent sous un nouveau nom (exoB7.ml) et modifiez-le pour obtenir : Situation initiale : Tas 1 :"T" Tas 2 :"K" Tas 3 :"C" Tas 4 :"" Situation Finale : Tas 1 :"" Tas 2 :"T" Tas 3 :"K" Tas 4 :"C" Dans le codage Ocaml de l'algorithme, il n'y a qu'un mot à changer et 2 valeurs à échanger. Lesquels? Faites-le
Exercice B8: le programme précédent comporte 3 parties :
mettre chacune d'entre elles (copier/coller) dans un fichier différent : exoB8I.mlcontient les initialisations exoB8A.mlcontient les affectations exoB8D.mlla boucle pour des déplacements. Testez, dans l'interprète ocamlcartes: #use "exoB8I.ml";; #use "exoB8A.ml";; #use "exoB8D.ml";;
Pour la suite, vous noterez le résultat de vos essais dans un fichier texte(<votreNom>.txt): On peut aussi taper directementdans l'interprète ocamlcartes(on peut utiliser avantageusement le copier/coller du contenu deexoB8I.ml) : init_tas(1, "T"); init_tas(2, "K"); init_tas(3, "C"); init_tas(4, "");; puis let ...= ...;;(* en remplaçant ces lignes par ce qu'il y a dansexoB8A.ml(pensez au copier/coller) *) et enfin #use "exoB8D.ml";; On va maintenant tester : Situation initiale : Tas 1 :"T" Tas 2 :"K" Tas 3 :"" Tas 4 :"" Situation Finale : Tas 1 :"" Tas 2 :"T" Tas 3 :"K" Tas 4 :"" dans l'interprète ocamlcartes(on peut utiliser avantageusement le copier/coller) : init_tas(1, "T"); init_tas(2, "K"); init_tas(3, ""); init_tas(4, "");; puis let ...= ...;;(* que faut-il mettre ici ? ) *) de façon à ce qu'on puisse réutiliser directement : #use "exoB8D.ml";; puis: Situation initiale : Tas 1 :"" Tas 2 :"T" Tas 3 :"K" Tas 4 :"" Situation Finale : Tas 1 :"" Tas 2 :"" Tas 3 :"T" Tas 4 :"K" dans l'interprète ocamlcartes(on peut remarquer qu'il est inutile de taper les 4 lignes qui suivent, puisque la nouvelle situation initiale correspond à la situation finale précédente, cependant, si l'on est amené à faire plusieurs tests il faudra bien réinitialiser … ) : init_tas(1, ""); init_tas(2, "T"); init_tas(3, "K"); init_tas(4, "");; mais directementlet ...= ...;;(* que faut-il mettre ici à la place des … ? ) *) de façon à ce qu'on puisse réutiliser directement : #use "exoB8D.ml";; et encore :
Situation initiale : Tas 1 :"" Tas 2 :"" Tas 3 :"T" Tas 4 :"K" Situation Finale : Tas 1 :"K" Tas 2 :"" Tas 3 :"" Tas 4 :"T" dans l'interprète ocamlcartes(on peut utiliser avantageusement le copier/coller, mais là encore, ce n'est pas la peine puisque la nouvelle situation initiale correspond à la situation finale précédente) : init_tas(1, ""); init_tas(2, ""); init_tas(3, "T"); init_tas(4, "K");; puis let ...= ...;;(* que faut-il mettre ici ) *) de façon à ce qu'on puisse réutiliser directement : #use "exoB8D.ml";; dommage : il faut réparer l'automate : Admin.repare();;
Partie 3 : Solution : il existe des opérateurs sur les entiers (on verra le détail dans les cours qui suivront) testez directementdans l'interprète ocamlcartes: 5 + 3;; 5 - 3;; 5 * 3;; cela se comprend facilement … 5 / 3 ;; ah, c'est la division entière et le reste ? 5 mod 3 ;; on peut aussi combiner ces différents opérateurs, mais, attention aux priorités (testez) : 5 mod 3 + 8 ;; 5 + 8 mod 3;; (5 + 8) mod 3 ;; ( on se souviendra du cours de math correspondant la division entière s'écrit a = b q + r a le dividende, b le diviseur, q le quotient et r le reste que l'on obtient grâce à ocaml pour q : a / b et pour r : a mod b) Interprétez et comprenez les résultats obtenus ci-dessus. Utilisation demod: à l'aide des tests préliminaires (donc assez indépendants des cartes) que vous allez fairedans l'interprète ocamlcartes, complétez le tableau ci-dessous :
n imod 3 1 22 2 03 3 11 4 22 5 03 6 11 7 23 Pour la 2ème colonne, il suffit de tester, dans l'interprète : … mod 3 ;; en essayant, à la place des …, les différentes valeurs de n (donc 7 essais). Pour la colonne 2 comme pour la 3, il s'agit de trouver une (seule) expression faisant intervenir mod , + , 1 ,et différentes valeurs de n; etqui donne cycliquement comme résultat respectivement 0,1,2 puis 0,1,2 puis 0,1,2 … pour la colonne2, on parle dans ce cas, en math, d'arithmétique modulaire  /n(ici /3) et 1,2,3 1,2,3 1,2,3 pour la colonne 3 Adaptez vos conclusions pour modifierexoB8D.mlenexoB9D.mlde façon à ce que l'on puisse déplacer cycliquement les2 cartes des tas 1 et 2 vers 2 et 3 puis 3et 4 puis 4 et 1 puis 1 et 2 et ainsi de suite...en tapant dansl'interprète ocamlcartes, init_tas(1, "T"); init_tas(2, "K"); init_tas(3, ""); init_tas(4, "");; let ...= ...;;(* que faut-il mettre ici ? ) *) #use "exoB9D.ml";; let ...=...; let ...= ...;;(* que faut-il mettre ici ? ) *) #use "exoB9D.ml";; let ...= ...;;(* que faut-il mettre ici ? ) *) #use "exoB9D.ml";; let ...= ...;;(* que faut-il mettre ici ? ) *) #use "exoB9D.ml";; let ...= ...;;(* que faut-il mettre ici ? ) *) #use "exoB9D.ml";; Vérifiez que cela fonctionne aussi avec un déplacement cyclique de 3 cartes: init_tas(1, "T"); init_tas(2, "K"); init_tas(3, "C"); init_tas(4, "");; let ...= ...;;(* que faut-il mettre ici ? ) *) #use "exoB9D.ml";; let ...= ...;;(* que faut-il mettre ici ? ) *) #use "exoB9D.ml";; let ...= ...;;(* que faut-il mettre ici ? ) *) #use "exoB9D.ml";; let ...= ...;;(* que faut-il mettre ici ? ) *) #use "exoB9D.ml";; let ...= ...;;(* que faut-il mettre ici ? ) *) #use "exoB9D.ml";; et même d'une seule
init_tas(1, "T"); init_tas(2, ""); init_tas(3, ""); init_tas(4, "");; let ...= ...;;(* que faut-il mettre ici ? ) *) #use "exoB9D.ml";; let ...= ...;;(* que faut-il mettre ici ? ) *) #use "exoB9D.ml";; let ...= ...;;(* que faut-il mettre ici ? ) *) #use "exoB9D.ml";; let ...= ...;;(* que faut-il mettre ici ? ) *) #use "exoB9D.ml";; let ...= ...;;(* que faut-il mettre ici ? ) *) #use "exoB9D.ml";; Conclure sur ce qu'il faut modifier comme association d'une version à l'autre. Ça marche avec une initialisation de 1, 2 ou 3 cartes . Est-ce que ça marche aussi avec 4? init_tas(1, "T"); init_tas(2, "K"); init_tas(3, "C"); init_tas(4, "P");; Pourquoi ? Écrire unexoB10D.ml pour faire « tourner » les cartes dans l'autre sens.
Écrire unexoB11.mlcette boucle dans une autre en séquence pour y inclure les initialisations puis avec une pause pour faire tourner dans un sens et dans l'autre de façon automatique
Soyez le premier à déposer un commentaire !

17/1000 caractères maximum.