P̶y Japaneset̶h̶̶o̶nust जंग और WebAssembly के साथ जापानी क्रॉसवर्ड को हल करना

पायथन के लिए एक नॉनोग्राम सॉल्वर कैसे बनाया जाए, इसे रस्ट को फिर से लिखें, ताकि इसे सीधे WebAssembly के माध्यम से ब्राउज़र में चलाया जा सके।

टीएल, डॉ

शुरुआत

Habré पर जापानी वर्ग पहेली (नॉनोग्राम्स) के बारे में पहले से ही कई पोस्ट थे। उदाहरण
और एक और ।

छवियों को पंक्तियों के बाईं ओर स्थित संख्याओं के साथ-साथ स्तंभों के ऊपर एन्क्रिप्ट किया गया है। संख्याओं की संख्या से पता चलता है कि काले के कितने समूह (या उनके रंग, रंग वर्ग के लिए) कोशिकाएं संगत पंक्ति या स्तंभ में हैं, और संख्याएँ स्वयं - इन समूहों में से कितने मर्ज किए गए सेल हैं (उदाहरण के लिए, तीन संख्याओं का एक सेट - 4, 1, और 3 इसका मतलब है कि इस पंक्ति में तीन समूह हैं: पहला - चार से, दूसरा - एक से, तीसरा - तीन काली कोशिकाओं से)। एक काले और सफेद क्रॉसवर्ड पहेली में, समूहों को कम से कम एक खाली सेल द्वारा अलग किया जाना चाहिए, रंग क्रॉसवर्ड में, यह नियम केवल एक-रंग समूहों पर लागू होता है, और बहु-रंगीन समूह बारीकी से फैलाए जा सकते हैं (रिक्त कोशिकाएं पंक्तियों के किनारों के साथ भी हो सकती हैं)। सेल समूहों के स्थान को निर्धारित करना आवश्यक है।

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

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

अजगर

लगभग डेढ़ साल पहले, मैं गलती से एक लेख पर अड़ गया था, जिसमें एक पंक्ति को हल करने के लिए एक विधि का वर्णन किया गया था (जैसा कि बाद में पता चला, विधि धीमी थी)।

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

मुझे ऐसा प्रतीत हुआ कि विभिन्न सॉल्वर कार्यान्वयन के विश्लेषण पर सबसे महत्वाकांक्षी कार्य जान वोल्टर ने अपनी साइट पर प्रकाशित किया था (जो कि, जहां तक ​​मुझे पता है, इंटरनेट पर गैर-सरकारी बैंकों का सबसे बड़ा सार्वजनिक भंडार बना हुआ है), एक विस्तृत अध्ययन जिसमें जानकारी और लिंक का खजाना है जो उनकी मदद कर सकता है। अपना खुद का सॉल्वर बनाना।

कई स्रोतों का अध्ययन (वे लेख के अंत में होंगे), मैंने धीरे-धीरे अपने सॉल्वर की गति और कार्यक्षमता में सुधार किया। नतीजतन, मुझे लत लग गई थी और मैं काम से खाली समय में लगभग 10 महीनों के लिए एल्गोरिदम के कार्यान्वयन, रिफैक्टिंग, डीबगिंग में लगा हुआ था।

कोर एल्गोरिदम

परिणामी सॉल्वर को चार निर्णय स्तरों के रूप में दर्शाया जा सकता है:

• ( लाइन ) लीनियर सॉल्वर: इनपुट पर, सेल्स की एक लाइन और आउटपुट लाइन पर एक विवरण लाइन (सुराग), एक आंशिक रूप से हल की गई लाइन। अजगर समाधान में, मैंने 4 अलग-अलग एल्गोरिदम लागू किए (उनमें से 3 को रंगीन क्रॉसवर्ड के लिए अनुकूलित किया गया है)। मूल स्रोत के नाम पर सबसे तेज़ बग्सोलर एल्गोरिथम निकला। डायनेमिक प्रोग्रामिंग का उपयोग करते हुए नॉनोग्राम स्ट्रिंग्स को हल करने के लिए यह एक बहुत प्रभावी और वस्तुतः मानक विधि है। इस विधि का छद्म कोड पाया जा सकता है, उदाहरण के लिए, इस लेख में ।

  
  

