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 [G02_Algo_Tableaux] avec le nom donné à l'exercice : ProgG02.51.py, ProgG02.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()

ProgG02.51☘

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

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    def decale_gauche_jusqu_a(tab, k):
    """
    tab – list, tableau d'éléments
    k – int, entier compris entre 0 et len(tab)-1
    Sortie: None – Permute à gauche tous les éléments de tab[0..k]
            (fonction à effet de bord)
    >>> tab = [3, 1, 7, 4]
    >>> decale_gauche_jusqu_a(tab, 2)
    >>> tab
    [1, 7, 3, 4]
    """

    Attention

    Les appels suivants doivent générer des erreurs : 

    >>> decale_gauche_jusqu_a([], 5)
AssertionError: Le tableau est vide
>>> decale_gauche_jusqu_a([3, 1, 7, 4], 5)
AssertionError: tab index out of range

    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
    def decale_gauche_jusqu_a(tab, k):
    """
    tab – list, tableau d'éléments
    k – int, entier compris entre 0 et len(tab)-1
    Sortie: None – Permute à gauche tous les éléments de tab[0..k]
            (fonction à effet de bord)
    >>> tab = [3, 1, 7, 4]
    >>> decale_gauche_jusqu_a(tab, 2)
    >>> tab
    [1, 7, 3, 4]
    """
    assert tab != [], "Le tableau est vide"
    assert 0 <= k < len(tab), "tab index out of range"
    temp = tab[0]
    for i in range(k):
        tab[i] = tab[i+1]
    tab[k] = temp

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

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    def decale_gauche_a_partir(tab, k):
    """
    tab – list, tableau d'éléments
    k – int, entier compris entre 0 et len(tab)-1
    Sortie: None – Permute à gauche tous les éléments de tab[k..]
            (fonction à effet de bord)
    >>> tab = [3, 1, 7, 4]
    >>> decale_gauche_a_partir(tab, 1)
    >>> tab
    [3, 7, 4, 1]
    """

    Attention

    Les appels suivants doivent générer des erreurs : 

    >>> decale_gauche_a_partir([], 5)
AssertionError: Le tableau est vide
>>> decale_gauche_a_partir([3, 1, 7, 4], 5)
AssertionError: tab index out of range

    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
    def decale_gauche_a_partir(tab, k):
    """
    tab – list, tableau d'éléments
    k – int, entier compris entre 0 et len(tab)-1
    Sortie: None – Permute à gauche tous les éléments de tab[k..]
            (fonction à effet de bord)
    >>> tab = [3, 1, 7, 4]
    >>> decale_gauche_a_partir(tab, 1)
    >>> tab
    [3, 7, 4, 1]
    """
    assert tab != [], "Le tableau est vide"
    assert 0 <= k < len(tab), "tab index out of range"
    temp = tab[k]
    for i in range(k, len(tab)-1):
        tab[i] = tab[i+1]
    tab[len(tab)-1] = temp

ProgG02.52☘

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

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    def decale_droite_jusqu_a(tab, k):
    """
    tab – list, tableau d'éléments
    k – int, entier compris entre 0 et len(tab)-1
    Sortie: None – Permute à droite tous les éléments de tab[0..k]
            (fonction à effet de bord)
    >>> tab = [3, 1, 7, 4]
    >>> decale_droite_jusqu_a(tab, 2)
    >>> tab
    [7, 3, 1, 4]
    """

    Attention

    Les appels suivants doivent générer des erreurs : 

    >>> decale_droite_jusqu_a([], 5)
AssertionError: Le tableau est vide
>>> decale_droite_jusqu_a([3, 1, 7, 4], 5)
AssertionError: tab index out of range

    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
    def decale_droite_jusqu_a(tab, k):
    """
    tab – list, tableau d'éléments
    k – int, entier compris entre 0 et len(tab)-1
    Sortie: None – Permute à droite tous les éléments de tab[0..k]
            (fonction à effet de bord)
    >>> tab = [3, 1, 7, 4]
    >>> decale_droite_jusqu_a(tab, 2)
    >>> tab
    [7, 3, 1, 4]
    """
    assert tab != [], "Le tableau est vide"
    assert 0 <= k < len(tab), "tab index out of range"
    temp = tab[k]
    for i in range(k):
        tab[k-i] = tab[k-i-1]
    tab[0] = temp

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

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    def decale_droite_a_partir(tab, k):
    """
    tab – list, tableau d'éléments
    k – int, entier compris entre 0 et len(tab)-1
    Sortie: None – Permute à droite tous les éléments de tab[k..]
            (fonction à effet de bord)
    >>> tab = [3, 1, 7, 4]
    >>> decale_droite_a_partir(tab, 1)
    >>> tab
    [3, 4, 1, 7]
    """

    Attention

    Les appels suivants doivent générer des erreurs : 

    >>> decale_droite_a_partir([], 5)
