import Foundation
func forFak(n: Int) -> Int {
/* In dieser Funktion wird die Fakultät mithilfe einer for-Schleife
iterativ ermittelt. */
/* Als Variable für das Ergebnis wird die Variable fak deklariert und ihr
wird der Wert 1 zugewiesen. */
var fak : Int
fak = 1
/* Die Variable i wird in der for Schleife verwendet und beginnt dort mit
dem Wert 1. Bei jedem Durchlauf der Schleife erhöht sich der Wert
von i um eins. */
var i : Int
for i in 1 ... n {
/* Solange der Wert von i kleiner als der Wert von n ist, wobei n die
Zahl, von der die Fakultät gebildet werden soll, wird die
Multiplikation fak * i durchgeführt und das Ergebnis in der
Variablen fak gespeichert. */
fak = fak * i
}
return fak
}
func recFak(n: Int) -> Int {
/* Mit dieser Funktion wird die Fakultät rekursiv berechnet. Als Variable
für das Ergebnis wird die Variable fak deklariert und ihr wird der
Wert 1 zugewiesen. */
var fak : Int
fak = 1
/* In der Fallunterscheidung wird geprüft, ob n den Wert null. Im Fall, dass
n ungleich null ist, wird die Multiplikation n * RecFak(n-1) durchgeführt
und das Ergebnis in der Variable fak gespeichert. */
if n == 0 {
} else {
fak = n * recFak(n: Int(n - 1))
}
return fak
}
func whileFak(n: Int) -> Int {
/* In dieser Funktion wird die Fakultät mithilfe einer while-Schleife
iterativ ermittelt. Als Variable für das Ergebnis wird die Variable fak
deklariert und ihr wird der Wert 1 zugewiesen. */
var fak : Int
fak = 1
/* Die Variable i wird in der while Schleife verwendet und beginnt dort
mit dem Wert 1. */
var i : Int
i = 1
while i <= n {
/* Solange der Wert von i kleiner als der Wert von n ist, wird die
Multiplikation fak * i durchgeführt und das Ergebnis in der
Variablen fak gespeichert. */
fak = fak * i
/* Bei jedem Durchlauf der Schleife erhöht sich der Wert von i um eins,
solange i kleiner gleich n ist. */
i = i + 1
}
return fak
}
/* Main
Für die Zahl, für die Fakultät berechnet werden soll, wird die
Variable n deklariert. */
var n : Int
// Für das (spätere) Ergebnis wird die Variable fak deklariert.
var fak : Int
/* Dann erfolgt die Abfrage der Zahl. Die Zahl, die eingegeben wird, wird der
Variablen n als Wert zugewiesen. */
print("Geben Sie die Zahl ein für die die Fakultät berechnet werden soll: ")
n = Int(readLine()!)!
/* Da Fakultäten sehr schnell anwachsen, das bedeutet, dass das Ergebnis sehr
schnell sehr groß werden, wird in diesem Programm die Größe der eingegebenen
Zahl auf 20 begrenzt. In der while-Schleife wird geprüft, ob die eingegebene
Zahl größer als 20 ist, und falls ja, wird der Benutzer zur Eingabe einer neuen
Zahl aufgefordert. Zudem wird geprüft, ob die Zahl kleiner als null ist, da
Fakultäten nur für ganze positive Zahlen definiert sind, und wenn ja, wird der
Benutzer ebenfalls darauf hingewiesen und zur Eingabe einer neuen Zahl
aufgefordert. */
while n > 20 || n < 0 {
print("Das Programm kann nur Zahlen bis 20 verarbeiten, bitte geben Sie eine ganze positive Zahl, die kleiner gleich 20 und größer als 0 ist ein:")
n = Int(readLine()!)!
}
/* Die Fakultät kann auf verschiedene Weise berechnet werden. In diesem Programm
wird die Fakultät auf drei verschiedene Arten berechnet. Mittels einer
for-Schleife und einer while-Schleife wird sie iterativ berechnet und als
Drittes wird sie mittels einer rekursiven Funktion berechnet. */
fak = forFak(n: n)
print(fak)
fak = whileFak(n: n)
print(fak)
fak = recFak(n: n)
print(fak)