Израчунајте и генеришете факторијеле, пермутације и комбинације у Питхон-у

Бусинесс

Стандардна модулска математика за математичке функције у Питхон-у може се користити за израчунавање факторијала. СциПи такође има функције за израчунавање укупног броја пермутација/комбинација.

Модул итертоолс се такође може користити за генерисање пермутација и комбинација из листа (низова) итд., и за њихово набрајање.

Овде је објашњено следеће, заједно са примером кода.

  • факторијел:math.factorial()
  • Израчунајте укупан број пермутација
    • math.factorial()
    • scipy.special.perm()
  • Генеришите и набројите пермутације са листе:itertools.permutations()
  • Израчунајте укупан број комбинација
    • math.factorial()
    • scipy.special.comb()
    • Како не користити матх.фацториал()
  • Генеришите и набројите комбинације са листа:itertools.combinations()
  • Израчунајте укупан број дупликата комбинација
  • Генеришите и набројите дупле комбинације са листе:itertools.combinations_with_replacement()

Као пример коришћења пермутација, објашњено је и следеће.

  • Креирајте анаграме од низова

Ако желите да генеришете комбинацију елемената вишеструких листа уместо једне листе, користите итертоолс.продуцт() у модулу итертоолс.

факторијел:math.factorial()

Математички модул обезбеђује функцију фацториал() која враћа факторијел.

import math

print(math.factorial(5))
# 120

print(math.factorial(0))
# 1

Не-целобројне негативне вредности ће резултирати ВалуеЕррор.

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

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

Израчунајте укупан број пермутација

math.factorial()

Пермутације су број случајева у којима је р изабрано између н различитих и постављено у ред.

Укупан број пермутација, п, добија се следећом једначином коришћењем факторијала.

p = n! / (n - r)!

Може се израчунати на следећи начин помоћу функције матх.фацториал(), која враћа факторијел. Оператор ⌘, који врши целобројно дељење, користи се за враћање целобројног типа.

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

сципи.специал.перм()

СциПи обезбеђује функцију сципи.специал.перм() која враћа укупан број пермутација. Потребна је посебна СциПи инсталација. Доступно од верзије 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
Трећи аргумент је подразумевано постављен као горе и враћа број у покретном зарезу. Имајте на уму да ако желите да га добијете као цео број, морате га поставити на следећи начин.
exact=True

Имајте на уму да само „импорт сципи“ неће учитати сципи.специал модул.

Извршите перм() као „из сципи.специал импорт перм“ као у горњем примеру, или извршите сципи.специал.перм() као „импорт сципи.специал“.

Генеришите и набројите пермутације са листе:itertools.permutations()

Не само укупни бројеви, већ и пермутације се могу генерисати и набрајати из листа (низова) итд.

Користите функцију пермутатионс() модула итертоолс.

Преношење итеративног типа (тип листе или скупа) као првог аргумента и броја делова који ће бити изабрани као други аргумент враћа итератор за ту пермутацију.

import itertools

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

p = itertools.permutations(l, 2)

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

Да бисте их све набројали, можете користити фор петљу.

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

Пошто је то коначан итератор, такође се може конвертовати у тип листе помоћу листе().

Када се број елемената на листи добије помоћу лен(), може се потврдити да се поклапа са укупним бројем пермутација израчунатим из факторијала.

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

Ако је други аргумент изостављен, враћа се пермутација за избор свих елемената.

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

У итертоолс.пермутатионс(), елементи се третирају на основу позиције, а не вредности. Дупликати вредности се не узимају у обзир.

l = ['a', 'a']

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

Исто важи и за следеће функције, описане у наставку.

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

Израчунајте укупан број комбинација

math.factorial()

Број комбинација је број р комада које можете изабрати између н различитих комада. Редослед се не сматра као у пермутацијама.

Укупан број комбинација ц добија се следећом једначином.

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

Може се израчунати на следећи начин помоћу функције матх.фацториал(), која враћа факторијел. Оператор ⌘, који врши целобројно дељење, користи се за враћање целобројног типа.

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

СциПи обезбеђује функцију сципи.специал.цомб() која враћа укупан број пермутација. Потребна је посебна СциПи инсталација. Доступно од верзије 0.14.0. Имајте на уму да сципи.мисц.цомб() не имплементира доле описано понављање аргумента.

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
Као и код сципи.специал.перм(), трећи аргумент је подразумевано постављен као горе и враћа број са покретним зарезом. Имајте на уму да ако желите да га добијете као цео број, морате га поставити на следећи начин.
exact=True
Укупан број дупликата комбинација се такође може добити са четвртим аргументом, понављањем. Ово је описано у наставку.

Опет, имајте на уму да само „импорт сципи“ неће учитати сципи.специал модул.

Као у горњем примеру, извршите цомб() као „из сципи.специал импорт цомб“ или извршите сципи.специал.цомб() као „импорт сципи.специал“. Исто важи и за „сципи.мисц“.

Како не користити матх.фацториал()

Други метод који користи само стандардну библиотеку и бржи је од метода који користи матх.фацториал() је следећи метод.

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

Генеришите и набројите комбинације са листа:itertools.combinations()

Могуће је генерисати и набрајати све комбинације из листа (низова) итд. као и укупне бројеве.

Користите функцију комбинације() модула итертоолс.

Прослеђивање итеративног типа (тип листе или скупа) као првог аргумента и броја делова који ће бити изабрани као други аргумент враћа итератор за ту комбинацију.

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

Израчунајте укупан број дупликата комбинација

Број дупликата комбинација је број случајева у којима је р изабрано између н различитих, дозвољавајући дупликате.

Укупан број дупликата комбинација једнак је броју комбинација које треба изабрати (р) од (н + р – 1) различитих.

Због тога можемо користити функцију дефинисану изнад да израчунамо укупан број комбинација.

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

print(combinations_with_replacement_count(4, 2))
# 10

У горе описаном „сципи.специал.цомб()“, укупан број дуплих комбинација се може добити постављањем четвртог аргумента „репетитион=Труе.
Имајте на уму да аргумент „репетитион“ није имплементиран у „сципи.мисц.цомб()“ у верзијама пре „СциПи0.14.0“.

from scipy.special import comb

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

Генеришите и набројите дупле комбинације са листе:itertools.combinations_with_replacement()

Могуће је генерисати и набрајати све дупле комбинације из листа (низова) итд. као и укупне бројеве.

Користите функцију комбинације_витх_реплацемент() у модулу итертоолс.

Прослеђивање итеративног типа (тип листе или скупа) као првог аргумента и броја делова који ће бити изабрани као други аргумент враћа итератор за ту комбинацију преклапања.

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

Креирајте анаграме од низова

Итертоолс.пермутатионс() олакшава креирање пермутација стрингова (анаграма).

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

Да бисте комбиновали низ од једног по једног знака у низ и претворили га у листу, урадите следеће

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

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

Користи се метода јоин(), која спаја елементе листе или тупле у стринг, и нотација разумевања листе.

Copied title and URL