लेबल किए गए लूप को दूर करना

Question

मुझे विश्वास था कि ब्रेक/जारी लेबल here पर कुल "nono" है, मुझे अपने कोड से लेबल को निकालने में सहायता चाहिए।

मेरे पास एक वर्ग मैट्रिक्स और एक वेक्टर है जो समान लंबाई है। वेक्टर में पहले से ही कुछ मान हैं मैट्रिक्स में मानों के आधार पर वेक्टर में वेक्टर बदल गया है।

मुझे आशा है कि, कोड-टुकड़ा मूल रूप से समझा जा सकता है ...

vectorLoop: 
for(int idx = 0; idx < vectorLength; idx++) { 
    if(conditionAtVectorPosition(v, idx)) continue vectorLoop; 

    matrixLoop: 
    for(rowIdx = 0; rowIdx < n; rowIdx++) { 
     if(anotherConditionAtVector(v, rowIdx)) continue matrixLoop; 
     if(conditionAtMatrixRowCol(m, rowIdx, idx)) continue vectorLoop; 
    } 
    setValueInVector(v, idx); 
}  

कृपया मुझे समझाने, एक और अधिक पठनीय/लेबल के बिना बेहतर संस्करण नहीं है।

Answer 1

समाधान को देखते हुए अब तक प्रस्तुत:

• वे सभी, मूल की तुलना में कम पठनीय देखो कि वे एल्गोरिथ्म ही

पर से कोड के तंत्र पर अधिक कोड खर्च नहीं बल्कि शामिल

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

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

• एक विधि में कोड के प्रासंगिक भाग को पुन: सक्रिय करना प्रभावी ढंग से नो-ऑप है: यह पुन: व्यवस्थित करता है कि फ़ाइल में कोड कैसे रखा गया है, लेकिन इसका निष्पादन इस पर कोई प्रभाव नहीं पड़ता है।

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

Answer 2

आसानी से, मेरे अच्छे आदमी।

for(int idx = 0; idx < vectorLength; idx++) { 
    if(conditionAtVectorPosition(v, idx)) continue; 

    for(rowIdx = 0; rowIdx < n; rowIdx++) { 
    if(anotherConditionAtVector(v, rowIdx)) continue; 
    if(conditionAtMatrixRowCol(m, rowIdx, idx)) break; 
    } 
    if(!conditionAtMatrixRowCol(m, rowIdx, idx)) 
    setValueInVector(v, idx); 
} 

संपादित करें: आप सही हैं एंडर्स। मैंने इसे अपने खाते में भी लेने के लिए संपादित किया है।

Answer 3

@ पैट्रिक आप कॉलिंग सेट वैल्यूइन वेक्टर (वी, आईडीएक्स) मान रहे हैं; दूसरे पाश के अंत में ठीक है। कोड समान होना है, तो तार्किक रूप से, यह इस तरह somethng फिर से लिखा जाना चाहिए:

