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/java/g3501_3600/s3525_find_x_value_of_array_ii)| Hard | Array, Math, Segment_Tree | 177 | 79.87
+| 3524 |[Find X Value of Array I](src/main/java/g3501_3600/s3524_find_x_value_of_array_i)| Medium | Array, Dynamic_Programming, Math | 12 | 95.54
+| 3523 |[Make Array Non-decreasing](src/main/java/g3501_3600/s3523_make_array_non_decreasing)| Medium | Array, Greedy, Stack, Monotonic_Stack | 3 | 63.29
+| 3522 |[Calculate Score After Performing Instructions](src/main/java/g3501_3600/s3522_calculate_score_after_performing_instructions)| Medium | Array, String, Hash_Table, Simulation | 1 | 100.00
+| 3521 |[Find Product Recommendation Pairs](src/main/java/g3501_3600/s3521_find_product_recommendation_pairs)| Medium | Database | 611 | 70.71
 | 3519 |[Count Numbers with Non-Decreasing Digits](src/main/java/g3501_3600/s3519_count_numbers_with_non_decreasing_digits)| Hard | String, Dynamic_Programming, Math | 19 | 100.00
 | 3518 |[Smallest Palindromic Rearrangement II](src/main/java/g3501_3600/s3518_smallest_palindromic_rearrangement_ii)| Hard | String, Hash_Table, Math, Counting, Combinatorics | 34 | 100.00
 | 3517 |[Smallest Palindromic Rearrangement I](src/main/java/g3501_3600/s3517_smallest_palindromic_rearrangement_i)| Medium | String, Sorting, Counting_Sort | 33 | 100.00
@@ -4276,7 +4281,7 @@
 | 0775 |[Global and Local Inversions](src/main/java/g0701_0800/s0775_global_and_local_inversions)| Medium | Array, Math | 1 | 99.74
 | 0773 |[Sliding Puzzle](src/main/java/g0701_0800/s0773_sliding_puzzle)| Hard | Array, Breadth_First_Search, Matrix | 9 | 81.80
 | 0771 |[Jewels and Stones](src/main/java/g0701_0800/s0771_jewels_and_stones)| Easy | String, Hash_Table | 1 | 91.74
-| 0770 |[Basic Calculator IV](src/main/java/g0701_0800/s0770_basic_calculator_iv)| Hard | String, Hash_Table, Math, Stack, Recursion | 8 | 96.92
+| 0770 |[Basic Calculator IV](src/main/java/g0701_0800/s0770_basic_calculator_iv)| Hard | String, Hash_Table, Math, Stack, Recursion | 8 | 95.70
 | 0769 |[Max Chunks To Make Sorted](src/main/java/g0701_0800/s0769_max_chunks_to_make_sorted)| Medium | Array, Sorting, Greedy, Stack, Monotonic_Stack | 0 | 100.00
 | 0768 |[Max Chunks To Make Sorted II](src/main/java/g0701_0800/s0768_max_chunks_to_make_sorted_ii)| Hard | Array, Sorting, Greedy, Stack, Monotonic_Stack | 1 | 87.58
 | 0767 |[Reorganize String](src/main/java/g0701_0800/s0767_reorganize_string)| Medium | String, Hash_Table, Sorting, Greedy, Heap_Priority_Queue, Counting | 1 | 94.60

src/main/java/g0701_0800/s0706_design_hashmap/readme.md

