Added tasks 3521-3525

Author: javadev

README.md

@@ -2088,6 +2088,11 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3525 |[Find X Value of Array II](src/main/kotlin/g3501_3600/s3525_find_x_value_of_array_ii)| Hard | Array, Math, Segment_Tree | 237 | 50.00
+| 3524 |[Find X Value of Array I](src/main/kotlin/g3501_3600/s3524_find_x_value_of_array_i)| Medium | Array, Dynamic_Programming, Math | 12 | 100.00
+| 3523 |[Make Array Non-decreasing](src/main/kotlin/g3501_3600/s3523_make_array_non_decreasing)| Medium | Array, Greedy, Stack, Monotonic_Stack | 4 | 75.00
+| 3522 |[Calculate Score After Performing Instructions](src/main/kotlin/g3501_3600/s3522_calculate_score_after_performing_instructions)| Medium | Array, String, Hash_Table, Simulation | 3 | 100.00
+| 3521 |[Find Product Recommendation Pairs](src/main/kotlin/g3501_3600/s3521_find_product_recommendation_pairs)| Medium | Database | 611 | 70.71
 | 3519 |[Count Numbers with Non-Decreasing Digits](src/main/kotlin/g3501_3600/s3519_count_numbers_with_non_decreasing_digits)| Hard | String, Dynamic_Programming, Math | 31 | 100.00
 | 3518 |[Smallest Palindromic Rearrangement II](src/main/kotlin/g3501_3600/s3518_smallest_palindromic_rearrangement_ii)| Hard | String, Hash_Table, Math, Counting, Combinatorics | 27 | 100.00
 | 3517 |[Smallest Palindromic Rearrangement I](src/main/kotlin/g3501_3600/s3517_smallest_palindromic_rearrangement_i)| Medium | String, Sorting, Counting_Sort | 49 | 100.00

src/main/kotlin/g0701_0800/s0770_basic_calculator_iv/readme.md

@@ -106,7 +106,7 @@ class Solution {
             return ans
         }
 
