feat: solve No.1561,1685,2870

Author: BaffinLee

1501-1600/1561. Maximum Number of Coins You Can Get.md

@@ -0,0 +1,91 @@
+# 1561. Maximum Number of Coins You Can Get
+
+- Difficulty: Medium.
+- Related Topics: Array, Math, Greedy, Sorting, Game Theory.
+- Similar Questions: .
+
+## Problem
+
+There are `3n` piles of coins of varying size, you and your friends will take piles of coins as follows:
+
+
+	
+- In each step, you will choose **any **`3` piles of coins (not necessarily consecutive).
+	
+- Of your choice, Alice will pick the pile with the maximum number of coins.
+	
+- You will pick the next pile with the maximum number of coins.
+	
+- Your friend Bob will pick the last pile.
+	
+- Repeat until there are no more piles of coins.
+
+
+Given an array of integers `piles` where `piles[i]` is the number of coins in the `ith` pile.
+
+Return the maximum number of coins that you can have.
+
+ 
+Example 1:
+
+```
+Input: piles = [2,4,1,2,7,8]
+Output: 9
+Explanation: Choose the triplet (2, 7, 8), Alice Pick the pile with 8 coins, you the pile with 7 coins and Bob the last one.
+Choose the triplet (1, 2, 4), Alice Pick the pile with 4 coins, you the pile with 2 coins and Bob the last one.
+The maximum number of coins which you can have are: 7 + 2 = 9.
+On the other hand if we choose this arrangement (1, 2, 8), (2, 4, 7) you only get 2 + 4 = 6 coins which is not optimal.
+```
+
+Example 2:
+
+```
+Input: piles = [2,4,5]
+Output: 4
+```
+
+Example 3:
+
+```
+Input: piles = [9,8,7,6,5,1,2,3,4]
+Output: 18
+```
+
+ 
+**Constraints:**
+
+
+	
+- `3 <= piles.length <= 105`
+	
+- `piles.length % 3 == 0`
+	
+- `1 <= piles[i] <= 104`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} piles
+ * @return {number}
+ */
+var maxCoins = function(piles) {
+    piles.sort((a, b) => a - b);
+    var res = 0;
+    for (var i = 0; i < piles.length / 3; i++) {
+        res += piles[piles.length - (i * 2) - 1 - 1];
+    }
+    return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n * log(n)).
+* Space complexity : O(1).

1601-1700/1685. Sum of Absolute Differences in a Sorted Array.md

@@ -0,0 +1,84 @@
+# 1685. Sum of Absolute Differences in a Sorted Array
+
+- Difficulty: Medium.
+- Related Topics: Array, Math, Prefix Sum.
+- Similar Questions: .
+
+## Problem
+
+You are given an integer array `nums` sorted in **non-decreasing** order.
+
+Build and return **an integer array **`result`** with the same length as **`nums`** such that **`result[i]`** is equal to the **summation of absolute differences** between **`nums[i]`** and all the other elements in the array.**
+
+In other words, `result[i]` is equal to `sum(|nums[i]-nums[j]|)` where `0 <= j < nums.length` and `j != i` (**0-indexed**).
+
+ 
+Example 1:
+
+```
+Input: nums = [2,3,5]
+Output: [4,3,5]
+Explanation: Assuming the arrays are 0-indexed, then
+result[0] = |2-2| + |2-3| + |2-5| = 0 + 1 + 3 = 4,
+result[1] = |3-2| + |3-3| + |3-5| = 1 + 0 + 2 = 3,
+result[2] = |5-2| + |5-3| + |5-5| = 3 + 2 + 0 = 5.
+```
+
+Example 2:
+
+```
+Input: nums = [1,4,6,8,10]
+Output: [24,15,13,15,21]
+```
+
+ 
+**Constraints:**
+
+
+	
+- `2 <= nums.length <= 105`
+	
+- `1 <= nums[i] <= nums[i + 1] <= 104`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var getSumAbsoluteDifferences = function(nums) {
+    var diffLeft = Array(nums.length);
+    for (var i = 0; i < nums.length; i++) {
+        if (i === 0) {
+            diffLeft[i] = 0;
+        } else {
+            diffLeft[i] = diffLeft[i - 1] + (nums[i] - nums[i - 1]) * i;
+        }
+    }
+    var diffRight = Array(nums.length);
+    for (var j = nums.length - 1; j >= 0; j--) {
+        if (j === nums.length - 1) {
+            diffRight[j] = 0;
+        } else {
+            diffRight[j] = diffRight[j + 1] + (nums[j + 1] - nums[j]) * (nums.length - 1 - j);
+        }
+    }
+    var diff = Array(nums.length);
+    for (var k = 0; k < nums.length; k++) {
+        diff[k] = diffLeft[k] + diffRight[k];
+    }
+    return diff;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).

2801-2900/2870. Minimum Number of Operations to Make Array Empty.md

@@ -0,0 +1,87 @@
+# 2870. Minimum Number of Operations to Make Array Empty
+
+- Difficulty: Medium.
+- Related Topics: Array, Hash Table, Greedy, Counting.
+- Similar Questions: .
+
+## Problem
+
+You are given a **0-indexed** array `nums` consisting of positive integers.
+
+There are two types of operations that you can apply on the array **any** number of times:
+
+
+	
+- Choose **two** elements with **equal** values and **delete** them from the array.
+	
+- Choose **three** elements with **equal** values and **delete** them from the array.
+
+
+Return **the **minimum** number of operations required to make the array empty, or **`-1`** if it is not possible**.
+
+ 
+Example 1:
+
+```
+Input: nums = [2,3,3,2,2,4,2,3,4]
+Output: 4
+Explanation: We can apply the following operations to make the array empty:
+- Apply the first operation on the elements at indices 0 and 3. The resulting array is nums = [3,3,2,4,2,3,4].
+- Apply the first operation on the elements at indices 2 and 4. The resulting array is nums = [3,3,4,3,4].
+- Apply the second operation on the elements at indices 0, 1, and 3. The resulting array is nums = [4,4].
+- Apply the first operation on the elements at indices 0 and 1. The resulting array is nums = [].
+It can be shown that we cannot make the array empty in less than 4 operations.
+```
+
+Example 2:
+
+```
+Input: nums = [2,1,2,2,3,3]
+Output: -1
+Explanation: It is impossible to empty the array.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `2 <= nums.length <= 105`
+	
+- `1 <= nums[i] <= 106`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minOperations = function(nums) {
+    var map = {};
+    for (var i = 0; i < nums.length; i++) {
+        var num = nums[i];
+        map[num] = map[num] || 0;
+        map[num] += 1;
+    }
+    var keys = Object.keys(map);
+    var res = 0;
+    for (var j = 0; j < keys.length; j++) {
+        var num = keys[j];
+        if (map[num] === 1) return -1;
+        res += Math.ceil(map[num] / 3);
+    }
+    return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).