Question

我尝试编写一个程序来计算列表中每个元素的频率。

    In: "aabbcabb"
    Out: [("a",3),("b",4),("c",1)]

您可以在以下链接中查看我的代码：http://codepad.org/nyIECIT2 在这段代码中，唯一函数的输出将是这样的

     In: "aabbcabb"
     Out: "abc"

使用唯一的输出我们将计算目标列表的频率。你也可以在这里看到代码：

    frequencyOfElt xs=ans
       where ans=countElt(unique xs) xs
          unique []=[]
      unique xs=(head xs):(unique (filter((/=)(head xs))xs))
      countElt ref target=ans'
             where ans'=zip ref lengths
            lengths=map length $ zipWith($)(map[(=='a'),(==',b'),(==',c')](filter.(==))ref)(repeat target)

    Error:Syntax error in input (unexpected symbol "unique")

但是在ghci 6.13中还出现了其他类型的错误

很少有人问我使用[（=='a'），（=='，b'），（=='，c'）]的目的是什么。我的期望：如果ref =“abc”和target =“aabbaacc” 然后

    zipWith($) (map filter ref)(repeat target)

将显示[“aaaa”，“bb”，“cc”]然后我可以使用地图长度来获取频率这里根据参考过滤列表使用[（=='a'），（=='，b'），（=='，c'）]

我假设一些逻辑错误在于[（=='a'），（=='，b'），（=='，c'）]这里..

Answer 1

你没有说你是想自己编写，还是从一些标准函数中编写它是否可以。

import Data.List

g s = map (\x -> ([head x], length x)) . group . sort $ s

-- g = map (head &&& length) . group . sort     -- without the [...]

是编码它的标准快速脏方法。

好的，所以你最初的想法是编码点免费风格（某些曲调在我脑海中播放......）：

frequencyOfElt :: (Eq a) => [a] -> [(a,Int)]
frequencyOfElt xs = countElt (unique xs) xs     -- change the result type
  where 
    unique [] = []
    unique (x:xs) = x : unique (filter (/= x) xs)  

    countElt ref target =   -- Code it Point-Free Style  (your original idea)
      zip 
        ref $               -- your original type would need (map (:[]) ref) here
        map length $
          zipWith ($)       -- ((filter . (==)) c) === (filter (== c))
            (zipWith ($) (repeat (filter . (==))) ref)  
            (repeat target)

我已将此处的类型更改为更合理的[a] -> [(a,Int)]顺便说一句。注意，那

zipWith ($) fs (repeat z) === map ($ z) fs
zipWith ($) (repeat f) zs === map (f $) zs === map f zs

因此代码简化为

    countElt ref target =  
      zip 
        ref $              
        map length $
          map ($ target)      
            (zipWith ($) (repeat (filter . (==))) ref)

然后

    countElt ref target =  
      zip 
        ref $              
        map length $
          map ($ target) $
            map (filter . (==)) ref

但是map f $ map g xs === map (f.g) xs，所以

    countElt ref target =  
      zip 
        ref $              
        map (length . ($ target) . filter . (==)) ref      -- (1)

用列表理解写的更清楚（按照我的口味），

    countElt ref target =  
        [ (c, (length . ($ target) . filter . (==)) c) | c <- ref] 
     == [ (c,  length ( ($ target) ( filter (== c))))  | c <- ref]     
     == [ (c,  length $ filter (== c) target)          | c <- ref]

这使我们有了进一步重写（1）的想法

    countElt ref target =  
      zip <*> map (length . (`filter` target) . (==)) $ ref

但是这种对无点代码的迷恋在这里变得毫无意义。

回到可读列表推导，使用与nub等效的标准unique函数，您的想法变为

import Data.List

frequencyOfElt xs = [ (c, length $ filter (== c) xs) | c <- nub xs]

此算法实际上是二次方（~ n^2），因此它比上面的sort支配的第一个版本更糟，即线性化（~ n log(n)）。

此代码可以通过等效转换原则进一步操作：

  = [ (c, length . filter (== c) $ sort xs) | c <- nub xs]

...因为在列表中搜索与在列表中搜索相同，已排序。在这里做更多的工作 - 它会得到回报吗？..

  = [ (c, length . filter (== c) $ sort xs) | (c:_) <- group $ sort xs]

......对吗？但是现在，group已经按(==)对它们进行了分组，因此filter调用不需要重复group已经完成的工作：

  = [ (c, length . get c . group $ sort xs) | (c:_) <- group $ sort xs]
            where get c gs = fromJust . find ((== c).head) $ gs

  = [ (c, length g) | g@(c:_) <- group $ sort xs]

  = [ (head g, length g) | g <- group (sort xs)]

  = (map (head &&& length) . group . sort) xs

不是吗？从这篇文章的开头，它就是一个相同的线性算法，实际上从你的代码中派生，通过分解其隐藏的公共计算，使它们可以重用和代码简化。

Answer 2

使用multiset-0.1：

import Data.Multiset

freq = toOccurList . fromList

计算列表中每个元素的频率

2 个答案: