[Swift]LeetCode398. 随机数索引 | Random Pick Index

原文地址：https://www.cnblogs.com/strengthen/p/10306011.html 

Given an array of integers with possible duplicates, randomly output the index of a given target number. You can assume that the given target number must exist in the array.

Note:
The array size can be very large. Solution that uses too much extra space will not pass the judge.

Example:

int[] nums = new int[] {1,2,3,3,3};
Solution solution = new Solution(nums);

// pick(3) should return either index 2, 3, or 4 randomly. Each index should have equal probability of returning.
solution.pick(3);

// pick(1) should return 0. Since in the array only nums[0] is equal to 1.
solution.pick(1);

---

给定一个可能含有重复元素的整数数组，要求随机输出给定的数字的索引。 您可以假设给定的数字一定存在于数组中。

注意：
数组大小可能非常大。 使用太多额外空间的解决方案将不会通过测试。

示例:

int[] nums = new int[] {1,2,3,3,3};
Solution solution = new Solution(nums);

// pick(3) 应该返回索引 2,3 或者 4。每个索引的返回概率应该相等。
solution.pick(3);

// pick(1) 应该返回 0。因为只有nums[0]等于1。
solution.pick(1);

---

792ms

class Solution {
    var v:[Int] = [Int]()

    init(_ nums: [Int]) {
        v = nums
    }
    
    func pick(_ target: Int) -> Int {
        var cnt:Int = 0
        var res:Int = -1
        for i in 0..<v.count
        {
            if v[i] != target {continue}
            cnt += 1
            if Int.random(in: 0...Int.max) % cnt == 0 
            {
                res = i
            }
        }
        return res      
    }
}

/**
 * Your Solution object will be instantiated and called as such:
 * let obj = Solution(nums)
 * let ret_1: Int = obj.pick(target)
 */
 

---

824ms

class Solution {

    let nums: [Int]
    let numSize: Int
    
    init(_ nums: [Int]) {
        self.nums = nums
        numSize = nums.count
    }
    
    func pick(_ target: Int) -> Int {
        for i in 0..<numSize {
            let idx = Int.random(in: 0..<numSize-i) + i
            if nums[idx] == target {
                return idx
            }
            if nums[i] == target {
                return i
            }
        }
        
        return 0
    }
}

---

916ms

class Solution {
    var map:[Int: [Int]] = [:]
    
    init(_ nums: [Int]) {
        map = [:]
        for i in 0 ..< nums.count {
            var array = map[nums[i]]
            if array == nil {
                array = []
            }
            array!.append(i)
            map[nums[i]] = array
        }
    }
    
    func pick(_ target: Int) -> Int {
        if let array = map[target] {
            let size = array.count
            let r = Int.random(in: 0 ..< size)
            return array[r]
        }
        return -1
    }
}

---

940ms

class Solution {
    var d: [Int: [Int]] = [:]

    init(_ nums: [Int]) {
        for (i, num) in nums.enumerated() {
            if let some = d[num] {
                d[num] = some + [i]
            } else {
                d[num] = [i]
            }
        }
    }
    
    func pick(_ target: Int) -> Int {
        let arr = d[target]!
        var randI = Int.random(in: 0..<arr.count)
        return arr[randI]
    }
}

---

952ms

class Solution {
    
    private let numsIndices: [Int: [Int]]

    init(_ nums: [Int]) {
        var idxMap = [Int: [Int]]()
        for (offset, num) in nums.enumerated() {
            if idxMap[num] == nil { idxMap[num] = [Int]() }
            idxMap[num]?.append(offset)
        }
        numsIndices = idxMap
    }
    
    func pick(_ target: Int) -> Int {
        return numsIndices[target]!.randomElement()!
    }
}

---

1020ms

class Solution {

    var mapping = [Int: [Int]]()//key is the number, value is the index array
    init(_ nums: [Int]) {
        for i in 0..<nums.count{
            if var indexArray = mapping[nums[i]]{
                indexArray.append(i)
                mapping[nums[i]] =  indexArray
            } else{
                mapping[nums[i]] = [i]
            }
        }
    }
    
    func pick(_ target: Int) -> Int {
        if let indexArray = mapping[target]{
            return indexArray.randomElement()!
        }
        return -1      
    }
}

---

1172ms

class Solution {
    
    var nums: [Int]
    
    init(_ nums: [Int]) {
        self.nums = nums
    }
    
    func pick(_ target: Int) -> Int {
        let array = self.nums.enumerated().shuffled()
        for i in stride(from: 0, to: array.count, by: 1) {
            if i >= array.count {
                return -1
            }
            if array[i].element == target {
                print(array[i].offset)
                return array[i].offset
            }
        }
        return -1 
    }
}