Added tasks 2523, 2525, 2526, 2527, 2528

Author: ThanhNIT

README.md

@@ -1848,6 +1848,11 @@ implementation 'com.github.javadev:leetcode-in-java:1.20'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2528 |[Maximize the Minimum Powered City](src/main/java/g2501_2600/s2528_maximize_the_minimum_powered_city/Solution.java)| Hard | Array, Greedy, Binary_Search, Prefix_Sum, Sliding_Window, Queue | 51 | 77.59
+| 2527 |[Find Xor-Beauty of Array](src/main/java/g2501_2600/s2527_find_xor_beauty_of_array/Solution.java)| Medium | Array, Math, Bit_Manipulation | 1 | 100.00
+| 2526 |[Find Consecutive Integers from a Data Stream](src/main/java/g2501_2600/s2526_find_consecutive_integers_from_a_data_stream/DataStream.java)| Medium | Hash_Table, Design, Counting, Queue, Data_Stream | 32 | 94.65
+| 2525 |[Categorize Box According to Criteria](src/main/java/g2501_2600/s2525_categorize_box_according_to_criteria/Solution.java)| Easy | Math | 0 | 100.00
+| 2523 |[Closest Prime Numbers in Range](src/main/java/g2501_2600/s2523_closest_prime_numbers_in_range/Solution.java)| Medium | Math, Number_Theory | 1 | 100.00
 | 2522 |[Partition String Into Substrings With Values at Most K](src/main/java/g2501_2600/s2522_partition_string_into_substrings_with_values_at_most_k/Solution.java)| Medium | String, Dynamic_Programming, Greedy | 6 | 84.66
 | 2521 |[Distinct Prime Factors of Product of Array](src/main/java/g2501_2600/s2521_distinct_prime_factors_of_product_of_array/Solution.java)| Medium | Array, Hash_Table, Math, Number_Theory | 2 | 100.00
 | 2520 |[Count the Digits That Divide a Number](src/main/java/g2501_2600/s2520_count_the_digits_that_divide_a_number/Solution.java)| Easy | Math | 0 | 100.00
@@ -1860,7 +1865,7 @@ implementation 'com.github.javadev:leetcode-in-java:1.20'
 | 2512 |[Reward Top K Students](src/main/java/g2501_2600/s2512_reward_top_k_students/Solution.java)| Medium | Array, String, Hash_Table, Sorting, Heap_Priority_Queue | 72 | 94.76
 | 2511 |[Maximum Enemy Forts That Can Be Captured](src/main/java/g2501_2600/s2511_maximum_enemy_forts_that_can_be_captured/Solution.java)| Easy | Array, Two_Pointers | 0 | 100.00
 | 2509 |[Cycle Length Queries in a Tree](src/main/java/g2501_2600/s2509_cycle_length_queries_in_a_tree/Solution.java)| Hard | Tree, Binary_Tree | 12 | 99.26
-| 2508 |[Add Edges to Make Degrees of All Nodes Even](src/main/java/g2501_2600/s2508_add_edges_to_make_degrees_of_all_nodes_even/Solution.java)| Hard | Hash_Table, Graph | 33 | 100.00
+| 2508 |[Add Edges to Make Degrees of All Nodes Even](src/main/java/g2501_2600/s2508_add_edges_to_make_degrees_of_all_nodes_even/Solution.java)| Hard | Hash_Table, Graph | 36 | 95.00
 | 2507 |[Smallest Value After Replacing With Sum of Prime Factors](src/main/java/g2501_2600/s2507_smallest_value_after_replacing_with_sum_of_prime_factors/Solution.java)| Medium | Math, Number_Theory | 1 | 84.27
 | 2506 |[Count Pairs Of Similar Strings](src/main/java/g2501_2600/s2506_count_pairs_of_similar_strings/Solution.java)| Easy | Array, String, Hash_Table | 6 | 85.15
 | 2503 |[Maximum Number of Points From Grid Queries](src/main/java/g2501_2600/s2503_maximum_number_of_points_from_grid_queries/Solution.java)| Hard | Array, Sorting, Breadth_First_Search, Heap_Priority_Queue, Union_Find | 47 | 96.38

src/main/java/g2501_2600/s2523_closest_prime_numbers_in_range/Solution.java

