नुकसान का नक्शा

#नुकसान का नक्शा > प्रोग्रामिंग

आंदोलनों के मूल्यांकन और हमले संयोजनों के प्रबंधन के साथ, लीकवार्स में क्षति मानचित्र एक बहुत जरूरी है। मुख्य उद्देश्य मोड़ के अंत में कम खतरे वाले बॉक्स में पीछे हटने में सक्षम होने के लिए, प्रत्येक बॉक्स के खतरे के स्तर पर निर्भर करते हुए, आकलन करने में सक्षम होना है। एक साहचर्य सरणी बनाने का सबसे आसान तरीका है: dangerMap=[ cell1:danger1 , cell2:danger2 , ... ], संभवतः आपके पहुंच योग्य सेल तक सीमित है। इस उद्देश्य के लिए, कई एल्गोरिदम संभव हैं

"बेवकूफ" एल्गोरिदम

यह आमतौर पर पहला विचार है जो खतरे के आकलन के लिए एल्गोरिथम बनाते समय दिमाग में आता है। विचार निम्नलिखित है:

/* -मेरे प्रत्येक सुलभ सेल के लिए -प्रत्येक प्रतिद्वंद्वी के लिए -प्रतिद्वंद्वी के प्रत्येक सुलभ सेल के लिए -प्रत्येक विरोधी के हथियार के लिए -अगर वह मेरे सेल को अपने सेल से शूट कर सकता है मेरे सेल में "डेंजर स्कोर" जोड़ें */

स्कोर का चुनाव आपके एल्गोरिथ्म का एक अभिन्न अंग है: आप इसमें "+1" डाल सकते हैं, या संभावित रूप से होने वाले नुकसान की गणना कर सकते हैं, ... इस मूल्यांकन को परिष्कृत करने के जितने तरीके हैं उतने ही खिलाड़ी हैं 😉

इस एल्गोरिथम के साथ बड़ी समस्या यह है कि यह संचालन में बेहद लालची है! इसलिए इसे आम तौर पर बहुत जल्दी अनुकूलित करना आवश्यक है।

अनुकूलन ट्रैक

करने के लिए पहली बात यह है कि अपने लीक को "दुर्घटनाग्रस्त" होने से रोकें ... तो आपको कोड में कहीं, getOperations() पर एक परीक्षण करना होगा और यदि संचालन की संख्या बहुत करीब हो जाती है तो लूप से बाहर निकलें सीमा: आपके पास खतरे का केवल एक आंशिक आकलन होगा, लेकिन आपका लीक अभी भी न्यूनतम स्थानांतरित करने में सक्षम होगा 😉

ऑप्टिमाइज़ेशन के लिए, पहले सिद्धांतों में से एक जो आपके दृष्टिकोण का मार्गदर्शन करना चाहिए, सबसे ऊपर है कि लूप में कई बार एक ही ऑपरेशन को दोहराने से बचें: इस मामले में टेबल में चीजों को तैयार करना बेहतर है, फिर याद रखें। इसलिए, उदाहरण के लिए, "खतरे के स्कोर" की गणना करने वाले अंतरतम लूप में, यदि आप इसमें getStrength(Anemy) को कॉल करते हैं, तो आप उस फ़ंक्शन को हजारों बार कॉल बैक करेंगे। इसके बाद विचार यह है कि केवल एक बार दुश्मन की ताकत की गणना की जाए और इसे *पहले * आंतरिक लूप करने के लिए एक चर में संग्रहीत किया जाए। आप पहले से ही कुछ लाख ट्रेड अर्जित करना शुरू कर देंगे! तो "आंतरिक" लूप के तत्वों की तलाश करें जो लूप वेरिएबल पर निर्भर नहीं हैं, बल्कि केवल "बाहरी" लूप पर निर्भर करते हैं: फिर आप इन तत्वों को उनके लूप पर वापस ढूंढ सकते हैं।

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

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

"एक बार और सभी के लिए" एल्गोरिथम

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