Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - sottosequenze contenute
Forum - C/C++ - sottosequenze contenute

Pagine: [ 1 2 ] Precedente | Prossimo
Avatar
()
Newbie


Messaggi:
Iscritto:

Segnala al moderatore
Postato alle 1:00
Giovedì, 01/01/1970
ho un problema in questo programma...il bug sta nel fatto che se metto nella sequenza iniziale numeri ad una sola cifra funziona, appena aumentano le cifre mi dice comunque che le sottosequenze sono contenute nonostante non lo siano....

Codice sorgente - presumibilmente C++

  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. const int Max  = 1000;
  6.  
  7.  
  8. int leggi(int [], int &);
  9.  
  10. bool contenuta(int [], int [], int, int);
  11.  
  12. int main (){
  13.    
  14.     int A[Max], B[Max], C[Max], dim = 0, dimb = 0, dimc = 0;
  15.    
  16.     cout << "\t\t\t***calcoli in sottesequenza***\n\n";
  17.     cout << "inserisci una sequenza di numeri(1000 per terminare): \n";
  18.    
  19.     leggi(A, dim);
  20.    
  21.     cout << "inserisci un'altra sottosequenza(1000 per terminare):\n";
  22.    
  23.     leggi(B, dimb);
  24.    
  25.     cout << "inserisci ancora un'altra sottosequenza(1000 per terminare): \n";
  26.    
  27.     leggi(C, dimc);
  28.    
  29.     cout << "ORA IL COMPUTER CONTROLLA SE LE DUE SOTTOSEQUENZE\nSONO CONTENUTE NELLA SEQUENZA PRINCIPALE:\n\n\n";
  30.    
  31.    
  32.     if (contenuta(A, B, dim, dimb))
  33.     cout << "la sottosequenza 1 e' contenuta nella sequenza di partenza!\n";
  34.     else
  35.     cout << "la sottosequenza 1 non e' contenuta nella sequenza di partenza!\n";
  36.     if (contenuta(A, C, dim, dimc))
  37.     cout << "la sottosequenza 2 e' contenuta nella sequenza di partenza!\n";
  38.     else
  39.     cout << "la sottosequenza 2 non e' contenuta nella sequenza di partenza!\n";
  40.     system("pause");
  41.     return 0;
  42.    
  43.     }
  44.  
  45.  
  46. int leggi(int A[], int & dim){
  47.  
  48.         for (int i = 0; i < Max; i++){
  49.                 cin >> A[i];
  50.                 if (A[i] == 1000 || dim > Max)
  51.                         return 0;
  52.                 dim++;
  53.         }
  54. }
  55.  
  56. bool contenuta(int A[], int B[], int dim, int dimS){
  57.        
  58.     for (int i = 0; i < dim; i++){
  59.         if(A[i] == B[0]){
  60.             int conti = i, contz = 0;
  61.        
  62.                while(contz < dimS){
  63.                  if (A[conti] == B[contz]){
  64.                  conti++;
  65.                  contz++;
  66.                }
  67.                else if (A[conti] != B[contz])
  68.                return false;    
  69.             }    
  70.            return true;  
  71.         }
  72.    
  73.  
  74.     }}


PM Quote
Avatar
HeDo (Founder Member)
Guru^2


Messaggi: 2763
Iscritto: 21/09/2007

Segnala al moderatore
Postato alle 18:00
Venerdì, 27/11/2009

come già detto in privato, il problema sta nel return false mancante alla fine di "contenute".

un altro possibile codice per quella funzione potrebbe essere il seguente:

Codice sorgente - presumibilmente C++

  1. bool contenuta(int A[], int B[], int dim1, int dim2) {
  2.  
  3.         // La più lunga non può essere contenuta nella più corta!
  4.         if (dim2 > dim1) return false;
  5.  
  6.         // Se stiamo comparando le due sequenze
  7.         bool bComparing = false;
  8.  
  9.         int h = 0;
  10.  
  11.         // Scorriamo tutti gli elementi della sequenza principare
  12.         for(int n = 0; n < dim1; n++) {
  13.                
  14.                 // Se le stiamo comparando
  15.                 if (bComparing) {
  16.                        
  17.                         // Andiamo avanti nella seconda sequenza
  18.                         h++;
  19.  
  20.                         // Se gli elementi sono diversi la sequenza è diversa
  21.                         if (A[n] != B[h]) return false;
  22.  
  23.                         // Se siamo arrivati in fondo alla seconda sequenza
  24.                         // e non abbiamo trovato nessun elemento diverso
  25.                         // vuol dire che sono uguali
  26.                         if (h == dim2 - 1) return true;
  27.                
  28.                 } else
  29.                         // Iniziamo il confronto al primo elemento uguale
  30.                         bComparing = (A[n] == B[0]);           
  31.  
  32.  
  33.         }
  34.  
  35.         // Se arriviamo qui vuol dire che il ciclo è finito senza attivare
  36.         // il flag bComparing, ne deduciamo che le stringhe non hanno
  37.         // nemmeno un elemento in comune => diverse
  38.         return false;
  39.  
  40. }



