Bonjour, je viens ici pour demander de l'aide à propos du code qui me pose soucis.

En gros, j'ai fais un tableau aléatoire de chaine de caractères de 5 lettres ce que j'ai réussi mais je n'arrive pas du tout à trouver la condition qui me permettra d'empêcher que 3 lettre identique ne puissent pas se trouver cote à cote horizontalement et verticalement.

Voici mon code :

#include <stdlib.h>

#include <time.h>

#define lig 10

#define col 15

int main()

{

char tab[]="SFOPM";

   int i,j;

    srand(time(NULL));

    int lettre;

    for(i=0;i<lig;i++)

    {

        for(j=0;j<col;j++)

        {

            lettre=(rand()%(0-6+1))+0;

            printf(" | %c |",tab[lettre]);

        }

                         printf("\n");

    }

    return 0;

}

Horizontalement et verticalement implique un tableau à deux dimensions. Or ton tableau n'a qu'une dimension.
Est-tu certain d'avoir des lettres avec rand() ?
Tu dois garder la lettre précédente et la fréquence d'occurences consécutives.

-
Edité par PierrotLeFou 27 mai 2022 à 14:54:02

PierrotLeFou a écrit:

Horizontalement et verticalement implique un tableau à deux dimensions. Or ton tableau n'a qu'une dimension.
Est-tu certain d'avoir des lettres avec rand() ?
Tu dois garder la lettre précédente et la fréquence d'occurences consécutives.dirait si la lettre a bien été placée ou non

-
Edité par PierrotLeFou il y a moins de 30s

Oui,il affiche bien des lettres en aléatoire et un tableau en deux dimension

Voici ce qu'affiche mon programme:

 | O | | M | | F | | F | | O | | S | | F | | P | | P | | M | | M | | M | | P | | M | | P |

 | O | | F | | P | | M | | M | | O | | O | | F | | M | | P | | M | | F | | O | | F | | S |

 | M | | F | | O | | S | | M | | M | | O | | M | | P | | M | | F | | M | | O | | F | | F |

 | P | | O | | O | | M | | P | | P | | M | | P | | O | | M | | O | | P | | S | | M | | O |

 | F | | P | | M | | O | | M | | O | | S | | O | | M | | M | | O | | P | | O | | S | | O |

 | P | | O | | F | | M | | S | | F | | S | | O | | P | | P | | S | | P | | F | | O | | S |

 | M | | M | | O | | F | | O | | O | | S | | F | | P | | F | | P | | S | | O | | S | | S |

 | F | | M | | O | | P | | F | | F | | O | | P | | O | | S | | M | | S | | P | | S | | F |

 | P | | P | | F | | F | | F | | M | | S | | O | | S | | S | | O | | P | | M | | M | | O |

 | P | | S | | P | | P | | P | | M | | S | | F | | P | | M | | M | | M | | P | | S | | S |

Si j'ai bien compris je dois faire une condition avec tab[i][j]!= de la frequence des ocurrence ?

Je n'avais pas saisi exactement ce que tu faisais.
Tu as 5 lettres que tu veux afficher aléatoirement sur deux dimensions.
Essaies de régler le problème avec une seule dimension.
Il te faudra le caractère placé précédemment et la fréquence si c'est le même.
Si tu obtiens 'a' et qu tu as déjà 'a', tu augmentes un compteur.
Si le compteur dépasse 2, tu redemandes une autre lettre jusqu'à ce que ça marche.
Mais avec 2 dimensions, au lieu d'avoir un seul compteur et un seul précédent, tu en a 5, donc ça te prendra 2 tableaux de 5.

Ça serait plus simple si tu avais un tableau à 2 dimensions de lettres. Tu regardes ce qui précède sur la ligne et la colonne courante.

-
Edité par PierrotLeFou 27 mai 2022 à 15:19:14

PierrotLeFou a écrit:

Je n'avais pas saisi exactement ce que tu faisais.
Tu as 5 lettres que tu veux afficher aléatoirement sur deux dimensions.
Essaies de régler le problème avec une seule dimension.
Il te faudra le caractère placé précédemment et la fréquence si c'est le même.
Si tu obtiens 'a' et qu tu as déjà 'a', tu augmentes un compteur.
Si le compteur dépasse 2, tu redemandes une autre lettre jusqu'à ce que ça marche.
Mais avec 2 dimensions, au lieu d'avoir un seul compteur et un seul précédent, tu en a 5, donc ça te prendra 2 tableaux de 5.

Ça serait plus simple si tu avais un tableau à 2 dimensions de lettres. Tu regardes ce qui précède sur la ligne et la colonne courante.

-
Edité par PierrotLeFou il y a environ 1 heure

