Amphi de rattrapage Algo / Prog

Présentation au sujet: "Amphi de rattrapage Algo / Prog"— Transcription de la présentation:

1 Amphi de rattrapage Algo / Prog
Jérémy Marin Arthur Patora Tom Brendlé

2 Plan du rattrapage Introduction et conseils
Commandes et notions de base Les listes Les piles et les files Les tris Les dictionnaires Les arbres Les graphes

3 Objectif : valider le CF
Epreuve de 3h à exercices indépendants Pas de documents et ordinateur (sauf formulaire types abstraits fourni pendant le CF) Retrouvez sur : Claroline Cours Slides Mais aussi sur people.via.ecp.fr/~modulo/algo/ Cours (2010) Exemples et bouts de codes Annales Documentation

4 Préparation et organisation
Pas de secret : faire des exos L’épreuve est courte (3h) et tardive Lire le CF en entier Faire proprement les premières questions Réfléchir avant d’écrire Indentation Commentaire au besoin Tester sur les cas simples (n=0, n=1) Gratter les points Se relire contre les étourderies

5 À ne pas faire À faire Choisir des noms de variable explicites :
def _check_call_py24(cmd): if not res == 0: print(“The world is big”) else: raise Error(msg) def _check_call_py24(cmd): if not res == 0: print(“The world is big”) else: raise Error(msg) Choisir des noms de variable explicites : resFonctRec = résultat de la fonction récursive res_Fonct_Rec Code aéré : sauter des lignes Commenter les endroits que vous jugez compliqués écrire d’une autre couleur et # commentaire # Calcul le terme de la suite

6 Algorithmique vs Programmation
Différence entre algorithme (concept) et programmation (langage) Notre langage : le Python Simple et haut niveau Répandu et utilisé Ca peut toujours resservir… (projet enjeu) Préférer le Python au Pseudo code : Si a > 0 alors afficher(« positif ») Sinon afficher(« negatif »)

7 Plan du rattrapage Introduction et conseils
Commandes et notions de base Les listes Les piles et les files Les tris Les dictionnaires Les arbres Les graphes

8 Notions de base On va voir : Dans Python : Les nombres
Expression logique L’instruction if Fonctions Boucles Exceptions Dans Python : Pas de déclaration => affectation directe a = 12 L’indentation définit les blocs Sauter une ligne change d’instruction

9 L’indentation définit les blocs

10 Les nombres A = 2 B = A # B vaut 2 C = A + B + 1 # C vaut 5
D = 5*C # D vaut 25 10/3 # 2**3 # 8 print(A) # affiche 2 print(D – 20) # affiche 5

11 Les commandes de base Sur les nombres :
+, -, * : addition, soustraction, multiplication ** : exposant (puissance) / : division mais qui arrive dans les réels // : division entière % : reste de la division euclidienne

12 Les expressions logiques (1/2)
Expression qui retourne un booléen (True/False) Attention : Majuscules !! Egalité 1==2 # False Différence 3 != 4 # True Inégalité 5 < 5 # False 5 <= 5 # True

13 Les expressions logiques (2/2)
Et True and False # False Ou True or False # True Négation not(True) # False En cas de doute, ajouter des parenthèses : 1==2 and 5 <= 5 or not(True) ((1==2) and (5 <= 5)) or not(True)

14 L’instruction if Pseudo-code (P-C) :
Si… Alors… {Sinon Si… Alors…} Sinon… if condition1: instruction1 # Exécuté si condition1est vrai instruction2 elif condition2: instruction # Exécuté si condition1 est faux instruction4 # et condition2 est vrai else: instruction # Exécuté dans les autres cas #Sortie du if Indentation et deux points (:) très importants

15 Les boucles (1/2) : la boucle for
P-C : Pour i allant de x à y Faire instruction(avec la valeur de i) Python : for i in range (x,y): instructions (avec la valeur de i) Pas besoin de gérer i (il augmente tout seul !)

