哈斯克爾 - 函數式編程（行使4.3）的工藝

Question

我有以下問題（哈斯克爾 - 函數式編程的工藝）：

給功能

howManyEqua1 :: Int -> Int -> Int -> Int 

的定義

它返回三個參數中有多少是相等的，這樣

howManyEqua1 :: 34 25 36 = 0 
howManyEqual :: 34 25 34 = 2 
howManyEqual :: 34 34 34 = 3 

我給出的答案是：

howManyEqual :: Int -> Int -> Int -> Int 
howManyEqual a  b  c 
    | a == b && b == c   = 3 
    | a == b      = 2 
    | b == c      = 2 
    | a == c      = 2 
    | otherwise     = 0 

不過，我相信這是一個更好的方式來分類，但我不知道如何。

Answer 1

如何：

howManyEqual a b c 
    | a == b && b == c   = 3 
    | a /= b && a /= c && b /= c = 0 
    | otherwise     = 2 

Answer 2

我在想：

howManyEqual a b c 
    | a == b && b == c   = 3 
    | a == b || b == c || a == c = 2 
    | otherwise     = 0 

我不知道，如果它比Sean的好/差。

由於||懶惰，我的平均測試次數可能會更少。

Answer 3

或者：

howManyEqual a b c = case length.nub $ [a,b,c] of 
    1 -> 3 
    2 -> 2 
    3 -> 0 

更新：

使用ryaner的回答爲出發點和luqui的概括定義，我們還可以用這一個襯墊和具有帶O的通用解決方案（N日誌N）複雜度：

howManyEqualG = sum.filter (>1).map length.group.sort 
-- Now, specialized to three: 
howManyEqual a b c = howManyEqualG [a,b,c] 

Answer 4

Here's a solution for any n。

Answer 5

一個一個班輪我能想到的，避免了警衛：

import Data.List 

howManyEqual :: Int -> Int -> Int -> Int 
howManyEqual a b c  = maximum $ 0 : (filter (> 1) . map length . group . sort) [a,b,c] 

這顯然是低效率的，但並看起來功能組合物矯枉過正。

如果你的輸入是一個巨大的列表，你想要計算最多的元素是多少，那麼使用這樣的算法可能是唯一有意義的。這是O（n log n）。

Answer 6

稍微有趣的解決方案：

howManyEqual a b c = [0,2,42,3] !! (length $ filter id [a == b, b == c, a == c]) 

[編輯]

較短

：

import Data.List 
howManyEqual a b c = [42,3,2,0] !! (length $ nub [a,b,c])