Le jeu du taquin, ou puzzle coulissant, est traditionnellement composé de tuiles numérotées ou avec des lettres, réparties dans une grille de 5 × 5, laissant un emplacement vide permettant de faire glisser les pièces. Le but du jeu est de replacer les tuiles dans l'ordre en les déplaçant une par une, uniquement en utilisant la case libre. À chaque déplacement, une lettre voisine de l’espace vide peut être coulissée dans celui-ci, créant une nouvelle configuration.

Le défi consiste à prévoir plusieurs coups à l’avance, car une erreur peut rendre la résolution plus complexe. Ce puzzle développe à la fois la logique, la mémoire spatiale et la patience. Le joueur doit souvent décomposer son objectif en petites étapes, réorganiser des lignes entières ou créer temporairement des désordres stratégiques pour atteindre la position souhaitée.

Le taquin à 24 lettres est ainsi un jeu ludique, mais aussi un excellent exercice d’organisation mentale et de résolution de problèmes.

Le programme doit :

1. mélanger les 25 tuiles ;

2. placer les tuiles dans la grille ;

3. afficher la grille mise à jour ;

4. rechercher les tuiles qui peuvent bouger ;

5. demander à l'utilisateur la tuile qu'il souhaite bouger ;

6. déplacer la tuile choisie et un nouvel emplacement vide ;

7. vérifier si les tuiles sont complétement ordonnées ;

8. si oui, proposer de faire une autre partie ;

9. si non, recommencer depuis afficher la grille ;

10. quitter le programme.

D'abord, faite-le fonctionner. Ensuite, faite-le beau. Enfin, faite-le performant.

Amusez-vous bien !

Télécharger RETROGICIEL - Taquin.

Cette présentation nécessite que Python 3 soit installé sur votre machine.

Après avoir téléchargé le fichierTaquin.7z, décompressez-le dansle répertoire de votre choix.

Ouvrez le répertoire qui vient d'être créé.

Lancez le fichier Retrogiciel.py.

Cliquez sur l'onglet RUN et testez le programme.

Créez votre propre script dans un des langages proposés ou un autre de votre choix.

Le répertoire contient aussi : 

- Python.py, l'exemple en PYTHON sans tkinter ;

- Tkinter.py, l'exemple en PYTHON avec tkinter ;

- Qb84.bas, l'exemple en QBASIC avec qb64 ;

- Bbc.bas, l'exemple en BBC BASIC avec bbc sdl.

# --- Origine Nerd ---

# --- RETROGICIEL - PYTHON ---

# --- Taquin ---

# -*- coding: utf-8 -*-

# --- IMPORTATION DES MODULES  ---

import random

# --- INITIALISATION GÉNÉRALE  ---

LST_Tuiles = [ klettre for klettre in "ABCDEFGHIJKLMNOPQRSTUVWX " ]

# --- DÉFINITION DES FONCTIONS PERSONNALISEES  ---

# --- Affichage du taquin ---

def FNC_Affichage ( ) :

print ( LST_Tuiles [ 0 : 5 ] )

print ( LST_Tuiles [ 5 : 10 ] )    

print ( LST_Tuiles [ 10 : 15 ] )

print ( LST_Tuiles [ 15 : 20 ] )    

print ( LST_Tuiles [ 20 : 25 ] )

# --- Choix de la tuile à bouger par l'utilisateur  ---

def FNC_Choix ( ) :

# --- Recherche des tuilles pouvant bouger ---

klibre = LST_Tuiles.index ( " " )

kpossibles = ""

kpossibles += LST_Tuiles [ klibre - 5 ] if klibre > 4 else ""

kpossibles += LST_Tuiles [ klibre - 1 ] if ( klibre % 5 ) != 0 else ""

kpossibles += LST_Tuiles [ klibre + 1 ] if ( klibre % 5 ) != 4 else ""

kpossibles += LST_Tuiles [ klibre + 5 ] if klibre < 20 else ""

# --- Saisie et validation du choix  ---

while True :

kchoix = input ( f"Quelle tuile voulez-vous bouger ({ kpossibles }) ? " )

if kchoix.upper () in kpossibles and kchoix != "" : break

print ("choix non valide !\n" )

# --- Déplacement de la tuile choisie  ---

kbouge = LST_Tuiles.index ( kchoix.upper () )

LST_Tuiles [ klibre ] , LST_Tuiles [ kbouge ] = LST_Tuiles [ kbouge ] , LST_Tuiles [ klibre ]

# --- Nouvelle partie ---

def FNC_Jouer ( ) :

ktour = 0

random.shuffle ( LST_Tuiles )

while True :

ktour += 1

print ( f"\ntour : { ktour }." )

FNC_Affichage ( )

