Aller au contenu

Tableaux

Chaque exercice est fourni avec un fichier Python à compléter et un énoncé « papier » distribué à l'élève et reproduit ci-dessous.

Remarques importantes

  1. Les exercices de cette page ne sont pas classés par ordre de « difficulté », cette notion de difficulté étant subjective et dépendante de chaque élève.

  2. Les solutions proposées ne sont que des propositions !
    Il existe d'autres codes valables pour répondre à chaque problème que ceux proposés ici : il ne faut pas hésiter à les soumettre à votre enseignant pour qu'il vous donne son avis sur les idées mises en oeuvre.

Différence de sommes

Programmer la fonction somme_pair_impair() prenant en paramètre un tableau non vide d'entiers tab (type list) 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 !
  1. Compléter la définition de la fonction somme_pair_impair(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    def somme_pair_impair(tab):
        """
        tab - 
        Sortie: 
        >>> somme_pair_impair([5, 3, 8])
        0
        >>> somme_pair_impair([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
        5
        """
        pass
    
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 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
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 
    >>> somme_pair_impair([5, 3, 8])
    0
    >>> somme_pair_impair([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    5
    """
    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__':
    import doctest
    doctest.testmod()

    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)

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

    somme_pair_impair([])

Moyenne simple

Programmer la fonction moyenne() prenant en paramètre un tableau non vide d'entiers tab (type list) et qui renvoie la moyenne de ses éléments.

Exemples

>>> moyenne([5, 3, 8])
5.333333333333333
>>> moyenne([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
5.5
>>> moyenne([])
AssertionError: Tableau vide !
  1. Compléter la définition de la fonction moyenne(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    def moyenne(tab):
        """
        tab - 
        Sortie: 
        >>> moyenne([5, 3, 8])
        5.333333333333333
        >>> moyenne([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
        5.5
        """
        pass
    
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
def moyenne(tab):
    """
    tab - list, tableau non vide d'entiers
    Sortie: float, moyenne des éléments de tab
    >>> moyenne([5, 3, 8])
    5.333333333333333
    >>> moyenne([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    5.5
    """
    assert len(tab) != 0, "Tableau vide !"
    somme = 0
    for elt in tab:
        somme = somme + elt
    return somme/len(tab)


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

    print(moyenne([14, 3, 4, 2, 15, 4]) == 7.0)    
    print(moyenne([14]) == 14)

Codage par différence

Le codage par différence (« delta encoding » en anglais) permet de compresser un tableau de données en indiquant, pour chaque donnée, sa différence avec la précédente (plutôt que la donnée elle-même). On se retrouve alors avec un tableau de données assez petites nécessitant moins de place en mémoire. Cette méthode se révèle efficace lorsque les valeurs consécutives sont proches.

Programmer la fonction delta() qui prend en paramètre un tableau non vide de nombres entiers et qui renvoie un tableau contenant les valeurs entières compressées à l’aide cette technique.

Exemples

>>> delta([1000, 800, 802, 1000, 1003])
[1000, -200, 2, 198, 3]

>>> delta([42])
[42]

>>> delta([])
AssertionError: Tableau vide !
  1. Compléter la définition de la fonction delta(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    def delta(tab):
        """
        tab - 
        Sortie: 
        >>> delta([1000, 800, 802, 1000, 1003])
        [1000, -200, 2, 198, 3]
        >>> delta([42])
        [42]
        """
        pass
    
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 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
def delta(tab):
    """
    tab - list, tableau non vide d'entiers
    Sortie: list, tableau des différences entre chaque élément de tab et
            l'élément précédent
    >>> delta([1000, 800, 802, 1000, 1003])
    [1000, -200, 2, 198, 3]
    >>> delta([42])
    [42]
    """
    assert len(tab) > 0, 'Tableau vide !'
    diff = [tab[0]]
    for i in range(1, len(tab)):
        diff.append(tab[i] - tab[i-1])
    return diff



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

    from random import randint
    print(delta([729, 183, 672, 134, 65, 451, 968, 277]) == [729, -546, 489, -538, -69, 386, 517, -691])

    t = [randint(0, 1000) for _ in range(8)]
    print(t)
    print(delta(t))

    delta([])

Éléments consécutifs

Écrire le code d'une fonction couples_consécutifs() qui prend en paramètre un tableau de nombres entiers tab, et qui renvoie le tableau (éventuellement vide) des couples d'entiers consécutifs successifs qu'il peut y avoir dans tab.

Exemples

>>> couples_consécutifs([1, 4, 3, 5])
[]

>>> couples_consécutifs([1, 4, 5, 3])
[(4, 5)]

>>> couples_consécutifs([7, 1, 2, 5, 3, 4])
[(1, 2), (3, 4)]

>>> couples_consécutifs([5, 1, 2, 3, 8, -5, -4, 7])
[(1, 2), (2, 3), (-5, -4)]
  1. Compléter la définition de la fonction couples_consécutifs().

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    def couples_consécutifs(tab):
        """
        tab - 
        Sortie: 
        >>> couples_consécutifs([1, 4, 3, 5])
        []
        >>> couples_consécutifs([1, 4, 5, 3])
        [(4, 5)]
        >>> couples_consécutifs([7, 1, 2, 5, 3, 4])
        [(1, 2), (3, 4)]
        >>> couples_consécutifs([5, 1, 2, 3, 8, -5, -4, 7])
        [(1, 2), (2, 3), (-5, -4)]
        """
        pass
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 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
def couples_consécutifs(tab):
    """
    tab - list, tableau de nombres entiers
    Sortie: list - tableau des couples d'entiers consécutifs successifs
            qu'il peut y avoir dans tab.
    >>> couples_consécutifs([1, 4, 3, 5])
    []
    >>> couples_consécutifs([1, 4, 5, 3])
    [(4, 5)]
    >>> couples_consécutifs([7, 1, 2, 5, 3, 4])
    [(1, 2), (3, 4)]
    >>> couples_consécutifs([5, 1, 2, 3, 8, -5, -4, 7])
    [(1, 2), (2, 3), (-5, -4)]
    """
    result = []
    for i in range(len(tab)-1):
        if tab[i+1] == tab[i]+1:
            result.append( (tab[i], tab[i+1]) )
    return result

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

    print(couples_consécutifs([7, 2, 9, 1, 8, 3, 6, 7, 2]) == [(6, 7)])

    from random import randint


    t = [randint(0, 10) for _ in range(8)]
    print(t)
    print(couples_consécutifs(t))

Syracuse

Soit un nombre entier k supérieur ou égal à 1 :

  • s'il est pair, on le divise par 2 ;
  • s’il est impair, on le multiplie par 3 et on ajoute 1.

Puis on recommence ces étapes avec le nombre entier obtenu, jusqu’à ce que l’on obtienne la valeur 1.

On admet que, quel que soit l’entier k choisi au départ, on arrivera forcément sur la valeur 1.

Écrire une fonction syracuse() prenant en paramètres cet entier k strictement positif et qui renvoie le tableau des valeurs successives obtenues, en partant de k et jusqu’à atteindre 1.

Exemple

>>> syracuse(1)
[1]
>>> syracuse(4)
[4, 2, 1]
>>> syracuse(7)
[7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]
  1. Compléter la définition de la fonction syracuse().

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    def syracuse(k):
        """
        k - 
        Sortie: 
        >>> syracuse(1)
        [1]
        >>> syracuse(4)
        [4, 2, 1]
        >>> syracuse(7)
        [7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]
        """
        pass
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible

Rappel : vous pouvez définir des fonctions supplémentaires si vous le souhaitez.

 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
def suivant(k):
    """
    k - int, entier strictement positif
    Sortie: int - k/2 si k est pair, 3*k+1 sinon
    """
    if k%2 == 0:
        return k//2
    else:
        return 3*k+1


def syracuse(k):
    '''
    k - int, entier strictement positif
    Sortie: list - tableau des entiers de k à 1 en suivant le principe de Syracuse 
    >>> syracuse(1)
    [1]
    >>> syracuse(4)
    [4, 2, 1]
    >>> syracuse(7)
    [7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]
    '''
    tab = [k]
    while k != 1:
        k = suivant(k)
        tab.append(k)
    return tab        


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

    print(syracuse(5) == [5, 16, 8, 4, 2, 1] )
    print(syracuse(15) == [15, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1])

Indice de la première occurrence

Écrire le code d’une fonction premiere_occurrence() qui prend en paramètres elt un nombre entier et tab un tableau de nombres entiers, et qui renvoie l’indice de la première occurrence de elt dans tab si elt est dans tab et -1 sinon.

Exemples

>>> premiere_occurrence(1, [2, 3, 4])
-1

>>> premiere_occurrence(1, [10, 12, 1, 56])
2

>>> premiere_occurrence(1, [1, 50, 1])
0

>>> premiere_occurrence(15, [8, 9, 10, 15])
3
  1. Compléter la définition de la fonction premiere_occurrence().

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    def premiere_occurrence(elt, tab):
        """
        elt - 
        tab - 
        Sortie: 
        >>> premiere_occurrence(1, [2, 3, 4])
        -1
        >>> premiere_occurrence(1, [10, 12, 1, 56])
        2
        >>> premiere_occurrence(1, [1, 50, 1])
        0
        >>> premiere_occurrence(15, [8, 9, 10, 15])
        3
        """
        pass
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 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
def premiere_occurrence(elt, tab):
    """
    elt - int, un entier quelconque
    tab - list, tableau d'entiers
    Sortie: int, indice de la première occurrence de elt dans tab
            Si elt n'est pas dans tab, renvoie -1
    >>> premiere_occurrence(1, [2, 3, 4])
    -1
    >>> premiere_occurrence(1, [10, 12, 1, 56])
    2
    >>> premiere_occurrence(1, [1, 50, 1])
    0
    >>> premiere_occurrence(15, [8, 9, 10, 15])
    3
    """
    for i in range(len(tab)):
        if tab[i] == elt:
            return i
    return -1

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

    print(premiere_occurrence(7, [2, 9, 1, 7, 3, 7, 7, 2]) == 3)

    from random import randint
    t = [randint(0, 10) for _ in range(8)]
    print(t)
    print(premiere_occurrence(7, t))

Nombre d'occurrences d'un élément

Écrire en langage Python une fonction nb_occurrences() prenant comme paramètres une variable val de type entier et un tableau d'entiers tab. Cette fonction renvoie le nombre d'occurrences de elt dans tab.

Exemples d'utilisations de la fonction recherche

>>> nb_occurrences(5, []) 
0

>>> nb_occurrences(5, [-2, 3, 4, 8]) 
0

>>> nb_occurrences(5, [-2, 3, 1, 5, 3, 7, 4]) 
1

>>> nb_occurrences(5, [-2, 5, 3, 5, 4, 5]) 
3
  1. Compléter la définition de la fonction nb_occurrences().

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    def nb_occurrences(val, tab):
        """
        val -
        tab - 
        Sortie: 
        >>> nb_occurrences(5, []) 
        0
        >>> nb_occurrences(5, [-2, 3, 4, 8]) 
        0
        >>> nb_occurrences(5, [-2, 3, 1, 5, 3, 7, 4]) 
        1
        >>> nb_occurrences(5, [-2, 5, 3, 5, 4, 5]) 
        3
        """
        pass
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 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
def nb_occurrences(val, tab):
    """
    val - int, un entier quelconque
    tab - list, tableau d'entiers
    Sortie: int, nombre d'occurences de val dans tab
    >>> nb_occurrences(5, []) 
    0
    >>> nb_occurrences(5, [-2, 3, 4, 8]) 
    0
    >>> nb_occurrences(5, [-2, 3, 1, 5, 3, 7, 4]) 
    1
    >>> nb_occurrences(5, [-2, 5, 3, 5, 4, 5]) 
    3
    """
    compte = 0
    for elt in tab:
        if elt == val:
            compte += 1
    return compte


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

    print(nb_occurrences(5, [5, 5, 5, 5, 5, 5]) == 5)
    print(nb_occurrences(0, [1, 0, 1, 0]) == 2)

Indice de la dernière occurrence

Écrire le code d’une fonction derniere_occurrence() qui prend en paramètres elt un nombre entier et tab un tableau de nombres entiers, et qui renvoie l’indice de la dernière occurrence de elt dans tab si elt est dans tab et la longueur du tableau sinon.

Exemples

>>> derniere_occurrence(1, [2, 3, 4])
3

>>> derniere_occurrence(1, [10, 12, 1, 56])
2

>>> derniere_occurrence(1, [1, 50, 1])
2

>>> derniere_occurrence(1, [8, 1, 10, 1, 7, 1, 8])
5
  1. Compléter la définition de la fonction derniere_occurrence().

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    def derniere_occurrence(elt, tab):
        """
        elt - 
        tab - 
        Sortie: 
        >>> derniere_occurrence(1, [2, 3, 4])
        3
        >>> derniere_occurrence(1, [10, 12, 1, 56])
        2
        >>> derniere_occurrence(1, [1, 50, 1])
        2
        >>> derniere_occurrence(1, [8, 1, 10, 1, 7, 1, 8])
        5
        """
        pass
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 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
def derniere_occurrence(elt, tab):
    """
    elt - int, un entier quelconque
    tab - list, tableau d'entiers
    Sortie: int, indice de la dernière occurrence de elt dans tab
            Si elt n'est pas dans tab, renvoie -1
    >>> derniere_occurrence(1, [2, 3, 4])
    3
    >>> derniere_occurrence(1, [10, 12, 1, 56])
    2
    >>> derniere_occurrence(1, [1, 50, 1])
    2
    >>> derniere_occurrence(1, [8, 1, 10, 1, 7, 1, 8])
    5
    """
    indice = len(tab)
    for i in range(len(tab)):
        if tab[i] == elt:
            indice = i
    return indice

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

    print(derniere_occurrence(7, [2, 9, 1, 7, 3, 7, 7, 2]) == 6)

    from random import randint
    t = [randint(0, 10) for _ in range(8)]
    print(t)
    print(derniere_occurrence(7, t))

Indices des occurrences

Écrire le code d’une fonction indices_occurrences() qui prend en paramètres elt un nombre entier et tab un tableau de nombres entiers, et qui renvoie le tableau des indices des occurrences de elt dans tab si elt est dans tab et le tableau vide sinon.

Exemples

>>> indices_occurrences(3, [3, 2, 1, 3, 2, 1])
[0, 3]

>>> indices_occurrences(4, [1, 2, 3])
[]
  1. Compléter la définition de la fonction indices_occurrences().

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    def indices_occurrences(elt, tab):
        """
        elt - 
        tab - 
        Sortie: 
        >>> indices_occurrences(3, [3, 2, 1, 3, 2, 1])
        [0, 3]
        >>> indices_occurrences(4, [1, 2, 3])
        []
        """
        pass
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 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
def indices_occurrences(elt, tab):
    """
    elt - int, un entier quelconque
    tab - list, tableau d'entiers
    Sortie: list, tableau des indices de elt dans tab
    >>> indices_occurrences(3, [3, 2, 1, 3, 2, 1])
    [0, 3]
    >>> indices_occurrences(4, [1, 2, 3])
    []
    """
    result = []
    for i in range(len(tab)):
        if tab[i] == elt:
            result.append(i)
    return result

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

    print(indices_occurrences(1, [1, 1, 1, 1, 1, 1, 1, 1]) == [0, 1, 2, 3, 4, 5, 6, 7])
    print(indices_occurrences(4, [3, 2, 1, 4, 2, 1]) == [3])

    from random import randint
    t = [randint(0, 10) for _ in range(8)]
    print(t)
    print(indices_occurrences(7, t))

Moyenne pondérée

Soit le couple (note, coefficient):

  • note est un nombre de type flottant (float) compris entre 0 et 20 ;
  • coefficient est un nombre entier positif.

Les résultats aux évaluations d'un élève sont regroupés dans un tableau non vide composé de couples (note, coefficient).

Écrire une fonction moyenne_pond() qui renvoie la moyenne pondérée de ce tableau donné en paramètre.

Par exemple, l’expression moyenne_pond([(15, 2), (9, 1), (12, 3)]) devra renvoyer le résultat du calcul suivant :

\frac {2 \times 15 + 1 \times 9 + 3 \times 12}{2+1+3} = 12,5

Exemples

>>> moyenne_pond([(15, 2), (9, 1), (12, 3)])
12.5

>>> moyenne_pond([(15, 2))])
15.0

>>> moyenne([])
AssertionError: Tableau vide !
  1. Compléter la définition de la fonction moyenne_pond(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    def moyenne_pond(tab):
        """
        tab - 
        Sortie: 
        >>> moyenne_pond([(15, 2), (9, 1), (12, 3)])
        12.5
        >>> moyenne_pond([(15, 2)])
        15.0
        """
        pass
    
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 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
def moyenne_pond(tab):
    """
    tab - list, tableau de couples (note, coefficient),
          note est de type float, avec 0 <= note <= 20
          coefficient est de type int
    Sortie: float - moyenne pondérée des couples de tab
            (somme des (note*coefficient))/(somme des coefficient)
    >>> moyenne_pond([(15, 2), (9, 1), (12, 3)])
    12.5
    >>> moyenne_pond([(15, 2)])
    15.0
    """
    assert tab != [], "Tableau vide !"
    numerateur = 0
    denominateur = 0
    for couple in tab:
        numerateur += couple[0]*couple[1]
        denominateur += couple[1]
    return numerateur/denominateur



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

    print(moyenne_pond([(14, 3), (4, 2), (15, 3)]) == 11.875)    
    print(moyenne_pond([(14, 3)]) == 14)

Ajouter 1

On considère un tableau contenant uniquement des entiers valant 0 ou 1.
On va modifier ce tableau selon l'algorithme suivant.

  • On ajoute 1 au premier élément du tableau :

    • ou bien le résultat donne 1, alors on remplace le premier élément par 1 et c'est terminé ;
    • ou bien le résultat donne 2, alors on remplace le premier élément par 0 et on ajoute 1 au deuxième élément du tableau.
  • On recommence, c'est-à-dire :

    • ou bien le résultat donne 1, alors on remplace le deuxième élément par 1 et c'est terminé ;
    • ou bien le résultat donne 2, alors on remplace le deuxième élément par 0 et on ajoute 1 au troisième élément du tableau.
  • etc... jusqu'au dernier élément :

    • ou bien le résultat donne 1, alors on remplace le dernier élément par 1 et c'est terminé ;
    • ou bien le résultat donne 2, alors on remplace le dernier élément par 0 et c'est terminé.

Exemples

Prenons le tableau [1, 1, 0, 1].

  1. Le premier élément vaut 1. En ajoutant 1, cela donne 2. On remplace cet élément par 0 et on poursuit.
  2. Le deuxième élément vaut 1. En ajoutant 1, cela donne 2. On remplace cet élément par 0 et on poursuit.
  3. Le troisième élément vaut 0. En ajoutant 1, cela donne 1. On remplace cet élément par 1 et on s'arrête.
  4. Le tableau initial est devenu [0, 0, 1, 1].

Écrire le code d’une fonction ajouter1() qui prend en 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 modifie le tableau passé en paramètre en appliquant l'alorithme présenté plus haut.

Exemples

>>> T = [1, 1, 0, 1]
>>> ajouter1(T)
>>> T
[0, 0, 1, 1]

>>> ajouter1(T)
>>> T
[1, 0, 1, 1]

>>> T = []
>>> ajouter1(T)
AssertionError: Le tableau passé en argument ne doit pas être vide !
  1. Compléter la définition de la fonction ajouter1(), sans oublier d'ajouter l'assertion signalée dans l'exemple précédent.

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    def ajouter1(tab):
        """
        tab - 
        Sortie: 
                (fonction à effet de bord)
        >>> T = [1, 1, 0, 1]
        >>> ajouter1(T)
        >>> T
        [0, 0, 1, 1]
        >>> ajouter1(T)
        >>> T
        [1, 0, 1, 1]
        """
        pass
    
    
    if __name__ == '__main__':
        import doctest
        doctest.testmod()
    
  2. Compléter le docstring de cette fonction.

  3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).
Une solution possible
 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
40
41
42
43
def ajouter1(tab):
    """
    tab - list, tableau d'entiers valant uniquement 0 ou 1
    Sortie: None - modifie le tableau passsé en paramètre
            en ajoutant 1 à partir du premier élément,
            et à chaque élément tant que la somme vaut 2.
            On remplace chaque 2 par un 0.
            (fonction à effet de bord)
    >>> T = [1, 1, 0, 1]
    >>> ajouter1(T)
    >>> T
    [0, 0, 1, 1]
    >>> ajouter1(T)
    >>> T
    [1, 0, 1, 1]
    """
    assert tab != [], "Le tableau passé en argument ne doit pas être vide !"
    indice = 0
    tab[indice] += 1
    while (indice <= len(tab)-1) and (tab[indice] == 2):
        tab[indice] = 0
        indice += 1
        if indice <= len(tab)-1:
            tab[indice] += 1


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

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

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

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