Es a tempo 2 Filè

#include<iostream>
using namespace std;

//PRE: gli array i parametri p, w, n, p2, nP sono definiti

bool trova(int * p,int w, int n, int * p2,int nP){

    if((w + nP) < n){
        for(int i = 0; i < nP; i++){//(0<= i <= 4) && (ritorna false se non c'è match)
            if(*(p + i) != *(p2 + i)){
                return false;
            }
        }
        return true;
    }
    return false;

}

//POST: ritorna vero sse trova un match

/*

    La funzione consiste in un if, con all'interno un for che a sua volta all'interno ha un if.
    Il primo if funziona come guardia, infatti non devo controllare gli elementi gli ultimi elementi se non sono in numero abbastanza alto,
    infatti se per esempio ci fossero 23 elementi non potrei esaminare gli nP elementi successivi al 22° in quanto non sarebbero stati valorizzati
    (anche se potrebbero essere a tutti gli effetti elementi dell'array). Questo controllo è stato fatto sfruttando il passaggio di parametri
    della funzione e passando per valore sia il numero di elementi totali , sia il numero di elementi da esaminare sia l'indice dell'elemento
    corrente, parametri tutti passati per valore. Nel caso in cui ci si trovasse in questa situazione la funzione restituirebbe come valore
    false in quanto non ci può essere un match. Nel caso in cui si entrasse nel ramo then dell'else invece si entrerebbe in
    un ciclo for con una variabile contatore inizializzata a 0 e inferiore a nP (perchè valore guardia del ciclo;
    nP è il numero di valori inseriti nell'array P e viene passato per valore come parametro alla funzione) che confronta il primo elemento
    dell'array X con il primo elemento dell'array P (a cui si può accedere grazie ai puntatoti passati per valore come parametri).
    Nel caso in cui i 2 numeri non fossero uguali la funzione restituirebbe false in quanto non ci sarebbe stato un match,
    mentre se i valori confrontati sono tutti uguali si esce dal ciclo for e la funzione restituisce true.

*/


int main()//PRE: I valori che verranno dati in input in X, n_ele, nP, P, lim1, lim2, lim3 sono definiti  e lim1*lim2*lim3 <= 400
{
  int X[400], n_ele, nP, P[20];
  cin>> n_ele;
  for(int i=0; i<n_ele; i++){
    cin >> X[i];
  }
  int lim1,lim2,lim3;
  cin>> lim1>>lim2>>lim3;
  cin >> nP;
  for(int i=0; i<nP; i++){
    cin>>P[i];
  }
  cout<<"start"<<endl;

  int strato = 0;
  int strati = n_ele / lim1;
  int el1 = n_ele % lim1;
  int righe = el1 / lim2;
  int el2 = el1 % lim2;

  int * p = X;
  int i;
  bool match = false;
  int w = 0;

  for(i = 0; i < lim1; i++){//(0<= i <= lim1) && (esaminati i strati completi) && (match == true sse è stato trovato un match di P)
      for(int j = 0; j < lim2; j++){//(0<= j <= lim2) && (esaminate j righe complete) && (match == true sse è stato trovato un match di P)
          for(int k = 0; k < lim3; k++){//(0<= k <= lim3) && (esaminati k elementi della riga di indice j) && (match == true sse è stato trovato un match di P)
              int * p2 = P;
              if(!match){
                  match = trova(p + w, w, n_ele, p2, nP);
                  strato = i;
                  w++;
              }

          }
      }
  }

  /*

        Il 3 cicli hanno le variabili contatore (i, j, k) che vengono sempre inizializzate a 0 e mai decrementate, pertanto saranno sempre maggiori
        o al massimo uguali a zero. Inoltre non saranno mai maggiori dei valori di guardia dei rispettivi cicli (lim1, lim2, lim3).
        Una volta entrato nel primo ciclo il programma entra subito nel secondo e analogamente entra nel terzo subito dopo essere entrato nel
        secondo che dichiara una variabile puntatore e la inizializza con l'indirizzo del primo elemento dell'array P.
        A questo punto con un controllo su una variabile booleana decido se chiamare la funzione. La variabile booleana match funziona da guardia,
        visto che devo stampare solo il primo match se ne ho già trovato uno non richiamo la funzione. La funzione trova restituisce un valore
        booleano, cioè true se trova un match o false se non lo trova. Salvo poi lo l'indice dello strato che sto esaminando, visto che l'ultima
        che il programma entra nel ramo then dell'if la variabile match avrà valore true e sarà quando la funzione troverà la prima occorrenza del
        target e quindi lo strato salvato sarà anche quello che presenta il primo match. Infine aumento il contatore dell'elemento corrente in modo
        da poterlo passare come parametro della funzione in caso non sia stato trovato un match.
        Per come sono strutturati i cicli for il contatore i aumenterà solo quando sarà stato esaminato l'intero "strato" corrente, il contatore j
        solo quando sarà esaminata l'intera "riga" corrente e k solo quando sarà stato esaminato l'elemento corrente.

  */

 if(match){
     cout<<"lo strato "<<strato<<" di T contiene un match"<<endl;
 }else{
     cout<<"Nessun match trovato"<<endl;
 }



  cout<<"end"<<endl;

    return 0;
}