Besoin d'aide pour un programme en javas'cool

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:

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;
}

1 pièce(s) jointe(s)

Salut,
boolean check(int[][]GRILLE, int x, int y, int a) {Que fait cette méthode ?
if (GRILLE[ligne][colonne] == a) {return false;}:arrow:
si on trouve a dans la case ligne,colonne on retourne false. Donc
Code:

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
Code:

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.
Code:

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
Code:

1 2 for (int i = 0; i < 2; i ++) { for (int j = 0; j < 2; j ++) {
On fait varier i et j

qui prennent pour valeur 0 ou 1
donc on a (0,0), (0,1), (1,0) et (1,1)
Code:

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.
A la fin, on fait return true;, soit on retourne vrai par défaut.
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

(x,y)-(x+1,y+1) si x pair et y pair
(x-1,y)-(x,y+1) si x impair, y pair
(x,y-1)-(x+1,y) si x pair et y impair
(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.
Pièce jointe 383510
vrai sinon

Cette méthode permet de déterminer si a est dans la grille à certains endroits.
La partie principale maintenant

Code:

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

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:

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:

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:

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:

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:

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:

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:

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.

Merci beaucoup, tu me sauve !!