Correction de Les trois nombres

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
  • Proposition 9
• 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 somme(nb1: int, nb2: int, nb3: int) -> int:
    """Cette fonction prend en paramètre 3 entiers non nuls. Cette fonctionne doit déterminer si l'un d'eux est égal à la
    somme des deux autres, sinon la fonction renvoie 0.
    >>> 18 42 24
    42
    >>> 11 37 18
    0
    """
    for x in range(3):
        if nb1 + nb2 == nb3:
            return nb3
        elif nb2 + nb3 == nb1:
            return nb1
        elif nb1 + nb3 == nb2: 
            return nb2
        else: 
            return 0
# tests 
import doctest
doctest.testmod()

# Entrée
nb1, nb2, nb3 = map(int, input().split())

# Sortie
print(somme(nb1, nb2, nb3))

• On peut factoriser ce code.
• nb_1, c'est mieux que nb1.
• Revoir le doctest.

Proposition 2

def les_trois_nombres(liste_nombres:list) -> int:
    """ Recherche si une addition des 2 nombres de la liste font le troisième nombre  et renvoie le troisième nombre ou 0 si il n'y pas de combinaison
    >>> les_trois_nombres([18,42,24])
    42
    >>> les_trois_nombres([10,32,18])
    0
    """
    for x in range(3):
        for y in range(x,3):
            nombre = liste_nombres[x] + liste_nombres[y] 
            if nombre in liste_nombres:
                return nombre
    return 0

# tests
import doctest
doctest.testmod()

# Entrée
liste_nombres = list(map(int,input().split()))

# Sortie
print(les_trois_nombres(liste_nombres))

• Erreur

        for y in range(x,3):

Devrait être

        for y in range(x + 1, 3):

Ce programme échoue avec 10 20 30, en renvoyant 20 au lieu de 30. En effet, le 10 est utilisé deux fois pour 10 + 10 == 20, or ce n'est pas autorisé par le sujet.

Proposition 3

n1, n2, n3 = map (int, input().split())
if n1 + n2 == n3:
    print(n3)
elif n1 + n3 == n2:
    print(n2)
elif n2 + n3 == n1:
    print(n1)
else:
    print(0)

• On attend une fonction avec doctest.
• n_1 est mieux que n1.
• Une factorisation est appréciée.

Proposition 4

nombre_1, nombre_2, nombre_3 = map(int, input().split(" "))

if nombre_1  + nombre_2 == nombre_3:
    print(nombre_3)
elif nombre_1 + nombre_3 == nombre_2:
    print(nombre_2)
elif nombre_2 + nombre_3 == nombre_1:
    print(nombre_1)
else:
    print(0)

• Avec une fonction, c'est beaucoup mieux.
• De préférence, un seul print.
• On peut factoriser ce code.

Proposition 5

def verifie(nb_1, nb_2, nb_3):
    """ Renvoie un nombre si la somme des deux autres sont égal. Sinon cela renvoie 0.
    >>> verifie(18, 42, 24)
    42
    >>> verifie(11, 37, 18)
    0
    """
    if nb_1 + nb_2 == nb_3:
        return nb_3
    elif nb_1 + nb_3 == nb_2:
        return nb_2
    elif nb_2 + nb_3 == nb_1:
        return nb_1
    else:
        return 0

# Test
import doctest
doctest.testmod()

# Entrées
nb_1, nb_2, nb_3 = map(int, input().split())

# Sortie
print(verifie(nb_1, nb_2, nb_3))

• Aérer le doctest.
• On peut factoriser ce code.
• On peut mettre un accent à vérifie en français.
• Sinon, c'est très propre.

Proposition 6

ef vérif_a_somme(nb_1, nb_2, nb_3, somme):
    """ vérifie si dans la liste(où il y a imparativemant que 3 chiffre) il existe une somme dans la lisste
    si on addicione les 2 autre nombre
    >>> vérif_a_somme(18, 24, 6, 0)
    24
    """ 
    if (nb_1 + nb_2) == nb_3:
        return nb_3
    elif (nb_2 + nb_3) == nb_1:
        return nb_1
    elif (nb_1 + nb_3) == nb_2:
        return nb_2
    else:
        return 0

import doctest
doctest.testmod()

nb_1, nb_2, nb_3 = map(int, input().split())
somme = 0
print(vérif_a_somme(nb_1, nb_2, nb_3, somme))



"""
"on peut faire aussi se code et sa marche aussi" 
def vérif_a_somme(liste_nb, somme: int):
    " vérifie si dans la liste(où il y a imparativemant que 3 chiffre) il existe une somme dans la lisste
    si on addicione les 2 autre nombre 
    >>> vérif_a_somme(['18', '42', '24'], 0)
    '42'
    >>> vérif_a_somme(['1', '100', '5'], 0)
    0
    " 
    liste_nb.sort()
    somme = int(liste_nb[0]) + int(liste_nb[1])
    if somme == int(liste_nb[2]):
        return liste_nb[2]
    else:
        return 0

import doctest
doctest.testmod()

liste_nb = list(map(int, input().split(" ")))
somme = 0
print(vérif_a_somme(liste_nb, somme))
"""

