Feuille 3 : Listes de listes

E1 : Matrice de zero

On souhaite disposer d'une fonction matrice_de_zero(l:int, h:int)->list qui prend deux entiers en paramètres et renvoie une liste de liste de 0 dont la dimension est l × h.

Ainsi, matrice_de_zero(3, 2) doit renvoyer [[0, 0, 0], [0, 0, 0]].

1. Indiquer ce que devra renvoyer matrice_de_zero(1, 1).

2. Écrire le code de la fonction matrice_de_zero(l:int, h:int)->list.

def matrice_de_zero(l:int, h:int)->list:
    matrice = []
    for _ in range(h):
        ligne = []
        for _ in range(l):
            ligne.append(0)
        matrice.append(ligne)
    return matrice

def test_matrice_de_zero():
    assert matrice_de_zero(1, 1) == [[0]]
    assert matrice_de_zero(3, 2) == [[0, 0, 0], [0, 0, 0]]
    print('Les tests sont validés.')

# Programme principal
test_matrice_de_zero()

E2 : Applatir une liste

Exercice inspiré de  : CodEx : le code par les exercices - Aplatir une liste.

On considère un tableau à deux dimensions (on dit aussi une matrice), non vide, rempli de nombres et l'on souhaite l'aplatir, c'est-à-dire le transformer en un tableau à une seule ligne.

Les tableaux de départ seront représentés par des listes de listes, et les tableaux aplatis par de simples listes.

Par exemple, si le tealbeau de départ est [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], alors le tableau aplati correspondant s'écrira [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

Écrire la fonction aplatir prenant en argument une liste de listes tableau et renvoyant une liste dans laquelle toutes les valeurs de tableau sont données à la suite les unes des autres.

On utilisera le jeu de tests suivant pour vérifier son code :

assert aplatir([[1, 2, 3, 4], [5, 6, 7, 8]]) == [1, 2, 3, 4, 5, 6, 7, 8]
assert aplatir([[1, 2, 3], [4, 5, 6]]) == [1, 2, 3, 4, 5, 6]
assert aplatir([[1, 2], [3, 4], [5, 6]]) == [1, 2, 3, 4, 5, 6]
assert aplatir([[1], [2], [3], [4], [5], [6]]) == [1, 2, 3, 4, 5, 6]

def aplatir(matrice):
    tab_plat = []
    for ligne in matrice:
        tab_plat = tab_plat + ligne
    return tab_plat

def test_applatir():
    assert aplatir([[1, 2, 3, 4], [5, 6, 7, 8]]) == [1, 2, 3, 4, 5, 6, 7, 8]
    assert aplatir([[1, 2, 3], [4, 5, 6]]) == [1, 2, 3, 4, 5, 6]
    assert aplatir([[1, 2], [3, 4], [5, 6]]) == [1, 2, 3, 4, 5, 6]
    assert aplatir([[1], [2], [3], [4], [5], [6]]) == [1, 2, 3, 4, 5, 6]
    print("Tous les tests sont passés.")

# Programme principal
test_applatir()

E3 : Jeu de cartes

En vue d’obtenir un tableau contenant les cartes d’un jeu de 32 cartes, on crée les deux tableaux suivants :

• • t_couleurs = [ "♠", "♣", "♥", "♦"]
• • t_valeurs = ["7", "8", "9", "10", "V", "D", "R", "A"].

1. Écrire la fonction paquet32() qui renvoie un tableau contenant toutes les cartes. Une carte sera représentée par un tableau ayant sa valeur comme premier élément et sa couleur comme deuxième élément. Par exemple ["9", "♥"].

2. Écrire une fonction qui distribue aléatoirement les cartes d'un paquet de 32 cartes à deux joueurs. Pour cela, la fonction prend les 32 cartes les unes après les autres et les répartit aléatoirement dans deux listes jusqu'à ce que ces listes aient chacun 16 cartes. Les deux listes sont finalement renvoyées par la fonction.

3. (Facultatif, à faire sur ordinateur) Compléter le programme pour simuler une bataille où l'ordinateur joue contre lui-même...

E4 : Moyenne des notes avec coefficients

Afin de calculer une moyenne de notes coefficientées, on procède de la façon suivante :

• - chaque note est un tableau de deux valeurs : la note et son coefficient ;
• - l’ensemble des notes est placé dans un tableau.

Exemple : [[12, 1], [14, 1], [13, 2]].

1. Écrire une fonction qui prend un tableau de notes en paramètre et renvoie la moyenne.

2. Écrire le programme principal qui permet de tester la fonction avec plusieurs exemples.

E5 : Carrés magiques

« En mathématiques, un carré magique d’ordre n est composé de n² entiers strictement positifs, écrits sous la forme d’un tableau carré. Ces nombres sont disposés de sorte que leurs sommes sur chaque rangée, sur chaque colonne et sur chaque diagonale principale soient égales. On nomme alors constante magique la valeur de ces sommes. » (Extrait de Wikipedia)

Dans cet exercice, un carré (magique ou non) sera stocké dans une liste de liste.

carré = [[2, 7, 6],
         [9, 5, 1],
         [4, 3, 8]]

1. Compléter la fonction somme_ligne(c, n) suivante :

def somme_ligne(c, n):
    """
    Renvoie la somme des nombres d'une ligne d'un carré.
    Paramètres :
        c (list) : liste de liste correspondant à un carré
        n (int) : entier correspondant à un numéro de ligne
    Return (int) : somme des nombres de la ligne n.
    """

2. De façon similaire à la question précédente, écrire la fonction somme_colonne(c:list, n:int)->int.

3. Écrire la fonction somme_1d(c:list)->int qui renvoie la somme des nombres de la diagonale qui va de la case en haut à gauche et va jusqu'à la case en bas à droite.

4. Écrire, de même, la fonction somme_diag2(c:list)->int qui renvoie la somme des nombres de la diagonale qui va de la case en haut à droite et va jusqu'à la case en bas à gauche.

5. Écrire la fonction est_magique(c:list)->bool qui renvoie True si le carré passé en paramètre et False dans le cas contraire.