Eine Fakultätentabelle von 1! bis n! wie mache ich das?

Hallo,

ich brauche dringend Hilfe! Ich soll morgen diese Aufgabe gelöst abgeben, damit ich eine Note in C++ bekomme.

Die Aufgabe ist diese:

Es ist eine Fakultätentabelle von 1! bin n! auszugeben. Der Endwert n ist als ganze Zahl zu lesen.

Beispiel: n = 4
1! = 1
2! = 2 (21)
3! = 6 (3*2*1 = 6)
4! = 24 (4*3*21 = 24)

Ich bin für jede Hilfe sehr dankbar!

C Newbie

Die Fakultät von einer Zahl kann man so berechnen:

int Fakultät(int Aktuelle Zahl)
Wenn Aktuelle Zahl == 1 dann return 1
Aktuelle Zahl * Fakultät(Aktuelle Zahl - 1)
return Aktuelle Zahl

Diese Funktion muss man nur noch in einer Schleife mit der Zahlenfolge aufrufen,
Werte speichern, ausgeben, fertig.

Danke Ersteinmahl!

Leider habe ich bis jetzt nur die Grundkenntnisse in C++ gelernt. Daher kann ich nicht sehr viel mit deiner Beschreibung anfangen

Könntest du mir eventuell den Kompletten Code schreiben?
Das wäre sehr, sehr nett von dir.

Mfg

C Newbie

Komplette Programme schreiben wir nicht.

Aber hier hast du die Funktion:

int Fakultät(int Zahl)
{
 if(Zahl == 1)
   return 1;

 return Zahl * Fakultät(Zahl-1);
}

const int n=4;
int fakultaet[n];
fakultaeten[0] = 1;

for (int i=1; i<n; ++i) {
   fakultaet[i] = fakultaet[i-1] * i;
}

Sanji

C Newbie schrieb:

Komplette Programme schreiben wir nicht.

Aber hier hast du die Funktion:
int Fakultät(int Zahl)
{
 if(Zahl == 1)
   return 1;
 
 return Zahl * Fakultät(Zahl-1);
}

Rekursive Funktionen find ich hässlich. :p Vor allem, wenn man ihnen zu große Argumente übergibt... Da explodiert dein Stack Dann lieber die Lösung helium logged out.
Wichtig: Keine zu großen Argumente übergeben, da sonst schnell der Wertebreich von int überschritten wird!

Walli

Happosai schrieb:

Wichtig: Keine zu großen Argumente übergeben, da sonst schnell der Wertebreich von int überschritten wird!

Jo, so bei 32 bit dürfte n gerade mal zweistellig sein (so um die n=12) bevor der Bereich gesprengt wird. Also besser mit __int64 (falls MSVC) oder long long etc. arbeiten .

Helium

und unsigend nicht vergessen.

PeterTheMaster

und auch nicht vergessen, dass alle zwischenergebnisse auszugeben sind. es waere krass dumm, jede zeile neu zu berechnen. es ist immer sehr drollig, neulinge, die irgendwo eine rekursive funktion abgeschrieben (und natuerlich nicht verstanden) haben, dabei zu beobachten, irgendwas daran aendern zu wollen. wann ist es aufsteigend? wann ist es absteigend? trial und error pur.

Rekursive Funktionen find ich hässlich

Was ist bitte daran hässlich?

dass alle zwischenergebnisse auszugeben sind

Wo bitte gibts du bei einer Rekursion Zwischenergebnisse aus?

PeterTheMaster

die aufgabenstellung ganz oben fordert das.

C Newbie

Anonymous schrieb:

Was ist bitte daran hässlich?

Jeder Funktionsaufruf wird auf dem Stack abgelegt. Bei einer rekursiven Funktion
wird also immer wieder die Funktion auf dem Stack abgelegt, was diesen füllt.
Dies verbraucht Zeit und Speicherplatz.
Darum sind rekursiven immer die iterativen ( ) vorzuziehen.

Bashar

Premature optimization

C Newbie

Premature optimization? Was optimiert die?

Helium

Jeder Funktionsaufruf wird auf dem Stack abgelegt. Bei einer rekursiven Funktion wird also immer wieder die Funktion auf dem Stack abgelegt, was diesen füllt.

Naja. nicht die Ganze funktion. nur die verwendeten Variablen.

Aber was sollen jetzt die Verfechter der Funktionalen Programmierung sagen? Bei denen gibts kine Schleifen. Die machen alles rekursiv. Sind die jetzt alle blöd?

TheTester

ne sind sie nicht...und die meisten funktionalen sprachen unterstüzen auch diverse schleifen konstrukte *g*, die leute halten rekursiv einfach für schöner...es ist ja auch praktisch du kannst zb. eine mathematisch rekursiv definierte funktion gleich so hinschreiben wie du sie vor dir hast...ob das effizient ist is eine andere frage...

bye

tt

ne sind sie nicht...und die meisten funktionalen sprachen unterstüzen auch diverse schleifen konstrukte *g*, die leute halten rekursiv einfach für schöner...es ist ja auch praktisch du kannst zb. eine mathematisch rekursiv definierte funktion gleich so hinschreiben wie du sie vor dir hast...ob das effizient ist is eine andere frage.

Meines erachtens ist eine Rekursion in funktionalen Programmiersprachen effizienter und mächtiger.

Aber was sollen jetzt die Verfechter der Funktionalen Programmierung sagen? Bei denen gibts kine Schleifen. Die machen alles rekursiv. Sind die jetzt alle blöd?

Was mir aufgefallen ist, das viele Menschen die iterativ progr., Probleme haben Rekursiv zu denken. Da sie immer den Programmablauf beschreiben wollen und net das Ergebnis.
Ist schon lustig, seine schleifenbedingte Denkweise übern Haufen zu werfen.

RPD

PeterTheMaster schrieb:

und auch nicht vergessen, dass alle zwischenergebnisse auszugeben sind. es waere krass dumm, jede zeile neu zu berechnen. es ist immer sehr drollig, neulinge, die irgendwo eine rekursive funktion abgeschrieben (und natuerlich nicht verstanden) haben, dabei zu beobachten, irgendwas daran aendern zu wollen. wann ist es aufsteigend? wann ist es absteigend? trial und error pur.

ich versteh kein wort

#include <iostream>
using namespace std;
int Fak(int Zahl) {  
   if(Zahl == 1)    
     return 1; 
   return Zahl * Fak(Zahl-1); 
}

int main() {
   int max_Fak = 4;
   for(int i = 1;i <= max_Fak; ++i)         
      cout<<i<<"! = "<<Fak(i)<<endl;
return 0;
}

wie jede zeile neu berechnen, natürlich jede zeile neu berechnen(!)...
aufsteigend, absteigend... hä?

Jeder Funktionsaufruf wird auf dem Stack abgelegt. Bei einer rekursiven Funktion
wird also immer wieder die Funktion auf dem Stack abgelegt, was diesen füllt.
Dies verbraucht Zeit und Speicherplatz.
Darum sind rekursiven immer die iterativen ( ) vorzuziehen.

Das was du beschrieben hast ist nicht häßlich. Häßlich wäre für mich was optisches, sozusagen das der Code bei einer Rekursion unlesbar wäre, oder in der Art. Aber das ist ja nicht der Fall. Rekursion ist eigentl. was schönes.

Muss dir aber Recht geben, Rekursion ist größtenteils für funtionale P-Sprachen ausgérichtet.