github地址:[email protected]:ZQCard/leetcode.git

給定一個整數陣列和一個目標值，找出陣列中和為目標值的兩個數。

你可以假設每個輸入只對應一種答案，且同樣的元素不能被重複利用。

示例:

給定 nums = [2, 7, 11, 15], target = 9

因為 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

package problem

// 56ms
// 複雜度分析：
// 時間複雜度：O(n^2)O(n2)， 對於每個元素，我們試圖通過遍歷陣列的其餘部分來尋找它所對應的目標元素，
// 這將耗費 O(n)O(n) 的時間。因此時間複雜度為 O(n^2)O(n2)。
// 空間複雜度：O(1)O(1)。 
func TwoSum(nums []int, target int) []int{
   var res  []int
   for key, value := range nums {
      for k, v := range nums{
         if k <= key {
            continue
         }
         if value + v == target {
            res = append(res, key)
            res = append(res, k)
            return res
         }
      }
   }
   return res
}

// 44ms
// 優化1
func TwoSum2(nums []int, target int) []int  {
   length := len(nums)
   for i := 0; i < length; i++ {
      for j := i + 1; j < length; j++ {
         if nums[i] + nums[j] == target{
            return []int{i, j}
         }
      }
   }
   return []int{}
}

// 8ms
// 複雜度分析：
// 時間複雜度：O(n)O(n)， 我們把包含有 nn 個元素的列表遍歷兩次。
// 由於雜湊表將查詢時間縮短到 O(1)O(1) ，所以時間複雜度為 O(n)O(n)。
// 空間複雜度：O(n)O(n)， 所需的額外空間取決於雜湊表中儲存的元素數量，該表中儲存了 nn 個元素。
func TwoSumTwoMap(nums []int, target int) []int {
   numMap := make(map[int]int)
   for i := 0; i < len(nums); i++ {
      numMap[i] = nums[i]
   }

   numMap2 := make(map[int]int)
   for i := 0; i < len(nums); i++ {
      numMap2[nums[i]] = i
   }

   for i := 0; i < len(nums); i++ {
      complement := target - numMap[i]
      if k, ok := numMap2[complement]; k != i && ok{
         return []int{i, k}
      }
   }
   return nil
}

// 4ms
func TheBest(nums []int, target int) []int {
   m := make(map[int]int)
   for i, num := range nums {
      t, found := m[target - num]
      if found {
         return []int{t, i}
      } else {
         m[num] = i
      }
   }
   return nil
}