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 ?

Rappels

  • Chaque programme Python doit être sauvegardé sous forme de fichier texte avec l'extension .py.
    Enregistrez ce fichier dans le dossier [F01-Bases de programmation] avec le nom donné à l'exercice : ProgF01.51.py, ProgF01.52.py, etc...
  • Pour exécuter ce programme, il suffit de le sauvegarder puis d'appuyer sur la touche [F5].

ProgF01.51☘

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

    1
2
3
4
5
6
    def echange(a, b):
    """
    a, b – int ou float
    Sortie: int ou float – la valeur de a va dans b, celle de b va dans a,
            les nouvelles valeurs de a et b sont renvoyées dans cet ordre
    """

  2. Vérifiez et corrigez si besoin votre travail avec l'aide des tests suivants : 

    >>> echange(3, 4)
(4, 3)

>>> echange(5.7, 2.3)
(2.3, 5.7)

Une piste

Avec un verre de grenadine dans la main droite et un verre de menthe à l'eau dans la main gauche, comment faire pour échanger les liquides de verre sans que les liquides ne se mélangent ?

Une autre piste

On introduit une troisième variable, notée temp. Alors :

  • on place la valeur de a dans temp ;
  • on place la valeur de b dans a ;
  • on place la valeur de temp dans b.
Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
def echange(a, b):
    """
    a, b – int ou float
    Sortie: int ou float – la valeur de a va dans b, celle de b va dans a,
            les nouvelles valeurs de a et b sont renvoyées dans cet ordre
    """
    temp = a
    a = b
    b = temp
    return a, b
Une autre solution

Puisque a et b contiennent des nombres, on peut aussi utiliser des opérations algébriques pour effectuer cet échange de valeur. Dans ce cas, il n'est plus nécessaire d'utiliser une variable intermédiaire : 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
def echange(a, b):
    """
    a, b – int ou float
    Sortie: int ou float – la valeur de a va dans b, celle de b va dans a,
            les nouvelles valeurs de a et b sont renvoyées dans cet ordre
    """
    a = a+b
    b = a-b
    a = a-b
    return a, b

Une astuce de Python

Python autorise l'affectation parallèle. On peut donc élaborer le code suivant (qui sera approfondit dans un prochain chapitre) : 

1
2
3
4
5
6
7
8
def echange(a, b):
    """
    a, b – int ou float
    Sortie: int ou float – la valeur de a va dans b, celle de b va dans a,
            les nouvelles valeurs de a et b sont renvoyées dans cet ordre
    """
    a, b = b, a
    return a, b

ProgF01.52☘

En mathématiques, la valeur absolue d'un nombre x est définie par :

