Added tasks 2529, 2530, 2531, 2532, 2535

Author: ThanhNIT

README.md

@@ -1848,6 +1848,11 @@ implementation 'com.github.javadev:leetcode-in-java:1.20'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2535 |[Difference Between Element Sum and Digit Sum of an Array](src/main/java/g2501_2600/s2535_difference_between_element_sum_and_digit_sum_of_an_array/Solution.java)| Easy | Array, Math | 3 | 77.42
+| 2532 |[Time to Cross a Bridge](src/main/java/g2501_2600/s2532_time_to_cross_a_bridge/Solution.java)| Hard | Array, Heap_Priority_Queue, Simulation | 67 | 72.50
+| 2531 |[Make Number of Distinct Characters Equal](src/main/java/g2501_2600/s2531_make_number_of_distinct_characters_equal/Solution.java)| Medium | String, Hash_Table, Counting | 7 | 100.00
+| 2530 |[Maximal Score After Applying K Operations](src/main/java/g2501_2600/s2530_maximal_score_after_applying_k_operations/Solution.java)| Medium | Array, Greedy, Heap_Priority_Queue | 168 | 67.97
+| 2529 |[Maximum Count of Positive Integer and Negative Integer](src/main/java/g2501_2600/s2529_maximum_count_of_positive_integer_and_negative_integer/Solution.java)| Easy | Array, Binary_Search, Counting | 0 | 100.00
 | 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

src/main/java/g2501_2600/s2529_maximum_count_of_positive_integer_and_negative_integer/Solution.java

@@ -0,0 +1,19 @@
+package g2501_2600.s2529_maximum_count_of_positive_integer_and_negative_integer;
+
+// #Easy #Array #Binary_Search #Counting #2023_04_20_Time_0_ms_(100.00%)_Space_42.4_MB_(77.96%)
+
+public class Solution {
+    public int maximumCount(int[] nums) {
+        int plus = 0;
+        int minus = 0;
+        for (int num : nums) {
+            if (num > 0) {
+                plus++;
+            }
+            if (num < 0) {
+                minus++;
+            }
+        }
+        return Math.max(plus, minus);
+    }
+}

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

