Besoin d'aide pour un programme en javas'cool

**blackrose0003** · 26/05/2018, 13h53

Bonjour, j'ai un projet à présenter pour mon oral d'isn,
Avec mon groupe, on a voulu programmé un sudoku en javas'cool, et je n'arrive pas à traduire ces lignes de code.
Je sais qu'elles servent pour qu'il n'y ait pas le même chiffre dans la même colonne, ligne et sous-grilles.
Mais je n'arrive pas à comprendre à quoi servent chacune des lignes.

Quelqu'un pourrait m'aider à traduire ces lignes en français s'il vous plaît ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
boolean creation(int[][]GRILLE, int x, int y) {
   int[] LISTE = new int[4];
   LISTE[0] = random(1, 5);
   for (int l = 1; l < 4; l ++) {
      for (boolean valable = false; ! valable;) {
         LISTE[l] = random(1, 5);
         valable = true;
      for (int c = 0; c < l; c ++) {
            if (LISTE[l] == LISTE[c]) {
               valable = false;
            }}}}
 
   for (int l = 0; l < 4; l ++) {
      if (check(GRILLE, x, y, LISTE[l])) {
         GRILLE[x][y] = LISTE[l];
         if ((x == 3) && (y == 3)) {
            return  true;
         }
         if (x == 3) {
            if (creation(GRILLE, 0, y +1)) {
               return  true;
            }
         } else {
            if (creation(GRILLE, x +1, y)) {
               return  true;
            }}}}
 
   GRILLE[x][y] =0;
   return  false;
}
boolean check(int[][]GRILLE, int x, int y, int a) {
   for (int i = 0; i < x; i ++) {
      if (GRILLE[i][y] == a) {
         return  false;
      }}
   for (int j = 0; j < y; j ++) {
      if (GRILLE[x][j] == a) {
         return  false;
      }}
   int xx = (x /2) *2;
   int yy = (y /2) *2;
   for (int i = 0; i < 2; i ++) {
   for (int j = 0; j < 2; j ++) {
         if (GRILLE[xx + j][yy + i] == a) {
            return  false;
         }
         if ((xx + j == x) && (yy + i == y)) {
            return  true;
         }}}
   return  true;
}

**joel.drigo** · 26/05/2018, 16h48

Salut,

