INFO401 corr TD TP - Historique des versions

Hyvernat le 11 janvier 2010 à 10:13

2010-01-11T10:13:42Z

Laurent corantin : /* Le TP2 */

2009-05-27T16:22:50Z

Le TP2

← Version précédente		Version du 27 mai 2009 à 16:22
Ligne 1 198 :		Ligne 1 198 :

	</source>		</source>
			<br/>
			QUESTION 9:<br/>
			la fonction trouveVal permet de renvoyer si oui ou non une valeur est présente dans l'arbre binaire.
			<source lang="ocaml">

			let rec trouveVal arbre valAtrouve=
			match arbre with
			Vide->false
			\| Noeud (a,b,c)->
			if (b=valAtrouve)
			then true
			else
			if (valAtrouve<b)
			then trouveVal a valAtrouve
			else trouveVal c valAtrouve

			</source>
			<br/>

			QUESTION 10:<br/>
			la fonction supprime_doublon sur un arbre binaire est plus complexe que celle sur les liste, en effet il faut vérifier aussi les doublons pouvant exister sur des branche séparé.
			<source lang="ocaml">

			let rec suppDoublon arbre=
			match arbre with
			Vide->Vide
			\| Noeud (a,b,c)->
			if (trouveVal a b)
			then
			if (trouveVal c b)
			then Noeud((suppDoublon(supp a b)),b,(suppDoublon(supp c b)))
			else Noeud((suppDoublon(supp a b)),b,(suppDoublon c))
			else
			if (trouveVal c b)
			then Noeud((suppDoublon a),b,(suppDoublon(supp c b)))
			else Noeud((suppDoublon a),b,(suppDoublon c))

			</source>
			<br/>

	==Contrôle continu 1==		==Contrôle continu 1==

Laurent corantin : /* Le TP2 */

2009-05-22T11:55:33Z

Le TP2

← Version précédente		Version du 22 mai 2009 à 11:55
Ligne 1 146 :		Ligne 1 146 :
	QUESTION 6 :<br/>		QUESTION 6 :<br/>
	la fonction ajoute permet d'ajouter une donnée en conservant un arbre binaire.		la fonction ajoute permet d'ajouter une donnée en conservant un arbre binaire.
	<source>		<source lang="ocaml">

	let rec ajoute arbre aInsert=		let rec ajoute arbre aInsert=
Ligne 1 158 :		Ligne 1 158 :
	la fonction supp utilise aissi la fonction ajoute afin de conserver un arbre binaire.		la fonction supp utilise aissi la fonction ajoute afin de conserver un arbre binaire.

	<source>		<source lang="ocaml">

	let rec supp arbre aSupp=		let rec supp arbre aSupp=
Ligne 1 183 :		Ligne 1 183 :
	QUESTION 8:<br/>		QUESTION 8:<br/>
	afin de verifier si un arbre est binaire on effectue deux match simultané a tous les noeuds rencontrés en parcourant l'arbre.		afin de verifier si un arbre est binaire on effectue deux match simultané a tous les noeuds rencontrés en parcourant l'arbre.
	<source>		<source lang="ocaml">

	let rec verifabr arbre=		let rec verifabr arbre=

Laurent corantin : /* Le TP2 */

2009-05-22T11:54:33Z

Le TP2

@@ Ligne 1 143 : / Ligne 1 143 : @@
 </source>
 <br/>
 ==Contrôle continu 1==
 '''Partie 2'''

Vincent : /* Le TP3 */

2009-05-16T15:18:54Z

Le TP3

@@ Ligne 1 289 : / Ligne 1 289 : @@
 </source>
 on insère systématiquement dans le tas de droite, mais on permute le tas de gauche et le tas de droite a chaque fois pour "mélanger" le tas et avoir un tas équilibré
 ==Le TD5==

Vincent : /* Le TP3 */

2009-05-16T14:49:28Z

Le TP3

← Version précédente		Version du 16 mai 2009 à 14:49
Ligne 1 288 :		Ligne 1 288 :
	\| Noeud (tv,tg,td) -> Noeud( min tv v, td, ajouter (max tv v) tg);;		\| Noeud (tv,tg,td) -> Noeud( min tv v, td, ajouter (max tv v) tg);;
	</source>		</source>
	on insère systématiquement dans le tas de droite, mais on		on insère systématiquement dans le tas de droite, mais on permute le tas de gauche et le tas de droite a chaque fois pour "mélanger" le tas et avoir un tas équilibré
	permute le tas de gauche et le tas de droite a chaque fois pour "mélanger" le tas
	et avoir un tas équilibré

	==Le TD5==		==Le TD5==

