પાયથોનમાં ફેક્ટોરિયલ્સ, ક્રમચયો અને સંયોજનોની ગણતરી કરો અને જનરેટ કરો

પાયથોનમાં ગાણિતિક કાર્યો માટે પ્રમાણભૂત મોડ્યુલ ગણિતનો ઉપયોગ ફેક્ટોરિયલ્સની ગણતરી કરવા માટે થઈ શકે છે. 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()

ક્રમચયો એ એવા કિસ્સાઓની સંખ્યા છે કે જ્યાં 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.special મોડ્યુલને લોડ કરશે નહીં.

ઉપરના ઉદાહરણની જેમ perm() ને “scipy.special આયાત 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')

તે મર્યાદિત પુનરાવર્તક હોવાથી, તેને 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
ડુપ્લિકેટ સંયોજનોની કુલ સંખ્યા ચોથી દલીલ, પુનરાવર્તન સાથે પણ મેળવી શકાય છે. આ નીચે વર્ણવેલ છે.

ફરીથી, નોંધ લો કે માત્ર “ઇમ્પોર્ટ સ્કીપી” 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 મોડ્યુલના 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()” માં, ડુપ્લિકેટ સંયોજનોની કુલ સંખ્યા ચોથી દલીલ “પુનરાવર્તન=ટ્રુ” સેટ કરીને મેળવી શકાય છે.
નોંધ કરો કે દલીલ “પુનરાવર્તન” “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() પદ્ધતિ, જે સૂચિના ઘટકોને જોડે છે અથવા સ્ટ્રિંગમાં ટપલ કરે છે, અને સૂચિ સમજણ સંકેતનો ઉપયોગ થાય છે.

• સંબંધિત:Python માં શબ્દમાળાઓનું જોડાણ (જોડાવું).
• સંબંધિત:પાયથોન સૂચિ સમજણનો ઉપયોગ કેવી રીતે કરવો