TLDR: मैंने Javascript और UIlicious के साथ एक Wordle सॉल्वर बॉट लिखा है। अपना दैनिक Wordle समाधान प्राप्त करने के लिए आप किसी भी दिन इस स्निपेट को फिर से चला सकते हैं या संपादित कर सकते हैं। कोशिश करें और देखें कि क्या आप बॉट से बेहतर स्कोर प्राप्त कर सकते हैं! इसे बेझिझक संपादित करें और सॉल्वर एल्गोरिथम को अनुकूलित करें!

पूर्ण प्रकटीकरण: मैं Uilicious.com का सह-संस्थापक और सीटीओ हूं (इस लेख में दिखाया गया है)

वर्डलर सॉल्वर को 3 भागों में कवर किया गया है, जो को कवर करता है

• यूआई इंटरेक्शन कोड (यहां लिंक किया गया)
• वर्डल स्टैटिस्टिकल मॉडल, और इसके पीछे का गणित (यह लेख)
• वर्डल सॉल्वर का यूनिट परीक्षण और बेंचमार्किंग (@todo)

सभी सांख्यिकीय उदाहरण निम्नलिखित लिंक पर देखे जा सकते हैं: https://uilicio.us/wordle-statistics-sample और यहां इस्तेमाल किए गए कोड के माध्यम से उत्पन्न होता है: https://github.com/uilicious/wordle-solver-and-tester

हमारी विश्व रणनीति

अस्वीकरण, मैं इसके लिए सबसे अच्छी WORDLE रणनीति (अभी तक) होने का दावा नहीं करता, लेकिन यह एक अच्छी रणनीति है =)

आँकड़ों में जाने से पहले, आइए पहले हमारी WORLDE रणनीति को कवर करें।

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

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

2 शब्द सूची को देखते हुए, एक संभावित उत्तरों से भरा (~ 2.3k शब्द), और दूसरा पूर्ण शब्द सूची (13k शब्द) के साथ ...

• पिछले अनुमानों से वर्तमान गेम स्थिति के विरुद्ध संभावित उत्तर सूची में शब्दों को फ़िल्टर करें।

• गिनें कि प्रत्येक वर्ण उत्तर शब्द सूची में उनके संबंधित शब्द स्थितियों में कितनी बार प्रकट होता है।

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

• उच्चतम स्कोरिंग शब्द चुनें और इसे आजमाएं।

• यदि आवश्यक हो तो ऊपर से दोहराएं।

  
  

यह भी स्पष्ट करने के लिए: हम पिछले वर्डल समाधानों को याद नहीं करते हैं (मुझे लगा कि यह धोखा था क्योंकि सिस्टम क्रम में दिन-प्रतिदिन की सूची को याद कर सकता है)।

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

तो यह व्यवहार में कैसे काम करता है? Wordle रणनीति के हमारे वर्तमान पुनरावृत्ति के लिए, हम इसे अभ्यास में चरण दर चरण (बिना कोड के) देखेंगे।

हमारा प्रारंभिक शब्द: SAINE - और आपको इसका उपयोग क्यों करना चाहिए

सेन के लिए एक उपनाम, जिसका अर्थ है: क्रॉस ओवर (स्वयं) का चिन्ह बनाना ताकि बुराई या पाप से आशीर्वाद या रक्षा हो सके

शुरुआती 2 शब्दों पर बहुत सारी सलाह दी गई है। और यह समझ में आता है कि यह शब्द इस प्रकार है:

• 3 बहुत ही सामान्य स्वर
• सभी अद्वितीय पात्र

लेकिन आइए जानें कि सॉल्वर संख्याओं को देखकर इस शब्द को क्यों चुनता है।

आँकड़ों के आधार पर। शीर्ष स्वरों में से 3 होने पर "SAINE" के पास एक शुरुआती शब्द के रूप में एक सटीक हरे वर्ण मिलान को खोजने का सबसे अधिक मौका है।

कच्ची वितरण तालिका को पढ़ना पचाने में काफी कठिन हो सकता है। तो मैं यहां उन नंबरों को फिर से संदर्भित करता हूं। सैनी ने एक…

• कम से कम 1 वर्ण (पीला/हरा) के आंशिक मिलान की 91.06% संभावना;
• कम से कम 2 वर्णों (पीला/हरा) के आंशिक मिलान की 55.94% संभावना;
• कम से कम 1 वर्ण (हरा) के सटीक मिलान की 50.24% संभावना।

