Ruby-Fakultätsfunktion

Ich werde verrückt: Wo ist die Ruby-Funktion für Fakultät? Nein, ich brauche keine Tutorial-Implementierungen, ich möchte nur die Funktion aus der Bibliothek. Es ist nicht in Mathe!

Ich fange an zu zweifeln, ist es eine Standardbibliotheksfunktion?

In der Standardbibliothek gibt es keine Fakultätsfunktion.

So ist das besser

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

Es ist nicht in der Standardbibliothek enthalten, aber Sie können die Integer-Klasse erweitern.

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 Fakultät ist aus offensichtlichen Leistungsgründen eine bessere Wahl.

Schamlos von http://rosettacode.org/wiki/Factorial#Ruby abgeschnitten , ist mein persönlicher Favorit

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

>> 400.fact
=> 64034522846623895262347970319503005850702583026002959458684445942802397169186831436278478647463264676294350575035856810848298162883517435228961988646802997937341654150838162426461942352307046244325015114448670890662773914918117331955996440709549671345290477020322434911210797593280795101545372667251627877890009349763765710326350331533965349868386831339352024373788157786791506311858702618270169819740062983025308591298346162272304558339520759611505302236086810433297255194852674432232438669948422404232599805551610635942376961399231917134063858996537970147827206606320217379472010321356624613809077942304597360699567595836096158715129913822286578579549361617654480453222007825818400848436415591229454275384803558374518022675900061399560145595206127211192918105032491008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Diese Implementierung ist auch die schnellste unter den in Rosetta Code aufgeführten Varianten.

Update Nr. 1

Hinzugefügt || 1, um den Nullfall zu behandeln.

Update Nr. 2

Mit Dank und Anerkennung an Mark Thomas ist hier eine Version, die etwas effizienter, eleganter und dunkler ist:

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

Sie können auch eine Math.gammaFunktion verwenden, die für ganzzahlige Parameter auf Fakultät hinausläuft.

In Mathe factorial of nist nur die gamma function of n+1
(siehe: http://en.wikipedia.org/wiki/Gamma_function )

Ruby hat es Math.gamma()also einfach benutzt Math.gamma(n+1)und auf Wunsch auf eine ganze Zahl zurückgesetzt.

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

Beispiele

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

Ich würde es tun

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

Ich habe gerade mein eigenes geschrieben:

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

Sie können auch eine fallende Fakultät definieren:

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

Rufen Sie einfach diese Funktion auf

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

Beispiele

factorial(3)
factorial(11)

Die Verwendung Math.gamma.floorist eine einfache Möglichkeit, eine Näherung zu erstellen und diese dann wieder auf das richtige ganzzahlige Ergebnis abzurunden. Sollte für alle Ganzzahlen funktionieren, fügen Sie gegebenenfalls eine Eingabeprüfung hinzu.

Mit großem Respekt für alle, die teilgenommen haben und ihre Zeit damit verbracht haben, uns zu helfen, möchte ich meine Benchmarks für die hier aufgeführten Lösungen teilen. Parameter:

Iterationen = 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)

Für 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)

Nur ein anderer Weg, obwohl es wirklich nicht notwendig ist.

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

Sie werden wahrscheinlich eine Ruby- Funktionsanforderung nützlich finden. Es enthält einen nicht trivialen Patch , der ein Demo-Bash-Skript enthält . Der Geschwindigkeitsunterschied zwischen einer naiven Schleife und der in der Charge dargestellten Lösung kann buchstäblich 100x (hundertfach) betragen. Geschrieben alles in reinem Rubin.

Hier scheint mir meine Version klar zu sein, obwohl sie nicht so sauber ist.

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

Dies war meine irb-Testlinie, die jeden Schritt zeigte.

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

Und noch ein anderer Weg (=

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)

Nur noch eine Möglichkeit:

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

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

fact(6) => 720

Warum sollte die Standardbibliothek eine faktorielle Methode erfordern, wenn es genau für diesen Zweck einen integrierten Iterator gibt? Es wird genanntupto .

Nein, Sie müssen keine Rekursion verwenden, wie all diese anderen Antworten zeigen.

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

Vielmehr kann der eingebaute Iterator bis zu verwendet werden, um Fakultäten zu berechnen:

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