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

ترتیب کو استعمال کرنے کی ایک مثال کے طور پر، درج ذیل کی بھی وضاحت کی گئی ہے۔

• تاروں سے anagrams بنائیں

اگر آپ کسی ایک فہرست کے بجائے متعدد فہرستوں کے عناصر کا مجموعہ بنانا چاہتے ہیں تو 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()

Permutations ان صورتوں کی تعداد ہیں جہاں 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

نوٹ کریں کہ صرف "import scipy” scipy.special ماڈیول کو لوڈ نہیں کرے گا۔

perm() کو بطور "scipy.special import 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()

مجموعوں کی تعداد مختلف ٹکڑوں میں سے منتخب کرنے کے لیے 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
چوتھی دلیل، تکرار سے بھی نقلی مجموعوں کی کل تعداد حاصل کی جا سکتی ہے۔ یہ ذیل میں بیان کیا گیا ہے۔

ایک بار پھر، نوٹ کریں کہ صرف "import scipy” scipy.special ماڈیول کو لوڈ نہیں کرے گا۔

جیسا کہ اوپر کی مثال میں ہے، comb() کو "scipy.special import comb سے” کے طور پر یا execute 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 ماڈیول کے 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

تاروں سے anagrams بنائیں

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() طریقہ، جو فہرست کے عناصر کو جوڑتا ہے یا سٹرنگ میں ٹپل کرتا ہے، اور فہرست کی سمجھ بوجھ استعمال کی جاتی ہے۔

• متعلقہ:Python میں تاروں کو جوڑنا (شامل ہونا)
• متعلقہ:ازگر کی فہرست کی تفہیم کا استعمال کیسے کریں۔