Aiuto per esercizi

di il
19 risposte

Aiuto per esercizi

E' passato un pò di tempo. Sto rifacendo gli esercizi, in particolare questo:
Siano dati in ingresso una matrice di numeri interi M e un valore intero K. Scrivere un programma che verifichi se esistono almeno due colonne di M i cui valori siano ordinati in modo crescente. Se tale condizione risulta verificata si provveda a fondere gli elementi di tali colonne in un vettore ordinato V: nel fare questa operazione si deve garantire che il vettore V contenga solo gli elementi che sono a distanza maggiore di K tra loro. Stampare infine la matrice M, indicare gli indici delle colonne a valori crescenti eventualmente trovate e, nel caso, il vettore V ottenuto.


Non capisco bene come interpretare la condizione "si deve garantire che il vettore V contenga solo gli elementi che sono a distanza maggiore di K tra loro. ". La richiesta secondo me è imprecisa. Sono in attesa di consigli grazie.

#include <iostream>
#include<math.h>
#include<stdlib.h>


using namespace std;
void imatrice(int nrig,int ncol,int M[][100])
{
    for(int i=0;i<nrig;i++)
    {
        cout<<"\n";
        for(int j=0;j<ncol;j++)
        {
            cout<<"Inserisci l'elemento posto alla riga "<<i+1<<" e colonna "<<j+1<<"\n";
            cin>>M[i][j];
        }
    }
}
void omatrice(int nrig,int ncol,int M[][100])
{
    for(int i=0;i<nrig;i++)
    {
        cout<<"\n";
        for(int j=0;j<ncol;j++)
        {
            cout<<"    "<<M[i][j]<<"    ";
        }
    }
}
void ivettore(int dim,int V[])
{
    for(int i=0;i<dim;i++)
    {
        cout<<"Inserisci l'elemento "<<i+1<<" ";
        cin>>V[i];
    }
}
void ovettore(int dim,int V[])
{
    for(int i=0;i<dim;i++)
    {
        cout<<"  "<<V[i];
    }
}


bool colonna_crescente(int nrig,int ncol,int M[][100],int col)
{
    for(int i=0;i<nrig-1;i++)
    {
        if(M[i][col]<M[i+1][col])
        {
            if(i+1==nrig-1)
                return true;
        }
        else
            return false;
    }
}
void filtra_vettore(int dim,int V[],int dis)
{
    for(int i=0;i<dim-1;i++)
    {
        while(abs(V[i]-V[i+1])<=dis)
        {
            if(i==dim-2)
            {
                dim=dim-2;
                cout<<"Il vettore che contiene solo gli elementi distanti più di "<<dis<<" è\n";
                ovettore(dim,V);
                exit(0);
            }
            for(int j=0;j<dim-2;j++)
            {
                V[i+j]=V[i+j+2];
            }
            dim=dim-2;
            if(dim<=1)
            {
              cout<<"Il vettore che contiene solo gli elementi distanti più di "<<dis<<" è\n";
              ovettore(dim,V);
              exit(0);
            }
        }
    }
}

