Un tableau à deux dimensions

Nous savons qu'il est possible de mettre dans des listes tout type d'objets, et donc pourquoi pas... des listes ! Nous pouvons donc obtenir ainsi des tableaux à deux dimensions. L'exemple suivant montre la création manuelle d'un tableau 3x3.

grille=[[1, 2, 3],[4,5,6], [7,8,9]]
grille[0][2]

Construction d'une grille

Construire une ligne

Ecrire une fonction creer_ligne_0

  • prenant en paramètre un nombre $n$
  • renbvoyant une liste contenant $n$ fois la valeur 0 Conseils :
  • pour initialiser notre ligne, on pourra utiliser une liste vide [ ]
  • on pourra utiliser une boucle pour
  • on pourra utiliser la méthode append() qui permet d'ajouter un élément à la fin d'une liste
def creer_ligne_0(n):
    # YOUR CODE HERE
    raise NotImplementedError()

Vérification : La cellule suivante doit s'exécuter sans erreurs

assert creer_ligne_0(10) == [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

On souhaite à présent remplacer quelques 0 aléatoirement par des 1. Fixons la probabilité d'avoir 1 à 0,2.

Voici comment mathématiquement nous pouvons obtenir 0 ou 1 avec une probabilité de 0,2 d'avoir 1. Il s'agit ici d'exploiter le fait que la fonction random()+0.2 renvoie un nombre entre 0.2 et 1.2...

En validant la cellule ci-dessous plusieurs fois, vous devriez obtenir 1 de temps en temps.

from random import *

p=0.2
print(int(random()+p))

A présent, utilisez cette astuce de calcul pour créer une fonction creer_ligne

  • prenant en paramètres deux nombres $n$ et $p$
  • renvoyant une liste de longueur $n$ formée de 0 et de 1 où 1 apparaît avec la probabilité $p$.
from random import random
def creer_ligne(n,p):
    # YOUR CODE HERE
    raise NotImplementedError()

Vérification : La cellule suivante doit s'exécuter sans erreurs

assert 175<=creer_ligne(1000,0.2).count(1)<=225

construire une grille

Une grille - ou un tableau à deux dimensions - est en réalité une liste de lignes. Chaque ligne est construite selon le même procédé que celui utilisé ci-dessus.

Pour construire notre grille, nous allons donc construire une liste de $n$ éléments mais au lieu de mettre 0 ou 1, nous mettrons une ligne que nous construirons à l'aide de la fonction creer_ligne.

Ecrire une fonction creer_grille

  • prenant en paramètre un nombre $n$ et une probabilité $$
  • renvoyant une grille $n\times n$ où 1 apparaît avec une probabilité p L'appel creer_grille(10,0.2) renverra quelque chose du genre :
      [[0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
       [1, 0, 0, 0, 0, 0, 1, 0, 1, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 1, 0, 1, 0, 1],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [1, 0, 0, 0, 0, 0, 0, 1, 0, 0],
       [0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 1, 0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 0, 0, 1, 0, 0, 0, 1]]
    
def creer_grille(n,p):
    # YOUR CODE HERE
    raise NotImplementedError()

Vérification : La cellule suivante doit afficher quelque chose ressemblant à ceci :

[[0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
 [1, 0, 0, 0, 0, 0, 1, 0, 1, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 1, 0, 1, 0, 1],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [1, 0, 0, 0, 0, 0, 0, 1, 0, 0],
 [0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 1, 0, 0, 0, 1, 0, 0, 0],
 [0, 0, 0, 0, 0, 1, 0, 0, 0, 1]]
# Vérification :
creer_grille(10,0.2)

Félicitations votre grille est créée !

Jouer un coup

Créer une fonction jouer_coup

  • prenant en paramètre une grille, un indice de ligne et un indice de colone
  • renvoyant False si on est tombé sur une bombe
  • dans le cas contraire, un "2" sera placé à l'emplacement joué et on renverra True

  • Pour faire un test comportant un sinon ... si, on pourra utiliser la structure Python suivante :

      if condition :
          bloc d'instructions à réaliser
          si condition est vraie
      else :
          bloc d'instructions à réaliser
          si aucune condition n'est vraie
  • l'accès à l'élément de la grille à la colonne c et la ligne l se fait par
      grille[l][c]
def jouer_coup(grille, ligne, col):
    # YOUR CODE HERE
    raise NotImplementedError()

Vérifiez en validant la cellule ci-dessous que des 2 ont bien été positionnés sur les cellules découvertes

grille = [[0,1],[1,0]]
assert jouer_coup(grille,1,1) == True
assert grille == [[0,1],[1,2]]
assert jouer_coup(grille,0,1) == False

Nombre de cases libres

Ecrire une fonction cases_libres

  • prenant en paramètre une grille
  • renvoyant le nombre de cases libres (0) dans la grille.

Une bombe ou un coup joué n'est pas considéré comme case libre.

def cases_libres(grille):
    # YOUR CODE HERE
    raise NotImplementedError()
grille=[[0, 2, 0], [1, 0, 0], [0, 0, 0]]
assert cases_libres(grille) == 7

Nombre de bombes alentours

Ecrire une fonction bombes_autour

  • prenant en paramètre une grille, un indice de ligne et un indice de colone
  • renvoyant le nombre de bombes dans les cases adjacentes.

Si une bombe est présente sur la case indiquée, celle-ci n'est pas comptabilisée.

Attention aux indices afin de ne pas dépasser des limites de la grille ! Pour tester si un nombre est compris entre 2 valeurs, on pourra utiliser la syntaxe suivante :

    if 0 <= x < n :
        blablabla
def bombes_autour(grille, ligne, col):
    # YOUR CODE HERE
    raise NotImplementedError()
grille=[[0, 0, 0], [1, 0, 0], [0, 0, 0]]
assert bombes_autour(grille,2,2) == 0
assert bombes_autour(grille,1,1) == 1

Afficher une grille

Ecrire une fonction afficher_grille

  • prenant en paramètre une grille
  • affichant la grille avec le format suivant :
    • si une case a été découverte, on affiche le nombre de bombes alentours
    • si une case n'a pas été découverte ou qu'elle contient une bombe on affiche "."

Indication On pourra observer la cellule suivante afin pour voir comment afficher des informations avec print

Exemple : voici une grille simple et l'affichage attendu

[[0, 2, 0],        . 1 .
 [1, 2, 0],   ==>  . 1 .
 [0, 0, 2]]        . . 0
print("Hello ",end=" ")
print("World")
print("Sans le paramètre end, je retourne à la ligne")
def afficher_grille(grille):
    # YOUR CODE HERE
    raise NotImplementedError()
# Testez vous-même votre fonction sur l'exemple donné

grille = [[0, 2, 0], [1, 2, 0], [0, 0, 2]]
afficher_grille(grille)

Jouer une partie

Ecrire une fonction jouer

  • qui prend en paramètres une grille, un indice de ligne et un indice de colonne
  • qui joue le coup indiqué et affiche la grille résultante
  • qui renvoie
      - -1 si on tombe sur une bombe
      - 0 si il ne reste plus de case à découvrir
      - le nombre de cases restant à découvrir (hors bombes) sinon
def jouer(grille,ligne, col):
    # YOUR CODE HERE
    raise NotImplementedError()
grille = [[0, 2, 0], [1, 2, 0], [0, 0, 2]]
assert jouer(grille,0,0) == 4
assert jouer(grille, 1,0) == -1
# Dérouler une partie
grille = creer_grille(10, 0.2)

jouer(grille,5,5)
jouer(grille,0,0)
jouer(grille,9,9)
grille