Added tasks 2038, 2040, 2042, 2043, 2044.

Author: ThanhNIT

src/main/java/g2001_2100/s2038_remove_colored_pieces_if_both_neighbors_are_the_same_color/Solution.java

@@ -0,0 +1,20 @@
+package g2001_2100.s2038_remove_colored_pieces_if_both_neighbors_are_the_same_color;
+
+// #Medium #String #Math #Greedy #Game_Theory #2022_05_26_Time_22_ms_(47.78%)_Space_53.9_MB_(61.32%)
+
+public class Solution {
+    public boolean winnerOfGame(String colors) {
+        int ans = 0;
+        for (int i = 1; i < colors.length() - 1; i++) {
+            if (colors.charAt(i) == colors.charAt(i - 1)
+                    && colors.charAt(i) == colors.charAt(i + 1)) {
+                if (colors.charAt(i) == 'A') {
+                    ans++;
+                } else {
+                    ans--;
+                }
+            }
+        }
+        return ans > 0;
+    }
+}

src/main/java/g2001_2100/s2038_remove_colored_pieces_if_both_neighbors_are_the_same_color/readme.md

@@ -0,0 +1,77 @@
+2038\. Remove Colored Pieces if Both Neighbors are the Same Color
+
+Medium
+
+There are `n` pieces arranged in a line, and each piece is colored either by `'A'` or by `'B'`. You are given a string `colors` of length `n` where `colors[i]` is the color of the <code>i<sup>th</sup></code> piece.
+
+Alice and Bob are playing a game where they take **alternating turns** removing pieces from the line. In this game, Alice moves **first**.
+
+*   Alice is only allowed to remove a piece colored `'A'` if **both its neighbors** are also colored `'A'`. She is **not allowed** to remove pieces that are colored `'B'`.
+*   Bob is only allowed to remove a piece colored `'B'` if **both its neighbors** are also colored `'B'`. He is **not allowed** to remove pieces that are colored `'A'`.
+*   Alice and Bob **cannot** remove pieces from the edge of the line.
+*   If a player cannot make a move on their turn, that player **loses** and the other player **wins**.
+
+Assuming Alice and Bob play optimally, return `true` _if Alice wins, or return_ `false` _if Bob wins_.
+
+**Example 1:**
+
+**Input:** colors = "AAABABB"
+
+**Output:** true
+
+**Explanation:** 
+
+AAABABB -> AABABB 
+
+Alice moves first. 
+
+She removes the second 'A' from the left since that is the only 'A' whose neighbors are both 'A'. 
+
+Now it's Bob's turn. 
+
+Bob cannot make a move on his turn since there are no 'B's whose neighbors are both 'B'.
+
+Thus, Alice wins, so return true.
+
+**Example 2:**
+
+**Input:** colors = "AA"
+
+**Output:** false
+
+**Explanation:** 
+
+Alice has her turn first. 
+
+There are only two 'A's and both are on the edge of the line, so she cannot move on her turn.
+
+Thus, Bob wins, so return false.
+
+**Example 3:**
+
+**Input:** colors = "ABBBBBBBAAA"
+
+**Output:** false
+
+**Explanation:** 
+
+ABBBBBBBAAA -> ABBBBBBBAA 
+
+Alice moves first. 
+
+Her only option is to remove the second to last 'A' from the right. 
+
+ABBBBBBBAA -> ABBBBBBAA 
+
+Next is Bob's turn. 
+
+He has many options for which 'B' piece to remove. 
+
+He can pick any. On Alice's second turn, she has no more pieces that she can remove.
+
+Thus, Bob wins, so return false.
+
+**Constraints:**
+
+*   <code>1 <= colors.length <= 10<sup>5</sup></code>
+*   `colors` consists of only the letters `'A'` and `'B'`

src/main/java/g2001_2100/s2040_kth_smallest_product_of_two_sorted_arrays/Solution.java

