Puissance 4 en C. (Tutoriel de Zds)

Pardon : de la position du premier pion ([current_indice - 1][nb_case - 1] jusqu'à [0][nb_case - 1])

Donc … la question que tu posais il y a 3 heures n'a plus de raison d'être, non ?

Hum j'ai toujours pas compris pourquoi il faudrait quitter la boucle si on a deux symboles différents

Version n°1 : On cherche à savoir s'il y a quelque part dans la grille une séquence de 4 pions identiques (ou même plus de 4.)

Version n°2 : On cherche à savoir s'il y a dans la grille une séquence de 4, qui contient le dernier pion joué

Si ton objectif, c'est la version 1, alors tu as raison. Si c'est la version 2, alors inutile d'aller voir les zones de la grille qui ne sont pas dans le voisinage direct du dernier pion joué.

OK, Au départ oui c'était la 1ère version, 4 même pions sur la même colonne mais je vois pas comment résoudre les pb que j'ai, peut-être que tu as une idée après si tu n'as pas d'idées non plus je vais essayer de faire avec la 2éme méthode !

Hier , à 16h56, je t'avis suggéré de faire la version 2 au lieu de la version 1, et dans la foulée, tu avais répondu 'Je vais essayer ça'

Et comme les commentaires de la fonction ne disaient pas très clairement ce que tu cherchais à faire, j'ai vraiment cru que tu étais passé à la version 2.

J'avais pas bien compris alors, je vais essayer!

Re ! j'ai fait les fonctions verticale et horizontale et ça semble marché,je vais essayer de faire la fonction parcours_diagonale maintenant: tu m'as dit qu'il y avait 2 lignes à tester, la diagonale montante et descendante mais il peut y en avoir 4 des diagonales non ?

Non, 2 diagonales seulement . Et aussi une seule horizontale.

Quand tu traites l'horizontale, tu pars de la colonne jouée par le joueur ; tu fais un Premier parcours vers la droite, un deuxième parcours vers la gauche, et tu testes si le CUMUL des pions à droite et à gauche , ça fait plus de 4 ou moins de 4, n'est-ce pas ?

Pour les diagonales, c'est similaire.

Vu cette question où tu envisages 4 diagonales, je pense que ta fonction parcours_horizontal() est fausse.

Tu as vu juste, j'ai fait 2 fonctions parcours_horizontal_gauche et parcours_horizontal_droite , c'est faux ?

Pour les diagonales, c'est les-qu’elles, 1 montante, 1 descendante mais au hasard ? 1 droite, 1 gauche par ex ?

Imagine la configuration suivante :

Tu as ton point 'central', le dernier pion joué, un pion 'X' par exemple.

Sur l'horizontale de droite, tu trouves 2 pions 'X', en plus du dernier pion joué, puis un vide ou bien un 'O' ; ça ne fait pas 4 pions.

Sur l'horizontale de gauche, tu trouves 1 pion 'X' en plus du dernier pion joué. Ca ne fait pas non plus 4 pions.

Et pourtant, au cumul, il y a bien 4 pions 'X' alignés.

Une nouvelle fois, tu as vaguement réfléchi à la méthode, et tu t'es précipité pour traduire cette méthode en langage étranger (le langage C), sans t'assurer que l'algorithme était correct.

Ecrire un programme, c'est écrire un algorithme (en français), décomposer précisément chaque étape de l'algorithme, s'assurer que l'algorithme est correct.

Et ensuite, quand l'algorithme détaillé est validé, traduire cet algorithme dans un langage de programmation. Là, dès qu'une idée te traverse l'esprit, tu t'empresses de la traduire en langage de programmation, sans t'assurer que l'idée est bonne. Je te rassure quand-même un peu, 95% des 'informaticiens' ont le même défaut.

bah ce qui m'inquiète perso c'est que je passe beaucoup beaucoup de temps sur des choses pas si compliquées(pour moi elles le sont) ou des gens doivent faire le programme en qq heures, je vais essayer de plus me préoccuper de l'algo tu as raison, après le dev c'est pas forcément le domaine ou je vais travailler, je suis plus dans le réseau, mais j'aime bien dev et ça me fait un peu peur quand même :/

Mais c'est bizarre parce que pour moi elles semblent marcher, faudra que je fasse d'autres tests!

et pour ce qui est des diago du coup comme je l'ai dans autre post, je dois choisir des diagonales précise ou juste une montante et une descendante au 'hasard' ?

Juste par curiosité, tu as jeter un œil au premier correctif fourni dans le cours ?

Je pensais le faire mais au final je veux essayer de le finir avant même si je l'ai pas vraiment finit seul car elegance m'a pas mal aidé, mais en fait je me dis si je dois déjà regarder la correction pour un projet qui n'est pas poussé, qu'est-ce-que ça va être pour les autres, après j'ai peut-être tort je sais pas.

T’inquiète pas ça viendra, à force de coder les patterns de base rentre et tu les remarques mieux se qui fais que tu codes plus vite mais c'est comme tout c'est en pratiquant que ça devient plus simple.

Je reviens ici, pour demander qq chose pour les diagonales, en fait comment tu fais pour savoir qu'elles diagonales tester ? entre les 4 ?

Techniquement, il n'y en que deux à tester : celles dont fait partie le pion qui vient d'être joué.

Le correctif te donne une solution parmi d'autres. Son objectif est avant tout de te permettre d'y voir plus clair après avoir essayé par toi même.

Donc en fait pour les diagonales, il faut déterminer d'abord les diagonales ou c'est possible qu'il y est 4 pions et ensuite tester les 2 possibles, c'est ça ?

Il n'est pas nécessaire de déterminer les deux possibles : tu pars de la position du coup joué et pour le reste, c'est un parcours du tableau.

Avant d'attaquer les diagonales, poste ce que tu as fait pour l'horizontale, pour qu'on valide ou non.

OK, donc j'ai testé et ça à l'air de fonctionner en tout cas avec mes deux fonctions :

 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

/*
*fonction avec en paramètre nb_case(numéro de colonne), current_indice : indice du dernier pion ajouté, caractere le caractere du joueur.
*La fonction va de l'indice [current_indice(indice du dernier pion)][nb_case - 1] juqu'a [current_indice][0];
*-> Donc la fonction fait un parcours vers la gauche.
*Si deux pions sont identiques donc le pion [current_indice][nb_case - 1] et celui à sa gauche
*->on incrémente compteur et décrémente i.
*sinon on break la boucle pour.
*/
int Puiss4_parcours_horizontal_gauche(Puiss4 A, int nb_case, int current_indice, char caractere)
{
  int i;
  int compteur = 1;
  for(i = nb_case - 1 ; i != 0 ; i--)
  {
    if(A->data[current_indice][i] == caractere)
    {
      if(A->data[current_indice][i] == A->data[current_indice][i - 1])
      {
        compteur++;
        printf("Compteur : %d\n", compteur);
      }
    }
    else
      {
        printf("Break : %c != %c\n",A->data[current_indice][i], caractere);
        break;
      }
  }
  return compteur;
}

 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

/*
*fonction avec en paramètre nb_case(numéro de colonne), current_indice : indice du dernier pion ajouté, caractere le caractere du joueur.
*La fonction va de l'indice [current_indice(indice du dernier pion)][nb_case - 1] juqu'a [current_indice][A->colonnes - 1(nombre de colonnes - 1)];
*-> Donc la fonction fait un parcours vers la droite.
*Si deux pions sont identiques donc le pion [current_indice][nb_case - 1] et celui à sa droite;
*->on incrémente compteur et incrémente i.
*sinon on break la boucle pour.
*/
int Puiss4_parcours_horizontal_droite(Puiss4 A, int nb_case, int current_indice, char caractere)
{
  int i;
  int compteur = 1;
  for(i = nb_case - 1 ; i < A->colonnes - 1; i++)
  {
    if(A->data[current_indice][i] == caractere)
    {
      if(A->data[current_indice][i] == A->data[current_indice][i + 1])
      {
        compteur++;
        printf("Compteur : %d\n", compteur);
      }
    }
    else
        {
          printf("Break : %c != %c\n",A->data[current_indice][i], caractere);
          break;
        }
      }
      return compteur;
}