• ( प्रसार ) हम सभी पंक्तियों और स्तंभों को एक कतार में रखते हैं, एक रैखिक सॉल्वर के साथ इसके माध्यम से जाते हैं, जब हम एक पंक्ति (स्तंभ) को हल करते समय नई जानकारी प्राप्त करते हैं, तो हम क्रमशः, नए कॉलम (पंक्तियों) के साथ कतार को अपडेट करते हैं। लाइन खाली रहने तक जारी रखें।

  
  
  उदाहरण और कोड

  हम कतार से हल करने के लिए अगला काम लेते हैं। इसे 7 की एक खाली (अनसुलझी) स्ट्रिंग होने दें (हम इसे ??????? रूप में दर्शाते हैं) ब्लॉक के विवरण के साथ [2, 3] । रैखिक सॉल्वर एक आंशिक रूप से हल स्ट्रिंग का उत्पादन करेगा ?X??XX? जहाँ X भरा हुआ सेल है। पंक्ति को अद्यतन करते समय, हम देखते हैं कि संख्या 1, 4, 5 वाले कॉलम बदल गए हैं (अनुक्रमण 0 से शुरू होता है)। इसका मतलब है कि संकेतित स्तंभों में नई जानकारी दिखाई दी है और उन्हें "रैखिक" सॉल्वर में वापस किया जा सकता है। हम इन स्तंभों को उच्च प्राथमिकता के साथ कार्यों की कतार में रखते हैं (ताकि उन्हें रैखिक सॉल्वर को दे सकें)।

  
  

   def propagation(board): line_jobs = PriorityDict() for row_index in range(board.height): new_job = (False, row_index) line_jobs[new_job] = 0 for column_index in range(board.width): new_job = (True, column_index) line_jobs[new_job] = 0 for (is_column, index), priority in line_jobs.sorted_iter(): new_jobs = solve_and_update(board, index, is_column) for new_job in new_jobs: # upgrade priority new_priority = priority - 1 line_jobs[new_job] = new_priority def solve_and_update(board, index, is_column): if is_column: row_desc = board.columns_descriptions[index] row = tuple(board.get_column(index)) else: row_desc = board.rows_descriptions[index] row = tuple(board.get_row(index)) updated = line_solver(row_desc, row) if row != updated: for i, (pre, post) in enumerate(zip(row, updated)): if _is_pixel_updated(pre, post): yield (not is_column, i) if is_column: board.set_column(index, updated) else: board.set_row(index, updated) 

  
  
  
  

