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 de pistes 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ées 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 [B01-Tableaux] avec le nom donné à l'exercice : ProgB01.51.py, ProgB01.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()

ProgB01.51☘

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

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    def tab_somme(tab1, tab2):
    """
    tab1, tab2 – list, tableaux d'entiers de même longueur
    Sortie: list – tableau des sommes des éléments de tab1 et tab2 
            ayant le même indice
    >>> tab_somme([1, 2, 4, 8], [1, 2, 3, 4])
    [2, 4, 7, 12]
    >>> tab_somme([0, 0, 1, 1], [1, 0, 1, 0])
    [1, 0, 2, 1]
    """

    Une piste

    Parcourir le premier tableau et comparez l'élément parcouru avec l'élément correspondant du deuxième tableau.

    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
    def tab_somme(tab1, tab2):
    """
    tab1, tab2 – list, tableaux d'entiers de même longueur
    Sortie: list – tableau des sommes des éléments de tab1 et tab2 
            ayant le même indice
    >>> tab_somme([1, 2, 4, 8], [1, 2, 3, 4])
    [2, 4, 7, 12]
    >>> tab_somme([0, 0, 1, 1], [1, 0, 1, 0])
    [1, 0, 2, 1]
    """
    result = []
    for i in range(len(tab1)):
        result.append(tab1[i] + tab2[i])
    return result

  2. Améliorez la fonction précédente pour qu'elle agisse même lorsque les tableaux tab1 et tab2 n'ont pas la même longueur. On considérera que les éléments manquants sont nuls.

    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    def tab_somme(tab1, tab2):
    """
    tab1, tab2 – list, tableaux d'entiers de même longueur
    Sortie: list – tableau des sommes des éléments de tab1 et tab2 
            ayant le même indice
    >>> tab_somme([1, 2, 4, 8], [1, 2, 3, 4])
    [2, 4, 7, 12]
    >>> tab_somme([0, 0, 1, 1], [1, 0, 1, 0])
    [1, 0, 2, 1]
    >>> tab_somme([0, 0, 1, 1], [1, 0, 1, 0, 3, 4])
    [1, 0, 2, 1, 3, 4]
    """
    result = []
    if len(tab1) > len(tab2):
        for i in range(len(tab2)):
            result.append(tab1[i] + tab2[i])
        for i in range(len(tab2), len(tab1)):
            result.append(tab1[i])
    else:
        for i in range(len(tab1)):
            result.append(tab1[i] + tab2[i])
        for i in range(len(tab1), len(tab2)):
            result.append(tab2[i])
    return result

ProgB01.52☘

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

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    def hamming(tab1, tab2):
    """
    tab1, tab2 – list, tableaux de même longueur
    Sortie: int – nombre d'indices i pour lesquels tab1[i]
            est différent de tab2[i]
    >>> hamming([1, 2, 4, 8], [1, 2, 3, 4])
    2
    >>> hamming([0, 0, 1, 1], [1, 0, 1, 0])
    2
    """

    Une piste

    Parcourir le premier tableau et comparez l'élément parcouru avec l'élément correspondant du deuxième tableau.

    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
    def hamming(tab1, tab2):
    """
    tab1, tab2 – list, tableaux de même longueur
    Sortie: int – nombre d'indices i pour lesquels tab1[i]
            est différent de tab2[i]
    >>> hamming([1, 2, 4, 8], [1, 2, 3, 4])
    2
    >>> hamming([0, 0, 1, 1], [1, 0, 1, 0])
    2
    """
    nb_diff = 0
    for i in range(len(tab1)):
        if tab1[i] != tab2[i]:
            nb_diff += 1
    return nb_diff

  2. Améliorez la fonction précédente pour qu'elle accepte des tableaux de longueur différente.
    Les éléments d'un tableau n'ayant pas de correspondant dans l'autre tableau sont comptés comme une différence.

    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    def hamming(tab1, tab2):
    """
    tab1, tab2 – list, tableaux de même longueur
    Sortie: int – nombre d'indices i pour lesquels tab1[i]
            est différent de tab2[i]
    >>> hamming([1, 2, 4, 8, 3, 4], [1, 2, 3, 4])
    4
    >>> hamming([0, 0, 1, 1], [1, 0, 1, 0])
    2
    >>> hamming([0, 0, 1, 1], [1, 0, 1, 0, 0])
    3
    """
    long1 = len(tab1)
    long2 = len(tab2)
    if long1 > long2:
        nb_diff = long1 - long2
        taille = long2
    else:
        nb_diff = long2 - long1
        taille = long1
    for i in range(taille):
        if tab1[i] != tab2[i]:
            nb_diff += 1
    return nb_diff

ProgB01.53☘

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def consecutifs(tab, val1, val2):
    """
    tab – list, tableau d'entiers
    val1, val2 – int
    Sortie: booléen – True si val1 et val2 sont des éléments
            consecutifs de tab (dans cet ordre), False sinon
    >>> consecutifs([1, 2, 4, 8], 2, 4)
    True
    >>> consecutifs([1, 2, 4, 8], 2, 8)
    False
    >>> consecutifs([1, 2, 4, 8], 4, 2)
    False
    """
Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
def consecutifs(tab, val1, val2):
    """
    tab – list, tableau d'entiers
    val1, val2 – int
    Sortie: booléen – True si val1 et val2 sont des éléments
            consecutifs de tab (dans cet ordre), False sinon
    >>> consecutifs([1, 2, 4, 8], 2, 4)
    True
    >>> consecutifs([1, 2, 4, 8], 2, 8)
    False
    >>> consecutifs([1, 2, 4, 8], 4, 2)
    False
    """
    for i in range(len(tab)-1):
        if tab[i] == val1 and tab[i+1] == val2:
            return True
    return False

