程序优化

时间:2012-03-05 22:05:16

标签: haskell

我正在学习Haskell并在spoj.pl上解决一些编程问题。 问题的概念如下:计算一个数的适当除数的总和。

所以我的程序读取第一行中的数字。然后读一个数字。对其进行分解(a1^p1 * a2^p2)并计算(a1 ^ (p1 + 1) - 1) / (a1 - 1) * ... 但程序运行缓慢。处理200000个号码需要4秒钟。 c上的相同程序在0.84秒内完成。请帮我优化一下。 代码风格的批评也受到欢迎。

以下是源代码:

main = do
        nRaw <- getLine
        let n = (read nRaw)::Int in 
         loop n (do
                  vS <- getLine
                  let v = (read vS)::Int in
                   putStrLn (show (solve v))
                )

loop 1 a = a
loop n a = do a
              loop (n - 1) a

simples = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]

solve n = (subsolve n simples 1 1 n) - n

subsolve n [] ansnum ansden threshold = (ansnum `div` ansden)
subsolve n (x:spls) ansnum ansden threshold | x * x > threshold    = if n > 1 then subsolve n [] (ansnum * (n * n - 1)) (ansden * (n - 1)) threshold
                                                                              else subsolve n [] ansnum ansden threshold
                                            | (n `mod` x) == 0 = (let (a, p) = (getPower n x 1)
                                                                   in (subsolve a spls (ansnum * ((x * p) - 1)) (ansden * (x - 1)) threshold))
                                            | otherwise        = subsolve n spls ansnum ansden threshold

getPower n x ans | n `mod` x == 0 = getPower (n `div` x) x (ans * x)
                 | n `mod` x /= 0 = (n, ans)

提前致谢。

3 个答案:

答案 0 :(得分:6)

使用Haskell的懒惰IO可以更清楚地表达从标准输入读取数字。

main :: IO ()
main = interact $ unlines . map (show . solve . read) . tail . lines

solve :: Int -> Int
solve ...

这将使您的代码更优雅,但速度更快。如果IO和解析数是瓶颈(您可以使用探查器进行检查),则应考虑使用Data.Text模块,该模块比使用字符列表(String)更有效。

不幸的是,使用Data.Text提高效率所获得的代价是代码变得更加冗长和笨重。例如:

{-# LANGUAGE OverloadedStrings #-}
import qualified Data.Text.Lazy as Text
import qualified Data.Text.Lazy.IO as Text
import qualified Data.Text.Lazy.Read as R
import qualified Data.Text.Lazy.Builder.Int as B
import qualified Data.Text.Lazy.Builder as B

main :: IO ()
main = Text.interact $ 
   Text.unlines . map (showInt . solve . readInt) . tail . Text.lines

readInt x = case R.decimal x of
  Left err -> error err
  Right (i,"") -> i

showInt = B.toLazyText . B.decimal  

(如果我正确使用Builder模块而不是将Builder转换为每行的延迟文本,那就更加笨重了)

答案 1 :(得分:5)

每当你有类似

的东西时
foo .... | condition     = result1
         | not condition = result2

您可以将其重写为

foo .... | condition     = result1
         | otherwise     = result2

这可能会在运行时节省几个周期。它可能有助于编译器生成更好的代码,因为它知道所有情况都被覆盖。请记住,(a `rem` b) == 0 || (a `rem` b) /= 0很明显,但编译器在一般情况中确实很难解决这个问题。因此,编译器编写者知道问题通常不可解决,可能已决定根本不检查防护完整性。

答案 2 :(得分:4)

显而易见的改进(使用ByteStringText改善输入读数后)是避免divmod而是使用quotremdivmod在处理负数时有更好的行为,但比quotrem慢得多,它们是通常的机器分割和余数指令。

更严格一些也可能有所帮助,但由于优化器非常好,所以这并不是一个先验明显的地方,因为它还没有使你的程序使用原始机器Int#

关于样式,不要让代码漫游到目前为止,并至少为所有顶级函数提供类型签名。