for(int idx = 0; idx

Answer 4

आप के लिए यह काम करता है? मैं एक विधि CheckedEntireMatrix में भीतरी पाश निकाले (आप यह मेरे से बेहतर नाम कर सकते हैं) - इसके अलावा मेरे जावा थोड़ा जंग लगी है .. लेकिन मैं इसे

for(int idx = 0; idx < vectorLength; idx++) { 
    if(conditionAtVectorPosition(v, idx) 
    || !CheckedEntireMatrix(v)) continue; 

    setValueInVector(v, idx); 
} 

private bool CheckedEntireMatrix(Vector v) 
{ 
    for(rowIdx = 0; rowIdx < n; rowIdx++) { 
     if(anotherConditionAtVector(v, rowIdx)) continue; 
     if(conditionAtMatrixRowCol(m, rowIdx, idx)) return false; 
    } 
    return true; 
} 

Answer 5

Gishu भर में संदेश हो जाता है सही विचार है लगता है:

for(int idx = 0; idx < vectorLength; idx++) { 
    if (!conditionAtVectorPosition(v, idx) 
     && checkedRow(v, idx)) 
     setValueInVector(v, idx); 
} 

private boolean checkedRow(Vector v, int idx) { 
    for(rowIdx = 0; rowIdx < n; rowIdx++) { 
     if(anotherConditionAtVector(v, rowIdx)) continue; 
     if(conditionAtMatrixRowCol(m, rowIdx, idx)) return false; 
    } 
    return true; 
} 

Answer 6

मुझे पहले जारी रखने को समझने में भी यकीन नहीं है। मैं Gishu की नक़ल की और की तरह कुछ लिखने (खेद अगर वहाँ कुछ गलतियों हैं):

for(int idx = 0; idx < vectorLength; idx++) { 
    if(!conditionAtVectorPosition(v, idx) && CheckedEntireMatrix(v)) 
     setValueInVector(v, idx); 
} 

inline bool CheckedEntireMatrix(Vector v) { 
    for(rowIdx = 0; rowIdx < n; rowIdx++) 
     if (!anotherConditionAtVector(v,rowIdx) && conditionAtMatrixRowCol(m,rowIdx,idx)) 
      return false; 
    return true; 
} 

Answer 7

अपने कोड को पढ़ने से।

• मैंने देखा है कि आप स्थिति में अमान्य वेक्टर स्थितियों को समाप्त कर सकते हैं ATVectorPosition तो आप किसी अन्य ConditionAtVector पर अमान्य पंक्तियों को हटा दें।
• ऐसा लगता है कि किसी अन्य कंडीशन एटवेक्टर पर पंक्तियों की जांच करना अनावश्यक है क्योंकि आईडीएक्स का मूल्य जो भी है, दूसरा कंडिशन एटवेक्टर केवल पंक्ति सूचकांक पर निर्भर करता है (एक और कंडिशन एक्टिवेटर का कोई दुष्प्रभाव नहीं है)।

तो तुम यह कर सकते हैं:

• वैध पदों पहले conditionAtVectorPosition (इन वैध स्तंभ हैं) का उपयोग कर प्राप्त करें।
• फिर किसी अन्य कंडिशन एटवेक्टर का उपयोग करके मान्य पंक्तियां प्राप्त करें।
• अंत में, मान्य कॉलम और पंक्तियों का उपयोग करके conditionAtMatrixRowCol का उपयोग करें।

मुझे उम्मीद है कि इससे मदद मिलती है।

Answer 8

@Sadie:

वे सभी, मूल की तुलना में कम पठनीय देखो कि वे एल्गोरिथ्म ही

दूसरा externalizing पर से कोड के तंत्र पर अधिक कोड खर्च नहीं बल्कि शामिल एल्गोरिदम के बाहर लूप आवश्यक रूप से कम पठनीय नहीं है। यदि विधि का नाम अच्छी तरह से चुना गया है, तो यह पठनीयता में सुधार कर सकता है।

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

मेरे पास एक अलग दृष्टिकोण है: उनमें से कुछ तोड़ दिए गए हैं क्योंकि मूल एल्गोरिदम के व्यवहार को समझना मुश्किल है।

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

प्रदर्शन दंड मामूली है। हालांकि मैं मानता हूं कि दो बार परीक्षण करना अच्छा समाधान नहीं है।

एक विधि में कोड के प्रासंगिक भाग को पुन: सक्रिय करना प्रभावी ढंग से नो-ऑप है: यह पुन: व्यवस्थित करता है कि फ़ाइल में कोड कैसे रखा गया है, लेकिन इसका निष्पादन इस पर कोई प्रभाव नहीं पड़ता है।

मुझे बिंदु नहीं दिख रहा है। हाँ, यह व्यवहार को बदलता नहीं है, जैसे ... refactoring?

निश्चित रूप से ऐसे मामले हैं जहां लेबल गलत तरीके से उपयोग किए जाते हैं और उन्हें फिर से प्रतिक्रिया दी जानी चाहिए। मुझे नहीं लगता कि इसे कुछ अटूट नियम माना जाना चाहिए।

मैं पूरी तरह से सहमत हूं। लेकिन जैसा कि आपने बताया है, इस उदाहरण को दोबारा करते हुए हम में से कुछ को कठिनाइयों का सामना करना पड़ता है। यहां तक ​​कि यदि प्रारंभिक उदाहरण पठनीय है, तो इसे बनाए रखना मुश्किल है।

Answer 9

@Nicolas

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

मैं देखने का एक अलग बिंदु है: उनमें से कुछ टूट रहे हैं, क्योंकि यह मूल एल्गोरिथ्म के व्यवहार समझ पाना कठिन है।

मुझे एहसास है कि यह व्यक्तिपरक है, लेकिन मुझे मूल एल्गोरिदम पढ़ने में कोई परेशानी नहीं है। प्रस्तावित प्रतिस्थापन से यह छोटा और स्पष्ट है।

इस धागे में सभी रिफैक्टरिंग अन्य भाषा सुविधाओं का उपयोग करके लेबल के व्यवहार का अनुकरण करती है - जैसे कि आप उस भाषा को कोड पोर्ट कर रहे थे जिसमें लेबल नहीं थे।

Answer 10

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

प्रदर्शन दंड मामूली है। हालांकि मैं मानता हूं कि दो बार परीक्षण करना अच्छा समाधान नहीं है।

मेरा मानना ​​है कि सवाल यह था कि लेबल को कैसे निकालना है, एल्गोरिदम को अनुकूलित करने के तरीके के बारे में नहीं। यह मुझे दिखाई दिया कि मूल पोस्टर लेबल के बिना 'जारी रखें' और 'ब्रेक' कीवर्ड का उपयोग करने के बारे में अनजान था, लेकिन निश्चित रूप से, मेरी धारणाएं गलत हो सकती हैं।

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

कहा जा रहा है कि, दो बार एक ही परीक्षण करना सिद्धांत में — अनुकूल नहीं है।

संपादित करें: दूसरे विचार पर, उदाहरण वास्तव में लेबल का भयानक उपयोग नहीं है। मैं सहमत हूं कि "goto is a no-no", लेकिन इस तरह के कोड के कारण नहीं। यहां लेबल का उपयोग वास्तव में कोड की पठनीयता को महत्वपूर्ण तरीके से प्रभावित नहीं करता है। बेशक, उन्हें जरूरी नहीं है और आसानी से छोड़ा जा सकता है, लेकिन इनका उपयोग नहीं कर रहा क्योंकि "लेबल का उपयोग करना बुरा है" इस मामले में एक अच्छी बहस नहीं है। आखिरकार, लेबल को हटाने से कोड को पढ़ने में ज्यादा आसान नहीं होता है, क्योंकि अन्य ने पहले से ही टिप्पणी की है।

Answer 11

यह सवाल एल्गोरिथ्म अनुकूलन के बारे में नहीं था - लेकिन धन्यवाद वैसे भी ;-)

