Haskell 中的素数分解以返回给出数量和幂的元组列表

Question

我一直在尝试通过做一些简单的问题来学习haskell。

问题

目前，我正在尝试实现一个函数primeFactorization :: Integer -> [(Integer, Integer)]使得输出是一个包含素数因子的元组列表以及它在数字中的幂。

示例输出

> primeFactorization 120
[(2,3), (3,1), (5,1)]因为 120 = 2^3 * 3^1 * 5^1

我的（部分）解决方案

primeFactorization :: Integer -> [Integer]
primeFactorization n = 
    let
        factors :: Integer -> [Integer]
        factors n = [x | x <- [2..n-1], n `mod` x == 0]

        isPrime :: Integer -> Bool
        isPrime n
            | n `elem` [0, 1] = False
            | n == 2 = True
            | n > 2 = null [ x | x <- [2..(ceiling . sqrt . fromIntegral) n], n `mod` x == 0]
            | otherwise = False
    in
        filter isPrime $ (factors n)

这是获取数字的主要因素的有效实现。 然而，正如所见，它只输出主要因素。 我不确定如何在haskell中存储次数。 另外，考虑到在haskell中迭代是不习惯的，我不知道我将如何实现该解决方案。 在python中，我会这样做：

def pf(number):
    factors=[]
    d=2
    while(number>1):
        while(number%d==0):
            factors.append(d)
            number=number/d
        d+=1
    return factors

那么，问题来了：如何实现素因数的权力？

笔记：

1. 我已经看到了： 阶乘的素数分解，但这并不能回答我的问题。
2. 这不是作业问题，我正在独立学习。

Answer 1

您总是可以用递归替换命令式语言循环（只要它们不干预任何全局状态）。 这可能不是最优雅的方法，但在这种情况下，用递归函数模仿你的内部 Python 循环似乎非常合适：

dividerPower :: Integer -> Integer -> Int
dividerPower n d
  | n`rem`d == 0  = 1 + dividerPower (n`quot`d) d
  | otherwise     = 0

（与 Python 循环相比，这算“向后”。您还可以使用辅助函数使其尾递归并在累加器变量上向前计数，但这更尴尬，我认为不会有内存/性能优势在这种情况下证明它是合理的。）

您可以将它与您的 Haskell 代码一起使用（对于您已经找到的每个因素，检查它发生的频率），或者扩展它以便整个事情像 Python 解决方案一样工作（实际上效率更高，因为它避免了每个数字检查它是否是素数）。 为此，您只需要返回结果中的最终n即可。 让我们使用where块来处理模式匹配，并制作rem和：

dividePower :: Integer -> Integer -> (Integer, Int)
dividePower n d
  | r == 0     = (nfin, p'+1)
  | otherwise  = (n, 0)
 where (n', r) = n `quotRem` d
       (nfin, p') = dividePower n' d

那么相当于你的Python代码是

pf :: Integer -> Integer -> [(Integer, Int)]
pf = go 2
 where go d n
         | n>1        = (d, p) : go (d+1) n'
         | otherwise  = []
        where (n', p) = dividePower n d

这实际上给了你，就像在 Python 中一样，列表也包括非除法器（幂为 0）。 为避免这种情况，请将列表构建更改为

         | n>1        = (if p>0 then ((d,p):) else id) $ go (d+1) n'