ï¿½ï¿½Rï¿½solution d un programme de type Griddlers

Résolution d’un programme de type Griddlers

Projet tutoré 2ème année Cet exposé propose une résolution d’un nonogramme à l’aide d’un logiciel programmé en langage C.

BARROS Anthony

BENE Samuel

CORREA Loup

SAUVADET Michael

VERDIER David

Département

Mesures Physiques

Projet Tutoré N°9 Résolution d’un programme de type

Griddlers

2ème Année

2008 - 2009

1

Nous voudrions remercier M. Yan Gérard, responsable de notre projet, qui nous a

beaucoup aidés tout au long de ce projet.


Griddlers

2ème Année

2008 - 2009

2

Sommaire

I. Introduction ..............................................................................................................3

II. Présentation des griddlers .........................................................................................4

A. Historique .............................................................................................................4

B. Comment jouer au Griddlers ? ..............................................................................5

C. La théorie de la complexité ...................................................................................6

1. Définition de la complexité................................................................................6

2. Dualité entre les classes. ....................................................................................7

III. Comment résoudre un griddlers ? ..........................................................................8

A. Méthodes de résolution à la main ..........................................................................8

B. Le langage C .........................................................................................................9

C. Présentation du programme de résolution ..............................................................9

3. Fonctionnement de la fonction de remplissage : .................................................9

4. Fonctionnement d’une fonction récursive : ...................................................... 10

IV. Le programme GridResolv .................................................................................. 12

A. Les problèmes rencontrés .................................................................................... 12

1. L’avancement primaire du programme ............................................................ 12

2. Avancement secondaire : les pointeurs ............................................................ 13

B. Effectuer des tests ............................................................................................... 14

C. Les fonctions intermédiaires ............................................................................... 20

1. La fonction d’initialisation .............................................................................. 20

2. La fonction de remplissage évident .................................................................. 21

3. La fonction de remplissage principal ............................................................... 26

4. La fonction récursive ....................................................................................... 28

D. La fonction principale ......................................................................................... 30

V. Conclusion ............................................................................................................. 32

VI. Bibliographie ...................................................................................................... 33


Griddlers

2ème Année

2008 - 2009

3

I. Introduction

Les nonogrammes, jeux de logiques tels que les sudoku, kakuro, ou encore griddlers,

sont des passes temps très populaires ; à tel point que tous les magazines, périodiques ou

journaux, en particulier au japon, en publient chaque jour (majoritairement des sudoku pour la

France).

Ainsi des programmes de résolution sont nécessaires pour valider, infirmer, voire

créer, ces grilles logiques. Cet exposé présente un exemple de programme permettant de

solutionner des nonogrammes appartenant aux problèmes difficiles à résoudre.

Tout d’abord un bref historique est dressé, puis l’avancement des méthodes à privilégier

pour la résolution avec les limites et les difficultés rencontrées sont détaillées, et enfin le

programme final est présenté et expliqué dans son intégralité.

Figure 1 : Symbole de propagande du langage C


Griddlers

2ème Année

2008 - 2009

4

II. Présentation des griddlers

A. Historique

Le griddlers, de son nom d’origine le Picross ou nonogram ou encore hanjie, est un jeu de

réflexion solitaire qui consiste à découvrir un dessin sur une grille en coloriant des cases,

d’après des indices logiques situés sur les bords gauche et haut de celle-ci.

Figure 2 : Exemple d’un griddlers coloré en forme de fleur

Les origines de ces jeux logiques tels que le sudoku ou le kakuro sont assez récentes : de

l’ordre du siècle. En ce qui concerne les picross, un périodique italien, le « Stephenson’s

train » en fait mention en 1925.

Plus récemment, au Japon, Non Ichida, graphiste, pour les besoins d’un concours, créé

une image sur un immeuble de Tokyo, en allumant et en éteignant les fenêtres de ce dernier.

A la suite de cet épisode elle met en place les règles du hanjie et publie trois grilles dans un

périodique japonais.

Le nom de nonogram apparait en 1990 en Angleterre lorsque Non Ichida fait découvrir

son nouveau jeu au journal anglais « The Telegraph ». Puis en 1998, « The Sunday

Telegraph » lance un concours afin de renommer ces puzzles ; c’est alors que ceux-ci

acquièrent le nom de Griddlers qui est aujourd’hui le nom d’usage.