• ( प्रोबिंग ) प्रत्येक अनसुलझे सेल के लिए, हम सभी रंग विकल्पों के माध्यम से सॉर्ट करते हैं और इस नई जानकारी के साथ प्रचार करने का प्रयास करते हैं। यदि हमें विरोधाभास मिलता है, तो हम इस रंग को सेल के लिए रंग विकल्पों से बाहर फेंक देते हैं और प्रचार का उपयोग करके फिर से इसका लाभ उठाने की कोशिश करते हैं। यदि यह अंत तक हल हो जाता है, तो हम समाधान को समाधान की सूची में जोड़ते हैं, लेकिन अन्य रंगों के साथ प्रयोग करना जारी रखें (कई समाधान हो सकते हैं)। यदि हम ऐसी स्थिति में आते हैं जहां आगे हल करना असंभव है, तो हम बस एक अलग रंग / सेल के साथ प्रक्रिया को अनदेखा करते हैं और दोहराते हैं।

  
  
  कोड

  यदि नमूना के परिणामस्वरूप एक विरोधाभास प्राप्त होता है तो यह सही है।

  
  

   def probe(self, cell_state): board = self.board pos, assumption = cell_state.position, cell_state.color # already solved if board.is_cell_solved(pos): return False if assumption not in board.cell_colors(pos): LOG.warning("The probe is useless: color '%s' already unset", assumption) return False save = board.make_snapshot() try: board.set_color(cell_state) propagation( board, row_indexes=(cell_state.row_index,), column_indexes=(cell_state.column_index,)) except NonogramError: LOG.debug('Contradiction', exc_info=True) # rollback solved cells board.restore(save) else: if board.is_solved_full: self._add_solution() board.restore(save) return False LOG.info('Found contradiction at (%i, %i)', *pos) try: board.unset_color(cell_state) except ValueError as ex: raise NonogramError(str(ex)) propagation( board, row_indexes=(pos.row_index,), column_indexes=(pos.column_index,)) return True 

  
  
  
  

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

  
  
  कोड

  Backtracking मेरे साथ बहुत गड़बड़ है, लेकिन इन दो कार्यों का वर्णन लगभग एक पुनरावर्ती खोज के दौरान होता है

  
  

   def search(self, search_directions, path=()): """ Return False if the given path is a dead end (no solutions can be found) """ board = self.board depth = len(path) save = board.make_snapshot() try: while search_directions: state = search_directions.popleft() assumption, pos = state.color, state.position cell_colors = board.cell_colors(pos) if assumption not in cell_colors: LOG.warning("The assumption '%s' is already expired. " "Possible colors for %s are %s", assumption, pos, cell_colors) continue if len(cell_colors) == 1: LOG.warning('Only one color for cell %r left: %s. Solve it unconditionally', pos, assumption) try: self._solve_without_search() except NonogramError: LOG.warning( "The last possible color '%s' for the cell '%s' " "lead to the contradiction. " "The path %s is invalid", assumption, pos, path) return False if board.is_solved_full: self._add_solution() LOG.warning( "The only color '%s' for the cell '%s' lead to full solution. " "No need to traverse the path %s anymore", assumption, pos, path) return True continue rate = board.solution_rate guess_save = board.make_snapshot() try: LOG.warning('Trying state: %s (depth=%d, rate=%.4f, previous=%s)', state, depth, rate, path) success = self._try_state(state, path) finally: board.restore(guess_save) if not success: try: LOG.warning( "Unset the color %s for cell '%s'. Solve it unconditionally", assumption, pos) board.unset_color(state) self._solve_without_search() except ValueError: LOG.warning( "The last possible color '%s' for the cell '%s' " "lead to the contradiction. " "The whole branch (depth=%d) is invalid. ", assumption, pos, depth) return False if board.is_solved_full: self._add_solution() LOG.warning( "The negation of color '%s' for the cell '%s' lead to full solution. " "No need to traverse the path %s anymore", assumption, pos, path) return True finally: # do not restore the solved cells on a root path - they are really solved! if path: board.restore(save) return True def _try_state(self, state, path): board = self.board full_path = path + (state,) probe_jobs = self._get_all_unsolved_jobs(board) try: # update with more prioritized cells for new_job, priority in self._set_guess(state): probe_jobs[new_job] = priority __, best_candidates = self._solve_jobs(probe_jobs) except NonogramError as ex: LOG.warning('Dead end found (%s): %s', full_path[-1], str(ex)) return False rate = board.solution_rate LOG.info('Reached rate %.4f on %s path', rate, full_path) if rate == 1: return True cells_left = round((1 - rate) * board.width * board.height) LOG.info('Unsolved cells left: %d', cells_left) if best_candidates: return self.search(best_candidates, path=full_path) return True 

  
  
  
  

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

