Correction de Grand écart

Quelques propositions d'élèves, et à la fin un corrigé du professeur.

• Propositions d'élèves
  • Proposition 1
  • Proposition 2
  • Proposition 3
  • Proposition 4
  • Proposition 5
  • Proposition 6
• Corrigé du professeur

Propositions d'élèves

À la suite de chaque proposition de code, un commentaire de correction du professeur. Le cartouche demandé en introduction a été supprimé ici.

Proposition 1

def ecart(nb_tableau: int, tableau: int) -> int:
    """Cette fonction prend en paramètre un tableau de nombres entiers, et qui recherche, dans ce tableau, la plus grande différence, 
    entre un élément et son successeur et renvoie cette différence.
    >>> 10
        [4, 2, 3, 5, 10, 6, 4, 9, 1, 3]
    8
    """
    grand_ecart = 0
    for x in range(nb_tableau):
        if x == nb_tableau - 1:
            break
        else:
            ecart = tableau[x] - tableau[x+1]
            if ecart > grand_ecart:
                grand_ecart = ecart
    return grand_ecart

# tests
import doctest
doctest.testmod()

# Entrée
nb_tableau = int(input())
tableau = list(map(int, input().split()))

# Sortie
print(ecart(nb_tableau, tableau))

• doctest à revoir.
• La présence de break témoigne qu'il faut penser à un return anticipé,
  • mais ici un tour de boucle en moins suffisait.
• Il manque la valeur absolue à ecart = tableau[x] - tableau[x+1]

Proposition 2

def Plus_grand_écart(nb_nombres : int,liste_nombres : list) -> int:
    """
    Prend en paramètre le nombre de nombres "nb_nombres" et une liste de nombres "liste_nombres" puis, 
    la fonction recherche et renvoie, la plus grande différence (en valeur absolue),
    entre un élément et son successeur (l'élément suivant dans le tableau).
    >>> Plus_grand_écart(10,[4,2,3,5,10,6,4,9,1,3])
    8
    >>> Plus_grand_écart(7,[17,5,3,5,10,6,9])
    12
    """
    écart_max = 0
    for x in range(nb_nombres-1):
        écart = abs(liste_nombres[x] - liste_nombres[x+1]) 

        if écart > écart_max:
            écart_max = écart
        else: 
            pass
    return écart_max

# tests
import doctest
doctest.testmod()

# Entrée
nb_nombres = int(input())
liste_nombres = list(map(int,input().split()))
# Sortie
print(Plus_grand_écart(nb_nombres,liste_nombres))

• Éviter les lignes trop longues.
• Ajouter une espace après la virgule ; cf PEP-8.
• Le else: pass peut être enlevé.
• Commencer Plus_grand_écart par une minuscule.

Proposition 3

def plus_grand_ecart(liste, nb_entier):
    """Renvoie le plus grand ecart entre deux nombre d'une liste
    >>> plus_grand_ecart([4, 2, 3, 5, 10, 6, 4, 9, 1, 3,], 10 )
    8
    """
    i = 0
    maximum = 0
    while i < nb_entier-1:
        ecart = abs(liste[i] - liste[i+1])
        if ecart>maximum:
            maximum = ecart
        i += 1
    return maximum

# Test
import doctest
doctest.testmod()

# Entrées
nb_entier = int(input())
liste = input().split(" ")
liste_entier = []
 
for i in liste:
    liste_entier.append(int(i))

# Sortie
print(plus_grand_ecart(liste_entier, nb_entier))

• Quitte à donner les deux, il vaut mieux débuter les paramètres de la fonction par la taille, puis la liste.
• Aérer ecart>maximum.
• Pour la lecture de plusieurs entiers sur une ligne, utiliser plutôt map(int, input().split()).

Proposition 4

def cherche_plus_grande_diférence(nb_de_nombre: int, liste_nb):
    """cherche plus grande diférence entre deux nombre dans une liste
    >>> cherche_plus_grande_diférence(10, ['4', '2', '3', '5', '10', '6', '4', '9', '1', '3'])
    8
    """
    plus_grande_diférence = 0
    diférence = 0
    for x in range(nb_de_nombre- 1):
        if liste_nb[x] >= liste_nb[x + 1]:
            diférence = int(liste_nb[x]) - int(liste_nb[x + 1])
        else:
            diférence = int(liste_nb[x + 1]) - int(liste_nb[x])
        if diférence >= plus_grande_diférence:
            plus_grande_diférence = diférence
    return plus_grande_diférence

