పైథాన్‌లో కారకాలు, ప్రస్తారణలు మరియు కలయికలను గణించండి మరియు ఉత్పత్తి చేయండి

పైథాన్‌లోని గణిత విధుల కోసం ప్రామాణిక మాడ్యూల్ గణితాన్ని కారకాలను గణించడానికి ఉపయోగించవచ్చు. 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 మాడ్యూల్‌ను లోడ్ చేయదని గమనించండి.

పై ఉదాహరణలో వలె “scipy.special దిగుమతి perm నుండి” 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 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 దిగుమతి దువ్వెన నుండి” లేదా 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() స్ట్రింగ్ ప్రస్తారణలను (అనగ్రామ్‌లు) సృష్టించడాన్ని సులభతరం చేస్తుంది.

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']

జాయిన్() పద్ధతి, ఇది జాబితా లేదా టుపుల్‌లోని మూలకాలను స్ట్రింగ్‌గా కలుపుతుంది మరియు జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం ఉపయోగించబడుతుంది.

• సంబంధిత:పైథాన్‌లో తీగలను సంగ్రహించడం (చేరడం).
• సంబంధిత:పైథాన్ జాబితా గ్రహణాలను ఎలా ఉపయోగించాలి