实施展平

Question

我目前正在尝试在列表上实现常用功能，并创建了函数“ ++”。

[11,22] ++ [4,2,8,1,7,12,4]

  

[11,22,4,2,8,1,7,12,4]

如下：

concatenate l t =  case l of
                     x:r -> x:concatenate r t
                     []  -> t

这有效！没问题。

但是现在，我正在尝试写flatten;

 flatten[[11,22],[4,2,8,1,7,12,4]]

  

[11,22,4,2,8,1,7,12,4]

但是，我不知道该怎么做，因为您有一个包含n个列表且大小不同的列表（目的是不使用任何标准函数）。我试过了。

concatenate l t =  case l of
                     x:r -> x:concatenate r t
                     []  -> t 

flatten l = flattenL l []
      where flattenL l t= case l of
              x:r -> flattenL (r (concatenate x t)) -- here x is a list, so that can't work
              []  -> t

Answer 1

您真的很接近，只需要更改一行，

x:r -> flattenL r (concatenate x t)

因为flattenL需要2个参数，而r不是一个函数。

请注意，这确实会颠倒外部列表的顺序，例如

flatten [[1,2],[3,4,5]] = [3,4,5,1,2]

要解决此问题，您可以先反转外部列表，然后再将其传递给flattenL

flatten l = flattenL (reverse l) []

或将另一行更改为

x:r -> concatenate x (flattenL r [])

但这表明我们根本没有真正在变量t中累积！因此该功能简化为

flatten l = case l of 
  [] -> []
  l:ls -> l ++ flatten ls

aka

flatten [] = [] flatten (l:ls) = l ++ flatten ls

折叠是表达它的自然方式，我知道您虽然不允许自己使用标准功能。列表理解也很好。 flatten ls = [x | l <- ls, x <- l]。

Answer 2

我只添加最后的修改，但我继续，谢谢泰勒    最后，我只是在最后一行使用catecatene功能：

concatene (l,t) =  case l of
                         x:r -> x:concatene (r,t)
                         []  -> t 
aplatir l = case l of 
  [] -> []
  x:r -> concatene (x,aplatir(r))

，也可以在本地声明它

aplatirF l = let concateneL (l,t) =  case l of
                     x:r -> x:concateneL (r,t)
                     []  -> t in
                     case l of 
                         [] -> []
                         x:r -> concateneL (x,aplatirF(r))

一切正常，谢谢！

Answer 3

请考虑以下过渡顺序：

flatten [[11,22],[4,2,8,1,7,12,4]] 
==> 11 : flatten [[22],[4,2,8,1,7,12,4]]
         ==> 22 : flatten [[],[4,2,8,1,7,12,4]]
                  ==> flatten [[4,2,8,1,7,12,4]]
                  ==> 4 : flatten [[2,8,1,7,12,4]]
                          ==> 2 : f [[8,1,7,12,4]]
                                  ==> .....
                                      .....
                                           ==> 4 : flatten [[]]
                                                   ==> flatten []
                                                   ==> []

因此，我们在这里仅看到一些法律：

flatten ((x:xs):r) = x : flatten (xs:r)
flatten (   [] :r) = flatten r
flatten []         = []

现在剩下的就是将这些法律纳入代码中。