E03 - Grand écart⚓︎
Le problème
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 à unreturn
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
, outaille
c'est mieux quenb_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...
- La fonction
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 encore5*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".