Aller au contenu

Sujet n°26

Sujet original

Pour télécharger l'énoncé original, cliquer ici.

Exercice n°1

Écrire le code d’une fonction indice_du_min() qui prend en paramètre un tableau d’entiers non trié tab, et qui renvoie l'indice de la première occurrence du minimum de ce tableau. Les tableaux seront représentés sous forme d’objets de type list en Python.

Commentaires
  1. Dans le sujet original, la fonction se nomme RechercheMin(), ce qui pourrait faire croire que c'est la valeur du minimum qui est recherchée, plutôt que la valeur de son indice.

  2. De plus, rien n'est indiqué pour les tableaux vides. Profitez-en pour programmer une assertion telle que celle ajoutée dans l'exemple ci-dessous.

Exemples

>>> indice_du_min([5])
0

>>> indice_du_min([2, 4, 1])
2

>>> indice_du_min([5, 3, 1, 1, 4])
2

>>> indice_du_min([])
AssertionError: tableau vide !
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 indice_du_min(tab):
    """
    tab - list, tableau non vide d'entiers
    Sortie: int, indice de la première occurrence du minimum dans tab
    """
    assert isinstance(tab, list), "Le paramètre doit être un tableau"
    assert tab != [], "Tableau vide !"
    indice_du_min = 0
    for i in range(len(tab)):
        if tab[i] < tab[indice_du_min]:
            indice_du_min = i
    return indice_du_min

if __name__ == '__main__':
    tab = [5]
    print(indice_du_min(tab) == 0)

    tab = [2, 4, 1]
    print(indice_du_min(tab) == 2)

    tab = [5, 3, 1, 1, 4]
    print(indice_du_min(tab) == 2)

    indice_du_min([])

Exercice n°2

On considère la fonction separe() ci-dessous qui prend en argument un tableau tab dont les éléments sont des 0 et des 1. Cette fonction renvoie un nouveau tableau qui contient les mêmes éléments en plaçant les 0 en début de tableau et les 1 à la suite.

1
2
3
4
5
6
7
8
def separe(tab):
    result = []
    for ... in ...:
        if elt == 0:
            ...
        else:
            ...
    ...

Compléter le code de cette fonction.

Commentaires sur le code original

Pour télécharger l'original du fichier à compléter, cliquer ici.

Dans le code original, on raisonne par effet de bord tout en renvoyant le tableau d'origine, ce qui peut conduire à des comportements indésirables.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
def separe(tab):
    i = 0
    j = ...
    while i < j :
        if tab[i] == 0 :
            i = ...
        else :
            tab[i], tab[j] = ...
            j = ...
    return tab

Le code modifié propose plutôt un parcours de tableau construisant un nouveau tableau qui, lui, sera renvoyé.

Exemples

>>> separe([1, 0, 1, 0, 1, 0, 1, 0])
[0, 0, 0, 0, 1, 1, 1, 1]

>>> separe([1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1])
[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]
Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
def separe(tab):
    result = []
    for elt in tab:
        if elt == 0:
            result = [0]+result
        else:
            result.append(1)
    return result


if __name__ == '__main__':
    tab = [1, 0, 1, 0, 1, 0, 1, 0]
    print(separe(tab) == [0, 0, 0, 0, 1, 1, 1, 1])

    tab = [1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1]
    print(separe(tab) == [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1])