Bac à sable Chaînes et listes Fonctions Numpy Piles Récursivité Tris

Révisions algorithmique


Sauvegardes

Il est impératif de sauvegarder régulièrement le code en le collant dans un fichier texte (Notepad++) ou dans l'éditeur de pyzo.

Rappels - Boucles - Fonctions

  1. Ecrire un script qui calcule la somme des carrés des entiers de 1 à 1 million.
  2. Ecrire un script qui renvoie le premier entier n tel que \(\sum\limits_{i = 1}^n {i^2 \ge 10^6} \).
  3. Ecrire une fonction somme2(n) qui renvoie la somme des carrés des entiers de 1 à n.



1. Une variable nommée somme est nécessaire pour stocker le résultat du calcul. Cette variable est initialisée à 0 puis on ajoute les carrés des entiers de 1 à n à l'aide d'une boucle for.


2. Dans cette question, on ne sait pas à l'avance pour quel entier la boucle s'arrête, une boucle while s'impose donc. Une variable i (qui joue le même rôle que dans le script précédent) doit être initalisée puis incrémentée par la boucle while (ces deux étapes sont inutiles avec la boucle for).


Il s'agit ici d'encapsuler le code de la question 1 dans une fonction.



A) Algorithmes de recherche

A.1 - Recherche d'un élément

Ecrire une fonction recherche(x, L) dont les paramètres sont un élément x et une liste L (supposée non vide). Cette fonction doit retourner un booléen (suivant que x est dans la liste ou non).
Tester cette fonction avec des listes variées (contennant des nombres et des chaînes... x étant en première position, en position quelconque ou en dernière position.)


Pour rechercher « à la main » un élément dans une liste, il faut nécessairement parcourir la liste (toute la liste dans le cas où l'élément cherché n'est pas dans la liste) ⇒ boucle.
Un test dans la boucle permet de sortir (instruction return) dès que l'élément cherché est trouvé.
La seule subtilité concerne le cas où l'élément n'est pas dans la liste : en aucun cas l'instruction return False ne doit se trouver dans la boucle (sous peine de sortir avant d'avoir parcouru la totalité de la liste), cette instruction doit donc être placée juste après la boucle (cf. indentation du code ci-dessous).




A.2 - Recherche du plus grand élément d'une liste de nombres

Ecrire une fonction plusGrand(L) dont le paramètre est une liste L. Cette fonction doit retourner la plus grande valeur de L (supposée constituée uniquement de nombres).
Tester cette fonction avec des listes variées (vide, contennant des nombres et des chaînes... x étant en première position, en position quelconque ou en dernière position.)


La recherche du plus grand élément de la liste nécessite de parcourir entièrement la liste ⇒ boucle for.
Il est nécessaire de mémoriser (stocker dans une variable) la valeur maxi (qui évolue au fur et à mesure du parcours de la liste) : il faut donc initialiser une variable (nommée maxi dans le code) avant la boucle et mettre à jour cette variable au cours de la boucle.
Pour initialiser la variable "maxi", on peut choisr n'importe quelle valeur de la liste, la première par exemple.
L'algorithme retourne la variable "maxi" à la fin de la boucle.




B) Histogramme et tri (d'après concours)

B.1 - Histogramme d'un tableau d'entiers

Nous travaillons ici avec des listes qui ne contiennent que des chiffres (de 0 à 9).
Écrire la fonction hist(L) qui retourne un histogramme (sous la forme d’une liste) des chiffres présents dans la liste L.
Rappel : l’histogramme H est une liste telle que H[i] est le nombre d’occurrences (apparitions) de la valeur i dans la liste L.
Exemple : l'histogramme H de la liste L = [1,5,9,3,0,1,2,0,1,0,2,5,0,5,2,0] est [5, 3, 3, 1, 0, 3, 0, 0, 0, 1] car dans la liste L on trouve :

  • 5 fois la valeur 0
  • 3 fois la valeur 1
  • 3 fois la valeur 2
  • ...

Histogramme

On représente un histogramme par un diagramme bâtons :
- abscisses = valeurs possibles
- ordonnées = nombre d’occurrences de chaque valeur


La liste L est composée de n nombres tous compris entre 0 et 9 (soit 10 valeurs possibles), l'histogramme H qui donne le nombre d'apparitions de ces 10 valeurs est donc une liste indexée de 0 à 9 : H[0] contient le nombre d'occurrences de la valeur "0" dans la liste L, etc...
Autrement dit, dès que la valeur "0" est rencontrée dans la liste L, il faut incrémenter H[0] de 1 : H[0] += 1.
L'algorithme doit donc initialiser une liste H de 10 valeurs (nulles au cas où une valeur n'est jamais rencontrée dans la liste L : si la valeur "7" n'existe pas dans L, il est nécessaire d'avoir initialisé L[7] à 0).
La liste L est ensuite parcourue entièrement (boucle for), valeur par valeur en modifiant H au fur et à mesure : H[valeur] += 1.

L'histogramme est un outil utilisé pour le traitement numérique des images par exemple (les couleurs étant codées par des entiers, cela permet de savoir si l'image est « équilibrée » ou non du point de vue des couleurs ou du contraste).




B.2 - Application au tri d'un tableau d'entiers

Utiliser la fonction hist pour écrire la fonction tri(L) qui trie la liste L en ordre croissant (la fonction construit une nouvelle liste qui doit être retournée).


Rappel : l'instruction [3]*5 crée la liste [3, 3, 3, 3, 3].

L'histogramme permet de savoir combien de fois une valeur (associée à l'index de la liste) apparaît dans la liste : par exemple, la valeur 4 apparaît H[4] fois.
Il est donc facile de reconstituer la liste : on crée une liste vide puis on lui ajoute, grâce à une boucle de compteur i, les listes de la forme [i]*H[i].




C) Entiers et listes (d'après concours)

C.1 - Entiers → liste

Écrire la fonction int_to_list(n,p) qui convertit le nombre n (entier naturel à au plus p chiffres) en une liste de ses chiffres éventuellement complétés par des 0 pour atteindre p chiffres.
Exemples :
int_to_list(27972,5) renvoie [2, 7, 9, 7, 2]
int_to_list(42,5) renvoie [2, 4, 0, 0, 0]


Cet algorithme repose sur la compréhension de l'écriture d'un nombre n en base 10 : chaque chiffre est le reste des divisions Euclidiennes successives de n par 10.




C.2 - Liste → entiers

Écrire la fonction list_to_ints(L) qui, à partir de la liste L non vide ne contenant que des chiffres (de 0 à 9), retourne le couple (left,right), avec :
- left le nombre construit avec les chiffres de L lus de gauche à droite,
- right le nombre construit avec les chiffres de L lus de droite à gauche.
Exemples :
list_to_ints([1,2,3,4,5,6]) renvoie (123456, 654321)
list_to_ints([2,4,0,0,0,]) renvoie (24000, 42)


La liste [1,2,3,4,5,6] permet de contruire le nombre 123456 en calculant 1*10**5 + 2 10**4 + 3*10**3 + 4*10**2 + 5*10**1 + 6*10**0 (la puissance 5 de départ corresnpond à len(L)-1).
Le principe est le même pour l'écriture de droite à gauche : au lieu d'utiliser les puissances décroissantes de 5 à 0, on utilise les puissances croissantes.