在Haskell中制作除数列表而不按顺序划分

Question

我在 Haskell 学习。

我一直在实现一个生成除数列表的函数。
我的第一个代码在这里：

代码：

divisors :: Integral a => a -> [a]
divisors n
  | n < 1 = []
  | otherwise = filter ((== 0) . (mod n)) [1..n]

此代码与Making a list of divisors in Haskell几乎相同。
它可以工作，但速度很慢。

我觉得除以[1..n]中的每一个都没有效率。
是否有另一种聪明的方法来制作除数列表？

更新：

在n < 1的情况下，[1..n]与[]相同。
因此，根本不需要守卫：

divisors :: Integral a => a -> [a]
divisors n = filter ((== 0) . (mod n)) [1..n]

Answer 1

强制性的一元代码：

import Control.Monad

divisors = map product . mapM (scanl (*) 1) . group . factors

factors 与您的其他链接问题一样。

您已经在使用 List monad 中的 sequence，无需显式调用 concatMap（mapM f 等效于 sequence . map f）。

该列表不会被排序，就像您原来的按顺序划分的 O(n) 代码生成的那样 - 您可以将其设为 O(sqrt(n)) 顺便说一句，它有一个足够简单的技巧，但平均而言，它仍然比这段代码慢得多。

Answer 2

我自己的实现现在使用幂集素数。

例如，要得到30的除数列表，其中素数是[2,3,5]，

1. 制作素因数的幂集，[[],[2],[3],[5],[2,3],[2,5],[3,5],[2,3,5]]
2. 产品每个元素并得到结果[1,2,3,5,6,10,15,30]，这是30的除数列表

代码：

divisors :: Integral a => a -> [a]
divisors n
  | n < 1 = []
  | otherwise = distinct $ map product $ (powerset . factors) n

-- | remove duplicated element in a list
distinct :: Eq a => [a] -> [a]
distinct [] = []
distinct (x : xs)
  | x `elem` xs = distinct xs
  | otherwise = x : distinct xs

-- | generate power set of a list
powerset :: [a] -> [[a]]
powerset [] = [[]]
powerset (x : xs) = xss ++ map (x :) xss where xss = powerset xs

-- | generate prime factors of a integer
factors :: Integral a => a -> [a]
factors m = f m (head primes) (tail primes) where
  f m n ns
    | m < 2 = []
    | m < n ^ 2 = [m]
    | m `mod` n == 0 = n : f (m `div` n) n ns
    | otherwise = f m (head ns) (tail ns)

-- | prime sequence
primes :: Integral a => [a]
primes = 2 : filter (\n-> head (factors n) == n) [3,5..]

在此代码中，如果存在重复的素因数，则会出现重复的除数。
我在最后一步删除了重复的除数，但它不能解决重复的基本原因。
我确信还有更聪明的方法。

注意：

• primes 和 factors 引用自 Prime factors in Haskell。
• powerset 引用自 powerset。

---

更新：

感谢comingstorm's advice，我学习了更多关于Data.List 模块并更新了我的代码：

import Data.List (group, subsequences)

divisors :: Integral a => a -> [a]
divisors = map product . concatMap sequence . subsequences . map (scanr1 (*)) . group . factors

primes = ...    -- same as before

factors m = ... -- same as before

我注意到原始代码中的distinct 和powerset 与Data.List 模块中的nub 和subsequences 相同。
它变得简单，但behzad.nouri's code 更快。

Answer 3

使用此代码：

import Data.List (group)
import Control.Arrow ((&&&))

divisors n = foldr go [1] . map (head &&& length) . group $ fac n 2
    where
    go (_, 0) xs = xs
    go (p, k) xs = let ys = map (* p) xs in go (p, pred k) ys ++ xs
    fac n i
        | n < i * i      = if n == 1 then [] else [n]
        | n `mod` i == 0 = i: fac (n `div` i) i
        | otherwise      = fac n $ succ i

你会得到：

\> -- print timing/memory stats after each evaluation
\> :set +s
\> length $ divisors 260620460100
2187
(0.01 secs, 0 bytes)
\> length $ divisors 1000000007  -- prime number
2
(0.08 secs, 13,678,856 bytes)

您可以与您的实现进行比较。