Etung lan ngasilake faktorial, permutasi lan kombinasi ing Python

Bisnis

Matématika modul standar kanggo fungsi matematika ing Python bisa digunakake kanggo ngitung faktorial. SciPy uga nduweni fungsi kanggo ngetung total permutasi/kombinasi.

Modul itertools uga bisa digunakake kanggo ngasilake permutasi lan kombinasi saka dhaptar (array), lan liya-liyane, lan enumerate.

Ing ngisor iki diterangake ing kene, bebarengan karo kode sampel.

  • faktorial:math.factorial()
  • Hitung jumlah total permutasi
    • math.factorial()
    • scipy.special.perm()
  • Nggawe lan enumerate permutasi saka dhaptar:itertools.permutations()
  • Etung jumlah total kombinasi
    • math.factorial()
    • scipy.special.comb()
    • Carane ora nggunakake math.faktorial()
  • Nggawe lan enumerate kombinasi saka dhaptar:itertools.combinations()
  • Etung jumlah total kombinasi duplikat
  • Gawe lan enumerate kombinasi duplikat saka dhaptar:itertools.combinations_with_replacement()

Minangka conto nggunakake permutasi, ing ngisor iki uga diterangake.

  • Nggawe anagrams saka strings

Yen sampeyan pengin generate kombinasi unsur sawetara listing tinimbang listing siji, nggunakake itertools.product () ing modul itertools.

faktorial:math.factorial()

Modul matematika menehi faktorial fungsi () sing ngasilake faktorial.

import math

print(math.factorial(5))
# 120

print(math.factorial(0))
# 1

Non-integer, nilai negatif bakal nyebabake ValueError.

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

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

Hitung jumlah total permutasi

math.factorial()

Permutasi yaiku jumlah kasus sing r dipilih saka n sing beda lan diselehake ing saurutan.

Jumlah total permutasi, p, dipikolehi kanthi persamaan ing ngisor iki kanthi nggunakake faktorial.

p = n! / (n - r)!

Iku bisa diwilang minangka nderek nggunakake fungsi math.faktorial (), kang ngasilake faktorial. Operator ⌘, sing nindakake divisi integer, digunakake kanggo ngasilake jinis 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()

SciPy nyedhiyakake fungsi scipy.special.perm () sing ngasilake total permutasi. Instalasi SciPy sing kapisah dibutuhake. Kasedhiya saka versi 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
Argumentasi katelu disetel kaya ing ndhuwur kanthi standar lan ngasilake nomer floating point. Elinga yen sampeyan pengin njaluk minangka integer, sampeyan kudu nyetel minangka nderek.
exact=True

Elinga yen mung “ngimpor scipy” ora bakal mbukak modul scipy.special.

Nglakokaké perm () minangka “saka scipy.special impor perm” minangka conto ing ndhuwur, utawa nglakokaké scipy.special.perm () minangka “impor scipy.special”.

Nggawe lan enumerate permutasi saka dhaptar:itertools.permutations()

Ora mung nomer total, nanging uga permutations bisa kui lan enumerated saka dhaftar (arrays), etc.

Gunakake fungsi permutasi () saka modul itertools.

Ngliwati iterable (dhaftar utawa jinis set) minangka argumen pisanan lan jumlah potongan sing bakal dipilih minangka argumen kapindho ngasilake iterator kanggo permutasi kasebut.

import itertools

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

p = itertools.permutations(l, 2)

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

Kanggo enumerate kabeh, sampeyan bisa nggunakake loop for.

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')

Wiwit iku iterator winates, iku uga bisa diowahi kanggo jinis dhaftar karo dhaftar ().

Nalika nomer unsur ing dhaftar dipikolehi karo len (), bisa dikonfirmasi sing cocog karo jumlah total permutations diwilang saka faktorial.

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

Yen argumen kapindho diilangi, permutasi kanggo milih kabeh unsur bakal bali.

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

Ing itertools.permutations (), unsur dianggep adhedhasar posisi, ora Nilai. Nilai duplikat ora dianggep.

l = ['a', 'a']

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

Padha ditrapake kanggo fungsi ing ngisor iki, diterangake ing ngisor iki.

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

