पायथनमध्ये फॅक्टोरियल, क्रमपरिवर्तन आणि संयोजनांची गणना करा आणि तयार करा

व्यवसाय

पायथनमधील गणितीय कार्यांसाठी मानक मॉड्यूल गणिताचा वापर फॅक्टोरियल्सची गणना करण्यासाठी केला जाऊ शकतो. 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.product() चा वापर itertools मॉड्यूलमध्ये करा.

तथ्यात्मक:math.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()

क्रमपरिवर्तन ही प्रकरणांची संख्या आहे जिथे r वेगवेगळ्या n मधून निवडला जातो आणि एका ओळीत ठेवला जातो.

क्रमपरिवर्तनांची एकूण संख्या, p, खालील समीकरणाने फॅक्टोरियल वापरून मिळवली जाते.

p = n! / (n - r)!

हे फंक्शन 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” scipy.special मॉड्यूल लोड करणार नाही.

वरील उदाहरणाप्रमाणे perm() “from scipy.special import perm” म्हणून कार्यान्वित करा किंवा scipy.special.perm() ला “इम्पोर्ट 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 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)!)

हे फंक्शन 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
चौथ्या युक्तिवाद, पुनरावृत्तीसह डुप्लिकेट संयोजनांची एकूण संख्या देखील मिळवता येते. हे खाली वर्णन केले आहे.

पुन्हा, लक्षात घ्या की फक्त “इम्पोर्ट scipy” ने scipy.special मॉड्यूल लोड होणार नाही.

वरील उदाहरणाप्रमाणे, comb() ला “from scipy.special import comb” म्हणून कार्यान्वित करा किंवा scipy.special.comb() “इम्पोर्ट 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 मॉड्यूलचे 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

डुप्लिकेट संयोजनांची एकूण संख्या मोजा

डुप्लिकेट कॉम्बिनेशन्सची संख्या ही केसेसची संख्या आहे ज्यामध्ये 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()” मध्ये, चौथा वितर्क “पुनरावृत्ती=सत्य” सेट करून डुप्लिकेट संयोजनांची एकूण संख्या मिळवता येते.
लक्षात घ्या की “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 मॉड्यूलमध्ये 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

स्ट्रिंग्समधून अॅनाग्राम तयार करा

Itertools.permutations() स्ट्रिंग क्रमपरिवर्तन (अ‍ॅनाग्राम) तयार करणे सोपे करते.

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