blocks|key|1089568|text|标准库中没有阶乘函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1089569|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

There is no factorial function in the standard library.

blocks|key|1089792|text|就像这样更好|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1089793|(1..n).inject(:*)+%7C%7C+1|code-block|syntax|javascript|1089794|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Like this is better 

<pre><code>(1..n).inject(:*) || 1
</code></pre>

blocks|key|1089597|text|它不在标准库中，但您可以扩展Integer类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1089598|class+Integer
++def+factorial_recursive
++++self+<=+1+?+1+:+self+*+(self+-+1).factorial
++end
++def+factorial_iterative
++++f+=+1;+for+i+in+1..self;+f+*=+i;+end;+f
++end
++alias+:factorial+:factorial_iterative
end|code-block|syntax|javascript|1089599|注意:出于明显的性能原因，迭代阶乘是更好的选择。|1089600|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

It's not in the standard library but you can extend the Integer class.

<pre><code>class Integer
 def factorial_recursive
 self &lt;= 1 ? 1 : self * (self - 1).factorial
 end
 def factorial_iterative
 f = 1; for i in 1..self; f *= i; end; f
 end
 alias :factorial :factorial_iterative
end
</code></pre>

N.B. Iterative factorial is a better choice for obvious performance reasons.

blocks|key|1089736|text|不知羞耻地抄袭自http://rosettacode.org/wiki/Factorial#Ruby，我个人最喜欢的是|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1089737|class+Integer
++def+fact
++++(1..self).reduce(:*)+%7C%7C+1
++end
end

>>+400.fact
=>+64034522846623895262347970319503005850702583026002959458684445942802397169186831436278478647463264676294350575035856810848298162883517435228961988646802997937341654150838162426461942352307046244325015114448670890662773914918117331955996440709549671345290477020322434911210797593280795101545372667251627877890009349763765710326350331533965349868386831339352024373788157786791506311858702618270169819740062983025308591298346162272304558339520759611505302236086810433297255194852674432232438669948422404232599805551610635942376961399231917134063858996537970147827206606320217379472010321356624613809077942304597360699567595836096158715129913822286578579549361617654480453222007825818400848436415591229454275384803558374518022675900061399560145595206127211192918105032491008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000|code-block|syntax|javascript|1089738|这个实现恰好也是Rosetta+Code中列出的变体中最快的。|1089739|更新#1|1089740|添加了%7C%7C+1来处理零案例。|style|CODE|1089741|更新#2|1089742|感谢并感谢Mark+Thomas，这里有一个更高效、更优雅、更晦涩的版本：|1089743|class+Integer
++def+fact
++++(2..self).reduce(1,:*)
++end
end|1089744|entityMap|0|LINK|mutability|MUTABLE|url|http://rosettacode.org/wiki/Factorial#Ruby|1|https://stackoverflow.com/users/182590/mark-thomas^0|8|16|0|0|0|0|0|3|4|0|0|5|B|1|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]]|C|$]]|$1|D|3|E|5|F|7|1A|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1B|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|1C|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|1D|8|@$A|1E|B|1F|O|P]]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1G|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1H|8|@]|9|@$A|1I|B|1J|1|1K]]|C|$]]|$1|U|3|V|5|F|7|1L|8|@]|9|@]|C|$G|H]]|$1|W|3|-4|5|6|7|1M|8|@]|9|@]|C|$]]]|X|$Y|$5|Z|10|11|C|$12|13]]|14|$5|Z|10|11|C|$12|15]]]]

Shamelessly cribbed from <a href="http://rosettacode.org/wiki/Factorial#Ruby" rel="noreferrer">http://rosettacode.org/wiki/Factorial#Ruby</a>, my personal favorite is

<pre><code>class Integer
 def fact
 (1..self).reduce(:*) || 1
 end
end

&gt;&gt; 400.fact
=&gt; 64034522846623895262347970319503005850702583026002959458684445942802397169186831436278478647463264676294350575035856810848298162883517435228961988646802997937341654150838162426461942352307046244325015114448670890662773914918117331955996440709549671345290477020322434911210797593280795101545372667251627877890009349763765710326350331533965349868386831339352024373788157786791506311858702618270169819740062983025308591298346162272304558339520759611505302236086810433297255194852674432232438669948422404232599805551610635942376961399231917134063858996537970147827206606320217379472010321356624613809077942304597360699567595836096158715129913822286578579549361617654480453222007825818400848436415591229454275384803558374518022675900061399560145595206127211192918105032491008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
</code></pre>

