1365_How_Many_Numbers_Are_Smaller_Than_the_Current_Number

qiyuangong · qiyuangong · commit 136d3fbcf8e5 · 2020-03-01T20:03:11.000+08:00
diff --git a/README.md b/README.md
@@ -220,6 +220,7 @@ Also, there are open source implementations for basic data structs and algorithm
 | 1089 | [Duplicate Zeros](https://leetcode.com/problems/duplicate-zeros/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/1089_Duplicate_Zeros.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/1089_Duplicate_Zeros.java) | 2 Pass, store last position and final move steps, O(n) and O(1) |
 | 1260 | [Shift 2D Grid](https://leetcode.com/problems/shift-2d-grid/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/1260_Shift_2D_Grid.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/1260_Shift_2D_Grid.java) | Final position of each element can be computed according to k, m and n, e.g., k == mn, then don't move, O(mn) and O(mn) |
 | 1337 | [The K Weakest Rows in a Matrix](https://leetcode.com/problems/the-k-weakest-rows-in-a-matrix/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/1337_The_K_Weakest_Rows_in_a_Matrix.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/1337_The_K_Weakest_Rows_in_a_Matrix.java) | Check by row, from left to right, until encount first zero, O(mn) and O(1) |
+| 1365 | [How Many Numbers Are Smaller Than the Current Number](https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/1365_How_Many_Numbers_Are_Smaller_Than_the_Current_Number.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/1365_How_Many_Numbers_Are_Smaller_Than_the_Current_Number.java) | 1. Sort and get position in sorted nums, O(nlogn) and O(n)<br>2. Fill count into 0-100, O(n) and O(1) |
 
 | # | To Understand |
 |---| ----- |
diff --git a/java/1365_How_Many_Numbers_Are_Smaller_Than_the_Current_Number.java b/java/1365_How_Many_Numbers_Are_Smaller_Than_the_Current_Number.java
@@ -0,0 +1,34 @@
+import java.util.Map;
+
+class Solution {
+/*     public int[] smallerNumbersThanCurrent(int[] nums) {
+        Map<Integer, Integer> sortedIndex = new HashMap<>();
+        int[] sortedNums = new int[nums.length];
+        // sort and get position
+        System.arraycopy(nums, 0, sortedNums, 0, nums.length);
+        Arrays.sort(sortedNums);
+        for (int i = 0; i < nums.length; i++) {
+            if (sortedIndex.containsKey(sortedNums[i])) continue;
+            sortedIndex.put(sortedNums[i], i);
+        }
+        for (int i = 0; i < nums.length; i++)
+            sortedNums[i] = sortedIndex.get(nums[i]);
+        return sortedNums;
+    } */
+
+    public int[] smallerNumbersThanCurrent(int[] nums) {
+        int[] countList = new int[101];
+        int[] res = new int[nums.length];
+        // count numbers
+        for (int i = 0; i < nums.length; i++)
+            countList[nums[i]]++;
+        // compute numbers before current index
+        for (int i = 1; i < 101; i++)
+            countList[i] += countList[i-1];
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] == 0) res[i] = 0;
+            else res[i] = countList[nums[i]-1];
+        }
+        return res;
+    }
+}
diff --git a/python/1365_How_Many_Numbers_Are_Smaller_Than_the_Current_Number.py b/python/1365_How_Many_Numbers_Are_Smaller_Than_the_Current_Number.py
@@ -0,0 +1,34 @@
+class Solution:
+    # def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:
+    #     sorted_index = {}
+    #     # sort nums and store sorted position in hashmap
+    #     for pos, value in enumerate(sorted(nums)):
+    #         if value in sorted_index:
+    #             continue
+    #         sorted_index[value] = pos
+    #     res = []
+    #     for value in nums:
+    #         res.append(sorted_index[value])
+    #     return res
+    
+    def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:
+        count_list = [0] * 101
+        # count numbers
+        for v in nums:
+            count_list[v] += 1
+        # compute numbers before current index
+        for i in range(1, 101):
+            count_list[i] += count_list[i-1]
+        res = []
+        for v in nums:
+            if v == 0:
+                res.append(0)
+            else:
+                res.append(count_list[v-1])
+        return res
+
+    # def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:
+    #     count = collections.Counter(nums)
+    #     for i in range(1,101):
+    #         count[i] += count[i-1]
+    #     return [count[x-1] for x in nums]
