[Java] metodo ricorsivo

[anymore1]

Ragazzi mi aiutate a fare questo esercizio?o qualche consiglio su come procedere....
Scrivere un metodo ricorsivo

 int som(int x, int y) 

che calcola la $x+y$ ($x$ ed $y$ supposti entrambi non negativi) per incrementi unitari della $x$. Cioè $ x+y=x+1+1+…$ tanti 1 per quanto è il valore di $y$. Fornire prima una definizione ricorsiva di som e quindi mostrare una versione corrispondente del metodo.

[akiross1]

Alura, mi pare ovvio che bisognera' chiamare la funzione ricorsivamente Y volte, ognuna delle quali incrementa la X.
Possiamo quindi decrementare la Y fino a 0 - in questo caso si termina la ricorsione, altrimenti si esegue l'incremento e si procede con Y - 1.

int som(int x, int y) {
  if (y != 0)
    return som(x + 1, y - 1);
  else
    return x;
}

Esempio per 3,4:
som(3, 4) 4 != 0? si -> return di
som(4, 3) 3 != 0? si -> return di
som(5, 2) 2 != 0? si -> return di
som(6, 1) 1 != 0? si -> return di
som(7, 0) 0 != 0? no -> return 7

Mi sembra funzionare!

[anymore1]

Ciao mi aiutate a capire questo esercizio?
anche un input

Scrivere un metodo ricorsivo min() che riceve un array di interi v, due indici inf e sup su v , e ritorna il minimo valore di v,tra gli indici inf e sup, cercandolo con la tecnica divide-e-impera.
Se lo spazio di ricerca tra inf e sup consiste di un solo elemento,esso è banalmente il minimo tra inf e sup.Se contiene più elementi,allora si divide in 2 segmenti "uguali" l'array tra inf e sup, si cercano ricorsivamente i minimi nei due segmenti,dopo di che si ritorna il minimo dei 2.Inserire il metodo in una classe col main che inizializza un array di interi,lancia su di esso il metodo il min() e visualizza il minimo trovato

[fu^2]

te come lo imposteresti?

[Umby2]

"anymore":Ciao mi aiutate a capire questo esercizio?
anche un input

Scrivere un metodo ricorsivo min() che riceve un array di interi v, due indici inf e sup su v , e ritorna il minimo valore di v,tra gli indici inf e sup, cercandolo con la tecnica divide-e-impera.
Se lo spazio di ricerca tra inf e sup consiste di un solo elemento,esso è banalmente il minimo tra inf e sup.Se contiene più elementi,allora si divide in 2 segmenti "uguali" l'array tra inf e sup, si cercano ricorsivamente i minimi nei due segmenti,dopo di che si ritorna il minimo dei 2.Inserire il metodo in una classe col main che inizializza un array di interi,lancia su di esso il metodo il min() e visualizza il minimo trovato

Non vorrei sbagliare, ma per applicare la tecnica è necessario che il vettore sia ordinato !
In questo caso la tecnica puo' servire per ricercare un determinato valore, e non di trovare il minimo valore.

Altri dettagli del quesito ne hai ?

[apatriarca]

Il testo mi sembra abbastanza chiaro su come si debba procedere per trovare il minimo. All'inizio del metodo si confronta se (sup - inf) == 1 (o 0 a seconda di come si considerano gli indici) e in questo caso si restituisce array[inf]. In caso contrario si trova mid = inf + (sup - inf)/2 il valore medio tra gli indici e si richiama il metodo su entrambe le parti dell'array (quella compresa tra inf e mid e quella compresa tra mid+1 e sup). A questo punto non resta che restituire il minimo tra i valori restituiti dai metodi chiamati sulle due parti.

[Umby2]

mbè... non capisco a cosa possa servire questo metodo, allora.

Se il vettore non è ordinato, il minimo potrebbe essere presente nella prima parte cosi' come nella seconda, e se si suddivide ancora, potrebbe essere presente nella terza o nella quarta .... e cosi' via....

tanto vale, verificare l'intero vettore sequenzialmente partendo di min, fino a max.

[apatriarca]

Si tratta semplicemente di un esercizio per imparare gli algoritmi di divide et impera. Gli esercizi non devono avere più di tanto senso. In questo caso è probabilmente più efficiente (sia dal punto di vista del tempo che dello spazio) il semplice metodo iterativo (almeno su una singola CPU). Se si permette alle varie parti dell'array di essere processate in contemporanea su diversi processori allora il metodo proposto potrebbe avere qualche vantaggio ma credo lo implementerei comunque diversamente. Ma esistono diversi algoritmi molto efficienti che sfruttano l'idea alla base di questo algoritmo e ha quindi senso fare esercizi su di esso.

[anymore1]

public class Esercizio5{
	static int min( int []v, int inf, int sup ){
		if( inf==sup ) return v[inf];
		int med=(inf+sup)/2;
		int m1=min( v, inf, med );
		int m2=min( v, med+1, sup );
		return (m1<m2)?m1:m2;
	}public static void main( String[] args ){
		int []a={5,7,10,1,8,3,25};
		System.out.println("min="+min(a,0,a.length-1));
	}

}

[apatriarca]

Esatto... Ti consiglio di usare il tag corretto (dovrebbe essere code) per visualizzare il codice in modo di poterlo leggere correttamente indentato.

[anymore1]

Ragazzi sto facendo un esercizio che mi dice con un metodo ricorsivo se il num è perfetto
boolean perfetto(int n.int d,int s) e ritorna true se il parametro n è perfetto
io l'ho fatto cosi me lo controllate?

public class metodoRicorsivo {
public static boolean perfetto(int n,int d,int s){
s=0;
for(int i=1;i<n;i++){
if(n%i==0){
s=s+i;
}
}
if(s==n){
return true;}
else return perfetto(n,d,s);}
public static void main (String[]args){
int n=6;
int d=3;
int s=6;
System.out.println("il num è perfetto?"+ perfetto(  n,  d,  s));
}
}

per lanciare il metodo cosi: perfetto (n,1,0) come devo fare? mi suggerite una soluzione possibile?(sempre se quello che ho fatto soprea è giusto)con textpad mi gira

[apatriarca]

Il metodo da te proposto entra in un ciclo infinito (bhe... manda proprio in crash il programma perché usa tutta la memoria disponibile). Inoltre il test se è perfetto viene eseguito in un ciclo e quindi di fatto non hai rispettato la richiesta dell'esercizio. Tu hai scritto un metodo ricorsivo che richiama indefinitamente se stesso se il numero non è perfetto, non un metodo ricorsivo per determinare se un ciclo è perfetto. Quello che dovevi fare era semplicemente implementare il ciclo di quella funzione come una funzione ricorsiva.