[Swift]LeetCode532. 数组中的K-diff数对 | K-diff Pairs in an Array

Given an array of integers and an integer k,you need to find the number of unique k-diff pairs in the array. Here a k-diff pair is defined as an integer pair (i,j),where i and j are both numbers in the array and their absolute difference is k.

Example 1:

Input: [3,1,4,5],k = 2
Output: 2
Explanation: There are two 2-diff pairs in the array,(1,3) and (3,5).
Although we have two 1s in the input,we should only return the number of unique pairs.

Example 2:

Input:[1,2,3,k = 1
Output: 4
Explanation: There are four 1-diff pairs in the array,2),(2,3),(3,4) and (4,5).

Example 3:

Input: [1,5,4],k = 0
Output: 1
Explanation: There is one 0-diff pair in the array,1).

Note:

The pairs (i,j) and (j,i) count as the same pair.
The length of the array won‘t exceed 10,000.
All the integers in the given input belong to the range: [-1e7,1e7].


 1 class Solution {
 2     func findPairs(_ nums: [Int],_ k: Int) -> Int {
 3         var count:Int = 0
 4         if k < 0 {return count}
 5         var hm:[Int:Int] = [Int:Int]()
 6         let len:Int = nums.count
 7         for i in 0..<len
 8         {
 9             hm[nums[i]] = i
10         }
11         for i in 0..<len
12         {
13 //如果字典包含所请求键的值，则下标返回包含该键的现有值的可选值。否则，下标返回nil：
14             if let keys = hm[nums[i] + k] 
15             {
16                 if keys != i
17                 {
18                     count += 1
19 //使用下标语法通过nil为该键指定值来从字典中删除键值对
20 //使用该removeValue(forKey:)方法从字典中删除键值对。hm.removeValue(forKey:key)
21 //此方法删除键值对（如果存在）并返回已删除的值，nil如果不存在值则返回
22                     hm[nums[i] + k] = nil                    
23                 }
24             }
25         }
26         return count
27     }
28 }

44ms

 1 class Solution {
 2     func findPairs(_ nums: [Int],_ k: Int) -> Int {
 3         guard k >= 0 else {
 4             return 0
 5         }
 6         
 7         var dict = [Int: Int]()
 8         for num in nums {
 9             //dict[num] = dict[num] == nil ? 0 : dict[num]! + 1
10             dict[num,default: 0] += 1
11         }
12         
13         var res = 0
14         for (num,count) in dict {
15             if k == 0 {
16                 if count > 1 {
17                     res += 1
18                 } 
19             } else {
20                 if dict[num - k] != nil {
21                     res += 1
22                 }
23             }
24             
25         }
26         return res
27     }
28 }

48ma

 1 class Solution {
 2     func findPairs(_ nums: [Int],_ k: Int) -> Int {
 3         guard nums.count > 1 else { return 0 }
 4         guard k >= 0 else { return 0 }
 5 
 6         var res = 0
 7         var dict = [Int: Int]()
 8         for n in nums {
 9             if let val = dict[n] {
10                 dict[n] = val + 1
11             } else {
12                 dict[n] = 1
13             }
14         }
15         
16         if k == 0 {
17             return dict.reduce(0) { (r,arg1) -> Int in
18                 if arg1.value > 1 {  return r + 1}
19                 return r
20             }
21         } else {
22             for key in dict.keys {
23                 if dict.keys.contains(key + k) {
24                     res = res + 1
25                 }
26             }
27             return res
28         }
29     }
30 }

52ms

 1 class Solution {
 2     func findPairs(_ nums: [Int],_ k: Int) -> Int {
 3         guard k >= 0 else {
 4             return 0
 5         }
 6         
 7         var dict = [Int: Int]()
 8         for num in nums {
 9             dict[num,default: 0] += 1
10         }
11         
12         var res = 0
13         for (num,count) in dict {
14             if k == 0 {
15                 if count > 1 {
16                     res += 1
17                 } 
18             } else {
19                 if dict[num - k] != nil {
20                     res += 1
21                 }
22             }
23             
24         }
25         return res
26     }
27 }

56ms

 1 class Solution {
 2     func findPairs(_ nums: [Int],_ k: Int) -> Int {
 3         var dict = [Int: Bool]()
 4         
 5         if k < 0 {
 6             return 0
 7         }
 8         
 9         var diff = k < 0 ? -1*k : k
10         var count = 0
11         
12         
13         
14         for num in nums {
15             if !dict.keys.contains(num) {
16                 dict[num] = false
17                 if diff == 0 { continue }
18             }
19             
20             if dict.keys.contains(num-diff) {
21                 if dict[num-diff] == false {
22                     dict[num-diff] = true
23                     count = count + 1
24                 }
25                 
26             } 
27             if dict.keys.contains(num+diff) {
28                 if dict[num] == false {
29                     dict[num] = true
30                     count = count + 1
31                 }
32             }
33         }
34         
35         return count
36     }
37 }