-        fun evaluate(vars: Map<String?, Int>): Node {
+        fun evaluate(vars: Map<String, Int>): Node {
             val ans = Node()
             for (cur in mem.keys) {
                 var cnt = mem[cur]!!
@@ -195,14 +195,14 @@ class Solution {
         return a.sub(b)
     }
 
-    fun basicCalculatorIV(expression: String?, evalvarS: Array<String?>?, evalintS: IntArray?): List<String> {
+    fun basicCalculatorIV(expression: String, evalvars: Array<String>, evalints: IntArray): List<String> {
         val ans: List<String> = ArrayList()
-        if (expression.isNullOrEmpty() || evalvarS == null || evalintS == null) {
+        if (expression.isEmpty()) {
             return ans
         }
-        val vars: MutableMap<String?, Int> = HashMap()
-        for (i in evalvarS.indices) {
-            vars[evalvarS[i]] = evalintS[i]
+        val vars: MutableMap<String, Int> = HashMap()
+        for (i in evalvars.indices) {
+            vars[evalvars[i]] = evalints[i]
         }
         val n = expression.length
         val numS = ArrayDeque<Node>()

src/main/kotlin/g1801_1900/s1825_finding_mk_average/readme.md

@@ -70,12 +70,12 @@ class MKAverage(private val capacity: Int, private val boundary: Int) {
                 val count = nums[num]
                 if (skipCount < 0) {
                     sum += num * min(count, numsCount)
-                    numsCount = (numsCount - min(count, numsCount)).toInt()
+                    numsCount = numsCount - min(count, numsCount)
                 } else {
                     skipCount -= count
                     if (skipCount < 0) {
                         sum += num * min(abs(skipCount), numsCount)
-                        numsCount = (numsCount - min(abs(skipCount), numsCount)).toInt()
+                        numsCount = numsCount - min(abs(skipCount), numsCount)
                     }
                 }
                 if (numsCount == 0) {

src/main/kotlin/g2901_3000/s2973_find_number_of_coins_to_place_in_tree_nodes/readme.md

@@ -123,7 +123,6 @@ class Solution {
             val bb = if (pq2.isNotEmpty()) pq2.poll() else 0
             result[i] = max(0, (a.toLong() * b * c))
             result[i] = max(result[i], max(0, (a.toLong() * aa * bb)))
-                .toLong()
             pq = PriorityQueue { x: Int, y: Int -> y - x }
             pq.add(a)
             pq.add(b)

src/main/kotlin/g3101_3200/s3130_find_all_possible_stable_binary_arrays_ii/readme.md

@@ -76,10 +76,9 @@ class Solution {
         }
         var ans: Long = 0
         val s = LongArray(one + 1)
-        val n = (min(zero, one) + 1).toInt()
+        val n = min(zero, one) + 1
         for (
         groups0 in (zero + limit - 1) / limit..min(zero, n)
-            .toInt()
         ) {
             val s0 = calc(groups0, zero, limit)
             for (

src/main/kotlin/g3401_3500/s3429_paint_house_iv/readme.md

@@ -90,7 +90,7 @@ class Solution {
         }
         var ans = Long.Companion.MAX_VALUE
         for (x in longArrayOf(dp0, dp1, dp2, dp3, dp4, dp5)) {
-            ans = min(ans, x).toLong()
+            ans = min(ans, x)
         }
         return ans
     }

src/main/kotlin/g3401_3500/s3468_find_the_number_of_copy_arrays/readme.md

@@ -75,7 +75,7 @@ class Solution {
             val diff = original[i] - original[i - 1]
             low = max((low + diff), bounds[i][0])
             high = min((high + diff), bounds[i][1])
-            ans = min(ans, (high - low + 1)).toInt()
+            ans = min(ans, high - low + 1)
         }
         return max(ans, 0)
     }

src/main/kotlin/g3401_3500/s3480_maximize_subarrays_after_removing_one_conflicting_pair/readme.md

@@ -75,7 +75,7 @@ class Solution {
         f[n + 1] = n + 1
         f[n] = h[n]
         for (i in n - 1 downTo 1) {
-            f[i] = min(h[i], f[i + 1]).toInt()
+            f[i] = min(h[i], f[i + 1])
         }
         // forbiddenCount(x) returns (n - x + 1) if x <= n, else 0.
         // This is the number of forbidden subarrays starting at some i when f[i] = x.
@@ -96,7 +96,7 @@ class Solution {
                 continue
             }
             // Simulate removal: new candidate at j becomes d2[j]
-            val newCandidate = if (j < n) min(d2[j], f[j + 1]).toInt() else d2[j]
+            val newCandidate = if (j < n) min(d2[j], f[j + 1]) else d2[j]
             // We'll recompute the new f values for indices 1..j.
             // Let newF[i] denote the updated value.
             // For i > j, newF[i] remains as original f[i].

src/main/kotlin/g3501_3600/s3521_find_product_recommendation_pairs/readme.md

@@ -0,0 +1,124 @@
+[![](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)
+
+## 3521\. Find Product Recommendation Pairs
+
+Medium
+
+Table: `ProductPurchases`
+
+    +-------------+------+
+    | Column Name | Type |
+    +-------------+------+
+    | user_id     | int  |
+    | product_id  | int  |
+    | quantity    | int  |
+    +-------------+------+
+    (user_id, product_id) is the unique key for this table.
+    Each row represents a purchase of a product by a user in a specific quantity. 
+
+Table: `ProductInfo`
+
+    +-------------+---------+
+    | Column Name | Type    |
+    +-------------+---------+
+    | product_id  | int     |
+    | category    | varchar |
+    | price       | decimal |
+    +-------------+---------+
+    product_id is the primary key for this table. Each row assigns a category and price to a product. 
+
+Amazon wants to implement the **Customers who bought this also bought...** feature based on **co-purchase patterns**. Write a solution to :
+
+1.  Identify **distinct** product pairs frequently **purchased together by the same customers** (where `product1_id` < `product2_id`)
+2.  For **each product pair**, determine how many customers purchased **both** products
+
+**A product pair** is considered for recommendation **if** **at least** `3` **different** customers have purchased **both products**.
+
+Return _the_ _result table ordered by **customer\_count** in **descending** order, and in case of a tie, by_ `product1_id` _in **ascending** order, and then by_ `product2_id` _in **ascending** order_.
+
+The result format is in the following example.
+
+**Example:**
+
+**Input:**
+
+ProductPurchases table:
+
+    +---------+------------+----------+
+    | user_id | product_id | quantity |
+    +---------+------------+----------+
+    | 1       | 101        | 2        |
+    | 1       | 102        | 1        |
+    | 1       | 103        | 3        |
+    | 2       | 101        | 1        |
+    | 2       | 102        | 5        |
+    | 2       | 104        | 1        |
+    | 3       | 101        | 2        |
+    | 3       | 103        | 1        |
+    | 3       | 105        | 4        |
+    | 4       | 101        | 1        |
+    | 4       | 102        | 1        |
+    | 4       | 103        | 2        |
+    | 4       | 104        | 3        |
+    | 5       | 102        | 2        |
+    | 5       | 104        | 1        |
+    +---------+------------+----------+ 
+
+ProductInfo table:
+
+    +------------+-------------+-------+
+    | product_id | category    | price |
+    +------------+-------------+-------+
+    | 101        | Electronics | 100   |
+    | 102        | Books       | 20    |
+    | 103        | Clothing    | 35    |
+    | 104        | Kitchen     | 50    |
+    | 105        | Sports      | 75    |
+    +------------+-------------+-------+ 
+
+**Output:**
+
+    +-------------+-------------+-------------------+-------------------+----------------+
+    | product1_id | product2_id | product1_category | product2_category | customer_count |
+    +-------------+-------------+-------------------+-------------------+----------------+
+    | 101         | 102         | Electronics       | Books             | 3              |
+    | 101         | 103         | Electronics       | Clothing          | 3              |
+    | 102         | 104         | Books             | Kitchen           | 3              |
+    +-------------+-------------+-------------------+-------------------+----------------+ 
+
+**Explanation:**
+
+*   **Product pair (101, 102):**
+    *   Purchased by users 1, 2, and 4 (3 customers)
+    *   Product 101 is in Electronics category
+    *   Product 102 is in Books category
+*   **Product pair (101, 103):**
+    *   Purchased by users 1, 3, and 4 (3 customers)
+    *   Product 101 is in Electronics category
+    *   Product 103 is in Clothing category
+*   **Product pair (102, 104):**
+    *   Purchased by users 2, 4, and 5 (3 customers)
+    *   Product 102 is in Books category
+    *   Product 104 is in Kitchen category
+
+The result is ordered by customer\_count in descending order. For pairs with the same customer\_count, they are ordered by product1\_id and then product2\_id in ascending order.
+
+## Solution
+
+```sql
+# Write your MySQL query statement below
+SELECT
+P1.product_id AS product1_id,
+P2.product_id AS product2_id,
+PI1.category AS product1_category,
+PI2.category AS product2_category,
+COUNT(P1.user_id) AS customer_count
+FROM ProductPurchases P1
+INNER JOIN ProductPurchases P2 ON P1.user_id=P2.user_id AND P1.product_id<P2.product_id
+LEFT JOIN ProductInfo PI1 ON P1.product_id=PI1.product_id
+LEFT JOIN ProductInfo PI2 ON P2.product_id=PI2.product_id
+GROUP BY 1,2,3,4
+HAVING COUNT(P1.user_id)>=3
+ORDER BY customer_count DESC,product1_id,product2_id
+```

src/main/kotlin/g3501_3600/s3522_calculate_score_after_performing_instructions/readme.md

@@ -0,0 +1,96 @@
+[![](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)
+
+## 3522\. Calculate Score After Performing Instructions
+
+Medium
+
+You are given two arrays, `instructions` and `values`, both of size `n`.
+
+You need to simulate a process based on the following rules:
+
+*   You start at the first instruction at index `i = 0` with an initial score of 0.
+*   If `instructions[i]` is `"add"`:
+    *   Add `values[i]` to your score.
+    *   Move to the next instruction `(i + 1)`.
+*   If `instructions[i]` is `"jump"`:
+    *   Move to the instruction at index `(i + values[i])` without modifying your score.
+
+The process ends when you either:
+
+*   Go out of bounds (i.e., `i < 0 or i >= n`), or
+*   Attempt to revisit an instruction that has been previously executed. The revisited instruction is not executed.
+
+Return your score at the end of the process.
+
+**Example 1:**
+
+**Input:** instructions = ["jump","add","add","jump","add","jump"], values = [2,1,3,1,-2,-3]
+
+**Output:** 1
+
+**Explanation:**
+
+Simulate the process starting at instruction 0:
+
+*   At index 0: Instruction is `"jump"`, move to index `0 + 2 = 2`.
+*   At index 2: Instruction is `"add"`, add `values[2] = 3` to your score and move to index 3. Your score becomes 3.
+*   At index 3: Instruction is `"jump"`, move to index `3 + 1 = 4`.
+*   At index 4: Instruction is `"add"`, add `values[4] = -2` to your score and move to index 5. Your score becomes 1.
+*   At index 5: Instruction is `"jump"`, move to index `5 + (-3) = 2`.
+*   At index 2: Already visited. The process ends.
+
+**Example 2:**
+
+**Input:** instructions = ["jump","add","add"], values = [3,1,1]
+
+**Output:** 0
+
+**Explanation:**
+
+Simulate the process starting at instruction 0:
+
+*   At index 0: Instruction is `"jump"`, move to index `0 + 3 = 3`.
+*   At index 3: Out of bounds. The process ends.
+
+**Example 3:**
+
+**Input:** instructions = ["jump"], values = [0]
+
+**Output:** 0
+
+**Explanation:**
+
+Simulate the process starting at instruction 0:
+
+*   At index 0: Instruction is `"jump"`, move to index `0 + 0 = 0`.
+*   At index 0: Already visited. The process ends.
+
+**Constraints:**
+
+*   `n == instructions.length == values.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `instructions[i]` is either `"add"` or `"jump"`.
+*   <code>-10<sup>5</sup> <= values[i] <= 10<sup>5</sup></code>
+
+## Solution
+
+```kotlin
+class Solution {
+    fun calculateScore(instructions: Array<String>, values: IntArray): Long {
+        var ans: Long = 0
+        val seen = BooleanArray(instructions.size)
+        var pos = 0
+        while (pos >= 0 && pos < instructions.size && !seen[pos]) {
+            seen[pos] = true
+            if (instructions[pos][0] == 'a') {
+                ans += values[pos].toLong()
+                pos++
+            } else {
+                pos += values[pos]
+            }
+        }
+        return ans
+    }
+}
+```

src/main/kotlin/g3501_3600/s3523_make_array_non_decreasing/readme.md

@@ -0,0 +1,60 @@
+[![](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)
+
+## 3523\. Make Array Non-decreasing
+
+Medium
+
+You are given an integer array `nums`. In one operation, you can select a subarray and replace it with a single element equal to its **maximum** value.
+
+Return the **maximum possible size** of the array after performing zero or more operations such that the resulting array is **non-decreasing**.
+
+A **subarray** is a contiguous **non-empty** sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [4,2,5,3,5]
+
+**Output:** 3
+
+**Explanation:**
+
+One way to achieve the maximum size is:
+
+1.  Replace subarray `nums[1..2] = [2, 5]` with `5` → `[4, 5, 3, 5]`.
+2.  Replace subarray `nums[2..3] = [3, 5]` with `5` → `[4, 5, 5]`.
+
+The final array `[4, 5, 5]` is non-decreasing with size 3.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** 3
+
+**Explanation:**
+
+No operation is needed as the array `[1,2,3]` is already non-decreasing.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 2 * 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 2 * 10<sup>5</sup></code>
+
+## Solution
+
+```kotlin
+class Solution {
+    fun maximumPossibleSize(nums: IntArray): Int {
+        var res = 0
+        var prev = Int.Companion.MIN_VALUE
+        for (x in nums) {
+            if (x >= prev) {
+                res++
+                prev = x
+            }
+        }
+        return res
+    }
+}
+```