नेस्टेड लूप्स को बुरा अभ्यास क्यों माना जाता है?


33

मेरे व्याख्याता ने आज उल्लेख किया कि जावा में लूप्स को "लेबल" करना संभव था, ताकि नेस्टेड लूप से निपटने के दौरान आप उन्हें संदर्भित कर सकें। इसलिए मैंने इस सुविधा को देखा क्योंकि मुझे इसके बारे में नहीं पता था और कई जगहों पर जहां इस सुविधा के बारे में बताया गया था कि यह एक चेतावनी थी, नेस्टेड लूप को हतोत्साहित करना।

मैं सच में समझ में क्यों नहीं आता? क्या यह इसलिए है क्योंकि यह कोड की पठनीयता को प्रभावित करता है? या यह कुछ और "तकनीकी" है?


4
अगर मुझे याद है मेरा CS3 पाठ्यक्रम सही ढंग से है क्योंकि यह अक्सर घातीय समय की ओर जाता है जिसका अर्थ है कि यदि आप एक बड़ा डेटा सेट प्राप्त करते हैं तो आपका आवेदन अनुपयोगी हो जाएगा।
ट्रैविस पेसेटो

21
सीएस व्याख्याताओं के बारे में आपको एक बात सीखनी चाहिए कि वे जो कुछ भी कहते हैं वह वास्तविक दुनिया में 100% लागू होता है। मैं कुछ से अधिक गहरे घोंसले को हतोत्साहित करता हूँ, लेकिन अगर आपको अपनी समस्या को हल करने के लिए m x n तत्वों को संसाधित करना है, तो आप कई पुनरावृत्तियों को करने जा रहे हैं।
ब्लरफ्ल

8
@TravisPessetto वास्तव में यह अभी भी बहुपद जटिलता है - O (n ^ k), k नस्टेड की संख्या, घातांक O (k ^ n) नहीं, जहां k एक स्थिर है।
m3th0dman

1
@ m3th0dman मुझे सही करने के लिए धन्यवाद। मेरे शिक्षक इस विषय पर सबसे महान नहीं थे। उन्होंने O (n ^ 2) और O (k ^ n) को समान माना।
ट्रैविस पेसेटो

2
नेस्टेड लूप्स साइक्लोमैटिक जटिलता ( यहां देखें ) को बढ़ाते हैं , जो कुछ लोगों के अनुसार, एक कार्यक्रम की स्थिरता को कम करता है।
मार्को

जवाबों:


62

नेस्टेड लूप तब तक ठीक होते हैं जब तक वे सही एल्गोरिदम का वर्णन करते हैं।

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

जावा में लूपिंग लेबल करने से कई नेस्टेड लूप्स को समय से पहले तोड़ने की अनुमति मिलती है जब ऐसा करने के अन्य तरीके बोझिल होंगे। जैसे कुछ गेम में कोड का एक टुकड़ा हो सकता है:

Player chosen_one = null;
...
outer: // this is a label
for (Player player : party.getPlayers()) {
  for (Cell cell : player.getVisibleMapCells()) {
    for (Item artefact : cell.getItemsOnTheFloor())
      if (artefact == HOLY_GRAIL) {
        chosen_one = player;
        break outer; // everyone stop looking, we found it
      }
  }
}

हालांकि ऊपर दिए गए उदाहरण की तरह कोड कभी-कभी एक निश्चित एल्गोरिदम को व्यक्त करने का इष्टतम तरीका हो सकता है, आमतौर पर इस कोड को छोटे कार्यों में तोड़ना बेहतर होता है, और शायद returnइसके बजाय इसका उपयोग करें break। तो एक breakलेबल के साथ एक बेहोश कोड गंध है ; जब आप इसे देखते हैं तो अतिरिक्त ध्यान दें।


2
जैसे एक साइड नोट ग्राफिक्स एक एल्गोरिथ्म का उपयोग करता है जिसे मैट्रिक्स के प्रत्येक टुकड़े तक पहुंचना होता है। हालाँकि, समय-प्रभावी तरीके से इसे संभालने के लिए GPU विशिष्ट है।
ट्रैविस पेसेटो

