Newsgroup: it.comp.java
Titolo: [OT] ricorsione

Salve ho un problema davvero pesante con un concetto che non riesco ad 
assimilare: la RICORSIONE BINARIA: sto affrontando il problema in assembler 
mips e questo rende il problema offtopic, ma credo che la cosa possa 
comunque essere postata qui, visto che programmare dovrebbe trascendere il 
linguaggio scelto;
Parlando in termini di pseudo codice il mio problema è molto semplice:
voglio calcolare l'MCD (massimo comune divisore) tra due numeri A e B, e 
voglio farlo sfruttando la ricorsione; Il problema è che per effettuare la 
cosa necessito di un terzo numero, una variabile, un registro che dir si 
voglia che deve decrementare dal minore tra A e B fino a 1  fungendo da 
divisore per i due numeri fin tanto che non trovo resto nullo per entrambi;
Ora come faccio a inizializzare tale variabile evitando che venga 
reinizializzata ogni volta???
 NB : non posso chiamare una funzione che ne chiami un'altra, voglio proprio 
la ricorsività pura, causa, l'esame di informatica 2 di dopo domani!!!
Vi scongiuro in ginocchio, potete lavorarci insieme a me ????
Vi imploro!
Potete anche a tale scopo utilizzare l'algoritmo di Fibonacci che presenta 
in pratica lo stesso problema e che è risolto sebbene io nn comprenda 
come!!!!

 reinizializzata ogni volta???
Qualcosa stile:
  main() {
    int variabile = n;
    ricorsione(a, b, variabile);
  }
  ricorsione(int a, int b, int variabile) {
    if (variabile = 1) return;
    else {
      ricorsione(a, b, variabile--);
    }
  }
La variabile in questione viene inizializzata in main() e passata ad
ogni "innestamento" della ricorsione, appositamente modificata (In
questo caso, decrementata di uno).
-- 
Giambo - Occhio al filtro antispam _e_ alla whitelist !

 questo caso, decrementata di uno).
Magari postessi fare cosi... come ho detto, non posso chiamare altre 
funzioni e posso impostare variabili solo internamente alla funzione , 
ovvero all'esterno di essa non posso toccare nulla!!! 

 ovvero all'esterno di essa non posso toccare nulla!!!
Per capirsi, un sistema sarebbe una cosa del genere (lo stack è la memoria 
hardware del processore nel qual caso.
funzione (a){
    alloca spazio allo stack
    salva (a) nello stack;
    salva l'indirizzo di ritorno della funzione chiamante nello stack
    se a> n.inero a mia scelta{
              a--;
              funzione (a);
    }
    leggi a dallo stack
    leggi l'indirizzo di ritorno dallo stack
    dealloca lo spazio dallo stack
    salta all'indirizzo di ritorno
gli indirizzi di ritorni nello stack sono
|......
|salto ricorsivo  |
|salto ricorsivo  |
|salto ricorsivo  |
|main                |
____________ 

 ____________
Concludo facendoti osservare che in questo modo posso avere un contatore che 
parte da n a mia scelta ed arriva fino ad a!
Ora quello che vorrei è di poter avere un contatore che parta da zero e 
arrivi fino ad a, ma la qual cosa non è cosi semplice per i seguenti motivi:
Dovrei avere un registro $zero da incrementare, questo esiste ma non va 
toccato MAI per regola
Pertanto non ho un punto di partenza da cui incrementare.
La cosa potrebbe sembrare stupida in quanto volendo potrei partire da a 
della funzione, decrementare fino a zero e tornare su, ma il problema in 
questo caso è che a necessariamente si modifica e io devo proprio operare su 
a "!" e il valore di a non viene ristabilito, fino a quando non ho estratto 
tutti i valori da n ad a dallo stack.
Cioè io vorrei in pratica che a fosse fissato e potessi inizializzare una 
variabile a zero e farla incrementare fino ad a gestendo opportune 
operazioni tra le due variabili.
Lo so è un casino pazzesco, e il tuo metodo sarebbe di gran lunga il più 
semplice, e la funzione potrebbe essere portabile e quindi inattaccabile da 
ogni punto di vista se facessi :
funzione_reale(a){
    int x = 0;
    funzione_ricorsiva (a)
}
funzione_ricorsiva(a){
uso x;
funzione_ricorsiva(a-1);
}