@@ -0,0 +1,52 @@
+package g2001_2100.s2040_kth_smallest_product_of_two_sorted_arrays;
+
+// #Hard #Array #Binary_Search #2022_05_26_Time_635_ms_(75.24%)_Space_50.6_MB_(92.26%)
+
+public class Solution {
+    static long inf = (long) 1e10;
+
+    public long kthSmallestProduct(int[] nums1, int[] nums2, long k) {
+        int n = nums2.length;
+        long lo = -inf - 1;
+        long hi = inf + 1;
+        while (lo < hi) {
+            long mid = lo + ((hi - lo) >> 1);
+            long cnt = 0;
+            for (int i : nums1) {
+                int l = 0;
+                int r = n - 1;
+                int p = 0;
+                if (0 <= i) {
+                    while (l <= r) {
+                        int c = l + ((r - l) >> 1);
+                        long mul = i * (long) nums2[c];
+                        if (mul <= mid) {
+                            p = c + 1;
+                            l = c + 1;
+                        } else {
+                            r = c - 1;
+                        }
+                    }
+                } else {
+                    while (l <= r) {
+                        int c = l + ((r - l) >> 1);
+                        long mul = i * (long) nums2[c];
+                        if (mul <= mid) {
+                            p = n - c;
+                            r = c - 1;
+                        } else {
+                            l = c + 1;
+                        }
+                    }
+                }
+                cnt += p;
+            }
+            if (cnt >= k) {
+                hi = mid;
+            } else {
+                lo = mid + 1L;
+            }
+        }
+        return lo;
+    }
+}

src/main/java/g2001_2100/s2040_kth_smallest_product_of_two_sorted_arrays/readme.md

@@ -0,0 +1,64 @@
+2040\. Kth Smallest Product of Two Sorted Arrays
+
+Hard
+
+Given two **sorted 0-indexed** integer arrays `nums1` and `nums2` as well as an integer `k`, return _the_ <code>k<sup>th</sup></code> _(**1-based**) smallest product of_ `nums1[i] * nums2[j]` _where_ `0 <= i < nums1.length` _and_ `0 <= j < nums2.length`.
+
+**Example 1:**
+
+**Input:** nums1 = [2,5], nums2 = [3,4], k = 2
+
+**Output:** 8
+
+**Explanation:** The 2 smallest products are: 
+
+- nums1[0] \* nums2[0] = 2 \* 3 = 6 
+
+- nums1[0] \* nums2[1] = 2 \* 4 = 8 
+  
+The 2<sup>nd</sup> smallest product is 8.
+
+**Example 2:**
+
+**Input:** nums1 = [-4,-2,0,3], nums2 = [2,4], k = 6
+
+**Output:** 0
+
+**Explanation:** The 6 smallest products are: 
+
+- nums1[0] \* nums2[1] = (-4) \* 4 = -16 
+
+- nums1[0] \* nums2[0] = (-4) \* 2 = -8 
+
+- nums1[1] \* nums2[1] = (-2) \* 4 = -8 
+
+- nums1[1] \* nums2[0] = (-2) \* 2 = -4 
+
+- nums1[2] \* nums2[0] = 0 \* 2 = 0 
+
+- nums1[2] \* nums2[1] = 0 \* 4 = 0 
+  
+The 6<sup>th</sup> smallest product is 0.
+
+**Example 3:**
+
+**Input:** nums1 = [-2,-1,0,1,2], nums2 = [-3,-1,2,4,5], k = 3
+
+**Output:** -6
+
+**Explanation:** The 3 smallest products are: 
+
+- nums1[0] \* nums2[4] = (-2) \* 5 = -10 
+
+- nums1[0] \* nums2[3] = (-2) \* 4 = -8 
+
+- nums1[4] \* nums2[0] = 2 \* (-3) = -6 
+  
+The 3<sup>rd</sup> smallest product is -6.
+
+**Constraints:**
+
+*   <code>1 <= nums1.length, nums2.length <= 5 * 10<sup>4</sup></code>
+*   <code>-10<sup>5</sup> <= nums1[i], nums2[j] <= 10<sup>5</sup></code>
+*   `1 <= k <= nums1.length * nums2.length`
+*   `nums1` and `nums2` are sorted.

