[C] Aiuto per favore

[Manugal]

Ciao a tutti.

E per la seconda volta non sono riuscito a passare l'esame perché non ho superato l'esercizio di sbarramento.

Allora l'esercizio è il seguente: Si scriva una funzione C che, dato un vettore di interi di dimensione nota ed un parametro k, verifichi se il vettore contiene esattamente k elementi uguali.

Io ho fatto così (da quello che mi ricordo):

int verificaElementi(int a[], int n, int k){
int cnt=0;
for(int i=0; i<n; ++i){
if(a[i]==a[i+1])
cnt++;
}
if (cnt==k)
return 1;
else return 0;
}

Mi pare fatto bene. Non capisco dove posso aver sbagliato. Cioè scandisco il vettore, controllo che siano uguali l'elemento corrente con il successivo, se lo sono aumento il contatore... Se questo contatore alla fine è uguale a k, significa che vi sono k elementi uguali (come richiede il testo) e ritorno 1, altrimenti ritorno 0. Dove ho sbagliato????

Grazie.

[D4rkAng3l]

mmm non mi pare sia corretto....poi non sò eprchè non l'hai scritto indentato e non si capisce bene

cmq che devi fare? devi fverificare se per ogni elemento ci stanno dei doppioni e se il numero di doppioni è proprio uguale a k

quindi devi fare 2 cicli annidati cioè per ogni elemento ti scorri tutti gli elementi del vettore e vedi se sono uguali..se ne trova uno uguale incrementa la variabili contatore...poi controlli se il contenuto della variabile contatore == k
se è uguale a k torna 1

[Manugal]

Ma scusa facendo quello che ho fatto io che cambia? Io confronto il precedente con il successivo (quindi ho probabilità di trovare k elementi uguali).

[D4rkAng3l]

aspe provo a farlo ad occhio sul forum...non prendelo come oro colato..su questo pc non ho il compilatore installato...

int verificaElementi(int a[], int n, int k){ 

     int i, j;
     int num = 0:
     for(i=0;i<n;i++){         // Per ogni elemento i del vettore
         for(j=0;j<n;j++){    // scorri il vettore alla ricerca di un elementouguale
          /* Se l'elemento indicizzato da i nel vettore è == all'elemento
              indicizzato da j nel vettore */  
          if(a[j]==a[j])
               num++;        // Incrementa il valore di num

         }
         if(num == k)     // Se num corrisponde al valore di k
              return 1;    // ritorna al chiamante il valore 1
      }
      return 0;   // Se non è stato restituito 1 e la funzione terminata anticipatamente allora vuol dire che non ci sono doppioni in numero pari a k e torna 0
}

L'esercizio è facile...ma potrei aver scritto cavolare teorieche serie...scrivere direttamente sul forum e indentare al momento a mano non è il massimo

Ciao
Andrea

[D4rkAng3l]

è sbalgiatissimo concettualmente te li confronti a coppie di 2 a 2 e poi passi alla coppia successiva...non può proprio andare così.-..ti consiglio di farti il diagramma a blocchi e di scriverti passo per passo quello che fà così ti accordi dei risultati che ti escono ;-)

[Gica78R]

Anche secondo me l'interpretazione non e' giusta.
Esempio:
se il vettore contiene gli elementi {1,2,4,2,6,5,3,2,6,3,6}, l'esito in base al valore di k dovrebbe essere:
k=1 -> Si (o true, o quello che vuoi che ritorni la funzione in caso di successo) perche' c'e' un 1 (ma anche un 4, un 5...)
k=2 -> Si, perche' ci sono due 3
k=3 -> Si, perche' ci sono tre 2 (ma anche tre 6)
k=4 -> No, perche' non c'e' nessun elemento ripetuto quattro volte

Almeno questa e' la mia interpretazione del testo:

Si scriva una funzione C che, dato un vettore di interi di dimensione nota ed un parametro k, verifichi se il vettore contiene esattamente k elementi uguali.

ma magari non e' l'interpretazione corretta...

Gica

[Madmind]

Originariamente inviato da D4rkAng3l

aspe provo a farlo ad occhio sul forum...non prendelo come oro colato..su questo pc non ho il compilatore installato...

