Haskell - 列表理解 - 获取输入元素

Question

如果输入是一个列表，我对列表理解有一些问题。

在所有 III 练习中都不允许使用：map、filter 和 concat!!!

---

第一部分

要求：

一个函数f1 得到一个列表xs 三元组(a, b, cs) 其中 a 和 b 的类型为 Int c 的类型为 [Int]

该函数应该生成一个对列表(a · b, b + c)，对于所有 cs 中的 c AND 在生成的列表中应该只出现第一个元素大于第二个元素的那些对 - (a · b) > b + c。

示例：

f1  [(10,20,[1,10,100]),  (4,5,[5,15,25])] 

应该返回以下列表：

[(200,21),(200,30),(200,120),(20,10)]

我的尝试：

f1 :: Int -> Int -> [Int] -> [(Int, Int)]
f1 a b cs = [(a*b, b+c)| c<-cs, (a*b)>(b+c)]

它工作正常，但不适用于列表作为输入。

所以我尝试了几种方法，但不幸的是不是正确的:-(

f1 :: [(Int, Int, [Int])] -> [(Int, Int)]

第一种方法：

f1 xs = [((xs !! 0)*(xs !! 1), (xs !! 1)+c)| c<-(xs !! 2), ((xs !! 0)*(xs !! 1))>((xs !! 1)+c)]

第二种方法：

f1 let (a, b, cs) = xs = [(a*b, b+c)| c<-cs, (a*b)>(b+c)]

第三种方法：

f1 (a b cs) = [(a*b, b+c)| c<-cs, (a*b)>(b+c)]

这三个都不行！

dave4420 的解决方案：

f1 :: [(Int, Int, [Int])] -> [(Int, Int)]
f1 xs = [ (a*b, b+c) | (a, b, cs) <- xs, c <- cs, (a*b)>(b+c) ]

---

第二部分

要求：

函数 g1 获取相同类型对的列表并从中生成一个普通列表。

示例：

g1 [(1,2),(3,4),(5,6)] returns [1,2,3,4,5,6]

我的尝试：

g1 :: [(Int, Int)] -> [Int]
g1 xs = [a,b | (a,b)<-xs]

我得到一个编译错误，因为列表理解输出中的 a,b 没有正确的语法。

但是我可以返回 a 或 b 或例如a+b：

g1 xs = [a | (a,b)<-xs]

或

g1 xs = [a+b | (a,b)<-xs]

你能帮我解决这个问题吗？

再次感谢

第三部分来了……

Answer 1

f1 :: [(Int, Int, [Int])] -> [(Int, Int)]
f1 xs = [ {-TODO-} | (a, b, cs) <- xs, c <- cs, {-TODO-} ]

我留下了几个 {-TODO-} 供你填写。

---

第二部分。

如果你不得不写

g1' :: [[Int]] -> [Int]

你会怎么做？然后你能把g1'修改成你想要的g1吗？

Answer 2

你已经接近了。使用你的

f1 :: Int -> Int -> [Int] -> [(Int, Int)]
f1 a b cs = [(a*b, b+c)| c<-cs, (a*b)>(b+c)]

您首先需要重写它以获取三元组(Int, Int, [Int])。这是一个微不足道的变化，

f1_a :: (Int, Int, [Int]) -> [(Int, Int)]
f1_a (a,b,cs) = [(a*b, b+c) | c <- cs, a*b > b+c]

现在，您需要将该函数应用于三元组输入列表的每个元素。如果你可以使用map，那就是map f1_a xs，但既然你不能，那就把它写成列表理解

f2 :: [(Int, Int, [Int])] -> [[(Int, Int)]]
f2 xs = [f1_a x | x <- xs]

但是单级列表太多了，你想要一个平面列表，所以你需要concat列表列表。你也不应该使用concat，所以你需要把它写成一个列表理解。

现在，concat 做了什么？

对于参数中的每个列表，对于该列表中的每个元素，将该元素放入结果中，所以

concat' xss = [x | xs <- xss, x <- xs]

现在将其应用于f2。

Answer 3

您已经完成了 90% 的工作。 请记住，在 GHCI 中，您在定义之前使用 let， 但是在常规源代码中，您不需要。 所以让我们看看你到目前为止有什么。

λ> let f1 (a,b,cs) = [(a*b, b+c)| c<-cs, (a*b)>(b+c)]

请注意，我在您的元组中添加了逗号。让我们找出f1的类型。

λ> :t f1
f1 :: (Num t, Ord t) => (t, t, [t]) -> [(t, t)]

现在，您可以忽略 (Num t, Ord t) => 部分。 这是一个函数，它接受一个包含一个元素的元组，另一个 元素和元素列表。 所以我们不能把整个元组列表传递给它， 只有一个元组。

λ> f1 (10,20,[1,10,100])
[(200,21),(200,30),(200,120)]
λ> f1 (4,5,[5,15,25])
[(20,10)]

这是您想要的结果的第一部分。

λ> f1 (4,5,[5,15,25])
[(20,10)]

这是第二部分。 所以现在你需要另一个接受输入的函数，如下所示：

[(10,20,[1,10,100]),  (4,5,[5,15,25])]

也就是说，我们想要一个接受元组列表的函数。 在f1 的基础上，我们可以这样写：

λ> let f2 xs = [f1 x | x <- xs]
λ> f2 [(10,20,[1,10,100]),  (4,5,[5,15,25])]
[[(200,21),(200,30),(200,120)],[(20,10)]]

请注意，结果是一个列表列表，我们只需要一个普通列表。 由于不允许使用concat，因此请看一下 groovy 或 Daniel Fisher 是如何解决这个问题的。 两种不同的方法，都不错。