Aller au contenu

Sujet n°31

Sujet original

Pour télécharger l'énoncé original, cliquer ici.

Exercice n°1

Écrire en langage Python une fonction recherche prenant comme paramètres une variable a de type numérique (float ou int) et un tableau t (type list) et qui renvoie le nombre d'occurrences de a dans t.

Commentaires

Nommer des variables a ou t sans lien avec leur signification (avec ce qu'elles représentent) n'est vraiment pas un exemple à suivre...

De plus, le nom de cette fonction recherche n'est pas explicite puisqu'elle renvoie le nombre d'occurrences d'éléments dans un tableau (qui n'a pas à se restreindre à des nombres).

Exemples d'utilisations de la fonction recherche

>>> recherche(5, []) 
0 
>>> recherche(5, [-2, 3, 4, 8]) 
0 
>>> recherche(5, [-2, 3, 1, 5, 3, 7, 4]) 
1 
>>> recherche(5, [-2, 5, 3, 5, 4, 5]) 
3 
Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
def recherche(a, t):
    """
    a - int ou float
    t - list, tableau d'entiers ou de flottants
    Sortie: int, nombre d'occurences de a dans t
    """
    compte = 0
    for elt in t:
        if elt == a:
            compte += 1
    return compte


if __name__ == '__main__':
    print(recherche(5, []) == 0)
    print(recherche(5, [-2, 3, 4, 8]) == 0)
    print(recherche(5, [-2, 3, 1, 5, 3, 7, 4]) == 1)
    print(recherche(5, [-2, 5, 3, 5, 4, 5]) == 3)

Exercice n°2

La fonction rendu_monnaie_centimes prend en paramètres deux nombres entiers positifs s_due et s_versee et elle permet de procéder au rendu de monnaie de la différence s_versee – s_due pour des achats effectués avec le système de pièces de la zone Euro. On utilise pour cela un algorithme qui commence par rendre le maximum de pièces de plus grandes valeurs et ainsi de suite. La fonction renvoie la liste des pièces qui composent le rendu.

Toutes les sommes sont exprimées en centimes d’euros. Les valeurs possibles pour les pièces sont donc [1, 2, 5, 10, 20, 50, 100, 200].

Ainsi, l’instruction rendu_monnaie_centimes(452, 500) renverra la liste [20, 20, 5, 2, 1].
En effet, la somme à rendre est de 48 centimes soit 20 + 20 + 5 + 2 + 1.

Le code de la fonction est donné ci-dessous :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def rendu_monnaie_centimes(s_due, s_versee):
    pieces = [1, 2, 5, 10, 20, 50, 100, 200]
    rendu = ...
    a_rendre = ...
    i = len(pieces) - 1
    while a_rendre > ... :
        if pieces[i] <= a_rendre :
            rendu.append(...)
            a_rendre = ...
        else :
            i = ...
    return rendu

Compléter ce code pour qu’il donne :

Exemples

>>> rendu_monnaie_centimes(700, 700) 
[] 
>>> rendu_monnaie_centimes(112, 500) 
[200, 100, 50, 20, 10, 5, 2, 1] 
Commentaires sur le code original
  1. Pour télécharger l'original du fichier à compléter, cliquer ici.

  2. C'est une application « classique » des algorithmes gloutons, même s'il est présenté sous une forme inutilement compliquée.

  3. Le mot « liste » est encore à comprendre dans le sens « liste Python » (c'est-à-dire tableau) plutôt que dans le sens du type abstrait de données liste étudié en Terminale.

  4. Il manque des exemples où on utilise plusieurs fois la même pièce.

Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
def rendu_monnaie_centimes(s_due, s_versee):
    pieces = [1, 2, 5, 10, 20, 50, 100, 200]
    rendu = []
    a_rendre = s_versee - s_due
    i = len(pieces) - 1
    while a_rendre > 0 :
        if pieces[i] <= a_rendre :
            rendu.append(pieces[i])
            a_rendre = a_rendre - pieces[i]
        else :
            i = i-1
    return rendu


if __name__ == '__main__':
    print(rendu_monnaie_centimes(700, 700) == [])
    print(rendu_monnaie_centimes(112, 500) == [200, 100, 50, 20, 10, 5, 2, 1])
    print(rendu_monnaie_centimes(9, 300) == [200, 50, 20, 20, 1])