Correction de Table de multiplication

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

Propositions d’élèves
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.
x n’était pas le meilleur nom de variable ici.

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.
Il vaut mieux ne pas choisir x ici comme variable.

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.
Dans la docstring, on recommande l’utilisation de Markdown quand on sait faire. Il est possible de générer la documentation complète d’un module à partir des doctring de ses différents composants.