@@ -0,0 +1,43 @@
+package g2501_2600.s2523_closest_prime_numbers_in_range;
+
+// #Medium #Math #Number_Theory #2023_04_19_Time_1_ms_(100.00%)_Space_39.9_MB_(97.74%)
+
+public class Solution {
+    public int[] closestPrimes(int left, int right) {
+        int diff = -1;
+        int x = -1;
+        int y = -1;
+        int prev = -1;
+        for (int i = left; i <= right; i++) {
+            boolean isPrime = isPrime(i);
+            if (isPrime) {
+                if (prev != -1) {
+                    int d = i - prev;
+                    if (diff == -1 || d < diff) {
+                        diff = d;
+                        x = prev;
+                        y = i;
+                        if (diff <= 2) {
+                            return new int[] {x, y};
+                        }
+                    }
+                }
+                prev = i;
+            }
+        }
+        return new int[] {x, y};
+    }
+
+    private boolean isPrime(int x) {
+        if (x == 1) {
+            return false;
+        }
+        double sqrt = Math.sqrt(x);
+        for (int i = 2; i <= sqrt; i++) {
+            if (x % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

src/main/java/g2501_2600/s2523_closest_prime_numbers_in_range/readme.md

@@ -0,0 +1,37 @@
+2523\. Closest Prime Numbers in Range
+
+Medium
+
+Given two positive integers `left` and `right`, find the two integers `num1` and `num2` such that:
+
+*   `left <= nums1 < nums2 <= right` .
+*   `nums1` and `nums2` are both **prime** numbers.
+*   `nums2 - nums1` is the **minimum** amongst all other pairs satisfying the above conditions.
+
+Return _the positive integer array_ `ans = [nums1, nums2]`. _If there are multiple pairs satisfying these conditions, return the one with the minimum_ `nums1` _value or_ `[-1, -1]` _if such numbers do not exist._
+
+A number greater than `1` is called **prime** if it is only divisible by `1` and itself.
+
+**Example 1:**
+
+**Input:** left = 10, right = 19
+
+**Output:** [11,13]
+
+**Explanation:** The prime numbers between 10 and 19 are 11, 13, 17, and 19. 
+
+The closest gap between any pair is 2, which can be achieved by [11,13] or [17,19]. 
+
+Since 11 is smaller than 17, we return the first pair.
+
+**Example 2:**
+
+**Input:** left = 4, right = 6
+
+**Output:** [-1,-1]
+
+**Explanation:** There exists only one prime number in the given range, so the conditions cannot be satisfied.
+
+**Constraints:**
+
+*   <code>1 <= left <= right <= 10<sup>6</sup></code>

src/main/java/g2501_2600/s2525_categorize_box_according_to_criteria/Solution.java

@@ -0,0 +1,26 @@
+package g2501_2600.s2525_categorize_box_according_to_criteria;
+
+// #Easy #Math #2023_04_19_Time_0_ms_(100.00%)_Space_40.1_MB_(36.65%)
+
+public class Solution {
+    public String categorizeBox(int length, int width, int height, int mass) {
+        long vol = (long) length * width * height;
+        boolean b = false;
+        boolean h = false;
+        if (length >= 10000 || width >= 10000 || height >= 10000 || vol >= 1000000000) {
+            b = true;
+        }
+        if (mass >= 100) {
+            h = true;
+        }
+        if (b && h) {
+            return "Both";
+        } else if (!b && !h) {
+            return "Neither";
+        } else if (b) {
+            return "Bulky";
+        } else {
+            return "Heavy";
+        }
+    }
+}

src/main/java/g2501_2600/s2525_categorize_box_according_to_criteria/readme.md

@@ -0,0 +1,53 @@
+2525\. Categorize Box According to Criteria
+
+Easy
+
+Given four integers `length`, `width`, `height`, and `mass`, representing the dimensions and mass of a box, respectively, return _a string representing the **category** of the box_.
+
+*   The box is `"Bulky"` if:
+    *   **Any** of the dimensions of the box is greater or equal to <code>10<sup>4</sup></code>.
+    *   Or, the **volume** of the box is greater or equal to <code>10<sup>9</sup></code>.
+*   If the mass of the box is greater or equal to `100`, it is `"Heavy".`
+*   If the box is both `"Bulky"` and `"Heavy"`, then its category is `"Both"`.
+*   If the box is neither `"Bulky"` nor `"Heavy"`, then its category is `"Neither"`.
+*   If the box is `"Bulky"` but not `"Heavy"`, then its category is `"Bulky"`.
+*   If the box is `"Heavy"` but not `"Bulky"`, then its category is `"Heavy"`.
+
+**Note** that the volume of the box is the product of its length, width and height.
+
+**Example 1:**
+
+**Input:** length = 1000, width = 35, height = 700, mass = 300
+
+**Output:** "Heavy"
+
+**Explanation:** 
+
+None of the dimensions of the box is greater or equal to 10<sup>4</sup>.
+
+Its volume = 24500000 <= 10<sup>9</sup>. So it cannot be categorized as "Bulky". 
+
+However mass >= 100, so the box is "Heavy". 
+
+Since the box is not "Bulky" but "Heavy", we return "Heavy".
+
+**Example 2:**
+
+**Input:** length = 200, width = 50, height = 800, mass = 50
+
+**Output:** "Neither"
+
+**Explanation:** 
+
+None of the dimensions of the box is greater or equal to 10<sup>4</sup>. 
+
+Its volume = 8 \* 10<sup>6</sup> <= 10<sup>9</sup>. So it cannot be categorized as "Bulky". 
+
+Its mass is also less than 100, so it cannot be categorized as "Heavy" either. 
+
+Since its neither of the two above categories, we return "Neither".
+
+**Constraints:**
+
+*   <code>1 <= length, width, height <= 10<sup>5</sup></code>
+*   <code>1 <= mass <= 10<sup>3</sup></code>

src/main/java/g2501_2600/s2526_find_consecutive_integers_from_a_data_stream/DataStream.java

@@ -0,0 +1,26 @@
+package g2501_2600.s2526_find_consecutive_integers_from_a_data_stream;
+
+// #Medium #Hash_Table #Design #Counting #Queue #Data_Stream
+// #2023_04_19_Time_32_ms_(94.65%)_Space_80.2_MB_(39.13%)
+
+public class DataStream {
+    private final int value;
+    private final int k;
+    private int count;
+
+    public DataStream(int value, int k) {
+        this.value = value;
+        this.k = k;
+    }
+
+    public boolean consec(int num) {
+        count = num == value ? count + 1 : 0;
+        return count >= k;
+    }
+}
+
+/*
+ * Your DataStream object will be instantiated and called as such:
+ * DataStream obj = new DataStream(value, k);
+ * boolean param_1 = obj.consec(num);
+ */

src/main/java/g2501_2600/s2526_find_consecutive_integers_from_a_data_stream/readme.md

@@ -0,0 +1,34 @@
+2526\. Find Consecutive Integers from a Data Stream
+
+Medium
+
+For a stream of integers, implement a data structure that checks if the last `k` integers parsed in the stream are **equal** to `value`.
+
+Implement the **DataStream** class:
+
+*   `DataStream(int value, int k)` Initializes the object with an empty integer stream and the two integers `value` and `k`.
+*   `boolean consec(int num)` Adds `num` to the stream of integers. Returns `true` if the last `k` integers are equal to `value`, and `false` otherwise. If there are less than `k` integers, the condition does not hold true, so returns `false`.
+
+**Example 1:**
+
+**Input** ["DataStream", "consec", "consec", "consec", "consec"] 
+
+[[4, 3], [4], [4], [4], [3]]
+
+**Output:** [null, false, false, true, false]
+
+**Explanation:** 
+
+    DataStream dataStream = new DataStream(4, 3); //value = 4, k = 3 
+    dataStream.consec(4); // Only 1 integer is parsed, so returns False.
+    dataStream.consec(4); // Only 2 integers are parsed. 
+                          // Since 2 is less than k, returns False. 
+    dataStream.consec(4); // The 3 integers parsed are all equal to value, so returns True. 
+    dataStream.consec(3); // The last k integers parsed in the stream are [4,4,3]. 
+                          // Since 3 is not equal to value, it returns False.
+
+**Constraints:**
+
+*   <code>1 <= value, num <= 10<sup>9</sup></code>
+*   <code>1 <= k <= 10<sup>5</sup></code>
+*   At most <code>10<sup>5</sup></code> calls will be made to `consec`.

src/main/java/g2501_2600/s2527_find_xor_beauty_of_array/Solution.java

@@ -0,0 +1,14 @@
+package g2501_2600.s2527_find_xor_beauty_of_array;
+
+// #Medium #Array #Math #Bit_Manipulation #2023_04_19_Time_1_ms_(100.00%)_Space_59.1_MB_(62.11%)
+
+public class Solution {
+    public int xorBeauty(int[] arr) {
+        int i = 1;
+        while (i < arr.length) {
+            arr[0] ^= arr[i];
+            i++;
+        }
+        return arr[0];
+    }
+}

src/main/java/g2501_2600/s2527_find_xor_beauty_of_array/readme.md

@@ -0,0 +1,57 @@
+2527\. Find Xor-Beauty of Array
+
+Medium
+
+You are given a **0-indexed** integer array `nums`.
+
+The **effective value** of three indices `i`, `j`, and `k` is defined as `((nums[i] | nums[j]) & nums[k])`.
+
+The **xor-beauty** of the array is the XORing of **the effective values of all the possible triplets** of indices `(i, j, k)` where `0 <= i, j, k < n`.
+
+Return _the xor-beauty of_ `nums`.
+
+**Note** that:
+
+*   `val1 | val2` is bitwise OR of `val1` and `val2`.
+*   `val1 & val2` is bitwise AND of `val1` and `val2`.
+
+**Example 1:**
+
+**Input:** nums = [1,4]
+
+**Output:** 5
+
+**Explanation:** 
+
+The triplets and their corresponding effective values are listed below:
+
+- (0,0,0) with effective value ((1 | 1) & 1) = 1 
+
+- (0,0,1) with effective value ((1 | 1) & 4) = 0 
+
+- (0,1,0) with effective value ((1 | 4) & 1) = 1 
+
+- (0,1,1) with effective value ((1 | 4) & 4) = 4 
+
+- (1,0,0) with effective value ((4 | 1) & 1) = 1 
+
+- (1,0,1) with effective value ((4 | 1) & 4) = 4 
+
+- (1,1,0) with effective value ((4 | 4) & 1) = 0 
+
+- (1,1,1) with effective value ((4 | 4) & 4) = 4 
+
+Xor-beauty of array will be bitwise XOR of all beauties = 1 ^ 0 ^ 1 ^ 4 ^ 1 ^ 4 ^ 0 ^ 4 = 5.
+
+**Example 2:**
+
+**Input:** nums = [15,45,20,2,34,35,5,44,32,30]
+
+**Output:** 34
+
+**Explanation:** `The xor-beauty of the given array is 34.`
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>

src/main/java/g2501_2600/s2528_maximize_the_minimum_powered_city/Solution.java

@@ -0,0 +1,67 @@
+package g2501_2600.s2528_maximize_the_minimum_powered_city;
+
+// #Hard #Array #Greedy #Binary_Search #Prefix_Sum #Sliding_Window #Queue
+// #2023_04_19_Time_51_ms_(77.59%)_Space_60_MB_(5.17%)
+
+public class Solution {
+    private boolean canIBeTheMinimum(long[] power, long minimum, int k, int r) {
+        int n = power.length;
+        long[] extraPower = new long[n];
+        for (int i = 0; i < n; i++) {
+            if (i > 0) {
+                extraPower[i] += extraPower[i - 1];
+            }
+            long curPower = power[i] + extraPower[i];
+            long req = minimum - curPower;
+            if (req <= 0) {
+                continue;
+            }
+            if (req > k) {
+                return false;
+            }
+            k -= req;
+            extraPower[i] += (req);
+            if (i + 2 * r + 1 < n) {
+                extraPower[i + 2 * r + 1] -= (req);
+            }
+        }
+        return true;
+    }
+
+    private long[] calculatePowerArray(int[] stations, int r) {
+        int n = stations.length;
+        long[] preSum = new long[n];
+        for (int i = 0; i < n; i++) {
+            int st = i - r;
+            int last = i + r + 1;
+            if (st < 0) {
+                st = 0;
+            }
+            preSum[st] += stations[i];
+            if (last < n) {
+                preSum[last] -= stations[i];
+            }
+        }
+        for (int i = 1; i < n; i++) {
+            preSum[i] += preSum[i - 1];
+        }
+        return preSum;
+    }
+
+    public long maxPower(int[] stations, int r, int k) {
+        long min = 0;
+        long sum = (long) Math.pow(10, 10) + (long) Math.pow(10, 9);
+        long[] power = calculatePowerArray(stations, r);
+        long ans = -1;
+        while (min <= sum) {
+            long mid = (min + sum) >> 1;
+            if (canIBeTheMinimum(power, mid, k, r)) {
+                ans = mid;
+                min = mid + 1;
+            } else {
+                sum = mid - 1;
+            }
+        }
+        return ans;
+    }
+}