पाइथनमा फ्याक्टोरियल, क्रमपरिवर्तन र संयोजनहरू गणना गर्नुहोस् र उत्पन्न गर्नुहोस्

पाइथनमा गणितीय कार्यहरूको लागि मानक मोड्युल गणित तथ्यांक गणना गर्न प्रयोग गर्न सकिन्छ। 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()

गणित मोड्युलले फ्याक्टोरियल () फ्याक्टोरियल प्रदान गर्दछ।

• math.factorial(x) — Mathematical functions — Python 3.10.4 Documentation

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 स्थापना आवश्यक छ। संस्करण ०.१४.० बाट उपलब्ध छ।

• scipy.special.perm — SciPy v1.8.0 Reference Guide

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 मोड्युल लोड गर्दैन।

माथिको उदाहरणमा जस्तै “scipy.special आयात perm बाट” को रूपमा perm() कार्यान्वयन गर्नुहोस्, वा scipy.special.perm() लाई “scipy.special आयात गर्नुहोस्” को रूपमा कार्यान्वयन गर्नुहोस्।

सूचीबाट क्रमपरिवर्तनहरू उत्पन्न गर्नुहोस् र गणना गर्नुहोस्:itertools.permutations()

कुल संख्या मात्र होइन, क्रमबद्धताहरू पनि सूचिहरू (एरेहरू) आदिबाट उत्पन्न र गणना गर्न सकिन्छ।

itertools मोड्युलको permutations() प्रकार्य प्रयोग गर्नुहोस्।

• itertools.permutations(iterable, r=None) — Functions creating iterators for efficient looping — Python 3.10.4 Documentation

पहिलो तर्कको रूपमा पुनरावृत्तियोग्य (सूची वा सेट प्रकार) र दोस्रो तर्कको रूपमा चयन गर्न टुक्राहरूको संख्या पास गर्दा त्यो क्रमबद्धताको लागि पुनरावृत्ति फर्काउँछ।

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 स्थापना आवश्यक छ। संस्करण ०.१४.० बाट उपलब्ध छ। ध्यान दिनुहोस् कि scipy.misc.comb() ले तल वर्णन गरिएको तर्क दोहोरिने कार्यान्वयन गर्दैन।

• scipy.special.comb — SciPy v1.8.0 Reference Guide
• scipy.misc.comb — SciPy v0.13.0 Reference Guide

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.special मोड्युल लोड गर्दैन।

माथिको उदाहरणमा जस्तै, “scipy.special import comb बाट” को रूपमा comb() लाई कार्यान्वयन गर्नुहोस् वा scipy.special.comb() लाई “scipy.special आयात गर्नुहोस्” को रूपमा कार्यान्वयन गर्नुहोस्। उही “scipy.misc” मा लागू हुन्छ।

math.factorial() कसरी प्रयोग नगर्ने

अर्को विधि जसले मानक पुस्तकालय मात्र प्रयोग गर्छ र math.factorial() प्रयोग गर्ने विधि भन्दा छिटो छ।

• Is there a math nCr function in python? – Stack Overflow

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 मोड्युलको संयोजन() प्रकार्य प्रयोग गर्नुहोस्।

• itertools.combinations(iterable, r) — Functions creating iterators for efficient looping — Python 3.10.4 Documentation

पहिलो तर्कको रूपमा पुनरावृत्तियोग्य (सूची वा सेट प्रकार) र दोस्रो तर्कको रूपमा चयन गरिने टुक्राहरूको सङ्ख्या पास गर्दा त्यो संयोजनको लागि पुनरावृत्ति फर्काउँछ।

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

• itertools.combinations_with_replacement(iterable, r) — Functions creating iterators for efficient looping — Python 3.10.4 Documentation

पहिलो तर्कको रूपमा पुनरावृत्तियोग्य (सूची वा सेट प्रकार) र दोस्रो तर्कको रूपमा चयन गरिने टुक्राहरूको सङ्ख्या पास गर्दा त्यो ओभरल्यापिङ संयोजनको लागि पुनरावृत्ति फर्काउँछ।

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() ले 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')

एक पटकमा एउटा क्यारेक्टरको टुपललाई स्ट्रिङमा जोड्न र यसलाई सूची बनाउन, निम्न गर्नुहोस्

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

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

join() विधि, जसले सूचीका तत्वहरूलाई स्ट्रिङमा जोड्दछ वा स्ट्रिङमा ट्यापल गर्छ, र सूची बुझ्ने सङ्केत प्रयोग गरिन्छ।

• सम्बन्धित:पाइथनमा स्ट्रिङहरू जोड्दै
• सम्बन्धित:पाइथन सूची समझ कसरी प्रयोग गर्ने