feat: add solutions to lc problem: No.0327

No.0327.Count of Range Sum

Author: yanglbme

solution/0300-0399/0327.Count of Range Sum/README.md

@@ -44,22 +44,105 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+离散化。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class Solution:
+    def arrayRankTransform(self, arr: List[int]) -> List[int]:
+        def find(x):
+            left, right = 0, len(t) - 1
+            while left < right:
+                mid = (left + right) >> 1
+                if t[mid] >= x:
+                    right = mid
+                else:
+                    left = mid + 1
+            return left + 1
+
+        t = sorted(set(arr))
+        return [find(x) for x in arr]
+```
 
+```python
+class Solution:
+    def arrayRankTransform(self, arr: List[int]) -> List[int]:
+        m = {v: i for i, v in enumerate(sorted(set(arr)), 1)}
+        return [m[v] for v in arr]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int[] arrayRankTransform(int[] arr) {
+        Set<Integer> s = new HashSet<>();
+        for (int v : arr) {
+            s.add(v);
+        }
+        List<Integer> alls = new ArrayList<>(s);
+        alls.sort((a, b) -> a - b);
+        Map<Integer, Integer> m = new HashMap<>();
+        for (int i = 0; i < alls.size(); ++i) {
+            m.put(alls.get(i), i + 1);
+        }
+        int[] ans = new int[arr.length];
+        for (int i = 0; i < arr.length; ++i) {
+            ans[i] = m.get(arr[i]);
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> arrayRankTransform(vector<int>& arr) {
+        unordered_set<int> s(arr.begin(), arr.end());
+        vector<int> alls(s.begin(), s.end());
+        sort(alls.begin(), alls.end());
+        unordered_map<int, int> m;
+        for (int i = 0; i < alls.size(); ++i) m[alls[i]] = i + 1;
+        vector<int> ans;
+        for (int v : arr) ans.push_back(m[v]);
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func arrayRankTransform(arr []int) []int {
+	s := make(map[int]bool)
+	for _, v := range arr {
+		s[v] = true
+	}
+	var alls []int
+	for v := range s {
+		alls = append(alls, v)
+	}
+	sort.Ints(alls)
+	m := make(map[int]int)
+	for i, v := range alls {
+		m[v] = i + 1
+	}
+	var ans []int
+	for _, v := range arr {
+		ans = append(ans, m[v])
+	}
+	return ans
+}
 ```
 
 ### **...**

solution/0300-0399/0327.Count of Range Sum/README_EN.md

@@ -43,13 +43,94 @@
 ### **Python3**
 
 ```python
+class Solution:
+    def arrayRankTransform(self, arr: List[int]) -> List[int]:
+        def find(x):
+            left, right = 0, len(t) - 1
+            while left < right:
+                mid = (left + right) >> 1
+                if t[mid] >= x:
+                    right = mid
+                else:
+                    left = mid + 1
+            return left + 1
+
+        t = sorted(set(arr))
+        return [find(x) for x in arr]
+```
 
+```python
+class Solution:
+    def arrayRankTransform(self, arr: List[int]) -> List[int]:
+        m = {v: i for i, v in enumerate(sorted(set(arr)), 1)}
+        return [m[v] for v in arr]
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int[] arrayRankTransform(int[] arr) {
+        Set<Integer> s = new HashSet<>();
+        for (int v : arr) {
+            s.add(v);
+        }
+        List<Integer> alls = new ArrayList<>(s);
+        alls.sort((a, b) -> a - b);
+        Map<Integer, Integer> m = new HashMap<>();
+        for (int i = 0; i < alls.size(); ++i) {
+            m.put(alls.get(i), i + 1);
+        }
+        int[] ans = new int[arr.length];
+        for (int i = 0; i < arr.length; ++i) {
+            ans[i] = m.get(arr[i]);
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> arrayRankTransform(vector<int>& arr) {
+        unordered_set<int> s(arr.begin(), arr.end());
+        vector<int> alls(s.begin(), s.end());
+        sort(alls.begin(), alls.end());
+        unordered_map<int, int> m;
+        for (int i = 0; i < alls.size(); ++i) m[alls[i]] = i + 1;
+        vector<int> ans;
+        for (int v : arr) ans.push_back(m[v]);
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func arrayRankTransform(arr []int) []int {
+	s := make(map[int]bool)
+	for _, v := range arr {
+		s[v] = true
+	}
+	var alls []int
+	for v := range s {
+		alls = append(alls, v)
+	}
+	sort.Ints(alls)
+	m := make(map[int]int)
+	for i, v := range alls {
+		m[v] = i + 1
+	}
+	var ans []int
+	for _, v := range arr {
+		ans = append(ans, m[v])
+	}
+	return ans
+}
 ```
 
 ### **...**

solution/0300-0399/0327.Count of Range Sum/Solution.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+    vector<int> arrayRankTransform(vector<int>& arr) {
+        unordered_set<int> s(arr.begin(), arr.end());
+        vector<int> alls(s.begin(), s.end());
+        sort(alls.begin(), alls.end());
+        unordered_map<int, int> m;
+        for (int i = 0; i < alls.size(); ++i) m[alls[i]] = i + 1;
+        vector<int> ans;
+        for (int v : arr) ans.push_back(m[v]);
+        return ans;
+    }
+};

solution/0300-0399/0327.Count of Range Sum/Solution.go

@@ -0,0 +1,20 @@
+func arrayRankTransform(arr []int) []int {
+	s := make(map[int]bool)
+	for _, v := range arr {
+		s[v] = true
+	}
+	var alls []int
+	for v := range s {
+		alls = append(alls, v)
+	}
+	sort.Ints(alls)
+	m := make(map[int]int)
+	for i, v := range alls {
+		m[v] = i + 1
+	}
+	var ans []int
+	for _, v := range arr {
+		ans = append(ans, m[v])
+	}
+	return ans
+}

solution/0300-0399/0327.Count of Range Sum/Solution.java

@@ -0,0 +1,19 @@
+class Solution {
+    public int[] arrayRankTransform(int[] arr) {
+        Set<Integer> s = new HashSet<>();
+        for (int v : arr) {
+            s.add(v);
+        }
+        List<Integer> alls = new ArrayList<>(s);
+        alls.sort((a, b) -> a - b);
+        Map<Integer, Integer> m = new HashMap<>();
+        for (int i = 0; i < alls.size(); ++i) {
+            m.put(alls.get(i), i + 1);
+        }
+        int[] ans = new int[arr.length];
+        for (int i = 0; i < arr.length; ++i) {
+            ans[i] = m.get(arr[i]);
+        }
+        return ans;
+    }
+}