Added tasks 3657-3661

Author: javadev

README.md

@@ -2088,6 +2088,11 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3661 |[Maximum Walls Destroyed by Robots](src/main/kotlin/g3601_3700/s3661_maximum_walls_destroyed_by_robots)| Hard | Weekly_Contest_464 | 146 | 100.00
+| 3660 |[Jump Game IX](src/main/kotlin/g3601_3700/s3660_jump_game_ix)| Medium | Weekly_Contest_464 | 5 | 100.00
+| 3659 |[Partition Array Into K-Distinct Groups](src/main/kotlin/g3601_3700/s3659_partition_array_into_k_distinct_groups)| Medium | Weekly_Contest_464 | 6 | 100.00
+| 3658 |[GCD of Odd and Even Sums](src/main/kotlin/g3601_3700/s3658_gcd_of_odd_and_even_sums)| Easy | Weekly_Contest_464 | 0 | 100.00
+| 3657 |[Find Loyal Customers](src/main/kotlin/g3601_3700/s3657_find_loyal_customers)| Medium | Database | 297 | 100.00
 | 3655 |[XOR After Range Multiplication Queries II](src/main/kotlin/g3601_3700/s3655_xor_after_range_multiplication_queries_ii)| Hard | Array, Divide_and_Conquer, Weekly_Contest_463 | 26 | 100.00
 | 3654 |[Minimum Sum After Divisible Sum Deletions](src/main/kotlin/g3601_3700/s3654_minimum_sum_after_divisible_sum_deletions)| Medium | Weekly_Contest_463 | 17 | 98.16
 | 3653 |[XOR After Range Multiplication Queries I](src/main/kotlin/g3601_3700/s3653_xor_after_range_multiplication_queries_i)| Medium | Array, Simulation, Divide_and_Conquer, Weekly_Contest_463 | 26 | 100.00

src/main/kotlin/g3601_3700/s3657_find_loyal_customers/readme.md

