बिग-ओ नोटेशन क्या है?

क्या आपने कभी सोचा है कि आपके द्वारा लिखे गए प्रोग्राम को चलने में इतना समय क्यों लगा? शायद आप जानना चाहेंगे कि क्या आप अपना कोड अधिक कुशल बना सकते हैं। यह समझना कि कोड कैसे चलता है, आपके कोड को अगले स्तर पर ला सकता है। आपका कोड वास्तव में कितना कुशल है, इसकी गणना करने के लिए बिग-ओ नोटेशन एक आसान उपकरण है।

बिग-ओ नोटेशन आपको यह गणना करने का एक तरीका देता है कि आपके कोड को चलाने में कितना समय लगेगा। आप भौतिक रूप से समय लगा सकते हैं कि आपके कोड को चलने में कितना समय लगता है, लेकिन उस पद्धति के साथ, छोटे समय के अंतर को पकड़ना मुश्किल है। उदाहरण के लिए, कोड की 20 से 50 पंक्तियों को चलाने में लगने वाला समय बहुत छोटा है। हालाँकि, एक बड़े कार्यक्रम में, वे अक्षमताएँ जुड़ सकती हैं।

विंडोज़ 10 charging को चार्ज न करने में प्लग इन किया गया

बिग-ओ नोटेशन यह गिनता है कि एक एल्गोरिथम को अपनी दक्षता का आकलन करने के लिए कितने चरणों को निष्पादित करना चाहिए। यदि आपको दक्षता बढ़ाने के लिए अपने कोड को ट्यून करने की आवश्यकता है तो इस तरीके से अपने कोड तक पहुंचना बहुत प्रभावी हो सकता है। बिग-ओ नोटेशन आपको अलग-अलग एल्गोरिदम को चलाने के लिए आवश्यक चरणों की संख्या और एल्गोरिदम की दक्षता की निष्पक्ष रूप से तुलना करने में सक्षम करेगा।

आप बिग-ओ नोटेशन की गणना कैसे करते हैं

आइए दो कार्यों पर विचार करें जो गिनते हैं कि एक दराज में कितने व्यक्तिगत मोज़े हैं। प्रत्येक फ़ंक्शन मोजे के जोड़े की संख्या लेता है और अलग-अलग मोजे की संख्या देता है। कोड पायथन में लिखा गया है, लेकिन यह प्रभावित नहीं करता है कि हम चरणों की संख्या कैसे गिनेंगे।

एल्गोरिथम 1:

def sockCounter(numberOfPairs):  
 individualSocks = 0  
 for x in range(numberOfPairs):  
 individualSocks = individualSocks + 2  
 return individualSocks

एल्गोरिथम 2:

def sockCounter(numberOfPairs):  
 return numberOfPairs * 2

यह एक मूर्खतापूर्ण उदाहरण है, और आपको आसानी से यह बताने में सक्षम होना चाहिए कि कौन सा एल्गोरिदम अधिक कुशल है। लेकिन अभ्यास के लिए, आइए प्रत्येक के माध्यम से चलते हैं।

सम्बंधित: प्रोग्रामिंग में एक फंक्शन क्या है?

एल्गोरिथम 1 में कई चरण हैं:

यह वेरिएबल इंडिविजुअल सॉक्स को शून्य का मान प्रदान करता है।
यह वेरिएबल i को एक का मान प्रदान करता है।
यह i के मान की तुलना numberOfPairs से करता है।
यह व्यक्तिगत सॉक्स में दो जोड़ता है।
यह व्यक्तिगत सॉक्स के बढ़े हुए मूल्य को स्वयं निर्दिष्ट करता है।
यह i को एक-एक करके बढ़ाता है।
इसके बाद यह चरण 3 से 6 तक उतनी ही बार लूप करता है जितनी बार (व्यक्तिगत सॉक्स - 1)।

एल्गोरिथम एक के लिए हमें जितने चरणों को पूरा करना है, उसे इस प्रकार व्यक्त किया जा सकता है:

4n + 2

चार चरण हैं जिन्हें हमें n बार पूरा करना है। इस मामले में, n numberOfPairs के मान के बराबर होगा। 2 चरण भी हैं जो एक बार पूरे हो जाते हैं।

इसकी तुलना में, एल्गोरिथम 2 में केवल एक चरण है। NumberOfPairs का मान दो से गुणा किया जाता है। हम इसे इस प्रकार व्यक्त करेंगे:

