Haskell 函数计算输入数字并找出有多少相等

Question

我正在尝试在 Haskell 中编写一个函数，该函数将 4 个整数作为输入并计算输入数字中有多少等于第一个整数。

例如：

howManyEq 3 4 5 6   returns 0
howManyEq 3 4 3 5   returns 2
howManyEq 3 4 3 3   returns 3
howManyEq 3 3 3 3   returns 4

这是我到目前为止创建的函数，它适用于没有与第一个整数匹配的输入的第一个实例。但是当有其他匹配的整数时，它不计算前3个，它总是少一个。

howManyEq :: Int -> Int-> Int -> Int -> Int
howManyEq a b c d = count (head (toList a b c d)) (tail (toList a b c d))

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

toList :: Int -> Int-> Int -> Int -> [Int]
toList a b c d = [a,b,c,d]

我的功能给了我：

howManyEq 3 4 5 6   returns 0
howManyEq 3 4 3 5   returns 1
howManyEq 3 4 3 3   returns 2
howManyEq 3 3 3 3   returns 3

当其他输入整数相等时，我不确定如何计算第一个整数。

Answer 1

您的count 函数计算“列表”剩余部分中相等元素的数量。如果该数字为零，则您的老师希望结果为零。如果有一个或多个，它会返回列表剩余部分中计数的数量，但由于列表头部已经有一个元素，你应该做 +1。你可以通过实现一个辅助函数来做到这一点：

fix :: (Eq a, Num a) => a -> a
fix 0 = 0
fix n = n+1

现在您可以简单地将count 函数的结果通过fix 传递：

howManyEq :: Int -> Int-> Int -> Int -> Int
howManyEq a b c d = fix $ count (head (toList a b c d)) (tail (toList a b c d))

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

toList :: Int -> Int-> Int -> Int -> [Int]
toList a b c d = [a,b,c,d]

其他建议：

• 您在调用中使用head (toList a b c d) 进行计数。但是你已经提前知道这是a，所以省略这个。

• 与尾部相同：只需输入最后三个参数，因此：toList b c d。

• 尽可能使用最通用的类​​型签名：toList :: a -> a -> a -> [a]（鉴于之前的修复）、count :: (Eq a, Num b) => a -> [a] -> b 和 howManyEq :: (Eq a, Eq b, Num b) => a -> a -> a -> a -> b。

• 如果你多次定义同一个东西，你可以使用where t = ...子句，比如where cys = count x ys

这将导致类似：

fix :: (Eq a, Num a) => a -> a
fix 0 = 0
fix n = n+1

howManyEq :: (Eq a, Eq b, Num b) => a -> a -> a -> a -> b
howManyEq a b c d = fix $ count a $ toList b c d

count :: (Eq a, Num b) => a -> [a] -> b
count x [] = 0
count x (y:ys)
 | x == y = 1 + cys
 | otherwise = cys
 where cys = count x ys

toList :: a -> a -> a -> [a]
toList a b c = [a,b,c]

Answer 2

这是一种方法：

{-# LANGUAGE TypeFamilies #-}

class HowManyEq a where
  howManyEq' :: Int -> Int -> Int -> a

instance HowManyEq Int where
  howManyEq' count x y = count + fromEnum (x == y)
  {-# INLINE howManyEq' #-}

instance (HowManyEq a, b ~ Int) => HowManyEq (b -> a) where
  howManyEq' count x y b = (howManyEq' $! count + fromEnum (b == x)) x y
  {-# INLINE howManyEq' #-}

howManyEq :: HowManyEq a => Int -> Int -> a
howManyEq = howManyEq' 0

howManyEq4 :: Int -> Int -> Int -> Int -> Int
howManyEq4 x y z w =
  case howManyEq x y z w of
    0 -> 0
    n -> n + 1