इस स्तर पर, यह पता चलता है (बल्कि अपेक्षित रूप से) कि अजगर पूरे उपकरण में नहीं है जो इस तरह के सीपीयू-गहन कार्य में अधिकतम प्रदर्शन के लिए उपयुक्त है: इसमें सभी गणना निम्न-स्तरीय भाषाओं की तुलना में बेहद अक्षम हैं। उदाहरण के लिए, माप के परिणामों के अनुसार, सबसे एल्गोरिदमिक रूप से बंद बीजीयू सॉल्वर (जावा में), विभिन्न प्रकार के कार्यों पर 7-17 (कभी-कभी 27 तक) गुना तेजी से निकला।

         pynogram_my BGU_my स्पीडअप
 नर्तकी 0.976 0.141 6.921986      
 बिल्ली 1.064 0.110 9.672727      
 स्किड 1.084 0.101 10.732673     
 रुपये 1.116 0.118 9.457627      
 बढ़त 1.208 0.094 12.851064     
 धुआं 1.464 0.120 12.200000     
 नॉट 1.332 0.140 9.514286      
 झूला 1.784 0.138 12.927536     
 मम 2.108 0.147 14.340136     
 DiCap 2.076 0.176 11.795455     
 दुखद 2.368 0.265 8.935849      
 मर्का 2.084 0.196 10.632653     
 पेट्रो 2.948 0.219 13.461187     
 एम एंड एम 3.588 0.375 9.568000      
 4.068 0.242 16.809917 पर हस्ताक्षर किए     
 लाइट 3.848 0.488 7.885246      
 फॉरएवर 111.000 13.570 8.179808  
 केंद्र 5.700 0.327 17.431193     
 हॉट 3.150 0.278 11.330935     
 कराटे 2.500 0.219 11.415525     
 9-डोम 510.000 70.416 7.242672      
 झंडा 149.000 5.628 26.474769     
 सिंह 71.000 2.895 24.525043     
 मार्ले 12.108 4.405 2.748695      
 बात 321.000 46.166 6.953169      
 प्रकृति inf 433.138 inf     
 Sierp inf inf NaN      
 Gettys inf NaN      

और यह पहले से ही मैंने PyPy का उपयोग करना शुरू कर दिया है, और मानक CPython पर गणना का समय PyPy की तुलना में 4-5 गुना अधिक लंबा था! हम कह सकते हैं कि एक समान जावा सॉल्वर का प्रदर्शन सीपीथॉन कोड की तुलना में 28-85 गुना अधिक निकला।

प्रोफाइलिंग (cProfile, SnakeViz, line_profiler) का उपयोग करके मेरे सॉल्वर के प्रदर्शन को बेहतर बनाने के प्रयासों के कारण कुछ तेजी आई, लेकिन निश्चित रूप से उन्होंने एक परिणाम नहीं दिया।

सारांश :

+ सॉल्वर साइटों https://webpbn.com , http://nonograms.org और इसके अपने (ini- आधारित) प्रारूप से सभी पहेलियों को हल कर सकता है

+ किसी भी रंग के साथ काले और सफेद और गैर-रंगीन रंगों को हल करता है (रंगों की अधिकतम संख्या 10 है)

+ लापता ब्लॉक आकार (धब्बा) के साथ पहेलियाँ हल करती है। ऐसी पहेली का एक उदाहरण ।

+ पहेली को ब्राउज़र में शाप / खिड़की पर सांत्वना / रेंडर करने के लिए प्रस्तुत कर सकता है (अतिरिक्त pynogram-web विकल्प स्थापित करते समय)। सभी मोड के लिए, वास्तविक समय में समाधान की प्रगति को देखने का समर्थन किया जाता है।

- धीमी गणना (सॉल्वर की लेख-तुलना में वर्णित कार्यान्वयन की तुलना में, तालिका देखें)।

- अक्षम बैकट्रैकिंग: कुछ पहेलियों को घंटों तक हल किया जा सकता है (जब निर्णय पेड़ बहुत बड़ा होता है)।

रतुआ

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

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

 pub trait Color { fn blank() -> Self; fn is_solved(&self) -> bool; fn solution_rate(&self) -> f64; fn is_updated_with(&self, new: &Self) -> Result<bool, String>; fn variants(&self) -> Vec<Self>; fn as_color_id(&self) -> Option<ColorId>; fn from_color_ids(ids: &[ColorId]) -> Self; } pub trait Block { type Color: Color; fn from_str_and_color(s: &str, color: Option<ColorId>) -> Self { let size = s.parse::<usize>().expect("Non-integer block size given"); Self::from_size_and_color(size, color) } fn from_size_and_color(size: usize, color: Option<ColorId>) -> Self; fn size(&self) -> usize; fn color(&self) -> Self::Color; } #[derive(Debug, PartialEq, Eq, Hash, Clone)] pub struct Description<T: Block> where T: Block, { pub vec: Vec<T>, } // for black-and-white puzzles #[derive(Debug, PartialEq, Eq, Hash, Copy, Clone, PartialOrd)] pub enum BinaryColor { Undefined, White, Black, BlackOrWhite, } impl Color for BinaryColor { // omitted } #[derive(Debug, PartialEq, Eq, Hash, Default, Clone)] pub struct BinaryBlock(pub usize); impl Block for BinaryBlock { type Color = BinaryColor; // omitted } // for multicolor puzzles #[derive(Debug, PartialEq, Eq, Hash, Default, Copy, Clone, PartialOrd, Ord)] pub struct MultiColor(pub ColorId); impl Color for MultiColor { // omitted } #[derive(Debug, PartialEq, Eq, Hash, Default, Clone)] pub struct ColoredBlock { size: usize, color: ColorId, } impl Block for ColoredBlock { type Color = MultiColor; // omitted } 