int main()
{
    int M[100][100];
    cout<<"\nNumero righe matrice ";
    int nrig;
    cin>>nrig;
    cout<<"\nNumero colonne ";
    int ncol;
    cin>>ncol;
    imatrice(nrig,ncol,M);
    cout<<"\nHai inserito la matrice ";
    omatrice(nrig,ncol,M);
    int col;
    
    int col_cresc[ncol];
    int i=-1;
    for(int col=0;col<ncol;col++)
    {
    if(colonna_crescente(nrig,ncol,M,col))
    {
        cout<<"\nLa colonna "<<col+1<<" è crescente.";
      
        ++i;
        col_cresc[i]=col;
    }
    else
    {
        cout<<"\nLa colonna "<<col+1<<" non è crescente.";
    }
    }
    
    if(i+1>=2) //i+1 rappresenta il numero di colonne crescenti
        cout<<"\nEsistono almeno 2 colonne crescenti.";
    else
        cout<<"\nNon esistono almeno 2 colonne crescenti.";
    
     int fusione_colcresc[100];
    int dim=nrig*(i+1); 
     int l=-1;
    for(int j=0;j<=i;j++)
    {
        for(int k=0;k<nrig;k++)
        {
          l++;  
        fusione_colcresc[l]=M[k][col_cresc[j]];
        }
    }
    cout<<"\nIl vettore ottenuto dalla fusione delle colonne crescenti è\n";
    ovettore(dim,fusione_colcresc);
    int dis;
    cout<<"\nLa distanza tra gli elementi deve essere maggiore di.......\n";
    cout<<"Scegli un valore ";
    cin>>dis;
    cout<<"Il vettore che contiene solo gli elementi distanti più di "<<dis<<" è\n";
    filtra_vettore(dim,fusione_colcresc,dis);
    ovettore(dim,fusione_colcresc);
}

