Quentin Madec Frédéric Hémery Aurélien Marion Marius Lombard-Platet

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

Objectif : valider le CF Epreuve d’une heure et demi à complexité croissante Rappelez-vous bien que vous avez droit aux documents Retrouvez sur : ClarolineClaroline Cours Slides Mais aussi sur people.via.ecp.fr/~modulo/algo/people.via.ecp.fr/~modulo/algo/ Cours (2010) Exemples et bouts de codes Annales Documentation

Préparation et organisation Pas de secret : faire des exos L’épreuve est courte Faire proprement les premières questions Réfléchir au plus simple Indentation Commentaire au besoin Tester sur cas simples Gratter les points Se relire contre les étourderies

À ne pas faire fibonacci = lambda x:map(lambda o:(map(lambda c:map(lambda l: o.__setslice__(l[0],l[1],l[2]),([o[2]+3,o[2]+4,[o[0]]],[0,3,[o[1], reduce(lambda x,o:x+o,o[:2]),o[2]+1]])),range(x)),o)[1],[[1,1,0]+ range(x)])[0][3:] fibonacci(n) renvoie le n ième nombre de Fibonacci (est valable sous python 2.7) Choisir des noms de variable explicites Code aéré : ne pas hésiter à sauter des lignes Commenter les endroits que vous jugez compliqués

Algorithmique vs Programmation Différence entre algorithme (concept) et programmation (langage) Notre langage : le Python Simple et haut niveau Répandu et utilisé (Google, Yahoo!, Cern, NASA, Youtube, … ) Ca peut toujours resservir… Préférer le Python au Pseudo code.

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

Notions de base On va voir : Les nombres Expression logique L’instruction if Fonctions Boucles Dans Python : On ne déclare pas les variables L’indentation définit les blocs Sauter une ligne change d’instruction

Les nombres A = 10 B = A# B vaut 10 C = A + B + 4# C vaut 24 D = 5*C# D vaut /3# **2# 16 Print(A)# affiche 10 Print(D – 20)# affiche 100

Les commandes de base Sur les entiers: +, -, * donnent addition, soustraction, multiplication / donne une division mais qui arrive dans les réels // donne une division entière % signifie modulo ** signifie puissance Sur les décimaux: Même chose sauf que // donne la partie entière

Les expressions logiques Expression qui retourne un booléen (True/False) Egalité(1+1) == 11# False Différence42 != 15# True Inégalité5 < 5# False 5 <= 5# True EtTrue and False# False OuTrue or False# True Négationnot(True)# False En cas de doute, ajouter des parenthèses : (1+1) == 11 and 5 <= 5 or not(True) !?

L’instruction if Si… Alors… {Sinon Si… Alors…} Sinon… If cond1: inst1# Exécuté si cond1 inst2# est vrai elif conf2: inst3# Exécuté si cond1 est faux inst4# et cond2 est vrai else: inst5# Exécuté dans les autres cas #Sortie du if Indentation et deux points (:) très importants

Les boucles (1/2) : la boucle for Pour i allant de x à y faire… For i in range (x,y): instructions (avec la valeur de i) Si on veut i de 0 à n inclus: for i in range (n+1): instructions Exemple: def remplissage (L) : L=[] for i in range (0,5) : L=[-i]+L+[i] return L Le résultat est: [-4,-3,-2,-1,0,0,1,2,3,4]

Les boucles (2/2) : la boucle while Tant que… Faire… While condition: instructions Attention aux boucles infinies : la condition doit devenir fausse Exemples

Les fonctions Def nom_fonction (param1, param2, …): bloc instruction {return solution} Nombre de paramètre quelconque Si on utilise un return, la fonction s’utilise comme une variable Voir les exemples

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

Les listes Définition : variable contenant un nombre fini d’éléments numérotés Syntaxe : 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 … ABCD 2013

Concaténation de deux listes 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 ABCD 2013 EFGHI ABCD 2013 EFGHI =

Extraction d’une tranche Syntaxe : liste[i:j] pour récupérer les éléments de i à j-1 Exemple : pour enlever un élément : liste = liste[0:len(liste)-1] del liste[ -1 ] ABCD 2013 EF 45 CD 23 E 4 liste liste[2:5]

Test de sous-liste (CF 2009) Est-ce que liste2 est une sous-liste de liste1 ? Eléments contigus Dans le même ordre ABCD 2013 EF 45 liste1 G 6 CDE 201 liste2 ADG 201 DC 01 ouinon

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 ABCD 2013 EF 45 G 6 ABCD 2013 Complexité :O(n) BCDE 2013 CDEF 2013 DEFG 2013 à comparer avec la sous-liste cherchée

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 else: return pgcd(b, a%b) Quantité décroissante : a%b Cas de base : a%b == 0

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

Les files ● Liste FIFO (First In First Out, i.e. file d’attente)

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

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

Algorithmes classiques Tri bulle Tri par insertion Tri rapide

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

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

Tri par insertion Idée : on fait reculer chaque élément jusqu’à ce qu’il trouve sa place. Exemple :

Tri rapide Algorithme récursif : s’appelle lui-même sur de plus petites listes Idées : On sait trier une liste de 2 éléments On coupe la liste de départ en deux morceaux auxquels on applique le tri rapide … jusqu’à ce que les morceaux fassent 2 éléments Ensuite on combine

Tri rapide Exemple : < 4 > < 3> < 7> Y’a plus qu’à recoller les morceaux C’est trié !

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

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 60 "France" 46 "Espagne" 10 "Belgique" dico = {"France": 60, "Espagne": 46, "Belgique": 10}

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 …) dico.keys() renvoie un tableau des clés dico.values() renvoie un tableau des éléments

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 !

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

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

Définitions (suite) Chemin Clés Degré = nombre de fils

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 »).

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

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’])

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

Arbre binaire de recherche Principe : un arbre ordonné ! Tout ce qui est dans le fils gauche <= racine <= tout ce qui est dans le fils droit. Les sous-arbres gauche et droit sont des arbres binaires de recherche

Arbre binaire de recherche Exemple

Arbre binaire de recherche Avantage : recherche plus rapide ! Lors d’une recherche, on ne parcourt qu’un seul chemin -> complexité en O(h) où h est la hauteur. Si l’arbre est équilibré, on a h = log(n) donc une recherche en O(log(n)), contre O(n) pour une liste.

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

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

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.

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

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

Graphes Définition : Un graphe G est un couple (E,A) : E est un ensemble de sommets. A est un ensemble d’arêtes

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

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

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 corrigé PC 9)

Exemple de fonctions sur les graphes Parcours en largeur en partant de

Exemple de fonctions sur les graphes Visited = [] File = [5]

Exemple de fonctions sur les graphes Visited = [5] File = [4]

Exemple de fonctions sur les graphes Visited = [5, 4] File = [2, 9]

Exemple de fonctions sur les graphes Visited = [5, 4, 2] File = [9, 1]

Exemple de fonctions sur les graphes Visited = [5, 4, 2, 9] File = [1, 3]

Exemple de fonctions sur les graphes Visited = [5, 4, 2, 9, 1] File = [3]

Exemple de fonctions sur les graphes Visited = [5, 4, 2, 9, 1, 3] File = [7]

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

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