Aller au contenu

Sujet n°12

Sujet original

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

Exercice n°1

Commentaires

Il n'est vraiment pas souhaitable qu'une fonction renvoie des valeurs de type si différents (ici un flottant dans certains cas, une chaîne de caractères dans d'autres).
Le cas du tableau vide devrait conduire à une erreur d'assertion, à programmer dans la fonction.

>>> moyenne([])
Assertion Error 'Le tableau est vide'

Étant donné l'incohérence du premier exercice vis-à-vis des instructions officielles (cf. Commentaires), on propose ci-dessous un exercice plus conforme.

Programmer la fonction somme_pair_impair() prenant en paramètre un tableau non vide d’entiers et qui renvoie la différence entre la somme des entiers pairs de ce tableau et la somme des entiers impairs de ce tableau.

Exemples

>>> somme_pair_impair([5, 3, 8])
0

>>> somme_pair_impair([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
5

>>> somme_pair_impair([])
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
def somme_pair_impair(tab):
    """
    tab - list, tableau non vide d'entiers
    Sortie: int, différence entre la somme des entiers pairs de tab
            et la somme des entiers impairs de tab
    """
    assert isinstance(tab, list), "Le paramètre doit être un tableau"
    assert tab != [], "Tableau vide !"
    somme_pairs = 0
    somme_impairs = 0
    for elt in tab:
        if elt%2 == 0:
            somme_pairs += elt
        else:
            somme_impairs += elt
    return somme_pairs - somme_impairs

if __name__ == '__main__':
    tab = [5, 3, 8]
    print(somme_pair_impair(tab) == 0)

    tab = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    print(somme_pair_impair(tab) == 5)

Exercice n°2

On considère un tableau d'entiers tab (type list dont les éléments sont des 0 ou des 1). On se propose de trier ce tableau selon l'algorithme suivant : à chaque étape du tri, le tableau est constitué de trois zones consécutives, la première ne contenant que des 0, la seconde n'étant pas triée et la dernière ne contenant que des 1.

Zone de 0 Zone non triée Zone de 1

Tant que la zone non triée n'est pas réduite à un seul élément, on regarde son premier élément :

  • si cet élément vaut 0, on considère qu'il appartient désormais à la zone ne contenant que des 0 ;
  • si cet élément vaut 1, il est échangé avec le dernier élément de la zone non triée et on considère alors qu’il appartient à la zone ne contenant que des 1.

Dans tous les cas, la longueur de la zone non triée diminue de 1.

Recopier sous Python en la complétant la fonction tri suivante :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def tri(tab):
    # i est le premier indice de la zone non triee, j le dernier indice.
    # Au debut, la zone non triee est le tableau entier.
    i = ...
    j = ...
    while i != j :
        if tab[i] == 0:
            i = ...
        else :
            valeur = tab[j]
            tab[j] = ...
            ...
            j = ...
    ...
Commentaire sur le code original

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

Exemple

>>> tri([0, 1, 0, 1, 0, 1, 0, 1, 0])
[0, 0, 0, 0, 0, 1, 1, 1, 1]
Une réponse

Vous devez compléter les pointillés, mais rien n'interdit d'ajouter d'autres instructions, voire de définir des fonctions supplémentaires.
Dans cet exercice, il est vraiment conseillé de « dérouler » l'algorithme sur un exemple AVANT de se lancer dans la programmation.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def tri(tab):
    # i est le premier indice de la zone non triée,
    # j le dernier indice de cette zone.
    # Au début, la zone non triée est le tableau entier.
    i = 0
    j = len(tab)-1
    while i != j :
        if tab[i] == 0:
            i = i+1
        else :
            valeur = tab[j]
            tab[j] = 1
            tab[i] = valeur
            j = j-1
    return tab


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

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