如何为多个数字制作一个排序的倍数列表？

Question

我在完成 Haskell 课程的作业时遇到问题。我已经解决了这个任务的一个部分问题：我必须编写一个函数，它接受一个 Int 并创建一个包含该 Int 的倍数的无限列表。

function :: Int -> [Int]
function d = [d*x | x <- [1..]]

控制台：

ghci> take 10 (function 3)

给了

[3,6,9,12,15,18,21,24,27,30]

在第二个任务中，我必须扩展该函数，以便它接受一个数字列表并将该列表的每个值用作一个因子（之前的 d）。例如：

ghci> take 10 (function [3, 5])

应该给

[3,5,6,9,10,12,15,18,20,21]

已经尝试过类似的列表理解

function d = [y*x | y <- [1..], x <- d]

但该函数以未排序的形式返回列表：

[3,5,6,10,9,15,12,20,15,25]

我们得到了应该使用 Haskell 的模函数的提示，但我不知道如何准确地进行。你有什么好的建议吗？

Answer 1

如果你认为d 不是一个因素

y = x * d 

而是

y `mod` d == 0,

然后您可以从列表[1..] 中获取列表推导并添加谓词函数，例如：

function ds 
    | null ds   = [1..]
    | otherwise = [ x | x <- [1..], qualifies x ]
    where
      qualifies x = any (==0) $ (flip mod) <$> ds <*> [x]

一个更有表现力的版本，一开始可能更容易掌握：