De nos jours, il existe des sites internet qui, comme les périodiques, publient des grilles de

toutes les tailles et de tous les niveaux moyennant une inscription gratuite ; citons par exemple

le site www.griddlers.net. Il existe aussi des logiciels en vente, comme Griddlers Deluxe

2006, qui permettent de créer ses propres grilles en couleur ou en noir et blanc, à partir par

exemple d’une photo ou d’une image. Le logiciel cité est très performant et est capable de

déterminer si pour une grille donnée, il existe une ou plusieurs solutions. Enfin récemment un

jeu nommé Picross est sorti pour les consoles Nintendo DS, proposant un didacticiel, des

grilles à résoudre, et la possibilité de créer ses propres grilles.

Les règles de ce jeu logique sont présentées plus loin.

http://www.griddlers.net/


Griddlers

2ème Année

2008 - 2009

5

B. Comment jouer au Griddlers ?

Le griddlers est un jeu de logique qui consiste à noircir ou colorier une grille à partir

d’indices donnés dans les cases de conditions. Dans le cas où le griddlers est en couleur

(figure 2), chaque indice est accompagné d’une couleur. Ces derniers ne sont pas abordés

dans cette étude qui se limite aux grilles en noir et blanc

Figure 3 : Exemple d’un griddlers en noir et blanc

Les règles du jeu sont on ne peut plus simple : chaque condition traduit un bloc de cases

noires dont la longueur est celle du chiffre inscrit dans la case des indices. Celles-ci sont

disposées dans l’ordre où elles apparaissent dans la grille. Par déduction successive,

moyennant parfois quelques hypothèses, d’où la nécessité d’utiliser un crayon à papier, on

obtient une figure particulière.

Le griddlers ci-dessus est un exemple, dont nous savons par l’intermédiaire du logiciel

Griddlers Deluxe, qu’il ne possède qu’une seule et unique solution (celle présentée).

L’objectif de notre projet est de parvenir à résoudre n’importe qu’elle grille de taille

10x10 telle que celle présentée sur la figure 3.

Indices sur les colonnes

Indices sur

les lignes

Une

condition =

un bloc de

cases noires


Griddlers

2ème Année

2008 - 2009

6

C. La théorie de la complexité

1. Définition de la complexité.

Résoudre un problème algorithmique en informatique ne se fait pas sans avoir conscience

de sa complexité. C’est en cela que la théorie de la complexité s’attache à évaluer la difficulté

d’un problème posé de façon mathématique.

a. Définition.

Dans cette partie, la complexité est définie au niveau informatique du terme ; c’est à dire

au niveau algorithmique. L’estimer, pour un problème possible à résoudre, c’est savoir si un

programme est efficace ou non. La complexité spatiale (espace mémoire nécessaire au

fonctionnement d’un programme) qui n’est pas abordée, se distingue de la complexité

temporelle (temps de traitement de la tâche). Cette dernière peut se définir comme étant le

temps de calcul d’une application (ici un programme en C) qui dépend fortement des

capacités de l’ordinateur employé. Cependant, pour remédier à ces inconvénients, la

complexité n’est plus définie comme étant un temps de calcul d’un programme entier mais

plutôt comme le nombre d’instructions élémentaires exécutées par le processeur pendant le

programme.

b. Les différentes classes de complexité.

Dans le but de pouvoir donner un sens critique à la complexité, les mathématiciens ont

hiérarchisé celle-ci en différents niveaux appelés « classes de complexité ». Ces classes sont

classées suivant qu’elles sont déterministes ou non sur le plan des calculs. Un algorithme est

dit déterministe lorsqu’à chaque étape un seul et unique choix lui permet d’avancer, ce qui

n’est pas le cas des algorithmes non-déterministes pour lesquels plusieurs choix s’offrent à

chaque étape.

Les classes de complexité sont réparties selon le rapport entre leur temps de traitement et

la taille des données qu’il y a en entrée, appelées instance du problème. Les principales

classes de complexité sont les suivantes :

LIN : Un problème de décision est dans LIN s'il peut être décidé par un algorithme

déterministe en un temps linéaire par rapport à la taille de l'instance (donnée source).

P : Un problème de décision est dans P s'il peut être décidé par un algorithme déterministe

en un temps polynomial par rapport à la taille de l’instance. On qualifiera plus simplement le

