在 Haskell 中过滤具有相同数量的不同元素的列表

Question

我是 Haskell 的新手，我有数据 data Instruction = Add | Sub | Mul | Div | Dup | Pop deriving (Eq,Ord,Show,Generic)，我正在生成列表，其中包含 Mul 和 Dup 的所有可能组合以及大小为 n 的 mapM (const [Mul, Dup]) [1..n])。

我只想要以Dup 开头并以Mul 结尾的列表，所以我使用了filter((== Mul) . last)(filter((== Dup) . head) (mapM (const [Mul, Dup]) [1..n]))，但我也只想要其中具有相同数量的Mul 和Dup 的列表，但我不能t 似乎想出一种方法来做到这一点。我该如何过滤？有没有更有效的方法来做这件事，因为随着列表变大，可能会有大量的组合？

示例列表如下所示：[Dup,Mul,Dup,Mul] 和 [Dup,Dup,Mul,Mul] 用于大小为 4 的列表。

Answer 1

虽然您的方法是正确的，但我认为这不是最有效的方法。您生成2^N 列表，然后过滤掉其中的许多。忘记保持计数简单的其他要求，通过要求我们有与Dups 一样多的Muls，我们最终只得到choose(N, N/2) 列表（1..N 的大小为N/2 的子集的数量)，这是一个小得多的数字。

我们可以尝试避免过滤并生成想要的列表，只是，首先。我建议以下方法，您可以根据需要对其进行修改以满足其他要求。

我们定义了一个函数sameMulDup，它接受两个整数m和d，并生成带有m Muls和d Dups的所有列表。

sameMulDup :: Int -> Int -> [[Instruction]]
sameMulDup 0 d = [replicate d Dup]
sameMulDup m 0 = [replicate d Mul]
sameMulDup m d = do
    -- generate the first element
    x <- [Dup, Mul]
    -- compute how many m and d we have left
    let (m', d') = case x of
           Dup -> (m  , d-1)
           Mul -> (m-1, d  )
    -- generate the other elements
    xs <- sameMulDup m' d'
    return (x:xs)

直观地说，如果d=0 或m=0 只有一个可能的列表包含在列表列表结果中。否则，我们不确定地选择第一个元素，递减对应的计数器d 或m，然后生成其余的。

或者，最后一个等式可以替换为以下更基本的等式：

sameMulDup m d =
    map (Dup:) (sameMulDup m (d-1))
    ++
    map (Mul:) (sameMulDup (m-1) d)

无论如何，鉴于sameMuldup，您应该能够解决您的全部任务。

Answer 2

应该可以定义一个函数countPred :: a -> [a] -> Int，它计算列表中等于第一个参数的项目数；然后你可以做filter (\l -> countPred Mul l == countPred Dup l)（或者filter ((==) <$> countPred Mul <*> countPred Dup)，如果你喜欢无点形式）。我认为另一种方法可能是使用(==0) . sum . map (\case { Mul -> 1, Dup -> (-1) })，但这让我觉得它比必要的稍微复杂一些。

Answer 3

我喜欢 chi 的回答，但在评论中，我提到它没有实现尽可能多的共享。我推测如果您多次迭代指令列表，共享将是有益的，但如果您只迭代一次则更糟。根据经验，无论您迭代多少次，共享版本似乎都更快，但内存权衡正如预测的那样：一次迭代更糟，多次迭代更好。所以我认为展示它可能会很有趣。

这是它的外观。我们将列出一个无限的答案列表。第一个索引是指令列表的长度；第二个是有多少Muls（尽管我将使用True 和False 而不是Mul 和Dup）。所以：

bits :: [[[[Bool]]]]
bits = iterate extend [[[]]] where
    extend bsss = zipWith (++)
        (map (map (False:)) bsss ++ [[]])
        ([[]] ++ map (map (True:)) bsss)

为了完整起见，下面是你如何编写一个与 chi 的 sameMulDup 具有相同签名的函数，并计算相同的答案（直到交换到 Bool）：

sameMulDup' :: Int -> Int -> [[Bool]]
sameMulDup' m d = bits !! (m+d) !! m

我机器上的一些计时，对于m=d=12，编译时-O2：

sameMulDup , one iteration  1.35s    6480Kb
sameMulDup', one iteration  1.11s  226476Kb
sameMulDup , two iterations 4.26s 2135368Kb
sameMulDup', two iterations 1.97s  620880Kb

这是我用于获取这些数字的驱动程序代码：

main :: IO ()
main = do
    [sharing, twice, m, d] <- getArgs
    let answer = (if read sharing then sameMulDup' else sameMulDup) (read m) (read d)
    if read twice
       then do
           print . sum . map (sum . map fromEnum) $ answer
           print . sum . map (sum . map (fromEnum . not)) $ answer
        else print . sum . map (sum . map fromEnum) $ answer

这里有一些微妙的地方：

1. 要对列表进行两次迭代，我们必须有一种方法可以在两次迭代中引用同一个列表。这是上面代码中的answer。
2. 我们必须使用实际上强制所有值使其有用的迭代。我通过计算有多少 Trues 来做到这一点，但还有其他方法。 （仅打印整个列表效果不佳：计算的运行时间与生成要打印的 String 以及将其传输到终端所做的工作相形见绌。）
3. 虽然第一次迭代在if 的两个分支中使用相同的代码，但重要的是不要共享此代码并将其移出if。我们希望编译器在else 分支中知道answer 将不会被再次使用，以便它可能会进行垃圾收集。如果你写print answer >> if twice then print answer else pure ()，那么answer的前缀可能被垃圾回收的时候静态就不那么明显了。
4. 在then 分支中，我在两个循环中使用了两种不同的计算，这样编译器就不会变得聪明，只计算一次，然后打印两次计算结果。