Ordinamento elementi della diagonale, ordine crescente Help

bad.alex
ho una matrice quadrata di ordine N. devo stampare i valori degli elementi dela prima diagonale, dopo averli ordinati in modo crescente.
Come si svolge la consegna? grazie-

Risposte
bad.alex
"david_e":
[quote="bad.alex"][quote="david_e"]Ci sono un po' di errori:

1. vec lo devi inizializzare in un ciclo a parte, prima di ordinarlo. In un ciclo for (con i=0,1,2,...N-1), prima del do-while. Non puoi contemporaneamente definirlo e ordinarlo.
2. Gli estremi del ciclo sono sbagliati: devi partire da 1 e arrivare a N-1 dato che accedi a vec[i-1] e vec.

Il printf non è il modo migliore per stampare a monitor in C++: molto meglio la cout. Tra l'altro dato che non uso printf e soci da una vita non ti so trovare errori li perché non mi ricordo assolutamente come si usano. E anche le librerie: al massimo bisognerebbe fare un #include (non stdio.h) in modo da non importare tutti i comandi nel namespace principale.


ancora non riesco.....devo riuscire ad inizializzare il vet con gli elementi della prima diagonale =([/quote]
Per inizializzare vec devi fare:
for(int i=0;i<N;++i) {
     vec[i]=mat[i][i];
}
[/quote]
di farlo l'ho fatto...ma non mi compare nulla come valore.....

david_e1
Puoi provare a postare ancora il tuo codice, per farmi vedere come è ora, dopo queste modifiche....

bad.alex
"david_e":
Puoi provare a postare ancora il tuo codice, per farmi vedere come è ora, dopo queste modifiche....

* ordinamento degli elementi della prima diagonale */

do{
changes = 0 ;

for( i=0; i<=N-1; i++) {
vet=mat ;
if (vet[i-1]>vet) {
changes++;
temp=vet;
vet=vet[i-1];
vet[i-1]=temp;
}
}
} while (changes==0 );


}
}
/*ordinamento degli elementi della seconda diagonale */
printf ( " fine del programma \n") ;
return ( 0 ) ;
}

bad.alex
e in altra versione:

david_e1
Iniziamo con la prima versione: inutile andare a fare cose più complicate fino a che la versione base non funziona.

L'errore è sempre lo stesso. Devi inizializzare vec, con gli elementi della diagonale, prima del sorting: fuori dal do-while.

bad.alex
"david_e":
Iniziamo con la prima versione: inutile andare a fare cose più complicate fino a che la versione base non funziona.

L'errore è sempre lo stesso. Devi inizializzare vec, con gli elementi della diagonale, prima del sorting: fuori dal do-while.


ehm...sono de coccio....come faccio? mi hai illustrato:

for(.....){
vec=mat;
}
poi inizio col ciclo do while e ripeto
for(....){
vec....??

david_e1
Ehm... esattamente come ho fatto io un po' di post fa:

#include<iostream>

#define N 5

void print(double const * v,int size);
void sort(double * v);

int main() {
    double matrix[N][N];
    double vec[N];

    for(int i=0;i<N;++i) {
        for(int j=0;j<N;++j) {
            matrix[i][j]=(double)(N*N-i-j);
        }
    }

    for(int i=0;i<N;++i) {
        vec[i]=matrix[i][i];
    }

    print(vec,N);
    sort(vec);
    std::cout << std::endl;
    print(vec,N);
}

void print(double const * v,int n) {
    for(int i=0;i<n;++i) {
        std::cout << v[i] << std::endl;
    }
}

void sort(double * v) {
    int changes=0;
    double tmp;
    do {
        changes=0;
        for(int i=1;i<N;++i) {
            if(v[i-1]>v[i]) {
                ++changes;
                tmp=v[i];
                v[i]=v[i-1];
                v[i-1]=tmp;
            }
        }
    } while(changes==0);
}


devi solo cambiare la parte di immissione della matrice... se non hai ancora fatto le funzioni, puoi sempre pensare che, dove compare "sort(vec)" ci sia tutto il codice che ho messo in fondo con "vec" al posto di "v".

bad.alex
scusami, è vero.


ma non ho la più pallida idea di come io debba sostituire nel mio programma:

print(vec,N);
sort(vec);
std::cout << std::endl;
print(vec,N);
}

void print(double const * v,int n) {
for(int i=0;i std::cout << v << std::endl;
}
}

