Schlurfen einer Liste auf der Grundlage einer Int Liste

Question

den Code Gegeben:

data Error a = Fail|Ok a 
       deriving (Eq, Ord, Show) 

split :: Int -> [a] -> (Error ([a],[a])) 
split 0 list = Ok ([], list) 
split n list 
    | n < 0 = Fail 
    | n > length (list) = Fail 
    | otherwise = Ok (take n list, drop n list) 

interleave :: [a] -> [a] -> [a] 
interleave list [] = list 
interleave [] list = list 
interleave (x:xs) (y:ys) = x : y : interleave xs ys 


shuffle :: [Int] -> [a] -> Error [a] 

Wie kann ich die Funktion shuffle schreiben, die eine Liste von Ints nehmen, und teilen eine andere Liste auf der Grundlage dieser ints. Beispiele für die int-Liste wären intList = [20,23,24,13] wobei shuffle eine Liste nach dem 20. Element, Verschachtelung, Aufspaltung nach dem 23. Element, Verschachtelung usw. aufteilt.

Answer 1

Okay, was Sie wollen, ist im Grunde die folgenden:

eine Liste gegeben xs und Indizes [a1, a2, a3, ..], spaltete xs bei a1, Verschachtelung, spaltete es in a2 und Verschachtelung, und so weiter ...

Jetzt haben wir zwei Funktionen:

step :: Int -> [a] -> [a] 
step index xs = ??? -- something with split and interleave 

shuffle :: [a] 
shuffle [] xs = xs 
shuffle (i:indices) xs = let newList = step i xs 
         in ??? -- something with recursion 

Versuchen Sie, den Rest dieser Funktionen auf sich selbst zu schreiben.

step kann leicht als let (x1, x2) = split index xs in interleave x1 x2 ausgedrückt werden. Grundsätzlich kann der Rest von shuffle als shuffle indices newList geschrieben werden.

Answer 2

ich es herausgefunden:

shuffle [] xs = Ok (xs) 
shuffle (x:xs) list = case (split x list) of 
          Fail  -> Fail 
          Ok (l1, l2) -> shuffle xs (interleave l1 l2)