Bonjours à tous, j'ai un projet de groupe (le projet est le jeu le "démineur" mais nous rencontrons une difficulté, nous avons une fonction qui doit renvoyée un booléen, elle doit renvoyer true si une des cases adjacente à la case de coordonnées (i,j) est révélée et n'a aucune mine adjacente (une mine correspond à un "-1" sur le jeu, le petit jeu étant le projet ) , par exemple on a : 

|A|B|C|D|E|F|G|H|I|J| 

00| | |1|0|0|0|0|2| | |

01| | |1|0|0|0|1|3| | | 

02| | |1|0|0|0|1|X| | | 

03| | |1|0|0|1|2| | | | 

04| | |1|1|1|2|X| | | | 

05| | | | | | | |3| | | 

06| | | | | | | | | | | 

07|1|1| | | | | | |2| | 

08|0|1| | | | | | | | | 

09|0|1| | | | | | | | | 

10|0|1| | | | | | | | |

La pour (7,1) la fonction va renvoyer "true" , car elle a une case adjacente révélée et n'a pas de mine adjacente.

J'avais pensé à faire une fonction "révélée" et si la case est révélée et n'a pas de mine adjacente, on renvoi true;

Je suis désolé si ce n'est pas clair  ! Dites moi si vous voulez plus de précision 

-
Edité par WanWan1 13 novembre 2020 à 3:10:36

Et? Un problème? Une question?

Un bon point de départ serait de nous montrer le code que tu as écrit, et de nous dire ce qui te bloque.

En faites je n'ai pas compris comment faire, j'ai essayé de faire au cas par cas mais ça ne fonctionne pas 'il y a une 30 aines de if je vous les épargnent  :

if ((caseCorrecte(i-1,j-1))==true && (T[i-1][j-1]==1)) {//1 : [i-1][j-1]
			k=i-1;
			l=j-1;	    //1 : [k-1][l-1]  		                              //2 : [k-1][l]		                            //3 : [k-1][l+1]	                                   //4 : [k][l-1]	                                 //5 : [k][l+1]	                                 //6 : [k+1][l-1]	                                 //7 : [k+1][l]	                                 //8 : [k+1][l+1]	
			if (caseCorrecte(k-1,l-1)==true) {
				if (Tadj[k-1][l-1]==-1) {
					b=false;
				}
			}
			if (caseCorrecte(k-1,l)==true) {
				if (Tadj[k-1][l]==-1) {
					b=false;
				}
			}
			if (caseCorrecte(k-1,l+1)==true) {
				if (Tadj[k-1][l+1]==-1) {
					b=false;
				}
			}
			if (caseCorrecte(k,l-1)==true) {
				if (Tadj[k][l-1]==-1) {
					b=false;
				}
			}
			if (caseCorrecte(k,l+1)==true) {
				if (Tadj[k][l+1]==-1) {
					b=false;
				}
			}
			if (caseCorrecte(k+1,l-1)==true) {
				if (Tadj[k+1][l-1]==-1) {
					b=false;
				}
			}
			if (caseCorrecte(k+1,l)==true) {
				if (Tadj[k+1][l]==-1) {
					b=false;
				}
			}
			if (caseCorrecte(k+1,l+1)==true) {
				if (Tadj[k+1][l+1]==-1) {
					b=false;
				}

La fonction "case correct" vérifie si l'indice i et j sont valides (s'ils sont bien présents dans le tableau 2D et renvoie un booléen )

Qu'est ce qui ne fonctionne pas?

Et tu peux faire deux boucles imbriquees plutot que de lister tous les voisins (de k-1 à k+1 et de l-1 à l+1).

Vo

static int[] dl = { -1, -1, -1,    0 ,    0,    1, 1, 1};
static int[] dc = { -1,  0,  1,    -1,    1,   -1, 0, 1};  

for (int  d = 0; d < 8; d++) {
    int nl = l + dl[d];  // coordonnées du d-ième voisin
    int nc = c + dc[d];

    if ( tableau[nl][nc] .....) {
    }
}

ire même une seule boucle pour les voisins dans les 8 directions

-
Edité par michelbillaud 14 novembre 2020 à 13:33:50

thetui a écrit:

Qu'est ce qui ne fonctionne pas?

Et tu peux faire deux boucles imbriquees plutot que de lister tous les voisins (de k-1 à k+1 et de l-1 à l+1).

Ouai j'avais pensé à faire ça mais évidemment je suis un peu neuneu du coup  j'ai voulu faire au cas pas cas...

Copier coller modifier 7 fois, ça donne l'impression de travailler. Heureusement que c'est pas en 3d avec 26 voisins

-
Edité par michelbillaud 15 novembre 2020 à 16:13:48

je comprends pas trop a quoi une méthode de ce type pourrait bien te servir, quand on y réfléchit un peu le démineur est un jeu assez simple à faire, il suffit de représenter les mines par un numéro >= 9 (puisqu'il est impossible d'avoir 9 mines adjacentes a une case) et à chaque fois que tu ajoutes une mine dans ta grille incrémenter les 8 cases adjacentes de 1. De cette manière pour savoir combien de mines sont a coté d'une case, il suffit de regarder le chiffre de la case  

michelbillaud a écrit:

Copier coller modifier 7 fois, ça donne l'impression de travailler. Heureusement que c'est pas en 3d avec 26 voisins

-
Edité par michelbillaud il y a environ 5 heures

Monsieur comprenez que j'apprends, je suis pas un génie .

Splintz a écrit:

je comprends pas trop a quoi une méthode de ce type pourrait bien te servir, quand on y réfléchit un peu le démineur est un jeu assez simple à faire, il suffit de représenter les mines par un numéro >= 9 (puisqu'il est impossible d'avoir 9 mines adjacentes a une case) et à chaque fois que tu ajoutes une mine dans ta grille incrémenter les 8 cases adjacentes de 1. De cette manière pour savoir combien de mines sont a coté d'une case, il suffit de regarder le chiffre de la case  

Oui on me le demande, je vous avoue que je ne comprends pas trop non plus !

-
Edité par WanWan1 15 novembre 2020 à 21:29:54

WanWan1 a écrit:

michelbillaud a écrit:

Copier coller modifier 7 fois, ça donne l'impression de travailler. Heureusement que c'est pas en 3d avec 26 voisins

-
Edité par michelbillaud il y a environ 5 heures

Toujours le même ton moralisateur de certains, c'est vrai que vous n'avez jamais débuté vous.

C'est pas moralisateur, c'est faire remarquer l'absurdité de la chose. Pourquoi préférer 7 copier-coller (avec les erreurs qui vont forcément s'y glisser) à quelques minutes de réflexion pour simplifier ? Et si on fait des choses absurdes comme ça il y a des raisons psychologiques.

L'impression d'avoir travaillé, c'est un facteur qui revient souvent.  On le retrouve chez les débutants quand ils pensent avoir "optimisé" alors qu'ils n'ont fait que se compliquer gravement la vie (et celle du compilateur qui fabrique du code pire qu'avec le code simple, basique).

 En fait, c'est comme si ils offraient leurs heures de dur labeur à une divinité, qui ne pourrait que les en récompenser, puisqu'ils ont beaucoup travaillé. Pensée magique.

Y aussi "ça marche comme ça et keskesapeufoutre". A ce moment là on pourrait causer lisibilité et maintenabilité.

PS Non seulement j'ai débuté, mais j'ai eu quelques centaines d'étudiants débutants, donc peut être qu'il y en au moins un de nous deux qui sait de quoi il parle en matière de programmes faits par des débutants :-) et d'incitations qu'on peut leur donner pour qu'ils progressent.

PS sans vouloir moraliser,

if (condition == true) {
   ...
}

ça se simplifie en

if (condition) {
   ...
}

-
Edité par michelbillaud 15 novembre 2020 à 21:36:21

Splintz a écrit:

je comprends pas trop a quoi une méthode de ce type pourrait bien te servir, quand on y réfléchit un peu le démineur est un jeu assez simple à faire, il suffit de représenter les mines par un numéro >= 9 (puisqu'il est impossible d'avoir 9 mines adjacentes a une case) et à chaque fois que tu ajoutes une mine dans ta grille incrémenter les 8 cases adjacentes de 1. De cette manière pour savoir combien de mines sont a coté d'une case, il suffit de regarder le chiffre de la case  