int verificaElementi(int a[], int n, int k){ 

     int i, j;
     int num = 0:
     for(i=0;i<n;i++){         // Per ogni elemento i del vettore
         for(j=0;j<n;j++){    // scorri il vettore alla ricerca di un elementouguale
          /* Se l'elemento indicizzato da i nel vettore è == all'elemento
              indicizzato da j nel vettore */  
          if(a[j]==a[j])
               num++;        // Incrementa il valore di num

         }
         if(num == k)     // Se num corrisponde al valore di k
              return 1;    // ritorna al chiamante il valore 1
      }
      return 0;   // Se non è stato restituito 1 e la funzione terminata anticipatamente allora vuol dire che non ci sono doppioni in numero pari a k e torna 0
}

L'esercizio è facile...ma potrei aver scritto cavolare teorieche serie...scrivere direttamente sul forum e indentare al momento a mano non è il massimo

Ciao
Andrea

attenzione a 2 cose... un errore di sintassi (hai fatto a[j] == a[j] invece che a[i] == a[j]).
Devi stare anche attento a non confrontare il valore con se stesso, quindi saltare il giro nel secondo ciclo quando j e i sono uguali.
Risolte queste due cose, c'e' cmq un problema di logica... non ottieni il risultato corretto... per prima cosa incrementi anche se trovi due coppie di valori diverse... 2 e 2 e 3 e 3... in piu', supponendo di avere un valore ripetuto che so 4 volte, tu, in tutte e 4 le volte lo conteggi 3 volte (ah tra l'altro cosi' non torna cmq perche' conteggi il valore sempre una volta in meno del dovuto).
Insomma e' proprio da impostare in maniera diversa

una possibile soluzione e' ordinare prima il vettore e poi confrontare i valori a coppie, in parte come aveva fatto Manugal, anche se nel suo ciclo il vettore andava fuori dimensione (l'ultimo confronto era fatto con a[i] con a[i+1], ma fatto sull'ultimo elemento del vettore non va bene) controllando ogni volta che il numero cambia se si e' conteggiato n numeri uguali a k.

Non so se mi sono spiegato, ma dopo 10 ore di lavoro sono un po' fuso e non riesco a esser piu' preciso

[Madmind]

dopo l'ordinamento (ne puoi implementare uno qualunque... ce ne sono parecchi di algoritmi) potevi scrivere una cosa del genere:

boolean verificaElementi(int a[], int n, int k) 
{
  boolean trovato = false;
  int cnt=1;
  for(int i=0; i<n-1 && !trovato ; i++)
  {
    if(a[i]==a[i+1])
    cnt++;
    else if (cnt == k) trovato = true;
    else cnt = 1;
  }
  if (n == 1 && k == 1) trovato = true;
  return trovato;
}

cnt sta inizializzato a 1 perche' almeno un elemento uguale a se stesso c'e' sempre.

Nel caso ci sia solo un elemento nel vettore e k sia uno, allora il ciclo viene skippato, ma bisogna ritornare true (l'ho gestita male lo so, ma l'ho fatto velocemente).

non ho verificato nulla e ho scritto il codice in questo istante... non garantisco nulla quindi :P

[Madmind]

ah pardon sono un fesso, non considerare il boolean e usa degli int (abituato a java)

#define TRUE 1
#define FALSE 0


int verificaElementi(int a[], int n, int k) 
{
  int trovato = FALSE;
  int cnt=1;
  for(int i=0; i<n-1 && trovato != TRUE ; i++)
  {
    if(a[i]==a[i+1])
    cnt++;
    else if (cnt == k) trovato = TRUE;
    else cnt = 1;
  }
  if (n == 1 && k == 1) trovato = TRUE;
  return trovato;
}

[D4rkAng3l]

Originariamente inviato da Madmind

attenzione a 2 cose... un errore di sintassi (hai fatto a[j] == a[j] invece che a[i] == a[j]).
Devi stare anche attento a non confrontare il valore con se stesso, quindi saltare il giro nel secondo ciclo quando j e i sono uguali.
Risolte queste due cose, c'e' cmq un problema di logica... non ottieni il risultato corretto... per prima cosa incrementi anche se trovi due coppie di valori diverse... 2 e 2 e 3 e 3... in piu', supponendo di avere un valore ripetuto che so 4 volte, tu, in tutte e 4 le volte lo conteggi 3 volte (ah tra l'altro cosi' non torna cmq perche' conteggi il valore sempre una volta in meno del dovuto).
Insomma e' proprio da impostare in maniera diversa

