Python හි සාධක, ප්‍රගමන සහ සංයෝජන ගණනය කර ජනනය කරන්න

ව්යාපාරික

Python හි ගණිතමය ශ්‍රිත සඳහා සම්මත මොඩියුල ගණිතය සාධක ගණනය කිරීමට භාවිතා කළ හැක. SciPy හි මුළු ප්‍රගමන/සංයෝජන සංඛ්‍යාව ගණනය කිරීමේ ක්‍රියාකාරකම් ද ඇත.

ලැයිස්තු (අරා) ආදියෙන් ප්‍රගමන සහ සංයෝජන උත්පාදනය කිරීමට සහ ඒවා ගණන් කිරීමට itertools මොඩියුලය ද භාවිතා කළ හැක.

නියැදි කේතය සමඟ පහත විස්තර මෙහි විස්තර කෙරේ.

  • සාධකමය:math.factorial()
  • සම්පූර්ණ විපර්යාස ගණන ගණනය කරන්න
    • math.factorial()
    • scipy.special.perm()
  • ලැයිස්තුවකින් ප්‍රතිවර්තන ජනනය කිරීම සහ ගණන් කිරීම:itertools.permutations()
  • මුළු සංයෝජන ගණන ගණනය කරන්න
    • math.factorial()
    • scipy.special.comb()
    • math.factorial() භාවිතා නොකරන්නේ කෙසේද
  • ලැයිස්තු වලින් සංයෝජන උත්පාදනය කරන්න සහ ගණන් කරන්න:itertools.combinations()
  • අනුපිටපත් සංයෝජන මුළු ගණන ගණනය කරන්න
  • ලැයිස්තුවකින් අනුපිටපත් සංයෝජන උත්පාදනය කිරීම සහ ගණන් කිරීම:itertools.combinations_with_replacement()

ප්‍රතිවර්තන භාවිතා කිරීමේ උදාහරණයක් ලෙස, පහත කරුණු ද පැහැදිලි කෙරේ.

  • නූල් වලින් ඇනග්‍රෑම් සාදන්න

ඔබට තනි ලැයිස්තුගත කිරීමක් වෙනුවට බහු ලැයිස්තුගත කිරීම් වල මූලද්‍රව්‍යවල එකතුවක් ජනනය කිරීමට අවශ්‍ය නම්, itertools මොඩියුලයේ itertools.product() භාවිතා කරන්න.

සාධකමය:math.factorial()

ගණිත මොඩියුලය කාරකය ආපසු ලබා දෙන 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()

පර්මියුටේෂන් යනු n විවිධ ඒවායින් r තෝරාගෙන පේළියක තබන අවස්ථා ගණනයි.

සම්පූර්ණ ප්‍රගමන සංඛ්‍යාව, p, සාධක භාවිතා කරමින් පහත සමීකරණය මගින් ලබා ගනී.

p = n! / (n - r)!

එය factorial නැවත ලබා දෙන 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

Scipy.special මොඩියුලය “ආනයන scipy” පමණක් පූරණය නොකරන බව සලකන්න.

ඉහත උදාහරණයේ මෙන් “scipy.special import perm” ලෙස perm() ක්‍රියාත්මක කරන්න, නැතහොත් scipy.special.perm() “import scipy.special” ලෙස ක්‍රියාත්මක කරන්න.

ලැයිස්තුවකින් ප්‍රතිවර්තන ජනනය කිරීම සහ ගණන් කිරීම:itertools.permutations()

සම්පූර්ණ සංඛ්‍යා පමණක් නොව, ලැයිස්තු (අරා) ආදියෙන් ප්‍රතිවර්තන ජනනය කර ගණනය කළ හැක.

itertools මොඩියුලයේ 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() සමඟ ලබා ගත් විට, එය සාධකයෙන් ගණනය කරන ලද මුළු ප්‍රගමන සංඛ්‍යාවට ගැළපෙන බව තහවුරු කළ හැක.

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

සංයෝජන ගණන යනු n විවිධ කෑලි වලින් තෝරා ගැනීමට ඇති r කෑලි ගණනයි. අනුපිළිවෙල ප්‍රතිවර්තනවල මෙන් නොසැලකේ.

c හි සම්පූර්ණ සංයෝජන සංඛ්‍යාව පහත සමීකරණය මගින් ලබා ගනී.

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

එය factorial නැවත ලබා දෙන 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(), තුන්වන තර්කය පෙරනිමියෙන් ඉහත පරිදි සකසා ඇති අතර පාවෙන ලක්ෂ්‍ය අංකයක් ලබා දෙයි. ඔබට එය පූර්ණ සංඛ්‍යාවක් ලෙස ලබා ගැනීමට අවශ්‍ය නම්, එය පහත පරිදි සැකසිය යුතු බව සලකන්න.
exact=True
සිව්වන තර්කය වන පුනරාවර්තනය සමඟ අනුපිටපත් සංයෝජනවල මුළු සංඛ්‍යාව ද ලබා ගත හැකිය. මෙය පහත විස්තර කෙරේ.

නැවතත්, “import scipy” පමණක් scipy.special මොඩියුලය පූරණය නොකරන බව සලකන්න.

ඉහත උදාහරණයේ මෙන්, comb() “scipy.special import comb” ලෙස හෝ 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 මොඩියුලයේ සංයෝජන() ශ්‍රිතය භාවිතා කරන්න.

පුනරාවර්තනය කළ හැකි (ලැයිස්තුව හෝ කට්ටල වර්ගය) පළමු තර්කය ලෙස සහ දෙවන තර්කය ලෙස තෝරා ගත යුතු කෑලි ගණන පසු කිරීමෙන් එම සංයෝජනය සඳහා පුනරාවර්තකය ලබා දේ.

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

අනුපිටපත් සංයෝජන මුළු ගණන ගණනය කරන්න

අනුපිටපත් සංයෝජන ගණන යනු අනුපිටපත් සඳහා ඉඩ සලසන විවිධ n වලින් r තෝරා ගන්නා අවස්ථා ගණනයි.

අනුපිටපත් සංයෝජනවල මුළු සංඛ්‍යාව (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” සැකසීමෙන් සම්පූර්ණ අනුපිටපත් සංයෝජන ගණන ලබා ගත හැක.
“SciPy0.14.0” ට පෙර අනුවාද වල “scipy.misc.comb()” හි “පුනරාවර්තනය” යන තර්කය ක්‍රියාත්මක කර නොමැති බව සලකන්න.

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

නූල් වලින් ඇනග්‍රෑම් සාදන්න

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

වරකට එක් අක්ෂරයක ටපල් එකක් තන්තුවකට ඒකාබද්ධ කර එය ලැයිස්තුවක් බවට පත් කිරීමට, පහත දේ කරන්න

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

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

ලැයිස්තුවක හෝ ටපල් එකක මූලද්‍රව්‍ය තන්තුවකට සම්බන්ධ කරන join() ක්‍රමය සහ ලැයිස්තු අවබෝධතා අංකනය භාවිතා වේ.

Copied title and URL