1

यदि यह पहले से ही स्पष्ट नहीं था, तो अब हम आसानी से देख सकते हैं कि एल्गोरिथम 2 काफी हद तक अधिक कुशल है।

बिग-ओ विश्लेषण

आम तौर पर, जब आप एल्गोरिदम के बिग-ओ नोटेशन में रुचि रखते हैं, तो आप समग्र दक्षता में अधिक रुचि रखते हैं और चरणों की संख्या के बारीक विश्लेषण में कम रुचि रखते हैं। संकेतन को सरल बनाने के लिए, हम केवल दक्षता की भयावहता बता सकते हैं।

उपरोक्त उदाहरणों में, एल्गोरिथम 2 को एक के रूप में व्यक्त किया जाएगा:

O(1)

लेकिन एल्गोरिथ्म 1 को इस प्रकार सरल बनाया जाएगा:

O(n)

यह त्वरित स्नैपशॉट हमें बताता है कि एल्गोरिथम की दक्षता n के मान से कैसे जुड़ी है। संख्या जितनी बड़ी होगी, एल्गोरिथम को उतने ही अधिक चरणों को पूरा करने की आवश्यकता होगी।

रैखिक कोड

छवि क्रेडिट: निक फ्लेडरस/ संज्ञा परियोजना

क्योंकि हम n का मान नहीं जानते हैं, इसलिए यह सोचना अधिक उपयोगी है कि n का मान चलाने के लिए आवश्यक कोड की मात्रा को कैसे प्रभावित करता है। एल्गोरिथम 1 में हम कह सकते हैं कि संबंध रैखिक है। यदि आप चरणों की संख्या बनाम n का मान प्लॉट करते हैं तो आपको एक सीधी रेखा मिलती है जो ऊपर जाती है।

द्विघात कोड

सभी रिश्ते रेखीय उदाहरण की तरह सरल नहीं होते हैं। कल्पना कीजिए कि आपके पास 2D सरणी है और आप सरणी में एक मान खोजना चाहते हैं। आप इस तरह एक एल्गोरिदम बना सकते हैं:

def searchForValue(targetValue, arraySearched):  
 foundTarget = False  
 for x in arraySearched:  
 for y in x:  
 if(y == targetValue):  
 foundTarget = True  
 return foundTarget

इस उदाहरण में, चरणों की संख्या सरणी खोज में सरणियों की संख्या और प्रत्येक सरणी में मानों की संख्या पर निर्भर करती है। तो, चरणों की सरलीकृत संख्या n * n या n² होगी।

फायर टैबलेट पर Google Play कैसे स्थापित करें

छवि क्रेडिट: निक फ्लेडरस/ संज्ञा परियोजना

यह संबंध एक द्विघात संबंध है, जिसका अर्थ है कि हमारे एल्गोरिथ्म में चरणों की संख्या n के साथ तेजी से बढ़ती है। बिग-ओ नोटेशन में, आप इसे इस प्रकार लिखेंगे:

O(n²)

सम्बंधित: CSS फाइलों की जांच, सफाई और अनुकूलन के लिए उपयोगी उपकरण

लघुगणक कोड

हालांकि कई अन्य संबंध हैं, अंतिम संबंध जो हम देखेंगे वह लघुगणक संबंध है। अपनी मेमोरी को रीफ्रेश करने के लिए, किसी संख्या का लॉग एक आधार दिए गए नंबर तक पहुंचने के लिए आवश्यक घातांक मान है। उदाहरण के लिए:

log 2 (8) = 3

लॉग तीन के बराबर होता है क्योंकि अगर हमारा आधार 2 था, तो हमें संख्या 8 पर पहुंचने के लिए 3 के घातांक मान की आवश्यकता होगी।

छवि क्रेडिट: निक फ्लेडरस/ संज्ञा परियोजना

तो, एक लॉगरिदमिक फ़ंक्शन का संबंध एक घातीय संबंध के विपरीत है। जैसे-जैसे n बढ़ता है, एल्गोरिथम को चलाने के लिए कम नए चरणों की आवश्यकता होती है।

पहली नज़र में, यह प्रति-सहज लगता है। एल्गोरिदम के कदम n से धीमे कैसे बढ़ सकते हैं? इसका एक अच्छा उदाहरण द्विआधारी खोज है। आइए अद्वितीय मानों की एक सरणी में किसी संख्या की खोज करने के लिए एक एल्गोरिदम पर विचार करें।

