पायथन में फैक्टोरियल, क्रमपरिवर्तन और संयोजन की गणना और उत्पन्न करें

व्यापार

पायथन में गणितीय कार्यों के लिए मानक मॉड्यूल गणित का उपयोग फैक्टोरियल की गणना के लिए किया जा सकता है। SciPy में क्रमपरिवर्तन/संयोजन की कुल संख्या की गणना करने के लिए कार्य भी हैं।

itertools मॉड्यूल का उपयोग सूचियों (सरणी), आदि से क्रमपरिवर्तन और संयोजन उत्पन्न करने और उनकी गणना करने के लिए भी किया जा सकता है।

नमूना कोड के साथ निम्नलिखित को यहां समझाया गया है।

  • कारख़ाने का:math.factorial()
  • क्रमपरिवर्तन की कुल संख्या की गणना करें
    • math.factorial()
    • scipy.special.perm()
  • एक सूची से क्रमपरिवर्तन उत्पन्न और गणना करें:itertools.permutations()
  • संयोजनों की कुल संख्या की गणना करें
    • math.factorial()
    • scipy.special.comb()
    • गणित का उपयोग कैसे न करें। तथ्यात्मक ()
  • सूचियों से संयोजन उत्पन्न और गणना करें: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)!

इसकी गणना गणित.फैक्टोरियल () फ़ंक्शन का उपयोग करके की जा सकती है, जो फैक्टोरियल लौटाता है। ऑपरेटर, जो पूर्णांक विभाजन करता है, का उपयोग पूर्णांक प्रकार को वापस करने के लिए किया जाता है।

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() को “scipy.special import perm से” के रूप में निष्पादित करें, या scipy.special.perm() को “import scipy.special” के रूप में निष्पादित करें।

एक सूची से क्रमपरिवर्तन उत्पन्न और गणना करें:itertools.permutations()

न केवल कुल संख्या, बल्कि क्रमपरिवर्तन भी सूचियों (सरणी), आदि से उत्पन्न और गणना की जा सकती है।

itertools मॉड्यूल के क्रमपरिवर्तन () फ़ंक्शन का उपयोग करें।

पहले तर्क के रूप में एक चलने योग्य (सूची या सेट प्रकार) पास करना और दूसरे तर्क के रूप में चुने जाने वाले टुकड़ों की संख्या उस क्रमपरिवर्तन के लिए एक पुनरावर्तक देता है।

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

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

इसकी गणना गणित.फैक्टोरियल () फ़ंक्शन का उपयोग करके की जा सकती है, जो फैक्टोरियल लौटाता है। ऑपरेटर, जो पूर्णांक विभाजन करता है, का उपयोग पूर्णांक प्रकार को वापस करने के लिए किया जाता है।

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 मॉड्यूल को लोड नहीं करेगा।

जैसा कि ऊपर दिए गए उदाहरण में, “scipy.special आयात कंघी से” के रूप में कंघी () निष्पादित करें या scipy.special.comb () को “आयात scipy.special” के रूप में निष्पादित करें। वही “scipy.misc” पर लागू होता है।

गणित का उपयोग कैसे न करें। तथ्यात्मक ()

एक अन्य विधि जो केवल मानक पुस्तकालय का उपयोग करती है और गणित.फैक्टोरियल () का उपयोग करने वाली विधि से तेज है, निम्न विधि है।

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 ()” में, चौथा तर्क “पुनरावृत्ति = ट्रू” सेट करके डुप्लिकेट संयोजनों की कुल संख्या प्राप्त की जा सकती है।
ध्यान दें कि तर्क “पुनरावृत्ति” “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 मॉड्यूल में 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']

जॉइन () विधि, जो एक सूची के तत्वों या एक स्ट्रिंग में टपल को जोड़ती है, और सूची समझ नोटेशन का उपयोग किया जाता है।

Copied title and URL