68ms

 1 class Solution {
 2     func findPairs(_ nums: [Int],_ k: Int) -> Int {
 3         
 4         guard k >= 0 else { return 0 }
 5         
 6         var dict = nums.reduce(into: [Int: Int]()) { dict,num in
 7             dict[num,default:0] += 1
 8         }
 9         
10         guard k > 0 else {
11             return dict.reduce(into: 0) { count,numAndCount in
12                 if numAndCount.1 > 1 {
13                     count += 1
14                 }
15             }
16         }
17         
18         var totalCount = 0
19         for (num,count) in dict {
20             if dict[num+k,default:0] > 0 {
21                 totalCount += 1
22             }
23             if dict[num-k,default: 0] > 0 {
24                 totalCount += 1
25             }
26             dict[num] = 0
27         }
28         
29         return totalCount
30     }
31 }

76ms

 1 class Solution {
 2     func findPairs(_ nums: [Int],default:0] += 1
 8         }
 9         
10         if k == 0 {
11             return dict.values.reduce(into: 0) { total,appearances in
12                 if appearances > 1 {
13                     total += 1
14                 }
15             }
16         }
17         
18         return dict.keys.reduce(into: 0) { total,num in
19             if dict[num+k,default:0] > 0 {
20                 total += 1
21             }
22             if dict[num-k,default: 0] > 0 {
23                 total += 1
24             }
25             dict[num] = 0
26         }
27         
28     }
29 }

96ms

 1 class Solution {
 2     func findPairs(_ nums: [Int],_ k: Int) -> Int {
 3         guard nums.count > 1 else { return 0}
 4         let sortednums = nums.sorted()
 5         var behind = 0
 6         var forward = 1
 7         var counter = 0
 8 
 9         while forward < nums.count,behind < nums.count {
10             if behind >= forward {
11                 forward = behind + 1
12                 continue
13             }
14             
15             let diff = abs(sortednums[forward] - sortednums[behind])
16             
17             if diff < k {
18                 repeat { forward += 1} while forward < nums.count && sortednums[forward] == sortednums[forward-1]
19                 continue
20             }
21 
22             if diff == k {
23                 counter += 1
24                 repeat { forward += 1} while forward < nums.count && sortednums[forward] == sortednums[forward-1]
25                 repeat { behind += 1} while behind < nums.count && sortednums[behind] == sortednums[behind-1]
26                 continue
27             }
28 
29             if diff > k {
30                 repeat { behind += 1} while behind < nums.count && sortednums[behind] == sortednums[behind-1]
31                 continue
32             }
33         }
34         return counter
35     }
36 }

116ms

 1 class Solution {
 2     func findPairs(_ nums: [Int],_ k: Int) -> Int {
 3         let nums =  nums.sorted()
 4         var i = 0
 5         var j = 1
 6         var res = 0
 7         while  i < nums.count && j < nums.count  {
 8             if nums[j] - nums[i] == k {
 9                 res += 1
10                 i += 1
11                 j += 1
12                 while j < nums.count && nums[j] == nums[j-1]  {
13                     j += 1
14                 }
15             }else if nums[j] - nums[i] < k {
16                 j += 1
17             }else  {
18                 i += 1
19                 j = i < j ? j : i+1
20             }
21         }
22         return res
23     }
24 }

132ms

 1 class Solution {
 2     func findPairs(_ nums: [Int],_ k: Int) -> Int {
 3         guard nums.count > 1 else {
 4             return 0
 5         }
 6         var resultSet: [[Int]] = []
 7         var sortednums = nums
 8         sortednums.sort()
 9         var firstPointer = 0
10         var secondPointer = 1
11         while secondPointer < sortednums.count {
12             // print("comparing : \(sortednums[firstPointer]) and \(sortednums[secondPointer])")
13             if abs(sortednums[firstPointer] - sortednums[secondPointer]) == k {
14                 var validList: [Int] = [sortednums[firstPointer],sortednums[secondPointer]]
15                 // if !resultSet.contains(where: {$0 == validList}) {
16                     resultSet.append(validList)
17                 // }
18                 firstPointer += 1
19             } else if (sortednums[secondPointer] - sortednums[firstPointer]) < k {
20                 secondPointer += 1
21             } else {
22                 firstPointer += 1
23             }
24             if firstPointer == secondPointer {
25                 secondPointer += 1
26             }
27         }
28         print("This is the result set : \(resultSet)")
29         var removeIndex:[Int] = []
30         if resultSet.count > 1 {
31             for index in 1..<resultSet.count {
32                 // print("index : \(index)")
33                 if resultSet[index] == resultSet[index-1] {
34                     removeIndex.append(index)
35                 }
36             }
37         }
38         while removeIndex.count != 0 {
39             // print("removing \(removeIndex.last) as \(removeIndex)")
40             resultSet.remove(at: removeIndex.last!)
41             let _ = removeIndex.popLast()
42         }
43         return resultSet.count
44     }
45 }

[Swift]LeetCode532. 数组中的K-diff数对 | K-diff Pairs in an Array

相关推荐