பைத்தானில் காரணிகள், வரிசைமாற்றங்கள் மற்றும் சேர்க்கைகளைக் கணக்கிட்டு உருவாக்கவும்

பைத்தானில் உள்ள கணிதச் செயல்பாடுகளுக்கான நிலையான தொகுதிக் கணிதம் காரணிகளைக் கணக்கிடப் பயன்படுகிறது. வரிசைமாற்றங்கள்/சேர்க்கைகளின் மொத்த எண்ணிக்கையைக் கணக்கிடுவதற்கான செயல்பாடுகளையும் 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 தொகுதியில் itertools.product() ஐப் பயன்படுத்தவும்.

காரணியான:math.factorial()

கணிதத் தொகுதியானது காரணியான () செயல்பாட்டை வழங்குகிறது.

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

import math

print(math.factorial(5))
# 120

print(math.factorial(0))
# 1

முழு எண் அல்லாத, எதிர்மறை மதிப்புகள் மதிப்புப் பிழையை ஏற்படுத்தும்.

# print(math.factorial(1.5))
# ValueError: factorial() only accepts integral values

# print(math.factorial(-1))
# ValueError: factorial() not defined for negative values

வரிசைமாற்றங்களின் மொத்த எண்ணிக்கையைக் கணக்கிடவும்

math.factorial()

வரிசைமாற்றங்கள் என்பது n வெவ்வேறுவற்றிலிருந்து r தேர்ந்தெடுக்கப்பட்டு ஒரு வரிசையில் வைக்கப்படும் நிகழ்வுகளின் எண்ணிக்கையாகும்.

வரிசைமாற்றங்களின் மொத்த எண்ணிக்கை, 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” மட்டுமே scipy.special தொகுதியை ஏற்றாது என்பதை நினைவில் கொள்ளவும்.

மேலே உள்ள எடுத்துக்காட்டில் உள்ளதைப் போல perm() ஐ “scipy.special import perm” ஆக செயல்படுத்தவும் அல்லது scipy.special.perm() ஐ “இறக்குமதி scipy.special” ஆக இயக்கவும்.

ஒரு பட்டியலிலிருந்து வரிசைமாற்றங்களை உருவாக்கவும் மற்றும் கணக்கிடவும்:itertools.permutations()

மொத்த எண்கள் மட்டுமல்ல, பட்டியல்கள் (வரிசைகள்) போன்றவற்றிலிருந்து வரிசைமாற்றங்களையும் உருவாக்கலாம் மற்றும் கணக்கிடலாம்.

itertools தொகுதியின் வரிசைமாற்றங்கள்() செயல்பாட்டைப் பயன்படுத்தவும்.

• 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 loop ஐப் பயன்படுத்தலாம்.

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” மட்டுமே scipy.special தொகுதியை ஏற்றாது என்பதை நினைவில் கொள்ளவும்.

மேலே உள்ள எடுத்துக்காட்டில் உள்ளது போல், comb() ஐ “scipy.special import 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()” இல், நான்காவது வாதமான “repetition=True” ஐ அமைப்பதன் மூலம் மொத்த நகல் சேர்க்கைகளின் எண்ணிக்கையைப் பெறலாம்.
“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 தொகுதியில் சேர்க்கைகள்_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() சரம் வரிசைமாற்றங்களை (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']

பட்டியல் அல்லது டூப்ளின் கூறுகளை ஒரு சரமாக இணைக்கும் ஜாயின்() முறை மற்றும் பட்டியல் புரிதல் குறியீடு பயன்படுத்தப்படுகிறது.

• தொடர்புடையது:பைத்தானில் இணைக்கும் (இணைக்கும்) சரங்கள்
• தொடர்புடையது:பைதான் பட்டியல் புரிதல்களை எவ்வாறு பயன்படுத்துவது