Aller au contenu

Exercices d'entraînement☘

Ces exercices doivent être utilisés pour vous entraîner à programmer. Ils sont généralement accompagnés d'aide et de leur solution pour vous permettre de progresser.

Avant de vous précipiter sur ces solutions dès la première difficulté, n'oubliez pas les conseils suivants :

  • Avez-vous bien fait un schéma au brouillon pour visualiser le problème posé ?
  • Avez-vous essayé de rédiger un algorithme en français, avec vos propres mots, avant de vous lancer dans la programmation sur machine ?
  • Avez-vous utilisé des affichages intermédiaires, des print(), pour visualiser au fur et à mesure le contenu des variables ?
  • Avez-vous testé le programme avec les propositions de tests donnés dans l'exercice ?
  • Avez-vous testé le programme avec de nouveaux tests, différents de ceux proposés ?
Rappels
  • Chaque programme Python doit être sauvegardé sous forme de fichier texte avec l'extension .py.
    Enregistrez ce fichier dans le dossier [B05-Tableaux_de_Tableaux] avec le nom donné à l'exercice : ProgB05.52.py, ProgB05.53.py, etc...
  • Pour exécuter ce programme, il suffit de le sauvegarder puis d'appuyer sur la touche [F5].
  • Le programme principal doit contenir un appel au module doctest : 
    ##----- Programme principal et tests -----##
if __name__ == '__main__':
    import doctest
    doctest.testmod()

Exercice B05.51☘

On définit par extension une matrice nommée B :

1
2
3
4
5
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)] ]

Proposez une définition par compréhension de B.

Une solution

Chaque tableau interne est de la forme [i**j for i in range(5)] pour la variable j allant de 1 à 5.

D'où la définition équivalente de B :

1
B = [ [i**j for i in range(5)] for j in range(1, 6)]

ProgB05.52☘

Complétez la définition de la fonction matrice_entiers_successifs() qui renvoie une matrice carrée de n lignes et n colonnes contenant les entiers de 0 à n²-1. De façon plus générale :

  • la ligne 0 est constituée des entiers de 0 à n-1,
  • la ligne 1 des entiers de n à 2n-1,
  • la ligne 2 des entiers de 2n à 3n-1,
  • ...
1
2
3
4
5
6
7
def matrice_entiers_successifs(n):
    """
    n - int, entier strictement positif
    Sortie: list -  matrice carrée contenant n lignes et n colonnes.
            Les éléments sont ordonnées par ordre croissant par colonne et
            par ligne, de 0 à n²-1. 
    """

Exemple de tests

>>> A = matrice_entiers_successifs(3)    
>>> affichage_matrice(A)
[0, 1, 2]
[3, 4, 5]
[6, 7, 8]

>>> B = matrice_entiers_successifs(4)
>>> affichage_matrice(B)
[0, 1, 2, 3]
[4, 5, 6, 7]
[8, 9, 10, 11]
[12, 13, 14, 15]
Une solution élément par élément

Dans cette solution, on se sert d'un compteur initialisé à 0, on place ce compteur dans la matrice puis on l'incrémente de 1 afin de placer l'élément suivant dans le tableau, etc...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
def matrice_entiers_successifs(n):
    """
    n - int, entier strictement positif
    Sortie: list -  matrice carrée contenant n lignes et n colonnes.
            Les éléments sont ordonnées par ordre croissant par colonne et
            par ligne, de 0 à n²-1. 
    """
    matrice = []
    compteur = 0
    for i in range(n):
        ligne = []
        for j in range(n):
            ligne.append(compteur)
            compteur = compteur+1
        matrice.append(ligne)
    return matrice
Une solution par compréhension

Regardons la colonne 1. Elle contient les éléments : 0, n, 2n, 3n, ...
En résumé la colonne 1 contient les entiers i\times n où i est le numéro de ligne.
Sur la ligne i, se trouvent donc les éléments i*n, i*n+1, i*n+2, ..., i*n + (n-1). En bref, à l'intersection de la ligne i et de la colonne j, on trouve l'élément i*n+j.

D'où le code :

1
2
3
4
5
6
7
8
def matrice_entiers_successifs(n):
    """
    n - int, entier strictement positif
    Sortie: list -  matrice carrée contenant n lignes et n colonnes.
            Les éléments sont ordonnées par ordre croissant par colonne et
            par ligne, de 0 à n²-1. 
    """
    return [ [i*n + j for j in range(n)] for i in range(n)]

ProgB05.53☘

On considère la matrice B : 

1
B = [ [i**j for i in range(5)] for j in range(1, 6)]

Comme tous les éléments de cette matrice n'ont pas le même nombre de caractères, l'affichage produit par la fonction affichage_matrice() n'est pasforcément très lisible. On aimerait un affichage sans crochets, sans virgules mais avec tabulations :

1
2
3
4
5
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

Complétez la définition de la fonction affichage_tabulation() qui permet de réaliser ce type d'affichage pour un paramètre de type « tableau de tableaux ». 

1
2
3
4
5
6
def affichage_tabulation(matrice):
    """
    matrice - list, Tableau de tableaux
    Sortie: None - Fonction d'affichage qui affiche chaque élément de matrice
            séparés par une tabulation, en passant à la ligne entre les listes.
    """

Exemple de tests

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

>>> B = [ [i**j for i in range(5)] for j in range(1, 6)]
>>> affichage_tabulation(B)
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
Une piste : aligner les affichages

Par défaut, la fonction print() réalise un passage à la ligne après l'affichage demandé.
Il est possible de changer ce comportement par défaut en ajoutant une valeur au paramètre end.

Testez par exemple ces instructions dans un programme puis exécutez-les : 

1
2
3
4
5
6
7
print("abc", end="")
print("def", end="   ")
print("ghi")

print("abc", end="\t")
print("def", end="\n")
print("ghi")

Vous obtenez : 

abcdef   ghi
abc def
ghi

La valeur par défaut de end est '\n', ce qui explique le passage à la ligne de l'affichage lorsqu'on ne renseigne pas explicitement end.

Le caractère '\t' correspond à la tabulation (généralement visualisée par 4 espaces).

Une solution
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
def affichage_tabulation(matrice):
    """
    matrice - list, Tableau de tableaux
    Sortie: None - Fonction d'affichage qui affiche chaque élément de matrice
            séparés par une tabulation, en passant à la ligne entre les listes.
    """
    for ligne in matrice:
        for element in ligne:
            print(element, end='\t')
        print()                         # Pour passer à la ligne