T.P.

4 : tableaux bi-dimensionnels, triangle de Pascal et plus

Un point important de terminologie : ce que nous appelons liste en python est plus souvent appelé
tableau en informatique. Une liste de nombres par exemple T = [1, 3, 4] sera pour nous aussi appelée tableau. 1
Pour nous, on emploiera indifféremment les mots listes ou tableaux pour parler des listes Python.
En revanche ce qu’on appelle tableau dans le langage courant est un objet ≪ bidimensionnel ≫ comme une
a b c
matrice, par exemple ( ). Comment coder de tels tableaux dits bidimensionnels en informatique ?
d e f

1 Tableaux bidimensionnels vus comme listes doubles

La façon la plus simple pour fabriquer un tableau bidimensionnel en Python est d’utiliser une liste de
listes. Par exemple L=[[1,2],[3,4]] est ce qu’on appelle en informatique un tableau bidimensionnel qui
1 2
code ce que les humains ont envie de voir comme le tableau pour humain : ( ).
3 4
On dira qu’un tableau est carré si les lignes ont toutes la même longueur et le nombre de lignes est égal
au nombre de colonnes. C’est le cas du tableau précédent. Ce n’est pas le cas de M=[[1,2,3],[4,5,6]] ni
de N=[[1,2,3],[4,5]].
a) Fabriquer une fonction affiche_tableau_pour_humain qui est une fonction d’affichage : elle prend
en argument un tableau informatique (liste de listes) et l’affiche ligne par ligne sans crochet ni
virgules. Par exemple pour L elle donnera
1 2
3 4
b) Comment modifier L pour obtenir dans L : [[1,2],[3,5]] ? (Vérifier à l’aide de id que l’identifiant
mémoire de L n’est pas modifié par votre opération).
c) Ecrire une fonction Tzeros(m,n) qui prend en arguments deux entiers m et n et retourne un tableau
à m lignes et n colonnes rempli de zéros.
N.B. Cette fois, il ne s’agit pas d’une fonction d’affichage, elle doit retourner un objet qui est une
liste de listes.
d) Soit L=Tzeros(3,3). Modifier la première entrée de la première ligne de L pour y mettre un 1.
Si votre résultat n’est pas satisfaisant, modifiez votre fonction Tzero.
e) Ecrire une fonction testcarre prenant comme argument un tableau bidimensionnel et qui renvoie
True ou False suivant que ce tableau est ou non carré .
f) Ecrire une fonction longmaxLigne prenant comme argument un tableau et qui renvoie la longueur
de la plus grande ligne du tableau.
g) En déduire une fonction transfMatrice prenant comme argument un tableau et le transformant
en matrice carrée en rajoutant des 0 à la fin des lignes incomplètes.
h) Fabriquer une fonction qui transforme une liste simple en un tableau bidimensionnel (liste de listes)
où les entrées sont regroupées dans des sous-listes formées de 10 entrées (sauf la dernière sous-liste
qui peut être plus petite) : attention, on veut que cette fonction retourne un tableau informatique
bidimensionnel (liste de listes). A l’aide de cette fonction et de affiche_tableau_pour_humain on
peut alors afficher tous les nombres entiers jusqu’à 100 à partir de L=list(range(101)) sous la
forme d’un tableau pour humain.

2 Calcul des binomiaux par la formule explicite

a) Ecrire une fonction factorielle(n) qui prend en argument un entier n et renvoie sa factorielle.
b) Ecrire une fonction binomial(m,n) qui prend en argument deux entiers m et n et retourne (m
n
) qui
doit être de type integer, grâce à la formule explicite.
1. En réalité du point de vue informatique, la structure de donnée tableau et la structure de donnée liste ont
des différences, suivant la façon dont elles sont codées en machine, pour savoir notamment si on accède à toutes les
entrées avec le même temps ou pas. Vous reviendrez à ce problèmes en Option Info. notamment.

