Ciao a tutti.
Non riesco a trovare l'errore nell'esercizio che ho svolto. Qui sotto vi metto la consegna ed il mio programma:
"Viene dato un main che esegue come letture n_ele, nP ed hf. n_ele sono gli elementi di X, che dovremo vedere
come un array a 3 dimensioni, [lim1][lim2][lim3], nP sono gli elementi di P e hf è l’indice di una H-fetta dell’array
a 3 dimensioni. Le operazioni da fare riguarderanno solo la H-fetta hf. Si tratta di eliminare i valori di P dalla H-fetta hf
ricompattando la H-fetta verso la sinistra.
Esempio 1:
Se la H-fetta consiste dei seguenti valori, [1,10,2,4,20,1] e P=[1,20,4], allora si tratta di eliminare il primo ed
il penultimo elemento della H-fetta che diventa quindi [10,2,4,1]. Si osservi che l’ultimo elemento di P non
viene eliminato perché il 20, che matcha il secondo elemento di P, nella H-fetta segue il 4. In altre parole i
valori della H-fetta che sono eliminati devono rispettare l’ordine che quei valori hanno in P. Quindi se P
fosse [1,4,20], allora sarebbe possibile eliminare tutti i 3 valori di P dalla H-fetta che diventerebbe: [10,2,1].
Quindi al massimo si possono eliminare nP valori dalla H-fetta. Inoltre, nel fare questa operazione si può
consumare tutto P, oppure solo un prefisso di P (anche vuoto). Quindi la H-fetta può restare invariata, può
perdere elementi e può anche diventare vuota, quando la H-fetta coincide con P.
A seconda dei casi il programma deve stampare un corrispondente messaggio:
“pattern consumato tutto” oppure “pattern rimasto” seguito dai valori del pattern che non sono stati usati.
Per l’output della H-fetta rimasta si dovrà stampare: “la H-fetta hf è diventata:” seguita accapo dalla
sequenza dei valori della H-fetta. Per eseguire questa stampa conviene definire una funzione ad-hoc che
stampi i valori di una H-fetta.
Visto che gli elementi di una H-fetta non sono tutti consecutivi in X, abbiamo bisogno di una funzione int
F(int i, int lim2, int lim3) che soddisfi la seguente POST-condizione:
POST=(restituisce la distanza in X tra il primo elemento di una qualsiasi H-fetta e l’elemento i della fetta)
Esempio 2:
Usiamo lim2=3 e lim3=3, come nell’Esempio 1. Per una qualsiasi H-fetta, le distanze dei suoi elementi
0,1,2,3,4, ecc, dall’inizio della H-fetta sono calcolati dalla funzione F nel modo seguente: F(0,3,3) =0,
F(1,3,3)= 1, F(2,3,3)2, F(3,3,3)=9, F(4,3,3)=10, F(5,3,3)=11, F(6,3,3) = 18, F(7,3,3)= 19, eccetera. "
#include<iostream>
using namespace std;
int F(int i, int lim2, int lim3)
{
return ((i/lim3)*lim3*lim2 + (i%lim3));
}
void pattern(int*P,int nP,int Lp)
{
if(Lp==0)
{
cout<<"pattern rimasto"<<endl;
}
else if(Lp>=nP)
{
cout<<"pattern consumato tutto"<<endl;
}
else if(0<Lp<nP)
{
cout<<"pattern rimasto ";
for(int i=Lp;i<nP;i++)
{
cout<<P[i]<<" ";
}
cout<<endl;
}
}
void stampa_fetta(int *iniziohf,int giusto,int lim2,int lim3,int lung, int Lp)
{
if(lung<Lp)
{
cout<<" "<<endl;
}
else
{
for(int i=0;i<giusto;i++)
{
cout<<iniziohf[F(i,lim2,lim3)]<<" ";
}
cout<<endl;
}
}
int main()
{
int X[400], P[20], n_ele, nP, lim1, lim2,lim3;// 400 max num elementi X, 20 max num elementi P
cin >> n_ele;
for(int i=0; i<n_ele; i++)
{cin >> X[i];}
cin >> lim1 >> lim2 >> lim3;
if(lim1*lim2*lim3 < n_ele)
{n_ele=lim1*lim2*lim3;}
cin >> nP;
for(int i=0; i<nP; i++)
{cin >> P[i];}
int nsp= n_ele/(lim2*lim3); //numero strati pieni
int eus= n_ele%(lim2*lim3); //elementi ultimo strato
int rpus= eus/lim3; //righe piene ultimo strato
int ur= eus%lim3; //elementi rimanenti ultimo strato
cout<<"start"<<endl;
int hf;
cin >> hf; // fetta da trattare
int lung; // lunghezza della H-fetta hf
lung=lim3*lim2;
if(hf<rpus)
{
lung=lung + lim3;
}
if(hf==rpus)
{
lung=lung+ur;
}
int*iniziohf=X+hf*lim3; //puntatore primo elemento H-fetta hf
int giusto=0; //primo valore con match
int Lp=0; //valori matchati tra X e P
for(int j=0; j < lung; j++)
{
if(iniziohf[ F(j,lim2,lim3)]!=P[Lp] || Lp==nP&&j>Lp)
{
iniziohf[F(giusto,lim2,lim3)]=iniziohf[F(j,lim2,lim3)];
giusto++;
}
else
{
Lp++;
}
}
pattern(P,nP,Lp);
cout<<"La H-fetta "<<hf<<" e' diventata:"<<endl;
stampa_fetta(iniziohf,giusto,lim2,lim3,lung,Lp);
cout<<"end"<<endl;
}
-----------------------------------------------------------------
Input 1:
22
1 2 3
11 20 20
11 8 12
10 11 12
20 12 15
16 20 18
19 20 21
22
5 3 3
4
20 20 15 22
1
Program output :
start
pattern consumato tutto
La H-fetta 1 e' diventata:
11 20 12 227633584 32765 1711582935
end
Expected output :
start
pattern consumato tutto
La H-fetta 1 e' diventata:
11 20 12
end
-----------------------------------------------
Input 2:
22
1 2 3
11 20 20
11 8 12
10 11 12
20 12 15
16 20 18
19 20 21
22
5 3 3
3
11 12 20
1
Program output:
start
pattern rimasto 20
La H-fetta 1 e' diventata:
20 20 20 15 22 1880018960 32766 -3031337
end
Expected output :
start
pattern rimasto 20
La H-fetta 1 e' diventata:
20 20 20 15 22
end
-----------------------------------------------
input 3
22
1 2 3
11 20 20
11 8 12
10 11 12
20 12 15
16 20 18
19 20 21
22
5 3 3
6
11 8 12 16 20 18
2
Program output :
start
pattern consumato tutto
La H-fetta 2 e' diventata:
1150143024 32765 -391884112
end
Expected output :
start
pattern consumato tutto
La H-fetta 2 e' diventata:
end