• Inutile de passer somme en paramètre.
• Deuxième méthode originale, mais il vaut mieux travailler avec les entiers plutôt qu'avec des chaînes de caractères.

Proposition 7

""" 
L'algorithme détermine si un nombre parmis les 3 est égal à la somme des deux autres. 
La fonction renvoie ce nombre s'il existe, 0 sinon.

Exemple d'entrée:  18 42 24 
Exemple de sortie: 42 

Exemple d'entrée:  11 37 18 
Exemple de sortie: 0
"""

# tests 
import doctest 
doctest.testmod()

#Entrée
nombre = list(map(int, input().split()))

#Algorithme
for i in range(nombre): 
    if liste[2] == liste[0]+liste[1]: 
        print(liste[2]) #Sortie
    if liste[0]==liste[1] + liste[2]:
        print(liste[0]) #Sortie
    if liste[1]==liste[0] + liste[2]: 
        print(liste[1]) #Sortie
    else: 
        print("0") #Sortie

• Le sujet du DM indiquait qu'on voulait des fonctions.
• Avec aussi des doctest.
• On attend un code factorisé, il y a trop de print ici.
• Erreur : nombre est une liste et range(nombre) échoue. De plus liste n'est pas défini. Ce code semble avoir été remanié, et n'est pas testé.

Proposition 8

# 0- Coeur du programme

def détermine_somme(nombres: list) -> int:
    """ Détermine si l'un des nombres de la liste est égal à la somme des 2 autres.
    Si oui, renvboie ce nombre, sinon revoie 0.
    >>> détermine_somme([18,42,24])
    42
    >>> détermine_somme([11,37,18])
    0
    """

    combinaisons = [(0,1,2),(1,0,2),(2,0,1)]    # Correspond aux identifiants des nombres
    for x, y, z in combinaisons:                # Chaque nombre est une fois la somme et 2 fois l'un des nombres additionné
        somme = nombres[y] + nombres[z]
        if nombres[x] == somme:
            return somme                        # Si un nombre est la somme des 2 autres alors on renvoie la somme
    return 0                                    # Si aucun n'est la somme, on renvoie 0

# 1- Tests

import doctest
doctest.testmod()

# 2- Lecture des entrées

nombres = list(map(int,input().split()))

# 3- Appel de la fonction / Sortie

print(détermine_somme(nombres))

• Bonne idée de jouer avec les indices ; tu as réussi à factoriser le code. Tu aurais pu utiliser aussi les indices négatifs, c'était encore plus simple.

Proposition 9

def trois_nb (nb1 : int, nb2 : int, nb3 : int) -> int :
    """ Si l'un des entier est égal à la somme des deux autres, 
    la fonction renvoie cet entier, 0 sinon.

    >>> nb1, nb2, nb3 = 18, 42, 24
    >>> trois_nb(nb1, nb2, nb3)
    42

    >>> nb1, nb2, nb3 = 11, 37, 18
    >>> trois_nb(nb1, nb2, nb3)
    0

    """
    sortie = 0
    somme1 = nb2 + nb3
    somme2 = nb1 + nb3
    somme3 = nb1 + nb2
    if somme1 == nb1 :
        sortie = nb1
    if somme2 == nb2 :
        sortie = nb2
    if somme3 == nb3 :
        sortie = nb3
    return sortie

# tests
import doctest
doctest.testmod()

# Entrée
entiers = list(map(int, input().split()))
nb1 = entiers[0]
nb2 = entiers[1]
nb3 = entiers[2]

# Sortie
print(trois_nb(nb1, nb2, nb3))

• C'est bien, il n'y a qu'un seul print et un seul return, mais on peut encore factoriser le code.

Corrigé du professeur

"""
auteur : Franck CHAMBON
https://prologin.org/train/2003/qualification/les_trois_nombres
"""

def égal_somme_des_autres(nombres: list[int]) -> int:
    """Renvoie le nombre si égal à la somme des autres,
    sinon renvoie 0.

    >>> égal_somme_des_autres([18, 42, 24])
    42

    >>> égal_somme_des_autres([11, 37, 18])
    0

    """
    somme = sum(nombres)
    for n in nombres:
        if 2 * n == somme:
            return n
    return 0

import doctest
doctest.testmod()

nombres = list(map(int, input().split()))

print(égal_somme_des_autres(nombres))

• On passe la liste des nombres en paramètres, c'est plus efficace que de passer chacun des trois nombres.
• Si la somme de deux nombres est égale au troisième, alors (et c'est équivalent) la somme des trois est égale au double du troisième.
  $$x + y = z \iff x + y + z = 2z$$