Oui on me le demande, je vous avoue que je ne comprends pas trop non plus !

michelbillaud a écrit:

PS Non seulement j'ai débuté, mais j'ai eu quelques centaines d'étudiants débutants, donc peut être qu'il y en au moins un de nous deux qui sait de quoi il parle en matière de programmes faits par des débutants :-) et d'incitations qu'on peut leur donner pour qu'ils progressent.

Mon dieu ... quel est l'intérêt de ce genre de commentaire ? A part se faire mousser 

-
Edité par Splintz 16 novembre 2020 à 10:39:42

Splintz a écrit:

michelbillaud a écrit:

PS Non seulement j'ai débuté, mais j'ai eu quelques centaines d'étudiants débutants, donc peut être qu'il y en au moins un de nous deux qui sait de quoi il parle en matière de programmes faits par des débutants :-) et d'incitations qu'on peut leur donner pour qu'ils progressent.

Mon dieu ... quel est l'intérêt de ce genre de commentaire ? A part se faire mousser 

C'est bien de poser la question. J'explique juste que ce que je dis n'est pas là pour "moraliser" (quelle connerie de supposer ça), ni me foutre de la gueule des débutants, mais les aider. Et que c'est basé sur une certaine pratique.

Maintenant on peut se demander pourquoi on s'énerve à la remarque que copier-coller 7 fois le même code, c'est pas ce qu'on fait de mieux ? Hein, pourquoi ? Quand on apprend, c'est pas normal ?

En gros, on observe que c'est ce que font spontanément + de 3/4 (*) des débutants (se balader dans une grille, ce sont des exos typiques qu'on donne évidemment tous les ans), parce que c'est ce qui leur PARAIT le plus simple (à ce stade d'apprentissage, une boucle, c'est compliqué vous savez, et deux, n'en parlons pas, alors on évite même d'y penser),  ou alors, la seule façon de faire parce qu'ils n'y ont pas du tout réfléchi.

Donc là, il faut les taquiner un peu pour les inciter à y regarder de plus près, et revoir leur point de vue. Sinon, aucun progrès possible.

(*) les autres font la double boucle, aucun la boucle dans les huit directions si on ne leur a pas montré avant.

-
Edité par michelbillaud 16 novembre 2020 à 11:07:45

C'est pas que votre débat soit inintéressant.

Mais pour revenir au problème du PO, on a proposé des solutions, et si ça ne marche toujours pas il faut préciser ce qui ne marche pas comme tu veux.

La boucle dans les "huit directions" ne sert à rien, elle n'apporte rien à la lisibilité et n'améliore pas la complexité du programme, cela me parait assez logique que personne ne la fasse. Pour ce qui est de la pédagogie, je serais curieux de voir à quoi ressemble les cours que vous proposez, si vous dites faites comme moi c'est mieux plutôt qu'expliquer pourquoi, mais bon ce n'est pas le sujet (en espérant que l'auteur est trouvé une solution).

Puisque vous posez la question, La boucle sur les huit directions permet d'écrire

for (int  d = 0; d < 8; d++) {
    int nl = l + dl[d];  // coordonnées du d-ième voisin
    int nc = c + dc[d];
    if ( tableau[nl][nc] .....) {
          ....
    }
}

ce qu'on ferait aussi, mais de façon beaucoup moins claire avec 2 boucles imbriquées

for (int nl = l-1; nl <= l+1; nl++) {
   for (int nc = c-1; cl <= c+1; nc++) {
       if ((nl != l) && (nc != c)) {
           if (tableau[nl][nc] .....) {
               ....
           }
       }
   }
}

On a ajouté un niveau de boucle et un if, soit deux niveaux d'imbrication supplémentaires. Si vous trouvez que c'est plus simple, il faudra expliquer la métrique que vous utilisez pour évaluer la simplicité et la lisibilité.

(Si vous voulez parler de la complexité algorithmique, évidemment ça ne change rien, puisque 8 est une constante qui n' a généralement pas tendance à tendre  vers l'infini).

