🕣 👰🏼 🎿 हास्केल में जापानी क्रॉसवर्ड समाधान 👩‍👩‍👦 🎷 🌏

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

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

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

इस तथ्य के बावजूद कि मैंने यथासंभव स्पष्ट रूप से लिखने की कोशिश की, मैं पूरी तरह से सफल नहीं हुआ। कट के तहत बहुत सारे पत्र और कोड और लगभग कोई चित्र नहीं।

bitmask

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

bmCreate :: Int -> BitMask bmLength :: BitMask -> Int bmSize :: BitMask -> Int bmIsEmpty :: BitMask -> Bool bmNot :: BitMask -> BitMask bmAnd :: BitMask -> BitMask -> BitMask bmOr :: BitMask -> BitMask -> BitMask bmIntersection :: [BitMask] -> BitMask bmUnion :: [BitMask] -> BitMask bmSplit :: BitMask -> [BitMask] bmByOne :: BitMask -> [BitMask] bmExpand :: BitMask -> BitMask bmFillGaps :: BitMask -> BitMask bmLeftIncursion :: Int -> BitMask -> BitMask bmRightIncursion :: Int -> BitMask -> BitMask bmTranspose :: [BitMask] -> [BitMask]

मुझे लगता है कि इस तरह के एक ग्राफिकल विवरण को छोड़कर सभी कार्यों के लिए संपूर्ण है, शायद, bmLeftIncursion और bmRightIncursion । उन्हें क्यों आवश्यक है, यह बाद में स्पष्ट होगा, उनके काम का सिद्धांत इस प्रकार है: bmLeftIncursion सबसे बाईं ओर भरा bmLeftIncursion पाता है और एक मुखौटा बनाता है जिसमें सभी बिट्स इसके पहले भरे जाते हैं, साथ ही साथ कई बिट्स से शुरू होता है जब फ़ंक्शन को निर्दिष्ट किया गया था; दूसरा फ़ंक्शन समान रूप से काम करता है।

संरचना

चूंकि क्रॉसवर्ड का हल लाइनों के साथ होता है, पूरे क्षेत्र के अनुरूप प्रकार सभी क्षैतिज और ऊर्ध्वाधर लाइनों का एक सेट होता है, हालांकि इससे क्रॉसवर्ड की सभी कोशिकाओं का दोहराव होता है।

 data Field = Field { flHorLines :: [Line], flVerLines :: [Line] } deriving Eq

प्रत्येक पंक्ति कोशिकाओं और ब्लॉकों के बारे में जानकारी संग्रहीत करती है (एक ब्लॉक एक स्थिति में एक संख्या से मेल खाती है)।

 data Line = Line { lnMask :: LineMask, lnBlocks :: [Block] } deriving Eq

कोशिकाओं के बारे में जानकारी एक ही लंबाई के दो बिट मास्क के रूप में संग्रहीत होती है, जो भरे और अवरुद्ध कोशिकाओं का प्रतिनिधित्व करती है।

 data LineMask = LineMask { lmFilledMask :: BitMask, lmBlockedMask :: BitMask } deriving Eq

ब्लॉक, संख्या के अलावा, इसमें एक मुखौटा होता है जो उस रेखा के क्षेत्र से मेल खाता है जिसमें यह ब्लॉक हो सकता है।

 data Block = Block { blScopeMask :: BitMask, blNumber :: Int } deriving Eq

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

पूर्णता और सिंक्रनाइज़ेशन

उपरोक्त सभी प्रकार ( BitMask को छोड़कर) दो वर्गों के उदाहरण हैं: Syncable और Syncable ।

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

 class Completable a where clIsCompleted :: a -> Bool instance Completable Field where clIsCompleted fl = all clIsCompleted (flHorLines fl) && all clIsCompleted (flVerLines fl) instance Completable Line where clIsCompleted ln = all clIsCompleted (lnBlocks ln) instance Completable Block where clIsCompleted bl = bmSize (blScopeMask bl) == blNumber bl