समय मैं इसे लिखा था, मैं माना लेबल को पढ़ने योग्य समाधान के रूप में जारी है।

मैंने जावा में लेबल के लिए सम्मेलन (सभी कैप्स में लेबल या नहीं) के बारे में SO question से पूछा।

मूल रूप से हर उत्तर ने मुझे बताया "उनका उपयोग न करें - हमेशा एक बेहतर तरीका है! रिफैक्टर!"। इसलिए मैंने इस प्रश्न को और अधिक पठनीय (और इसलिए बेहतर?) समाधान मांगने के लिए पोस्ट किया।

अब तक, मैं अब तक प्रस्तुत विकल्पों से पूरी तरह से आश्वस्त नहीं हूं।

कृपया मुझे गलत न करें। लेबल ज्यादातर समय बुराई हैं।

लेकिन मेरे मामले में, सशर्त परीक्षण बहुत सरल हैं और एल्गोरिदम गणितीय कागज से लिया जाता है और इसलिए निकट भविष्य में बदलने की संभावना नहीं है। तो मैं checkMatrixAtRow (x) जैसे किसी अन्य विधि पर स्क्रॉल करने के बजाय एक बार में सभी प्रासंगिक भागों को दृश्यमान करना पसंद करता हूं।

विशेष रूप से और अधिक जटिल गणितीय एल्गोरिदम में, मैं इसे खोजने के लिए बहुत कठिन "अच्छा" समारोह के नामों को खोजने - लेकिन मुझे लगता है कि है कि अभी तक एक और सवाल

Answer 12

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

---

प्रभारी मूल प्रश्न में छोरों पुनर्रचना का सुझाव के लिए अग्रणी है और अब सवाल में कोड देखने के बाद, मैं तुम्हें वहाँ एक बहुत ही पठनीय पाश मिल गया है लगता है।

जो मैंने कल्पना की थी वह कोड का एक बहुत ही अलग हिस्सा था - वास्तविक उदाहरण को ऊपर रखकर, मैं देख सकता हूं कि यह मेरे विचार से कहीं ज्यादा स्वच्छ है।

गलतफहमी के लिए मेरी क्षमा।