Added tasks 1103, 1104, 1105, 1106, 1108.

Author: ThanhNIT

src/main/java/g1101_1200/s1103_distribute_candies_to_people/Solution.java

@@ -0,0 +1,29 @@
+package g1101_1200.s1103_distribute_candies_to_people;
+
+// #Easy #Math #Simulation #2022_02_28_Time_2_ms_(49.07%)_Space_41.9_MB_(19.20%)
+
+public class Solution {
+    public int[] distributeCandies(int candies, int numPeople) {
+        int[] candiesDistribution = new int[numPeople];
+        int count = 1;
+
+        while (candies > 0) {
+            for (int i = 0; i < numPeople; i++) {
+                if (candies >= count) {
+                    candiesDistribution[i] += count;
+                    candies -= count;
+                    count++;
+                } else if (candies > 0) {
+                    candiesDistribution[i] += candies;
+                    candies -= candies;
+                }
+
+                if (candies == 0) {
+                    return candiesDistribution;
+                }
+            }
+        }
+
+        return candiesDistribution;
+    }
+}

src/main/java/g1101_1200/s1103_distribute_candies_to_people/readme.md

@@ -0,0 +1,50 @@
+1103\. Distribute Candies to People
+
+Easy
+
+We distribute some number of `candies`, to a row of **`n = num_people`** people in the following way:
+
+We then give 1 candy to the first person, 2 candies to the second person, and so on until we give `n` candies to the last person.
+
+Then, we go back to the start of the row, giving `n + 1` candies to the first person, `n + 2` candies to the second person, and so on until we give `2 * n` candies to the last person.
+
+This process repeats (with us giving one more candy each time, and moving to the start of the row after we reach the end) until we run out of candies. The last person will receive all of our remaining candies (not necessarily one more than the previous gift).
+
+Return an array (of length `num_people` and sum `candies`) that represents the final distribution of candies.
+
+**Example 1:**
+
+**Input:** candies = 7, num\_people = 4
+
+**Output:** [1,2,3,1]
+
+**Explanation:** 
+
+On the first turn, ans[0] += 1, and the array is [1,0,0,0]. 
+
+On the second turn, ans[1] += 2, and the array is [1,2,0,0]. 
+
+On the third turn, ans[2] += 3, and the array is [1,2,3,0]. 
+
+On the fourth turn, ans[3] += 1 (because there is only one candy left), and the final array is [1,2,3,1].
+
+**Example 2:**
+
+**Input:** candies = 10, num\_people = 3
+
+**Output:** [5,2,3]
+
+**Explanation:**  
+
+On the first turn, ans[0] += 1, and the array is [1,0,0]. 
+
+On the second turn, ans[1] += 2, and the array is [1,2,0]. 
+
+On the third turn, ans[2] += 3, and the array is [1,2,3]. 
+
+On the fourth turn, ans[0] += 4, and the final array is [5,2,3].
+
+**Constraints:**
+
+*   1 <= candies <= 10^9
+*   1 <= num\_people <= 1000

src/main/java/g1101_1200/s1104_path_in_zigzag_labelled_binary_tree/Solution.java

@@ -0,0 +1,23 @@
+package g1101_1200.s1104_path_in_zigzag_labelled_binary_tree;
+
+// #Medium #Math #Tree #Binary_Tree #2022_02_28_Time_1_ms_(58.50%)_Space_41.6_MB_(28.60%)
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class Solution {
+    public List<Integer> pathInZigZagTree(int label) {
+        List<Integer> answer = new LinkedList<>();
+        while (label != 0) {
+            answer.add(0, label);
+            int logNode = (int) (Math.log(label) / Math.log(2));
+            int levelStart = (int) (Math.pow(2, logNode));
+            int diff = label - levelStart;
+            int d2 = diff / 2;
+            int prevEnd = levelStart - 1;
+            int prevLabel = prevEnd - d2;
+            label = prevLabel;
+        }
+        return answer;
+    }
+}

src/main/java/g1101_1200/s1104_path_in_zigzag_labelled_binary_tree/readme.md