una possibile soluzione e' ordinare prima il vettore e poi confrontare i valori a coppie, in parte come aveva fatto Manugal, anche se nel suo ciclo il vettore andava fuori dimensione (l'ultimo confronto era fatto con a[i] con a[i+1], ma fatto sull'ultimo elemento del vettore non va bene) controllando ogni volta che il numero cambia se si e' conteggiato n numeri uguali a k.

Non so se mi sono spiegato, ma dopo 10 ore di lavoro sono un po' fuso e non riesco a esser piu' preciso

mmm l'avevo detto che non ne ero sicuro l'ho scritto in 20 secondi direttamente sul forum

[D4rkAng3l]

Originariamente inviato da Madmind

attenzione a 2 cose... un errore di sintassi (hai fatto a[j] == a[j] invece che a[i] == a[j]).
Devi stare anche attento a non confrontare il valore con se stesso, quindi saltare il giro nel secondo ciclo quando j e i sono uguali.
Risolte queste due cose, c'e' cmq un problema di logica... non ottieni il risultato corretto... per prima cosa incrementi anche se trovi due coppie di valori diverse... 2 e 2 e 3 e 3... in piu', supponendo di avere un valore ripetuto che so 4 volte, tu, in tutte e 4 le volte lo conteggi 3 volte (ah tra l'altro cosi' non torna cmq perche' conteggi il valore sempre una volta in meno del dovuto).
Insomma e' proprio da impostare in maniera diversa

una possibile soluzione e' ordinare prima il vettore e poi confrontare i valori a coppie, in parte come aveva fatto Manugal, anche se nel suo ciclo il vettore andava fuori dimensione (l'ultimo confronto era fatto con a[i] con a[i+1], ma fatto sull'ultimo elemento del vettore non va bene) controllando ogni volta che il numero cambia se si e' conteggiato n numeri uguali a k.

Non so se mi sono spiegato, ma dopo 10 ore di lavoro sono un po' fuso e non riesco a esser piu' preciso

si è vero...ora l'ho rivisto perchè basta che arriva a quel numero e restituisce 1 anche se poi magari si incrementa ancora

[tglman]

io Sono per il metodo di D4rkAng3l ma con qualche semplice e rapida modifica

L'altro metodo non può andare.....

Comunque ecco a voi:

int verificaElementi(int a[], int n, int k)
{ 
     int i, j;
     int num = 0:
     for(i=0;i<n;i++)
     {     
         for(j=i;j<n;j++)
         {  
               if(a[j]==a[i])num++;        
               if(num==k)return 1;
         }
         num=0;
      }
      return 0;  
}

non lo provato ma cosi di loggica funziona quasi certamente.

Ciao mitici

[anx721]

Originariamente inviato da tglman

io Sono per il metodo di D4rkAng3l ma con qualche semplice e rapida modifica

L'altro metodo non può andare.....

Comunque ecco a voi:

int verificaElementi(int a[], int n, int k)
{ 
     int i, j;
     int num = 0:
     for(i=0;i<n;i++)
     {     
         for(j=i;j<n;j++)
         {  
               if(a[j]==a[i])num++;        
               if(num==k)return 1;
         }
         num=0;
      }
      return 0;  
}

non lo provato ma cosi di loggica funziona quasi certamente.

Ciao mitici

Cosi ti ritorna 1 se contiene almeno k elementi; devi spostare l'if fuori dai cicli for e anche il secondo contatore, j, deve partire da 0 non da i se no restituisce 1 se ci sono k elementi a partire da i e ce ne potrebbero essere altri prima di i

[tglman]

per l'if fuori ti do ragione perchè altrimenti andiamo a finire su almeno e non su un numero preciso, per il fatto che riguarda la partenza da i è cosi perchè i valori precedenti sono gia stati controllati.

Ciao.

[IspiCiosa]

prima ordini il vettore!!!!!!!!!! poi ci aggiungi il primo esercizio ke hai postato pero inizializzando cnt a 1 e nn a zero..........

vedrai ke è giusto....

facendo a[i]==a[i+1] se nn è ordinato nn è detto ke a[i] != a[i+2]capito?


ps: 5--4--4--5--6

confronta il primo col secondo il terzo col quarto....ma nn il quarto col primo!!!!

se lo ordini....

4--4--5--5--6

cosi poi è apposto.......



capito?

[tglman]

no scusa hai ragione tu anche sul secondo punto, però si può migliorare lo stesso la cosa