Correction de Table de multiplication

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
  • Proposition 7
  • Proposition 8
• 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 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

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

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

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

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

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

"""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.

# 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 chaînes 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 avec séparateur.join(cumul).

Proposition 8

# 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

"""
auteur : Franck CHAMBON
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.