हां, GPU इसे बड़े पैमाने पर समानांतर तरीके से करता है; सवाल निष्पादन के एक ही धागे के बारे में था, मुझे लगता है।
9000

2
जिन कारणों से लेबल संदिग्ध होते हैं, उनमें से एक यह है कि अक्सर एक विकल्प होता है। इस मामले में आप इसके बजाय वापस आ सकते हैं।
jgmjgm

22

नेस्टेड लूप्स अक्सर (लेकिन हमेशा नहीं) बुरे अभ्यास होते हैं, क्योंकि आप जो करने की कोशिश कर रहे हैं उसके लिए वे अक्सर (लेकिन हमेशा नहीं) ओवरकिल करते हैं। कई मामलों में, जिस लक्ष्य को हासिल करने के लिए आप प्रयास कर रहे हैं, उसे पूरा करने के लिए बहुत तेज़ और कम बेकार तरीका है।

उदाहरण के लिए, यदि आपके पास सूची ए में 100 आइटम हैं, और सूची बी में 100 आइटम हैं, और आप जानते हैं कि सूची ए में प्रत्येक आइटम के लिए सूची बी में एक आइटम है जो इसे मेल खाता है, ("मैच" की परिभाषा के साथ जानबूझकर अस्पष्ट छोड़ दिया गया है) यहाँ), और आप जोड़े की एक सूची बनाना चाहते हैं, इसे करने का सरल तरीका इस प्रकार है:

for each item X in list A:
  for each item Y in list B:
    if X matches Y then
      add (X, Y) to results
      break

प्रत्येक सूची में 100 आइटम के साथ, यह औसतन 100 * 100/2 (5,000) का matchesसंचालन करेगा। अधिक वस्तुओं के साथ, या यदि 1: 1 सहसंबंध का आश्वासन नहीं दिया जाता है, तो यह और भी महंगा हो जाता है।

दूसरी ओर, इस तरह का ऑपरेशन करने का एक बहुत तेज़ तरीका है:

sort list A
sort list B (according to the same sort order)
I = 0
J = 0
repeat
  X = A[I]
  Y = B[J]
  if X matches Y then
    add (X, Y) to results
    increment I
    increment J
  else if X < Y then
    increment I
  else increment J
until either index reaches the end of its list

यदि आप इसे इस तरह से करते हैं, तो इसके matchesसंचालन की संख्या के बजाय length(A) * length(B), यह अब पर आधारित है length(A) + length(B), जिसका अर्थ है कि आपका कोड बहुत तेज़ी से चलेगा।


10
O(n log n)कैविट के साथ कि सॉर्टिंग सेटअप गैर-तुच्छ मात्रा में समय लेता है, दो बार, यदि क्विकॉर्ट का उपयोग किया जाता है।
रॉबर्ट हार्वे

@ रोबर्टहाइवे: बिल्कुल। लेकिन यह अभी भी O(n^2)एन के गैर-छोटे मूल्यों के लिए बहुत कम है ।
मेसन व्हीलर

10
एल्गोरिथ्म का दूसरा संस्करण आम तौर पर गलत है। सबसे पहले, यह मानता है कि एक्स और वाई <ऑपरेटर के माध्यम से तुलनीय हैं , जो आमतौर पर matchesऑपरेटर से प्राप्त नहीं किया जा सकता है । दूसरे, भले ही X और Y दोनों संख्यात्मक हों, फिर भी दूसरा एल्गोरिथ्म गलत परिणाम दे सकता है, उदाहरण के लिए जब X matches Yहै X + Y == 100
पाशा

9
@ user958624: जाहिर है कि यह एक सामान्य एल्गोरिथ्म का एक बहुत ही उच्च-स्तरीय अवलोकन है। "मैचों" ऑपरेटर की तरह, "<" को इस तरह से परिभाषित किया जाना चाहिए जो डेटा की तुलना में सही हो। यदि यह सही ढंग से किया जाता है, तो परिणाम सही होंगे।
मेसन व्हीलर

PHP ने ऐसा कुछ किया जो उनके सरणी के साथ आखिरी है जो मुझे लगता है कि अद्वितीय है और / या इसके विपरीत है। लोग इसके बजाय बस PHP के सरणियों का उपयोग करेंगे जो हैश आधारित हैं और यह बहुत जल्दी होगा।
jgmjgm

