比较 Haskell 中的列表

Question

我必须定义一个名为 Zeros 的函数，它接受两个列表的输入并返回一个布尔值，如果数字 0 在每个列表中出现相同的次数，则返回 True，否则返回 false。

这是我作业中的最后一个问题，我已经设法解决了这个问题，让它发挥作用，但我想知道是否有人可以找到减少代码量的方法。任何想法表示赞赏。
到目前为止我的代码如下：

x :: Int
x = 0 
instances::[Int]->Int
instances [] = 0
instances (y:ys)
    | x==y = 1+(instances ys)
    | otherwise = instances ys



zeros :: [Int] -> [Int] -> Bool
zeros [] [] = False
zeros x y
       | ((instances x) == (instances y)) = True
       | otherwise = False

Answer 1

无需透露太多，因为这是家庭作业，这里有一些提示。

你知道列表推导式吗？在这种情况下它们会很有用。例如，您可以将它们与

if

表达式组合起来执行如下操作：

*Main> let starS s = [if c == 's' then '*' else ' ' | c <- s]
*Main> starS "schooners"
"*       *"

您甚至可以使用它们进行过滤。例如：

*Main> let findFives xs = [x | x <- xs, x == 5]
*Main> findFives [3,7,5,6,3,4,5,7,5,5]
[5,5,5,5]

这些都不是完整的答案，但不难看出如何使这些结构适应您的情况。

你也应该考虑一下这里是否真的需要警卫！例如，这是一个使用与您的风格相同的守卫编写的函数：

lensMatch [] [] = True
lensMatch xs ys
             | ((length xs) == (length ys)) = True
             | otherwise = False

这是一个做同样事情的函数！

lensMatch' xs ys = length xs == length ys

可以看到它们是一样的；测试第一个：

*Main> lensMatch [1..4] [1..4]
True
*Main> lensMatch [1..4] [1..5]
False
*Main> lensMatch [] [1..5]
False
*Main> lensMatch [] []
True

并测试第二个：

*Main> lensMatch' [1..4] [1..4]
True
*Main> lensMatch' [1..4] [1..5]
False
*Main> lensMatch' [] [1..5]
False
*Main> lensMatch' [] []
True

最后，我非常同意sblom上面的评论；

zeros [] []

应该是

True

！考虑以下陈述：“对于集合 s 中的每个项目 x，x > 0”。如果集合 s 为空，则该语句为真！这是真的，因为 s 中根本没有任何项目。在我看来，这似乎是类似的情况。

Answer 2

我不敢相信还没有人建议使用

foldr

。不是最短或最好的定义，但在我看来是最具教育意义的：

instances :: Eq a => a -> [a] -> Int
instances n = foldr incrementIfEqual 0
    where incrementIfEqual x subtotal
              | x == n = subtotal + 1
              | otherwise = subtotal

zeros :: Num a => [a] -> [a] -> Bool
zeros xs ys = instances 0 xs == instances 0 ys

尽管对于

instances

的非常简短的定义，我想出的基本上与 Abizern 相同：

instances :: Eq a => a -> [a] -> Int
instances x = length . filter (==x)

Answer 3

您是否考虑过通过过滤每个列表以仅获取零，然后比较列表的长度以查看它们是否相等来一次性完成此操作？

zeroCompare xs ys = cZeroes xs == cZeroes ys
  where
    cZeroes as = length $ filter (== 0) as

Answer 4

代替

length

和

filter

，您可以获取谓词

p

的结果，将其转换为 0 或 1，并对结果求和：

count p = sum . map (fromEnum.p)

--or

import Data.List
count p = foldl' (\x -> (x+).fromEnum.p) 0

就您而言，

p

当然是

(==0)

。使用

Bool

将

Int

转换为

fromEnum

是一个非常有用的技巧。

Answer 5

另一个想法是同时处理两个列表，这有点长，但很容易理解：

zeros xs ys = cmp xs ys == 0 where
  cmp (0:xs) ys = cmp xs ys + 1
  cmp xs (0:ys) = cmp xs ys - 1
  cmp (_:xs) ys = cmp xs ys
  cmp xs (_:ys) = cmp xs ys
  cmp [] []     = 0

Answer 6

我会将问题分解为涉及辅助函数的较小问题。

这就是我将其分解的方式：

1. 比较两个计数的主要功能
2. 计数辅助功能

首先：您需要一种方法来计算列表中零的数量。例如，如果在整数列表中搜索 0 的数量，我将通过执行以下操作来解决此问题：

count :: [Int] -> Int
count xs = foldl (\count num -> if num == 0 then (count + 1) else count) 0 xs

第二：您需要一种方法来比较两个列表的计数。本质上，您需要一个函数，该函数接受两个列表作为参数，计算每个列表的计数，然后根据结果返回一个布尔值。例如，如果每个列表都是一个 int 列表，与我上面的 count 示例相对应：

    equalZeroes :: [Int] -> [Int] -> Bool
    equalZeroes x y = (count x) == (count y)

您还可以在 equalZeroes 函数内的 where 关键字下定义计数，如下所示：

equalZeroes :: [Int] -> [Int] -> Bool
equalZeroes x y = (count x) == (count y)
    where
        count :: [Int] -> Int
        count xs = foldl (\count num -> if num == 0 then (count + 1) else count) 0 xs

运行此代码时，按如下方式调用该函数将获得返回所需的布尔值：

equalZeroes [0,1,4,5,6] [1,4,5,0,0]
-> False

 equalZeroes [0,1,4,5,6] [1,4,5,0]
 -> True