Matrice Dinamica - Trovare il valore intero ripetuto + volte

di il
17 risposte

Matrice Dinamica - Trovare il valore intero ripetuto + volte

Ciao a tutti !!! Ho un esercizio da svolgere,e sono quasi alla fine,ma vorrei una delucidazione,se possibile,su come trovare negli interi inseriti in ogni vettore che ho creato dinamicamente,quello che si ripete piu volte,non riesco a trovare un ragionamento logico adatto! Se qualcuno riuscisse a spiegarmi glie ne sarei grato ! Vi incollo il codice qui sotto,l'ultimo pezzo è il tentativo ( non funzionante ) di stampare il valore intero ripetuto piu volte all'interno della mia matrice dinamica creata.
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int Ordinamento();

int main()
{
    int **vettore/* Puntatore di puntatori */, dimensione, k, i, j, h ;
    srand((int) time(NULL));
    
    printf("Inserire quanti vettori dinamici si vogliono creare : ");
    fflush(stdin);
    k = scanf("%d",&dimensione);
    
    while( k == 0 )
    {
           printf("\n\nErrore di Input!Reinserire quanti vettori dinamici si vogliono creare : ");
           fflush(stdin);
           k = scanf("%d", &dimensione);
           
    }
    
    vettore = (int**) malloc ( dimensione * sizeof(int) ); /* Vettore di puntatori */
    
    for( k = 0 ; k < dimensione ; k++ )
    {
         vettore[k] = (int*) malloc (( k+2 ) * sizeof(int) ); /* Creo un vettore da ogni puntatore di vettori */
         
    }
    
    printf("\nI Valori Random memorizzati nei vettori dinamici creati sono :\n");
    
    for ( k = 0 ; k < dimensione ; k++ )
    {
        puts("");
        
        for( i = 0 ; i < (k + 2) ; i++ )
        {
             vettore[k][i] =  -100 + (rand()% 200);
             printf("%d  ", vettore[k][i]);
        }
    }
    
    puts("\n");
    system("pause");
    system("cls");
    fflush(stdin);
    
    printf("I valori Random memorizzati nei vettori disposti in ordine crescente sono : \n");
    
    for ( k = 0 ; k < dimensione ; k++ )
    {
        puts("");
        
        for( i = 0 ; i < ( k + 2 ) ; i++ )
        {
             qsort(vettore[k], dimensione, sizeof(int), Ordinamento );
             printf("%d  ", vettore[k][i]);
             
        }
    }
    
    int massimo = 0;
    
    for ( k = 0 ; k < dimensione ; k++ )
    {
        for(i = 0 ; i < ( k + 2 ) ; i++ )
        {
              if( vettore[k][i] >= massimo )
              {
                  massimo = vettore[k][i];
                  
              }
        }
    }
    
    printf("\n\nIl numero intero maggiore contenuto nei vettori e' %d ", massimo);
    
    int ripetuto = 0,
    contatore = 0 ;
    
    for ( k = 0 ; k < dimensione ; k++ )
    {
        for( i = 0 ; i < (k + 2) ; i++ )
        {
             ripetuto = vettore[k][i];
             
             for ( j = 0 ; j < dimensione ; j++)
             {
                 for ( h = 0 ; j < ( j + 2 ) ; h++)
                 {
                     if( vettore[j][h] == ripetuto )
                     {
                         contatore++;
                         
                     }
                 }
             }
        }
    }
    
    printf("Il numero presente piu' volte nella matrice e' %d ripetuto %d volte",ripetuto,contatore);
                     
    puts("\n");
    system("pause");
    return 0;
    
}

int Ordinamento ( const void *P, const void *S )
{
    int *a, *b ;
    
    a = (int*) P ;
    b = (int*) S ;
    
    if ( *a == *b )
    {
         return 0;
         
    }
    
    if ( *a < *b )
    {
         return -1;
         
    }
    
    if ( *a > *b )
    {
         return 1;
         
    }
    
} 