16 Explication fonction range()
range(x,y) => [x,y[ range(x) => [0,x[ Exemple : for i in range (n+1): print(i) => Affiche : … (n-1) n

17 Les boucles (2/2) : la boucle while
P-C : Tant que condition Faire instruction Python : while condition: instructions Attention aux boucles infinies : vérifier que la condition doit devenir fausse Exemple (avec un compteur) n = # Initialisation while n <= 10: n = n+1 Préférez la boucle for à while quand vous pouvez !

18 Instruction break A éviter !
Permet de sortir de la plus petite structure de boucle Exemple : for j in range(n): # Boucle for i = 0 while True: # Boucle infinie ? i = i + 1 if i > 10: break # On sort de la boucle while mais pas de for

19 Les fonctions def nom_fonction (param1, param2, …): instruction1
instruction2 {return solution} (optionnel) Nombre de paramètres quelconque return solution : - stop la fonction immédiatement - la fonction s’utilise comme une variable print(nom_fonction(param1,…)) => affiche le résultat de la fonction

20 Les exceptions (1/2) : raise
Définition en haut du code (ne pas oublier !): class monException(Exception): pass Exemple d’utilisation (fonction top de pile.py) : def top(Pile) : if isEmpty(Pile): raise EmptyException else: return P[0]

21 Les exceptions (2/2) : try, except
Gérer des erreurs qui existent dejà dans python Peut servir Exemple : def division(a, b) : try: # Code qui risque de produire une erreur return (a/b) # Si b = 0 => erreur except ZeroDivisionError: # Code qui gére l’erreur (ici, on affiche un message) print(“Erreur : argument nul fourni”)

22 Plan du rattrapage Introduction et conseils
Commandes et notions de base Les listes Les piles et les files Les tris Les dictionnaires Les arbres Les graphes

23 Les listes A B C D 2 1 3 Définition : variable contenant un nombre fini d’éléments numérotés Déclaration : liste = [a, b, c] Accès à un élément : liste[i] Attention ! Numérotation à partir de 0 ! len(liste) : nombre d’éléments La taille d’une liste est fixée au moment de la création mais …

24 Concaténation de deux listes
B C D 2 1 3 E F G H I 2 1 3 4 + A B C D 2 1 3 E F G H I 6 4 5 7 8 = Syntaxe : liste3 = liste1 + liste2 Utile pour rajouter un élément en fin de liste : liste = liste + [élément] En début de liste: liste = [élément] + liste

25 Extraction d’une tranche
B C D 2 1 3 E F 4 5 2 3 4 C D E liste liste[2:5] Syntaxe : liste[i:j] pour récupérer les éléments de i à j-1 Exemple : pour enlever le dernier élément : liste = liste[0:len(liste)-1] Pour supprimer le i-ème élément : del liste[i]

26 Test de sous-liste (CF 2009)
Est-ce que liste2 est une sous-liste de liste1 ? Eléments contigus Dans le même ordre A B C D 2 1 3 E F 4 5 liste1 G 6 C D E 2 1 liste2 A D G 2 1 liste2 D C 1 liste2 non oui non

27 Test de sous-liste (CF 2009)
Idée : regarder toutes les sous-listes de liste1 qui ont la bonne longueur Exemple : la sous-liste cherchée est de longueur 4 A B C D 2 1 3 B C D E 2 1 3 A B C D 2 1 3 E F 4 5 G 6 à comparer avec la sous-liste cherchée C D E F 2 1 3 D E F G 2 1 3 Complexité : O(n)

28 Récursivité Fonction qui s'appelle elle-même, et pour laquelle une certaine quantité décroît (strictement). Pour une valeur minimale, la fonction renvoie une valeur, c'est le cas de base. Exemple 1: def fact( n ) : if n == 1 : return 1 else: return ( n * fact( n - 1 ) ) Quantité décroissante : n Cas de base : n=1 Exemple 2: def pgcd (a,b) : if b > a : return pgcd(b,a) else: if a%b == 0 : return b return pgcd(b, a%b) Quantité décroissante : a%b Cas de base : a%b == 0

29 Plan du rattrapage Introduction et conseils
Commandes et notions de base Les listes Les piles et les files Les tris Les dictionnaires Les arbres Les graphes

30

31 Les files Liste FIFO (First In First Out, i.e. file d’attente)
Caisses de supermarché

32 Plan du rattrapage Introduction et conseils
Commandes et notions de base Les listes Les piles et les files Les tris Les dictionnaires Les arbres Les graphes

33 Algorithmes de tri Entrée : liste de nombres
Sortie : les mêmes en ordre croissant Pourquoi plusieurs algorithmes de tri ? Complexités Variantes itératives ou récursives + ou – adaptés aux listes déjà triées, ou triées à l’envers (pire ou meilleur cas)

34 Algorithmes classiques
Tri bulle Tri par insertion Tri rapide

35 Tri bulle Idée : examiner des couples (« bulles »).
Solution itérative : On parcourt la liste du début à la fin (ça fait n-1 bulles) On échange les bulles qui sont à l’envers Condition d’arrêt : si en un passage on n’a rien changé.

36 Tri bulle 12 11 11 12 17 23 10 23 10 Complexité O(n²) Exemple :
Puis on recommence, jusqu’à ce que la liste soit triée. Complexité O(n²)

37 Tri par insertion Idée : on fait reculer chaque élément jusqu’à ce qu’il trouve sa place. Exemple : 4 3 7 9 5 2 8 6 1 4 3 7 9 5 2 8 6 1 4 3 7 9 5 2 8 6 1 4 3 7 9 5 2 8 6 1 4 3 7 9 5 2 8 6 1 4 3 7 9 5 2 8 6 1 9 7 5 3 4 9 7 3 4 3 4 4 7 3 4

38 Tri rapide Algorithme récursif : s’appelle lui- même sur de plus petites listes Idées : Initialisation à 2 éléments Choix du pivot : par exemple le premier élément Classement des éléments restants par rapport au pivot Tri des deux listes formées et concaténation

39 Tri rapide Exemple : 4 3 7 9 5 2 8 6 1 > 4 < 4 3 2 1 4 7 9 5 8 6 < 3 > 3 < 7 > 7 1 2 2 1 3 4 5 6 7 8 9 9 8 Y’a plus qu’à recoller les morceaux. C’est trié !

40 Plan du rattrapage Introduction et conseils
Commandes et notions de base Les listes Les piles et les files Les tris Les dictionnaires Les arbres Les graphes

41 C’est quoi un dictionnaire ?
Définition : comme une liste sauf que les éléments ne sont pas forcément repérés par des numéros Exemple : dico "France" 60 "Espagne" 46 "Belgique" 10 dico = {"France": 60, "Espagne": 46, "Belgique": 10}

42 Dictionnaires Eléments pas ordonnés
Un seul élément par clé (l’élément peut être une liste) Appel d’un élément : dico[clé] (si la clé est une chaîne de caractères on n’oublie pas les guillemets …) list(dico.keys()) : liste des clés list(dico.values()) : liste des éléments

43 Pour les plus courageux
Table de hachage : But : stocker des données variées et y accéder efficacement Fonction de hachage : prend une clé et renvoie l’indice dans la table Le dictionnaire fonctionne sur ce principe ! 

44 Plan du rattrapage Introduction et conseils
Commandes et notions de base Les listes Les piles et les files Les tris Les dictionnaires Les arbres Les graphes

45 Les arbres Définitions Racine Arête Hauteur Nœud Feuille

46 Arbres binaires Définition : arbre dont chaque nœud est de degré au plus deux. Se construit récursivement : chaque arbre est constitué d’une clé, d’un sous-arbre gauche (« fils gauche ») et d’un sous-arbre droit (« fils droit »).

47 Arbres binaires : implémentation
On les implémente avec un dictionnaire ayant trois champs : ‘rac’, ‘g’ et ‘d’. Ex: {‘rac’ = 8, ‘g’ = {‘rac’ = 2, ‘g’ = {}, ‘d’ = {} }, ‘d’ = {‘rac’ = 6, ‘g’ = {‘rac’ = 1, ‘g’ = {}, ‘d’ = {} }, ‘d’ = {} } } {‘rac’ = 2, ‘g’ = {}, ‘d’ = {} } 8 {‘rac’ = 6, ‘g’ = {‘rac’ = 1, ‘g’ = {}, ‘d’ = {} }, ‘d’ = {} } 2 6 1 {‘rac’ = 1, ‘g’ = {}, ‘d’ = {} }

48 Arbres binaires : seconde implémentation
On les implémente avec un tuple : (racine, liste de fils) Ex: (8,[(2,[ ]), (6,[(1,[ ])])]) (2,[ ]) 8 (6,[(1,[ ])]) 2 6 1 (1,[ ])

49 Quelques fonctions Il est clairement plus simple de faire des fonctions récursives pour traiter un arbre. Ex : nombre de nœuds = 1 + nombre de nœuds du fils gauche + nombre de nœuds du fils droit. En python: def nombre_noeud(arbre) : if arbre == {} : return 0 else : return 1 + nombre_noeud (arbre[’g’]) + nombre_noeud (arbre[‘d’])

50 Quelques fonctions 8 Parcours infixe : 2 6 3 1
def p_infixe(arbre) : if arbre == {} : return [] else : return (p_infixe(arbre[’g’]) + [ arbre[‘rac’] ] + p_infixe(arbre[‘d’]) ) 2 6 3 1 Résultat : [2, 8, 1, 6, 3]

51 Arbre binaire de recherche
Arbre ordonné Facilite la recherche ! Conditions : Tout nœud du fils gauche ≤ racine ≤ Tout nœud du fils droit Tout fils est un arbre binaire de recherche 5 2 6 1 4 8 3 7 9

52 Ex : recherche dans un arbre binaire de recherche
def recherche(elem, arbre) : if arbre == {} : return False else: if arbre[‘rac’] == elem : return True else: if arbre[‘rac’] < elem : return recherche(elem, arbre[‘d’]) else : return recherche(elem, arbre[‘g’]) 5 5 5<7 2 6 6 6<7 1 4 8 8 8>7 3 7 7 9 True Recherche(7,arbre)

53 Pour les courageux : le parcours en largeur
Manipule à la fois les arbres et les files !

54 Principe du parcours en largeur
Problème : on ne peut pas le faire récursivement, car il faut traiter les deux sous-arbres simultanément ! Astuce : à chaque nœud, on affiche la racine et on mémorise sous-arbres pour les traiter plus tard. Il faut traiter d’abord les premiers sous- arbres enregistrés : on utilise une file.

55 toVisit : [arbre_c, arbre_d, arbre_e] parcours: [a,b]
def largeurFile2(arbre): toVisit= [arbre] parcours = [] while len(toVisit)>0: #je prends le premier élément, je l'affiche parcours+=(racine(toVisit [0])) #j'ajoute ses fils s'il y en a, à la fin de la file if not est_vide(gauche(toVisit[0])): toVisit+= (gauche(toVisit [0])) if not est_vide(droit(toVisit [0])): toVisit+=(droit(toVisit [0])) #je défile toVisit = toVisit[1:] return parcours toVisit : [arbre_c, arbre_d, arbre_e] parcours: [a,b] toVisit : [arbre_a] parcours : [ ] toVisit : [arbre_b, arbre_c] parcours : [a]

56 Plan du rattrapage Introduction et conseils
Commandes et notions de base Les listes Les piles et les files Les tris Les dictionnaires Les arbres Les graphes

57 Graphes Définition : Un graphe G est un couple (E,A) :
E est un ensemble de sommets (ou états). A est un ensemble d’arêtes. 1 2 4 3 5 6 8 7 9

58 Graphes Vocabulaire : Chemin : séquence d’arêtes telles que l’extrémité de l’une correspond à l’origine de la suivante Cycle : chemin dont l’origine est égale à l’extrémité Boucle : cycle de longueur 1 2 5 4 9 2 4 9 3 5

59 Graphes Sous forme de dictionnaire: Implémentations possibles :
1 2 4 3 8 7 9 Implémentations possibles : Sous forme de dictionnaire: Les clés sont les étiquettes des sommets Les valeurs sont des listes de successeurs Sous forme d’un dictionnaire de deux listes : Une liste de sommets Une liste de couples qui représentent les arêtes G = { 1 : [ 3 ], 2 : [1, 4], 3 : [ 7 ], 4 : [ 2 ], 7 : [ ], 8 : [ ], 9 : [ 3, 4 ] } l_sommets = [ 8, 2, 4, 9, 3, 7, 1 ] l_aretes = [ (2, 1), (2, 4), (1, 3), (3, 7), (9, 3), (9, 4), (4, 2) ] G = { ‘vertices’ : l_sommets, ‘edges’ : l_aretes } Matrice d’adjacence : Matrice dont le coefficient (i,j) vaut 1 si l’arête i → j existe et 0 sinon

60 Exemple de fonctions sur les graphes
Parcours en largeur : On visite tous les fils d’un sommet puis on visite les fils de ces fils. Implémentation : On utilise une file pour stocker les sommets en cours de traitement et une liste pour les sommets déjà visités. (cf arbres)

61 Exemple de fonctions sur les graphes
5 Parcours en largeur en partant de 5. 6 2 4 9 3 1 8 7

62 Exemple de fonctions sur les graphes
5 Visited = [] toVisit = [5] 6 2 4 9 3 1 8 7

63 Exemple de fonctions sur les graphes
5 Visited = [5] toVisit = [4] 6 2 4 9 3 1 8 7

64 Exemple de fonctions sur les graphes
5 Visited = [5, 4] toVisit = [2, 9] 6 2 4 9 3 1 8 7

65 Exemple de fonctions sur les graphes
5 Visited = [5, 4, 2] toVisit = [9, 1] 6 2 4 9 3 1 8 7

66 Exemple de fonctions sur les graphes
5 Visited = [5, 4, 2, 9] toVisit = [1, 3] 6 2 4 9 3 1 8 7

67 Exemple de fonctions sur les graphes
5 Visited = [5, 4, 2, 9, 1] toVisit = [3] 6 2 4 9 3 1 8 7

68 Exemple de fonctions sur les graphes
5 Visited = [5, 4, 2, 9, 1, 3] toVisit = [7] 6 2 4 9 3 1 8 7

69 Exemple de fonctions sur les graphes
5 Visited = [5, 4, 2, 9, 1, 3, 7] toVisit = [] On doit recommencer avec les sommets qui n’ont pas été visités. 6 2 4 9 3 1 8 7

70 Exemple de fonctions sur les graphes
Visited = [5, 4, 2, 9, 1, 3, 7] toVisit = [] notVisited = [6,8] 5 6 Ajouter l.remove(n) 2 4 9 3 1 8 7

71 C’est fini ! Récupérez sur votre PC tous les documents
Faites quelques exos Retrouvez des documents sur : people.via.ecp.fr/~modulo/algo Les slides sont sur : people.via.ecp.fr/~htime/ Retrouvez les cours sur : cours.etudes.ecp.fr/claroline/ Bonnes révisions !