Si les étudiants n'y pensent pas, c'est parce qu'ils voient uniquement le notion de case voisine sous la forme  t[indice+constante][indice+constante]. 

La première étape de progression conceptuelle est de passer à t[indice+variable][indice+variable] - qui conduit fatalement au copier coller - avec les deux variables contrôlées par des boucles.

Ensuite, il y a un saut conceptuel à faire, qui s'appelle la réification ("data driven"), qui consiste à ranger une partie des infos  dans des données (ici les tableaux de déplacement). Mais c'est l'étape d'après, un concept qu'ils n'ont encore jamais vu. Faut bien commencer, et justement, c'est l'occasion.

Par exemple, essayez de faire le truc des deux boucles avec les mouvements du cavalier sur un échiquier.

--

Des cours, j'en ai plein sur mon site boulot que vous trouverez facilement si vous avez réellement la curiosité de chercher. Bonne lecture.

-
Edité par michelbillaud 16 novembre 2020 à 12:19:45

le double if n'est absolument pas obligatoire, il suffit de réfléchir comment on peut incrémenter le pas de la deuxième boucle, ensuite ça évite d'avoir à écrire les positions des huit cases environnante en dur dans le code, donc oui personnellement je trouve que le code est plus clair (c'est personnel).

Pour ce qui est du problème du cavalier je conçois que c'est pas la solution optimale d'utiliser deux boucles mais la on change de contexte, il est facile de trouver un problème ou une solution est plus adaptée, par exemple imaginez qu'au lieu de prendre les 8 cases on demande les 24 cases ou pire les 48 cases environnantes, votre solution devient ingérable

Splintz a écrit:

(1) le double if n'est absolument pas obligatoire, il suffit de réfléchir comment on peut incrémenter le pas de la deuxième boucle, ensuite ça évite d'avoir à écrire les positions des huit cases environnante en dur dans le code, donc oui personnellement je trouve que le code est plus clair (c'est personnel).

(2) Pour ce qui est du problème du cavalier je conçois que c'est pas la solution optimale d'utiliser deux boucles mais la on change de contexte, il est facile de trouver un problème ou une solution est plus adaptée, par exemple imaginez qu'au lieu de prendre les 8 cases on demande les 24 cases ou pire les 48 cases environnantes, votre solution devient ingérable

1- Allez-y faites voir que ça donne quand on réfléchit à incrémenter le pas de la seconde boucle (en fonction de la premiere ?). Parce que "c'est plus simple", faut voir pour comparer.

2- qu'est-ce que vous trouvez "ingérable" dans un tableau de 24 ou 48 constantes ? Faites les deux solutions avant de spéculer sur des comparaisons.

---
Pour revenir à des considérations qui intéresseront davantage celui qui a posé la question, en général on y gagne (en terme de simplification du code) si on écrit par exemple  une fonction qui retourne vrai quand une case est "dans le tableau" et contient une mine

boolean positionContientMine(int ligne, int colonne)
{
    return positionCorrecte(ligne, colonne)
           && (tableau[ligne][colonne] == -1);
}

parce que sinon on se trimbale des if (positionCorrecte) partout dans le code.

-
Edité par michelbillaud 16 novembre 2020 à 13:19:46

(1) Je n'ai pas dis plus simple juste que c'est possible

for(int i = -1; i < 2; i++)
    for(int j = -1; j < 2; j += 1 + (i + 1) % 2 )
        ...

(2) Vous trouvez que faire 7 copier / coller amène forcement des erreurs mais faire 48 positions à la mains non ? c'est peu contradictoire, et il n'y a aucune spéculations voila les solutions pour 24 et 48 cases :

for (int nl = l-2; nl <= l+2; nl++) {
   for (int nc = c-2; cl <= c+2; nc++) {
       if ((nl != l) && (nc != c)) {
           if (tableau[nl][nc] .....) {
               ....
           }
       }
   }
}

for (int nl = l-3; nl <= l+3; nl++) {
   for (int nc = c-3; cl <= c+3; nc++) {
       if ((nl != l) && (nc != c)) {
           if (tableau[nl][nc] .....) {
               ....
           }
       }
   }
}

mais je veux bien voir comment vous auriez fait ? 

C'est pas plus simple, on est d'accord. Et on vise la simplicité.

Le tableau de 48 cases est fabriqué UNE FOIS, et jamais copié collé. Donc pas d'erreur de copier-coller possible.
Et son contenu peut faire l'objet de tests unitaires.

Au besoin, on peut construire ce tableau une fois au début du programme, et on l'exploite ensuite.

La construction par programme de tables réutilisées ensuite, ça vient après la réification. Y a des degrés dans les concepts.

-
Edité par michelbillaud 16 novembre 2020 à 14:50:49

Faire un tableau de 48 cases est du non sens complet, du coup si on vous dis qu'il faut prendre les 224 cases environnante, vous allez faire un tableau de 224 cases à la main ?? Si on vise la simplicité, le fait de faire deux boucles est certainement le plus simple sans avoir aucune contrepartie. C'est bien de pouvoir énoncer des concepts mais le mieux reste de le faire dans des cas ou ils sont utiles, on est ici dans un cas ou la solution triviale est suffisante.

Au bout d'un moment, à force d'augmenter la taille du problème, il change de nature. On est parti de 8, nous voila à 244 maintenant. C'est plus l'enumération des voisins, mais le parcours d'un rectangle.

Faut quand même rappeler que la solution triviale, la première que trouve le débutant, pour les voisins, et qu'il trouve de toute évidence la plus simple, c'est de copier-coller. Pour 8 cases.

Et on n'est bien  d'accord que ce n'est pas satisfaisant ?

---

A l'autre bout, on arrive à la programmation de "générateurs", streams et autres trucs beaucoup plus simples à utiliser et qui réduisent énormément les possibilités d'erreur.

Exercice : implémenter ceci :

pourChaqueVoisin(l,c).faire(

       (nl, nc) -> { ..... }

);

:-)

-
Edité par michelbillaud 18 novembre 2020 à 10:57:06

Merci à tous de vos réponses tout d'abord ! Déjà Michel je reconnais que j'ai été un peu trop agressif, c'est juste que j'utilise les forums pour diverses raisons et dans certains cas on me répond de façon condescendante et je déteste ça. 

Pour revenir au problème, si je résume, j'essaye de faire une fonction qui vérifie si la case est une mine et est dans le tableau (donc case correcte que j'ai déjà faites ) et j'essaye de faire avec la première base que vous m'avez donné ?

