Aller au contenu

Exercices d'entraînement☘

Ces exercices doivent être utilisés pour vous entraîner à programmer. Ils sont généralement accompagnés d'aide et de leur solution pour vous permettre de progresser.

Avant de vous précipiter sur ces solutions dès la première difficulté, n'oubliez pas les conseils suivants :

  • Avez-vous bien fait un schéma au brouillon pour visualiser le problème posé ?
  • Avez-vous essayé de rédiger un algorithme en français, avec vos propres mots, avant de vous lancer dans la programmation sur machine ?
  • Avez-vous utilisé des affichages intermédiaires, des print(), pour visualiser au fur et à mesure le contenu des variables ?
  • Avez-vous testé le programme avec les propositions de tests donnés dans l'exercice ?
  • Avez-vous testé le programme avec de nouveaux tests, différents de ceux proposés et placés dans le « main » ?
Rappels
  • Chaque programme Python doit être sauvegardé sous forme de fichier texte avec l'extension .py.
    Enregistrez ce fichier dans le dossier [B02-T-uplet] avec le nom donné à l'exercice : ProgB02.51.py, ProgB02.52.py, etc...
  • Pour exécuter ce programme, il suffit de le sauvegarder puis d'appuyer sur la touche [F5].
  • Le programme principal doit contenir un appel au module doctest : 
    ##----- Programme principal et tests -----##
if __name__ == '__main__':
    import doctest
    doctest.testmod()

ProgB02.51☘

  1. Copiez/collez et complétez le corps de la fonction temps_secondes() qui renvoie le temps en secondes correspondant au cumul de h heures, m minutes et s secondes. 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    def temps_seconde(h, m, s):
    """
    h, m, s – int, triplet d’entiers positifs
    Sortie: int – temps en secondes égal à h heures,
            m minutes et s secondes
    >>> temps_seconde(1, 2, 3)
    3723
    >>> temps_seconde(2, 0, 1)
    7201
    """

    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
    def temps_seconde(h, m, s):
    """
    h, m, s – int, triplet d’entiers positifs
    Sortie: int – temps en secondes égal à h heures,
            m minutes et s secondes
    >>> temps_seconde(1, 2, 3)
    3723
    >>> temps_seconde(2, 0, 1)
    7201
    """
    return h*3600 + m*60 + s

if __name__ == '__main__':
    import doctest
    doctest.testmod()

  2. Copiez/collez et complétez le corps de la fonction a fonction sec_to_heure() qui prend pour paramètre un nombre entier de secondes et qui renvoie la valeur correspondante sous forme d'un triplet (heures, minutes, secondes). 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    def sec_to_heure(s):
    """
    s – int
    Sortie: triplet – conversion de s secondes en un
            triplet (heure, minute, seconde)
    >>> sec_to_heure(3723)
    (1, 2, 3)
    >>> sec_to_heure(7201)
    (2, 0, 1)
    """

    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
    def sec_to_heure(s):
    """
    s – int
    Sortie: triplet – conversion de s secondes en un
            triplet (heure, minute, seconde)
    >>> sec_to_heure(3723)
    (1, 2, 3)
    >>> sec_to_heure(7201)
    (2, 0, 1)
    """
    h = s//3600
    reste = s%3600
    m = reste//60
    s = reste%60
    return h, m, s


if __name__ == '__main__':
    import doctest
    doctest.testmod()
    Une autre solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
    def sec_to_heure(s):
    """
    s – int
    Sortie: triplet – conversion de s secondes en un
            triplet (heure, minute, seconde)
    >>> sec_to_heure(3723)
    (1, 2, 3)
    >>> sec_to_heure(7201)
    (2, 0, 1)
    """
    h = s//3600
    m = (s%3600)//60
    s = (s%3600) % 60
    return h, m, s


if __name__ == '__main__':
    import doctest
    doctest.testmod()

ProgB02.52☘