Vincent : /* Le TP3 */

2009-05-16T14:48:49Z

Le TP3

@@ Ligne 1 280 : / Ligne 1 280 : @@
     (min,max) -> (max - min)<2 ;;  (* on calcule la difference entre max et min et on test si elle est inférieur à 2 *)
 </source>
 ==Le TD5==

Vincent : /* Le TP3 */

2009-05-16T14:36:48Z

Le TP3

@@ Ligne 1 255 : / Ligne 1 255 : @@
 <source lang="ocaml">
 let min_tas tas = ((premier tas),(enlever tas));;
 </source>

Vincent le 16 mai 2009 à 14:00

2009-05-16T14:00:53Z

← Version précédente		Version du 16 mai 2009 à 14:00
Ligne 1 206 :		Ligne 1 206 :

	==Le TP3==		==Le TP3==
			'''Partie 1'''

			'''Queston 1'''
			Déclaration du type pour les tas ( 'a tas )
			<source lang="ocaml">type 'a tas = Vide \| Noeud of 'a * 'a tas * 'a tas ;;</source>
			La fonction pour tester si un élement de type 'a tas est effectivement un tas :
			<source lang="ocaml">let rec test tas vPrec = match tas with
			Noeud(v,t1,t2) -> if v >= vPrec
			then ((test t1 v)&(test t2 v))
			else false
			\|Vide -> true

			let testTas tas = match tas with
			Noeud(v,_,_) -> test tas v
			\|Vide -> true </source>


			'''Queston 2'''
			Pour cette question nous allons écrire 3 fonctions.
			La première a pour but de supprimer le premier élément du tas (donc le plus petit), la seconde a pour but de retourner la valeur du premier élément du tas.

			<source lang="ocaml">(*Enleve le premier element du tas

			Explication du nom de variables
			tgv -> tas gauche valeur ( valeur du tas de gauche)
			tgg -> tas gauche gauche ( le tas gauche du tas gauche)
			tgd -> tas gauche droit ( le tas droit du tas gauche)
			*)
			let rec enlever tas = match tas with
			Vide -> Vide (* Si le tas est vide on retourne le tas Vide *)
			\| Noeud (v,Vide,td) -> td (* Si le tas gauche est Vide on retourne le tas droit *)
			\| Noeud (v,tg,Vide) -> tg (* Si le tas droit est Vide on retourne le tas gauche *)
			\| Noeud (v, (Noeud (tgv,tgg,tgd) as tg),
			(Noeud (tdv,tdg,tdd) as td)) (* Si aucun des deux tas est vide *)
			-> if tgv < tdv
			then Noeud (tgv, enlever tg, td)
			else Noeud (tdv, tg, enlever td);;
			</source>

			<source lang="ocaml">
			(* Renvoie la valeur du premier element du tas *)
			let premier tas = match tas with
			Vide -> raise Tas_Vide
			\| Noeud(v,_,_) -> v ;;
			</source>

			On combine ces deux fonctions pour crée la fonction demandée.
			<source lang="ocaml">
			let min_tas tas = ((premier tas),(enlever tas));;
			</source>

	==Le TD5==		==Le TD5==

Clamendji : /* Contrôle continu 1 */

2009-05-05T11:37:00Z

Contrôle continu 1

← Version précédente		Version du 5 mai 2009 à 11:37
Ligne 1 144 :		Ligne 1 144 :
	<br/>		<br/>
	==Contrôle continu 1==		==Contrôle continu 1==
	'''Partie 2'''		'''Partie 2'''

			'''Queston 1'''

	cette fonction s'applique a tout les elements d'une liste		cette fonction s'applique a tout les elements d'une liste

	'''let rec pam0 a l =		'''let rec pam0 a l '''=
	match l with []->[]		match l with []->[]
	\|f::l->(f a)::(pam0 a l)~~'''~~;;		\|f::l->(f a)::(pam0 a l);;


	la meme fonction mais cette fois on utilise Fold_right		la meme fonction mais cette fois on utilise Fold_right

	let pam a l = List.fold_right(fun f t ->(f a)::t)l [];;		''' let pam a l''' = List.fold_right(fun f t ->(f a)::t)l [];;

	ou encore la version avec List.map,elle a le meme type que pam		ou encore la version avec List.map,elle a le meme type que pam
	let pam1 a = List.map(fun f->f a);;		'''let pam1 a''' = List.map(fun f->f a);;

			'''Question 2'''
	question 2

	let rec seq i n = if n<i then []		'''let rec seq i n''' = if n<i then []
	else (seq i(n-1))@[n];;		else (seq i(n-1))@[n];;

Ligne 1 168 :		Ligne 1 170 :
	d'entier consecutifs et concatène un element en fin de liste par exemple::		d'entier consecutifs et concatène un element en fin de liste par exemple::
	seq 5 14;;		seq 5 14;;
	-:int list = [5;6;7;8;9;10;11;12;13;14]		'''-:int list''' = [5;6;7;8;9;10;11;12;13;14]
	mais a partir de 5 chriffres l'execution met plus d'une demi seconde		mais a partir de 5 chriffres l'execution met plus d'une demi seconde

	essayons la version simple		essayons la version simple
	let rec seq1 i n = if n<i then [] else i::(seq(i+1)n);;		'''let rec seq1 i n''' = if n<i then [] else i::(seq(i+1)n);;

	la version recursive terminale avec un accumulateur nous permettons d'avoir		la version recursive terminale avec un accumulateur nous permettons d'avoir
	une execution rapide de la fonction		une execution rapide de la fonction

	let seq2 i n =		'''let seq2 i n''' =
	let rec aux i n acc =		''' let rec aux i n acc '''=
	if n<i then acc		if n<i then acc
	else aux i(n-1) (n::acc)		else aux i(n-1) (n::acc)
Ligne 1 184 :		Ligne 1 186 :
	aux i n [];;		aux i n [];;

	'''~~partie~~ 3'''		'''Partie 3'''
	suite de robinson		suite de robinson
	ecrivons d'abord une iteration qui nous permet de repéter		ecrivons d'abord une iteration qui nous permet de repéter
	l'action sur la fonction		l'action sur la fonction
	'''let rec iter f n x = if n=0 then x else iter f(n-1)(f x);;~~'''~~		'''let rec iter f n x''' = if n=0 then x else iter f(n-1)(f x);;
	ensuite la fonction suivant pour passer d'un terme a l'autre		ensuite la fonction suivant pour passer d'un terme a l'autre
	''' let suivant u =		''' let suivant u '''=
	(*nous avons aussi la fonction aux permettant de compter le nombre de fois		(*nous avons aussi la fonction aux permettant de compter le nombre de fois
	ou d apparait dans n*)		ou d apparait dans n*)
	''' let rec aux u n d = match u with []->n::d::[]		''' let rec aux u n d '''= match u with []->n::d::[]
	\|a::u when a=d -> aux u (n+1) d		\|a::u when a=d -> aux u (n+1) d
	\|a::u->n::d::(aux u 1 a)		\|a::u->n::d::(aux u 1 a)
	in		in
	'''let u = List.sort(fun x y->y-x)u (*et la fonction u qui nous permet de trier par ordre		'''let u '''= List.sort(fun x y->y-x)u (*et la fonction u qui nous permet de trier par ordre
	decroissant en utilisant List.sort*)		decroissant en utilisant List.sort*)
	in		in

INFO401 corr TD TP - Historique des versions

Hyvernat le 11 janvier 2010 à 10:13

Laurent corantin : /* Le TP2 */

Laurent corantin : /* Le TP2 */

Laurent corantin : /* Le TP2 */

Vincent : /* Le TP3 */

Vincent : /* Le TP3 */

Vincent : /* Le TP3 */

Vincent : /* Le TP3 */

Vincent le 16 mai 2009 à 14:00

Clamendji : /* Contrôle continu 1 */

Laurent corantin : /* Le TP2 */

Laurent corantin : /* Le TP2 */

Laurent corantin : /* Le TP2 */

Vincent : /* Le TP3 */

Vincent : /* Le TP3 */

Vincent : /* Le TP3 */

Vincent : /* Le TP3 */

Clamendji : /* Contrôle continu 1 */