DOMANDA Trovare Il Valore Piu Frequente Di Un Vettore Con Un Semplice Esercizio In C

Pubblicità
angelo0001

angelo0001

Utente Èlite
Messaggi
4,071
Reazioni
638
Punteggio
141
Ciao, oggi ho fatto una verifica di informatica, e il secondo esercizio chiedeva proprio di trovare, all'interno di un vettore già caricata, il valore più frequente, tenendo conto che l'informatica è molto basiliare la prof ci ha detto di usare solo il vettore iniziale, ma io non riesco a capire come potrebbe essere possibile fare questo
Qualcuno mi sa dire se si può?
io ho fatto una cosa del genere
C: 
int main()
{
    int v[999], n, m, c[9999], i, r;
    for(i=0;i<n;i++)
    {
        r = v[I];
        c[r]++;
    }
    max = c[0];
    for (i = 0; i<9999;i++)
    {
        if(c[I]>max)
        {
            max = c[I];
            m = i;
        }
    }
    printf("\n%d - %d\n",m, max);
}
Che ovviamente non funziona così, ma la prof aveva detto che il vettore era già caricato.
Aggiustando il programma con l'inizializzazione fa quello che deve sul compilatore
 
Ultima modifica:
angelo0001 ha detto:
Ciao, oggi ho fatto una verifica di informatica, e il secondo esercizio chiedeva proprio di trovare, all'interno di un vettore già caricata, il valore più frequente, tenendo conto che l'informatica è molto basiliare la prof ci ha detto di usare solo il vettore iniziale, ma io non riesco a capire come potrebbe essere possibile fare questo
Qualcuno mi sa dire se si può?
io ho fatto una cosa del genere
C: 
int main()
{
    int v[999], n, m, c[9999], i, r;
    for(i=0;i<n;i++)
    {
        r = v[I];
        c[r]++;
    }
    max = c[0];
    for (i = 0; i<9999;i++)
    {
        if(c[I]>max)
        {
            max = c[I];
            m = i;
        }
    }
    printf("\n%d - %d\n",m, max);
}
Che ovviamente non funziona così, ma la prof aveva detto che il vettore era già caricato.
Aggiustando il programma con l'inizializzazione fa quello che deve sul compilatore
Clicca per espandere...
Dove compilate? Non credo sia linux quello che posti, inoltre con vettore già caricato cosa intendi? (Un vettore/array già definito?)
 
VidRam ha detto:
Dove compilate? Non credo sia linux quello che posti, inoltre con vettore già caricato cosa intendi? (Un vettore/array già definito?)
Clicca per espandere...
L'esercizio era una verifica scritta su foglio protocollo, tornato a casa l'ho provato su VS15 aggiungendo la parte iniziale mancante e funziona anche se sare più opportuno fare un ultimo ciclo for per stampare gli indici di c che hanno il valore uguale a max.
Ma la domanda è un altra: si può trovare il valore più frequente senza usare un secondo vettore?
 
Codice: 
int top = a[0];
int count = 1;
int count_temp = 1;
Fai un ciclo per contare quante volte compare top. Dopo fai un'altro ciclo partendo da a[1] e conti quante volte compare (count_temp++), se è maggiore di count, sostituisci count con count_temp, resetti count_temp e top diventa a[1]. E avanti cosi. Alla fine ti ritrovi con il valore più frequente e la sua frequenza. Si può comunque ottimizzare alla grande. Se il valore in lettura è uguale a top salta il ciclo
 
Ultima modifica:
rodhellas ha detto:
Codice: 
int top = a[0];
int count = 1;
int count_temp = 1;
Fai un ciclo per contare quante volte compare top. Dopo fai un'altro ciclo partendo da a[1] e conti quante volte compare (count_temp++), se è maggiore di count, sostituisci count con count_temp, resetti count_temp e top diventa a[1]. E avanti cosi. Alla fine ti ritrovi con il valore più frequente e la sua frequenza. Si può comunque ottimizzare alla grande. Se il valore in lettura è uguale a top salta il ciclo
Clicca per espandere...
Quanti cicli dovrei fare quindi?
 
rodhellas ha detto:
Codice: 
int top = a[0];
int count = 1;
int count_temp = 1;
Fai un ciclo per contare quante volte compare top. Dopo fai un'altro ciclo partendo da a[1] e conti quante volte compare (count_temp++), se è maggiore di count, sostituisci count con count_temp, resetti count_temp e top diventa a[1]. E avanti cosi. Alla fine ti ritrovi con il valore più frequente e la sua frequenza. Si può comunque ottimizzare alla grande. Se il valore in lettura è uguale a top salta il ciclo
Clicca per espandere...
In effetti si, però il grado di difficoltà non è minore a quello che avevo pensato io
In effetti il tuo programma dovrebbe però però fare x*y cicli, mentre a me basterebbero x+y cicli
 
rodhellas ha detto:
Però funziona :veach:

Due cicli, potresti farlo con uno (fai il conteggio anche da 0 e magari mettendo che se i != 0 allora usami count_temp e non temp(che sarà relativo ad a[0] e ai successivi top))
Clicca per espandere...
Qualcuno lo ha anche consegnato in bianco :nunu:, e il mio era il piu difficile in assoluto
 
