e rekursive berechnen

reden wir von der Eulerzahl?

ja genau.

Na dann wirst Du sie wohl etwas auflösen müssen, damit C etwas damit 
anfangen kann. Immerhin steckt da so eine Art While-Schleife in der 
Formel

http://de.wikipedia.org/wiki/Eulersche_Zahl

PS.
Dozentin: Frau Kothe?

Hi
Auf der Seite war ich schon.
Ich habe je versucht, die Reihenformel in C umzusetzen.
Das dumme ist nur, dass mein Prof. die Lösung gerne rekursive haben 
möchte.
Und leider funktioniert mein Programm nicht.

int fak(int n)
{
if (n == 0 || n == 1)
return 1;
return (fak(n-1)*n);
}

  double e_rek (int n)
{
  //return ( rekursivBiKo((n-1),k)+ rekursivBiKo ((n-1),(k-1)));
  if(n ==1)
  {return 1;}
  else{  return (e_rek(n) + 1.0/fak(n));}
}

Brauche echt Hife, morgen ist die Klausur. :-(

??
Ich komme noch nicht ganz darauf was Du meinst.
In der Regl ist es so dass die Eulerzahl anhand einer Reihe berechnet 
wird. Wenn Ich Deinen Ansatz richtig deute sollst Du die Euler-Zahl bis 
zur n-ten Reihe berechnen, also er gibt n= 5 vor und dann wird eben 
aufsummiert bis 1/5!
Habe ich das richtig verstanden?

Wo wird denn in der Funktion double e_rek dein n verändert???

Ja richtig. Wir sollen es als Reihe entwickeln.
Nur diese Entwicklung soll halt rekursive sein. Sprich die Funktion zur 
Berechnung ruft sich immer wieder selber auf.

<< Sprich die Funktion zur
Berechnung ruft sich immer wieder selber auf. >>
Nun gut. Das ist überschaubar und macht Sinn
Die Anzahl der Aufrufe wird vorgegeben == n
Dann beginnst Du eine Schleife die von 1 an die Variable y hochzählt, 
bis n erreicht ist.
Und y dient Dir gleich für die Fakultät also     temp = fak(y).
Das Ergbenis in seinen Kerwehrt wandeln    ergebnis = 1/temp.
und dann der Eulerzahl, die in der Initialisierung mit 1 geladen wurde
int Eulerzahl = 1;
hinzuaddieren  Eulerzahl = Eulerzahl + ergebnis;
Die Schleife ist zu ende, wenn y == n ist.

Danke erstmal für eure Hilfe.
Leider klappt es immer noch nicht
Mein Code sieht nun so aus:

int fak(int n)
{
if (n == 0 || n == 1)
return 1;
return (fak(n-1)*n);
}

  double e_rek (int n)
{
  if(n ==1)
  {return 1;}
  else{  return (e_rek(n-1) + 1.0/fak(n));}
}

es gibt zwar keine Fehler mehr, aber das Ergebnis ist sehr weit von e 
entfernt

Danke ihr seid super. :-)

Richtig schön anspruchsvoll ist es, den Nenner als doppelte Rekursion 
zwischenzuspeichern, sodaß man nicht immer den Nenner neu berechnen 
muss, sondern nur den neuen Teiler hinzumultipliziert. Das Ding läuft 
als pipeline in Form eines Testprogrammes auf einem Altera FPGA. Ist 
sauschnellt und rechnet in Windeseile auf X-Stellen herunter.