Kody źródłowe/Silnia

Z Wikibooks, biblioteki wolnych podręczników.
Przejdź do nawigacji Przejdź do wyszukiwania
Silnia
Kod źródłowy
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.