Python ရှိ factorials၊ permutations နှင့် ပေါင်းစပ်မှုများကို တွက်ချက်ပြီး ထုတ်လုပ်ပါ။

စီးပွားရေးလုပ်ငန်း

Python ရှိ သင်္ချာလုပ်ငန်းဆောင်တာများအတွက် စံမော်ဂျူးသင်္ချာသင်္ချာကို factorial များကိုတွက်ချက်ရန်အတွက် အသုံးပြုနိုင်ပါသည်။ SciPy တွင် permutations/combinations စုစုပေါင်းအရေအတွက်ကို တွက်ချက်ရန် လုပ်ဆောင်ချက်များရှိသည်။

Itertools မော်ဂျူးကို စာရင်းများ (အခင်းအကျင်းများ) စသည်တို့မှ ကူးပြောင်းမှုများနှင့် ပေါင်းစပ်မှုများကို ထုတ်ပေးရန်နှင့် ၎င်းတို့ကို စာရင်းပေးသွင်းရန်အတွက်လည်း အသုံးပြုနိုင်သည်။

နမူနာကုဒ်နှင့်အတူ အောက်ပါတို့ကို ဤနေရာတွင် ရှင်းပြထားသည်။

  • စက်ရုံအလုပ်ရုံ:math.factorial()
  • ပြောင်းလဲမှုစုစုပေါင်းအရေအတွက်ကို တွက်ချက်ပါ။
    • math.factorial()
    • scipy.special.perm()
  • စာရင်းတစ်ခုမှ အပြောင်းအလဲများကို ဖန်တီးပြီး စာရင်းကောက်ပါ။:itertools.permutations()
  • ပေါင်းစပ်စုစုပေါင်းအရေအတွက်ကို တွက်ချက်ပါ။
    • math.factorial()
    • scipy.special.comb()
    • math.factorial() မသုံးရနည်း
  • စာရင်းများမှ ပေါင်းစပ်မှုများကို ဖန်တီးပြီး စာရင်းကောက်ပါ။:itertools.combinations()
  • ထပ်နေသောပေါင်းစပ်မှု စုစုပေါင်းအရေအတွက်ကို တွက်ချက်ပါ။
  • စာရင်းတစ်ခုမှ ပွားနေသော ပေါင်းစပ်မှုများကို ဖန်တီးပြီး စာရင်းကောက်ပါ။:itertools.combinations_with_replacement()

အပြောင်းအရွှေ့များကို အသုံးပြုခြင်း၏ ဥပမာတစ်ခုအနေဖြင့် အောက်ပါတို့ကိုလည်း ရှင်းပြထားပါသည်။

  • strings များမှ anagrams ကိုဖန်တီးပါ။

စာရင်းတစ်ခုတည်းအစား များစွာသောစာရင်းများ၏ဒြပ်စင်များပေါင်းစပ်ဖန်တီးလိုပါက itertools မော်ဂျူးရှိ itertools.product() ကို အသုံးပြုပါ။

စက်ရုံအလုပ်ရုံ:math.factorial()

သင်္ချာ module သည် factorial ကိုပြန်ပေးသည့် function factorial() ကိုပေးသည်။

import math

print(math.factorial(5))
# 120

print(math.factorial(0))
# 1

ကိန်းပြည့်မဟုတ်သော၊ အနုတ်တန်ဖိုးများသည် ValueError ဖြစ်ပေါ်လိမ့်မည်။

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

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

ပြောင်းလဲမှုစုစုပေါင်းအရေအတွက်ကို တွက်ချက်ပါ။

math.factorial()

Permutations များသည် r ကို n မတူညီသော အရာများမှ ရွေးချယ်ပြီး အတန်းထဲတွင် ထည့်ထားသည့် အမှုအရေအတွက်များဖြစ်သည်။

Factorials များကို အသုံးပြု၍ အောက်ပါညီမျှခြင်းများဖြင့် ကူးပြောင်းခြင်း စုစုပေါင်းအရေအတွက်၊ p ကို ရရှိသည်။

p = n! / (n - r)!

factorial ကို ပြန်ပေးသည့် function math.factorial() ကို အသုံးပြု၍ အောက်ပါအတိုင်း တွက်ချက်နိုင်ပါသည်။ ကိန်းပြည့်ခွဲဝေမှုကို လုပ်ဆောင်သည့် ⌘ အော်ပရေတာအား ကိန်းပြည့်အမျိုးအစားကို ပြန်ပေးရန်အတွက် အသုံးပြုသည်။

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 သည် ပြောင်းလဲမှုစုစုပေါင်းအရေအတွက်ကို ပြန်ပေးသည့် scipy.special.perm() လုပ်ဆောင်ချက်ကို ပံ့ပိုးပေးပါသည်။ သီးခြား SciPy ထည့်သွင်းမှု လိုအပ်သည်။ ဗားရှင်း 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

“ import scipy” သာလျှင် scipy.special module ကို တင်မည်မဟုတ်ကြောင်း သတိပြုပါ။

