在未排序的数字数组中查找具有给定总和的所有对[关闭]

Question

例如，函数将有两个输入：

• 任意长度的数组，例如[1, 8, 5, 2, 5, 6, 7, 3, 9, 4].

• 目标总和，例如10.

输出将是一个包含所有对目标求和的数字对的数组，例如[(1,9),(8,2),(5,5),(7,3),(6,4)].

我完全不知道如何创建此代码。如果有人可以提供一些见解，以下是我到目前为止的内容，但它不起作用：

sums :: (Num a, Num b) => [a] -> b -> [(a,a)]
sums ([x] i) = (x i)
sums (x:xs) i
    | x == [] = []
    | x + sums(xs) == i = [(x,xs)]
    | otherwise = []

Answer 1

您的尝试在句法和语义上都存在一些问题。 这是一种可能的解决方案。它不是递归的，但我希望它能帮助你理解问题（请参阅最后关于递归的建议）：

sums :: (Num a, Eq a) => [a] -> a -> [(a,a)]
sums l s = filter (\(x,y) -> x+y == s) [ (x,y) | x <- l, y <- l ]

• [ (x,y) | x <- l, y <- l ] 定义了一个包含所有可能对的列表
• \(x,y) -> x+y == s 是一个函数，给定一对告诉它是否满足你的条件
• filter 使用该函数过滤所有可能对的列表

请花点时间了解一些主题：

• 如何编写函数签名
• 列表和最常用的函数（例如filter）
• 理解语法 ([ (x,y) | x <- l, y <- l ])
• Lambda 表达式 (\(x,y) -> x+y == s)
• 延迟评估。您尝试在一个函数中完成所有操作：遍历列表、配对、检查它们是否满足条件。 上面的解决方案首先定义了所有可能的组合，然后过滤，只选择那些总和为s 的组合。如果您来自命令式编程，从概念上讲更简单，也很有效，直观地思考它可能看起来很慢。

正如 cmets 中所指出的，表达这一点的最紧凑的方式是使用理解“即时”将条件应用于生成的组合的能力：

sums l s = [ (x,y) | x <- l, y <- l, x+y == s ]

但是，尝试使用递归解决问题会更有指导意义。

建议：保持结构filter (\(x,y) -> x+y == s) (all_pairs l)，但尝试自己想出一个递归函数all_pairs，它从列表中生成所有可能的对，而不是像我那样使用理解语法。 您需要编写的函数比您之前尝试过的函数要简单得多。只需从列表中创建所有对，没有条件，没有检查。

Answer 2

当您得到一个未排序的列表时，有时最好的第一步就是对其进行排序。那么让我们开始吧：

import Data.List (sort)
sums :: (Num a, Ord a) => [a] -> a -> [(a,a)]
sums xs s = ...
  where
    sorted = sort xs

酷。下一步是什么？让我们同时从双方处理排序列表。列表对此不好，所以让我们在这里使用序列。

import Data.List (sort)
import Data.Sequence (Seq (..), fromList)

sums :: (Num a, Ord a) => [a] -> a -> [(a,a)]
sums xs s = go sorted
  where
    sorted = fromList (sort xs)
    go Empty = []
    go (_ :<| Empty) = []
    go (a :<| asb@(as :|> b)) = case compare (a + b) s of
      EQ -> (a,b) : go as
      LT -> go asb
      GT -> go (a :<| as)

这将以与您的示例不同的顺序给出结果，但它的工作时间为 O(n log n) 而不是 O(n^2) 时间——对于长列表来说要快得多。

不幸的是，这里仍然存在效率低下的问题：我们可能会从序列中取出一个元素，然后多次将其放回。这没什么大不了的，但很容易解决。

import Data.List (sort)
import Data.Sequence (Seq (..), fromList)

sums :: (Num a, Ord a) => [a] -> a -> [(a,a)]
sums xs s = start sorted
  where
    sorted = fromList (sort xs)
    start Empty = []
    start (_ :<| Empty) = []
    start (a :<| (as :> b)) = go a as b

    go a as b = case compare (a + b) s of
      EQ -> (a,b) : start as
      LT
        | a' :<| as' <- as
        -> go a' as' b
        | otherwise -> []
      GT
        | as' :|> b' <- as
        -> go a as' b'
        | otherwise -> []

正如现在已删除的评论中所指出的，Data.Sequence 在这里真的是矫枉过正。各种各样的类似双端队列、类似多集和双端优先级队列结构都可以工作，其中许多比Data.Sequence 更简单和/或更快。