Feuille 3 : Les listes de listes

Exercice 1 : 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

# Programme principal
print(matrice_de_zero(1, 1) == [[0]])
print(matrice_de_zero(3, 2) == [[0, 0, 0], [0, 0, 0]])

Exercice 2 : 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

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.")

Exercice 3 : 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.

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

from random import randint

# Fonctions
def paquet32():
    t_couleurs = [ "♠", "♣", "♥", "♦"]
    t_valeurs = ["7", "8", "9", "10", "V", "D", "R", "A"]
    paquet = []
    for couleur in t_couleurs:
        for valeur in t_valeurs:
            carte = [valeur, couleur]
            paquet.append(carte)
    return paquet

def distribue():
    paquet = paquet32()
    liste0 = []
    liste1 = []
    for carte in paquet:
        num = randint(0,1)
        if (num == 0 and len(liste0) < 16) or len(liste1) >= 16 :
            liste0.append(carte)
        else:
            liste1.append(carte)
    return liste0, liste1

# Programme principal
l1, l2 = distribue()
print("--- Joueur 1 ---")
for carte in l1:
    print(carte[0], carte[1])
print("--- Joueur 2 ---")
for carte in l2:
    print(carte[0], carte[1])

Exercice 4 : 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.

def moy_pond(liste_notes_pond):
    somme_notes_pond = 0
    somme_coefs = 0
    for note_coef in liste_notes_pond:
        note = note_coef[0]
        coef = note_coef[1]
        somme_notes_pond = somme_notes_pond + note * coef
        somme_coefs = somme_coefs + coef
    return somme_notes_pond / somme_coefs

# Programme principal
print(moy_pond([[10,2],[12,1],[8,1]]))
print(moy_pond([[12, 1], [14, 1], [13, 2]]))