E07 - Table de multiplication⚓︎
Le problème
Proposition 1⚓︎
🐍 Script Python
def table_multiplication(nb: int) -> str:
"""Cette fonction prend en paramètre un chiffre entre 1 et 9 et affiche sa table de multiplication.
>>> 3
3x1=3
3x2=6
3x3=9
3x4=12
3x5=15
3x6=18
3x7=21
3x8=24
3x9=27
"""
for x in range(1, 10):
print(str(nb) + "x" + str(x) + "=" + str(nb*x))
# tests
import doctest
doctest.testmod()
# Entrée
nb = int(input())
# Sortie
table_multiplication(nb)
- doctest à revoir.
- fstring à privilégier.
Proposition 2⚓︎
🐍 Script Python
def table_de_multiplication(chiffre:int):
"""Renvoie la table de multiplication du chiffre donné partant de 1 jusqu'à 9 dans une liste
>>> table_de_multiplication(4)
['4x1=4', '4x2=8', '4x3=12', '4x4=16', '4x5=20', '4x6=24', '4x7=28', '4x8=32', '4x9=36']
>>> table_de_multiplication(8)
['8x1=8', '8x2=16', '8x3=24', '8x4=32', '8x5=40', '8x6=48', '8x7=56', '8x8=64', '8x9=72']
"""
affichage = []
for x in range(1,10):
affichage.append(f'{chiffre}x{x}={chiffre * x}')
return affichage
# tests
import doctest
doctest.testmod()
# Entrée
chiffre = int(input())
# Sortie
affichage = table_de_multiplication(chiffre)
for multiplication in affichage:
print(multiplication)
- Annotation de type incomplète.
- Il était plus simple d'afficher dans la fonction.
Proposition 3⚓︎
🐍 Script Python
chiffre = int(input())
for y in range (1, 10):
print(chiffre,"x",y,"=",chiffre*y, sep="")
- On attendait une fonction.
- Revoir le PEP-8, on attend une espace après la virgule.
- Penser aux fstring. C'est très bien !
Proposition 4⚓︎
🐍 Script Python
multiple = int(input())
for x in range(1,10):
print(f"{multiple}x{x}={multiple*x}")
- On attendait une fonction.
- Revoir le PEP-8, on attend une espace après la virgule.
Proposition 5⚓︎
🐍 Script Python
def table_de_multiplications(chiffre: int) -> str:
"""Revoie la table de multiplication de l'entier demandé.
>>> table_de_multiplications(3)
3x1=3
3x2=6
3x3=9
3x4=12
3x5=15
3x6=18
3x7=21
3x8=24
3x9=27
"""
for i in range(1,10):
print(chiffre, "x", i, "=", i*chiffre, sep="")
# Test
import doctest
doctest.testmod()
# Entrée
chiffre = int(input())
if not (1<= chiffre <= 9):
raise ValueError("Chiffre trop grand, il ne doit pas dépasser 9.")
# Sortie
table_de_multiplications(chiffre)
- Annotation de type fausse, ici la fonction renvoie
None
. - De même, la docstring est fausse ; la fonction affiche, elle ne renvoie pas.
- Bon doctest, mais penser à l'aérer.
- Penser aux fstring.
- Le
raise
est inutile ici.
Proposition 6⚓︎
🐍 Script Python
nb_à_multiplier = int(input())
liste_tableu= [0] * 9
resulta = 0
for y in range(1, 10): #10 est eclue dans la boucle va de 1 à 9
resulta = nb_à_multiplier * y
liste_tableu[y - 1] = [nb_à_multiplier, "x", y, "=", resulta]
for x in liste_tableu:
for z in x:
print(z, end="")
print()
- Ici, le style n'est pas formidable ; une liste de liste ne se justifie pas.
- Les identifiants
x
,y
,z
ne sont pas clairs du tout...
Proposition 7⚓︎
🐍 Script Python
"""Cette algorithme prend en paramètre un chiffre (entre 1 et 9), et il affiche la table de multiplication de ce chiffre.
exemple d'entrée : 3
exemple de sortie : 3x1=3
3x2=6
3x3=9
3x4=12
3x5=15
3x6=18
3x7=21
3x8=24
3x9=27
"""
# tests
import doctest
doctest.testmod()
# Entrée
nombre = int(input())
# Algorithme
for i in range(1,10):
print(nombre,"x",i,"=",i*nombre,sep="") # Sortie
- On attendait une fonction.
- Revoir le PEP-8, on attend une espace après chaque virgule.
🐍 Script Python
# 0- Coeur du programme
def construction_table_de_multiplication_de(chiffre: int) -> str:
""" Renvoie la table de multiplication de chiffre.
>>> construction_table_de_multiplication_de(1)
'1x1=1\\n1x2=2\\n1x3=3\\n1x4=4\\n1x5=5\\n1x6=6\\n1x7=7\\n1x8=8\\n1x9=9\\n'
>>> construction_table_de_multiplication_de(3)
'3x1=3\\n3x2=6\\n3x3=9\\n3x4=12\\n3x5=15\\n3x6=18\\n3x7=21\\n3x8=24\\n3x9=27\\n'
"""
table_de_multiplication = ""
for multiplicateur in range(1,10):
table_de_multiplication += str(chiffre) + "x" + str(multiplicateur) + "=" + str(chiffre * multiplicateur) + "\n"
return table_de_multiplication
# 1- Tests
import doctest
doctest.testmod()
# 2- Lecture de l'entrée
chiffre = int(input())
# 3- Appel de la fonction / Sortie
print(construction_table_de_multiplication_de(chiffre))
- Joli tour de force de réussir le doctest, mais ici on attendait plutôt une fonction qui affiche...
- Il vaut mieux éviter
+=
avec les chaines de caractères, quand on peut. Question de complexité. Très souvent, il suffit d'accumuler dans une liste les morceaux, puis de les coller à la fin avecséparateur.join(cumul)
.
Proposition 8⚓︎
🐍 Script Python
# Fonction avec multiplication
def table_multiplication(nb_réf : int) -> str :
""" Renvoie la table de multiplication du 'nb_réf' (de 1 jusqu'à 9)'.
>>> chiffre = 3
>>> table_multiplication(chiffre)
3x1=3
3x2=6
3x3=9
3x4=12
3x5=15
3x6=18
3x7=21
3x8=24
3x9=27
"""
longueur_table = 9
début, fin = 1, 9
for nb in range (début, fin+1) :
résultat = nb_réf * nb
structure = [str(nb_réf), "x", str(nb), "=", str(résultat)]
print("".join(structure))
# OU avec addition
"""
longueur_table = 9
résultat = nb_réf
multiplication = "x"
égal = "="
début, fin = 1, 9
for nb in range (début, fin+1) :
structure = [str(nb_réf), multiplication, str(nb), égal, str(résultat)]
print("".join(structure))
résultat += nb_réf
"""
# tests
import doctest
doctest.testmod()
# Entrée
chiffre = int(input())
assert 1 <= chiffre <= 9
# Sortie
table_multiplication(chiffre)
- Erreur de docstring et d'annotation. La fonction ne renvoie pas la table, elle l'affiche.
- Le
assert
est inutile ici.
Corrigé du professeur⚓︎
🐍 Script Python
"""
author : Franck CHAMBON
problem: https://prologin.org/train/2003/semifinal/table_de_multiplications
"""
def affiche_table(chiffre: int) -> None:
"""Affiche la table de multiplication de `chiffre`.
>>> affiche_table(3)
3x1=3
3x2=6
3x3=9
3x4=12
3x5=15
3x6=18
3x7=21
3x8=24
3x9=27
"""
for k in range(1, 10):
## Version classique
#print(chiffre, "x", k, "=", chiffre * k, sep="")
## Version f-string ; recommandée
print(f"{chiffre}x{k}={chiffre * k}")
import doctest
doctest.testmod()
chiffre = int(input())
affiche_table(chiffre)
- Ici, on réalise l'affichage dans la fonction.
- Le résultat n'est pas utile ici, à part pour l'afficher, autant le faire directement.
- Le code et le doctest sont plus simples à écrire.
- On recommande chaudement l'utilisation des fstring, sauf sur FranceIOI qui utilise une ancienne version de Python.