कम से कम एक या दो प्रमुख सुराग मिलने की बहुत अधिक संभावना है। इसके विपरीत, क्योंकि ए, आई और ई के बिना कुछ शब्द हैं, मिलान करने में विफलता एक "विशाल सुराग" है।

एक उद्घाटन हुह के लिए बुरा नहीं है?

"क्रेन" और "एडीईपीटी" जैसे अन्य लोकप्रिय शुरुआती शब्दों के बारे में क्या?

"क्रैन/एडीईपीटी" के लिए एकमात्र महत्वपूर्ण लाभ यह है कि दोनों के पास 1-शब्द अनुमान सफलतापूर्वक करने का 0.04% मौका है। मुझे संदेह है कि पिछले सार्वजनिक विश्लेषण का दोष यह था कि वे शुरुआती शब्द को ज्ञात उत्तर सूची तक कैसे सीमित कर रहे थे। मेरा मानना है कि हालांकि, हमें 1-शब्द अनुमान करने के बहुत ही संकीर्ण अवसर के पक्ष में सुराग की संभावनाओं को अधिकतम करने के लिए पूर्ण शब्द सूची का उपयोग करना चाहिए।

इससे भी महत्वपूर्ण बात यह है कि SAINE के पास पहले प्रयास में सटीक मिलान (हरा) का अनुमान लगाने की काफी अधिक संभावना (~ 7%) है। जो एक सुराग के रूप में अविश्वसनीय रूप से सहायक है।

शुरुआती शब्द बहस के साथ, हम देखेंगे कि सिस्टम विभिन्न परिणामों के साथ कैसे प्रतिक्रिया करता है!

यह समझना कि कैसे दूसरा अनुमान प्लूटो, ठहराव की ओर ले जाता है

तो आइए देखें कि उत्तर "PAUSE" (बाईं ओर) के लिए दूसरा शब्द कैसे चुना जाता है।

हमें निम्नलिखित जानकारी दी गई है:

• अक्षर I और N शब्द में नहीं है।

• A दूसरा वर्ण है, E पाँचवाँ वर्ण है।

• S या तो तीसरा या चौथा वर्ण है (यह पहला वर्ण नहीं है)।

• शब्द सूची में केवल 12 संभावित उत्तर हैं

  
  

सुंदर मानक वर्डल सामान। लेकिन आइए देखें कि यह शेष संभावित उत्तरों पर आँकड़ों को कैसे प्रभावित करता है। और कैसे "प्लूटो" को चुना गया।

केवल 12 शब्दों के साथ, आइए अपने विकल्पों को खत्म करने का सबसे कारगर तरीका खोजें।

• चूंकि हमारे पास पहले से ही एस, ई, ए अक्षरों की जानकारी है, इसलिए हमारी स्कोरिंग प्रणाली उन्हें दंड (लाल रंग में चिह्नित) से बचाएगी।
• पदों में वर्णों की अगली सबसे बड़ी संभावनाएं जिनके बारे में हम नहीं जानते हैं, क्रमशः 1, 3 और 4 की स्थिति में पी, यू और टी हैं (नारंगी में चिह्नित)।
• अंत में, क्योंकि हमारे पास स्थिति 2 और 5 हल हैं, हम अतिरिक्त जानकारी प्राप्त करने के लिए इसका उपयोग कर सकते हैं। तो आइए हम एल एंड सी के पात्रों का उपयोग करने की पूरी कोशिश करते हैं।

निम्नलिखित बाधाओं से, कोशिश करने के लिए एकमात्र मान्य शब्द प्लूटो था। हालाँकि हम जानते हैं कि O अक्षर अंतिम उत्तर में नहीं है, लेकिन "PLUTC" के लिए कोई शब्द नहीं है। इसके अलावा, जबकि प्लूटो शब्द उत्तर सूची में नहीं था, यह पूर्ण शब्द सूची में था, जिससे यह एक वैध अनुमान बन गया।

सबमिशन के बाद, सिस्टम अब निम्नलिखित जानता है:

