feat: add solutions to lc problem: No.1636

No.1636.Sort Array by Increasing Frequency

Author: YangFong

solution/1600-1699/1636.Sort Array by Increasing Frequency/README.md

@@ -125,6 +125,40 @@ func frequencySort(nums []int) []int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function frequencySort(nums: number[]): number[] {
+    const map = new Map<number, number>();
+    for (const num of nums) {
+        map.set(num, (map.get(num) ?? 0) + 1);
+    }
+    return nums.sort((a, b) => map.get(a) - map.get(b) || b - a);
+}
+```
+
+### **Rust**
+
+```rust
+use std::collections::HashMap;
+impl Solution {
+    pub fn frequency_sort(mut nums: Vec<i32>) -> Vec<i32> {
+        let n = nums.len();
+        let mut map = HashMap::new();
+        for &num in nums.iter() {
+            *map.entry(num).or_insert(0) += 1;
+        }
+        nums.sort_by(|a, b| {
+            if map.get(a) == map.get(b) {
+                return b.cmp(a);
+            }
+            map.get(a).cmp(&map.get(b))
+        });
+        nums
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1600-1699/1636.Sort Array by Increasing Frequency/README_EN.md

@@ -110,6 +110,40 @@ func frequencySort(nums []int) []int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function frequencySort(nums: number[]): number[] {
+    const map = new Map<number, number>();
+    for (const num of nums) {
+        map.set(num, (map.get(num) ?? 0) + 1);
+    }
+    return nums.sort((a, b) => map.get(a) - map.get(b) || b - a);
+}
+```
+
+### **Rust**
+
+```rust
+use std::collections::HashMap;
+impl Solution {
+    pub fn frequency_sort(mut nums: Vec<i32>) -> Vec<i32> {
+        let n = nums.len();
+        let mut map = HashMap::new();
+        for &num in nums.iter() {
+            *map.entry(num).or_insert(0) += 1;
+        }
+        nums.sort_by(|a, b| {
+            if map.get(a) == map.get(b) {
+                return b.cmp(a);
+            }
+            map.get(a).cmp(&map.get(b))
+        });
+        nums
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1600-1699/1636.Sort Array by Increasing Frequency/Solution.rs

@@ -0,0 +1,17 @@
+use std::collections::HashMap;
+impl Solution {
+    pub fn frequency_sort(mut nums: Vec<i32>) -> Vec<i32> {
+        let n = nums.len();
+        let mut map = HashMap::new();
+        for &num in nums.iter() {
+            *map.entry(num).or_insert(0) += 1;
+        }
+        nums.sort_by(|a, b| {
+            if map.get(a) == map.get(b) {
+                return b.cmp(a);
+            }
+            map.get(a).cmp(&map.get(b))
+        });
+        nums
+    }
+}

solution/1600-1699/1636.Sort Array by Increasing Frequency/Solution.ts

@@ -0,0 +1,7 @@
+function frequencySort(nums: number[]): number[] {
+    const map = new Map<number, number>();
+    for (const num of nums) {
+        map.set(num, (map.get(num) ?? 0) + 1);
+    }
+    return nums.sort((a, b) => map.get(a) - map.get(b) || b - a);
+}