यदि कोई कथन खराब अभ्यास में असाइनमेंट स्टेटमेंट डाल रहा है?

Question

नीचे दिए गए कोड स्निपेट के आधार पर (उन्हें स्पष्टता के लिए छोटा कर दिया गया है)।

scoreBoardState विधि का उद्देश्य एक मिनीमैक्स एल्गोरिदम में पत्ती नोड्स पर गेम की स्थिति के लिए स्कोर निर्धारित करने के लिए उपयोग किया जाना है जो एआई के लिए सबसे अच्छा कदम निर्धारित करने के लिए पारित किया जाएगा।

hasThreeInARowAndTwoOpenSpaces_HorizontalscoreBoardState द्वारा कई ऐसी विधियों में से एक है जिसे यह निर्धारित करने के लिए कहा जाता है कि कुछ शर्त पूरी हो गई है (जैसे कि एक पंक्ति में 3 टोकन वाला खिलाड़ी)। यदि यह सच है तो वह उस खिलाड़ी की संख्या लौटाता है जो उस परिस्थितियों को पूरा करता है तो उस खिलाड़ी के स्कोर को बढ़ाता है (या तो मानव खिलाड़ी या एआई)।

विधि को वापस करने के लिए विधि को कॉल करने की आवश्यकता है यह जांचने के लिए कि क्या मान वापस शून्य है (जिसका अर्थ है कि कुछ स्कोर जोड़ा जाना चाहिए)। मैं या तो अगर कथन (जिसे मैंने कोड स्निपेट में किया था) के भीतर विधि द्वारा लौटाए गए मान को सेट कर सकते हैं, या यदि यह 0 वापस नहीं लौटाता है और फिर इसे चर में सेट करता है तो मैं विधि को फिर से कॉल कर सकता हूं। जाहिर है कि दूसरी विधि कम कुशल है, लेकिन यह हो रहा है कि यह क्या हो रहा है, यह ध्यान देने योग्य और अधिक आसान है।

सवाल यह है कि, यदि खराब कथन माना जाता है तो विधि द्वारा लौटाए गए चर द्वारा परिवर्तनीय चर सेट कर रहा है? या यह ठीक है क्योंकि यह अधिक कुशल है?

नोट: दूसरी विधि की अक्षमता काफी तेजी से बढ़ती है क्योंकि यह फॉर-लूप के भीतर है और यह स्थिति कई बार उत्पन्न होती है क्योंकि प्रत्येक स्थिति का परीक्षण किया जाता है। यह प्रत्येक लीफ नोड के लिए एक मिनीमैक्स एल्गोरिदम में भी किया जाता है (प्रत्येक नोड में 7 शाखाएं हो सकती हैं) का मतलब केवल 3 (गहराई से मैं उपयोग कर रहा हूं) की गहराई है, वहां 343 पत्ती नोड्स और 7 की गहराई गहराई है (उच्चतम मैं वर्तमान में हूं उपयोग कर रहे हैं) लगभग 825,000 पत्ते नोड्स हैं।

/* scores the board state of a root node in a minimax algorithm 
* @gameState a 2 dimensional array that stores values for each space on the 
* board. Stores 0 for empty or 1 or 2 if position is taken by a player 
*/ 
int scoreBoardState (int[][] boardState) { 

    int aiScore = 0; 
    int playerScore = 0; 

    int player = -1; 

    for (int i = 0; i < boardState.length; i++) { 
     for (int j = 0; j < boardState[i].length - 4; j++) { 
      if (j < boardState[i].length - 5 && (player = hasThreeInARowAndTwoOpenSpaces_Horizontal(boardState, i, j)) != 0) { 

       if (player == AI) 
        aiScore += 1000; //magic number entered for clarity 
       else if (player == PLAYER) 
        playerScore += 1000; 

      } 
      else if (i < boardState.length - 4 && j > 2 && (player = hasThreeInARowAndOneOpenSpace_Diagonal_UpperRightToLowerLeft(boardState, i, j)) != 0) { 

       if (player == AI) 
        aiScore += SCORE_THREE_IAR_ONE_OS; 
       else if (player == PL) 
        playerScore += SCORE_THREE_IAR_ONE_OS; 
      } 

     } 

    }  

    return aiScore - playerScore; 
} 

/* 
* checks if, starting from the passed in coordinates, whether there are 3 
* spaces taken by the same player with an empty space on either side in a horizontal direction (left to right). 
* 
* returns the player number if the result is true. returns 0 if the result 
*is false or all spaces are empty 
*/ 
int hasThreeInARowAndTwoOpenSpaces_Horizontal(int[][] boardState, int row, int col) { 
    if (boardState[row][col] == 0 
     && boardState[row][col + 1] == boardState[row][col + 2] && boardState[row][col + 2] == boardState[row][col + 3] 
     && boardState[row][col + 4] == 0) 
    { 
     return boardState[row][col + 1]; 
    } 

    return 0; 
} 

Answer 1

यह निश्चित रूप से अप्रत्याशित किसी के द्वारा किया जा रहा है कोड है, जो कोड और अधिक कठिन समर्थन करने के लिए बनाता है पढ़ने के जोखिम को चलाता है। यह अक्सर बचने के लिए एक योग्य चीज है।

दोनों मामलों में यदि कोई प्रदर्शन लागत से बचा जा सकता है तो आप स्थिति को निहित स्थितियों में बदलने के लिए संशोधित कर सकते हैं। तो बजाय इस की:

if (j < boardState[i].length - 5) { 
    player = hasThreeInARowAndTwoOpenSpaces_Horizontal(boardState, i, j); 
    if (player != 0) { 

इस तरह आपरेशन के प्रदर्शन की सजा अभी भी केवल खर्च किया जाता है, जब यह अन्यथा तार्किक मूल कोड में होगा:

if (j < boardState[i].length - 5 && (player = hasThreeInARowAndTwoOpenSpaces_Horizontal(boardState, i, j)) != 0) { 

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

यहां लाभ यह है कि सशर्त स्वयं स्वयं बहुत स्पष्ट और संक्षिप्त हैं। लंबी सशर्त तुलना होने से कोड को बहुत मुश्किल करना पड़ सकता है, लेकिन एक साधारण तुलना सीधा है।

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

Answer 2

मैं नहीं कहूंगा कि यह खराब अभ्यास है। जब तक यह सही ढंग से उपयोग किया जाता है। आपके मामले में उपयोग ठीक है क्योंकि एक वैध शर्त है जिसे एक चर की आवश्यकता होने से पहले पूरा करने की आवश्यकता है। शीर्ष विधि जहां यह एक या अन्य विकल्प नहीं है में, आप निम्नलिखित विचार कर सकते हैं, लेकिन यह सिर्फ एक व्यक्तिगत स्वाद बात है:

condition ? true value : false value 

अगर बयान ठीक जब तक वे उपयोग किया जाता है का उपयोग अगर बयान जारी किए जाने से बयान अतिरिक्त रुकने के लिए तो सब कुछ ठीक है।