src/main/java/g2001_2100/s2042_check_if_numbers_are_ascending_in_a_sentence/Solution.java

@@ -0,0 +1,20 @@
+package g2001_2100.s2042_check_if_numbers_are_ascending_in_a_sentence;
+
+// #Easy #String #2022_05_26_Time_2_ms_(75.46%)_Space_42.7_MB_(29.81%)
+
+public class Solution {
+    public boolean areNumbersAscending(String s) {
+        String[] words = s.split("\\ ");
+        int prev = 0;
+        for (String word : words) {
+            if (Character.isDigit(word.charAt(0))) {
+                if (Integer.parseInt(word) <= prev) {
+                    return false;
+                } else {
+                    prev = Integer.parseInt(word);
+                }
+            }
+        }
+        return true;
+    }
+}

src/main/java/g2001_2100/s2042_check_if_numbers_are_ascending_in_a_sentence/readme.md

@@ -0,0 +1,49 @@
+2042\. Check if Numbers Are Ascending in a Sentence
+
+Easy
+
+A sentence is a list of **tokens** separated by a **single** space with no leading or trailing spaces. Every token is either a **positive number** consisting of digits `0-9` with no leading zeros, or a **word** consisting of lowercase English letters.
+
+*   For example, `"a puppy has 2 eyes 4 legs"` is a sentence with seven tokens: `"2"` and `"4"` are numbers and the other tokens such as `"puppy"` are words.
+
+Given a string `s` representing a sentence, you need to check if **all** the numbers in `s` are **strictly increasing** from left to right (i.e., other than the last number, **each** number is **strictly smaller** than the number on its **right** in `s`).
+
+Return `true` _if so, or_ `false` _otherwise_.
+
+**Example 1:**
+
+![example-1](https://assets.leetcode.com/uploads/2021/09/30/example1.png)
+
+**Input:** s = "1 box has 3 blue 4 red 6 green and 12 yellow marbles"
+
+**Output:** true
+
+**Explanation:** The numbers in s are: 1, 3, 4, 6, 12. They are strictly increasing from left to right: 1 < 3 < 4 < 6 < 12.
+
+**Example 2:**
+
+**Input:** s = "hello world 5 x 5"
+
+**Output:** false
+
+**Explanation:** The numbers in s are: **5**, **5**. They are not strictly increasing.
+
+**Example 3:**
+
+![example-3](https://assets.leetcode.com/uploads/2021/09/30/example3.png)
+
+**Input:** s = "sunset is at 7 51 pm overnight lows will be in the low 50 and 60 s"
+
+**Output:** false
+
+**Explanation:** The numbers in s are: 7, **51**, **50**, 60. They are not strictly increasing.
+
+**Constraints:**
+
+*   `3 <= s.length <= 200`
+*   `s` consists of lowercase English letters, spaces, and digits from `0` to `9`, inclusive.
+*   The number of tokens in `s` is between `2` and `100`, inclusive.
+*   The tokens in `s` are separated by a single space.
+*   There are at least **two** numbers in `s`.
+*   Each number in `s` is a **positive** number **less** than `100`, with no leading zeros.
+*   `s` contains no leading or trailing spaces.

src/main/java/g2001_2100/s2043_simple_bank_system/Bank.java

@@ -0,0 +1,41 @@
+package g2001_2100.s2043_simple_bank_system;
+
+// #Medium #Array #Hash_Table #Design #Simulation
+// #2022_05_26_Time_159_ms_(48.01%)_Space_133.1_MB_(20.58%)
+
+public class Bank {
+    private final long[] accounts;
+
+    public Bank(long[] balance) {
+        accounts = balance;
+    }
+
+    private boolean validate(int account, long money, boolean withdraw) {
+        return account < accounts.length && (!withdraw || accounts[account] >= money);
+    }
+
+    public boolean transfer(int account1, int account2, long money) {
+        if (validate(account1 - 1, money, true) && validate(account2 - 1, 0, false)) {
+            accounts[account1 - 1] -= money;
+            accounts[account2 - 1] += money;
+            return true;
+        }
+        return false;
+    }
+
+    public boolean deposit(int account, long money) {
+        if (validate(account - 1, money, false)) {
+            accounts[account - 1] += money;
+            return true;
+        }
+        return false;
+    }
+
+    public boolean withdraw(int account, long money) {
+        if (validate(account - 1, money, true)) {
+            accounts[account - 1] -= money;
+            return true;
+        }
+        return false;
+    }
+}

src/main/java/g2001_2100/s2043_simple_bank_system/readme.md

@@ -0,0 +1,48 @@
+2043\. Simple Bank System
+
+Medium
+
+You have been tasked with writing a program for a popular bank that will automate all its incoming transactions (transfer, deposit, and withdraw). The bank has `n` accounts numbered from `1` to `n`. The initial balance of each account is stored in a **0-indexed** integer array `balance`, with the <code>(i + 1)<sup>th</sup></code> account having an initial balance of `balance[i]`.
+
+Execute all the **valid** transactions. A transaction is **valid** if:
+
+*   The given account number(s) are between `1` and `n`, and
+*   The amount of money withdrawn or transferred from is **less than or equal** to the balance of the account.
+
+Implement the `Bank` class:
+
+*   `Bank(long[] balance)` Initializes the object with the **0-indexed** integer array `balance`.
+*   `boolean transfer(int account1, int account2, long money)` Transfers `money` dollars from the account numbered `account1` to the account numbered `account2`. Return `true` if the transaction was successful, `false` otherwise.
+*   `boolean deposit(int account, long money)` Deposit `money` dollars into the account numbered `account`. Return `true` if the transaction was successful, `false` otherwise.
+*   `boolean withdraw(int account, long money)` Withdraw `money` dollars from the account numbered `account`. Return `true` if the transaction was successful, `false` otherwise.
+
+**Example 1:**
+
+**Input** ["Bank", "withdraw", "transfer", "deposit", "transfer", "withdraw"] [[[10, 100, 20, 50, 30]], [3, 10], [5, 1, 20], [5, 20], [3, 4, 15], [10, 50]]
+
+**Output:** [null, true, true, true, false, false]
+
+**Explanation:** 
+
+Bank bank = new Bank([10, 100, 20, 50, 30]); 
+
+bank.withdraw(3, 10); // return true, account 3 has a balance of $20, so it is valid to withdraw $10. 
+                       // Account 3 has $20 - $10 = $10. 
+
+bank.transfer(5, 1, 20); // return true, account 5 has a balance of $30, so it is valid to transfer $20.
+                         // Account 5 has $30 - $20 = $10, and account 1 has $10 + $20 = $30. 
+
+bank.deposit(5, 20); // return true, it is valid to deposit $20 to account 5. 
+                     // Account 5 has $10 + $20 = $30.
+
+bank.transfer(3, 4, 15); // return false, the current balance of account 3 is $10, 
+                         // so it is invalid to transfer $15 from it.
+
+bank.withdraw(10, 50); // return false, it is invalid because account 10 does not exist.
+
+**Constraints:**
+
+*   `n == balance.length`
+*   <code>1 <= n, account, account1, account2 <= 10<sup>5</sup></code>
+*   <code>0 <= balance[i], money <= 10<sup>12</sup></code>
+*   At most <code>10<sup>4</sup></code> calls will be made to **each** function `transfer`, `deposit`, `withdraw`.