• एल, टी, ओ शब्द में नहीं है (ओ एक धारणा की पुष्टि है)।
• P पहला वर्ण है, U तीसरा वर्ण है।
• S चौथा वर्ण है (क्या यह अब तीसरा वर्ण नहीं हो सकता है)।

इसका मतलब है कि मुझे अब आँकड़ों की आवश्यकता नहीं है क्योंकि केवल एक ही सच्चाई है: PAUSE।

लेकिन पागल अनुमान लगाने के पैटर्न के साथ क्या है? मोहर, ब्लाइप और अंत में अल्सर के साथ

मोहर एक सोने का सिक्का है जिसे पूर्व में ब्रिटिश भारत और इसके साथ मौजूद कुछ रियासतों सहित कई सरकारों द्वारा ढाला गया था।

यहां आँकड़ों का लाइव मूल्यांकन किया जा रहा है और परिवर्तन प्रत्येक दौर के परिणाम पर निर्भर हैं। तो परिणाम अलग था जहां:

• अक्षर S, A, I, N शब्द में नहीं है।

• अक्षर E 1, 2, 3, 4 की स्थिति में हो सकता है लेकिन 5 में नहीं।

  
  

संभावित उत्तर सूची को छानने से निम्नलिखित आँकड़े प्राप्त होते हैं:

यह पहली बार में समझ में नहीं आता है क्योंकि शब्द सी या बी से शुरू नहीं होता है। 187 शब्दों के साथ, यह वह जगह है जहां स्कोरिंग का विवरण मायने रखता है।

• एक बार फिर, हम ई अक्षर को अनदेखा कर देते हैं, जो कि वह जानकारी है जिसे हम पहले से जानते हैं (लाल रंग में)।
• अंत में अक्षर R में बड़े अंतर से उच्चतम भार (62 शब्दों का) है। इस वर्ण के लिए उत्तर का पता लगाना या तो संभावना सूची को आधा कर देता है (कोई मेल नहीं), या एक तिहाई (यह मेल खाता है)।
• यहां से, अगला चरण संबंधित पदों में अन्य अक्षरों के खिलाफ सबसे अधिक मिलान वाले शब्द को ढूंढ रहा है जैसे ओ स्थिति 2 (37 का स्कोर), उसके बाद किसी भी शेष वर्ण। या तो उनकी स्थितीय सूची या अद्वितीय अक्षरों की सूची का मिलान करना।

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

अनुमान के परिणाम दिलचस्प थे।

मोहुर शब्द जितना अजीब और भ्रमित करने वाला था, परिणाम ने संभावना को घटाकर 12 शब्द कर दिया। एक बार फिर, यह नए पात्रों की कोशिश करने और इसे BLYPE का अस्पष्ट शब्द देने को प्राथमिकता देने की कोशिश करता है।

BLYPE: त्वचा का एक टुकड़ा या टुकड़ा

यह शब्द संभावनाओं की सूची को एक शब्द तक कम कर देता है - ULCER, जो कि अंतिम उत्तर है।

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

⚠️ कोड चेतावनी आगे: यदि आप केवल गणित और आँकड़ों के लिए यहाँ थे तो अंत तक जाएँ। इस लेख की शेष सामग्री में JS कोड है।

मुझे कोड दिखाओ

पूर्ण समाधान वर्ग यहां पाया जा सकता है।

यह आलेख मुख्य कार्यक्षमता पर ध्यान केंद्रित करेगा जो इस प्रक्रिया को काम करने के लिए आवश्यक है, न कि कोड के सभी हिस्सों पर। यदि आपने भाग 1 नहीं पढ़ा है तो इसे यहाँ पढ़ें ।

"बॉयलरप्लेट" सामग्री को छोड़ने के लिए यहां कोड को सरल बनाया गया है।

सॉल्वर को निम्नलिखित करने की आवश्यकता है:

• वर्तमान गेम स्थिति को देखते हुए, संभावित शब्द सूची को फ़िल्टर करें।
• फ़िल्टर की गई शब्द सूची को देखते हुए, आँकड़ों की गणना करें।
• आंकड़ों और खेल की स्थिति को देखते हुए, रणनीति के बाद शब्द स्कोर करें।
• एक शब्द सुझाएं।

आइए हम इसे तोड़ दें, टुकड़े-टुकड़े कर दें।

गेम स्टेट ऑब्जेक्ट को सामान्य करें (भाग 1 में उत्पन्न)