@@ -0,0 +1,114 @@
+[![](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)
+
+## 3657\. Find Loyal Customers
+
+Medium
+
+Table: `customer_transactions`
+
+    +------------------+---------+
+    | Column Name      | Type    |
+    +------------------+---------+
+    | transaction_id   | int     |
+    | customer_id      | int     |
+    | transaction_date | date    |
+    | amount           | decimal |
+    | transaction_type | varchar |
+    +------------------+---------+
+    transaction_id is the unique identifier for this table. transaction_type can be either 'purchase' or 'refund'. 
+
+Write a solution to find **loyal customers**. A customer is considered **loyal** if they meet ALL the following criteria:
+
+*   Made **at least** `3` purchase transactions.
+*   Have been active for **at least** `30` days.
+*   Their **refund rate** is less than `20%` .
+
+Return _the result table ordered by_ `customer_id` _in **ascending** order_.
+
+The result format is in the following example.
+
+**Example:**
+
+**Input:**
+
+customer\_transactions table:
+
+    +----------------+-------------+------------------+--------+------------------+
+    | transaction_id | customer_id | transaction_date | amount | transaction_type |
+    |----------------|-------------|------------------|--------|------------------|
+    | 1              | 101         | 2024-01-05       | 150.00 | purchase         |
+    | 2              | 101         | 2024-01-15       | 200.00 | purchase         |
+    | 3              | 101         | 2024-02-10       | 180.00 | purchase         |
+    | 4              | 101         | 2024-02-20       | 250.00 | purchase         |
+    | 5              | 102         | 2024-01-10       | 100.00 | purchase         |
+    | 6              | 102         | 2024-01-12       | 120.00 | purchase         |
+    | 7              | 102         | 2024-01-15       | 80.00  | refund           |
+    | 8              | 102         | 2024-01-18       | 90.00  | refund           |
+    | 9              | 102         | 2024-02-15       | 130.00 | purchase         |
+    | 10             | 103         | 2024-01-01       | 500.00 | purchase         |
+    | 11             | 103         | 2024-01-02       | 450.00 | purchase         |
+    | 12             | 103         | 2024-01-03       | 400.00 | purchase         |
+    | 13             | 104         | 2024-01-01       | 200.00 | purchase         |
+    | 14             | 104         | 2024-02-01       | 250.00 | purchase         |
+    | 15             | 104         | 2024-02-15       | 300.00 | purchase         |
+    | 16             | 104         | 2024-03-01       | 350.00 | purchase         |
+    | 17             | 104         | 2024-03-10       | 280.00 | purchase         |
+    | 18             | 104         | 2024-03-15       | 100.00 | refund           |
+    +----------------+-------------+------------------+--------+------------------+
+
+
+**Output:**
+
+    +-------------+
+    | customer_id |
+    |-------------|
+    | 101         |
+    | 104         |
+    +-------------+
+
+**Explanation:**
+
+*   **Customer 101**:
+    *   Purchase transactions: 4 (IDs: 1, 2, 3, 4)
+    *   Refund transactions: 0
+    *   Refund rate: 0/4 = 0% (less than 20%)
+    *   Active period: Jan 5 to Feb 20 = 46 days (at least 30 days)
+    *   Qualifies as loyal
+*   **Customer 102**:
+    *   Purchase transactions: 3 (IDs: 5, 6, 9)
+    *   Refund transactions: 2 (IDs: 7, 8)
+    *   Refund rate: 2/5 = 40% (exceeds 20%)
+    *   Not loyal
+*   **Customer 103**:
+    *   Purchase transactions: 3 (IDs: 10, 11, 12)
+    *   Refund transactions: 0
+    *   Refund rate: 0/3 = 0% (less than 20%)
+    *   Active period: Jan 1 to Jan 3 = 2 days (less than 30 days)
+    *   Not loyal
+*   **Customer 104**:
+    *   Purchase transactions: 5 (IDs: 13, 14, 15, 16, 17)
+    *   Refund transactions: 1 (ID: 18)
+    *   Refund rate: 1/6 = 16.67% (less than 20%)
+    *   Active period: Jan 1 to Mar 15 = 73 days (at least 30 days)
+    *   Qualifies as loyal
+
+The result table is ordered by customer\_id in ascending order.
+
+## Solution
+
+```sql
+# Write your MySQL query statement below
+SELECT 
+    customer_id
+FROM 
+    customer_transactions
+GROUP BY 
+    customer_id
+HAVING 
+    COUNT(CASE WHEN transaction_type = 'purchase' THEN 1 END) > 2
+    AND TIMESTAMPDIFF(DAY, MIN(transaction_date), MAX(transaction_date)) > 29
+    AND (COUNT(CASE WHEN transaction_type = 'refund' THEN 1 END) * 1.0 / COUNT(*)) < 0.2
+ORDER BY 
+    customer_id ASC;
+```

src/main/kotlin/g3601_3700/s3658_gcd_of_odd_and_even_sums/readme.md

@@ -0,0 +1,55 @@
+[![](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)
+
+## 3658\. GCD of Odd and Even Sums
+
+Easy
+
+You are given an integer `n`. Your task is to compute the **GCD** (greatest common divisor) of two values:
+
+*   `sumOdd`: the sum of the first `n` odd numbers.
+    
+*   `sumEven`: the sum of the first `n` even numbers.
+    
+
+Return the GCD of `sumOdd` and `sumEven`.
+
+**Example 1:**
+
+**Input:** n = 4
+
+**Output:** 4
+
+**Explanation:**
+
+*   Sum of the first 4 odd numbers `sumOdd = 1 + 3 + 5 + 7 = 16`
+*   Sum of the first 4 even numbers `sumEven = 2 + 4 + 6 + 8 = 20`
+
+Hence, `GCD(sumOdd, sumEven) = GCD(16, 20) = 4`.
+
+**Example 2:**
+
+**Input:** n = 5
+
+**Output:** 5
+
+**Explanation:**
+
+*   Sum of the first 5 odd numbers `sumOdd = 1 + 3 + 5 + 7 + 9 = 25`
+*   Sum of the first 5 even numbers `sumEven = 2 + 4 + 6 + 8 + 10 = 30`
+
+Hence, `GCD(sumOdd, sumEven) = GCD(25, 30) = 5`.
+
+**Constraints:**
+
+*   `1 <= n <= 1000`
+
+## Solution
+
+```kotlin
+class Solution {
+    fun gcdOfOddEvenSums(n: Int): Int {
+        return if (n < 0) -n else n
+    }
+}
+```

src/main/kotlin/g3601_3700/s3659_partition_array_into_k_distinct_groups/readme.md

@@ -0,0 +1,88 @@
+[![](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)
+
+## 3659\. Partition Array Into K-Distinct Groups
+
+Medium
+
+You are given an integer array `nums` and an integer `k`.
+
+Your task is to determine whether it is possible to partition all elements of `nums` into one or more groups such that:
+
+*   Each group contains **exactly** `k` **distinct** elements.
+*   Each element in `nums` must be assigned to **exactly** one group.
+
+Return `true` if such a partition is possible, otherwise return `false`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4], k = 2
+
+**Output:** true
+
+**Explanation:**
+
+One possible partition is to have 2 groups:
+
+*   Group 1: `[1, 2]`
+*   Group 2: `[3, 4]`
+
+Each group contains `k = 2` distinct elements, and all elements are used exactly once.
+
+**Example 2:**
+
+**Input:** nums = [3,5,2,2], k = 2
+
+**Output:** true
+
+**Explanation:**
+
+One possible partition is to have 2 groups:
+
+*   Group 1: `[2, 3]`
+*   Group 2: `[2, 5]`
+
+Each group contains `k = 2` distinct elements, and all elements are used exactly once.
+
+**Example 3:**
+
+**Input:** nums = [1,5,2,3], k = 3
+
+**Output:** false
+
+**Explanation:**
+
+We cannot form groups of `k = 3` distinct elements using all values exactly once.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>
+*   `1 <= k <= nums.length`
+
+## Solution
+
+```kotlin
+import kotlin.math.max
+
+class Solution {
+    fun partitionArray(nums: IntArray, k: Int): Boolean {
+        val n = nums.size
+        if (n % k != 0) {
+            return false
+        }
+        var max = 0
+        for (x in nums) {
+            max = max(max, x)
+        }
+        val count = IntArray(max + 1)
+        val limit = n / k
+        for (x in nums) {
+            if (++count[x] > limit) {
+                return false
+            }
+        }
+        return true
+    }
+}
+```

src/main/kotlin/g3601_3700/s3660_jump_game_ix/readme.md

@@ -0,0 +1,76 @@
+[![](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)
+
+## 3660\. Jump Game IX
+
+Medium
+
+You are given an integer array `nums`.
+
+From any index `i`, you can jump to another index `j` under the following rules:
+
+*   Jump to index `j` where `j > i` is allowed only if `nums[j] < nums[i]`.
+*   Jump to index `j` where `j < i` is allowed only if `nums[j] > nums[i]`.
+
+For each index `i`, find the **maximum** **value** in `nums` that can be reached by following **any** sequence of valid jumps starting at `i`.
+
+Return an array `ans` where `ans[i]` is the **maximum** **value** reachable starting from index `i`.
+
+**Example 1:**
+
+**Input:** nums = [2,1,3]
+
+**Output:** [2,2,3]
+
+**Explanation:**
+
+*   For `i = 0`: No jump increases the value.
+*   For `i = 1`: Jump to `j = 0` as `nums[j] = 2` is greater than `nums[i]`.
+*   For `i = 2`: Since `nums[2] = 3` is the maximum value in `nums`, no jump increases the value.
+
+Thus, `ans = [2, 2, 3]`.
+
+**Example 2:**
+
+**Input:** nums = [2,3,1]
+
+**Output:** [3,3,3]
+
+**Explanation:**
+
+*   For `i = 0`: Jump forward to `j = 2` as `nums[j] = 1` is less than `nums[i] = 2`, then from `i = 2` jump to `j = 1` as `nums[j] = 3` is greater than `nums[2]`.
+*   For `i = 1`: Since `nums[1] = 3` is the maximum value in `nums`, no jump increases the value.
+*   For `i = 2`: Jump to `j = 1` as `nums[j] = 3` is greater than `nums[2] = 1`.
+
+Thus, `ans = [3, 3, 3]`.
+
+**Constraints:**
+
+*   <code>1 <= 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 maxValue(nums: IntArray): IntArray {
+        val f = IntArray(nums.size)
+        var cur = 0
+        for (i in nums.indices) {
+            cur = max(cur, nums[i])
+            f[i] = cur
+        }
+        var min = nums[nums.size - 1]
+        for (i in nums.size - 2 downTo 0) {
+            if (f[i] > min) {
+                f[i] = max(f[i], f[i + 1])
+            }
+            min = min(min, nums[i])
+        }
+        return f
+    }
+}
+```