Esercizio su ricorsione

[Michele/9611]

Salve a tutti, ho da pochi minuti svolto il seguente esercizio:


* Scrivere un metodo ricorsivo exDue con le seguenti caratteristiche:
* a) exDue lavora su un array a passato per riferimento;
* b) exDue restituisce l'array a, modificato in modo che:
* 1) tutti e soli gli elementi di a per cui il metodo test dato e' vero siano incrementati di 1;
* 2) l'indice che guida la ricorsione CRESCA durante le chiamate ricorsive.
*
* ESEMPI.
* Se b-->{0, 2, 5, 1, 4} allora exDue(b) restituisce b-->{0, 3, 6, 1, 4}.
* Se b-->{2, 5, 8} allora exUno(b) restituisce b-->{3, 6, 9}.
* Se b-->{2} allora exUno(b) restituisce b-->{3}.
* Se b-->{1} allora exUno(b) restituisce b-->{1}.
* Se b-->{} allora exUno(b) restituisce b-->{}.

Il metodo test dato è il seguente:

 private static boolean test(int x) {
           return (x % 3 == 2);
   }

La mia soluzione è la seguente:

public static int[] exDue(int[] a){
		int i=0;
		if(a!=null){
			return exDueRic(a,i);
		}
		else{
			return null;
		}
	}
	public static int[] exDueRic(int[] a,int i){
		if(i<a.length){
			if(test(a[i])==true){
				a[i]++;				
			}
			return exDueRic(a,i+1);
		}
		else{
			return a;
		}
	}

Quello che mi chiedo è:"sarebbe possibile svolgere tale esercizio senza richiamare metodi di supporto e/o passare come
parametro formale l' indice che guida la ricorsione?"
Ringraziamenti anticipati a chiunque sappia darmi una risposta!!
Saluti

[apatriarca]

Non usando il linguaggio che stai utilizzando (che suppongo sia Java?) o non usando gli array. Sarebbe possibile se il linguaggio supportasse argomenti di default (come in C++) e se quindi facessi qualcosa come il seguente (non restituisco alcun valore che l'array viene comunque modificato in place):

void exDue(std::vector<int> &a, int i = 0)
{
    if (i >= a.size()) { return; }
    if (test(a[i]) { ++a[i]; }
    exDue(a, i+1);
}

In alternativa è possibile usando iteratori invece che array. Per esempio:

public static void exDue(ListIterator<int> it)
{
    if (!it.hasNext()) { return; }
    int value = it.next();
    if (test(value)) { it.set(value + 1); }
    exDue(it);
}

Ovviamente tutto questo è un inutile esercizio in quanto in pratica nessuno userebbe un metodo ricorsivo per una cosa del genere in un linguaggio come questi.

[Michele/9611]

Anzitutto ti ringrazio per la risposta, in secondo luogo sono pienamente d' accordo, è un esercizio finalizzato a comprendere certi meccanismi(credo), da un punto di vista pratico cose del genere si possono ottenere con molto meno, ma questo è l' esercizio
Saluti.