हम टॉप 10 में बाहर हो गए। टेलीग्राम बॉट

प्रागितिहास

यह सब इस तथ्य से शुरू हुआ कि उन्होंने मुझे टेलीग्राम में एक बॉट के लिए एक लिंक भेजा जिसमें खेलने की पेशकश थी।
यह कुछ इस तरह दिखता है।

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

चलो चलते हैं

मैंने डेटाबेस के लिए sqlite3 का उपयोग करने का निर्णय लिया, यह मोबाइल है और इस कार्य के लिए सबसे अधिक है।

आधार की संरचना इस तरह दिखती है।

CREATE TABLE IF NOT EXISTS words ( word VARCHAR(225) UNIQUE NOT NULL, length INTEGER NOT NULL ); 

• शब्द - नाम से यह स्पष्ट है कि यह शब्द का संग्रहीत शाब्दिक अर्थ है।
• लंबाई - चरित्र की लंबाई।

एक संरचना है; इसे भरने के लिए, मैंने रूसी शब्दों की संज्ञा की एक सूची का उपयोग किया।

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

बेस फ़ाइल का निर्माण और तालिका का निर्माण भी init () में लागू किया गया है

 func init() { var err error connection, err = sql.Open("sqlite3", "./words.db") if err != nil { log.Fatalf("Failed connection: %v", err) } _, err = connection.Exec(`CREATE TABLE IF NOT EXISTS words (word VARCHAR(225) UNIQUE NOT NULL, length INTEGER NOT NULL);`) if err != nil { log.Fatalf("Failed create database table words: %v", err) } } 

सम्मिलित करें () फ़ंक्शन

शब्दों को जोड़ते समय, आपको यह याद रखना होगा कि हम सिरिलिक वर्णमाला का उपयोग करते हैं, यही वजह है कि सामान्य len() फ़ंक्शन हमें सूट नहीं करता है, हम शब्द की लंबाई की सही गणना करने के लिए utf8.RuneCountInString() का उपयोग करेंगे।

त्रुटि की जाँच करें if err.Error() != "UNIQUE constraint failed: words.word" - नए शब्दकोशों को शुरू करने की संभावना के लिए आवश्यक है जिसमें डेटाबेस से शब्दों की एक प्रति शामिल है।

 func insert(word string) error { _, err := connection.Exec("INSERT INTO words (word,length) VALUES(?,?)", word, utf8.RuneCountInString(word)) if err != nil && err.Error() != "UNIQUE constraint failed: words.word" { return err } return nil } 

स्रोत बनाने वाले शब्दों की खोज करने के लिए, इसे अक्षरों में विघटित करना आवश्यक है। एक शब्द में कई समान अक्षर हो सकते हैं, राशि के लिए हम map[rune]int उपयोग करते हैं map[rune]int जहां int शब्द में पाए जाने वाले अक्षरों की संख्या है।

 func decay(word string) map[rune]int { var m = make(map[rune]int) for _, char := range word { m[char]++ } return m } 

खोज स्वयं को मल्टीथ्रेडेड मोड में ले जाया जाता है, गोरुटाइन की संख्या = मूल शब्द की लंबाई, माइनस एक गोरूटाइन हम दो या दो से अधिक अक्षरों वाले शब्दों को खोजकर शुरू करते हैं।

इस दृष्टिकोण के साथ, कार्यक्रम ने बहुत तेजी से काम किया और बॉट को चैट में जवाब = गोरूटाइन की संख्या भेजी, हालांकि हर गोरटाइन में समय था time.Sleap(1 * time.Second) - इसके कारण मेरे टेलीग्राम को 10 मिनट के लिए सभी उपकरणों को अवरुद्ध करना पड़ा। मैंने इसे ध्यान में रखा और वर्तमान संस्करण में मैंने भेजने में देरी की, और भेजने के कार्य को एक अलग गोरूटीन में डाल दिया, जो एक सामान्य चैनल के माध्यम से दूसरों के साथ संचार करता है। खोज को पहले की तरह किया जाता है।

हम डेटाबेस से सभी शब्दों की खोज को समाप्त करने के लिए और फिर चैनल को बंद करने के लिए एक तंत्र के रूप में waitGroup{} उपयोग करते हैं।

 func findSubWords(word string) { list := decay(word) for length := 2; length <= utf8.RuneCountInString(word); length++ { wg.Add(1) go func(out chan<- string, length int) { search(out, list, length) wg.Done() fmt.Println("Done: ", length) }(out, length) } wg.Wait() fmt.Println("search done") close(out) } 

खोज फ़ंक्शन डेटाबेस से वांछित लंबाई वाले सभी शब्दों का चयन करता है और लूप की जाँच करता है कि क्या शब्द उपयुक्त है। सत्यापन कई चरणों में किया जाता है। map के उपयोग के कारण map हम हर बार लूप चक्र को पूरा करने के लिए एक नई प्रति बनाते हैं। हमें किसी शब्द में अक्षरों की संख्या की जांच करने के लिए map की एक प्रति की आवश्यकता होती है, हर बार एक पत्र मेल खाता है, हम एक-एक कुंजी का मूल्य तब तक घटाते हैं जब तक कि यह शून्य तक कम नहीं हो जाता है, जिसके बाद यदि इस तरह के पत्र का मान = 0 होता है, तो हम चर को देते हैं ontain=false जब चक्र समाप्त होता है, तो शब्द चैनल में नहीं जोड़ा जाएगा।

 func search(out chan<- string, wordRuneList map[rune]int, length int) { wordList, err := selects(length) if err != nil { log.Printf("fail length %v, error: %v", length, err) } for _, word := range wordList { var ( wordCopyList = make(map[rune]int) contain = true ) for k, v := range wordRuneList { wordCopyList[k] = v } for _, r := range word { if _, ok := wordCopyList[r]; ok && wordCopyList[r] > 0 { wordCopyList[r]-- } else { contain = false break } } if contain { out <- word } } } 

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

