ਪਾਈਥਨ ਵਿੱਚ ਫੈਕਟੋਰੀਅਲ, ਕ੍ਰਮਵਾਰ ਅਤੇ ਸੰਜੋਗਾਂ ਦੀ ਗਣਨਾ ਕਰੋ ਅਤੇ ਤਿਆਰ ਕਰੋ

ਪਾਈਥਨ ਵਿੱਚ ਗਣਿਤਿਕ ਫੰਕਸ਼ਨਾਂ ਲਈ ਮਿਆਰੀ ਮੋਡੀਊਲ ਗਣਿਤ ਨੂੰ ਫੈਕਟੋਰੀਅਲ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। 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 ਇੰਸਟਾਲੇਸ਼ਨ ਦੀ ਲੋੜ ਹੈ। ਸੰਸਕਰਣ 0.14.0 ਤੋਂ ਉਪਲਬਧ।

• 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.special ਮੋਡੀਊਲ ਨੂੰ ਲੋਡ ਨਹੀਂ ਕਰੇਗਾ।

perm() ਨੂੰ “scipy.special import perm ਤੋਂ” ਦੇ ਤੌਰ ‘ਤੇ ਲਾਗੂ ਕਰੋ ਜਿਵੇਂ ਕਿ ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ ਹੈ, ਜਾਂ scipy.special.perm() ਨੂੰ “import 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')

ਕਿਉਂਕਿ ਇਹ ਇੱਕ ਸੀਮਿਤ ਇਟਰੇਟਰ ਹੈ, ਇਸ ਨੂੰ ਸੂਚੀ () ਨਾਲ ਸੂਚੀ ਕਿਸਮ ਵਿੱਚ ਵੀ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਜਦੋਂ ਸੂਚੀ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ 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() ਹੇਠਾਂ ਦੱਸੇ ਗਏ ਆਰਗੂਮੈਂਟ ਦੁਹਰਾਓ ਨੂੰ ਲਾਗੂ ਨਹੀਂ ਕਰਦਾ ਹੈ।

• 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 ਮੋਡੀਊਲ ਨੂੰ ਲੋਡ ਨਹੀਂ ਕਰੇਗਾ।

ਜਿਵੇਂ ਕਿ ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ, comb() ਨੂੰ “scipy.special import comb” ਵਜੋਂ ਚਲਾਓ ਜਾਂ scipy.special.comb() ਨੂੰ “import 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 ਮੋਡੀਊਲ ਦੇ combinations() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।

• 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()” ਵਿੱਚ, ਡੁਪਲੀਕੇਟ ਸੰਜੋਗਾਂ ਦੀ ਕੁੱਲ ਸੰਖਿਆ ਚੌਥੀ ਆਰਗੂਮੈਂਟ “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 ਮੋਡੀਊਲ ਵਿੱਚ 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() ਸਟਰਿੰਗ ਪਰਮਿਊਟੇਸ਼ਨ (ਐਨਾਗ੍ਰਾਮ) ਬਣਾਉਣਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ।

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() ਵਿਧੀ, ਜੋ ਇੱਕ ਸੂਚੀ ਦੇ ਤੱਤਾਂ ਨੂੰ ਜੋੜਦੀ ਹੈ ਜਾਂ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਟਿਪਲ ਕਰਦੀ ਹੈ, ਅਤੇ ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

• ਸੰਬੰਧਿਤ:ਪਾਈਥਨ ਵਿੱਚ ਤਾਰਾਂ ਨੂੰ ਜੋੜਨਾ (ਜੋੜਨਾ)
• ਸੰਬੰਧਿਤ:ਪਾਈਥਨ ਸੂਚੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