@@ -0,0 +1,27 @@
+1104\. Path In Zigzag Labelled Binary Tree
+
+Medium
+
+In an infinite binary tree where every node has two children, the nodes are labelled in row order.
+
+In the odd numbered rows (ie., the first, third, fifth,...), the labelling is left to right, while in the even numbered rows (second, fourth, sixth,...), the labelling is right to left.
+
+![](https://assets.leetcode.com/uploads/2019/06/24/tree.png)
+
+Given the `label` of a node in this tree, return the labels in the path from the root of the tree to the node with that `label`.
+
+**Example 1:**
+
+**Input:** label = 14
+
+**Output:** [1,3,4,14]
+
+**Example 2:**
+
+**Input:** label = 26
+
+**Output:** [1,2,6,10,26]
+
+**Constraints:**
+
+*   `1 <= label <= 10^6`

src/main/java/g1101_1200/s1105_filling_bookcase_shelves/Solution.java

@@ -0,0 +1,26 @@
+package g1101_1200.s1105_filling_bookcase_shelves;
+
+// #Medium #Array #Dynamic_Programming #2022_02_28_Time_4_ms_(23.85%)_Space_42.7_MB_(31.80%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int minHeightShelves(int[][] books, int shelfWidth) {
+        int n = books.length;
+        int[] dp = new int[n + 1];
+        Arrays.fill(dp, Integer.MAX_VALUE);
+        dp[0] = 0;
+        for (int i = 1; i <= n; i++) {
+            int widthLeft = shelfWidth;
+            int maxH = 0;
+            for (int j = i - 1; j >= 0; j--) {
+                widthLeft -= books[j][0];
+                maxH = Math.max(maxH, books[j][1]);
+                if (widthLeft >= 0) {
+                    dp[i] = Math.min(dp[i], maxH + dp[j]);
+                }
+            }
+        }
+        return dp[n];
+    }
+}

src/main/java/g1101_1200/s1105_filling_bookcase_shelves/readme.md

@@ -0,0 +1,41 @@
+1105\. Filling Bookcase Shelves
+
+Medium
+
+You are given an array `books` where <code>books[i] = [thickness<sub>i</sub>, height<sub>i</sub>]</code> indicates the thickness and height of the <code>i<sup>th</sup></code> book. You are also given an integer `shelfWidth`.
+
+We want to place these books in order onto bookcase shelves that have a total width `shelfWidth`.
+
+We choose some of the books to place on this shelf such that the sum of their thickness is less than or equal to `shelfWidth`, then build another level of the shelf of the bookcase so that the total height of the bookcase has increased by the maximum height of the books we just put down. We repeat this process until there are no more books to place.
+
+Note that at each step of the above process, the order of the books we place is the same order as the given sequence of books.
+
+*   For example, if we have an ordered list of `5` books, we might place the first and second book onto the first shelf, the third book on the second shelf, and the fourth and fifth book on the last shelf.
+
+Return _the minimum possible height that the total bookshelf can be after placing shelves in this manner_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/06/24/shelves.png)
+
+**Input:** books = [[1,1],[2,3],[2,3],[1,1],[1,1],[1,1],[1,2]], shelf\_width = 4
+
+**Output:** 6
+
+**Explanation:** 
+
+The sum of the heights of the 3 shelves is 1 + 3 + 2 = 6. 
+
+Notice that book number 2 does not have to be on the first shelf.
+
+**Example 2:**
+
+**Input:** books = [[1,3],[2,4],[3,2]], shelfWidth = 6
+
+**Output:** 4
+
+**Constraints:**
+
+*   `1 <= books.length <= 1000`
+*   <code>1 <= thickness<sub>i</sub> <= shelfWidth <= 1000</code>
+*   <code>1 <= height<sub>i</sub> <= 1000</code>

src/main/java/g1101_1200/s1106_parsing_a_boolean_expression/Solution.java

