[C]Non ridete ,ho appena iniziato....

[toz]

Allora, ho questo codice che non riesco ad interpretare...se qualcuno mi da una mano....

#include <stdio.h>
int funz (int,int);
int main ()
{
	int a=10,b=12,t;
	t=funz(a,b);
	printf("t=%d\n\n",t);
	return 0;
}
int funz (int x,int y)
{
	if(y!=0)
	   return(y+funz(y,x%y));
    else
       return x;
}

L'ho fatto girare e mi risulata che il "printf" riporta t=26.
Le mie perplessita' sono : ma la "funz" in realta' non fa nulla?Perche' y(che sarebbe b?) e' diverso da 0,quindi dovrebbe uscire con il "return x" che si dovrebbe limitare a riportare il valore di a cosi' come dichiarato nella main.
Ma allora il valore di t=26 da cosa e' dato,cioe' t=funz(a,b) che calcoli esegue ?
Grazie.

[bobbytre]

Originariamente inviato da toz

Allora, ho questo codice che non riesco ad interpretare...se qualcuno mi da una mano....

#include <stdio.h>
int funz (int,int);
int main ()
{
	int a=10,b=12,t;
	t=funz(a,b);
	printf("t=%d\n\n",t);
	return 0;
}
int funz (int x,int y)
{
	if(y!=0)
	   return(y+funz(y,x%y));
    else
       return x;
}

L'ho fatto girare e mi risulata che il "printf" riporta t=26.
Le mie perplessita' sono : ma la "funz" in realta' non fa nulla?Perche' y(che sarebbe b?) e' diverso da 0,quindi dovrebbe uscire con il "return x" che si dovrebbe limitare a riportare il valore di a cosi' come dichiarato nella main.
Ma allora il valore di t=26 da cosa e' dato,cioe' t=funz(a,b) che calcoli esegue ?
Grazie.

La funzione funz è ricorsiva è bisogna ragionare un attimo per capirne il funzionamento ,
quando viene eseguita la prima volta chiamata nel main y = 12

quindi if(y!=0) è verificato
ed esegue return(y+funz(y,x%y));

che equivale a return ( 12 + funz(12,10) )
anche adesso la if è verificata quindi ritorna ( 10 + funz(10 ,2) )
che continua ad essere verificato quindi ritorna ( 2 + funz(2,0) )
adesso l'if non è piu verificato perchè la y = 0 quindi ritorna la x che è = a 2.

quindi ricapitolando
( 12 + funz(12,10) )
diventa
( 12 + ( 10 + funz(10 ,2) ) )
che diventa
( 12 + ( 10 + ( 2 + funz(2,0) ) ) )
che diventa
( 12 + ( 10 + ( 2 + (2) ) ) )

Totale 26

Spero che ti risulta piu chiaro il funzionamento di quella funzione

[toz]

Grazie mille.....ora mi e' molto piu' chiaro.....avevo fatto un madornale errore di "concentrazione" : y!=0 ,fin quando e' vero viene eseguita ricorsivamente la funz...non il contrario.....ne approfitto per chiedere una'altra cosa :ma x%y non dovrebbe riportare il resto di x/y ??Perch'e' nel primo pasaggio scrivi ( 12 + funz(12,10) ) ?

[toz]

