更复杂的群体

Question

我想以某种方式对列表进行分组，每个组尽可能大并且最多包含 n 个不同的值（分组是贪婪的）。

例如： groupN 2 [2,2,3,4,5,5,4,3,4,5]应该是[[2,2,3],[4,5,5,4],[3,4],[5]] , groupN 3 [2,2,3,4,5,5,4,3,4,5]应该是[[2,2,3,4],[5,5,4,3,4,5]]和group = groupN 1 。

我还没有想出一个很好的方法来实现它。 你？ 解决方案应该尽可能通用，因为我需要更多关于组的条件。

Answer 1

您可以通过定义一个辅助函数来实现这一点，该函数从列表的头部获取适当的部分。 就像是

splitNDistinct :: (Eq a) => Int -> [a] -> ([a],[a])
splitNDistinct n xs = go 0 [] xs
   where 
     go _ _ [] = ([], [])
     go count seen xs'@(x:xs)
      | x `elem` seen = let (taken, rest) = go count seen xs in (x:taken, rest)
      | count /= n = let (taken, rest) = go (count+1) (x:seen) xs in (x:taken, rest)   
      | otherwise = ([], xs')

这给

> splitNDistinct 1 [1, 1,2, 1,2,3, 1,2,3,4]
([1,1],[2,1,2,3,1,2,3,4])
> splitNDistinct 2 [1, 1,2, 1,2,3, 1,2,3,4]
([1,1,2,1,2],[3,1,2,3,4])
> splitNDistinct 3 [1, 1,2, 1,2,3, 1,2,3,4]
([1,1,2,1,2,3,1,2,3],[4])
> splitNDistinct 4 [1, 1,2, 1,2,3, 1,2,3,4]
([1,1,2,1,2,3,1,2,3,4],[])

上面的函数记录了它之前看到了多少和哪些元素，然后只在之前看到过的或者是否有新元素的空间时才取新元素。

（通过认识到除了值count和递归调用中seen的不同之外， go的两个递归案例具有几乎相同的结构，可以简化上述内容。尽管如此，分解很容易使函数变得不那么干净。）

groupN可以通过重复应用splitNDistinct来实现。

---

一想到这件事，那么我们可以定义mapFst f (a,b) = (fa, b)并更换let在递归调用-expressions go与mapFst (x:) $ go count seen xs和mapFst (x:) $ go (count+1) (x:seen) xs分别，这使得它们的相似性更加令人讨厌。

Answer 2

编辑：正如 dbaupp 所指出的，我回答了一个不同的、更简单的问题。 正确理解会产生

import Data.List
import qualified Data.Set as S

groupN :: Ord a => Int -> [a] -> [[a]]
groupN n (h:t) = reverse . fmap reverse . fst $
                 foldl' add ([[h]], S.singleton h) t
  where insHead (l:t) i = (i:l):t
        add (l, s) i
          | i `S.member` s = (insHead l i, s)
          | S.size s == n  = ([i]:l, S.singleton i)
          | True           = (insHead l i, S.insert i s)

这是（我认为）正确且相当简洁的，并且在相对于其输入的线性时间内运行（对于 m 组唯一值和长度为 n 的输入列表的 O(n log m)；理论最大值是 O(n) 使用具有恒定时间插入和查找的数据结构，我认为 dbaupp 的运行时间为 O(mn)。但是，我确实通过使用集合来加强条件Eq a到Ord a ，并牺牲了惰性。

---

不正确的代码：

import Data.List

groupN :: Eq a => Int -> [a] -> [[a]]
groupN n = concatN n . group
  where concatN n l = case splitAt n l of
          (l, [])  -> return $ concat l
          (l1, l2) -> (concat l1):(concatN n l2)

您可以使用genericSplitAt将Int松弛为Integral 。