11

घोंसले के शिकार से बचने का एक कारण यह है क्योंकि यह ब्लॉक संरचनाओं को बहुत गहराई से घोंसला बनाने के लिए एक बुरा विचार है, भले ही वे लूप हों या नहीं।

प्रत्येक फ़ंक्शन या विधि को समझना आसान होना चाहिए, दोनों का उद्देश्य है (नाम को व्यक्त करना चाहिए कि यह क्या करता है) और अनुरक्षकों के लिए (यह आंतरिक को समझना आसान होना चाहिए)। यदि कोई फ़ंक्शन आसानी से समझने के लिए बहुत जटिल है, तो आमतौर पर इसका मतलब है कि कुछ इंटर्नल को अलग-अलग कार्यों में विभाजित किया जाना चाहिए ताकि उन्हें नाम से (अब छोटे) मुख्य कार्य में संदर्भित किया जा सके।

नेस्टेड लूप्स को अपेक्षाकृत जल्दी समझना मुश्किल हो सकता है, हालांकि लूप्स के कुछ नेस्टिंग ठीक है - प्रदान करते हुए, जैसा कि अन्य बताते हैं, इसका मतलब यह नहीं है कि आप एक बेहद (और अनावश्यक रूप से) धीमी एल्गोरिदम का उपयोग करके एक प्रदर्शन मुद्दा बना रहे हैं।

वास्तव में, आपको बेतुके धीमे प्रदर्शन की सीमा प्राप्त करने के लिए नेस्टेड छोरों की आवश्यकता नहीं है। उदाहरण के लिए, उदाहरण के लिए, एक एकल लूप जो प्रत्येक पुनरावृत्ति में एक आइटम को एक कतार से लेता है, फिर संभवतः कई वापस डालता है - जैसे कि भूलभुलैया की पहली-पहली खोज। प्रदर्शन लूप के घोंसले की गहराई से तय नहीं किया जाता है (जो कि केवल 1 है) लेकिन अंततः समाप्त होने से पहले उस कतार में डालने वाली वस्तुओं की संख्या से ( यदि यह कभी समाप्त हो गया है) - कितना बड़ा पहुंच योग्य हिस्सा भूलभुलैया है


1
आप अक्सर बस एक नेस्टेड लूप को समतल कर सकते हैं और यह अभी भी एक ही समय लेता है। 0 से चौड़ाई के लिए, 0 से ऊंचाई के लिए; आप इसके बजाय सिर्फ 0 से चौड़ाई गुणा ऊँचाई तक डाल सकते हैं।
jgmjgm

@jgmjgm - हां, लूप के अंदर कोड को जटिल करने के जोखिम पर। चपटेपन को कभी-कभी सरल बना सकते हैं, लेकिन अधिक बार आप कम से कम उन सूचकांकों को पुनर्प्राप्त करने की जटिलता को जोड़ रहे हैं जो आप वास्तव में चाहते हैं। इसके लिए एक ट्रिक एक इंडेक्स टाइप का उपयोग कर रही है जो एक विशेष कंपाउंड इंडेक्स को बढ़ाने के लिए सभी लूप को तर्क में डालती है - आप केवल एक लूप के लिए ऐसा करने की संभावना नहीं रखते हैं, लेकिन हो सकता है कि आपके पास समान संरचनाओं के साथ कई लूप हों या हो सकता है आप अधिक लचीला जेनेरिक संस्करण लिख सकते हैं। उस प्रकार का उपयोग करने के लिए ओवरहेड्स (यदि कोई हो) स्पष्टता के लिए इसके लायक हो सकता है।
स्टीव

मैं इसे करने के लिए एक अच्छी बात के रूप में सुझाव नहीं दे रहा हूं, लेकिन केवल आश्चर्यजनक रूप से सरल कैसे हो सकता है कि दो छोरों को एक में बदल दें लेकिन फिर भी समय की जटिलता पर प्रभाव नहीं पड़ता है।
jgmjgm

7

कई नेस्टेड छोरों के मामले को देखते हुए आप बहुपद समय के साथ समाप्त होते हैं। उदाहरण के लिए यह छद्म कोड दिया गया है:

set i equal to 1
while i is not equal to 100
  increment i
  set j equal to 1
  while j is not equal to i
    increment j
  end
 end

इसे O (n ^ 2) समय माना जाएगा जो एक ग्राफ के समान होगा: यहाँ छवि विवरण दर्ज करें

जहां y- अक्ष आपके कार्यक्रम को समाप्त करने में लगने वाले समय की मात्रा है और x- अक्ष डेटा की मात्रा है।

यदि आप बहुत अधिक डेटा प्राप्त करते हैं तो आपका कार्यक्रम इतना धीमा हो जाएगा कि कोई भी इसका इंतजार नहीं करेगा। और ऐसा नहीं है कि मुझे विश्वास है कि लगभग 1,000 डेटा प्रविष्टियाँ बहुत लंबी होंगी।


10
आप अपने ग्राफ को फिर से आकार देना चाह सकते हैं: यह एक घातीय वक्र है जो द्विघात नहीं है, पुनरावृत्ति भी O (n ^ 2) से सामान O (n लॉग एन) नहीं बनाता है
शाफ़्ट फ्रीक

5
पुनरावृत्ति के लिए मेरे पास दो शब्द "स्टैक" और "अतिप्रवाह" हैं
माट्यूज़

10
आपका कथन कि पुनरावर्तन एक O (n लॉग 2) के लिए O (n ^ 2) ऑपरेशन को कम कर सकता है, काफी हद तक गलत है। पुनरावृत्ति बनाम पुनरावृत्ति द्वारा लागू किए गए एक ही एल्गोरिथ्म में सटीक एक ही बड़ा-ओ समय जटिलता होनी चाहिए। इसके अलावा, पुनरावृत्ति अक्सर धीमी हो सकती है (भाषा कार्यान्वयन के आधार पर), क्योंकि प्रत्येक पुनरावर्ती कॉल के लिए एक नए स्टैक फ्रेम के निर्माण की आवश्यकता होती है, जबकि पुनरावृत्ति के लिए केवल एक शाखा / तुलना की आवश्यकता होती है। फ़ंक्शन कॉल आमतौर पर सस्ते होते हैं, लेकिन वे मुफ्त नहीं हैं।
dckrooney

2
@TravisPessetto मैंने पिछले 6 महीनों में 3 स्टैक ओवरफ्लो देखा है जबकि पुनरावर्तन या चक्रीय वस्तुओं के संदर्भ के कारण C # एप्लिकेशन विकसित कर रहा है। इसके बारे में क्या मजेदार है कि यह दुर्घटनाग्रस्त हो जाएगा और आपको नहीं पता कि आपको क्या मारा। जब आप नेस्टेड छोरों को देखते हैं तो आप जानते हैं कि कुछ बुरा हो सकता है, और कुछ के लिए गलत इंडेक्स के बारे में अपवाद आसानी से दिखाई देता है।
माट्यूज़

2
@Mateusz, जावा जैसी भाषाएँ भी आपको स्टैक ओवरफ़्लो त्रुटि को पकड़ने की अनुमति देती हैं। स्टैक ट्रेस के साथ यह देखना चाहिए कि क्या हुआ। मेरे पास बहुत अनुभव नहीं है, लेकिन केवल एक बार जब मैंने एक स्टैक ओवरफ्लो त्रुटि देखी है, एक PHP में है, जिसमें एक बग था जो एक अनंत पुनरावृत्ति का कारण था और PHP 512MB मेमोरी से बाहर भाग गया था जिसे इसे सौंपा गया था। रिकर्सन को एक अंतिम समाप्ति मूल्य की आवश्यकता है जो अनंत छोरों के लिए अच्छा नहीं है। सीएस में सब कुछ की तरह एक समय और सभी चीजों के लिए एक जगह है।
ट्रैविस पेसेटो

0

एक छोटे यात्री वाहन के बजाय तीस टन ट्रक चलाना बुरी प्रथा है। सिवाय इसके कि जब आपको 20 या 30 टन सामान की ढुलाई करनी हो।

