Ampli de rattrapage Algo / P rog

1. Ampli de rattrapageAlgo/ Prog Benjamin Fernandes lothar@via.ecp.fr Léo Cavailléchiron@via.ecp.fr Gautier Minstergautier.minster@student.ecp.fr Louis Guthmannlouis.guthmann@student.ecp.fr

2. Plan du rattrapage • Introduction et conseils • Commandes et notions de base • Les listes • Les piles • Le tri • Les dictionnaires • Les fichiers • Les arbres

3. Objectif : valider le CF • Epreuve d’une heure et demi à complexité croissante • Rappeler vous bien que vous avez droit aux documents • Retrouvez sur : people.via.ecp.fr/~lothar/algo/ • Cours • Slides • Mais aussi sur Claroline • Cours • Exemples et bouts de codes • Annales • Documentation

4. 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 • Ne pas perdre son temps sur le PC • Se relire contre les étourderies

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

6. Coder simplement : IDLE • Indentation automatique • Coloration syntaxique • Vérification du code • Erreurs détaillées • Exécution • Partir d’un fichier code.py • Ctrl + S pour sauvegarder • F5 pour exécuter

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

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

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

10. Les fonctions • Defnom_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

11. Les expressions logiques • Expression qui retourne un booléen (True/False) • Egalité (1+1) == 11 # False • Différence 42 != 15 # True • Inégalité 5 < 5 # False 5 <= 5 # True • Et and # False • Ou or # True • Négation not(True) # False • En cas de doute, ajouter des parenthèses • Attention: dans un return retournant des nombres, ne pas utiliser and mais « , » . And ne s’applique que pour les Booléens.

12. L’instruction if • Si… Alors… {Sinon Si… Alors…} Sinon… • If cond1: inst1 # Exécuté si cond1 inst2 # est vraielif conf2: inst3 # Exécuté si cond1 est faux inst4 # et cond2 est vraielse: inst5 # Exécuté dans les autres cas#Sortie du if • Indentation très importante

13. 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] Le résultat est: [-4,-3,-2,-1,0,0,1,2,3,4]

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

15. Les listes 0 1 2 3 • Définition : variable contenant unnombre fini d’éléments numérotés • Syntaxe : [a, b, c] (puis affecter à une variable) • 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 … A B C D

16. Concaténation de deux listes 0 1 2 3 0 1 2 3 4 + A B C D E F G H I • 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 0 1 2 3 4 5 6 7 8 = A B C D E F G H I

17. Extraction d’une tranche 0 1 2 3 4 5 2 3 4 • 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] A B C D E F C D E liste liste[2:5]

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

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

20. Récursivité • Fonction qui s'appelleelle-même, et pour laquelleunecertainequantitédécroît (strictement). Pour unevaleurminimale, la fonctionrenvoieunevaleur, c'est le cas de base. • Exemple 1: • def fact(n): • if (n==1): • 1 • else: • 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

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

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

24. Algorithmes classiques • Tri bulle • Tri par insertion • Tri rapide

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

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

27. Tri par insertion • Idée : on fait reculer chaque élément jusqu’à ce qu’il trouve sa place. • Exemple : • Solution itérative (avec un compteur du nombre d’éléments déjà triés) 4 7 10 23 15 19 30 4 7 10 15 23 19 30 4 4 7 7 10 10 15 15 19 19 23 23 30 30

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

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

30. 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}

31. Caractéristiques • Eléments pas ordonnés • Un seul élément par clé • 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

32. Et sinon ? • C’est tout pour les dictionnaires • En fait c’est facile …

33. Les fichiers De l'utilité des fichiers La manipulation des fichiers est très importante car elle permet de gérer un grand nombre de données, soit pour les utilisées en entrée (ex : une page web por l'afficher) soit pour enregistrer le résultat d'un programme Il est donc primordial d'écrire et de lire des fichiers

34. Qu'est-ce qu'un fichier ? Modules (Rappel : import module) pour les répertoires et les fichiers, ce sont des file en python os os.path os.stat fileinput gzip zipfile

35. Ouverture-lecture- fermeture Première approche Le fichier est dans le répertoire courant et se nomme test.txt #On ouvre le fichier test.txt f=open(''test.txt'') #on lit les 4 premiers caractères avec read qui renvoie une chaîne de caractère f.read(4) #on lit les 4 caractères suivant et on les met dans x x=f.read(4) print x #on ferme le fichier qui n'est donc plus accessible f.close()

36. Manipulation de fichier L'ouverture se fait à l'aide de open([nom[,mode]]) mais mode est optionnel nom = nom sur le disque Modes 'r' en lecture (par défaut) 'r+' en lecture et écriture 'a' en ajout (écriture en fin du fichier) 'w' en écriture (écrase) 'w+' en lecture et écriture (écrase) La fermeture se fait avec close()

37. Lecture d'un fichier On suppose que l'on a ouvert un fichier f (f = open(nom)) Lecture f.read() : lit le fichier f et le renvoie sous forme de string f.read(n) : lit n caractères de f à partir de la position courante f.readline() : lit une ligne du fichier f et renvoie un string f.readlines() : lit plusieurs lignes et renvoie une liste de string Écriture f.write(texte) : ecrit la texte (de type string) dans f f.writelines(seq) : ecrit la séquence de chaine dans f Autre f.tell() : retourne la position courante f.seek(npos) : change la position courante en npos

38. Les arbres Définitions Racine Arrête Nœud Hauteur Feuille

39. Définitions (suite) 3 Clés Degré = nombre de fils Chemin 8 5 2 6 4 1

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

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

42. 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: defnombre_noeud(arbre): if arbre == {}: return 0; else: return 1 + nombre_noeud (arbre[’g’]) + nombre_noeud (arbre[‘d’]);

43. 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. • Lors d’une recherche, on ne parcours 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)).

44. Ex : recherche dans un arbre binaire • 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’]);

45. Pour les courageux : le parcours en largeur • Manipule à la fois les arbres et les piles !

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

47. def largeurFile2(a): file = [a] liste = [] whilelen(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

48. Graphes de contrôle La formalisation logique permet de retracer l’ensemble des chemins possibles d’un algorithme et d’expliciter tous ces chemins. * est l’opérateur représentant un while

49. Exemple For i in range(n): #a x=i #b if x=3: #c x=5 #d z=i+2 #e Donne en logique des graphes: (ab(cd+e))puissance n

50. Logique de Hoare