Aller au contenu

TP - Définir une matrice☘

Dans le dossier [NSI], créez le dossier [B05_Tableaux_de_Tableaux].

Dans ce TP, les différentes parties sont globalement indépendantes.

Consignes communes à chaque partie

Le programme principal contient un appel au module doctest : 

##----- Programme principal et tests -----##
if __name__ == '__main__':
    import doctest
    doctest.testmod()
Dans le « main », il faudra penser à élaborer un plan de test (avec des affichages console).
Pensez à demander au professeur de valider ce plan de test...

Partie 1 : Affichage d'une matrice☘

  1. Recopiez le code ci-dessous dans un (nouveau) programme Python :

    1
2
3
4
5
6
7
    B = [ [i for i in range(5)],  
      [i*i for i in range(5)], 
      [i*i*i for i in range(5)], 
      [i**4 for i in range(5)], 
      [i**5 for i in range(5)] ]

print(B)

  2. Exécutez ce programme, voici ce qui doit s'afficher dans la console :

    >>> (executing file "<tmp 1>")
[[0, 1, 2, 3, 4], [0, 1, 4, 9, 16], [0, 1, 8, 27, 64], [0, 1, 16, 81, 256], [0, 1, 32, 243, 1024]]
    Peu lisible, n'est-ce pas ?
    On aimerait plutôt un affichage où chaque liste interne est affichée sur une ligne distincte, comme ci-dessous :

    >>> (executing file "<tmp 1>")
[0, 1, 2, 3, 4]
[0, 1, 4, 9, 16]
[0, 1, 8, 27, 64]
[0, 1, 16, 81, 256]
[0, 1, 32, 243, 1024]

  3. Téléchargez le fichier « à trous » TPB05.20.py (clic droit -> [Enregistrer sous]) et enregistrez-le dans le dossier [B05_Tableaux_de_Tableaux].

  4. Complétez dans le fichier TPB05.20.py la définition de la fonction affichage_par_ligne() qui permet de réaliser ce type d'affichage pour une matrice passée en paramètre.

    1
2
3
4
5
6
    def affichage_par_ligne(matrice):
    """
    matrice - list, tableau de tableaux de nombres
    Sortie: None - Fonction d'affichage qui affiche chaque sous-tableau
            de matrice en passant à la ligne entre les sous-tableaux.
    """

    Exemple de test

    >>> A = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ]
>>> affichage_par_ligne(A)
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

Partie 2 : Matrice aléatoire☘

Complétez la définition de la fonction matrice_alea() qui renvoie une matrice de nb_lignes lignes et nb_colonnes colonnes. Chaque élément est un entier aléatoire compris entre borne_inf et borne_sup, où nb_lignes, nb_colonnes, borne_inf et borne_sup sont les quatre paramètres entiers de la fonction.

1
2
3
4
5
6
7
def matrice_alea(nb_lignes, nb_colonnes, borne_inf, borne_sup):
    """
    nb_lignes, nb_colonnes - int, entiers strictement positifs
    borne_inf, borne_sup - int, entiers tels que borne_inf < borne_sup
    Sortie: list -  matrice contenant nb_lignes lignes et nb_colonnes colonnes.
            Chaque élément est un entier aléatoire compris entre borne_inf et borne_sup. 
    """

Exemple de test

Génération d'une matrice contenant 4 tableaux de 6 éléments.
Ces éléments sont des entiers générés aléatoirement entre -10 et 10 (inclus). 

>>> C = matrice_alea(4, 6, -10, 10)
>>> affichage_par_ligne(C)
[-2, 7, -5, 4, 9, 1]
[9, -1, -1, 6, 8, 6]
[4, -5, -5, 4, -8, 9]
[1, -1, 6, -6, -2, 5]

Partie 3 : Tables de multiplication☘

Complétez la définition de la fonction table_multi() qui renvoie une matrice contenant les produits i × j, où i est le numéro de la ligne et j, le numéro de la colonne.

1
2
3
4
5
6
7
8
def table_multi(nb_lignes, nb_colonnes):
    """
    nb_lignes, nb_colonnes - int, entiers strictement positifs
    Sortie: list - matrice contenant nb_lignes lignes et nb_colonnes colonnes.
            L'élément situé en ligne i et en colonne j a pour valeur i*j. 
    >>> table_multi(3, 5)
    [[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]]
    """

Exemple de test

>>> D = table_multi(7, 5)    
>>> affichage_par_ligne(D)
[0, 0, 0, 0, 0]
[0, 1, 2, 3, 4]
[0, 2, 4, 6, 8]
[0, 3, 6, 9, 12]
[0, 4, 8, 12, 16]
[0, 5, 10, 15, 20]
[0, 6, 12, 18, 24]

