5cba93d25eb47a677c14a56ef90a1e6176d544c2 to master · Vuillemot Romain / INF-TC1

Some changes are not shown.

For a faster browsing experience, only 100 of 148 files are shown. Download one of the files below to see all changes.

README.md

+17 −9

Original line number	Original line	Diff line number	Diff line
	# INF-TC1		# INF-TC1


	## Installation		## Installation

	* La distribution Anaconda offre cet avantage en étant multi-plateformes (Windows, Mac, Linux) et disposant de tous les outils dont vous aurez besoin en Informatique au cours du semestre (interpréteur Python, éditeur Spyder, divers modules).		* La distribution Anaconda offre cet avantage en étant multi-plateformes (Windows, Mac, Linux) et disposant de tous les outils dont vous aurez besoin en Informatique au cours du semestre (interpréteur Python, éditeur Spyder, divers modules). Vous obtiendrez la dernière version sur ce site : https://www.anaconda.com/download/

	* Nous vous demandons donc de l’installer sur vos ordinateurs et de vérifier son fonctionnement (l’exécution d’un code simple devrait suffire) avant votre première séance de TD.		* Nous vous demandons donc de l’installer sur vos ordinateurs et de vérifier son fonctionnement (l’exécution d’un code simple devrait suffire) avant votre première séance de TD.

	* Vous obtiendrez la dernière version d’Anaconda sur ce site : https://www.anaconda.com/download/		* Concerant l'éditeur de code Python, vous pouvez utiliser Spyder inclu dans Anaconda, mais vous pouvez aussi télécharger et installer Microsoft Code qui est une excellente alternative : https://code.visualstudio.com/download

	* Veillez à bien télécharger celle reposant sur Python 3.7 et adaptée à votre environnement (Windows/Mac/Linux, 32/64 bits)
	Ce n’est pas un problème si vous avez déjà une version de Python installée, Anaconda viendra en complément et ajoutera d’autres fonctionnalités.

	* Télécharger et installer Microsoft Code : https://code.visualstudio.com/download


	## Aides en informatique		## Aides en informatique

	* Des [transparents d'aide](aide-informatique.pdf)		* Des [transparents d'aide](aide-informatique.pdf)
	* Une vidéo de présentation de ces transparents https://replay.ec-lyon.fr/video/0920-aides-en-informatique/		* Une vidéo de présentation de ces transparents https://replay.ec-lyon.fr/video/0920-aides-en-informatique/

			## Livres

			Les livres suivants sont disponibles sous forme de pdf et couvrent les points abordés en cours et en TD :

			- [Think Python](books/thinkpython2.pdf), 2nd edition, par Allen B. Downey
			- [Python for Everybody](books/pythonlearn.pdf), par Charles Severance
			- [Problem Solving with Algorithms and Data Structures using Python](books/problemsolving.pdf), par Brad Miller et David Ranum
			- [ODS Pyhon](books/ods-python.pdf), par Pat Morin ([url](https://opendatastructures.org/ods-python/))

			Autres ressources :

			- https://en.wikibooks.org/wiki/Algorithms/
			- [computer science books](https://freecomputerbooks.com/compscAlgorithmBooks.html)
			No newline at end of file

TD01/BE1-INF-TC1-25-26-Eleves.pdf

0 → 100644

+1.69 MiB

File added.

No diff preview for this file type.

View file

TD01/Readme.md

0 → 100644

+0 −0

Original line number	Original line	Diff line number	Diff line

TD01/code/arbre-k-aire.py

deleted100644 → 0

+0 −56

Original line number	Original line	Diff line number	Diff line
	import sys

	class Noeud:
	def __init__(self, v, c = []):
	self.v = v
	self.c = c

	def parcours_affiche(arbre):
	for c in arbre.c:
	parcours_affiche(c)

	print(arbre.v)


	def parcours_recherche(arbre, valeur):

	if arbre is None:
	return False

	stack = arbre.c

	if valeur > arbre.v:
	return False

	if valeur == arbre.v:
	return True

	prev = sys.maxsize

	while len(stack) > 0:
	children = stack.pop(0)
	if valeur == children.v:
	return True
	if valeur > prev and valeur < children.v:
	stack = children.c
	prev = stack[0].v
	else:
	prev = children.v

	return False

	if __name__=="__main__":

	racine = Noeud(13, [Noeud(4, [Noeud(1), Noeud(2), Noeud(3)]), Noeud(8, \
	[Noeud(5), Noeud(6), Noeud(7)]), Noeud(12, [Noeud(9), Noeud(10), Noeud(11)])])

	print(parcours_affiche(racine))

	# renvoie False pour un arbre vide
	parcours_recherche(None, -1)

	# 11 est dans l'arbre
	assert parcours_recherche(racine, 11) == True

	# 12 n'est pas dans l'arbre
	assert parcours_recherche(racine, 12) == False
	No newline at end of file

TD01/code/arbre-parcours-largeur.py

deleted100644 → 0

+0 −35

Original line number	Original line	Diff line number	Diff line
	class Noeud:
	def __init__(self, v, c = []):
	self.v = v
	self.c = c

	def parcours(n):
	stack = []
	stack.append(n)
	r = []
	while len(stack) > 0:
	current = stack.pop(0)
	r.append(current.v)
	for v in current.c:
	stack.append(v)
	return r

	if __name__=="__main__":

	print(parcours(Noeud(1, \
	[ \
	Noeud(2, [ \
	Noeud(4), Noeud(5) \
	]), \
	Noeud(3) \
	] \
	) \
	))

	# [1, 2, 3, 4, 5]
	print(parcours(Noeud(5, [Noeud(4, [Noeud(2), Noeud(1)]), Noeud(3)])))
	# [5, 4, 3, 1, 2]
	print(parcours(Noeud(5, [Noeud(1), Noeud(2), Noeud(3), Noeud(4)])))
	# [5, 1, 2, 3, 4]
	print(parcours(Noeud(1, [Noeud(5), Noeud(4), Noeud(3), Noeud(2)])))
	# [1, 5, 4, 3, 2]

TD01/code/arbre-parcours-profondeur.py

deleted100644 → 0

+0 −80

Original line number	Original line	Diff line number	Diff line
	class Noeud:
	def __init__(self, v, c = []):
	self.v = v
	self.c = c

	def parcour_largeur(n):

	stack = []
	stack.append(n)

	while len(stack) > 0:
	current = stack.pop(0)

	for s in current.c:
	stack.append(s)

	print(current.v)

	def parcour_largeur(n):

	stack = []
	stack.append(n)

	while len(stack) > 0:
	current = stack.pop(0)

	for s in current.c:
	stack.append(s)

	print(current.v)

	def parcour_profondeur(n):

	stack = []
	stack.append(n)

	while len(stack) > 0:
	current = stack.pop()

	for s in reversed(current.c):
	stack.append(s)

	print(current.v)

	def parcour_profondeur_rec(n):

	if len(n.c) > 0:
	parcour_profondeur_rec(n.c[0])

	print(n.v)

	if len(n.c) > 1:
	parcour_profondeur_rec(n.c[1])

	def parcour_profondeur_rec_dic(n, A):

	if len(A[n]) > 0:
	parcour_profondeur_rec_dic(A[n][0], A)

	print(n)

	if len(A[n]) > 1:
	parcour_profondeur_rec_dic(A[n][1], A)


	racine = Noeud("chien", [Noeud("petit", [Noeud("le")]), Noeud("et", [Noeud("jaune"), Noeud("noir")])])

	parcour_profondeur_rec(racine)

	A = {"chien": ["petit", "et"],
	"petit": ["le"],
	"le": [],
	"et": ["jaune", "noir"],
	"jaune": [],
	"noir": []
	}

	parcour_profondeur_rec_dic("chien", A)

	print(A.keys())
	No newline at end of file

TD01/code/arbre-tuple.py

deleted100644 → 0

+0 −56

Original line number	Original line	Diff line number	Diff line
	import sys

	class Noeud:
	def __init__(self, v, c = []):
	self.v = v
	self.c = c

	def parcours_affiche(arbre):
	for c in arbre.c:
	parcours_affiche(c)

	print(arbre.v)


	def parcours_recherche(arbre, valeur):

	if arbre is None:
	return False

	stack = arbre.c

	if valeur > arbre.v:
	return False

	if valeur == arbre.v:
	return True

	prev = sys.maxsize

	while len(stack) > 0:
	children = stack.pop(0)
	if valeur == children.v:
	return True
	if valeur > prev and valeur < children.v:
	stack = children.c
	prev = stack[0].v
	else:
	prev = children.v

	return False

	if __name__=="__main__":

	racine = Noeud(13, [Noeud(4, [Noeud(1), Noeud(2), Noeud(3)]), Noeud(8, \
	[Noeud(5), Noeud(6), Noeud(7)]), Noeud(12, [Noeud(9), Noeud(10), Noeud(11)])])

	print(parcours_affiche(racine))

	# renvoie False pour un arbre vide
	parcours_recherche(None, -1)

	# 11 est dans l'arbre
	assert parcours_recherche(racine, 11) == True

	# 12 n'est pas dans l'arbre
	assert parcours_recherche(racine, 12) == False
	No newline at end of file

TD01/code/bfs-tree.py

deleted100644 → 0

+0 −30

Original line number	Original line	Diff line number	Diff line
	import collections

	class graph:
	def __init__(self,gdict=None):
	if gdict is None:
	gdict = {}
	self.gdict = gdict

	def bfs(graph, startnode):
	seen, queue = set([startnode]), collections.deque([startnode])
	while queue:
	vertex = queue.popleft()
	marked(vertex)
	for node in graph[vertex]:
	if node not in seen:
	seen.add(node)
	queue.append(node)

	def marked(n):
	print(n)

	tree = { "a" : set(["b","c"]),
	"b" : set(["e", "d"]),
	"c" : set(["f"]),
	"f" : set(["i"]),
	"e" : set(["g", "h"]),
	"d" : set(), "i" : set(), "g" : set(), "h" : set()
	}

	bfs(tree, "a")
	No newline at end of file

TD01/code/bfs.py

deleted100644 → 0

+0 −32

Original line number	Original line	Diff line number	Diff line
	import collections

	class graph:
	def __init__(self,gdict=None):
	if gdict is None:
	gdict = {}
	self.gdict = gdict

	def bfs(graph, startnode):
	# Track the visited and unvisited nodes using queue
	seen, queue = set([startnode]), collections.deque([startnode])
	while queue:
	vertex = queue.popleft()
	marked(vertex)
	for node in graph[vertex]:
	if node not in seen:
	seen.add(node)
	queue.append(node)

	def marked(n):
	print(n)

	if __name__=="__main__":

	gdict = { "a" : set(["b","c"]),
	"b" : set(["a", "d"]),
	"c" : set(["a", "d"]),
	"d" : set(["e"]),
	"e" : set(["a"])
	}

	bfs(gdict, "a")
	No newline at end of file

TD01/code/chaines-valide.py

deleted100644 → 0

+0 −10

Original line number	Original line	Diff line number	Diff line
	def valide(seq):
	"""Retourne True si séquence ADN."""
	ret = len(seq) != 0
	for c in seq:
	ret = (ret and True) if (c in "atgc") else False
	return ret

	if __name__=="__main__":
	assert valide("atgc")
	assert not valide("atgcz")

TD01/code/commentaires.py

deleted100644 → 0

+0 −15

Original line number	Original line	Diff line number	Diff line
	# Un commentaire court commence par un # et se limite à la fin de la ligne

	"""
	On peut aussi créer un commentaire long = une zone de
	commentaires sur plusieurs lignes placées
	entre une paire de triple-guillements dont le second suit :
	"""

	# Remarques :
	# Un ';' à la fin d'une ligne rend la ligne muette (pas d'affichage des résultats).
	# Il permet également de placer plusieurs expressions sur la même ligne.

	# Si vous placez un commentaire immédiatement après la signature d'une fonction}
	# (ou une méthode, une classe, etc.) entre un couple de """,
	# votre commentaire (appelé docstring) devient accessible avec help
	No newline at end of file

TD01/code/comprehension-list-filter.py

deleted100755 → 0

+0 −9

Original line number	Original line	Diff line number	Diff line
	carres = []

	for x in range(10):
	if x % 2:
	carres.append(x * x)

	list(map(lambda x: x * x, filter(lambda x: x % 2, range(10))))

	[x * x for x in range(10) if x % 2]

TD01/code/comprehension.py

deleted100644 → 0

+0 −37

Original line number	Original line	Diff line number	Diff line
	S = [x**2 for x in range(10)]
	V = [2**i for i in range(13)]
	M = [x for x in S if x % 2 == 0]

	print(S); print(V); print(M)
	# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
	# [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]
	# [0, 4, 16, 36, 64]


	S = {x**2 for x in range(10)} # {} au lieu de [] : on veut un ensemble
	print(S)
	# {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}
	type(S)
	#set

	V = (2**i for i in range(13))
	print(V)
	# <generator object <genexpr> at 0x7f7bb55edc18>

	type(V)
	# generator

	# On peut mieux comprendre les listes en compréhension à travers leurs fonctions équivalentes
	S = []
	for i in range(10):
	S.append(i*2)

	# Et
	S = [i*2 for i in range(10)]

	S
	# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

	[c for c in "foobar"]

	# Donne ['f', 'o', 'o', 'b', 'a', 'r']
	No newline at end of file

TD01/code/dfs-arbre.py

deleted100644 → 0

+0 −17

Original line number	Original line	Diff line number	Diff line
	def dfs(graph, start):
	visited, stack = set(), [start]
	while stack:
	vertex = stack.pop()
	if vertex not in visited:
	visited.add(vertex)
	stack.extend(graph[vertex] - visited)
	return visited

	graph = {'A': set(['B', 'C']),
	'B': set(['A', 'D', 'E']),
	'C': set(['A', 'F']),
	'D': set(['B']),
	'E': set(['B', 'F']),
	'F': set(['C', 'E'])}

	dfs(graph, 'A') # {'E', 'D', 'F', 'A', 'C', 'B'}
	No newline at end of file

TD01/code/dict.py

deleted100644 → 0

+0 −62

Original line number	Original line	Diff line number	Diff line
	# Trois fonctions importantes sur les dicts : keys(), values() et items()

	a = dict(one=1, two=2, three=3)
	b = {'one': 1, 'two': 2, 'three': 3}
	c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
	d = dict([('two', 2), ('one', 1), ('three', 3)])
	e = dict({'three': 3, 'one': 1, 'two': 2})
	a == b == c == d == e
	# True

	capitals = {'Iowa':'DesMoines','Wisconsin':'Madison'}
	print(capitals['Iowa'])
	# DesMoines

	capitals['Utah']='SaltLakeCity'
	print(capitals)
	# {'Iowa': 'DesMoines', 'Utah': 'SaltLakeCity', 'Wisconsin': 'Madison'}

	capitals['California']='Sacramento'
	print(len(capitals))
	# 4

	for k in capitals:
	print(capitals[k]," is the capital of ", k)
	# DesMoines is the capital of Iowa
	# SaltLakeCity is the capital of Utah
	# Madison is the capital of Wisconsin
	# Sacramento is the capital of California

	phone_ext={'david':1410, 'brad':1137}
	phone_ext
	# {'brad': 1137, 'david': 1410}

	phone_ext.keys() # Renvoie les clés de phone_ext
	# dict_keys(['brad', 'david'])

	list(phone_ext.keys())
	# ['brad', 'david']

	"brad" in phone_ext
	# True

	1137 in phone_ext
	# False # 1137 n'est pas une clé

	phone_ext.values() # Renvoie les valeurs de phone_ext
	# dict_values([1137, 1410])

	list(phone_ext.values())
	# [1137, 1410]

	phone_ext.items()
	# dict_items([('brad', 1137), ('david',1410)])

	phone_ext.get("kent")
	# Rien ! La clé n'y est pas.

	phone_ext.get("kent","NO ENTRY") # Si on veut récupérer la réponse en cas d'absence de la clé.
	'NO ENTRY'

	del phone_ext["david"]
	phone_ext
	No newline at end of file

TD01/code/exceptions.py

deleted100644 → 0

+0 −33

Original line number	Original line	Diff line number	Diff line
	# https://docs.python.org/3/tutorial/errors.html
	import addition

	class Error(Exception):
	"""Classe de base d'exceptions"""
	pass

	class ValueTooSmallError(Error):
	"""Si la valeur est trop petite"""
	pass

	if __name__ == "__main__":

	a, b = 1, 2

	try:
	if a < 0 or b < 0:
	raise ValueTooSmallError
	# assert addition(a, b) == 3
	# assert not addition(a, b) == 4
	# addition(a, "c")

	# raise EnvironmentError
	except AssertionError:
	print("test non validé")
	except TypeError:
	print("problème de typage")
	except ValueTooSmallError:
	print("valeur trop petite")
	except:
	print("erreur inconnue")
	finally:
	print("c'est la fin, toujours exécuté")

TD01/code/fibo-mem.py

deleted100644 → 0

+0 −18

Original line number	Original line	Diff line number	Diff line
	def fib(n, lookup):

	# Cas d'arrêt
	if n == 0 or n == 1 :
	lookup[n] = n

	# On calcule la valeur si pas déjà calculée
	if lookup[n] is None:
	lookup[n] = fib(n-1 , lookup) + fib(n-2 , lookup)

	# On renvoie la n-eme valeur
	return lookup[n]

	if __name__=="__main__":
	n = 6
	max = 100
	lookup = [None]*(max) # initialise la table de cache
	print("Le nombre de fibonacci est ", fib(n, lookup)) # affiche 8
	No newline at end of file

TD01/code/fibo-rec.py

deleted100644 → 0

+0 −11

Original line number	Original line	Diff line number	Diff line
	def fibo(n):
	if n <= 1:
	return n
	else:
	return(fibo(n-1) + fibo(n-2))

	if __name__=="__main__":
	n = 10
	print("Séquence de Fibonacci de {} nombres :".format(n))
	for i in range(10):
	print(fibo(i))
	No newline at end of file

TD01/code/file.py

deleted100644 → 0

+0 −31

Original line number	Original line	Diff line number	Diff line
	class File():
	def __init__(self, values = []):
	self.__values = []
	for v in values:
	self.ajoute(v)

	def ajoute(self, v):
	self.__values.append(v)
	return v

	def supprime(self):
	v = self.__values.pop(0)
	return v

	def renvoie(self, critere = lambda x : True):
	for v in self.__values:
	if critere(v):
	return v
	return False

	def affiche(self):
	for v in self.__values:
	print(v)

	def taille(self):
	return len(self.__values)

	if __name__ == "__main__":
	f = File()
	for d in [1, 2, 3]:
	f.ajoute(d)

TD01/code/graph-check-color.py

deleted100644 → 0

+0 −38

Original line number	Original line	Diff line number	Diff line
	class Node:
	def __init__(self, v = None, n = []):
	self.v = v
	self.n = n
	self.visited = False

	def verifier(r):

	stack = [r]

	while len(stack) > 0:
	c = stack.pop(0)
	for n in c.n:
	if(c.v == n.v): # meme couleur
	print("deux voisins de meme couleur")
	return False
	if not n.visited:
	stack.append(n)
	n.visited = True

	return True

	if __name__=="__main__":
	n1 = Node("gray")
	n2 = Node("black")
	n3 = Node("gray")
	n4 = Node("gray")
	n5 = Node("black")
	n6 = Node("gray")

	n1.n = [n2]
	n2.n = [n1, n3, n4]
	n3.n = [n2, n5]
	n4.n = [n2, n5]
	n5.n = [n3, n4, n6]
	n6.n = [n5]

	print(verifier(n1)) # True
	No newline at end of file

TD01/code/graph-cycle.py

deleted100644 → 0

+0 −26

Original line number	Original line	Diff line number	Diff line
	graph = { 0 : [1], 1 : [2], 2 : [3], 3 : [4], 4 : [1] }
	# https://algocoding.wordpress.com/2015/04/02/detecting-cycles-in-a-directed-graph-with-dfs-python/
	def cycle_existe(G):
	color = { u : "white" for u in G } # Noeuds tous blancs
	trouve_cycle = [False]

	for u in G: # On visite tous les noeuds
	if color[u] == "white":
	dfs_visite(G, u, color, trouve_cycle)
	if trouve_cycle[0]:
	break
	return trouve_cycle[0]

	def dfs_visite(G, u, color, trouve_cycle):
	if trouve_cycle[0]:
	return
	color[u] = "gray"
	for v in G[u]:
	if color[v] == "gray":
	trouve_cycle[0] = True
	return
	if color[v] == "white":
	dfs_visite(G, v, color, trouve_cycle)
	color[u] = "black"

	print(cycle_existe(graph))
	No newline at end of file

TD01/code/graph-get.py

deleted100644 → 0

+0 −25

Original line number	Original line	Diff line number	Diff line
	graph = { "a" : ["c"],
	"b" : ["c", "e"],
	"c" : ["a", "b", "d", "e"],
	"d" : ["c"],
	"e" : ["c", "b"],
	"f" : []
	}


	def genere_arretes(graph):
	edges = []
	for node in graph:
	for neighbour in graph[node]:
	edges.append((node, neighbour))

	return edges

	# Affiche les sommets
	print(list(graph.keys()))

	# Affiche les arrêtes
	print(genere_aretes(graph))

	# >>> [('a', 'c'), ('c', 'a'), ('c', 'b'), ('c', 'd'), ('c', 'e'),
	# ('b', 'c'), ('b', 'e'), ('e', 'c'), ('e', 'b'), ('d', 'c')]
	No newline at end of file

TD01/code/graph-labyrinthe.py

deleted100644 → 0

+0 −36

Original line number	Original line	Diff line number	Diff line
	labyrinthe = [[0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 1, 0, 1, 1, 1, 1, 1, 1, 0],
	[0, 1, 0, 1, 0, 0, 0, 0, 1, 0],
	[0, 1, 0, 1, 0, 1, 1, 0, 1, 0],
	[0, 0, 0, 1, 0, 1, 1, 0, 1, 0],
	[0, 1, 0, 1, 0, 0, 1, 0, 1, 0],
	[0, 1, 0, 1, 1, 1, 1, 0, 1, 0],
	[0, 1, 0, 0, 0, 0, 0, 0, 1, 0],
	[0, 1, 1, 1, 0, 1, 1, 1, 1, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]

	def affiche_labyrinthe (l):
	print('\n'.join(''.join('#' if item else '.' for item in row) for row in l))
	print()

	def voisins(l, x, y):
	return ((x+dx, y+dy)
	for dx, dy in ((-1,-1), (-1,0), (-1,1), (0,-1), (0,1), (1,-1), (1,0), (1,1))
	if 0 <= x+dx < len(l[0]) and 0 <= y+dy < len(l) and l[y+dy][x+dx] == 0)

	# IMPORTANT : chaque appel récursif ne doit pas modifier les chemins des autres,
	# donc chacun a une copie non modifiable du chemin, ce pourquoi on utilise un tuple plutôt que liste
	def existe_profondeur(l, x0=0, y0=0, chemin=()):
	# print(x0, y0)
	if (x0, y0) == (len(l[0])-1, len(l)-1): # condition de terminaison
	return True
	chemin += ((x0, y0),) # on crée un nouveau chemin avec la position courante
	for x, y in voisins(l, x0, y0):
	if (x, y) in chemin: # on ignore le voisin si déjà visité par le chemin courant
	continue
	if existe_profondeur(l, x, y, chemin): # appel récursif à partir de la position voisine
	return True # on a trouvé un chemin par la position voisine, donc aussi par l'actuelle
	return False # aucun des voisins ne mène à la sortie, donc l'actuelle non plus

	affiche_labyrinthe(labyrinthe)
	print(existe_profondeur(labyrinthe))

TD01/code/graph-parcours-bellman.py

deleted100644 → 0

+0 −20

Original line number	Original line	Diff line number	Diff line
	def BellmanFord(self, src):

	# Distances infinies
	dist = [float("Inf")] * self.V
	dist[src] = 0

	# Relache les sommets - 1
	for i in range(self.V - 1):

	# Met a jour noeud et parents
	for u, v, w in self.graph:
	if dist[u] != float("Inf") and dist[u] + w < dist[v]:
	dist[v] = dist[u] + w

	# Verifie si cycle
	for u, v, w in self.graph:
	if dist[u] != float("Inf") and dist[u] + w < dist[v]:
	print "Le graphe contient des cycles négatifs"
	return

	No newline at end of file

TD01/code/graph-parcours-dijkstra.py

deleted100644 → 0

+0 −43

Original line number	Original line	Diff line number	Diff line
	class Graph:
	def __init__(self):
	self.nodes = set()
	self.edges = defaultdict(list)
	self.distances = {}

	def add_node(self, value):
	self.nodes.add(value)

	def add_edge(self, from_node, to_node, distance):
	self.edges[from_node].append(to_node)
	self.edges[to_node].append(from_node)
	self.distances[(from_node, to_node)] = distance


	def dijsktra(graph, initial):
	visited = {initial: 0}
	path = {}

	nodes = set(graph.nodes)

	while nodes:
	min_node = None
	for node in nodes:
	if node in visited:
	if min_node is None:
	min_node = node
	elif visited[node] < visited[min_node]:
	min_node = node

	if min_node is None:
	break

	nodes.remove(min_node)
	current_weight = visited[min_node]

	for edge in graph.edges[min_node]:
	weight = current_weight + graph.distance[(min_node, edge)]
	if edge not in visited or weight < visited[edge]:
	visited[edge] = weight
	path[edge] = min_node

	return visited, path
	No newline at end of file

TD01/code/graph-similarite.py

deleted100644 → 0

+0 −37

Original line number	Original line	Diff line number	Diff line
	# Par exemple pour Fool et Sage vous devez renvoyez le résultat suivant :
	#
	# FOOL
	# POOL
	# POLL
	# POLE
	# PALE
	# SALE
	# SAGE
	#
	# SOLUTION:

	graph = {'A': ['B', 'C'],
	'B': ['C', 'D'],
	'C': ['D'],
	'D': ['C'],
	'E': ['F'],
	'F': ['C']
	}

	def chemin(graphe, source, destination, visite=None):

	if source == destination:
	return [destination]
	else:
	visite = visite or set()
	for s in graphe[source]:
	if s not in visite:
	visite.add(s)
	print("trace:", source + " > " + s)
	sous_chemin = chemin(graphe, s, destination, visite)
	if sous_chemin is not None:
	return [source] + sous_chemin

	print(chemin(simGraphe(["AA", "AB", "BC", "AC", "DD"]), "AA", "BC"))

	# ['AA', 'AB', 'AC', 'BC']
	No newline at end of file

TD01/code/graphe-dico.py

deleted100644 → 0

+0 −25

Original line number	Original line	Diff line number	Diff line
	G = {
	'A' : ['B','C', 'F'],
	'B' : ['D', 'E'],
	'C' : ['F'],
	'D' : ['G'],
	'E' : ['F'],
	'F' : ['G', 'H'],
	'G' : ['H'],
	'H' : []
	}

	v = set()

	def traitement(v, G, n):
	if n not in v:
	v.add(n)
	print(n)
	for m in G[n]:
	traitement(v, G, m)

	if __name__ == '__main__':
	traitement(v, G, 'A')

	if len(v) > 0:
	print("Que se passe-t-il ?")

TD01/code/graphe-liens.py

deleted100644 → 0

+0 −23

Original line number	Original line	Diff line number	Diff line
	class Graphe:
	def __init__(self, *args):
	self.edges = [e for e in args]
	self.nodes = []
	for e in self.edges:
	if e[0] not in self.nodes:
	self.nodes += [ e[0] ]
	if e[1] not in self.nodes:
	self.nodes += [ e[1] ]

	def mat(self):
	self.mat = [[ 0 for j in range(len(self.nodes))] for i in range(len(self.nodes))]
	for i in self.edges:
	self.mat[ self.nodes.index(i[0]) ][ self.nodes.index(i[1]) ] = 1
	self.mat[ self.nodes.index(i[1]) ][ self.nodes.index(i[0]) ] = 1

	return self.mat

	if __name__ == "__main__":
	G = Graphe( ('A','B') , ('A','C') , ('B','C') )
	print( 'Les noeuds de G sont : {}'.format(G.nodes) )
	print( 'Les arêtes de G sont : {}'.format(G.edges) )
	print( 'La matrice d\'adjacence de G est : {}'.format(G.mat()) )
	No newline at end of file

TD01/code/graphe-matrice.py

deleted100644 → 0

+0 −12

Original line number	Original line	Diff line number	Diff line

	# Création d'un matrice d'adjacence pour un graphe
	n = 5
	G = [[0 for j in range(n)] for i in range (n)]

	# Ajout d'un lien (si le graphe est non orienté)
	G[0][1] = 1
	G[1][0] = 1

	# Affichage du graphe
	for row in G:
	print(row)
	No newline at end of file

TD01/code/graphe-sim.py

deleted100644 → 0

+0 −70

Original line number	Original line	Diff line number	Diff line
	# Par exemple pour Fool et Sage vous devez renvoyez le résultat suivant :
	#
	# FOOL
	# POOL
	# POLL
	# POLE
	# PALE
	# SALE
	# SAGE
	#
	# SOLUTION:

	graph = {'A': ['B', 'C'],
	'B': ['C', 'D'],
	'C': ['D'],
	'D': ['C'],
	'E': ['F'],
	'F': ['C']
	}

	class Graphe(dict):
	def __init__(self, liens, noeuds):
	for v in liens:
	self[v] = set()
	for e in noeuds:
	self.ajout_noeud(e)

	def ajout_lien(self, lien):
	self[lien[0]].add(lien[1])
	self[lien[1]].add(lien[0])

	def ajout_noeud(self, noeud):
	self[noeud] = set()

	def simGraphe(mots):
	d = {}
	g = Graphe(mots, [])

	for mot in mots:
	for i in range(len(mot)):
	groupe = mot[:i] + '_' + mot[i+1:]
	if groupe in d:
	d[groupe].append(mot)
	else:
	d[groupe] = [mot]

	for groupe in d.keys():
	for mot1 in d[groupe]:
	for mot2 in d[groupe]:
	if mot1 != mot2:
	g.ajout_lien([mot1, mot2])
	return g

	def chemin(graphe, source, destination, visite=None):

	if source == destination:
	return [destination]
	else:
	visite = visite or set()
	for s in graphe[source]:
	if s not in visite:
	visite.add(s)
	print("trace:", source + " > " + s)
	sous_chemin = chemin(graphe, s, destination, visite)
	if sous_chemin is not None:
	return [source] + sous_chemin

	print(chemin(simGraphe(["AA", "AB", "BC", "AC", "DD"]), "AA", "BC"))

	# ['AA', 'AB', 'AC', 'BC']
	No newline at end of file

TD01/code/liste-liee.py

deleted100644 → 0

+0 −33

Original line number	Original line	Diff line number	Diff line
	class Node:
	def __init__(self, data = None, next = None):
	self.data = data
	self.next = next

	class LinkedList:
	def __init__(self):
	self.head = None

	def listprint(self):
	printval = self.head
	while printval is not None:
	print(printval.dataval)
	printval = printval.nextval

	def push(self, n):
	if self.head is None:
	self.head = Node(n)
	else:
	node = self.head
	while node.next is not None:
	node = node.next
	node.next = Node(n)

	def detectLoop(self):
	s = set()
	temp = self.head
	while (temp):
	if (temp in s):
	return True
	s.add(temp)
	temp = temp.next
	return False
	No newline at end of file

TD01/code/listes-fusion.py

deleted100644 → 0

+0 −26

Original line number	Original line	Diff line number	Diff line
	def fusion(l1, l2):

	res = []
	i = 0
	j = 0

	while i < len(l1) and j < len(l2):
	if l1[i] < l2[j]:
	res.append(l1[i])
	i += 1
	else:
	res.append(l2[i])
	j += 1

	while i < len(l1):
	res.append(l1[i])
	i += 1

	while j < len(l2):
	res.append(l2[j])
	j += 1

	return res

	print(fusion([2, 2, 3], [0, 4, 5, 14, 20, 25]))
	# [0, 2, 2, 3, 4, 5, 14, 20, 25]
	No newline at end of file

TD01/code/listes-liee-boucle.py

deleted100644 → 0

+0 −15

Original line number	Original line	Diff line number	Diff line
	from liste_liee import *

	ll = liste_liee() # Ajout de données
	ll.push(20)
	ll.push(4)
	ll.push(15)
	ll.push(10)

	# Création d'une boucle
	ll.head.next.next.next.next = ll.head;

	if( ll.detectLoop()):
	print ("Il y a une boucle !")
	else :
	print ("Pas de boucle ! ")
	No newline at end of file

TD01/code/listes-liees-boucle.py

deleted100644 → 0

+0 −15

Original line number	Original line	Diff line number	Diff line
	from LinkedList import *

	ll = LinkedList() # Ajout de données
	ll.push(20)
	ll.push(4)
	ll.push(15)
	ll.push(10)

	# Création d'une boucle
	ll.head.next.next.next.next = ll.head;

	if( ll.detectLoop()):
	print ("Il y a une boucle !")
	else :
	print ("Pas de boucle ! ")
	No newline at end of file

TD01/code/math-addition.py

deleted100644 → 0

+0 −17

Original line number	Original line	Diff line number	Diff line
	def addition(a, b):
	return a + b

	def addition_inf(*argv):
	res = 0
	for arg in argv:
	res += arg
	return res

	if __name__=="__main__":
	assert addition(1, 2) == 3
	assert not addition(1, 2) == 2

	assert addition_inf(1, 1, 1) == 3
	assert not addition_inf(1, 1, 1) == 2

	assert addition_inf(1, 1, 1) == addition(1, 2)
	No newline at end of file

TD01/code/math-division.py

deleted100644 → 0

+0 −15

Original line number	Original line	Diff line number	Diff line
	def division(x, y):
	return x / y

	if __name__=="__main__":
	try:
	r = division(2, 1)
	# division(2, 0)
	# division("2", "1")
	except ZeroDivisionError:
	print("Division par zero !")
	else:
	print("Le résultat est", r)
	finally:
	print("Clause finale")

TD01/code/math-moyenne.py

deleted100644 → 0

+0 −10

Original line number	Original line	Diff line number	Diff line
	# Calcul de la moyenne de deux entiers

	a=input('Donner la valeur de a : ')
	b=input('Donner la valeur de b : ')
	print('la moyenne = ', (int(a) + int(b))/2) # int(a) : conversion de 'a' en entier

	# Une seconde méthode : on convertit en lisant les valeurs en int
	a=int(input('Donner la valeur de a : '))
	b=int(input('Donner la valeur de b : '))
	print('la moyenne = ', (a+b)/2)

TD01/code/math-multiplication-rec.py

deleted100644 → 0

+0 −8

Original line number	Original line	Diff line number	Diff line
	def mult(a, b):
	if(b == 1):
	return a
	else:
	return a + mult(a, b-1)


	print(10 * 13, mult(10, 13))

TD01/code/math-parite.py

deleted100644 → 0

+0 −18

Original line number	Original line	Diff line number	Diff line
	def parite(a):
	""" Lire un entier au clavier et décider (et afficher) s'il est pair ou impair. """
	if (a%2 == 1):
	print(a, " est impair")
	else :
	print(a, " est pair")

	if __name__=="__main__":

	while True:
	try:
	a = int(input('Donner un entier positif : '))
	parite(a)
	break
	except ValueError:
	print("Ce n'est pas un nombre valide.. ré-essayer !")


	No newline at end of file

TD01/code/math-premier.py

deleted100644 → 0

+0 −30

Original line number	Original line	Diff line number	Diff line
	from math import sqrt

	def premier(a):

	# si == 1 ou ==2
	if(a == 1 or a== 2):
	return True
	# si pair
	elif(a % 2 == 0):
	return False
	else:
	if (int(sqrt(a)) == sqrt(a)):
	return False

	for k in range(3, int(sqrt(a)+1), 2):
	if a % k == 0:
	return False

	return True
	# autre

	assert premier(1) == True
	assert premier(2) == True
	assert premier(4) == False
	assert premier(9) == False

	assert premier(3) == True
	assert premier(20) == False
	assert premier(23) == True
	assert premier(6067) == True

TD01/code/math-racines.py

deleted100644 → 0

+0 −18

Original line number	Original line	Diff line number	Diff line
	from math import sqrt;

	def trinome(a, b, c):
	""" Résolution équation quadratique """
	delta = b*2 - 4a*c
	if delta > 0.0:
	assert(a != 0)
	racine_delta = sqrt(delta)
	return (2, (-b-racine_delta)/(2a), (-b+racine_delta)/(2a))
	elif delta < 0.0: return (0,)
	else:
	assert(a != 0)
	return (1, (-b/(2*a)))

	if __name__ == "__main__":
	print(trinome(1.0, -3.0, 2.0))
	print(trinome(1.0, -2.0, 1.0))
	print(trinome(1.0, 1.0, 1.0))
	No newline at end of file

TD01/code/pile.py

deleted100644 → 0

+0 −25

Original line number	Original line	Diff line number	Diff line
	class Pile():
	def __init__(self, values = []):
	self.__values = []
	for v in values:
	self.ajoute(v)

	def ajoute(self, v):
	self.__values.append(v)
	return v

	def supprime(self):
	v = self.__values.pop()
	return v

	def affiche(self):
	for v in self.__values:
	print(v)

	def taille(self):
	return len(self.__values)

	if __name__ == "__main__":
	p = Pile()
	for d in [1, 2, 3]:
	p.ajoute(d)

TD01/code/recherche-dichotomie-place.py

deleted100644 → 0

+0 −27

Original line number	Original line	Diff line number	Diff line
	def trouveOuDitOuInserer(sequence, val, inf=0, sup=None):
	if sup is None:
	sup = len(sequence)-1
	if sup < inf :
	return inf
	mid = (inf + sup) // 2
	if sequence[mid] == val: return mid
	if sequence[mid] < val: inf = mid + 1
	else: sup = mid-1
	return trouveOuDitOuInserer(sequence, val, inf, sup)
	3
	ary = (2, 3, 4, 6, 7,9,10, 12, 13)
	print('On cherche dans ', ary, ' et les places sont : ')
	print('7 ', trouveOuDitOuInserer(ary, 7, 0, len(ary) -1));input('?');
	print('2 ',trouveOuDitOuInserer(ary, 2, 0, len(ary) -1));input('?')
	print('5 ',trouveOuDitOuInserer(ary, 5, 0, len(ary) -1));input('?')
	print('15', trouveOuDitOuInserer(ary, 15, 0, len(ary) -1));input('?')
	print('1', trouveOuDitOuInserer(ary, 1, 0, len(ary) -1));input('?')

	""" tests
	On cherche dans (2, 3, 4, 6, 7, 9, 10, 12, 13) et les places sont :
	7 4
	2 0
	5 3
	15 9
	1 0
	"""
	No newline at end of file

TD01/code/recherche-dichotomie.py

deleted100644 → 0

+0 −40

Original line number	Original line	Diff line number	Diff line
	from random import randint;

	def dichotomie(liste, val):
	print("La liste reçue : ",liste, ' de taille ', len(liste))
	if liste==[] : return False
	m=len(liste)//2
	print('\ton compare liste[',m,']=', liste[m], ' et ', val)
	if liste[m] == val: return True
	elif liste[m] > val: return dichotomie(liste[:m], val) # dans liste[:m], liste[m] n'est pas inclu.
	else: return dichotomie(liste[m+1:], val) # dans liste[X:], liste[X] est inclu.

	ll=[randint(1,50) for i in range(10)]
	ll.sort()
	x=int(input("chercher une valeur entre 1 et 50 dans la liste " + repr(ll) + " ? : "))
	print("La présence de ", x, " dans la liste : ", ll, dichotomie(ll, x))

	"""
	# Et un cas de succès :
	chercher une valeur entre 1 et 50 dans la liste [4, 7, 10, 14, 19, 27, 31, 32, 35, 47] ? : 32
	La liste reçue : [4, 7, 10, 14, 19, 27, 31, 32, 35, 47] de taille 10
	on compare liste[ 5 ]= 27 et 32
	La liste reçue : [31, 32, 35, 47] de taille 4
	on compare liste[ 2 ]= 35 et 32
	La liste reçue : [31, 32] de taille 2
	on compare liste[ 1 ]= 32 et 32
	La présence de 32 dans la liste : [4, 7, 10, 14, 19, 27, 31, 32, 35, 47] True

	# Et un cas d'échec :
	chercher une valeur entre 1 et 50 dans la liste [22, 23, 30, 33, 37, 42, 42, 43, 47, 49] ? : 35
	La liste reçue : [22, 23, 30, 33, 37, 42, 42, 43, 47, 49] de taille 10
	on compare liste[ 5 ]= 42 et 35
	La liste reçue : [22, 23, 30, 33, 37] de taille 5
	on compare liste[ 2 ]= 30 et 35
	La liste reçue : [33, 37] de taille 2
	on compare liste[ 1 ]= 37 et 35
	La liste reçue : [33] de taille 1
	on compare liste[ 0 ]= 33 et 35
	La liste reçue : [] de taille 0
	La présence de 35 dans la liste : [22, 23, 30, 33, 37, 42, 42, 43, 47, 49] False
	"""
	No newline at end of file

TD01/code/recherche-dico.py

deleted100644 → 0

+0 −17

Original line number	Original line	Diff line number	Diff line
	def recherche(element, liste):
	a = 0
	b = len(liste)-1

	while a < b :
	m = (a+b) //2
	if liste[m] == element :
	return m
	elif liste[m] > element :
	b = m-1
	else :
	a = m+1

	return a

	if __name__=="__main__":
	print (recherche(3, [3, 1, 4, 2, 3]))

TD01/code/recherche2.py

deleted100644 → 0

+0 −23

Original line number	Original line	Diff line number	Diff line
	def recherche(L, v):

	if(len(L) <= 0):
	return False

	a = 0
	b = len(L)
	m = b // 2

	if(L[m] == v):
	return True
	elif(L[m] > v):
	return recherche(L[0:m], v)
	elif(L[m] < v):
	return recherche(L[m+1:b], v)
	else:
	return False

	if __name__=="__main__":
	assert recherche([1, 2, 3], 1)
	assert recherche([], 1) == False
	assert recherche([1], 1) == True
	assert recherche([1, 2, 3], 3) == True
	No newline at end of file

TD01/code/rod-cutting.py

deleted100644 → 0

+0 −20

Original line number	Original line	Diff line number	Diff line
	INT_MIN = 0

	def cutRod(price, n):

	# Initialisation tables de cache
	val = [0 for x in range(n+1)]
	val[0] = 0

	for i in range(1, n+1):
	max_val = INT_MIN
	for j in range(i):
	max_val = max(max_val, price[j] + val[i-j-1])
	val[i] = max_val

	return val[n]

	if __name__=="__main__":
	arr = [1, 5, 8, 9, 10, 17, 17, 20]
	size = len(arr)
	print("Valeur maximum de découpe " + str(cutRod(arr, size)))
	No newline at end of file

TD01/code/set-duplicatas.py

deleted100644 → 0

+0 −11

Original line number	Original line	Diff line number	Diff line
	def duplicatas(L):
	s = set()
	for x in L:
	if x in s:
	return True
	s.add(x)
	return False

	if __name__=="__main__":
	assert duplicatas([3, 5, 3]) == True
	assert duplicatas([3, 5, 5]) == False

TD01/code/set-exemples.py

deleted100644 → 0

+0 −59

Original line number	Original line	Diff line number	Diff line
	{3,6,"cat",4.5,False}

	# {False, 4.5, 3, 6, 'cat'} # L'ensemble est ordonné
	my_set = {3,6,"cat",4.5,False}
	my_set

	#{False, 3, 4.5, 6, 'cat'}

	len(my_set)
	# 5

	False in my_set
	# True

	"dog" in my_set
	#False

	your_set = {99,3,100}
	my_set.union(your_set)
	# {False, 3, 4.5, 6, 99, 'cat', 100}

	my_set \| your_set
	# {False, 3, 4.5, 6, 99, 'cat', 100}

	my_set.intersection(your_set)
	# {3}

	my_set & your_set
	# {3}

	my_set.difference(your_set)
	# {False, 4.5, 6, 'cat'}

	my_set - your_set
	# {False, 4.5, 6, 'cat'}

	{3,100}.issubset(your_set)
	# True

	{3,100} <= your_set
	# True

	my_set.add("house")
	my_set
	# {False, 3, 4.5, 6, 'house', 'cat'}

	my_set.remove(4.5)
	my_set
	# {False, 3, 6, 'house', 'cat'}

	my_set.pop()
	# False

	my_set
	# {3, 6, 'house', 'cat'}

	my_set.clear()
	my_set
	set() # Ensemble vide
	No newline at end of file

TD01/code/tas.py

deleted100644 → 0

+0 −62

Original line number	Original line	Diff line number	Diff line
	class Tas():
	def __init__(self):
	self.__values = []

	def push(self, value):
	self.__values.append(value)

	def peek(self, i): # pop sans suppression
	return self.__values[i], i

	def fg(self, i):
	left_i = 2 * i + 1
	if left_i > len(self.__values):
	return None, left_i
	else:
	return self.__values[left_i], left_i

	def fd(self, i):
	droite_i = 2 * i + 2
	if droite_i > len(self.__values):
	return None, droite_i
	else:
	return self.__values[droite_i], droite_i

	def parent(self, i):
	return self.__values[(i - 1) // 2]

	def afficher(self):
	return ' '.join(str(v) for v in self.__values)

	def inserer(self, value):
	self.push(value)
	i = len(self.__values) - 1
	while (i + 1) // 2 > 0:
	if self.__values[i] < self.parent(i):
	tmp = self.__values[i // 2]
	self.__values[i // 2] = self.__values[i]
	self.__values[i] = tmp
	i = i // 2

	def supprimer(self, i):

	v = self.__values.pop(i)
	max_i = i
	n = len(self.__values) - 1

	while self.__values[i] > self.fg(i)[0] or self.__values[i] > self.fd(i)[0]:

	max = self.__values[i]

	if i < n and max > self.fg(i)[0]:
	max_i = 2 * i + 1

	if i < n and max > self.fd(i)[0]:
	max_i = 2 * i + 2

	if max_i != i:
	self.__values[i], self.__values[max_i] = self.__values[max_i], self.__values[i]

	i = max_i

	return v
	No newline at end of file

TD01/code/time.py

deleted100644 → 0

+0 −7

Original line number	Original line	Diff line number	Diff line
	import timeit

	print(timeit.timeit("x = 2 + 2"))
	#.0188..............

	print(timeit.timeit("x = range(10)"))
	#.589.........

TD01/code/tirage-des.py

deleted100644 → 0

+0 −26

Original line number	Original line	Diff line number	Diff line
	from random import *

	effectifs=[0,0,0,0,0,0]
	# OU
	# effectif=[0]*6
	for n in range(10000):
	dice=randint(1,6)
	effectifs[dice-1]+=1

	print(effectifs)

	#--> [1642, 1710, 1683, 1661, 1678, 1626]
	# Donner l'intervalle de confiance associé à ce résultat à 95%

	#Même chose avec 2 dés
	from random import *

	effectifs=[0]*11
	for n in range(10000):
	de1=randint(1,6)
	de2=randint(1,6)
	twodice=de1+de2
	effectifs[twodice-2]+=1

	print(effectifs)
	# --> [299, 540, 832, 1159, 1401, 1665, 1401, 1103, 787, 541, 272]
	No newline at end of file

TD01/code/tirage-gaussienne.py

deleted100644 → 0

+0 −24

Original line number	Original line	Diff line number	Diff line
	from math import *
	from random import *

	def tirage_gauss_centre_reduit():
	x=uniform(0,1)
	y=sqrt(-2*log(uniform(0,1)))
	y = ycos(x2*pi)
	return y

	try :
	n=int(input("combien de valeurs : "))
	for i in range(n) :
	print("Le tirage : ", tirage_gauss_centre_reduit())
	except ValueError as err :
	print("Error: {0}".format(err))

	""" TRACE :
	combien de valeurs : 5
	Le tirage : 0.1675459650607427
	Le tirage : -0.8810297798592189
	Le tirage : 0.4764601603767129
	Le tirage : -1.8446292482050937
	Le tirage : -0.35483078367598453
	"""
	No newline at end of file

TD01/code/tirage-random.py

deleted100644 → 0

+0 −19

Original line number	Original line	Diff line number	Diff line
	# imports
	from random import seed, random

	# fonctions
	def listAleatoireFloat(n):
	"""Retourne une liste de <n> flottants aleatoires."""
	return [random() for i in range(n)]

	# programme principal
	n = int(input("Entrez un entier [2 .. 100] : "))
	while not (2 <= n <= 100): # saisie filtree
	n = int(input("Entrez un entier [2 .. 100], s.v.p. : "))

	seed() # initialise le generateur de nombres aleatoires
	t = listAleatoireFloat(n) # construction de la liste

	print("Liste :", t)
	print("Amplitude : {:.2f}".format(max(t) - min(t)))
	print("Moyenne : {:.2f}".format(sum(t)/n))
	No newline at end of file

TD01/code/tirage-remise.py

deleted100644 → 0

+0 −26

Original line number	Original line	Diff line number	Diff line
	from math import *
	from random import *

	# Simulation d'un tirage avec remise de k objets parmi n

	def tirage_uniforme_k_of_n_avec_remise(n,k):
	if k > n :
	raise ValueError("k (%d) doit être =< que n (%d) " % (k,n))
	T=[x for x in range(1,n+1,1)] # On constitue une urne avec p objets

	for i in range(k) : # Tirage de k numéros
	d=randint(1,n)
	# On permute le d-ème élément de l'urne et la derniere
	temp=T[d-1]
	T[d-1]=T[n-1]
	T[n-1]=temp
	n=n-1
	return T[n:n+k+1]


	n=int(input("La valeur de n ? "))
	k=int(input("La valeur de k (parmi n) ? "))
	try :
	print("Le tirage : ", tirage_uniforme_k_of_n_avec_remise(n,k))
	except ValueError as err :
	print("Error: {0}".format(err))
	No newline at end of file

TD01/code/tri-analyse.py

deleted100644 → 0

+0 −261

Original line number	Original line	Diff line number	Diff line
	# Comparaison des différents tris
	import time
	import random
	import matplotlib.pyplot as plt
	import numpy as np

	# On commence par définir une petite méthode "utilitaire" qui va nous servir souvent.
	# permute permet de permuter deux éléments situés aux indices i et j d'un tableau.
	def permute(tab, i, j):
	'''
	:e/s: tab, un tableau d'éléments
	:entrees i et j: (int) les indices des éléments à permuter
	:pre-cond: i et j sont des indices valides dans tab
	:post-cond: le tableau est modifié, deux valeurs sont perumtées
	'''
	temp = tab[i]
	tab[i] = tab[j]
	tab[j] = temp

	# Tri par sélection
	# Rappel : on recherche le minimum du tableau, et on le permute avec l'élément dans la première case.
	# Ensuite, on recherche le minimum dans le reste du tableau, et on le permute avec l'élément dans la 2ème case.
	# Et ainsi de suite...


	def triSelection(tab):
	'''
	:e/s tab: tableau (de float)
	:post-cond:
	- ∀ i ∈ [0;len(tab)[, ∃ j ∈ [0;len(tab)[, tabₛ[j] = tabₑ[i]
	(les éléments de tab ont simplent changé d'ordre)
	- ∀ i ∈ [1;len(tab)[, tabₛ[i] ≥ tabₛ[i-1]
	(les éléments de tab sont triés par valeur croissante)
	:complexité : 𝓞(n²)
	'''
	for i in range(len(tab)-1):
	indice_min = i

	# Boucle de recherche du minimum dans le tableau restant
	for j in range(i+1,len(tab)):
	if tab[j]<tab[indice_min]:
	indice_min=j

	# Une fois le min trouvé, on le permute pour le mettre à sa place
	permute(tab, i, indice_min)


	# Tri par insertion
	# Rappel : on considère que le "début" du tableau est trié.
	# On se place au niveau de la première valeur non triée, et on la décale à gauche jusqu'à ce qu'elle trouve sa place
	# Observez que la partie gauche du tableau est déjà triée...


	# On commence par écrire une petite fonction utilitaire (une autre).
	# Cette fonction prend un élément à un indice i, et le décale sur
	# sa gauche jusqu'à ce qu'il soit à sa place... en faisant
	# l'hypothèse que tous les éléments sur sa gauche sont bien triés.

	def insereElt(tab, i):
	'''
	:e/s tab: tableau d'éléments
	:entrée i: int
	:pré-cond:
	- 1 ≤ i < len(tab)
	- ∀ j ∈ [1;i[, tab[j] ≥ tab[j-1] (tab est trié entre 0 et i-1)
	:post-cond:
	- ∀ j ∈ [0;i+1[, ∃ k ∈ [0;i+1[, tabₛ[k] = tabₑ[j]
	(les éléments entre 0 et i+1 ont simplement changé d'ordre)
	- ∀ j ∈ [i+1;len(tab)[, tabₛ[j] = tabₑ[j]
	(les éléments au delà de i n'ont pas été modifiés)
	- ∀ j ∈ [1;i+1[, tab[j] ≥ tab[j-1]
	(tab est trié entre 0 et i)
	'''
	while (tab[i-1] > tab[i]) and i>0 :
	permute(tab, i, i-1)
	i -= 1

	# On écrit ensuite l'algo principal qui consiste à prendre
	# tour à tour chaque élément "non trié", et à l'insérer dans
	# le tableau trié (c'est-à-dire à le décaler jusqu'à sa bonne
	# place sur sa gauche).
	def triInsertion(tab):
	'''
	:e/s tab: tableau d'éléments
	:pré- et post-conditions usuelles
	'''
	for i in range(1,len(tab)):
	insereElt(tab, i)


	# Tri binaire, ou quicksort
	# Le quicksort est un tri récursif par excellence.
	# Le principe est que l'on choisit une valeur pivot,
	# on range toutes les valeurs plus petites que le pivot à gauche du pivot
	# et toutes les valeurs plus grandes à droite.
	# Ensuite, on applique la même démarche sur les sous-tableaux gauche et droite.
	# Une simulation intéressante est disponible ici :
	# http://interactivepython.org/runestone/static/pythonds/SortSearch/TheQuickSort.html


	# On définit une méthode utilitaire qui va nous aider à partitionner notre tableau autour d'un pivot
	def partitionne(tab, imin, imax):
	'''
	:e/s tab: tableau d'éléments
	:entrée imin: int
	:entrée imax: int
	:sortie idroite: int
	:pré-cond: 0 ≤ imin ≤ imax < len(tab)
	:post-cond:
	- imin ≤ idroite ≤ imax
	- ∀ i ∈ [0;imin[ U ]imax;len(tab)[, tabₛ[i] = tabₑ[i]
	(tab n'est pas modifié en dehors de la plage [imin;imax])
	- ∀ i ∈ [imin;imax], ∃ j ∈ [imin;imax], tabₛ[j] = tabₑ[i]
	(les éléments de tab ont simplent changé d'ordre entre imin et imax)
	- ∀ i ∈ [imin;idroite], tabₛ[i] ≤ tabₛ[idroite]
	(les éléments à gauche du pivot lui sont inférieurs ou égaux)
	- ∀ i ∈ ]idroite;imax], tabₛ[i] > tabₛ[idroite]
	(les éléments à droite du pivot lui sont supérieurs)
	'''
	pivot = tab[imin] # On choisit arbitrairement le premier élément comme pivot

	igauche = imin + 1
	idroite = imax
	fini = False
	while not fini:
	while igauche <= idroite and tab[igauche] <= pivot:
	igauche = igauche + 1
	while tab[idroite] >= pivot and idroite >= igauche:
	idroite = idroite - 1
	if idroite < igauche:
	fini= True
	else:
	temp = tab[igauche]
	tab[igauche] = tab[idroite]
	tab[idroite] = temp
	#permute(tab, igauche, idroite)
	temp = tab[imin]
	tab[imin] = tab[idroite]
	tab[idroite] = temp
	#permute(tab, imin, imax)
	return idroite


	# Si notre tableau n'est pas vide, on appelle tri_rec :
	# Sinon, le tableau vide n'est pas modifié.
	def triRecursif(tab):
	if len(tab) > 0:
	tri_rec(tab, 0, len(tab)-1)

	def tri_rec(tab, imin, imax):
	'''
	:e/s tab: tableau d'éléments
	:entrée imin: int
	:entrée imax: int
	:pré-cond: 0 ≤ imin ≤ imax < len(tab) (les indices existent dans le tableau)
	:post-cond:
	- ∀ i ∈ [0;imin[ U ]imax;len(tab)[, tabₛ[i] = tabₑ[i]
	(tab n'est pas modifié en dehors de la plage [imin;imax])
	- ∀ i ∈ [imin;imax], ∃ j ∈ [imin;imax], tabₛ[j] = tabₑ[i]
	(les éléments de tab ont simplent changé d'ordre entre imin et imax)
	- ∀ i ∈ [imin;imax[, tabₛ[i+1] ≥ tabₛ[i]
	(tab est trié entre imin et imax)
	'''
	if imin < imax:
	# partition the list
	pivot = partitionne(tab, imin, imax)
	# sort both halves
	tri_rec(tab, imin, pivot-1)
	tri_rec(tab, pivot+1, imax)
	return tab

	# Tri bulle
	def triBulle(tab):
	'''
	:entree/sortie: tab un tableau d'éléments
	:post-condition : tab est trié
	'''
	swap = True
	while swap == True:
	swap = False
	for j in range(0,len(tab)-1):
	if tab[j]>tab[j+1]:
	swap = True
	temp=tab[j]
	tab[j]=tab[j+1]
	tab[j+1]=temp




	nvalues = [10, 100, 500, 1000]
	timesSelection = []
	timesInsertion = []
	timesBulle = []
	timesRecursif = []

	for i in nvalues:
	random.seed()
	p = 12**2 # Ordre de grandeur des valeurs
	liste = []

	for x in range(i): liste.append(random.randint(0, p))

	tableau = list(liste)
	a=time.process_time()
	triSelection(tableau)
	if x <= 10:
	print(tableau)
	b=time.process_time()
	timesSelection.append(b-a)

	tableau = list(liste)
	a=time.process_time()
	triInsertion(tableau)
	if x <= 10:
	print(tableau)
	b=time.process_time()
	timesInsertion.append(b-a)

	tableau = list(liste)
	a=time.process_time()
	triRecursif(tableau)
	if x <= 10:
	print(tableau)
	b=time.process_time()
	timesRecursif.append(b-a)

	tableau = list(liste)
	a=time.process_time()
	triBulle(tableau)
	if x <= 10:
	print(tableau)
	b=time.process_time()
	timesBulle.append(b-a)

	print(nvalues)

	print(timesSelection)
	print(timesInsertion)
	print(timesRecursif)
	print(timesBulle)


	#xs = range(0,1000)
	plt.plot(nvalues,timesSelection, "r-", label="Tri par sélection")
	plt.plot(nvalues,timesInsertion, "g-", label="Tri par insertion")
	plt.plot(nvalues,timesRecursif, "b-", label="Tri par récursif")
	plt.plot(nvalues,timesBulle, "g--", label="Tri bulles")

	#plt.plot(nvalues,timesRecursif, "b-", label="Quick sort")
	#plt.plot(xs, sqrt(xs), "r-", label=" √n")
	plt.title("Comparaison des performances des différents algorithmes de tri")



	plt.savefig('analyse-tri.png')

	# Outil pour tester les algos de tri à la main
	tableauATrier = [42,1,6,0,8,9,2,4,7,3,19,34,23,67,45,23,105,18,190,20]
	triBulle(tableauATrier)
	print(tableauATrier)

TD01/code/tri-bulle.py

deleted100644 → 0

+0 −12

Original line number	Original line	Diff line number	Diff line
	def tri_bulle_iteratif(lst):
	""" Tri par bulle """
	taille = len(lst)
	for i in range(taille-1) :
	for j in range(i+1, taille) :
	if lst[i] > lst[j] :
	lst[i] , lst[j] = lst[j] , lst[i] # permutaion
	return lst

	liste=[1,3,13,4,7,2,9,2,18]
	print(tri_bulle_iteratif(liste))
	# [1, 2, 2, 3, 4, 7, 9, 13, 18]
	No newline at end of file

TD01/code/tri-comparaison.py

deleted100644 → 0

+0 −1

Original line number	Original line	Diff line number	Diff line
	# TODO: comparaison de différents tris
	No newline at end of file

TD01/code/tri-fusion.py

deleted100644 → 0

+0 −62

Original line number	Original line	Diff line number	Diff line
	from random import seed, randint, shuffle

	def tri_split_merge(L) :
	""" TRI SPLIT-MERGE avec 2 fonctions imbriquées """
	def my_split(L) :
	choix=True # on met dans L1, sinon dans L2
	L1=[]; L2=[] ; N =len(L)
	i=0
	while i < N :
	crt=L[i]
	if choix : L1.append(crt)
	else : L2.append(crt)
	i +=1
	# voyons si on a une séquence Descendante
	while i < N and L[i] >= crt :
	crt=L[i]
	if choix : L1.append(crt)
	else : L2.append(crt)
	i +=1

	choix = not choix

	return(L1,L2)

	#---------------------
	def my_merge(L1,L2) :
	N1=len(L1)
	N2=len(L2)
	L=[]; i,j=0,0
	while(i < N1 and j < N2) :
	if L1[i] <= L2[j] :
	L.append(L1[i])
	i+=1
	else :
	L.append(L2[j])
	j+=1
	L.extend(L1[i:]) # Ajouter le reste de L1 (s'il y en a) à L
	L.extend(L2[j:]) # Ajouter le reste de L2 (s'il y en a) à L
	return L

	# Fonction tri_split_merge
	while True :
	(L1,L2) = my_split(L)
	if (L2==[]) : break # Fini
	L=my_merge(L1,L2)
	return L

	# programme principal -----------------------------------------------
	seed() # initialise le generateur de nombres aleatoires
	N=10
	L = [randint(2, N*4) for i in range(N)] # construction de la liste
	print("Avant le tri, liste = {}".format(L))
	L=tri_split_merge(L)
	print("Après le tri, liste = {}".format(L))

	""" Deux Traces
	Avant le tri, liste = [9, 17, 12, 24, 36, 26, 35, 25, 5, 31]
	Après le tri, liste = [5, 9, 12, 17, 24, 25, 26, 31, 35, 36]

	Avant le tri, liste = [30, 14, 2, 11, 5, 15, 5, 21, 29, 31]
	Après le tri, liste = [2, 5, 5, 11, 14, 15, 21, 29, 30, 31]
	"""
	No newline at end of file

TD01/code/tri-insertion.py

deleted100644 → 0

+0 −34

Original line number	Original line	Diff line number	Diff line
	from random import seed, randint


	def tri_insertion_iter(T) :
	def inserer_a_sa_place_iter(ind) : # insere le Ieme dans T[0:i]
	save = T[ind]
	i=ind
	while (i>0 and T[i-1] > save) :
	T[i]=T[i-1]
	i -= 1
	T[i]=save

	if len(T) < 2 : return
	for i in range(1,len(T)) :
	inserer_a_sa_place_iter(i) # insere le Ieme dans T[0:i]

	# ------- Prog Princ
	seed() # initialise le generateur de nombres aleatoires
	N=10
	T = [randint(2, 3*N) for i in range(N)] # construction de la liste
	print("Avant le tri, liste = {}".format(T))
	TT=[] # Avant d'utiliser TT, il faut la faire exister !
	TT[:]=T[:]
	tri_insertion_iter(T)
	TT.sort()
	if (T == TT) :
	print("Après le tri, liste = {}".format(T))
	else :
	print("ERREUR !!, T={}, TT={}".format(T,TT))

	""" TRACE :
	Avant le tri, liste = [14, 11, 24, 24, 27, 14, 30, 22, 22, 17]
	Après le tri, liste = [11, 14, 14, 17, 22, 22, 24, 24, 27, 30]
	"""
	No newline at end of file

TD01/code/tri-rapide.py

deleted100644 → 0

+0 −17

Original line number	Original line	Diff line number	Diff line
	def quicksort(t):
	if t == []:
	return []
	else:
	pivot = t[0]
	t1 = []
	t2 = []
	for x in t[1:]:
	print(x, pivot)
	if x < pivot:
	t1.append(x)
	else:
	t2.append(x)
	return quicksort(t1) + [pivot] + quicksort(t2)

	if __name__=="__main__":
	quicksort([1 ,4, 5])
	No newline at end of file

TD01/code/tri-selection.py

deleted100644 → 0

+0 −16

Original line number	Original line	Diff line number	Diff line
	def selectionSort(alist):

	for l in range(len(alist )-1,0,-1):
	positionOfMax =0

	for location in range (1, l+1):
	if alist[location]>alist[ positionOfMax ]:
	positionOfMax = location

	temp = alist[l]
	alist[l] = alist[positionOfMax]
	alist[positionOfMax] = temp

	alist = [54 ,26 ,93 ,17 ,77 ,31 ,44 ,55 ,20]
	selectionSort(alist)
	print(alist)
	No newline at end of file

TD01/code/tri-stabilite.py

deleted100644 → 0

+0 −17

Original line number	Original line	Diff line number	Diff line
	def algo(words):
	t = []
	for word in words:
	t.append((len(word), word))

	t.sort(key=lambda t: t[1][-1])

	res = []
	for l, w in t:
	res.append(w)

	res = filter(lambda t: 'a' in t, res)

	return list(res)

	if __name__=="__main__":
	print(algo(["Pierre", "Jean", "Marie", "Eric", "Nathalie", "Yvonne"]))
	No newline at end of file

TD01/code/util-commentaires.py

deleted100644 → 0

+0 −15

Original line number	Original line	Diff line number	Diff line
	# Un commentaire court commence par un # et se limite à la fin de la ligne

	"""
	On peut aussi créer un commentaire long = une zone de
	commentaires sur plusieurs lignes placées
	entre une paire de triple-guillements dont le second suit :
	"""

	# Remarques :
	# Un ';' à la fin d'une ligne rend la ligne muette (pas d'affichage des résultats).
	# Il permet également de placer plusieurs expressions sur la même ligne.

	# Si vous placez un commentaire immédiatement après la signature d'une fonction}
	# (ou une méthode, une classe, etc.) entre un couple de """,
	# votre commentaire (appelé docstring) devient accessible avec help
	No newline at end of file

TD01/code/util-format.py

deleted100644 → 0

+0 −87

Original line number	Original line	Diff line number	Diff line
	from math import pi

	s = "Python"
	s.center(10) # centrer sur 10 positions
	print(s)
	# Donne -->' Python '

	s.center(10,"") # centrer sur 10 positions en complétant par des ''
	# Donne -->'Python'
	print(s)

	s = "Training"
	s.ljust(12) # justifier à gauche sur 12 positions}
	# Donne -->'Training '
	print(s)

	s.ljust(12,":")
	# Donne -->'Training::::'

	s = "Programming"
	s.rjust(15)
	# Donne -->' Programming'
	s.rjust(15, "~")
	# Donne -->'~~~~Programming'

	account_number = "43447879"
	account_number.zfill(12)
	# Donne -->'000043447879'

	# Même chose avec rjust :
	account_number.rjust(12,"0")
	# Donne -->'000043447879'

	s = 'Hello, world.'
	str(s)
	# Donne -->'Hello, world.'

	repr(s)
	# Donne --> "'Hello, world.'"
	str(1/7)
	# Donne --> '0.14285714285714285'

	r=2
	print("La surface pour un rayon {rayon:3d} sera {surface:8.3f}".format(surface=rrpi, rayon=r))
	# Donne --> 'La surface pour un rayon 2 sera 12.566'

	x = 10 * 3.25
	y = 200 * 200
	s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
	print(s)
	# Donne --> The value of x is 32.5, and y is 40000...

	# Le repr() d'un string ajoute des quotes et backslashes:
	hello = 'hello, world\n'
	str(hello)
	# Donne --> 'hello world\n'
	repr(hello)
	# Donne --> 'hello, world\\n' %* {\color{magenta} noter le double slash} *)

	# L'argument d'appel de repr() peut être n'importe quel objet Python :
	repr((x, y, ('spam', 'eggs')))
	# Donne -->"(32.5, 40000, ('spam', 'eggs'))"

	for x in range(1, 11):
	print(repr(x).rjust(2), repr(xx).rjust(3), repr(xx*x).rjust(4))
	# Donne -->
	# 1 1 1
	# 2 4 8
	# 3 9 27
	# 4 16 64
	# 5 25 125
	# 6 36 216
	# 7 49 343
	# 8 64 512
	# 9 81 729
	# 10 100 1000

	for x in range(1, 6):
	print(repr(x).rjust(2), end='#'x+'\n') # on ajoute x fois \# + \textbackslash n à la fin de chaque ligne} )

	# Donne -->
	# 1#
	# 2##
	# 3###
	# 4####
	# 5#####
	#
	No newline at end of file

TD01/code/util-types-conversion.py

deleted100644 → 0

+0 −141

Original line number	Original line	Diff line number	Diff line
	# 8 Conversion de types

	list1 = ['1', '2', '3']
	str1 = ''.join(list1)

	str1
	# '123'

	list1 = [1, 2, 3]
	str1 = ''.join(str(e) for e in list1) # ou avec "" à la place de ''

	str1
	# '123'


	a = "545.2222"
	float(a)
	# 545.2222 suivant le système, on peut avoir des '0' après les '2'

	int(float(a))
	# 545

	def is_float(value):
	try:
	float(value)
	return True
	except:
	return False

	# On peut aussi utiliser la prédéfinie eval() qui évalue du code Python
	eval("1.5")
	# 1.5

	# Une alternative plus sûre à eval()
	import ast
	ast.literal_eval("545.2222")
	545.2222

	ast.literal_eval("31")
	31

	# Des cas d'erreur
	eval(toto) # toto non défini ou n'est pas un str/octes/code
	ast.literal_eval(toto)
	# Erreur dans les 2 cas


	# Converstion en binaire
	st = "hello Debase"
	' '.join(format(ord(x), 'b') for x in st)
	# '1101000 1100101 1101100 1101100 1101111 100000 1000100 1100101 1100010 1100001 1110011 1100101'

	# Conversion de string en hexadécimal
	s='Hello Debase of Ecl'
	' '.join(format(ord(x), 'x') for x in s)
	# '48 65 6c 6c 6f 20 44 65 62 61 73 65 20 6f 66 20 45 63 6c'

	# Conversion entier en Unicode
	chr(16) # Quelle est la forme hexa de 16 ?
	#'\x10'

	# Conversions décimal <==> base xx

	int('12',8) # Quelle est la valeur décimale du nombre octal '12' (octal car base = 8)
	# 10

	int('12',16) # Quelle est la valeur décimale du nombre hexa '12' (hexa car base = 16)
	# 18

	int('12') # Quelle est la valeur décimale du nombre décimale '12' (décimal car base par défaut = 10)
	# 12

	int('1000',2) # Que donne le nombre binaire '1000' en décimal (binaire car base = 2)
	# 8

	# Pour convertir un entier en octal

	oct(12)
	# '0o14' #un 'O' au début (pour Octal)

	oct(8)
	# '0o10'

	# Autres conversions

	# octal
	eval('0o010') == 10 # La valeur décimale de '0o010' est-elle 10
	# False

	eval('0o010')
	# 8

	oct(42) # La valeur octale de l'entier 42
	# '0o52'

	int('0o52', 0) # La valeur décimale de l'octale '0o52' (si base=0 alors base est dans le string)
	# 42

	int('1101', 2) # La valeur décimale du binaire '1101' (base explicite = 2)
	#13

	int('0b1101', 2) # Idem, base explicitée = 2, peut importe '0b'
	#13

	int('0b1101', 0) # La valeur décimale du binaire '0b1101' (base = 0 --> la base '0b' est dans le string)
	#13

	from struct import *

	pack('hhl', 1, 2, 3)
	# b'\x01\x00\x02\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00'
	# b veut dire byte (2 octes). \x veut dire hexa

	pack('b', 1)
	# b'\x01'

	pack('b', 16) # signed char de taille 1. On convertie 16 en signed char
	# b'\x10'

	In [39]: pack('B', 16) # unsigned char de taille 1
	# b'\x10'

	pack('h', 1)
	# b'\x01\x00'

	calcsize('h')
	# 2

	calcsize('b')
	# 1

	unpack('b', b'\x10')
	# (16,)

	type(unpack('b', b'\x10'))
	# tuple

	unpack('b', b'\x10')[0] # Première élé. Il y a virgule car taille tuple >= 2
	# 16

	pack('B',65) # donne b'A' = i.e. le caractère dont le code = 65
	No newline at end of file

TD01/code/util-types.py

deleted100644 → 0

+0 −39

Original line number	Original line	Diff line number	Diff line
	# 7 Types principaux en Python

	if type(1) is not int : print('oups')

	if type('1') is not int : print(1)

	type(3.14)
	# float

	type(None)
	# NoneType

	f = lambda c : c if type(c) is str and c.isalpha() else '?'
	type(f)
	# function

	# Utilisation de f (voir plus loin les "lambda expressions") :
	f('a') # donne 'a' car 'a' est alphabétique
	f('1') # donne '?' car '1' n'est pas alphabétique
	f(1) # donne '?' car 1 n'est pas une chaine

	import sys;

	print(sys.int_info)
	# sys.int_info(bits_per_digit=30, sizeof_digit=4)

	print(sys.float_info)
	# sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308,
	# min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15,
	# mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

	print(sys.getsizeof(float)) # La taille de la classe float
	# 400
	print(sys.getsizeof(float())) # La taille d'un float
	# 24 # Ce que coute en octes un réel
	# (valeur + infos supplémentaires)

TD01/code/util-version-python.py

deleted100644 → 0

+0 −9

Original line number	Original line	Diff line number	Diff line
	# Vous devez valider ce code qui affiche le numéro de version
	# Rien d'autre à faire !
	import sys

	if not sys.version_info.major == 3 and sys.version_info.minor >= 7:
	print("Python 3.7 ou supérieur est nécessaire !")
	else:
	print("Vous utilisez {}.{}.".format(sys.version_info.major, sys.version_info.minor))
	sys.exit(1)
	No newline at end of file

TD01/code/zip-codes-romain.py

deleted100644 → 0

+0 −14

Original line number	Original line	Diff line number	Diff line
	code = zip([1000,900 ,500,400 ,100,90 ,50 ,40 ,10 ,9 ,5 ,4 ,1], ["M" ,"CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"])

	# fonctions
	def zipConversionRomain(num):
	res = []
	for d, r in code:
	while num >= d:
	res.append(r)
	num -= d
	return ''.join(res)

	# programme principal -----------------------------------------------
	for i in range(1, 15):
	print(i, zipConversionRomain(i))
	No newline at end of file

TD01/td1.pdf

deleted100644 → 0

−4.34 MiB

File deleted.

View file

TD02/INF-TC1-td02.ipynb

0 → 100644

+1362 −0

File added.

Preview size limit exceeded, changes collapsed.

TD02/code/load.py

deleted100644 → 0

+0 −12

Original line number	Original line	Diff line number	Diff line
	data = []

	with open("etudiants.txt") as f:
	keys = None
	for line in f:
	l = [w.strip() for w in line.split(';')]
	if keys is None:
	keys = l
	else:
	data.append(l)

	print(data)
	No newline at end of file

TD02/code/test_analyse.py

deleted100644 → 0

+0 −28

Original line number	Original line	Diff line number	Diff line
	#%%
	import time
	import random
	import matplotlib.pyplot as plt
	import numpy as np
	#%matplotlib inline

	nvalues = [100, 500, 1000, 1500, 2000, 2500, 3000]
	timesEtudiants1 = []

	for i in nvalues:

	random.seed()
	p = 12**2 # Ordre de grandeur des valeurs
	liste = []

	for x in range(i): liste.append(random.randint(0, p))

	a=time.perf_counter()
	e1 = []
	for n in liste:
	e1.append(n)
	b=time.perf_counter()
	timesEtudiants1.append(b-a)

	plt.plot(nvalues,timesEtudiants1, "r-", label="Etudiants 1")
	plt.title("Comparaison des performances")
	# %%

TD02/code/test_file.py

deleted100644 → 0

+0 −23

Original line number	Original line	Diff line number	Diff line
	from File import *

	if __name__=="__main__":

	data = []

	with open("etudiants.txt") as f:
	keys = None
	for line in f:
	l = [w.strip() for w in line.split(';')]
	if keys is None:
	keys = l
	else:
	data.append({k:v for k, v in zip(keys, l)})

	file = File()

	for d in data:
	file.ajoute(d)

	e = file.renvoie(lambda x : x['filiere'] == "PC")

	print(e['nom'] + " " + e['prenom'])
	No newline at end of file

TD02/code/test_heap.py

deleted100644 → 0

+0 −9

Original line number	Original line	Diff line number	Diff line
	import heapq
	tas = []

	for i in range(5): heapq.heappush(tas, i)

	while not len(tas) == 0:
	print(heapq.heappop(tas), end=" ")

	# 0 1 2 3 4
	No newline at end of file

TD02/code/test_lifoqueue.py

deleted100644 → 0

+0 −9

Original line number	Original line	Diff line number	Diff line
	import queue
	pile = queue.LifoQueue()

	for i in range(5): pile.put(i)

	while not pile.empty():
	print(pile.get(), end=" ")

	# 4 3 2 1 0
	No newline at end of file

TD02/code/test_pile.py

deleted100644 → 0

+0 −21

Original line number	Original line	Diff line number	Diff line
	from Pile import *

	if __name__=="__main__":

	data = []

	with open("etudiants.txt") as f:
	keys = None
	for line in f:
	l = [w.strip() for w in line.split(';')]
	if keys is None:
	keys = l
	else:
	data.append({k:v for k, v in zip(keys, l)})

	p = Pile()
	for d in data:
	p.ajoute(d)

	e = p.supprime()
	assert(e['nom'] == "Arthaud" and e['prenom'] == "Nathalie")
	No newline at end of file

TD02/code/test_tas.py

deleted100644 → 0

+0 −26

Original line number	Original line	Diff line number	Diff line
	from Tas import *

	if __name__=="__main__":

	data = []

	with open("etudiants.txt") as f:
	keys = None
	for line in f:
	l = [w.strip() for w in line.split(';')]
	if keys is None:
	keys = l
	else:
	data.append({k:v for k, v in zip(keys, l)})

	tas = Tas()

	for d in data:
	tas.ajoute(int(d['moyenne']))

	r = tas.get_racine()
	fg, fg_i = tas.get_fils_gauche(0)
	ffg, ffg_i = tas.get_fils_droit(0)

	assert(r == 19 and fg == 14 and ffg == 16)

	No newline at end of file

TD02/code/etudiants-large100.txt→TD02/etudiants-large100.txt

+0 −0

File moved.

TD02/code/etudiants.txt→TD02/etudiants.txt

+6 −0

Original line number	Original line	Diff line number	Diff line
	nom;prenom;filiere;moyenne;absences		nom;prenom;filiere;note;absences
	Dupond;Pierre;MP;19;0		Dupond;Pierre;MP;19;7
			Dupont;Jeanne;MP;19;5
	Clavier;Christian;PSI;14;1		Clavier;Christian;PSI;14;1
	Gilles;Eric;PC;16;3		Gilles;Eric;PC;16;3
	Arthaud;Nathalie;MP;15;0		Arthaud;Nathalie;MP;15;0
			No newline at end of file

TD02/td2.pdf

deleted100644 → 0

−246 KiB

File deleted.

View file

TD03/INF-TC1-td03.ipynb

0 → 100644

+896 −0

File added.

Preview size limit exceeded, changes collapsed.

TD03/Image10.bmp

deleted100644 → 0

−192 KiB

192.05 KiB

TD03/Image8.bmp

deleted100644 → 0

−2.84 MiB

2.84 MiB

TD03/code/viz.py

deleted100644 → 0

+0 −14

Original line number	Original line	Diff line number	Diff line
	from graphviz import Digraph

	name = 'arbre-viz-profondeur'

	g = Digraph('G', filename = name + '.gv', format='png') # par defaut format='pdf'

	g.edge('chien', 'petit')
	g.edge('chien', 'et')
	g.edge('petit', 'le')
	g.edge('et', 'jaune')
	g.edge('et', 'noir')

	# génere et affiche le graphe name.gv.png
	g.view()
	No newline at end of file

TD03/ecl.jpg

deleted100644 → 0

−103 KiB

102.55 KiB

TD03/td3-modalite-rendu.pdf

deleted100644 → 0

−66.4 KiB

File deleted.

View file

TD03/td3.pdf

deleted100644 → 0

−2.18 MiB

File deleted.

View file

TD04/INF-TC1-td04.ipynb

0 → 100644

+1025 −0

File added.

Preview size limit exceeded, changes collapsed.

TD04/code/load.py

deleted100644 → 0

+0 −14

Original line number	Original line	Diff line number	Diff line
	labyrinthe = [[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]

	def affiche_labyrinthe(l):
	print('\n'.join([''.join(['{:4}'.format(item) for item in row])
	for row in l]))
	No newline at end of file

TD04/code/priorite.py

deleted100644 → 0

+0 −18

Original line number	Original line	Diff line number	Diff line
	from queue import PriorityQueue

	# initialisation de la file
	file_prio = PriorityQueue()

	# remplissage
	file_prio.put((2, "Bob"))
	file_prio.put((1, "Alice"))
	file_prio.put((6, "Nat"))

	# permet d'accéder au premier élément de la file
	# (sans le supprimer)
	print(file_prio.queue[0])

	# tant que non vide, affiche par ordre de priorité
	# (mais supprimer chaque élément accédé)
	while not file_prio.empty():
	print(file_prio.get()[1])

TD03/lyon.png→TD04/lyon.png

100644 → 100755

(1.05 MiB)

File moved.File mode changed from 100644 to 100755.

View file

TD04/td4-correction.pdf

deleted100644 → 0

−138 KiB

File deleted.

View file

TD04/td4.pdf

deleted100644 → 0

−111 KiB

File deleted.

View file

TD05/INF-TC1-td05.ipynb

0 → 100644

+160 −0

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

			NAME:

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

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

			%% Cell type:markdown id:1bb26026-8560-4a3c-90e6-2cfd7a49320a 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 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:

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

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

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

			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)

			- 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 détail des étapes que vous avez suivies

			- La description de parties de code difficiles

			- Tout souci ou point bloquant dans votre code

			- Les graphiques et diagrammes nécessaires

			- Des analyses et discussions en lien avec votre approche

			- Des exemples simples mais aussi difficiles

			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


			Un groupe avec une note entre 10 et 12 :

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

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

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

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

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

			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
			- Une démarche expérimentale très détaillée sur les optimisations
			- Code et tests



			</details>

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

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

			1. utiliser moins de couleurs que le nombre disponible dans l'image donnée;
			2. être la plus représentative possible des couleurs de l'image donnée.

			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.

			<div style="text-align:center;">
			<table>
			<tr>
			<td>
			<img src="figures/color-rainbow.png" alt="Image originale" style="height:5cm;">
			<p>Image donnée</p>
			</td>
			<td>
			<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>
			</td>
			<td>
			<img src="figures/rainbow-recoloriee.png" alt="Image originale recoloriée avec la palette" style="height:5cm;">
			<p>Image donnée recoloriée avec la palette</p>
			</td>
			</tr>
			</table>
			</div>

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

			## Étapes de travail

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

			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. 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;">
			<table>
			<tr>
			<td>
			<img src="figures/1-color-back.png" alt="1 couleur noir" style="width:3cm;">
			<p>1 couleur noir</p>
			</td>
			<td>
			<img src="figures/4-color.png" alt="4 couleurs" style="width:3cm;">
			<p>4 couleurs</p>
			</td>
			</tr>
			</table>
			</div>

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

			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.

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


			### Bonus

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

Source

Target

Files

Some changes are not shown.