इसे बंदरगाह पर चलाना: 9090। हम बॉट को चैट के लिए संदेश भेजते हैं।

 func send(in <-chan string) { conn, _ := net.Dial("tcp", "localhost:9090") // conncect to client telegram for word := range in { fmt.Fprintf(conn, "msg WordsGame-bot %v\n", word) time.Sleep(5 * time.Second) } } 

डेबियन पर टेलीग्राम-क्ली को जल्दी से लॉन्च करने की आज्ञा देता है।

आवश्यक लाइब्रेरी स्थापित करें।

 sudo apt install libreadline-dev libconfig-dev libssl-dev lua5.2 liblua5.2-dev libevent-dev libjansson-dev libpython-dev libgcrypt20 libz-dev make git 

एक भंडार का क्लोनिंग।

 git clone --recursive https://github.com/vysheng/tg.git && cd tg 

कॉन्फ़िगरेशन का निष्पादन।

 ./configure make 

पोर्ट 9090 पर क्लाइंट लॉन्च

 bin/telegram-cli -P 9090 

ग्राहक को बॉट खोजने के लिए, क्लाइंट में पहले से ही search WordsGame-bot कमांड चलाना आवश्यक है, फिर msg WordsGame-bot test कमांड के साथ परिणाम की जांच करें, यदि क्रियाओं के बाद आपने चैट पर टेक्स्ट टेस्ट नहीं लिखा है, तो व्यक्तिगत रूप से इसके साथ गेम खेलने का प्रयास करें।
क्लाइंट के लिए काम करना शुरू करने के लिए, लॉग इन करना न भूलें, वह सुझाव देगा कि जब आप पहली बार लॉग इन करें।

लगता है सब कुछ तैयार है। कार्यक्रम आधार को भरने के साथ-साथ बॉट के साथ गेम खेल सकता है, लेकिन केवल अगर आप खुद बॉट से शब्द पूछते हैं।

लेकिन यह सब धीमा है, लेकिन हम तुरंत पहली पंक्ति लेना चाहते हैं, और इसके लिए हमें बॉट से शब्दों का अनुरोध करने के लिए कार्यक्रम सिखाना होगा। हम एक कनेक्शन बनाएंगे और msg WordsGame-bot /play कमांड भेजेंगे, बॉट में देरी है, इसलिए हम 5 सेकंड प्रतीक्षा करते हैं। जिसके बाद हम कहानी से अंतिम संदेश का अनुरोध करते हैं history WordsGame-bot 1 साथ history WordsGame-bot 1 यह उत्तर होगा, या बल्कि वह शब्द जो हमें स्रोत के रूप में उपयोग करना चाहिए। conn से पढ़ने के लिए, वैरिएबल reply = make([]byte, 512) बनाएं reply = make([]byte, 512) बनाएं। हम पूरे जवाब को onn साथ पा लेते हैं onn ऐसा कुछ दिखता है।

  history @manymanywords_bot 1 ANSWER 58 [16:10] WordsGame-bot »»»  

सिरिलिक वर्णमाला के शब्दों की खोज के लिए regexp.MustCompile("([-]{1,100})") बनाएं। जिसके बाद, हम अपना शब्द चुनते हैं।

 else if *god { go send(out) for { var ( conn, _ = net.Dial("tcp", "localhost:9090") // conncect to client telegram reply = make([]byte, 512) r = regexp.MustCompile("([-]{1,100})") ) fmt.Fprintln(conn, "msg WordsGame-bot /play") time.Sleep(5 * time.Second) fmt.Fprintln(conn, "history WordsGame-bot 1") time.Sleep(2 * time.Second) _, err := conn.Read(reply) if err != nil { log.Fatalf("failed read connection %v", err) } word := r.FindAllString(string(reply), 1) if len(word) <= 0 { log.Fatalf("somthing wrong %s", reply) } findSubWords(word[0]) time.Sleep(5 * time.Minute) } 

लेकिन एक समस्या है, क्योंकि हमने सभी शब्द पाए जाने के बाद चैनल को बंद कर दिया। इसे ठीक करने के लिए, हमें वैश्विक GODMOD चर की आवश्यकता है। findSubWords लिए एक शर्त जोड़ें। अब जब हम -g स्विच का उपयोग करते हैं, तो GODMOD वेरिएबल सही पर सेट होता है और चैनल बंद नहीं होता है, और लूप पूरा करने के बाद, हम एक नए शब्द का अनुरोध करते हैं।

  if !GODMOD { close(out) } 

अब आप परिणाम देख सकते हैं।

उपयोगी लिंक

• स्रोत कोड
• तार-CLI
• जिप शब्द आधार संग्रह से लिंक