अगर नेस्टेड की सरल/अधिक कुशल विधि ... और प्रवाह?

Question

मैं वर्तमान में फ्लैश-क्लाइंट आधारित गेम के लिए एक इम्यूलेशन सर्वर पर काम कर रहा हूं, जिसमें "पालतू जानवर प्रणाली" है, और मैं सोच रहा था कि निर्दिष्ट पालतू जानवरों के स्तर की जांच करने का एक आसान तरीका है या नहीं।

वर्तमान कोड:

public int Level 
{ 
    get 
    { 
     if (Expirience > 100) // Level 2 
     { 
      if (Expirience > 200) // Level 3 
      { 
       if (Expirience > 400) // Level 4 - Unsure of Goal 
       { 
        if (Expirience > 600) // Level 5 - Unsure of Goal 
        { 
         if (Expirience > 1000) // Level 6 
         { 
          if (Expirience > 1300) // Level 7 
          { 
           if (Expirience > 1800) // Level 8 
           { 
            if (Expirience > 2400) // Level 9 
            { 
             if (Expirience > 3200) // Level 10 
             { 
              if (Expirience > 4300) // Level 11 
              { 
               if (Expirience > 7200) // Level 12 - Unsure of Goal 
               { 
                if (Expirience > 8500) // Level 13 - Unsure of Goal 
                { 
                 if (Expirience > 10100) // Level 14 
                 { 
                  if (Expirience > 13300) // Level 15 
                  { 
                   if (Expirience > 17500) // Level 16 
                   { 
                    if (Expirience > 23000) // Level 17 
                    { 
                     return 17; // Bored 
                    } 
                    return 16; 
                   } 
                   return 15; 
                  } 
                  return 14; 
                 } 
                 return 13; 
                } 
                return 12; 
               } 
               return 11; 
              } 
              return 10; 
             } 
             return 9; 
            } 
            return 8; 
           } 
           return 7; 
          } 
          return 6; 
         } 
         return 5; 
        } 
        return 4; 
       } 
       return 3; 
      } 
      return 2; 
     } 
     return 1; 
    } 
} 

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

Answer 1

int[] levelCutoffs = new int[] {0, 100, 200, 400, 600 /*...*/}; 

for (int level = 0; level < levelCuttoffs.size; ++level) { 
    if (Experience < levelCuttofs[level]) 
     return level; 
} 
return levelCuttoffs.size; 

संपादित करें: ब्राडली Mountford के सुझाव का उपयोग करने के बदले हुए।

Answer 2

SortedList<int, int> का उपयोग करें और तब तक इसे फिर से चालू करें जब तक कि आप उस मूल्य को प्राप्त न करें जो आपके द्वारा खोजे जा रहे मूल्य से अधिक है। आप इसे एक सरल पुनरावृत्ति का उपयोग करके कर सकते हैं जैसा कि आपने पहले ही स्वीकार कर लिया है। या यह सुंदर ढंग से (एक मामूली प्रदर्शन कीमत पर) LINQ का उपयोग किया जा सकता है:

SortedList<int, int> levels = new SortedList<int, int> 
    { 
     {0, 1}, 
     {100, 2}, 
     {200, 3}, 
     {400, 4}, 
     {600, 5}, 
    }; 

public int Experience; 
public int Level 
{ 
    get 
    { 
     return levels.Last(kvp => Experience >= kvp.Key).Value; 
    } 
} 

ध्यान दें कि 'स्तर' भंडारण वास्तव में सख्ती से आवश्यक नहीं है के रूप में आप यह सूची में आइटम के सूचकांक से निकाले जाते हैं कर सकते हैं। एक सरल List<int> का उपयोग करना फायदेमंद हो सकता है जो कि त्रुटियों को रोकने के लिए सॉर्ट किया गया है जहां आप गलती से एक स्तर को याद करते हैं, जैसा कि आपने पहले ही स्वीकार कर लिया है।

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

List<int> levels = new List<int> { 0, 100, 200, 400, 600 /* etc... */ }; 

int index = levels.BinarySearch(Experience); 
int level; 
if (index < 0) 
{ 
    level = ~index; 
} 
else 
{ 
    level = index + 1; 
} 
return level; 

Answer 3

आप सबसे अधिक समावेशी से अधिक समावेशी जा रहे हैं। यदि आप दूसरी दिशा में जाते हैं, तो आपको सभी घोंसले की आवश्यकता नहीं है।

if (Expirience > 23000) // Level 17 
    { 
    return 17; // Bored 
    } 
    else if (Expirience > 17500) // Level 16 
    { 
    return 16; 
    } 
    else if (Expirience > 13300) // Level 15 
    { 
    return 15; 
    } 
    ... 

Answer 4

@ मार्क का सुझाव एक उचित है। तुम भी अन-घोंसला करने के लिए भारतीय विदेश सेवा के अनुभव का मूल्यांकन का क्रम उलटने सकता है:

if (Expirience > 23000) return 17; 
if (Expirience > 17500) return 16; 
//... and so on. 

लेकिन मैं शायद सिर्फ एक नियमित रूप से सी # सरणी और BinarySearch विधि है, जो मिलान के आइटम या के सूचकांक लौट सकते हैं का प्रयोग करेंगे कम से कम आइटम सिर्फ आपके द्वारा खोजे गए मूल्य से भी बड़ा है कि 2 के पूरक:

int[] levelThresholds = new[] { 100, 200, 400, 600, 1000, ..., 23000 }; 

int experience = 11403; 
int index = Array.BinarySearch(levelThresholds, experience); 
// returns either the index, or the 2's complement of the 
// first index greater than the value being sought 
int level = index < 0 ? ~index : index+1; 

Answer 5

मैं मार्क बायर्स ले एक कदम आगे का जवाब होगा। के बाद से थोड़ा भ्रामक इसके बजाय

SortedList<UserLevel> 

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

Answer 6

अनुभव एल्गोरिथ्म एक समारोह को कम किया जा सकता है, यह कार्यात्मक गणना का उपयोग करना चाहिए, अर्थात्:

return (Expirience/200); // if each level was 200 xp etc 

हालांकि अपने नेस्टेड अगर ऊपर है, किसी भी समारोह की अवस्था को लागू करने के लिए नहीं लग रहे है?ऑपरेटर:

return 
(Expirience > 23000) ? 17 : 
(Expirience > 17500) ? 16 : 
(Expirience > 13300) ? 15 : 
.. etc .. 
(Expirience > 100) ? 2 : 1; 

Answer 7

लॉगरिदमिक फ़ंक्शन के आधार पर एक साधारण सूत्र के बारे में कैसे?

कुछ की तरह

return Math.Floor(LinearScale * Math.Log(Expirience, LogBase));