19 Risposte

  • Re: Aiuto per esercizi

    A ME il buon senso suggerisce che possa intendere che dapprima si copiano nel vettore tutti i valori delle colonne individuate, quindi li si ordina, poi si eliminano tutti i valori tra i quali la differenza <= k.

    Però, per come è scritta, la traccia è davvero ambigua perché potrebbe anche significare che si copiano nel vettore solo quei valori tra i quali la differenza è <= k nell'ambito della singola colonna. Intendendola in questo modo si finirebbe per avere nel vettore risultante probabili valori con differenza <= k tra i quali anche probabili valori duplicati.

    Bah... le scienze esatte...
  • Re: Aiuto per esercizi

    Avendo tempo libero, ho voluto provare a svolgere anch'io l'esercizio (senza guardare il tuo codice). M'è venuta fuori una roba infinita: 336 righe di codice! Però sembra funzionare...
  • Re: Aiuto per esercizi

    Posta il tuo codice così vedo come hai ragionato.
    Si mi sono scordato di ordinare il vettore. Io penso che bisogna copiare tutte le colonne crescenti (e non solo 2) in un vettore, poi ordinarlo e "filtrarlo".
    Quindi quella condizione va soddisfatta con l'algoritmo seguente:
    considero la prima coppia di elementi e se la loro differenza è <=k li elimino, riconsidero la prima coppia (che sarà costituita da nuovi elementi) e ricalcolo la loro differenza e se <=k li elimino e così via (ciclo while).
    Se è >=k passo alla coppia successiva e così via.
    Giusto?
  • Re: Aiuto per esercizi

    Credo di sì, anch'io ho fatto così, anche se come al solito alla mia maniera cervellotica.

    Lo schema generale che ho seguito è:

    alloca_matrice
    popola_matrice
    mostra_matrice
    rileva_colonne_crescenti
    mostra_indici (delle colonne con valori crescenti)
    fondi_colonne_crescenti
    mostra_vettore_fusione

    Con tutti gli arzigogoli dovuti al fatto che ho usato la memoria dinamica e che son solito verificare più condizioni di errore possibile, sviluppare tutto ha richiesto questa bella pappardella, neppure particolarmente ordinata (ricordati che non sono un programmatore ma un hobbista):
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    #define MAX_VALORE  100 // la gamma dei valori impiegati va da 0 a 100
    #define DIFF_MIN     10 // il valore di riferimento per valutare la " distanza"
    #define Q_RIGHE       4 // la quantita' delle righe nella matrice
    #define Q_COLONNE    15 // la quantita' delle colonne nella matrice
    
    int alloca_matrice( int ***pm, size_t qr, size_t qc );
    void libera_matrice( int ***m, size_t qr );
    int popola_matrice( int **m, size_t qr, size_t qc );
    int rileva_colonne_crescenti( int **m, size_t qr, size_t qc,
                                  int **colCresc, size_t *qColCresc );
    int fondi_colonne_crescenti( int **m, size_t qr, size_t qc,
                                 int *cc, size_t qcc, int k,
                                 int **vf, size_t *qElVf );
    int mostra_matrice( int **m, size_t qr, size_t qc );
    int mostra_indici( int *pi, size_t qc, size_t qi );
    int mostra_vettore_fusione( int *v, size_t qEl, int diff );
    int altra_matrice( void );
    
    int main() {
        int **m = NULL;     // la matrice
        int k = DIFF_MIN;   // la "distanza"
    
        if( alloca_matrice(&m,Q_RIGHE,Q_COLONNE) ) {
    
            do {
                int *colCresc = NULL;
                size_t qColCresc = 0;
    
                popola_matrice( m, Q_RIGHE, Q_COLONNE );
                mostra_matrice( m, Q_RIGHE, Q_COLONNE );
    
                if( rileva_colonne_crescenti(m,Q_RIGHE,Q_COLONNE,&colCresc,&qColCresc) ) {
                    mostra_indici( colCresc, Q_COLONNE, qColCresc );
    
                    if( qColCresc > 1 ) {
                        int ok, *vettFus = NULL;
                        size_t qElVettFus = 0;
    
                        ok = fondi_colonne_crescenti( m, Q_RIGHE,Q_COLONNE,
                                                      colCresc, qColCresc, k,
                                                      &vettFus, &qElVettFus );
    
                        if( ok ) {
                            mostra_vettore_fusione( vettFus, qElVettFus, k );
                            free( vettFus );
                        }
                        else {
                            printf( "Errore nel fondere le colonne crescenti.\n\n" );
                        }
                    }
    
                    if( colCresc ) free( colCresc );
                }
                else {
                    printf( "Errore nel rilevare le colonne crescenti.\n\n" );
                }
            } while( altra_matrice() );
    
            libera_matrice( &m, Q_RIGHE );
        }
        else {
            printf( "Errore nell'allocare la matrice.\n\n" );
        }
    
        return 0;
    }
    
    // pm = puntatore a matrice; qr = quantita righe; qc = quantita colonne
    int alloca_matrice( int ***pm, size_t qr, size_t qc ) {
        int ok = 0;
    
        if( pm ) {
            int **m = calloc( qr, sizeof(*m) );
    
            if( m ) {
                size_t r;
    
                for( r=0; r<qr; ++r ) {
                    m[r] = calloc( qc, sizeof(*m) );
                    if( NULL == m[r] ) break;
                }
    
                ok = r==qr;
    
                if( !ok ) libera_matrice( pm, r );
            }
    
            *pm = m;
        }
    
        return ok;
    }
    
    // m = matrice; qr = quantita righe
    void libera_matrice( int ***pm, size_t qr ) {
        if( pm ) {
            int **m = *pm;
            size_t r;
    
            for( r=0; r<qr; ++r )
                m[r] = m[r] ? free(m[r]), NULL : NULL;
            free( m );
            m = NULL;
    
            *pm = m;
        }
    }
    
    /*==============================================================================
    Immette nella matrice m valori casuali compresi tra 0 e MAX_VALORE (inclusi).
    ==============================================================================*/
    
    int popola_matrice( int **m, size_t qr, size_t qc ) {
    // m = matrice; qr = quantita righe; qc = quantita colonne
        int ok = 0;
    
        if( m ) {
            size_t r, c;
    
            srand( time(NULL) );
    
            for( r=0; r<qr; ++r ) {
                if( m[r] ) {
                    for( c=0; c<qc; ++c ) {
                        // tra 0 e MAX_VALORE inclusi
                        m[r][c] = rand()%(MAX_VALORE+1);
                    }
                }
                else {
                    break;
                }
            }
    
            ok = r==qr;
        }
    
        return ok;
    }
    
    /*==============================================================================
    Analizza la matrice m in cerca delle colonne contenenti valori crescenti.
    In uscita, immette 1 in ciascuno degli elementi del vettore colCresc che
    corrisponde ad una delle colonne che contengono valori crescenti, zero in tutti
    gli altri.
    Immette in qColCresc la quantita' delle colonne crescenti rilevate.
    Il vettore colCresc viene allocato dinamicamente, ed e' responsabilita' del
    chiamante liberare la memoria allocata.
    ==============================================================================*/
    
    int rileva_colonne_crescenti( int **m, size_t qr, size_t qc,
                                  int **colCresc, size_t *qColCresc ) {
    // m = matrice; qr = quantita righe; qc = quantita colonne
    // colCresc=flags colonne crescenti; qColCresc=quantita' delle colonne crescenti
        int ok = 0;
    
        if( m && colCresc && qColCresc ) {
            int *i = NULL;
            size_t r;
    
            for( r=0; r<qr; ++r ) if( !m[r] ) break;
            if( r<qr ) return 0; // errore, righe non valide
    
            i = calloc( qc, sizeof(*i) );
    
            if( i ) {
                size_t qi, c;
    
                for( qi=0, c=0; c<qc; ++c ) {
                    for( r=0; r<qr-1; ++r ) {
                        if( m[r][c] >= m[r+1][c] ) break;
                    }
    
                    i[c] = r == qr-1;
                    qi += i[c];
                }
    
                *colCresc  = i;
                *qColCresc = qi;
                ok = 1;
            }
        }
    
        return ok;
    }
    
    /*==============================================================================
    Usata in qsort() per ordinare vettori di interi.
    ==============================================================================*/
    
    int confronta_int( const void *p1, const void *p2 ) {
        int i1 = *((int*)p1);
        int i2 = *((int*)p2);
        return i1!=i2 ? (i1>i2?1:-1) : 0;
    }
    
    /*==============================================================================
    Elimina dal vettore v di qEl elementi tutti quegli elementi la differenza tra i
    quali e' minore di diff.
    ==============================================================================*/
    
    size_t distanzia_elementi_vettore( int *v, size_t qEl, int diff ) {
        size_t i=0, j=1;
    
        while( j < qEl ) {
            while( v[j]-v[i]<diff && j<qEl ) ++j;
            if( j!=qEl ) v[++i] = v[j++];
        }
    
        return i+1;
    }
    
    /*==============================================================================
    Copia in un unico vettore vf tutte le colonne della matrice m che sono
    costituite esclusivamente da valori progressivamente crescenti.
    Ordina il vettore ottenuto.
    Elimina dal vettore (usando distanzia_elementi_vettore()) tutti quegli elementi
    la differenza tra i quali e' minore di diff.
    In uscita, vf contiene il puntatore al vettore elaborato e qElVf la quantita'
    degli elementi contenuti nel vettore stesso.
    Dal momento che il vettore e' allocato dinamicamente, spetta al chiamante
    liberare la memoria allocata.
    ==============================================================================*/
    
    int fondi_colonne_crescenti( int **m, size_t qr, size_t qc,
                                 int *cc, size_t qcc, int k,
                                 int **vf, size_t *qElVf ) {
    // m = matrice; qr = quantita righe; qc = quantita colonne
    // cc = colonne crescenti; qcc = quantita' delle colonne crescenti
    // k = differenza minima tra i valori delle colonne crescenti
    // vf = vettore fusione; qElVf = quantita' degli elementi in vf
        int ok = 0;
    
        if( m && cc && vf && qElVf ) {
    
            *vf = calloc( qcc*qr, sizeof(**vf) );
            *qElVf = 0;
    
            if( *vf ) {
                size_t r, c, i, j;
    
                for( i=0, j=0, c=0; c<qc&&j<qcc; ++c ) {
                    if( cc[c] ) {
                        for( r=0; r<qr; ++r, ++i )
                            (*vf)[i] = m[r][c];
                        ++j;
                    }
                }
    
                qsort( *vf, qcc*qr, sizeof(**vf), confronta_int );
    
                *qElVf = distanzia_elementi_vettore( *vf, j*qr, k );
    
                ok = 1;
            }
        }
    
        return ok;
    }
    
    /*==============================================================================
    Dato un valore intero senza segno, restituisce la quantita' di cifre necessarie,
    nella base di numerazione specificata, per esprimerlo come stringa.
    ==============================================================================*/
    
    size_t calcola_quantita_cifre( size_t numero, size_t base ) {
        size_t qc = 1; // "qc" = quantita' delle cifre
        while( numero /= base ) ++qc;
        return qc;
    }
    
    /*==============================================================================
    Predispone la stringa di formato necessaria a mostra_matrice() per visualizzare
    i valori della matrice.
    ==============================================================================*/
    
    void predisponi_formato( char *strFrmt ) {
        size_t qc = calcola_quantita_cifre( MAX_VALORE, 10 );
        sprintf( strFrmt, "%%%dd%%c", qc );
    }
    
    int mostra_matrice( int **m, size_t qr, size_t qc ) {
    // m = matrice; qr = quantita righe; qc = quantita colonne
        int ok = 0;
    
        if( m ) {
            char frmt[16];
            size_t r, c;
    
            printf( "Matrice:\n" );
    
            predisponi_formato( frmt );
    
            for( r=0; r<qr; ++r ) {
                if( m[r] ) {
                    for( c=0; c<qc; ++c ) {
                        printf( frmt, m[r][c], c<qc-1?' ':'\n' );
                    }
                }
                else {
                    printf( "riga nulla\n" );
                }
            }
    
            ok = 1;
        }
    
        return ok;
    }
    
    /*==============================================================================
    Visualizza in console gli indici delle colonne che contengono esclusivamente
    valori in ordine crescente.
    ==============================================================================*/
    
    int mostra_indici( int *pi, size_t qc, size_t qi ) {
    // pi: puntatore al vettore dei flag che individuano le colonne crescenti
    // qc: quantita' colonne nella matrice, qi: quantita' indici nel vettore
        int ok = 0;
    
        if( pi ) {
            if( qi > 0 ) {
                size_t i, c;
    
                printf( "\n%u colonn%c con valori crescenti a%sindic%c",
                        qi, qi>1?'e':'a', qi>1?"gli ":"ll'", qi>1?'i':'e' );
    
                for( i=0, c=0; c<qc; ++c )
                    if( pi[c] ) printf( " %d%c", c, i++<qi-1?',':'.' );
                printf( "\n\n" );
            }
            else {
                printf( "\nNessuna colonna con valori crescenti.\n\n" );
            }
    
            ok = 1;
        }
    
        return ok;
    }
    
    /*==============================================================================
    Visualizza in console il vettore predisposto da fondi_colonne_crescenti().
    ==============================================================================*/
    
    int mostra_vettore_fusione( int *v, size_t qEl, int diff ) {
    // v = il vettore; qEl = la quantita' degli elementi nel vettore
        int ok = 0;
    
        if( v ) {
            if( qEl > 0 ) {
                size_t i;
    
                printf( "%d valori con differenza maggiore di %d:\n  ", qEl, diff );
    
                for( i=0; i<qEl; ++i )
                    printf( " %d%c", v[i], i<qEl-1?',':'.' );
                printf( "\n\n" );
            }
            else {
                printf( "Nessun valore con differenza maggiore di %d.\n\n", diff );
            }
    
            ok = 1;
        }
    
        return ok;
    }
    
    /*==============================================================================
    Chiede all'utente se desidera lasciare il programma o procedere con
    l'elaborazione di una nuova matrice.
    ==============================================================================*/
    
    int altra_matrice( void ) {
        do {
            int c;
    
            printf( "\"Invio\" per valutare un'altra matrice, \"Q\" per uscire...     " );
            c = getchar();
    
            if( c == '\n' ) {
                system( "cls" );
                return 1;
            }
            else {
                while( getchar() != '\n' );
    
                if( c == 'q' || c == 'Q' )
                    return 0;
            }
        } while( 1 );
    }
    
  • Re: Aiuto per esercizi

    Non gira sul mio ide netbeans, vengono segnalati vari errori.
  • Re: Aiuto per esercizi

    Strano, con Code::Blocks e il compilatore gcc, pur impostato sul massimo livello di "pedanteria", non ricevo neppure un warning...
  • Re: Aiuto per esercizi

    Giusto per curiosità, che tipo di errori ti vengono segnalati? (mi viene un sospetto: non è che lo compili come se fosse c++ anziché c? perché in quel caso ci sarebbe da tenere presente la necessità di sottoporre a cast esplicito i void* forniti da calloc() )
  • Re: Aiuto per esercizi

    La pappa pronta non serve (quante volte te l'ho detto Aldo? Poi succede questo ... )

    Devi comprendere il metodo, l'algoritmo usato ... Lascia perdere eventuali errori (di cui non dici nulla fra l'altro) ma studialo per fare da te l'esercizio.
  • Re: Aiuto per esercizi

    La "pappa pronta" che arriva dalla mia tastiera di hobbista potrebbe anche essere un pappone avvelenato (pieno di errori, incongruenze, non-si-fa-così e altre stupidaggini). Lo so e lo scrivo con chiarezza ogni volta, perché non voglio passare per l'esperto che non sono. Più che altro, vedi questi miei interventi nella forma "io ho fatto così, che dite, va bene?". Dalle chiacchierate, assorbo correzioni e informazioni. E mi diverto!
  • Re: Aiuto per esercizi

    Questo codice che interpreta la richiesta di lasciare solo le coppie che distano più di K va bene?
    Il mio professore me lo dice esplicitamente quando vuole che usi la memoria dinamica, quindi in questo caso ho usato la statica.
    Ho fatto come dici selezionando codice C e il programma gira ma funziona in modo strano......
    Non cerco la pappa pronta né tantomeno cerco la perfezione. E' da tanto che sbatto per quest'esame (studio meccanica non informatica) e anche se interessante non è che abbia tutta sta voglia di stare incollato al pc.......quindi vi sarei molto grato se mi deste indicazioni su eventuali errori GRAVI nel mio codice
    
    #include<iostream>
    
    #include <cstdlib>
    
    using namespace std;
    void ivettore(int dim,int v[])
    {
        for(int i=0;i<dim;i++)
        {
            cout<<"\nInserisci l'elemento "<<i+1<<" ";
            cin>>v[i];
        }
    }
    void ovettore(int dim,int v[])
    {
        for(int i=0;i<dim;i++)
        {
            cout<<"  "<<v[i];
        }
    }
    
    int main()
    {
        int dim;
        int v[100];
        cout<<"Dimensione vettore ";
        cin>>dim;
        ivettore(dim,v);
        cout<<"v= ";
        ovettore(dim,v);
        int dis;
        cout<<"\nLascio solo le coppie di elementi che distano più di...";
        cout<<"\nScegli valore ";
        cin>>dis;
       
       for(int i=0;i<dim-1;i=i+2)
        {
            while(abs(v[i]-v[i+1])<=dis)
            {
                for(int j=0;j<dim-2;j++)
                {
                    v[i+j]=v[i+j+2];
                }
                dim=dim-2;
            }
        }
        
        cout<<"\nIl vettore filtrato è\n";
        ovettore(dim,v);
    }
    
    
  • Re: Aiuto per esercizi

    Va bene non ricercare la perfezione ma... il tuo programma sembra generare un ciclo infinito, no? L'hai provato?

    Secondo me è più semplice risolvere il caso con DUE indici anziché con uno (diciamo i e j): con "i" puoi seguire la posizione dell'ultimo elemento valido e con "j" quella dell'elemento che stai verificando, a partire dalla condizione i=0 e j=1.

    Se le condizioni di differenza minima non sono verificate tra l'elemento v e quello v[j] fai avanzare solo il secondo indice; se invece le condizioni di differenza minima sono verificate, dapprima copi l'elemento v[j] nella posizione v[i+1], quindi fai avanzare entrambi gli indici.

    Esci dal ciclo quando "j" raggiunge l'ultima posizione dell'array. In uscita dal ciclo, i+1 è la quantità degli elementi che hai "selezionato".

    Tutta questa pappardella si risolve in tre righe di codice (alla lettera), ma se le scrivo mi tirano le orecchie.
  • Re: Aiuto per esercizi

    E' vero genera un ciclo infinito....ora ci ragiono e vedo di modificarlo. Comunque questo programma parte dalla prima coppia e la lascia o la elimina, poi va alla seconda coppia e così via.......quindi nel vettore "filtrato" può comunque esserci una coppia di elementi consecutivi a distanza <=k giusto?
  • Re: Aiuto per esercizi

    Ho bloccato i cicli infiniti aggiungendo
    if(dim==2)
    {
    dim=0;
    cout<<"\nIl vettore filtrato è\n";
    ovettore(dim,v);
    exit(0);
    }

    e

    if(dim==1)
    {
    cout<<"\nIl vettore filtrato è\n";
    ovettore(dim,v);
    exit(0);
    }

    Quindi ora il programma diventa
    
    #include<iostream>
    
    #include <cstdlib>
    
    using namespace std;
    void ivettore(int dim,int v[])
    {
        for(int i=0;i<dim;i++)
        {
            cout<<"\nInserisci l'elemento "<<i+1<<" ";
            cin>>v[i];
        }
    }
    void ovettore(int dim,int v[])
    {
        for(int i=0;i<dim;i++)
        {
            cout<<"  "<<v[i];
        }
    }
    
    int main()
    {
        int dim;
        int v[100];
        cout<<"Dimensione vettore ";
        cin>>dim;
        ivettore(dim,v);
        cout<<"v= ";
        ovettore(dim,v);
        int dis;
        cout<<"\nLascio solo le coppie di elementi che distano più di...";
        cout<<"\nScegli valore ";
        cin>>dis;
       
       for(int i=0;i<dim-1;i=i+2)
        {
            while(abs(v[i]-v[i+1])<=dis)
            {
                if(dim==2)
                {
                    dim=0;
                    cout<<"\nIl vettore filtrato è\n";
                    ovettore(dim,v);
                    exit(0);
                }
                for(int j=0;j<dim-2;j++)
                {
                    v[i+j]=v[i+j+2];
                }
                dim=dim-2;
                if(dim==1)
                {
                    cout<<"\nIl vettore filtrato è\n";
                    ovettore(dim,v);
                    exit(0);  
                }
            }
        }
        cout<<"\nIl vettore filtrato è\n";
        ovettore(dim,v);
    }
    
    
  • Re: Aiuto per esercizi

    Non so... io interpreto diversamente la richiesta dell'esercizio. Secondo me non devi scartare ogni volta una coppia di dati quando non è rispondente alla condizione, bensì procedere come ho descritto nel commento precedente.

    Ad esempio, se hai una serie del tipo: 2,3,6,7,8 e la differenza minima è 4, cominci a vedere se 3-2>4; siccome non è così, nel ciclo successivo passi a vedere se 6-2>4; non è così neppure in quel caso, quindi passi a 7-2>4. Bingo! La condizione è vera, quindi passi il 7 nella posizione dove si trovava inizialmente il 3, trasformando la serie in 2,7,6,7,8. Prosegui quindi a vedere se 8-7>4 (cioè riprendi il confronto dal punto appena oltre quello che avevi appena verificato, confrontando il quinto elemento con il secondo)...

    Se l'array è ordinato, così dovrebbe funzionare.
    Qualora non fosse chiaro quel che ho appena descritto, torna al commento dove ti parlavo dell'usare due indici anziché uno solo.

    (Oh, ovviamente se qualcuno tra gli esperti ritiene che io stia scrivendo delle stupidaggini mi placchi, eh!)
Devi accedere o registrarti per scrivere nel forum
19 risposte