कोड को पोर्ट करते समय, कुछ बिंदुओं ने स्पष्ट रूप से संकेत दिया कि एक सांख्यिकीय रूप से टाइप की गई भाषा जैसे कि रस्ट (अच्छी तरह से, या, उदाहरण के लिए, C ++) इस कार्य के लिए अधिक उपयुक्त है। अधिक सटीक रूप से, जेनेरिक और लक्षण वर्ग पदानुक्रम से बेहतर डोमेन का वर्णन करते हैं। तो पायथन कोड में, मेरे पास एक रैखिक BguSolver , BguSolver और BguColoredSolver लिए दो कक्षाएं BguColoredSolver जो BguColoredSolver एक काले और सफेद लाइन और एक रंग लाइन को हल करती BguColoredSolver । रस्ट कोड में, मेरे पास अभी भी एकमात्र जेनेरिक struct DynamicSolver<B: Block, S = <B as Block>::Color> संरचना है, जो इसे बनाते समय टाइप किए गए प्रकार के आधार पर दोनों प्रकार के कार्यों को हल कर सकता है ( DynamicSolver<BinaryBlock>, DynamicSolver<ColoredBlock> )। यह, ज़ाहिर है, इसका मतलब यह नहीं है कि पायथन में कुछ ऐसा नहीं किया जा सकता है, बस जंग में टाइप सिस्टम ने मुझे स्पष्ट रूप से संकेत दिया है कि यदि आप इस तरह से नहीं गए, तो आपको एक टन दोहराने का कोड लिखना होगा।

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

 write_initial_code
 जबकि (संकलक_हंट = $ (कार्गो चेक))! = 0;  करना
     fix_errors (संकलक_हंट)
 अंत

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

मैं उन कार्यों के कुछ उदाहरण देता हूँ जो दिखाते हैं कि रस्ट कोड कितना संक्षिप्त हो सकता है (पायथन समकक्षों की तुलना में)।

 def unsolved_neighbours(self, position): for pos in self.neighbours(position): if not self.is_cell_solved(*pos): yield pos 

 fn unsolved_neighbours(&self, point: &Point) -> impl Iterator<Item = Point> + '_ { self.neighbours(&point) .into_iter() .filter(move |n| !self.cell(n).is_solved()) } 

             १ २ ३ ४ ५ ६ 9। ९ 
             _ _ _ _ _ _ _ _ _ _ _
      2 3 1 | _ | _ | _ | _ | _ | _ | _ | _ | _ | 
               ^ ^ ^
               |  |  |
 1 ब्लॉक का अंत |  |  | 
 ब्लॉक 2 का अंत -------- |
 ब्लॉक 3 का अंत ------------

 @expand_generator def partial_sums(blocks): if not blocks: return sum_so_far = blocks[0] yield sum_so_far for block in blocks[1:]: sum_so_far += block + 1 yield sum_so_far 

 fn partial_sums(desc: &[Self]) -> Vec<usize> { desc.iter() .scan(None, |prev, block| { let current = if let Some(ref prev_size) = prev { prev_size + block.0 + 1 } else { block.0 }; *prev = Some(current); *prev }) .collect() } 

पोर्ट करते समय, मैंने कई बदलाव किए

