Mag-compute at bumuo ng mga factorial, permutation at kumbinasyon sa Python

Negosyo

Ang karaniwang module math para sa mga mathematical function sa Python ay maaaring gamitin upang mag-compute ng mga factorial. Ang SciPy ay mayroon ding mga function upang kalkulahin ang kabuuang bilang ng mga permutasyon/kombinasyon.

Ang module ng itertools ay maaari ding gamitin upang makabuo ng mga permutasyon at kumbinasyon mula sa mga listahan (mga array), atbp., at ibilang ang mga ito.

Ang mga sumusunod ay ipinaliwanag dito, kasama ang sample code.

  • factorial:math.factorial()
  • Kalkulahin ang kabuuang bilang ng mga permutasyon
    • math.factorial()
    • scipy.special.perm()
  • Bumuo at magbilang ng mga permutasyon mula sa isang listahan:itertools.permutations()
  • Kalkulahin ang kabuuang bilang ng mga kumbinasyon
    • math.factorial()
    • scipy.special.comb()
    • Paano hindi gamitin ang math.factial()
  • Bumuo at magbilang ng mga kumbinasyon mula sa mga listahan:itertools.combinations()
  • Kalkulahin ang kabuuang bilang ng mga duplicate na kumbinasyon
  • Bumuo at magbilang ng mga duplicate na kumbinasyon mula sa isang listahan:itertools.combinations_with_replacement()

Bilang halimbawa ng paggamit ng mga permutasyon, ipinaliwanag din ang mga sumusunod.

  • Lumikha ng mga anagram mula sa mga string

Kung gusto mong bumuo ng kumbinasyon ng mga elemento ng maraming listahan sa halip na isang listahan, gamitin ang itertools.product() sa module ng itertools.

factorial:math.factorial()

Ang math module ay nagbibigay ng function factorial() na nagbabalik ng factorial.

import math

print(math.factorial(5))
# 120

print(math.factorial(0))
# 1

Ang mga negatibong value na hindi integer ay magreresulta sa isang ValueError.

# print(math.factorial(1.5))
# ValueError: factorial() only accepts integral values

# print(math.factorial(-1))
# ValueError: factorial() not defined for negative values

Kalkulahin ang kabuuang bilang ng mga permutasyon

math.factorial()

Ang mga permutasyon ay ang bilang ng mga kaso kung saan pinipili ang r mula sa n magkaibang mga kaso at inilagay sa isang hilera.

Ang kabuuang bilang ng mga permutasyon, p, ay nakuha ng sumusunod na equation gamit ang mga factorial.

p = n! / (n - r)!

Maaari itong kalkulahin bilang mga sumusunod gamit ang function na math.factorial(), na nagbabalik ng factorial. Ang ⌘ operator, na nagsasagawa ng integer division, ay ginagamit upang ibalik ang isang uri ng integer.

def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

print(permutations_count(4, 2))
# 12

print(permutations_count(4, 4))
# 24

scipy.special.perm()

Nagbibigay ang SciPy ng function na scipy.special.perm() na nagbabalik ng kabuuang bilang ng mga permutasyon. Ang isang hiwalay na pag-install ng SciPy ay kinakailangan. Magagamit mula sa bersyon 0.14.0.

from scipy.special import perm

print(perm(4, 2))
# 12.0

print(perm(4, 2, exact=True))
# 12

print(perm(4, 4, exact=True))
# 24

exact=False
Ang pangatlong argumento ay nakatakda sa itaas bilang default at nagbabalik ng isang lumulutang na numero ng punto. Tandaan na kung gusto mong makuha ito bilang isang integer, kailangan mong itakda ito bilang mga sumusunod.
exact=True

Tandaan na ang “import scipy” lang ang hindi maglo-load sa scipy.special na module.

Ipatupad ang perm() bilang “mula sa scipy.special import perm” tulad ng sa halimbawa sa itaas, o isagawa ang scipy.special.perm() bilang “import scipy.special”.

Bumuo at magbilang ng mga permutasyon mula sa isang listahan:itertools.permutations()

Hindi lamang kabuuang mga numero, kundi pati na rin ang mga permutasyon ay maaaring mabuo at mabilang mula sa mga listahan (mga array), atbp.

Gamitin ang permutations() function ng itertools module.

Ang pagpasa ng iterable (listahan o uri ng hanay) bilang unang argumento at ang bilang ng mga pirasong pipiliin bilang pangalawang argumento ay nagbabalik ng iterator para sa permutasyong iyon.

import itertools

l = ['a', 'b', 'c', 'd']

p = itertools.permutations(l, 2)

print(type(p))
# <class 'itertools.permutations'>

Upang mabilang ang lahat ng mga ito, maaari kang gumamit ng para sa loop.

for v in itertools.permutations(l, 2):
    print(v)
