अनंत काउंटरों की अनंत सूची

Question

संदिग्ध दिमाग वाले लोगों के लिए, यह होमवर्क नहीं है, केवल उत्सुक है।

एक सीमित वर्णमाला को देखते हुए, क्या रिवर्स लेक्सोग्राफिक ऑर्डर में वर्णमाला से बने असीमित लंबे शब्दों की सूची बनाना संभव है?

अर्थात वर्णमाला "ab"

दिया यह संभव सूची का निर्माण करने के लिए है:

["aaaaaa...", "baaaaa...", "abaaaa...", "bbaaaa...", "aabaaa...", ...] 

जहां ... सूची (और सूचियों की सूची) अनंत लंबाई करने के लिए प्रदान प्रतिनिधित्व करता है।

एक भोली प्रयास है:

counters alphabet = [c:ounter | ounter <- counters alphabet, c <- alphabet] 

लेकिन जब से यह पुनरावर्ती छोड़ दिया है यह काम नहीं करता।

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

mapM_ (print . take 2) . take 4 . counters $ "ab" 

और आउटपुट देखें:: हालाँकि, यदि आप ऐसा करने में सक्षम होना चाहिए

aa 
ba 
ab 
bb 

Answer 1

fix क्यों नहीं?

ghci> let bar = let foo ~(st:sts) = [c:st | c <- "ab"] ++ foo sts in fix foo 
ghci> take 5 . map (take 5) $ bar 
["aaaaa","baaaa","abaaa","bbaaa","aabaa"] 
take 10 . map (take 5) $ bar 
["aaaaa","baaaa","abaaa","bbaaa","aabaa","babaa","abbaa","bbbaa","aaaba","baaba"] 

Answer 2

शायद नहीं सबसे कारगर समाधान है, लेकिन कम से कम यह काम करता है:

counters alphabet = map f [0..] 
    where f n = let (q, r) = quotRem n (length alphabet) in alphabet !! r : f q 

> take 10 $ map (take 5) $ counters "ab" 
["aaaaa","baaaa","abaaa","bbaaa","aabaa","babaa","abbaa","bbbaa","aaaba","baaba"] 

Answer 3

प्रगति कम-महत्वपूर्ण-खुदाई के साथ बेस-एन संख्या एन्कोडिंग की तरह दिखती है यह बाईं तरफ है, तो हम इसे के रूप में

1. दृष्टिकोण सकता है एक "एन आधार पर" समारोह f बनाओ पत्र के रूप में अपने अक्षर का उपयोग कर।
2. map[0..]
3. संलग्न repeat $ head alphabets सूची के प्रत्येक तत्व के लिए करने के लिए f।

Answer 4

आप निम्नलिखित दृष्टिकोण मिल सकता है मनोरंजक/भ्रामक:

duplicates s ss = cycle ss : duplicates s (ss >>= \c -> s >> [c]) 
counters = transpose . join duplicates 

यह अवलोकन है कि पहले पत्र पैटर्न "ababab...", दूसरा पत्र पैटर्न "aabbaabbaabb...", तीसरे पत्र का पालन करें पालन से आता है पैटर्न "aaaabbbbaaaabbbb...", आदि

Answer 5

इसके बारे में क्या?

f@(a:as) = a:('b':a):concatMap (\x -> ['a':x,'b':x]) as where a = ['a','a'..] 

इसके अलावा (\x -> ['a':x,'b':x])([('a':),('b':)] <*>) . pure रूप Applicative में लिखा जा सकता है अगर आप समझते हैं इसे और अधिक सुंदर होना करने के लिए।

Answer 6

फिर भी एक और संस्करण डैनियल विचार पर आधारित:

counters = transpose $ map cycle $ iterate (>>= \x -> [x,x]) "ab"