import doctest
doctest.testmod()

nb_de_nombre = int(input())
liste_nb = input().split()
print(cherche_plus_grande_diférence(nb_de_nombre, liste_nb))

• Ici, il vaut mieux passer une liste d'entiers, plutôt que de chaînes.
• Aérer le doctest.
• Code Spell Checker est un module pour VSCodium qui sera très utile...
• effectif, ou taille c'est mieux que nb_de_nombres.

Proposition 5

# 0- Coeur du programme

def plus_grand_écart(nb_éléments: int, liste_éléments: list) -> int:
    """ Renvoie la plus grande différence entre un élément et son successeur dans le tableau.
    >>> plus_grand_écart(2, [0,5])
    5
    >>> plus_grand_écart(10, [4, 2, 3, 5, 10, 6, 4, 9, 1, 3])
    8
    """

    écart_max = 0
    for i in range(nb_éléments-1):
        écart = abs(liste_éléments[i] - liste_éléments[i+1])
        if écart > écart_max:
            écart_max = écart
    return écart_max

# 1- Tests

import doctest
doctest.testmod()

# 2- Lecture des entrées

nb_éléments = int(input())
liste_éléments = list(map(int,input().split()))

# 3- Appel de la fonction / Sortie

print(plus_grand_écart(nb_éléments, liste_éléments))

• Aérer le doctest.
• Aérer nb_éléments-1.
• Ajouter une espace après chaque virgule.

Proposition 6

def écart_max (tableau : list) -> int :
    """ Renvoie un entier qui est le plus grand écart 
    entre une paire d'entier qui se succèdent dans une liste.

    >>> tableau = [4, 2, 3, 5, 10, 6, 4, 9, 1, 3]
    >>> écart_max(tableau)
    8
    
    """
    max = 0
    for élément in range (len(tableau)-1) :
        écart = abs(tableau[élément] - tableau[élément + 1])
        if max < écart :
            max = écart
    return max

# tests
import doctest
doctest.testmod()

# Entrée 
nb_éléments = int(input())
assert 2 <= nb_éléments <= 300
tableau = list(map(int, input().split()))

# Sortie
print (écart_max(tableau))

• Inutile de faire assert pour vérifier l'entrée du juge ; lui faire confiance.
• max et élément ne sont pas des noms idéaux.
  • La fonction max existe, et sera écrasée...
  • élément est ici un indice d'un élément...

Corrigé du professeur

"""
auteur : Franck CHAMBON
https://prologin.org/train/2003/semifinal/grand_ecart
"""

def grand_écart(tableau: list[int]) -> int:
    """Renvoie le plus grand écart entre un élément et son successeur.

    >>> grand_écart([4, 2, 3, 5, 10, 6, 4, 9, 1, 3])
    8

    """
    taille = len(tableau)
    écart_max = 0
    for i in range(taille - 1):
        écart = abs(tableau[i] - tableau[i + 1])
        if écart_max < écart:
            écart_max = écart
    return écart_max


import doctest
doctest.testmod()

taille = int(input())
tableau = list(map(int, input().split()))

print(grand_écart(taille, tableau))

• On utilise souvent i comme indice pour itérer sur un tableau, comme première dimension.
• Uniquement pour les variables à une lettre, on pourrait resserrer l'écriture autour des opérations prioritaires ou uniques, comme i+1, (ou encore 5*x + 7).
• Le paramètre taille est utile pour les codes traditionnels en C pour la lecture d'un tableau. En Python, c'est inutile.
  • Il faut le lire.
  • Ensuite, en C, on le passe en paramètre avec le lien vers le tableau.
  • En Python, on préfère s'en passer. Quitte à demander sa longueur dans la fonction, comme ici.
• Après la lecture du tableau, on aurait pu écrire un test de vérification des données. C'est utile en cas de doute sur les données d'un problème. Cela arrive. Ce n'est pas demandé dans ce DM.

assert len(tableau) == taille, f"La taille donnée est {taille}, mais le tableau a {len(tableau)} éléments".