Syncable वर्ग फ़ंक्शंस प्रदान करता है जो आपको विभिन्न निर्णय शाखाओं को एक साथ लाने देता है। snAverage केवल दो शाखाओं से सामान्य को निकालता है, और snSync - जो कम से कम एक शाखा में दिखाई देता है (हम उन्हें क्रमशः bmAnd और bmOr सामान्यीकरण पर विचार कर सकते हैं)। snAverageAll और snSyncAll बिल्कुल एक ही काम करते हैं, लेकिन वे दो वस्तुओं के साथ नहीं, बल्कि वस्तुओं की सूची के साथ काम करते हैं।

 class Syncable a where snSync :: a -> a -> Maybe a sn1 `snSync` sn2 = snSyncAll [sn1, sn2] snAverage :: a -> a -> Maybe a sn1 `snAverage` sn2 = snAverageAll [sn1, sn2] snSyncAll :: [a] -> Maybe a snSyncAll [] = Nothing snSyncAll sns = foldr1 (wrap snSync) (map return sns) snAverageAll :: [a] -> Maybe a snAverageAll [] = Nothing snAverageAll sns = foldr1 (wrap snAverage) (map return sns) wrap :: Monad m => (a -> b -> mc) -> ma -> mb -> mc wrap f mx my = do x <- mx y <- my fxy

संगति

Syncable क्लास के कार्यों के विवरण से, Syncable देखा जा सकता है कि उनका परिणाम Maybe मोनड में लिपटी हुई वस्तु है। वास्तव में, यह इस प्रकार है कि संगति की महत्वपूर्ण अवधारणा स्वयं प्रकट होती है, जो उपरोक्त सभी प्रकारों के लिए भी परिभाषित है, लेकिन इनकैप्सुलेशन कारणों के लिए एक अलग वर्ग में नहीं ले जाया गया है। एक उदाहरण के रूप में, एक ही सेल को एक ही समय में छायांकित और लॉक नहीं किया जा सकता है; यदि कोई ऑपरेशन ऐसी स्थिति को जन्म दे सकता है, तो यह Maybe मोनड के साथ चिह्नित है (आमतौर पर यह टाइप type TransformFunction a = a -> Maybe a ), और अगर यह इस स्थिति की ओर जाता है, तो परिणाम Nothing होगा, क्योंकि कार्यक्रम में कोई भी वस्तु असंगत स्थिति में मौजूद नहीं हो सकती है। चूंकि Nothing , बदले में, अन्य वस्तुओं का एक अभिन्न हिस्सा नहीं हो सकता है, पूरे क्षेत्र में असंगठित हो जाएगा, जिसका अर्थ होगा समाधान की अनुपस्थिति।

क्षैतिज और ऊर्ध्वाधर लाइनों के सिंक्रनाइज़ेशन द्वारा क्षेत्र की स्थिरता सुनिश्चित की जाती है। इस प्रकार, यदि कोई कोशिका किसी क्षैतिज अवस्था में किसी अवस्था (चित्रित, अवरुद्ध, या रिक्त) में है, तो वह उसी स्थिति में संगत ऊर्ध्वाधर रेखा में है, और इसके विपरीत।

 flEnsureConsistency :: TransformFunction Field flEnsureConsistency fl = do let lnsHor = flHorLines fl let lnsVer = flVerLines fl lnsHor' <- zipWithM lnSyncWithLineMask (lmTranspose $ map lnMask lnsVer) lnsHor lnsVer' <- zipWithM lnSyncWithLineMask (lmTranspose $ map lnMask lnsHor) lnsVer return $ Field lnsHor' lnsVer' lnSyncWithLineMask :: LineMask -> TransformFunction Line lnSyncWithLineMask lm ln = do lm' <- lm `snSync` lnMask ln return ln { lnMask = lm' }