This implementation also happens to be the fastest among the variants listed in Rosetta Code.

<h2>update #1</h2>

Added <code>|| 1</code> to handle the zero case.

<h2>update #2</h2>

With thanks and appreciation to <a href="https://stackoverflow.com/users/182590/mark-thomas">Mark Thomas</a>, here's a version that is a bit more efficient, elegant and obscure:

<pre><code>class Integer
 def fact
 (2..self).reduce(1,:*)
 end
end
</code></pre>

blocks|key|1305588|text|在数学上，factorial+of+n就是gamma+function+of+n%2B1|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1305589|(请参阅：http://en.wikipedia.org/wiki/Gamma_function)|1305590|Ruby有Math.gamma()，所以如果需要，只需使用Math.gamma(n%2B1)并将其转换回整数即可。|1305591|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Gamma_function^0|5|E|L|L|0|5|17|0|0|5|C|T|F|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|H|3|I|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]]]

In math, <code>factorial of n</code> is just the <code>gamma function of n+1</code> 
 (see: <a href="http://en.wikipedia.org/wiki/Gamma_function" rel="noreferrer">http://en.wikipedia.org/wiki/Gamma_function</a>)

Ruby has <code>Math.gamma()</code> so just use <code>Math.gamma(n+1)</code> and cast it back to an integer if desired.

blocks|key|1304885|text|您也可以使用Math.gamma函数，它归结为整数参数的阶乘。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1304886|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ruby-doc.org/core-1.9.3/Math.html#method-c-gamma^0|6|A|6|A|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

You could also use <a href="http://www.ruby-doc.org/core-1.9.3/Math.html#method-c-gamma"><code>Math.gamma</code></a> function which boils down to factorial for integer parameters.

blocks|key|1090136|text|class+Integer
++def+!
++++(1..self).inject(:*)
++end
end|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1090137|示例|unstyled|1090138|!3++#+=>+6
!4++#+=>+24|1090139|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>class Integer
 def !
 (1..self).inject(:*)
 end
end
</code></pre>

<h3>examples</h3>

<pre><code>!3 # =&gt; 6
!4 # =&gt; 24
</code></pre>

blocks|key|1089851|text|我会这么做的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1089852|(1..n).inject(1,+:*)|code-block|syntax|javascript|1089853|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I would do

<pre><code>(1..n).inject(1, :*)
</code></pre>

blocks|key|1089694|text|我刚刚写了我自己的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1089695|def+fact(n)
++if+n<=+1
++++1
++else
++++n+*+fact(+n+-+1+)
++end
end|code-block|syntax|javascript|1089696|此外，您还可以定义一个下降阶乘：|1089697|def+fall_fact(n,k)
++if+k+<=+0
++++1
++else
++++n*fall_fact(n+-+1,+k+-+1)
++end
end|1089698|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I just wrote my own:

<pre><code>def fact(n)
 if n&lt;= 1
 1
 else
 n * fact( n - 1 )
 end
end
</code></pre>

Also, you can define a falling factorial:

<pre><code>def fall_fact(n,k)
 if k &lt;= 0
 1
 else
 n*fall_fact(n - 1, k - 1)
 end
end
</code></pre>

blocks|key|1305307|text|只需调用此函数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1305308|def+factorial(n=0)
++(1..n).inject(:*)
end|code-block|syntax|javascript|1305309|示例|1305310|factorial(3)
factorial(11)|1305311|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<h3>Just call this function</h3>

<pre><code>def factorial(n=0)
 (1..n).inject(:*)
end
</code></pre>

<h3>examples</h3>

<pre><code>factorial(3)
factorial(11)
</code></pre>

blocks|key|1305757|text|怀着对所有参与并花费时间帮助我们的人的高度尊重，我想分享我在这里列出的解决方案的基准。参数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1305758|迭代次数=+1000|1305759|N=6|1305760|+++++++++++++++++++++++++++++++++++++user+++++system++++++total++++++++real
Math.gamma(n%2B1)+++++++++++++++++++0.000383+++0.000106+++0.000489+(++0.000487)
(1..n).inject(:*)+%7C%7C+1++++++++++++0.003986+++0.000000+++0.003986+(++0.003987)
(1..n).reduce(1,+:*)++++++++++++++0.003926+++0.000000+++0.003926+(++0.004023)
1.upto(n)+{%7Cx%7C+factorial+*=+x+}+++0.003748+++0.011734+++0.015482+(++0.022795)|code-block|syntax|javascript|1305761|对于n=+10|1305762|++user+++++system++++++total++++++++real
0.000378+++0.000102+++0.000480+(++0.000477)
0.004469+++0.000007+++0.004476+(++0.004491)
0.004532+++0.000024+++0.004556+(++0.005119)
0.027720+++0.011211+++0.038931+(++0.058309)|1305763|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

With high respect to all who participated and spent their time to help us, I would like to share my benchmarks of the solutions listed here.
Params:

iterations = 1000

n = 6

<pre><code> user system total real
Math.gamma(n+1) 0.000383 0.000106 0.000489 ( 0.000487)
(1..n).inject(:*) || 1 0.003986 0.000000 0.003986 ( 0.003987)
(1..n).reduce(1, :*) 0.003926 0.000000 0.003926 ( 0.004023)
1.upto(n) {|x| factorial *= x } 0.003748 0.011734 0.015482 ( 0.022795)
</code></pre>

For n = 10

<pre><code> user system total real
0.000378 0.000102 0.000480 ( 0.000477)
0.004469 0.000007 0.004476 ( 0.004491)
0.004532 0.000024 0.004556 ( 0.005119)
0.027720 0.011211 0.038931 ( 0.058309)
</code></pre>

blocks|key|1089842|text|使用Math.gamma.floor是一种生成近似值，然后将其向下舍入为正确的整数结果的简单方法。应适用于所有整数，如有必要，请包括输入检查。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1089843|entityMap^0|2|G|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Using <code>Math.gamma.floor</code> is an easy way to produce an approximation and then round it back down to the correct integer result. Should work for all Integers, include an input check if necessary.

blocks|key|1305088|text|这只是另一种方式，尽管这真的没有必要。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1305089|class+Factorial
+++attr_reader+:num
+++def+initialize(num)
++++++@num+=+num
+++end

+++def+find_factorial
++++++(1..num).inject(:*)+%7C%7C+1
+++end
end

number+=+Factorial.new(8).find_factorial
puts+number|code-block|syntax|javascript|1305090|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Just another way to do it, although it really isn't necessary.

<pre><code>class Factorial
 attr_reader :num
 def initialize(num)
 @num = num
 end

 def find_factorial
 (1..num).inject(:*) || 1
 end
end

number = Factorial.new(8).find_factorial
puts number
</code></pre>

blocks|key|1090042|text|你可能会发现Ruby的feature+request很有用。它包含一个包含demo+Bash+script的非平凡patch。一个简单的循环和批处理中的解决方案之间的速度差异可以是100倍(数百倍)。全部用纯Ruby编写。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1090043|entityMap|0|LINK|mutability|MUTABLE|url|https://bugs.ruby-lang.org/issues/9528|1|https://bugs.ruby-lang.org/attachments/download/4856/run_demo.bash|2|https://bugs.ruby-lang.org/attachments/download/4855/the_code.rb^0|B|F|0|11|G|1|1L|5|2|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]|N|$5|G|H|I|C|$J|O]]]]

You will probably find a Ruby <a href="https://bugs.ruby-lang.org/issues/9528" rel="nofollow">feature request</a> useful. It contains a nontrivial <a href="https://bugs.ruby-lang.org/attachments/download/4855/the_code.rb" rel="nofollow">patch</a> that includes a <a href="https://bugs.ruby-lang.org/attachments/download/4856/run_demo.bash" rel="nofollow">demo Bash script</a>. The speed difference between a naive loop and the solution presented in the batch can be literally 100x (hundred fold). Written all in pure Ruby.

blocks|key|1090121|text|这是我的版本，尽管它不是很干净，但对我来说似乎很清楚。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1090122|def+factorial(num)
++++step+=+0
++++(num+-+1).times+do+(step+%2B=+1+;num+*=+step)+end
++++return+num
end|code-block|syntax|javascript|1090123|这是我的irb测试线，显示了每一步。|1090124|num+=+8;step+=+0;(num+-+1).times+do+(step+%2B=+1+;num+*=+step;+puts+num)+end;num|1090125|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is my version seems to be clear to me even though it's not as clean.

<pre><code>def factorial(num)
 step = 0
 (num - 1).times do (step += 1 ;num *= step) end
 return num
end
</code></pre>

This was my irb testing line that showed each step.

<pre><code>num = 8;step = 0;(num - 1).times do (step += 1 ;num *= step; puts num) end;num
</code></pre>

blocks|key|1305690|text|既然有一个内置的迭代器可以达到这个目的，那么标准库为什么需要阶乘方法呢？它被称为upto。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1305691|不，你不需要使用递归，就像所有其他答案一样。|1305692|def+fact(n)
++n+==+0+?+1+:+n+*+fact(n+-+1)
end++|code-block|syntax|javascript|1305693|相反，内置的迭代器upto可以用来计算阶乘：|1305694|factorial+=+1
1.upto(10)+{%7Cx%7C+factorial+*=+x+}
factorial
+=>+3628800|1305695|entityMap^0|14|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

Why would the standard library require a factorial method, when there is a built-in iterator for this exact purpose? It is called <code>upto</code>.

No you do not need to use recursion, like all these other answers show.

<pre><code>def fact(n)
 n == 0 ? 1 : n * fact(n - 1)
end 
</code></pre>

Rather, the built-in iterator upto can be used to calculate factorials:

<pre><code>factorial = 1
1.upto(10) {|x| factorial *= x }
factorial
 =&gt; 3628800
</code></pre>

blocks|key|1089812|text|class+Integer
++def+factorial
++++return+self+<+0+?+false+:+self==0+?+1+:+self.downto(1).inject(:*)
++++#Not+sure+what+other+libraries+say,+but+my+understanding+is+that+factorial+of+
++++#anything+less+than+0+does+not+exist.
++end
end|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1089813|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>class Integer
 def factorial
 return self &lt; 0 ? false : self==0 ? 1 : self.downto(1).inject(:*)
 #Not sure what other libraries say, but my understanding is that factorial of 
 #anything less than 0 does not exist.
 end
end
</code></pre>

blocks|key|1089954|text|还有另一种方式(=|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1089955|def+factorial(number)
++number+=+number.to_i
++number_range+=+(number).downto(1).to_a
++factorial+=+number_range.inject(:*)
++puts+"The+factorial+of+#{number}+is+#{factorial}"
end
factorial(#number)|code-block|syntax|javascript|1089956|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

And yet another way (=

<pre><code>def factorial(number)
 number = number.to_i
 number_range = (number).downto(1).to_a
 factorial = number_range.inject(:*)
 puts "The factorial of #{number} is #{factorial}"
end
factorial(#number)
</code></pre>

blocks|key|1090390|text|只有一种方法可以做到：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1090391|#+fact(n)+=>+Computes+the+Factorial+of+"n"+=+n!

def+fact(n)+(1..n).inject(1)+{%7Cr,i%7C+r*i+}end

fact(6)+=>+720|code-block|syntax|javascript|1090392|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Just one more way to do it:

<pre><code># fact(n) =&gt; Computes the Factorial of "n" = n!

def fact(n) (1..n).inject(1) {|r,i| r*i }end

fact(6) =&gt; 720
</code></pre>

I'm going crazy: Where is the Ruby function for factorial? No, I don't need tutorial implementations, I just want the function from the library. It's not in Math!

I'm starting to doubt, is it a standard library function?

Ruby factorial function

我要发疯了:阶乘的Ruby函数在哪里？不，我不需要教程实现，我只需要库中的函数。它不在数学中！我开始怀疑，它是一个标准库函数吗？

问Ruby阶乘函数
EN

回答 19

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby阶乘函数EN

回答 19

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby阶乘函数
EN