Aller au contenu

E03 - Grand écart⚓︎

Le problème

Grand écart

Proposition 1⚓︎

🐍 Script Python
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⚓︎

🐍 Script Python
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⚓︎

🐍 Script Python
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⚓︎

🐍 Script Python
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 chaines.
  • 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⚓︎

🐍 Script Python
# 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⚓︎

🐍 Script Python
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⚓︎

🐍 Script Python
"""
author : Franck CHAMBON
problem: https://prologin.org/train/2003/semifinal/grand_ecart
"""

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

    >>> grand_ecart([4, 2, 3, 5, 10, 6, 4, 9, 1, 3])
    8

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


import doctest
doctest.testmod()

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

print(grand_ecart(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.
🐍 Script Python
assert len(tableau) == taille, f"La taille donnée est {taille}, mais le tableau a {len(tableau)} éléments".