Codice: 
due cicli sul vettore per confrontare ogni elemento con gli altri
numeroFrequente = 0
prendo l'elemento x e lo memorizzo in nome_temp
scorro il vettore per contare quanti ce ne sono e lo memorizzo in numero_temp
se numero_temp > numeroFrequente
      assegno a nomeFrequente nome_temp
e' solo una bozza immaginata in pochi minuti ma si potrebbe approfondire e, soprattuto, vedere se funziona...
se ho tempo lo provo in C
 
C: 
#include "stdafx.h"


int main()
{
    int v[999], n, m, i, r, max = 0, c = 0;
    scanf_s("%d", &n);
    for (i = 0; i < n;i++)
    {
        scanf_s("%d", &v[i]);
    }
    for (r = 0;r < 9999;r++)
    {
        c = 0;
        for (i = 0; i < n;i++)
        {
            if (v[i] == r)
            {
                c++;
            }
        }
        if (c>max)
        {
            max = c;
            m = r;
        }

    }
    
printf("\n%d - %d\n", m, max);

}

Si puo vedere che il pc effettuerà prima n operazioni, poi addirittura 9999n operazioni, mentre con il programma che avevo fatto io faceva 2(9999+n) operazioni, e l'esercizio da me fatto conserva i valori di ogni numero

Testando i programmi, con un vettore 99999 valori, dopo 5 secondi per inserire in input per entrambi i programmi, il mio programma fatto all'inizio con due vettori ti calcola istantaneamente il risultato, questo invece impiega altri 2 secondi
 
Ultima modifica:
Codice: 
int arr[N];
int max = arr[0];
int i;
int count = 0;
int count_temp = 0;
int j = 1;

for( i = 0; i < N; i++) {
    if ( arr[i] == max) {
        count++;
        }
        }

while ( j < N) {
for ( i = j; i < N; i++) {
    if ( arr[j] == arr[i]) {
        count_temp++;
        }
    }
    if ( count < count_temp) {
        count = count_temp;
        count_temp = 0;
        max = arr[j];
        }
        j++;
        }
   
        printf("%i %i", max, count);
Che non sia efficiente può essere, ma la prof ti ha chiesto di usare solo l'array iniziale. Secondo, tu confronti solo i numeri da 0 a 9998, le soluzioni proposte da me e da @Mursey accettano tutti i numeri possibili (nel range degli int). Terzo, stai allocando spazio per 999 e 9999 blocchi di memoria. Servono tutti? Non solo, ma 9000 posizioni dell'array non hanno valore (guardando il tuo codice)
 
Un altro modo potrebbe essere:
Ordini l'array, parti dal primo valore e conti finchè si ripete. Appena cambia, riparti dall'ultimo valore (quello diverso) e conti quante volte si ripete e cosi via. Fai tutto con un while(i != 998) e un ciclo for (j = i; .. ; j++). Ti salvi il massimo e count come al solito
 
angelo0001 ha detto:
C: 
#include "stdafx.h"


int main()
{
    int v[999], n, m, i, r, max = 0, c = 0;
    scanf_s("%d", &n);
    for (i = 0; i < n;i++)
    {
        scanf_s("%d", &v[i]);
    }
    for (r = 0;r < 9999;r++)
    {
        c = 0;
        for (i = 0; i < n;i++)
        {
            if (v[i] == r)
            {
                c++;
            }
        }
        if (c>max)
        {
            max = c;
            m = r;
        }

    }
     
printf("\n%d - %d\n", m, max);

}

Si puo vedere che il pc effettuerà prima n operazioni, poi addirittura 9999n operazioni, mentre con il programma che avevo fatto io faceva 2(9999+n) operazioni
Clicca per espandere...
rodhellas ha detto:
Codice: 
int arr[N];
int max = arr[0];
int i;
int count = 0;
int count_temp = 0;
int j = 1;

for( i = 0; i < N; i++) {
    if ( arr[i] == max) {
        count++;
        }
        }

while ( j < N) {
for ( i = j; i < N; i++) {
    if ( arr[j] == arr[i]) {
        count_temp++;
        }
    }
    if ( count < count_temp) {
        count = count_temp;
        count_temp = 0;
        max = arr[j];
        }
        j++;
        }
  
        printf("%i %i", max, count);
Che non sia efficiente può essere, ma la prof ti ha chiesto di usare solo l'array iniziale. Secondo, tu confronti solo i numeri da 0 a 9998, le soluzioni proposte da me e da @Mursey accettano tutti i numeri possibili (nel range degli int). Terzo, stai allocando spazio per 999 e 9999 blocchi di memoria. Servono tutti? Non solo, ma 9000 posizioni dell'array non hanno valore (guardando il tuo codice)
Clicca per espandere...
In effetti è più corretto
Ma:
Se la prof vede questa cosa mi manda lo stesso a quel paese, visto che non vuole cose complesse, mi sa che è un circolo vizioso. :search:
 
Poi posta qui la soluzione della prof, ormai sono curioso !!!

Che non sia ottimizzato e' normale, dopotutto e' solo un esercizio di problem-solving, nella realta' puoi usare quello che vuoi e farlo piu' efficiente possibile.
 
Pubblicità
Pubblicità
Indietro
Top