feat: solve No.1846,1877

Author: BaffinLee

1801-1900/1846. Maximum Element After Decreasing and Rearranging.md

@@ -0,0 +1,98 @@
+# 1846. Maximum Element After Decreasing and Rearranging
+
+- Difficulty: Medium.
+- Related Topics: Array, Greedy, Sorting.
+- Similar Questions: .
+
+## Problem
+
+You are given an array of positive integers `arr`. Perform some operations (possibly none) on `arr` so that it satisfies these conditions:
+
+
+	
+- The value of the **first** element in `arr` must be `1`.
+	
+- The absolute difference between any 2 adjacent elements must be **less than or equal to **`1`. In other words, `abs(arr[i] - arr[i - 1]) <= 1` for each `i` where `1 <= i < arr.length` (**0-indexed**). `abs(x)` is the absolute value of `x`.
+
+
+There are 2 types of operations that you can perform any number of times:
+
+
+	
+- **Decrease** the value of any element of `arr` to a **smaller positive integer**.
+	
+- **Rearrange** the elements of `arr` to be in any order.
+
+
+Return **the **maximum** possible value of an element in **`arr`** after performing the operations to satisfy the conditions**.
+
+ 
+Example 1:
+
+```
+Input: arr = [2,2,1,2,1]
+Output: 2
+Explanation: 
+We can satisfy the conditions by rearranging arr so it becomes [1,2,2,2,1].
+The largest element in arr is 2.
+```
+
+Example 2:
+
+```
+Input: arr = [100,1,1000]
+Output: 3
+Explanation: 
+One possible way to satisfy the conditions is by doing the following:
+1. Rearrange arr so it becomes [1,100,1000].
+2. Decrease the value of the second element to 2.
+3. Decrease the value of the third element to 3.
+Now arr = [1,2,3], which satisfies the conditions.
+The largest element in arr is 3.
+```
+
+Example 3:
+
+```
+Input: arr = [1,2,3,4,5]
+Output: 5
+Explanation: The array already satisfies the conditions, and the largest element is 5.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= arr.length <= 105`
+	
+- `1 <= arr[i] <= 109`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+var maximumElementAfterDecrementingAndRearranging = function(arr) {
+    arr.sort((a, b) => a - b);
+    arr[0] = 1;
+    for (var i = 1 ; i < arr.length; i++) {
+        if (arr[i] - arr[i - 1] <= 1) continue;
+        arr[i] = arr[i - 1] + 1;
+    }
+    return arr[arr.length - 1];
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n * log(n)).
+* Space complexity : O(1).

1801-1900/1877. Minimize Maximum Pair Sum in Array.md

@@ -0,0 +1,84 @@
+# 1877. Minimize Maximum Pair Sum in Array
+
+- Difficulty: Medium.
+- Related Topics: Array, Two Pointers, Greedy, Sorting.
+- Similar Questions: .
+
+## Problem
+
+The **pair sum** of a pair `(a,b)` is equal to `a + b`. The **maximum pair sum** is the largest **pair sum** in a list of pairs.
+
+
+	
+- For example, if we have pairs `(1,5)`, `(2,3)`, and `(4,4)`, the **maximum pair sum** would be `max(1+5, 2+3, 4+4) = max(6, 5, 8) = 8`.
+
+
+Given an array `nums` of **even** length `n`, pair up the elements of `nums` into `n / 2` pairs such that:
+
+
+	
+- Each element of `nums` is in **exactly one** pair, and
+	
+- The **maximum pair sum **is **minimized**.
+
+
+Return **the minimized **maximum pair sum** after optimally pairing up the elements**.
+
+ 
+Example 1:
+
+```
+Input: nums = [3,5,2,3]
+Output: 7
+Explanation: The elements can be paired up into pairs (3,3) and (5,2).
+The maximum pair sum is max(3+3, 5+2) = max(6, 7) = 7.
+```
+
+Example 2:
+
+```
+Input: nums = [3,5,4,2,4,6]
+Output: 8
+Explanation: The elements can be paired up into pairs (3,5), (4,4), and (6,2).
+The maximum pair sum is max(3+5, 4+4, 6+2) = max(8, 8, 8) = 8.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `n == nums.length`
+	
+- `2 <= n <= 105`
+	
+- `n` is **even**.
+	
+- `1 <= nums[i] <= 105`
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minPairSum = function(nums) {
+    nums.sort((a, b) => a - b);
+    var res = 0;
+    for (var i = 0; i < nums.length / 2; i++) {
+        res = Math.max(res, nums[i] + nums[nums.length - i - 1]);
+    }
+    return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n * log(n)).
+* Space complexity : O(1).