()
Newbie
Messaggi:
Iscritto:
|
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++ |
#include <iostream> using namespace std; const int Max = 1000; int leggi(int [], int &); bool contenuta(int [], int [], int, int); int main (){ int A[Max], B[Max], C[Max], dim = 0, dimb = 0, dimc = 0; cout << "\t\t\t***calcoli in sottesequenza***\n\n"; cout << "inserisci una sequenza di numeri(1000 per terminare): \n"; leggi(A, dim); cout << "inserisci un'altra sottosequenza(1000 per terminare):\n"; leggi(B, dimb); cout << "inserisci ancora un'altra sottosequenza(1000 per terminare): \n"; leggi(C, dimc); cout << "ORA IL COMPUTER CONTROLLA SE LE DUE SOTTOSEQUENZE\nSONO CONTENUTE NELLA SEQUENZA PRINCIPALE:\n\n\n"; if (contenuta(A, B, dim, dimb)) cout << "la sottosequenza 1 e' contenuta nella sequenza di partenza!\n"; else cout << "la sottosequenza 1 non e' contenuta nella sequenza di partenza!\n"; if (contenuta(A, C, dim, dimc)) cout << "la sottosequenza 2 e' contenuta nella sequenza di partenza!\n"; else cout << "la sottosequenza 2 non e' contenuta nella sequenza di partenza!\n"; system("pause"); return 0; } int leggi(int A[], int & dim){ for (int i = 0; i < Max; i++){ cin >> A[i]; if (A[i] == 1000 || dim > Max) return 0; dim++; } } bool contenuta(int A[], int B[], int dim, int dimS){ for (int i = 0; i < dim; i++){ if(A[i] == B[0]){ int conti = i, contz = 0; while(contz < dimS){ if (A[conti] == B[contz]){ conti++; contz++; } else if (A[conti] != B[contz]) return false; } return true; } }}
|
|
|
HeDo (Founder Member)
Guru^2
Messaggi: 2765
Iscritto: 21/09/2007
|
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++ |
bool contenuta(int A[], int B[], int dim1, int dim2) { // La più lunga non può essere contenuta nella più corta! if (dim2 > dim1) return false; // Se stiamo comparando le due sequenze bool bComparing = false; int h = 0; // Scorriamo tutti gli elementi della sequenza principare for(int n = 0; n < dim1; n++) { // Se le stiamo comparando if (bComparing) { // Andiamo avanti nella seconda sequenza h++; // Se gli elementi sono diversi la sequenza è diversa if (A[n] != B[h]) return false; // Se siamo arrivati in fondo alla seconda sequenza // e non abbiamo trovato nessun elemento diverso // vuol dire che sono uguali if (h == dim2 - 1) return true; } else // Iniziamo il confronto al primo elemento uguale bComparing = (A[n] == B[0]); } // Se arriviamo qui vuol dire che il ciclo è finito senza attivare // il flag bComparing, ne deduciamo che le stringhe non hanno // nemmeno un elemento in comune => diverse return false; }
|
da notare anche il fatto che nella funzione leggi il numero 1000 non va messo nell'array, quindi:
Codice sorgente - presumibilmente C++ |
int leggi(int A[], int & dim){ int temp = 0; for (int i = 0; i < Max; i++){ cin >> temp; if (temp == 1000 || dim > Max) return 0; A[i] = temp; dim++; } return 0; }
|
|
|
()
Newbie
Messaggi:
Iscritto:
|
ma questo codice:
Codice sorgente - presumibilmente Plain Text |
bComparing = (A[n] == B[0]);
|
non dovrebbe essere :
Codice sorgente - presumibilmente Plain Text |
bComparing = (A[n] == B[h]);
|
con la h al posto dello 0.... |
|
Lawliet (Normal User)
Expert
Messaggi: 386
Iscritto: 09/04/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!
Postato originariamente da Riuzaki:
ma questo codice:
Codice sorgente - presumibilmente Plain Text |
bComparing = (A[n] == B[0]);
|
non dovrebbe essere :
Codice sorgente - presumibilmente Plain Text |
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 |
|
HeDo (Founder Member)
Guru^2
Messaggi: 2765
Iscritto: 21/09/2007
|
Codice sorgente - presumibilmente C++ |
bool contenuta(int A[], int B[], int dim1, int dim2) { // La più lunga non può essere contenuta nella più corta! if (dim2 > dim1) return false; // Se stiamo comparando le due sequenze bool bComparing = false; int h = 0; // Scorriamo tutti gli elementi della sequenza principare for(int n = 0; n < dim1; n++) { // Se le stiamo comparando if (bComparing) { // Andiamo avanti nella seconda sequenza h++; // Se gli elementi sono diversi la sequenza è diversa if (A[n] != B[h]) return false; // Se siamo arrivati in fondo alla seconda sequenza // e non abbiamo trovato nessun elemento diverso // vuol dire che sono uguali if (h == dim2 - 1) return true; } else // Iniziamo il confronto al primo elemento uguale bComparing = (A[n] == B[0]); } // Se arriviamo qui vuol dire che il ciclo è finito senza attivare // il flag bComparing o entrambe le liste hanno un solo elemento // ne deduciamo che le stringhe non hanno nemmeno un elemento in comune // oppure è stato comparato un solo elemnto return bComparing; }
|
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 |
|
Lawliet (Normal User)
Expert
Messaggi: 386
Iscritto: 09/04/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++ |
// Andiamo avanti nella seconda sequenza
h++;
// Se gli elementi sono diversi la sequenza è diversa
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++ |
if (A[n] != B[h] && h < dim2) return false;
|
Ultima modifica effettuata da Lawliet il 27/11/2009 alle 20:29 |
|
HeDo (Founder Member)
Guru^2
Messaggi: 2765
Iscritto: 21/09/2007
|
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++ |
// Andiamo avanti nella seconda sequenza
h++;
// Se gli elementi sono diversi la sequenza è diversa
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++ |
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. |
|
Lawliet (Normal User)
Expert
Messaggi: 386
Iscritto: 09/04/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 |
|
HeDo (Founder Member)
Guru^2
Messaggi: 2765
Iscritto: 21/09/2007
|
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. |
|