void sort(double * v) {


il procedimento che dovrei applicare sta nell'altra versione anche se ritengo che si possano fondere in una!!!

david_e1
Dovrebbe venire fuori più o meno così:
for(i=0;i<=N-1;i++) {
      vet[i]=mat[i][i];
}

do{
    changes = 0 ;

    for( i=1; i<=N-1; i++) {
        if (vet[i-1]>vet[i]) {
            changes++;
            temp=vet[i];
            vet[i]=vet[i-1];
            vet[i-1]=temp;
        }
    }
} while (changes==0 );

con l'inizializzazione di vet prima del ciclo do-while e gli indici apposto nel for... bisogna sempre prestare molta attenzione ai limiti dei cicli onde evitare di andare a leggere o a scrivere fuori dal vettore, in oltre è sempre buona norma inizializzare tutto prima di usarlo. In questo caso è molto meglio inizializzare vet prima di cominciare a sortarlo: magari con qualche strano trucco si potevano fare le due cose assieme per "risparmiare un ciclo for", ma non conviene mai farlo perché:

1. Il codice finale viene un pastrocchio e la probabilità di sbagliare è quasi pari a 1.
2. Il numero di istruzioni da eseguire è praticamente lo stesso, anzi, spesso (=quasi sempre) risulta essere molto più efficiente fare un ciclo for in più che inventarsi strani trucchi per eliminare i cicli. Io chiamo questa "ottimizzazione psicologica"nel senso che l'idea che "già che ci sono durante il ciclo faccio anche questo" è piuttosto stupida visto che il numero totale di operazioni da eseguire rimane lo stesso e spesso il codice risulta molto più lento, ma molti questa cosa non riescono proprio a capirla... :-D

bad.alex
"david_e":
Dovrebbe venire fuori più o meno così:
for(i=0;i<=N-1;i++) {
      vet[i]=mat[i][i];
}

do{
    changes = 0 ;

    for( i=1; i<=N-1; i++) {
        if (vet[i-1]>vet[i]) {
            changes++;
            temp=vet[i];
            vet[i]=vet[i-1];
            vet[i-1]=temp;
        }
    }
} while (changes==0 );

con l'inizializzazione di vet prima del ciclo do-while e gli indici apposto nel for... bisogna sempre prestare molta attenzione ai limiti dei cicli onde evitare di andare a leggere o a scrivere fuori dal vettore, in oltre è sempre buona norma inizializzare tutto prima di usarlo. In questo caso è molto meglio inizializzare vet prima di cominciare a sortarlo: magari con qualche strano trucco si potevano fare le due cose assieme per "risparmiare un ciclo for", ma non conviene mai farlo perché:

1. Il codice finale viene un pastrocchio e la probabilità di sbagliare è quasi pari a 1.
2. Il numero di istruzioni da eseguire è praticamente lo stesso, anzi, spesso (=quasi sempre) risulta essere molto più efficiente fare un ciclo for in più che inventarsi strani trucchi per eliminare i cicli. Io chiamo questa "ottimizzazione psicologica"nel senso che l'idea che "già che ci sono durante il ciclo faccio anche questo" è piuttosto stupida visto che il numero totale di operazioni da eseguire rimane lo stesso e spesso il codice risulta molto più lento, ma molti questa cosa non riescono proprio a capirla... :-D


speriamo bene....

ma....per la seconda diagonale...il vet come lo inizializzo?
dal momento che dovrò prdinarlo in senso decrescente mi basterà sostituire il > con <....


ti ringrazio per la pazienza.... :D

david_e1
Per la seconda diagonale lo devi inzializzare allo stesso modo: con un ciclo for prima del sort. L'unica cosa cui devi stare molto attento è che la seconda diagonale non ha N elementi, quindi le estensioni dei cicli vanno sistemate adeguatamente per evitare problemi.

bad.alex
"david_e":
Per la seconda diagonale lo devi inzializzare allo stesso modo: con un ciclo for prima del sort. L'unica cosa cui devi stare molto attento è che la seconda diagonale non ha N elementi, quindi le estensioni dei cicli vanno sistemate adeguatamente per evitare problemi.


:cry: più confuso.....

ma il vet è comunque ???

per non parlare delle N....dovrò mettermi d'impegno...

david_e1
Devi fare come per la prima diagonale, tenendo conto che la seconda, ovviamente, non ha lo stesso numero di elementi della prima... :-D

bad.alex
"david_e":
Devi fare come per la prima diagonale, tenendo conto che la seconda, ovviamente, non ha lo stesso numero di elementi della prima... :-D


non ti seguo....la seconda diagonale non ha 6 componenti?


per maggiore chiarezza, avrò
for(...)
vet=mat[N-1-i]
......?

david_e1
Certo che no: prendi una matrice a caso e conta il numero di elementi sulla diagonale principale e poi sulle sottidiagonali, non è mica lo stesso numero...

bad.alex
"david_e":
Certo che no: prendi una matrice a caso e conta il numero di elementi sulla diagonale principale e poi sulle sottidiagonali, non è mica lo stesso numero...


00 01 02 03
10 11 12 13
20 21 22 23
30 31 32 33


non sono quattro elementi sulla diagonale principale e quattro sulla seconda diagonale??

00 11 22 33
03 12 21 30?

david_e1
Dipende da cosa intendi per seconda diagonale io intendevo:

10 21 32

bad.alex
"david_e":
Dipende da cosa intendi per seconda diagonale io intendevo:

10 21 32
e beh...ci siamo ritrovati.

anche se ancora una soluzione non 'ho trovata per la seconda diagonale...uffa:(

Rispondi
Per rispondere a questa discussione devi prima effettuare il login.