Etung jumlah total kombinasi

math.factorial()

Jumlah kombinasi iku jumlah r bêsik kanggo milih saka n bêsik beda. Urutan kasebut ora dianggep kaya ing permutasi.

Jumlah total kombinasi c dipikolehi kanthi persamaan ing ngisor iki.

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

Iku bisa diwilang minangka nderek nggunakake fungsi math.faktorial (), kang ngasilake faktorial. Operator ⌘, sing nindakake divisi integer, digunakake kanggo ngasilake jinis 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()

SciPy nyedhiyakake fungsi scipy.special.comb () sing ngasilake total permutasi. Instalasi SciPy sing kapisah dibutuhake. Kasedhiya saka versi 0.14.0. Elinga yen scipy.misc.comb () ora ngleksanakake pengulangan argumen sing diterangake ing ngisor iki.

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
Kaya scipy.special.perm (), bantahan katelu disetel minangka ndhuwur minangka standar lan ngasilake nomer floating-titik. Elinga yen sampeyan pengin njaluk minangka integer, sampeyan kudu nyetel minangka nderek.
exact=True
Jumlah total kombinasi duplikat uga bisa dipikolehi kanthi argumen kaping papat, pengulangan. Iki diterangake ing ngisor iki.

Maneh, elinga yen mung “impor scipy” ora bakal mbukak modul scipy.special.

Kaya ing conto ing ndhuwur, nglakokaké sisir () minangka “saka scipy.special import comb” utawa nglakokaké scipy.special.comb () minangka “import scipy.special”. Padha ditrapake kanggo “scipy.misc”.

Carane ora nggunakake math.faktorial()

Cara liya sing mung nggunakake perpustakaan standar lan luwih cepet saka cara nggunakake math.faktorial () cara ing ngisor iki.

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

Nggawe lan enumerate kombinasi saka dhaptar:itertools.combinations()

Sampeyan bisa kanggo generate lan enumerate kabeh kombinasi saka dhaptar (susun), etc.. uga nomer total.

Gunakake kombinasi () fungsi modul itertools.

Ngliwati iterable (dhaftar utawa jinis set) minangka argumen pisanan lan jumlah potongan sing bakal dipilih minangka argumen kapindho ngasilake iterator kanggo kombinasi kasebut.

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

Etung jumlah total kombinasi duplikat

Jumlah kombinasi duplikat yaiku jumlah kasus sing r dipilih saka n sing beda-beda, ngidini duplikat.

Jumlah total kombinasi duplikat padha karo jumlah kombinasi kanggo milih (r) saka (n + r – 1) beda.

Mulane, kita bisa nggunakake fungsi sing ditetepake ing ndhuwur kanggo ngetung jumlah total kombinasi.

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

print(combinations_with_replacement_count(4, 2))
# 10

Ing “scipy.special.comb ()” sing diterangake ing ndhuwur, total kombinasi duplikat bisa dipikolehi kanthi nyetel argumen kaping papat “repetition = True.
Elinga yen argumen “pengulangan” ora dileksanakake ing “scipy.misc.comb ()” ing versi sadurunge “SciPy0.14.0”.

from scipy.special import comb

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

Gawe lan enumerate kombinasi duplikat saka dhaptar:itertools.combinations_with_replacement()

Sampeyan bisa kanggo generate lan enumerate kabeh kombinasi duplikat saka dhaptar (larik), etc.. uga nomer total.

Gunakake fungsi combinations_with_replacement () ing modul itertools.

Ngliwati iterable (dhaftar utawa jinis set) minangka argumen pisanan lan jumlah potongan sing bakal dipilih minangka argumen kapindho ngasilake iterator kanggo kombinasi tumpang tindih kasebut.

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

Nggawe anagrams saka strings

Itertools.permutations () nggampangake nggawe permutasi senar (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')

Kanggo gabungke tuple siji karakter ing wektu dadi senar lan nggawe dhaptar, tindakake ing ngisor iki

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

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

Cara gabung (), sing nggabungake unsur dhaptar utawa tuple dadi senar, lan notasi pangerten dhaptar digunakake.