Partie 4 : Beaucoup de 0, quelques 1☘

Diagonale 01

  1. Complétez la définition de la fonction premiere_diagonale() qui renvoie une matrice carrée de n lignes et n colonnes contenant des 0 sauf la première diagonale qui contient des 1.
    Les carrés blancs de l'image ci-contre représente les 0 de la matrice et les carrés noirs représentent les 1.

    1
2
3
4
5
6
7
8
9
    def premiere_diagonale(n):
    """
    n - int, entier strictement positif
    Sortie: list -  matrice contenant n lignes et n colonnes.
            Les éléments valent tous 0 sauf ceux de la première
            diagonale qui valent 1.
    >>> premiere_diagonale(4)
    [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
    """

    Exemple de test

    >>> E = premiere_diagonale(4)        
>>> affichage_par_ligne(E)
[1, 0, 0, 0]
[0, 1, 0, 0]
[0, 0, 1, 0]
[0, 0, 0, 1]
    Une piste

    Répondez à la question :
    « à quelle condition doit-on placer un 1 plutôt qu'un 0 ? »
    (un schéma répétitif se dessine-t-il ?)

    Diagonale 02

  2. Complétez la définition de la fonction deuxieme_diagonale() qui renvoie une matrice carrée de n lignes et n colonnes contenant des 0 sauf la seconde diagonale qui contient des 1.
    Les carrés blancs de l'image ci-contre représente les 0 de la matrice et les carrés noirs représentent les 1.

    1
2
3
4
5
6
7
8
9
    def deuxieme_diagonale(n):
    """
    n - int, entier strictement positif
    Sortie: list -  matrice contenant n lignes et n colonnes.
            Les éléments valent tous 0 sauf ceux de la seconde
            diagonale qui valent 1. 
    >>> deuxieme_diagonale(4)
    [[0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]]
    """

    Exemple de test

    >>> F = deuxieme_diagonale(4)    
>>> affichage_par_ligne(F)
[0, 0, 0, 1]
[0, 0, 1, 0]
[0, 1, 0, 0]
[1, 0, 0, 0]
    Une piste

    À partir de l'exemple de test proposé, répondez aux questions qui suivent :

    1. Quelle est la valeur de n ?
    2. On s'intéresse au premier 1, en haut à droite de cette matrice.
      1. Quel est le numéro de ligne i de ce premier 1 ?
      2. Quel est le numéro de colonne j de ce premier 1 ?
    3. On s'intéresse au deuxième 1, situé en-dessous à gauche du premier.
      1. Quel est le numéro de ligne i de ce deuxième 1 ?
      2. Quel est le numéro de colonne j de ce deuxième 1 ?
    4. On s'intéresse au troisième 1, situé en-dessous à gauche du deuxième.
      1. Quel est le numéro de ligne i de ce troisième 1 ?
      2. Quel est le numéro de colonne j de ce troisième 1 ?
    5. On s'intéresse au dernier 1, situé en-dessous à gauche du troisième.
      1. Quel est le numéro de ligne i de ce dernier 1 ?
      2. Quel est le numéro de colonne j de ce dernier 1 ?

    Diagonale 03

  3. Complétez la définition de la fonction losange() qui renvoie une matrice carrée de n lignes et n colonnes, avec n impair, contenant des 0 partout hormis dans un losange (représenté ci-contre) constitué de 1.

    1
2
3
4
5
6
7
8
    def losange(n):
    """
    n - entier impair strictement positif
    Sortie: list -  matrice contenant n lignes et n colonnes.
            Les éléments valent tous 0 sauf ceux formant le losange. 
    >>> losange(5)
    [[0, 0, 1, 0, 0], [0, 1, 0, 1, 0], [1, 0, 0, 0, 1], [0, 1, 0, 1, 0], [0, 0, 1, 0, 0]]
    """

    Exemple de test

    >>> G = losange(7)    
>>> affichage_par_ligne(G)
[0, 0, 0, 1, 0, 0, 0]
[0, 0, 1, 0, 1, 0, 0]
[0, 1, 0, 0, 0, 1, 0]
[1, 0, 0, 0, 0, 0, 1]
[0, 1, 0, 0, 0, 1, 0]
[0, 0, 1, 0, 1, 0, 0]
[0, 0, 0, 1, 0, 0, 0]
    Un algorithme possible

    i correspond au numéro de la ligne en cours et j au numéro de la colonne en cours.
    On note aussi m le quotient n//2, c'est-à-dire le numéro de la ligne (ou de la colonne) du « milieu ».
    On va traiter les lignes en deux parties :

    1. Première moitié : on place 1 lorsque i+j ou j-i est égal à m.
    2. Seconde moitié : on place 1 lorsque i-j est égal à m ou lorsque i+j est égal à n+m-1.