हम बाद में लाइन की स्थिरता के बारे में बात करेंगे, क्योंकि यह सीधे निर्णय प्रक्रिया से संबंधित है।

ब्लॉक की स्थिरता को गैर-तुच्छ रूप से प्रदान किया जाता है: इसके लिए, ब्लॉक क्षेत्र से उन निरंतर भागों को बाहर करना आवश्यक है जो इसे समायोजित नहीं कर सकते हैं। इस प्रकार, यदि संख्या 3 और मूल क्षेत्र के साथ ब्लॉक क्षेत्र से

मास्क को बाहर रखें

(उदाहरण के लिए, इस तथ्य के कारण कि यह सेल अवरुद्ध था), तो इस ऑपरेशन का अंतिम परिणाम एक क्षेत्र के साथ एक ब्लॉक होगा

लेकिन बिल्कुल नहीं

।

 blEnsureConsistency :: TransformFunction Block blEnsureConsistency bl = do let bms = filter ((blNumber bl <=) . bmSize) $ bmSplit $ blScopeMask bl guard $ not $ null bms return bl { blScopeMask = bmUnion bms }

मास्क के लिए, स्थिरता स्पष्ट है और पहले से ही ऊपर वर्णित किया गया है: आप एक ही समय में एक ही सेल को पेंट और ब्लॉक नहीं कर सकते।

 lmEnsureConsistency :: TransformFunction LineMask lmEnsureConsistency lm = do guard $ bmIsEmpty $ lmFilledMask lm `bmAnd` lmBlockedMask lm return lm

रूपांतरण

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

 lmFill :: BitMask -> TransformFunction LineMask lmFill bm lm = lmEnsureConsistency lm { lmFilledMask = lmFilledMask lm `bmOr` bm } lmBlock :: BitMask -> TransformFunction LineMask lmBlock bm lm = lmEnsureConsistency lm { lmBlockedMask = lmBlockedMask lm `bmOr` bm } blExclude :: BitMask -> TransformFunction Block blExclude bm bl = blEnsureConsistency $ bl { blScopeMask = blScopeMask bl `bmAnd` bmNot bm } blKeep :: BitMask -> TransformFunction Block blKeep bm bl = blEnsureConsistency $ bl { blScopeMask = blScopeMask bl `bmAnd` bm }

निर्णय

निर्णय प्रक्रिया को अलग-अलग हिस्सों में माना जाएगा, जब तक कि वे अंततः बड़ी तस्वीर नहीं बनाते हैं।

लाइन की संगति

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

 lnUpdateBlocked :: [Block] -> TransformFunction LineMask lnUpdateBlocked [] lm = lmBlock (bmNot $ lmBlockedMask lm) lm lnUpdateBlocked bls lm = lmBlock (bmNot $ bmUnion $ map blScopeMask bls) lm

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

 blMinimumLeftMask :: Block -> BitMask blMinimumLeftMask bl = bmLeftIncursion (blNumber bl) (blScopeMask bl) blMinimumRightMask :: Block -> BitMask blMinimumRightMask bl = bmRightIncursion (blNumber bl) (blScopeMask bl) blToFillMask :: Block -> BitMask blToFillMask bl = blMinimumLeftMask bl `bmAnd` blMinimumRightMask bl lnUpdateFilled :: [Block] -> TransformFunction LineMask lnUpdateFilled [] = return lnUpdateFilled bls = lmFill (bmUnion $ map blToFillMask bls)

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

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

 lnEnsureConsistency :: TransformFunction Line lnEnsureConsistency ln = do let bls = lnBlocks ln lm <- lnUpdateBlocked bls >=> lnUpdateFilled bls $ lnMask ln return $ ln { lnMask = lm }

सरल रेखा रूपांतरण

लाइन के भीतर निर्णय अनिवार्य रूप से दो परिवर्तनों के लिए उबलता है।