हम खोज के लिए एक सरणी के साथ शुरू करेंगे जो कि सबसे छोटे से सबसे बड़े के क्रम में है।
इसके बाद, हम सरणी के बीच में मान की जांच करेंगे।
यदि आपकी संख्या अधिक है, तो हम अपनी खोज में निम्न संख्याओं को बाहर कर देंगे और यदि संख्या कम थी, तो हम उच्च संख्याओं को बाहर कर देंगे।
अब, हम शेष संख्याओं की मध्य संख्या देखेंगे।
फिर से, हम इस आधार पर आधी संख्या को बाहर कर देंगे कि हमारा लक्ष्य मूल्य मध्य मूल्य से अधिक है या कम है।
हम इस प्रक्रिया को तब तक जारी रखेंगे जब तक हमें अपना लक्ष्य नहीं मिल जाता, या यह निर्धारित नहीं हो जाता कि यह सूची में नहीं है।

जैसा कि आप देख सकते हैं, चूंकि द्विआधारी खोज हर पास के संभावित मूल्यों में से आधे को समाप्त कर देती है, जैसे-जैसे n बड़ा होता जाता है, हम जितनी बार सरणी की जांच करते हैं, उस पर प्रभाव मुश्किल से प्रभावित होता है। इसे बिग-ओ नोटेशन में व्यक्त करने के लिए, हम लिखेंगे:

O(log(n))

बिग-ओ नोटेशन का महत्व

बिग-ओ नेशन आपको यह बताने का एक त्वरित और आसान तरीका देता है कि एल्गोरिथम कितना कुशल है। इससे विभिन्न एल्गोरिदम के बीच निर्णय लेना आसान हो जाता है। यह विशेष रूप से सहायक हो सकता है यदि आप किसी पुस्तकालय से एल्गोरिदम का उपयोग कर रहे हैं और जरूरी नहीं जानते कि कोड कैसा दिखता है।

जलाने की आग पर Google Play कैसे प्राप्त करें

जब आप पहली बार कोड करना सीखते हैं, तो आप रैखिक कार्यों से शुरू करते हैं। जैसा कि आप ऊपर दिए गए ग्राफ से देख सकते हैं, यह आपको बहुत दूर तक ले जाएगा। लेकिन जैसे-जैसे आप अधिक अनुभवी होते जाते हैं और अधिक जटिल कोड बनाना शुरू करते हैं, दक्षता एक समस्या बनने लगती है। अपने कोड की दक्षता को मापने के तरीके की समझ आपको दक्षता के लिए ट्यूनिंग शुरू करने और एल्गोरिदम के पेशेवरों और विपक्षों को तौलने के लिए आवश्यक उपकरण देगी।

साझा करना साझा करना कलरव ईमेल 10 सबसे आम प्रोग्रामिंग और कोडिंग गलतियाँ

कोडिंग की गलतियाँ कई समस्याओं का कारण बन सकती हैं। ये टिप्स आपको प्रोग्रामिंग गलतियों से बचने और अपने कोड को सार्थक बनाए रखने में मदद करेंगे।

आगे पढ़िए संबंधित विषय

प्रोग्रामिंग
प्रोग्रामिंग

लेखक के बारे में जेनिफर सीटन(21 लेख प्रकाशित)

जे. सीटन एक विज्ञान लेखक हैं जो जटिल विषयों को तोड़ने में माहिर हैं। उन्होंने सास्काचेवान विश्वविद्यालय से पीएचडी की है; उनका शोध ऑनलाइन छात्रों की व्यस्तता बढ़ाने के लिए खेल-आधारित शिक्षा के उपयोग पर केंद्रित था। जब वह काम नहीं कर रही होती है, तो आप उसे उसके पढ़ने, वीडियो गेम खेलने या बागवानी करते हुए पाएंगे।

जेनिफ़र सीटन . की अन्य फ़िल्में-टीवी शो

हमारे न्यूज़लेटर की सदस्यता लें

तकनीकी युक्तियों, समीक्षाओं, निःशुल्क ई-पुस्तकों और अनन्य सौदों के लिए हमारे न्यूज़लेटर से जुड़ें!

सब्सक्राइब करने के लिए यहां क्लिक करें