两个数组的交集

Stupid man are always struggling ！！

给定两个数组，编写一个函数来计算它们的交集。

示例 1:

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]

示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]

我的

func intersect(_ nums1: [Int], _ nums2: [Int]) -> [Int] {
    
    var re1=nums1.sorted()
    var re2=nums2.sorted()
    
    if re1.isEmpty||nums2.isEmpty{
        return []
    }
    
    var i:Int = -1
    var j:Int = -1
    
    if(re1.count<=re2.count){
        for _ in 0..<re1.count{
            i+=1
            j = -1
            for _ in 0..<re2.count{
                j+=1
                if re1[i] == re2[j]{
                    re2.remove(at: j)
                    j-=1
                    break
                }
                else{
                    if (j==re2.count-1||re1[i]<re2[j]) {
                        re1.remove(at: i)
                        i-=1
                        break
                    }
                }
            }
        }
        
    }else{
        for _ in 0..<re2.count{
        i+=1
        j = -1
        for _ in 0..<re1.count{
            
            j+=1
            if re2[i] == re1[j]{
                re1.remove(at: j)
                j-=1
                break
            }
            else{
                if (j==re1.count-1||re2[i]<re1[j]) {
                    re2.remove(at: i)
                    i-=1
                    break
                }
            }
        }
        }
        return re2
    }
    return re1
}

$愚蠢的人总是事倍功半 —— Gaochengzhi$

我花了好大力气来Debug，设计了两个解决数组删除问题的 i, j 变量，优化了数组长短的选择方案，最后程序通过了，但是性能非常差，记得就在几天之前我还嘲笑过一个把代码写的老长却却获得糟糕性能分数的人。那时我用很简短的代码就击败了99%的选手。

人果然还是要谦虚一点好啊。

这不禁令我反思，我生命中遇到过的很多人，他们花了巨大的力气做某件事，事实上被证明只是浪费时间和精力罢了。啊！愚蠢又可悲的人类呀！

24 ms

class Solution {
    func intersect(_ nums1: [Int], _ nums2: [Int]) -> [Int] {
        var dict:[Int:Int] = [:]
        var array:[Int] = []
        for i in 0..<nums1.count {
            let value = nums1[i]
            var dVlue = dict[value] ?? 0
            dVlue += 1
            dict[value] = dVlue
        }
        for i in 0..<nums2.count {
            let value = nums2[i]
            var dVlue = dict[value] ?? 0
            if dVlue > 0 { 
                dVlue -= 1
                array.append(value)
                dict[value] = dVlue
            }
        }
        return array
    }
}

• 使用map[数字为key，数字个数为value]记录数字和数字个数
• 遍历数组2，map[num]的值大于0的就是两个数组共有的数字，然后map[num]-=1
• 返回添加数字的数组

或者：

但是不知道为什么会慢很多

func intersect(_ nums1: [Int], _ nums2: [Int]) -> [Int] {
    var result = [Int]()
    var tmp = [Int:Int]()
    for num in nums1 {
        var t = tmp[num] ?? 0
        t+=1
        tmp.updateValue(t, forKey: num)
    }
    for n in nums2 {
        let tt = tmp[n] ?? 0
        if tt > 0 {
            result.append(n)
            tmp[n]!-=1
        }
    }
    return result
}