subStringa

#include <iostream>
#include <ctime>
#include <cstdlib>
#include <string>

using namespace std;

//Questi sono prototipi di funzioni che ho creato per evitare di impasticciare un po' il tutto. Se non sapete cosa sono saltateli! Poi il proffolo li spiegherà.
string alloca_Array( int n, char consonanti[], char vocali[], string parole[], const int MAX_STRING, int j );
void trova_subStringa( string subStringa,  string parole[], const int MAX_STRING, bool niente);

int main()
{
    /*
     * Avendo un array dire se una stringa x letta in input è presente come sottostringa nell'array,
     * che è formato da stringhe generato dall'algoritmo vocale_Consonante
     *
     * Creato da Trupia Ludovico
     */

    srand(time(NULL));
    const int MAX_STRING = 10;
    //Servono nella funzione alloca_Array()
    int n = 0;
    char consonanti[16] = {'b','c','d','f','g','h','l','m','n','p','q','r','s','t','v','z'};
    char vocali[5] = {'a','e','i','o','u'};
    string parole[MAX_STRING];
    int j = 0;
    string subStringa;
    bool niente = true;

    while( j < MAX_STRING ) //j varia da 0 a MAX_STRING - 1 in questo caso da 0 a 9
    {
        parole[j] = alloca_Array( n, consonanti, vocali, parole, MAX_STRING, j ); //Viene richiamata la funzione alloca_Array e le passiamo le variabili n, gli array consonanti, vocali e parole, la costante MAX_STRING e la j !!!Guardare in basso alla funzione alloca_Array()!!!
        j++; //Incremento della j e passaggio all'inserimento della successiva parola
    }
    cout << endl << endl;

    cout << " Inserisci una parola // ";
    cin >> subStringa;

    trova_subStringa( subStringa, parole, MAX_STRING, niente); //Viene richiamata la funzione trova_subStringa con passaggio dei parametri subStringa, l'array parole, la costante MAX_STRING e la bool niente che serve a verificare, alla fine se la sottostringa è contenuta in qualche parola !!!Guardare in basso alla funzione trova_subStringa()!!!

    return 0;

} //FINE DEL MAIN!

//** INIZIO FUNZIONI **//

string alloca_Array( int n, char consonanti[], char vocali[], string parole[], const int MAX_STRING, int j )
{
    //Il funzionamento della funzione è banale (XD)
    cout << endl;

    if( j < MAX_STRING ) //fino a che la variabile j non raggiunge la dimensione dell'array di stringhe l'if viene eseguito
    {
        n = ((rand() % 4) + 2) * 2; //Creo un numero casuale tra 4 - 6 - 8 - 10 che determinerà la lunghezza della parola

        for( int i = 0; i < n; i++)
        {
            if( i % 2 == 0 ) //Scelgo tra consonante e vocale
            {
               parole[j] += consonanti[rand()%16]; //Inserisco la consonante
            }
            else
            {
                parole[j] += vocali[rand()%5]; //Inserisco la vocale
            }
        }

        cout << " | " << parole[j]; //Stampo a video la parola

        if( n == 4 ) cout << "\t\t|"; else cout << "\t|";   //La funzionalità di \t è la tabulazione dell'output in modo da averlo bello ordinato

        cout << endl << " | \t\t|";
    }

    return parole[j]; //ritorno al main la parola-jesima e la inserisco nell'array parole vero e proprio
}

void trova_subStringa( string subStringa,  string parole[], const int MAX_STRING, bool niente)
{
    //Il concetto di questa funzione è trovare la sottostringa

    int k = 0; //Imposto una variabile k = 0 che mi servirà per prendere ad una ad una le lettere della stringa inserita da noi

    for( int i = 0; i < MAX_STRING; i++ ) //ciclo for da 0 a MAX_STRING - 1
    {
        for( int j = 0; j < parole[i].length(); j++) //ciclo for da 0 a lunghezza della parola-iesima - 1
        {
            if( subStringa.at(k) == parole[i][j] ) //Se il carattere-kappesimo (non si può sentire D:) è uguale al carattere-jesimo della parola-iesima allora...
            {
                k++; //Incremento k in modo da passare al carattere successivo della nostra sottostringa
                if( k < subStringa.length() && j < parole[i].length() && subStringa.at(k) != parole[i][j+1] ) //Se la k è mino della lunghezza della sottostringa e j è minore della lunghezza della parola e il carattere della sottostringa (ora k+1) è diverso dal successivo carattere della parola-iesima allora...
                {
                    k = 0; //Imposto k = 0 perchè la sottostringa non è contenuta al momento in quella parola
                    /*
                     * Es.
                     *    banana (parola-iesima)            "b" è il carattere j-esimo(in questo caso j=0) della parola-iesima
                     *    na     (sottostringa)             "n" è il carattere k-esimo(in questo caso k=0) della sottostringa
                     */
                }

                if( k == subStringa.length() ) //Se j raggiunge la fine della sottostringa vorrà dire che la sottostringa è contenuta in quella parola! :D
                {
                    cout << endl << endl << "La parola // " << parole[i] << " // contiene la sottostringa // " << subStringa << " //" <<endl;
                    k = 0; //K=0 perchè si passa alla prossima parola;
                    niente = false; //falso perchè abbiamo trovato almeno una sottostringa valida!
                }
            }
        }
    }

    if( niente ) //Se niente == vero allora nessuna parola contiene la nostra sottostringa;
    {
        cout << endl << endl << "Nessuna parola contiene la sottostringa // " << subStringa << " //" << endl;
    }
    cout << endl;
}

//** FINE FUNZIONI **//