Aller au contenu

Préparation de l’épreuve pratique

Introduction

Voici des ressources utiles :

Vous trouverez ci-dessous l’ensemble des algorithmes susceptibles de tomber le jour de l’épreuve pratique en tant qu’exerice 1. Ces algorithmes, que j’ai choisis pour leur niveau de difficulté modéré, concernent le parcours de tableaux (ou de chaînes de caractères).

Dans chaque rubrique, certains exercices très simples figurent dans en premier à titre d’aide à la révision dans le but de vous préparer aux exercices suivants plus complexes.

Consignes pour s’entrainer
  1. Mettez vous dans les conditions de l’examen. Pour cela, positionner côte à côte sur l’écran de votre ordinateur :
    • à gauche cette page Web ;
    • à droite Visual Studio Code ;
  2. Sur votre ordinateur, créez vous un dossier de travail par exemple revision_epreuve_pratique et ouvrez ce dossier dans Visual Studio Code
  3. Dans ce dossier, créez un fichier de programme Python pour chaque exercice par exemple exo01.py, exo02.py etc.
  4. Commencez par essayer d’écrire la fonction sans aide.
  5. En cas de difficulté, consulter le diaporama proposé qui rappelle le principe de l’algorithme.
  6. Si nécessaire, entrainez-vous d’abord sur les codes à trous proposés. Attention, à terme, vous devrez être capable d’écrire ces fonctions sans l’aide du code à trous.
  7. Pensez à toujours tester en intégralité le jeu de test fourni.
  8. Lorsque votre fonction passe tous les tests, préparer la documentation du code en faisant des phrases complètes. Une correction avec documentation est aussi fournie.
  9. Entraînez-vous à présenter le programme à l’oral à un camarade.
La check list le jour de l’examen pour l’exercice 1.
  1. Je prends le temps de lire attentivement l’énoncé de l’exercice 1.
  2. J’étudie en particulier les exemples du jeu de test qui permettent de comprendre exactement ce que doit faire la fonction.
  3. J’écris le prototype de la fonction :
    • J’écris le mot clé def 
      def
    • Je le fais suivre du nom exact de la fonction proposé dans l’énonce. J’ouvre la parenthèse et ajoute le :. 
      def nom_fonction():
    • J’ajoute les paramètres dans le bon ordre. Pour cela, je m’appuie sur les exemples du jeu de test pour vérifier que l’odre que j’ai choisi est correct. 
      def nom_fonction(par1, par2):
      Si les noms des paramètres sont proposés dans l’énoncé, je les respecte scrupuleusement sinon je choisis des noms selon les conventions habituelles :
      • tab pour un tableau
      • val pour une valeur recherchée
      • etc.
  4. Je prépare le jeu de test. Pour cela :
    • J’ajoute le mot-clé pass provisoirement pour que la syntaxe soit correcte avant de compléter la fonction. 
      def nom_fonction(par1, par2):
    pass
    • Je saute deux lignes et écris tous les appels du jeu de test fourni dans l’énoncé. 
      def nom_fonction(par1, par2):
    pass


print(nom_fonction(5, [4, 7, 10, 5]))
print(nom_fonction(2, [4, 7, 10, 5]))
  5. Je code le corps de la fonction.
  6. J’exécute régulièrement le programme pour vérifier au fur et à mesure que la fonction passe tous les tests et qu’aucune erreur n’est déclenchée.
  7. En cas d’erreur déclenchée, j’analyse le message d’erreur pour identifier le problème.
  8. En cas d’erreur ou de test non passé, je peux copier-coller le programme de Visual Studio Code vers Thonny et utiliser le débogueur pour identifier le problème.
  9. En cas de blocage sévère je peux demander un coup de pouce à l’examinateur-ice. Un échange fructueux est valorisé et retire peu de points.
  10. Lorsque la fonction est correcte, si je juge le temps restant suffisant, je prépare les commentaires du code.
    • J’écris des phrases sans abbréviation et vérifie l’orthographe.
    • Je vais au plus court sans paraphraser inutilement le code.
  11. J’appelle l’examinateur-ice pour lui présenter le programme.
    • Je commence toujours par lire l’énoncé en sélectionant la phrase (ou les deux phrases) pertinente(s) qui indique(nt) ce que la fonction prend en paramètre et renvoie.
    • J’explique à l’aide des commentaires ce que fait la fonction.
    • Je parle distinctement en articulant correctement avec un débit modéré.

Occurrences d’une valeur

Exercice 1. Présence d’une valeur

Écrire un fonction presence qui prend en paramètre une valeur numérique val et un tableau de nombres tab. Cette fonction renvoie True si la valeur est présente dans le tableau et False sinon.

Exemple :

>>> presence(8, [4, 5, 8, 2])
True
>>> presence(3, [4, 5, 8, 2])
False
>>> presence(3, [2])
False
>>> presence(3, [3])
True
>>> presence(3, [])
False
Aides
Codes à trous 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def presence(val, tab):
    for ...:
        if ...:
            return ...
    return ...


print(presence(8, [4, 5, 8, 2]))
print(presence(3, [4, 5, 8, 2]))
print(presence(3, [2]))
print(presence(3, [3]))
print(presence(3, []))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def presence(val, tab):
    for elt in tab:
        if ...:
            return True
    return ...


print(presence(8, [4, 5, 8, 2]))
print(presence(3, [4, 5, 8, 2]))
print(presence(3, [2]))
print(presence(3, [3]))
print(presence(3, []))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def presence(val, tab):
    for elt in tab:
        if elt == ...:
            return True
    return ...


print(presence(8, [4, 5, 8, 2]))
print(presence(3, [4, 5, 8, 2]))
print(presence(3, [2]))
print(presence(3, [3]))
print(presence(3, []))
Correction 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def presence(val, tab):
    for elt in tab:
        if elt == val:
            return True
    return False


