Die Anzahl der zur Berechnung der Wahrscheinlichkeit erforderlichen Skalierungs-, Ordnungs- und Kombinationsmuster. Python verfügt über itertools Referenz: Studieren der Reihenfolge, Kombination und des direkten Produkts mit itertools, mit denen Sie Muster erstellen können. Darüber hinaus verwendet Golang eine eigene Methode zum Erstellen von Mustern, wie in Fälle wie dieser gezeigt. Hier wird eine einfache Methode zur Berechnung der Anzahl der einzelnen Muster in Python3, Ruby, PHP und GoLang beschrieben.
Das Produkt der sequentiellen Multiplikation aufeinanderfolgender Ganzzahlen von 1 bis zu einer bestimmten Zahl. Beispielsweise kann die Gesamtzahl der Anordnungen beim Anordnen von fünf Karten, die als 1 bis 5 in einer Reihe beschrieben sind, durch die folgende Formel berechnet werden.
5! = 5\times4\times3\times2\times1 = 120
In dem Beispiel zum Zeitpunkt der Stornierung wurde angenommen, dass alle 5 Karten verwendet wurden. Wenn jedoch 3 Karten verwendet werden (Duplikate sind nicht zulässig), kann dies nach der folgenden Formel berechnet werden.
{}_5\mathrm{ P }_3 = 5\times4\times3 = 60
Wenn hier eine Vervielfältigung zulässig ist, ist dies wie folgt.
5^3 = 125
Verwenden Sie im Python3-Code einfach den algebraischen Operator (**). In Golang eine Methode wie "math.Pow (5,3)".
Im Fall der Bestellung wurde die Bestellung berücksichtigt, aber wenn die Bestellung nicht berücksichtigt wird, kann beispielsweise die Anzahl, aus der 3 Sorten (dieselbe Art ist nicht zulässig) aus 5 Obstsorten ausgewählt werden, nach der folgenden Formel berechnet werden.
{}_5\mathrm{ C }_3 = \frac{5\times4\times3}{3\times2\times1} = 10
{}_5\mathrm{ H }_3 = {}_{5+3-1}\mathrm{ C }_3 = \frac{7\times6\times5}{3\times2\times1} = 35
Python3
import functools as ft
def permutation(n, k):
if k > n:
return 0
elif 0 < k <= n:
return ft.reduce(lambda x, y:x * y, [n - v for v in range(k)])
else:
return 1
def factorial(n):
return permutation(n, n - 1)
def combination(n, k):
return int(permutation(n, k) / factorial(k))
def homogeneous(n, k):
return combination(n + k - 1, k)
if __name__ == '__main__':
print(permutation(5, 3))
print(factorial(5))
print(combination(5, 3))
print(homogeneous(5, 3))
print(5 ** 3)
60
120
10
35
125
Ruby2.4
def permutation(n, k)
if k > n
0
elsif 0 < k && k <= n then ((n - k + 1)..n).inject(:*)
else 1
end
end
def factorial(n)
permutation(n, n - 1)
end
def combination(n, k)
(permutation(n, k) / factorial(k)).to_i
end
def homogeneous(n, k)
combination(n + k - 1, k)
end
p permutation(5, 3)
p factorial(5)
p combination(5,3)
p homogeneous(5, 3)
p 5**3
Ich glaube, dass die Formel "H" "homogen" bedeutet. Ich habe versucht, es mit dem Quellcode Python3 bzw. GoLang zu realisieren. Der Einfachheit halber wird jedoch zuerst "Permutation" definiert, und die doppelte Reihenfolge wird am Ende beschrieben. Ausgabeergebnis Ausgabeergebnis
60
120
10
35
125
PHP7.1
<?php
function permutation(int $n, int $k) : int {
if ($k > $n) return 0;
elseif (0 < $k && $k <= $n)
return array_reduce(range($n - $k + 1, $n), function ($c, $v) { return $c *= $v; }, 1);
else return 1;
}
function factorial(int $n) : int {
return permutation($n, $n - 1);
}
function combination(int $n, int $k) : int {
return intval(permutation($n, $k) / factorial($k));
}
function homogeneous(int $n, int $k) : int {
return combination($n + $k - 1, $k);
}
print(permutation(5, 3). PHP_EOL);
print(factorial(5). PHP_EOL);
print(combination(5, 3). PHP_EOL);
print(homogeneous(5, 3). PHP_EOL);
print(5 ** 3);
Ausgabeergebnis
60
120
10
35
125
Golang
package main;
import (
"fmt"
"math"
)
func permutation(n int, k int) int {
v := 1
if 0 < k && k <= n {
for i := 0; i < k; i++ {
v *= (n - i)
}
} else if k > n {
v = 0
}
return v
}
func factorial(n int) int {
return permutation(n, n - 1)
}
func combination(n int, k int) int {
return permutation(n, k) / factorial(k)
}
func homogeneous(n int, k int) int {
return combination(n + k - 1, k)
}
func main () {
fmt.Printf("%v\n", permutation(5, 3))
fmt.Printf("%v\n", factorial(5))
fmt.Printf("%v\n", combination(5, 3))
fmt.Printf("%v\n", homogeneous(5, 3))
fmt.Printf("%v\n", math.Pow(5, 3))
}
Ausgabeergebnis
60
120
10
35
125
In der überlappenden Kombination wird angenommen, dass es 3 oder mehr Früchte in jedem der 5 Sorten gibt, aber wenn es eine Obergrenze wie jeweils 2 gibt, kann sie mit keiner der oben genannten Methoden abgeleitet werden, so dass das Einschlussprinzip berücksichtigt werden muss. Gibt es. Diese Idee ist durchaus anwendbar. Beispielsweise ist es möglich, die Anzahl zu berechnen, wenn die Würfel dreimal geschüttelt werden und die Gesamtzahl der Würfe zwölf beträgt. Das Verknüpfen von Früchten mit diesem Würfelbeispiel ist gleichbedeutend mit der Anzahl von 12 Früchten, die aus jeder der 6 Früchte von 3 Arten entnommen wurden. Unter hier erfahren Sie, wie Sie diese begrenzte doppelte Kombination mit Python3 und Go finden.
Recommended Posts