Kody źródłowe/Silnia
C edytuj
Poniższy krótki program napisany w języku C oblicza dokładnie wartości silni. Została przy jego pomocy wygenerowana tablica umieszczona niżej. Zwyczajne mnożenie liczb typu int nie mogło być zastosowane, gdyż wartości silni wielokrotnie przekraczają górne ograniczenie tego typu. Zwyczajne mnożenie liczb rzeczywistych nie mogło być zastosowane, gdyż wprowadzałoby niedokładność.
#include <stdio.h>
int main(void)
{
int cyfry[1000] = { 1 };
int n, p, w, liczba;
printf("Podaj maksymalna podstawe silni\n");
scanf("%d", &liczba);
printf("<table border=\"1\"><tr><th align=\"right\">n</th>"
"<th align=\"left\">n!</th></tr>\n");
for (n=1; n<=liczba; n++) {
printf("<tr><td align=\"right\">%2d</td><td>",n-1);
for (p=999; !cyfry[p]; p--)
/* NIC */;
while (p>=0)
printf("%c",'0'+cyfry[p--]);
printf("</td></tr>\n");
for (w=0, p=0; p<1000; p++) {
w += n*cyfry[p];
cyfry[p] = w % 10;
w /= 10;
}
}
printf("</table>");
return 0;
}
Po uruchomieniu program generuje tablicę zawierającą kolejne wartości silni.
C++ edytuj
Przykłady wymagają nagłówka inttype.h
Rekurencyjnie edytuj
inline uint64_t silnia(unsigned int n) // wersja rekurencyjna
{
return (n < 1) ? 1 : n * silnia(n-1);
}
Iteracyjnie edytuj
inline uint64_t silnia(unsigned int n) {
uint64_t ret = 1;
do {
ret *= n;
} while (--n);
return ret;
}
Metaprogramowanie edytuj
template <unsigned int num>
struct Silnia {
static const uint64_t value = num * Silnia<num - 1>::value;
};
template <>
struct Silnia<0> {
static const int value = 1;
};
template <>
struct Silnia<1> {
static const int value = 1;
};
PHP edytuj
Rekurencyjnie edytuj
function silnia($n) {
return ($n < 1) ? 1 : $n * silnia($n-1);
}
Iteracyjnie edytuj
function silnia2($n) {
$ret = 1;
if($n == 0) return $ret;
do {
$ret *= $n;
} while (--$n);
return $ret;
}
D edytuj
Rekurencyjnie edytuj
ulong silnia(uint n) {
return n < 2 ? 1 : n * silnia(n - 1);
}
Iteracyjnie edytuj
ulong silnia(uint n) {
ulong ret = 1;
do {
ret *= n;
} while (--n);
return ret;
}
Metaprogramowanie edytuj
template Silnia(uint n) {
static if (n < 2)
const Silnia = 1;
else
const Silnia = n * Silnia!(n - 1);
}
Pascal edytuj
program silnia;
var
a:integer;
i:byte;
n:longint;
begin
repeat
writeln('Podaj podstawe silni');
readln(a);
until (a >= 0);
n:=1;
for i:=1 to a do n:=n*i;
writeln('Wynik to:',n);
readln;
end.
Common Lisp edytuj
(defun silnia(n)
(if (<= n 1)
1
(* n (silnia (- n 1)))))
Emacs Lisp edytuj
(defun silnia(n)
(apply '* (number-sequence 1 n)))
Clojure edytuj
(defn silnia [n]
(reduce *' (range 1 (inc n))))
Python edytuj
Rekurencyjnie edytuj
def silnia(n):
if n> 1:
return n * silnia(n-1)
elif n in (0,1):
return 1
Funkcjonalnie edytuj
import operator
def silnia(n):
return reduce(operator.mul, range(1, n+1)) if n>1 else 1
Iteracyjnie edytuj
def silnia(n):
if n<2:
return 1
else:
for i in range(2,n):
n*=i
return n
Ruby edytuj
Rekurencyjnie edytuj
def silnia(n)
n < 2 ? 1 : n * silnia(n-1)
end
Funkcyjnie edytuj
def silnia(n)
(1..n).inject(&:*)
end
Iteracyjnie edytuj
def silnia(n)
ret = 1
while n > 0
ret *= n
n -= 1
end
end
Java edytuj
import java.math.BigInteger;
public class Silnia {
public static void main (String[] arg) {
BigInteger silnia = BigInteger.ONE;
BigInteger n = new BigInteger(arg[0]); //Konwersja podanego argumentu do liczby całkowitej
while (n.compareTo(BigInteger.ONE)>0) {
silnia = silnia.multiply(n);
n = n.subtract(BigInteger.ONE);
}
System.out.print(silnia.toString());
}
}
Aby policzyć wartość na przykład 1000! piszemy w linii poleceń: java Silnia 1000
Haskell edytuj
import System(getArgs)
fact :: Integer -> Integer
fact n = product [1..n]
main = do args <- getArgs
mapM (\x -> print $ fact (read x::Integer)) args
Wyżej wymieniony kod podaje wartości dla wszystkich liczb podanych jako argumenty programu.