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 [F04-Portee des variables] avec le nom donné à l'exercice : ProgF04.51.py, ProgF04.52.py, etc...
  • Pour exécuter ce programme, il suffit de le sauvegarder puis d'appuyer sur la touche [F5].
  • Le programme principal peut contenir un appel au module doctest : 
    ##----- Programme principal et tests -----##
if __name__ == '__main__':
    import doctest
    doctest.testmod()

ProgF04.51 - Complémentaires☘

Complétez la définition de la fonction complement() qui prend pour paramètre un tableau non vide tab d'entiers valant uniquement 0 ou 1.
Cette fonction est à effet de bord, c'est-à-dire qu'elle ne renvoie rien mais modifie le tableau passé en paramètre en remplaçant chaque 0 par un 1 et chaque 1 par un 0.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def complement(tab):
    """
    tab - list, tableau d'entiers valant uniquement 0 ou 1
    Sortie: None - modifie le tableau passé en paramètre
            en remplaçant chaque 0 par un 1 et chaque 1 par un 0
            (fonction à effet de bord, ne renvoie rien)
    >>> T = [0, 1, 0, 0]
    >>> complement(T)
    >>> T
    [1, 0, 1, 1]
    >>> complement(T)
    >>> T
    [0, 1, 0, 0]
    """
Une première solution

Elle doit ressembler à ce que vous avez programmé. Pensez à étudier la seconde solution proposée. 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
def complement(tab):
    """
    tab - list, tableau d'entiers valant uniquement 0 ou 1
    Sortie: None - modifie le tableau passé en paramètre
            en remplaçant chaque 0 par un 1 et chaque 1 par un 0
            (fonction à effet de bord)
    >>> T = [0, 1, 0, 0]
    >>> complement(T)
    >>> T
    [1, 0, 1, 1]
    >>> complement(T)
    >>> T
    [0, 1, 0, 0]
    """
    assert tab != [], "Le tableau passé en argument ne doit pas être vide !"
    for i in range(len(tab)):
        if tab[i] == 0:
            tab[i] = 1
        else:
            tab[i] = 0


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

    T = [1, 1, 0, 1]
    complement(T)
    print(T == [0, 0, 1, 0])

    T = [0, 0, 0, 0]
    complement(T)
    print(T == [1, 1, 1, 1])
    complement(T)
    print(T == [0, 0, 0, 0])

    T = [1]
    complement(T)
    print(T == [0])

Une seconde solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
def complement(tab):
    """
    tab - list, tableau d'entiers valant uniquement 0 ou 1
    Sortie: None - modifie le tableau passé en paramètre
            en remplaçant chaque 0 par un 1 et chaque 1 par un 0
            (fonction à effet de bord)
    >>> T = [0, 1, 0, 0]
    >>> complement(T)
    >>> T
    [1, 0, 1, 1]
    >>> complement(T)
    >>> T
    [0, 1, 0, 0]
    """
    assert tab != [], "Le tableau passé en argument ne doit pas être vide !"
    for i in range(len(tab)):
        tab[i] = 1-tab[i]


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

ProgF04.52 - Mélange de Knuth☘

Complétez le corps de la fonction melange() qui prend pour paramètre un tableau et qui « mélange » les éléments de ce tableau (fonction avec effet de bord : elle ne renvoie rien).

Pour cela, programmez l'algorithme suivant :

  1. On parcourt le tableau de gauche à droite.

  2. Pour chaque élément d'indice i, on génère un entier aléatoire j entre 0 et i (inclus).

  3. On échange les valeurs des éléments d'indice i et j.

Testez ensuite cette fonction sur des tableaux de votre choix.

1
2
3
4
5
6
def melange(tab):
    """
    tab - list
    Sortie : None - mélange les éléments de tab
             (fonction à effet de bord, ne renvoie rien)
    """

Un exemple d'appel

>>> tab = [2001, 42, 3, 1, 666, 2]
>>> melange(tab)
>>> tab
[42, 2001, 3, 2, 1, 666]
Une piste

On pourra se servir de la fonction echange() programmée dans le TP.

Une solution
1
2
3
4
5
6
7
8
9
def melange(tab):
    """
    tab - list
    Sortie : None - mélange les éléments de tab
             (fonction à effet de bord, ne renvoie rien)
    """
    for i in range(len(tab)):
        j = randint(0, i)
        echange(tab, i, j)

ProgF04.53 - Pair ou impair ?☘

Complétez la définition de la fonction pair_impair() qui prend pour paramètre un tableau tab d'entiers et qui place les entiers pairs de ce tableau en début de tableau et les entiers impairs en fin de tableau (fonction avec effet de bord : elle ne renvoie rien).

Pour cela, programmez l'algorithme suivant :

  1. On initialise les variables gauche à 0 et droite à len(tab)-1.

  2. Si tab[gauche] est pair, on incrémente gauche.

  3. Si tab[droite] est impair, on décrémente droite.

  4. Si tab[gauche] est impair et tab[droite] est pair, on échange leur contenu.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
def pair_impair(tab):
    """
    tab - list, tableau d'entiers
    Sortie: None - place les éléments pairs en début de tableau
            et les éléments impairs en fin de tableau
            (fonction à effet de bord, ne renvoie rien)
    >>> T = [2, 3, 4, 5, 6, 8]
    >>> pair_impair(T)
    >>> T
    [2, 8, 4, 6, 5, 3]
    """
Une piste

On pourra se servir de la fonction echange() programmée dans le TP.

Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
def pair_impair(tab):
    """
    tab - list, tableau d'entiers
    Sortie: None - place les éléments pairs en début de tableau
            et les éléments impairs en fin de tableau
            (fonction à effet de bord, ne renvoie rien)
    >>> T = [2, 3, 4, 5, 6, 8]
    >>> pair_impair(T)
    >>> T
    [2, 8, 4, 6, 5, 3]
    """
    gauche = 0
    droite = len(tab)-1
    while gauche < droite:
        if tab[gauche] % 2 == 0:
            gauche += 1
        if tab[droite] % 2 == 1:
            droite -= 1
        if gauche < droite and tab[gauche] % 2 == 1 and tab[droite] % 2 == 0:
            echange(tab, gauche, droite)
            gauche += 1
            droite -= 1