LeetCode（1） two sum -- scala 题解与思路

---

题目

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案
进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？

吐槽一下 LeetCode 的scala 没有关键词提示，还运行慢

---

题解 1 ---- 差集数组

用target 把 原来的数组减去，然后遍历两个数组，对应下标相加 = target 输出第一个数组的下标

错误解法

import scala.collection.mutable.ArrayBuffer

object TwoSum {

  def twoSum(nums: Array[Int], target: Int): Array[Int] = {

    var temp_nums:Array[Int] = new Array[Int](nums.length)

    for ( i <- 0 to (temp_nums.length - 1)) {
      temp_nums(i) = target-nums(i)
    }

    var result:ArrayBuffer[Int] = new ArrayBuffer[Int]()
    for ( i <- 0 to (nums.length - 1)) {
      for(j <- 0 to (temp_nums.length - 1)){
        if(nums(i)==temp_nums(j)){
          result +=  i
        }
      }
    }
    result.toArray
  }


  def main(args: Array[String]): Unit = {

    val nums = Array(7,1,2,3,4)
    val target = 8
    val result = twoSum(nums, target)

    println(result)
  }

}

限制条件 与 结束条件

对比数组的下标位置不能一样，比如 4，这种特殊情况上下一样代表它正好是target 的一半

上述代码输出的时候还有一个问题，是没有立即结束，当遍历到1 的时候有发现了一次结果，覆盖了上一次正确结果，正确的应该是有结果了立即返回

修改后通过测试

object TwoSum {

  def twoSum(nums: Array[Int], target: Int): Array[Int] = {

    var temp_nums:Array[Int] = new Array[Int](nums.length)

    for ( i <- 0 to (temp_nums.length - 1)) {
      temp_nums(i) = target-nums(i)
    }

    var result:Array[Int] = new Array[Int](2)
    for ( i <- 0 to (nums.length - 1)) {
      for(j <- 0 to (temp_nums.length - 1)){
        if((nums(i)==temp_nums(j))&&(i!=j)){
          result(0) = i
          result(1) = j
          return result
        }
      }
    }
    result
  }


  def main(args: Array[String]): Unit = {

//    val nums = Array(7,1,2,3,4)
//    val target = 8
      val nums = Array(2,7,11,15)
      val target = 9
      val result = twoSum(nums, target)

   result.foreach(x=>println(x))
  }

}

跑个这，占了51 m 内存，也是够绝的。。。

---

题解 2 ---- 两层循环语法糖版本

object Solution {
    def twoSum(nums: Array[Int], target: Int): Array[Int] = {
    
    for(i<- nums.indices;j<-i+1 until nums.length){
        if(nums(i)+nums(j)==target){
            return Array(i,j)
            }
        }
        null
    }
}

---

题解 3 ---- hash 表

object Solution {
    def twoSum(nums: Array[Int], target: Int): Array[Int] = {
        
        var tempMap:Map[Int, Int] = Map()
        
        for(i<-nums.indices){
            if(tempMap.contains(nums(i))){
                return Array(tempMap(nums(i)),i)
            }
            tempMap+=((target - nums(i))->i)
        }
        
        Array(0,0)
    }
}

---

题解 4 ---- 短代码

object Solution {
    def twoSum(nums: Array[Int], target: Int): Array[Int] = {
        
        val map = nums.zipWithIndex
        map.filter(elem => map.exists(kv=>kv._1==target - elem._1&&kv._2!=elem._2)).map(_._2)

    }
}

---

参考文献

一个写scala 的notebook

https://polynote.org/latest/