जब आप नेस्टेड लूप का उपयोग करते हैं, तो यह बुरा अभ्यास नहीं है। यह या तो पूरी तरह से मूर्ख है, या यह वास्तव में जरूरत है। आप तय करें।

हालांकि, किसी ने लूपिंग लेबल के बारे में शिकायत की । उसके लिए उत्तर: यदि आपको प्रश्न पूछना है, तो लेबलिंग का उपयोग न करें। अगर आप खुद को तय करना जानते हैं, तो आप खुद फैसला करें।


यदि आप अपने आप को तय करने के लिए पर्याप्त जानते हैं, तो आप लेबल वाले छोरों का उपयोग नहीं करना जानते हैं। :-)
user949300

नहीं, जब आपको पर्याप्त पढ़ाया जाता है, तो आपको लेबल का उपयोग न करने के लिए सिखाया जाता है। जब आप पर्याप्त जानते हैं तो आप हठधर्मिता से परे हो जाते हैं और वही करते हैं जो सही है।
gnasher729

1
लेबल के साथ समस्या यह है कि इसकी शायद ही कभी आवश्यकता होती है और बहुत से लोग इसका उपयोग प्रवाह नियंत्रण गलतियों के आसपास काम करने के लिए जल्दी करते हैं। इस तरह की तरह कि कैसे लोग प्रवाह नियंत्रण गलत होने पर सभी जगह से बाहर निकल जाते हैं। कार्य भी इसे बड़े पैमाने पर निरर्थक बनाते हैं।
jgmjgm

-1

स्वाभाविक रूप से गलत या जरूरी नहीं कि नेस्टेड छोरों के बारे में भी कुछ बुरा हो। वे हालांकि कुछ विचार और नुकसान है।

जिन लेखों का आप नेतृत्व कर रहे थे, संभवत: संक्षिप्तता के नाम पर या एक मनोवैज्ञानिक प्रक्रिया के कारण, जिसे ज्वलनशील के रूप में जाना जाता है।

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

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

कई उत्तरों के रूप में यहां बताया गया है कि लूप के लिए नेस्टेड होना आपके प्रोग्राम की प्रदर्शन विशेषताओं का एक संकेत है जो आपके घोंसले के शिकार के लिए तेजी से खराब हो सकता है। यही है, O (n), O (n ^ 2), O (n ^ 3) और इसी तरह जिसमें O (n ^ गहराई) शामिल है, जहां गहराई यह दर्शाती है कि आपने कितने छोरों को नेस्ट किया है। जैसे-जैसे आपका घोंसला बढ़ता है, समय की आवश्यकता तेजी से बढ़ती है। समस्या यह है कि यह कोई निश्चितता नहीं है कि आपका समय या स्थान जटिलता या तो यह होगा कि (अक्सर एक * बी * सी लेकिन सभी घोंसले छोरों को हर समय नहीं चलाया जा सकता है) और न ही यह निश्चितता है कि आप भले ही वह एक प्रदर्शन समस्या है।

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

नेस्टेड लूप जंगली जा सकते हैं, कि वे नेस्टेड को बहुत गहराई से समाप्त कर सकते हैं। यदि मैं प्रत्येक महाद्वीप से गुजरता हूं, तो प्रत्येक देश के माध्यम से, फिर प्रत्येक शहर के माध्यम से, फिर प्रत्येक दुकान के माध्यम से, फिर प्रत्येक शेल्फ के माध्यम से, फिर प्रत्येक उत्पाद के माध्यम से यदि प्रत्येक सेम के माध्यम से फलियों की कैन हो सकती है और औसत आकार प्राप्त करने के लिए इसका आकार मापता है तो आप देख सकते हैं कि घोंसला बहुत गहराई से होगा। आपके पास एक पिरामिड और बहुत सी जगह होगी जो बचे हुए मार्जिन से दूर होगी। तुम भी पृष्ठ बंद जा रहा अंत हो सकता है।

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

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

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

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

देखभाल का एक बड़ा सौदा की जरूरत है क्योंकि यह अक्सर छोरों को अमूर्त करने के लिए संभव है या अंतिम परिणाम के साथ उन्हें अभी तक समतल कर देता है अंततः बीमारी से भी बदतर इलाज हो सकता है, खासकर यदि आप उदाहरण के लिए प्रयास से एक औसत दर्जे का और महत्वपूर्ण प्रदर्शन वृद्धि प्राप्त नहीं कर रहे हैं।

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

