Question

我在Python中有这个代码，它找到数组中所有数字对，总和为k：

def two_sum_k(array, k):
    seen = set()
    out = set()

    for v in array:
        if k - v in seen:
            out.add((min(v, k-v), max(v, k-v)))
        seen.add(v)
    return out

任何人都可以帮我将其转换为Scala（功能样式）吗？也具有线性复杂性。

Answer 1

我认为这是 for-comprehension 可以提供额外清晰度的典型案例

scala> def algo(xs: IndexedSeq[Int], target: Int) =
   | for {
   |   i <- 0 until xs.length
   |   j <- (i + 1) until xs.length if xs(i) + xs(j) == target
   | }
   | yield xs(i) -> xs(j)
algo: (xs: IndexedSeq[Int], target: Int)scala.collection.immutable.IndexedSeq[(Int, Int)]

使用它：

scala> algo(1 to 20, 15)
res0: scala.collection.immutable.IndexedSeq[(Int, Int)] = Vector((1,14), (2,13), (3,12), (4,11), (5,10), (6,9), (7,8))

我认为它也不会遇到你的算法存在的问题

Answer 2

我不确定这是最清晰的，但折叠通常可以解决问题：

def two_sum_k(xs: Seq[Int], k: Int) = {
  xs.foldLeft((Set[Int](),Set[(Int,Int)]())){ case ((seen,out),v) =>
    (seen+v, if (seen contains k-v) out+((v min k-v, v max k-v)) else out)
  }._2
}

Answer 3

你可以只使用那些x作为第一个元素来过滤（k-x <= x），它们不大于k / 2：

def two_sum_k (xs: List[Int], k: Int): List [(Int, Int)] =
  xs.filter (x => (x <= k/2)).
    filter (x => (xs contains k-x) && (xs.indexOf (x) != xs.lastIndexOf (x))).
      map (x => (x, k-x)).distinct

第3行的第一个过滤器只是filter (x => xs contains k-x).，在Someone Else的评论中找不到。现在它更复杂，找不到（4,4）。

scala> li
res6: List[Int] = List(2, 3, 3, 4, 5, 5)

scala> two_sum_k (li, 8) 
res7: List[(Int, Int)] = List((3,5))

Answer 4

def twoSumK(xs: List[Int], k: Int): List[(Int, Int)] = {
  val tuples = xs.iterator map { x => (x, k-x) }
  val potentialValues = tuples map { case (a, b) => (a min b) -> (a max b) }
  val values = potentialValues filter { xs contains _._2 }
  values.toSet.toList
}

Answer 5

嗯，直接翻译就是这样：

import scala.collection.mutable

def twoSumK[T : Numeric](array: Array[T], k: T) = {
  val num = implicitly[Numeric[T]]
  import num._

  val seen = mutable.HashSet[T]()
  val out: mutable.Set[(T, T)]  = mutable.HashSet[(T, T)]()

  for (v <- array) {
    if (seen contains k - v) out += min(v, k - v) -> max(v, k - v)
    seen += v
  }

  out
}

这样做的一个聪明方法是：

def twoSumK[T : Numeric](array: Array[T], k: T) = {
  val num = implicitly[Numeric[T]]
  import num._

  // One can write all the rest as a one-liner
  val s1 = array.toSet
  val s2 = s1 map (k -)
  val s3 = s1 intersect s2

  s3 map (v => min(v, k - v) -> max(v, k - v))
}

Answer 6

这就是诀窍：

def two_sum_k(xs: List[Int], k: Int): List[(Int, Int)] ={
      xs.map(a=>xs.map(b=>(b,a+b)).filter(_._2 == k).map(b=>(b._1,a))).flatten.collect{case (a,b)=>if(a>b){(b,a)}else{(a,b)}}.distinct
}

将迭代的两个和k转换为函数

6 个答案: