Leggere array in avanti

[del_ta]

Ciao ragazzi! Sto cercando di risolvere un esercizio che mi chiede di stampare il contenuto degli indici dispari(in ordine crescente)di un array con una funzione del tipo: void dispari(int x[],int n) con x il vettore ed n la dimensione. Il problema è che non riesco a leggere il vettore in avanti. Come posso fare?
Grazie.

[vict85]

È sufficiente usare un ciclo. Sai cosa sono i cicli?

[del_ta]

"vict85":È sufficiente usare un ciclo. Sai cosa sono i cicli?

Sisi certo. Scusa ma mi sono sbagliato io.La funzione deve essere ricorsiva,per questo non riesco a usare un ciclo.

[apatriarca]

Un primo metodo consiste nell'usare una funzione ricorsiva di appoggio void dispari2(int x[], int i, int n) che richiama se stessa con un valore crescente di i fino a raggiungere n. In questo caso il corpo della tua funzione sarà semplicemente dispari2(x, 1, n)..

Un secondo metodo consiste nell'osservare che esistono due momenti in una chiamata ricorsiva: quello precedente alla chiamata ricorsiva e quello successivo. Il codice prima della chiamata ricorsiva viene eseguito in ordine dalla chiamata "meno profonda" a quella "più profonda", mentre il codice dopo la chiamata ricorsiva viene eseguito in ordine inverso. La soluzione in questo caso è quindi quella di stampare dopo la chiamata ricorsiva. Qualcosa come segue (pseudocodice simil python):

def dispari(x, n):
    if n > 0:
        dispari(x, n-1)              # Chiamata ricorsiva..
        if isOdd(n):                 # Stampa se l'indice è dispari
            print x[n]

[del_ta]

"apatriarca":Un primo metodo consiste nell'usare una funzione ricorsiva di appoggio void dispari2(int x[], int i, int n) che richiama se stessa con un valore crescente di i fino a raggiungere n. In questo caso il corpo della tua funzione sarà semplicemente dispari2(x, 1, n)..

Un secondo metodo consiste nell'osservare che esistono due momenti in una chiamata ricorsiva: quello precedente alla chiamata ricorsiva e quello successivo. Il codice prima della chiamata ricorsiva viene eseguito in ordine dalla chiamata "meno profonda" a quella "più profonda", mentre il codice dopo la chiamata ricorsiva viene eseguito in ordine inverso. La soluzione in questo caso è quindi quella di stampare dopo la chiamata ricorsiva. Qualcosa come segue (pseudocodice simil python):

def dispari(x, n):
    if n > 0:
        dispari(x, n-1)              # Chiamata ricorsiva..
        if isOdd(n):                 # Stampa se l'indice è dispari
            print x[n]

Perfetto, con il caso della stampa ho capito. Ma se invece volessi moltiplicare gli indici dispari usando il secondo metodo?
Grazie mille per l'aiuto!

[apatriarca]

Moltiplichi il valore restituito dalla funzione per 1 se è un indice pari o l'elemento se è dispari.

[del_ta]

"apatriarca":Moltiplichi il valore restituito dalla funzione per 1 se è un indice pari o l'elemento se è dispari.

Ho pensato qualcosa del genere:

int molt_dispari(int x[],int n){
     if(n>0){
         if(n%2!=0) return molt_dispari(x,n-1)*x[n];
          else return molt_dispari(x,n-1);
     }
     if(n==0) return 1;}

Che ne pensi?Può andare?

[apatriarca]

Userei un "else" al posto della condizione "n == 0", ma l'idea è quella.

[del_ta]

"apatriarca":Userei un "else" al posto della condizione "n == 0", ma l'idea è quella.

Ok,bene! E se invece li voglio valutare in senso inverso? Non so se mi sono spiegato ma l'esercizio mi chiede di scrivere 2 versioni della funzione: una che moltiplica i dispari in ordine di inserimento del vettore (dall’indice più piccolo all’indice
più grande) e l’altra viceversa. Come si può fare?

[apatriarca]

Se ti interessa semplicemente cambiare l'ordine degli operandi è allora sufficiente scrivere molt_dispari(x, n-1)*x[ n ] o x[ n ] * molt_dispari(x, n-1). Altrimenti è necessario usare delle funzioni intermedie.