Problème fonction récursive

bonjour, sans l'énoncé de l'exercice et sans commentaire, il est difficile de comprendre à quoi sert le code que tu as écrit.

C'est moi qui l'ai écrit, et c'est marqué à la ligne 5 de la fonction. mSetPlayed est une macro qui met un bit d'une variable à 1. Dans ce cas, il s'agit du 32ème bit d'une variable qui symbolise une case

ajoute des printf dans ton programme, afin de mieux comprendre comment il se comporte.

Bonjour,

Ce qui est bizarre c'est que dans le démineur, on découvre les cases une par une et donc il n'y a pas de récursivité. La seule exception, c'est quand on clique sur une case avec aucune mine adjacente (donc si

mCellValue[i][j] == 0

en admettant que j'ai bien compris ton code). Dans ce cas le jeu de démineur sous windows découvre les cases voisines et répète le processus pour les éventuelles cases.

Quelle que soit la répétition que tu veux faire, il faut s'assurer que

• ta récursion exprime, à partir d'une case, quelle case explorer ;
• ta récursion se termine (n'engendre pas une boucle infinie) et idéalement ne re-déclenche pas des calculs déjà faits.

Si on se place dans le cas du démineur standard, si une case dont le nombre de bombes adjacentes 0 est dévoilée, alors on dévoile les cases voisines. Si l'une de ces cases voisine a également 0 bombe adjacentes, alors on répète le processus récursivement :

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#define X 9

int min(int x, int y) {
    return x < y ? x : y;
}

int max(int x, int y) {
    return x > y ? x : y;
}

void display(int **tab, int **played, size_t num_rows, size_t num_cols) {
    for (size_t i = 0; i < num_rows; i++) {
        for (size_t j = 0; j < num_cols; j++) {
            if (played[i][j]) {
                if (tab[i][j] == X) {
                    printf("*");
                } else {
                    printf("%d", tab[i][j]);
                }
            } else {
                printf(".");
            }
        }
        printf("\n");
    }
}

int ** calloc_matrix(size_t num_rows, size_t num_cols) {
    int ** matrix = (int **) malloc(sizeof(int *) * num_rows);
    if (matrix) {
        for (size_t i = 0; i < num_rows; i++) {
            matrix[i] = (int *) calloc(sizeof(int), num_rows);
        }
    }
    return matrix;
}

void free_matrix(int ** matrix, size_t num_rows) {
    if (matrix) {
        for (size_t i = 0; i < num_rows; i++) {
            if (matrix[i]) {
                free(matrix[i]);
            }
        }
        free(matrix);
    }
}

void play(int **tab, int **played, size_t num_rows, size_t num_cols, size_t k, size_t l) {
    played[k][l] = 1;
    if (tab[k][l] == 0) {
        for (size_t i = max(0, k - 1); i < min(num_rows, k + 2); i++) {
            for (size_t j = max(0, l - 1); j < min(num_cols, l + 2); j++) {
                if (!played[i][j]) {
                    play(tab, played, num_rows, num_cols, i, j);
                }
            }
        }
    }
}


int main(){
    const size_t num_rows = 4;
    const size_t num_cols = 5;

    int ** played = calloc_matrix(num_rows, num_cols);

    // X == mine
    // autre valeur == nombre de mines adjacentes
    int ** tab = calloc_matrix(num_rows, num_cols);
    tab[0][0] = 0; tab[0][1] = 0; tab[0][2] = 1; tab[0][3] = 1; tab[0][4] = 1;
    tab[1][0] = 0; tab[1][1] = 0; tab[1][2] = 2; tab[1][3] = X; tab[1][4] = 2;
    tab[2][0] = 1; tab[2][1] = 1; tab[2][2] = 2; tab[2][3] = X; tab[2][4] = 2;
    tab[3][0] = X; tab[3][1] = 1; tab[3][2] = 1; tab[3][3] = 1; tab[3][4] = 1;


    printf("Before:\n");
    display(tab, played, num_rows, num_cols);

    printf("\nAfter:\n");
    play(tab, played, num_rows, num_cols, 0, 0);
    display(tab, played, num_rows, num_cols);

    free_matrix(tab, num_rows);
    free_matrix(played, num_rows);
    return 0;
}

Résultat :

Before:
.....
.....
.....
.....

After:
001..
002..
112..
.....

Bonne chance