da notare anche il fatto che nella funzione leggi il numero 1000 non va messo nell'array, quindi:

Codice sorgente - presumibilmente C++

  1. int leggi(int A[], int & dim){
  2.  
  3.         int temp = 0;
  4.  
  5.         for (int i = 0; i < Max; i++){
  6.                
  7.                 cin >> temp;
  8.  
  9.                 if (temp == 1000 || dim > Max)
  10.                         return 0;
  11.  
  12.                 A[i] = temp;
  13.  
  14.                 dim++;
  15.         }
  16.  
  17.         return 0;
  18. }



Ingegnere Informatico
https://ldlagency.it
PM Quote
Avatar
()
Newbie


Messaggi:
Iscritto:

Segnala al moderatore
Postato alle 18:14
Venerdì, 27/11/2009
ma questo codice:

Codice sorgente - presumibilmente Plain Text

  1. bComparing = (A[n] == B[0]);




non dovrebbe essere :

Codice sorgente - presumibilmente Plain Text

  1. bComparing = (A[n] == B[h]);



con la h al posto dello 0....

PM Quote
Avatar
Lawliet (Normal User)
Expert


Messaggi: 386
Iscritto: 09/04/2009

Segnala al moderatore
Postato alle 18:45
Venerdì, 27/11/2009
In effetti manca una return false nel tuo codice Riuzaki, ma è molto confuso il tuo... meglio quello proposto da HeDo, però c'è un errore che non ha considerato la possibilità se la sottosequenza abbia un elemento, o entrambi! :)

Testo quotato

Postato originariamente da Riuzaki:

ma questo codice:

Codice sorgente - presumibilmente Plain Text

  1. bComparing = (A[n] == B[0]);




non dovrebbe essere :

Codice sorgente - presumibilmente Plain Text

  1. bComparing = (A[n] == B[h]);



con la h al posto dello 0....



Non ti serve a niente questo dettaglio, tanto sempre 0 è ^^'


Ultima modifica effettuata da Lawliet il 27/11/2009 alle 18:57


"Dai un pesce (programma) a un uomo e lo nutrirai per un giorno. Insegnagli a pescare (programmare) e lo nutrirai per tutta la vita." (niente pappa pronta)
cit. theprogrammer
PM Quote
Avatar
HeDo (Founder Member)
Guru^2


Messaggi: 2763
Iscritto: 21/09/2007

Segnala al moderatore
Postato alle 19:44
Venerdì, 27/11/2009

Codice sorgente - presumibilmente C++

  1. bool contenuta(int A[], int B[], int dim1, int dim2) {
  2.  
  3.         // La più lunga non può essere contenuta nella più corta!
  4.         if (dim2 > dim1) return false;
  5.  
  6.         // Se stiamo comparando le due sequenze
  7.         bool bComparing = false;
  8.  
  9.         int h = 0;
  10.  
  11.         // Scorriamo tutti gli elementi della sequenza principare
  12.         for(int n = 0; n < dim1; n++) {
  13.                
  14.                 // Se le stiamo comparando
  15.                 if (bComparing) {
  16.                        
  17.                         // Andiamo avanti nella seconda sequenza
  18.                         h++;
  19.  
  20.                         // Se gli elementi sono diversi la sequenza è diversa
  21.                         if (A[n] != B[h]) return false;
  22.  
  23.                         // Se siamo arrivati in fondo alla seconda sequenza
  24.                         // e non abbiamo trovato nessun elemento diverso
  25.                         // vuol dire che sono uguali
  26.                         if (h == dim2 - 1) return true;
  27.                
  28.                 } else
  29.                         // Iniziamo il confronto al primo elemento uguale
  30.                         bComparing = (A[n] == B[0]);           
  31.  
  32.  
  33.         }
  34.  
  35.         // Se arriviamo qui vuol dire che il ciclo è finito senza attivare
  36.         // il flag bComparing o entrambe le liste hanno un solo elemento
  37.         // ne deduciamo che le stringhe non hanno nemmeno un elemento in comune
  38.         // oppure è stato comparato un solo elemnto
  39.         return bComparing;
  40.  
  41. }