Copiez/collez et complétez le corps de la fonction coincidence() en respectant ses spécifications. 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
def coincidence(t):
    """
    t – tuple, t-uplet d'entiers positifs ou nuls
    Sortie: int – nombre de valeurs égales à leur indice
    >>> coincidence( (3, 2, 6) )
    0
    >>> coincidence( (3, 1, 6) )
    1
    >>> coincidence( (0, 1, 6, 3) )
    3
    """

Une piste

Parcourir le t-uplet et comparer l'élément parcouru avec son indice.

Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
def coincidence(t):
    """
    t – tuple, t-uplet d'entiers positifs ou nuls
    Sortie: int – nombre de valeurs égales à leur indice
    >>> coincidence( (3, 2, 6) )
    0
    >>> coincidence( (3, 1, 6) )
    1
    >>> coincidence( (0, 1, 6, 3) )
    3
    """
    nb_coincidences = 0
    for i in range(len(t)):
        if t[i] == i:
            nb_coincidences = nb_coincidences+1
    return nb_coincidences


if __name__ == '__main__':
    import doctest
    doctest.testmod()

ProgB02.53☘

On souhaite définir la fonction fractions_egales(), dont les paramètres sont quatre entiers a, b, c, d et qui renvoie True si les fractions \frac{a}{b} et \frac{c}{d} sont égales, False sinon.

  1. Quelle précondition semble-t-il raisonnable d'imposer ?

    Une solution

    Le dénominateur d'une fraction ne peut pas être nul dont b et d doivent être non nuls.

  2. Copiez/collez et complétez le corps de la fonction fractionsEgales() en n'oubliant pas de faire l'assertion correspondant à la précondition précédente.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
    def fractions_egales(a, b, c, d):
    """
    a, b, c, d – int
    Sortie: booléen – True si les fractions a/b et c/d sont égales,
            False sinon
    >>> fractions_egales(1, 2, 4, 8)
    True
    >>> fractions_egales(3, 9, 12, 36)
    True
    >>> fractions_egales(3, 4, 5, 7)
    False
    """

    Un exemple d'appel qui ne respecte pas la précondition

    >>> fractions_egales(4, 2, 3, 0)
AssertionError: Un dénominateur ne peut pas être nul !
    Une mauvaise solution

    Il ne faut pas comparer les quotients a/b et c/d comme dans le programme ci-dessous. En effet, ces calculs renvoient des flottants qui ne sont pas représentés de manière exacte en machine comme pourraient l'être des fractions en mathématiques.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
    def fractions_egales(a, b, c, d):
    """
    a, b, c, d – int
    Sortie: booléen – True si les fractions a/b et c/d sont égales,
            False sinon
    >>> fractions_egales(1, 2, 4, 8)
    True
    >>> fractions_egales(3, 9, 12, 36)
    True
    >>> fractions_egales(3, 4, 5, 7)
    False
    """
    assert (b != 0) and (d != 0), "Un dénominateur ne peut pas être nul !"
    return a/b == c/d
    Cette particularité sera étudiée de manière plus approfondie dans le chapitre sur la représentation des flottants en machine.

    Une meilleure solution

    Dire que les fractions \frac{a}{b} et \frac{c}{d} sont égales équivaut à dire que les produits a \times d et b \times c sont égaux. 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
    def fractions_egales(a, b, c, d):
    """
    a, b, c, d – int
    Sortie: booléen – True si les fractions a/b et c/d sont égales,
            False sinon
    >>> fractions_egales(1, 2, 4, 8)
    True
    >>> fractions_egales(3, 9, 12, 36)
    True
    >>> fractions_egales(3, 4, 5, 7)
    False
    """
    assert (b != 0) and (d != 0), "Un dénominateur ne peut pas être nul !"
    return a*d == b*c


if __name__ == '__main__':
    import doctest
    doctest.testmod()

ProgB02.54 - Un peu de géométrie☘