အထက်ဥပမာတွင်ကဲ့သို့ “ from scipy.special import perm” အဖြစ်၊ သို့မဟုတ် scipy.special.perm() ကို “ import scipy.special” အဖြစ် လုပ်ဆောင်ပါ။

စာရင်းတစ်ခုမှ အပြောင်းအလဲများကို ဖန်တီးပြီး စာရင်းကောက်ပါ။:itertools.permutations()

စုစုပေါင်း ဂဏန်းများသာမက စာရင်းများ (အခင်းအကျင်းများ) စသည်တို့မှ ထုတ်ပေးပြီး စာရင်းကောက်နိုင်သည်။

itertools module ၏ permutations() လုပ်ဆောင်ချက်ကို အသုံးပြုပါ။

ပထမအငြင်းအခုံအဖြစ် ထပ်ကာထပ်ကာပြုလုပ်နိုင်သော (စာရင်း သို့မဟုတ် သတ်မှတ်အမျိုးအစား) ကိုဖြတ်ခြင်းဖြင့် ဒုတိယအငြင်းအခုံအဖြစ် ရွေးချယ်ရမည့်အပိုင်းအရေအတွက်သည် ထိုပြောင်းလဲမှုအတွက် ထပ်တလဲလဲပြန်ပေးသည်။

import itertools

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

p = itertools.permutations(l, 2)

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

၎င်းတို့အားလုံးကို ရေတွက်ရန် for 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')

၎င်းသည် အကန့်အသတ်ဖြင့် ပြန်တမ်းတင်သူဖြစ်သောကြောင့်၊ ၎င်းကို list() ဖြင့် စာရင်းအမျိုးအစားအဖြစ်လည်း ပြောင်းနိုင်သည်။

စာရင်းရှိဒြပ်စင်အရေအတွက်ကို len() ဖြင့် ရယူသောအခါ ၎င်းသည် factorial မှတွက်ချက်ထားသော စုစုပေါင်း permutation အရေအတွက်နှင့် ကိုက်ညီကြောင်း အတည်ပြုနိုင်သည်။

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

itertools.permutations() တွင် ဒြပ်စင်များကို တန်ဖိုးမဟုတ်ဘဲ ရာထူးအပေါ် အခြေခံ၍ ဆက်ဆံသည်။ ပွားနေသောတန်ဖိုးများကို ထည့်သွင်းစဉ်းစားမည်မဟုတ်ပါ။

l = ['a', 'a']

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

အောက်တွင်ဖော်ပြထားသော အောက်ပါလုပ်ဆောင်ချက်များနှင့် တူညီပါသည်။

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

ပေါင်းစပ်စုစုပေါင်းအရေအတွက်ကို တွက်ချက်ပါ။

math.factorial()

ပေါင်းစပ်အရေအတွက်သည် မတူညီသောအပိုင်းများမှ ရွေးချယ်ရန် r အပိုင်းအရေအတွက်ဖြစ်သည်။ အမိန့်ကို အပြောင်းအလဲအဖြစ် ထည့်သွင်းမစဉ်းစားပါ။

ပေါင်းစပ်မှု စုစုပေါင်း အရေအတွက် c ကို အောက်ပါညီမျှခြင်းဖြင့် ရရှိသည်။

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

factorial ကို ပြန်ပေးသည့် function math.factorial() ကို အသုံးပြု၍ အောက်ပါအတိုင်း တွက်ချက်နိုင်ပါသည်။ ကိန်းပြည့်ခွဲဝေမှုကို လုပ်ဆောင်သည့် ⌘ အော်ပရေတာအား ကိန်းပြည့်အမျိုးအစားကို ပြန်ပေးရန်အတွက် အသုံးပြုသည်။

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 သည် ပြောင်းလဲမှုစုစုပေါင်းအရေအတွက်ကို ပြန်ပေးသည့် scipy.special.comb() လုပ်ဆောင်ချက်ကို ပံ့ပိုးပေးပါသည်။ သီးခြား SciPy ထည့်သွင်းမှု လိုအပ်သည်။ ဗားရှင်း 0.14.0 မှ ရရှိနိုင်ပါသည်။ scipy.misc.comb() သည် အောက်တွင်ဖော်ပြထားသော အငြင်းပွားမှုကို ထပ်ခါတလဲလဲ လုပ်ဆောင်ခြင်းမရှိကြောင်း သတိပြုပါ။

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
scipy.special.perm() ကဲ့သို့ပင် တတိယအငြင်းအခုံကို ပုံသေဖြင့် အထက်တွင်သတ်မှတ်ထားပြီး floating-point နံပါတ်ကို ပြန်ပေးသည်။ ၎င်းကို ကိန်းပြည့်အဖြစ် ရယူလိုပါက အောက်ပါအတိုင်း သတ်မှတ်ရန် လိုအပ်ကြောင်း သတိပြုပါ။
exact=True
စတုတ္ထမြောက် အငြင်းအခုံ၊ ထပ်တလဲလဲ ပေါင်းစပ်မှု စုစုပေါင်း အရေအတွက်ကိုလည်း ရရှိနိုင်သည်။ ဒါကို အောက်မှာ ဖော်ပြထားပါတယ်။