# ('a', 'b')
# ('a', 'c')
# ('a', 'd')
# ('b', 'a')
# ('b', 'c')
# ('b', 'd')
# ('c', 'a')
# ('c', 'b')
# ('c', 'd')
# ('d', 'a')
# ('d', 'b')
# ('d', 'c')

Dahil ito ay isang may hangganan na iterator, maaari din itong ma-convert sa isang uri ng listahan na may list().

Kapag ang bilang ng mga elemento sa listahan ay nakuha gamit ang len(), maaari itong makumpirma na tumutugma ito sa kabuuang bilang ng mga permutasyon na kinakalkula mula sa factorial.

p_list = list(itertools.permutations(l, 2))

print(p_list)
# [('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'a'), ('b', 'c'), ('b', 'd'), ('c', 'a'), ('c', 'b'), ('c', 'd'), ('d', 'a'), ('d', 'b'), ('d', 'c')]

print(len(p_list))
# 12

Kung ang pangalawang argumento ay tinanggal, ang permutasyon para sa pagpili ng lahat ng mga elemento ay ibabalik.

for v in itertools.permutations(l):
    print(v)
# ('a', 'b', 'c', 'd')
# ('a', 'b', 'd', 'c')
# ('a', 'c', 'b', 'd')
# ('a', 'c', 'd', 'b')
# ('a', 'd', 'b', 'c')
# ('a', 'd', 'c', 'b')
# ('b', 'a', 'c', 'd')
# ('b', 'a', 'd', 'c')
# ('b', 'c', 'a', 'd')
# ('b', 'c', 'd', 'a')
# ('b', 'd', 'a', 'c')
# ('b', 'd', 'c', 'a')
# ('c', 'a', 'b', 'd')
# ('c', 'a', 'd', 'b')
# ('c', 'b', 'a', 'd')
# ('c', 'b', 'd', 'a')
# ('c', 'd', 'a', 'b')
# ('c', 'd', 'b', 'a')
# ('d', 'a', 'b', 'c')
# ('d', 'a', 'c', 'b')
# ('d', 'b', 'a', 'c')
# ('d', 'b', 'c', 'a')
# ('d', 'c', 'a', 'b')
# ('d', 'c', 'b', 'a')

print(len(list(itertools.permutations(l))))
# 24

Sa itertools.permutations(), ang mga elemento ay ginagamot batay sa posisyon, hindi halaga. Hindi isinasaalang-alang ang mga dobleng halaga.

l = ['a', 'a']

for v in itertools.permutations(l, 2):
    print(v)
# ('a', 'a')
# ('a', 'a')

Ang parehong naaangkop sa mga sumusunod na function, na inilarawan sa ibaba.

  • itertools.combinations()
  • itertools.combinations_with_replacement()

Kalkulahin ang kabuuang bilang ng mga kumbinasyon

math.factorial()

Ang bilang ng mga kumbinasyon ay ang bilang ng mga r piraso na pipiliin mula sa n magkakaibang piraso. Ang pagkakasunud-sunod ay hindi isinasaalang-alang tulad ng sa mga permutasyon.

Ang kabuuang bilang ng mga kumbinasyon c ay nakuha ng sumusunod na equation.

c = n! / (r! * (n - r)!)

Maaari itong kalkulahin bilang mga sumusunod gamit ang function na math.factorial(), na nagbabalik ng factorial. Ang ⌘ operator, na nagsasagawa ng integer division, ay ginagamit upang ibalik ang isang uri ng integer.

def combinations_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

print(combinations_count(4, 2))
# 6

scipy.special.comb()

Nagbibigay ang SciPy ng function na scipy.special.comb() na nagbabalik ng kabuuang bilang ng mga permutasyon. Ang isang hiwalay na pag-install ng SciPy ay kinakailangan. Magagamit mula sa bersyon 0.14.0. Tandaan na hindi ipinapatupad ng scipy.misc.comb() ang pag-uulit ng argumento na inilarawan sa ibaba.

from scipy.special import comb

print(comb(4, 2))
# 6.0

print(comb(4, 2, exact=True))
# 6

print(comb(4, 0, exact=True))
# 1

exact=False
Tulad ng sa scipy.special.perm(), ang ikatlong argumento ay itinakda bilang nasa itaas bilang default at nagbabalik ng isang floating-point na numero. Tandaan na kung gusto mong makuha ito bilang isang integer, kailangan mong itakda ito bilang mga sumusunod.
exact=True
Ang kabuuang bilang ng mga dobleng kumbinasyon ay maaari ding makuha sa ikaapat na argumento, ang pag-uulit. Ito ay inilarawan sa ibaba.

Muli, tandaan na ang “import scipy” lang ang hindi maglo-load sa scipy.special na module.

Tulad ng sa halimbawa sa itaas, i-execute ang comb() bilang “mula sa scipy.special import comb” o i-execute ang scipy.special.comb() bilang “import scipy.special”. Ang parehong naaangkop sa “scipy.misc”.

Paano hindi gamitin ang math.factial()