| x | = \left \{ \begin{array}{cc} x & \text{lorsque } x \geqslant 0 \\ -x & \text{lorsque } x < 0 \\ \end{array} \right .

  1. Copiez/collez et complétez le corps de la fonction val_abs() qui renvoie la valeur absolue du nombre passé en paramètre. 

    1
2
3
4
5
    def val_abs(x):
    """
    x - int ou float
    Sortie: int ou float – la valeur absolue de x
    """

  2. Vérifiez et corrigez si besoin votre travail avec l'aide des tests suivants : 

    >>> val_abs(3)
3

>>> val_abs(-5.2)
5.2

Une solution
1
2
3
4
5
6
7
8
9
def val_abs(x):
    """
    x - int ou float
    Sortie: int ou float – la valeur absolue de x
    """
    if x >= 0 :
        return x
    else:
        return -x

ProgF01.53☘

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

    1
2
3
4
5
6
7
    def terme(n):
    """
    n – int, entier positif ou nul
    Sortie: int – la valeur de u après n tours de boucle
             dans laquelle u est remplacé par 2*u+3
    """
    u = 1

  2. Vérifiez et corrigez si besoin votre travail avec l'aide des tests suivants : 

    >>> terme(3)
29

>>> terme(14)
65533

Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
def terme(n):
    """
    n – int, entier positif ou nul
    Sortie: int – la valeur de u après n tours de boucle
             dans laquelle u est remplacé par 2*u+3
    """
    u = 1
    for i in range(n):
        u = 2*u+3
    return u

ProgF01.54☘

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

    1
2
3
4
5
    def somme_pairs(n):
    """
    n – int, entier positif ou nul
    Sortie: int – la somme des entiers pairs compris entre 0 et n
    """

  2. Vérifiez et corrigez si besoin votre travail avec l'aide des tests suivants : 

    >>> somme_pairs(3)
2

>>> somme_pairs(14)
56

Une piste

Qu'est-ce qu'un entier pair ?
Réponse : un entier multiple du nombre 2...

Une solution

Dans cette solution, on utilise un pas de 2 dans les valeurs générées par la fonction range() : 

1
2
3
4
5
6
7
8
9
def somme_pairs(n):
    """
    n – int, entier positif ou nul
    Sortie: int – la somme des entiers pairs compris entre 0 et n
    """
    somme = 0
    for i in range(0, n+1, 2):
        somme = somme + i
    return somme

Une autre solution

Dans cette solution, on effectue un test de parité : 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
def somme_pairs(n):
    """
    n – int, entier positif ou nul
    Sortie: int – la somme des entiers pairs compris entre 0 et n
    """
    somme = 0
    for i in range(n+1):
        if i%2 == 0:
            somme = somme + i
    return somme

ProgF01.55☘

Soient a et b deux variables prenant pour valeurs des entiers positifs. L'algorithme ci-dessous permet de déterminer le quotient et le reste de la division entière de a par b :

  • On initialise le quotient à zéro.
  • Tant que a est plus grand que b, le quotient est incrémenté de 1 et on remplace a par a-b.
  • Dès que a devient plus petit que b, le reste est a.
  • On renvoie le quotient et le reste.

Bien évidemment, il est interdit d'utiliser les opérations quotient « // » et modulo « % » dans cet exercice...

  1. Utilisez cet algorithme pour compléter le corps de la fonction quotient_reste(). 

    1
2
3
4
5
6
7
    def quotient_reste(a, b):
    """
    a – int, entiers spositif ou nul
    b - int, entier strictement positif
    Sortie: (int, int) – le premier entier est le quotient de la division entière de a par b,
            l'autre entier est le reste.
    """

  2. Vérifiez et corrigez si besoin votre travail avec l'aide des tests suivants : 

    >>> quotient_reste(14, 3)
(4, 2)

>>> quotient_reste(3, 14)
(0, 3)

  3. Pourquoi l'entier b doit-il être strictement positif comme indiqué dans les spécifications ?

Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def quotient_reste(a, b):
    """
    a – int, entiers spositif ou nul
    b - int, entier strictement positif
    Sortie: (int, int) – le premier entier est le quotient de la division entière de a par b,
            l'autre entier est le reste.
    """
    quotient = 0
    while a >= b:
        quotient = quotient + 1
        a = a-b
    reste = a
    return quotient, reste
Réponse du 3.

En ligne 11 du programme, on trouve : 

11
        a = a-b
Si b vaut zéro, alors la valeur de a reste inchangé après cette ligne et le test de la ligne 9 : 
9
    while a >= b:
restera indéfiniment vrai : la boucle while ne se terminera jamais...

ProgF01.56☘

On appelle PGCD de deux entiers a et b, le Plus Grand Diviseur Commun à ces deux nombres. L'algorithme d'Euclide permet de déterminer ce PGCD :

  • On calcule le reste r de la division de a par b
  • Tant que le reste n'est pas nul, a prend la valeur de b et b, celle de r
  • Le PGCD est le dernier reste non nul.

Dans cet exercice, vous pouvez utiliser les opérations quotient « // » et modulo « % ».

  1. Utilisez cet algorithme pour compléter le corps de la fonction pgcd(). 

    1
2
3
4
5
6
    def pgcd(a, b):
    """
    a – int, entiers spositif ou nul
    b - int, entier strictement positif
    Sortie: int – le PGCD de a et b
    """

  2. Vérifiez et corrigez si besoin votre travail avec l'aide des tests suivants : 

    >>> pgcd(14, 3)
1

>>> pgcd(14, 42)
14

>>> pgcd(64, 24)
8

Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def pgcd(a, b):
    """
    a – int, entiers spositif ou nul
    b - int, entier strictement positif
    Sortie: int – le PGCD de a et b
    """
    r = a%b
    while r != 0:
        a = b
        b = r
        r = a%b
    return b