56c66b9d2b9db18e4557a5857adbe9c963be5e49 to master · Vuillemot Romain / INF-TC1

Original line number	Original line	Diff line number	Diff line
	%% Cell type:markdown id:4770edbf tags:		%% Cell type:markdown id:39a8f123 tags:

	NAME:		NAME:

	%% Cell type:markdown id:e1098061-ab50-4ba8-aa59-0b76ec1049a2 tags:		%% Cell type:markdown id:e1098061-ab50-4ba8-aa59-0b76ec1049a2 tags:

	# INF TC1 - TD3 (2h) - Arbres binaires		# INF TC1 - TD3 (2h) - Arbres binaires

	%% Cell type:markdown id:fc6c7558-96c4-435b-a841-e38c5d14bc9f tags:		%% Cell type:markdown id:fc6c7558-96c4-435b-a841-e38c5d14bc9f tags:

	---		---

	%% Cell type:markdown id:b0997389-5a87-4e8d-9600-29ed76e01759 tags:		%% Cell type:markdown id:b0997389-5a87-4e8d-9600-29ed76e01759 tags:

	<details style="border: 1px">		<details style="border: 1px">
	<summary> RAPPELS SUR L'UTILISATION DES NOTEBOOKS</summary>		<summary> RAPPELS SUR L'UTILISATION DES NOTEBOOKS</summary>

	### Comment utiliser ces notebooks ?		### Comment utiliser ces notebooks ?

	Le but de votre travail est de répondre aux questions des exercices en remplissant certaines cellules de ce notebook avec votre solution. Ces cellules, une foit remplies et lancées au fur et à mesure de vos avancées, permettront de valider des tests écrits dans d'autres cellules de ce notebook. Il est donc important de bien suivre les instructions et répondre aux questions dans l'ordre, et ne pas changer le nom des fonctions et/ou les cellules. En particulier :		Le but de votre travail est de répondre aux questions des exercices en remplissant certaines cellules de ce notebook avec votre solution. Ces cellules, une foit remplies et lancées au fur et à mesure de vos avancées, permettront de valider des tests écrits dans d'autres cellules de ce notebook. Il est donc important de bien suivre les instructions et répondre aux questions dans l'ordre, et ne pas changer le nom des fonctions et/ou les cellules. En particulier :

	1) Répondez aux questions dans les cellules en dessous des questions.		1) Répondez aux questions dans les cellules en dessous des questions.

	2) Votre code devra remplacer le texte suivant :		2) Votre code devra remplacer le texte suivant :

	```python		```python
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

	(vous pouvez effacer ces deux lignes quand vous les rencontrez mais ne modifiez pas les noms de fonctions sinon les tests ne marchent plus).		(vous pouvez effacer ces deux lignes quand vous les rencontrez mais ne modifiez pas les noms de fonctions sinon les tests ne marchent plus).

	3) Exécuter enfin les cellules dans leur ordre d'apparition, de haut en bas et si votre code est correct alors les tests (sous forme d'`assert` seront validés (ils ne lanceront pas d'exception du type `AssertionError` ). Vous pouvez lancer plusieurs fois la même cellule, cela ne pose pas de soucis.		3) Exécuter enfin les cellules dans leur ordre d'apparition, de haut en bas et si votre code est correct alors les tests (sous forme d'`assert` seront validés (ils ne lanceront pas d'exception du type `AssertionError` ). Vous pouvez lancer plusieurs fois la même cellule, cela ne pose pas de soucis.

	4) Vous pouvez créer de nouvelles cellules comme bon vous semble.		4) Vous pouvez créer de nouvelles cellules comme bon vous semble.

	En cas de problème, une solution est de relancer les cellules depuis le début du notebook une par une. Pensez à bien sauvegarder ce notebook et ne pas le remplacer par un notebook qui a le même nom.		En cas de problème, une solution est de relancer les cellules depuis le début du notebook une par une. Pensez à bien sauvegarder ce notebook et ne pas le remplacer par un notebook qui a le même nom.
	</details>		</details>

	%% Cell type:markdown id:de645c99-52cf-4cff-9c6b-b156101ad47c tags:		%% Cell type:markdown id:de645c99-52cf-4cff-9c6b-b156101ad47c tags:

	## Objectif du TD		## Objectif du TD

	Ce TD vous fera manipuler les Arbres Binaires, qui sont une structure de données permettant de stocker des informations de manière hierarchique, et de les récupérer grace à des méthodes de parcours.		Ce TD vous fera manipuler les Arbres Binaires, qui sont une structure de données permettant de stocker des informations de manière hierarchique, et de les récupérer grace à des méthodes de parcours.

	%% Cell type:markdown id:abde77ea-e21d-434e-b72e-a62ac464c793 tags:		%% Cell type:markdown id:abde77ea-e21d-434e-b72e-a62ac464c793 tags:

	## Exercice 1 : Introduction aux Arbres Binaires		## Exercice 1 : Introduction aux Arbres Binaires

	Dans ce exercice nous allons créer et parcourir un Arbre Binaire. Un Arbre Binaire est un Arbre qui a les propriétés suivantes :		Dans ce exercice vous allez créer et parcourir un Arbre Binaire. Un Arbre Binaire est un Arbre qui a les propriétés suivantes :

	- il comporte des noeuds ayant au _maximum deux enfants_		- il est dit _binaire_ car il comporte des noeuds ayant au _maximum_ deux enfants
	- il est dit _complet_ si tous les niveaux de l'arbre sont remplis (sauf éventuellement le dernier), et dans lequel les feuilles sont alignées à gauche		- il est dit _complet_ si tous les niveaux de l'arbre sont remplis (sauf éventuellement le dernier), et dans lequel les feuilles sont alignées à gauche
	- il est dit _équilibré_ si la différence de hauteur entre les sous-arbres gauche et droit de chaque nœud est au plus 1		- il est dit _équilibré_ si la différence de hauteur entre les sous-arbres gauche et droit de chaque nœud est au plus 1

	Voici un exemple d'Arbre Binaire :		Voici un exemple d'Arbre Binaire :

	```		```
	1		1
	/ \		/ \
	2 3		2 3
	```		```

	Dans cet exercice nous stockeront l'Arbre Binaire avec une structure de donnée _explicite_ en POO (comme ci-dessous) qui contient des valeurs entières (et uniques, à savoir deux noeuds n'auront pas la même valeur `value`) dans chaque noeud :		Dans cet exercice nous stockeront l'Arbre Binaire avec une structure de donnée _explicite_ (en POO comme ci-dessous, et non plus dans un tableau comme pour le tas dans le TD 2) qui contient des valeurs entières (et uniques, à savoir deux noeuds n'auront pas la même valeur `value`) dans chaque noeud :

	%% Cell type:code id:9318f291-f289-4eb6-a7f7-94cbc4e3f459 tags:		%% Cell type:code id:9318f291-f289-4eb6-a7f7-94cbc4e3f459 tags:

	``` python		``` python
	class Node:		class Node:
	def __init__(self, value : int, left = None, right = None):		def __init__(self, value : int, left = None, right = None):
	self.value = value		self.value = value
	self.left = left		self.left = left
	self.right = right		self.right = right
	```		```

	%% Cell type:markdown id:31993aa6-7361-4a58-856d-32f3a3fcec36 tags:		%% Cell type:markdown id:31993aa6-7361-4a58-856d-32f3a3fcec36 tags:

	Question 1.1 - Utilisez la structure de donnée `Node` ci-dessus afin d'implémenter l'arbre donné en introduction. Votre arbre sera stocké dans la variable `root`. Vous pouvez rajouter des noeuds supplémentaires à cet arbre (mais il doit rester binaire).		Question 1.1 - Utilisez la structure de donnée `Node` ci-dessus afin d'implémenter l'arbre donné en introduction. Votre arbre sera stocké dans la variable `root`. Vous pouvez rajouter des noeuds supplémentaires à cet arbre (mais il doit rester binaire).

	%% Cell type:code id:48a9b647-260e-40a5-a3da-c11ed77a9e62 tags:		%% Cell type:code id:48a9b647-260e-40a5-a3da-c11ed77a9e62 tags:

	``` python		``` python
	root = Node(1) # a modifier		root = Node(1) # a modifier
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

	%% Cell type:markdown id:0a4461c4-09b8-4f9f-ad70-6b953dc4b7e6 tags:		%% Cell type:markdown id:0a4461c4-09b8-4f9f-ad70-6b953dc4b7e6 tags:

	Les tests suivant doivent être validés (vous pouvez rajouter d'autres tests) :		Les tests suivant doivent être validés (rajoutez d'autres tests) :

	%% Cell type:code id:c08d3050-ccba-4b51-8a01-1d2689455e96 tags:		%% Cell type:code id:c08d3050-ccba-4b51-8a01-1d2689455e96 tags:

	``` python		``` python
	assert root.value == 1		assert root.value == 1
	assert root.left.value == 2		assert root.left.value == 2
	assert root.right.value == 3		assert root.right.value == 3
	```		```

	%% Cell type:markdown id:24670502-ecd5-4d86-a32c-1d7d43eb04fe tags:		%% Cell type:markdown id:24670502-ecd5-4d86-a32c-1d7d43eb04fe tags:

	Question 1.2. Proposer une méthode `bfs` de _parcours en largeur_ de l'Arbre afin d'afficher la valeur des noeuds dans l'ordre croissant. Pour cela vous utiliserez une structure de données de File (sous forme de liste, cela sera suffisant). Une méthode possible pour mener cela à bien consiste à :		Question 1.2. Proposez une méthode `bfs` de _parcours en largeur_ de l'Arbre afin d'afficher la valeur des noeuds dans l'ordre croissant. Pour cela vous utiliserez une structure de données de File (sous forme de liste, cela sera suffisant). Une méthode possible pour mener cela à bien consiste à :

	1. Intialiser la File avec la racine de l'Arbre		1. intialiser la File avec la racine de l'Arbre;
	2. Dé-filer une valeur et la stocker dans une liste de résultat		2. dé-filer une valeur et la stocker dans une liste de résultats;
	3. En-filer ses enfants (si il y en a) dans la File		3. en-filer ses enfants (si il y en a) dans la File;
	4. Répéter l'étape 2 jusqu'à ce que la File soit vide, renvoyer le résultat		4. répéter l'étape 2 jusqu'à ce que la File soit vide, renvoyer le résultat.

	%% Cell type:code id:1f92e83b-ba51-4fa4-a127-2aa970a96a26 tags:		%% Cell type:code id:1f92e83b-ba51-4fa4-a127-2aa970a96a26 tags:

	``` python		``` python
	def bfs(node: Node):		def bfs(node: Node):
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

	%% Cell type:code id:c1b198c7-8387-4552-a163-7a70a70c61a3 tags:		%% Cell type:code id:c1b198c7-8387-4552-a163-7a70a70c61a3 tags:

	``` python		``` python
	assert bfs(root) == [1, 2, 3]		assert bfs(root) == [1, 2, 3]
	```		```

	%% Cell type:markdown id:675c8c46-ed69-4a2e-a9cf-57301112e3ab tags:		%% Cell type:markdown id:675c8c46-ed69-4a2e-a9cf-57301112e3ab tags:

	Question 1.3 - Écrire une fonction `depth` de calcul de la _profondeur_ d'un noeud d'un Arbre. La profondeur est défini comme la distance entre ce noeud et la racine (celle-ci aura une profondeur de `0`) ou autrement dit le nombre d'arête entre le noeud et la racine. Cette fonction prendra en paramètre la racine de l'arbre `root`, ainsi que le noeud dont on veut calculer la profondeur avec le paramètre `target_value`.		Question 1.3 - Écrivez une fonction `depth` de calcul de la _profondeur_ d'un noeud d'un Arbre. La profondeur est défini comme la distance entre ce noeud et la racine (celle-ci aura une profondeur de `0`). Autrement dit la profondeur correspond au nombre d'arêtes entre un noeud et la racine de l'arbre. Cette fonction prendra en paramètre la racine de l'arbre `root`, ainsi que le noeud dont on veut calculer la profondeur avec le paramètre `target_value`.

	Conseils :		Conseils :

	- s'inspirer de la fonction précédente en incluant la profondeur de chaque noeud parcouru lors de son ajout dans la file;		- s'inspirer de la fonction précédente de parcours en largeur en incluant la profondeur de chaque noeud parcouru lors de son ajout dans la file;
	- autrement dit rajouter un tuple `(noeud, profondeur)` au lieu du simple noeud parcouru.		- autrement dit rajouter un tuple `(noeud, profondeur)` au lieu du simple noeud parcouru afin de mémoriser la profondeur des noeuds parcourus.

	%% Cell type:code id:6c21f3f7-0f21-47ad-a4ce-a2af7b9743d4 tags:		%% Cell type:code id:6c21f3f7-0f21-47ad-a4ce-a2af7b9743d4 tags:

	``` python		``` python
	def depth(root: Node, target_value: int) -> int:		def depth(root: Node, target_value: int) -> int:
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

	%% Cell type:code id:37a27a50-68f4-486b-a0da-b0905b8db8dd tags:		%% Cell type:code id:37a27a50-68f4-486b-a0da-b0905b8db8dd tags:

	``` python		``` python
	assert depth(root, 1) == 0		assert depth(root, 1) == 0
	assert depth(root, 2) == 1		assert depth(root, 2) == 1
	assert depth(root, 3) == 1		assert depth(root, 3) == 1
	```		```

	%% Cell type:markdown id:f8abb2f4-24dc-4346-9081-4400df30e3af tags:		%% Cell type:markdown id:f8abb2f4-24dc-4346-9081-4400df30e3af tags:

	Question 1.4 - Écrire une fonction `height` de calcul de la _hauteur_ d'un Arbre définie comme la prodondeur maximale possible dans un Arbe. Vous pouvez l'implémenter comme la profondeur maximale des noeuds de l'Arbre, ou bien de manière récursive.		Question 1.4 - Écrivez une fonction `height` de calcul de la _hauteur_ d'un Arbre définie comme la prodondeur maximale possible dans un Arbe. Vous pouvez l'implémenter comme la profondeur maximale des noeuds de l'Arbre, ou bien de manière récursive.

	%% Cell type:code id:4944b0bb-5f59-41c2-b5d9-052a0d5386dd tags:		%% Cell type:code id:4944b0bb-5f59-41c2-b5d9-052a0d5386dd tags:

	``` python		``` python
	def height(root: Node) -> int:		def height(root: Node) -> int:
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

	%% Cell type:code id:2d11935c-2212-4ec3-ba57-5303ec05b274 tags:		%% Cell type:code id:2d11935c-2212-4ec3-ba57-5303ec05b274 tags:

	``` python		``` python
	assert height(root) == 2		assert height(root) == 1
	```		```

	%% Cell type:markdown id:29fca7e0-aaf9-495b-822d-f20e1a672092 tags:		%% Cell type:markdown id:29fca7e0-aaf9-495b-822d-f20e1a672092 tags:

	Question 1.5 - Valider si l'Arbre est bien équilibré, autrement dit si il n'y a pas de différence de profondeur suppérieur à 1 entre les feuilles d'un arbre.		Question 1.5 - Ecrivez une fonction de validation afin de déterminer si un Arbre est bien équilibré, autrement dit si il n'y a pas de différence de profondeur suppérieur à 1 entre les feuilles d'un arbre. Conseil : utilisez une approche récursive.

	%% Cell type:code id:3b4f56e8-e4bf-4d27-97eb-b24995d741fe tags:		%% Cell type:code id:3b4f56e8-e4bf-4d27-97eb-b24995d741fe tags:

	``` python		``` python
	def est_equlibre(root: Node) -> bool:		def est_equlibre(root: Node) -> bool:
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

	%% Cell type:code id:69b03c9b-2092-4343-b9e4-7d9904a445b0 tags:		%% Cell type:code id:69b03c9b-2092-4343-b9e4-7d9904a445b0 tags:

	``` python		``` python
	assert est_equlibre(root)		assert est_equlibre(root)
	```		```

	%% Cell type:markdown id:9e29fddc-c249-4b2a-a9d3-26e56f5474ab tags:		%% Cell type:markdown id:9e29fddc-c249-4b2a-a9d3-26e56f5474ab tags:

	## Exercice 2 : Arbres syntaxiques		## Exercice 2 : Arbres syntaxiques

	Un Arbre _syntaxique_ permet le stockage d'une expression structurée, par exemple une équation. Dans cet exercice nous allons modéliser un tel arbre sous forme d'arbre binaire (exemple ci-dessous à gauche) afin de réaliser un calcul arithmétique simple à partir de l'expression fournie de manière textuelle :		Un Arbre _syntaxique_ permet le stockage d'une expression structurée, par exemple une équation. Dans cet exercice nous allons modéliser un tel arbre sous forme d'arbre binaire (exemple ci-dessous à gauche) afin de réaliser un calcul arithmétique simple à partir de l'expression fournie de manière textuelle :

	Expression : `(3-2) * (7+(10/2))`		Expression : `(3-2) * (7+(10/2))`

	Résultat : `12.0`		Résultat : `12.0`

	Nous ferons l'hypothèse que les opérations sont limitées à `+ - / *`, seront toujours binaires et porteront sur des valeurs numériques entières (mais le résultat peut ne pas être un entier).		Nous ferons l'hypothèse que les opérations sont limitées à `+ - / *`, seront toujours binaires et porteront sur des valeurs numériques entières (mais le résultat peut ne pas être un entier).

	```		```
	*		*
	/ \		/ \
	- +		- +
	/ \ / \		/ \ / \
	3 2 7 /		3 2 7 /
	/ \		/ \
	10 2		10 2
	```		```

	Vous utiliserez la structure d'arbre binaire ci-dessous afin de le stocker :		Vous utiliserez la structure d'arbre binaire ci-dessous afin de stocker l'arbre comme pour l'abre binaire précédent :

	%% Cell type:code id:e78ec913-cd5f-4304-8c8a-438758d909f4 tags:		%% Cell type:code id:e78ec913-cd5f-4304-8c8a-438758d909f4 tags:

	``` python		``` python
	class Noeud:		class Noeud:
	def __init__(self, v = None, g = None, d = None) -> None:		def __init__(self, v = None, g = None, d = None) -> None:
	self.valeur = v		self.valeur = v
	self.gauche = g		self.gauche = g
	self.droit = d		self.droit = d
	```		```

	%% Cell type:markdown id:88fbc62f-ae5a-4765-bf8f-bb127f5d5a13 tags:		%% Cell type:markdown id:88fbc62f-ae5a-4765-bf8f-bb127f5d5a13 tags:

	Question 2.1 - Utilisez la structure de données d'Arbre ci-dessus afin de stocker l'Arbre syntaxique donné en exemple.		Question 2.1 - Stockez l'Arbre syntaxique donné en exemple graphique en utilisant la structure de données d'arbre binaire ci-dessus (il s'agit d'écrire une instance d'arbre dans la variable `arbre`, et non une fonction).

	%% Cell type:code id:4661ca46-489c-4330-9e72-64fe25e4b49c tags:		%% Cell type:code id:4661ca46-489c-4330-9e72-64fe25e4b49c tags:

	``` python		``` python
	arbre = None # à changer		arbre = None # à changer
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

	%% Cell type:code id:cee8c8d3-f4ab-4dcc-931e-f0b8681b225c tags:		%% Cell type:code id:cee8c8d3-f4ab-4dcc-931e-f0b8681b225c tags:

	``` python		``` python
	assert arbre.valeur == "*"		assert arbre.valeur == "*"
	assert arbre.gauche.valeur == "-"		assert arbre.gauche.valeur == "-"
	assert arbre.droit.valeur == "+"		assert arbre.droit.valeur == "+"
	```		```

	%% Cell type:markdown id:0be8aab9-1aba-4340-9235-eb3d1cc7fd29 tags:		%% Cell type:markdown id:0be8aab9-1aba-4340-9235-eb3d1cc7fd29 tags:

	Question 2.2 - Implémenter désormais une méthode d'évaluation (autrement dit de calcul) automatique d'un arbre syntaxique tel que vous l'avez stocké dans la variable `arbre` ci-dessus.		Question 2.2 - Implémentez désormais une méthode d'évaluation (autrement dit de calcul) automatique d'un arbre syntaxique tel que vous l'avez stocké dans la variable `arbre` ci-dessus.

	Conseil : proposer une solution récursive avec un cas d'arrêt et des appels récursifs comme suit :		Conseil : proposez une solution récursive avec un cas d'arrêt et des appels récursifs comme suit :
	- si la valeur du noeud en cours est un opérateur, l'appliquer sur les deux sous-branches;		- si la valeur du noeud en cours est un opérateur, l'appliquer sur les deux sous-branches;
	- si c'est une valeur numérique, renvoyer cette valeur (cas d'arrêt car c'est une feuille de l'arbre)		- si il s'agit d'une valeur numérique, renvoyez cette valeur (cas d'arrêt car c'est une feuille de l'arbre).

	%% Cell type:code id:dc899d17-67fd-4cc9-bf92-f5f32e08f89e tags:		%% Cell type:code id:dc899d17-67fd-4cc9-bf92-f5f32e08f89e tags:

	``` python		``` python
	def eval(r: Noeud) -> float:		def eval(r: Noeud) -> float:
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

	%% Cell type:code id:00eb3e33-64b1-486f-97c8-d87de80f3a1a tags:		%% Cell type:code id:00eb3e33-64b1-486f-97c8-d87de80f3a1a tags:

	``` python		``` python
	eval(arbre)		eval(arbre)
	```		```

	%% Cell type:markdown id:de5c394d-df35-4d7b-b057-164620b0b38d tags:		%% Cell type:markdown id:de5c394d-df35-4d7b-b057-164620b0b38d tags:

	Question 2.3 - Écrire une méthode permettant de construire l'Arbre à partir d'une expression fournie sous forme de chaîne de caractère en entrée comme `( ( 3 - 2 ) * ( 7 + ( 10 / 2 ) ) )"`. Les espaces sont nécessaires et vous permettront de faire un `.split(" ")}`.		Question 2.3 - Écrivez une méthode permettant de construire l'Arbre à partir d'une expression fournie sous forme de chaîne de caractère en entrée comme `( ( 3 - 2 ) * ( 7 + ( 10 / 2 ) ) )`. Les espaces sont nécessaires et vous permettront de faire un `.split(" ")`.

	Conseil :		Conseil :
	- parcourez caractère par caractère l'expression textuelle transformée en liste;		- parcourez caractère par caractère l'expression textuelle transformée en liste;
	- créez au fur et à mesure l'arbre initialisé par une racine et une variable stockage le noeud courant en cours de construction		- créez au fur et à mesure l'arbre initialisé par une racine et une variable stockage le noeud courant en cours de construction;
	- identifiez les 4 cas possibles : début d'une expression, valeurs numériques, opérateur, fin d'une expression		- identifiez les 4 cas possibles : début d'une expression, valeurs numériques, opérateur, fin d'une expression :
	- si une expression commence, créer un nouveau fils gauche au noeud courant et stockez le noeud courant dans une Pile		- si une expression commence, créez un nouveau fils gauche au noeud courant et stockez le noeud courant dans une Pile
	- si une expression finie, considérez comme noeud courant l'élément que vous dé-Pilerez		- si une expression finie, considérez comme noeud courant l'élément que vous dé-Pilerez
	- si un opérateur, stocker sa valeur dans le noeud courant, empiliez ce noeud mais avant lui rajoute un fils droit qui devient le noeud courant		- si un opérateur, stockez sa valeur dans le noeud courant, empilez ce noeud mais avant lui rajoute un fils droit qui devient le noeud courant
	- si une valeur numérique, la stocker dans le noeud courant et considérez comme noeud courant l'élément que vous dé-Pilerez		- si une valeur numérique, la stocker dans le noeud courant et considérez comme noeud courant l'élément que vous dé-Pilerez

	%% Cell type:code id:1c33faaa-2289-498f-9ef1-5afeb4da4628 tags:		%% Cell type:code id:1c33faaa-2289-498f-9ef1-5afeb4da4628 tags:

	``` python		``` python
	def construit_arbre(exp: str) -> int:		def construit_arbre(exp: str) -> int:
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

	%% Cell type:code id:b56d0304-5d23-4e1c-91fb-09b511465ad5 tags:		%% Cell type:code id:b56d0304-5d23-4e1c-91fb-09b511465ad5 tags:

	``` python		``` python
	r = construit_arbre("( ( 3 - 2 ) * ( 7 + ( 10 / 2 ) )")		r = construit_arbre("( ( 3 - 2 ) * ( 7 + ( 10 / 2 ) )")
	```		```

	%% Cell type:markdown id:89a9015c-dd4e-409d-91b2-9b64b55288e9 tags:		%% Cell type:markdown id:89a9015c-dd4e-409d-91b2-9b64b55288e9 tags:

	Enfin vérifiez que vous obtenez la bonne valeur en évaluant l'expression.		Enfin vérifiez que vous obtenez la bonne valeur en évaluant l'expression.

	%% Cell type:code id:e5c49c1f-75e0-4872-8578-40a532c7cea1 tags:		%% Cell type:code id:e5c49c1f-75e0-4872-8578-40a532c7cea1 tags:

	``` python		``` python
	assert eval(r) == 12.0		assert eval(r) == 12.0
	```		```

	%% Cell type:markdown id:012a5378-a2b7-498f-8115-e35f55c529ce tags:		%% Cell type:markdown id:012a5378-a2b7-498f-8115-e35f55c529ce tags:

	Question 2.4 (Bonus) - - Ecrire une fonction qui renvoie `True` ou `False` si l'Arbre est bien un arbre syntaxique tel que défini en introduction. Autrement dit qu'il est binaire, et comporte des opérateurs partout sauf aux feuilles.		Question 2.4 (Bonus) - Ecrire une fonction qui renvoie `True` ou `False` si l'Arbre est bien un arbre syntaxique tel que défini en introduction. Autrement dit qu'il est binaire, et comporte des opérateurs partout sauf aux feuilles.

	Proposez une méthode itérative :		Proposez d'abord une méthode itérative :

	%% Cell type:code id:823d29e7-66c3-41a0-bdad-da6862a5e420 tags:		%% Cell type:code id:823d29e7-66c3-41a0-bdad-da6862a5e420 tags:

	``` python		``` python
	def valide_ite(r: Noeud) -> bool:		def valide_ite(r: Noeud) -> bool:
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

	%% Cell type:code id:06e73b57-959a-436f-bd7a-e12c615c805c tags:		%% Cell type:code id:06e73b57-959a-436f-bd7a-e12c615c805c tags:

	``` python		``` python
	assert valide_ite(arbre)		assert valide_ite(arbre)
	```		```

	%% Cell type:markdown id:dfdf1d42-60bb-4a7e-9cd4-e6cb72b8130a tags:		%% Cell type:markdown id:dfdf1d42-60bb-4a7e-9cd4-e6cb72b8130a tags:

	Proposez une méthode récursive :		Proposez ensuite une méthode récursive :

	%% Cell type:code id:df0033e9-c076-4cde-ab6f-982a3677ce05 tags:		%% Cell type:code id:df0033e9-c076-4cde-ab6f-982a3677ce05 tags:

	``` python		``` python
	def valide_rec(r: Noeud) -> bool:		def valide_rec(r: Noeud) -> bool:
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

	%% Cell type:code id:9998c852-ec74-4225-9f01-4368899e303f tags:		%% Cell type:code id:9998c852-ec74-4225-9f01-4368899e303f tags:

	``` python		``` python
	assert valide_rec(arbre)		assert valide_rec(arbre)
	```		```

			%% Cell type:markdown id:3503e6a5-2bc1-46d2-bef0-d1f1ceb6827e tags:

			Montrez que les deux méthodes ont un comportement identique :

			%% Cell type:code id:81e1b468-5d22-4a25-a2c3-17ab165627e5 tags:

			``` python
			# YOUR CODE HERE
			raise NotImplementedError()
			```

			%% Cell type:markdown id:81842c6c-1784-432b-8322-f3793d633e03 tags:

			Question 2.5 (Bonus) - Créez une table de hachage afin de mémoriser les opérations déja réalisées pour l'Arbre syntaxique. Conseil : utilisez les informations sur le noeud comme clé (valeurs, opérateur).

			%% Cell type:code id:fb91bda6-7076-44be-9014-ceb5507eb01c tags:

			``` python
			def eval_hash(r: Noeud, memo=None) -> float:
			# YOUR CODE HERE
			raise NotImplementedError()
			```

			%% Cell type:code id:22979a11-3455-4525-b816-a84b2164291c tags:

			``` python
			assert eval_hash(arbre) == eval(arbre)
			```

	%% Cell type:markdown id:85c6a3e6-dea0-4e86-b7d9-b0c5735c3630 tags:		%% Cell type:markdown id:85c6a3e6-dea0-4e86-b7d9-b0c5735c3630 tags:

	## Pour aller plus loin		## Pour aller plus loin

	- Rajouter des tests dans les exemples ci-dessus avec des arbres plus complexes, des cas particuliers, etc.		- Rajouter des tests dans les exemples ci-dessus avec des arbres plus complexes, des cas particuliers, etc.
	- Inclure des Exceptions dans votre code afin de gérer par exemple l'accès à un index de liste inexistant, etc.		- Inclure des [Exceptions](https://docs.python.org/3/tutorial/errors.html) dans votre code afin de gérer par exemple l'accès à un index de liste inexistant, etc.
	- Créer une table de hachage afin de mémoriser les opérations déja réalisées pour l'Arbre syntaxique
	- Modulariser votre code afin de créer des fonctions auxiliaires (par exemple pour vérifier la valeur des noeuds de l'Arbre syntaxique).		- Modulariser votre code afin de créer des fonctions auxiliaires (par exemple pour vérifier la valeur des noeuds de l'Arbre syntaxique).

	%% Cell type:markdown id:08c48261 tags:		%% Cell type:markdown id:08c48261 tags:

	## Visualiser avec Graphviz		## Visualiser avec Graphviz

	Graphviz est une bibliothèque de visualisation de graphe. Elle peut être très pratique afin de comprendre la structure de votre instance de graphe.		Graphviz est une bibliothèque de visualisation de graphe. Elle peut être très pratique afin de comprendre la structure de votre instance de graphe.

	Cependant, la bibliothèque pose quelques soucis d'installation en Python, voici des étapes éventuellement à suivre.		Cependant, la bibliothèque pose quelques soucis d'installation en Python, voici des étapes éventuellement à suivre.

	Tout d'abord vérifiez que le module est bien installé :		Tout d'abord vérifiez que le module est bien installé :

	%% Cell type:code id:c8c95b89 tags:		%% Cell type:code id:c8c95b89 tags:

	``` python		``` python
	!pip install graphviz		!pip install graphviz
	```		```

	%% Cell type:markdown id:5a9ebd95 tags:		%% Cell type:markdown id:5a9ebd95 tags:

	Si oui (vous avez le message du type `Requirement already satisfied:`) testez l'import du module :		Si oui (vous avez le message du type `Requirement already satisfied:`) testez l'import du module :

	%% Cell type:code id:e897987f tags:		%% Cell type:code id:e897987f tags:

	``` python		``` python
	import graphviz		import graphviz
	from graphviz import Digraph		from graphviz import Digraph
	```		```

	%% Cell type:markdown id:2bf9b677 tags:		%% Cell type:markdown id:2bf9b677 tags:

	Si vous avez des erreurs, essayer l'installation du module à partir des exécutables		Si vous avez des erreurs, essayer l'installation du module à partir des exécutables

	%% Cell type:code id:bd3cfb66 tags:		%% Cell type:code id:bd3cfb66 tags:

	``` python		``` python
	https://graphviz.org/		https://graphviz.org/
	```		```

	%% Cell type:markdown id:9373f3bc tags:		%% Cell type:markdown id:9373f3bc tags:

	Un autre source d'erreur est l'installation à partir de la mauvaise version de Python qu'il faut utiliser avec pip.		Un autre source d'erreur est l'installation à partir de la mauvaise version de Python qu'il faut utiliser avec pip.

	%% Cell type:code id:504eff4a tags:		%% Cell type:code id:504eff4a tags:

	``` python		``` python
	!python --version		!python --version
	```		```

	%% Cell type:code id:5eb4ab77 tags:		%% Cell type:code id:5eb4ab77 tags:

	``` python		``` python
	from IPython.display import display		from IPython.display import display
	def visualize_oop(root):		def visualize_oop(root):
	def build(node, dot=None):		def build(node, dot=None):
	if dot is None:		if dot is None:
	dot = graphviz.Digraph(format='png')		dot = graphviz.Digraph(format='png')

	if node is not None:		if node is not None:
	dot.node(str(node.value))		dot.node(str(node.value))

	if node.left is not None:		if node.left is not None:
	dot.edge(str(node.value), str(node.left.value))		dot.edge(str(node.value), str(node.left.value))
	build(node.left, dot)		build(node.left, dot)

	if node.right is not None:		if node.right is not None:
	dot.edge(str(node.value), str(node.right.value))		dot.edge(str(node.value), str(node.right.value))
	build(node.right, dot)		build(node.right, dot)

	return dot		return dot

	return build(root)		return build(root)
	```		```

	%% Cell type:code id:ded5b1fe tags:		%% Cell type:code id:ded5b1fe tags:

	``` python		``` python
	visualize_oop(root)		visualize_oop(root)
	```		```

TD04/INF-TC1-td04.ipynb

+123 −56

File changed.

Preview size limit exceeded, changes collapsed.

TD05/INF-TC1-td05.ipynb

+20 −27

Original line number	Original line	Diff line number	Diff line
	%% Cell type:markdown id:052d9fc3 tags:		%% Cell type:markdown id:751c51f9 tags:

	NAME:		NAME:

	%% Cell type:markdown id:b97bad7e-82ff-44a7-9779-13c139085623 tags:		%% Cell type:markdown id:b97bad7e-82ff-44a7-9779-13c139085623 tags:

	# INF TC1 - TD5 (2h) - Devoir à rendre #1		# INF TC1 - TD5 (2h + 2h AUTONOMIE) - Devoir à rendre #1

	%% Cell type:markdown id:1bb26026-8560-4a3c-90e6-2cfd7a49320a tags:		%% Cell type:markdown id:1bb26026-8560-4a3c-90e6-2cfd7a49320a tags:

	---		---

	%% Cell type:markdown id:dd8d4905-55f9-4957-8008-a963cc6de061 tags:		%% Cell type:markdown id:dd8d4905-55f9-4957-8008-a963cc6de061 tags:

	Vous serez évalué sur le rendu de ce TD qui sera à déposer sur Moodle deux (2) semaines après les séances d'autonomie et de TD. Le rendu sera à réaliser sous forme de notebook qui contient votre code et images.		Vous serez évalué sur le rendu de ce TD qui sera à déposer sur Moodle deux (2) semaines après la séance d'autonomie #1. Le rendu sera à réaliser sous forme de notebook qui contient votre code et images.

	%% Cell type:markdown id:99ee8fad-7f32-4fe2-85d3-3b8da49f317f tags:		%% Cell type:markdown id:99ee8fad-7f32-4fe2-85d3-3b8da49f317f tags:

	<details style="border: 1px">		<details style="border: 1px">
	<summary> MODALITES DE RENDU</summary>		<summary> MODALITES DE RENDU</summary>

	### Comment rendre son devoir ?		### Comment rendre son devoir ?

	Vous serez évalué sur le rendu de ce TD qui sera à déposer sur Moodle deux (2) semaines après les séances d'autonomie et de TD. Vous devrez créer une archive (zip, rar, etc.) nomée `nom1-nom2-inf-tc1-td5.zip` qui contiendra tous les éléments de votre rendu (rapport en notebook, code, images de test). Vous pouvez rendre ce rapport seul ou en binôme. Le rendu du TD doit contenir a minima :		Vous serez évalué sur le rendu de ce TD qui sera à déposer sur Moodle deux (2) semaines après les séances d'autonomie et de TD. Vous devrez créer une archive (zip, rar, etc.) nomée `nom1-nom2-inf-tc1-td5.zip` qui contiendra tous les éléments de votre rendu (rapport en notebook, code, images de test). Vous pouvez rendre ce rapport seul ou en binôme. Le rendu du TD doit contenir a minima :

	1. Toutes les étapes jusqu'à la 6ème doivent avoir été abordées		1. Toutes les étapes jusqu'à la 6ème doivent avoir été abordées
	2. Justifications, illustrations et tests sur plusieurs images		2. Justifications, illustrations et tests sur plusieurs images

	A garder en tête :		A garder en tête :

	- Un code fonctionnel et les tests appropriés devront être fournis dans l'archive qui doit être autonome (le correcteur ne doit pas avoir à rajouter d'image ou de fichier supplémentaire)		- Un code fonctionnel et les tests appropriés devront être fournis dans l'archive qui doit être autonome (le correcteur ne doit pas avoir à rajouter d'image ou de fichier supplémentaire)

	- Vous fournirez les images de test et leurs résultats; évitez cependant de prendre des tailles d'images trop importantes.		- Vous fournirez les images de test et leurs résultats; évitez cependant de prendre des tailles d'images trop importantes.

	- Le rapport devra être au format Notebook Jupyter et comprendre :		- Le rapport devra être au format Notebook Jupyter et comprendre :

	- Le détail des étapes que vous avez suivies		- Le détail des étapes que vous avez suivies

	- La description de parties de code difficiles		- La description de parties de code difficiles

	- Tout souci ou point bloquant dans votre code		- Tout souci ou point bloquant dans votre code

	- Les graphiques et diagrammes nécessaires		- Les graphiques et diagrammes nécessaires

	- Des analyses et discussions en lien avec votre approche		- Des analyses et discussions en lien avec votre approche

	- Des exemples simples mais aussi difficiles		- Des exemples simples mais aussi difficiles

	Tout travail supplémentaire (méthode originale, optimisation poussée) fera l'objet de points en bonus.		Tout travail supplémentaire (méthode originale, optimisation poussée) fera l'objet de points en bonus.



	Voici une suggestion afin de se faire un ordre d'idée		Voici une suggestion afin de se faire un ordre d'idée

	En dessous de 10 :

	- Les étapes suivies
	- Un code fonctionnel et les méthodes basiques
	- Un rapport de quelques pages
	- Un code certes fonctionnel mais peu commenté
	- Les exemples d'images fournies

	Un groupe avec une note entre 10 et 12 :		Un groupe avec une note entre 10 et 12 :

	- Les étapes suivies		- Les étapes suivies
	- Un code fonctionnel et les méthodes basiques		- Un code fonctionnel et les méthodes basiques
	- Un rapport de quelques pages		- Un rapport succint
	- Un code certes fonctionnel mais peu commenté		- Un code certes fonctionnel mais peu commenté
	- Les exemples d'images fournies		- Les exemples d'images fournies

	Un groupe entre 12 et 14 a en plus proposé :		Un groupe entre 12 et 14 a en plus proposé :

	- Des structures de données avancées (Set, Files, etc)		- Des structures de données avancées (Ensembles, Files, etc)
	- Une justification de chaque étape		- Une justification de chaque étape
	- Une méthode un petit peu plus poussée		- Une méthode un petit peu plus poussée

	Un groupe entre 14 et 16 a en plus proposé :		Un groupe entre 14 et 16 a en plus proposé :

	- Une méthode originale (K-Means, etc)		- Une méthode originale (K-Means, etc)
	- Une démarche expérimentale très détaillée sur les optimisations		- Une démarche expérimentale très détaillée sur les optimisations
	- Des tests plutôt originaux		- Des tests plutôt originaux

	Un groupe au-dessus de 16 comporte une ou plusieurs parties exceptionnelles :		Un groupe au-dessus de 16 comporte une ou plusieurs parties exceptionnelles :

	- Rapport très détaillé et exemplaire sur le fond comme sur la forme		- Rapport très détaillé et exemplaire sur le fond comme sur la forme
	- Une démarche expérimentale très détaillée sur les optimisations		- Une démarche expérimentale très détaillée sur les optimisations
	- Code et tests		- Code et tests



	</details>		</details>

	%% Cell type:markdown id:d48155b2-8db8-4557-a66b-363351712560 tags:		%% Cell type:markdown id:d48155b2-8db8-4557-a66b-363351712560 tags:

	## Objectif du devoir		## Objectif du devoir

	Le but de ce devoir est de déterminer automatiquement une palette de couleurs optimale pour une image donnée. Cette palette devra valider les contraintes suivantes :		Le but de ce devoir est de déterminer automatiquement une palette de couleurs optimale pour une image donnée. Cette palette devra valider les contraintes suivantes :

	1. de taille réduite par rapport au nombre initial de couleurs		1. utiliser moins de couleurs que le nombre disponible dans l'image donnée;
	2. la plus représentative possible des couleurs initiales.		2. être la plus représentative possible des couleurs de l'image donnée.

	En effet une image affichée sur un ordinateur peut être encodée sur 8 bits par composantes rouge, verte et bleue (soit 256 valeurs possibles par composante) ainsi potentiellement utiliser $256 \times 256 \times 256 = 16 777 216$ couleurs. En réalité, beaucoup moins sont utilisées et surtout perceptibles par l'humain. Réduire le nombre de couleur ou réaliser une "_quantification de couleurs_" est une tâche fréquente et c'est une fonctionnalité classique des outils éditeurs d'images (Photoshop, Gimp, etc.) implémentée aussi dans le module Pillow de Python. A noter que cette réduction s'effectue avec perte de couleurs et doit être réalisée avec les bons paramètres (nombre et choix des couleurs) ce qui est votre objectif.		Comme nous l'avons vu dans le TD 4, les couleurs peuvent être encodée par composantes rouge, verte et bleue (soit 256 valeurs possibles par composante, autrement dit sur 8 bits) ainsi potentiellement utiliser $256 \times 256 \times 256 = 16 777 216$ couleurs. En réalité, beaucoup moins sont nécessaires et surtout perceptibles par l'humain. Réduire le nombre de couleurs ou réaliser une "_quantification de couleurs_" est une tâche fréquente et c'est une fonctionnalité classique des outils éditeurs d'images (Photoshop, Gimp, etc.) implémentée aussi dans le module Pillow de Python. A noter que cette réduction s'effectue avec perte de couleurs et doit être réalisée avec les bons paramètres (nombre et choix des couleurs) ce qui est votre objectif.

	La figure ci-dessous illustre le problème à résoudre : étant donnée une image en entrée, proposer une liste de couleurs (que l'on appellera la palette), afin de re-colorier une image en sortie.		La figure ci-dessous illustre le problème à résoudre : étant donnée une image en entrée, proposer une liste de couleurs (que l'on appellera la palette), afin de re-colorier une image en sortie.

	<div style="text-align:center;">		<div style="text-align:center;">
	<table>		<table>
	<tr>		<tr>
	<td>		<td>
	<img src="figures/color-rainbow.png" alt="Image originale" style="height:5cm;">		<img src="figures/color-rainbow.png" alt="Image originale" style="height:5cm;">
	<p>Image originale</p>		<p>Image donnée</p>
	</td>		</td>
	<td>		<td>
	<img src="figures/rainbow-palette-8.png" alt="Palette de 8 couleurs représentatives" style="height:5cm;">		<img src="figures/rainbow-palette-8.png" alt="Palette de 8 couleurs représentatives" style="height:5cm;">
	<p>Palette de 8 couleurs représentatives</p>		<p>Palette de 8 couleurs représentatives</p>
	</td>		</td>
	<td>		<td>
	<img src="figures/rainbow-recoloriee.png" alt="Image originale recoloriée avec la palette" style="height:5cm;">		<img src="figures/rainbow-recoloriee.png" alt="Image originale recoloriée avec la palette" style="height:5cm;">
	<p>Image originale recoloriée avec la palette</p>		<p>Image donnée recoloriée avec la palette</p>
	</td>		</td>
	</tr>		</tr>
	</table>		</table>
	</div>		</div>

	%% Cell type:markdown id:fd464e65-adfe-4e11-bf87-f12c513fbaea tags:		%% Cell type:markdown id:fd464e65-adfe-4e11-bf87-f12c513fbaea tags:

	## Étapes de travail		## Étapes de travail

	Voici des étapes de travail suggérées :		Voici des étapes de travail suggérées :

	1. Prendre en main une image de votre choix (pas trop grande) en la chargeant avec PIL. Lister les couleurs présentes, identifier celles qui sont uniques et leur fréquence. Vous pouvez pour cela utiliser [Matplotlib](https://matplotlib.org/stable/gallery/index.html).		1. Prenez une image de votre choix (pas trop grande) en la chargeant avec PIL. Lister les couleurs présentes, identifier celles qui sont uniques et leur fréquence.

	2. Proposer une méthode (naïve pour commencer) de choix d'une palette de $k$ couleurs. Affichez là sous forme d'image (exemple de d'image au milieu de la figure du dessus) avec une nouvelle image PIL. Utilisez également des images simples où le résultat attendu est connu comme mour les images ci-dessous :		2. Proposez une méthode (naïve pour commencer) de choix d'une palette de $k$ couleurs. Affichez là sous forme d'image (exemple de d'image au milieu de la figure du dessus) avec une nouvelle image PIL. Utilisez également des images simples où le résultat attendu est connu comme pour les images ci-dessous :

	<div style="text-align:center;">		<div style="text-align:center;">
	<table>		<table>
	<tr>		<tr>
	<td>		<td>
	<img src="figures/1-color-back.png" alt="1 couleur noir" style="width:3cm;">		<img src="figures/1-color-back.png" alt="1 couleur noir" style="width:3cm;">
	<p>1 couleur noir</p>		<p>1 couleur noir</p>
	</td>		</td>
	<td>		<td>
	<img src="figures/4-color.png" alt="4 couleurs" style="width:3cm;">		<img src="figures/4-color.png" alt="4 couleurs" style="width:3cm;">
	<p>4 couleurs</p>		<p>4 couleurs</p>
	</td>		</td>
	</tr>		</tr>
	</table>		</table>
	</div>		</div>

	3. Re-colorier une image avec une palette de $k$ couleurs, et afficher le résultat sous forme d'image PIL. Pour re-colorier chaque pixel, prendre la couleur la plus proche dans la palette en utilisant une fonction de distance (Euclidienne par exemple).		3. Re-coloriez une image avec une palette de $k$ couleurs, et affichez le résultat sous forme d'image PIL. Pour re-colorier chaque pixel, prendre la couleur la plus proche dans la palette en utilisant une fonction de distance (Euclidienne par exemple..).

	4. Proposer une méthode de validation de votre approche. Par exemple afficher la différence entre l'image originale et celle re-coloriée. Calculer un score global d'erreur.		4. Proposez une méthode de validation de votre approche. Par exemple affichez la différence entre l'image originale et celle re-coloriée. Calculez un score global d'erreur.

	5. Améliorer le choix des $k$ couleurs afin de minimiser l'erreur entre l'image originale et re-coloriée. Une piste possible est de trier les couleurs dans une liste, diviser cette liste en $k$ intervals de couleurs et prendre la couleur du milieu de chaque interval. D'autres méthodes plus avancées peuvent être explorées !		5. Améliorez le choix des $k$ couleurs afin de minimiser l'erreur entre l'image originale et re-coloriée. Une piste possible est de trier les couleurs dans une liste, diviser cette liste en $k$ intervals de couleurs et prendre la couleur du milieu de chaque interval. D'autres méthodes plus avancées peuvent être explorées !

	6. Tester sur plusieurs images de votre choix ou générées automatiquement avec un nombre et une distribution connue de couleurs. Comparer les performances de vos techniques avec d'autres méthodes (cette fois vous pouvez utiliser un éditeur de texte ou la fonction _quantize_ de PIL [(doc)](https://pillow.readthedocs.io/en/stable/reference/Image.html).		6. Testez votre palette sur plusieurs images de votre choix ou générées automatiquement avec un nombre et une distribution connue de couleurs. Comparer les performances de vos techniques avec d'autres méthodes (cette fois vous pouvez utiliser un éditeur de texte ou la fonction _quantize_ de PIL [(doc)](https://pillow.readthedocs.io/en/stable/reference/Image.html).

	7. Utiliser un pré-traitement des images (flou gaussien, etc) afin de lisser les couleurs est une piste afin de choisir de meilleurs couleurs représentatives. Proposez une quantification de cette amélioration (ou de déterioration éventuelle).		7. Utilisez un pré-traitement des images (flou gaussien, etc) afin de lisser les couleurs. Cela est une piste afin de choisir de meilleurs couleurs représentatives. Proposez une comparaison de cette amélioration (ou de déterioration éventuelle) avec les autres méthodes.

	7. Proposer une méthode d'amélioration de calcul de la distance entre deux couleurs, vous pouvez vous baser sur d'autres espaces de couleur [(doc)](https://fr.wikipedia.org/wiki/Espace_de_couleur). Cette partie est difficile, les espaces de couleurs possibles sont complexes à comprendre.		8. Proposez une méthode d'amélioration de calcul de la distance entre deux couleurs, vous pouvez vous baser sur d'autres espaces de couleur [(doc)](https://fr.wikipedia.org/wiki/Espace_de_couleur). Cette partie est difficile, les espaces de couleurs possibles sont complexes à comprendre.

	8. Optimiser les étapes précédentes (complexité, espace nécessaire, structures de données, etc.).		9. Optimisez les étapes précédentes (complexité, espace nécessaire, structures de données, etc.) et justifiez vos choix.


	### Bonus		### Bonus

	10. Créer une palette représentative à partir de plusieurs images.		10. Créez une palette représentative à partir de plusieurs images.

TD06/INF-TC1-td06.ipynb

+39 −3

Original line number	Original line	Diff line number	Diff line
	%% Cell type:markdown id:caaef4d1 tags:		%% Cell type:markdown id:886b66ed tags:

	NAME:		NAME:

	%% Cell type:markdown id:6d71a1d5-6589-4320-900f-b07f08df01f4 tags:		%% Cell type:markdown id:6d71a1d5-6589-4320-900f-b07f08df01f4 tags:

	# INF TC1 - TD6 (2h) - Automates		# INF TC1 - TD6 (2h) - Automates

	%% Cell type:markdown id:54c3bdf8-4ded-45da-a79a-6530af149f51 tags:		%% Cell type:markdown id:54c3bdf8-4ded-45da-a79a-6530af149f51 tags:

	---		---

	%% Cell type:markdown id:33320365-404e-4424-96d1-6e6b742c8f44 tags:		%% Cell type:markdown id:33320365-404e-4424-96d1-6e6b742c8f44 tags:

	## Objectif du TD		## Objectif du TD

	Dans ce TD nous allons introduire les automates, qui sont (en informatique) un modèle de calcul permettant de déterminer si une séquence d'information est valide ou non, selon une règle déterminée. Dans un premier temps nous allons définir des automates simples, et ensuite les implémenter en Python et résoudre des problèmes de complexité croissante.		Dans ce TD nous allons introduire les automates, qui sont (en informatique) un modèle de calcul permettant de déterminer si une séquence d'information est valide ou non, selon une règle déterminée. Dans un premier temps nous allons définir des automates simples, et ensuite les implémenter en Python et résoudre des problèmes de complexité croissante.

	%% Cell type:markdown id:02ba4e95-34be-41b9-b36c-255b5af6b3de tags:		%% Cell type:markdown id:02ba4e95-34be-41b9-b36c-255b5af6b3de tags:

	## Qu'est-ce qu'un automate ?		## Qu'est-ce qu'un automate ?

	Un automate est un outil de calcul permettant la validation de séquences d'instructions, à base d'états et de transitions. Un exemple d'automate est un feu tricolore, où :		Un automate est un outil de calcul permettant la validation de séquences d'instructions, à base d'états et de transitions. Un exemple d'automate est un feu tricolore, où :

	- les états sont la couleur du feu (rouge, vert ou orange)		- les états sont la couleur du feu (rouge, vert ou orange)
	- les transitions les changements possibles de couleurs (du rouge au vert, du vert au orange, et du orange au rouge).		- les transitions les changements possibles de couleurs (du rouge au vert, du vert au orange, et du orange au rouge).

	Les automates permettent donc de formaliser le fonctionnement d'un système et de détecter des erreurs éventuelles qui ne respectent pas les changements pré-définis (en reprenant l'exemple du feu tricolore, passer du vert au rouge directement est une erreur). Les applications des automates sont nombreuses et offrent souvent un code plus facile à écire et lire.		Les automates permettent donc de formaliser le fonctionnement d'un système et de détecter des erreurs éventuelles qui ne respectent pas les changements pré-définis (en reprenant l'exemple du feu tricolore, passer du vert au rouge directement est une erreur). Les applications des automates sont nombreuses et offrent souvent un code plus facile à écire et lire.

	%% Cell type:code id:ca93dafe-32d7-4332-9d26-c57c928805ee tags:		%% Cell type:code id:ca93dafe-32d7-4332-9d26-c57c928805ee tags:

	``` python		``` python
	from IPython.core.display import HTML		from IPython.core.display import HTML
	HTML('<?xml version="1.0" encoding="UTF-8" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><!-- Generated by graphviz version 7.1.0 (20230121.1956) --><!-- Pages: 1 --><svg width="131pt" height="52pt" viewBox="0.00 0.00 131.00 52.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 48)"><polygon fill="white" stroke="none" points="-4,4 -4,-48 127,-48 127,4 -4,4"/><g id="node1" class="node"><title>0</title><ellipse fill="none" stroke="black" stroke-width="2" cx="18" cy="-22" rx="18" ry="18"/><text text-anchor="middle" x="18" y="-18.3" font-family="Times,serif" font-size="14.00">0</text></g><g id="node2" class="node"><title>1</title><ellipse fill="none" stroke="black" cx="101" cy="-22" rx="18" ry="18"/><ellipse fill="none" stroke="black" cx="101" cy="-22" rx="22" ry="22"/><text text-anchor="middle" x="101" y="-18.3" font-family="Times,serif" font-size="14.00">1</text></g><g id="edge1" class="edge"><title>0→1</title><path fill="none" stroke="black" d="M36.18,-22C45.15,-22 56.45,-22 67.03,-22"/><polygon fill="black" stroke="black" points="67,-25.5 77,-22 67,-18.5 67,-25.5"/><text text-anchor="middle" x="57.5" y="-25.8" font-family="Times,serif" font-size="14.00">a</text></g></g></svg>')		HTML('<?xml version="1.0" encoding="UTF-8" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><!-- Generated by graphviz version 7.1.0 (20230121.1956) --><!-- Pages: 1 --><svg width="131pt" height="52pt" viewBox="0.00 0.00 131.00 52.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 48)"><polygon fill="white" stroke="none" points="-4,4 -4,-48 127,-48 127,4 -4,4"/><g id="node1" class="node"><title>0</title><ellipse fill="none" stroke="black" stroke-width="2" cx="18" cy="-22" rx="18" ry="18"/><text text-anchor="middle" x="18" y="-18.3" font-family="Times,serif" font-size="14.00">0</text></g><g id="node2" class="node"><title>1</title><ellipse fill="none" stroke="black" cx="101" cy="-22" rx="18" ry="18"/><ellipse fill="none" stroke="black" cx="101" cy="-22" rx="22" ry="22"/><text text-anchor="middle" x="101" y="-18.3" font-family="Times,serif" font-size="14.00">1</text></g><g id="edge1" class="edge"><title>0→1</title><path fill="none" stroke="black" d="M36.18,-22C45.15,-22 56.45,-22 67.03,-22"/><polygon fill="black" stroke="black" points="67,-25.5 77,-22 67,-18.5 67,-25.5"/><text text-anchor="middle" x="57.5" y="-25.8" font-family="Times,serif" font-size="14.00">a</text></g></g></svg>')
	```		```

	%% Cell type:markdown id:07c95f05-1782-4f25-80fe-9dcf93bdedc6 tags:		%% Cell type:markdown id:07c95f05-1782-4f25-80fe-9dcf93bdedc6 tags:

	## Définitions		## Définitions

	Un automate possède une structure de données similaire à un graphe orienté, où chaque nœud représente un état et un arc représente une transition possible d'un état à un autre. Ce graphe est ensuite parcouru à partir de `mots` (par exemple : `aba`), qui sont une suite de symboles (comme les lettres `a` et `b`) permettant de passer d'un état à un autre. L'état initial (unique) est représenté visuellement par un cercle en gras, et le dernier état (il peut y en avoir plusieurs) par un double cercle. Les symboles `a` et `b` constituent l'alphabet de l'automate (il est possible d'utiliser tout type d'alphabet, comme les transitions d'un feu tricolore).		Un automate possède une structure de données similaire à un graphe orienté, où chaque nœud représente un état et un arc représente une transition possible d'un état à un autre. Ce graphe est ensuite parcouru à partir de `mots` (par exemple : `aba`), qui sont une suite de symboles (comme les lettres `a` et `b`) permettant de passer d'un état à un autre. L'état initial (unique) est représenté visuellement par un cercle en gras, et le dernier état (il peut y en avoir plusieurs) par un double cercle. Les symboles `a` et `b` constituent l'alphabet de l'automate (il est possible d'utiliser tout type d'alphabet, comme les transitions d'un feu tricolore).

	Dans l'exemple ci-dessus, si le mot à lire est `a`, l'automate commence à lire le mot depuis l'état `0` et réalise ensuite une transition vers l'état `1` et s'arrête. Comme l'état `1` est un état final le mot `a` est validé. On parlera de motif pour indiquer les familles de mots validés par un automate, comme par exemple les mots qui commencent par `a` nous notons `a*` (l'astérisque indiquant que tout symbole peut être utilisé).		Dans l'exemple ci-dessus, si le mot à lire est `a`, l'automate commence à lire le mot depuis l'état `0` et réalise ensuite une transition vers l'état `1` et s'arrête. Comme l'état `1` est un état final le mot `a` est validé. On parlera de motif pour indiquer les familles de mots validés par un automate, comme par exemple les mots qui commencent par `a` nous notons `a*` (l'astérisque indiquant que tout symbole peut être utilisé).

	De manière générale, un automate est défini comme $A = (\Sigma, S, s_{0}, \delta, F)$, avec :		De manière générale, un automate est défini comme $A = (\Sigma, S, s_{0}, \delta, F)$, avec :

	- $\Sigma$, un ensemble fini, non vide de symboles qui est l'alphabet d'entrée		- $\Sigma$, un ensemble fini, non vide de symboles qui est l'alphabet d'entrée
	- $S$, un ensemble fini, non vide d'états		- $S$, un ensemble fini, non vide d'états
	- $s_{0}$, l'état initial, élément de $S$		- $s_{0}$, l'état initial, élément de $S$
	- $\delta$, la fonction de transition d'états: $\delta : S \times \Sigma \rightarrow S$		- $\delta$, la fonction de transition d'états: $\delta : S \times \Sigma \rightarrow S$
	- $F$ est l'ensemble des états terminaux, un sous-ensemble (éventuellement vide) de $S$		- $F$ est l'ensemble des états terminaux, un sous-ensemble (éventuellement vide) de $S$

	%% Cell type:markdown id:15b6ca9c-be1c-4757-b02c-1511fed5df68 tags:		%% Cell type:markdown id:15b6ca9c-be1c-4757-b02c-1511fed5df68 tags:

	## Dessin d'automates		## Dessin d'automates

	Pour dessiner des automates, nous utiliserons [Graphviz](https://graphviz.org/), un outil en ligne de commande qui permet de dessiner des graphes basé sur le langage [DOT](https://graphviz.org/doc/info/lang.html). Un exemple d'automate est donné ci-dessous :		Pour dessiner des automates, nous utiliserons [Graphviz](https://graphviz.org/), un outil en ligne de commande qui permet de dessiner des graphes basé sur le langage [DOT](https://graphviz.org/doc/info/lang.html). Un exemple d'automate est donné ci-dessous :

	```python		```python
	from graphviz import Digraph		from graphviz import Digraph

	dot = Digraph()		dot = Digraph()
	dot.graph_attr['rankdir'] = 'LR'		dot.graph_attr['rankdir'] = 'LR'

	dot.node('A', shape='circle', style='bold', label='0')		dot.node('A', shape='circle', style='bold', label='0')
	dot.node('B', shape='doublecircle', label='1')		dot.node('B', shape='doublecircle', label='1')

	dot.edge('A', 'B', label='a')		dot.edge('A', 'B', label='a')
	dot.edge('B', 'A', label='a')		dot.edge('B', 'A', label='a')

	dot		dot
	``````		``````

	%% Cell type:markdown id:07d1cd6d-1845-4707-b126-fbe219408a92 tags:		%% Cell type:markdown id:07d1cd6d-1845-4707-b126-fbe219408a92 tags:

	IMPORTANT : vérifier que le code ci-dessus s'exécute bien (dans la cellule ci-dessous). Si cela n'est pas le cas alors suivez ces [instructions d'installation de la bibliothèque Graphviz](https://gitlab.ec-lyon.fr/rvuillem/inf-tc1/-/blob/master/graphviz.ipynb).		IMPORTANT : vérifier que le code ci-dessus s'exécute bien (dans la cellule ci-dessous). Si cela n'est pas le cas alors suivez ces [instructions d'installation de la bibliothèque Graphviz](https://gitlab.ec-lyon.fr/rvuillem/inf-tc1/-/blob/master/graphviz.ipynb).

	%% Cell type:code id:bff8d514-4ab5-4a24-81c2-ecd7ef39aa9e tags:		%% Cell type:code id:bff8d514-4ab5-4a24-81c2-ecd7ef39aa9e tags:

	``` python		``` python
	from graphviz import Digraph		from graphviz import Digraph

	dot = Digraph()		dot = Digraph()
	dot.graph_attr['rankdir'] = 'LR'		dot.graph_attr['rankdir'] = 'LR'

	dot.node('0', shape='circle', style='bold', label='0')		dot.node('0', shape='circle', style='bold', label='0')
	dot.node('1', shape='doublecircle', label='1')		dot.node('1', shape='doublecircle', label='1')

	dot.edge('0', '1', label='a')		dot.edge('0', '1', label='a')

	dot		dot
	```		```

			%% Cell type:markdown id:5e0cae70-8346-4664-af97-02fb5a426518 tags:

			VERSION EN LIGNE SANS GRAPHVIZ : si l'installation de graphviz ne fonctionne pas, vous pouvez utiliser une [version en ligne](https://dreampuf.github.io/GraphvizOnline/#digraph%20G%20%7B%0A%20%20rankdir%3DLR%3B%0A%20%20a%20-%3E%20b%20%5Blabel%3D%22X%22%5D%3B%0A%0A%20%20a%20%5Bshape%3Dcircle%2C%20style%3Dbold%5D%3B%0A%20%20b%20%5Bshape%3Ddoublecircle%5D%3B%0A%7D) afin de réaliser le dessins sous forme de code, et exporter le résultat en image à inclure dans une cellule comme ci-dessous.

			%% Cell type:code id:0178c283 tags:

			``` python
			# version sans graphviz : version qui contient une image au lieu de code graphviz
			from IPython.core.display import HTML
			HTML('<img src="figures_automates/0_1.png">')
			```

	%% Cell type:markdown id:ad7810cc-eefc-4733-993e-50c131c3e514 tags:		%% Cell type:markdown id:ad7810cc-eefc-4733-993e-50c131c3e514 tags:

	## Exercice 1 : Automates simples		## Exercice 1 : Automates simples

	Dans cette section, nous vous demandons de proposer un automate qui valide un motif donné. Pour les questions 1.1, 1.2 et 1.3, nous considérons un alphabet contenant les lettres `a` et `b` seulement. Vous pouvez répondre aux questions sur papier de préférence, ou utiliser le code ci-dessus du module `graphviz` pour dessiner l'automate.		Dans cette section, nous vous demandons de proposer un automate qui valide un motif donné. Pour les questions 1.1, 1.2 et 1.3, nous considérons un alphabet contenant les lettres `a` et `b` seulement. Vous pouvez répondre aux questions sur papier de préférence, ou utiliser le code ci-dessus du module `graphviz` pour dessiner l'automate.

	Question 1.1 - Proposer un automate qui contient un nombre paire de fois la lettre `a`.		Question 1.1 - Proposer un automate qui contient un nombre paire de fois la lettre `a`.

	%% Cell type:code id:d33a29aa-5e07-476d-bfa9-4ef7454bc6f4 tags:		%% Cell type:code id:d33a29aa-5e07-476d-bfa9-4ef7454bc6f4 tags:

	``` python		``` python
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

			%% Cell type:code id:3187d0f6 tags:

			``` python
			# version sans graphviz
			# YOUR CODE HERE
			raise NotImplementedError()
			```

	%% Cell type:markdown id:87566002-5968-4b5f-aa05-c108bfe1cf33 tags:		%% Cell type:markdown id:87566002-5968-4b5f-aa05-c108bfe1cf33 tags:

	Question 1.2 - Proposer un automate qui valide le motif `a*a` (les mots qui commencent et finissent par `a`, de taille > 2).		Question 1.2 - Proposer un automate qui valide le motif `a*a` (les mots qui commencent et finissent par `a`, de taille > 2).

	%% Cell type:code id:a8a32710-840f-4385-a85f-670c992ddca7 tags:		%% Cell type:code id:a8a32710-840f-4385-a85f-670c992ddca7 tags:

	``` python		``` python
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

			%% Cell type:code id:9017ef71 tags:

			``` python
			# version sans graphviz
			# YOUR CODE HERE
			raise NotImplementedError()
			```

	%% Cell type:markdown id:70c4a996-c123-49c9-b771-b58046b6bb97 tags:		%% Cell type:markdown id:70c4a996-c123-49c9-b771-b58046b6bb97 tags:

	penser à proposer une liste de mots à valider et à ne pas valider afin de guider les étudiants.		penser à proposer une liste de mots à valider et à ne pas valider afin de guider les étudiants.

	%% Cell type:markdown id:14d7d169-fa9b-4c90-87d9-b07cfb1cc323 tags:		%% Cell type:markdown id:14d7d169-fa9b-4c90-87d9-b07cfb1cc323 tags:

	Question 1.3 - Quel langage valide l'automate ci-dessous ? Donnez un exemple de mots validés et le langage.		Question 1.3 - Quel langage valide l'automate ci-dessous ? Donnez un exemple de mots validés et le langage.

	%% Cell type:code id:b83f2bad-2864-4eeb-9851-510c7d5dd273 tags:		%% Cell type:code id:b83f2bad-2864-4eeb-9851-510c7d5dd273 tags:

	``` python		``` python
	from IPython.core.display import HTML		from IPython.core.display import HTML
	HTML('<?xml version="1.0" encoding="UTF-8" standalone="no"?><!-- Generated by graphviz version 7.1.0 (20230121.1956) --><!-- Pages: 1 --><svg width="368pt" height="118pt" viewBox="0.00 0.00 368.00 118.00" version="1.1" id="svg1036" sodipodi:docname="a.svg" inkscape:version="1.2.2 (b0a8486, 2022-12-01)" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg"> <defs id="defs1040" /> <sodipodi:namedview id="namedview1038" pagecolor="#ffffff" bordercolor="#000000" borderopacity="0.25" inkscape:showpageshadow="2" inkscape:pageopacity="0.0" inkscape:pagecheckerboard="0" inkscape:deskcolor="#d1d1d1" inkscape:document-units="pt" showgrid="false" inkscape:zoom="1.5" inkscape:cx="245.66667" inkscape:cy="78.666667" inkscape:window-width="1309" inkscape:window-height="456" inkscape:window-x="0" inkscape:window-y="25" inkscape:window-maximized="0" inkscape:current-layer="svg1036" /> <g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 114)"> <polygon fill="white" stroke="none" points="-4,4 -4,-114 364,-114 364,4 -4,4" id="polygon906" /> <!-- Q_0 --> <g id="node1" class="node"> <title id="title908">Q_0</title> <ellipse fill="none" stroke="black" stroke-width="2" cx="18" cy="-39" rx="18" ry="18" id="ellipse910" /> <text text-anchor="middle" x="18" y="-35.3" font-family="Times,serif" font-size="14.00" id="text912">0</text> </g> <!-- Q_0->Q_0 --> <g id="edge2" class="edge"> <title id="title915">Q_0->Q_0</title> <path fill="none" stroke="black" d="M11,-56.04C9.57,-65.86 11.91,-75 18,-75 21.52,-75 23.79,-71.94 24.8,-67.47" id="path917" /> <polygon fill="black" stroke="black" points="28.3,-67.61 24.97,-57.55 21.3,-67.49 28.3,-67.61" id="polygon919" /> <text text-anchor="middle" x="18" y="-78.8" font-family="Times,serif" font-size="14.00" id="text921">b</text> </g> <!-- Q_1 --> <g id="node2" class="node"> <title id="title924">Q_1</title> <ellipse fill="none" stroke="black" cx="97" cy="-52" rx="18" ry="18" id="ellipse926" /> <text text-anchor="middle" x="97" y="-48.3" font-family="Times,serif" font-size="14.00" id="text928">1</text> </g> <!-- Q_0->Q_1 --> <g id="edge1" class="edge"> <title id="title931">Q_0->Q_1</title> <path fill="none" stroke="black" d="M34.18,-47.66C40.16,-50.6 47.21,-53.52 54,-55 58.45,-55.97 63.23,-56.29 67.9,-56.22" id="path933" /> <polygon fill="black" stroke="black" points="67.86,-59.73 77.58,-55.49 67.34,-52.75 67.86,-59.73" id="polygon935" /> <text text-anchor="middle" x="57.5" y="-58.8" font-family="Times,serif" font-size="14.00" id="text937">a</text> </g> <!-- Q_1->Q_0 --> <g id="edge4" class="edge"> <title id="title940">Q_1->Q_0</title> <path fill="none" stroke="black" d="M80.82,-43.34C74.84,-40.4 67.79,-37.48 61,-36 56.55,-35.03 51.77,-34.71 47.1,-34.78" id="path942" /> <polygon fill="black" stroke="black" points="47.14,-31.27 37.42,-35.51 47.66,-38.25 47.14,-31.27" id="polygon944" /> <text text-anchor="middle" x="57.5" y="-39.8" font-family="Times,serif" font-size="14.00" id="text946">b</text> </g> <!-- Q_2 --> <g id="node3" class="node"> <title id="title949">Q_2</title> <ellipse fill="none" stroke="black" cx="176" cy="-52" rx="18" ry="18" id="ellipse951" /> <text text-anchor="middle" x="176" y="-48.3" font-family="Times,serif" font-size="14.00" id="text953">2</text> </g> <!-- Q_1->Q_2 --> <g id="edge3" class="edge"> <title id="title956">Q_1->Q_2</title> <path fill="none" stroke="black" d="M115.47,-52C124.53,-52 135.83,-52 146.14,-52" id="path958" /> <polygon fill="black" stroke="black" points="146.08,-55.5 156.08,-52 146.08,-48.5 146.08,-55.5" id="polygon960" /> <text text-anchor="middle" x="136.5" y="-55.8" font-family="Times,serif" font-size="14.00" id="text962">a</text> </g> <!-- Q_2->Q_2 --> <g id="edge6" class="edge"> <title id="title965">Q_2->Q_2</title> <path fill="none" stroke="black" d="M169,-69.04C167.57,-78.86 169.91,-88 176,-88 179.52,-88 181.79,-84.94 182.8,-80.47" id="path967" /> <polygon fill="black" stroke="black" points="186.3,-80.61 182.97,-70.55 179.3,-80.49 186.3,-80.61" id="polygon969" /> <text text-anchor="middle" x="176" y="-91.8" font-family="Times,serif" font-size="14.00" id="text971">a</text> </g> <!-- Q_3 --> <g id="node4" class="node"> <title id="title974">Q_3</title> <ellipse fill="none" stroke="black" cx="255" cy="-22" rx="18" ry="18" id="ellipse976" /> <text text-anchor="middle" x="255" y="-18.3" font-family="Times,serif" font-size="14.00" id="text978">3</text> </g> <!-- Q_2->Q_3 --> <g id="edge5" class="edge"> <title id="title981">Q_2->Q_3</title> <path fill="none" stroke="black" d="M193.33,-45.64C203.13,-41.82 215.84,-36.87 227.09,-32.48" id="path983" /> <polygon fill="black" stroke="black" points="228.24,-35.79 236.28,-28.9 225.7,-29.27 228.24,-35.79" id="polygon985" /> <text text-anchor="middle" x="215.5" y="-40.8" font-family="Times,serif" font-size="14.00" id="text987">b</text> </g> <!-- Q_3->Q_0 --> <g id="edge8" class="edge"> <title id="title990">Q_3->Q_0</title> <path fill="none" stroke="black" d="M236.53,-21.08C204.94,-19.69 136.3,-17.91 79,-25 68.32,-26.32 56.76,-28.77 46.67,-31.25" id="path992" /> <polygon fill="black" stroke="black" points="45.9,-27.83 37.1,-33.73 47.66,-34.61 45.9,-27.83" id="polygon994" /> <text text-anchor="middle" x="136.5" y="-23.8" font-family="Times,serif" font-size="14.00" id="text996">b</text> </g> <!-- Q_4 --> <g id="node5" class="node"> <title id="title999">Q_4</title> <ellipse fill="none" stroke="black" cx="338" cy="-22" rx="18" ry="18" id="ellipse1001" /> <ellipse fill="none" stroke="black" cx="338" cy="-22" rx="22" ry="22" id="ellipse1003" /> <text text-anchor="middle" x="338" y="-18.3" font-family="Times,serif" font-size="14.00" id="text1005">4</text> </g> <!-- Q_3->Q_4 --> <g id="edge7" class="edge"> <title id="title1008">Q_3->Q_4</title> <path fill="none" stroke="black" d="M273.18,-22C282.15,-22 293.45,-22 304.03,-22" id="path1010" /> <polygon fill="black" stroke="black" points="304,-25.5 314,-22 304,-18.5 304,-25.5" id="polygon1012" /> <text text-anchor="middle" x="294.5" y="-25.8" font-family="Times,serif" font-size="14.00" id="text1014">a</text> </g> <!-- Q_4->Q_4 --> <g id="edge9" class="edge"> <title id="title1017">Q_4->Q_4</title> <path fill="none" stroke="black" d="M333.99,-43.81C333.6,-53.56 334.94,-62 338,-62 339.72,-62 340.9,-59.33 341.53,-55.26" id="path1019" /> <polygon fill="black" stroke="black" points="345.02,-55.46 341.95,-45.32 338.03,-55.16 345.02,-55.46" id="polygon1021" /> <text text-anchor="middle" x="338" y="-65.8" font-family="Times,serif" font-size="14.00" id="text1023">a</text> </g> <!-- Q_4->Q_4 --> <g id="edge10" class="edge"> <title id="title1026">Q_4->Q_4</title> <path fill="none" stroke="black" d="M331.14,-43.11C328.11,-61.1 330.4,-80 338,-80 344,-80 346.69,-68.23 346.07,-54.43" id="path1028" /> <polygon fill="black" stroke="black" points="349.56,-54.19 345.02,-44.62 342.6,-54.93 349.56,-54.19" id="polygon1030" /> <text text-anchor="middle" x="338" y="-83.8" font-family="Times,serif" font-size="14.00" id="text1032">b</text> </g> </g></svg>')		HTML('<?xml version="1.0" encoding="UTF-8" standalone="no"?><!-- Generated by graphviz version 7.1.0 (20230121.1956) --><!-- Pages: 1 --><svg width="368pt" height="118pt" viewBox="0.00 0.00 368.00 118.00" version="1.1" id="svg1036" sodipodi:docname="a.svg" inkscape:version="1.2.2 (b0a8486, 2022-12-01)" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg"> <defs id="defs1040" /> <sodipodi:namedview id="namedview1038" pagecolor="#ffffff" bordercolor="#000000" borderopacity="0.25" inkscape:showpageshadow="2" inkscape:pageopacity="0.0" inkscape:pagecheckerboard="0" inkscape:deskcolor="#d1d1d1" inkscape:document-units="pt" showgrid="false" inkscape:zoom="1.5" inkscape:cx="245.66667" inkscape:cy="78.666667" inkscape:window-width="1309" inkscape:window-height="456" inkscape:window-x="0" inkscape:window-y="25" inkscape:window-maximized="0" inkscape:current-layer="svg1036" /> <g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 114)"> <polygon fill="white" stroke="none" points="-4,4 -4,-114 364,-114 364,4 -4,4" id="polygon906" /> <!-- Q_0 --> <g id="node1" class="node"> <title id="title908">Q_0</title> <ellipse fill="none" stroke="black" stroke-width="2" cx="18" cy="-39" rx="18" ry="18" id="ellipse910" /> <text text-anchor="middle" x="18" y="-35.3" font-family="Times,serif" font-size="14.00" id="text912">0</text> </g> <!-- Q_0->Q_0 --> <g id="edge2" class="edge"> <title id="title915">Q_0->Q_0</title> <path fill="none" stroke="black" d="M11,-56.04C9.57,-65.86 11.91,-75 18,-75 21.52,-75 23.79,-71.94 24.8,-67.47" id="path917" /> <polygon fill="black" stroke="black" points="28.3,-67.61 24.97,-57.55 21.3,-67.49 28.3,-67.61" id="polygon919" /> <text text-anchor="middle" x="18" y="-78.8" font-family="Times,serif" font-size="14.00" id="text921">b</text> </g> <!-- Q_1 --> <g id="node2" class="node"> <title id="title924">Q_1</title> <ellipse fill="none" stroke="black" cx="97" cy="-52" rx="18" ry="18" id="ellipse926" /> <text text-anchor="middle" x="97" y="-48.3" font-family="Times,serif" font-size="14.00" id="text928">1</text> </g> <!-- Q_0->Q_1 --> <g id="edge1" class="edge"> <title id="title931">Q_0->Q_1</title> <path fill="none" stroke="black" d="M34.18,-47.66C40.16,-50.6 47.21,-53.52 54,-55 58.45,-55.97 63.23,-56.29 67.9,-56.22" id="path933" /> <polygon fill="black" stroke="black" points="67.86,-59.73 77.58,-55.49 67.34,-52.75 67.86,-59.73" id="polygon935" /> <text text-anchor="middle" x="57.5" y="-58.8" font-family="Times,serif" font-size="14.00" id="text937">a</text> </g> <!-- Q_1->Q_0 --> <g id="edge4" class="edge"> <title id="title940">Q_1->Q_0</title> <path fill="none" stroke="black" d="M80.82,-43.34C74.84,-40.4 67.79,-37.48 61,-36 56.55,-35.03 51.77,-34.71 47.1,-34.78" id="path942" /> <polygon fill="black" stroke="black" points="47.14,-31.27 37.42,-35.51 47.66,-38.25 47.14,-31.27" id="polygon944" /> <text text-anchor="middle" x="57.5" y="-39.8" font-family="Times,serif" font-size="14.00" id="text946">b</text> </g> <!-- Q_2 --> <g id="node3" class="node"> <title id="title949">Q_2</title> <ellipse fill="none" stroke="black" cx="176" cy="-52" rx="18" ry="18" id="ellipse951" /> <text text-anchor="middle" x="176" y="-48.3" font-family="Times,serif" font-size="14.00" id="text953">2</text> </g> <!-- Q_1->Q_2 --> <g id="edge3" class="edge"> <title id="title956">Q_1->Q_2</title> <path fill="none" stroke="black" d="M115.47,-52C124.53,-52 135.83,-52 146.14,-52" id="path958" /> <polygon fill="black" stroke="black" points="146.08,-55.5 156.08,-52 146.08,-48.5 146.08,-55.5" id="polygon960" /> <text text-anchor="middle" x="136.5" y="-55.8" font-family="Times,serif" font-size="14.00" id="text962">a</text> </g> <!-- Q_2->Q_2 --> <g id="edge6" class="edge"> <title id="title965">Q_2->Q_2</title> <path fill="none" stroke="black" d="M169,-69.04C167.57,-78.86 169.91,-88 176,-88 179.52,-88 181.79,-84.94 182.8,-80.47" id="path967" /> <polygon fill="black" stroke="black" points="186.3,-80.61 182.97,-70.55 179.3,-80.49 186.3,-80.61" id="polygon969" /> <text text-anchor="middle" x="176" y="-91.8" font-family="Times,serif" font-size="14.00" id="text971">a</text> </g> <!-- Q_3 --> <g id="node4" class="node"> <title id="title974">Q_3</title> <ellipse fill="none" stroke="black" cx="255" cy="-22" rx="18" ry="18" id="ellipse976" /> <text text-anchor="middle" x="255" y="-18.3" font-family="Times,serif" font-size="14.00" id="text978">3</text> </g> <!-- Q_2->Q_3 --> <g id="edge5" class="edge"> <title id="title981">Q_2->Q_3</title> <path fill="none" stroke="black" d="M193.33,-45.64C203.13,-41.82 215.84,-36.87 227.09,-32.48" id="path983" /> <polygon fill="black" stroke="black" points="228.24,-35.79 236.28,-28.9 225.7,-29.27 228.24,-35.79" id="polygon985" /> <text text-anchor="middle" x="215.5" y="-40.8" font-family="Times,serif" font-size="14.00" id="text987">b</text> </g> <!-- Q_3->Q_0 --> <g id="edge8" class="edge"> <title id="title990">Q_3->Q_0</title> <path fill="none" stroke="black" d="M236.53,-21.08C204.94,-19.69 136.3,-17.91 79,-25 68.32,-26.32 56.76,-28.77 46.67,-31.25" id="path992" /> <polygon fill="black" stroke="black" points="45.9,-27.83 37.1,-33.73 47.66,-34.61 45.9,-27.83" id="polygon994" /> <text text-anchor="middle" x="136.5" y="-23.8" font-family="Times,serif" font-size="14.00" id="text996">b</text> </g> <!-- Q_4 --> <g id="node5" class="node"> <title id="title999">Q_4</title> <ellipse fill="none" stroke="black" cx="338" cy="-22" rx="18" ry="18" id="ellipse1001" /> <ellipse fill="none" stroke="black" cx="338" cy="-22" rx="22" ry="22" id="ellipse1003" /> <text text-anchor="middle" x="338" y="-18.3" font-family="Times,serif" font-size="14.00" id="text1005">4</text> </g> <!-- Q_3->Q_4 --> <g id="edge7" class="edge"> <title id="title1008">Q_3->Q_4</title> <path fill="none" stroke="black" d="M273.18,-22C282.15,-22 293.45,-22 304.03,-22" id="path1010" /> <polygon fill="black" stroke="black" points="304,-25.5 314,-22 304,-18.5 304,-25.5" id="polygon1012" /> <text text-anchor="middle" x="294.5" y="-25.8" font-family="Times,serif" font-size="14.00" id="text1014">a</text> </g> <!-- Q_4->Q_4 --> <g id="edge9" class="edge"> <title id="title1017">Q_4->Q_4</title> <path fill="none" stroke="black" d="M333.99,-43.81C333.6,-53.56 334.94,-62 338,-62 339.72,-62 340.9,-59.33 341.53,-55.26" id="path1019" /> <polygon fill="black" stroke="black" points="345.02,-55.46 341.95,-45.32 338.03,-55.16 345.02,-55.46" id="polygon1021" /> <text text-anchor="middle" x="338" y="-65.8" font-family="Times,serif" font-size="14.00" id="text1023">a</text> </g> <!-- Q_4->Q_4 --> <g id="edge10" class="edge"> <title id="title1026">Q_4->Q_4</title> <path fill="none" stroke="black" d="M331.14,-43.11C328.11,-61.1 330.4,-80 338,-80 344,-80 346.69,-68.23 346.07,-54.43" id="path1028" /> <polygon fill="black" stroke="black" points="349.56,-54.19 345.02,-44.62 342.6,-54.93 349.56,-54.19" id="polygon1030" /> <text text-anchor="middle" x="338" y="-83.8" font-family="Times,serif" font-size="14.00" id="text1032">b</text> </g> </g></svg>')
	```		```

	%% Cell type:code id:7aae22c9 tags:		%% Cell type:code id:7aae22c9 tags:

	``` python		``` python
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

	%% Cell type:markdown id:b1c8a625-b2e5-4958-b49f-009c7bcdb038 tags:		%% Cell type:markdown id:b1c8a625-b2e5-4958-b49f-009c7bcdb038 tags:

	Question 1.4 - Proposer un automate qui valide la propriété suivante : une chaîne de caractères est une adresse email. Les adresses email peuvent être définies comme suit (de manière simplifiée) :		Question 1.4 - Proposer un automate qui valide la propriété suivante : une chaîne de caractères est une adresse email. Les adresses email peuvent être définies comme suit (de manière simplifiée) :

	- le premier caractère ne peut pas être un chiffre		- le premier caractère ne peut pas être un chiffre
	- ensuite tous les caractères de `a` à `z` (majuscules et minuscules) et chiffres sont acceptés		- ensuite tous les caractères de `a` à `z` (majuscules et minuscules) et chiffres sont acceptés
	- un `@` doit être présent		- un `@` doit être présent
	- ensuite un nom de domaine qui lui aussi ne peut commencer par un chiffre (et doit faire + de 1 caractère)		- ensuite un nom de domaine qui lui aussi ne peut commencer par un chiffre (et doit faire + de 1 caractère)
	- un "."		- un "."
	- une extension parmis une liste autorisée (`fr`, `com`, etc)		- une extension parmis une liste autorisée (`fr`, `com`, etc)

	Un exemple de chaîne qui n'est pas validée est `3toto@a.fr2` car la première partie commence par un chiffre, le nom de domaine est trop court et enfin l'extension n'est pas valide. Pour la partie de validation de l'extension (`.fr`, etc.), vous pouvez simplifier en proposant une reconnaissance de motifs pré-définis (`.fr`, `.com`, etc.). Vous pouvez vous référer à la page Wikipedia [ici](https://fr.wikipedia.org/wiki/Adresse_\%C3\%A9lectronique) ou à la RFC 8222 [ici](https://www.w3.org/Protocols/rfc822/) pour une définition plus précise.		Un exemple de chaîne qui n'est pas validée est `3toto@a.fr2` car la première partie commence par un chiffre, le nom de domaine est trop court et enfin l'extension n'est pas valide. Pour la partie de validation de l'extension (`.fr`, etc.), vous pouvez simplifier en proposant une reconnaissance de motifs pré-définis (`.fr`, `.com`, etc.). Vous pouvez vous référer à la page Wikipedia [ici](https://fr.wikipedia.org/wiki/Adresse_\%C3\%A9lectronique) ou à la RFC 8222 [ici](https://www.w3.org/Protocols/rfc822/) pour une définition plus précise.

	%% Cell type:code id:2ee41daa-5611-433d-862a-f098127cad73 tags:		%% Cell type:code id:2ee41daa-5611-433d-862a-f098127cad73 tags:

	``` python		``` python
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

			%% Cell type:code id:73d884f0 tags:

			``` python
			# version sans graphviz
			# YOUR CODE HERE
			raise NotImplementedError()
			```

	%% Cell type:markdown id:6655a83e tags:		%% Cell type:markdown id:6655a83e tags:

	## Exercice 2 : Structure de données d'automate en Python		## Exercice 2 : Structure de données d'automate en Python

	%% Cell type:markdown id:bd6c2f5f-a14a-4a72-bbbe-ad7ec0406dad tags:		%% Cell type:markdown id:bd6c2f5f-a14a-4a72-bbbe-ad7ec0406dad tags:

	Question 2.1 - Nous allons désormais implémenter en Python une structure de données d'automate. Celle-ci doit être en mesure de stocker toutes les informations relatives à la définition d'un automate (symboles reconnu, états, états initiaux/finaux) et valider un mot donné. Votre structure de données peut être composée comme suit :		Question 2.1 - Nous allons désormais implémenter en Python une structure de données d'automate. Celle-ci doit être en mesure de stocker toutes les informations relatives à la définition d'un automate (symboles reconnu, états, états initiaux/finaux) et valider un mot donné. Votre structure de données peut être composée comme suit :

	1. Un constructeur `__init__` qui initialise l'automate avec les symboles du motif (ici `a` et `b`) et les variables d'état interne. En particulier l'état initial.		1. Un constructeur `__init__` qui initialise l'automate avec les symboles du motif (ici `a` et `b`) et les variables d'état interne. En particulier l'état initial.

	2. Une méthode `ajout_etat` qui rajoute un nouvel état et s'assure que l'état n'existe pas déjà; un paramètre additionnel `final` indiquera si il s'agit d'un état finaal		2. Une méthode `ajout_etat` qui rajoute un nouvel état et s'assure que l'état n'existe pas déjà; un paramètre additionnel `final` indiquera si il s'agit d'un état finaal

	3. Une méthode `ajout_transition` qui rajoute un nouvel état et s'assure que l'état n'existe pas déjà.		3. Une méthode `ajout_transition` qui rajoute une nouvelle transition entre deux états (et s'assure que ces états existent bien et qu'il n'y a pas de transition existante entre ces états).

	4. Une méthode `recherche_etat` qui étant donné un état source et un symbole, renvoie l'état correspondant (via la transition correspondant au symbole donné).		4. Une méthode `recherche_etat` qui étant donné un état source et un symbole, renvoie l'état correspondant (via la transition correspondant au symbole donné).

	5. Une fonction `run` qui valide un mot donné, et renvoie `True` si l'état final est atteint et `False`.		5. Une fonction `run` qui valide un mot donné, et renvoie `True` si l'état final est atteint et `False`.

	%% Cell type:code id:445d2964 tags:		%% Cell type:code id:445d2964 tags:

	``` python		``` python
	class automate:		class automate:
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

	%% Cell type:markdown id:dd5fe66b-8232-4ab6-94d7-0e49ca591f26 tags:		%% Cell type:markdown id:dd5fe66b-8232-4ab6-94d7-0e49ca591f26 tags:

	Voici un exemple attendu d'utilisation de votre structure de données :		Voici un exemple attendu d'utilisation de votre structure de données :

	%% Cell type:code id:51a7c400 tags:		%% Cell type:code id:51a7c400 tags:

	``` python		``` python
	a = automate("ab")		a = automate("ab")

	a.ajout_etat("0")		a.ajout_etat("0")
	a.ajout_etat("1", True)		a.ajout_etat("1", True)

	a.ajout_transition("0", "b", "0")		a.ajout_transition("0", "b", "0")
	a.ajout_transition("0", "a", "1")		a.ajout_transition("0", "a", "1")
	a.ajout_transition("1", "a", "1")		a.ajout_transition("1", "a", "1")
	a.ajout_transition("1", "b", "1")		a.ajout_transition("1", "b", "1")

	assert a.run("abaaaaa") == True		assert a.run("abaaaaa") == True
	assert a.run("bbb") == False		assert a.run("bbb") == False
	```		```

	%% Cell type:markdown id:d16f624a-7810-489c-9b6a-f0bba5eb25f2 tags:		%% Cell type:markdown id:d16f624a-7810-489c-9b6a-f0bba5eb25f2 tags:

	Question 2.2 - Utilisez votre structure de données pour implémenter les automates de la partie précédente.		Question 2.2 - Utilisez votre structure de données pour implémenter les automates de la partie précédente.

	%% Cell type:markdown id:244afe6c-a606-4e1f-b09b-f9dd59882135 tags:		%% Cell type:markdown id:244afe6c-a606-4e1f-b09b-f9dd59882135 tags:

	Question 1.1 (solution) :		Question 1.1 (solution) :

	%% Cell type:code id:428cf819-3d60-4776-ba94-3e8733eeadea tags:		%% Cell type:code id:428cf819-3d60-4776-ba94-3e8733eeadea tags:

	``` python		``` python
	# automate qui valide un nombre pair de fois la lettre "a" avec langage a, b		# automate qui valide un nombre pair de fois la lettre "a" avec langage a, b
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()

	# tests valides		# tests valides
	assert a.run("") == True		assert a.run("") == True
	assert a.run("aa") == True		assert a.run("aa") == True
	assert a.run("aaaa") == True		assert a.run("aaaa") == True
	assert a.run(''.join("a" for i in range(100))) == True		assert a.run(''.join("a" for i in range(100))) == True

	# tests non-valides		# tests non-valides
	assert a.run("a") == False		assert a.run("a") == False
	assert a.run(''.join("a" for i in range(100 + 1))) == False		assert a.run(''.join("a" for i in range(100 + 1))) == False

	```		```

	%% Cell type:markdown id:64e021b0-4613-444d-87d8-b0abeed5aef2 tags:		%% Cell type:markdown id:64e021b0-4613-444d-87d8-b0abeed5aef2 tags:

	Question 1.2 (solution) :		Question 1.2 (solution) :

	%% Cell type:code id:f51ce343-fcdb-49c0-a126-4ffeaf4e1920 tags:		%% Cell type:code id:f51ce343-fcdb-49c0-a126-4ffeaf4e1920 tags:

	``` python		``` python
	# automate qui valide a*a		# automate qui valide a*a
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()

	# tests valides		# tests valides
	assert a.run("aa") == True		assert a.run("aa") == True
	assert a.run("aaaa") == True		assert a.run("aaaa") == True
	assert a.run(''.join("a" for i in range(100))) == True		assert a.run(''.join("a" for i in range(100))) == True

	# tests non-valides		# tests non-valides
	assert a.run("") == False		assert a.run("") == False
	assert a.run("a") == False		assert a.run("a") == False
	assert a.run("aabb") == False		assert a.run("aabb") == False
	assert a.run("b") == False		assert a.run("b") == False
	```		```

	%% Cell type:markdown id:9b44355d-e2a6-4ef2-b427-d5c39cc72662 tags:		%% Cell type:markdown id:9b44355d-e2a6-4ef2-b427-d5c39cc72662 tags:

	Question 1.3 (solution) :		Question 1.3 (solution) :

	%% Cell type:code id:6c1a0049-03c3-47b1-adf7-35a59d8c78f7 tags:		%% Cell type:code id:6c1a0049-03c3-47b1-adf7-35a59d8c78f7 tags:

	``` python		``` python
	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

	%% Cell type:markdown id:34eb2bb6-aba0-4263-9702-761694af7348 tags:		%% Cell type:markdown id:34eb2bb6-aba0-4263-9702-761694af7348 tags:

	Question 2.3 (bonus) - Implémentez une méthode `visualize(self)` afin d'afficher votre automate en utilisant le code `graphviz` fourni dans les questions précédentes. En voici les principales étapes (il s'agit de construire un graphe..) :		Question 2.3 (bonus) - Implémentez une méthode `visualize(self)` afin d'afficher votre automate en utilisant le code `graphviz` fourni dans les questions précédentes. En voici les principales étapes (il s'agit de construire un graphe..) :

	1. Initialiser les sommes		1. Initialiser les sommes
	2. Rajouter les arrêtes		2. Rajouter les arrêtes
	3. Inclure les propriétés et labels		3. Inclure les propriétés et labels

	%% Cell type:markdown id:954a7d30-9e8a-4269-aee4-e36924da2e86 tags:		%% Cell type:markdown id:954a7d30-9e8a-4269-aee4-e36924da2e86 tags:

	Question 2.4 (bonus) - Implémentez une méthode `__str__` afin que la commande `print(a)` affiche les états internes à l'automate comme ci-dessous :		Question 2.4 (bonus) - Implémentez une méthode `__str__` afin que la commande `print(a)` affiche les états internes à l'automate comme ci-dessous :

	%% Cell type:markdown id:0a4548cc-197f-4c70-a4f9-e3c5c706d378 tags:		%% Cell type:markdown id:0a4548cc-197f-4c70-a4f9-e3c5c706d378 tags:

	```		```
	automate :		automate :
	- alphabet : 'ab'		- alphabet : 'ab'
	- init : 0		- init : 0
	- final : ['1']		- final : ['1']
	- etats (2) :		- etats (2) :
	- (0)automate :		- (0)automate :
	- alphabet : 'ab'		- alphabet : 'ab'
	- init : 0		- init : 0
	- final : ['1']		- final : ['1']
	- etats (2) :		- etats (2) :
	- (0):		- (0):
	--(b)--> (0)		--(b)--> (0)
	--(a)--> (1)		--(a)--> (1)
	- (1):		- (1):
	--(a)--> (1)		--(a)--> (1)
	--(b)--> (1)		--(b)--> (1)
	```		```

	%% Cell type:markdown id:6764667b-ab2b-46c1-a5bb-2a12bb670afd tags:		%% Cell type:markdown id:6764667b-ab2b-46c1-a5bb-2a12bb670afd tags:

	## Exercice 3 : Analyse de texte avec un automate		## Exercice 3 : Analyse de texte avec un automate

	%% Cell type:markdown id:b13e013c-8c73-4008-ac92-cf981b2a5cb0 tags:		%% Cell type:markdown id:b13e013c-8c73-4008-ac92-cf981b2a5cb0 tags:

	Nous allons maintenant développer un programme qui utilise votre structure de données d'automate implémentée en Python dans la section précédente. L'objectif de ce programme sera le suivant : proposer de compléter un mot, à partir d'une séquence de lettres partielle donnée. Par exemple si votre programme prend en entrée la séquence `bon`, en retour vous devez proposer une séquence de lettres pertinentes afin de compléter ce mot comme `bonjour` ou `bonsoir`.		Nous allons maintenant développer un programme qui utilise votre structure de données d'automate implémentée en Python dans la section précédente. L'objectif de ce programme sera le suivant : proposer de compléter un mot, à partir d'une séquence de lettres partielle donnée. Par exemple si votre programme prend en entrée la séquence `bon`, en retour vous devez proposer une séquence de lettres pertinentes afin de compléter ce mot comme `bonjour` ou `bonsoir`.

	Vous êtes libres de proposer la stratégie de recommandation de lettres que vous souhaitez. Nous vous proposons de vous baser sur es listes de mots les plus fréquents en Français [ce lien](http://www.pallier.org/extra/liste.de.mots.francais.frgut.txt) (fourni dans le fichier `mots.txt`). Ces mots permettent de réaliser des statistiques de co-occurences. Par exemple, étant donné les mots suivants :		Vous êtes libres de proposer la stratégie de recommandation de lettres que vous souhaitez. Nous vous proposons de vous baser sur des listes de mots les plus fréquents en Français [ce lien](http://www.pallier.org/extra/liste.de.mots.francais.frgut.txt) (fourni dans le fichier `mots.txt`). Ces mots permettent de réaliser des statistiques de co-occurences. Par exemple, étant donné les mots suivants :

	```		```
	abaissa		abaissa
	abaissable		abaissable
	abaissables		abaissables
	abaissai		abaissai
	abaissaient		abaissaient
	abaissais		abaissais
	abaissait		abaissait
	abaissâmes		abaissâmes
	```		```


	Si le mot d'entrée est `abaissa` alors votre programme suggère les lettres suivantes ordonnées par ordre de probabilité de transition pour compléter le mot (basé sur l'analyse du fichier `code/mots-10.txt` qui contient les mots ci-dessus):		Si le mot d'entrée est `abaissa` alors votre programme suggère les lettres suivantes ordonnées par ordre de probabilité de transition pour compléter le mot (basé sur l'analyse du fichier `code/mots-10.txt` qui contient les mots ci-dessus):



	```		```
	i (4)		i (4)
	b (2)		b (2)
	m (1)		m (1)
	```		```


	Conseils :		Conseils :

	1. Utiliser les fichiers de listes de mots (`mots.txt`, ..) en analysant la fréquence de co-occurrences de lettres (autrement dit calculer probabilité d'être l'une après l'autre)		1. Utiliser les fichiers de listes de mots (`mots.txt`, ..) en analysant la fréquence de co-occurrences de lettres (autrement dit calculer probabilité d'être l'une après l'autre)

	2. Construire un automate dont les transitions sont les probabilités de co-occurence entre les lettres		2. Construire un automate dont les transitions sont les probabilités de co-occurence entre les lettres

	3. Proposer une méthode de recommandation de transition à partir de quelques lettres fournies en entrée		3. Proposer une méthode de recommandation de transition à partir de quelques lettres fournies en entrée

	%% Cell type:code id:b5309ac0 tags:		%% Cell type:code id:b5309ac0 tags:

	``` python		``` python
	# lecture du fichier de mots		# lecture du fichier de mots
	data = []		data = []
	with open("mots-10.txt") as f:		with open("mots-10.txt") as f:
	keys = None		keys = None
	for line in f:		for line in f:
	l = [w.strip() for w in line.split(';')]		l = [w.strip() for w in line.split(';')]
	if keys is None:		if keys is None:
	keys = l		keys = l
	else:		else:
	data.append(l)		data.append(l)

	# YOUR CODE HERE		# YOUR CODE HERE
	raise NotImplementedError()		raise NotImplementedError()
	```		```

	%% Cell type:markdown id:77408003 tags:		%% Cell type:markdown id:77408003 tags:

	## Pour aller plus loin		## Pour aller plus loin

	- Vérifier si les automates sont [déterministes](https://fr.wikipedia.org/wiki/Automate_fini_d%C3%A9terministe)		- Vérifier si les automates sont [déterministes](https://fr.wikipedia.org/wiki/Automate_fini_d%C3%A9terministe)

	- Comparer vos résultats avec une implémentation [Python d'Automate](https://pypi.org/project/python-automaton/) :		- Comparer vos résultats avec une implémentation [Python d'Automate](https://pypi.org/project/python-automaton/) :

	- Enregistrer les automates en utilisant la commande		- Enregistrer les automates en utilisant la commande

	`dot.render('graph', format='svg', view=True)`		`dot.render('graph', format='svg', view=True)`

TD06/figures_automates/0_1.png

0 → 100644

+15.7 KiB

15.73 KiB

TD06/figures_automates/0_1_2.png

0 → 100644

+25.4 KiB

25.38 KiB

TD06/figures_automates/0_1_2_3_4.png

0 → 100644

+43.5 KiB

43.53 KiB

TD06/figures_automates/0_1_a_b.png

0 → 100644

+20.5 KiB

20.48 KiB

TD06/figures_automates/email.png

0 → 100644

+55.2 KiB

55.16 KiB

TD07/INF-TC1-td07.ipynb

+16 −13

TD07/INF-TC1-td07bis.ipynb→TD07bis/INF-TC1-td07bis.ipynb

+0 −0

File moved.

Compare revisions

Source

Target

Commits on Source 14

Files

TD01/BE1-INF-TC1-23-24-eleves.pdf

TD01/BE1-INF-TC1-22-23-version-eleves.pdf→TD01/BE1-INF-TC1-24-25-Eleves.pdf

TD02/INF-TC1-td02.ipynb

TD03/INF-TC1-td03.ipynb

TD04/INF-TC1-td04.ipynb

TD05/INF-TC1-td05.ipynb

TD06/INF-TC1-td06.ipynb

TD06/figures_automates/0_1.png

TD06/figures_automates/0_1_2.png

TD06/figures_automates/0_1_2_3_4.png

TD06/figures_automates/0_1_a_b.png

TD06/figures_automates/email.png

TD07/INF-TC1-td07.ipynb

TD07/INF-TC1-td07bis.ipynb→TD07bis/INF-TC1-td07bis.ipynb

Original line number	Original line	Diff line number	Diff line
	%% Cell type:markdown id:931d31d6 tags:		%% Cell type:markdown id:7f210b68 tags:

	NAME:		NAME:

	%% Cell type:markdown id:57c2dc5b-0ce7-47e4-bfeb-445c2f90cb6e tags:		%% Cell type:markdown id:57c2dc5b-0ce7-47e4-bfeb-445c2f90cb6e tags:

	# INF TC1 - TD7 (2h) - Rendu de monnaie		# INF TC1 - TD7 (2h) - Rendu de monnaie

	%% Cell type:markdown id:2a40aa1b-c3fe-4cd2-9236-3c7aeddedf55 tags:		%% Cell type:markdown id:2a40aa1b-c3fe-4cd2-9236-3c7aeddedf55 tags:

	---		---

	%% Cell type:markdown id:25995ac6-8673-46f2-9c77-37b48a889b73 tags:		%% Cell type:markdown id:25995ac6-8673-46f2-9c77-37b48a889b73 tags:

	## Objectif du TD		## Objectif du TD

	Dans ce TD nous allons aborder le problème de rendu de monnaie selon plusieurs méthodes algorithmiques :		Dans ce TD nous allons aborder le problème dit de de _rendu de monnaie_ selon plusieurs méthodes algorithmiques :

	- technique dite Gloutonne		- technique de programmation Gloutonne
	- chemin minimal dans un arbre de recherche		- chemin minimal dans un arbre de recherche
	- Programmation Dynamique (prochain TD7bis et devoir à rendre)		- Programmation Dynamique (cela fera l'objet du prochain TD7bis et du devoir à rendre)

	Vous serez amené également à créer une structure de données de graphe et une méthode de parcours de celui-ci.		Vous serez amené dans ce TD (et les suivant) à créer une structure de données de graphe et une méthode de parcours de celui-ci.

	Les réponses de la partie sur la programmation dynamique feront l'objet d'un autre sujet de TD et d'un rendu sous forme de rapport à rendre sur Moodle.		Les réponses de la partie sur la programmation dynamique feront l'objet d'un autre sujet de TD et d'un rendu sous forme de rapport à rendre sur Moodle.

	%% Cell type:markdown id:c38c9de3-f716-4907-8387-7cf6f4f5e926 tags:		%% Cell type:markdown id:c38c9de3-f716-4907-8387-7cf6f4f5e926 tags:

	## Le problème de "rendu de monnaie"		## Le problème de "rendu de monnaie"

	Le problème de rendu de monnaie est très fréquent dans la vie de tous les jours et peut être défini comme suit : étant donné un montant, une machine capable de rendre la monnaie doit rendre ce montant au client à partir de pièces (1c à 2€) et de billets. On suppose pour simplifier qu'il n'y a que des pièces en centimes; un billet de 5€ sera représenté comme une pièce de 500 centimes. On supposera dans un premier temps qu'il existe un nombre suffisant (autant que nécessaire) de chaque pièce, mais dans un second temps nous introduirons des contraintes de disponibilité des pièces.		Le problème de rendu de monnaie est très fréquent dans la vie de tous les jours et peut être défini comme suit : étant donné un montant, une machine capable de rendre la monnaie doit rendre ce montant au client à partir de pièces (1c, 2€, etc.) et de billets (10€, 50€, etc.). On suppose pour simplifier qu'il n'y a que des pièces en centimes; un billet de 5€ sera représenté comme une pièce de 500 centimes. On suppose également (dans un premier temps) qu'il existe un nombre suffisant (autant que nécessaire) de chaque pièce, mais dans un second temps nous introduirons des contraintes de disponibilité des pièces.

	%% Cell type:markdown id:5a29e913-8954-4e88-b477-234c4ee0fd9b tags:		%% Cell type:markdown id:5a29e913-8954-4e88-b477-234c4ee0fd9b tags:

	\| \| la table S \| la table D \|		\| \| la table S \| la table D \|
	\|---------------\|------------------------\|----------------------------------\|		\|---------------\|------------------------\|----------------------------------\|
	\| indice $i$\| Valeur ($v_i$) \| Disponibilité ($d_i$) \|		\| indice $i$\| Valeur ($v_i$) \| Disponibilité ($d_i$) \|
	\| 1 \| 1c \| nombre de pièces de 1c disponibles \|		\| 1 \| 1c \| nombre de pièces de 1c disponibles \|
	\| 2 \| 2c \| nombre de pièces de 2c disponibles \|		\| 2 \| 2c \| nombre de pièces de 2c disponibles \|
	\| 3 \| 5c \| ... \|		\| 3 \| 5c \| ... \|