@@ -48,7 +48,7 @@ import java.util.ArrayList;
 
 @SuppressWarnings("unchecked")
 public class MyHashMap {
-    private ArrayList[] arr = null;
+    private final ArrayList[] arr;
 
     public MyHashMap() {
         arr = new ArrayList[1000];

src/main/java/g1801_1900/s1837_sum_of_digits_in_base_k/readme.md

@@ -35,9 +35,9 @@ After converting, each digit should be interpreted as a base `10` number, and th
 ```java
 public class Solution {
     public int sumBase(int n, int k) {
-        int a = 0;
+        int a;
         int sum = 0;
-        int b = 0;
+        int b;
         while (n != 0) {
             a = n % k;
             b = n / k;

src/main/java/g2301_2400/s2332_the_latest_time_to_catch_a_bus/readme.md

@@ -84,7 +84,7 @@ public class Solution {
                 b++;
             }
         }
-        int start = 0;
+        int start;
         if (c == capacity) {
             // capcity is full in last bus, find time last passenger might have boarded
             start = Math.min(passengers[p - 1], buses[blen - 1]);

src/main/java/g2301_2400/s2380_time_needed_to_rearrange_a_binary_string/readme.md

@@ -51,7 +51,7 @@ public class Solution {
     public int secondsToRemoveOccurrences(String s) {
         int lastOne = -1;
         int result = 0;
-        int prevResult = 0;
+        int prevResult;
         int curResult = 0;
         int countOne = 0;
         int countZero = 0;

src/main/java/g2301_2400/s2384_largest_palindromic_number/readme.md

@@ -55,26 +55,26 @@ public class Solution {
         for (char c : num.toCharArray()) {
             count[c - '0']++;
         }
-        int c = 0;
+        int c;
         for (int i = 9; i >= 0; i--) {
             c = 0;
             if (count[i] % 2 == 1 && center == -1) {
                 center = i;
             }
-            if (first.length() == 0 && i == 0) {
+            if (first.isEmpty() && i == 0) {
                 continue;
             }
             while (c < count[i] / 2) {
-                first.append(String.valueOf(i));
+                first.append(i);
                 c++;
             }
         }
         second = new StringBuilder(first.toString());
         if (center != -1) {
             first.append(center);
         }
-        first.append(second.reverse().toString());
-        return first.length() == 0 ? "0" : first.toString();
+        first.append(second.reverse());
+        return first.isEmpty() ? "0" : first.toString();
     }
 }
 ```

src/main/java/g2401_2500/s2410_maximum_matching_of_players_with_trainers/readme.md

@@ -54,7 +54,7 @@ public class Solution {
     public int matchPlayersAndTrainers(int[] players, int[] trainers) {
         Arrays.sort(players);
         Arrays.sort(trainers);
-        int i = 0;
+        int i;
         int j = 0;
         int count = 0;
         i = 0;

src/main/java/g2401_2500/s2468_split_message_based_on_limit/readme.md

@@ -55,7 +55,7 @@ Under the given constraints, the string can be split into two parts:
 @SuppressWarnings("java:S3518")
 public class Solution {
     public String[] splitMessage(String message, int limit) {
-        int total = 0;
+        int total;
         int running = 0;
         int count;
         int totalReq;

src/main/java/g2701_2800/s2745_construct_the_longest_new_string/readme.md

@@ -39,7 +39,7 @@ A **substring** is a contiguous **non-empty** sequence of characters within a st
 public class Solution {
     public int longestString(int x, int y, int z) {
         int min = Math.min(x, y);
-        int res = 0;
+        int res;
         if (x == y) {
             res = 2 * min + z;
         } else {

src/main/java/g2801_2900/s2812_find_the_safest_path_in_a_grid/readme.md

@@ -99,7 +99,7 @@ public class Solution {
         int[] tmpDeque;
         int[] queue = new int[yLen * xLen];
         int[] root = new int[yLen * xLen];
-        int head = -1;
+        int head;
         int tail = -1;
         int qIdx = -1;
         int end = yLen * xLen - 1;

src/main/java/g2801_2900/s2816_double_a_number_represented_as_a_linked_list/readme.md

@@ -76,7 +76,7 @@ public class Solution {
 
     private ListNode revList(ListNode head) {
         ListNode prev = null;
-        ListNode nxt = null;
+        ListNode nxt;
         ListNode current = head;
         while (current != null) {
             nxt = current.next;

src/main/java/g2901_3000/s2932_maximum_strong_pair_xor_i/readme.md

@@ -50,7 +50,7 @@ Return _the **maximum**_ `XOR` _value out of all possible strong pairs in the ar
 public class Solution {
     public int maximumStrongPairXor(int[] nums) {
         int max = 0;
-        int pair = 0;
+        int pair;
         for (int i = 0; i < nums.length; i++) {
             for (int j = i; j < nums.length; j++) {
                 if (Math.abs(nums[i] - nums[j]) <= Math.min(nums[i], nums[j])) {

src/main/java/g2901_3000/s2972_count_the_number_of_incremovable_subarrays_ii/readme.md

@@ -49,7 +49,7 @@ A **subarray** is a contiguous non-empty sequence of elements within an array.
 ```java
 public class Solution {
     public long incremovableSubarrayCount(int[] nums) {
-        long ans = 0;
+        long ans;
         int n = nums.length;
         int l = 0;
         int r = n - 1;

src/main/java/g3101_3200/s3108_minimum_cost_walk_in_weighted_graph/readme.md

@@ -80,7 +80,7 @@ public class Solution {
             if (parent1 == parent2) {
                 bitwise[parent1] &= weight;
             } else {
-                int bitwiseVal = 0;
+                int bitwiseVal;
                 boolean check1 = bitwise[parent1] == -1;
                 boolean check2 = bitwise[parent2] == -1;
                 if (check1 && check2) {

src/main/java/g3301_3400/s3395_subsequences_with_a_unique_middle_mode_i/readme.md

@@ -60,14 +60,14 @@ import java.util.Map;
 
 public class Solution {
     private static final int MOD = (int) 1e9 + 7;
-    private long[] c2 = new long[1001];
+    private final long[] c2 = new long[1001];
 
     public int subsequencesWithMiddleMode(int[] nums) {
         if (c2[2] == 0) {
             c2[0] = c2[1] = 0;
             c2[2] = 1;
             for (int i = 3; i < c2.length; ++i) {
-                c2[i] = i * (i - 1) / 2;
+                c2[i] = (long) i * (i - 1) / 2;
             }
         }
         int n = nums.length;
@@ -111,8 +111,8 @@ public class Solution {
                     ans -=
                             leftY
                                     * rightY
-                                    * (leftX * (right - rightX - rightY)
-                                            + rightX * (left - leftX - leftY));
+                                    * ((long) leftX * (right - rightX - rightY)
+                                            + (long) rightX * (left - leftX - leftY));
                 }
             }
             leftCount[x]++;

src/main/java/g3401_3500/s3407_substring_matching_pattern/readme.md

@@ -73,7 +73,7 @@ public class Solution {
     private int fun(String s, String k) {
         int n = s.length();
         int m = k.length();
-        int j = 0;
+        int j;
         for (int i = 0; i <= n - m; i++) {
             for (j = 0; j < m; j++) {
                 char ch1 = s.charAt(j + i);

src/main/java/g3401_3500/s3424_minimum_cost_to_make_arrays_identical/readme.md

@@ -54,7 +54,7 @@ public class Solution {
     public long minCost(int[] arr, int[] brr, long k) {
         int n = arr.length;
         long sum1 = 0;
-        long sum2 = 0;
+        long sum2;
         for (int i = 0; i < n; i++) {
             sum1 += Math.abs(arr[i] - brr[i]);
         }

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

@@ -0,0 +1,124 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/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
+```