我想看看你能想出的所有不同方法，用于阶乘子例程或程序。希望任何人都可以来这里看看他们是否想学习一门新语言。
基本上我想看一个例子，写一个算法的不同方式，以及它们在不同语言中的样子。
请限制为每个条目一个示例。如果您试图突出一种特定的风格、语言或只是一个适合发表在一篇文章中的深思熟虑的想法，我将允许您在每个答案中提供多个示例。
唯一真正的要求是它必须在所有表示的语言中找到给定参数的阶乘。
# 语言名称：可选样式类型
- 可选的要点
代码在这里
其他信息文本在这里
我偶尔会继续编辑任何格式不正确的答案。
所以，我写了一个多语种语言，它使用我经常使用的三种语言，以及我对这个问题的另一个答案和我今天刚学的一种语言。它是一个独立的程序，它读取包含非负整数的单行并打印包含其阶乘的单行。Bignums 用于所有语言，因此最大可计算阶乘仅取决于您的计算机资源。
perl FILENAME。runhugs FILENAME或您最喜欢的编译器的等价物运行。g++ -lgmpxx -lgmp -x c++ FILENAME链接到正确的库。编译后运行./a.out。或者使用你最喜欢的编译器的等价物。bf < FILENAME > EXECUTABLE. 使输出可执行并运行它。或者使用你最喜欢的发行版。wspace FILENAME。编辑：添加空白作为第五种语言。顺便说一句，不要用标签包装代码<code>；它打破了空白。此外，固定宽度的代码看起来要好得多。
char //# b=0+0{- |0*/; #>>>>,---------[>>>>,--------
#define a/*#--]>>>>++<<<<<<<<[>++++++[<------>-]<-<<<
#Perl ><><><> <> <> <<]>>>>[[>>+<<-]>>[<<+>+>-]<->
#C++ --><><> <><><>< > < > < +<[>>>>+<<<-<[-]]>[-]
#Haskell >>]>[-<<<<<[<<<<]>>>>[[>>+<<-]>>[<<+>+>-]>>]
#空格>>>>[-[>+<-]+>>>>]<<<<[<<<<]<<<<[<<<<
#brainf*ck > < ]>>>>>[>>>[>>>>]>>>>[>>>>]<<<<[[>>>>*/
经验; ;//;#+<<<<-]<<<<]>>>>+<<<<<<<[<<<<][.POLYGLOT^5.
#include <gmpxx.h>//]>>>>-[>>>[>>>>]>>>>[>>>>]<<<<[>>
#define eval int main()//>+<<<-]>>>[<<<+>>+>->
#include <iostream>//<]<-[>>+<<[-]]<<[<<<<]>>>>[>[>>>
#define print std::cout << // > <+<-]>[<<+>+>-]<<[>>>
#define z std::cin>>//<< +<<<-]>>>[<<<+>>+>-]<->+++++
#define c/*++++[-<[-[>>>>+<<<<-]]>>>>[<<<<+>>>>-]<<*/
#define abs int $n //>< <]<[>>+<<<<[-]>>[<<+>>-]]>>]<
#define uc mpz_class fact(int $n){/*<<<[<<<<]<<<[<<
使用 bignum;sub#<<]>>>>-]>>>>]>>>[>[-]>>>]<<<<[>>+<<-]
z{$_[0+0]=readline(*STDIN);}sub fact{my($n)=shift;#>>
#[<<+>+>-]<->+<[>-<[-]]>[-<<-<<<<[>>+<<-]>>[<<+>+> +*/
uc;if($n==0){return 1;}return $n*fact($n-1); }//;#
eval{abs;z($n);print fact($n);print("\n")/*2;};#-]<->
'+<[>-<[-]]>]<<[<<<<]<<<<-[>>+<<-]>>[<<+>+>-]+<[>- +++
-}-- <[-]]>[-<<++++++++++<<<<-[>>+<<-]>>[<<+>+>-++
事实 0 = 1 -- ><><><>< > <><>< ]+<[>-<[-]]>]<<[<<+
事实 n=n*fact(n-1){-<<]>>>>[[>>+<<-]>>[<<+>++>+-}
main=do{n<-readLn;print(fact n)}-- +>-]<->+<[>>>>+<<+
{-x<-<[-]]>[-]>>]>]>>>[>>>>]<<<<[>+++++++[<+++++++ >-]
<--.<<<<]+written+by+++A+Rex+++2009+.';#+++x-}--x*/;}
对不起，我无法抗拒xD
HAI
CAN HAS STDIO?
I HAS A VAR
I HAS A INT
I HAS A CHEEZBURGER
I HAS A FACTORIALNUM
IM IN YR LOOP
UP VAR!!1
TIEMZD INT!![CHEEZBURGER]
UP FACTORIALNUM!!1
IZ VAR BIGGER THAN FACTORIALNUM? GTFO
IM OUTTA YR LOOP
U SEEZ INT
KTHXBYE
使用经典的枚举 hack。
template<unsigned int n>
struct factorial {
enum { result = n * factorial<n - 1>::result };
};
template<>
struct factorial<0> {
enum { result = 1 };
};
用法。
const unsigned int x = factorial<4>::result;
阶乘在编译时根据模板参数 n 完全计算。因此，一旦编译器完成工作，factorial<4>::result 就是一个常量。
. . . . . . . . . . . . . . . . . . . . . . . . . .
很难让它在这里正确显示，但现在我尝试从预览中复制它并且它可以工作。您需要输入数字并按回车键。
C# 查找：
没有什么可计算的，只是看看它。要扩展它，请在表中添加另外 8 个数字，并且 64 位整数已达到极限。除此之外，还需要一个 BigNum 类。
public static int Factorial(int f)
{
if (f<0 || f>12)
{
throw new ArgumentException("Out of range for integer factorial");
}
int [] fact={1,1,2,6,24,120,720,5040,40320,362880,3628800,
39916800,479001600};
return fact[f];
}
您的纯函数式编程噩梦成真！
唯一具有以下功能的深奥图灵完备编程语言：
这是所有括号中的阶乘代码：
K(SII(S(K(S(S(KS)(S(K(S(KS)))(S(K(S(KK)))(S(K(S(K(S(K(S(K(S(SI(K(S(K(S(S(KS)K)I))
(S(S(KS)K)(SII(S(S(KS)K)I))))))))K))))))(S(K(S(K(S(SI(K(S(K(S(SI(K(S(K(S(S(KS)K)I))
(S(S(KS)K)(SII(S(S(KS)K)I))(S(S(KS)K))(S(SII)I(S(S(KS)K)I))))))))K)))))))
(S(S(KS)K)(K(S(S(KS)K)))))))))(K(S(K(S(S(KS)K)))K))))(SII))II)
特征：
如果您有兴趣尝试理解它，这里是通过 Lazier 编译器运行的 Scheme 源代码：
(lazy-def '(fac input)
'((Y (lambda (f n a) ((lambda (b) ((cons 10) ((b (cons 42)) (f (1+ n) b))))
(* a n)))) 1 1))
（对于 Y、cons、1、10、42、1+ 和 * 的合适定义）。
编辑：
（10KB 的乱码，否则我会粘贴它）。例如，在 Unix 提示符下：
$回声“4”| ./lazy facdec.lazy
24
$回声“5”| ./lazy facdec.lazy
120
对于上面的数字，比如 5，相当慢。
代码有点臃肿，因为我们必须包含所有我们自己的原语的库代码（用Hazy编写的代码，一个 lambda 演算解释器和用 Haskell 编写的 LC-to-Lazy K 编译器）。
输入文件factorial.xml：
<?xml version="1.0"?>
<?xml-stylesheet href="factorial.xsl" type="text/xsl" ?>
<n>
20
</n>
XSLT 文件factorial.xsl：
<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:msxsl="urn:schemas-microsoft-com:xslt" >
<xsl:output method="text"/>
<!-- 0! = 1 -->
<xsl:template match="text()[. = 0]">
1
</xsl:template>
<!-- n! = (n-1)! * n-->
<xsl:template match="text()[. > 0]">
<xsl:variable name="x">
<xsl:apply-templates select="msxsl:node-set( . - 1 )/text()"/>
</xsl:variable>
<xsl:value-of select="$x * ."/>
</xsl:template>
<!-- Calculate n! -->
<xsl:template match="/n">
<xsl:apply-templates select="text()"/>
</xsl:template>
</xsl:stylesheet>
将两个文件保存在同一目录中，并在 IE 中打开factorial.xml 。
factorial = lambda n: reduce(lambda x,y: x*y, range(1, n+1), 1)
笔记：
print factorial(100)
93326215443944152681699238856266700490715968264381621468592963895217599993229915\
608941463976156518286253697920827223758251185210916864000000000000000000000000
×/⍳X
或者使用内置运算符：
!X
来源：http ://www.webber-labs.com/mpl/lectures/ppt-slides/01.ppt
您可以从 C 调用它（仅在 linux amd64 上使用 GCC 测试）。组装是用 nasm 组装的。
section .text
global factorial
; factorial in x86-64 - n is passed in via RDI register
; takes a 64-bit unsigned integer
; returns a 64-bit unsigned integer in RAX register
; C declaration in GCC:
; extern unsigned long long factorial(unsigned long long n);
factorial:
enter 0,0
; n is placed in rdi by caller
mov rax, 1 ; factorial = 1
mov rcx, 2 ; i = 2
loopstart:
cmp rcx, rdi
ja loopend
mul rcx ; factorial *= i
inc rcx
jmp loopstart
loopend:
leave
ret
（它让你想起了 COBOL，因为它是用来写文字冒险的；比例字体是故意的）：
决定什么数是 (n - a number) 的阶乘：
如果 n 为零，则选择 1；
否则决定 (n 减一) 乘以 n 的阶乘。
如果你想从游戏中实际调用这个函数（“短语”），你需要定义一个动作和语法规则：
《阶乘游戏》【这一定是出处的第一行】
有一个房间。[必须至少有一个！]
因子分解是应用于数字的操作。
将“阶乘[一个数字]”理解为阶乘。
进行阶乘：
设n为所理解数的阶乘；
说“它是 [n]”。
哈斯克尔：
ones = 1 : ones
integers = head ones : zipWith (+) integers (tail ones)
factorials = head integers : zipWith (*) factorials (tail integers)
public static int factorial(int n)
{
return (Enumerable.Range(1, n).Aggregate(1, (previous, value) => previous * value));
}
fac(0) -> 1;
fac(N) when N > 0 -> fac(N, 1).
fac(1, R) -> R;
fac(N, R) -> fac(N - 1, R * N).
+++++
>+<[[->>>>+<<<<]>>>>[-<<<<+>>+>>]<<<<>[->>+<<]<>>>[-<[->>+<<]>>[-<<+<+>>>]<]<[-]><<<-]
迈克尔·雷岑斯坦 (Michael Reitzenstein) 撰写。
10 HOME
20 INPUT N
30 LET ANS = 1
40 FOR I = 1 TO N
50 ANS = ANS * I
60 NEXT I
70 PRINT ANS
let rec fact x =
if x < 0 then failwith "Invalid value."
elif x = 0 then 1
else x * fact (x - 1)
let fact x = [1 .. x] |> List.fold_left ( * ) 1
批次（新台币）：
@echo off
set n=%1
set result=1
for /l %%i in (%n%, -1, 1) do (
set /a result=result * %%i
)
echo %result%
用法：C:>factorial.bat 15
fac(0,1).
fac(N,X) :- N1 is N -1, fac(N1, T), X is N * T.
fac(0,N,N).
fac(X,N,T) :- A is N * X, X1 is X - 1, fac(X1,A,T).
fac(N,T) :- fac(N,1,T).
(factorial=Hash.new{|h,k|k*h[k-1]})[1]=1
用法：
factorial[5]
=> 120
方案
这是一个简单的递归定义：
(define (factorial x)
(if (= x 0) 1
(* x (factorial (- x 1)))))
在 Scheme 中，尾递归函数使用常量堆栈空间。这是尾递归的阶乘版本：
(define factorial
(letrec ((fact (lambda (x accum)
(if (= x 0) accum
(fact (- x 1) (* accum x))))))
(lambda (x)
(fact x 1))))
template factorial(int n : 1)
{
const factorial = 1;
}
template factorial(int n)
{
const factorial =
n * factorial!(n-1);
}
或者
template factorial(int n)
{
static if(n == 1)
const factorial = 1;
else
const factorial =
n * factorial!(n-1);
}
像这样使用：
factorial!(5)
奇怪的例子？使用 gamma 函数怎么样！由于，Gamma n = (n-1)!.
let rec gamma z =
let pi = 4.0 *. atan 1.0 in
if z < 0.5 then
pi /. ((sin (pi*.z)) *. (gamma (1.0 -. z)))
else
let consts = [| 0.99999999999980993; 676.5203681218851; -1259.1392167224028;
771.32342877765313; -176.61502916214059; 12.507343278686905;
-0.13857109526572012; 9.9843695780195716e-6; 1.5056327351493116e-7;
|]
in
let z = z -. 1.0 in
let results = Array.fold_right
(fun x y -> x +. y)
(Array.mapi
(fun i x -> if i = 0 then x else x /. (z+.(float i)))
consts
)
0.0
in
let x = z +. (float (Array.length consts)) -. 1.5 in
let final = (sqrt (2.0*.pi)) *.
(x ** (z+.0.5)) *.
(exp (-.x)) *. result
in
final
let factorial_gamma n = int_of_float (gamma (float (n+1)))
大一 Haskell 程序员
fac n = if n == 0
then 1
else n * fac (n-1)
麻省理工学院的二年级 Haskell 程序员（大一时学习了 Scheme）
fac = (\(n) ->
(if ((==) n 0)
then 1
else ((*) n (fac ((-) n 1)))))
初级 Haskell 程序员（Peano 初学者）
fac 0 = 1
fac (n+1) = (n+1) * fac n
另一位初级 Haskell 程序员（读到 n+k 模式是“Haskell 中令人作呕的部分”[1] 并加入了“禁止 n+k 模式”运动 [2]）
fac 0 = 1
fac n = n * fac (n-1)
高级 Haskell 程序员（投票给尼克松·布坎南·布什——“偏右”）
fac n = foldr (*) 1 [1..n]
另一位 Haskell 高级程序员（投票给 McGovern Biafra Nader——“偏左”）
fac n = foldl (*) 1 [1..n]
又一位高级 Haskell 程序员（靠得很靠右，他又回到了左边！）
-- using foldr to simulate foldl
fac n = foldr (\x g n -> g (x*n)) id [1..n] 1
记忆 Haskell 程序员（每天服用银杏叶）
facs = scanl (*) 1 [1..]
fac n = facs !! n
Pointless (ahem) “Points-free” Haskell 程序员（在牛津学习）
fac = foldr (*) 1 . enumFromTo 1
迭代 Haskell 程序员（前 Pascal 程序员）
fac n = result (for init next done)
where init = (0,1)
next (i,m) = (i+1, m * (i+1))
done (i,_) = i==n
result (_,m) = m
for i n d = until d n i
迭代单行 Haskell 程序员（前 APL 和 C 程序员）
fac n = snd (until ((>n) . fst) (\(i,m) -> (i+1, i*m)) (1,1))
积累Haskell程序员（建立一个快速的高潮）
facAcc a 0 = a
facAcc a n = facAcc (n*a) (n-1)
fac = facAcc 1
续传 Haskell 程序员（早年养 RABBITS，后移居新泽西）
facCps k 0 = k 1
facCps k n = facCps (k . (n *)) (n-1)
fac = facCps id
童子军 Haskell 程序员（喜欢打结；总是“虔诚”，他属于最小定点教会 [8]）
y f = f (y f)
fac = y (\f n -> if (n==0) then 1 else n * f (n-1))
组合 Haskell 程序员（避开变量，如果不是混淆的话；所有这些柯里化只是一个阶段，尽管它很少阻碍）
s f g x = f x (g x)
k x y = x
b f g x = f (g x)
c f g x = f x g
y f = f (y f)
cond p f g x = if p x then f x else g x
fac = y (b (cond ((==) 0) (k 1)) (b (s (*)) (c b pred)))
列表编码 Haskell 程序员（喜欢一元计数）
arb = () -- "undefined" is also a good RHS, as is "arb" :)
listenc n = replicate n arb
listprj f = length . f . listenc
listprod xs ys = [ i (x,y) | x<-xs, y<-ys ]
where i _ = arb
facl [] = listenc 1
facl n@(_:pred) = listprod n (facl pred)
fac = listprj facl
解释型 Haskell 程序员（从未“遇到过他不喜欢的语言”）
-- a dynamically-typed term language
data Term = Occ Var
| Use Prim
| Lit Integer
| App Term Term
| Abs Var Term
| Rec Var Term
type Var = String
type Prim = String
-- a domain of values, including functions
data Value = Num Integer
| Bool Bool
| Fun (Value -> Value)
instance Show Value where
show (Num n) = show n
show (Bool b) = show b
show (Fun _) = ""
prjFun (Fun f) = f
prjFun _ = error "bad function value"
prjNum (Num n) = n
prjNum _ = error "bad numeric value"
prjBool (Bool b) = b
prjBool _ = error "bad boolean value"
binOp inj f = Fun (\i -> (Fun (\j -> inj (f (prjNum i) (prjNum j)))))
-- environments mapping variables to values
type Env = [(Var, Value)]
getval x env = case lookup x env of
Just v -> v
Nothing -> error ("no value for " ++ x)
-- an environment-based evaluation function
eval env (Occ x) = getval x env
eval env (Use c) = getval c prims
eval env (Lit k) = Num k
eval env (App m n) = prjFun (eval env m) (eval env n)
eval env (Abs x m) = Fun (\v -> eval ((x,v) : env) m)
eval env (Rec x m) = f where f = eval ((x,f) : env) m
-- a (fixed) "environment" of language primitives
times = binOp Num (*)
minus = binOp Num (-)
equal = binOp Bool (==)
cond = Fun (\b -> Fun (\x -> Fun (\y -> if (prjBool b) then x else y)))
prims = [ ("*", times), ("-", minus), ("==", equal), ("if", cond) ]
-- a term representing factorial and a "wrapper" for evaluation
facTerm = Rec "f" (Abs "n"
(App (App (App (Use "if")
(App (App (Use "==") (Occ "n")) (Lit 0))) (Lit 1))
(App (App (Use "*") (Occ "n"))
(App (Occ "f")
(App (App (Use "-") (Occ "n")) (Lit 1))))))
fac n = prjNum (eval [] (App facTerm (Lit n)))
静态 Haskell 程序员（他在课堂上做，他得到了 Fundep Jones！在 Thomas Hallgren 的“Fun with Functional Dependencies”[7] 之后）
-- static Peano constructors and numerals
data Zero
data Succ n
type One = Succ Zero
type Two = Succ One
type Three = Succ Two
type Four = Succ Three
-- dynamic representatives for static Peanos
zero = undefined :: Zero
one = undefined :: One
two = undefined :: Two
three = undefined :: Three
four = undefined :: Four
-- addition, a la Prolog
class Add a b c | a b -> c where
add :: a -> b -> c
instance Add Zero b b
instance Add a b c => Add (Succ a) b (Succ c)
-- multiplication, a la Prolog
class Mul a b c | a b -> c where
mul :: a -> b -> c
instance Mul Zero b Zero
instance (Mul a b c, Add b c d) => Mul (Succ a) b d
-- factorial, a la Prolog
class Fac a b | a -> b where
fac :: a -> b
instance Fac Zero One
instance (Fac n k, Mul (Succ n) k m) => Fac (Succ n) m
-- try, for "instance" (sorry):
--
-- :t fac four
刚毕业的 Haskell 程序员（研究生教育倾向于让一个人从琐碎的担忧中解放出来，例如，基于硬件的整数的效率）
-- the natural numbers, a la Peano
data Nat = Zero | Succ Nat
-- iteration and some applications
iter z s Zero = z
iter z s (Succ n) = s (iter z s n)
plus n = iter n Succ
mult n = iter Zero (plus n)
-- primitive recursion
primrec z s Zero = z
primrec z s (Succ n) = s n (primrec z s n)
-- two versions of factorial
fac = snd . iter (one, one) (\(a,b) -> (Succ a, mult a b))
fac' = primrec one (mult . Succ)
-- for convenience and testing (try e.g. "fac five")
int = iter 0 (1+)
instance Show Nat where
show = show . int
(zero : one : two : three : four : five : _) = iterate Succ Zero
Origamist Haskell 程序员（总是从“基本的 Bird fold”开始）
-- (curried, list) fold and an application
fold c n [] = n
fold c n (x:xs) = c x (fold c n xs)
prod = fold (*) 1
-- (curried, boolean-based, list) unfold and an application
unfold p f g x =
if p x
then []
else f x : unfold p f g (g x)
downfrom = unfold (==0) id pred
-- hylomorphisms, as-is or "unfolded" (ouch! sorry ...)
refold c n p f g = fold c n . unfold p f g
refold' c n p f g x =
if p x
then n
else c (f x) (refold' c n p f g (g x))
-- several versions of factorial, all (extensionally) equivalent
fac = prod . downfrom
fac' = refold (*) 1 (==0) id pred
fac'' = refold' (*) 1 (==0) id pred
笛卡尔倾向的 Haskell 程序员（更喜欢希腊食物，避免辛辣的印度食物；灵感来自 Lex Augusteijn 的“Sorting Morphisms”[3]）
-- (product-based, list) catamorphisms and an application
cata (n,c) [] = n
cata (n,c) (x:xs) = c (x, cata (n,c) xs)
mult = uncurry (*)
prod = cata (1, mult)
-- (co-product-based, list) anamorphisms and an application
ana f = either (const []) (cons . pair (id, ana f)) . f
cons = uncurry (:)
downfrom = ana uncount
uncount 0 = Left ()
uncount n = Right (n, n-1)
-- two variations on list hylomorphisms
hylo f g = cata g . ana f
hylo' f (n,c) = either (const n) (c . pair (id, hylo' f (c,n))) . f
pair (f,g) (x,y) = (f x, g y)
-- several versions of factorial, all (extensionally) equivalent
fac = prod . downfrom
fac' = hylo uncount (1, mult)
fac'' = hylo' uncount (1, mult)
博士 Haskell 程序员（吃了太多香蕉，眼睛都肿了，现在他需要新镜头！）
-- explicit type recursion based on functors
newtype Mu f = Mu (f (Mu f)) deriving Show
in x = Mu x
out (Mu x) = x
-- cata- and ana-morphisms, now for *arbitrary* (regular) base functors
cata phi = phi . fmap (cata phi) . out
ana psi = in . fmap (ana psi) . psi
-- base functor and data type for natural numbers,
-- using a curried elimination operator
data N b = Zero | Succ b deriving Show
instance Functor N where
fmap f = nelim Zero (Succ . f)
nelim z s Zero = z
nelim z s (Succ n) = s n
type Nat = Mu N
-- conversion to internal numbers, conveniences and applications
int = cata (nelim 0 (1+))
instance Show Nat where
show = show . int
zero = in Zero
suck = in . Succ -- pardon my "French" (Prelude conflict)
plus n = cata (nelim n suck )
mult n = cata (nelim zero (plus n))
-- base functor and data type for lists
data L a b = Nil | Cons a b deriving Show
instance Functor (L a) where
fmap f = lelim Nil (\a b -> Cons a (f b))
lelim n c Nil = n
lelim n c (Cons a b) = c a b
type List a = Mu (L a)
-- conversion to internal lists, conveniences and applications
list = cata (lelim [] (:))
instance Show a => Show (List a) where
show = show . list
prod = cata (lelim (suck zero) mult)
upto = ana (nelim Nil (diag (Cons . suck)) . out)
diag f x = f x x
fac = prod . upto
博士后 Haskell 程序员（来自 Uustalu、Vene 和 Pardo 的“Recursion Schemes from Comonads”[4]）
-- explicit type recursion with functors and catamorphisms
newtype Mu f = In (f (Mu f))
unIn (In x) = x
cata phi = phi . fmap (cata phi) . unIn
-- base functor and data type for natural numbers,
-- using locally-defined "eliminators"
data N c = Z | S c
instance Functor N where
fmap g Z = Z
fmap g (S x) = S (g x)
type Nat = Mu N
zero = In Z
suck n = In (S n)
add m = cata phi where
phi Z = m
phi (S f) = suck f
mult m = cata phi where
phi Z = zero
phi (S f) = add m f
-- explicit products and their functorial action
data Prod e c = Pair c e
outl (Pair x y) = x
outr (Pair x y) = y
fork f g x = Pair (f x) (g x)
instance Functor (Prod e) where
fmap g = fork (g . outl) outr
-- comonads, the categorical "opposite" of monads
class Functor n => Comonad n where
extr :: n a -> a
dupl :: n a -> n (n a)
instance Comonad (Prod e) where
extr = outl
dupl = fork id outr
-- generalized catamorphisms, zygomorphisms and paramorphisms
gcata :: (Functor f, Comonad n) =>
(forall a. f (n a) -> n (f a))
-> (f (n c) -> c) -> Mu f -> c
gcata dist phi = extr . cata (fmap phi . dist . fmap dupl)
zygo chi = gcata (fork (fmap outl) (chi . fmap outr))
para :: Functor f => (f (Prod (Mu f) c) -> c) -> Mu f -> c
para = zygo In
-- factorial, the *hard* way!
fac = para phi where
phi Z = suck zero
phi (S (Pair f n)) = mult f (suck n)
-- for convenience and testing
int = cata phi where
phi Z = 0
phi (S f) = 1 + f
instance Show (Mu N) where
show = show . int
终身教授（向新生教授 Haskell）
fac n = product [1..n]
电源外壳
function factorial( [int] $n )
{
$result = 1;
if ( $n -gt 1 )
{
$result = $n * ( factorial ( $n - 1 ) )
}
$result
}
这是一个单行：
$n..1 | % {$result = 1}{$result *= $_}{$result}
private static Map<BigInteger, BigInteger> _results = new HashMap()
public static BigInteger factorial(BigInteger n){
if (0 >= n.compareTo(BigInteger.ONE))
return BigInteger.ONE.max(n);
if (_results.containsKey(n))
return _results.get(n);
BigInteger result = factorial(n.subtract(BigInteger.ONE)).multiply(n);
_results.put(n, result);
return result;
}
在 bash 和递归中，但具有额外的优势，即它处理新进程中的每次迭代。它可以计算的最大值是 !20 在溢出之前，但是如果您不关心答案并希望您的系统崩溃，您仍然可以运行它以获得大数字；）
#!/bin/bash
echo $(($1 * `( [[ $1 -gt 1 ]] && ./$0 $(($1 - 1)) ) || echo 1`));
C/C++：程序化
unsigned long factorial(int n)
{
unsigned long factorial = 1;
int i;
for (i = 2; i <= n; i++)
factorial *= i;
return factorial;
}
PHP：程序
function factorial($n)
{
for ($factorial = 1, $i = 2; $i <= $n; $i++)
$factorial *= $i;
return $factorial;
}
@Niyaz：您没有为函数指定返回类型
上面大部分的问题是它们会在大约 25 处用完精度！（12！使用 32 位整数）或只是溢出。这是突破这些限制的 ac# 实现！
class Number
{
public Number ()
{
m_number = "0";
}
public Number (string value)
{
m_number = value;
}
public int this [int column]
{
get
{
return column < m_number.Length ? m_number [m_number.Length - column - 1] - '0' : 0;
}
}
public static implicit operator Number (string rhs)
{
return new Number (rhs);
}
public static bool operator == (Number lhs, Number rhs)
{
return lhs.m_number == rhs.m_number;
}
public static bool operator != (Number lhs, Number rhs)
{
return lhs.m_number != rhs.m_number;
}
public override bool Equals (object obj)
{
return this == (Number) obj;
}
public override int GetHashCode ()
{
return m_number.GetHashCode ();
}
public static Number operator + (Number lhs, Number rhs)
{
StringBuilder
result = new StringBuilder (new string ('0', lhs.m_number.Length + rhs.m_number.Length));
int
carry = 0;
for (int i = 0 ; i < result.Length ; ++i)
{
int
sum = carry + lhs [i] + rhs [i],
units = sum % 10;
carry = sum / 10;
result [result.Length - i - 1] = (char) ('0' + units);
}
return TrimLeadingZeros (result);
}
public static Number operator * (Number lhs, Number rhs)
{
StringBuilder
result = new StringBuilder (new string ('0', lhs.m_number.Length + rhs.m_number.Length));
for (int multiplier_index = rhs.m_number.Length - 1 ; multiplier_index >= 0 ; --multiplier_index)
{
int
multiplier = rhs.m_number [multiplier_index] - '0',
column = result.Length - rhs.m_number.Length + multiplier_index;
for (int i = lhs.m_number.Length - 1 ; i >= 0 ; --i, --column)
{
int
product = (lhs.m_number [i] - '0') * multiplier,
units = product % 10,
tens = product / 10,
hundreds = 0,
unit_sum = result [column] - '0' + units;
if (unit_sum > 9)
{
unit_sum -= 10;
++tens;
}
result [column] = (char) ('0' + unit_sum);
int
tens_sum = result [column - 1] - '0' + tens;
if (tens_sum > 9)
{
tens_sum -= 10;
++hundreds;
}
result [column - 1] = (char) ('0' + tens_sum);
if (hundreds > 0)
{
int
hundreds_sum = result [column - 2] - '0' + hundreds;
result [column - 2] = (char) ('0' + hundreds_sum);
}
}
}
return TrimLeadingZeros (result);
}
public override string ToString ()
{
return m_number;
}
static string TrimLeadingZeros (StringBuilder number)
{
while (number [0] == '0' && number.Length > 1)
{
number.Remove (0, 1);
}
return number.ToString ();
}
string
m_number;
}
static void Main (string [] args)
{
Number
a = new Number ("1"),
b = new Number (args [0]),
one = new Number ("1");
for (Number c = new Number ("1") ; c != b ; )
{
c = c + one;
a = a * c;
}
Console.WriteLine (string.Format ("{0}! = {1}", new object [] { b, a }));
}
FWIW：10000！长度超过 35500 个字符。
斯基兹
输入和输出是教堂数字（即自然数k是\f n. f^k n; 所以3 = \f n. f (f (f n)))
(\x. x x) (\y f. f (y y f)) (\y n. n (\x y z. z) (\x y. x) (\f n. f n) (\f. n (y (\f m. n (\g h. h (g f)) (\x. m) (\x. x)) f)))
下面的代码是开玩笑的，但是当您考虑到 uint32 的返回值限制为 n < 34 时，在我们用 uint 用完返回值的空间之前，<65 uint64，硬编码 33 个值不是疯了:)
public static int Factorial(int n)
{
switch (n)
{
case 1:
return 1;
case 2:
return 2;
case 3:
return 6;
case 4:
return 24;
default:
throw new Exception("Sorry, I can only count to 4");
}
}
红宝石：函数式
def factorial(n)
return 1 if n == 1
n * factorial(n -1)
end
procedure factorial(n)
return (0<n) * factorial(n-1) | 1
end
我已经作弊了一点，允许否定返回 1。如果你希望它在给出否定参数的情况下失败，它会稍微不那么简洁：
return (0<n) * factorial(n-1) | (n=0 & 1)
然后
write(factorial(3))
write(factorial(-1))
write(factorial(20))
印刷
6
2432902008176640000
procedure factorials()
local f,n
f := 1; n := 0
repeat suspend f *:= (n +:= 1)
end
然后
every write(factorials() \ 5)
印刷
1
2
6
24
120
要理解这一点：评估是目标导向的，失败时回溯。没有布尔类型，在其他语言中将返回布尔值的二元运算符要么失败，要么返回它们的第二个参数 - 除了 |，它在单值上下文中如果成功则返回其第一个参数，否则尝试其第二个论点。（在多值上下文中，它返回第一个参数，然后返回第二个参数）
suspend就像yield在其他语言中一样，除了没有明确调用生成器多次返回其结果。相反，
every它询问所有值的参数，但默认情况下不返回任何内容；它对副作用很有用（在本例中为 I/O）。
\限制生成器返回的值的数量，在这种情况下factorials将是无限的。
(defn fact
([n] (fact n 1))
([n acc] (if (= n 0)
acc
(recur (- n 1) (* acc n)))))
(defn fact [n] (apply * (range 1 (+ n 1))))
factorial n = product [1..n]
没有什么比bash & bc快：
function fac { seq $1 | paste -sd* | bc; }
$ fac 42
1405006117752879898543142606244511569936384000000000
$
Mathematica：使用纯递归函数
(If[#>1,# #0[#-1],1])&
function factorial (n)
if (n <= 1) then return 1 end
return n*factorial(n-1)
end
这是一个在野外捕获的堆栈溢出：
> print (factorial(234132))
stdin:3: stack overflow
stack traceback:
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
...
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
stdin:3: in function 'factorial'
stdin:1: in main chunk
[C]: ?
Agda 2：函数式，依赖类型。
data Nat = zero | suc (m::Nat)
add (m::Nat) (n::Nat) :: Nat
= case m of
(zero ) -> n
(suc p) -> suc (add p n)
mul (m::Nat) (n::Nat)::Nat
= case m of
(zero ) -> zero
(suc p) -> add n (mul p n)
factorial (n::Nat)::Nat
= case n of
(zero ) -> suc zero
(suc p) -> mul n (factorial p)
facts: array[2..12] of integer;
function TForm1.calculate(f: integer): integer;
begin
if f = 1 then
Result := f
else if f > High(facts) then
Result := High(Integer)
else if (facts[f] > 0) then
Result := facts[f]
else begin
facts[f] := f * Calculate(f-1);
Result := facts[f];
end;
end;
initialize
for i := Low(facts) to High(facts) do
facts[i] := 0;
在第一次计算出大于或等于所需值的阶乘后，该算法仅在常数时间 O(1) 内返回阶乘。
考虑到 int32 最多只能容纳 12 个！
Nemerle：功能性
def fact(n) {
| 0 => 1
| x => x * fact(x-1)
}
#Language: T-SQL
#Style: Recursive, divide and conquer
只是为了好玩 - 在 T-SQL 中使用分而治之的递归方法。是的，递归 - 在没有堆栈溢出的 SQL 中。
create function factorial(@b int=1, @e int) returns float as begin
return case when @b>=@e then @e else
convert(float,dbo.factorial(@b,convert(int,@b+(@e-@b)/2)))
* convert(float,dbo.factorial(convert(int,@b+1+(@e-@b)/2),@e)) end
end
像这样称呼它：
print dbo.factorial(1,170) -- the 1 being the starting number
/fact0 { dup 2 lt { pop } { 2 copy mul 3 1 roll 1 sub exch pop fact0 } ifelse } def
/fact { 1 exch fact0 } def
第四（递归）：
: 阶乘 ( n -- n )
重复 1 > 如果
重复 1 - 递归 *
别的
下降 1
然后
;
阶乘可以在功能上定义为：
def fact(n: Int): BigInt = 1 to n reduceLeft(_*_)
或者更传统的
def fact(n: Int): BigInt = if (n == 0) 1 else fact(n-1) * n
我们可以做！Ints 上的有效方法：
object extendBuiltins extends Application {
class Factorizer(n: Int) {
def ! = 1 to n reduceLeft(_*_)
}
implicit def int2fact(n: Int) = new Factorizer(n)
println("10! = " + (10!))
}
C++ 编译时间
template<unsigned i>
struct factorial
{ static const unsigned value = i * factorial<i-1>::value; };
template<>
struct factorial<0>
{ static const unsigned value = 1; };
在代码中用作：
Factorial<5>::value
Java Script：使用“面试问题”计数位 fnc 的创造性方法。
function nu(x)
{
var r=0
while( x ) {
x &= x-1
r++
}
return r
}
function fac(n)
{
var r= Math.pow(2,n-nu(n))
for ( var i=3 ; i <= n ; i+= 2 )
r *= Math.pow(i,Math.floor(Math.log(n/i)/Math.LN2)+1)
return r
}
最多可工作 21 个！然后 Chrome 切换到科学记数法。灵感要归功于睡眠不足和 Knuth 等人的“具体数学”。
接受一个非负整数后跟换行符作为输入，并输出相应的阶乘，后跟换行符。
>>>>,----------[>>>>,----------]>>>>++<<<<<<<<[>++++++[<----
-->-]<-<<<<]>>>>[[>>+<<-]>>[<<+>+>-]<->+<[>>>>+<<<-<[-]]>[-]
>>]>[-<<<<<[<<<<]>>>>[[>>+<<-]>>[<<+>+>-]>>]>>>>[-[>+<-]+>>>
>]<<<<[<<<<]<<<<[<<<<]>>>>>[>>>[>>>>]>>>>[>>>>]<<<<[[>>>>+<<
<<-]<<<<]>>>>+<<<<<<<[<<<<]>>>>-[>>>[>>>>]>>>>[>>>>]<<<<[>>>
+<<<-]>>>[<<<+>>+>-]<-[>>+<<[-]]<<[<<<<]>>>>[>[>+<-]>[<<+>+>
-]<<[>>>+<<<-]>>>[<<<+>>+>-]<->+++++++++[-<[-[>>>>+<<<<-]]>>
>>[<<<<+>>>>-]<<<]<[>>+<<<<[-]>>[<<+>>-]]>>]<<<<[<<<<]<<<[<<
<<]>>>>-]>>>>]>>>[>[-]>>>]<<<<[>>+<<-]>>[<<+>+>-]<->+<[>-<[-
]]>[-<<-<<<<[>>+<<-]>>[<<+>+>-]<->+<[>-<[-]]>]<<[<<<<]<<<<-[
>>+<<-]>>[<<+>+>-]+<[>-<[-]]>[-<<++++++++++<<<<-[>>+<<-]>>[<
<+>+>-]+<[>-<[-]]>]<<[<<<<]>>>>[[>>+<<-]>>[<<+>+>-]<->+<[>>>
>+<<<-<[-]]>[-]>>]>]>>>[>>>>]<<<<[>+++++++[<+++++++>-]<--.<<
<<]++++++++++.
与之前发布的brainf*ck 答案不同，这不会溢出任何内存位置。（该实现将 n! 放在单个内存位置，根据标准 bf 规则有效地将其限制为 n 小于 6。）该程序将输出 n! 对于任何 n 值，仅受时间和内存（或 bf 实现）的限制。例如，在我的机器上使用 Urban Muller 的编译器，计算 1000 需要 12 秒！我认为这很好，考虑到程序只能向左/向右移动和递增/递减一。
信不信由你，这是我编写的第一个 bf 程序；大约花了 10 个小时，大部分时间都花在了调试上。不幸的是，我后来发现 Daniel B Cristofani 写了一个阶乘生成器，它只输出越来越大的阶乘，从不终止：
>++++++++++>>>+>+[>>>+[-[<<<<<[+<<<<<]>>[[-]>[<<+>+>-]<[>+<-
]<[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>[-]>>>>+>+<
<<<<<-[>+<-]]]]]]]]]]]>[<+>-]+>>>>>]<<<<<[<<<<<]>>>>>>>[>>>>
>]++[-<<<<<]>>>>>>-]+>>>>>]<[>++<-]<<<<[<[>+<-]<<<<]>>[->[-]
++++++[<++++++++>-]>>>>]<<<<<[<[>+>+<<-]>.<<<<<]>.>>>>]
他的计划要短得多，但他实际上是一名职业高尔夫球手。
它是 Agda2，使用非常好的 Agda2 语法。
module fac where
data Nat : Set where -- Peano numbers
zero : Nat
suc : Nat -> Nat
{-# BUILTIN NATURAL Nat #-}
{-# BUILTIN SUC suc #-}
{-# BUILTIN ZERO zero #-}
infixl 10 _+_ -- Addition over Peano numbers
_+_ : Nat -> Nat -> Nat
zero + n = n
(suc n) + m = suc (n + m)
infixl 20 _*_ -- Multiplication over Peano numbers
_*_ : Nat -> Nat -> Nat
zero * n = zero
n * zero = zero
(suc n) * (suc m) = suc n + (suc n * m)
_! : Nat -> Nat -- Factorial function, syntax: "x !"
zero ! = suc zero
(suc n) ! = (suc n) * (n !)
Python： 使用短路布尔评估的功能性递归单线。
factorial = lambda n: ((n <= 1) and 1) or factorial(n-1) * n
multi factorial ( Int $n where { $n <= 0 } ){
return 1;
}
multi factorial ( Int $n ){
return $n * factorial( $n-1 );
}
这也将起作用：
multi factorial(0) { 1 }
multi factorial(Int $n) { $n * factorial($n - 1) }
查看Jonathan Worthington在use.perl.org上的日志，了解关于最后一个示例的更多信息。
sub factorial ( int $n ){
my $result = 1;
loop ( ; $n > 0; $n-- ){
$result *= $n;
}
return $result;
}
C：
编辑：实际上我猜是 C++，因为 for 循环中的变量声明。
int factorial(int x) {
int product = 1;
for (int i = x; i > 0; i--) {
product *= i;
}
return product;
}
factorial = function( n )
{
return n > 0 ? n * factorial( n - 1 ) : 1;
}
我不确定 Factorial 是什么，但它可以做其他程序在 javascript 中所做的事情。
Python：
递归的
def fact(x):
return (1 if x==0 else x * fact(x-1))
使用迭代器
import operator
def fact(x):
return reduce(operator.mul, xrange(1, x+1))
许多 Mathematica 解决方案中的两个（尽管 ! 是内置且高效的）：
(* returns pure function *)
(FixedPoint[(If[#[[2]]>1,{#[[1]]*#[[2]],#[[2]]-1},#])&,{1,n}][[1]])&
(* not using built-in, returns pure function, don't use: might build 1..n list *)
(Times @@ Range[#])&
<Extension()> _
Public Function Product(ByVal xs As IEnumerable(Of Integer)) As Integer
Return xs.Aggregate(1, Function(a, b) a * b)
End Function
Public Function Fact(ByVal n As Integer) As Integer
Return Aggregate x In Enumerable.Range(1, n) Into Product()
End Function
这显示了如何Aggregate在 VB 中使用关键字。C# 无法做到这一点（尽管 C# 当然可以直接调用扩展方法）。
(define (factorial n)
(define (fac-times n acc)
(if (= n 0)
acc
(fac-times (- n 1) (* acc n))))
(if (< n 0)
(display "Wrong argument!")
(fac-times n 1)))
def factorial(n)
(1 .. n).inject{|a, b| a*b}
end
def factorial(n)
n == 1 ? 1 : n * factorial(n-1)
end
#Language: T-SQL
#Style: Big Numbers
这是另一个 T-SQL 解决方案——以最鲁布戈德伯格的方式支持大数字。许多基于集合的操作。试图保持它唯一的 SQL。糟糕的性能（400！在戴尔 Latitude D830 上花了 33 秒）
create function bigfact(@x varchar(max)) returns varchar(max) as begin
declare @c int
declare @n table(n int,e int)
declare @f table(n int,e int)
set @c=0
while @c<len(@x) begin
set @c=@c+1
insert @n(n,e) values(convert(int,substring(@x,@c,1)),len(@x)-@c)
end
-- our current factorial
insert @f(n,e) select 1,0
while 1=1 begin
declare @p table(n int,e int)
delete @p
-- product
insert @p(n,e) select sum(f.n*n.n), f.e+n.e from @f f cross join @n n group by f.e+n.e
-- normalize
while 1=1 begin
delete @f
insert @f(n,e) select sum(n),e from (
select (n % 10) as n,e from @p union all
select (n/10) % 10,e+1 from @p union all
select (n/100) %10,e+2 from @p union all
select (n/1000)%10,e+3 from @p union all
select (n/10000) % 10,e+4 from @p union all
select (n/100000)% 10,e+5 from @p union all
select (n/1000000)%10,e+6 from @p union all
select (n/10000000) % 10,e+7 from @p union all
select (n/100000000)% 10,e+8 from @p union all
select (n/1000000000)%10,e+9 from @p
) f group by e having sum(n)>0
set @c=0
select @c=count(*) from @f where n>9
if @c=0 break
delete @p
insert @p(n,e) select n,e from @f
end
-- decrement
update @n set n=n-1 where e=0
-- normalize
while 1=1 begin
declare @e table(e int)
delete @e
insert @e(e) select e from @n where n<0
if @@rowcount=0 break
update @n set n=n+10 where e in (select e from @e)
update @n set n=n-1 where e in (select e+1 from @e)
end
set @c=0
select @c=count(*) from @n where n>0
if @c=0 break
end
select @c=max(e) from @f
set @x=''
declare @l varchar(max)
while @c>=0 begin
set @l='0'
select @l=convert(varchar(max),n) from @f where e=@c
set @x=@x+@l
set @c=@c-1
end
return @x
end
例子：
print dbo.bigfact('69')
返回：
171122452428141311372468338881272839092270544893520369393648040923257279754140647424000000000000000
Moog moog => dac;
4.0 => moog.gain;
for (0 => int i; i < 8; i++) {
<<< factorial(i) >>>;
}
fun int factorial(int n) {
1 => int result;
if (n != 0) {
n * factorial(n - 1) => result;
}
Std.mtof(result % 128) => moog.freq;
0.25::second => now;
return result;
}
听起来像这样。不是很有趣，但是，嘿，它只是一个阶乘函数！
简单的解决方案是最好的：
#include <stdexcept>;
long fact(long f)
{
static long fact [] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 1932053504, 1278945280, 2004310016, 2004189184 };
static long max = sizeof(fact)/sizeof(long);
if ((f < 0) || (f >= max))
{ throw std::range_error("Factorial Range Error");
}
return fact[f];
}
(defun fact (n)
(loop for i from 1 to n
for acc = 1 then (* acc i)
finally (return acc)))
现在，如果有人能想出一个基于 FORMAT 的版本......
好的，那我自己试试看。
(defun format-fact (stream arg colonp atsignp &rest args)
(destructuring-bind (n acc) arg
(format stream
"~[~A~:;~*~/format-fact/~]"
(1- n)
acc
(list (1- n) (* acc n)))))
(defun fact (n)
(parse-integer (format nil "~/format-fact/" (list n 1))))
必须有一个更好，甚至更晦涩的基于 FORMAT 的实现。这个非常简单和无聊，只需使用 FORMAT 作为 IF 替代品。显然，我不是 FORMAT 专家。
AWK
#!/usr/bin/awk -f
{
result=1;
for(i=$1;i>0;i--){
result=result*i;
}
print result;
}
#Language: T-SQL, C#
#Style: Custom Aggregate
另一种疯狂的方法是创建一个自定义聚合并将其应用于整数 1..n 的临时表。
/* ProductAggregate.cs */
using System;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;
[Serializable]
[SqlUserDefinedAggregate(Format.Native)]
public struct product {
private SqlDouble accum;
public void Init() { accum = 1; }
public void Accumulate(SqlDouble value) { accum *= value; }
public void Merge(product value) { Accumulate(value.Terminate()); }
public SqlDouble Terminate() { return accum; }
}
将此添加到sql
create assembly ProductAggregate from 'ProductAggregate.dll' with permission_set=safe -- mod path to point to actual dll location on disk.
create aggregate product(@a float) returns float external name ProductAggregate.product
创建表（在 SQL 中应该有一种内置的方法来执行此操作——嗯。对 SO有疑问吗？）
select 1 as n into #n union select 2 union select 3 union select 4 union select 5
然后最后
select dbo.product(n) from #n
哈斯克尔：
factorial n = product [1..n]
class
APPLICATION
inherit
ARGUMENTS
create
make
feature -- Initialization
make is
-- Run application.
local
l_fact: NATURAL_64
do
l_fact := factorial(argument(1).to_natural_64)
print("Result is: " + l_fact.out)
end
factorial(n: NATURAL_64): NATURAL_64 is
--
require
positive_n: n >= 0
do
if n = 0 then
Result := 1
else
Result := n * factorial(n-1)
end
end
end -- class APPLICATION
v
>v"Please enter a number (1-16) : "0<
,: >$*99g1-:99p#v_.25*,@
^_&:1-99p>:1-:!|10 <
^ <
Cat's Eye Technologies的 Chris Pressey 的深奥语言。
Perl (Y-combinator/Functional)
print sub {
my $f = shift;
sub {
my $f1 = shift;
$f->( sub { $f1->( $f1 )->( @_ ) } )
}->( sub {
my $f2 = shift;
$f->( sub { $f2->( $f2 )->( @_ ) } )
} )
}->( sub {
my $h = shift;
sub {
my $n = shift;
return 1 if $n <=1;
return $n * $h->($n-1);
}
})->(5);
'print' 之后和 '->(5)' 之前的所有内容都代表子例程。阶乘部分在最后的“sub {...}”中。其他一切都是为了实现 Y 组合器。
fact=. verb define
*/ >:@i. y
)
fac := [ :x | x = 0 ifTrue: [ 1 ] ifFalse: [ x * (fac value: x -1) ]].
Transcript show: (fac value: 24) "-> 620448401733239439360000"
NB 在 Squeak 中不起作用，需要完全关闭。
在 Dictionary 上定义一个方法
Dictionary >> fac: x
^self at: x ifAbsentPut: [ x * (self fac: x - 1) ]
用法
d := Dictionary new.
d at: 0 put: 1.
d fac: 24
(1 to: 24) inject: 1 into: [ :a :b | a * b ]
fact[n_] := Times @@ Range[n]
这是Apply[Times, Range[n]]. 我认为这是最好的方法，当然，不包括内置的n!。请注意，它会自动使用 bignums。
普通 Lisp 版本：
(defun ! (n) (reduce #'* (loop for i from 2 below (+ n 1) collect i)))
似乎相当快。
* (! 42)
1405006117752879898543142606244511569936384000000000
虽然递归可能是解决问题的唯一体面解决方案，但对于阶乘却不是。描述它，是的。要对其进行编程，不。迭代是最便宜的。
此函数计算较大参数的阶乘。
function Factorial(aNumber: Int64): String;
var
F: Double;
begin
F := 0;
while aNumber > 1 do begin
F := F + log10(aNumber);
dec(aNumber);
end;
Result := FloatToStr(Power(10, Frac(F))) + ' * 10^' + IntToStr(Trunc(F));
end;
100万！= 8.2639327850046 * 10^5565708
? to factorial :n
> ifelse :n = 0 [output 1] [output :n * factorial :n - 1]
> end
并调用：
? print factorial 5
120
这是使用标志的UCBLogo方言。
Perl，悲观的：
# Because there are just so many other ways to get programs wrong...
use strict;
use warnings;
sub factorial {
my ($x)=@_;
for(my $f=1;;$f++) {
my $tmp=$f;
foreach my $g (1..$x) {
$tmp/=$g;
}
return $f if $tmp == 1;
}
}
我相信我会因为不使用“*”运算符而获得加分......
*NIX 壳牌
Linux 版本：
seq -s'*' 42 | bc
BSD版本：
jot -s'*' 42 | bc
FORTH，迭代 1 班轮
: FACT 1 SWAP 1 + 1 DO I * LOOP ;
(define factorial
(lambda (n)
(if (= n 0)
1
(* n (factorial (- n 1))))))
应该可以，但是请注意，在大量数字上调用此函数将在每次递归时扩展堆栈，这在 C 和 Java 等语言中是不好的。
(define factorial
(lambda (n)
(factorial_cps n (lambda (k) k))))
(define factorial_cps
(lambda (n k)
(if (zero? n)
(k 1)
(factorial (- n 1) (lambda (v)
(k (* n v)))))))
啊，这样，我们不会在每次递归时都增加堆栈，因为我们可以扩展一个延续。但是，C 没有延续。
(define factorial
(lambda (n)
(factorial_cps n (k_))))
(define factorial_cps
(lambda (n k)
(if (zero? n)
(apply_k 1)
(factorial (- n 1) (k_extend n k))))
(define apply_k
(lambda (ko v)
(ko v)))
(define kt_empty
(lambda ()
(lambda (v) v)))
(define kt_extend
(lambda ()
(lambda (v)
(apply_k k (* n v)))))
请注意，在原始 CPS 程序中使用的延续表示的责任已转移到kt_帮助程序。
由于延续的表示是在帮助程序中，我们可以切换到使用ParentheC作为kt_类型指示符。
(define factorial
(lambda (n)
(factorial_cps n (kt_empty))))
(define factorial_cps
(lambda (n k)
(if (zero? n)
(apply_k 1)
(factorial (- n 1) (kt_extend n k))))
(define-union kt
(empty)
(extend n k))
(define apply_k
(lambda ()
(union-case kh kt
[(empty) v]
[(extend n k) (begin
(set! kh k)
(set! v (* n v))
(apply_k))])))
这还不够。我们现在通过设置全局变量和程序计数器来替换所有函数调用。过程现在是适合 GOTO 语句的标签。
(define-registers n k kh v)
(define-program-counter pc)
(define-label main
(begin
(set! n 5) ; what is the factorial of 5??
(set! pc factorial_cps)
(mount-trampoline kt_empty k pc)
(printf "Factorial of 5: ~d\n" v)))
(define-label factorial_cps
(if (zero? n)
(begin
(set! kh k)
(set! v 1)
(set! pc apply_k))
(begin
(set! k (kt_extend n k))
(set! n (- n 1))
(set! pc factorial_cps))))
(define-union kt
(empty dismount) ; get off the trampoline!
(extend n k))
(define-label apply_k
(union-case kh kt
[(empty dismount) (dismount-trampoline dismount)]
[(extend n k) (begin
(set! kh k)
(set! v (* n v))
(set! pc apply_k))]))
哦，看，我们main现在也有一个程序。现在剩下要做的就是将此文件另存为fact5.pc并通过 ParentheC 的 pc2c 运行它：
> (load "pc2c.ss")
> (pc2c "fact5.pc" "fact5.c" "fact5.h")
可以吗？我们得到fact5.c和fact5.h。让我们来看看...
$ gcc fact5.c -o fact5
$ ./fact5
Factorial of 5: 120
成功！我们已将递归 Scheme 程序转换为非递归 C 程序！而且只用了几个小时，在墙上留下了许多额头形的印象！为方便起见，fact5.c和和fact5.h。
C++
factorial(int n)
{
for(int i=1, f = 1; i<=n; i++)
f *= i;
return f;
}
Java：函数式
int factorial(int x) {
return x == 0 ? 1 : x * factorial(x-1);
}
fact 0 = 1
fact n = n * fact (n-1)
这不仅计算 n!，它也是 O(n!)。如果你想计算任何“大”的东西，它可能会有问题。
long f(long n)
{
long r=1;
for (long i=1; i<n; i++)
r=r*i;
return r;
}
long factorial(long n)
{
// iterative implementation should be efficient
long result;
for (long i=0; i<f(n); i++)
result=result+1;
return result;
}
Bourne Shell：功能性
factorial() {
if [ $1 -eq 0 ]
then
echo 1
return
fi
a=`expr $1 - 1`
expr $1 \* `factorial $a`
}
也适用于 Korn Shell 和 Bourne Again Shell。:-)
Lisp 递归：
(defun factorial (x)
(if (<= x 1)
1
(* x (factorial (- x 1)))))
JavaScript 使用匿名函数：
var f = function(n){
if(n>1){
return arguments.callee(n-1)*n;
}
return 1;
}
int f(int n) { for (int i = n - 1; i > 0; n *= i, i--); return n ? n : 1; }
为简洁起见，我使用了 int；使用其他类型来支持更大的数字。
四种实现方式：
代码：
#!/usr/bin/env python
""" weave_factorial.py
"""
# [weave] factorial() as extension module in C++
from scipy.weave import ext_tools
def build_factorial_ext():
func = ext_tools.ext_function(
'factorial',
r"""
unsigned long long i = 1;
for ( ; n > 1; --n)
i *= n;
PyObject *o = PyLong_FromUnsignedLongLong(i);
return_val = o;
Py_XDECREF(o);
""",
['n'],
{'n': 1}, # effective type declaration
{})
mod = ext_tools.ext_module('factorial_ext')
mod.add_function(func)
mod.compile()
try: from factorial_ext import factorial as factorial_weave
except ImportError:
build_factorial_ext()
from factorial_ext import factorial as factorial_weave
# [python] pure python procedural factorial()
def factorial_python(n):
i = 1
while n > 1:
i *= n
n -= 1
return i
# [psyco] factorial() psyco-optimized
try:
import psyco
factorial_psyco = psyco.proxy(factorial_python)
except ImportError:
pass
# [list] list-lookup factorial()
factorials = map(factorial_python, range(21))
factorial_list = lambda n: factorials[n]
测量相对性能：
$ python -mtimeit \
-s "from weave_factorial import factorial_$label as f" "f($n)"
n = 12
n = 20
µsec代表微秒。
这是一个有趣的 Ruby 版本。在我的笔记本电脑上它会找到 30000！不到一秒钟。（Ruby 将其格式化以打印比计算它需要更长的时间。）这比仅按顺序相乘的简单解决方案要快得多。
def factorial (n)
return multiply_range(1, n)
end
def multiply_range(n, m)
if (m < n)
return 1
elsif (n == m)
return m
else
i = (n + m) / 2
return multiply_range(n, i) * multiply_range(i+1, m)
end
end
.
def factorial( value: BigInt ): BigInt = value match {
case 0 => 1
case _ => value * factorial( value - 1 )
}
Occamp-pi
PROC subprocess(MOBILE CHAN INT parent.out!,parent.in?)
INT value:
SEQ
parent.in ? value
IF
value = 1
SEQ
parent.out ! value
OTHERWISE
INITIAL MOBILE CHAN INT child.in IS MOBILE CHAN INT:
INITIAL MOBILE CHAN INT child.out IS MOBILE CHAN INT:
FORKING
INT newvalue:
SEQ
FORK subprocess(child.in!,child.out?)
child.out ! (value-1)
child.in ? newvalue
parent.out ! (newalue*value)
:
PROC main(CHAN BYTE in?,src!,kyb?)
INITIAL INT value IS 0:
INITIAL MOBILE CHAN INT child.out is MOBILE CHAN INT
INITIAL MOBILE CHAN INT child.in is MOBILE CHAN INT
SEQ
WHILE TRUE
SEQ
subprocess(child.in!,child.out?)
child.out ! value
child.in ? value
src ! value:
value := value + 1
:
以免有人相信 OCaml 和奇怪的球齐头并进，我想我会提供一个合理的阶乘实现。
# let rec factorial n =
if n=0 then 1 else n * factorial(n - 1);;
我觉得我的案子不是很好...
真正的功能Java：
public final class Factorial {
public static void main(String[] args) {
final int n = Integer.valueOf(args[0]);
System.out.println("Factorial of " + n + " is " + create(n).apply());
}
private static Function create(final int n) {
return n == 0 ? new ZeroFactorialFunction() : new NFactorialFunction(n);
}
interface Function {
int apply();
}
private static class NFactorialFunction implements Function {
private final int n;
public NFactorialFunction(final int n) {
this.n = n;
}
@Override
public int apply() {
return n * Factorial.create(n - 1).apply();
}
}
private static class ZeroFactorialFunction implements Function {
@Override
public int apply() {
return 1;
}
}
}
在一行中使用递归的 C# 阶乘
private static int factorial(int n){ if (n == 0)return 1;else return n * factorial(n - 1); }
注意：破坏e和f寄存器：
[2++d]se[d1-d_1<fd0>e*]sf
使用时，将你想要的阶乘值放在栈顶，然后执行lfx（加载f寄存器并执行它），然后弹出栈顶并压入该值的阶乘。
解释：如果栈顶是x，那么第一部分使栈顶看起来像(x, x-1)。如果新的栈顶是非负的，它会递归调用阶乘，所以现在栈(x, (x-1)!)> x=1，或者=0 (0, -1)。x然后，如果新的栈顶是负的，它2++d执行(0, -1)用替换(1, 1)。最后，它将堆栈顶部的两个值相乘。
setGeneric( 'fct', function( x ) { standardGeneric( 'fct' ) } )
setMethod( 'fct', 'numeric', function( x ) {
lapply( x, function(a) {
if( a == 0 ) 1 else a * fact( a - 1 )
} )
} )
优点是您可以传入数字数组，并且可以将它们全部解决...
例如：
> fct( c( 3, 5, 6 ) )
[[1]]
[1] 6
[[2]]
[1] 120
[[3]]
[1] 720
伊斯威姆/清醒：
factorial = 1 fby factorial * (time+1);
Python，一个班轮：
比其他 python 答案更干净。如果输入小于 1，这个和前面的答案都会失败。
def fact(n): return reduce( int.mul ,xrange(2,n))
!（定义！（n）
“阶乘”
（标签（（fac（n产品）
(如果 (zerop n)
产品
(fac (- n 1) (* prod n)))))
（事实 1）））
编辑：或使用累加器作为可选参数：
(defun ! (n &optional prod)
“阶乘”
(如果 (zerop n)
产品
(! (- n 1) (* prod n))))
或者作为减少，以更大的内存占用和更多的consing为代价：
(defun range (start end & optional acc)
"范围从包含开始到不包含结束，开始 = 开始结束)
(nreverse acc)
(范围 (+ start 1) end (cons start acc))))
（定义！（n）
“阶乘”
(减少#'* (范围 1 (+ n 1))))
用途：math.ranges
: 阶乘 (n -- n!) 1 [a,b] 乘积;
在腮腺炎中：
fact(N)
N F,I S F=1 F I=2:1:N S F=F*I
QUIT F
或者，如果您是间接的粉丝：
fact(N)
N F,I S F=1 F I=2:1:N S F=F_"*"_I
QUIT @F
ActionScript：程序/OOP
function f(n) {
var result = n>1 ? arguments.callee(n-1)*n : 1;
return result;
}
// function call
f(3);
嗯……没有TCL
proc factorial {n} {
if { $n == 0 } { return 1 }
return [expr {$n*[factorial [expr {$n-1}]]}]
}
puts [factorial 6]
但是，对于 n 的大值，这当然是行不通的……我们可以用 tcllib 做得更好！
package require math::bignum
proc factorial {n} {
if { $n == 0 } { return 1 }
return [ ::math::bignum::tostr [ ::math::bignum::mul [
::math::bignum::fromstr $n] [ ::math::bignum::fromstr [
factorial [expr {$n-1} ]
]]]]
}
puts [factorial 60]
看看最后所有的]。这实际上是 LISP！
我将保留 n>2^32 值的版本作为读者的 excersize
f[n_ /; n < 2] := 1
f[n_] := (f[n] = n*f[n - 1])
Mathematica 支持 n! 本机，但这显示了如何动态定义。当您执行 f[2] 时，此代码将定义 f[2]=2，随后执行的定义与您硬编码时没有什么不同；不需要内部数据结构；您只需使用语言自己的函数定义机制。
Lisp：尾递归
(defun factorial(x)
(labels((f (x acc)
(if (> x 1)
(f (1- x)(* x acc))
acc)))
(f x 1)))
另一个红宝石。
class Integer
def fact
return 1 if self.zero?
(1..self).to_a.inject(:*)
end
end如果符号支持 to_proc，则此方法有效。
数学绝对是不是 REBOL 的强项之一，因为它缺乏任意精度的整数。为了完整起见，我想我还是会添加它。
这是一个标准的、朴素的递归实现：
fac: func [ [catch] n [整数！] ] [
如果 n < 0 [ 抛出 make 错误！“嘿笨蛋，你的论点小于0！” ]
要么 n = 0 [ 1 ] [
n * fac (n - 1)
]
]
就是这样。继续前进，伙计们，这里没什么可看的...... :)
这是我的建议。在 Mathematica 中运行，工作正常：
gen[f_, n_] := Module[{id = -1, val = Table[Null, {n}], visit},
visit[k_] := Module[{t},
id++; If[k != 0, val[[k]] = id];
If[id == n, f[val]];
Do[If[val[[t]] == Null, visit[t]], {t, 1, n}];
id--; val[[k]] = Null;];
visit[0];
]
Factorial[n_] := Module[{res=0}, gen[res++&, n]; res]
更新 好吧，它是这样工作的：访问函数来自 Sedgewick 的算法书，它“访问”所有长度为 n 的排列。在访问时，它以排列作为参数调用函数 f。
因此，Factorial 会枚举所有长度为 n 的排列，并且对于每个排列，计数器 res 都会增加，从而计算 n！在 O(n+1) 中！时间。
Python：
def factorial(n):
return reduce(lambda x, y: x * y,range(1, n + 1))
function f($n){return array_reduce(range(1,$n),'bcmul',1);}
array_product(range(1,$n));
... Haskell 和 Python 从那里借用了他们的列表推导。
proc factorial(n);
return 1 */ {1..n};
end factorial;
并且内置INTEGER类型是任意精度的，因此这适用于任何正数n。
我看到 Common Lisp 解决方案滥用递归、循环甚至 FORMAT。我想是时候有人写一个滥用 CLOS 的解决方案了！
(defgeneric factorial (n))
(defmethod factorial ((n (eql 0))) 1)
(defmethod factorial ((n integer)) (* n (factorial (1- n))))
（你最喜欢的语言的对象系统调度器能做到这一点吗？）
~),1>{*}*
~评估输入字符串（为整数）)增加数字,是范围（4，变为 [0 1 2 3]）1>选择索引为 1 或更大的值{*}*在列表上折叠乘法跑步：
echo 5 | ruby gs.rb fact.gs
这将利用您的多核 CPU……尽管可能不是最有效的方式。open语句使用fork 克隆进程并打开从子进程到父进程的管道。一次将数字 2 相乘的工作被分配在一棵生命周期非常短的过程树中。当然，这个例子有点傻。关键是，如果您实际上有更困难的计算要做，那么这个例子说明了一种并行划分工作的方法。
#!/usr/bin/perl -w
use strict;
use bigint;
print STDOUT &main::rangeProduct(1,$ARGV[0])."\n";
sub main::rangeProduct {
my($l, $h) = @_;
return $l if ($l==$h);
return $l*$h if ($l==($h-1));
# arghhh - multiplying more than 2 numbers at a time is too much work
# find the midpoint and split the work up :-)
my $m = int(($h+$l)/2);
my $pid = open(my $KID, "-|");
if ($pid){ # parent
my $X = &main::rangeProduct($l,$m);
my $Y = <$KID>;
chomp($Y);
close($KID);
die "kid failed" unless defined $Y;
return $X*$Y;
} else {
# kid
print STDOUT &main::rangeProduct($m+1,$h)."\n";
exit(0);
}
}
使用递归公用表表达式的内联表函数。SQL Server 2005 及更高版本。
CREATE FUNCTION dbo.Factorial(@n int) RETURNS TABLE
AS
RETURN
WITH RecursiveCTE (N, Value) AS
(
SELECT 1, CAST(1 AS decimal(38,0))
UNION ALL
SELECT N+1, CAST(Value*(N+1) AS decimal(38,0))
FROM RecursiveCTE
)
SELECT TOP 1 Value
FROM RecursiveCTE
WHERE N = @n
factorial n = factorial' n 1
factorial' 0 a = a
factorial' n a = factorial' (n-1) (n*a)
福克斯专业版：
function factorial
parameters n
return iif( n>0, n*factorial(n-1), 1)
Common Lisp，因为还没有人这样做：
(defun factorial (n)
(if (<= n 1)
1
(* n (factorial (1- n)))))
我相当肯定这可能会更有效。这是我的第一个 lisp 函数，除了 "hello, world" 和在第三章中输入示例代码。Practical Common Lisp是一本很棒的书。这个函数似乎可以很好地处理大阶乘。
(defun factorial (x)
(if (< x 2) (return-from factorial (print 1)))
(let ((tempx 1) (ans 1))
(loop until (equalp x tempx) do
(incf tempx)
(setf ans (* tempx ans)))
(list ans)))
在艾欧：
factorial := method(n,
if (list(0, 1) contains(n),
1,
n * factorial(n - 1)
)
)
C++ 常量表达式
constexpr uint64_t fact(uint32_t n)
{
return (n==0) ? 1:n*fact(n-1);
}
VB6：
Private Function factCalculation(ByVal Number%)
Dim intNum%
intNum = 1
For i = 2 To Number
intNum = intNum * Number
Next i
return intNum
End Function
Private Sub Form_Load()
Dim FactResult% : FactResult = factCalculation(3) 'e.g
Print FactResult
End Sub