Added tasks 2801-2824

Author: javadev

README.md

@@ -1816,6 +1816,19 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 2824 |[Count Pairs Whose Sum is Less than Target](src/main/kotlin/g2801_2900/s2824_count_pairs_whose_sum_is_less_than_target)| Easy | Array, Sorting | s | s
+| 2818 |[Apply Operations to Maximize Score](src/main/kotlin/g2801_2900/s2818_apply_operations_to_maximize_score)| Hard | Array, Math, Greedy, Stack, Monotonic_Stack, Number_Theory | 727 | 100.00
+| 2817 |[Minimum Absolute Difference Between Elements With Constraint](src/main/kotlin/g2801_2900/s2817_minimum_absolute_difference_between_elements_with_constraint)| Medium | Array, Binary_Search, Ordered_Set | 759 | 100.00
+| 2816 |[Double a Number Represented as a Linked List](src/main/kotlin/g2801_2900/s2816_double_a_number_represented_as_a_linked_list)| Medium | Math, Stack, Linked_List | 393 | 100.00
+| 2815 |[Max Pair Sum in an Array](src/main/kotlin/g2801_2900/s2815_max_pair_sum_in_an_array)| Easy | Array, Hash_Table | 223 | 82.35
+| 2813 |[Maximum Elegance of a K-Length Subsequence](src/main/kotlin/g2801_2900/s2813_maximum_elegance_of_a_k_length_subsequence)| Hard | Array, Hash_Table, Sorting, Greedy, Heap_Priority_Queue | 853 | 100.00
+| 2812 |[Find the Safest Path in a Grid](src/main/kotlin/g2801_2900/s2812_find_the_safest_path_in_a_grid)| Medium | Array, Breadth_First_Search, Binary_Search, Matrix, Union_Find | 902 | 100.00
+| 2811 |[Check if it is Possible to Split Array](src/main/kotlin/g2801_2900/s2811_check_if_it_is_possible_to_split_array)| Medium | Array, Dynamic_Programming, Greedy | 180 | 100.00
+| 2810 |[Faulty Keyboard](src/main/kotlin/g2801_2900/s2810_faulty_keyboard)| Easy | String, Simulation | 196 | 91.67
+| 2809 |[Minimum Time to Make Array Sum At Most x](src/main/kotlin/g2801_2900/s2809_minimum_time_to_make_array_sum_at_most_x)| Hard | Array, Dynamic_Programming, Sorting | 325 | 100.00
+| 2808 |[Minimum Seconds to Equalize a Circular Array](src/main/kotlin/g2801_2900/s2808_minimum_seconds_to_equalize_a_circular_array)| Medium | Array, Hash_Table, Greedy | 847 | 50.00
+| 2807 |[Insert Greatest Common Divisors in Linked List](src/main/kotlin/g2801_2900/s2807_insert_greatest_common_divisors_in_linked_list)| Medium | Array, Math, Linked_List | 225 | 67.65
+| 2806 |[Account Balance After Rounded Purchase](src/main/kotlin/g2801_2900/s2806_account_balance_after_rounded_purchase)| Easy | Math | 108 | 100.00
 | 2800 |[Shortest String That Contains Three Strings](src/main/kotlin/g2701_2800/s2800_shortest_string_that_contains_three_strings)| Medium | String, Greedy, Enumeration | 259 | 100.00
 | 2799 |[Count Complete Subarrays in an Array](src/main/kotlin/g2701_2800/s2799_count_complete_subarrays_in_an_array)| Medium | Array, Hash_Table, Sliding_Window | 206 | 96.97
 | 2798 |[Number of Employees Who Met the Target](src/main/kotlin/g2701_2800/s2798_number_of_employees_who_met_the_target)| Easy | Array, Enumeration | 153 | 92.50

src/main/kotlin/g2801_2900/s2806_account_balance_after_rounded_purchase/readme.md

@@ -0,0 +1,49 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 2806\. Account Balance After Rounded Purchase
+
+Easy
+
+Initially, you have a bank account balance of `100` dollars.
+
+You are given an integer `purchaseAmount` representing the amount you will spend on a purchase in dollars.
+
+At the store where you will make the purchase, the purchase amount is rounded to the **nearest multiple** of `10`. In other words, you pay a **non-negative** amount, `roundedAmount`, such that `roundedAmount` is a multiple of `10` and `abs(roundedAmount - purchaseAmount)` is **minimized**.
+
+If there is more than one nearest multiple of `10`, the **largest multiple** is chosen.
+
+Return _an integer denoting your account balance after making a purchase worth_ `purchaseAmount` _dollars from the store._
+
+**Note:** `0` is considered to be a multiple of `10` in this problem.
+
+**Example 1:**
+
+**Input:** purchaseAmount = 9
+
+**Output:** 90
+
+**Explanation:** In this example, the nearest multiple of 10 to 9 is 10. Hence, your account balance becomes 100 - 10 = 90.
+
+**Example 2:**
+
+**Input:** purchaseAmount = 15
+
+**Output:** 80
+
+**Explanation:** In this example, there are two nearest multiples of 10 to 15: 10 and 20. So, the larger multiple, 20, is chosen. Hence, your account balance becomes 100 - 20 = 80.
+
+**Constraints:**
+
+*   `0 <= purchaseAmount <= 100`
+
+## Solution
+
+```kotlin
+class Solution {
+    fun accountBalanceAfterPurchase(purchaseAmount: Int): Int {
+        val x = ((purchaseAmount + 5) / 10.0).toInt() * 10
+        return 100 - x
+    }
+}
+```

