rekursion addition

ensi

hey leute,

gefordett ist eine rekursive funktion, die von 1 bis 100 zählt ( mehr nicht) :

#include <stdio.h>

int zaehlen(int z) {

	if ( z == 100 ) 
		return 1;

	return (z+zaehlen(z+1));
}

void main(){
	int i;
	i = 1;

	printf("Dieses Programm zaehlt von 1 bis 100");

	printf("\n\nEndergebnis: %i ", zaehlen(i));

	getchar();
}

* ich weiß nicht, woran es liegt, aber es gibt einen stack overflow - kann mir jemand helfen bitte?

viele grüße

int recurse(int i){
	printf("%d\n",i);
	if(i!=100)
	  return recurse(i+1);
	return i;
}

int main()
{
	recurse(1);
    return 0;
}

also bei mir gehts, evtl. ist auch dein stack etwas klein

lg lolo

eigentlich brauchst da keine rückgabe

void recurse(int i){
	printf("%d\n",i);
	if(i!=100)
	  recurse(i+1);
}

ensi

kurze frage, also das, was ihr da geschrieben habt, ist dasselbe wie mein code?
weil recurse() seh ich jetzt zum ersten mal

Hallo,

ensi schrieb:

* ich weiß nicht, woran es liegt, aber es gibt einen stack overflow - kann mir jemand helfen bitte?

viele grüße

Das liegt daran, das die Bedingung z == 100 nie wahr wird.
Gruß,
B.B.

ensi

weißt du auch warum nicht?

z startet doch bei 1?

Ja, du übergibst 1, dann 1 + 1 + 1 = 3, dann 3 + 3 + 1 == 7, usw.
Also immer ungerade Werte. Die Zahl 100 wird übersprungen.

Big Brother schrieb:

Ja, du übergibst 1, dann 1 + 1 + 1 = 3, dann 3 + 3 + 1 == 7, usw.
Also immer ungerade Werte. Die Zahl 100 wird übersprungen.

du meinst die rückgabe, der parameter wird immer um eins erhöht oder täusch ich mich da und damit terminiert auch i==100

lg lolo

mngbd

Big Brother schrieb:

Ja, du übergibst 1, dann 1 + 1 + 1 = 3, dann 3 + 3 + 1 == 7, usw.
Also immer ungerade Werte. Die Zahl 100 wird übersprungen.

Hmm, wie kommst du darauf? z wird bei jedem Aufruf um genau eins grösser.

Ich würde es so machen:

int zaehlen(int z)
{
    if (z == 10)   // mal mit 10 versuchen, wenn bei 100 der stack übergeht
        return z;  // <-- hier besser "z" als "1"
    else
        return z + zaehlen(z + 1);
}

Ja, verdammt das war Stuss, sorry.
Mich hat return z + zaehlen (z+1); irgendwie irritiert, obwohl es doch ein
return zaehlen ( z+1 ); auch tut:

int zaehlen(int z) {
if ( z == 100 )
return z;
printf ( "%d\n", z );
return zaehlen (z+1);
}

mngbd schrieb:

#define unlikely(x)     __builtin_expect((x),0)

int zaehlen(int z)
{
    if(unlikely(z == 10))
        return z;
    else
        return z + zaehlen(z + 1);
}

http://kerneltrap.org/node/4705

stefan-tiger

Zur Sicherheit:

if(z >= ...

mngbd

ensis Code sieht danach aus, als wollte er die Zahlen von 1 bis 100 addieren. Wenn's eine rekursive Funktion sein muss, und auf dem Stack nicht genug Platz ist, geht's in der Not auch so:

#include <stdio.h>

int zaehlen(int z)
{
    if (z < 0)
        return -z;
    else
        return zaehlen((-z / 2.0) * (z + 1));
}

int main(void)
{
    printf("Dieses Programm zaehlt von 1 bis 100");
    printf("\n\nEndergebnis: %i ", zaehlen(100));

    return 0;
}

Big Brother schrieb:

Ja, verdammt das war Stuss, sorry.

Ich kann noch nicht sehen wo das Stuss war.

Tim schrieb:

Big Brother schrieb:

Ja, verdammt das war Stuss, sorry.

Ich kann noch nicht sehen wo das Stuss war.

Die Werte 1, 1 + 1 + 1 = 3, 3 + 3 + 1 = 7, usw. die sich scheinbar aus der Zeile
z + zaehlen(z + 1); ergeben, haben keinen Einfluss auf die Abbruchbedingung, sondern nur der übergebene Wert z+1 in der Klammer. Da hab ich mich vom unnötig geklammerten Rückgabewert foppen lassen.

return (z+zaehlen(z+1));

Big Brother schrieb:

Tim schrieb:

Big Brother schrieb:

Ja, verdammt das war Stuss, sorry.

Ich kann noch nicht sehen wo das Stuss war.

Die Werte 1, 1 + 1 + 1 = 3, 3 + 3 + 1 = 7, usw. die sich scheinbar aus der Zeile
z + zaehlen(z + 1); ergeben, haben keinen Einfluss auf die Abbruchbedingung, sondern nur der übergebene Wert z+1 in der Klammer. Da hab ich mich vom unnötig geklammerten Rückgabewert foppen lassen.

return (z+zaehlen(z+1));

O.K. jetzt seh ichs auch. Zu lange gearbeitet... Trotzdem albern was die Funktion zurückgibt.

ensi

also wo ist jetzt der hacken? , d.h. ich überspring die 100?
die funktion soll von 1 bis 100 zählen -
1. ) 1
2. ) 2
3. ) 3
...
am ende hat man doch logischerweise die summe 1 + 2 + 3 + 4 ... + 100, weil es doch rückwärts vom stack genommen wird oder?

mngbd

ensi schrieb:

also wo ist jetzt der hacken? , d.h. ich überspring die 100?

Nein.

ensi schrieb:

am ende hat man doch logischerweise die summe 1 + 2 + 3 + 4 ... + 100, weil es doch rückwärts vom stack genommen wird oder?

Ja. (Aber die Summe in die andere Richtung ergäbe das gleiche, wahrscheinlich wollte dein Lehrer abwärts zählen.)

EOP

int zaehlen( int i )
{
	static int z = 0;
	z = i;
	return z < 10 ? zaehlen( z + 1 ) : z ;
}

EOP schrieb:

int zaehlen( int i )
{
	static int z = 0;
	z = i;
	return( z < 10 ? zaehlen( z + 1 ) : z );
}

was soll denn der schmarn?