Comparazioni Matrici in C

di il
5 risposte

Comparazioni Matrici in C

Salve gente è da ieri che svolgendo un esercizio sono arrivato in un punto di stallo .
Durante l'esercizio il programma deve confrontare una matrice (8x8) chiamata per esempio "mat1[j]" e una matrice (8x8) " nullmat[z][w]", che rappresenta la matrice nulla , e nel caso in cui esse siano uguali viene stampata una determinata frase altrimenti il programma continua la lettura del codice. Inizialmente pensavo di cavarmela con un banale controllo del tipo
mat1[i][j] == nulmat[z][w]
ma come ho potuto notare ciò nono funziona (sarebbe stato troppo facile per funzionare ).
Ringrazio tutti quanti in anticipo per le risposte!

5 Risposte

  • Re: Comparazioni Matrici in C

    Devi usare due cicli, uno dentro l'altro e confrontare i corrispondenti elementi i j delle due matrici
  • Re: Comparazioni Matrici in C

    Una domanda magari ingenua...

    Se le matrici non sono dinamiche e si e' certi che hanno le stesse dimensioni, non sarebbe comodo anche usare memcmp()? Perché ho provato a fare un programmino di test e funziona.
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <time.h>
    
    #define NR  4 /* numero di righe nella matrice */
    #define NC  6 /* numero di colonne nella matrice */
    
    void mostra_contenuto_matrice( int m[NR][NC] ) {
        int r, c;
    
        for( r=0; r<NR; ++r ) {
            for( c=0; c<NC; ++c ) {
                printf( "%7d", m[r][c] );
            }
    
            printf( "\n" );
        }
    }
    
    void copia_matrice( int dest[NR][NC], int sorg[NR][NC] ) {
        int r, c;
    
        for( r=0; r<NR; ++r )
            for( c=0; c<NC; ++c )
                dest[r][c] = sorg[r][c];
    }
    
    int main() {
        int m1[NR][NC];
        int m2[NR][NC];
        int r, c;
    
        srand( time(NULL) );
    
        /*========================================================================*/
    
        /* azzero la matrice m2 */
        memset( m2, 0, sizeof(m2) );
    
        /* riempio la matrice m con valori a caso */
        for( r=0; r<NR; ++r )
            for( c=0; c<NC; ++c )
                m1[r][c] = rand();
    
        printf( "\nMatrice \"m1\":\n\n" );
        mostra_contenuto_matrice( m1 );
    
        printf( "\nMatrice \"m2\":\n\n" );
        mostra_contenuto_matrice( m2 );
    
        if( 0 == memcmp(m1,m2,sizeof(m1)) )
            printf( "\nLe matrici contengono gli stessi valori.\n" );
        else printf( "\nLe matrici contengono valori diversi.\n" );
    
        printf( "\n===========================================\n" );
    
        /*========================================================================*/
    
        /* copio il contenuto della matrice m nella matrice m2
        ** non uso memcpy() per evitare "fraintendimenti", anche
        ** se il fatto che memset() funzioni lascia intedere che
        ** anche memcpy() dovrebbe funzionare altrettanto */
        copia_matrice( m2, m1 );
    
        printf( "\nMatrice \"m1\":\n\n" );
        mostra_contenuto_matrice( m1 );
    
        printf( "\nMatrice \"m2\":\n\n" );
        mostra_contenuto_matrice( m2 );
    
        if( 0 == memcmp(m1,m2,sizeof(m1)) )
            printf( "\nLe matrici contengono gli stessi valori.\n" );
        else printf( "\nLe matrici contengono valori diversi.\n" );
    
        printf( "\n===========================================\n" );
    
        /*========================================================================*/
    
        /* azzero entrambe le matrici */
        memset( m1, 0, sizeof(m1) );
        memset( m2, 0, sizeof(m2) );
    
        printf( "\nMatrice \"m1\":\n\n" );
        mostra_contenuto_matrice( m1 );
    
        printf( "\nMatrice \"m2\":\n\n" );
        mostra_contenuto_matrice( m2 );
    
        if( 0 == memcmp(m1,m2,sizeof(m1)) )
            printf( "\nLe matrici contengono gli stessi valori.\n" );
        else printf( "\nLe matrici contengono valori diversi.\n" );
    
        /*========================================================================*/
    
        return 0;
    }
    
  • Re: Comparazioni Matrici in C

    Sì, Aldo, ovviamente funziona, e funzionerebbe meglio anche con qualche istruzione Assembler ...

    Ma nel dare suggerimenti, come ti ho detto tante volte, non serve indicare come sappiamo farlo NOI, ma come potrebbe farlo LUI con quello che conosce in quel momento. E chi inizia a fare esercizi per università/scuola non conosce il memcmp. Se lo usa, ovviamente il professore se ne rende conto ...
  • Re: Comparazioni Matrici in C

    Grazie tutti e due per le risposte! Purtroppo Aldo sto al primo anno di università e come programma finora svolto siamo arrivati agli array e funzioni ed il comando memcmp() ancora non lo abbiamo fatto però grazie comunque casomai gli do' un occhiata!

    Invece oregon, grazie anche a te per la risposta, quello che dici te sarebbe questa?
    #define RIG 8
    #define COL 8
    
    int main () {
    
    	int mat1[RIG][COL];
    	int i, j;
    	
    	for(i = 0; i < RIG; i++){
    		for(j = 0; j < COL; i++){
    		mat1[i][j] == 0;
    		}
    	 }	
    }
    
    Cosi dovrebbe verificare se ogni singolo elemento è uguale a 0 e restituire true o false a seconda dell'elemento in quella casella. Però non riesco ad immagine come porter proseguire il codice dicendo che se tutti gli elementi sono uguali a 0 allora stampa "hai vinto" altrimenti continua nella lettura del codice.
  • Re: Comparazioni Matrici in C

    @Oregon

    Sì, Oregon, la mia richiesta non intendeva essere un suggerimento, bensì il chiarimento di un dubbio che mi è venuto leggendo le tue risposte precedent. Mi son chiesto: "ma perché segue una strada tortuosa?". Non ho pensato che lo facessi per evitare memcmp() in quanto argomento più avanzato, bensì perché per qualche ragione non si poteva proprio usare. Per quello ho fatto la prova.

    @Frostbyte98

    Però... cosa te ne fai di quel ciclo? Messa a quel modo l'esito del confronto non va da nessuna parte!

    Se devi verificare che tutta la matrice sia azzerata, potresti fare in modo (ad esempio) che quando incontra un elemento non-zero esce dai cicli. A quel punto, verifichi: se in uscita dal ciclo annidato RIG==i e COL==j, allora l'intera matrice è azzerata; in caso contrario c'è ancora qualche elemento non azzerato.

    Ovviamente, avresti tutta convenienza a fare una funzione dedicata verifica_matrice_azzerata(), o come vuoi chiamarla, che si occupi della verifica, magari restituendo 1 (come se fosse una specie di "true") in caso d'avvenuto azzeramento e restituendo 0 (come se fosse una specie di "false") in caso contrario.

    P.S. Occhio che nel ciclo più interno hai scambiato quello che doveva essere un "j" con un "i".
    #define RIG 8
    #define COL 8
    
    int main() {
        int mat1[RIG][COL];
        int i, j;
       
        for( i=0; i<RIG; i++ ) {
            for( j=0; j<COL; j++ ) {
                if( 0 != mat1[i][j] ) /* se incontra un valore non-zero... */
                    break; /* esce ma... occhio, solo dal ciclo piu' interno! */
            }
            
            if( COL != j ) /* c'e' stata un'uscita "prematura" */
                break; /* se c'e' stata un'uscita "prematura" dal ciclo
                          interno significa che e' stato trovato un valore
                          non-zero, quindi interrompe anche il ciclo esterno */
        }
        
        /* se arrivi qui e trovi RIG==i e COL==j significa per forza che TUTTI
           gli elementi della matrice sono azzerati; in caso contrario significa
           che ALMENO uno degli elementi della matrice non e' azzerato */
    }
Devi accedere o registrarti per scrivere nel forum
5 risposte