Le nombre de modèles d'échelle, d'ordre et de combinaison requis pour calculer la probabilité. python a itertools Référence: étude de l'ordre, de la combinaison et du produit direct par itertools, qui vous permet de créer des modèles. De plus, Golang utilise sa propre méthode pour créer des motifs, comme indiqué dans Cas comme celui-ci. Ici, une méthode simple pour calculer le nombre de chaque motif est décrite respectivement dans Python3, Ruby, PHP et GoLang.
Produit de la multiplication séquentielle d'entiers consécutifs de 1 à un certain nombre. Par exemple, le nombre total d'arrangements lors de la disposition de cinq cartes décrites de 1 à 5 dans une rangée peut être calculé par la formule suivante.
5! = 5\times4\times3\times2\times1 = 120
Dans l'exemple au moment de l'annulation, on a supposé que les 5 cartes étaient toutes utilisées, mais lorsque 3 cartes sont utilisées (la duplication n'est pas autorisée), il peut être calculé par la formule suivante.
{}_5\mathrm{ P }_3 = 5\times4\times3 = 60
Ici, lorsque la duplication est autorisée, c'est comme suit.
5^3 = 125
Dans le code Python3, utilisez simplement l'opérateur algébrique (**). Dans Golang, une méthode comme math.Pow (5,3).
Dans le cas de la commande, la commande a été prise en considération, mais si la commande n'est pas prise en considération, par exemple, le nombre lorsque 3 types (le même type n'est pas autorisé) sont sélectionnés parmi 5 types de fruits peut être calculé par la formule suivante.
{}_5\mathrm{ C }_3 = \frac{5\times4\times3}{3\times2\times1} = 10
Lors de la combinaison, il était censé sélectionner 3 types parmi 5 types de fruits sans permettre la duplication, mais autoriser le même type et sélectionner 3 types de fruits (3 ou plus de chacun des 5 types de fruits) S'il y en a), il peut être calculé par la formule suivante. Je pense que la formule «H» signifie «homogène».
{}_5\mathrm{ H }_3 = {}_{5+3-1}\mathrm{ C }_3 = \frac{7\times6\times5}{3\times2\times1} = 35
J'ai essayé de le réaliser avec Python3 et GoLang respectivement. Cependant, pour des raisons de commodité, la "permutation" est définie en premier et l'ordre des doublons est décrit à la fin.
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)
Résultat de sortie
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
Résultat de sortie
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);
Résultat de sortie
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))
}
Résultat de sortie
60
120
10
35
125
Dans la combinaison de chevauchement, on suppose qu'il y a 3 fruits ou plus dans chacun des 5 types, mais s'il y a une limite supérieure telle que 2 chacun, elle ne peut être dérivée par aucune des méthodes ci-dessus, il est donc nécessaire de considérer le principe d'inclusion. y a-t-il. Cette idée est tout à fait applicable, par exemple, il est possible de calculer le nombre lorsque les dés sont secoués trois fois et le nombre total de lancers est de douze. Lier les fruits à cet exemple de dés est synonyme du nombre de 12 fruits prélevés sur chacun des 6 fruits de 3 types. Voir ici pour savoir comment trouver cette limite supérieure de combinaisons en double avec Python3 et Go.
Recommended Posts