पहला परिवर्तन, वास्तव में, स्थिरता की स्थिति का विलोम है: यह सुनिश्चित करता है कि यदि मुखौटा पूरा हो गया है तो ब्लॉक पूरा हो जाएगा। इसके लिए तीन क्रियाओं का उपयोग किया जाता है।

सभी अवरुद्ध कोशिकाओं को सभी ब्लॉकों के क्षेत्रों से बाहर रखा जाना चाहिए।
```
 lnRemoveBlocked :: LineMask -> TransformFunction [Block] lnRemoveBlocked = mapM . blExclude . lmBlockedMask 
```
यदि ब्लॉक मुखौटा के किसी भी निरंतर छायांकित भाग को समायोजित नहीं कर सकता है (अर्थात, यदि यह ब्लॉक क्षेत्र से बाहर निकलता है या इसकी संख्या से बड़ा आकार है), तो इसे ब्लॉक क्षेत्र से बाहर रखा जाना चाहिए।
```
 lnRemoveFilled :: LineMask -> TransformFunction [Block] lnRemoveFilled lm = mapM (\ bl -> foldM f bl $ bmSplit $ lmFilledMask lm) where f bl bm = if blCanContainMask bm bl then return bl else blExclude (bmExpand bm) bl blCanContainMask :: BitMask -> Block -> Bool blCanContainMask bm bl = let bm' = bmFillGaps bm in bmSize bm' <= blNumber bl && bmIsEmpty (bm' `bmAnd` bmNot (blScopeMask bl)) 
```
अपने बाएं पड़ोसी के blMinimumRightMask दाहिने पड़ोसी के blMinimumRightMask प्रत्येक ब्लॉक के क्षेत्र से बाहर रखा जाना चाहिए (यहां उन्हें ऊपर वर्णित रूप में बिल्कुल आवश्यकता है)। सटीक होने के लिए, एक सेल द्वारा विस्तारित इन मास्क को बाहर रखा गया है, क्योंकि ब्लॉक के बीच कम से कम एक खाली सेल होना चाहिए।
```
 lnExcludeNeighbours :: TransformFunction [Block] lnExcludeNeighbours bls = sequence $ scanr1 (flip $ wrap $ blExclude . bmExpand . blMinimumRightMask) $ scanl1 (wrap $ blExclude . bmExpand . blMinimumLeftMask) $ map return bls 
```

साथ में, ये क्रियाएं निम्नलिखित फ़ंक्शन का निर्माण करती हैं (बाद में slLoop फ़ंक्शन का वर्णन किया जाएगा):

 lnSimpleTransform :: TransformFunction Line lnSimpleTransform ln = do let lm = lnMask ln bls <- lnRemoveBlocked lm >=> slLoop (lnRemoveFilled lm >=> lnExcludeNeighbours) $ lnBlocks ln lnEnsureConsistency ln { lnBlocks = bls }

दूसरी पंक्ति रूपांतरण

यदि हम सभी ब्लॉकों में से सबसे बाईं ओर ले जाते हैं, जिसमें सिद्धांत रूप में मास्क का कुछ छायांकित हिस्सा हो सकता है, तो इसकी सही स्थिति इस मास्क तक ही सीमित होगी, क्योंकि यदि यह अधिक दाईं ओर चला जाता है, तो यह छायांकित क्षेत्र अब किसी को भी नहीं दिया जाएगा। इन ब्लॉकों के सही होने के लिए समान विचार सही हैं।

 lnExtremeOwners :: BitMask -> TransformFunction [Block] lnExtremeOwners bm bls = do bls' <- fmap reverse $ maybe (return bls) (f bmLeftIncursion bls) (h bls) fmap reverse $ maybe (return bls') (f bmRightIncursion bls') (h bls') where fg = varyNth (\ bl -> blKeep (g (blNumber bl) bm) bl) h = findIndex (blCanContainMask bm) varyNth :: Monad m => (a -> ma) -> [a] -> Int -> m [a] varyNth f xs idx = do let (xs1, x : xs2) = splitAt idx xs x' <- fx return $ xs1 ++ x' : xs2