problème de polynomial.

NP : Un problème de décision pour lequel la réponse oui peut être décidée par un

algorithme non déterministe en un temps polynomial par rapport à la taille de l’instance.

Co-NP (Complémentaire de NP) : Les problèmes de décision quand la réponse est non

avec un algorithme non déterministe en un temps polynomial par rapport à la taille de

l’instance.

EXPTIME : De même que pour P mais avec un temps exponentiel par rapport à la taille

de l’instance.


Griddlers

2ème Année

2008 - 2009

7

L : Un problème de décision qui peut être résolu par un algorithme déterministe en temps

logarithmique par rapport à la taille de l'instance est dans L.

NL : La classe NL s'apparente à la classe L mais sur une machine non déterministe.

PSPACE : Un problème décidable par une machine déterministe en espace polynomial

par rapport à la taille de sa donnée.

NPSPACE : Un problème décidable par une machine non déterministe en espace

polynomial par rapport à la taille de sa donnée.

2. Dualité entre les classes.

a. La dualité P=NP. Une question encore ouverte…

Un algorithme déterministe est un cas particulier d’un algorithme non déterministe ce qui

implique que PNP. Cependant la réciproque, NP P, est loin d’être découverte et

représente la vraie difficulté dans l’égalité P=NP. Il s’agit d’un problème ouvert

d’informatique théorique pour lequel les grands spécialistes conjecturent que les problèmes

NP-Complet (ou NP-difficile) ne sont pas solvables en un temps polynomial. Pourtant,

plusieurs approches ont été tentées, en utilisant des algorithmes d’approximation avec des

nombres aléatoires, des algorithmes stochastiques ou encore des algorithmes par séparation et

évaluation qui permettent de trouver la ou les solutions exactes (le temps n’est alors pas borné

par un polynôme mais reste modéré pour des instances relativement grandes).

b. Les autres dualités.

D’autres dualités entre les classes peuvent être évoquées :

Par exemple si on s’intéresse à l’égalité L = NL ?

PSPACE = NPSPACE est vrai. Par contre NP PSPACE. Donc, avant de résoudre NP

= PSPACE, il faut résoudre PSPACENP soit d’abord P = NP.

Cette inclusion est vérifiée :

L NL P NP PSPACE NPSPACE EXPTIME NEXPTIME.

NL ⊊ PSPACE est vrai donc deux classes au moins entre NL et PSPACE ne sont pas

égales.

P ≠ EXPTIME est aussi vérifié.

Les nonogrammes sont dans la classe des problèmes NP-difficiles, c’est à dire des

problèmes qui ne peuvent être résolus simplement. Autrement dit, on ne peut pas trouver

d’algorithme qui donne la réponse en temps polynomial par rapport à la taille des données.

Dans cette classe on trouve aussi le problème du voyageur de commerce

http://fr.wikipedia.org/wiki/Algorithmique


Griddlers

2ème Année

2008 - 2009

8

III. Comment résoudre un griddlers ?

Il existe plusieurs techniques pour résoudre ce genre de grille logique. Certaines personnes

dotées d’une pertinence inexplicable peuvent résoudre ces grilles à la main en un temps

record. Pour un amateur, des techniques permettent d’aller plus vite.

A. Méthodes de résolution à la main

La première chose à regarder est les indices dont le nombre et très grand, en particulier

plus grand que la moitié du nombre de cases dans la ligne ou la colonne. En commençant par

cela, il est possible de noircir quelques cases qui permettent ensuite d’en noircir d’autres.

Ensuite il faut penser à barrer chaque indice qui a été satisfait et alors barrer les cases qui ne

pourront plus être noircie par la suite. En utilisant juste ces deux méthodes, il est possible de

parvenir à bout d’un bon nombre de grilles.

Figure 4 : Les différentes étapes de résolution d’un griddlers

Parfois, les grilles difficiles nécessitent d’avoir recours à des hypothèses. Le but est alors

de choisir une case, de la noircir, et de continuer la résolution basique jusqu’à finalement

résoudre le griddlers ou bien tomber sur une incohérence ; auquel cas il faut alors effacer tout

ce qui a été noirci jusqu’à l’hypothèse fausse, choisir une autre hypothèse et recommencer. Il

arrive que plusieurs hypothèses enchainées soient nécessaires. Ainsi certain griddlers ne


Griddlers