print(presence(8, [4, 5, 8, 2]))
print(presence(3, [4, 5, 8, 2]))
print(presence(3, [2]))
print(presence(3, [3]))
print(presence(3, []))

La fonction presence prend en paramètre une valeur numérique val et un tableau de nombres tab. Cette fonction renvoie True si la valeur est présente dans le tableau et False sinon.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
def presence(val, tab):
    # On parcourt le tableau.
    for elt in tab:
        # Dès que l'élément courant est égal à la valeur recherchée,
        if elt == val:
            # on renvoie True ce qui met fin au parcours.
            return True
    # Si tout le tableau a été parcouru sans renvoi, cela signifie
    # que la valeur recherchée n'a pas été trouvée. On renvoie donc
    # False.
    return False


print(presence(8, [4, 5, 8, 2]))
print(presence(3, [4, 5, 8, 2]))
print(presence(3, [2]))
print(presence(3, [3]))
print(presence(3, []))
Exercice 2. Nombre d’occurrences d’une valeur

Écrire une fonction nbre_occurrences qui prend en paramètre une valeur numérique val et un tableau de nombres tab. Cette fonction renvoie le nombre d’occurrences de val dans tab.

Exemple :

>>> nbre_occurrences(2, [5, 9, 3, 5, 7, 5])
0
>>> nbre_occurrences(5, [5, 9, 3, 5, 7, 5])
3
>>> nbre_occurrences(5, [5])
1
>>> nbre_occurrences(5, [])
0
Aides
Codes à trous 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def nbre_occurrences(val, tab):
    ...
    for ...:
        if ...:
            ...
    return ...


print(nbre_occurrences(2, [5, 9, 3, 5, 7, 5]))
print(nbre_occurrences(5, [5, 9, 3, 5, 7, 5]))
print(nbre_occurrences(5, [5]))
print(nbre_occurrences(5, []))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def nbre_occurrences(val, tab):
    cpt = ...
    for elt in tab:
        if ...:
            ...
    return cpt


print(nbre_occurrences(2, [5, 9, 3, 5, 7, 5]))
print(nbre_occurrences(5, [5, 9, 3, 5, 7, 5]))
print(nbre_occurrences(5, [5]))
print(nbre_occurrences(5, []))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def nbre_occurrences(val, tab):
    cpt = ...
    for elt in tab:
        if elt == ...:
            cpt += ...
    return cpt


print(nbre_occurrences(2, [5, 9, 3, 5, 7, 5]))
print(nbre_occurrences(5, [5, 9, 3, 5, 7, 5]))
print(nbre_occurrences(5, [5]))
print(nbre_occurrences(5, []))
Correction 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def nbre_occurrences(val, tab):
    cpt = 0
    for elt in tab:
        if elt == val:
            cpt += 1 #(1)!
    return cpt


print(nbre_occurrences(2, [5, 9, 3, 5, 7, 5]))
print(nbre_occurrences(5, [5, 9, 3, 5, 7, 5]))
print(nbre_occurrences(5, [5]))
print(nbre_occurrences(5, []))
  1. 🙋‍♀️ Cette instruction d’incrémentation est équivalente à cpt = cpt + 1

La fonction nbre_occurrences prend en paramètre une valeur numérique val et un tableau de nombres tab. Cette fonction renvoie le nombre d’occurrences de val dans tab.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
def nbre_occurrences(val, tab):
    # On initialise à zéro une variable compteur.
    cpt = 0
    # On parcourt le tableau.
    for elt in tab:
        # Si l'élélement courant est égal à la valeur recherchée,
        if elt == val:
            # on incrémente la variable compteur.
            cpt += 1 #(1)!
    # En fin de parcours, la variable compteur contient le nombre
    # d'occurrences de la valeur recherchée.
    return cpt


print(nbre_occurrences(2, [5, 9, 3, 5, 7, 5]))
print(nbre_occurrences(5, [5, 9, 3, 5, 7, 5]))
print(nbre_occurrences(5, [5]))
print(nbre_occurrences(5, []))
  1. 🙋‍♀️ Cette instruction d’incrémentation est équivalente à cpt = cpt + 1
Exercice 3. Indice de la première occurrence

Écrire un fonction premiere_occurrence qui prend en paramètre une valeur numérique val et un tableau de nombres tab. Cette fonction renvoie l’indice de la première occurrence de val dans tab si val est présente dans tab. Sinon renvoie None.

Exemple :

>>> premiere_occurrence(2, [7, 9, 5, 1, 2, 2, 8, 2, 7])
4
>>> premiere_occurrence(6, [7, 9, 5, 1, 2, 2, 8, 2, 7]) # renvoie None
>>> premiere_occurrence(6, [7]) # renvoie None
>>> premiere_occurrence(6, [6])
0
>>> premiere_occurrence(6, []) # renvoie None
Aides
Codes à trous 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def premiere_occurrence(val, tab):
    for i in ...:
        if ...:
            ...
    ...


print(premiere_occurrence(2, [7, 9, 5, 1, 2, 2, 8, 2, 7]))
print(premiere_occurrence(6, [7, 9, 5, 1, 2, 2, 8, 2, 7]))
print(premiere_occurrence(6, [7]))
print(premiere_occurrence(6, [6]))
print(premiere_occurrence(6, []))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def premiere_occurrence(val, tab):
    for i in range(...):
        if ... == ...:
            return ...
    return ...


