Metodo ricorsivo

di il
2 risposte

Metodo ricorsivo

Ciao a tutti sono nuova!!
Sto studiando programmazione ...pero' ho un problema con questa cosa qui sotto!
Spero che qualcuno mi aiuti grazie a tutti comunque:):):):)
ciaooooooooo





il problema dice : Scrivere un metodo Java che, ricevendo come parametri un
intero positivo P e un array A di interi, stabilisca se si possa ottenere il valore
P sommando parte delle componenti dell’array A (eventualmente anche tutte
o una sola, senza obbligo di contiguit`a). Ad esempio, il responso per
A = 2 0 5 7 5 -1 10 ,
dovr`a essere: negativo se P = 3 oppure P = 30; affermativo se P = 2,
P = 28, oppure P = 9 ;

io ho scritto cosi il metodo : pero'....leggete


public static boolean ottieniSommaDesirata( int[]x, int n )
{

    assert n > 0;

    if ( x == null || x.length == 0 ) return false;

    return ottieniSommaDesirata( x, n, 0 );
}

private static boolean ottieniSommaDesirata( int[] x, int n,
                             int i // inizio parte inesplorata
                           )
{ 


   if ( n == 0 ) return true;

   if ( (x.length) - 1 == i )

       return n == x[i]; 

   if (ottieniSommaDesirata( x, n, i + 1 )) return true;
/* qui scarta la posizione i e prende quella i+1 // la mia domanda è questa
  secondo quanto ho studiado con la ricorsione si procede a ritroso   dal         caso base, e via via risalendo si risolve il problema  ma qui come si fa a risalire? cioe una volta che arrivo  a torrente.length - 1 = i sono al caso base e dopo ? come faccio  a sapere se era giusto scartare la posizione i ? */
   return ottieniSommaDesirata( x, n- x[i],   
                                                         i + 1 );  // qui non scarta la prende
}









2 Risposte

  • Re: Metodo ricorsivo

    Io non sono un guru del java, ma come primo passo io penso sia utile ordinare l'array; poi controlli se il numero inserito è già presente nell'array. Nel caso non lo fosse, il fatto che l'array sia ordinato dovrebbe facilitarti di molto la ricerca, per esempio:
    
    int[] sortedArray = {2, 5, 7, 21, 43, 54};
    int n = 15;
    
    boolean èOttenibile(int n, int[] array) {
       int maxIndex = -1;
       for (int i = 0; i < array.length; i++) {
          if (array[i] > n) {
             maxIndex = i;
             break;
          }
       }
    ...
    }
    
    Già questo semplice ciclo ti consentirebbe di restringere il campo a pochi elementi dell'array, sapendo che (a patto che gli elementi siano tutti positivi) 'n' può essere ottenuto, al massimo, sommando elementi minori di array[maxIndex]. Siccome non ho provato a realizzare il programma e ti sto consigliando così su due piedi, poi sta a te vedere come utilizzare un metodo ricorsivo. Comunque puoi aspettare soluzioni migliori, ripeto: non sono un gran che XD.
  • Re: Metodo ricorsivo

    E' simpatico questo giochino, pero' non ho capito se si deve trovare solo una delle tante potenziali combinazioni o tutte quelle possibili.
    Secondo me per qunto riguarda la progressione della i puo rimanere cosi, importante che si arrivi a una fine, se proprio vuoi fare al contrario si potrebbe asegnare a i la lunghezza di x - 1 e andare a ritroso fino a 0.
    Ai controlli di SimoneS93 aggiungerei anche la somma delle posizioni alternate prima i pari e poi i dispari.una ricerca di 2 solo elementi sommati partendo da array ordinato e dall'ultimo(scoorimento decrescente ) sommati con gli elementi in ordine crescente.
    for( j = array.length-1; j >= 0; j-- )
    for( i = 0; i < j; i++ )
    int trovato = ( array + array[j] ) - numeroDaCercare;
    if( trovato == 0 ) fine;
    if( trovato < 0 ) continue;
    if( trovato > 0 ) break;

    e dopo questi controlli si possono lanciare delle scansioni del tipo x[j]+(x+x[i+1]), finito questo si puo procedere con x[j]+(x+x[i+1]+x[i+2]) continuando cosi fino a quando la somma delle x dentro la tonda rimane < x.length-3, anche tutta la parte dentro le tonda potrebbe finire dentro a una funzione che ha come
    private int somma parziale( int array[], int j, int numeroDiElementiDaSommare, int partenzaSommaParziale){
    int somma = 0;
    for( int i = 0; i<numeroDiElementiDaSommare; i++ partenzaSommaParziale++)
    somma += array[partenzaSommaParziale];
    return somma;
    }
    naturalmente vanno aggiunto i giusti accorgimenti per evitare di sommare dentro il parziale anche il valore dento a j, e passare opportunamente i valori al metodo.
    Io l'ho concepito piu' come struttura iterattiva ma spesso le iterazioni si possono trasformare tranquillamente in ricorsioni.
    Ora provo a proposso questo gioco anche a dei miei amici alle prime armi come me vediamo se riescono a tirar fuori qualcosa di diverso.
    Ciao Lingyong Sun
    ps. scusa il casino ma sono le prime volte cche scivo in un forum, mi sono iscritto per vedere come gli altri risolvono i problemi e cercarne di nuovi da risolvere per migliore in programmazione.
Devi accedere o registrarti per scrivere nel forum
2 risposte