@@ -0,0 +1,41 @@
+2529\. Maximum Count of Positive Integer and Negative Integer
+
+Easy
+
+Given an array `nums` sorted in **non-decreasing** order, return _the maximum between the number of positive integers and the number of negative integers._
+
+*   In other words, if the number of positive integers in `nums` is `pos` and the number of negative integers is `neg`, then return the maximum of `pos` and `neg`.
+
+**Note** that `0` is neither positive nor negative.
+
+**Example 1:**
+
+**Input:** nums = [-2,-1,-1,1,2,3]
+
+**Output:** 3
+
+**Explanation:** There are 3 positive integers and 3 negative integers. The maximum count among them is 3.
+
+**Example 2:**
+
+**Input:** nums = [-3,-2,-1,0,0,1,2]
+
+**Output:** 3
+
+**Explanation:** There are 2 positive integers and 3 negative integers. The maximum count among them is 3.
+
+**Example 3:**
+
+**Input:** nums = [5,20,66,1314]
+
+**Output:** 4
+
+**Explanation:** There are 4 positive integers and 0 negative integers. The maximum count among them is 4.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 2000`
+*   `-2000 <= nums[i] <= 2000`
+*   `nums` is sorted in a **non-decreasing order**.
+
+**Follow up:** Can you solve the problem in `O(log(n))` time complexity?

src/main/java/g2501_2600/s2530_maximal_score_after_applying_k_operations/Solution.java

@@ -0,0 +1,26 @@
+package g2501_2600.s2530_maximal_score_after_applying_k_operations;
+
+// #Medium #Array #Greedy #Heap_Priority_Queue #2023_04_20_Time_168_ms_(67.97%)_Space_60_MB_(30.08%)
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.PriorityQueue;
+
+public class Solution {
+    public long maxKelements(int[] nums, int k) {
+        PriorityQueue<Integer> p = new PriorityQueue<>(Collections.reverseOrder());
+        Arrays.sort(nums);
+        for (int i = 0; i < nums.length; i++) {
+            p.add(nums[nums.length - i - 1]);
+        }
+        long score = 0;
+        while (k != 0) {
+            int v1 = p.poll();
+            score += v1;
+            int v2 = (int) Math.ceil((double) v1 / 3);
+            p.add(v2);
+            k--;
+        }
+        return score;
+    }
+}

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

@@ -0,0 +1,44 @@
+2530\. Maximal Score After Applying K Operations
+
+Medium
+
+You are given a **0-indexed** integer array `nums` and an integer `k`. You have a **starting score** of `0`.
+
+In one **operation**:
+
+1.  choose an index `i` such that `0 <= i < nums.length`,
+2.  increase your **score** by `nums[i]`, and
+3.  replace `nums[i]` with `ceil(nums[i] / 3)`.
+
+Return _the maximum possible **score** you can attain after applying **exactly**_ `k` _operations_.
+
+The ceiling function `ceil(val)` is the least integer greater than or equal to `val`.
+
+**Example 1:**
+
+**Input:** nums = [10,10,10,10,10], k = 5
+
+**Output:** 50
+
+**Explanation:** Apply the operation to each array element exactly once. The final score is 10 + 10 + 10 + 10 + 10 = 50.
+
+**Example 2:**
+
+**Input:** nums = [1,10,3,3,3], k = 3
+
+**Output:** 17
+
+**Explanation:** You can do the following operations: 
+
+Operation 1: Select i = 1, so nums becomes [1,**<ins>4</ins>**,3,3,3]. Your score increases by 10.
+
+Operation 2: Select i = 1, so nums becomes [1,**<ins>2</ins>**,3,3,3]. Your score increases by 4. 
+
+Operation 3: Select i = 2, so nums becomes [1,1,<ins>**1**</ins>,3,3]. Your score increases by 3. 
+
+The final score is 10 + 4 + 3 = 17.
+
+**Constraints:**
+
+*   <code>1 <= nums.length, k <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>

src/main/java/g2501_2600/s2531_make_number_of_distinct_characters_equal/Solution.java

@@ -0,0 +1,69 @@
+package g2501_2600.s2531_make_number_of_distinct_characters_equal;
+
+// #Medium #String #Hash_Table #Counting #2023_04_20_Time_7_ms_(100.00%)_Space_43_MB_(96.82%)
+
+@SuppressWarnings("java:S135")
+public class Solution {
+    public boolean isItPossible(String word1, String word2) {
+        int[] count1 = count(word1);
+        int[] count2 = count(word2);
+        int d = count1[26] - count2[26];
+        int[] zip1 = zip(count1, count2);
+        int[] zip2 = zip(count2, count1);
+        for (int i = 0; i < 26; i++) {
+            int d1 = zip1[i];
+            if (d1 == -1) {
+                continue;
+            }
+            for (int j = 0; j < 26; j++) {
+                int d2 = zip2[j];
+                if (d2 == -1) {
+                    continue;
+                }
+                if (i == j) {
+                    if (d == 0) {
+                        return true;
+                    }
+                    continue;
+                }
+                if (d - d1 + d2 == 0) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private int[] zip(int[] c1, int[] c2) {
+        int[] zip = new int[26];
+        for (int i = 0; i < 26; i++) {
+            int d = 0;
+            if (c1[i] == 0) {
+                d = -1;
+            } else {
+                if (c2[i] == 0) {
+                    d++;
+                }
+                if (c1[i] == 1) {
+                    d++;
+                }
+            }
+            zip[i] = d;
+        }
+        return zip;
+    }
+
+    private int[] count(String word) {
+        int[] count = new int[27];
+        int len = word.length();
+        for (int i = 0; i < len; i++) {
+            count[word.charAt(i) - 'a']++;
+        }
+        for (int i = 0; i < 26; i++) {
+            if (count[i] > 0) {
+                count[26]++;
+            }
+        }
+        return count;
+    }
+}

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

@@ -0,0 +1,38 @@
+2531\. Make Number of Distinct Characters Equal
+
+Medium
+
+You are given two **0-indexed** strings `word1` and `word2`.
+
+A **move** consists of choosing two indices `i` and `j` such that `0 <= i < word1.length` and `0 <= j < word2.length` and swapping `word1[i]` with `word2[j]`.
+
+Return `true` _if it is possible to get the number of distinct characters in_ `word1` _and_ `word2` _to be equal with **exactly one** move._ Return `false` _otherwise_.
+
+**Example 1:**
+
+**Input:** word1 = "ac", word2 = "b"
+
+**Output:** false
+
+**Explanation:** Any pair of swaps would yield two distinct characters in the first string, and one in the second string.
+
+**Example 2:**
+
+**Input:** word1 = "abcc", word2 = "aab"
+
+**Output:** true
+
+**Explanation:** We swap index 2 of the first string with index 0 of the second string. The resulting strings are word1 = "abac" and word2 = "cab", which both have 3 distinct characters.
+
+**Example 3:**
+
+**Input:** word1 = "abcde", word2 = "fghij"
+
+**Output:** true
+
+**Explanation:** Both resulting strings will have 5 distinct characters, regardless of which indices we swap.
+
+**Constraints:**
+
+*   <code>1 <= word1.length, word2.length <= 10<sup>5</sup></code>
+*   `word1` and `word2` consist of only lowercase English letters.

src/main/java/g2501_2600/s2532_time_to_cross_a_bridge/Solution.java

@@ -0,0 +1,58 @@
+package g2501_2600.s2532_time_to_cross_a_bridge;
+
+// #Hard #Array #Heap_Priority_Queue #Simulation
+// #2023_04_20_Time_67_ms_(72.50%)_Space_50.4_MB_(15.00%)
+
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class Solution {
+    public int findCrossingTime(int n, int k, int[][] time) {
+        // create 2 PQ
+        PriorityQueue<int[]> leftBridgePQ =
+                new PriorityQueue<>((a, b) -> (a[1] == b[1] ? b[0] - a[0] : b[1] - a[1]));
+        PriorityQueue<int[]> rightBridgePQ =
+                new PriorityQueue<>((a, b) -> (a[1] == b[1] ? b[0] - a[0] : b[1] - a[1]));
+        PriorityQueue<int[]> leftWHPQ = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
+        PriorityQueue<int[]> rightWHPQ = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
+        for (int i = 0; i < k; i++) {
+            int effciency = time[i][0] + time[i][2];
+            leftBridgePQ.offer(new int[] {i, effciency});
+        }
+        int duration = 0;
+        while (n > 0 || !rightBridgePQ.isEmpty() || !rightWHPQ.isEmpty()) {
+            while (!leftWHPQ.isEmpty() && leftWHPQ.peek()[1] <= duration) {
+                int id = leftWHPQ.poll()[0];
+                int e = time[id][0] + time[id][2];
+                leftBridgePQ.offer(new int[] {id, e});
+            }
+            while (!rightWHPQ.isEmpty() && rightWHPQ.peek()[1] <= duration) {
+                int id = rightWHPQ.poll()[0];
+                int e = time[id][0] + time[id][2];
+                rightBridgePQ.offer(new int[] {id, e});
+            }
+            if (!rightBridgePQ.isEmpty()) {
+                int id = rightBridgePQ.poll()[0];
+                duration += time[id][2];
+                leftWHPQ.offer(new int[] {id, duration + time[id][3]});
+            } else if (!leftBridgePQ.isEmpty() && n > 0) {
+                int id = leftBridgePQ.poll()[0];
+                duration += time[id][0];
+                rightWHPQ.offer(new int[] {id, duration + time[id][1]});
+                --n;
+            } else {
+                // update duration
+                int left = Integer.MAX_VALUE;
+                if (!leftWHPQ.isEmpty() && n > 0) {
+                    left = leftWHPQ.peek()[1];
+                }
+                int right = Integer.MAX_VALUE;
+                if (!rightWHPQ.isEmpty()) {
+                    right = rightWHPQ.peek()[1];
+                }
+                duration = Math.min(left, right);
+            }
+        }
+        return duration;
+    }
+}