src/main/kotlin/g2801_2900/s2807_insert_greatest_common_divisors_in_linked_list/readme.md

@@ -0,0 +1,82 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 2807\. Insert Greatest Common Divisors in Linked List
+
+Medium
+
+Given the head of a linked list `head`, in which each node contains an integer value.
+
+Between every pair of adjacent nodes, insert a new node with a value equal to the **greatest common divisor** of them.
+
+Return _the linked list after insertion_.
+
+The **greatest common divisor** of two numbers is the largest positive integer that evenly divides both numbers.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/07/18/ex1_copy.png)
+
+**Input:** head = [18,6,10,3]
+
+**Output:** [18,6,6,2,10,1,3]
+
+**Explanation:** The 1<sup>st</sup> diagram denotes the initial linked list and the 2<sup>nd</sup> diagram denotes the linked list after inserting the new nodes (nodes in blue are the inserted nodes). 
+
+- We insert the greatest common divisor of 18 and 6 = 6 between the 1<sup>st</sup> and the 2<sup>nd</sup> nodes. 
+- We insert the greatest common divisor of 6 and 10 = 2 between the 2<sup>nd</sup> and the 3<sup>rd</sup> nodes. 
+- We insert the greatest common divisor of 10 and 3 = 1 between the 3<sup>rd</sup> and the 4<sup>th</sup> nodes. 
+
+There are no more adjacent nodes, so we return the linked list.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2023/07/18/ex2_copy1.png)
+
+**Input:** head = [7]
+
+**Output:** [7]
+
+**Explanation:** The 1<sup>st</sup> diagram denotes the initial linked list and the 2<sup>nd</sup> diagram denotes the linked list after inserting the new nodes. There are no pairs of adjacent nodes, so we return the initial linked list.
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range `[1, 5000]`.
+*   `1 <= Node.val <= 1000`
+
+## Solution
+
+```kotlin
+import com_github_leetcode.ListNode
+
+/*
+ * Example:
+ * var li = ListNode(5)
+ * var v = li.`val`
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int) {
+ *     var next: ListNode? = null
+ * }
+ */
+class Solution {
+    fun insertGreatestCommonDivisors(head: ListNode?): ListNode? {
+        var prevNode: ListNode? = null
+        var currNode = head
+        while (currNode != null) {
+            if (prevNode != null) {
+                val gcd = greatestCommonDivisor(prevNode.`val`, currNode.`val`)
+                prevNode.next = ListNode(gcd, currNode)
+            }
+            prevNode = currNode
+            currNode = currNode.next
+        }
+        return head
+    }
+
+    private fun greatestCommonDivisor(val1: Int, val2: Int): Int {
+        return if (val2 == 0) {
+            val1
+        } else greatestCommonDivisor(val2, val1 % val2)
+    }
+}
+```

src/main/kotlin/g2801_2900/s2808_minimum_seconds_to_equalize_a_circular_array/readme.md