On représente un point du plan par le couple (x, y) de ses coordonnées dans un repère orthonormé.

  1. On définit le point N par le couple (3, 7) : 

    N = (3, 7)
    Donnez les instructions qui permettent d'obtenir son abscisse d'une part, son ordonnée d'autre part.

    Une solution

    L'abscisse de N est la première valeur du couple de coordonnées qui représente le point N. On l'obtient grâce à l'instruction N[0].
    De manière analogue, l'ordonnée de N s'obtient grâce à N[1].

  2. Copiez/collez et complétez le corps de la fonction milieu() qui renvoie le couple de coordonnées du point milieu des deux points passés en paramètre.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    def milieu(A, B):
    """
    A – tuple, couple de nombres - coordonnées du premier point
    B – tuple, couple de nombres - coordonnées du second point
    Sortie: tuple – couple des coordonnées du milieu de [AB]
    >>> milieu( (1, 2), (4, 8) )
    (2.5, 5.0)
    >>> milieu( (-5, 7), (3, -2) )
    (-1.0, 2.5)
    """
    Rappel de mathématiques

    L'abscisse du milieu de [AB] est la moyenne des abscisses de A et B...

    Une solution sans déballage
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
    def milieu(A, B):
    """
    A – tuple, couple de nombres - coordonnées du premier point
    B – tuple, couple de nombres - coordonnées du second point
    Sortie: tuple – couple des coordonnées du milieu de [AB]
    >>> milieu( (1, 2), (4, 8) )
    (2.5, 5.0)
    >>> milieu( (-5, 7), (3, -2) )
    (-1.0, 2.5)
    """
    xI = (A[0] + B[0])/2
    yI = (A[1] + B[1])/2
    return xI, yI


if __name__ == '__main__':
    import doctest
    doctest.testmod()
    Une solution avec déballage
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
    def milieu(A, B):
    """
    A – tuple, couple de nombres - coordonnées du premier point
    B – tuple, couple de nombres - coordonnées du second point
    Sortie: tuple – couple des coordonnées du milieu de [AB]
    >>> milieu( (1, 2), (4, 8) )
    (2.5, 5.0)
    >>> milieu( (-5, 7), (3, -2) )
    (-1.0, 2.5)
    """
    xA, yA = A
    xB, yB = B
    xI = (xA + xB)/2
    yI = (yA + yB)/2
    return xI, yI


if __name__ == '__main__':
    import doctest
    doctest.testmod()

  3. Copiez/collez et complétez le corps de la fonction distance() qui renvoie le couple de coordonnées du point milieu des deux points passés en paramètre.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    def distance(A, B):
    """
    A – tuple, couple de nombres - coordonnées du premier point
    B – tuple, couple de nombres - coordonnées du second point
    Sortie: float – longueur du segment [AB]
    >>> distance( (1, 2), (4, 6) )
    5.0
    >>> distance( (-5, 18), (16, -2) )
    29.0
    """
    Rappel de mathématiques

    La formule de la distance est AB = \sqrt{ (x_B-x_A)^2+(y_B-y_A)^2}.
    il faut donc importer la fonction sqrt() du module math...

    Une solution sans déballage
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
    from math import sqrt

def distance(A, B):
    """
    A – tuple, couple de nombres - coordonnées du premier point
    B – tuple, couple de nombres - coordonnées du second point
    Sortie: float – longueur du segment [AB]
    >>> distance( (1, 2), (4, 6) )
    5.0
    >>> distance( (-5, 18), (16, -2) )
    29.0
    """
    carre = (A[0] - B[0])**2 + (A[1] - B[1])**2
    return sqrt(carre)


if __name__ == '__main__':
    import doctest
    doctest.testmod()
    Une solution avec déballage
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
    from math import sqrt

def distance(A, B):
    """
    A – tuple, couple de nombres - coordonnées du premier point
    B – tuple, couple de nombres - coordonnées du second point
    Sortie: float – longueur du segment [AB]
    >>> distance( (1, 2), (4, 6) )
    5.0
    >>> distance( (-5, 18), (16, -2) )
    29.0
    """
    xA, yA = A
    xB, yB = B
    carre = (xB - xA)**2 + (yB - yA)**2
    return sqrt(carre)


if __name__ == '__main__':
    import doctest
    doctest.testmod()