boolean check(int[][]GRILLE, int x, int y, int a) {Que fait cette méthode ?
1. if (GRILLE[ligne][colonne] == a) {return false;}
  si on trouve a dans la case ligne,colonne on retourne false. Donc
  1. Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
3
4
for (int i = 0; i < x; i ++) {
      if (GRILLE[i][y] == a) {
         return  false;
      }}
```
    si on trouve a dans la colonne y, dans l'une des x premières lignes, on retourne false
  2. Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
3
4
   for (int j = 0; j < y; j ++) {
      if (GRILLE[x][j] == a) {
         return  false;
      }}
```
    si on trouve a dans la ligne x, dans l'une des y premières colonne, on retourne false
  Donc si on trouve a dans la partie de la grille entre (0,0) et (x,y) on retourne false.
2. Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
int xx = (x /2) *2;
int yy = (y /2) *2;
```
  A/B*B=B en math. Comme le type est int, A/B donne un int, celui le plus grand inférieur à A/B.
  Donc si x = 5, par exemple, alors x/2 vaut 2, et x*2 vaut 4. Si x=4, alors x/2 vaut 2, et x*2 vaut 4, soit x.
  En résumé, si x est impaire, alors on prend x-1. Et si x est pair, on prend x.
  Idem pour y
3. - Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
for (int i = 0; i < 2; i ++) {
   for (int j = 0; j < 2; j ++) {
```
    On fait varier i et j
    1. qui prennent pour valeur 0 ou 1
    2. donc on a (0,0), (0,1), (1,0) et (1,1)
  - Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
3
         if (GRILLE[xx + j][yy + i] == a) {
            return  false;
         }
```
    Si on trouve a dans la case [xx+j][yy+i], on retourne false. Pour tous les (i,j) dans (0,0), (0,1), (1,0) et (1,1) et les xx et yy calculé précédemment.
  On parcourt une sous grille : si on trouve a dans cette sous grille, on retourne false.
4. A la fin, on fait return true;, soit on retourne vrai par défaut.
5. en résumé, la méthode retourne
  - faux si a est dans la grille (0,0)-(x-1,y-1) (tous index inclus)
  - faux si a est dans la sous grille
    1. (x,y)-(x+1,y+1) si x pair et y pair
    2. (x-1,y)-(x,y+1) si x impair, y pair
    3. (x,y-1)-(x+1,y) si x pair et y impair
    4. (x-1,y-1)-(x,y) si x impair, y impair
    En résumé, chaque grille est une grille 2x2 qui "tourne" autour de x,y.
  - vrai sinon
  Cette méthode permet de déterminer si a est dans la grille à certains endroits.

La partie principale maintenant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

boolean creation(int[][]GRILLE, int x, int y) {

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
   int[] LISTE = new int[4];
   LISTE[0] = random(1, 5);

On commence par créer un tableau de 4 cases et on met un nombre aléatoire entre 1 et 4 inclus, dans la première

for (int l = 1;l < 4; l ++) { : on parcourt les éléments du tableau du deuxième au dernier avec l'indice l.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
      for (boolean valable = false; ! valable;) {
         LISTE[l] = random(1, 5);
         valable = true;
      for (int c = 0; c < l; c ++) {
            if (LISTE[l] == LISTE[c]) {
               valable = false;
            }}}}

ça c'est un peu tordu pour être facilement compris. On a deux boucles :

une sur un booléen, valable. On démarre avec valable = false et on boucle tant qu'il est faux
on commence à chaque itération à mettre un nombre aléatoire dans la case l de LISTE et à dire que valable est vrai.
puis on fait une seconde boucle qui parcourt les éléments dans le tableau LISTE avant LISTE[l], et si l'un d'eux est égal à LISTE[l], alors on dit que valable est false

EN résumé, on place dans chaque case un nombre aléatoire différent (parce qu'il n'a pas déjà été placé dans une case avant).
On a donc juste la liste de nombres 1,2,3,4, dans un ordre aléatoire.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
   for (int l = 0; l < 4; l ++) {
      if (check(GRILLE, x, y, LISTE[l])) {
```
On parcourt la liste des nombres, et pour chacun on vérifie "sa présence" dans la grille en appelant check().
Et si ce n'est pas le cas, on le met dans la grille à l'endroit x,y : GRILLE[x][y] = LISTE[l];

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
         if ((x == 3) && (y == 3)) {
            return  true;
         }

Si on est en x=3, y=3, on a terminé et on retourne à l'appelant. En résumé, si le nombre peut être placé en 3,3, on le fait et on arrête en disant à l'appelant que ça bien été fait.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
         if (x == 3) {
            if (creation(GRILLE, 0, y +1)) {
               return  true;
            }
         }

Si x est 3 alors, on appelle récursivement creation pour la case 0,y+1, et si elle est place bien un nombre, on retourne à l'appelant en disant que ça c'est bien passé, sinon on continue la suite...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
 else {
            if (creation(GRILLE, x +1, y)) {
               return  true;
            }}}}

La suite est on fait la même chose pour x+1, y, et si on arrive toujours pas on boucle pour essayer le nombre suivant dans la boucle

A la fin, après avoir essayer chaque nombre de la liste
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
3
 
   GRILLE[x][y] =0;
   return  false;
```
Si on n'a pas réussi à placer/valider quoique ce soit, on met 0 dans la case de grille et on retourne false

Pour le décodage de cette boucle+récursivité, en français :
Si on veut parcourir (toutes les cases d') une grille, on va fait varier des coordonnées de cases dans cette grille. On peut faire cette variation par une boucle (double). Ici elle est fait par une récursivité.
En simplifiant, pour voir les deux cas :

boucle : for(int i=0; i<fin; i++);

récursive :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
void method(int i) {
      if(  i<fin ) {
           method(i+1);
      }
}

Donc

On va commencer par x=0; y=0
Ensuite, on peut parcourir ligne après ligne ou colonne après colonne, et dans chaque, chaque case. Essayons ligne après ligne : on parcourt donc chaque case en faisant varier x, ne l'incrémentant à chaque fois. Ici le parcourt est fait par récursivité : on appelle la méthode à nouveau avec x+1,y. Quand on arrive au bout de la ligne, soit x=3, on passe à la ligne suivante en faisant x=0,y+1, et qu'on on arrive au bout (x=3 et y=3), on a terminé, et on arrête

En résumé, on essaye tour à tour de placer un nombre parmi 1, 2, 3 ou 4, de manière à ce qu'il ne soit pas déjà dans une partie de la grille, et si x et y correspondent à une certaine condition, on arrête, sinon, on refait ça dans une autre case.

**blackrose0003** · 27/05/2018, 19h30

Merci beaucoup, tu me sauve !!

Besoin d'aide pour un programme en javas'cool

avec Java

Vue hybride

Discussions similaires

Partager

Partager