[C] Gestione di matrici

di
Luca997
il
7 risposte
L
Luca997
Pochi posts
Iscritto da
ott, 2016
Messaggi:
14

[C] Gestione di matrici

Salve a tutti, sto cercando di realizzare una versione ascii di prato fiorito ma sto avendo difficoltà nella generazione della matrice che poi verrà visualizzata dall'utente (ovvero quella in cui le celle contengono il numero di mine adiacenti).
Inizialmente randomizzo, con la funzione 'randomize', una matrice booleana (in questo caso, per comodità, fatta di 9 e 0) per posizionare le mine sul campo da gioco (ogni cella ha il 15% di probabilità di contenerne una).
A questo punto vorrei creare una seconda matrice in cui al posto degli 0 (ovvero celle vuote) ci sia il numero di mine adiacenti.
Ovviamente per fare ciò devo prendere in considerazione i casi limite delle celle agli angoli e ai bordi.
Il codice compila, il problema è che la gestione dei bordi, nonostante l'abbia tenuta a mente, non funziona come dovrebbe e i numeri che ottengo sembrano casuali.
Riporto qui il codice nella speranza che qualcuno sappia dirmi dove sbaglio. Grazie in anticipo. 

#include <stdio.h>
#include <stdlib.h>

/*Legenda:
    matbool
    9=mina
    0=nessuna mina adiacente
    matvis:
    9=mina (quando stampo a video per prove uso il carattere #)
    0-8=numero mine adiacenti
*/

/*Funzione per ottenere casualmente valori 9 e 0 con il 15% di probabilità di avere un 9*/
int randomize(a,b){
    int f,r;
    r=rand()%100;
    if (r<=14){f=9;}
    else {f=0;}
    return f;
}



int main()
{   /*INPUT DEL NUMERO DI RIGHE E COLONNE*/
    int row,col;
    printf("Inserire il numero di righe e colonne:\n ");
    printf("Righe: ");
    scanf("%d",&row);
    printf("\nColonne: ");
    scanf("%d",&col);
    /*GENERAZIONE MATRICE BOOLEANA: matrice con solo 9(a video #) e 0 per posizionare le mine */
    int matbool[row][col];
    int i,j;
    for(i=0;i<row;i++){
        for(j=0;j<col;j++){
            matbool[i][j]=randomize(row,col);
        }
    }
    /*STAMPA DI PROVA*/
    for(i=0;i<row;i++){                          /*DA TOGLIERE QUANDO FINITO*/
        for(j=0;j<col;j++){                        /*DA TOGLIERE QUANDO FINITO*/
            if(matbool[i][j]==9) {printf("  #");}/*DA TOGLIERE QUANDO FINITO*/
            else {printf("%3d",matbool[i][j]);}  /*DA TOGLIERE QUANDO FINITO*/
        }                                             /*DA TOGLIERE QUANDO FINITO*/
    printf("\n");                                /*DA TOGLIERE QUANDO FINITO*/
    }                                           /*DA TOGLIERE QUANDO FINITO*/

    /*GENERAZIONE MATVIS: matrice che si vedrà effettivamente con il numero di mine adiacenti*/
    int matvis[row][col];
    for(i=0;i<row;i++){
        for(j=0;j<col;j++){
            matvis[i][j]=0;    /*Inizializzo a 0 e incremento ogni volta che trovo una mina adiacente*/
            if(matbool[i][j]!=9){       /*Analizzo solo nelle celle in cui non c'è già una mina*/

                /*CASO ANGOLO N/O(NORD/OVEST)*/
                if((i==0)&&(j==0)){
                    if (matbool[i+1][j]==9){matvis[i][j]++;}
                    if (matbool[i][j+1]==9){matvis[i][j]++;}
                    if (matbool[i+1][j+1]==9){matvis[i][j]++;}
                }

                /*CASO ANGOLO N/E */
                if((i==0)&&(j==(col-1))){
                    if (matbool[i+1][j]==9){matvis[i][j]++;}
                    if (matbool[i][j-1]==9){matvis[i][j]++;}
                    if (matbool[i+1][j-1]==9){matvis[i][j]++;}
                }

                /*CASO ANGOLO S/O*/
                if((i==(row-1))&&(j==0)){
                    if (matbool[i-1][j]==9){matvis[i][j]++;}
                    if (matbool[i][j+1]==9){matvis[i][j]++;}
                    if (matbool[i-1][j+1]==9){matvis[i][j]++;}
                }

                /*CASO ANGOLO S/E*/
                if((i==0)&&(j==(col-1))){
                    if (matbool[i-1][j]==9){matvis[i][j]++;}
                    if (matbool[i][j-1]==9){matvis[i][j]++;}
                    if (matbool[i-1][j-1]==9){matvis[i][j]++;}
                }

                /*CASO LATO N*/
                if((i==0)&&(j!=0)&&(j!=(col-1))){
                    if(matbool[i+1][j]==9){matvis[i][j]++;}
                    if(matbool[i][j+1]==9){matvis[i][j]++;}
                    if(matbool[i][j-1]==9){matvis[i][j]++;}
                    if(matbool[i+1][j+1]==9){matvis[i][j]++;}
                    if(matbool[i+1][j-1]==9){matvis[i][j]++;}
                }

                /*CASO LATO S*/
                if((i==(row-1))&&(j!=0)&&(j!=(col-1))){
                    if(matbool[i-1][j]==9){matvis[i][j]++;}
                    if(matbool[i][j+1]==9){matvis[i][j]++;}
                    if(matbool[i][j-1]==9){matvis[i][j]++;}
                    if(matbool[i-1][j-1]==9){matvis[i][j]++;}
                    if(matbool[i-1][j+1]==9){matvis[i][j]++;}
                }

                /*CASO LATO O*/
                if((j==0)&&(i!=0)&&(i!=(row-1))){
                    if(matbool[i-1][j]==9){matvis[i][j]++;}
                    if(matbool[i+1][j]==9){matvis[i][j]++;}
                    if(matbool[i][j+1]==9){matvis[i][j]++;}
                    if(matbool[i+1][j+1]==9){matvis[i][j]++;}
                    if(matbool[i-1][j+1]==9){matvis[i][j]++;}
                }

                /*CASO LATO E*/
                if((j==(col-1))&&(i!=0)&&(i!=(row-1))){
                    if(matbool[i-1][j]==9){matvis[i][j]++;}
                    if(matbool[i+1][j]==9){matvis[i][j]++;}
                    if(matbool[i][j-1]==9){matvis[i][j]++;}
                    if(matbool[i+1][j-1]==9){matvis[i][j]++;}
                    if(matbool[i-1][j-1]==9){matvis[i][j]++;}
                }

                /*CASO GENERICO (IN MEZZO)*/
                else {
                    if(matbool[i+1][j]==9){matvis[i][j]++;}
                    if(matbool[i][j+1]==9){matvis[i][j]++;}
                    if(matbool[i-1][j]==9){matvis[i][j]++;}
                    if(matbool[i][j-1]==9){matvis[i][j]++;}
                    if(matbool[i+1][j+1]==9){matvis[i][j]++;}
                    if(matbool[i-1][j-1]==9){matvis[i][j]++;}
                    if(matbool[i-1][j+1]==9){matvis[i][j]++;}
                    if(matbool[i+1][j-1]==9){matvis[i][j]++;}
                }
            }
            else {matvis[i][j]=9;}  /*Nelle celle in cui ho già una mina impongo il valore 9(che stamperò come #)*/
        }
    }

/*STAMPA DI PROVA DELLA MATRICE MATVIS*/
    printf("\n\n\n");                             /*DA TOGLIERE QUANDO FINITO*/
    for(i=0;i<row;i++){                          /*DA TOGLIERE QUANDO FINITO*/
        for(j=0;j<col;j++){                     /*DA TOGLIERE QUANDO FINITO*/
            if(matvis[i][j]==9) {printf("  #");}/*DA TOGLIERE QUANDO FINITO*/
            else {printf("%3d",matvis[i][j]);}  /*DA TOGLIERE QUANDO FINITO*/
        }                                    /*DA TOGLIERE QUANDO FINITO*/
    printf("\n");                                /*DA TOGLIERE QUANDO FINITO*/
    }                                           /*DA TOGLIERE QUANDO FINITO*/
}

7 Risposte

  • LPs
    LPs
    Utente Attivo
    Iscritto da
    mag, 2017
    Messaggi:
    209

    Re: [C] Gestione di matrici

    Concettualmente dovresti sempre analizzare, come ha correttamente fatto, i casi limite, ma poi dovresti portarli a fattor comune ed implementare qualcosa che valga per tutti i casi con poche righe.

    Eseguire una lista infinita di if per ogni singola posizione, quando i vincoli di dimensione sono chiari, è una complicazione inutile e nel tempo ingestibile e indebuggabile. Per debuggare e verificare tutti quegli if dovresti fare un test case per ogni singolo if scritto, per natale hai finito...

    Il tuo codice dovrebbe, prima di tutto ragionare al contrario, ovvero vedere dove ci sono le bombe e incrementare le celle a lei vicino.
    Dovresti precalcolare sempre le celle adiacenti e poi incrementare solamente quelle che rientrano nei limiti della tabella.
    
int N,S,O,E;

.....

if (matbool[i][j] == 9)
{ /*Analizzo solo nelle celle in cui c'è già una mina*/
	
	N = i-1;
	S = i+1;
	O = j-1;
	E = j+1;
	
	if (N>=0)
	{
		matvis[N][j]++;
	}
	if (S<row)
	{
		matvis[S][j]++;
	}
	if(O>=0)
	{
		matvis[i][O]++;
	}
	if (E<col)
	{
		matvis[i][E]++;
	}
}
    In questo modo analizzi meno celle,in quanto ci sono meno bombe che celle libere, quindi l'algoritmo è più efficiente e veloce.
  • L
    Luca997
    Pochi posts
    Iscritto da
    ott, 2016
    Messaggi:
    14

    Re: [C] Gestione di matrici

    Capisco quello che dici e concordo sul fatto che il mio codice non fosse il metodo più intelligente per farlo.
    Ho provato quindi a riscriverlo come mi hai detto tu (aggiungendo anche l'analisi delle celle agli angoli) però il problema rimane, addirittura ora in alcune celle ottengo come risultato 10 (che è impossibile). 
    
#include <stdio.h>
#include <stdlib.h>

/*Legenda:
    matbool
    9=mina
    0=nessuna mina adiacente
    matvis:
    9=mina (quando stampo a video per prove uso il carattere #)
    0-8=numero mine adiacenti
*/

/*Funzione per ottenere casualmente valori 9 e 0 con il 15% di probabilità di avere un 9*/
int randomize(a,b){
    int f,r;
    r=rand()%100;
    if (r<=14){f=9;}
    else {f=0;}
    return f;
}



int main()
{   /*INPUT DEL NUMERO DI RIGHE E COLONNE*/
    int row,col;
    int N,S,O,E;
    printf("Inserire il numero di righe e colonne:\n ");
    printf("Righe: ");
    scanf("%d",&row);
    printf("\nColonne: ");
    scanf("%d",&col);
/*GENERAZIONE MATRICE BOOLEANA: matrice con solo 9(a video #) e 0 per posizionare le mine */
    int matbool[row][col];
    int i,j;
    for(i=0;i<row;i++){
        for(j=0;j<col;j++){
            matbool[i][j]=randomize(row,col);
        }
    }
    /*STAMPA DI PROVA*/
    for(i=0;i<row;i++){                          /*DA TOGLIERE QUANDO FINITO*/
        for(j=0;j<col;j++){                     /*DA TOGLIERE QUANDO FINITO*/
            if(matbool[i][j]==9) {printf("  #");}/*DA TOGLIERE QUANDO FINITO*/
            else {printf("%3d",matbool[i][j]);}  /*DA TOGLIERE QUANDO FINITO*/
        }                                    /*DA TOGLIERE QUANDO FINITO*/
    printf("\n");                                /*DA TOGLIERE QUANDO FINITO*/
    }                                           /*DA TOGLIERE QUANDO FINITO*/

    /*GENERAZIONE MATVIS: matrice che si vedrà effettivamente con il numero di mine adiacenti*/
    int matvis[row][col];
    for(i=0;i<row;i++){
        for(j=0;j<col;j++){
            matvis[i][j]=0;
            if(matbool[i][j]==9){
                 N=i-1;
                 S=i+1;
                 O=j-1;
                 E=j+1;
                if(N>=0){matvis[N][j]++;}
                if(S<row){matvis[S][j]++;}
                if(O>=0){matvis[i][O]++;}
                if(E<col){matvis[i][E]++;}
                if((N>=0)&&(O>=0)){matvis[N][O]++;}
                if((N>=0)&&(E<col)){matvis[N][E]++;}
                if((S<row)&&(O>=0)){matvis[S][O]++;}
                if((S<row)&&(E<col)){matvis[S][E]++;}
                matvis[i][j]=9;

            }
        }
    }

/*STAMPA DI PROVA DELLA MATRICE MATVIS*/
    printf("\n\n\n");                             /*DA TOGLIERE QUANDO FINITO*/
    for(i=0;i<row;i++){                          /*DA TOGLIERE QUANDO FINITO*/
        for(j=0;j<col;j++){                     /*DA TOGLIERE QUANDO FINITO*/
            if(matvis[i][j]==9) {printf("  #");}/*DA TOGLIERE QUANDO FINITO*/
            else {printf("%3d",matvis[i][j]);}  /*DA TOGLIERE QUANDO FINITO*/
        }                                    /*DA TOGLIERE QUANDO FINITO*/
    printf("\n");                                /*DA TOGLIERE QUANDO FINITO*/
    }                                           /*DA TOGLIERE QUANDO FINITO*/
}
  • LPs
    LPs
    Utente Attivo
    Iscritto da
    mag, 2017
    Messaggi:
    209

    Re: [C] Gestione di matrici

    Luca997 ha scritto:

    Capisco quello che dici e concordo sul fatto che il mio codice non fosse il metodo più intelligente per farlo.
    Ho provato quindi a riscriverlo come mi hai detto tu (aggiungendo anche l'analisi delle celle agli angoli) però il problema rimane, addirittura ora in alcune celle ottengo come risultato 10 (che è impossibile). 
    
#include <stdio.h>
#include <stdlib.h>

/*Legenda:
    matbool
    9=mina
    0=nessuna mina adiacente
    matvis:
    9=mina (quando stampo a video per prove uso il carattere #)
    0-8=numero mine adiacenti
*/

/*Funzione per ottenere casualmente valori 9 e 0 con il 15% di probabilità di avere un 9*/
int randomize(a,b){
    int f,r;
    r=rand()%100;
    if (r<=14){f=9;}
    else {f=0;}
    return f;
}



int main()
{   /*INPUT DEL NUMERO DI RIGHE E COLONNE*/
    int row,col;
    int N,S,O,E;
    printf("Inserire il numero di righe e colonne:\n ");
    printf("Righe: ");
    scanf("%d",&row);
    printf("\nColonne: ");
    scanf("%d",&col);
/*GENERAZIONE MATRICE BOOLEANA: matrice con solo 9(a video #) e 0 per posizionare le mine */
    int matbool[row][col];
    int i,j;
    for(i=0;i<row;i++){
        for(j=0;j<col;j++){
            matbool[i][j]=randomize(row,col);
        }
    }
    /*STAMPA DI PROVA*/
    for(i=0;i<row;i++){                          /*DA TOGLIERE QUANDO FINITO*/
        for(j=0;j<col;j++){                     /*DA TOGLIERE QUANDO FINITO*/
            if(matbool[i][j]==9) {printf("  #");}/*DA TOGLIERE QUANDO FINITO*/
            else {printf("%3d",matbool[i][j]);}  /*DA TOGLIERE QUANDO FINITO*/
        }                                    /*DA TOGLIERE QUANDO FINITO*/
    printf("\n");                                /*DA TOGLIERE QUANDO FINITO*/
    }                                           /*DA TOGLIERE QUANDO FINITO*/

    /*GENERAZIONE MATVIS: matrice che si vedrà effettivamente con il numero di mine adiacenti*/
    int matvis[row][col];
    for(i=0;i<row;i++){
        for(j=0;j<col;j++){
            matvis[i][j]=0;
            if(matbool[i][j]==9){
                 N=i-1;
                 S=i+1;
                 O=j-1;
                 E=j+1;
                if(N>=0){matvis[N][j]++;}
                if(S<row){matvis[S][j]++;}
                if(O>=0){matvis[i][O]++;}
                if(E<col){matvis[i][E]++;}
                if((N>=0)&&(O>=0)){matvis[N][O]++;}
                if((N>=0)&&(E<col)){matvis[N][E]++;}
                if((S<row)&&(O>=0)){matvis[S][O]++;}
                if((S<row)&&(E<col)){matvis[S][E]++;}
                matvis[i][j]=9;

            }
        }
    }

/*STAMPA DI PROVA DELLA MATRICE MATVIS*/
    printf("\n\n\n");                             /*DA TOGLIERE QUANDO FINITO*/
    for(i=0;i<row;i++){                          /*DA TOGLIERE QUANDO FINITO*/
        for(j=0;j<col;j++){                     /*DA TOGLIERE QUANDO FINITO*/
            if(matvis[i][j]==9) {printf("  #");}/*DA TOGLIERE QUANDO FINITO*/
            else {printf("%3d",matvis[i][j]);}  /*DA TOGLIERE QUANDO FINITO*/
        }                                    /*DA TOGLIERE QUANDO FINITO*/
    printf("\n");                                /*DA TOGLIERE QUANDO FINITO*/
    }                                           /*DA TOGLIERE QUANDO FINITO*/
}
    Si, il mio era un codice di massima.

    Tu devi controllare anche che la cella che vai ad incrementare non sia una cella in cui c'è una bomba.
    Hai 10 in alcune celle proprio perchè tu, trovata una bomba, nella tabella matvis ci metti 9, poi trovi una bomba adiacente e incrementi quella cella "sbagliatamente".


    Inoltre gli altri IF ch hai aggiunto non so a cosa servano......
  • L
    Luca997
    Pochi posts
    Iscritto da
    ott, 2016
    Messaggi:
    14

    Re: [C] Gestione di matrici

    Ok capito... comunque gli altri if li ho messi per posizionare i numeri agli angoli della mina. Per farlo allora devo verificare due condizioni contemporaneamente, ovvero che non si trovi lungo due bordi contemporaneamente. Pero così mi metti il dubbio di aver fatto una cavolata
  • LPs
    LPs
    Utente Attivo
    Iscritto da
    mag, 2017
    Messaggi:
    209

    Re: [C] Gestione di matrici

    Luca997 ha scritto:

    Ok capito... comunque gli altri if li ho messi per posizionare i numeri agli angoli della mina. Per farlo allora devo verificare due condizioni contemporaneamente, ovvero che non si trovi lungo due bordi contemporaneamente. Pero così mi metti il dubbio di aver fatto una cavolata
    Guarda, sinceramente non ricordo bene come funziona prato fiorito, pensavo che evidenziasse le bombe in posizione ortogonale e non anche nelle celle "diagonali". Se devi contare anche in quelle, hai fatto la cosa giusta.
  • L
    Luca997
    Pochi posts
    Iscritto da
    ott, 2016
    Messaggi:
    14

    Re: [C] Gestione di matrici

    Ragazzi a ma dispiace continuare a rompere le scatole ma sto impazzendo... nonostante tutte le correzioni il problema iniziale continua a rimanere e io proprio non capisco dove stia il problema. Dopo i consigli di LPs ora il codice è questo, però i numeri nelle celle continuano a essere sbagliati . 
    
#include <stdio.h>
#include <stdlib.h>

/*Legenda:
    matbool
    9=mina
    0=nessuna mina adiacente
    matvis:
    9=mina (quando stampo a video per prove uso il carattere #)
    0-8=numero mine adiacenti
*/

/*Funzione per ottenere casualmente valori 9 e 0 con il 15% di probabilità di avere un 9*/
int randomize(a,b){
    int f,r;
    r=rand()%100;
    if (r<=14){f=9;}
    else {f=0;}
    return f;
}



int main()
{   /*INPUT DEL NUMERO DI RIGHE E COLONNE*/
    int row,col;
    int N,S,O,E;
    printf("Inserire il numero di righe e colonne:\n ");
    printf("Righe: ");
    scanf("%d",&row);
    printf("\nColonne: ");
    scanf("%d",&col);
/*GENERAZIONE MATRICE BOOLEANA: matrice con solo 9(a video #) e 0 per posizionare le mine */
    int matbool[row][col];
    int i,j;
    for(i=0;i<row;i++){
        for(j=0;j<col;j++){
            matbool[i][j]=randomize(row,col);
        }
    }
    /*STAMPA DI PROVA*/
    for(i=0;i<row;i++){                          /*DA TOGLIERE QUANDO FINITO*/
        for(j=0;j<col;j++){                     /*DA TOGLIERE QUANDO FINITO*/
            if(matbool[i][j]==9) {printf("  #");}/*DA TOGLIERE QUANDO FINITO*/
            else {printf("%3d",matbool[i][j]);}  /*DA TOGLIERE QUANDO FINITO*/
        }                                    /*DA TOGLIERE QUANDO FINITO*/
    printf("\n");                                /*DA TOGLIERE QUANDO FINITO*/
    }                                           /*DA TOGLIERE QUANDO FINITO*/

    /*GENERAZIONE MATVIS: matrice che si vedrà effettivamente con il numero di mine adiacenti*/
    int matvis[row][col];
    for(i=0;i<row;i++){
        for(j=0;j<col;j++){
            matvis[i][j]=0;
            if(matbool[i][j]==9){
                 N=i-1;
                 S=i+1;
                 O=j-1;
                 E=j+1;
                if((N>=0)&&(matbool[N][j]!=9)){matvis[N][j]++;}
                if((S<row)&&(matbool[S][j]!=9)){matvis[S][j]++;}
                if((O>=0)&&(matbool[i][O]!=9)){matvis[i][O]++;}
                if((E<col)&&(matbool[i][E]!=9)){matvis[i][E]++;}
                if((N>=0)&&(O>=0)&&(matbool[N][O]!=9)){matvis[N][O]++;}
                if((N>=0)&&(E<col)&&(matbool[N][E]!=9)){matvis[N][E]++;}
                if((S<row)&&(O>=0)&&(matbool[S][O]!=9)){matvis[S][O]++;}
                if((S<row)&&(E<col)&&(matbool[S][E]!=9)){matvis[S][E]++;}
                matvis[i][j]=9;

            }
        }
    }

/*STAMPA DI PROVA DELLA MATRICE MATVIS*/
    printf("\n\n\n");                             /*DA TOGLIERE QUANDO FINITO*/
    for(i=0;i<row;i++){                          /*DA TOGLIERE QUANDO FINITO*/
        for(j=0;j<col;j++){                     /*DA TOGLIERE QUANDO FINITO*/
            if(matvis[i][j]==9) {printf("  #");}/*DA TOGLIERE QUANDO FINITO*/
            else {printf("%3d",matvis[i][j]);}  /*DA TOGLIERE QUANDO FINITO*/
        }                                    /*DA TOGLIERE QUANDO FINITO*/
    printf("\n");                                /*DA TOGLIERE QUANDO FINITO*/
    }                                           /*DA TOGLIERE QUANDO FINITO*/
}
  • LPs
    LPs
    Utente Attivo
    Iscritto da
    mag, 2017
    Messaggi:
    209

    Re: [C] Gestione di matrici

    Luca997 ha scritto:

    Ragazzi a ma dispiace continuare a rompere le scatole ma sto impazzendo... nonostante tutte le correzioni il problema iniziale continua a rimanere e io proprio non capisco dove stia il problema. Dopo i consigli di LPs ora il codice è questo, però i numeri nelle celle continuano a essere sbagliati . 
    
#include <stdio.h>
#include <stdlib.h>

/*Legenda:
    matbool
    9=mina
    0=nessuna mina adiacente
    matvis:
    9=mina (quando stampo a video per prove uso il carattere #)
    0-8=numero mine adiacenti
*/

/*Funzione per ottenere casualmente valori 9 e 0 con il 15% di probabilità di avere un 9*/
int randomize(a,b){
    int f,r;
    r=rand()%100;
    if (r<=14){f=9;}
    else {f=0;}
    return f;
}



int main()
{   /*INPUT DEL NUMERO DI RIGHE E COLONNE*/
    int row,col;
    int N,S,O,E;
    printf("Inserire il numero di righe e colonne:\n ");
    printf("Righe: ");
    scanf("%d",&row);
    printf("\nColonne: ");
    scanf("%d",&col);
/*GENERAZIONE MATRICE BOOLEANA: matrice con solo 9(a video #) e 0 per posizionare le mine */
    int matbool[row][col];
    int i,j;
    for(i=0;i<row;i++){
        for(j=0;j<col;j++){
            matbool[i][j]=randomize(row,col);
        }
    }
    /*STAMPA DI PROVA*/
    for(i=0;i<row;i++){                          /*DA TOGLIERE QUANDO FINITO*/
        for(j=0;j<col;j++){                     /*DA TOGLIERE QUANDO FINITO*/
            if(matbool[i][j]==9) {printf("  #");}/*DA TOGLIERE QUANDO FINITO*/
            else {printf("%3d",matbool[i][j]);}  /*DA TOGLIERE QUANDO FINITO*/
        }                                    /*DA TOGLIERE QUANDO FINITO*/
    printf("\n");                                /*DA TOGLIERE QUANDO FINITO*/
    }                                           /*DA TOGLIERE QUANDO FINITO*/

    /*GENERAZIONE MATVIS: matrice che si vedrà effettivamente con il numero di mine adiacenti*/
    int matvis[row][col];
    for(i=0;i<row;i++){
        for(j=0;j<col;j++){
            matvis[i][j]=0;
            if(matbool[i][j]==9){
                 N=i-1;
                 S=i+1;
                 O=j-1;
                 E=j+1;
                if((N>=0)&&(matbool[N][j]!=9)){matvis[N][j]++;}
                if((S<row)&&(matbool[S][j]!=9)){matvis[S][j]++;}
                if((O>=0)&&(matbool[i][O]!=9)){matvis[i][O]++;}
                if((E<col)&&(matbool[i][E]!=9)){matvis[i][E]++;}
                if((N>=0)&&(O>=0)&&(matbool[N][O]!=9)){matvis[N][O]++;}
                if((N>=0)&&(E<col)&&(matbool[N][E]!=9)){matvis[N][E]++;}
                if((S<row)&&(O>=0)&&(matbool[S][O]!=9)){matvis[S][O]++;}
                if((S<row)&&(E<col)&&(matbool[S][E]!=9)){matvis[S][E]++;}
                matvis[i][j]=9;

            }
        }
    }

/*STAMPA DI PROVA DELLA MATRICE MATVIS*/
    printf("\n\n\n");                             /*DA TOGLIERE QUANDO FINITO*/
    for(i=0;i<row;i++){                          /*DA TOGLIERE QUANDO FINITO*/
        for(j=0;j<col;j++){                     /*DA TOGLIERE QUANDO FINITO*/
            if(matvis[i][j]==9) {printf("  #");}/*DA TOGLIERE QUANDO FINITO*/
            else {printf("%3d",matvis[i][j]);}  /*DA TOGLIERE QUANDO FINITO*/
        }                                    /*DA TOGLIERE QUANDO FINITO*/
    printf("\n");                                /*DA TOGLIERE QUANDO FINITO*/
    }                                           /*DA TOGLIERE QUANDO FINITO*/
}

    Speravo ci arrivassi da solo, ma oggi sono buono:

    L'errore sta nel fatto che continui a reimpostare a 0 tutte le celle in cui analizzi: in pratica azzeri continuamente quello gli incrementi che sono già stati fatti per le celle.

    Per inizializzare matvis a 0 in tutti gli items usa un doppio for prima di quello in cui vai ad analizzarla oppure usa semplicemente la funzione memset:
    
	memset(matvis, 0, sizeof(int)*row*col);
    Inoltre la tua funzione randomize è dichiarata con due parametri (inutili) e senza tipo.... correggi anche quella


    Ultima cosa: sarebbe ora di imparare a deguggare il codice: anche solamente un paio di printf messe nel punto giusto possono farti capire dove è un errore.
Devi accedere o registrarti per scrivere nel forum
7 risposte