मास्किंग के प्रत्येक निरंतर भाग में इस तर्क को लागू करते हुए, हम दूसरी पंक्ति परिवर्तन प्राप्त करते हैं:

 lnTransformByExtremeOwners :: TransformFunction Line lnTransformByExtremeOwners ln = do bls <- foldM (flip lnExtremeOwners) (lnBlocks ln) $ bmSplit $ lmFilledMask $ lnMask ln lnEnsureConsistency ln { lnBlocks = bls }

क्षेत्र रूपांतरण

फ़ील्ड का अपना कोई विशेष परिवर्तन नहीं है, इसके लिए एकमात्र विकल्प कुछ तैयार किए गए परिवर्तन लेना है और इसे सभी लाइनों पर लागू करना है।

 flTransformByLines :: TransformFunction Line -> TransformFunction Field flTransformByLines f fl = do lnsHor <- mapM f (flHorLines fl) fl' <- flEnsureConsistency fl { flHorLines = lnsHor } lnsVer <- mapM f (flVerLines fl') flEnsureConsistency fl' { flVerLines = lnsVer }

शाखाओं में

चूंकि जापानी क्रॉसवर्ड को हल करना एक एनपी-पूर्ण कार्य है, इसलिए आप बिना ब्रांचिंग के नहीं कर पाएंगे। हम शाखाओं के प्रकार के एक फ़ंक्शन के रूप में ब्रांचिंग को परिभाषित करेंगे type ForkFunction a = a -> [[a]] , जहां आंतरिक सूची में पारस्परिक रूप से अनन्य विकल्प और बाहरी एक - इन विकल्पों का उत्पादन करने के विभिन्न तरीके शामिल हैं।

सबसे सरल तरीका कोशिकाओं में शाखाओं में बंट रहा है: प्रत्येक खाली सेल बाहरी सूची के एक तत्व को उत्पन्न करता है, जो बदले में दो तत्वों की एक सूची है, जिसमें से एक में यह सेल भर जाता है और दूसरे में अवरुद्ध होता है।

 lnForkByCells :: ForkFunction Line lnForkByCells ln = do let lm = lnMask ln bm <- bmByOne $ lmEmptyMask lm return $ do lm' <- [fromJust $ lmBlock bm lm, fromJust $ lmFill bm lm] maybeToList $ lnEnsureConsistency ln { lnMask = lm' } flForkByCells :: ForkFunction Field flForkByCells fl = do let lnsHor = flHorLines fl let lnsVer = flVerLines fl idx <- findIndices (not . clIsCompleted) lnsHor let (lns1, ln : lns2) = splitAt idx lnsHor lns <- lnForkByCells ln return $ do ln' <- lns maybeToList $ flEnsureConsistency $ Field (lns1 ++ ln' : lns2) lnsVer

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

 lnForkByOwners :: ForkFunction Line lnForkByOwners ln = do let bls = lnBlocks ln bm <- bmSplit $ lmFilledMask $ lnMask ln case findIndices (blCanContainMask bm) bls of [_] -> [] idxs -> return $ do idx <- idxs maybeToList $ do bls' <- varyNth (g bm) bls idx lnEnsureConsistency ln { lnBlocks = bls' } where g bm bl = blKeep ((bmAnd `on` ($ bm) . ($ blNumber bl)) bmLeftIncursion bmRightIncursion) bl

सामान्यीकृत कार्य

