Added tasks 2511, 2512, 2513, 2514, 2515

Author: ThanhNIT

README.md

@@ -1848,6 +1848,11 @@ implementation 'com.github.javadev:leetcode-in-java:1.19'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2515 |[Shortest Distance to Target String in a Circular Array](src/main/java/g2501_2600/s2515_shortest_distance_to_target_string_in_a_circular_array/Solution.java)| Easy | Array, String | 1 | 62.21
+| 2514 |[Count Anagrams](src/main/java/g2501_2600/s2514_count_anagrams/Solution.java)| Hard | String, Hash_Table, Math, Counting, Combinatorics | 22 | 100.00
+| 2513 |[Minimize the Maximum of Two Arrays](src/main/java/g2501_2600/s2513_minimize_the_maximum_of_two_arrays/Solution.java)| Medium | Math, Binary_Search, Number_Theory | 0 | 100.00
+| 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
 | 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

src/main/java/g2501_2600/s2511_maximum_enemy_forts_that_can_be_captured/Solution.java

@@ -0,0 +1,38 @@
+package g2501_2600.s2511_maximum_enemy_forts_that_can_be_captured;
+
+// #Easy #Array #Two_Pointers #2023_03_21_Time_0_ms_(100.00%)_Space_40.9_MB_(19.40%)
+
+public class Solution {
+    public int captureForts(int[] forts) {
+        int maxCapture = 0;
+        int n = forts.length;
+        int i = 0;
+        while (i < n) {
+            if (forts[i] == 1) {
+                int currMax = 0;
+                i++;
+                while (i < n && forts[i] == 0) {
+                    currMax++;
+                    i++;
+                }
+                if (i < n && forts[i] == -1) {
+                    maxCapture = Math.max(maxCapture, currMax);
+                }
+                i--;
+            } else if (forts[i] == -1) {
+                int currMax = 0;
+                i++;
+                while (i < n && forts[i] == 0) {
+                    currMax++;
+                    i++;
+                }
+                if (i < n && forts[i] == 1) {
+                    maxCapture = Math.max(maxCapture, currMax);
+                }
+                i--;
+            }
+            i++;
+        }
+        return maxCapture;
+    }
+}

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

@@ -0,0 +1,45 @@
+2511\. Maximum Enemy Forts That Can Be Captured
+
+Easy
+
+You are given a **0-indexed** integer array `forts` of length `n` representing the positions of several forts. `forts[i]` can be `-1`, `0`, or `1` where:
+
+*   `-1` represents there is **no fort** at the <code>i<sup>th</sup></code> position.
+*   `0` indicates there is an **enemy** fort at the <code>i<sup>th</sup></code> position.
+*   `1` indicates the fort at the <code>i<sup>th</sup></code> the position is under your command.
+
+Now you have decided to move your army from one of your forts at position `i` to an empty position `j` such that:
+
+*   `0 <= i, j <= n - 1`
+*   The army travels over enemy forts **only**. Formally, for all `k` where `min(i,j) < k < max(i,j)`, `forts[k] == 0.`
+
+While moving the army, all the enemy forts that come in the way are **captured**.
+
+Return _the **maximum** number of enemy forts that can be captured_. In case it is **impossible** to move your army, or you do not have any fort under your command, return `0`_._
+
+**Example 1:**
+
+**Input:** forts = [1,0,0,-1,0,0,0,0,1]
+
+**Output:** 4
+
+**Explanation:** 
+
+- Moving the army from position 0 to position 3 captures 2 enemy forts, at 1 and 2. 
+
+- Moving the army from position 8 to position 3 captures 4 enemy forts. 
+
+Since 4 is the maximum number of enemy forts that can be captured, we return 4.
+
+**Example 2:**
+
+**Input:** forts = [0,0,1,-1]
+
+**Output:** 0
+
+**Explanation:** Since no enemy fort can be captured, 0 is returned.
+
+**Constraints:**
+
+*   `1 <= forts.length <= 1000`
+*   `-1 <= forts[i] <= 1`