• सॉल्वर कोर (एल्गोरिदम) में मामूली बदलाव हुए (मुख्य रूप से कोशिकाओं और ब्लॉकों के लिए सामान्य प्रकार का समर्थन करने के लिए)
• लीनियर सॉल्वर के लिए एकमात्र (सबसे तेज) एल्गोरिदम छोड़ दिया
• ini प्रारूप के बजाय, थोड़ा संशोधित TOML प्रारूप पेश किया
• दागी हुई क्रॉसवर्ड के लिए समर्थन नहीं जोड़ा गया, क्योंकि, कड़ाई से बोलना, यह कार्यों का एक अलग वर्ग है

• उत्पादन का एकमात्र तरीका बचा है - सिर्फ कंसोल के लिए, लेकिन अब कंसोल में रंगीन सेल वास्तव में रंगीन हैं ( इस टोकरे के लिए धन्यवाद)

  
  
  उस तरह

  

  
  
  
  

उपयोगी उपकरण

• clippy एक मानक स्थैतिक विश्लेषक है जो कभी-कभी सुझावों को थोड़ा बढ़ाकर कोड प्रदर्शन भी दे सकता है।
• valgrind डायनेमिक एप्लिकेशन विश्लेषण का एक उपकरण है। मैंने इसे बोटनेक्स ( valrgind --tool=callgrind ) और विशेष रूप से valrgind --tool=massif कोड के valrgind --tool=massif वर्गों ( valrgind --tool=massif ) की खोज करने के लिए एक प्रोफाइलर के रूप में इस्तेमाल किया। युक्ति: प्रोफाइलर को शुरू करने से पहले [profile.release] debug = true to Cargo.toml को सेट करें। यह निष्पादन योग्य वर्णों में डीबग वर्ण छोड़ देगा।
• कॉलग्रिंड फ़ाइलों को देखने के लिए kcachegrind। प्रदर्शन के मामले में सबसे अधिक समस्याग्रस्त स्थानों को खोजने के लिए एक बहुत ही उपयोगी उपकरण।

उत्पादकता

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

 import pandas as pd import numpy as np import matplotlib.pyplot as plt %matplotlib inline # strip the spaces df = pd.read_csv('perf.csv', skipinitialspace=True) df.columns = df.columns.str.strip() df['name'] = df['name'].str.strip() # convert to numeric df = df.replace('\+\ *', np.inf, regex=True) ALL_SOLVERS = list(df.columns[3:]) df.loc[:,ALL_SOLVERS] = df.loc[:,ALL_SOLVERS].apply(pd.to_numeric) # it cannot be a total zero df = df.replace(0, 0.001) #df.set_index('name', inplace=True) SURVEY_SOLVERS = [s for s in ALL_SOLVERS if not s.endswith('_my')] MY_MACHINE_SOLVERS = [s for s in ALL_SOLVERS if s.endswith('_my') and s[:-3] in SURVEY_SOLVERS] MY_SOLVERS = [s for s in ALL_SOLVERS if s.endswith('_my') and s[:-3] not in SURVEY_SOLVERS] bar_width = 0.17 df_compare = df.replace(np.inf, 10000, regex=True) plt.rcParams.update({'font.size': 20}) def compare(first, others): bars = [first] + list(others) index = np.arange(len(df)) fig, ax = plt.subplots(figsize=(30,10)) df_compare.sort_values(first, inplace=True) for i, column in enumerate(bars): ax.bar(index + bar_width*i, df_compare[column], bar_width, label=column[:-3]) ax.set_xlabel("puzzles") ax.set_ylabel("Time, s (log)") ax.set_title("Compare '{}' with others (lower is better)".format(first[:-3])) ax.set_xticks(index + bar_width / 2) ax.set_xticklabels("#" + df_compare['ID'].astype(str) + ": " + df_compare['name'].astype(str)) ax.legend() plt.yscale('log') plt.xticks(rotation=90) plt.show() fig.savefig(first[:-3] + '.png', bbox_inches='tight') for my in MY_SOLVERS: compare(my, MY_MACHINE_SOLVERS) compare(MY_SOLVERS[0], MY_SOLVERS[1:]) 

अजगर सॉल्वर

( तस्वीर क्लिक करने योग्य है )