@@ -0,0 +1,79 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 2808\. Minimum Seconds to Equalize a Circular Array
+
+Medium
+
+You are given a **0-indexed** array `nums` containing `n` integers.
+
+At each second, you perform the following operation on the array:
+
+*   For every index `i` in the range `[0, n - 1]`, replace `nums[i]` with either `nums[i]`, `nums[(i - 1 + n) % n]`, or `nums[(i + 1) % n]`.
+
+**Note** that all the elements get replaced simultaneously.
+
+Return _the **minimum** number of seconds needed to make all elements in the array_ `nums` _equal_.
+
+**Example 1:**
+
+**Input:** nums = [1,2,1,2]
+
+**Output:** 1
+
+**Explanation:** We can equalize the array in 1 second in the following way: 
+- At 1<sup>st</sup> second, replace values at each index with [nums[3],nums[1],nums[3],nums[3]]. After replacement, nums = [2,2,2,2]. It can be proven that 1 second is the minimum amount of seconds needed for equalizing the array.
+
+**Example 2:**
+
+**Input:** nums = [2,1,3,3,2]
+
+**Output:** 2
+
+**Explanation:** We can equalize the array in 2 seconds in the following way: 
+- At 1<sup>st</sup> second, replace values at each index with [nums[0],nums[2],nums[2],nums[2],nums[3]]. After replacement, nums = [2,3,3,3,3]. 
+- At 2<sup>nd</sup> second, replace values at each index with [nums[1],nums[1],nums[2],nums[3],nums[4]]. After replacement, nums = [3,3,3,3,3]. 
+
+It can be proven that 2 seconds is the minimum amount of seconds needed for equalizing the array.
+
+**Example 3:**
+
+**Input:** nums = [5,5,5,5]
+
+**Output:** 0
+
+**Explanation:** We don't need to perform any operations as all elements in the initial array are the same.
+
+**Constraints:**
+
+*   <code>1 <= n == nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>
+
+## Solution
+
+```kotlin
+import kotlin.math.max
+import kotlin.math.min
+
+class Solution {
+    fun minimumSeconds(nums: List<Int>): Int {
+        val n = nums.size
+        var min = n / 2
+        val hm = HashMap<Int, MutableList<Int>>()
+        for (i in 0 until n) {
+            val v = nums[i]
+            hm.computeIfAbsent(v) { _: Int? -> ArrayList() }.add(i)
+        }
+        for (list in hm.values) {
+            if (list.size > 1) {
+                var curr = (list[0] + n - list[list.size - 1]) / 2
+                for (i in 1 until list.size) {
+                    curr = max(curr.toDouble(), ((list[i] - list[i - 1]) / 2).toDouble()).toInt()
+                }
+                min = min(min.toDouble(), curr.toDouble()).toInt()
+            }
+        }
+        return min
+    }
+}
+```

src/main/kotlin/g2801_2900/s2809_minimum_time_to_make_array_sum_at_most_x/readme.md

@@ -0,0 +1,82 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 2809\. Minimum Time to Make Array Sum At Most x
+
+Hard
+
+You are given two **0-indexed** integer arrays `nums1` and `nums2` of equal length. Every second, for all indices `0 <= i < nums1.length`, value of `nums1[i]` is incremented by `nums2[i]`. **After** this is done, you can do the following operation:
+
+*   Choose an index `0 <= i < nums1.length` and make `nums1[i] = 0`.
+
+You are also given an integer `x`.
+
+Return _the **minimum** time in which you can make the sum of all elements of_ `nums1` _to be **less than or equal** to_ `x`, _or_ `-1` _if this is not possible._
+
+**Example 1:**
+
+**Input:** nums1 = [1,2,3], nums2 = [1,2,3], x = 4
+
+**Output:** 3
+
+**Explanation:**
+
+    For the 1st second, we apply the operation on i = 0. Therefore nums1 = [0,2+2,3+3] = [0,4,6].
+    For the 2nd second, we apply the operation on i = 1. Therefore nums1 = [0+1,0,6+3] = [1,0,9].
+    For the 3rd second, we apply the operation on i = 2. Therefore nums1 = [1+1,0+2,0] = [2,2,0].
+    Now sum of nums1 = 4. It can be shown that these operations are optimal, so we return 3. 
+
+**Example 2:**
+
+**Input:** nums1 = [1,2,3], nums2 = [3,3,3], x = 4
+
+**Output:** -1
+
+**Explanation:** It can be shown that the sum of nums1 will always be greater than x, no matter which operations are performed. 
+
+**Constraints:**
+
+*   <code>1 <= nums1.length <= 10<sup>3</sup></code>
+*   <code>1 <= nums1[i] <= 10<sup>3</sup></code>
+*   <code>0 <= nums2[i] <= 10<sup>3</sup></code>
+*   `nums1.length == nums2.length`
+*   <code>0 <= x <= 10<sup>6</sup></code>
+
+## Solution
+
+```kotlin
+import kotlin.math.max
+
+class Solution {
+    fun minimumTime(nums1: List<Int?>, nums2: List<Int?>, x: Int): Int {
+        val n = nums1.size
+        val nums = Array(n) { IntArray(2) }
+        for (i in 0 until n) {
+            nums[i] = intArrayOf(nums1[i]!!, nums2[i]!!)
+        }
+        nums.sortWith { a: IntArray, b: IntArray -> a[1] - b[1] }
+        val dp = IntArray(n + 1)
+        var sum1: Long = 0
+        var sum2: Long = 0
+        for (i in 0 until n) {
+            sum1 += nums[i][0].toLong()
+            sum2 += nums[i][1].toLong()
+        }
+        if (sum1 <= x) {
+            return 0
+        }
+        for (j in 0 until n) {
+            for (i in j + 1 downTo 1) {
+                dp[i] = max(dp[i].toDouble(), (nums[j][0] + nums[j][1] * i + dp[i - 1]).toDouble())
+                    .toInt()
+            }
+        }
+        for (i in 1..n) {
+            if (sum1 + sum2 * i - dp[i] <= x) {
+                return i
+            }
+        }
+        return -1
+    }
+}
+```