2010-01-25 10 views
5

ठीक है - मैं इसकितने संयोजनों यह तो वक्तव्य में

if() 
    if() 
     if() 
     if() 
     if() 

मैं इस तरह न की तरह किसी कि मैं कौन के साथ काम लिखा है somthing है !!

यदि दस अलग-अलग बूलियन झंडे हैं तो कितने संयोजन हैं?

10 फैक्टोरियल?

मैं समझाने के लिए क्यों यह बुरा

+0

मैं कैसे इस कोड refactor करने में दिलचस्पी है ... –

+0

मैं क्यों नहीं देख पा रहे हैं यह बुरा है, यह – harryovers

+0

पर जिस समस्या पर काम कर रहा है उसे हल करने का सबसे अच्छा तरीका हो सकता है, इससे कोई फर्क नहीं पड़ता कि आप अपने 'अगर' की व्यवस्था कैसे करते हैं। – Kobi

उत्तर

2

दो राज्यों और 10 झंडे 2^10 = 1024

एक अधिकतम स्तर
3

2 10 वीं डिग्री में है कोशिश कर रहा हूँ = 1024

मैं समझाने के लिए क्यों यह बुरा है

यह आवश्यक रूप से बुरा नहीं हो सकता है कोशिश कर रहा हूँ । प्रत्येक स्थिति में आधा मामलों में कटौती होती है। यदि आपको पता है कि पहली शर्त सही होने पर आपको केवल कुछ करने की आवश्यकता है, तो आप पहले से ही 512 मामलों को छोड़ दें। यही उन चेकों का मुद्दा है।

आप लेकिन यह पुनर्लेखन कर सकते हैं बेहतर की तलाश में और अधिक पठनीय होने के लिए:

झंडा प्रति
if(c1 && c2 && c3 && c4 && c5) 
+0

यह कहना है, 2 ** 10, या 1024. –

+0

@ इग्नासिओ: आपका मतलब 2^10 है। ;) – Bobby

+2

@ बॉबी: स्मार्ट प्रोग्रामर जानते हैं कि 2^10 बराबर 8; पी –

1

सबसे अच्छा स्थिर कोड विश्लेषक है इसका मतलब है इस सटीक कारण के लिए इंडेंटेशन का। घोंसले के ऐसे उच्च स्तरों के साथ सभी तार्किक मामलों को संभालना बहुत मुश्किल हो जाता है।

क्या यह फ़ंक्शन के शीर्ष पर एक बड़ी गांठ में सभी त्रुटि स्थितियों की जांच करने की सामान्य नौसिखिया त्रुटि है?

यदि ऐसा है, तो हो सकता है कि आप कोड के लेखक को इसे भारी घोंसले के निर्माण के बजाए यदि बयानों के अनुक्रम में बदलना चाहें।

if(error1) { 
    /* report error 1 and exit */ 
} 

if(error2) { 
    /* report error 2 and exit */ 
} 

if(error3) { 
    /* report error 3 and exit */ 
} 

... 

यह बहुत आसान है एक विशिष्ट त्रुटि के बजाय एक सामान्य "कुछ का बुरा" बयान के बारे में जानकारी प्रदान करने के अनुरूप कोड का परीक्षण और यह भी बनाता है।

+0

कई रिटर्न स्टेटमेंट्स होने पर रिफैक्टर करने में कठिनाई होती है ... – cjk

+0

@ck, अगर किसी फ़ंक्शन में छः रिटर्न स्टेटमेंट्स के रूप में वापसी विवरण का इरादा स्पष्ट नहीं है। व्यक्तिगत त्रुटि मामलों के लिए शीर्ष पर पांच और अच्छे परिणाम के लिए नीचे एक। हालांकि, अलग-अलग चीजों को वापस करने वाले फ़ंक्शन के चारों ओर रिटर्न स्टेटमेंट्स को ड्रिब्बल किया गया है * निश्चित रूप से रिफैक्टर के लिए दर्द है! –

0

अधिक से अधिक 2^10 = 1024 पथ (अधिकतम करता है, तो स्थिति पूरी तरह से स्वतंत्र हैं तक पहुँच जाता है)

एक विधि में कई रास्ते रखना एक उच्च जटिलता होने कहा जाता है। यह उच्च जटिलता बनाए रखने और परीक्षण योग्यता पर प्रभाव डालती है। जाहिर है जटिल तरीके अधिक त्रुटि प्रवण हैं और परीक्षण और रखरखाव के लिए और अधिक कठिन है।

जटिलता एक समस्या नहीं है: समस्याओं के कुछ समाधानों में एक अंतर्निहित जटिलता है जिसे हटाया नहीं जा सकता है। दूसरे शब्दों में कुछ समस्याओं को समाधान खोजने में निश्चित रूप से मुश्किल होती है। इन मामलों में आप जटिल जटिलताओं को छोटे से विभाजित करके स्थानीय जटिलता को कम कर सकते हैं (इससे स्पष्ट रूप से वैश्विक जटिलता कम नहीं होती है)।

अन्य मामलों में अतिरिक्त जटिलता को दूर: एक सरल समाधान खोजने (कहने के लिए आसान है, मुझे पता है) ;-)

संबंधित मुद्दे