Feb 2 and added hint

Author: aliasvishnu

README.md

@@ -89,6 +89,7 @@ Solutions <a href = "https://github.com/aliasvishnu/leetcode/tree/master/Solutio
 | 150 | Stack | Use stack to store operands and whenever operator is seen, evaluate. Use stoi() to convert string to number. | O(n) |
 | 152 | Array | Maintain max and min values while iterating through the array. If A[i] is -ve, then swap max and min, as min is now a candidate to become max (after multiplying). While multiplying with A[i], only multiply if it can increase max or decrease min. If it cannot, then that subarray ends there and must start with A[i]. | O(n) |
 | 161 | BF | When there is mismatch, check if A[i+1:] == B[j:], A[i+1:] == B[j+1:], A[i:] == B[j+1:]. | O(n) |
+| 164 | Bucketing | Try to bucket numbers b/w min and max with gap = ceil(max-min / n-1). This way minimum gap is atleast according to the formula. If the numbers are in the same bucket then they cannot form the answer. So for every bucket you only have to maintain the min and max, compare max[i-1] with min[i] for all i, as they would be consecutive in the final sorting order. Note that maybe you can't place largest number inside some bucket, so keep an extra check later. | O(n) |
 | 168 | BF | If n <= 26, then this is easy. Otherwise it is F(n) = F(n/26)+ (char)n%26; something like this. Calculate the exact relation. | O(log(n)) |
 | 169 | Array | Assume A[0] is the majority element i.e. curmax = 0, whenever A[i] != A[curmax], reduce the count, if the count becomes -ve at any point, set curmax = i. Idea is that we are cancelling all non-equal elements, if some element occurs more than half times, then in the end curmax should point to that element. | O(n) |
 | 172 | Math | [n/5] + [n/25] + [n/125] and so on .. where [] is floor operator. | O(log(n))|

Solutions/*164-MaximumGap.cpp

@@ -0,0 +1,38 @@
+#include <math.h>
+class Solution {
+public:
+    int maximumGap(vector<int>& nums) {
+        int len = nums.size();
+
+        if(len < 2) return 0;
+
+        vector<int> mins (len, INT_MAX);
+        vector<int> maxs (len, INT_MIN);
+
+        int mn = *min_element(nums.begin(), nums.end());
+        int mx = *max_element(nums.begin(), nums.end());
+
+        int gap = ceil( (mx - mn)*1.0 / (len-1) );
+
+        for(int i: nums){
+            if(i == mn || i == mx) continue;
+
+            int ind = (i - mn)/gap;
+
+            mins[ind] = (mins[ind] < i)? mins[ind]: i;
+            maxs[ind] = (maxs[ind] > i)? maxs[ind]: i;
+        }
+
+        int prev = mn, answer = 0;
+
+        for(int i = 0; i < len-1; i++){
+            if(mins[i] == INT_MAX) continue;
+
+            answer = max(answer, mins[i]-prev);
+            prev = maxs[i];
+        }
+
+        answer = max(answer, mx-prev);
+        return answer;
+    }
+};