C/C++ - sottosequenze contenute

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....

#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;   
        }
    

    }}

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:

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:

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;
} 

ma questo codice:

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

non dovrebbe essere :

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

con la h al posto dello 0....

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!



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

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

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

// 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è:

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.

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!?