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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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|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>

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|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>

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby阶乘函数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby阶乘函数
EN