110 lines
3.0 KiB
Python
Executable File
110 lines
3.0 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
def creerTableau(n):
|
|
return [0]*n
|
|
|
|
#Premiere partie
|
|
#1.
|
|
|
|
def creerTabVide(n):
|
|
T=creerTableau(n+1)
|
|
for i in range(n+1):
|
|
T[i]=0
|
|
return T
|
|
#2.
|
|
def estDansTab(tab, x):
|
|
for el in tab[1:tab[0]+1]:
|
|
if el==x:
|
|
return True
|
|
return False
|
|
"""
|
|
Dans le pire cas, c'est à dire le cas ou l'élément recherché
|
|
n'est pas dans le tableau, la boucle parcourera la totalité de la liste
|
|
et effectuera un test. Or il y a n éléments dans la liste, donc
|
|
le test sera effectué n fois. Par conséquent, la complexité de la
|
|
fonction est O(n)
|
|
"""
|
|
|
|
#3.
|
|
def ajouteDansTab(tab, x):
|
|
if not estDansTab(tab, x):
|
|
tab[tab[0] + 1] = x
|
|
tab[0]+=1
|
|
"""
|
|
Si la liste tab est pleine et que x n'est pas encore dans la liste initiale
|
|
, la procédure renvoira une erreur car l'index maximal sera dépassé.
|
|
|
|
Dans tous les cas, le tableau ne contiendra pas x.
|
|
La procedure appellera d'abord estDansTab puis executera deux instructions.
|
|
par conséquent, la complexité sera celle de estDansTab.
|
|
La procédure a une complexité O(n)
|
|
"""
|
|
|
|
#Deuxième partie
|
|
|
|
#1.
|
|
plan1=[ [5, 7],
|
|
[2, 2, 3, 0, 0],
|
|
[3, 1, 3, 5, 0],
|
|
[4, 1, 2, 4, 5],
|
|
[2, 3, 5, 0, 0],
|
|
[3, 2, 3, 4, 0] ]
|
|
plan2=[ [5, 4],
|
|
[1, 2, 0, 0, 0],
|
|
[3, 1, 3, 4, 0],
|
|
[1, 2, 0, 0, 0],
|
|
[2, 2, 5, 0, 0],
|
|
[1, 4, 0, 0, 0]]
|
|
#2.
|
|
def creerPlanSansRoute(n):
|
|
return [[n,0]]+[creerTabVide(n-1) for _ in range(n)]
|
|
|
|
#3.
|
|
def estVoisine(plan, x, y):
|
|
return estDansTab(plan[x], y)
|
|
|
|
#4.
|
|
def ajouteRoute(plan, x, y):
|
|
plan[0][1] += 1
|
|
ajouteDansTab(plan[x], y)
|
|
ajouteDansTab(plan[y], x)
|
|
"""
|
|
Il y a n villes dans le plan. donc chaque ville peut avoir, au plus
|
|
n-1 voisines. Les tableaux représentant les voisines de chaque ville
|
|
peuvent contenir au plus n-1 élément. Il n'y aura donc pas de dépassement."""
|
|
|
|
#5.
|
|
|
|
def afficheToutesLesRoutes(plan):
|
|
routes=[None]
|
|
for i in range(1,plan[0][0] + 1):
|
|
for voisine in plan[i][1:plan[i][0] + 1]:
|
|
for route in routes:
|
|
if route == {i, voisine}:
|
|
break
|
|
if route is None:
|
|
routes.insert(0, {i, voisine})
|
|
|
|
print("["+", ".join([str(tuple(route)).replace(", ", " - ") for route in routes[:-1][::-1]])+"]")
|
|
"""
|
|
Dans le pire des cas, la fonction effectura :
|
|
n fois la suite d'opération qui consiste à effectuer:
|
|
n-1 fois la suite d'operation qui consiste à
|
|
boucler parmi les routes déjà trouvées.
|
|
ainsi, dans le pire des cas, la procédure aura une complexité
|
|
O(n(n-1)m = O (mn² - mn)' = O(mn²)
|
|
|
|
"""
|
|
plan3=creerPlanSansRoute(11)
|
|
ajouteRoutes = lambda plan, x : [ajouteRoute(plan, *route) for route in x]
|
|
ajouteRoutes(plan3, [(1,6),(1,2),(2,7),(6,7),(6,5),(5,10),(10,11),(11,9),(9,8),(8,7),(8,3),(3,4),(8,4)])
|
|
|
|
#Troisième partie
|
|
|
|
#Préliminaire
|
|
import random
|
|
def entierAleatoire(k):
|
|
return random.randint(1,k)
|
|
#1.
|
|
|
|
def coloriageAleatoire(plan, couleur, k, s, t):
|