Added tasks 806, 807, 808, 809, 810.

Author: ThanhNIT

src/main/java/g0801_0900/s0806_number_of_lines_to_write_string/Solution.java

@@ -0,0 +1,29 @@
+package g0801_0900.s0806_number_of_lines_to_write_string;
+
+// #Easy #Array #String
+
+public class Solution {
+    public int[] numberOfLines(int[] widths, String s) {
+        int count = 0;
+        int line = 0;
+        for (int i = 0; i < s.length(); i++) {
+            count += widths[s.charAt(i) - 'a'];
+            if (count == 100) {
+                line++;
+                count = 0;
+            }
+            if (count > 100) {
+                line++;
+                i--;
+                count = 0;
+            }
+        }
+        if (count > 0 && count < 100) {
+            line++;
+        }
+        if (count == 0) {
+            count = 100;
+        }
+        return new int[] {line, count};
+    }
+}

src/main/java/g0801_0900/s0806_number_of_lines_to_write_string/readme.md

@@ -0,0 +1,49 @@
+806\. Number of Lines To Write String
+
+Easy
+
+You are given a string `s` of lowercase English letters and an array `widths` denoting **how many pixels wide** each lowercase English letter is. Specifically, `widths[0]` is the width of `'a'`, `widths[1]` is the width of `'b'`, and so on.
+
+You are trying to write `s` across several lines, where **each line is no longer than** `100` **pixels**. Starting at the beginning of `s`, write as many letters on the first line such that the total width does not exceed `100` pixels. Then, from where you stopped in `s`, continue writing as many letters as you can on the second line. Continue this process until you have written all of `s`.
+
+Return _an array_ `result` _of length 2 where:_
+
+*   `result[0]` _is the total number of lines._
+*   `result[1]` _is the width of the last line in pixels._
+
+**Example 1:**
+
+**Input:** widths = [10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10], s = "abcdefghijklmnopqrstuvwxyz"
+
+**Output:** [3,60]
+
+**Explanation:** You can write s as follows: 
+
+abcdefghij // 100 pixels wide 
+
+klmnopqrst // 100 pixels wide 
+
+uvwxyz // 60 pixels wide 
+
+There are a total of 3 lines, and the last line is 60 pixels wide.
+
+**Example 2:**
+
+**Input:** widths = [4,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10], s = "bbbcccdddaaa"
+
+**Output:** [2,4]
+
+**Explanation:** You can write s as follows: 
+
+bbbcccdddaa // 98 pixels wide 
+
+a // 4 pixels wide 
+
+There are a total of 2 lines, and the last line is 4 pixels wide.
+
+**Constraints:**
+
+*   `widths.length == 26`
+*   `2 <= widths[i] <= 10`
+*   `1 <= s.length <= 1000`
+*   `s` contains only lowercase English letters.

src/main/java/g0801_0900/s0807_max_increase_to_keep_city_skyline/Solution.java

@@ -0,0 +1,49 @@
+package g0801_0900.s0807_max_increase_to_keep_city_skyline;
+
+// #Medium #Array #Greedy #Matrix
+
+public class Solution {
+    public int maxIncreaseKeepingSkyline(int[][] grid) {
+
+        int rows = grid.length;
+        int cols = grid[0].length;
+        int[] tallestR = new int[rows];
+        int[] tallestC = new int[cols];
+        int max;
+
+        for (int i = 0; i < rows; i++) {
+            max = 0;
+            for (int j = 0; j < cols; j++) {
+                if (grid[i][j] > max) {
+                    max = grid[i][j];
+                }
+            }
+            tallestR[i] = max;
+        }
+
+        for (int i = 0; i < cols; i++) {
+            max = 0;
+            for (int[] ints : grid) {
+                if (ints[i] > max) {
+                    max = ints[i];
+                }
+            }
+            tallestC[i] = max;
+        }
+
+        int increase = 0;
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (tallestR[i] < tallestC[j]) {
+                    increase += tallestR[i] - grid[i][j];
+                    grid[i][j] += tallestR[i] - grid[i][j];
+                } else {
+                    increase += tallestC[j] - grid[i][j];
+                    grid[i][j] += tallestC[j] - grid[i][j];
+                }
+            }
+        }
+
+        return increase;
+    }
+}

src/main/java/g0801_0900/s0807_max_increase_to_keep_city_skyline/readme.md

