Terminale NSI.

Projet “Labyrinthe”

Thésée terrassant le minotaure. Mosaïque romaine v 275-350, Vienne Kunsthistorisches Museum

Présentation 2

Algorithmes 2

Objectif 4

Déroulé 5

Travail à faire 6

Ressources 6

Evaluation 7

1
Présentation
Il s’agit d’un projet dans lequel s'affrontent les créateurs de labyrinthe et ceux qui doivent en
sortir. Les créateurs de labyrinthe vont créer aléatoirement des labyrinthes aussi grands que
l’on veut. Ceux qui doivent en sortir doivent choisir deux cases du labyrinthe au hasard, et
trouver un chemin pour en sortir.

Algorithmes
L’algorithme proposé de création de labyrinthe est relativement simple.
Au début, le labyrinthe est constitué de cases toutes séparées par des murs.

L’idée est de partir d’une case, et de creuser le labyrinthe en partant de cette case.
On part donc d’une case au hasard, elle est reliée aux autres cases par 2 (si elle est dans
un coin), 3 (si elle est sur un bord) ou 4 murs.

On casse un de ces murs, au hasard, on a donc maintenant une zone de 2 cases contigües.

1 2

2
Cette zone est reliée aux autres cases par des murs, on en casse un au hasard, on a donc
maintenant une zone de 3 cases contigües.

1 2

On continue, et de proche en proche on a couvert tout le labyrinthe.

10 6 7

5 1 2 4

3 9

L’algorithme d’exploration du labyrinthe est simplement un parcours des cases du labyrinthe,

tout comme on parcourt un graphe: en effet, une fois donné un labyrinthe, on peut
représenter ses cases sous forme d’un graphe.

Deux remarques:
1. Cet algorithme va engendrer un labyrinthe dit “parfait” (il existe un unique chemin
entre deux cases quelconques). On l’appelle parfois l’algorithme de Prim.
2. Il existe d’autres algorithmes de génération de labyrinthes.

3
Objectif
Vous devez programmer:

● une fonction creeLaby(longueur,largeur) qui implémente l’algorithme de

création du labyrinthe de longueur et de largeur donnés,
● une fonction afficheLaby(laby) qui affiche le labyrinthe,
● une fonction stockeLaby(laby) qui le stocke dans un fichier sous forme de
chaîne de caractères,
● une fonction trouveChemin(laby, depart, arrivee) qui, à partir de deux
cases quelconques du labyrinthe, trouve un chemin entre ces deux cases,
● une fonction afficheChemin(laby,chemin) qui affiche le chemin entre les deux
cases,
● une fonction resoudLaby(nomfichier)qui prend un fichier texte représentant un
labyrinthe avec 2 cases de départ et d’arrivée et affiche la solution.

Vous devrez obligatoirement utiliser les classes suivantes.

# classes pour les labyrinthes

class Labyrinthe:
def __init__(self,la,ha):
self.largeur = la
self.hauteur = ha
self.tableau = [[Cellule(i,j) for j in range(la)] for i in range(ha)]

class Cellule:
def __init__(self,li,col):
self.ligne = li
self.colonne = col
self.voisines = {'N':None , 'S':None , 'E': None, 'O': None }
self.connectees = {'N':None , 'S':None , 'E': None, 'O': None }

4
Par exemple, pour le labyrinthe ci-contre on peut le coder ainsi:

Lab = Labyrinthe(2,2)
c1 = Lab.tableau[0][0]
c2 = Lab.tableau[0][1]
c3 = Lab.tableau[1][0]
c2 = Lab.tableau[1][1]

c1.voisines[‘E’] = c2
c1.voisines[‘S’] = c3
c2.voisines[‘O’] = c1
c2.voisines[‘S’] = c4
c3.voisines[‘E’] = c4
c3.voisines[‘N’] = c1
c4.voisines[‘O’] = c3
c4.voisines[‘N’] = c2

c1.connectees[‘E’] = c2
c2.connectees[‘O’] = c1
c2.connectees[‘S’] = c4
c3.connectees[‘E’] = c4
c4.connectees[‘O’] = c3
c4.connectees[‘N’] = c2

Un exemple d’impression d’un labyrinthe(10x10), en utilisant la

barre du 6 et le tiret du 8:

Déroulé

Date Contenu

Lundi 1er mars Lancement du projet

Jeudi 4 mars Point d’étape individuel 1 (travail réalisé, objectifs)

Vendredi 5 mars Point d’étape individuel 2 (travail réalisé, objectifs)

Lundi 8 mars Point d’étape individuel 3 (travail réalisé, objectifs)

Jeudi 11 mars Point d’étape individuel 4 (travail réalisé, objectifs)

Vendredi 12 mars 8h Finalisation du projet et du document de présentation.

Vendredi 12 mars 9h Soutenance

5
Travail à faire
1. Rendre un dossier contenant les fichiers python, dont l’un s’appelant main.py
contient les fonctions demandées.
2. Préparer pour la présentation un diaporama expliquant le fonctionnement de votre
programme. Il contiendra les éléments listés ci-dessous.

● intitulé et objectif du projet

● méthode suivie
● déroulement du projet (jour par jour)
● description du fonctionnement du code
● objectifs atteints
● difficultés rencontrées

Ressources
Lecture et écriture dans un fichier avec Python:
https://python.sdv.univ-paris-diderot.fr/07_fichiers/

La génération de labyrinthes paru dans GnuLinux Mag France n°62, juin 2004:
https://ilay.org/yann/articles/maze/

Génération et résolution de labyrinthes (projet étudiant sur le WIKI du Laboratoire de

mathématiques de l’université de Savoie (Lama)):
https://www.lama.univ-savoie.fr/mediawiki/index.php/G%C3%A9n%C3%A9ration_et_r%C3
%A9solution_de_labyrinthes_II

Un joli générateur de labyrinthe très visuel sur le site hurna.io:

https://hurna.io/fr/academy/algorithms/explorers/maze_generator/prim_s.html

Un article (en anglais) avec une belle illustration de la construction d’un labyrinthe 3x3 avec
l’algorithme de Prim:
http://weblog.jamisbuck.org/2011/1/10/maze-generation-prim-s-algorithm

6
Evaluation
Grille d’évaluation projet 4

Compétences analyser un problème en terme de flux de 2

informatiques traitements et d’information:
interactions entre les différentes parties
bien comprises
vu lors des points d’étape

Décomposer un problème en sous-problèmes; 1

reconnaître/réutiliser des solutions
Utilisation des objets correcte
vu lors des points d’étape

concevoir des solutions: 2

%age de réussite

traduire un algorithme dans un langage: 5

● Code commenté
● bonne utilisation des objets

TOTAL 10

Compétences Autonomie, initiative, créativité 4

transversales Jokers, Idées personnelles
vu lors des points d’étape

présenter un problème 3
Qualité de la présentation

rechercher de l’information, 2
utilisation des documents et des sites vus
en classe, utilisation des ressources
vu lors des points d’étape

coopérer dans une équipe 1

vu lors des points d’étapes

TOTAL 10

NOTE /20

Remarques