[C] Funzioni ricorsive

[leomagic]

mi sto grattando la testa con queste funzioni ricorsive..:muro: :muro: è 2 gg che cerco di fare questa funzione..ve la spiego.
Dato un reddito inziale ed un reddito finale devo calcolare in quanti anni riesco a raggiungere il reddito finale con l'interesse del 3.5% ed una tassazione del 12.5%.
Iterativamente non ci sono problemi,ma chi sa aiutarmi con la ricorsiva?

[maxithron]

Ti va bene un link esplicativo oppure non è sufficiente?:

http://www.in-f-or.it/informatica/c/cap55.html

E poi potresti dire con quale metodo?(ricerca,fibonacci,dicotomica..)

[leomagic]

io a scuola ho fatto la ricorsiva solo con il fattoriale,la ricerca e fibonacci,ma x questa esercitazione nn sa da che parte cominciare..

[lombardp]

Dovresti spiegare quali sono le regole per l'applicazione dell'interesse e della tassazione.

E poi non penso sia il "reddito finale" quanto il "capitale finale", mi sbaglio?

In tal caso

potresti provare con:


int quantocimetto(int reddito,int parziale, int finale, int step)
{
parziale = parziale * 1.035 + reddito * 0.875;
printf("\n%i",parziale);
step++;
if (parziale<finale) step = nuovoanno(reddito,parziale,finale,step);
return step;
}


Da usare così:


anniperarrivarci = quantocimetto(mio_reddito,0,capitale_finale,0);

[cionci]

IMHO:

capitale_iniziale += capitale_iniziale * 0.035 * 0.875;

Almeno di solito la tassa statale del 12,5% è sugli interessi maturati ;)

int quantocimetto(int iniziale, int finale)
{
if (iniziale < finale) //solo per controllo di errori nei parametri
return 0;

iniziale += iniziale * 0.035 * 0.875;
printf("\n%i", iniziale);
if (iniziale > finale)
return 1;

return 1 + quantocimetto(iniziale, finale);
}

[leomagic]

vi scrivo tutto il testo dell'esercitazione ok?

Una banca offre ai propri clienti la seguente formula per la gestione del capitale:
- l'interessa annuo è costante e corrisponde al 3.5%
- ogni guadagno è sottoposto ad una tassazione del 12,5%

Costruire 2 funzioni ricorsive in grado di rispondere alle seguenti domande del potenziale cliente :

1.investendo un determinato capitale inziale, quanti anni occorreranno affinchè il capitale risulti raddoppiato o comunque corrispondente ad una cifra finale diversamente specificata?

2. partendo da un capitale inziale specificato,quale sarà il valore disponibile dopo un certo numero di anni?

Dopo aver implementato le suddette specifiche, realizzare un codice in grado di visualizzare graficamente l'andamento dell'investimento e predisporre il programma per la possibilità di ricevere i dai d'ingresso da un file di testo specificato dall'utente e ridirezionare il risultato dell'elaborazione su un ulteriore file specificato.
Modellare la realtà proposta in modo accurato e fornire una dettagliata documentazione della soluzione proposta.

[leomagic]

Originariamente inviato da cionci

printf("\n%i", iniziale);

[/code]

cosa vuol dire quel %i?

[leomagic]

ho provato entrambi i codici,il primo funziona il secondo mi da sempre risultato zero,x quella condizione posta subito all'inizio..

[cionci]

Sì...scusa... iniziale > finale ;)
int quantocimetto(int iniziale, int finale)
{
if (iniziale >= finale)
return 0;

iniziale += iniziale * 0.035 * 0.875;
printf("\n%i", iniziale);

return 1 + quantocimetto(iniziale, finale);
}
Va bene anche così...l'altro controllo era superfluo...

[leomagic]

peggio ancora..così ho due condizioni uguali..

[cionci]

Originariamente inviato da leomagic
peggio ancora..così ho due condizioni uguali..
Il fatto di due condizioni uguali serviva per risparmiarte una ricorsione, ma ora ho aggiornato...

[leomagic]

ho provato e sembra funzionare,così scritta xò mi da errore nel cacolo degli interessi,ma nn sarebbe opportuno usare un conto parziale come nella prima funzione?

[leomagic]

Originariamente inviato da cionci
Sì...scusa... iniziale > finale ;)
[code]int quantocimetto(int iniziale, int finale)
{
iniziale += iniziale * 0.035 * 0.875;


cosa è quel += ?

[cionci]

Perchè usare un conteggio parziale ? Probabilmente è un problema legato agli interi ed agli arrotondamenti...

Non vedo perchè si debbano usare due variabili quando il totale degli interessi...

Fammi vedere come tu lo calcoli senza ricorsione...

[cionci]

Originariamente inviato da leomagic
cosa è quel += ?
Equivale a "interessi = interessi + quello che segue"...

[leomagic]

in flash funziona così
calcolaAnni = function (capitaleIniziale, capitaleParziale) {
anni++;
if (capitaleParziale<(capitaleIniziale*2)) {
capitaleParziale = capitaleParziale*1.035;
// -----------------------------------| occhio a questo numero
calcolaAnni(capitaleIniziale, capitaleParziale);
} else {
_root.risultato = "con un capitale Iniziale di "+capitaleIniziale+" il capitale raddoppia in anni "+anni+" circa "+capitaleParziale;
anni = 0;
}
};


ponendo che il finale sia il doppio di quello inziale e gli anni sono circa sempre 22,se lo fai a mano ti torna pressocche quegli anni..

[cionci]

Sì ma i tuoi numeri cosa sono float...double...interi ?
E' un questione di arrotondamenti...

Guarda questo... Ecco cosa succede usando i double:

int quantocimetto(double iniziale, double finale)
{
if (iniziale >= finale)
return 0;

iniziale += iniziale * 0.035 * 0.875;
printf("\n%f", iniziale);

return 1 + quantocimetto(iniziale, finale);
}

[cionci]

Il fatto è che se fai un calcolo preciso sugli interi...devi fare diversi arrotondamenti...

Supponendo che negli interi ci stiano i centesimi di Euro credo che un conto molto vicino a quello che avviene realmente sia:


int round(double num)
{
if((num-(int)num) < 0.5)
return (int)num;
return (int)num + 1;
}

int quantocimetto(int iniziale, int finale)
{
if (iniziale >= finale)
return 0;

iniziale += round((double)round((double)iniziale * 0.035) * 0.875);
printf("\n%f", iniziale);

return 1 + quantocimetto(iniziale, finale);
}

Non sono sicuro sull'arrotondamento perchè non so se lo fanno veramente...o usano qualche arrotondamento particolare...

[leomagic]

la seconda nn ho capito esattamente cosa esegue,cmq la prima che mi hai scritto ha funzionato finalmente,grazie x l'aiuto..che fatica che è stata!
ora ha da venire il peggio..

[leomagic]

per la seconda opzione devo fare il verso contrario,dati gli anni sapere a quanto ammonta il reddito ocn gil interessi,devo fare la stessa funzione solo che la condizione x cui deve uscire dalla ricorsione è diversa vero?x capirci..

int cap_finale(double iniziale,int anni)
{
if (iniziale = 6);
return 0;
iniziale = iniziale + iniziale * 0.035 * 0.875;
printf("\n%f", iniziale);
return 1 + cap_finale(iniziale,anni);
}

devo cambiare solo quell'if all'inzio(che adesso è messo a caso)?

[cionci]

Non solo... Così dovrebbe andare...
double cap_finale(double iniziale,int anni)
{
if (anni <= 0);
return iniziale;
iniziale = iniziale + iniziale * 0.035 * 0.875;
printf("\n%f", iniziale);
return cap_finale(iniziale, anni-1); //nota il -1
}

[leomagic]

teoricamente è giusto,xche quando arriva all'anno 0 lui si è già calcolato l'ultimo capitale iniziale,xò mi da risultato zero..
la stampo così la funzione..sbaglio a chiamarla?
printf("%f",cap_finale(iniziale,n));

[leomagic]

Mea culpa, non avevo chiesto il paramatro da passare e lui passava zero..:eek:

[leomagic]

Originariamente inviato da cionci
Non solo... Così dovrebbe andare...
double cap_finale(double iniziale,int anni)
{
if (anni <= 0);
return iniziale;
iniziale = iniziale + iniziale * 0.035 * 0.875;
printf("\n%f", iniziale);
return cap_finale(iniziale, anni-1); //nota il -1
}

c'era un piccolo errorino quel ; dopo l'if..ora è tutto apposto..a presto nuovi problemi..mi spieghi una cosa?
quel meno 1 l'ho capito,ma come mai quel + 1 alla prima funzione?

[cionci]

Per il ; scusa...avevo fatto le modifiche partendo dal tuo codice e così non me ne sono accorto...

Il + 1 alla fine della prima funzione serve per contare le ricorsioni fatte...

Fai conto di essere alla N-esima chiamata... Se alla successiva chiamata la funzione ritorna 0 (abbiamo superato la soglia)...si ritorna alla N-esima chiamata che ritorna 1+0... La N-1 ritorna 1+1+0... La prima chiamata ritorna N al programma principale...con N il numero di chaimate (in realtà il numero di chiamate è N+1, ma l'ultima ritorna 0)...

A chi si trova male con le ricorsione io suggerisco sempre di lavorare in modo similare alle dimostrazioni per induzione...

La prima cosa da fare è settare la/le condizioni di arresto...cioè le condizioni per cui la ricorsione si deve fermare...

Poi settare i valori da ritornare nel caso siano raggiunte le condizioni di arresto...cioè i valori da ritornare in caso che i valori passati alla funzione siano tali da non permettere alcuna ricorsione...

Poi si passa alla ricorsione...e bisogna metterci nel caso più generico possibile (senza fare alcuna supposizione sui valori di ingresso)... L'unica cosa che sappiamo è che non sono tali da verificare una condizione di arresto...
A questo punto bisogna ragionare su quello che il nostro algoritmo deve fare al generico passo i...

Se si ragiona in questo modo l'algoritmo ricorsivo funziona quasi automaticamente...