Added tasks 3587-3594

Author: javadev

README.md

@@ -2088,6 +2088,15 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3594 |[Minimum Time to Transport All Individuals](src/main/kotlin/g3501_3600/s3594_minimum_time_to_transport_all_individuals)| Hard | Array, Dynamic_Programming, Bit_Manipulation, Heap_Priority_Queue, Graph, Bitmask, Shortest_Path | 213 | 100.00
+| 3593 |[Minimum Increments to Equalize Leaf Paths](src/main/kotlin/g3501_3600/s3593_minimum_increments_to_equalize_leaf_paths)| Medium | Array, Dynamic_Programming, Depth_First_Search, Tree | 37 | 100.00
+| 3592 |[Inverse Coin Change](src/main/kotlin/g3501_3600/s3592_inverse_coin_change)| Easy | Array, Dynamic_Programming | 2 | 100.00
+| 3591 |[Check if Any Element Has Prime Frequency](src/main/kotlin/g3501_3600/s3591_check_if_any_element_has_prime_frequency)| Easy | Array, Hash_Table, Math, Counting, Number_Theory | 1 | 100.00
+| 3590 |[Kth Smallest Path XOR Sum](src/main/kotlin/g3501_3600/s3590_kth_smallest_path_xor_sum)| Hard | Array, Depth_First_Search, Tree, Ordered_Set | 395 | 100.00
+| 3589 |[Count Prime-Gap Balanced Subarrays](src/main/kotlin/g3501_3600/s3589_count_prime_gap_balanced_subarrays)| Medium | Array, Math, Sliding_Window, Queue, Number_Theory, Monotonic_Queue | 341 | 100.00
+| 3588 |[Find Maximum Area of a Triangle](src/main/kotlin/g3501_3600/s3588_find_maximum_area_of_a_triangle)| Medium | Array, Hash_Table, Math, Greedy, Enumeration, Geometry | 470 | 100.00
+| 3587 |[Minimum Adjacent Swaps to Alternate Parity](src/main/kotlin/g3501_3600/s3587_minimum_adjacent_swaps_to_alternate_parity)| Medium | Array, Greedy | 38 | 100.00
+| 3586 |[Find COVID Recovery Patients](src/main/kotlin/g3501_3600/s3586_find_covid_recovery_patients)| Medium | Database | 471 | 97.17
 | 3585 |[Find Weighted Median Node in Tree](src/main/kotlin/g3501_3600/s3585_find_weighted_median_node_in_tree)| Hard | Array, Dynamic_Programming, Tree, Binary_Search, Depth_First_Search | 123 | 100.00
 | 3584 |[Maximum Product of First and Last Elements of a Subsequence](src/main/kotlin/g3501_3600/s3584_maximum_product_of_first_and_last_elements_of_a_subsequence)| Medium | Array, Two_Pointers | 8 | 100.00
 | 3583 |[Count Special Triplets](src/main/kotlin/g3501_3600/s3583_count_special_triplets)| Medium | Array, Hash_Table, Counting | 238 | 55.56

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

