# Fakultät im Java Pseudocode berechnen



## MSshady (27. Oktober 2002)

also ich möchte in Java, (Aber erstmal nur in einem Pseudocode) die Fakultät von n berechnen lasse, habe da auch schon ne idee


```
Algorithmus fakultaet(n)
	input:  (n)
	output: fakultät (n)
	if n<0 then return ("n muss  sein")
	n!:=n*(n-1)*(n-2)
	return(n!)
```

aber so ganz funktioniert das ja net, das müsste man doch eigentlich mit ner schleife machen oder?

Wenn jemand vorschläge hat immer her damit


----------



## Robert Martinu (27. Oktober 2002)

Vielleicht umgefähr so:


```
Ergebnis=n;

while (n!=0)
{
n--;
Ergebnis=Ergebnis*n;
}
```


----------



## MSshady (27. Oktober 2002)

habe noch nicht viel ahnung von java und programmieren allgemein, aber fehlt da nicht noch irgendwie ne count variable?
Oder verstehe ich da grad was nicht?


----------



## Robert Martinu (27. Oktober 2002)

Nein, eine Variable wird sowieso bei jedem Schleifendurchlauf monoton verändert - nimm einfach die zum Zählen.

(Allerdings solltest du den Code so nicht in etwaigen Hausübungen verwenden - da ist nämlich ein kleiner Bug drinnen, der dir beim Ausprobieren im Debugger sicher ins Auge fallen wird, siehs als Inspiration )


----------



## MSshady (27. Oktober 2002)

Hm..., könntest du deinen code noch kommentieren? 

Ergebnis=n;

while (n!=0)  bedeutet das, dass wenn n!=0 ist das er dann das da in dem block machen soll? (aber n! ist doch net null wenn n einen wert hat oder?
{
n--; <-- heißt denke ich mal das er von n immer eins abziehen soll
Ergebnis=Ergebnis*n; bedeutet, dass er der variablen ergebnis den wert ergebnis*n zuordnen soll gell?
}


----------



## Robert Martinu (27. Oktober 2002)

while (n!=0)
solange n ungleich 0 (!= bedeutet ungleich, == gleich und = ist im Gegensatz dazu eine Zuweisung)

Ansonsten richtig.
n-- nennt sich Dekrement und verringert um eins (n++, seines Zeichens Inkrement, macht das Gegenteil)


----------



## MSshady (27. Oktober 2002)

Ja stimmt, != bedeutet ungleich, war grad auf dem falschen dampfer wegen fakultät und so *g* . Danke nochmal


dann fehlt da doch im prinzip nur noch, dass wenn n=0 ist, dass er dann nochmal *(n-1) rechnen soll oder?

weil die formel aus dem TW ist ja fakultät von n=1*2*3*...*(n-1)*n
aber ich will das ja dann so mache fakultät von n=n*(n-1)*(n-1), ach so ne dann fehlt das nicht  fällt mir grad auf, weil macht der ja automatisch, aber er müsste am anfang ja mit sich selbst multiplizieren also mit der zahl n (von der eingabe) oder macht er das sowie so?


----------



## Thomas Darimont (15. August 2003)

Servus!

Aus der rekursiven Definition der Fakultät:

n! = { 1, falls n = 0; n*(n-1)! , sonst);

-->

public int fakult (int n){
    if (n == 0) return 1;
    else return n * fakult(n-1);
}

Gruß Tom


----------



## chibisuke (10. September 2003)

sag mal hast du des öfteren mit lisp zu tun? weil da arbeitet man mit rekursiven aufrufen..

im ernst... also rekursion is dafür wohl ziemlich unangebracht, wenn du das mit beispielsweise 500 machst, hast du nen overhead von mehr als 16KB das is inakzeptabel für so eine miniatur funktion...

das selbe aber im speichermanipukations model hatt einen overhead von 16Byte... fehlt also n faktor 1024...

nun also ich wprde es so schreiben:


```
public int fakult(int nr) {
   for (int i = nr;i > 0; i--) {
         nr *= i;
    }
    return 0;
}
```


----------



## Thomas Darimont (10. September 2003)

Servus



> im ernst... also rekursion is dafür wohl ziemlich unangebracht



...hast recht, ist langsam, spiegelt aber die rekursive Definition der Fakultät in der Mathematik wieder.

Gruß Tom


----------



## Peter Bönnen (11. September 2003)

Naja, ich glaube über Overhead braucht man sich gar nicht groß auslassen, wenn man bedenkt, dass ein int  ohnehin schon bei Fakultät 13 überläuft... 

Peter


----------

