Added tasks 1828, 1829, 1830, 1832, 1833.

Author: ThanhNIT

src/main/java/g1801_1900/s1828_queries_on_number_of_points_inside_a_circle/Solution.java

@@ -0,0 +1,22 @@
+package g1801_1900.s1828_queries_on_number_of_points_inside_a_circle;
+
+// #Medium #Array #Math #Geometry #2022_05_07_Time_23_ms_(75.03%)_Space_50.5_MB_(46.96%)
+
+public class Solution {
+    public int[] countPoints(int[][] points, int[][] queries) {
+        int[] result = new int[queries.length];
+        int i = 0;
+        for (int[] query : queries) {
+            int pts = 0;
+            for (int[] point : points) {
+                if ((point[0] - query[0]) * (point[0] - query[0])
+                                + (point[1] - query[1]) * (point[1] - query[1])
+                        <= query[2] * query[2]) {
+                    pts++;
+                }
+            }
+            result[i++] = pts;
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,44 @@
+1828\. Queries on Number of Points Inside a Circle
+
+Medium
+
+You are given an array `points` where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> is the coordinates of the <code>i<sup>th</sup></code> point on a 2D plane. Multiple points can have the **same** coordinates.
+
+You are also given an array `queries` where <code>queries[j] = [x<sub>j</sub>, y<sub>j</sub>, r<sub>j</sub>]</code> describes a circle centered at <code>(x<sub>j</sub>, y<sub>j</sub>)</code> with a radius of <code>r<sub>j</sub></code>.
+
+For each query `queries[j]`, compute the number of points **inside** the <code>j<sup>th</sup></code> circle. Points **on the border** of the circle are considered **inside**.
+
+Return _an array_ `answer`_, where_ `answer[j]` _is the answer to the_ <code>j<sup>th</sup></code> _query_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/25/chrome_2021-03-25_22-34-16.png)
+
+**Input:** points = [[1,3],[3,3],[5,3],[2,2]], queries = [[2,3,1],[4,3,1],[1,1,2]]
+
+**Output:** [3,2,2]
+
+**Explanation:** The points and circles are shown above. queries[0] is the green circle, queries[1] is the red circle, and queries[2] is the blue circle.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/25/chrome_2021-03-25_22-42-07.png)
+
+**Input:** points = [[1,1],[2,2],[3,3],[4,4],[5,5]], queries = [[1,2,2],[2,2,2],[4,3,2],[4,3,3]]
+
+**Output:** [2,3,2,4]
+
+**Explanation:** The points and circles are shown above. queries[0] is green, queries[1] is red, queries[2] is blue, and queries[3] is purple.
+
+**Constraints:**
+
+*   `1 <= points.length <= 500`
+*   `points[i].length == 2`
+*   <code>0 <= x<sub>i</sub>, y<sub>i</sub> <= 500</code>
+*   `1 <= queries.length <= 500`
+*   `queries[j].length == 3`
+*   <code>0 <= x<sub>j</sub>, y<sub>j</sub> <= 500</code>
+*   <code>1 <= r<sub>j</sub> <= 500</code>
+*   All coordinates are integers.
+
+**Follow up:** Could you find the answer for each query in better complexity than `O(n)`?

src/main/java/g1801_1900/s1829_maximum_xor_for_each_query/Solution.java

@@ -0,0 +1,20 @@
+package g1801_1900.s1829_maximum_xor_for_each_query;
+
+// #Medium #Array #Bit_Manipulation #Prefix_Sum
+// #2022_05_07_Time_7_ms_(20.94%)_Space_152.5_MB_(6.86%)
+
+public class Solution {
+    public int[] getMaximumXor(int[] nums, int maximumBit) {
+        int[] result = new int[nums.length];
+        long[] xOr = new long[nums.length];
+        xOr[0] = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            xOr[i] ^= xOr[i - 1] ^ nums[i];
+        }
+        long maxNum = (long) Math.pow(2, maximumBit) - 1;
+        for (int i = 0; i < nums.length; i++) {
+            result[nums.length - i - 1] = (int) (maxNum ^ xOr[i]);
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,56 @@
+1829\. Maximum XOR for Each Query
+
+Medium
+
+You are given a **sorted** array `nums` of `n` non-negative integers and an integer `maximumBit`. You want to perform the following query `n` **times**:
+
+1.  Find a non-negative integer <code>k < 2<sup>maximumBit</sup></code> such that `nums[0] XOR nums[1] XOR ... XOR nums[nums.length-1] XOR k` is **maximized**. `k` is the answer to the <code>i<sup>th</sup></code> query.
+2.  Remove the **last** element from the current array `nums`.
+
+Return _an array_ `answer`_, where_ `answer[i]` _is the answer to the_ <code>i<sup>th</sup></code> _query_.
+
+**Example 1:**
+
+**Input:** nums = [0,1,1,3], maximumBit = 2
+
+**Output:** [0,3,2,3]
+
+**Explanation:**: The queries are answered as follows: 
+
+1<sup>st</sup> query: nums = [0,1,1,3], k = 0 since 0 XOR 1 XOR 1 XOR 3 XOR 0 = 3. 
+
+2<sup>nd</sup> query: nums = [0,1,1], k = 3 since 0 XOR 1 XOR 1 XOR 3 = 3. 
+
+3<sup>rd</sup> query: nums = [0,1], k = 2 since 0 XOR 1 XOR 2 = 3. 
+
+4<sup>th</sup> query: nums = [0], k = 3 since 0 XOR 3 = 3.
+
+**Example 2:**
+
+**Input:** nums = [2,3,4,7], maximumBit = 3
+
+**Output:** [5,2,6,5]
+
+**Explanation:**: The queries are answered as follows: 
+
+1<sup>st</sup> query: nums = [2,3,4,7], k = 5 since 2 XOR 3 XOR 4 XOR 7 XOR 5 = 7. 
+
+2<sup>nd</sup> query: nums = [2,3,4], k = 2 since 2 XOR 3 XOR 4 XOR 2 = 7. 
+
+3<sup>rd</sup> query: nums = [2,3], k = 6 since 2 XOR 3 XOR 6 = 7. 
+
+4<sup>th</sup> query: nums = [2], k = 5 since 2 XOR 5 = 7.
+
+**Example 3:**
+
+**Input:** nums = [0,1,2,2,5,7], maximumBit = 3
+
+**Output:** [4,3,6,4,6,7]
+
+**Constraints:**
+
+*   `nums.length == n`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `1 <= maximumBit <= 20`
+*   <code>0 <= nums[i] < 2<sup>maximumBit</sup></code>
+*   `nums` is sorted in **ascending** order.

src/main/java/g1801_1900/s1830_minimum_number_of_operations_to_make_string_sorted/Solution.java

@@ -0,0 +1,55 @@
+package g1801_1900.s1830_minimum_number_of_operations_to_make_string_sorted;
+
+// #Hard #String #Math #Combinatorics #2022_05_07_Time_125_ms_(94.12%)_Space_42.7_MB_(64.71%)
+
+public class Solution {
+    public int makeStringSorted(String s) {
+        int n = s.length();
+        int[] count = new int[26];
+        for (int i = 0; i < n; i++) {
+            count[s.charAt(i) - 'a']++;
+        }
+
+        long[] fact = new long[n + 1];
+        fact[0] = 1;
+        int mod = 1000000007;
+        for (int i = 1; i <= n; i++) {
+            fact[i] = (fact[i - 1] * i) % mod;
+        }
+        int len = n;
+        long ans = 0;
+        for (int i = 0; i < n; i++) {
+            len--;
+            int bound = s.charAt(i) - 'a';
+            int first = 0;
+            long rev = 1;
+            for (int k = 0; k < 26; k++) {
+                if (k < bound) {
+                    first += count[k];
+                }
+                rev = (rev * fact[count[k]]) % mod;
+            }
+            ans =
+                    ans % mod
+                            + (((first * fact[len]) % mod)
+                                            * (modPow(rev, (long) mod - 2, mod))
+                                            % mod)
+                                    % mod;
+            ans = ans % mod;
+            count[bound]--;
+        }
+        return (int) ans;
+    }
+
+    private long modPow(long x, long n, int m) {
+        long result = 1;
+        while (n > 0) {
+            if ((n & 1) != 0) {
+                result = (result * x) % m;
+            }
+            x = (x * x) % m;
+            n = n >> 1;
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,45 @@
+1830\. Minimum Number of Operations to Make String Sorted
+
+Hard
+
+You are given a string `s` (**0-indexed**). You are asked to perform the following operation on `s` until you get a sorted string:
+
+1.  Find **the largest index** `i` such that `1 <= i < s.length` and `s[i] < s[i - 1]`.
+2.  Find **the largest index** `j` such that `i <= j < s.length` and `s[k] < s[i - 1]` for all the possible values of `k` in the range `[i, j]` inclusive.
+3.  Swap the two characters at indices `i - 1` and `j`.
+4.  Reverse the suffix starting at index `i`.
+
+Return _the number of operations needed to make the string sorted._ Since the answer can be too large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** s = "cba"
+
+**Output:** 5
+
+**Explanation:** The simulation goes as follows: Operation 1: i=2, j=2. Swap s[1] and s[2] to get s="cab", then reverse the suffix starting at 2. Now, s="cab".
+
+Operation 2: i=1, j=2. Swap s[0] and s[2] to get s="bac", then reverse the suffix starting at 1. Now, s="bca". 
+
+Operation 3: i=2, j=2. Swap s[1] and s[2] to get s="bac", then reverse the suffix starting at 2. Now, s="bac".
+
+Operation 4: i=1, j=1. Swap s[0] and s[1] to get s="abc", then reverse the suffix starting at 1. Now, s="acb". 
+
+Operation 5: i=2, j=2. Swap s[1] and s[2] to get s="abc", then reverse the suffix starting at 2. Now, s="abc".
+
+**Example 2:**
+
+**Input:** s = "aabaa"
+
+**Output:** 2
+
+**Explanation:** The simulation goes as follows: 
+
+Operation 1: i=3, j=4. Swap s[2] and s[4] to get s="aaaab", then reverse the substring starting at 3. Now, s="aaaba". 
+
+Operation 2: i=4, j=4. Swap s[3] and s[4] to get s="aaaab", then reverse the substring starting at 4. Now, s="aaaab".
+
+**Constraints:**
+
+*   `1 <= s.length <= 3000`
+*   `s` consists only of lowercase English letters.

src/main/java/g1801_1900/s1832_check_if_the_sentence_is_pangram/Solution.java

@@ -0,0 +1,16 @@
+package g1801_1900.s1832_check_if_the_sentence_is_pangram;
+
+// #Easy #String #Hash_Table #2022_05_07_Time_3_ms_(41.29%)_Space_42.1_MB_(54.65%)
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    public boolean checkIfPangram(String sentence) {
+        Set<Character> alphabet = new HashSet<>();
+        for (char c : sentence.toCharArray()) {
+            alphabet.add(c);
+        }
+        return alphabet.size() == 26;
+    }
+}

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

@@ -0,0 +1,26 @@
+1832\. Check if the Sentence Is Pangram
+
+Easy
+
+A **pangram** is a sentence where every letter of the English alphabet appears at least once.
+
+Given a string `sentence` containing only lowercase English letters, return `true` _if_ `sentence` _is a **pangram**, or_ `false` _otherwise._
+
+**Example 1:**
+
+**Input:** sentence = "thequickbrownfoxjumpsoverthelazydog"
+
+**Output:** true
+
+**Explanation:** sentence contains at least one of every letter of the English alphabet.
+
+**Example 2:**
+
+**Input:** sentence = "leetcode"
+
+**Output:** false
+
+**Constraints:**
+
+*   `1 <= sentence.length <= 1000`
+*   `sentence` consists of lowercase English letters.

src/main/java/g1801_1900/s1833_maximum_ice_cream_bars/Solution.java

@@ -0,0 +1,19 @@
+package g1801_1900.s1833_maximum_ice_cream_bars;
+
+// #Medium #Array #Sorting #Greedy #2022_05_07_Time_39_ms_(84.49%)_Space_56.7_MB_(78.12%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int maxIceCream(int[] costs, int coins) {
+        Arrays.sort(costs);
+        int i = 0;
+        int ans = 0;
+        while (i < costs.length && costs[i] <= coins) {
+            coins -= costs[i];
+            i++;
+            ans++;
+        }
+        return ans;
+    }
+}

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

@@ -0,0 +1,42 @@
+1833\. Maximum Ice Cream Bars
+
+Medium
+
+It is a sweltering summer day, and a boy wants to buy some ice cream bars.
+
+At the store, there are `n` ice cream bars. You are given an array `costs` of length `n`, where `costs[i]` is the price of the <code>i<sup>th</sup></code> ice cream bar in coins. The boy initially has `coins` coins to spend, and he wants to buy as many ice cream bars as possible.
+
+Return _the **maximum** number of ice cream bars the boy can buy with_ `coins` _coins._
+
+**Note:** The boy can buy the ice cream bars in any order.
+
+**Example 1:**
+
+**Input:** costs = [1,3,2,4,1], coins = 7
+
+**Output:** 4
+
+**Explanation:** The boy can buy ice cream bars at indices 0,1,2,4 for a total price of 1 + 3 + 2 + 1 = 7.
+
+**Example 2:**
+
+**Input:** costs = [10,6,8,7,7,8], coins = 5
+
+**Output:** 0
+
+**Explanation:** The boy cannot afford any of the ice cream bars.
+
+**Example 3:**
+
+**Input:** costs = [1,6,3,1,2,5], coins = 20
+
+**Output:** 6
+
+**Explanation:** The boy can buy all the ice cream bars for a total price of 1 + 6 + 3 + 1 + 2 + 5 = 18.
+
+**Constraints:**
+
+*   `costs.length == n`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= costs[i] <= 10<sup>5</sup></code>
+*   <code>1 <= coins <= 10<sup>8</sup></code>

src/test/java/g1801_1900/s1828_queries_on_number_of_points_inside_a_circle/SolutionTest.java

@@ -0,0 +1,28 @@
+package g1801_1900.s1828_queries_on_number_of_points_inside_a_circle;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void countPoints() {
+        assertThat(
+                new Solution()
+                        .countPoints(
+                                new int[][] {{1, 3}, {3, 3}, {5, 3}, {2, 2}},
+                                new int[][] {{2, 3, 1}, {4, 3, 1}, {1, 1, 2}}),
+                equalTo(new int[] {3, 2, 2}));
+    }
+
+    @Test
+    void countPoints2() {
+        assertThat(
+                new Solution()
+                        .countPoints(
+                                new int[][] {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}},
+                                new int[][] {{1, 2, 2}, {2, 2, 2}, {4, 3, 2}, {4, 3, 3}}),
+                equalTo(new int[] {2, 3, 2, 4}));
+    }
+}