ထပ်မံ၍ “ import scipy” သာလျှင် scipy.special module ကို တင်မည်မဟုတ်ကြောင်း သတိပြုပါ။

အထက်ဖော်ပြပါ ဥပမာတွင်အတိုင်း၊ “ မှ scipy.special import comb” အဖြစ် comb() ကို execute သို့မဟုတ် “ import scipy.special.comb() အဖြစ် “ import scipy.special” အဖြစ် လုပ်ဆောင်ပါ။ “ scipy.misc” နှင့် အလားတူသည်။

math.factorial() မသုံးရနည်း

စံစာကြည့်တိုက်ကိုသာအသုံးပြုပြီး math.factorial() ကိုအသုံးပြုသည့်နည်းလမ်းထက် ပိုမိုမြန်ဆန်သော အခြားနည်းလမ်းမှာ အောက်ပါနည်းလမ်းဖြစ်သည်။

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

စာရင်းများ (အခင်းအကျင်းများ) စသည်တို့အပြင် စုစုပေါင်း နံပါတ်များမှ ပေါင်းစပ်မှုအားလုံးကို ထုတ်လုပ်၍ ရေတွက်နိုင်သည်။

itertools module ၏ ပေါင်းစပ်မှုများ() လုပ်ဆောင်ချက်ကို အသုံးပြုပါ။

ပထမအငြင်းအခုံအဖြစ် ထပ်ကာထပ်ကာပြုလုပ်နိုင်သော (စာရင်း သို့မဟုတ် သတ်မှတ်အမျိုးအစား) နှင့် ဒုတိယအငြင်းအခုံအဖြစ် ရွေးချယ်ရမည့်အပိုင်းအရေအတွက်ကို ၎င်းပေါင်းစပ်မှုအတွက် ထပ်ဆင့်ပြန်ပေးသည်။

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

ထပ်နေသောပေါင်းစပ်မှု စုစုပေါင်းအရေအတွက်ကို တွက်ချက်ပါ။

ပွားနေသောပေါင်းစပ်မှုအရေအတွက်သည် r ကို n မတူညီသောအရာများမှ ရွေးချယ်ထားသည့် အမှုအရေအတွက်ဖြစ်ပြီး ပွားမှုများကို ခွင့်ပြုသည်။

ထပ်နေသောပေါင်းစပ်မှုစုစုပေါင်းအရေအတွက်သည် (n + r – 1) ကွဲပြားသော (n + r – 1) ထဲမှ (r) ကိုရွေးချယ်ရန် ပေါင်းစပ်အရေအတွက်နှင့် ညီမျှသည်။

ထို့ကြောင့်၊ ပေါင်းစပ်စုစုပေါင်းအရေအတွက်ကို တွက်ချက်ရန် အထက်ဖော်ပြပါ လုပ်ဆောင်ချက်ကို ကျွန်ုပ်တို့ အသုံးပြုနိုင်ပါသည်။

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

print(combinations_with_replacement_count(4, 2))
# 10

အထက်တွင်ဖော်ပြထားသော “ scipy.special.comb()” တွင်၊ စတုတ္ထမြောက် အကြောင်းပြချက် “ repetition=True” ကို သတ်မှတ်ခြင်းဖြင့် ထပ်နေသော ပေါင်းစပ်မှု စုစုပေါင်းအရေအတွက်ကို ရယူနိုင်ပါသည်။
အငြင်းအခုံ “ ထပ်တလဲလဲ” ကို “ Scipy.misc.comb()” တွင် “ SciPy0.14.0” မတိုင်မီ ဗားရှင်းများတွင် အကောင်အထည်မဖော်ကြောင်း သတိပြုပါ။

from scipy.special import comb

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

စာရင်းတစ်ခုမှ ပွားနေသော ပေါင်းစပ်မှုများကို ဖန်တီးပြီး စာရင်းကောက်ပါ။:itertools.combinations_with_replacement()

စာရင်းများ (အခင်းအကျင်းများ) စသည်တို့အပြင် စုစုပေါင်း နံပါတ်များမှ ပွားနေသော ပေါင်းစပ်မှုအားလုံးကို ထုတ်ပေးနိုင်ပြီး ရေတွက်နိုင်သည်။

itertools မော်ဂျူးတွင် ပေါင်းစပ်_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

strings များမှ anagrams ကိုဖန်တီးပါ။

Itertools.permutations() သည် 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')

တစ်ကြိမ်လျှင် စာလုံးတစ်လုံး၏ tuple ကို string တစ်ခုအဖြစ် ပေါင်းစပ်ပြီး စာရင်းတစ်ခုအဖြစ် ပြုလုပ်ရန် အောက်ပါတို့ကို လုပ်ဆောင်ပါ။

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

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

စာရင်းတစ်ခု သို့မဟုတ် tuple ၏ဒြပ်စင်များကို စာကြောင်းတစ်ခုသို့ ပေါင်းစည်းပြီး စာရင်းနားလည်မှုအမှတ်အသားကို အသုံးပြုသည့် Join() နည်းလမ်း။