Hackaton 2025

Un labyrinthe qui prend du gras

Détails
Catégorie : Hackathon 2025
Affichages : 64

Un labyrinthe qui prend du gras.

1°/ Objectif

Le problème est de transformer un labyrinthe généré avec des cases dont les murs sont "fins" en un labyrinthe à murs "épais". Par exemple, les figures ci-dessous donnent l'aspect d'un labyrinthe avant et après la transformation.

laby1-fat
Labyrinthe de 4x6 cases, à murs fin Conversion du labyrinthe : 9x13 cases, avec murs épais

 

  • D'un point de vue programmation, un labyrinthe est représenté par un tableau à 2 dimensions, chaque élément représentant une case (i,j) du tableau.
  • Dans le cas d'un labyrinthe à murs fins, une case contient une valeur qui dépend du nombre de murs qui l'entourent, ce qui donne 16 valeurs possibles.
  • Dans le cas d'un labyrinthe à murs épais, chaque case contient une valeur représentant soit un mur, soit un chemin.

 2°/ A faire

Vous devez créer un fichier .java contenant obligatoirement tout le code nécessaire. Vous êtes donc obligé de mettre plusieurs classes dans un même fichier. Pour vous simplifier la tâche (à priori), vous pouvez trouver un canevas de code à télécharger : [ ici ]. (Pour télécharger le fichier directement, faites un clic droit, puis "Enregistrer sous")

Les contraintes sont les suivantes :

  • Votre programme va recevoir toutes les données nécessaires sur l'entrée standard et écrire le résultat sur la sortie standard.
  • C'est pourquoi l'exemple utilise un BufferedReader sur System.in pour lire des lignes de texte sur l'entrée standard, et que vous devrez afficher votre résultat en utiliser System.out.println().
  • Votre programme va d'abord recevoir une ligne au format : nbrow,nbcol
  • nbrow correspond au nombre de lignes du labyrinthe à convertir et nbcol, le nombre de colonnes.
  • Ensuite, viennent nbrow lignes de texte, chacune contenant une liste de nbcol éléments séparés par des virgules.
  • De ce fait, le j-ième élément de la i-ième ligne lue représente la case (i,j) du labyrinthe.
  • Chaque case (i,j) prend une valeur de 0 à 15 indiquant les murs entourant la case.
  • La valeur 0 signifie que la case est complètement entourée de murs (ce qui ne devrait jamais être le cas)
  • La valeur 1 signifie que la case est ouverte au nord, donc qu'il y a des murs à l'ouest, sud et est.
  • La valeur 2 signifie que la case est ouverte à l'ouest, donc qu'il y a des murs au nord, sud et est.
  • La valeur 4 signifie que la case est ouverte au sud, donc qu'il y a des murs à l'ouest, nord et est.
  • La valeur 8 signifie que la case est ouverte à l'est, donc qu'il y a des murs à l'ouest, sud et nord.
  • Une addition entre 2, 3 ou 4 de ces valeurs donne une des autres 11 possibilités. Par exemple, 3 signifie que la case est ouverte au nord et à l'ouest, 15 signifie qu'elle est ouverte de tous les côtés.
  • La conversion doit produire un labyrinthe de convnbrow = 1+2*nbrow lignes et convnbcol = 1+2*nbcol colonnes.
  • Chaque case du labyrinthe résultat contient soit un espace (= une case chemin), soit un # (= une case mur).
  • Votre programme doit d'abord afficher la taille du résultat, au format : convnbrow,convnbcol
  • Ensuite, il écrit chaque ligne du résultat, sous la forme d'une suite de convnbcol caractères valant espace ou #.
 
3°/ Pour tester votre programme

Comme indiqué dans le canevas de code, vous pouvez utiliser des fichiers d'exemples (à télécharger [ ici ] pour vérifier si votre programme fonctionne correctement. 
Ces fichiers sont lisibles dans un éditeur de texte mais ne les modifiez pas. Pour lancer votre programme avec ces fichiers de test, suivez les indications données dans le canevas.
Par exemple, le fichier maze_C1-test1.csv contient :
1
2
3
4
5

4,6
8,10,14,10,14,2
12,6,5,12,15,6
1,5,1,5,13,3
8,11,10,3,9,10

 


Et le résultat produit par : java ExoLaby1 <maze_C1-test1.csv doit être :
1
2
3
4
5
6
7
8
9
10

9,13
#############
#           #
##### ### ###
#   # #     #
# # # # #   #
# # # # #   #
### ### # ###
#       #    
#############

 

Remarques :
  • Chaque ligne doit contenir exactement convnbcol caractères espace ou dièse, plus un \n (retour à la ligne) à la fin.
  • Ces 3 labyrinthes ont une sortie unique qui est placée sur le pourtour. Cela vaut également pour les labyrinthes qui seront créées lors des tests de soumission (cf. ci-dessous).

4°/ Soumettre votre programme
  • Une fois que vous obtenez un résultat à priori cohérent sur les 3 exemples, utilisez le site domjudge pour soumettre votre solution.
  • Votre programme va être testé avec 3 labyrinthes de taille croissante, tirés aléatoirement, avec une unique sortie.