src/main/java/g2501_2600/s2512_reward_top_k_students/Solution.java

@@ -0,0 +1,55 @@
+package g2501_2600.s2512_reward_top_k_students;
+
+// #Medium #Array #String #Hash_Table #Sorting #Heap_Priority_Queue
+// #2023_03_21_Time_72_ms_(94.76%)_Space_51.1_MB_(21.67%)
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.PriorityQueue;
+
+public class Solution {
+    public List<Integer> topStudents(
+            String[] positiveFeedback,
+            String[] negativeFeedback,
+            String[] report,
+            int[] studentId,
+            int k) {
+        HashMap<String, Integer> feedback = new HashMap<>();
+        for (String s : positiveFeedback) {
+            feedback.put(s, 3);
+        }
+        for (String s : negativeFeedback) {
+            feedback.put(s, -1);
+        }
+        PriorityQueue<Student> pq =
+                new PriorityQueue<>(
+                        (a, b) -> {
+                            int result = Integer.compare(a.points, b.points);
+                            return result == 0 ? Integer.compare(a.id, b.id) : -result;
+                        });
+        for (int i = 0; i < report.length; i++) {
+            String[] split = report[i].split(" ");
+            int sum = 0;
+            for (String subStr : split) {
+                sum += feedback.getOrDefault(subStr, 0);
+            }
+            pq.offer(new Student(studentId[i], sum));
+        }
+        List<Integer> result = new ArrayList<>();
+        while (!pq.isEmpty() && k-- > 0) {
+            result.add(pq.poll().id);
+        }
+        return result;
+    }
+
+    private static class Student {
+        int points;
+        int id;
+
+        public Student(int id, int points) {
+            this.id = id;
+            this.points = points;
+        }
+    }
+}

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

@@ -0,0 +1,46 @@
+2512\. Reward Top K Students
+
+Medium
+
+You are given two string arrays `positive_feedback` and `negative_feedback`, containing the words denoting positive and negative feedback, respectively. Note that **no** word is both positive and negative.
+
+Initially every student has `0` points. Each positive word in a feedback report **increases** the points of a student by `3`, whereas each negative word **decreases** the points by `1`.
+
+You are given `n` feedback reports, represented by a **0-indexed** string array `report` and a **0-indexed** integer array `student_id`, where `student_id[i]` represents the ID of the student who has received the feedback report `report[i]`. The ID of each student is **unique**.
+
+Given an integer `k`, return _the top_ `k` _students after ranking them in **non-increasing** order by their points_. In case more than one student has the same points, the one with the lower ID ranks higher.
+
+**Example 1:**
+
+**Input:** positive\_feedback = ["smart","brilliant","studious"], negative\_feedback = ["not"], report = ["this student is studious","the student is smart"], student\_id = [1,2], k = 2
+
+**Output:** [1,2]
+
+**Explanation:** Both the students have 1 positive feedback and 3 points but since student 1 has a lower ID he ranks higher.
+
+**Example 2:**
+
+**Input:** positive\_feedback = ["smart","brilliant","studious"], negative\_feedback = ["not"], report = ["this student is not studious","the student is smart"], student\_id = [1,2], k = 2
+
+**Output:** [2,1]
+
+**Explanation:** 
+
+- The student with ID 1 has 1 positive feedback and 1 negative feedback, so he has 3-1=2 points. 
+
+- The student with ID 2 has 1 positive feedback, so he has 3 points. Since student 2 has more points, [2,1] is returned.
+
+**Constraints:**
+
+*   <code>1 <= positive_feedback.length, negative_feedback.length <= 10<sup>4</sup></code>
+*   `1 <= positive_feedback[i].length, negative_feedback[j].length <= 100`
+*   Both `positive_feedback[i]` and `negative_feedback[j]` consists of lowercase English letters.
+*   No word is present in both `positive_feedback` and `negative_feedback`.
+*   `n == report.length == student_id.length`
+*   <code>1 <= n <= 10<sup>4</sup></code>
+*   `report[i]` consists of lowercase English letters and spaces `' '`.
+*   There is a single space between consecutive words of `report[i]`.
+*   `1 <= report[i].length <= 100`
+*   <code>1 <= student_id[i] <= 10<sup>9</sup></code>
+*   All the values of `student_id[i]` are **unique**.
+*   `1 <= k <= n`

