Le démineur

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.

In [ ]:
tableau=[[1, 2, 3],[4,5,6], [7,8,9]]
print (tableau[0][2])

Construction d'une grille

Construire une ligne

Ecrire un programme permettant de construire une liste ligne contenant 10 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 fonction ligne.append(0) qui permet d'ajouter un 0 à la liste
In [ ]:
# Votre programme ici 

Vérification : La cellule suivante doit retourner

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
In [ ]:
print(ligne)

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.

In [ ]:
from random import *

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

A présent, utilisez cette astuce de calcul pour créer une ligne contenant 1 de temps en temps avec une probabilité de 0.2.

In [ ]:
# Votre programme ici 

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

[0, 0, 1, 1, 1, 0, 0, 0, 0, 0]
In [ ]:
print(ligne)

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 10 éléments comme précédemment, mais au lieu de mettre 0 ou 1, nous mettrons une ligne que nous construirons selon le procédé déjà utilisé.

conseils :

  • Vous pourrez utiliser deux boucles pour imbriquées l'une dans l'autre.
  • vous pourrez construire votre grille dans une variable grille que vous initialiserez à [ ]
  • Vous remplirez votre grille grâce à l'appel grille.append(ligne) après chaque construction d'une ligne
In [ ]:
from random import *

# votre programme ici

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]]
In [ ]:
grille

Félicitations votre grille est créée !

Jouer un coup

A présent, demander à l'utilisateur de saisir un numéro de ligne et de colonne (entre 0 et 9).

  • Si cela correspond à une case contenant 0, écrire le chiffre 2 dans cette case
  • Si cela correspond à une case contenant 1, afficher "Boooouum"
  • Si cela correspond à une case contenant 2, afficher "Case déjà découverte"

Conseils :

  • On pourra utiliser notre variable grille déjà construite. Pour refaire une grille propre, revalider la cellule permettant de construire cette grille.
  • Pour saisir un nombre, on pourra utiliser :
      l=int(input("Saisir un numero de ligne"))
  • 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
      elif autreCondition :
          bloc d'instructions à réaliser
          si autreCOndition 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]
In [ ]:
# Taper votre code ici

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

In [ ]:
grille

Jouer une partie

A présent, nous voulons jouer une partie entière, à savoir demander à l'utilisateur de jouer un coup jusqu'à ce qu'on tombe sur une mine. Conseils :

  • Ne conaissant pas par avance le nombre de coups à jouer, utiliser une boucle Tant que contenant le programme jouer un coup déjà réalisé
  • Créer une variable booleenne toutVaBien initialisée à True afin de mémorisé quand on tombe sur une mine. En cas d'explosion, on pourra positionner cette variable à False.
In [ ]:
# Recalculer une grille propre en copiant collant le code déjà existant pour fabriquer une grille propre
In [ ]:
# Ecrire le code permettant de jouer une partie ici

Modifier le programme ci-dessus pour mémoriser le nombre de coups utilisés. Afficher le nombre de coup en fin de partie.

Conseil : On pourra utiliser une variable nbCoups initialisée à 0, que l'on incrémentera à chaque tentative.

In [ ]:
# Ecrire le code permettant de jouer une partie ici

Compter le nombre de cases découvertes

Conseil : On pourra utiliser la méthode .count(element) sur chacune des lignes de la grille et ajouter le tout

In [ ]:
# Tapez votre ligne ici
In [ ]:
grille
In [ ]: