Pagina 1 di 2 1 2 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 12
  1. #1
    Utente di HTML.it
    Registrato dal
    Jan 2014
    Messaggi
    5

    [c++]Ruotare di 90° una matrice quadrata di interi

    Ciao a tutti!
    Devo svolgere questo esercizio:
    "Scrivere un programma che ruoti di 90° in senso orario una matrice quadrata di interi."

    Purtroppo dopo la fase di inizializzazione della matrice non riesco ad andare avanti...
    Qualcuno mi può aiutare?

    Grazie infinitamente in anticipo!!!

  2. #2
    Utente di HTML.it L'avatar di Scara95
    Registrato dal
    Jul 2009
    residenza
    Zimella (VR)
    Messaggi
    2,590
    Intanto come memorizzi la matrice? Di dimensioni date?
    "Quid enim est, quod contra vim sine vi fieri possit?" - Cicerone, Ad Familiares

  3. #3
    Utente di HTML.it
    Registrato dal
    Jan 2014
    Messaggi
    5
    deve essere di dimensioni date. matrice [3][3].

    scusa mi ero dimenticato...

  4. #4
    Utente di HTML.it L'avatar di Scara95
    Registrato dal
    Jul 2009
    residenza
    Zimella (VR)
    Messaggi
    2,590
    Quote Originariamente inviata da toni123 Visualizza il messaggio
    deve essere di dimensioni date. matrice [3][3].

    scusa mi ero dimenticato...
    Ti basta scambiare la prima riga con l'ultima colonna, la seconda con la penultima ... l'ultima con la prima.

    C'è un modo più efficiente per farlo con una matrice quadrata, ma intanto prova semplicemente scambiando le righe e le colonne.
    "Quid enim est, quod contra vim sine vi fieri possit?" - Cicerone, Ad Familiares

  5. #5
    Utente di HTML.it
    Registrato dal
    Jan 2014
    Messaggi
    5
    Quote Originariamente inviata da Scara95 Visualizza il messaggio
    Ti basta scambiare la prima riga con l'ultima colonna, la seconda con la penultima ... l'ultima con la prima.

    C'è un modo più efficiente per farlo con una matrice quadrata, ma intanto prova semplicemente scambiando le righe e le colonne.
    Grazie mille

  6. #6
    Utente di HTML.it L'avatar di Scara95
    Registrato dal
    Jul 2009
    residenza
    Zimella (VR)
    Messaggi
    2,590
    Quote Originariamente inviata da toni123 Visualizza il messaggio
    Grazie mille
    Prego
    "Quid enim est, quod contra vim sine vi fieri possit?" - Cicerone, Ad Familiares

  7. #7
    Occhio però che il metodo suggerito funziona se hai matrice di origine e di destinazione diverse, ma se vuoi fare una rotazione "in place" l'algoritmo è un po' più complicato.
    Amaro C++, il gusto pieno dell'undefined behavior.

  8. #8
    Utente di HTML.it
    Registrato dal
    Jan 2014
    Messaggi
    5
    infatti mi sono accorto...
    la matrice di destinazione è della stessa grandezza di quella originale( sempre [3][3]). quindi la matrice deve proprio "ruotare su se stessa".

    Come posso fare?

  9. #9
    C'è un malinteso... Le dimensioni sono ovviamente uguali, quello che dicevo è che è necessario un algoritmo più sofisticato se intendi ruotare la matrice "sovrascrivendo sé stessa", ovvero se l'array di origine e destinazione coincidono. In tal caso se non copi gli elementi in un ordine preciso vai a sovrascrivere roba che devi ancora copiare.

    Se però sono due matrici distinte (per quanto con le stesse dimensioni) il problema non si pone e puoi copiare gli elementi in qualunque ordine, compreso quello "intuitivo" suggerito da Scara95.
    Amaro C++, il gusto pieno dell'undefined behavior.

  10. #10
    Utente di HTML.it L'avatar di Scara95
    Registrato dal
    Jul 2009
    residenza
    Zimella (VR)
    Messaggi
    2,590
    Quote Originariamente inviata da toni123 Visualizza il messaggio
    infatti mi sono accorto...
    la matrice di destinazione è della stessa grandezza di quella originale( sempre [3][3]). quindi la matrice deve proprio "ruotare su se stessa".

    Come posso fare?
    codice:
    #include <stdio.h>
    
    #define MAX 5
    
    #define max(i) (MAX-(i)-1)
    
    void stampa_matrice(int mat[MAX][MAX]) {
        int i, j;
        printf("\n################################################################################");
        for(i = 0; i < MAX; ++i) {
            printf("\n");
            for(j = 0; j < MAX; ++j) {
                printf("%4d", mat[i][j]);
            }
        }
        printf("\n################################################################################");
    }
    
    int main(void) {
        int a[MAX][MAX];
        int b[MAX][MAX];
        int i, j, *ptmp, itmp;
        
        //inizializzazione matrice
        ptmp = (int *)a;
        for(i = 0; i < MAX*MAX; ++i) {
            *(ptmp+i) = i+1;
        }
        //rotazione in nuova matrice
        stampa_matrice(a);
        for(i = 0; i < MAX; ++i) {
            for(j = 0; j < MAX; j++) {
                b[j][max(i)] = a[i][j];
            }
        }
        stampa_matrice(b);
        //rotazione in-place
        stampa_matrice(a);
        for(i = 0; i < MAX - 1; ++i) {
            for(j = i; j < max(i); ++j) {
                itmp = a[i][j];
                a[i][j] = a[max(j)][i];
                a[max(j)][i] = a[max(i)][max(j)];
                a[max(i)][max(j)] = a[j][max(i)];
                a[j][max(i)] = itmp;
                
            }
        }
        stampa_matrice(a);
        return 0;
    }
    "Quid enim est, quod contra vim sine vi fieri possit?" - Cicerone, Ad Familiares

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.