루비 계승 함수

미쳐 버릴거야 : 팩토리얼을위한 루비 함수는 어디에 있나요? 아니요, 튜토리얼 구현이 필요하지 않으며 라이브러리의 함수 만 원합니다. 수학이 아닙니다!

나는 의심하기 시작했습니다. 표준 라이브러리 기능입니까?

표준 라이브러리에는 계승 함수가 없습니다.

이게 더 낫다

(1..n).inject(:*) || 1

표준 라이브러리에는 없지만 Integer 클래스를 확장 할 수 있습니다.

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

NB Iterative factorial은 명백한 성능상의 이유로 더 나은 선택입니다.

http://rosettacode.org/wiki/Factorial#Ruby 에서 뻔뻔스럽게 집어 넣은 제가 개인적으로 가장 좋아하는 것은

class Integer
  def fact
    (1..self).reduce(:*) || 1
  end
end

>> 400.fact
=> 64034522846623895262347970319503005850702583026002959458684445942802397169186831436278478647463264676294350575035856810848298162883517435228961988646802997937341654150838162426461942352307046244325015114448670890662773914918117331955996440709549671345290477020322434911210797593280795101545372667251627877890009349763765710326350331533965349868386831339352024373788157786791506311858702618270169819740062983025308591298346162272304558339520759611505302236086810433297255194852674432232438669948422404232599805551610635942376961399231917134063858996537970147827206606320217379472010321356624613809077942304597360699567595836096158715129913822286578579549361617654480453222007825818400848436415591229454275384803558374518022675900061399560145595206127211192918105032491008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

이 구현은 또한 Rosetta Code에 나열된 변형 중에서 가장 빠릅니다.

업데이트 # 1

|| 1제로 케이스를 처리하기 위해 추가되었습니다 .

업데이트 # 2

Mark Thomas 에게 감사와 감사를 표하며 , 좀 더 효율적이고 우아하며 모호한 버전이 있습니다.

class Integer
  def fact
    (2..self).reduce(1,:*)
  end
end

수학에서, factorial of n단지이다 gamma function of n+1
(참조 : http://en.wikipedia.org/wiki/Gamma_function )

Ruby는 원하는 경우 Math.gamma()사용 Math.gamma(n+1)하고 정수로 다시 캐스팅합니다.

Math.gamma정수 매개 변수에 대해 계승으로 요약되는 함수를 사용할 수도 있습니다 .

class Integer
  def !
    (1..self).inject(:*)
  end
end

예

!3  # => 6
!4  # => 24

나는 할것이다

(1..n).inject(1, :*)

나는 방금 내 자신을 썼다.

def fact(n)
  if n<= 1
    1
  else
    n * fact( n - 1 )
  end
end

또한 하강 팩토리얼을 정의 할 수 있습니다.

def fall_fact(n,k)
  if k <= 0
    1
  else
    n*fall_fact(n - 1, k - 1)
  end
end

이 함수를 호출하십시오.

def factorial(n=0)
  (1..n).inject(:*)
end

예

factorial(3)
factorial(11)

사용 Math.gamma.floor은 근사치를 생성 한 다음 올바른 정수 결과로 다시 반올림하는 쉬운 방법입니다. 모든 정수에 대해 작동해야하며 필요한 경우 입력 확인을 포함합니다.

우리를 돕기 위해 참여하고 시간을 보낸 모든 분들을 높이 평가하며 여기에 나열된 솔루션의 벤치 마크를 공유하고 싶습니다. 매개 변수 :

반복 = 1000

n = 6

                                     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)

n = 10 인 경우

  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)

실제로 필요한 것은 아니지만이를 수행하는 또 다른 방법입니다.

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

Ruby 기능 요청이 유용 할 것입니다. 데모 Bash 스크립트 를 포함 하는 중요한 패치 가 포함되어 있습니다 . 순진한 루프와 배치에 제시된 솔루션 간의 속도 차이는 문자 그대로 100 배 (100 배)가 될 수 있습니다. 모두 순수한 루비로 작성되었습니다.

여기에 내 버전이 깨끗하지는 않지만 분명한 것 같습니다.

def factorial(num)
    step = 0
    (num - 1).times do (step += 1 ;num *= step) end
    return num
end

이것은 각 단계를 보여주는 내 irb 테스트 라인이었습니다.

num = 8;step = 0;(num - 1).times do (step += 1 ;num *= step; puts num) end;num

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

그리고 또 다른 방법 (=

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)

한 가지 더 방법이 있습니다.

# fact(n) => Computes the Factorial of "n" = n!

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

fact(6) => 720

이 정확한 목적을위한 내장 반복기가 있는데 표준 라이브러리에 팩토리얼 메서드가 필요한 이유는 무엇입니까? 그것은이라고upto 합니다.

이 다른 모든 답변이 보여주는 것처럼 재귀를 사용할 필요가 없습니다.

def fact(n)
  n == 0 ? 1 : n * fact(n - 1)
end  

오히려 내장 반복기를 사용하여 계승을 계산할 수 있습니다.

factorial = 1
1.upto(10) {|x| factorial *= x }
factorial
 => 3628800