Je ne peux pas le mettre a un dimension car enft je dois faire un jeu de type candy crush et j'en ai donc besoin pour pouvoir faire jouer la personne. Puis-je avoir plus d'informations sur les occurence je n'ai jamais fait ca. 

Utilises le bouton code </> du forum pour poster ton code ! (tu peux modifier ton post, lien modifier en haut à droite du post).

Pour pouvoir analyser le contenu du tableau que tu affiches, il faudrait le construire en mémoire, or ce n'est pas le cas puisque tu ne fais qu'afficher les caractères en ligne, colonnes. Ensuite tu auras plusieurs possibilités. Une pourrait être de le construire entièrement et de faire une deuxième passes pour éliminer les triplés.

Pour le calcul de l'indice de la lettre dans le tableau de 5 char,

   lettre=rand()%5;

devrait suffire ! Je n'ai pas compris ce que tu voulais calculer là ? 

Il te manque aussi le #include <stdio.h> pour printf.

Rien ne t'empèche d'avoir deux tableaux. Le tableau une dimension de départ, et le tableau deux dimensions que tu vas construire.
"Occurence", ça veut juste dire le nombre.
Il faut que tu regardes de la position courante jusqu'à 2 en arrière. Si l'indice est moins que 2, tu ne regardes rien.
Il faut le faire pour les lignes et les colonnes.
Si ça ne marche pas pour l'une ou l'autre, tu piges une nouvelle lettre et tu recommences.

-
Edité par PierrotLeFou 27 mai 2022 à 17:36:33

rouIoude a écrit:

Utilises le bouton code </> du forum pour poster ton code ! (tu peux modifier ton post, lien modifier en haut à droite du post).

Pour pouvoir analyser le contenu du tableau que tu affiches, il faudrait le construire en mémoire, or ce n'est pas le cas puisque tu ne fais qu'afficher les caractères en ligne, colonnes. Ensuite tu auras plusieurs possibilités. Une pourrait être de le construire entièrement et de faire une deuxième passes pour éliminer les triplés.

Pour le calcul de l'indice de la lettre dans le tableau de 5 char,

   lettre=rand()%5;

devrait suffire ! Je n'ai pas compris ce que tu voulais calculer là ? 

Il te manque aussi le #include <stdio.h> pour printf.

Merci pour les renseignements !

Enft comme je dois faire un jeu démo comme candy crush, pour l'instant je veux pouvoir afficher un tableau en alétoire sans que 3 lettre identique ou plus soit cote à cote. Pour l'instant, je ne veux pas supprimer 3 lettres identique, je ne le ferais que pour faire gagner les points plus tard.

Il faut savoir que normalement c'est un sous progamme en procédure, et je n'ai pas compris vous voulez dire quoi exactement.

Je pense que nous non plus on ne comprend pas ce que tu veux faire.
Veux-tu mettre n'importe quoi et vérifier seulement à la fin?
Si tu veux faire une fonction, tu pourrais lui passer les 2 tableaux en paramètre.

PierrotLeFou a écrit:

Je pense que nous non plus on ne comprend pas ce que tu veux faire.
Veux-tu mettre n'importe quoi et vérifier seulement à la fin?
Si tu veux faire une fonction, tu pourrais lui passer les 2 tableaux en paramètre.

Concrètement, ce que je veux faire c'est faire apparaitre un tableau aléatoire ou 3 lettres identique ne sont pas cote à cote.

Mais comme j'ai déjà réussis à faire un tableau aléatoire, comme vous avez expliquer il faut faire l'occurence.

Je me disais au début qu'il fallait juste rajouter une condition à mon programme un if ou autre pour dire que 3 lettre ne doit pas être cote a cote mais ca ne marchait pas. Comme vous l'avez expliquer la solution et de faire un autre tableau a deux dimension et rajouter l'occurence dedans.

Exactement, tu sauras le faire?

Si j'ai bien compris il faut faire ceci :

Faire
    Construire tableau de lettres
Tant que
    Condition sur les lettres consécutives = faux

Tu dois donc faire deux choses :

1) La construction du tableau de lettres. Si j'ai bien compris c'est fait.

2) Écrire la fonction qui retourne vrai ou faux selon qu'il y a ou non trois lettres consécutives. C'est ceci que tu dois faire. Et tu dois le faire indépendamment de la fonction qui a créé le tableau, pour ne pas tout mélanger et ne pas se compliquer la vie inutilement.

Bonjour,

ce qu'il faut surtout faire avant de te lancer dans la production d'un code important est de réfléchir sur ce que le programme doit faire, identifier les parties du jeu, les modéliser,  les données que tu vas avoir à manipuler, quelles manipulations tu vas être amené à faire, etc …

Enfin bref, si tu dois construire un tableau de taille L×C avec les contraintes que tu donnes (en plus de celles qu'on devine, il n'y a apparemment que 5 possibilités pour les éléments de ton tableau, à moins que ce ne soit paramétrable) il y a un algo simple qui donne par construction ce que tu veux. Je pars du principe que L≥2 et C≥2.