Ang isa pang paraan na gumagamit lamang ng karaniwang aklatan at mas mabilis kaysa sa pamamaraang gumagamit ng math.factorial() ay ang sumusunod na pamamaraan.

from operator import mul
from functools import reduce

def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom

print(combinations_count(4, 2))
# 6

print(combinations_count(4, 0))
# 1

Bumuo at magbilang ng mga kumbinasyon mula sa mga listahan:itertools.combinations()

Posibleng bumuo at magbilang ng lahat ng kumbinasyon mula sa mga listahan (mga array), atbp. pati na rin ang kabuuang mga numero.

Gamitin ang combinations() function ng itertools module.

Ang pagpasa ng iterable (listahan o uri ng hanay) bilang unang argumento at ang bilang ng mga piraso na pipiliin bilang pangalawang argumento ay nagbabalik ng iterator para sa kumbinasyong iyon.

l = ['a', 'b', 'c', 'd']

c = itertools.combinations(l, 2)

print(type(c))
# <class 'itertools.combinations'>

for v in itertools.combinations(l, 2):
    print(v)
# ('a', 'b')
# ('a', 'c')
# ('a', 'd')
# ('b', 'c')
# ('b', 'd')
# ('c', 'd')

c_list = list(itertools.combinations(l, 2))

print(c_list)
# [('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd'), ('c', 'd')]

print(len(c_list))
# 6

Kalkulahin ang kabuuang bilang ng mga duplicate na kumbinasyon

Ang bilang ng mga duplicate na kumbinasyon ay ang bilang ng mga kaso kung saan ang r ay pinili mula sa n iba’t ibang mga kumbinasyon, na nagbibigay-daan para sa mga duplicate.

Ang kabuuang bilang ng mga duplicate na kumbinasyon ay katumbas ng bilang ng mga kumbinasyong pipiliin (r) sa (n + r – 1) magkaibang mga kumbinasyon.

Samakatuwid, maaari naming gamitin ang function na tinukoy sa itaas upang kalkulahin ang kabuuang bilang ng mga kumbinasyon.

def combinations_with_replacement_count(n, r):
    return combinations_count(n + r - 1, r)

print(combinations_with_replacement_count(4, 2))
# 10

Sa “scipy.special.comb()” na inilarawan sa itaas, ang kabuuang bilang ng mga duplicate na kumbinasyon ay maaaring makuha sa pamamagitan ng pagtatakda ng ikaapat na argumento na “repetition=True.
Tandaan na ang argumentong “pag-uulit” ay hindi ipinatupad sa “scipy.misc.comb()” sa mga bersyon bago ang “SciPy0.14.0”.

from scipy.special import comb

print(comb(4, 2, exact=True, repetition=True))
# 10

Bumuo at magbilang ng mga duplicate na kumbinasyon mula sa isang listahan:itertools.combinations_with_replacement()

Posibleng bumuo at magbilang ng lahat ng mga duplicate na kumbinasyon mula sa mga listahan (mga array), atbp. pati na rin ang kabuuang mga numero.

Gamitin ang combinations_with_replacement() function sa itertools module.

Ang pagpasa ng iterable (listahan o uri ng hanay) bilang unang argumento at ang bilang ng mga pirasong pipiliin bilang pangalawang argumento ay nagbabalik ng iterator para sa magkakapatong na kumbinasyong iyon.

h = itertools.combinations_with_replacement(l, 2)

print(type(h))
# <class 'itertools.combinations_with_replacement'>

for v in itertools.combinations_with_replacement(l, 2):
    print(v)
# ('a', 'a')
# ('a', 'b')
# ('a', 'c')
# ('a', 'd')
# ('b', 'b')
# ('b', 'c')
# ('b', 'd')
# ('c', 'c')
# ('c', 'd')
# ('d', 'd')

h_list = list(itertools.combinations_with_replacement(l, 2))

print(h_list)
# [('a', 'a'), ('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'b'), ('b', 'c'), ('b', 'd'), ('c', 'c'), ('c', 'd'), ('d', 'd')]

print(len(h_list))
# 10

Lumikha ng mga anagram mula sa mga string

Pinapadali ng Itertools.permutations() ang paggawa ng mga string permutations (anagrams).

s = 'arc'

for v in itertools.permutations(s):
    print(v)
# ('a', 'r', 'c')
# ('a', 'c', 'r')
# ('r', 'a', 'c')
# ('r', 'c', 'a')
# ('c', 'a', 'r')
# ('c', 'r', 'a')

Upang pagsamahin ang isang tuple ng isang character sa isang pagkakataon sa isang string at gawin itong isang listahan, gawin ang sumusunod

anagram_list = [''.join(v) for v in itertools.permutations(s)]

print(anagram_list)
# ['arc', 'acr', 'rac', 'rca', 'car', 'cra']

Ang join() na paraan, na nagsasama-sama ng mga elemento ng isang listahan o tuple sa isang string, at ginagamit ang notasyon sa pag-unawa sa listahan.

Copied title and URL