17 Risposte

  • Re: Matrice Dinamica - Trovare il valore intero ripetuto + volte

    Hai bisogno di una struttura dati di appoggio.
    L'ideale sarebbe una lista semplice collegata. ma anche un array può andare se il range dei valori non è grande (maxint-minint), come nel tuo caso.
    Quindi:
    int ripetuti[maxint-minint];

    l'algoritmo può essere il seguente:

    scandisci tutti gli elementi dei vettori incrementando di 1 ripetuti[vettore[k]-minint]
    Poi, una valutazione, che lascio fare a te per esercizio , su ripetuti ti darà il risultato che cerchi.
    Ciao.
  • Re: Matrice Dinamica - Trovare il valore intero ripetuto + volte

    Grazie intanto per la risposta! Si avevo pensato anche io ad un vettore, liste pile e alberi ancora non sono di mia competenza ! Allora, non arrivo a capire bene il tuo ragionamento, ok per quanto riguarda il nuovo vettore che mi creo,e in cui salvo i valori che scorro nella matrice(cosi da sistemarli appunto in un vettore unico) va bene,ma poi non capisco cosa intente con "ripetuti[vettore[k],min int]...cioè io vorrei avere un modo per scandire ogni numero presente e salvarmi quante volte lo incontro,ma è un casino perchè dovrei avere una variabile contatore per ogni numero presente... Nha...
  • Re: Matrice Dinamica - Trovare il valore intero ripetuto + volte

    E' proprio il sistema che ti ho suggerito.
    Vediamo un piccolo esempio con MaxInt=2 e MinInt =0.
    Immaginiamo che il tuo vettore dei vettori sia questo:
    | 0 1 0|
    | 2 2 1|
    | 1 1 1|

    Il pezzetto di codice che fa la magia è questo
    
    int ripetuti[MaxInt-MinInt+1]; //ATTENTO: per errore ti avevo suggerito MaxInt-MinInt
    ...
    for (i=0;i<=2;i++) ripetuti[i]=0; //prima azzero ripetuti!
    
    for (i=0;i<=2;i++) 
      for (j=0;j<=2;j++)
        ripetuti[vettore[i][j]]+=1;
    
    dopo la scansione avrai che ripetuti vale:

    [2 5 2]

    Dopo di ciò entri in gioco tu e trovi l'indice del massimo in ripetuti .
    Tale indice è proprio l'intero più ripetuto.
    Se vedi l'esempio, nel nostro caso l'1 è l'intero più ripetuto ed è ripetuto 5 volte. l'indice del valore 5 (il massimo) in ripetuti è proprio 1;
    Spero ti aiuti.
  • Re: Matrice Dinamica - Trovare il valore intero ripetuto + volte

    Certo che mi aiuta!!! Piu o meno ci siamo,sono connesso ! Adesso prova a sistemare il tutto ! Intanto GRAZIE !!!
  • Re: Matrice Dinamica - Trovare il valore intero ripetuto + volte

    Se l'intervallo di interi non è noto a priori o è molto grande, allora devi usare una struttura dati un pochino più complessa. Ciao.
  • Re: Matrice Dinamica - Trovare il valore intero ripetuto + volte

    L'esercizio dice che dato un valore "n", si allocchino "n" vettori,di grandezza da 2 a n+1...!!! Quindi se metto che voglio creare 3 vettori,il programma creera il primo di 2 elementi,secondo di 3,e terzo di quattro!!!...ho messo un limite di input di massimo 20 vettori,quindi penso propio che i valori si possano tranquillamente memorizzare in un singolo vettore! O sbaglio ?!
  • Re: Matrice Dinamica - Trovare il valore intero ripetuto + volte

    Dipende. La traccia dice vettori di interi. La tua interpretazione prevede una generazione di interi random in un certo intervallo. Se la tua scelta è giusta, allora l'intervallo dei numeri interi è limitato e va bene l'array ripetuti. Se gli elementi sono interi (e basta) allora l'array unidimensionale ripetuti non ti basta più e devi passare ad un array bidimensionale con righe pari al numero di totale di elementi da esaminare e due colonne. In una colonna memorizzi l'intero che incontri nella scansione e nell'altra il numero delle sue occorrenze.
    Una successiva scansione dell'array ti darà la risposta.
    Ciao
  • Re: Matrice Dinamica - Trovare il valore intero ripetuto + volte

    Sono arrivato a questo punto! ma non mi funziona...mi sta scoppiando la faccia quindi se hai voglia dimmi cosa sbaglio e bona !
    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    #include <time.h>
    
    int main()
    {
        int **vettore/* Puntatore di puntatori */, dimensione, k, i, j, h ;
        srand((int) time(NULL));
        
        printf("Inserire quanti vettori dinamici si vogliono creare ( Massimo 20 ) : ");
        fflush(stdin);
        k = scanf("%d",&dimensione);
        
        while( k == 0 || dimensione > 20 )
        {
               printf("\nErrore di Input! Reinserire quanti vettori dinamici si vogliono creare : ");
               fflush(stdin);
               k = scanf("%d", &dimensione);
               
        }
        
        vettore = (int**) malloc ( dimensione * sizeof(int) ); /* Vettore di puntatori */
        
        for( k = 0 ; k < dimensione ; k++ )
        {
             vettore[k] = (int*) malloc (( k + 2 ) * sizeof(int) ); /* Creo un vettore da ogni puntatore di vettori */
             
        }
        
        printf("\nI Valori Random memorizzati nei vettori dinamici creati sono :\n");
        
        for ( k = 0 ; k < dimensione ; k++ )
        {
            puts("");
            
            for( i = 0 ; i < (k + 2) ; i++ )
            {
                 vettore[k][i] =  0 + (rand()% 100);
                 printf("%d  ", vettore[k][i]);
            }
        }
        
        int massimo = 0 ; /* Variabile in cui memorizzo il valore massimo*/
        int minimo = 0 ;
        
        for ( k = 0 ; k < dimensione ; k++ )
        {
            for(i = 0 ; i < ( k + 2 ) ; i++ )
            {
                  if( vettore[k][i] >= massimo ) /* Se il l'elemento al punto in cui è il ciclo è maggiore del valore massimo memorizzato lo memorizzo */
                  {
                      massimo = vettore[k][i];
                      
                  }
                  
                  if( vettore[k][i] <= minimo )
                  {
                      minimo = vettore[k][i];
                      
                  }
            }
        }
        
        printf("\n\nIl numero intero maggiore contenuto nei vettori e' %d \n\n", massimo);
        
        int ripetuti[(massimo - (minimo + 1))]; //ATTENTO: per errore ti avevo suggerito MaxInt-MinInt
        
        for( i = 0; i < dimensione ; i++) 
        {
                  ripetuti[i] = 0;
        }
             
             for( i = 0 ; i < dimensione ; i++)
             {
                  for ( j = 0 ; j < (k + 2 ) ; j++)
                  {
                      ripetuti[vettore[i][j]] += 1 ;
                      
                  }
             }
        
        printf("Il numero presente piu' volte nella matrice e' %d ripetuto tot volte",ripetuti[vettore[i][j]]);
                         
        puts("\n");
        system("pause");
        return 0;
        
    }]
  • Re: Matrice Dinamica - Trovare il valore intero ripetuto + volte

    Questo pezzo
    
      int ripetuti[(massimo - (minimo + 1))]; //ATTENTO: per errore ti avevo suggerito MaxInt-MinInt
        
        for( i = 0; i < dimensione ; i++) 
        {
                  ripetuti[i] = 0;
        }
    
    deve essere così:
    
        int ripetuti[(massimo - minimo + 1)]; 
        for( i = 0; i < (massimo - minimo + 1) ; i++) 
        {
                  ripetuti[i] = 0;
        }
    
    Poi questo pezzo
    
        printf("Il numero presente piu' volte nella matrice e' %d ripetuto tot volte",ripetuti[vettore[i][j]]);
    non va bene.
    Al posto di questa dannosissima istruzione, avevamo condiviso che devi cercare l'indice del massimo valore dentro l'array ripetuti, che è anche l'intero ripetuto più volte nei tuoi array. Questo pezzo devi farlo tu! Buon lavoro.
  • Re: Matrice Dinamica - Trovare il valore intero ripetuto + volte

    Si ma il fatto è che non essendo mio il ragionamento da internet faccio una fatica bestia a capire il ragionamento che fai tu! Praticamente io mi creo un vettore con maxInt - minInt + 1 ...Ma non capisco perche poniamo "ripetuti = 0"...!!! Io ora l'ho impostato cosi !
    int ripetuti[(massimo - minimo + 1)]; 
        
        for( i = 0; i < (massimo - minimo + 1) ; i++) 
        {
                  ripetuti[i] = 0;
        }
        
        massimo = 0 ;
        
        for( i = 0; i < (massimo - minimo + 1) ; i++ )
        {
             if ( ripetuti[i] >= massimo )
             {
                  massimo = ripetuti[i];
                  
             }
        }
        
        if ( massimo == 0 )
        {
             printf("Non ci sono valori ripetuti !!!");
             
        }
        else
        
        printf("Il valore ripetuto piu' volte nei vettori e' : %d\n\n", massimo);
  • Re: Matrice Dinamica - Trovare il valore intero ripetuto + volte

    Lo azzeriamo perché altrimenti contiene dati spuri e perché all'inizio tutti gli interi li abbiamo contati 0 volte.No?
    Poi, questa istruzione

    ripetuti[vettore[j]] += 1 ;

    deve essere
    ripetuti[vettore[j]-minimo] += 1 ;
    leggiti di nuovo la descrizione che ti ho fatto dell'algoritmo per capire.

    ciao
  • Re: Matrice Dinamica - Trovare il valore intero ripetuto + volte

    Raga una semplice domanda. Il testo completo dell'esercizio si può sapere?
    Anzi due domande; la seconda: Cosa sai della parola chiave struct?
  • Re: Matrice Dinamica - Trovare il valore intero ripetuto + volte

    @skynet: Ottimo!
  • Re: Matrice Dinamica - Trovare il valore intero ripetuto + volte

    Sò che la struct è una struttura contenente dati di diverso tipo (int char float ecc),alla quale assegno un nome come una semplice variabile,e dentro quella struttura ci memorizzo i dati relalativi all'oggetto in questione,ad esempio se lavoriamo su degli studenti usiamo una struttura per memorizzarci dentro nome,cognome,matricola,voti,ecc per ogni studente ! Ma in questo caso le struttura possono essere utili,volendo creo un vettore di struct in maniera dimanica,e uso una struttura per ogni numero,nella quale ci memorizzo il numero in questione e quante volte si ripete nei vettori, a questo avevo pensato ma è una cosa troppo avanti,sia per l'esercizio sia x me,non mi piace fare passi piu lunghi della mia gamba! cmq il testo completo è questo :

    -Scrivere un programma che chieda all'utente un numero n e quindi - allochi n vettori di interi di lunghezza rispettivamente da 2 a n+1; - riempa i vettori - cerchi fra gli interi quello di valore massimo e quello ripetuto più volte.

    Comunque io sono arrivato a pensarla cosi :
    for ( k = 0 ; k < dimensione ; k++ )
        {
            for( i = 0 ; i < ( k + 2 ) ; i++ )
            {
                 
                 for( h = 0 ; h < dimensione ; h++ )
                 {
                      for( j = 0  ; j < ( h + 2 ) ; j++ )
                      {
                           if ( vettore[k][i] == vettore[h][j] )
                           {
                                ripetuto1 = vettore[k][i];
                                cont += 1 ;
                                
                           }
                           
                           if ( cont > contatore ) 
                           {
                                contatore = cont ;
                                ripetuto2 = vettore[k][i];
                                
                           }
    
                      }
                 }
            }
        }
    Non và del tutto bene, ma il ragionamento non penso sia sbagliato,xkè cosi facendo "fisso" un valore,e poi lo confronto con tutti gli altri e tengo il conteggio di quante volte è presente,faccio lo stesso con tutti gli altri valori,e li memorizzo se e solo se sono presenti un numero maggiore di volte di quello precedente.
Devi accedere o registrarti per scrivere nel forum
17 risposte