@@ -0,0 +1,45 @@
+807\. Max Increase to Keep City Skyline
+
+Medium
+
+There is a city composed of `n x n` blocks, where each block contains a single building shaped like a vertical square prism. You are given a **0-indexed** `n x n` integer matrix `grid` where `grid[r][c]` represents the **height** of the building located in the block at row `r` and column `c`.
+
+A city's **skyline** is the the outer contour formed by all the building when viewing the side of the city from a distance. The **skyline** from each cardinal direction north, east, south, and west may be different.
+
+We are allowed to increase the height of **any number of buildings by any amount** (the amount can be different per building). The height of a `0`\-height building can also be increased. However, increasing the height of a building should **not** affect the city's **skyline** from any cardinal direction.
+
+Return _the **maximum total sum** that the height of the buildings can be increased by **without** changing the city's **skyline** from any cardinal direction_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/06/21/807-ex1.png)
+
+**Input:** grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]
+
+**Output:** 35
+
+**Explanation:** The building heights are shown in the center of the above image. 
+    
+The skylines when viewed from each cardinal direction are drawn in red. 
+
+The grid after increasing the height of buildings without affecting skylines is: 
+    
+    gridNew = [ [8, 4, 8, 7], 
+                [7, 4, 7, 7], 
+                [9, 4, 8, 7],  
+                [3, 3, 3, 3] ]
+
+**Example 2:**
+
+**Input:** grid = [[0,0,0],[0,0,0],[0,0,0]]
+
+**Output:** 0
+
+**Explanation:** Increasing the height of any building will result in the skyline changing.
+
+**Constraints:**
+
+*   `n == grid.length`
+*   `n == grid[r].length`
+*   `2 <= n <= 50`
+*   `0 <= grid[r][c] <= 100`

src/main/java/g0801_0900/s0808_soup_servings/Solution.java

@@ -0,0 +1,58 @@
+package g0801_0900.s0808_soup_servings;
+
+// #Medium #Dynamic_Programming #Math #Probability_and_Statistics
+
+public class Solution {
+    public double soupServings(int n) {
+        return solve(n);
+    }
+
+    private double solve(int n) {
+        n = n / 25 + (n % 25 > 0 ? 1 : 0);
+        if (n >= 500) {
+            return 1.0;
+        }
+        return find(n, n, new Double[n + 1][n + 1]);
+    }
+
+    private double find(int a, int b, Double[][] mem) {
+        if (a <= 0 && b <= 0) {
+            return 0.5;
+        } else if (a <= 0) {
+            return 1;
+        } else if (b <= 0) {
+            return 0;
+        }
+
+        double prob = 0;
+
+        if (mem[a][b] != null) {
+            return mem[a][b];
+        }
+
+        prob = find(a - 4, b, mem);
+        prob += find(a - 3, b - 1, mem);
+        prob += find(a - 2, b - 2, mem);
+        prob += find(a - 1, b - 3, mem);
+        mem[a][b] = 0.25 * prob;
+        return mem[a][b];
+    }
+
+    private double find(int a, int b) {
+        if (a <= 0 && b <= 0) {
+            return 0.5;
+        } else if (a <= 0) {
+            return 1;
+        } else if (b <= 0) {
+            return 0;
+        }
+
+        double prob = 0;
+
+        prob = find(a - 100, b);
+        prob += find(a - 75, b - 25);
+        prob += find(a - 50, b - 50);
+        prob += find(a - 25, b - 75);
+        return 0.25 * prob;
+    }
+}

src/main/java/g0801_0900/s0808_soup_servings/readme.md

@@ -0,0 +1,40 @@
+808\. Soup Servings
+
+Medium
+
+There are two types of soup: **type A** and **type B**. Initially, we have `n` ml of each type of soup. There are four kinds of operations:
+
+1.  Serve `100` ml of **soup A** and `0` ml of **soup B**,
+2.  Serve `75` ml of **soup A** and `25` ml of **soup B**,
+3.  Serve `50` ml of **soup A** and `50` ml of **soup B**, and
+4.  Serve `25` ml of **soup A** and `75` ml of **soup B**.
+
+When we serve some soup, we give it to someone, and we no longer have it. Each turn, we will choose from the four operations with an equal probability `0.25`. If the remaining volume of soup is not enough to complete the operation, we will serve as much as possible. We stop once we no longer have some quantity of both types of soup.
+
+**Note** that we do not have an operation where all `100` ml's of **soup B** are used first.
+
+Return _the probability that **soup A** will be empty first, plus half the probability that **A** and **B** become empty at the same time_. Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.
+
+**Example 1:**
+
+**Input:** n = 50
+
+**Output:** 0.62500
+
+**Explanation:** If we choose the first two operations, A will become empty first. 
+
+For the third operation, A and B will become empty at the same time. 
+
+For the fourth operation, B will become empty first. 
+
+So the total probability of A becoming empty first plus half the probability that A and B become empty at the same time, is 0.25 \* (1 + 1 + 0.5 + 0) = 0.625.
+
+**Example 2:**
+
+**Input:** n = 100
+
+**Output:** 0.71875
+
+**Constraints:**
+
+*   <code>0 <= n <= 10<sup>9</sup></code>

