List 基于整型列表洗牌列表

鉴于代码：

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]

数据错误a=失败|正常a
推导（Eq、Ord、Show）
拆分：：Int->[a]->（错误（[a]，[a]））
拆分0列表=确定（[]，列表）
拆分n列表
|n<0=失败
|n>长度（列表）=失败
|否则=正常（取n列表，删除n列表）
交织：：[a]->[a]->[a]
交错列表[]=列表
交错[]列表=列表
交织（x:xs）（y:ys）=x:y:interleave xs-ys
洗牌：：[Int]->[a]->错误[a]

---

如何编写函数

shuffle

，该函数将获取一个整数列表，并基于这些整数拆分另一个列表。int列表的示例是intList=[20,23,24,13]，其中shuffle将在第20个元素后拆分列表，交错，在第23个元素后拆分，交错，依此类推。

好的，您需要的基本内容如下：

给定一个列表

xs

和索引

[a1、a2、a3，…]

，在

a1

处拆分

xs

，交错，在

a2

处拆分，然后交错，依此类推

现在剩下两个功能：

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

试着自己编写这些函数的其余部分

step

可以很容易地表示为

let（x1，x2）=交织x1x2中的分割索引xs

。基本上，

shuffle

的其余部分可以写成

shuffle索引newList

我想出来了：

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

---

但是

split

函数返回一个错误（[a]，[a]），这是您考虑如何将约束应用于解决方案的部分。在我看来这是最有趣的；）我无法真正理解你的解决方案，但我设法找到了答案