数组去重

// 数组去重
    func rotate(_ nums: inout [Int], _ k: Int) {
        guard k != 0 else {
            return
        }
        let step = k%nums.count
        nums.reverse()
        for i in 0..<step {
            if i >= step/2 {
                break
            }
            nums.swapAt(i, step-1-i)
        }
        for j in step ..< nums.count {
            if j - step >= (nums.count - step)/2 {
                break
            }
            nums.swapAt(j, nums.count-1 - (j-step))
        }
    }

只出现一次

// 只出现一次
    func singleNumber(_ nums: [Int]) -> Int {
        var i = 0
        for index in 0..<nums.count {
            i ^= nums[index]
        }
        return i
    }

交集

// 交集
    func intersect(_ nums1: [Int], _ nums2: [Int]) -> [Int] {
        
        let set1: Set<Int> = Set(nums1)
        let set2: Set<Int> = Set(nums2)
        let setR = set1.intersection(set2)
        let arr = Array(setR)
        return arr
    }

加一

// 加一
    func plusOne(_ digits: [Int]) -> [Int] {
        var digits = digits
        var carray = 1
        for i in (0..<digits.count).reversed() {
            let sum = digits[i] + carray
            digits[i] = sum%10
            carray = sum/10
            if carray == 0 {return digits}
        }
        digits.insert(1, at: 0)
        return digits
    }

移动零

// 移动0 （方法一）
    func moveZeroes(_ nums: inout [Int]) {
        var step = nums.count - 1
        for i in (0...step).reversed() {
            if nums[i] == 0 && i != step {
                let temp = nums[i]
                for index in i...step {
                    if index == step {
                        break
                    }
                    nums[index] = nums[index + 1]
                }
                nums[step] = temp
                step -= 1
            }
        }
    }

// 移动0 （方法二）
    func moveZeroes(_ nums: inout [Int]) {
        var pointer = 0
        var numsOf_0 = 0
        for index in 0..<nums.count {
            if nums[index] != 0 {
                (nums[index], nums[pointer]) = (nums[pointer], nums[index])
                pointer += 1
            } else {
                numsOf_0 += 1
            }
            if index == nums.count - numsOf_0 - 1 {
                break
            }
        }
    }

两数之和

func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
         var dic: [Int: Int] = [:]
        for i in 0..<nums.count {
            if let j = dic[target-nums[i]] {
                return [i, j]
            }
            dic[nums[i]] = i
        }
        return [0]
    }