2ème Année

2008 - 2009

9

laissent découvrir leur image qu’au bout de plusieurs heures. D’où la nécessité de créer des

programmes informatiques pour nous aider lesquels utilisent un langage particulier.

B. Le langage C

Concrètement il est question de créer un programme informatique utilisant le langage C.

Le langage C est un langage de programmation informatique qui permet de faire

l’intermédiaire entre le langage machine de l’ordinateur et le langage assembleur d’un

programme. Apparu au début des années 1970, et développé par Dennis Ritchie et Bell Labs,

il est rapidement devenu un des langages de programmation les plus utilisé au monde. Il a

notamment inspiré le langage Java, PHP, C++, C#.

Figure 4 : Dennis Ritchie, un des concepteurs du langage C

C. Présentation du programme de résolution

Le but de cette étude est de construire un programme en langage C capable de résoudre,

de déterminer la ou les solutions d’une grille proposée dans un temps aussi court que possible.

Pour cela, le programme exécute tout d’abord une fonction de remplissage évident puis une

fonction récursive pour gérer les hypothèses, la manière la plus simple, rapide et efficace pour

résoudre ce genre de problème. Ces deux fonctions sont expliquées par la suite.

3. Fonctionnement de la fonction de remplissage :

La fonction de remplissage utilise les principes de résolution évidents qu’utiliserait

n’importe quelle personne en voulant résoudre une grille logique (expliqués au paragraphe

III-A). Elle utilise les indices dont le nombre est élevé, les indices dont la somme donne le

nombre exact du nombre de cases dans la ligne ou la colonne etc…

Cette fonction à une limite : en effet certaines grilles peuvent être résolues juste avec cette

fonction, mais en général une grille de niveau difficile impose de faire des hypothèses pour

avancer. Ce que ne fait pas cette fonction. La fonction récursive lui vient alors en aide.


Griddlers

2ème Année

2008 - 2009

10

4. Fonctionnement d’une fonction récursive :

La récursivité est une méthode utilisée en mathématique pour démontrer certains

théorèmes dont l’évolution est caractérisée par un entier que l’on appelle rang de la fonction.

Il s’agit d’une démarche qui consiste à faire référence à ce qui fait l'objet de la démarche.

Ainsi l’état de la fonction à un certain rang dépend du résultat de cette même fonction au rang

précédent. La fonction s’appelle elle-même.

Dans le présent problème, au rang 0, la fonction récursive dispose d’une certaine

disposition de la grille, celle obtenue après avoir effectué le remplissage évident. Elle

sélectionne une case dont la valeur n’a pas encore été déterminée par la fonction de

remplissage évident, et la met par hypothèse en noir (à 1). Ensuite le remplissage évident est

activé. Si l’on tombe sur une contradiction, alors la case de départ est forcément blanche (à 0).

La fonction passe toutes les cases les unes après les autres jusqu’à terminer la grille.

La figure 6 schématise ainsi comment sont regroupées ces deux fonctions pour le

programme.

Cette méthode est très couteuse en complexité (exponentielle) : le principal problème

étant le back-track. Ce qui signifie qu’un retour en arrière est toujours délicat à envisager et

très couteux en temps et en espace mémoire. Il faut donc avoir recours à la récursivité le

moins souvent possible. Pour cela, il est plus que nécessaire de posséder une fonction de

remplissage optimale qui envisage un maximum de cas, afin d’éviter l’appel aux hypothèses

et donc à la récursivité.

Figure 5 : le principe du back track

Hypothèse de départ : deux solutions

Deux solutions Deux solutions

Deux solutions

Première solution fausse, voir l’autre solution…

Chemin bloqué, Back-track


Griddlers

2ème Année

2008 - 2009

11

Fig

ure

6 :

Sch

ém

a d

e p

rin

cip

e d

e fo

ncti

on

nem

en

t d

u p

rog

ram

me


Griddlers

2ème Année

2008 - 2009

12

IV. Le programme GridResolv

A. Les problèmes rencontrés

1. L’avancement primaire du programme

La création d’un programme informatique est un parcours semé d’embuche. Nous avons

au départ utilisé les connaissances acquises au cours d’informatique de première année au

département Mesures Physiques pour commencer à coder le programme.

Nous avons tout d’abord commencé par créer différents types de grilles :

Finalement la solution 1 a été retenue par simplicité de programmation. En effet le

remplissage automatique des conditions est plus intéressant et le codage en C plus simple. En

ce qui concerne l’affichage à l’écran de la grille résolue, les deux méthodes sont équivalentes.

Une avancée importante lors de la réalisation de ce projet fût de s’apercevoir de la quasi-

impossibilité de résoudre ce problème en se limitant aux connaissances en informatique que

nous avions au début du projet. La plus grosse part de travail de ce point de vue a été de

l’apprentissage d’un outil de programmation appelé « pointeur », présenté au paragraphe

suivant.

Le problème suivant a été de constater la limite en performances de notre fonction de

remplissage, car impossible de terminer une grille difficile juste en remplissant petit à petit les

cases. Il faut gérer le problème de l’hypothèse. C’est ainsi qu’est venue l’idée d’une fonction

récursive pour la résolution de la grille.

Dans cette première solution il y a trois

tableaux distincts. Ceux du haut et de gauche

se voient remplis des conditions à partir d’un

fichier texte. La grille du milieu est source de

tous les calculs logiques de résolution de la

grille

Dans cette seconde solution un seul

tableau contient les trois du dessus. Le

remplissage des indices est réalisé à la main,

ce qui est un peu long.


Griddlers

2ème Année

2008 - 2009

13

2. Avancement secondaire : les pointeurs

En C, une fonction ne peut renvoyer qu’une seule valeur. Or, dans le cas présent, il

était nécessaire que nos fonctions puissent modifier n*n valeurs, c'est-à-dire l’ensemble des

cases du griddlers. De ce fait, les fonctions utilisées dans le programme ne renvoient rien et se

contentent de modifier la grille. Le problème, qui justifie l’utilisation des pointeurs dont le

fonctionnement est détaillé par la suite, est qu’une fonction, lorsqu’elle reçoit un argument,

effectue en fait une copie de celui-ci. Toutes les opérations sur cet argument sont alors

effectuées sur cette copie, qui n’est plus exploitable au moment où la fonction s’arrête.

En utilisant les pointeurs, ce ne sont plus les valeurs des variables qui sont envoyées

aux fonctions mais leurs adresses. Or, une seule et même variable étant stockée par adresse, et

celle-ci y demeurant jusqu’à interruption du programme, les fonctions peuvent ainsi travailler

sur le même tableau que celui créé dans le main.c et non une réplique.

Pour comprendre comment le pointeur est utilisé un rappel concernant la mémoire est

nécessaire. Celle-ci comporte un nombre conséquent de cases dont chacune possède une

adresse différente et ne peut contenir qu’une et une seule valeur. Tant que l’ordinateur reste

allumé, ou en veille, la mémoire RAM conserve l’information contenue dans ses cases, mais à

la mise hors-tension de l’ordinateur, toutes ces cases repassent à zéro et l’information qui y

est contenue est perdue.

Figure 7 : Représentation de la mémoire vive d’un ordinateur type PC

Lors de la création d’une variable u dans un programme, celle-ci est stocké dans une

case mémoire d’adresse @u. En utilisant le pointeur de cette variable, noté *u, il est possible

de la modifier à la source.

En tapant u, on affiche la valeur de u, tandis qu’en tapant &u, on affiche l’adresse où

elle est contenue. Concrètement un pointeur se code *nomdupointeur, par exemple *p, et en

tapant p = &u, le pointeur contient alors l’adresse où u est stocké.

Par exemple si la valeur de u est 10 et qu’elle est stockée à l’adresse 177450 dans la

mémoire RAM de l’ordinateur, alors le pointeur garde en mémoire l’adresse de valeur

177450.


Griddlers

2ème Année

2008 - 2009

14

Figure 8 : Sauvegarde de l’adresse de u dans le pointeur p

L’important pour le codage des pointeurs en langage C est ceci :

Sur une variable, comme la variable u :

"u" signifie : "Je veux la valeur de la variable u".

"&u" signifie : "Je veux l'adresse où se trouve la variable u".

Sur un pointeur, comme p :

"p" signifie : "Je veux la valeur de p" (cette valeur étant une adresse).

"*p" signifie : "Je veux la valeur de la variable qui se trouve à l'adresse contenue

dans p"

L’intérêt pour nous est de pouvoir ainsi modifier à chaque étape dans la résolution de