src/main/java/g0801_0900/s0809_expressive_words/Solution.java

@@ -0,0 +1,58 @@
+package g0801_0900.s0809_expressive_words;
+
+// #Medium #Array #String #Two_Pointers
+
+public class Solution {
+    public int expressiveWords(String s, String[] words) {
+        int ans = 0;
+        for (String w : words) {
+            if (check(s, w)) {
+                ans++;
+            }
+        }
+        return ans;
+    }
+
+    private boolean check(String s, String w) {
+        int i = 0;
+        int j = 0;
+        /* Logic is to check whether character at same index of S and w are same
+          if same,
+           1. Find the consecutive number of occurrences of the char in S (say len1) and w ( say len2)
+           2. If len1 == len 2 , move to the next char in S and w
+           3. If  len1 >= 3 and len2 < len1, means we can make the char in w stretchy to match len1
+           4. else, return false, because it's not possible to stretch the char in w
+        */
+        while (i < s.length() && j < w.length()) {
+            char ch1 = s.charAt(i);
+            char ch2 = w.charAt(j);
+
+            int len1 = getLen(s, i);
+            int len2 = getLen(w, j);
+            if (ch1 == ch2) {
+                if (len1 == len2 || (len1 >= 3 && len2 < len1)) {
+                    i = i + len1;
+                    j = j + len2;
+                } else {
+                    return false;
+                }
+            } else {
+                return false;
+            }
+        }
+        return i == s.length() && j == w.length();
+    }
+
+    private int getLen(String value, int i) {
+        i = i + 1;
+        int count = 1;
+        for (int j = i; j < value.length(); j++) {
+            if (value.charAt(j) == value.charAt(i - 1)) {
+                count++;
+            } else {
+                break;
+            }
+        }
+        return count;
+    }
+}

src/main/java/g0801_0900/s0809_expressive_words/readme.md

@@ -0,0 +1,40 @@
+809\. Expressive Words
+
+Medium
+
+Sometimes people repeat letters to represent extra feeling. For example:
+
+*   `"hello" -> "heeellooo"`
+*   `"hi" -> "hiiii"`
+
+In these strings like `"heeellooo"`, we have groups of adjacent letters that are all the same: `"h"`, `"eee"`, `"ll"`, `"ooo"`.
+
+You are given a string `s` and an array of query strings `words`. A query word is **stretchy** if it can be made to be equal to `s` by any number of applications of the following extension operation: choose a group consisting of characters `c`, and add some number of characters `c` to the group so that the size of the group is **three or more**.
+
+*   For example, starting with `"hello"`, we could do an extension on the group `"o"` to get `"hellooo"`, but we cannot get `"helloo"` since the group `"oo"` has a size less than three. Also, we could do another extension like `"ll" -> "lllll"` to get `"helllllooo"`. If `s = "helllllooo"`, then the query word `"hello"` would be **stretchy** because of these two extension operations: `query = "hello" -> "hellooo" -> "helllllooo" = s`.
+
+Return _the number of query strings that are **stretchy**_.
+
+**Example 1:**
+
+**Input:** s = "heeellooo", words = ["hello", "hi", "helo"]
+
+**Output:** 1
+
+**Explanation:** 
+
+We can extend "e" and "o" in the word "hello" to get "heeellooo". 
+
+We can't extend "helo" to get "heeellooo" because the group "ll" is not size 3 or more.
+
+**Example 2:**
+
+**Input:** s = "zzzzzyyyyy", words = ["zzyy","zy","zyy"]
+
+**Output:** 3
+
+**Constraints:**
+
+*   `1 <= s.length, words.length <= 100`
+*   `1 <= words[i].length <= 100`
+*   `s` and `words[i]` consist of lowercase letters.

src/main/java/g0801_0900/s0810_chalkboard_xor_game/Solution.java

@@ -0,0 +1,13 @@
+package g0801_0900.s0810_chalkboard_xor_game;
+
+// #Hard #Array #Math #Bit_Manipulation #Game_Theory #Brainteaser
+
+public class Solution {
+    public boolean xorGame(int[] nums) {
+        int xor = 0;
+        for (int i : nums) {
+            xor = xor ^ i;
+        }
+        return xor == 0 || (nums.length & 1) == 0;
+    }
+}