为什么该程序的 F# 版本比 Haskell 版本快 6 倍？

Haskell版本（1.03s）：

module Main where
  import qualified Data.Text as T
  import qualified Data.Text.IO as TIO
  import Control.Monad
  import Control.Applicative ((<$>))
  import Data.Vector.Unboxed (Vector,(!))
  import qualified Data.Vector.Unboxed as V

  solve :: Vector Int -> Int
  solve ar =
    V.foldl' go 0 ar' where
      ar' = V.zip ar (V.postscanr' max 0 ar)
      go sr (p,m) = sr + m - p

  main = do
    t <- fmap (read . T.unpack) TIO.getLine -- With Data.Text, the example finishes 15% faster.
    T.unlines . map (T.pack . show . solve . V.fromList . map (read . T.unpack) . T.words)
      <$> replicateM t (TIO.getLine >> TIO.getLine) >>= TIO.putStr

F#版本（0.17s）：

open System

let solve (ar : uint64[]) =
    let ar' = 
        let t = Array.scanBack max ar 0UL |> fun x -> Array.take (x.Length-1) x
        Array.zip ar t

    let go sr (p,m) = sr + m - p
    Array.fold go 0UL ar'

let getIntLine() =
    Console.In.ReadLine().Split [|' '|]
    |> Array.choose (fun x -> if x <> "" then uint64 x |> Some else None)    

let getInt() = getIntLine().[0]

let t = getInt()
for i=1 to int t do
    getInt() |> ignore
    let ar = getIntLine()
    printfn "%i" (solve ar)

以上两个方案是针对这个问题的解决方案库存最大化问题 https://www.hackerrank.com/challenges/stockmax/时间是第一个测试用例的时间Run Code button.

由于某种原因，F# 版本大约快 6 倍，但我非常确定，如果我用命令式循环替换缓慢的库函数，我可以将其速度提高至少 3 倍，更有可能是 10 倍。

Haskell 版本可以进行类似的改进吗？

我这样做是出于学习目的，总的来说，我发现很难弄清楚如何编写高效的 Haskell 代码。

If you switch to ByteString http://hackage.haskell.org/package/bytestring-0.10.8.1/docs/Data-ByteString.html and stick with plain Haskell lists (instead of vectors) you will get a more efficient solution. You may also rewrite the solve function with a single left fold and bypass zip and right scan ⁽¹⁾. Overall, on my machine, I get 20 times performance improvement compared to your Haskell solution ⁽²⁾.

下面的 Haskell 代码比 F# 代码执行得更快：

import Data.List (unfoldr)
import Control.Applicative ((<$>))
import Control.Monad (replicateM_)
import Data.ByteString (ByteString)
import qualified Data.ByteString as B
import qualified Data.ByteString.Char8 as C

parse :: ByteString -> [Int]
parse = unfoldr $ C.readInt . C.dropWhile (== ' ')

solve :: [Int] -> Int
solve xs = foldl go (const 0) xs minBound
    where go f x s = if s < x then f x else s - x + f s

main = do
    [n] <- parse <$> B.getLine
    replicateM_ n $ B.getLine >> B.getLine >>= print . solve . parse

<sub>1. See edits https://stackoverflow.com/posts/37527523/revisions for an earlier version of this answer which implements solve using zip and scanr.
2. HackerRank website shows even a larger performance improvement.</sub>