[C++] Ricorsione palindroma in array

[suricata]

Salve ho davanti il seguente problema:

Si scriva in C++ una funzione ricorsiva che riceva due array di interi A e B e le loro dimensioni dimA e dimB
(sapendo che dimB = 2*dimA – 1) e riempia B con gli elementi di A di modo da ottenere un array palindromo secondo il
seguente schema: il primo elemento di A dovrà essere l’elemento centrale di B, i successivi riempiranno B dal centro verso i
lati simmetricamente.
ESEMPIO: sia A l’array
1 2 3
allora l’array B dovrà essere riempito come segue
3 2 1 2 3


IL PROBLEMA è che non so come riempire l'array b in tutte due le direzioni (avanti ed indietro), avevo pensato ad utilizare due indici per l'array b che partivano dal centro e uno andava avanti e l'altro indietro mentre si scorreva l'array a, ma non so come farlo , se qualcuno mi potesse dare una mano lo ringrazerei

# include <iostream>
using namespace std;
void ricorsione (int [],int [], int , int ,int );
void stampa (int b[]);
const int n=3;
const int k=5;

int main ()
{
	int a[n]={1,2,3};
	int b[k]={0};
	
	ricorsione (a,b,0,2,2);
	stampa (b);
	
	
return 0;	
}

void ricorsione (int a[],int b[], int i, int l, int j)
{
	if (  (i != n )  
	{
		b[j]=a[i];
		b[l]=a[i];
	}
	return  ricorsione (a,b,i+1,l+1,j-1);
}

void stampa (int b[])
{
	for (int i=0;i<n;i++)
	{
		cout<<b[i]<<' ';
		cout<<endl;
	}
}

[Celebron]

Una soluzione banale potrebbe essere
parti da i=dimA-1; j=0; e k=dimB-1;

inserisci il valore di A[i] in B[j] e B[k]
decrementi i e k, incrementi j
sino a che i!=0

i= dimA -1; 
j= 0;
k= dimB -1;

while(i!=0){

	B[j] = B[k] = A[i];
	j++; k--; i--; 
}

[suricata]

Guarda ho fatto come dici, l'idea è sicuramente quella , ma comunque non stampa l'1 centrale.
io l'ho implementato come hai detto cosi:

# include <iostream>
using namespace std;
void ricorsione (int [],int [], int , int ,int);
void stampa (int b[]);
const int n=3;
const int k=5;

int main ()
{
	int a[n]={1,2,3};
	int b[k]={0};
	
	ricorsione (a,b,n-1,0,n-1);
	stampa (b);
	
	
return 0;	
}

void ricorsione (int a[],int b[], int i, int j,int k)
{
	while(i!=0)
	{
		b[j] = b[k] = a[i];
		j++; k--; i--; 
	}

}
	
void stampa (int b[])
{
	for (int i=0;i<n;i++)
	{
		cout<<b[i]<<' ';
		cout<<endl;
	}
}

stampa : 3 2 3

[suricata]

scusami era un errore di stampa soltanto
funziona perffettamente,,,
grazie!!!

[Celebron]

prego


EDIT: ops, non avevo notato la volessi ricorsiva D: quella che ti ho dato io è puramente iterativa

ad ogni modo, lavorando con gli indici in un modo parecchio simile ti verrà semplice costruire anche la sua variante ricorsiva

[premoli]

Ciao a tutti!!!

Ora, non vorrei essere il guasta feste della situazione, ma la funzione "ricorsione" tutto mi sembra tranne che ricorsiva...

[suricata]

andando a fare la stampa , infatti non funziona mi stampa una cosa del tipo :
1 3 2 3 1

sto cercando di correggerla ma senza successo

[suricata]

io la funzione l'ho fatta cosi:

void ricorsione (int a[],int b[], int i,int j,int k)
{
	while (i >=0)	
	{
		b[j]=b[k]=a[i];
		return ricorsione (a,b,i-1,j+1,k-1);
	}
}

[premoli]

mhh...

vediamo, ti dò un piccolo suggerimento, se ad esempio abbiamo la necessità di stampare la stringa "ciao" prima da sinistra verso destra e poi da destra verso sinistra attraverso la ricorsione diventa abbastanza facile, basta fare una cosa del genere

void ric(char *s, int i, int j)
{
    if(i>=j)
        return;
    else{
        printf("%c", s[i]);
        ric(s, i+1, j);
        printf("%c", s[i]);
    }

}

dove i è l'indice iniziale e j è la lunghezza della parola, in questo caso 4, con questa semplice funzione otteniamo ciaooaic, se hai presente come funziona la ricorsione il perché dovrebbe esserti abbastanza chiaro, in pratica noi stampiamo s[0] e chiamiamo la funzione ric, attenzione perché intanto la chiamata numero 1 non è ancora terminata, e via dicendo fino a quando la condizione nell'if non è verificata.

Facciamo il punto della situazione

chiamata 1: i=0; s[i]='c'
             2: i=1; s[i]='i'
             3: i=2; s[i]='a'
             4: i=3; s[i]='o'

arrivati a questo punto la condizione dell'if al passo seguente è verificata, quindi non vengono più effettuate chiamate alla funzione e vengono riprese le funzioni precedentemente chiamate, partendo dall'ultima, quindi si avrà la stampa al contrario "oaic".

Ora prova ad applicare più o meno lo stesso ragionamento sul tuo esercizio, se non ti è chiaro qualcosa chiedi pure.

[suricata]

mi dispiace ma ci ho provato e niente , non ho tocato ancora i puntatori e non so bene come funzionano, so che puntano all'indirizzo di memoria e poco altro, adesso vado a studiare i puntatori perche mi sono reso conto che sono molto importanti, vediamo se poi riesco a farlo come dici tu
grazie