ho un esercizio:
dato un array v[] con dimensione N, si verifichi se l'array è ripiegabile su se stesso con passo pari a 3.
Per ripiegatura si intende: i primi tre numeri devono essere uguali ai secondi 3 numeri capovolti(cioè leggendoli in modo inverso..in modo palindromo diciamo: ad esempio 123 è uguale a 321).
ad esempio avendo l'array: 1,2,3,3,2,1,2,4,6,12,8,4 di dimensione 12
la ripiegatura è possibile perchè 123 è uguale a 321. Dalla loro sovrapposizione si creerà una nuova terna sommando 1+1,2+2 e 3+3 e si forma la nuova terna cioè 6,4,2
quindi ora la ripiegatura va fatta con la nuova terna e l'array diventa:
6,4,2,2,4,6,12,8,4.. stesso discorso di prima....
quando si arriva ad avere solo 3 numeri non è possibile piu ripiegatura e quindi la funzione termina stampando questi ultimi 3 numeri.

A me non funzione, ma non capisco il perchè:
codice:
#include <iostream>
using namespace std;

bool ricorsiva(int v[], int dim, int i, int k, int sommaA, int sommaB, int sommaC);

int main(){
 const int dim=12; 
 int i=0,k=0, sommaA=0, sommaB=0, sommaC=0;
 int v[dim]={1,2,3,3,2,1,2,4,6,12,8,4};
 
 if(ricorsiva(v,dim,i,k,sommaA,sommaB,sommaC))
    for(int i=0; i<dim; i++)
            cout<<v[i]<<endl;
 else
     cout<<"non sovrapponibile"<<endl;
     
 system("pause");       
return 0;
}

bool ricorsiva(int v[], int dim, int i, int k, int sommaA, int sommaB, int sommaC){
     
     if(i%3!=0)
     return false;
     
     if(i==dim-3)
     return true;
     
     sommaA=v[i], sommaB=v[i+1], sommaC=v[i+2];
     
     if(sommaA != v[k] || sommaB != v[k-1] || sommaC != v[k-2])
     
     ricorsiva(v,dim,i+3,k+3,v[i],v[i+1],v[i+2]);
}