int fakultaet(int zahl)
{
    int ergebnis = 1;

    for (int i=2;i<=zahl;i++)
    {
        ergebnis = ergebnis * i;
    }    

    return ergebnis;
}

Oder

(define (fact n)
  (if (= n 1)
      1
      (* n (fact (- n 1)))))

Oder

double fak( double x) {
if(x>=1)
return 1
return fak( x-1);
}

Das eine ist übrigens kein C++. Lisp?

Im Code steht dann:

#include <boost/math/special_functions/factorials.hpp>
int fact10 = boost::math::factorial(10);

// oder
#include <boost/math/special_functions/factorials.hpp>
using namespace boost::math;
int fact10 = factorial(10);

Das eine ist übrigens kein C++. Lisp?

Scheme.
Und das dritte ist syntaktisch falsch und ansonsten eine recht umständliche Art und Weise, return 1; zu schreiben, aber keine Fakultät Das erste sieht doch ganz gut aus, wo ist das Problem?

int fak(int n) { return (n<2) ? n : n * fak(n-1); }

rekursive definition und sehr kurz geschrieben

kurz und knapp:

int fak(int n) { return (n<2) ? n : n * fak(n-1); }

rekursive definition und sehr kurz geschrieben

und falsch.

TheQ schrieb:

kurz und knapp:

int fak(int n) { return (n<2) ? n : n * fak(n-1); }

rekursive definition und sehr kurz geschrieben

und falsch.

wo denn?

Bashar schrieb:

TheQ schrieb:

kurz und knapp:

int fak(int n) { return (n<2) ? n : n * fak(n-1); }

rekursive definition und sehr kurz geschrieben

und falsch.

wo denn?

Gib mal 0 ein.

int fak(int n) { return (n==0) ? 1 : n * fak(n-1); }

// 1. Variante
unsigned fak(unsigned n) { return n?n*fak(n-1):1; }
// 2. Variante
int fak(int n) { return n<2?1:n*fak(n-1); } // 1 bei -1 ist zwar komisch, aber verständlich

int i;
std::cin >> i;
std::cout << fakultaet<i>() << std::endl;

Da verwende ich doch lieber Boost, weil für vordefinierte Werte Fakultäten vom Compiler berechnen zu lassen ist doch eher unüblich (und ausserdem musst du die Funktion sehr oft aufrufen, um die dafür zusätzlich benötigte Compilezeit wieder reinzuholen).

Sieht zwar weniger schick aus, aber lasst das mal gegen die Rekursionsfunktion rennen.

edit: <= natürlich. Alte Gewohnheit

int fak(unsigned n)
{
  unsigned result=1;
  for (unsigned i=1; i<=n; ++n) result*=i;
  return result;
}

Sieht zwar weniger schick aus, aber lasst das mal gegen die Rekursionsfunktion rennen.

edit: <= natürlich. Alte Gewohnheit

Ist aber immernoch falsch

x>(2^13) kommt doch so oder so ein überlauf,... da beschwer ich mich doch nicht über die performance,... geschweige das das double noch net mal darstellen kann,..

greetz

Ist aber immernoch falsch

template<typename Type>
Type Facul(Type x) {
	if(x<0) return 0;
	Type f=1;
	while(x>1) f*=x--;
	return(f);
}

So kann's aussehen. Von rekursiven Aufrufen kann ich nur abraten, bei solchen Spielfunktonen noch akzeptabel, ist bei einigen anderen Algorithmen wie z.B. Floodfill nicht angebracht.