1
3 Le tableau du triangle de Pascal
a) Fabriquer une fonction qui prend comme argument un entier naturel n et renvoie une liste double
qui correspond au triangle de Pascal jusqu’à la ligne n. N.B. On n’utilisera pas la formule explicite,
mais la formule du triangle de Pascal.
b) Appliquer la fonction d’affichage précédent pour obtenir le tableau du triangle de Pascal aligné à
gauche.
c) Modifier la fonction d’affichage précédent pour obtenir le tableau du triangle de Pascal centré.
 
Indication : on peut, si on veut, utiliser la méthode center sur les chaı̂nes de caractères.
 
d) A partir d’un tableau obtenu par la question précédente, obtenir le tableau où l’on remplace chaque
entrée par un O si elle est paire et un ∗ si elle est impaire. Commentez le dessin obtenu pour une
valeur de n assez grande.

4 Pour les plus rapides (et les plus motivé(e)s) : un démineur

Le démineur est un jeu de réflexion dont le but est de localiser des mines dans un champ qui est un
tableau bidimensionnel. Pour nous les mines seront représentées par le chiffre 9. Les autres chiffres de 0 à 8
sur une case servent à dire le nombre de mines qui sont adjacentes à cette case : une case qui n’est pas sur le
bord du tableau a exactement huit cases adjacentes. Dans la version avec la souris, un clic normal permet
de savoir le chiffre qu’il y a sur une case, mais si on clique sur une mine, on a perdu. Un clic droit permet
de mettre un drapeau sur une case pour dire qu’on la considère comme une mine. Ici, on programmera en
mode texte, et le clic droit sera signifié par un d qu’on rentrera à la suite du numéro de la case.
a) Ecrire une fonction qui prend comme arguments trois entiers n, p, k qui fabrique une matrice à
n lignes et p colonnes, dont toutes les entrées sont nulles sauf k entrées qui valent 9, placées
aléatoirement. On pourra utiliser le module random.
b) On donne sur le fichier aideDemineur.py dans /home/profs/bondil/public une fonction voisins(i,j,n,p)
qui renvoie la liste des coordonnées des voisins d’une entrées [i,j] dans un tableau de taille n × p.
A l’aide de cette fonction écrire une fonction qui prend comme argument un tableau t et un couple
d’entier (i, j) et qui compte le nombre de voisins de la case t[i][j] qui valent 9.
c) En déduire une fonction prenant comme argument une matrice remplie de 0 et de 9 (comme celle
qu’on a créée au a)) et remplaçant les zéros par le nombre de mines adjacentes à la case correspon-
dante.
d) Ecrire un programme permettant d’effectuer une partie de démineur (en mode texte, ce n’est pas
très beau, mais c’est plus simple). Le programme procédera comme suit :
(i) il demande au joueur des valeurs de n, p, k : le nombre de lignes, de colonnes, et le nombre de
mines cachées
(ii) il crée une matrice représentant complètement la grille de démineur comme vu au c), qu’il ne
montre pas au joueur !
(iii) il crée une deuxième matrice de même taille ne contenant que des ∗ : cette matrice représente
la grille de jeu du joueur, ici le ∗ représente une case non explorée.
(iv) il crée une variable contenant le nombre de cases sans mines encore non explorées : initialement
np − k.
(v) à chaque tour de jeu, on affiche la grille du joueur, on lui demande de rentrer les coordonnées
d’une case de la grille, éventuellement suivie de ,d pour un clic droit. S’il n’y pas de d et si c’est
une case avec une mine, le joueur a perdu et le jeu s’arrête. S’il n’y pas de d et que ce n’est pas
une case avec une mine, on modifie le ∗ de la grille du joueur en le remplaçant par le nombres
de mines adjacentes à cette case. S’il y a un d et que c’est une case avec une mine, le joueur a
trouvé une mine et le ∗ est remplacé par un M .
(vi) Le joueur gagne s’il arrive à explorer toutes les cases non minées ou encore s’il a trouvé toutes
les mines.