fakultät berechnen ...



  • also ich hab das mal ausgetestet. mit einem 32bit langen unsigned int kommt man bis zu 12! bei einem 64bit unsigned long long (gcc) kommt man bis 20!
    da kann man also problemlos eine tabelle benutzen. für grössere zahlen braucht man sowieso eine eigene library wie GMP und die hat dann ihre eigenen, optimierten algorithmen.

    d.h. ich würd sowas vorschlagen:

    unsigned long long faculty(int n)
    {
       static const unsigned long long tab[] = {1, 1, 2, 6, 24, 120, 720, 5040,
       40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 
       1307674368000, 20922789888000, 355687428096000, 6402373705728000,
       121645100408832000, 2432902008176640000};
       if(n>=0 && n<21)
          return tab[n];
       else
          return 0;
    }
    

    natürlich vorausgesetzt der compiler kennt einen entsprechenden 64bit datentyp. das "long long" müsste man gegebenenfalls ersetzen.



  • Wie wärs hiermit?...

    #include <stdio.h>
    
    float fakultaet(float x);
    int main(){
    float y=0,x;
    printf("\n\t\Geben Sie eine Zahl ein:");
    scanf("%f",&x);
    y=fakultaet(x);
    if (y>999999.9)
    printf("\n\t\fakultaet(%8.1f) = %e",x,y);
    else
    printf("\n\t\fakultaet(%8.1f) = %8.1f",x,y);
    }
    float fakultaet (float x);
    float ergebnis=0;
    if (x<=1)
    ergebnis =1;
    else
    ergebnis =x*fakultaet(x-1);
    return ergebnis;
    


  • das ist die bereits besprochene rekursion 🙄



  • Ist zwar ein etwas älteres Thema, aber so kann man das ja nicht stehen lassen!
    Wer die Faktultät "richtig" berechen will, der sollte mal nach
    "Boiten Split", "Recursive Product" oder auch Primfaktorzerlegung
    googeln.

    Jockel



  • const double fac(double n)
    {
      return sqrt(6.283185307 * n) * pow(n / 2.718281828, n);
    }
    


  • Noch eine unnötige Methode 😉

    template<unsigned int N> struct Fak    { enum { V=N*Fak<N-1>::V  }; };
    template<>               struct Fak<0> { enum { V=1 };              };
    
    static const unsigned fak[] = { Fak<0>::V, Fak<1>::V, Fak<2>::V, Fak<3>::V,
                                    Fak<4>::V, Fak<5>::V, Fak<6>::V, Fak<7>::V,
                                    Fak<8>::V, Fak<9>::V, Fak<10>::V, Fak<11>::V,
                                    Fak<12>::V };
    


  • Wahnsinn! Da kann man ja gleich ne Bruchrechenklasse mit Templateargumenten bauen 😉 .



  • #include <stdio.h>

    int main(void)
    {
    int i,n,p=1;
    printf("Fakulteat n!( n<17, sonst Ueberlauf!)\n");
    printf("n= ");
    scanf("%d",&n);

    for(i=1;i<=n;i++)
    {
    p*=i;
    }

    printf("Fuer %d! bekommt man %d\n",n,p);
    }



  • Schleifendurchläufe: ich habe als test für n gleich 5 genommen.

    1. p=1 i=1

    (p *= i heisst ja auch p = p * i)
    also p = 1 * 1
    p = 1

    1 * 2 = 2 // p = 1, i = 2
    p = 2

    2 * 3 = 6 // p = 2, i = 3
    p = 6

    4. 6 * 4 = 24 // p = 6, i = 4
    p = 24

    5. 24 * 5 = 120 // p = 24, i = 5
    p = 120

    ...

    5! = 120 🙂



  • gut, das DU kein spasst bis! 😡 😡 😡



  • was hast du für ein problem?



  • Naja, die Lösung war jetzt nicht sooo innovativ... Dass man ne einfache Schleife machen kann war ja klar. Man kann wenn man will auch ne Rekursion machen (noch schlechter, da ziemlich anfällig für einen stack overflow), aber ne gute Performance hat beides im Gegensatz zu den numerischen Lösungen nicht.


Anmelden zum Antworten