src/main/java/g2501_2600/s2513_minimize_the_maximum_of_two_arrays/Solution.java

@@ -0,0 +1,34 @@
+package g2501_2600.s2513_minimize_the_maximum_of_two_arrays;
+
+// #Medium #Math #Binary_Search #Number_Theory
+// #2023_03_21_Time_0_ms_(100.00%)_Space_39.4_MB_(35.80%)
+
+public class Solution {
+    private int gcd(int a, int b) {
+        if (b == 0) {
+            return a;
+        }
+        return gcd(b, a % b);
+    }
+
+    public int minimizeSet(int divisor1, int divisor2, int uniqueCnt1, int uniqueCnt2) {
+        long lo = 1;
+        long hi = (int) 10e10;
+        if (divisor2 == 0) {
+            divisor2 = 1;
+        }
+        long lcm = ((long) divisor1 * (long) divisor2) / gcd(divisor1, divisor2);
+        while (lo < hi) {
+            long mi = lo + (hi - lo) / 2;
+            int cnt1 = (int) (mi - mi / divisor1);
+            int cnt2 = (int) (mi - mi / divisor2);
+            int cntAll = (int) (mi - mi / lcm);
+            if (cnt1 < uniqueCnt1 || cnt2 < uniqueCnt2 || cntAll < uniqueCnt1 + uniqueCnt2) {
+                lo = mi + 1;
+            } else {
+                hi = mi;
+            }
+        }
+        return (int) lo;
+    }
+}

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

@@ -0,0 +1,57 @@
+2513\. Minimize the Maximum of Two Arrays
+
+Medium
+
+We have two arrays `arr1` and `arr2` which are initially empty. You need to add positive integers to them such that they satisfy all the following conditions:
+
+*   `arr1` contains `uniqueCnt1` **distinct** positive integers, each of which is **not divisible** by `divisor1`.
+*   `arr2` contains `uniqueCnt2` **distinct** positive integers, each of which is **not divisible** by `divisor2`.
+*   **No** integer is present in both `arr1` and `arr2`.
+
+Given `divisor1`, `divisor2`, `uniqueCnt1`, and `uniqueCnt2`, return _the **minimum possible maximum** integer that can be present in either array_.
+
+**Example 1:**
+
+**Input:** divisor1 = 2, divisor2 = 7, uniqueCnt1 = 1, uniqueCnt2 = 3
+
+**Output:** 4
+
+**Explanation:**
+
+We can distribute the first 4 natural numbers into arr1 and arr2. 
+
+arr1 = [1] and arr2 = [2,3,4]. 
+
+We can see that both arrays satisfy all the conditions. 
+
+Since the maximum value is 4, we return it.
+
+**Example 2:**
+
+**Input:** divisor1 = 3, divisor2 = 5, uniqueCnt1 = 2, uniqueCnt2 = 1
+
+**Output:** 3
+
+**Explanation:** 
+
+Here arr1 = [1,2], and arr2 = [3] satisfy all conditions. 
+
+Since the maximum value is 3, we return it.
+
+**Example 3:**
+
+**Input:** divisor1 = 2, divisor2 = 4, uniqueCnt1 = 8, uniqueCnt2 = 2
+
+**Output:** 15
+
+**Explanation:** 
+
+Here, the final possible arrays can be arr1 = [1,3,5,7,9,11,13,15], and arr2 = [2,6]. 
+
+It can be shown that it is not possible to obtain a lower maximum satisfying all conditions.
+
+**Constraints:**
+
+*   <code>2 <= divisor1, divisor2 <= 10<sup>5</sup></code>
+*   <code>1 <= uniqueCnt1, uniqueCnt2 < 10<sup>9</sup></code>
+*   <code>2 <= uniqueCnt1 + uniqueCnt2 <= 10<sup>9</sup></code>