AssertionError: Le tableau est vide
>>> decale_droite_a_partir([3, 1, 7, 4], 5)
AssertionError: tab index out of range

    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
    def decale_droite_a_partir(tab, k):
    """
    tab – list, tableau d'éléments
    k – int, entier compris entre 0 et len(tab)-1
    Sortie: None – Permute à droite tous les éléments de tab[k..]
            (fonction à effet de bord)
    >>> tab = [3, 1, 7, 4]
    >>> decale_droite_a_partir(tab, 1)
    >>> tab
    [3, 4, 1, 7]
    """
    assert tab != [], "Le tableau est vide"
    assert 0 <= k < len(tab), "tab index out of range"
    temp = tab[len(tab)-1]
    for i in range(len(tab)-1, k, -1):
        tab[i] = tab[i-1]
    tab[k] = temp

ProgG02.53☘

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

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
    def est_trie_jusqu_a(tab, k):
    """
    tab – list, tableau d'éléments comparables
    k – int, entier compris entre 0 et len(tab)-1
    Sortie: bool – True si tab[0..k] est trié par ordre croissant,
            False sinon
    >>> est_trie_jusqu_a([2, 5, 6, 3, 4], 2)
    True
    >>> est_trie_jusqu_a([2, 5, 6, 3, 4], 3)
    False
    >>> est_trie_jusqu_a([2, 3, 4, 5, 6], 4)
    True
    """

    Attention

    L'appel suivant doit générer une erreurs : 

    >>> est_trie_jusqu_a([3, 1, 7, 4], 5)
AssertionError: tab index out of range

    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
    def est_trie_jusqu_a(tab, k):
    """
    tab – list, tableau d'éléments comparables
    k – int, entier compris entre 0 et len(tab)-1
    Sortie: bool – True si tab[0..k] est trié par ordre croissant,
            False sinon
    >>> est_trie_jusqu_a([2, 5, 6, 3, 4], 2)
    True
    >>> est_trie_jusqu_a([2, 5, 6, 3, 4], 3)
    False
    >>> est_trie_jusqu_a([2, 3, 4, 5, 6], 4)
    True
    """
    assert 0 <= k < len(tab), "tab index out of range"
    for i in range(k):
        if tab[i] > tab[i+1]:
            return False
    return True

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

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
    def est_trie_a_partir(tab, k):
    """
    tab – list, tableau d'éléments comparables
    k – int, entier compris entre 0 et len(tab)-1
    Sortie: bool – True si tab[k..] est trié par ordre croissant,
            False sinon
    >>> est_trie_a_partir([2, 5, 6, 3, 4], 2)
    False
    >>> est_trie_a_partir([2, 5, 6, 3, 4], 3)
    True
    >>> est_trie_a_partir([2, 3, 4, 5, 6], 4)
    True
    """

    Attention

    L'appel suivant doit générer une erreurs : 

    >>> est_trie_a_partir([3, 1, 7, 4], 5)
AssertionError: tab index out of range

    Une solution
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
    def est_trie_a_partir(tab, k):
    """
    tab – list, tableau d'éléments comparables
    k – int, entier compris entre 0 et len(tab)-1
    Sortie: bool – True si tab[k..] est trié par ordre croissant,
            False sinon
    >>> est_trie_a_partir([2, 5, 6, 3, 4], 2)
    False
    >>> est_trie_a_partir([2, 5, 6, 3, 4], 3)
    True
    >>> est_trie_a_partir([2, 3, 4, 5, 6], 4)
    True
    """
    assert 0 <= k < len(tab), "tab index out of range"
    for i in range(k, len(tab)-1):
        if tab[i] > tab[i+1]:
            return False
    return True