sistemato, dovevo solo sostituire return false alla fine con return bComparing.

per il resto funziona :)

Ultima modifica effettuata da HeDo il 27/11/2009 alle 21:48


Ingegnere Informatico
https://ldlagency.it
PM Quote
Avatar
Lawliet (Normal User)
Expert


Messaggi: 386
Iscritto: 09/04/2009

Segnala al moderatore
Postato alle 20:12
Venerdì, 27/11/2009
Ti sbagli, non funziona invece ^^'
Tu fai lo sbaglio comunque a non verificare se la sottosequenza ha 1 elemento.

Codice sorgente - presumibilmente C/C++

  1. // Andiamo avanti nella seconda sequenza
  2. h++;
  3.  
  4. // Se gli elementi sono diversi la sequenza è diversa
  5. if (A[n] != B[h]) return false;



confronti e verifichi l'h-esimo elemento della sottosequenza (!?!? se ha un solo elemento), e così ti dà falso in qualunque modo.
Al momento mi verrebbe di fare così al primo pensiero cioè:
Codice sorgente - presumibilmente C/C++

  1. if (A[n] != B[h] && h < dim2) return false;


Ultima modifica effettuata da Lawliet il 27/11/2009 alle 20:29


"Dai un pesce (programma) a un uomo e lo nutrirai per un giorno. Insegnagli a pescare (programmare) e lo nutrirai per tutta la vita." (niente pappa pronta)
cit. theprogrammer
PM Quote
Avatar
HeDo (Founder Member)
Guru^2


Messaggi: 2763
Iscritto: 21/09/2007

Segnala al moderatore
Postato alle 21:49
Venerdì, 27/11/2009
Testo quotato

Postato originariamente da Lawliet:

Ti sbagli, non funziona invece ^^'
Tu fai lo sbaglio comunque a non verificare se la sottosequenza ha 1 elemento.

Codice sorgente - presumibilmente C/C++

  1. // Andiamo avanti nella seconda sequenza
  2. h++;
  3.  
  4. // Se gli elementi sono diversi la sequenza è diversa
  5. if (A[n] != B[h]) return false;



confronti e verifichi l'h-esimo elemento della sottosequenza (!?!? se ha un solo elemento), e così ti dà falso in qualunque modo.
Al momento mi verrebbe di fare così al primo pensiero cioè:
Codice sorgente - presumibilmente C/C++

  1. if (A[n] != B[h] && h < dim2) return false;




a me sembra che stai sparando vaccate ora, al posto di dire che non funziona scrivi un input che da output sbagliato.


Ingegnere Informatico
https://ldlagency.it
PM Quote
Avatar
Lawliet (Normal User)
Expert


Messaggi: 386
Iscritto: 09/04/2009

Segnala al moderatore
Postato alle 22:26
Venerdì, 27/11/2009
Perchè dovrei sparare vaccate? Ti ho detto che secondo il tuo codice non funziona se la sottosequenza ha un solo elemento, e con l'aggiunta di quella condizione come ho scritto dovrebbe funzionare anche nel caso che non ti funziona.
Mi sbaglio!?

Ultima modifica effettuata da Lawliet il 27/11/2009 alle 22:27


"Dai un pesce (programma) a un uomo e lo nutrirai per un giorno. Insegnagli a pescare (programmare) e lo nutrirai per tutta la vita." (niente pappa pronta)
cit. theprogrammer
PM Quote
Avatar
HeDo (Founder Member)
Guru^2


Messaggi: 2763
Iscritto: 21/09/2007

Segnala al moderatore
Postato alle 22:53
Venerdì, 27/11/2009
Testo quotato

Postato originariamente da Lawliet:

Perchè dovrei sparare vaccate? Ti ho detto che secondo il tuo codice non funziona se la sottosequenza ha un solo elemento, e con l'aggiunta di quella condizione come ho scritto dovrebbe funzionare anche nel caso che non ti funziona.
Mi sbaglio!?



il mio codice funziona, la tua riga è inutile e se sostieni il contrario portami ad esempio un input che porta un output sbagliato, punto.


Ingegnere Informatico
https://ldlagency.it
PM Quote
Pagine: [ 1 2 ] Precedente | Prossimo