• tu remplis aléatoirement les 2×2 cases en haut à gauche de ton plateau de jeu ;
• tu complètes les deux premières lignes (tu n'as qu'à tester les valeurs de deux cases à gauche) ;
• tu complètes les deux premières colonnes (tu n'as qu'à tester les valeurs de cases en haut) ;
• tu complètes les C-2 colonnes ligne par ligne en testant les valeurs des deux cases en haut et des cases à gauche ;

L'idéal serait d'avoir une fonction du genre :

int choose(int n, int forbidden_up, int forbidden_left);

C'est une fonction qui renvoie un nombre aléatoirement choisi entre 0 et n-1 tel que ce choix soit différent de forbidden_up et forbidden_left. Si l'un de ces deux derniers paramètres vaut -1 alors cela signifie qu'il n'y a pas de valeur interdite.

Par exemple pour choisir un nombre aléatoire entre 0 et 4 inclus tu pourras faire :

choose(5, -1, -1);

Pour choisir aléatoirement un nombre entre 0 et 4 inclus qui soit différent de 3 :

choose(5, 3, -1);

// ou 

choose(5, -1, 3);

Et pour choisir un aléatoirement un nombre entre 0 et 4 inclus différent de 3 et 0 :

choose(5, 3, 0);

Du coup remplir un tableau est relativement simple :

#define NO_CONSTRAINT ((int)-1)

void fill(size_t row, size_t col, int array[row][col], int max_value)
{
    // étape 1
    for(size_t i=0; i<2; i++)
        for(size_t j=0; j<2; j++)
            array[i][j] = choose(max_value, NO_CONSTRAINT, NO_CONSTRAINT);

    // étape 2
    for(size_t i=0; i<2; i++)
        for(size_t j=2; j<col; j++) {
            int left_value = (array[i][j-2]==array[i][j-1]) ? array[i][j-2] : NO_CONSTRAINT;
            array[i][j] = choose(max_value, NO_CONSTRAINT, value);
        }

    // étape 3
    for(size_t i=2; i<row; i++)
        for(size_t j=0; j<2; j++) {
            int up_value = (array[i-2][j]==array[i-1][j]) ? array[i-2][j] : NO_CONSTRAINT;
            array[i][j] = choose(max_value, up_value, NO_CONSTRAINT);
        }

    // étape 4
    for(size_t i=2; i<row; i++)
        for(size_t j=2; j<col; j++) {
            int left_value = (array[i][j-2]==array[i][j-1]) ? array[i][j-2] : NO_CONSTRAINT;
            int up_value = (array[i-2][j]==array[i-1][j]) ? array[i-2][j] : NO_CONSTRAINT;
            array[i][j] = choose(max_value, up_value, left_value);
        }
}

Alors, j'ai pissé ceci en supposant que la chaîne de départ a été construite:
-
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(void) {
    char tab[] ="zxcbef";
    char new[5][5];
    srand(time(NULL));
    for(int i=0; i<5; i++) {
        for(int j=0; j<5; j++) {
            char car;
            do {
                car = tab[rand()%5];
            } while((i >= 2 && new[i-1][j] == car && new[i-2][j] == car) ||
                (j >= 2 && new[i][j-1] == car && new[i][j-2] == car));
            new[i][j] = car;
        }
    }
    for(int i=0; i<5; i++) {
        for(int j=0; j<5; j++) {
           printf("%c ", new[i][j]);
        }
      printf("\n");
    }
    return 0;
}

-
Si on veut quelque chose d'un peu plus tordu ...
Si les éléments d'un tableau sont placés par ligne: la premiêre ligne, suivi de la seconde, etc.
Et si on tolère N-1 éléments consécutifs, ça donne ceci:
-
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>
// columns=1 pour les lignes et columns=nombre_de_colonnes pour les colonnes.
bool all(char *array, size_t columns, size_t count, char value) {
    while(count--) {
        if(*(array-columns)!=value) return false;
        array -= columns;
    }
    return true;
}
 
int main(void) {
    char tab[] ="zxcbef";
    char new[5][5];
    srand(time(NULL));
    for(int i=0; i<5; i++) {
        for(int j=0; j<5; j++) {
            char car;
            do {
                car = tab[rand()%5];
            } while((i >= 2 && all(&new[i][j], 1, 2, car)) || (j >= 2 && all(&new[i][j], 5, 2, car)));
            new[i][j] = car;
        }
    }
    for(int i=0; i<5; i++) {
        for(int j=0; j<5; j++) {
           printf("%c ", new[i][j]);
        }
      printf("\n");
    }
    return 0;
}

-
Edité par PierrotLeFou 28 mai 2022 à 2:35:16