Désolé que tu ai trouvé les réponses condescendantes, le but est simplement de te donner les pistes d'améliorations qui nous semblent les plus pertinentes

Apres pour ton probleme, plutôt que de donner les coordonnées de chaque voisin en dur, on te faisait remarquer qu'ils sont de la forme "coordonnées de la case plus ou moins un décalage" et que ce décalage peut être une variable. Quand à savoir si tu fait une ou deux boucles c'est ce que tu comprends le mieux.

WanWan1 a écrit:

Pour revenir au problème, si je résume, j'essaye de faire une fonction qui vérifie si la case est une mine et est dans le tableau (donc case correcte que j'ai déjà faites ) et j'essaye de faire avec la première base que vous m'avez donné ?

NON, IL NE FAUT SURTOUT PAS ESSAYER.

Bon sans rire, faut complètement revoir l'attitude.

• Quand on apprend, on apprend des choses qu'on ne sait pas faire.
• Quand on essaie des trucs qu'on ne sait pas, il y a obligatoirement des choses qui ne marcheront pas
• C'est pas du tout un problème : on apprend à partir des erreurs (on élimine les fausses conceptions, par exemple).
  
• Dans le cas où on imaginait qu'on est un génie qui sait tout faire du premier coup, c'est juste un retour à la réalité. Ca va peut être être vexant d'y être confronté, alors dans ce cas on trouve des bonnes raisons de ne même pas essayer (par exemple validation externe : "est-ce que je dois vraiment essayer ce que vous m'avez dit" - avec en plus le vous  pour rejeter préventivement la faute sur le coupable)
  
• Pour les autres, on essaie, ça marche pas, ok, l'erreur est moteur de l'apprentissage, on cherche pourquoi, on corrige, et on est content d'avoir appris quelque chose de nouveau.

-
Edité par michelbillaud 18 novembre 2020 à 11:02:28