我正在学习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)
提前致谢。
答案 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)
显而易见的改进(使用ByteString
或Text
改善输入读数后)是避免div
和mod
而是使用quot
和rem
。 div
和mod
在处理负数时有更好的行为,但比quot
和rem
慢得多,它们是通常的机器分割和余数指令。
更严格一些也可能有所帮助,但由于优化器非常好,所以这并不是一个先验明显的地方,因为它还没有使你的程序使用原始机器Int#
。
关于样式,不要让代码漫游到目前为止,并至少为所有顶级函数提供类型签名。