Added tasks 65, 66, 67, 68.

Author: ThanhNIT

README.md

@@ -558,6 +558,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0066 |[Plus One](src/main/kotlin/g0001_0100/s0066_plus_one/Solution.kt)| Easy | Top_Interview_Questions, Array, Math | 303 | 35.18
 
 #### Day 4
 
@@ -569,6 +570,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0067 |[Add Binary](src/main/kotlin/g0001_0100/s0067_add_binary/Solution.kt)| Easy | String, Math, Bit_Manipulation, Simulation | 327 | 32.67
 
 #### Day 6
 
@@ -1039,6 +1041,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | 0189 |[Rotate Array](src/main/kotlin/g0101_0200/s0189_rotate_array/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Math, Two_Pointers | 483 | 86.95
 | 0055 |[Jump Game](src/main/kotlin/g0001_0100/s0055_jump_game/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Greedy | 670 | 66.67
 | 0075 |[Sort Colors](src/main/kotlin/g0001_0100/s0075_sort_colors/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Two_Pointers | 198 | 85.66
+| 0066 |[Plus One](src/main/kotlin/g0001_0100/s0066_plus_one/Solution.kt)| Easy | Top_Interview_Questions, Array, Math | 303 | 35.18
 | 0238 |[Product of Array Except Self](src/main/kotlin/g0201_0300/s0238_product_of_array_except_self/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Prefix_Sum | 669 | 48.96
 | 0041 |[First Missing Positive](src/main/kotlin/g0001_0100/s0041_first_missing_positive/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table | 345 | 100.00
 | 0239 |[Sliding Window Maximum](src/main/kotlin/g0201_0300/s0239_sliding_window_maximum/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Heap_Priority_Queue, Sliding_Window, Queue, Monotonic_Queue | 1059 | 86.14
@@ -1528,6 +1531,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | 0073 |[Set Matrix Zeroes](src/main/kotlin/g0001_0100/s0073_set_matrix_zeroes/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table, Matrix, Udemy_2D_Arrays/Matrix | 255 | 100.00
 | 0072 |[Edit Distance](src/main/kotlin/g0001_0100/s0072_edit_distance/Solution.kt)| Hard | Top_100_Liked_Questions, String, Dynamic_Programming, Algorithm_II_Day_18_Dynamic_Programming, Dynamic_Programming_I_Day_19, Udemy_Dynamic_Programming | 320 | 63.53
 | 0070 |[Climbing Stairs](src/main/kotlin/g0001_0100/s0070_climbing_stairs/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Dynamic_Programming, Math, Memoization, Algorithm_I_Day_12_Dynamic_Programming, Dynamic_Programming_I_Day_2, Level_1_Day_10_Dynamic_Programming, Udemy_Dynamic_Programming | 127 | 97.06
+| 0068 |[Add Binary](src/main/kotlin/g0001_0100/s0068_text_justification/Solution.kt)| Hard | Array, String, Simulation | 269 | 50.00
+| 0067 |[Add Binary](src/main/kotlin/g0001_0100/s0067_add_binary/Solution.kt)| Easy | String, Math, Bit_Manipulation, Simulation, Programming_Skills_II_Day_5 | 327 | 32.67
+| 0066 |[Plus One](src/main/kotlin/g0001_0100/s0066_plus_one/Solution.kt)| Easy | Top_Interview_Questions, Array, Math, Programming_Skills_II_Day_3, Udemy_Arrays | 303 | 35.18
+| 0065 |[Valid Number](src/main/kotlin/g0001_0100/s0065_valid_number/Solution.kt)| Hard | String | 310 | 81.82
 | 0064 |[Minimum Path Sum](src/main/kotlin/g0001_0100/s0064_minimum_path_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Matrix, Dynamic_Programming_I_Day_16, Udemy_Dynamic_Programming | 222 | 95.70
 | 0063 |[Unique Paths II](src/main/kotlin/g0001_0100/s0063_unique_paths_ii/Solution.kt)| Medium | Array, Dynamic_Programming, Matrix, Dynamic_Programming_I_Day_15 | 187 | 84.62
 | 0062 |[Unique Paths](src/main/kotlin/g0001_0100/s0062_unique_paths/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Dynamic_Programming, Math, Combinatorics, Algorithm_II_Day_13_Dynamic_Programming, Dynamic_Programming_I_Day_15, Level_1_Day_11_Dynamic_Programming | 209 | 49.18

src/main/kotlin/g0001_0100/s0065_valid_number/Solution.kt

@@ -0,0 +1,39 @@
+package g0001_0100.s0065_valid_number
+
+// #Hard #String #2022_09_23_Time_310_ms_(81.82%)_Space_35.5_MB_(87.88%)
+
+class Solution {
+    fun isNumber(s: String): Boolean {
+        if (s.isEmpty()) {
+            return false
+        }
+        var eSeen = false
+        var numberSeen = false
+        var decimalSeen = false
+        for (i in 0 until s.length) {
+            val c = s[i]
+            if (c.code >= 48 && c.code <= 57) {
+                numberSeen = true
+            } else if (c == '+' || c == '-') {
+                if (i == s.length - 1 ||
+                    i != 0 && s[i - 1] != 'e' && s[i - 1] != 'E'
+                ) {
+                    return false
+                }
+            } else if (c == '.') {
+                if (eSeen || decimalSeen) {
+                    return false
+                }
+                decimalSeen = true
+            } else if (c == 'e' || c == 'E') {
+                if (i == s.length - 1 || eSeen || !numberSeen) {
+                    return false
+                }
+                eSeen = true
+            } else {
+                return false
+            }
+        }
+        return numberSeen
+    }
+}

src/main/kotlin/g0001_0100/s0065_valid_number/readme.md

@@ -0,0 +1,48 @@
+65\. Valid Number
+
+Hard
+
+A **valid number** can be split up into these components (in order):
+
+1.  A **decimal number** or an **integer**.
+2.  (Optional) An `'e'` or `'E'`, followed by an **integer**.
+
+A **decimal number** can be split up into these components (in order):
+
+1.  (Optional) A sign character (either `'+'` or `'-'`).
+2.  One of the following formats:
+    1.  One or more digits, followed by a dot `'.'`.
+    2.  One or more digits, followed by a dot `'.'`, followed by one or more digits.
+    3.  A dot `'.'`, followed by one or more digits.
+
+An **integer** can be split up into these components (in order):
+
+1.  (Optional) A sign character (either `'+'` or `'-'`).
+2.  One or more digits.
+
+For example, all the following are valid numbers: `["2", "0089", "-0.1", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7", "+6e-1", "53.5e93", "-123.456e789"]`, while the following are not valid numbers: `["abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3", "95a54e53"]`.
+
+Given a string `s`, return `true` _if_ `s` _is a **valid number**_.
+
+**Example 1:**
+
+**Input:** s = "0"
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** s = "e"
+
+**Output:** false
+
+**Example 3:**
+
+**Input:** s = "."
+
+**Output:** false
+
+**Constraints:**
+
+*   `1 <= s.length <= 20`
+*   `s` consists of only English letters (both uppercase and lowercase), digits (`0-9`), plus `'+'`, minus `'-'`, or dot `'.'`.

src/main/kotlin/g0001_0100/s0066_plus_one/Solution.kt

@@ -0,0 +1,28 @@
+package g0001_0100.s0066_plus_one
+
+// #Easy #Top_Interview_Questions #Array #Math #Programming_Skills_II_Day_3 #Udemy_Arrays
+// #2022_09_23_Time_303_ms_(35.18%)_Space_35.1_MB_(80.78%)
+
+class Solution {
+    fun plusOne(digits: IntArray): IntArray {
+        val num = 1
+        var carry = 0
+        var sum: Int
+        for (i in digits.indices.reversed()) {
+            sum = if (i == digits.size - 1) {
+                digits[i] + carry + num
+            } else {
+                digits[i] + carry
+            }
+            carry = sum / 10
+            digits[i] = sum % 10
+        }
+        if (carry != 0) {
+            val ans = IntArray(digits.size + 1)
+            ans[0] = carry
+            System.arraycopy(digits, 0, ans, 1, ans.size - 1)
+            return ans
+        }
+        return digits
+    }
+}

src/main/kotlin/g0001_0100/s0066_plus_one/readme.md

@@ -0,0 +1,55 @@
+66\. Plus One
+
+Easy
+
+You are given a **large integer** represented as an integer array `digits`, where each `digits[i]` is the <code>i<sup>th</sup></code> digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading `0`'s.
+
+Increment the large integer by one and return _the resulting array of digits_.
+
+**Example 1:**
+
+**Input:** digits = [1,2,3]
+
+**Output:** [1,2,4]
+
+**Explanation:** 
+
+The array represents the integer 123. 
+
+Incrementing by one gives 123 + 1 = 124. 
+
+Thus, the result should be [1,2,4].
+
+**Example 2:**
+
+**Input:** digits = [4,3,2,1]
+
+**Output:** [4,3,2,2]
+
+**Explanation:** 
+
+The array represents the integer 4321. 
+
+Incrementing by one gives 4321 + 1 = 4322. 
+
+Thus, the result should be [4,3,2,2].
+
+**Example 3:**
+
+**Input:** digits = [9]
+
+**Output:** [1,0]
+
+**Explanation:** 
+
+The array represents the integer 9. 
+
+Incrementing by one gives 9 + 1 = 10. 
+
+Thus, the result should be [1,0].
+
+**Constraints:**
+
+*   `1 <= digits.length <= 100`
+*   `0 <= digits[i] <= 9`
+*   `digits` does not contain any leading `0`'s.

src/main/kotlin/g0001_0100/s0067_add_binary/Solution.kt

@@ -0,0 +1,30 @@
+package g0001_0100.s0067_add_binary
+
+// #Easy #String #Math #Bit_Manipulation #Simulation #Programming_Skills_II_Day_5
+// #2022_09_23_Time_327_ms_(32.67%)_Space_36_MB_(75.91%)
+
+class Solution {
+    fun addBinary(a: String, b: String): String {
+        val aArray = a.toCharArray()
+        val bArray = b.toCharArray()
+        val sb = StringBuilder()
+        var i = aArray.size - 1
+        var j = bArray.size - 1
+        var carry = 0
+        while (i >= 0 || j >= 0) {
+            val sum = (if (i >= 0) aArray[i] - '0' else 0) + (if (j >= 0) bArray[j] - '0' else 0) + carry
+            sb.append(sum % 2)
+            carry = sum / 2
+            if (i >= 0) {
+                i--
+            }
+            if (j >= 0) {
+                j--
+            }
+        }
+        if (carry != 0) {
+            sb.append(carry)
+        }
+        return sb.reverse().toString()
+    }
+}

src/main/kotlin/g0001_0100/s0067_add_binary/readme.md

@@ -0,0 +1,23 @@
+67\. Add Binary
+
+Easy
+
+Given two binary strings `a` and `b`, return _their sum as a binary string_.
+
+**Example 1:**
+
+**Input:** a = "11", b = "1"
+
+**Output:** "100"
+
+**Example 2:**
+
+**Input:** a = "1010", b = "1011"
+
+**Output:** "10101"
+
+**Constraints:**
+
+*   <code>1 <= a.length, b.length <= 10<sup>4</sup></code>
+*   `a` and `b` consist only of `'0'` or `'1'` characters.
+*   Each string does not contain leading zeros except for the zero itself.

src/main/kotlin/g0001_0100/s0068_text_justification/Solution.kt

@@ -0,0 +1,79 @@
+package g0001_0100.s0068_text_justification
+
+// #Hard #Array #String #Simulation #2022_09_23_Time_269_ms_(50.00%)_Space_34.8_MB_(97.06%)
+
+class Solution {
+    fun fullJustify(words: Array<String>, maxWidth: Int): List<String> {
+        // Trying to gauge the number of lines so the ArrayList doesn't need to resize
+        val output: MutableList<String> = ArrayList((words.size + 1) / (1 + maxWidth / 7))
+        // Setting StringBuilder capacity also
+        var sb = StringBuilder(maxWidth)
+        var lineTotal = 0
+        var numWordsOnLine = 0
+        var startWord = 0
+        // looping until the 2nd last word, since we're checking words[i + 1] for
+        // overflows
+        for (i in 0 until words.size - 1) {
+            lineTotal += words[i].length
+            // tracking line length + #words
+            numWordsOnLine++
+            // checking if the next word causes an overflow
+            if (lineTotal + numWordsOnLine + words[i + 1].length > maxWidth) {
+                // if only one word fits on the line...
+                if (numWordsOnLine == 1) {
+                    // append word
+                    sb.append(words[i])
+                    // pad right with spaces
+                    while (lineTotal++ < maxWidth) {
+                        sb.append(' ')
+                    }
+                } else {
+                    // # of extra spaces
+                    var extraSp = (maxWidth - lineTotal) % (numWordsOnLine - 1)
+
+                    // Creating the line
+                    for (j in startWord until startWord + numWordsOnLine - 1) {
+                        // appending the word
+                        sb.append(words[j])
+                        if (extraSp-- > 0) {
+                            // appending an extra space, if required
+                            sb.append(' ')
+                        }
+                        // appending the rest of the required spaces
+                        for (k in 0 until (maxWidth - lineTotal) / (numWordsOnLine - 1)) {
+                            sb.append(' ')
+                        }
+                    }
+                    // appending the last word of the line
+                    sb.append(words[startWord + numWordsOnLine - 1])
+                }
+                // adding to output list
+                output.add(sb.toString())
+                // reset everything for next line
+                // keeping track of the first word for next line
+                startWord = i + 1
+                // resetting these to 0 for processing next line
+                lineTotal = 0
+                numWordsOnLine = lineTotal
+                // need a new StringBuilder for the next line
+                sb = StringBuilder(maxWidth)
+            }
+        }
+        // handling the final line (no justification, right padded with spaces)
+        lineTotal = 0
+        for (i in startWord until words.size) {
+            lineTotal += words[i].length
+            sb.append(words[i])
+            if (lineTotal++ < maxWidth) {
+                sb.append(' ')
+            }
+        }
+        // padding right side with spaces
+        while (lineTotal++ < maxWidth) {
+            sb.append(' ')
+        }
+        // add the final line to output list
+        output.add(sb.toString())
+        return output
+    }
+}

src/main/kotlin/g0001_0100/s0068_text_justification/readme.md

@@ -0,0 +1,23 @@
+67\. Add Binary
+
+Easy
+
+Given two binary strings `a` and `b`, return _their sum as a binary string_.
+
+**Example 1:**
+
+**Input:** a = "11", b = "1"
+
+**Output:** "100"
+
+**Example 2:**
+
+**Input:** a = "1010", b = "1011"
+
+**Output:** "10101"
+
+**Constraints:**
+
+*   <code>1 <= a.length, b.length <= 10<sup>4</sup></code>
+*   `a` and `b` consist only of `'0'` or `'1'` characters.
+*   Each string does not contain leading zeros except for the zero itself.