इस तरह का छिपाना आपके मार्ग पर दस मगर्स के समान है। यदि आप एक सीधा रास्ता रखने के बजाय जहां आप जाना चाहते हैं तो आप इसे व्यवस्थित करें ताकि हर कोने के पीछे एक मगजर हो जाए, यह भ्रम देता है क्योंकि आप अपनी यात्रा शुरू करते हैं कि कोई मगर्स नहीं हैं। नज़र से ओझल, दिमाग से ओझल। आप अभी भी दस बार मग करने जा रहे हैं, लेकिन अब आप इसे नहीं देखेंगे।

आपके प्रश्न का उत्तर यह है कि यह दोनों है, लेकिन दोनों में कोई चिंता नहीं है। वे या तो पूरी तरह से व्यक्तिपरक हैं या केवल प्रासंगिक उद्देश्य हैं। दुर्भाग्य से कभी-कभी पूरी तरह से व्यक्तिपरक या बल्कि राय मिसाल बन जाती है और हावी हो जाती है।

अंगूठे के एक नियम के रूप में, अगर इसे एक नेस्टेड लूप की आवश्यकता होती है या जो अगले स्पष्ट कदम की तरह लगता है, तो यह जानबूझकर और बस इसे करने के लिए नहीं है। हालाँकि अगर कोई संदेह है तो बाद में इसकी समीक्षा की जानी चाहिए।

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

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


तेज <-> कुंद चाकू उदाहरण महान नहीं है, क्योंकि कुंद चाकू आमतौर पर काटने के लिए अधिक खतरनाक होते हैं । और O (n) -> O (n ^ 2) -> O (n ^ 3) में घातांक नहीं है n, यह ज्यामितीय या बहुपद है
कैलथ

सुस्त चाकू बदतर शहरी मिथक का एक सा है। व्यवहार में यह भिन्न होता है और आमतौर पर इस मामले के लिए विशिष्ट होता है जहां सुस्त चाकू विशेष रूप से अनुपयुक्त होते हैं, जिनमें आमतौर पर बहुत अधिक बल की आवश्यकता होती है और बहुत अधिक फिसलन होती है। हालांकि आप सही हैं, वहां एक छिपी हुई लेकिन अंतर्निहित सीमा है, आप केवल नरम सब्जियां काट सकते हैं। मैं n ^ गहराई घातांक पर विचार करता हूं, लेकिन आप अपने आप ही उन उदाहरणों को सही नहीं कर रहे हैं।
jgmjgm

@jgmjgm: n ^ गहराई बहुपद है, गहराई ^ n घातीय है। यह वास्तव में व्याख्या का विषय नहीं है।
रोएल श्रोएवेन

x ^ y, y ^ x से अलग है? आपके द्वारा की गई गलती यह है कि आपने कभी जवाब नहीं पढ़ा। आप घातीय के लिए grepped है और फिर समीकरणों के लिए grepped है कि अपने दम पर घातीय नहीं हैं। यदि आप पढ़ते हैं तो आप देखेंगे कि मैंने कहा है कि यह घोंसले के शिकार की प्रत्येक परत के लिए तेजी से बढ़ता है और यदि आप इसे स्वयं परीक्षण के लिए रखते हैं, तो समय (a = 0; a <n; a ++); के लिए (b = 0; b <n; बी ++); के लिए (ग = 0; ग <n; c ++); जब लूप जोड़ते या हटाते हैं तो आप देखेंगे कि यह वास्तव में घातीय है। आपको n ^ 1 पर एक लूप प्रदर्शन, n ^ 2 पर दो प्रदर्शन और n ^ 3 पर तीन प्रदर्शन मिलेंगे। आप नेस्टेड समझने में विफल: डी। जेओमेट्रिक सबसेट घातीय।
jgmjgm

मुझे लगता है कि यह एक बिंदु साबित होता है कि लोग वास्तव में नेस्टेड निर्माणों के साथ संघर्ष करते हैं।
jgmjgm
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.