हम देखते हैं कि यहाँ प्रस्तुत सभी सॉल्वरों की तुलना में यहाँ pynogram धीमा है। इस नियम का एकमात्र अपवाद सैट पर आधारित तमूरा / कॉप्री सॉल्वर है, जो हमारी तुलना में सबसे सरल पहेलियों (ग्राफ के बाएं हिस्से) को हल करता है। हालाँकि, यह SAT-solvers की एक विशेषता है: वे सुपर कॉम्प्लेक्स क्रॉसवर्ड के लिए डिज़ाइन किए गए हैं जिसमें एक नियमित सॉल्वर लंबे समय तक बैकट्रैकिंग में फंस जाता है। यह ग्राफ के दाईं ओर स्पष्ट रूप से दिखाई देता है, जहां तमूरा / कॉपिस सबसे कठिन पहेली को दसियों और सैकड़ों बार हर किसी के लिए तेजी से हल करता है।

जंग सॉल्वर

( तस्वीर क्लिक करने योग्य है )

यह ग्राफ़ दिखाता है कि साधारण कार्यों पर गैर-सरकारी भी C या C ++ ( वोल्टर और सिरोमोलोटोव ) में लिखे गए उच्च-प्रदर्शन वाले सॉल्वरों के साथ या उससे भी बदतर है। कार्यों की जटिलता के साथ, हमारा सॉल्वर लगभग BGU- सॉल्वर (जावा) के प्रक्षेपवक्र को दोहराता है, लेकिन परिमाण के क्रम के बारे में लगभग हमेशा इससे आगे रहता है। सबसे कठिन कार्यों में, तमूरा / कॉपिस हमेशा सभी से आगे होता है।

जंग बनाम अजगर

( तस्वीर क्लिक करने योग्य है )

और अंत में, हमारे दो सॉल्वरों की तुलना यहां वर्णित है। यह देखा जा सकता है कि पायथॉन सॉल्वर के आगे रस्ट सॉल्वर लगभग हमेशा परिमाण के 1-3 क्रम हैं।

सारांश :

+ सॉल्वर साइटों https://webpbn.com से सभी पहेलियों को हल कर सकता है (आंशिक रूप से छिपे हुए ब्लॉक आकार के साथ - दागदार को छोड़कर), http://nonograms.org और इसका अपना (TOML- आधारित) प्रारूप

+ काले और सफेद और रंग के किसी भी संख्या के साथ गैर-रंगीन हल करती है

+ कंसोल को रेंडर कर सकते हैं (color c webpbn.com ड्रॉ असली रंग)

+ तेजी से काम करता है (सॉल्वर की लेख-तुलना में वर्णित कार्यान्वयन की तुलना में, तालिका देखें)।

- बैकट्रैकिंग अप्रभावी बनी हुई है, जैसा कि पायथन समाधान में: कुछ पहेलियाँ (उदाहरण के लिए , ऐसा हानिरहित 20x20 ) घंटों के लिए हल किया जा सकता है (जब निर्णय पेड़ बहुत बड़ा होता है)। शायद पीछे हटने के बजाय यह हब पर पहले से ही उल्लेखित सॉल्वर का उपयोग करने के लायक है सच है, एकमात्र सैट सॉल्वर जिसे मैंने पहली नज़र में जंग पर पाया था , अधूरा और परित्यक्त लगता है।

WebAssembly

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

इस सुविधा को लागू करने के लिए, रस्ट के लिए एक विशेष उपकरण है जो आवश्यक बाँध प्रदान करता है और जेएस कोड में रस्ट फ़ंक्शंस को दर्द रहित रूप से चलाने के लिए आपके लिए एक बॉयलरप्लेट बनाता है - यह wasm-pack (+ wasm-bindgen )। इसके साथ अधिकांश कार्य और अन्य महत्वपूर्ण उपकरण पहले से ही रस्ट और वेबएज़वेर्म ट्यूटोरियल में वर्णित हैं। हालाँकि, कुछ बिंदु हैं जिन्हें मुझे अपने दम पर पता लगाना था:

• पढ़ते समय, यह महसूस करता है कि ट्यूटोरियल मुख्य रूप से जेएस डेवलपर के लिए लिखा गया है, जो रुस्त के साथ अपने कोड को गति देना चाहता है। खैर, या कम से कम किसी npm से परिचित व्यक्ति के लिए। मेरे लिए, सामने के छोर से दूर के व्यक्ति के रूप में, यह जानकर आश्चर्य हुआ कि पुस्तक से मानक उदाहरण भी तीसरे पक्ष के वेब सर्वर के साथ काम नहीं करना चाहता है जो npm run start से अलग है।

  
  

  सौभाग्य से, wasm-pack में एक मोड है जो आपको नियमित JS कोड (जो कि एक npm मॉड्यूल नहीं है) उत्पन्न करने की अनुमति देता है। wasm-pack build --target no-modules --no-typescript आउटपुट में केवल दो फाइलें प्राप्त होंगी: प्रोजेक्ट-name.wasm - WebAssembly और प्रोजेक्ट- name.js में संकलित रस्ट कोड का बाइनरी। अंतिम फ़ाइल को किसी भी HTML पेज <script src="project-name.js"></script> जोड़ा जा सकता है और npm, webpack, ES6, मॉड्यूल और आधुनिक JS डेवलपर के अन्य खुशियों से परेशान हुए बिना WASM फ़ंक्शन का उपयोग कर सकते हैं। no-modules मोड WASM एप्लिकेशन के विकास के साथ-साथ उदाहरणों और डेमो के लिए गैर-फ्रंट-एंड डेवलपर्स के लिए आदर्श है, क्योंकि इसमें किसी भी अतिरिक्त फ्रंट-एंड इंफ्रास्ट्रक्चर की आवश्यकता नहीं होती है।

  
  

• WebAssembly उन कार्यों के लिए अच्छा है जो जावास्क्रिप्ट के लिए बहुत भारी हैं। सबसे पहले, ये ऐसे कार्य हैं जो कई गणना करते हैं। और यदि ऐसा है, तो इस तरह के कार्य को लंबे समय तक WebAssembly के साथ भी किया जा सकता है और जिससे आधुनिक वेब के अतुल्यकालिक सिद्धांत का उल्लंघन हो सकता है। मैं सभी प्रकार की चेतावनी के बारे में बात कर रहा हूं : गैर-स्क्रिप्ट स्क्रिप्ट जो कि मेरे सॉल्वर के काम करने के दौरान मैंने देखी थी। इस समस्या को हल करने के लिए, आप वेब कर्मचारी तंत्र का उपयोग कर सकते हैं। इस मामले में, "भारी" WASM कार्यों के साथ काम करने की योजना इस तरह दिख सकती है:

  
  
  1. किसी घटना के लिए मुख्य स्क्रिप्ट से (उदाहरण के लिए, एक बटन पर क्लिक करके) एक भारी फ़ंक्शन लॉन्च करने के कार्य के साथ कार्यकर्ता को एक संदेश भेजें।
  2. , .
  3. - ()
  
  

WASM- JS, WASM . - ( ), HashMap , . ( JS) , / .

, Mutex , thread-safe. smart- . thread-safe Rc Arc RefCell RwLock . : 30%. --features=threaded thread-safe , WASM-.

6574 8098 ( 10 ):

, - 40..70% , , (32..37%) thread-safe ( cargo build --release --features=threaded ).

Firefox 67.0 Chromium 74.0.

WASM- ( ). https://webpbn.com/ http://www.nonograms.org/

TODO

• "" /, / .

  
  

• , . "" , , . .

  
  

• ( , 3600 ). WASM , ( , (!) , , WASM). , , - , nonogrid .

  
  

• . : , , WASM . , ( ) , JS , .

  
  

• JS. backtrace, .

  
  

• ( TOML- )

  
  

परिणाम

• , (, , etc).

  
  

• Rust 1-3 PyPy 1.5-2 ( ).

  
  

• Python Rust , Python (, , comprehensions), Rust-.

  
  

• Rust WebAssembly . Rust , WASM, ( 1.5 ).

  
  

1. The 'pbnsolve' Paint-by-Number Puzzle Solver by Jan Wolter and the survey
2. The BGU Nonograms Project
3. Solving Nonograms by combining relaxations
4. An Efficient Approach to Solving Nonograms
6. Color and black and white Japanese crosswords on-line
8. 'Nonolib' library by Dr. Steven Simpson
9. Rust and WebAssembly