@@ -0,0 +1,116 @@
+package g1101_1200.s1106_parsing_a_boolean_expression;
+
+// #Hard #String #Stack #Recursion #2022_02_28_Time_3_ms_(93.78%)_Space_42_MB_(70.54%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    private String source;
+    private int index;
+
+    public boolean parseBoolExpr(String expression) {
+        this.source = expression;
+        this.index = 0;
+
+        return expr();
+    }
+
+    private boolean expr() {
+        boolean res = false;
+
+        if (match('!')) {
+            res = not();
+        } else if (match('&')) {
+            res = and();
+        } else if (match('|')) {
+            res = or();
+        } else {
+            res = bool();
+        }
+
+        return res;
+    }
+
+    private boolean not() {
+        consume('!', "Expect '!'");
+
+        return !group().get(0);
+    }
+
+    private boolean or() {
+        consume('|', "Expect '|'");
+
+        boolean res = false;
+        for (boolean e : group()) {
+            res |= e;
+        }
+
+        return res;
+    }
+
+    private boolean and() {
+        consume('&', "Expect '&'");
+
+        boolean res = true;
+        for (boolean e : group()) {
+            res &= e;
+        }
+
+        return res;
+    }
+
+    private List<Boolean> group() {
+        consume('(', "Expect '('");
+
+        List<Boolean> res = new ArrayList<>();
+        while (!match(')')) {
+            res.add(expr());
+
+            if (match(',')) {
+                advance();
+            }
+        }
+
+        consume(')', "Expect ')'");
+
+        return res;
+    }
+
+    private boolean bool() {
+        boolean isTrue = match('t');
+        advance();
+        return isTrue;
+    }
+
+    private boolean isAtEnd() {
+        return index >= source.length();
+    }
+
+    private void advance() {
+        if (isAtEnd()) {
+            return;
+        }
+
+        index++;
+    }
+
+    private char peek() {
+        return source.charAt(index);
+    }
+
+    private boolean match(char ch) {
+        if (isAtEnd()) {
+            return false;
+        }
+
+        return peek() == ch;
+    }
+
+    private void consume(char ch, String message) {
+        if (!match(ch)) {
+            return;
+        }
+        advance();
+    }
+}

src/main/java/g1101_1200/s1106_parsing_a_boolean_expression/readme.md

@@ -0,0 +1,37 @@
+1106\. Parsing A Boolean Expression
+
+Hard
+
+Return the result of evaluating a given boolean `expression`, represented as a string.
+
+An expression can either be:
+
+*   `"t"`, evaluating to `True`;
+*   `"f"`, evaluating to `False`;
+*   `"!(expr)"`, evaluating to the logical NOT of the inner expression `expr`;
+*   `"&(expr1,expr2,...)"`, evaluating to the logical AND of 2 or more inner expressions `expr1, expr2, ...`;
+*   `"|(expr1,expr2,...)"`, evaluating to the logical OR of 2 or more inner expressions `expr1, expr2, ...`
+
+**Example 1:**
+
+**Input:** expression = "!(f)"
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** expression = "|(f,t)"
+
+**Output:** true
+
+**Example 3:**
+
+**Input:** expression = "&(t,f)"
+
+**Output:** false
+
+**Constraints:**
+
+*   <code>1 <= expression.length <= 2 * 10<sup>4</sup></code>
+*   `expression[i]` consists of characters in `{'(', ')', '&', '|', '!', 't', 'f', ','}`.
+*   `expression` is a valid expression representing a boolean, as given in the description.

src/main/java/g1101_1200/s1108_defanging_an_ip_address/Solution.java

@@ -0,0 +1,9 @@
+package g1101_1200.s1108_defanging_an_ip_address;
+
+// #Easy #String #2022_02_28_Time_3_ms_(26.20%)_Space_42.8_MB_(5.79%)
+
+public class Solution {
+    public String defangIPaddr(String address) {
+        return address.replaceAll("\\.", "\\[\\.\\]");
+    }
+}

src/main/java/g1101_1200/s1108_defanging_an_ip_address/readme.md

@@ -0,0 +1,23 @@
+1108\. Defanging an IP Address
+
+Easy
+
+Given a valid (IPv4) IP `address`, return a defanged version of that IP address.
+
+A _defanged IP address_ replaces every period `"."` with `"[.]"`.
+
+**Example 1:**
+
+**Input:** address = "1.1.1.1"
+
+**Output:** "1[.]1[.]1[.]1"
+
+**Example 2:**
+
+**Input:** address = "255.100.50.0"
+
+**Output:** "255[.]100[.]50[.]0"
+
+**Constraints:**
+
+*   The given `address` is a valid IPv4 address.