हर राउंड के लिए, गेम स्टेट के साथ उत्पन्न होगा:

• .इतिहास [] : पिछले शब्द अनुमानों की एक सरणी।
• .pos[]: निम्नलिखित जानकारी वाली वस्तुओं की एक सरणी।
  • .hintSet : वर्णों का समूह जो मान्य "संकेत" हैं।
  • .foundChar: वर्ण जो दिए गए पद के लिए पुष्टि की जाती हैं।

यह भाग 1 में स्क्रीन पर जानकारी का उपयोग करके उत्पन्न होता है।

हालांकि, हमारे उपयोग के मामले के लिए, हमें कुछ सामान्य डेटा सेट को सामान्य करने की आवश्यकता होगी जिनकी हमें आवश्यकता होगी। _normalizeStateObj फ़ंक्शन के माध्यम से, हम निम्नलिखित प्राप्त करते हैं।

• badCharSet: वर्ण हम जानते हैं कि शब्द में नहीं है;
• goodCharSet: जिन वर्णों की हमने पुष्टि की है, वे शब्द में हैं।

यह .history , और .pos डेटा को पहले अच्छी वर्ण सूची बनाने के लिए पुनरावृत्त करके आसानी से उत्पन्न होता है। फिर इसका उपयोग ऐतिहासिक शब्द सूची के विपरीत खराब चरित्र सूची बनाने के लिए किया जाता है।

 /** * Given the state object, normalize various values, using the minimum "required" value. * This does not provide as much data as `WordleSolvingAlgo` focusing on the minimum required * to make the current system work * * @param {Object} state * * @return {Object} state object normalized */ function _normalizeStateObj( state ) { // Setup the initial charset state.badCharSet = new Set(); state.goodCharSet = new Set(); // Lets build the good charset for(let i=0; i<state.wordLength; ++i) { if( state.pos[i].foundChar ) { state.goodCharSet.add(state.pos[i].foundChar); } for(let char of state.pos[i].hintSet) { state.goodCharSet.add(char); } } // Lets iterate history and build badCharSet for(let i=0; i<state.history.length; ++i) { const word = state.history[i]; for( let w=0; w<word.length; ++w ) { // check the individual char let char = word.charAt(w); // If char is not in good set if( !state.goodCharSet.has(char) ) { // its in the bad set state.badCharSet.add(char); } } } // Return the normalize state object return state; }

संभावित शब्द सूची को छानना

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

 /** * Given the wordList, filter only for possible answers, using the state object. * And returns the filtered list. This function just returns the wordList, if state == null * @param {Array<String>} wordList * @param {Object} state */ function filterWordList( wordList, state ) { // Skip if its not setup if( state == null || wordList.length <= 0 ) { return wordList; } // Get the word length const wordLength = wordList[0].length; // Filter and return return wordList.filter(function(s) { // Filtering logic // .... // all checks pass, return true return true; }); }

फ़िल्टरिंग लॉजिक के लिए, हम पहले badCharSET के भीतर के शब्दों को हटाते हैं।

 // filter out invalid words (aka hard mode) for(const bad of state.badCharSet) { // PS : this does nothing if the set is empty if(s.includes(bad)) { return false; } }

गलत संकेत स्थानों वाले शब्दों को फ़िल्टर करने के बाद:

 // filter out words with wrong hint locations, for each character position for(let i=0; i<wordLength; ++i) { // Get the word character let sChar = s.charAt(i); // Check if the chracter, conflicts with an existing found char (green) if(state.pos[i].foundChar && sChar != state.pos[i].foundChar) { return false; } // Check if the character is already a known mismatch (yellow, partial match) // for each position for(const bad of state.pos[i].hintSet) { if(sChar == bad) { return false; } } }

सभी ज्ञात (सटीक, और आंशिक) मिलानों के बिना बाद के शब्दों के लिए:

 // filter out words WITHOUT the hinted chars // PS : this does nothing if the set is empty for(const good of state.goodCharSet) { if(!s.includes(good)) { return false; } }

इसके अलावा, हमारे पास filterForUniqueWordList के लिए अद्वितीय शब्दों को फ़िल्टर करने के लिए एक प्रकार है। इसमें कोई वर्ण डुप्लिकेट नहीं है और पहले कुछ राउंड में इसका उपयोग किया जाता है:

 let wordCharSet = new Set(); // iterate the characters for(const char of s) { // Update the word charset wordCharSet.add(char); } // There is duplicate characters if( wordCharSet.size != s.length ) { return false; }

सांख्यिकी शब्द उत्पन्न करना

शेष सभी संभावित उत्तरों को फ़िल्टर करने के बाद, आंकड़े charsetStatistics( dictArray ) के माध्यम से उत्पन्न होते हैं

यह आँकड़ों के प्रकार के लिए एक वस्तु का निर्माण करके किया जाता है। शब्द सूची को पुनरावृत्त करें और संख्याओं में वृद्धि करें:

 /** * Analyze the given dictionary array, to get character statistics * This will return the required statistics model, to be used in guessing a word. * * Which is provided in 3 major parts, using an object, which uses the character as a key, followed by its frequency as a number * * - overall : Frequency of apperance of each character * - unique : Frequency of apperance of each character per word (meaning, duplicates in 1 word is ignored) * - positional : An array of object, which provides the frequency of apperance unique to that word position * * Note that because it is possible for the dataset to not have characters in the list / positional location, * you should assume any result without a key, means a freqency of 0 * * @param {Array<String>} dictArray - containg various words, of equal length * * @return Object with the respective, overall / unique / positional stats **/ charsetStatistics( dictArray ) { // Safety check if( dictArray == null || dictArray.length <= 0 ) { throw `Unexpected empty dictionary list, unable to perform charsetStatistics / guesses`; } // The overall stats, for each character let overallStats = {}; // The overall stats, for each unique charcter // (ignore duplicates in word) let overallUniqueStats = {}; // The stats, for each character slot let positionalStats = []; // Lets initialize the positionalStats let wordLen = dictArray[0].length; for(let i=0; i<wordLen; ++i) { positionalStats[i] = {}; } // Lets iterate the full dictionary for( const word of dictArray ) { // Character set for the word const charSet = new Set(); // For each character, populate the overall stats for( let i=0; i<wordLen; ++i ) { // Get the character const char = word.charAt(i); // Increment the overall stat this._incrementObjectProperty( overallStats, char ); // Populate the charset, for overall unique stats charSet.add( char ); // Increment each positional stat this._incrementObjectProperty( positionalStats[i], char ); } // Populate the unique stats for( const char of charSet ) { // Increment the overall unique stat this._incrementObjectProperty( overallUniqueStats, char ); } } // Lets return the stats obj return { overall: overallStats, unique: overallUniqueStats, positional: positionalStats } }

यह संबंधित सांख्यिकीय गणना के भीतर प्रत्येक शब्द और प्रत्येक वर्ण वृद्धि में लूपिंग के लिए काफी सरल है।

एकमात्र गोचा यह है कि जब हम प्रारंभ नहीं होते हैं तो हम किसी ऑब्जेक्ट प्रॉपर्टी पर ++ वृद्धि करने में असमर्थ होते हैं। इसके परिणामस्वरूप निम्न त्रुटि होगी:

 // This will give an exception for // TypeError: Cannot read properties of undefined (reading 'a') let obj; obj["a"]++;

इसलिए हमें अपने आवश्यक उपयोग के मामले को ठीक से बढ़ाने के लिए एक साधारण सहायक फ़ंक्शन का उपयोग करने की आवश्यकता होगी:

 /** * Increment an object key, used at various stages of the counting process * @param {Object} obj * @param {String} key **/ _incrementObjectProperty( obj, key ) { if( obj[key] > 0 ) { obj[key]++; } else { obj[key] = 1; } } 

प्रत्येक शब्द स्कोरिंग

सॉल्वर के केंद्र में स्कोरिंग लॉजिक है। जो दिए गए आँकड़ों और स्थिति के साथ हर संभव शब्द इनपुट पर रैंक किया गया है।

अस्वीकरण: मैं यह दावा नहीं करता कि वर्डल के लिए यह सबसे इष्टतम शब्द स्कोरिंग फ़ंक्शन है। इसमें निश्चित रूप से सुधार किया जा सकता है, लेकिन यह मेरे अब तक के परीक्षण से काफी अच्छा है। =)

 /** * The heart of the wordle solving system. * * @param {Object} charStats, output from charsetStats * @param {String} word to score * @param {Object} state object (to refine score) * * @return {Number} representing the word score (may have decimal places) **/ function scoreWord( charStats, word, state = null ) { // Character set for the word, used to check for uniqueness const charSet = new Set(); // the final score to return let score = 0; // Wordle Strategy note: // // - Penalize duplicate characters, as they limit the amount of information we get // - Priotize characters with high positional score, this helps increase the chances of "exact green matches" early // reducing the effort required to deduce "partial yello matches" // - If there is a tie, in positional score, tie break it with "unique" score and overall score // this tends to be relevent in the last <100 matches // // - We used to favour positional score, over unique score in the last few rounds only // but after several trial and errors run, we found it was better to just use positonal score all the way // Lets do scoring math // ... // Return the score return score; }

यह विभिन्न चरणों से गुजरता है: सबसे पहले, हम सिस्टम को फिर से एक शब्द का सुझाव देने से रोकने के लिए एक सुरक्षा जाल जोड़ते हैं (विशाल नकारात्मक स्कोर)।

 // Skip attempted words - like WHY ??? if( state && state.history ) { if( state.history.indexOf(word) >= 0 ) { return -1000*1000; } }

फिर हम शब्द के प्रत्येक वर्ण को पुनरावृत्त करते हैं, और उन्हें क्रमशः स्कोर करते हैं:

 // For each character, populate the overall stats for( let i=0; i<word.length; ++i ) { // Get the character const char = word.charAt(i); // Does scoring for each character // ... }

दोहराए गए वर्णों या ज्ञात वर्णों वाले शब्दों को दंडित करना:

 // skip scoring of known character matches // or the attempted character hints if( state ) { // Skip known chars (good/found) if( state.pos && state.pos[i].foundChar == char ) { score += -50; charSet.add( char ); continue; } // Skip scoring of duplicate char if( charSet.has( char ) ) { score += -25; continue; } // Skip known chars (good/found) if( state.goodCharSet && state.goodCharSet.has(char) ) { score += -10; charSet.add( char ); continue; } } else { // Skip scoring of duplicate char if( charSet.has( char ) ) { score += -25; continue; } } // Populate the charset, we check this to favour words of unique chars charSet.add( char );

अंत में, हम टाई-ब्रेकर के रूप में उपयोग किए जा रहे अद्वितीय वर्ण स्कोरिंग के साथ प्रत्येक स्थितीय आंकड़े के लिए स्कोर की गणना करते हैं:

 // Dev Note: // // In general - we should always do a check if the "character" exists in the list. // This helps handle some NaN situations, where the character has no score // this is possible because the valid list will include words, that can be inputted // but is not part of the filtered list - see `charsetStatistics` if( charStats.positional[i][char] ) { score += charStats.positional[i][char]*10000; } if (charStats.unique[char]) { score += charStats.unique[char] } // -- Loops to the next char -- //

अब जब हमारे पास स्कोरिंग फ़ंक्शन है तो हम "suggestWord" फ़ंक्शन के लिए सभी भागों को एक साथ रखना शुरू कर सकते हैं।

एक शब्द का सुझाव देना (इसे एक साथ रखना)

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

हम खेल राज्य दिए जाने के साथ शुरू करते हैं:

• खेल की स्थिति को सामान्य करें;
• फ़िल्टर, अद्वितीय, और पूर्ण शब्द सूचियां उत्पन्न करें।

 /** * Given the minimum state object, suggest the next word to attempt a guess. * * --- * # "state" object definition * * The solver, requires to know the existing wordle state information so this would consist of (at minimum) * * .history[] : an array of past wordle guesses * .pos[] : an array of objects containing the following info * .hintSet : set of characters that are valid "hints" * .foundChar : characters that are confirmed for the given position * * The above is compliant with the WordleAlgoTester state object format * Additional values will be added to the state object, using the above given information * --- * * @param {Object} state * * @return {String} word guess to perform */ suggestWord( state ) { // Normalize the state object state = this._normalizeStateObj(state); // Let'sLets get the respective wordlist let fullWordList = this.fullWordList; let filteredWordList = this.filterWordList( this.filteredWordList, state ); let uniqueWordList = this.filterForUniqueWords( this.uniqueWordList, state ); // As an object let wordList = { full: fullWordList, unique: uniqueWordList, filtered: filteredWordList }; // Lets do work on the various wordlist, and state // this is refactored as `suggestWord_fromStateAndWordList` // in the code base // .... }

एक बार जब हमारे पास विभिन्न गेम स्टेट्स और शब्द सूचियां हों, तो हम "सांख्यिकी शब्द सूची" पर निर्णय ले सकते हैं, जिसका उपयोग हम आंकड़े मॉडल बनाने के लिए करते हैं।

 // Let's decide on which word list we use for the statistics // which should be the filtered word list **unless** there is // no possible answers on that list, which is possible when // the system is being used against a WORDLE variant // // In such a case, lets fall back to the filtered version of the "full // word list", instead of the filtered version of the "answer list". let statsList = wordList.filtered; if( wordList.filtered == null || wordList.filtered.length <= 0 ) { console.warn("[WARNING]: Unexpected empty 'filtered' wordlist, with no possible answers : falling back to full word list"); statsList = this.filterWordList( wordList.full, state ); } if( wordList.filtered == null || wordList.filtered.length <= 0 ) { console.warn("[WARNING]: Unexpected empty 'filtered' wordlist, with no possible answers : despite processing from full list, using it raw"); statsList = wordList.full; }

एक बार जब हम आँकड़े शब्द सूची पर निर्णय लेते हैं, तो हमें आँकड़े प्राप्त होते हैं:

 // Get the charset stats const charStats = this.charsetStatistics(statsList);

अब हम शब्द सूची का निर्णय किसी शब्द को तय करने में करते हैं। हम इस सूची को "स्कोरलिस्ट" के रूप में संदर्भित करते हैं।

पहले कुछ दौरों में, हम जितना संभव हो सके अनूठे शब्दों का उपयोग करने का लक्ष्य रखते हैं। जिसमें वे पात्र शामिल नहीं होंगे जिन्हें हमने पहले आजमाया है। इसमें वे शब्द शामिल हो सकते हैं जिन्हें हम जानते हैं कि संभावित उत्तर सूची में नहीं हैं।

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

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

 // sort the scored list, use unique words in first few rounds let scoredList = wordList.unique; // Use valid list from round 5 onwards // or when the unique list is drained if( scoredList.length == 0 || state.round >= 5 ) { scoredList = wordList.full; } // Use filtered list in last 2 round, or when its a gurantee "win" if( wordList.filtered.length > 0 && // (wordList.filtered.length < state.roundLeft || state.roundLeft <= 1) // ) { scoredList = wordList.filtered; }

एक बार जब हमने आँकड़ों को लागू करने के लिए स्कोरिंग सूची पर निर्णय लिया, तो आइए हम स्कोर करें और इसे क्रमबद्ध करें:

 // Self reference const self = this; // Score word sorting scoredList = scoredList.slice(0).sort(function(a,b) { // Get the score let bScore = self.scoreWord( charStats, b, state, finalStretch ); let aScore = self.scoreWord( charStats, a, state, finalStretch ); // And arrange them accordingly if( bScore > aScore ) { return 1; } else if( bScore == aScore ) { // Tie breakers - rare // as we already have score breakers in the algori if( b > a ) { return 1; } else if( a > b ) { return -1; } // Equality tie ??? return 0; } else { return -1; } });

और उच्चतम स्कोरिंग आइटम लौटाएं:

 // Return the highest scoring word guess return scoredList[0]; 

यह सब एक साथ डालें

भाग 1 में किए गए UI इंटरैक्शन कोड के साथ। यह देखने के लिए "रन" बटन दबाएं कि हमारा वर्डल बॉट कैसा करता है!

अरे, बुरा नहीं, मेरे बॉट ने आज के वर्डले को हल कर दिया!

ले लो - मनुष्यों के लिए?

क्योंकि बॉट विशाल शब्दकोशों के साथ संभावनाओं की गणना करने की एक "अमानवीय" तकनीक का उपयोग करेंगे।

अधिकांश मनुष्य पाएंगे कि यह वास्तव में अजीब और पागल अनुमान लगाने की सीमा रेखा है। गणित पर विश्वास करें क्योंकि यह काम करता है।

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

यह आप पर निर्भर है क्योंकि यह आपका खेल है! =) मज़े करो।

हैप्पी वर्डलिंग! मैं

पहली बार यहां प्रकाशित हुआ