function' ds   
    | null ds   = [1..]
    | otherwise = [ x | x <- [1..], divByAnyIn ds x ]
    where
      divByAnyIn ds x = 
          case ds of
            (d:ds') -> if x `mod` d == 0 then True 
                                         else divByAnyIn ds' x
            _       -> False

Answer 2

我只有一个班轮。

import Data.List (nub)

f xs = nub [x|x<-[1..], d<-xs, x `mod` d == 0]

take 10 $ f [3,5] -- [3,5,6,9,10,12,15,18,20,21]

从结果列表中运行时间应该是 O(n² + n*d)。 nub 在 O(n²) 中运行。摆脱它会很好。

g xs = [x |x<-[1..], let ys = map (mod x) xs in 0 `elem` ys]

这表现相当不错。它应该在 O (n*d) 中运行。我也有这个版本，我认为它的性能至少和 g 一样好，但显然它的性能比 f 好，比 g 差。

h xs = [x |x<-[1..], or [x `mod` d == 0 |d<-xs] ]

我不确定为什么会这样， 或 据我所知是懒惰的，我看不出有什么理由让它运行得更慢。当您增加输入列表的长度时，它尤其不能缩放。

i xs = foldr1 combine [[x, x+x ..] |x<- sort xs]
    where
      combine l [] = l
      combine [] r = r
      combine l@(x:xs) r@(y:ys)
        | x < y = (x: combine xs r)
        | x > y = (y: combine l ys)
        | otherwise = (x: combine xs ys)

不再是一个班轮，而是我能想到的最快的班轮。我不是百分百确定为什么如果您向右或向左折叠以及提前对输入列表进行排序，它会在运行时产生如此大的差异。但它不应该对结果产生影响，因为：

commutative a b = combine [a] [b] == combine [b] [a]

我发现从将递归函数折叠到无穷无尽的输入系数倍数列表的列表中来考虑这个问题是完全疯狂的。

在我的系统上，它仍然比此处使用 Data.List.Ordered 提供的另一个解决方案慢约 10 倍。

Answer 3

这里的答案只是说明这个想法，它不是一个优化的解决方案，可能存在多种实现方式。

首先，从输入的列表中计算每个因子的所有值：

map (\d->[d*x|x<-[1..]]) xs

例如：xs = [3, 5] 给予

[[3, 6, 9, ...], [5, 10, 15, ...]]

然后，找到每个列表的第一个元素的最小值为：

findMinValueIndex::[(Int, [Int])]->Int
findMinValueIndex xss = minimum $ 
                        map fst $ 
                        filter (\p-> (head $ snd p) == minValue) xss
    where minValue = minimum $ map (head . snd) xss

一旦我们发现列表包含最小值，将其返回并从列表中删除最小值：

sortMulti xss = 
            let idx = findMinValueIndex $ zip [0..] xss
            in  head (xss!!idx):sortMulti (updateList idx (tail $ xss!!idx) xss

因此，例如，在找到结果的第一个值（即3）之后，查找下一个值的列表是：

[[6, 9, ...], [5, 10, 15, ...]]

重复以上步骤我们就可以构造出想要的列表了。最后，删除重复的值。这是完成的编码：

import Data.Sequence (update, fromList)
import Data.Foldable (toList)

function :: [Int] -> [Int]
function xs = removeDup $ sortMulti $ map (\d->[d*x|x<-[1..]]) xs
    where sortMulti xss = 
            let idx = findMinValueIndex $ zip [0..] xss
            in  head (xss!!idx):sortMulti (updateList idx (tail $ xss!!idx) xss)

removeDup::[Int]->[Int]
removeDup [] = []
removeDup [a] = [a]
removeDup (x:xs) | x == head xs = removeDup xs
                 | otherwise = x:removeDup xs

findMinValueIndex::[(Int, [Int])]->Int
findMinValueIndex xss = minimum $ 
                        map fst $ 
                        filter (\p-> (head $ snd p) == minValue) xss
    where minValue = minimum $ map (head . snd) xss

updateList::Int->[Int]->[[Int]]->[[Int]]
updateList n xs xss = toList $ update n xs $ fromList xss

Answer 4

有一个很好的递归解决方案

function' :: Int -> [Int]
function' d = [d * x | x <- [1..]]

braid :: [Int] -> [Int] -> [Int]
braid []        bs = bs
braid as        [] = as
braid aa@(a:as) bb@(b:bs) 
  | a < b     = a:braid as bb
  | a == b    = a:braid as bs # avoid duplicates
  | otherwise = b:braid aa bs

function :: [Int] -> [Int]
function ds = foldr braid [] (map function' ds)

braid 函数仅使用输入的头部和惰性“即时”构建所需的列表

Answer 5

如果你想用模函数来做，你可以定义一个简单的单行

foo ds = filter (\x -> any (== 0) [mod x d | d <- ds]) [1..]

或者，以更易读的形式，

foo ds = filter p [1..]
  where
  p x = any id [ mod x d == 0 | d <- ds]
      = any (== 0) [ mod x d | d <- ds]
      = not $ null [ () | d <- ds, mod x d == 0]
      = null [ () | d <- ds, mod x d /= 0]
      = null [ () | d <- ds, rem x d > 0]

这样，我们得到

> take 20 $ foo [3,5]
[3,5,6,9,10,12,15,18,20,21,24,25,27,30,33,35,36,39,40,42]

但是，它效率低下：last $ take 20 $ foo [300,500] == 4200，所以要生成这 20 个数字，这段代码测试了 4200。数字越大，情况就越糟。

我们应该在与n 大致成比例的时间内生成n 数字，而不是。

为此，首先将每个数字的倍数写在自己的列表中：

[ [d*x | x <- [1..]] | d <- ds ] ==
[ [d, d+d ..] | d <- ds ] 

然后，合并这些有序递增的数字列表以一种有序的方式生成一个有序的非递减数字列表。包data-ordlist 有很多functions 来处理这种列表：

import qualified Data.List.Ordered as O
import           Data.List               (sort)

bar :: (Ord a, Num a, Enum a) => [a] -> [a]
bar ds = foldr    O.merge [] [ [d, d+d ..] | d <- ds ]
       = O.foldt' O.merge [] [ [d, d+d ..] | d <- ds ]   -- more efficient, 
       = O.mergeAll [ [d, d+d ..] | d <- sort ds ]       -- tree-shaped folding

如果我们希望生成的列表不包含任何重复项，即创建一个递增列表，我们可以将其更改为

baz ds = O.nub $ foldr O.merge [] [ [d, d+d ..] | d <- ds ]
       = foldr    O.union [] [ [d, d+d ..] | d <- ds ]
       = O.foldt' O.union [] [ [d, d+d ..] | d <- ds ]
       = O.unionAll [ [d, d+d ..] | d <- sort ds ]
       = (O.unionAll . map (iterate =<< (+)) . sort)  ds

哦，而且，与二次方 Data.List.nub 不同，Data.List.Ordered.nub 是线性的，在输入列表的每个元素上花费 O(1) 时间。