Cerco di spiegarmi meglio:
Nel primo passaggio della funz,essendo verificato y!=0 (12!=0) si ha (y+funz(y,x%y) => (12+funz(12,10).
Nel secondo pasaggio ,essendo ancora verificato y!=0 (10!=0) si ha (y1+(y2+funz(y2,x%y2))) => (12+(10+funz(10,10%10))) ma tu scrivi ( 12 + ( 10 + funz(10 ,2) ) ) non dovrebbe essere ( 12 + ( 10 + funz(10 ,0) ) ) ? Perche' x%y e' uguale a 2 ?
Grazie.

[bobbytre]

Originariamente inviato da toz

Cerco di spiegarmi meglio:
Nel primo passaggio della funz,essendo verificato y!=0 (12!=0) si ha (y+funz(y,x%y) => (12+funz(12,10).
Nel secondo pasaggio ,essendo ancora verificato y!=0 (10!=0) si ha (y1+(y2+funz(y2,x%y2))) => (12+(10+funz(10,10%10))) ma tu scrivi ( 12 + ( 10 + funz(10 ,2) ) ) non dovrebbe essere ( 12 + ( 10 + funz(10 ,0) ) ) ? Perche' x%y e' uguale a 2 ?
Grazie.

Ho ricontrollato i miei calcoli è sono corretti.
Non so da dove ti esce quel 10 mod 10 , forse fai riferimento in una funzione ai ai valori delle varibili della funzione precedente piuttosto che a quelli correnti...

[toz]

I tuoi calcoli sono corretti,quello che non riesco a capire e' come varia il valore di x all'interno della funzione......

[bobbytre]

Originariamente inviato da toz

I tuoi calcoli sono corretti,quello che non riesco a capire e' come varia il valore di x all'interno della funzione......

ogni volta che richiami la funzione funz
è una storia a se stante che non ha nulla a che vedere con le chiamate precedenti

quindi quindi ogni chiamata ha le sue variabili che contengono i propri valori anche se hanno lo stesso nome

quindi la A del main e la X della prima chiamata di funzione sono due variabili diverse

cosi come lo sono la X della prima chiamata e la X della seconda chiamata di funz

quindi la X della prima chiamata vale 12
la X della seconda vale 10
la X della terza vale ... non mi ricordo ...

[toz]

Ti ringrazio per l'infinita pazienza......ti devo gia' una birra....
Il prototipo di funzione "int funz(int x,int y)" si prende i valori x=a=10 (dove a e' la prima variabile dichiarata nel main) e y=b=12 (dove b e' la seconda variabile dichiarata nel main).Dopodiche' i valori di x ed y
saranno assegnati dagli operandi nella funz,in particolare per qualsiasi valore che assumera' funz(pippo,pluto) io avro' x=pippo e y=pluto.
E' corretto?

x0=a=10,y0=b12
y!=0 VERO =>IF
(y+funz(y,x%y)) => (12+funz(12,10%12) => (12+funz(12,10)

x1=12,y1=10
y!=0 VERO =>IF
(y0+(y1+funz(y1,x1%y1))) => (12+(10+funz(10,12%10))) => (12+(10+funz(10,2)))

x2=10,y2=2
y!=0 VERO =>IF
(y0+(y1+(y2+funz(y2,x2%y2)))) => (12+(10+(2+funz(2,10%2)))) => (12+(10+(2+funz(2,0) => 12+10+2+2=26 => nella main funz(a,b)=26

x3=2,y3=0
y!=0 FALSO =>ELSE
return x=2 (che non viene preso in considerazione nella main)

Ci dovrei essere no?

[toz]

Mi sa che ho sbagliato......cioe'
una volta arrivato all'ELSE ho return x,cioe' il valore di x sara' il valore della funzione quindi il tutto diventa cosi' :

x0=a=10,y0=b12
y!=0 VERO =>IF
(y+funz(y,x%y)) => (12+funz(12,10%12) => (12+funz(12,10)

x1=12,y1=10
y!=0 VERO =>IF
(y0+(y1+funz(y1,x1%y1))) => (12+(10+funz(10,12%10))) => (12+(10+funz(10,2)))

x2=10,y2=2
y!=0 VERO =>IF
(y0+(y1+(y2+funz(y2,x2%y2)))) => (12+(10+(2+funz(2,10%2)))) => (12+(10+(2+funz(2,0)))

x3=2,y3=0
y!=0 FALSO =>ELSE
return x=2

=> funz(y2,x2%y2) vale 2
=> (12+(10+(2+2))) = 26=funz(a,b)

sto proprio esaurito

[toz]

Sempre ste cavolo di funzioni......qualcuno mi potrebbe spiegare come avviene la ricursione della funzione di questo prog???

#include <stdio.h>
#define N 9
int funz(int *x,int y);
int main ()
{
	int i,z=0;
	int A[N]={0,1,2,3,4,5,6,7,8};
	for(i=N-1;i>=0;i-=2)
	{
		A[i]=(i+3)/2;
		z+=A[i];
	}
	z+=funz(A,0);
	printf("z=%d A[0]=%d\n\n",z,A[0]);
	return 0;
}
int funz(int *x,int y)
{
	if (*x < *(x+y))
	return y;
	else
	return *x=funz(x,y+1)+y;
}

[dierre]

Originariamente inviato da toz

Sempre ste cavolo di funzioni......qualcuno mi potrebbe spiegare come avviene la ricursione della funzione di questo prog???

#include <stdio.h>
#define N 9
int funz(int *x,int y);
int main ()
{
	int i,z=0;
	int A[N]={0,1,2,3,4,5,6,7,8};
	for(i=N-1;i>=0;i-=2)
	{
		A[i]=(i+3)/2;
		z+=A[i];
	}
	z+=funz(A,0);
	printf("z=%d A[0]=%d\n\n",z,A[0]);
	return 0;
}
int funz(int *x,int y)
{
	if (*x < *(x+y))
	return y;
	else
	return *x=funz(x,y+1)+y;
}

La ricorsione avviene come nel caso precedente.

Ora, non tocco più il C da 4 o 5 anni, però ricordo che gli Array ed i puntatori sono in relazione molto stretta, quindi quello che vedi lì è un modo malsano per scorrere un array attraverso puntatori

Chiedo a chi ne sa più di me.
Ma se nel main chiamo

z+=funz(A,0);

e la signature di funz è:

int funz(int *x,int y)

vuol dire che *x è il primo elemento dell'array, giusto?


Quindi in poche parole nell'if vai a paragone il primo elemento dell'array con tutti gli elementi successivi dell'array che sono > del primo elemento.

Dovrebbe tornare:

*x = 0 + funz(x,1) = 0 + 1;

Prendi con le pinze quello che ti dico perché ripeto che il C non lo tocco da anni.

PS: concittadino!

[toz]

Grazie concittadino!!!
Quello che non capisco pero' e',dopo il primo return dell ELSE,cosa succede...cioe' debbo sostiuire *x con 0 + funz(x,1) = 0 + 1 ?
In tal caso nell IF diventerebbe 0 + 1 < *( 0 + 1)+y) e y che valore avrebbe?

Interamnia caput mundi!!

[dierre]

Originariamente inviato da toz

Grazie concittadino!!!
Quello che non capisco pero' e',dopo il primo return dell ELSE,cosa succede...cioe' debbo sostiuire *x con 0 + funz(x,1) = 0 + 1 ?
In tal caso nell IF diventerebbe 0 + 1 < *( 0 + 1)+y) e y che valore avrebbe?

Interamnia caput mundi!!

Allora: prima regola del programmatore, usare molto l'output. printati *x così vedi come cambia.
A mio parere lì x è sempre lo stesso "all'andata", quindi

*x = f(x,1) + 0

quindi

f(x,1) dovrebbe essere 0<1 perché *x punta sempre al primo elemento e *(x+y) dovrebbe puntare all'elemento 1, cioè (0+1).

Infatti nota che passa x e non *x, quindi rimane invariato nei passaggi perché x è l'indirizzo dell'array e rimane costante.

infatti tu in generale fai così:

int a[n];
int *x;

x = a;

Tutto ciò, ribadendo che sicuramente c'è qualcuno con mente più fresca della mia sul C.