Added tasks 401, 402, 403, 404.

Author: ThanhNIT

README.md

@@ -245,6 +245,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0104 |[Maximum Depth of Binary Tree](src.save/main/kotlin/g0101_0200/s0104_maximum_depth_of_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 236 | 83.39
+| 0404 |[Sum of Left Leaves](src/main/kotlin/g0401_0500/s0404_sum_of_left_leaves/Solution.kt)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 173 | 86.05
 
 #### Day 11 Containers and Libraries
 
@@ -1618,6 +1619,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | 0438 |[Find All Anagrams in a String](src/main/kotlin/g0401_0500/s0438_find_all_anagrams_in_a_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Sliding_Window, Algorithm_II_Day_5_Sliding_Window, Programming_Skills_II_Day_12, Level_1_Day_12_Sliding_Window/Two_Pointer | 561 | 54.68
 | 0437 |[Path Sum III](src/main/kotlin/g0401_0500/s0437_path_sum_iii/Solution.kt)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree | 403 | 54.12
 | 0416 |[Partition Equal Subset Sum](src/main/kotlin/g0401_0500/s0416_partition_equal_subset_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Level_2_Day_13_Dynamic_Programming | 509 | 57.56
+| 0404 |[Sum of Left Leaves](src/main/kotlin/g0401_0500/s0404_sum_of_left_leaves/Solution.kt)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Programming_Skills_I_Day_10_Linked_List_and_Tree | 173 | 86.05
+| 0403 |[Frog Jump](src/main/kotlin/g0401_0500/s0403_frog_jump/Solution.kt)| Hard | Array, Dynamic_Programming | 240 | 100.00
+| 0402 |[Remove K Digits](src/main/kotlin/g0401_0500/s0402_remove_k_digits/Solution.kt)| Medium | String, Greedy, Stack, Monotonic_Stack | 375 | 75.00
+| 0401 |[Binary Watch](src/main/kotlin/g0401_0500/s0401_binary_watch/Solution.kt)| Easy | Bit_Manipulation, Backtracking | 266 | 71.43
 | 0400 |[Nth Digit](src.save/main/kotlin/g0301_0400/s0400_nth_digit/Solution.kt)| Medium | Math, Binary_Search | 271 | 50.00
 | 0399 |[Evaluate Division](src.save/main/kotlin/g0301_0400/s0399_evaluate_division/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Graph, Union_Find, Shortest_Path | 183 | 91.49
 | 0398 |[Random Pick Index](src.save/main/kotlin/g0301_0400/s0398_random_pick_index/Solution.kt)| Medium | Hash_Table, Math, Randomized, Reservoir_Sampling | 1091 | 75.00

src/main/kotlin/g0401_0500/s0401_binary_watch/Solution.kt

@@ -0,0 +1,61 @@
+package g0401_0500.s0401_binary_watch
+
+// #Easy #Bit_Manipulation #Backtracking #2022_11_30_Time_266_ms_(71.43%)_Space_34.9_MB_(100.00%)
+
+import java.util.ArrayList
+
+class Solution {
+    fun readBinaryWatch(turnedOn: Int): List<String> {
+        val times: MutableList<String> = ArrayList()
+        for (hour in 0..11) {
+            for (minutes in 0..59) {
+                readBinaryWatchHelper(turnedOn, times, hour, minutes)
+            }
+        }
+        return times
+    }
+
+    private fun readBinaryWatchHelper(
+        turnedOn: Int,
+        selectedTimes: MutableList<String>,
+        hour: Int,
+        minutes: Int
+    ) {
+        if (isValidTime(turnedOn, hour, minutes)) {
+            selectedTimes.add(getTimeString(hour, minutes))
+        }
+    }
+
+    private fun getTimeString(hour: Int, minutes: Int): String {
+        val time = StringBuilder()
+        time.append(hour)
+        time.append(':')
+        if (minutes < 10) {
+            time.append('0')
+        }
+        time.append(minutes)
+        return time.toString()
+    }
+
+    private fun isValidTime(turnedOn: Int, hour: Int, minutes: Int): Boolean {
+        var hour = hour
+        var minutes = minutes
+        var counter = 0
+        while (hour != 0) {
+            if (hour and 1 == 1) {
+                counter++
+            }
+            hour = hour ushr 1
+        }
+        if (counter > turnedOn) {
+            return false
+        }
+        while (minutes != 0) {
+            if (minutes and 1 == 1) {
+                counter++
+            }
+            minutes = minutes ushr 1
+        }
+        return counter == turnedOn
+    }
+}

src/main/kotlin/g0401_0500/s0401_binary_watch/readme.md

@@ -0,0 +1,35 @@
+401\. Binary Watch
+
+Easy
+
+A binary watch has 4 LEDs on the top to represent the hours (0-11), and 6 LEDs on the bottom to represent the minutes (0-59). Each LED represents a zero or one, with the least significant bit on the right.
+
+*   For example, the below binary watch reads `"4:51"`.
+
+![](https://assets.leetcode.com/uploads/2021/04/08/binarywatch.jpg)
+
+Given an integer `turnedOn` which represents the number of LEDs that are currently on (ignoring the PM), return _all possible times the watch could represent_. You may return the answer in **any order**.
+
+The hour must not contain a leading zero.
+
+*   For example, `"01:00"` is not valid. It should be `"1:00"`.
+
+The minute must be consist of two digits and may contain a leading zero.
+
+*   For example, `"10:2"` is not valid. It should be `"10:02"`.
+
+**Example 1:**
+
+**Input:** turnedOn = 1
+
+**Output:** ["0:01","0:02","0:04","0:08","0:16","0:32","1:00","2:00","4:00","8:00"]
+
+**Example 2:**
+
+**Input:** turnedOn = 9
+
+**Output:** []
+
+**Constraints:**
+
+*   `0 <= turnedOn <= 10`

src/main/kotlin/g0401_0500/s0402_remove_k_digits/Solution.kt

@@ -0,0 +1,25 @@
+package g0401_0500.s0402_remove_k_digits
+
+// #Medium #String #Greedy #Stack #Monotonic_Stack
+// #2022_12_01_Time_375_ms_(75.00%)_Space_42.8_MB_(66.67%)
+
+class Solution {
+    fun removeKdigits(num: String, k: Int): String {
+        var k = k
+        val list = CharArray(num.length)
+        val len = num.length - k
+        var top = 0
+        for (i in 0 until num.length) {
+            while (top > 0 && k > 0 && num[i] < list[top - 1]) {
+                top--
+                k--
+            }
+            list[top++] = num[i]
+        }
+        var number = 0
+        while (number < len && list[number] == '0') {
+            number++
+        }
+        return if (number == len) "0" else String(list, number, len - number)
+    }
+}

src/main/kotlin/g0401_0500/s0402_remove_k_digits/readme.md

@@ -0,0 +1,35 @@
+402\. Remove K Digits
+
+Medium
+
+Given string num representing a non-negative integer `num`, and an integer `k`, return _the smallest possible integer after removing_ `k` _digits from_ `num`.
+
+**Example 1:**
+
+**Input:** num = "1432219", k = 3
+
+**Output:** "1219"
+
+**Explanation:** Remove the three digits 4, 3, and 2 to form the new number 1219 which is the smallest.
+
+**Example 2:**
+
+**Input:** num = "10200", k = 1
+
+**Output:** "200"
+
+**Explanation:** Remove the leading 1 and the number is 200. Note that the output must not contain leading zeroes.
+
+**Example 3:**
+
+**Input:** num = "10", k = 2
+
+**Output:** "0"
+
+**Explanation:** Remove all the digits from the number and it is left with nothing which is 0.
+
+**Constraints:**
+
+*   <code>1 <= k <= num.length <= 10<sup>5</sup></code>
+*   `num` consists of only digits.
+*   `num` does not have any leading zeros except for the zero itself.

src/main/kotlin/g0401_0500/s0403_frog_jump/Solution.kt

@@ -0,0 +1,73 @@
+package g0401_0500.s0403_frog_jump
+
+// #Hard #Array #Dynamic_Programming #2022_11_30_Time_240_ms_(100.00%)_Space_37.1_MB_(100.00%)
+
+import java.util.HashMap
+import java.util.HashSet
+
+class Solution {
+    // global hashmap to store visited index -> set of jump lengths from that index
+    private val visited: HashMap<Int, HashSet<Int>> = HashMap()
+    fun canCross(stones: IntArray): Boolean {
+        // a mathematical check before going in the recursion
+        for (i in 3 until stones.size) {
+            if (stones[i] > stones[i - 1] * 2) {
+                return false
+            }
+        }
+        // map of values -> index to make sure we get the next index quickly
+        val rocks: HashMap<Int, Int> = HashMap()
+        for (i in stones.indices) {
+            rocks.put(stones[i], i)
+        }
+        return jump(stones, 0, 1, 0, rocks)
+    }
+
+    private fun jump(
+        stones: IntArray,
+        index: Int,
+        jumpLength: Int,
+        expectedVal: Int,
+        rocks: Map<Int, Int>
+    ): Boolean {
+        // overshoot and going backwards not allowed
+        if (index >= stones.size || jumpLength <= 0) {
+            return false
+        }
+        // reached the last index
+        if (index == stones.size - 1) {
+            return expectedVal == stones[index]
+        }
+        // check if this index -> jumpLength pair was seen before, otherwise record it
+        val rememberJumps: HashSet<Int> = visited.getOrDefault(index, HashSet())
+        if (stones[index] > expectedVal || rememberJumps.contains(jumpLength)) {
+            return false
+        }
+        rememberJumps.add(jumpLength)
+        visited.put(index, rememberJumps)
+        // check for jumpLength-1, jumpLength, jumpLength+1 for a new expected value
+        return (
+            jump(
+                stones,
+                rocks[stones[index] + jumpLength] ?: stones.size,
+                jumpLength + 1,
+                stones[index] + jumpLength,
+                rocks
+            ) ||
+                jump(
+                    stones,
+                    rocks[stones[index] + jumpLength] ?: stones.size,
+                    jumpLength,
+                    stones[index] + jumpLength,
+                    rocks
+                ) ||
+                jump(
+                    stones,
+                    rocks[stones[index] + jumpLength] ?: stones.size,
+                    jumpLength - 1,
+                    stones[index] + jumpLength,
+                    rocks
+                )
+            )
+    }
+}

src/main/kotlin/g0401_0500/s0403_frog_jump/readme.md

@@ -0,0 +1,32 @@
+403\. Frog Jump
+
+Hard
+
+A frog is crossing a river. The river is divided into some number of units, and at each unit, there may or may not exist a stone. The frog can jump on a stone, but it must not jump into the water.
+
+Given a list of `stones`' positions (in units) in sorted **ascending order**, determine if the frog can cross the river by landing on the last stone. Initially, the frog is on the first stone and assumes the first jump must be `1` unit.
+
+If the frog's last jump was `k` units, its next jump must be either `k - 1`, `k`, or `k + 1` units. The frog can only jump in the forward direction.
+
+**Example 1:**
+
+**Input:** stones = [0,1,3,5,6,8,12,17]
+
+**Output:** true
+
+**Explanation:** The frog can jump to the last stone by jumping 1 unit to the 2nd stone, then 2 units to the 3rd stone, then 2 units to the 4th stone, then 3 units to the 6th stone, 4 units to the 7th stone, and 5 units to the 8th stone.
+
+**Example 2:**
+
+**Input:** stones = [0,1,2,3,4,8,9,11]
+
+**Output:** false
+
+**Explanation:** There is no way to jump to the last stone as the gap between the 5th and 6th stone is too large.
+
+**Constraints:**
+
+*   `2 <= stones.length <= 2000`
+*   <code>0 <= stones[i] <= 2<sup>31</sup> - 1</code>
+*   `stones[0] == 0`
+*   `stones` is sorted in a strictly increasing order.

src/main/kotlin/g0401_0500/s0404_sum_of_left_leaves/Solution.kt

@@ -0,0 +1,35 @@
+package g0401_0500.s0404_sum_of_left_leaves
+
+// #Easy #Depth_First_Search #Breadth_First_Search #Tree #Binary_Tree
+// #Programming_Skills_I_Day_10_Linked_List_and_Tree
+// #2022_12_01_Time_173_ms_(86.05%)_Space_35_MB_(25.58%)
+
+import com_github_leetcode.TreeNode
+
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    fun sumOfLeftLeaves(root: TreeNode): Int {
+        fun dfs(root: TreeNode?, left: Boolean): Int {
+            root ?: return 0
+            if (root.left == null && root.right == null) {
+                return if (left) {
+                    root.`val`
+                } else {
+                    0
+                }
+            }
+            return dfs(root.left, true) + dfs(root.right, false)
+        }
+
+        return dfs(root, false)
+    }
+}

src/main/kotlin/g0401_0500/s0404_sum_of_left_leaves/readme.md

@@ -0,0 +1,28 @@
+404\. Sum of Left Leaves
+
+Easy
+
+Given the `root` of a binary tree, return _the sum of all left leaves._
+
+A **leaf** is a node with no children. A **left leaf** is a leaf that is the left child of another node.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/08/leftsum-tree.jpg)
+
+**Input:** root = [3,9,20,null,null,15,7]
+
+**Output:** 24
+
+**Explanation:** There are two left leaves in the binary tree, with values 9 and 15 respectively.
+
+**Example 2:**
+
+**Input:** root = [1]
+
+**Output:** 0
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[1, 1000]`.
+*   `-1000 <= Node.val <= 1000`

src/test/kotlin/g0401_0500/s0401_binary_watch/SolutionTest.kt

@@ -0,0 +1,31 @@
+package g0401_0500.s0401_binary_watch
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+import java.util.Arrays
+
+internal class SolutionTest {
+    @Test
+    fun readBinaryWatch() {
+        assertThat(
+            Solution().readBinaryWatch(1),
+            equalTo(
+                Arrays.asList(
+                    "0:01", "0:02", "0:04", "0:08", "0:16", "0:32", "1:00", "2:00",
+                    "4:00", "8:00"
+                )
+            )
+        )
+    }
+
+    @Test
+    fun readBinaryWatch2() {
+        assertThat(
+            Solution().readBinaryWatch(9),
+            equalTo(
+                Arrays.asList()
+            )
+        )
+    }
+}