क्रमबद्ध sublists में विभाजन विभाजन

Question

मैं सूची [1,2,4,1,5,7,3,4,3,3] सूची को कैसे सूचीबद्ध कर सकता हूं जो उपन्यासों की सूची में विभाजित होगा जो कि तोड़ने वाले मानों पर विभाजित होंगे अनुक्रम। उदाहरण के लिए एक सूची [1,2,4,1,5,7,3,4,2,3] [[1,2,4], [1,5,7], [जैसे [ 3,4], [2,3]]।

इस पर कोई विचार या सुझाव इस समस्या को हल करने के लिए कैसे करें?

धन्यवाद।

Answer 1

यहाँ एक संकेत है:

Prelude> let f xs = zip xs $ tail xs 
Prelude> f [1,2,4,1,5,7,3,4,2,3] 
[(1,2),(2,4),(4,1),(1,5),(5,7),(7,3),(3,4),(4,2),(2,3)] 

अब आप splitWhen $ uncurry (>) की तरह कुछ का उपयोग कर सकते हैं (: जब भी आप एक सूची को संसाधित करते समय लगातार तत्वों को देखने के लिए की जरूरत है, यह एक अच्छा विचार अपनी पूंछ के खिलाफ सूची ज़िप करने से शुरू करने के लिए है जहां सूची उचित रूप से विभाजित करने के लिए splitWhenData.List.Split से है)।

Answer 2

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

splitList :: [Int] -> [[Int]] 
splitList [] = [] 
splitList (x:xs) = ys : splitList zs 
    where (ys,zs) = splitHead (x:xs) 


splitHead :: [Int] -> ([Int], [Int]) 
splitHead [x] = ([x], []) 
splitHead (x:y:xs) 
    | x > y = ([x], (y:xs)) 
    | x <= y = (x:ys, zs) 
    where (ys,zs) = splitHead (y:xs) 

Answer 3

ट्रैविस की तरह ऊपर, तो मेरा पहला विचार अपनी ही पूँछ के साथ इस सूची ज़िप करने है। न केवल वास्तव में एक विभाजन समारोह है जो वास्तव में आप चाहते हैं, लेकिन यह भी मुद्दा है कि आप शुरुआत या अंत से या तो तत्व खो देंगे।

splitAscending :: Ord a => [a] -> [[a]] 
splitAscending = foldr f [] where 
    f x [] = [[x]] 
    f x (y:ys) = if x < head y 
    -- It's okay to call head here because the list y is 
    -- coming from the summary value of the fold, which is [[a]]. 
    -- While the sum value may be empty itself (above case), it will 
    -- never CONTAIN an empty list. In general be VERY CAREFUL when 
    -- calling head. 
     then (x:y):ys -- prepend x to the first list in the summary value 
     else [x]:y:ys -- prepend the new list [x] to the summary value 

एक त्वरित और गंदे समाधान, मुझे आशा है कि यह आपकी आवश्यकताओं

सूट - इसके अलावा, इस स्टैक ओवरफ़्लो पर मेरी पहली पोस्ट है: एक ठीक से निकाला समाधान के एवज में, इस पर एक नज़र डालें:)

Answer 4

ठीक है, यह उतना साफ नहीं है जितना मैं चाहता हूं, लेकिन यहां यह है। का उपयोग करना पैकेज विभाजित: http://hackage.haskell.org/package/split

:m+ Data.List.Split 
Prelude Data.List.Split> let f ys = let ys' = zip ys (tail ys) in map (map fst) ((split . whenElt) (uncurry (>)) $ ys') 

ब्रेसिज़ बहुत संभावना यहाँ साफ किया जा सकता है।

Answer 5

कैसे

के बारे में

asc [] = [[]] 
asc (x:xs) = map reverse $ reverse $ foldl ins [[x]] xs 
    where ins ((y:ys):yss) z | z > y = (z:y:ys) : yss 
          | otherwise = [z] : (y:ys) : yss 

या

asc = map reverse.reverse.foldl ins [[]] 
     where ins [[]] z = [[z]] 
      ins ((y:ys):yss) z | z > y = (z:y:ys) : yss 
           | otherwise = [z] : (y:ys) : yss  

?