notre grille une valeur inconnu, et de décider de renvoyer 1 ou 0.

Afin d’utiliser correctement les pointeurs, il a fallu recréer la forme du tableau de travail de

sorte que celui-ci soit « uni-ligne ». En effet l’appel d’un pointeur de type *p[n1][n2] dans un

tableau à deux dimensions est impossible.

B. Effectuer des tests

Le griddlers est un problème d’existence ou de recherche de solution : « Existe-t-il au

moins une solution, si oui, en trouver une ». La question étant : « Trouver une solution qui

satisfasse les conditions inscrites dans cases des indices ».

Avant de s’attaquer à la résolution d’une grille, il est important de savoir si celle-ci existe.

Pour cela un simple test sur la somme des conditions sur les lignes d’une part, et sur les

colonnes d’autres part permet de vérifier si celle ci à des chances d’avoir une solution. En

effet le nombre de cases dans la grille finie étant fixe, la somme des conditions en ligne doit

être exactement égale à celle sur les conditions en colonnes.

lignes colonnesconditions conditions

p

u u = 10


Griddlers

2ème Année

2008 - 2009

15

Ensuite, un test du même ordre doit être fait en direct et à chaque étape lorsque l’on

commence à remplir des case. Il est nécessaire de vérifier que la mise à 1 ou à 0 d’une case est

en accord avec les conditions respectives en ligne et en colonne. Cette action est lourde et

génère une complexité temporelle supplémentaire, mais elle est néanmoins obligatoire afin

d’obtenir un résultat juste.

Deux possibilités

Résultat juste. Continuer Résultat faux, retour à l’étape précédente

Figure 9 : Exemple de test pour valider l’avancement de la résolution

Voici concrètement comment est codé ce test :

Le même test est effectué en parcourant les colonnes

3 1

3 1 3 1


Griddlers

2ème Année

2008 - 2009

16

Ensuite une fonction Testprincipal est crée :


Griddlers

2ème Année

2008 - 2009

17


Griddlers

2ème Année

2008 - 2009

18


Griddlers

2ème Année

2008 - 2009

19


Griddlers

2ème Année

2008 - 2009

20

C. Les fonctions intermédiaires

Ces fonctions représentent le cœur du programme, en particulier la fonction de

remplissage qui peut constamment être améliorée.

1. La fonction d’initialisation


Griddlers

2ème Année

2008 - 2009

21

2. La fonction de remplissage évident

La même fonction est crée pour les colonnes.


Griddlers

2ème Année

2008 - 2009

22


Griddlers

2ème Année

2008 - 2009

23


Griddlers

2ème Année

2008 - 2009

24


Griddlers

2ème Année

2008 - 2009

25


Griddlers

2ème Année

2008 - 2009

26

3. La fonction de remplissage principal


Griddlers

2ème Année

2008 - 2009

27


Griddlers

2ème Année

2008 - 2009

28

4. La fonction récursive


Griddlers

2ème Année

2008 - 2009

29


Griddlers

2ème Année

2008 - 2009

30

D. La fonction principale


Griddlers

2ème Année

2008 - 2009

31


Griddlers

2ème Année

2008 - 2009

32

V. Conclusion

La résolution d’un nonogramme par un programme informatique est un problème difficile.

La meilleure façon d’améliorer un tel programme est de compléter au maximum la fonction

de remplissage basée sur les méthodes logiques de résolution à la main.

Une extension à la résolution des grilles de taille indéterminée telle que n x p est possible,

à conditions de reconsidérer les bases de la fonction de remplissage.

Une autre étude pourrait être portée sur la résolution des grilles colorées, des grilles

hexagonales, ou encore des griddlers en trois dimensions visualisable seulement sur un

ordinateur.

Figure 10 : Griddlers en trois dimensions


Griddlers

2ème Année

2008 - 2009

33

VI. Bibliographie

Article et sites internet

wikipedia.fr -> Théorie de la complexité

wikipedia.fr -> Le langage C

Le site du zéro -> formation pour apprendre à se servir des pointeurs

Griddlers.net -> Exemple de grille 10 par 10

Logiciels et jeux

Logiciel Griddlers Deluxe

Jeux Picross sur Nintendo DS

ï¿½ï¿½Rï¿½solution d un programme de type Griddlers

Documents

Transcript of ï¿½ï¿½Rï¿½solution d un programme de type Griddlers