src/main/java/g2501_2600/s2514_count_anagrams/Solution.java

@@ -0,0 +1,39 @@
+package g2501_2600.s2514_count_anagrams;
+
+// #Hard #String #Hash_Table #Math #Counting #Combinatorics
+// #2023_03_21_Time_22_ms_(100.00%)_Space_43_MB_(98.15%)
+
+import java.util.Arrays;
+
+public class Solution {
+    private static final int MOD = (int) 1e9 + 7;
+
+    public int countAnagrams(String s) {
+        var charArray = s.toCharArray();
+        long ans = 1L;
+        long mul = 1L;
+        var cnt = new int[26];
+        int j = 0;
+        for (char c : charArray) {
+            if (c == ' ') {
+                Arrays.fill(cnt, 0);
+                j = 0;
+            } else {
+                mul = mul * ++cnt[c - 'a'] % MOD;
+                ans = ans * ++j % MOD;
+            }
+        }
+        return (int) (ans * pow(mul, MOD - 2) % MOD);
+    }
+
+    private long pow(long x, int n) {
+        var res = 1L;
+        for (; n > 0; n /= 2) {
+            if (n % 2 > 0) {
+                res = res * x % MOD;
+            }
+            x = x * x % MOD;
+        }
+        return res;
+    }
+}

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

@@ -0,0 +1,33 @@
+2514\. Count Anagrams
+
+Hard
+
+You are given a string `s` containing one or more words. Every consecutive pair of words is separated by a single space `' '`.
+
+A string `t` is an **anagram** of string `s` if the <code>i<sup>th</sup></code> word of `t` is a **permutation** of the <code>i<sup>th</sup></code> word of `s`.
+
+*   For example, `"acb dfe"` is an anagram of `"abc def"`, but `"def cab"` and `"adc bef"` are not.
+
+Return _the number of **distinct anagrams** of_ `s`. Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** s = "too hot"
+
+**Output:** 18
+
+**Explanation:** Some of the anagrams of the given string are "too hot", "oot hot", "oto toh", "too toh", and "too oht".
+
+**Example 2:**
+
+**Input:** s = "aa"
+
+**Output:** 1
+
+**Explanation:** There is only one anagram possible for the given string.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of lowercase English letters and spaces `' '`.
+*   There is single space between consecutive words.

src/main/java/g2501_2600/s2515_shortest_distance_to_target_string_in_a_circular_array/Solution.java

@@ -0,0 +1,26 @@
+package g2501_2600.s2515_shortest_distance_to_target_string_in_a_circular_array;
+
+// #Easy #Array #String #2023_03_21_Time_1_ms_(62.21%)_Space_42.6_MB_(84.53%)
+
+public class Solution {
+    public int closetTarget(String[] words, String target, int startIndex) {
+        int n = words.length;
+        if (words[startIndex].equals(target)) {
+            return 0;
+        }
+        int ld = -1;
+        int rd;
+        int ans = Integer.MAX_VALUE;
+        for (int i = (startIndex + 1) % n; i != startIndex; i = (i + 1) % n) {
+            if (words[i].equals(target)) {
+                ld = i > startIndex ? startIndex + (n - i) : startIndex - i;
+                rd = i > startIndex ? i - startIndex : n - startIndex + i;
+                ans = Math.min(ans, Math.min(ld, rd));
+            }
+        }
+        if (ld == -1) {
+            return -1;
+        }
+        return ans;
+    }
+}