RandomPickByWeight

/*
Given an array w of positive integers, where w[i] describes the weight of index i, write a function pickIndex which randomly picks an index in proportion to its weight.

Note:

1 <= w.length <= 10000
1 <= w[i] <= 10^5
pickIndex will be called at most 10000 times.
Example 1:

Input: 
["Solution","pickIndex"]
[[[1]],[]]
Output: [null,0]
Example 2:

Input: 
["Solution","pickIndex","pickIndex","pickIndex","pickIndex","pickIndex"]
[[[1,3]],[],[],[],[],[]]
Output: [null,0,1,1,1,0]
Explanation of Input Syntax:

The input is two lists: the subroutines called and their arguments. Solution's constructor has one argument, the array w. pickIndex has no arguments. Arguments are always wrapped with a list, even if there aren't any.
*/

class Solution {

    int[] bucketsArray;
    int maxRange;
    
    public Solution(int[] w) {
        
        int len=w.length;
        bucketsArray=new int[len];
        bucketsArray[0]=w[0];
        
        for(int i=1;i<len;i++){
            bucketsArray[i]=bucketsArray[i-1]+w[i];
        }
        maxRange=bucketsArray[len-1];
    }
    
    public int pickIndex() {
        
        Random random=new Random();
        
        int rand=random.nextInt(maxRange)+1;
        
        return binarySearch(rand);
    }
    
    public int binarySearch(int key){
        
        int low=0;
        int high=bucketsArray.length-1;
        
        while(low<=high){
            
            int mid=low+(high-low)/2;
            
            if(bucketsArray[mid]==key) return mid;
            else
            if(bucketsArray[mid]<key) low=mid+1;
            else
            if(bucketsArray[mid]>key) high=mid-1;
        }
        
            return low;
    }
    
}

/**
 * Your Solution object will be instantiated and called as such:
 * Solution obj = new Solution(w);
 * int param_1 = obj.pickIndex();
 */