FNC_Choix ( )

if "".join ( LST_Tuiles ) == "ABCDEFGHIJKLMNOPQRSTUVWX " : break

# --- PRESENTATION ---

print ( "FAISONs UN TAQUIN.\n" )

print ( )

# --- BOUCLE PRINCIPALE ---

while True :

# --- Mélange aléatoire des tuiles ---

FNC_Jouer ( )

FNC_Affichage ( )

print ( "\n\u2606\u2606\u2606 FELICITATION \u2606\u2606\u2606" )

print ( "\u272e\u272e\u272e C'est  gagné \u272e\u272e\u272e" )

# --- Choix du bouclage du programme ---

kchoix = input ( "\nUne autre partie PGDC (O ou N) ?" )

if kchoix.upper ( ) == "N" : break

# --- FIN DU PROGRAMME ---

print ( "Au revoir" )

# --- Programme : JFB ---

# --- Décembre 2025 ---

# --- Fin ---

Pour mieux comprendre l'exemple en PYTHON sans tkinter.

# --- Origine Nerd ---

# --- RETROGICIEL - TKINTER ---

# --- Taquin ---

# -*- coding: utf-8 -*-

# --- IMPORTATION DES MODULES ---

# --- Modules de la bibliothèque standard ---

import tkinter

import random

# --- INITIALISATION GÉNÉRALE ---

LST_Tuiles = [ klettre for klettre in "ABCDEFGHIJKLMNOPQRSTUVWX " ]

LST_Boutons = [ ]

LST_Possibles = [ ]

# --- DÉFINITION DES FONCTIONS PERSONNALISEES ---

# --- Initialisation d'une nouvelle partie ---

def FNC_Nouveau ( ) :

BUT_Nouveau [ "state" ] = "disabled"

LAB_Tours [ "text" ] = "Tour : 1" 

random.shuffle ( LST_Tuiles )

for kindex in range ( 25 ) :

LST_Boutons [ kindex ] [ "text" ] = LST_Tuiles [ kindex ]

LST_Boutons [ kindex ] [ "state" ] = "disabled"

LST_Boutons [ kindex ] [ "background" ] = "palegreen"

FNC_Possibles ( )

# --- Recherche les tuilles mobiles et MaJ du plateau de jeu ---

def FNC_Possibles ( ) :

klibre = LST_Tuiles.index ( " " )

LST_Possibles.clear ( )

if klibre > 4 : LST_Possibles.append ( LST_Boutons [ klibre - 5 ] )

if ( klibre % 5 ) != 0 : LST_Possibles.append ( LST_Boutons [ klibre - 1 ] )

if ( klibre % 5 ) != 4 : LST_Possibles.append ( LST_Boutons [ klibre + 1 ] )

if klibre < 20 : LST_Possibles.append ( LST_Boutons [ klibre + 5 ] )

for kbouton in LST_Possibles :

kbouton [ "state" ] = "normal"

kbouton [ "background" ] = "aqua"

# --- Choix du joueur ---

def FNC_Action ( Q ) :

ktour = int ( LAB_Tours [ "text" ].split ( ":" ) [ 1 ] ) + 1

LAB_Tours [ "text" ] = f"Tour : { ktour }"

klibre = LST_Tuiles.index ( " " )

LST_Boutons [ klibre ] [ "text" ] = LST_Boutons [ Q ] [ "text" ]

LST_Boutons [ Q ] [ "text" ] = ""

LST_Tuiles [ klibre ] , LST_Tuiles [ Q ] = LST_Tuiles [ Q ] , LST_Tuiles [ klibre ]   

for kbouton in LST_Possibles :

kbouton [ "state" ] = "disabled"

kbouton [ "background" ] = "palegreen"

if "".join ( LST_Tuiles ) == "ABCDEFGHIJKLMNOPQRSTUVWX " : BUT_Nouveau [ "state" ] = "normal" 

else : FNC_Possibles ( )

# --- CREATION DE L'INTERFACE GRAPHIQUE ---

# --- Création de la fenêtre principale ---

TKI_Principal = tkinter.Tk ( )

TKI_Principal.title ( "RETROGICIEL -Taquin" )

# --- Création des variables de controles ---

BUT_Nouveau = tkinter.Button ( TKI_Principal , text = "Nouveau" , command = FNC_Nouveau )

LAB_Tours = tkinter.Label ( TKI_Principal , text = "Tour : 0" )

# --- Création des controles nommées ---

FRM_Plateau = tkinter.Frame ( TKI_Principal , width = 249 , height = 249 )

for ktuile in range ( 25 ) :

kabscisse = ( ktuile % 5 ) * 50

kordonnee = ( ktuile // 5 ) * 50

kbouton = tkinter.Button ( FRM_Plateau , 

font = ( None , 18 ) , 

foreground = "blue" , 

disabledforeground = "green" , 

relief = "solid" , 

command = lambda k = ktuile : FNC_Action ( k ) )

kbouton.place ( x = kabscisse , y = kordonnee , width = 49 , height = 49 , anchor = "nw" )

LST_Boutons.append ( kbouton )

# --- Mise en place des controles (anonymes et nommés) dans la fenêtre principale ---

LAB_Tours.pack ( fill = "both" )

FRM_Plateau.pack ( fill = "both" )

BUT_Nouveau.pack ( fill = "both" )

tkinter.Button ( TKI_Principal , text = "Quitter" , command = TKI_Principal.destroy ).pack ( fill = "both" )

# --- Mise à jour de controle ---

FNC_Nouveau ( )

# --- DEBUT DU PROGRAMME ---

TKI_Principal.mainloop ( )

# --- Programme : JFB ---

# --- Décembre 2025 ---

# --- Fin ---

Pour mieux comprendre l'exemple en PYTHON avec tkinter.

' --- Origine Nerd propose pour ---

' --- RETROGICIEL - QB64 ---

' --- Taquin ---

' --- INITIALISATION GENERALE ---

' --- Declarations des variables globales ---

DIM SHARED LST_Suite$(24)

FOR kindex = 0 TO 23: LST_Suite$(kindex) = CHR$(65 + kindex): NEXT kindex

LST_Suite$(24) = " "

' --- Initialisation des nombres aléatoires ---

RANDOMIZE TIMER

' --- DEBUT DU PROGRAMME ---

LOCATE 1, 31: PRINT "FAISONS UN TAQUIN."

PRINT

' --- BOUCLE PRINCIPALE ---

DO

' --- Demarer une nouvelle partie ---

FNC_Melange

FNC_Jouer

LOCATE 11, 34: PRINT "FELICITATION"

LOCATE 12, 34: PRINT "C'est gagne."

' --- Bouclage du programme ---

PRINT

INPUT "Voulez-vous recommencer [ O ou N ] "; kchoix$

LOOP UNTIL UCASE$(kchoix$) = "N"

' --- FIN DU PROGRAMME ---

PRINT "Au revoir."

END

' --- DEFINITION DES FONCTIONS PERSONNALISEES ---

' ---  Affichage de la grille du taquin ---

SUB FNC_Affichage

FOR kindex = 0 TO 24

kcolonne = 35 + ((kindex MOD 5) * 2)

kligne = 5 + (kindex \ 5)

LOCATE kligne, kcolonne: PRINT LST_Suite$(kindex)

NEXT kindex

END SUB

' --- Choix de la tuile a bouger par l'utilisateur  ---

SUB FNC_Choix

' --- Recherche de la tuile vide ---

FOR klibre = 0 TO 24

IF LST_Suite$(klibre) = " " THEN EXIT FOR

NEXT klibre

' --- Recherche des tuiles qui peuvent bouger ---

kpossibles$ = ""

IF klibre > 4 THEN kpossibles$ = kpossibles$ + LST_Suite$(klibre - 5)

IF (klibre MOD 5) <> 0 THEN kpossibles$ = kpossibles$ + LST_Suite$(klibre - 1)

IF (klibre MOD 5) <> 4 THEN kpossibles$ = kpossibles$ + LST_Suite$(klibre + 1)

IF klibre < 20 THEN kpossibles$ = kpossibles$ + LST_Suite$(klibre + 5)

' --- Saisie et validation du choix  ---

LOCATE 11, 34: PRINT "Votre choix"

LOCATE 12, 37: PRINT kpossibles$; " ? "

DO

kchoix$ = INKEY$

IF kchoix$ <> "" THEN kchoix$ = UCASE$(kchoix$) ELSE kchoix$ = "?"

LOOP UNTIL INSTR(kpossibles$, kchoix$) <> 0

' --- Place de la tuile qui bouge ---

FOR kchoix = 0 TO 24

IF LST_Suite$(kchoix) = kchoix$ THEN EXIT FOR

NEXT kchoix

' --- Deplacement de la tuile choisie  ---

SWAP LST_Suite$(klibre), LST_Suite$(kchoix)

END SUB

' ---  Jouer une partie ---

SUB FNC_Jouer

ktour = 0

DO

ktour = ktour + 1

LOCATE 3, 36: PRINT "Tour"; STR$(ktour)

FNC_Affichage

FNC_Choix

FOR kindex = 0 TO 23

IF LST_Suite$(kindex) <> CHR$(65 + kindex) THEN EXIT FOR

NEXT kindex

LOOP UNTIL kindex = 23

END SUB

' ---  Melange aléatoire des lettres ---

SUB FNC_Melange

FOR kindex = 24 TO 1 STEP -1

ktempo = INT(RND * kindex)

SWAP LST_Suite$(kindex), LST_Suite$(ktempo)

NEXT kindex

END SUB

' --- FIN DU PROGRAMME ---

PRINT "Au revoir."

END

' --- Programme : JFB ---

' --- Decembre 2025 ---

' --- Fin ---

Pour mieux comprendre l'exemple en QB64.

REM --- Origine Nerd propose pour ---

REM --- RETROGICIEL - BBC BASIC ---

REM --- Taquin ---

REM --- INITIALISATION GENERALE ---

REM --- Déclarations des variables globales ---

DIM LST_Suite$(24)

FOR kindex = 0 TO 23: LST_Suite$(kindex) = CHR$(65 + kindex): NEXT kindex

LST_Suite$(24) = " "

REM --- Preparation de la fenetre de sortie ---

MODE 6 : COLOUR 142 : CLS

REM --- DEBUT DU PROGRAMME ---

COLOUR 13 : PRINT TAB( 11 , 1 ) "FAISONS UN TAQUIN."

VDU 28 , 0 , 25 , 40 , 3

REM --- BOUCLE PRINCIPALE ---

REPEAT

REM --- Demarer une nouvelle partie ---

PROC_Melanger

PROC_Jouer

COLOUR 139 : COLOUR 9

PRINT TAB( 14 , 11 ) " FELICITATION "

PRINT TAB( 14 , 12 ) " C'est gagne. "

REM --- Bouclage du programme ---

COLOUR 142 : COLOUR (

INPUT TAB( 6 , 18 ) "Une autre partie [ O ou N ] "; kchoix$

UNTIL kchoix$ = "N" OR kchoix$ = "N"

REM --- FIN DU PROGRAMME ---

PRINT "Au revoir."

END

REM --- DEFINITION DES FONCTIONS PERSONNALISEES ---

REM ---  Affichage de la grille du taquin ---

DEF PROC_Affichage

COLOUR 12

FOR kindex = 0 TO 24

kcolonne = 16 + ((kindex MOD 5) * 2)

kligne = 5 + (kindex DIV 5)

PRINT TAB( kcolonne, kligne) LST_Suite$(kindex)

NEXT kindex

ENDPROC

REM --- Choix de la tuile a bouger par l'utilisateur  ---

DEF PROC_Choix

REM --- Recherche des tuiles qui peuvent bouger ---

kpossibles$ = ""

FOR klibre = 0 TO 24

IF LST_Suite$(klibre) = " " THEN EXIT FOR klibre

NEXT klibre

IF klibre > 4 THEN kpossibles$ += LST_Suite$(klibre - 5)

IF (klibre MOD 5) <> 0 THEN kpossibles$ += LST_Suite$(klibre - 1)

IF (klibre MOD 5) <> 4 THEN kpossibles$ += LST_Suite$(klibre + 1)

IF klibre < 20 THEN kpossibles$ += LST_Suite$(klibre + 5)

REM --- Saisie et validation du choix  ---

COLOUR 7 : PRINT TAB( 15 , 11 ) "Votre choix"

COLOUR 0 : PRINT TAB( 18 , 12 ) kpossibles$; " ? "

REPEAT

kchoix$ = GET$

IF ASC( kchoix$ ) > 90 THEN kchoix$ = CHR$( ASC( kchoix$ ) - 32 )

UNTIL INSTR(kpossibles$, kchoix$) <> 0

REM --- Deplacement de la tuile choisie ---

FOR kchoix = 0 TO 24

IF LST_Suite$( kchoix ) = kchoix$ THEN EXIT FOR kchoix

NEXT kchoix

SWAP LST_Suite$(klibre), LST_Suite$(kchoix)

ENDPROC

REM ---  Jouer une partie ---

DEF PROC_Jouer

ktour = 0

REPEAT

ktour += 1

COLOUR 6 : PRINT TAB( 17, 3 ) "Tour " ; STR$( ktour )

PROC_Affichage

PROC_Choix

FOR kindex = 0 TO 23

IF LST_Suite$(kindex) <> CHR$(65 + kindex) THEN EXIT FOR kindex

NEXT kindex

UNTIL kindex = 23                                          

ENDPROC

REM --- Melanger aleatoirement les lettres ---

DEF PROC_Melanger

FOR kindex = 24 TO 1 STEP -1

ktempo = RND(kindex)

SWAP LST_Suite$(kindex), LST_Suite$(ktempo)

NEXT kindex

ENDPROC

REM --- Programme : JFB ---

REM --- Decembre 2025 ---

REM --- Fin ---

Pour mieux comprendre l'exemple en BBC BASIC.