print(premiere_occurrence(2, [7, 9, 5, 1, 2, 2, 8, 2, 7]))
print(premiere_occurrence(6, [7, 9, 5, 1, 2, 2, 8, 2, 7]))
print(premiere_occurrence(6, [7]))
print(premiere_occurrence(6, [6]))
print(premiere_occurrence(6, []))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def premiere_occurrence(val, tab):
    for i in range(len(tab)):
        if tab[i] == ...:
            return ...
    return None


print(premiere_occurrence(2, [7, 9, 5, 1, 2, 2, 8, 2, 7]))
print(premiere_occurrence(6, [7, 9, 5, 1, 2, 2, 8, 2, 7]))
print(premiere_occurrence(6, [7]))
print(premiere_occurrence(6, [6]))
print(premiere_occurrence(6, []))
Correction 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def premiere_occurrence(val, tab):
    for i in range(len(tab)):
        if tab[i] == val:
            return i
    return None


print(premiere_occurrence(2, [7, 9, 5, 1, 2, 2, 8, 2, 7]))
print(premiere_occurrence(6, [7, 9, 5, 1, 2, 2, 8, 2, 7]))
print(premiere_occurrence(6, [7]))
print(premiere_occurrence(6, [6]))
print(premiere_occurrence(6, []))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
def premiere_occurrence(val, tab):
    # On parcourt le tableau.
    for i in range(len(tab)):
        # Dès que l'élément courant est égal à la valeur recherchée,
        if tab[i] == val:
            # On renvoie l'indice courant qui correspond donc à
            # l'indice de la première occurrence de la valeur
            # recherchée ce qui met fin au parcours.
            return i
    # Si tout le tableau a été parcouru sans renvoi, cela signifie
    # que la valeur recherchée n'a pas été trouvée. On renvoie donc
    # None.
    return None


print(premiere_occurrence(2, [7, 9, 5, 1, 2, 2, 8, 2, 7]))
print(premiere_occurrence(6, [7, 9, 5, 1, 2, 2, 8, 2, 7]))
print(premiere_occurrence(6, [7]))
print(premiere_occurrence(6, [6]))
print(premiere_occurrence(6, []))
Exercice 4. Indice de la dernière occurrence

Écrire une fonction derniere_occurrence qui prend en paramètre une valeur numérique val et un tableau de nombres tab. Cette fonction renvoie l’indice de la dernière occurrence de val dans tab si val est présente dans tab. Sinon renvoie None.

Exemple :

>>> derniere_occurrence(2, [7, 9, 5, 1, 2, 2, 8, 2, 9])
7
>>> derniere_occurrence(6, [7, 9, 5, 1, 2, 2, 8, 2, 9]) # renvoie None
>>> derniere_occurrence(6, [7]) # renvoie None
>>> derniere_occurrence(6, [6])
0
>>> derniere_occurrence(6, []) # renvoie None
Aides
Codes à trous 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def derniere_occurrence(val, tab):
    ...
    for i in ...:
        if ...:
            ...
    return res


