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

現在，您可以簡單地通過fix傳遞count函數的結果：

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 abcd)進行計數。 但是您已經預先知道這是a ，因此請忽略它。

• 與尾巴相同：只需僅提供最后三個參數，即： toList bcd 。

• 盡可能使用最通用的類​​型簽名：for toList :: a -> a -> a -> [a] （鑒於先前的修復）， count :: (Eq a, Num b) => a -> [a] -> b 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 count :: (Eq a, Num b) => a -> [a] -> b howManyEq :: (Eq a, Eq b, Num b) => a -> a -> a -> a -> b count :: (Eq a, Num b) => a -> [a] -> b howManyEq :: (Eq a, Eq b, Num b) => a -> a -> a -> a -> b 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