ProgB01.54☘

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def successifs(tab, val1, val2):
    """
    tab – list, tableau d'entiers
    val1, val2 – int
    Sortie: booléen – True si val1 et val2 sont des éléments de tab
            dans cet ordre  (pas forcément consécutifs), False sinon
    >>> successifs([1, 2, 4, 8], 2, 4)
    True
    >>> successifs([1, 2, 4, 8], 2, 8)
    True
    >>> successifs([1, 2, 4, 8], 4, 2)
    False
    """
Une solution
 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
def successifs(tab, val1, val2):
    """
    tab – list, tableau d'entiers
    val1, val2 – int
    Sortie: booléen – True si val1 et val2 sont des éléments de tab
            dans cet ordre  (pas forcément consécutifs), False sinon
    >>> successifs([1, 2, 4, 8], 2, 4)
    True
    >>> successifs([1, 2, 4, 8], 2, 8)
    True
    >>> successifs([1, 2, 4, 8], 4, 2)
    False
    """
    indice = 0
    while indice <= len(tab)-1 and tab[indice] != val1:
        indice += 1
    if indice == len(tab):
        return False
    else:
        while indice < len(tab)-1 and tab[indice] != val2:
            indice +=1

        if tab[indice] == val2:
            return True
        else:
            return False

ProgB01.55☘

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

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    def prefixe(tab1, tab2):
    """
    tab1, tab2 – list, deux tableaux
    Sortie: bool – True si tab1 commence par les éléments de tab2 dans le même ordre.
    >>> prefixe([1, 2, 4, 8], [1, 2])
    True
    >>> prefixe([1, 2, 4, 8], [4, 8])
    False
    >>> prefixe([1, 2, 4, 8], [1, 2, 4, 8, 0])
    False
    """
    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
    def prefixe(tab1, tab2):
    """
    tab1, tab2 – list, deux tableaux
    Sortie: bool – True si tab1 commence par les éléments de tab2 dans le même ordre.
    >>> prefixe([1, 2, 4, 8], [1, 2])
    True
    >>> prefixe([1, 2, 4, 8], [4, 8])
    False
    >>> prefixe([1, 2, 4, 8], [1, 2, 4, 8, 0])
    False
    """
    if len(tab2) > len(tab1):
        return False
    for i in range(len(tab2)):
        if tab1[i] != tab2[i]:
            return False
    return True

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

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    def suffixe(tab1, tab2):
    """
    tab1, tab2 – list, deux tableaux
    Sortie: bool – True si tab1 termine par les éléments de tab2 dans le même ordre.
    >>> suffixe([1, 2, 4, 8], [1, 2])
    False
    >>> suffixe([1, 2, 4, 8], [4, 8])
    True
    >>> suffixe([1, 2, 4, 8], [1, 2, 4, 8, 0])
    False
    """
    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
    def suffixe(tab1, tab2):
    """
    tab1, tab2 – list, deux tableaux
    Sortie: bool – True si tab1 termine par les éléments de tab2 dans le même ordre.
    >>> suffixe([1, 2, 4, 8], [1, 2])
    False
    >>> suffixe([1, 2, 4, 8], [4, 8])
    True
    >>> suffixe([1, 2, 4, 8], [1, 2, 4, 8, 0])
    False
    """
    if len(tab2) > len(tab1):
        return False
    dernier1 = len(tab1)-1
    dernier2 = len(tab2)-1
    for i in range(len(tab2)):
        if tab1[dernier1-i] != tab2[dernier2-i]:
            return False
    return True

ProgB01.56☘

La suite de Fibonacci est définie ainsi :

  • on part des entiers 0 et 1
  • puis on construit chaque nouvel entier comme la somme des deux entiers précédents.

Complétez le corps de la fonction fibo(nb) qui renvoie le tableau des nb premiers entiers construits selon ce principe.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
def fibo(nb):
    """
    nb – int, entier positif ou nul
    Sortie: list – tableau des nb premiers termes de la
             suite de Fibonacci
    >>> fibo(0)
    [0]
    >>> fibo(1)
    [0, 1]
    >>> fibo(7)
    [0, 1, 1, 2, 3, 5, 8]
    """

Vérifiez que le trentième terme est 514 229.

Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
def fibo(nb):
    """
    nb – int, entier positif ou nul
    Sortie: list – tableau des nb premiers termes de la
             suite de Fibonacci
    >>> fibo(0)
    [0]
    >>> fibo(1)
    [0, 1]
    >>> fibo(7)
    [0, 1, 1, 2, 3, 5, 8]
    """
    if nb == 0:
        result = [0]
    elif nb == 1:
        result = [0, 1]
    else:
        result = [0, 1]
        for i in range(2, nb):
            result.append(result[i-1] + result[i-2])
    return result