यह परिवर्तन के अधिकांश परिवर्तनों को लागू करने के लिए समझ में आता है। इस मामले में, आप केवल तब तक परिवर्तन लागू कर सकते हैं जब तक कि यह कम से कम कुछ नहीं बदलता है, या आप (उस स्थिति में जब अनावश्यक आवेदन में काफी समय लग सकता है) पूर्णता के लिए वस्तु की पूर्व जांच करें।

 slLoop :: Eq a => TransformFunction a -> TransformFunction a slLoop fx = do x' <- fx if x == x' then return x else slLoop fx' slSmartLoop :: (Completable a, Eq a) => TransformFunction a -> TransformFunction a slSmartLoop fx | clIsCompleted x = return x | otherwise = do x' <- fx if x == x' then return x else slLoop fx'

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

 slForkAndSyncAll :: (Syncable a) => ForkFunction a -> TransformFunction a -> TransformFunction a slForkAndSyncAll fgx = do xs <- mapM (snAverageAll . mapMaybe g) $ fx snSyncAll (x : xs) slForkAndSmartSync :: (Syncable a, Completable a, Eq a) => ForkFunction a -> TransformFunction a -> TransformFunction a slForkAndSmartSync fgx = foldr h (return x) (fx) where h xs mx = do x' <- mx if clIsCompleted x' then mx else case mapMaybe (snSync x') xs of [] -> Nothing xs' -> case filter (/= x') xs' of [] -> return x' xs'' -> snAverageAll . mapMaybe g $ xs''

अंत में, यदि अन्य सभी विफल हो जाते हैं, तो आप पुनरावृत्ति में जा सकते हैं। केवल इस तरह से आप सभी समाधान प्राप्त कर सकते हैं, अगर कई हैं।

 slAllSolutions :: (Completable a) => ForkFunction a -> TransformFunction a -> a -> [a] slAllSolutions fgx = do x' <- maybeToList $ gx if clIsCompleted x' then return x' else case fx' of (xs : _) -> do x'' <- xs slAllSolutions fg x'' [] -> []

फिन वेंको

वह सब है। उपलब्ध उपकरण कुछ सरल चरणों में सॉल्वर प्राप्त करने के लिए पर्याप्त हैं।

दो लाइन ट्रांसफॉर्म को मिलाएं।

 lineTransform = slSmartLoop $ lnSimpleTransform >=> lnTransformByExtremeOwners

हम लाइन-विशिष्ट ब्रांचिंग की प्रक्रिया करते हैं।
```
 lineTransform' = slForkAndSyncAll lnForkByOwners lineTransform 
```
हम इन दो परिवर्तनों से एक क्षेत्र परिवर्तन की रचना करते हैं।
```
 fieldTransform = slSmartLoop $ slSmartLoop (flTransformByLines lineTransform) >=> flTransformByLines lineTransform' 
```
हम क्षेत्र को कोशिकाओं में विभाजित करने के परिणामों को संसाधित करते हैं।
```
 fieldTransform' = slForkAndSmartSync flForkByCells fieldTransform 
```
पिछले दो परिवर्तनों को मिलाएं।
```
 fieldTransform'' = slSmartLoop $ fieldTransform >=> fieldTransform' 
```
और अंत में, पुनरावृत्ति जोड़ें।
```
 solve = slAllSolutions flForkByCells fieldTransform'' 
```

अंतभाषण

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

सैद्धांतिक रूप से, कुछ परिशोधन के साथ, कार्यक्रम का उपयोग स्वचालित रूप से क्रॉसवर्ड की जटिलता का आकलन करने के लिए किया जा सकता है (क्योंकि समाधान विधियां आम तौर पर किसी व्यक्ति द्वारा उपयोग किए जाने के समान होती हैं) और समाधान की विशिष्टता को साबित करने के लिए; LaTeX को निर्यात उपलब्ध है, और जल्द ही SVN में भी दिखाई दे सकता है। इसलिए, यदि आप चाहें, तो आप पत्रिकाओं का एक होम इश्यू आयोजित कर सकते हैं :)

हास्केल में जापानी क्रॉसवर्ड समाधान