feat: add solutions for lc No.2615 (#5171)

Author: yanglbme

solution/2600-2699/2615.Sum of Distances/README.md

@@ -32,10 +32,10 @@ tags:
 <strong>输入：</strong>nums = [1,3,1,1,2]
 <strong>输出：</strong>[5,0,3,4,0]
 <strong>解释：</strong>
-i = 0 ，nums[0] == nums[2] 且 nums[0] == nums[3] 。因此，arr[0] = |0 - 2| + |0 - 3| = 5 。 
+i = 0 ，nums[0] == nums[2] 且 nums[0] == nums[3] 。因此，arr[0] = |0 - 2| + |0 - 3| = 5 。
 i = 1 ，arr[1] = 0 因为不存在值等于 3 的其他下标。
 i = 2 ，nums[2] == nums[0] 且 nums[2] == nums[3] 。因此，arr[2] = |2 - 0| + |2 - 3| = 3 。
-i = 3 ，nums[3] == nums[0] 且 nums[3] == nums[2] 。因此，arr[3] = |3 - 0| + |3 - 2| = 4 。 
+i = 3 ，nums[3] == nums[0] 且 nums[3] == nums[2] 。因此，arr[3] = |3 - 0| + |3 - 2| = 4 。
 i = 4 ，arr[4] = 0 因为不存在值等于 2 的其他下标。
 </pre>
 
@@ -184,6 +184,73 @@ func distance(nums []int) []int64 {
 }
 ```
 
+#### TypeScript
+
+```ts
+function distance(nums: number[]): number[] {
+    const n = nums.length;
+    const ans = new Array(n).fill(0);
+    const d = new Map<number, number[]>();
+    for (let i = 0; i < n; ++i) {
+        if (!d.has(nums[i])) {
+            d.set(nums[i], []);
+        }
+        d.get(nums[i])!.push(i);
+    }
+    for (const idx of d.values()) {
+        const m = idx.length;
+        let left = 0;
+        let right = -1 * m * idx[0];
+        for (const i of idx) {
+            right += i;
+        }
+        for (let i = 0; i < m; ++i) {
+            ans[idx[i]] = left + right;
+            if (i + 1 < m) {
+                left += (idx[i + 1] - idx[i]) * (i + 1);
+                right -= (idx[i + 1] - idx[i]) * (m - i - 1);
+            }
+        }
+    }
+    return ans;
+};
+```
+
+#### Rust
+
+```rust
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn distance(nums: Vec<i32>) -> Vec<i64> {
+        let n = nums.len();
+        let mut ans = vec![0i64; n];
+        let mut d: HashMap<i32, Vec<usize>> = HashMap::new();
+        for i in 0..n {
+            d.entry(nums[i]).or_insert(Vec::new()).push(i);
+        }
+        for idx in d.values() {
+            let m = idx.len();
+            let mut left = 0i64;
+            let mut right = 0i64;
+            for &i in idx {
+                right += i as i64;
+            }
+            right -= m as i64 * idx[0] as i64;
+            for i in 0..m {
+                ans[idx[i]] = left + right;
+                if i + 1 < m {
+                    let diff = (idx[i + 1] - idx[i]) as i64;
+                    left += diff * (i + 1) as i64;
+                    right -= diff * (m - i - 1) as i64;
+                }
+            }
+        }
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2600-2699/2615.Sum of Distances/README_EN.md

@@ -30,12 +30,12 @@ tags:
 <pre>
 <strong>Input:</strong> nums = [1,3,1,1,2]
 <strong>Output:</strong> [5,0,3,4,0]
-<strong>Explanation:</strong> 
-When i = 0, nums[0] == nums[2] and nums[0] == nums[3]. Therefore, arr[0] = |0 - 2| + |0 - 3| = 5. 
+<strong>Explanation:</strong>
+When i = 0, nums[0] == nums[2] and nums[0] == nums[3]. Therefore, arr[0] = |0 - 2| + |0 - 3| = 5.
 When i = 1, arr[1] = 0 because there is no other index with value 3.
-When i = 2, nums[2] == nums[0] and nums[2] == nums[3]. Therefore, arr[2] = |2 - 0| + |2 - 3| = 3. 
-When i = 3, nums[3] == nums[0] and nums[3] == nums[2]. Therefore, arr[3] = |3 - 0| + |3 - 2| = 4. 
-When i = 4, arr[4] = 0 because there is no other index with value 2. 
+When i = 2, nums[2] == nums[0] and nums[2] == nums[3]. Therefore, arr[2] = |2 - 0| + |2 - 3| = 3.
+When i = 3, nums[3] == nums[0] and nums[3] == nums[2]. Therefore, arr[3] = |3 - 0| + |3 - 2| = 4.
+When i = 4, arr[4] = 0 because there is no other index with value 2.
 
 </pre>
 
@@ -64,7 +64,15 @@ When i = 4, arr[4] = 0 because there is no other index with value 2.
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Hash Map + Prefix Sum
+
+First, use a hash map $d$ to record the list of indices for each element in the array $nums$, that is, $d[x]$ represents the list of all indices in $nums$ where the value is $x$.
+
+For each list of indices $idx$ in the hash map $d$, we can calculate the value of $arr[i]$ for each index $i$ in $idx$. For the first index $idx[0]$, the sum of distances to all indices on the right is $right = \sum_{i=0}^{m-1} - idx[0] \times m$. Then, we iterate through $idx$, and for each iteration, compute $ans[idx[i]] = left + right$, then update $left$ and $right$ as follows: $left = left + (idx[i+1] - idx[i]) \times (i+1)$, and $right = right - (idx[i+1] - idx[i]) \times (m-i-1)$.
+
+After the iteration, we obtain the array $arr$ corresponding to each element in $nums$, which is stored in $ans$.
+
+The time complexity is $O(n)$ and the space complexity is $O(n)$, where $n$ is the length of the array $nums$.
 
 <!-- tabs:start -->
 
@@ -178,6 +186,73 @@ func distance(nums []int) []int64 {
 }
 ```
 
+#### TypeScript
+
+```ts
+function distance(nums: number[]): number[] {
+    const n = nums.length;
+    const ans = new Array(n).fill(0);
+    const d = new Map<number, number[]>();
+    for (let i = 0; i < n; ++i) {
+        if (!d.has(nums[i])) {
+            d.set(nums[i], []);
+        }
+        d.get(nums[i])!.push(i);
+    }
+    for (const idx of d.values()) {
+        const m = idx.length;
+        let left = 0;
+        let right = -1 * m * idx[0];
+        for (const i of idx) {
+            right += i;
+        }
+        for (let i = 0; i < m; ++i) {
+            ans[idx[i]] = left + right;
+            if (i + 1 < m) {
+                left += (idx[i + 1] - idx[i]) * (i + 1);
+                right -= (idx[i + 1] - idx[i]) * (m - i - 1);
+            }
+        }
+    }
+    return ans;
+};
+```
+
+#### Rust
+
+```rust
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn distance(nums: Vec<i32>) -> Vec<i64> {
+        let n = nums.len();
+        let mut ans = vec![0i64; n];
+        let mut d: HashMap<i32, Vec<usize>> = HashMap::new();
+        for i in 0..n {
+            d.entry(nums[i]).or_insert(Vec::new()).push(i);
+        }
+        for idx in d.values() {
+            let m = idx.len();
+            let mut left = 0i64;
+            let mut right = 0i64;
+            for &i in idx {
+                right += i as i64;
+            }
+            right -= m as i64 * idx[0] as i64;
+            for i in 0..m {
+                ans[idx[i]] = left + right;
+                if i + 1 < m {
+                    let diff = (idx[i + 1] - idx[i]) as i64;
+                    left += diff * (i + 1) as i64;
+                    right -= diff * (m - i - 1) as i64;
+                }
+            }
+        }
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2600-2699/2615.Sum of Distances/Solution.rs

@@ -0,0 +1,30 @@
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn distance(nums: Vec<i32>) -> Vec<i64> {
+        let n = nums.len();
+        let mut ans = vec![0i64; n];
+        let mut d: HashMap<i32, Vec<usize>> = HashMap::new();
+        for i in 0..n {
+            d.entry(nums[i]).or_insert(Vec::new()).push(i);
+        }
+        for idx in d.values() {
+            let m = idx.len();
+            let mut left = 0i64;
+            let mut right = 0i64;
+            for &i in idx {
+                right += i as i64;
+            }
+            right -= m as i64 * idx[0] as i64;
+            for i in 0..m {
+                ans[idx[i]] = left + right;
+                if i + 1 < m {
+                    let diff = (idx[i + 1] - idx[i]) as i64;
+                    left += diff * (i + 1) as i64;
+                    right -= diff * (m - i - 1) as i64;
+                }
+            }
+        }
+        ans
+    }
+}

solution/2600-2699/2615.Sum of Distances/Solution.ts

@@ -0,0 +1,27 @@
+function distance(nums: number[]): number[] {
+    const n = nums.length;
+    const ans = new Array(n).fill(0);
+    const d = new Map<number, number[]>();
+    for (let i = 0; i < n; ++i) {
+        if (!d.has(nums[i])) {
+            d.set(nums[i], []);
+        }
+        d.get(nums[i])!.push(i);
+    }
+    for (const idx of d.values()) {
+        const m = idx.length;
+        let left = 0;
+        let right = -1 * m * idx[0];
+        for (const i of idx) {
+            right += i;
+        }
+        for (let i = 0; i < m; ++i) {
+            ans[idx[i]] = left + right;
+            if (i + 1 < m) {
+                left += (idx[i + 1] - idx[i]) * (i + 1);
+                right -= (idx[i + 1] - idx[i]) * (m - i - 1);
+            }
+        }
+    }
+    return ans;
+};