print(derniere_occurrence(2, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(derniere_occurrence(6, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(derniere_occurrence(6, [7]))
print(derniere_occurrence(6, [6]))
print(derniere_occurrence(6, []))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def derniere_occurrence(val, tab):
    ...
    for i in range(...):
        if ... == ...:
            res = ...
    return res


print(derniere_occurrence(2, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(derniere_occurrence(6, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(derniere_occurrence(6, [7]))
print(derniere_occurrence(6, [6]))
print(derniere_occurrence(6, []))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def derniere_occurrence(val, tab):
    res = ...
    for i in range(len(tab)):
        if tab[i] == ...:
            res = ...
    return res


print(derniere_occurrence(2, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(derniere_occurrence(6, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(derniere_occurrence(6, [7]))
print(derniere_occurrence(6, [6]))
print(derniere_occurrence(6, []))
Correction 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def derniere_occurrence(val, tab):
    res = None
    for i in range(len(tab)):
        if tab[i] == val:
            res = i
    return res


print(derniere_occurrence(2, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(derniere_occurrence(6, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(derniere_occurrence(6, [7]))
print(derniere_occurrence(6, [6]))
print(derniere_occurrence(6, []))

La fonction derniere_occurrence prend en paramètre une valeur numérique val et un tableau de nombres tab. Cette fonction renvoie l’indice de la dernière occurrence de val dans tab si val est présente dans tab. Sinon renvoie None.

Il faut parcourir tout le tableau pour être sûr de reprérer la dernière occurrence. Il faut donc utiliser un algorithme en temps constant.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def derniere_occurrence(val, tab):
    # On initialise une variable résultat à None. Ainsi, en fin
    # de parcours, si la valeur recherchée n'a pas été trouvée
    # None sera renvoyée. 
    res = None
    # On parcourt le tableau.
    for i in range(len(tab)):
        # Si l'élément courant est égal à la valeur recherchée,
        if tab[i] == val:
            # La variable résultat prend comme valeur le rang
            # courant.
            res = i
    # En fin de parcours, il y a deux possibilités :
    #    - la valeur recherchée n'a pas été trouvée et res a
    #      conservé sa valeur initiale de None ;
    #    - la valeur recherchée a été trouvée au moins une fois
    #      et res contient l'indice de la dernière occurrence.
    return res


print(derniere_occurrence(2, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(derniere_occurrence(6, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(derniere_occurrence(6, [7]))
print(derniere_occurrence(6, [6]))
print(derniere_occurrence(6, []))
Exercice 5. Liste des indices des occurrences

Écrire une fonction indices_occurrences qui prend en paramètre une valeur numérique val et un tableau de nombres tab. Cette fonction renvoie dans un tableau la liste des indices des occurrences de val dans tab.

Exemple :

>>> indices_occurrences(2, [7, 9, 5, 1, 2, 2, 8, 2, 9])
[4, 5, 7]
>>> indices_occurrences(6, [7, 9, 5, 1, 2, 2, 8, 2, 9])
[]
>>> indices_occurrences(6, [7])
[]
>>> indices_occurrences(6, [6])
[0]
>>> indices_occurrences(6, [])
[]
Aides
Codes à trous 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def indices_occurrences(val, tab):
    ...
    for i in :
        if ...:
            ...
    return res


print(indices_occurrences(2, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(indices_occurrences(6, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(indices_occurrences(6, [7]))
print(indices_occurrences(6, [6]))
print(indices_occurrences(6, []))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def indices_occurrences(val, tab):
    res = ...
    for i in range(...):
        if ... == ...:
            res.append(...)
    return res


print(indices_occurrences(2, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(indices_occurrences(6, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(indices_occurrences(6, [7]))
print(indices_occurrences(6, [6]))
print(indices_occurrences(6, []))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def indices_occurrences(val, tab):
    res = ...
    for i in range(len(tab)):
        if tab[i] == ...:
            res.append(...)
    return res


print(indices_occurrences(2, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(indices_occurrences(6, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(indices_occurrences(6, [7]))
print(indices_occurrences(6, [6]))
print(indices_occurrences(6, []))
Correction 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def indices_occurrences(val, tab):
    res = []
    for i in range(len(tab)):
        if tab[i] == val:
            res.append(i)
    return res


print(indices_occurrences(2, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(indices_occurrences(6, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(indices_occurrences(6, [7]))
print(indices_occurrences(6, [6]))
print(indices_occurrences(6, []))

La fonction indices_occurrences prend en paramètre une valeur numérique val et un tableau de nombres tab. Cette fonction renvoie dans un tableau la liste des indices des occurrences de val dans tab.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
def indices_occurrences(val, tab):
    # On initalise le tableau résultat en tant que tableau vide.
    res = []
    # On parcourt le tableau.
    for i in range(len(tab)):
        # Si l'élément courant est égal à la valeur recherchée,
        if tab[i] == val:
            # on ajoute le rang courant au tableau résultat.
            res.append(i)
    return res


print(indices_occurrences(2, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(indices_occurrences(6, [7, 9, 5, 1, 2, 2, 8, 2, 9]))
print(indices_occurrences(6, [7]))
print(indices_occurrences(6, [6]))
print(indices_occurrences(6, []))

Minimum et maximum

Dans cette partie, on choisit comme exemple de traiter le cas du maximum. Des notes sur les programmes indiquent ce qu’il faudrait modifier pour traiter le cas du minimum.

Exercice 6. Valeur du maximum

Écrire une fonction maximum qui renvoie la valeur maximum d’un tableau non-vide (1) contenant des nombres positifs et/ou négatifs.

  1. 🙋‍♀️ Le fait que la mention non-vide apparaisse dans l’énoncé indique que le cas du tableau vide n’a pas à être pris en charge par la fonction maximum.

Exemple.

>>> maximum([4, 7, 3, 11, 12, 23, 5, 2, 16])
23
>>> maximum([-4, -7, -3, -11, -12, -23, -5, -2, -16])
- 2
>>> maximum([-4, -7, -3, -11, -12, 23, 5, 2, 16])
23
>>> maximum([4])
4
>>> maximum([-4])
-4
Aides
Codes à trous 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def maximum(tab):
    ...
    for elt in ...:
        if ...:
            ...
    return maxi


print(maximum([4, 7, 3, 11, 12, 23, 5, 2, 16]))
print(maximum([-4, -7, -3, -11, -12, -23, -5, -2, -16]))
print(maximum([-4, -7, -3, -11, -12, 23, 5, 2, 16]))
print(maximum([4]))
print(maximum([-4]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def maximum(tab):
    maxi = ...
    for elt in ...:
        if ... > ...:
            maxi = ...
    return maxi


print(maximum([4, 7, 3, 11, 12, 23, 5, 2, 16]))
print(maximum([-4, -7, -3, -11, -12, -23, -5, -2, -16]))
print(maximum([-4, -7, -3, -11, -12, 23, 5, 2, 16]))
print(maximum([4]))
print(maximum([-4]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def maximum(tab):
    maxi = tab[...]
    for elt in tab:
        if elt > ...:
            maxi = ...
    return maxi


print(maximum([4, 7, 3, 11, 12, 23, 5, 2, 16]))
print(maximum([-4, -7, -3, -11, -12, -23, -5, -2, -16]))
print(maximum([-4, -7, -3, -11, -12, 23, 5, 2, 16]))
print(maximum([4]))
print(maximum([-4]))
Correction 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def maximum(tab):
    maxi = tab[0]
    for elt in tab:
        if elt > maxi: #(1)!
            maxi = elt
    return maxi


print(maximum([4, 7, 3, 11, 12, 23, 5, 2, 16]))
print(maximum([-4, -7, -3, -11, -12, -23, -5, -2, -16]))
print(maximum([-4, -7, -3, -11, -12, 23, 5, 2, 16]))
print(maximum([4]))
print(maximum([-4]))
  1. 🙋‍♂️ Pour trouver le minimum, il suffirait de remplacer maxi par mini et de remplacer if elt > maxi: par if elt < mini:.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def maximum(tab):
    # On choisit comme maximum provisoire le premier élément du
    # tableau. Choisir à la place la valeur 0 serait une erreur car
    # cela ne prendrait pas en charge le cas où le tableau ne
    # contient que des nombres strictement négatifs.
    maxi = tab[0]
    # On parcourt le tableau.
    for elt in tab:
        # Si l'élément courant est strictement plus grand que le
        # maximum rencontré jusqu'à présent,
        if elt > maxi: #(1)!
            # On met à jour le maximum.
            maxi = elt
    # En fin de parcours, le dernier maximum provisoire est le
    # maximum du tableau.
    return maxi


print(maximum([4, 7, 3, 11, 12, 23, 5, 2, 16]))
print(maximum([-4, -7, -3, -11, -12, -23, -5, -2, -16]))
print(maximum([-4, -7, -3, -11, -12, 23, 5, 2, 16]))
print(maximum([4]))
print(maximum([-4]))
  1. 🙋‍♂️ Pour trouver le minimum, il suffirait de remplacer maxi par mini et de remplacer if elt > maxi: par if elt < mini:.
Exercice 7. Indice du premier maximum

Écrire une fonction premier_maximum qui prend en paramètre un tableau non-vide de nombre et renvoie l’indice de la première occurrence du maximum de ce tableau.

Exemple.

>>> premier_maximum([4, 7, 23, 11, 3, 23, 5, 3, 16])
2
>>> premier_maximum([-4, -7, -23, -11, -3, -23, -5, -3, -16])
4
>>> premier_maximum([-4, -7, 23, -11, -3, 23, 23, 2, 16])
2
>>> premier_maximum([4])
0
>>> premier_maximum([-4])
0
Aides
Codes à trous 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def premier_maximum(tab):
    i_maxi = ...
    for i in ...:
        if ... > ...:
            ...
    return ...


print(premier_maximum([4, 7, 23, 11, 3, 23, 5, 3, 16]))
print(premier_maximum([-4, -7, -23, -11, -3, -23, -5, -3, -16]))
print(premier_maximum([-4, -7, 23, -11, -3, 23, 23, 2, 16]))
print(premier_maximum([4]))
print(premier_maximum([-4]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def premier_maximum(tab):
    i_maxi = ...
    for i in range(...):
        if tab[...] > ...:
            i_maxi = ...
    return ...


print(premier_maximum([4, 7, 23, 11, 3, 23, 5, 3, 16]))
print(premier_maximum([-4, -7, -23, -11, -3, -23, -5, -3, -16]))
print(premier_maximum([-4, -7, 23, -11, -3, 23, 23, 2, 16]))
print(premier_maximum([4]))
print(premier_maximum([-4]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def premier_maximum(tab):
    i_maxi = ...
    for i in range(len(tab)):
        if tab[i] > tab[...]:
            i_maxi = ...
    return i_maxi


print(premier_maximum([4, 7, 23, 11, 3, 23, 5, 3, 16]))
print(premier_maximum([-4, -7, -23, -11, -3, -23, -5, -3, -16]))
print(premier_maximum([-4, -7, 23, -11, -3, 23, 23, 2, 16]))
print(premier_maximum([4]))
print(premier_maximum([-4]))
Correction 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def premier_maximum(tab):
    i_maxi = 0
    for i in range(len(tab)):
        if tab[i] > tab[i_maxi]: #(1)!
            i_maxi = i
    return i_maxi


print(premier_maximum([4, 7, 23, 11, 3, 23, 5, 3, 16]))
print(premier_maximum([-4, -7, -23, -11, -3, -23, -5, -3, -16]))
print(premier_maximum([-4, -7, 23, -11, -3, 23, 23, 2, 16]))
print(premier_maximum([4]))
print(premier_maximum([-4]))
  1. 🙋‍♂️ Pour trouver l’indice du premier minimum, il suffirait de remplacer i_maxi par i_mini et de remplacer if tab[i] > tab[i_maxi]: par if tab[i] < tab[i_mini]:.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
def premier_maximum(tab):
    # L'indice du maximum prend provisoirement la valeur
    # zéro (indice de la première case du tableau).
    i_maxi = 0
    # On parcourt le tableau.
    for i in range(len(tab)):
        # Si l'élément courant est strictement supérieur au
        # au maximum provisoire, (l'égalité stricte permet de 
        # ne prendre en compte que la première occurrence).
        if tab[i] > tab[i_maxi]: #(1)!
            # On met à jour l'indice du maximum
            i_maxi = i
    # En fin de parcours i_maxi contient l'indice de la
    # prmeière cocurrence du maximum.
    return i_maxi


print(premier_maximum([4, 7, 23, 11, 3, 23, 5, 3, 16]))
print(premier_maximum([-4, -7, -23, -11, -3, -23, -5, -3, -16]))
print(premier_maximum([-4, -7, 23, -11, -3, 23, 23, 2, 16]))
print(premier_maximum([4]))
print(premier_maximum([-4]))
  1. 🙋‍♂️ Pour trouver l’indice du premier minimum, il suffirait de remplacer i_maxi par i_mini et de remplacer if tab[i] > tab[i_maxi]: par if tab[i] < tab[i_mini]:.
Exercice 8. Indice du dernier maximum

Écrire une fonction dernier_maximum qui prend en paramètre un tableau non-vide de nombre et renvoie l’indice de la dernière occurrence du maximum de ce tableau.

Exemple.

>>> dernier_maximum([4, 7, 23, 11, 3, 23, 6, 3, 16])
5
>>> dernier_maximum([-4, -7, -23, -11, -3, -23, -5, -3, -16])
7
>>> dernier_maximum([-4, -7, 23, -11, -3, 23, 23, 2, 16])
6
>>> dernier_maximum([4])
0
>>> dernier_maximum([-4])
0
Aides
Codes à trous 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def dernier_maximum(tab):
    ...
    for i in ...:
        if ... >= ...:
            i_maxi = ...
    return ...


print(dernier_maximum([4, 7, 23, 11, 3, 23, 6, 3, 16]))
print(dernier_maximum([-4, -7, -23, -11, -3, -23, -5, -3, -16]))
print(dernier_maximum([-4, -7, 23, -11, -3, 23, 23, 2, 16]))
print(dernier_maximum([4]))
print(dernier_maximum([-4]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def dernier_maximum(tab):
    i_maxi = ...
    for i in range(...):
        if tab[...] >= tab[...]:
            i_maxi = ...
    return i_maxi


print(dernier_maximum([4, 7, 23, 11, 3, 23, 6, 3, 16]))
print(dernier_maximum([-4, -7, -23, -11, -3, -23, -5, -3, -16]))
print(dernier_maximum([-4, -7, 23, -11, -3, 23, 23, 2, 16]))
print(dernier_maximum([4]))
print(dernier_maximum([-4]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def dernier_maximum(tab):
    i_maxi = ...
    for i in range(len(tab)):
        if tab[i] >= tab[...]:
            i_maxi = ...
    return i_maxi


print(dernier_maximum([4, 7, 23, 11, 3, 23, 6, 3, 16]))
print(dernier_maximum([-4, -7, -23, -11, -3, -23, -5, -3, -16]))
print(dernier_maximum([-4, -7, 23, -11, -3, 23, 23, 2, 16]))
print(dernier_maximum([4]))
print(dernier_maximum([-4]))
Correction 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def dernier_maximum(tab):
    i_maxi = 0
    for i in range(len(tab)):
        if tab[i] >= tab[i_maxi]: #(1)!
            i_maxi = i
    return i_maxi


print(dernier_maximum([4, 7, 23, 11, 3, 23, 6, 3, 16]))
print(dernier_maximum([-4, -7, -23, -11, -3, -23, -5, -3, -16]))
print(dernier_maximum([-4, -7, 23, -11, -3, 23, 23, 2, 16]))
print(dernier_maximum([4]))
print(dernier_maximum([-4]))
  1. 🙋‍♂️ Pour trouver l’indice du dernier minimum, il suffirait de remplacer i_maxi par i_mini et de remplacer if tab[i] >= tab[i_maxi]: par if tab[i] <= tab[i_mini]:.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def dernier_maximum(tab):
    # L'indice du maximum prend provisoirement la valeur
    # zéro (indice de la première case du tableau).
    i_maxi = 0
    # On parcourt le tableau.
    for i in range(len(tab)):
        # Si l'élément courant est supérieur ou égal au
        # maximum provisoire, (l'égalité large permet de 
        # prendre en compte toutes les occurrences et donc
        # la dernière en fin de parcours).
        if tab[i] >= tab[i_maxi]: #(1)!
            # On met à jour l'indice du maximum
            i_maxi = i
        # En fin de parcours i_maxi contient l'indice de la
        # dernière occurrence du maximum.
    return i_maxi


print(dernier_maximum([4, 7, 23, 11, 3, 23, 6, 3, 16]))
print(dernier_maximum([-4, -7, -23, -11, -3, -23, -5, -3, -16]))
print(dernier_maximum([-4, -7, 23, -11, -3, 23, 23, 2, 16]))
print(dernier_maximum([4]))
print(dernier_maximum([-4]))
  1. 🙋‍♂️ Pour trouver l’indice du dernier minimum, il suffirait de remplacer i_maxi par i_mini et de remplacer if tab[i] >= tab[i_maxi]: par if tab[i] <= tab[i_mini]:.

Moyenne pondérée

Exercice 9. Moyenne pondérée

Dans cet exercice on cherche à calculer la moyenne pondérée d’un élève dans une matière donnée. Chaque note est associée à un coefficient qui la pondère.

Par exemple, si ses notes sont : 14 avec coefficient 3, 12 avec coefficient 1 et 16 avec coefficient 2, sa moyenne pondérée sera donnée par

\frac{14 \times 3 + 12 \times 1 + 16 \times 2}{3 + 1 + 2} = 14{,}333...

Écrire une fonction moyenne :

  • qui prend en paramètre une liste notes non vide de tuples à deux éléments entiers de la forme (note, coefficient) (int ou float) positifs ou nuls ;
  • et qui renvoie la moyenne pondérée des notes de la liste sous forme flottant si la somme des coefficients est non nulle, None sinon.

Exemple :

>>> moyenne([(8, 2), (12, 0), (13.5, 1), (5, 0.5)])
9.142857142857142
>>> moyenne([(3, 0), (5, 0)]) # renvoie None (1)
  1. 🙋‍♂️ Rappel. Dans la console, un appel exécuté qui renvoie None ne donne aucun résultat. En mode programme, on insère l’appel dans un print(...). On exécutera donc ici print(moyenne([(3, 0), (5, 0)])) ce qui donnera pour affichage None.
Aides
Codes à trous 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def moyenne(...):
    ...
    ...
    for ... in ...:
        ...
        ...
    if ...:
        ...
    else:
        ...


print(moyenne([(8, 2), (12, 0), (13.5, 1), (5, 0.5)]))
print(moyenne([(3, 0), (5, 0)]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def moyenne(notes):
    somme_points = ...
    ...
    for note, coeff in ...:
        ... += note * ...
        somme_coeffs += ...
    if ...:
        return None
    else:
        return ... / ...


print(moyenne([(8, 2), (12, 0), (13.5, 1), (5, 0.5)]))
print(moyenne([(3, 0), (5, 0)]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def moyenne(notes):
    somme_points = 0
    somme_coeffs = ...
    for note, coeff in ...:
        somme_points += note * ...
        somme_coeffs += ...
    if somme_coeffs == ...:
        return None
    else:
        return somme_points / ...


print(moyenne([(8, 2), (12, 0), (13.5, 1), (5, 0.5)]))
print(moyenne([(3, 0), (5, 0)]))
Correction 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def moyenne(notes):
    somme_points = 0
    somme_coeffs = 0
    for note, coeff in notes:
        somme_points += note * coeff
        somme_coeffs += coeff
    if somme_coeffs == 0: #(1)!
        return None
    else:
        return somme_points / somme_coeffs


print(moyenne([(8, 2), (12, 0), (13.5, 1), (5, 0.5)]))
print(moyenne([(3, 0), (5, 0)]))
  1. 🙋‍♂️ Attention, dans ce branchement conditionnel, il faut placer d’abord l’aternative somme_coeffs == 0. Si on tente d’abord le calcul avec une somme de coefficients nulle, une erreur ZeroDivisionError se déclenchera avec le premier appel.

La fonction moyenne :

  • prend en paramètre une liste notes non vide de tuples à deux éléments entiers de la forme (note, coefficient) (int ou float) positifs ou nuls ;
  • et renvoie la moyenne pondérée des notes de la liste sous forme flottant si la somme des coefficients est non nulle, None sinon.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def moyenne(notes):
    # On initialise deux variables d'accumulation qui vont accumuler
    # respectivement les points obtenus par l'ensemble des élèves et
    # les coefficients des notes.
    somme_points = 0
    somme_coeffs = 0
    # On parcourt le tableau des notes en déballant chaque tuple du
    # tableau en deux variables stockant respectivement les note et
    # coefficient courants.
    for note, coeff in notes:
        # On incrémente les deux variables d'accumulation.
        somme_points += note * coeff
        somme_coeffs += coeff
    # Si la somme des coefficients est zéro,
    if somme_coeffs == 0: #(1)!
        # on renvoie None.
        return None
    # Sinon,
    else:
        # on renvoie le quotient des deux sommes calculées.
        return somme_points / somme_coeffs


print(moyenne([(8, 2), (12, 0), (13.5, 1), (5, 0.5)]))
print(moyenne([(3, 0), (5, 0)]))
  1. 🙋‍♂️ Attention, dans ce branchement conditionnel, il faut placer d’abord l’aternative somme_coeffs == 0. Si on tente d’abord le calcul avec une somme de coefficients nulle, une erreur ZeroDivisionError se déclenchera avec le premier appel.

Comparaisons d’éléments consécutifs

Exercice 10. Doublons dans un tableau trié

Écrire une fonction a_doublon qui prend en paramètre un tableau trié de nombres dans l’ordre croissant et renvoie True si ce tableau contient au moins deux nombres identiques, False sinon.

Exemple :

>>> a_doublon([])
False
>>> a_doublon([1])
False
>>> a_doublon([1, 2, 4, 6, 6])
True
>>> a_doublon([2, 5, 7, 7, 7, 9])
True
>>> a_doublon([0, 2, 3])
False
Aides
Codes à trous 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def a_doublon(tab):
    if ...:
        return False
    for i in ...:
        if ...:
            return True
    return ...


print(a_doublon([]))
print(a_doublon([1]))
print(a_doublon([1, 2, 4, 6, 6]))
print(a_doublon([2, 5, 7, 7, 7, 9]))
print(a_doublon([0, 2, 3]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def a_doublon(tab):
    if ... < ...:
        return False
    for i in range(...):
        if tab[i] == ...:
            return True
    return ...


print(a_doublon([]))
print(a_doublon([1]))
print(a_doublon([1, 2, 4, 6, 6]))
print(a_doublon([2, 5, 7, 7, 7, 9]))
print(a_doublon([0, 2, 3]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def a_doublon(tab):
    if len(tab) < ...:
        return False
    for i in range(len(tab) - 1):
        if tab[i] == tab[...]:
            return True
    return ...


print(a_doublon([]))
print(a_doublon([1]))
print(a_doublon([1, 2, 4, 6, 6]))
print(a_doublon([2, 5, 7, 7, 7, 9]))
print(a_doublon([0, 2, 3]))
Correction 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def a_doublon(tab):
    if len(tab) < 2:
        return False
    for i in range(len(tab) - 1):
        if tab[i] == tab[i + 1]:
            return True
    return False


print(a_doublon([]))
print(a_doublon([1]))
print(a_doublon([1, 2, 4, 6, 6]))
print(a_doublon([2, 5, 7, 7, 7, 9]))
print(a_doublon([0, 2, 3]))

La fonction a_doublon prend en paramètre un tableau trié de nombres dans l’ordre croissant et renvoie True si ce tableau contient au moins deux nombres identiques, False sinon.

Comme le tableau passé en paramètre est trié dans l’ordre croissant, deux éléments identiques sont forcément côte à côte. On va donc vérifier s’il existe dans le tableau au moins une paire d’éléments consécutifs de même valeur.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
def a_doublon(tab):
    # Si le tableau est vide ou comprend un seul élément.
    if len(tab) < 2:
        # Le tableau ne peut pas contenir de doublon. On renvoie donc
        # False.
        return False
    # Sinon, on parcourt le tableau en comparant deux à deux les
    # éléments consécutifs du tableau. On prend soin de choisir comme
    # dernier indice len(tab) - 2 pour éviter un dépassement d'indice
    # dans tab[i + 1].
    for i in range(len(tab) - 1):
        # Si l'élément courant est identique à l'élément suivant,
        if tab[i] == tab[i + 1]:
            # il y a un doublon donc on renvoie True
            return True
    # En fin de parcours, si aucun doublon n'a été détectée, cela
    # indique que le tableau ne possède pas de doublon et on renvoie
    # False.
    return False


print(a_doublon([]))
print(a_doublon([1]))
print(a_doublon([1, 2, 4, 6, 6]))
print(a_doublon([2, 5, 7, 7, 7, 9]))
print(a_doublon([0, 2, 3]))
Exercice 11. Vérification du tri d’un tableau

Écrire une fonction verifie qui prend en paramètre un tableau de valeurs numériques et qui renvoie True si ce tableau est trié dans l’ordre croissant, False sinon. Un tableau vide est considéré comme trié.

Exemples :

>>> verifie([0, 5, 8, 8, 9])
True
>>> verifie([8, 12, 4])
False
>>> verifie([-1, 4])
True
>>> verifie([])
True
>>> verifie([5])
True
Aides
Codes à trous 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def verifie(tab):
    if ...:
        return True
    for i in ...:
        if ...:
            return ...
    return ...


print(verifie([0, 5, 8, 8, 9]))
print(verifie([8, 12, 4]))
print(verifie([-1, 4]))
print(verifie([]))
print(verifie([5]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def verifie(tab):
    if ... < ...:
        return True
    for i in range(...):
        if tab[i] > ...:
            return False
    return ...


print(verifie([0, 5, 8, 8, 9]))
print(verifie([8, 12, 4]))
print(verifie([-1, 4]))
print(verifie([]))
print(verifie([5]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def verifie(tab):
    if len(tab) < ...:
        return True
    for i in range(len(tab) - 1):
        if tab[i] > tab[...]:
            return False
    return True


print(verifie([0, 5, 8, 8, 9]))
print(verifie([8, 12, 4]))
print(verifie([-1, 4]))
print(verifie([]))
print(verifie([5]))
Correction 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def verifie(tab):
    if len(tab) < 2:
        return True
    for i in range(len(tab) - 1):
        if tab[i] > tab[i + 1]:
            return False
    return True


print(verifie([0, 5, 8, 8, 9]))
print(verifie([8, 12, 4]))
print(verifie([-1, 4]))
print(verifie([]))
print(verifie([5]))

La fonction verifie prend en paramètre un tableau de valeurs numériques et renvoie True si ce tableau est trié dans l’ordre croissant, False sinon. Un tableau vide est considéré comme trié.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
def verifie(tab):
    # Si le tableau est vide ou comprend un seul élément.
    if len(tab) < 2:
        # Le tableau est considéré comme trié donc on renvoie True
        return True
    # Sinon, on parcourt le tableau en comparant deux à deux les
    # éléments consécutifs du tableau. On prend soin de choisir comme
    # dernier indice len(tab) - 2 pour éviter un dépassement d'indice
    # dans tab[i + 1].
    for i in range(len(tab) - 1):
        # Si l'élément courant est strictement supérieur à l'élément
        # suivant,
        if tab[i] > tab[i + 1]:
            # cela indique que le tableau est mal trié donc on
            # renvoie False.
            return False
    # En fin de parcours, si aucune anomalie n'a été détectée, cela
    # indique que le tableau est bien trié et on renvoie True.
    return True


print(verifie([0, 5, 8, 8, 9]))
print(verifie([8, 12, 4]))
print(verifie([-1, 4]))
print(verifie([]))
print(verifie([5]))
Exercice 12. Codage par différence

Le codage par différence (delta encoding en anglais) permet de compresser un tableau de données en indiquant pour chaque donnée, sa différence avec la précédente (plutôt que la donnée elle-même). On se retrouve alors avec un tableau de données plus petit, nécessitant moins de place en mémoire. Cette méthode se révèle efficace lorsque les valeurs consécutives sont proches.

Programmer la fonction delta(tab) qui prend en paramètre un tableau de nombres entiers et qui renvoie un tableau contenant les valeurs entières compressées à l’aide cette technique.

Exemples :
>>> delta([1000, 800, 802, 1000, 1003])
[1000, -200, 2, 198, 3]
>>> delta([42])
[42]
>>> delta([])
[]
Aides
Codes à trous 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def delta(tab):
    if ...:
        return ...
    res = ...
    for i in ...:
        ...
    return res


print(delta([1000, 800, 802, 1000, 1003]))
print(delta([42]))
print(delta([]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def delta(tab):
    if ... < ...:
        return tab
    res = ...
    for i in range(...):
        res.append(... - ...)
    return res


print(delta([1000, 800, 802, 1000, 1003]))
print(delta([42]))
print(delta([]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def delta(tab):
    if len(tab) < ...:
        return tab
    res = [...]
    for i in range(len(tab) - 1):
        res.append(tab[i + 1] - ...)
    return res


print(delta([1000, 800, 802, 1000, 1003]))
print(delta([42]))
print(delta([]))
Correction 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def delta(tab):
    if len(tab) < 2:
        return tab
    res = [tab[0]]
    for i in range(len(tab) - 1):
        res.append(tab[i + 1] - tab[i])
    return res


print(delta([1000, 800, 802, 1000, 1003]))
print(delta([42]))
print(delta([]))

Le codage par différence (delta encoding en anglais) permet de compresser un tableau de données en indiquant pour chaque donnée, sa différence avec la précédente (plutôt que la donnée elle-même).

La fonction delta(tab) prend en paramètre un tableau de nombres entiers et renvoie un tableau contenant les valeurs entières compressées à l’aide cette technique.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
def delta(tab):
    # Si le tableau est vide ou comprend un seul élément.
    if len(tab) < 2:
        # on renvoie simplement le tableau.
        return tab
    # Sinon, on initialise le tableau résultat comme un tableau à une
    # case contenant le premier élément du tableau passé en paramètre.
    res = [tab[0]]
    # On parcourt le tableau passé en paramètre à l'exception de son
    # dernier élément. On construit progressivement le tableau
    # résultat en lui ajoutant à chaque étape la différence entre
    # l'élément suivant et l'élément courant.
    for i in range(len(tab) - 1):
        res.append(tab[i + 1] - tab[i])
    return res


print(delta([1000, 800, 802, 1000, 1003]))
print(delta([42]))
print(delta([]))