通过递归检查尾部来迭代列表的性能

Question

我决定尝试通过做一些CodinGame 挑战来学习 Haskell（所以我敢肯定这个问题是超级初学者级别的东西）。其中之一需要在整数列表中搜索任意两个值之间的最小差异。我以前通过这样做在 Clojure 中解决了它：

(ns Solution
  (:gen-class))

(defn smallest-difference [values]
  (let [v (sort values)]
    (loop [[h & t] v curr-min 999999]
      (if (nil? t) curr-min
        (let [dif (- (first t) h)]
          (recur t (if (> curr-min dif) dif curr-min)))))))

(defn -main [& args]
  (let [horse-strengths (repeatedly (read) #(read))]
      (let [answer (smallest-difference horse-strengths)]
        (println answer)))) 

我尝试在 Haskell 中实现相同的解决方案，如下：

readHorses :: Int -> [Int] -> IO [Int]
readHorses n h
    | n < 1 = return h
    | otherwise = do
        l <- getLine
        let hn = read l :: Int
        readHorses (n - 1) (hn:h)

findMinDiff :: [Int] -> Int -> Int
findMinDiff h m
    | (length h) < 2    = m
    | (h!!1 - h!!0) < m = findMinDiff (tail h) (h!!1 - h!!0)
    | otherwise         = findMinDiff (tail h) m



main :: IO ()
main = do
    hSetBuffering stdout NoBuffering -- DO NOT REMOVE
    input_line <- getLine
    let n = read input_line :: Int
    hPrint stderr n
    horses <- readHorses n []
    hPrint stderr "Read all horses"
    print (findMinDiff (sort horses) 999999999)
    return ()

对于 Clojure 解决方案没有的大输入（99999 个值）会超时。然而，它们看起来和我很相似。

至少从表面上看，读取值和构建列表似乎不是问题，因为“读取所有马匹”是在超时之前打印的。

如何使 Haskell 版本的性能更高？

Answer 1

您在每次递归到findMinDiff 时计算列表的length。因为length 需要O(n) 时间findMinDiff 需要O(n^2) 时间而不是O(n)。

你可以用pattern matching代替length、!!和tail写同样的东西

findMinDiff :: [Int] -> Int -> Int
findMinDiff (h0 : hs@(h1 : _)) m = 
    if h1 - h0 < m
    then findMinDiff hs (h1 - h0)
    else findMinDiff hs m
findMinDiff _ m = m

Answer 2

顺便说一下，一个完全替代的实现可以写成如下。 （后面是伪代码）

拿清单

h = [h0, h1, h2 ...

删除一个元素

drop 1 h = [h1, h2, h3 ...

计算逐点差异

zipWith (-) (drop 1 h) h = [h1-h0, h2-h1, h3-h2, ...

然后取最小值。完整代码：

minDiff :: [Int] -> Int
minDiff h = minimum (zipWith (-) (drop 1 h) h)

请注意，这将在空列表上崩溃。另一方面，不需要9999999 hack。由于懒惰，它也可以在恒定空间中运行。

为了更好地处理错误：

minDiff :: [Int] -> Int
minDiff [] = error "minDiff: empty list"
minDiff h = minimum (zipWith (-) (drop 1 h) h)

甚至，更迂腐（但尊重整体）：

minDiff :: [Int] -> Maybe Int
minDiff [] = Nothing
minDiff h  = Just (minimum (zipWith (-) (drop 1 h) h))