@@ -0,0 +1,171 @@
+[![](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)
+
+## 3586\. Find COVID Recovery Patients
+
+Medium
+
+Table: `patients`
+
+    +-------------+---------+
+    | Column Name | Type    |
+    +-------------+---------+
+    | patient_id  | int     |
+    | patient_name| varchar |
+    | age         | int     |
+    +-------------+---------+
+    patient_id is the unique identifier for this table.
+    Each row contains information about a patient.
+
+Table: `covid_tests`
+
+    +-------------+---------+
+    | Column Name | Type    |
+    +-------------+---------+
+    | test_id     | int     |
+    | patient_id  | int     |
+    | test_date   | date    |
+    | result      | varchar |
+    +-------------+---------+
+    test_id is the unique identifier for this table.
+    Each row represents a COVID test result. The result can be Positive, Negative, or Inconclusive. 
+
+Write a solution to find patients who have **recovered from COVID** - patients who tested positive but later tested negative.
+
+*   A patient is considered recovered if they have **at least one** **Positive** test followed by at least one **Negative** test on a **later date**
+*   Calculate the **recovery time** in days as the **difference** between the **first positive test** and the **first negative test** after that **positive test**
+*   **Only include** patients who have both positive and negative test results
+
+Return _the result table ordered by_ `recovery_time` _in **ascending** order, then by_ `patient_name` _in **ascending** order_.
+
+The result format is in the following example.
+
+**Example:**
+
+**Input:**
+
+patients table:
+
+    +------------+--------------+-----+
+    | patient_id | patient_name | age |
+    +------------+--------------+-----+
+    | 1          | Alice Smith  | 28  |
+    | 2          | Bob Johnson  | 35  |
+    | 3          | Carol Davis  | 42  |
+    | 4          | David Wilson | 31  |
+    | 5          | Emma Brown   | 29  |
+    +------------+--------------+-----+ 
+
+covid\_tests table:
+
+    +---------+------------+------------+--------------+
+    | test_id | patient_id | test_date  | result       |
+    |---------|------------|------------|--------------|
+    | 1       | 1          | 2023-01-15 | Positive     |
+    | 2       | 1          | 2023-01-25 | Negative     |
+    | 3       | 2          | 2023-02-01 | Positive     |
+    | 4       | 2          | 2023-02-05 | Inconclusive |
+    | 5       | 2          | 2023-02-12 | Negative     |
+    | 6       | 3          | 2023-01-20 | Negative     |
+    | 7       | 3          | 2023-02-10 | Positive     |
+    | 8       | 3          | 2023-02-20 | Negative     |
+    | 9       | 4          | 2023-01-10 | Positive     |
+    | 10      | 4          | 2023-01-18 | Positive     |
+    | 11      | 5          | 2023-02-15 | Negative     |
+    | 12      | 5          | 2023-02-20 | Negative     |
+    +---------+------------+------------+--------------+
+
+**Output:**
+
+    +------------+--------------+-----+---------------+
+    | patient_id | patient_name | age | recovery_time |
+    |------------|--------------|-----|---------------|
+    | 1          | Alice Smith  | 28  | 10            |
+    | 3          | Carol Davis  | 42  | 10            |
+    | 2          | Bob Johnson  | 35  | 11            |
+    +------------+--------------+-----+---------------+
+
+**Explanation:**
+
+*   **Alice Smith (patient\_id = 1):**
+    *   First positive test: 2023-01-15
+    *   First negative test after positive: 2023-01-25
+    *   Recovery time: 25 - 15 = 10 days
+*   **Bob Johnson (patient\_id = 2):**
+    *   First positive test: 2023-02-01
+    *   Inconclusive test on 2023-02-05 (ignored for recovery calculation)
+    *   First negative test after positive: 2023-02-12
+    *   Recovery time: 12 - 1 = 11 days
+*   **Carol Davis (patient\_id = 3):**
+    *   Had negative test on 2023-01-20 (before positive test)
+    *   First positive test: 2023-02-10
+    *   First negative test after positive: 2023-02-20
+    *   Recovery time: 20 - 10 = 10 days
+*   **Patients not included:**
+    *   David Wilson (patient\_id = 4): Only has positive tests, no negative test after positive
+    *   Emma Brown (patient\_id = 5): Only has negative tests, never tested positive
+
+Output table is ordered by recovery\_time in ascending order, and then by patient\_name in ascending order.
+
+## Solution
+
+```sql
+# Write your MySQL query statement below
+-- mysql
+-- SELECT 
+--     p.patient_id,
+--     p.patient_name,
+--     p.age,
+--     DATEDIFF(
+--         min(neg.test_date),
+--         min(pos.test_date)
+--     ) AS recovery_time
+-- FROM 
+--     patients p
+--     JOIN covid_tests pos ON
+--         p.patient_id = pos.patient_id AND pos.result = 'Positive'
+--     JOIN covid_tests neg ON 
+--         p.patient_id = neg.patient_id AND neg.result = 'Negative'
+-- WHERE 
+--     neg.test_date > pos.test_date
+-- GROUP BY 
+--     p.patient_id, p.patient_name, p.age
+-- ORDER BY 
+--     recovery_time, p.patient_name;
+select 
+    p.patient_id,
+    p.patient_name,
+    p.age,
+    datediff(
+        day, 
+        pos.first_pos_date, 
+        neg.first_neg_date
+    ) as recovery_time
+from 
+    patients p
+    join (
+        select patient_id, min(test_date) as first_pos_date 
+        from covid_tests 
+        where result = 'Positive'
+        group by patient_id
+    ) pos on p.patient_id = pos.patient_id
+    join (
+        select 
+            c1.patient_id, 
+            min(c1.test_date) as first_neg_date
+        from 
+            covid_tests c1
+            join (
+                select patient_id, min(test_date) as first_pos_date 
+                from covid_tests 
+                where result = 'Positive'
+                group by patient_id
+            ) p2 on c1.patient_id = p2.patient_id
+        where 
+            c1.result = 'Negative'
+            and c1.test_date > p2.first_pos_date
+        group by c1.patient_id
+    ) neg on p.patient_id = neg.patient_id
+order by 
+    recovery_time ASC, p.patient_name ASC;
+```

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

@@ -0,0 +1,108 @@
+[![](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)
+
+## 3587\. Minimum Adjacent Swaps to Alternate Parity
+
+Medium
+
+You are given an array `nums` of **distinct** integers.
+
+In one operation, you can swap any two **adjacent** elements in the array.
+
+An arrangement of the array is considered **valid** if the parity of adjacent elements **alternates**, meaning every pair of neighboring elements consists of one even and one odd number.
+
+Return the **minimum** number of adjacent swaps required to transform `nums` into any valid arrangement.
+
+If it is impossible to rearrange `nums` such that no two adjacent elements have the same parity, return `-1`.
+
+**Example 1:**
+
+**Input:** nums = [2,4,6,5,7]
+
+**Output:** 3
+
+**Explanation:**
+
+Swapping 5 and 6, the array becomes `[2,4,5,6,7]`
+
+Swapping 5 and 4, the array becomes `[2,5,4,6,7]`
+
+Swapping 6 and 7, the array becomes `[2,5,4,7,6]`. The array is now a valid arrangement. Thus, the answer is 3.
+
+**Example 2:**
+
+**Input:** nums = [2,4,5,7]
+
+**Output:** 1
+
+**Explanation:**
+
+By swapping 4 and 5, the array becomes `[2,5,4,7]`, which is a valid arrangement. Thus, the answer is 1.
+
+**Example 3:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** 0
+
+**Explanation:**
+
+The array is already a valid arrangement. Thus, no operations are needed.
+
+**Example 4:**
+
+**Input:** nums = [4,5,6,8]
+
+**Output:** \-1
+
+**Explanation:**
+
+No valid arrangement is possible. Thus, the answer is -1.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>
+*   All elements in `nums` are **distinct**.
+
+## Solution
+
+```kotlin
+import kotlin.math.abs
+import kotlin.math.min
+
+class Solution {
+    fun minSwaps(nums: IntArray): Int {
+        val evenIndices: MutableList<Int> = ArrayList<Int>()
+        val oddIndices: MutableList<Int> = ArrayList<Int>()
+        for (i in nums.indices) {
+            if (nums[i] % 2 == 0) {
+                evenIndices.add(i)
+            } else {
+                oddIndices.add(i)
+            }
+        }
+        val evenCount = evenIndices.size
+        val oddCount = oddIndices.size
+        if (abs(evenCount - oddCount) > 1) {
+            return -1
+        }
+        var ans = Int.Companion.MAX_VALUE
+        if (evenCount >= oddCount) {
+            ans = min(ans, helper(evenIndices))
+        }
+        if (oddCount >= evenCount) {
+            ans = min(ans, helper(oddIndices))
+        }
+        return ans
+    }
+
+    private fun helper(indices: MutableList<Int>): Int {
+        var swaps = 0
+        for (i in indices.indices) {
+            swaps += abs(indices[i] - 2 * i)
+        }
+        return swaps
+    }
+}
+```