Added tasks 1017, 1018, 1019, 1020

Author: ThanhNIT

README.md

@@ -1608,6 +1608,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 1020 |[Number of Enclaves](src/main/kotlin/g1001_1100/s1020_number_of_enclaves/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find | 369 | 76.26
 
 #### Day 4 Matrix Related Problems
 
@@ -1749,6 +1750,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
 | 1143 |[Longest Common Subsequence](src/main/kotlin/g1101_1200/s1143_longest_common_subsequence/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming, Algorithm_II_Day_17_Dynamic_Programming, Dynamic_Programming_I_Day_19, Udemy_Dynamic_Programming | 307 | 38.36
+| 1020 |[Number of Enclaves](src/main/kotlin/g1001_1100/s1020_number_of_enclaves/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find, Graph_Theory_I_Day_3_Matrix_Related_Problems | 369 | 76.26
+| 1019 |[Next Greater Node In Linked List](src/main/kotlin/g1001_1100/s1019_next_greater_node_in_linked_list/Solution.kt)| Medium | Array, Stack, Linked_List, Monotonic_Stack | 472 | 75.00
+| 1018 |[Binary Prefix Divisible By 5](src/main/kotlin/g1001_1100/s1018_binary_prefix_divisible_by_5/Solution.kt)| Easy | Array | 297 | 100.00
+| 1017 |[Convert to Base -2](src/main/kotlin/g1001_1100/s1017_convert_to_base_2/Solution.kt)| Medium | Math | 138 | 100.00
 | 1016 |[Binary String With Substrings Representing 1 To N](src/main/kotlin/g1001_1100/s1016_binary_string_with_substrings_representing_1_to_n/Solution.kt)| Medium | String | 134 | 75.00
 | 1015 |[Smallest Integer Divisible by K](src/main/kotlin/g1001_1100/s1015_smallest_integer_divisible_by_k/Solution.kt)| Medium | Hash_Table, Math | 123 | 100.00
 | 1014 |[Best Sightseeing Pair](src/main/kotlin/g1001_1100/s1014_best_sightseeing_pair/Solution.kt)| Medium | Array, Dynamic_Programming, Dynamic_Programming_I_Day_7 | 336 | 66.67

src/main/kotlin/g1001_1100/s1017_convert_to_base_2/Solution.kt

@@ -0,0 +1,27 @@
+package g1001_1100.s1017_convert_to_base_2
+
+// #Medium #Math #2023_05_21_Time_138_ms_(100.00%)_Space_34.5_MB_(100.00%)
+
+class Solution {
+    fun baseNeg2(n: Int): String {
+        val sb = StringBuilder(Integer.toBinaryString(n))
+        sb.reverse()
+        var carry = 0
+        var sum: Int
+        var pos = 0
+        while (pos < sb.length) {
+            sum = carry + sb[pos].code - '0'.code
+            sb.setCharAt(pos, if (sum % 2 == 0) '0' else '1')
+            carry = sum / 2
+            if (pos % 2 == 1 && sb[pos] == '1') {
+                carry += 1
+            }
+            pos++
+            if (pos >= sb.length && carry > 0) {
+                sb.append(Integer.toBinaryString(carry))
+                carry = 0
+            }
+        }
+        return sb.reverse().toString()
+    }
+}

src/main/kotlin/g1001_1100/s1017_convert_to_base_2/readme.md

@@ -0,0 +1,29 @@
+1017\. Convert to Base -2
+
+Medium
+
+Given an integer `n`, return _a binary string representing its representation in base_ `-2`.
+
+**Note** that the returned string should not have leading zeros unless the string is `"0"`.
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** "110" **Explantion:** (-2)<sup>2</sup> + (-2)<sup>1</sup> = 2
+
+**Example 2:**
+
+**Input:** n = 3
+
+**Output:** "111" **Explantion:** (-2)<sup>2</sup> + (-2)<sup>1</sup> + (-2)<sup>0</sup> = 3
+
+**Example 3:**
+
+**Input:** n = 4
+
+**Output:** "100" **Explantion:** (-2)<sup>2</sup> = 4
+
+**Constraints:**
+
+*   <code>0 <= n <= 10<sup>9</sup></code>

src/main/kotlin/g1001_1100/s1018_binary_prefix_divisible_by_5/Solution.kt

@@ -0,0 +1,15 @@
+package g1001_1100.s1018_binary_prefix_divisible_by_5
+
+// #Easy #Array #2023_05_21_Time_297_ms_(100.00%)_Space_50_MB_(100.00%)
+
+class Solution {
+    fun prefixesDivBy5(nums: IntArray): List<Boolean> {
+        val result: MutableList<Boolean> = ArrayList(nums.size)
+        var remainder = 0
+        for (j in nums) {
+            remainder = (j + (remainder shl 1)) % 5
+            result.add(remainder == 0)
+        }
+        return result
+    }
+}

src/main/kotlin/g1001_1100/s1018_binary_prefix_divisible_by_5/readme.md

@@ -0,0 +1,30 @@
+1018\. Binary Prefix Divisible By 5
+
+Easy
+
+You are given a binary array `nums` (**0-indexed**).
+
+We define <code>x<sub>i</sub></code> as the number whose binary representation is the subarray `nums[0..i]` (from most-significant-bit to least-significant-bit).
+
+*   For example, if `nums = [1,0,1]`, then <code>x<sub>0</sub> = 1</code>, <code>x<sub>1</sub> = 2</code>, and <code>x<sub>2</sub> = 5</code>.
+
+Return _an array of booleans_ `answer` _where_ `answer[i]` _is_ `true` _if_ <code>x<sub>i</sub></code> _is divisible by_ `5`.
+
+**Example 1:**
+
+**Input:** nums = [0,1,1]
+
+**Output:** [true,false,false]
+
+**Explanation:** The input numbers in binary are 0, 01, 011; which are 0, 1, and 3 in base-10. Only the first number is divisible by 5, so answer[0] is true.
+
+**Example 2:**
+
+**Input:** nums = [1,1,1]
+
+**Output:** [false,false,false]
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   `nums[i]` is either `0` or `1`.

src/main/kotlin/g1001_1100/s1019_next_greater_node_in_linked_list/Solution.kt

@@ -0,0 +1,71 @@
+package g1001_1100.s1019_next_greater_node_in_linked_list
+
+// #Medium #Array #Stack #Linked_List #Monotonic_Stack
+// #2023_05_21_Time_472_ms_(75.00%)_Space_97.4_MB_(25.00%)
+
+import com_github_leetcode.ListNode
+
+/*
+ * Example:
+ * var li = ListNode(5)
+ * var v = li.`val`
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int) {
+ *     var next: ListNode? = null
+ * }
+ */
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun nextLargerNodes(head: ListNode?): IntArray {
+        var head = head
+        val len = length(head)
+        var i = 0
+        val arr = IntArray(len)
+        val idx = IntArray(len)
+        while (head != null) {
+            arr[i] = head.`val`
+            head = head.next
+            i++
+        }
+        hlp(arr, idx, 0)
+        i = 0
+        while (i < idx.size) {
+            val j = idx[i]
+            if (j != -1) {
+                arr[i] = arr[j]
+            } else {
+                arr[i] = 0
+            }
+            i++
+        }
+        arr[i - 1] = 0
+        return arr
+    }
+
+    private fun hlp(arr: IntArray, idx: IntArray, i: Int) {
+        if (i == arr.size - 1) {
+            idx[i] = -1
+            return
+        }
+        hlp(arr, idx, i + 1)
+        var j = i + 1
+        while (j != -1 && arr[i] >= arr[j]) {
+            j = idx[j]
+        }
+        if (j != -1 && arr[i] >= arr[j]) {
+            idx[i] = -1
+        } else {
+            idx[i] = j
+        }
+    }
+
+    private fun length(head: ListNode?): Int {
+        var head = head
+        var len = 0
+        while (head != null) {
+            head = head.next
+            len++
+        }
+        return len
+    }
+}

src/main/kotlin/g1001_1100/s1019_next_greater_node_in_linked_list/readme.md

@@ -0,0 +1,31 @@
+1019\. Next Greater Node In Linked List
+
+Medium
+
+You are given the `head` of a linked list with `n` nodes.
+
+For each node in the list, find the value of the **next greater node**. That is, for each node, find the value of the first node that is next to it and has a **strictly larger** value than it.
+
+Return an integer array `answer` where `answer[i]` is the value of the next greater node of the <code>i<sup>th</sup></code> node (**1-indexed**). If the <code>i<sup>th</sup></code> node does not have a next greater node, set `answer[i] = 0`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/08/05/linkedlistnext1.jpg)
+
+**Input:** head = [2,1,5]
+
+**Output:** [5,5,0]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/08/05/linkedlistnext2.jpg)
+
+**Input:** head = [2,7,4,3,5]
+
+**Output:** [7,0,5,5,0]
+
+**Constraints:**
+
+*   The number of nodes in the list is `n`.
+*   <code>1 <= n <= 10<sup>4</sup></code>
+*   <code>1 <= Node.val <= 10<sup>9</sup></code>

src/main/kotlin/g1001_1100/s1020_number_of_enclaves/Solution.kt

@@ -0,0 +1,40 @@
+package g1001_1100.s1020_number_of_enclaves
+
+// #Medium #Array #Depth_First_Search #Breadth_First_Search #Matrix #Union_Find
+// #Graph_Theory_I_Day_3_Matrix_Related_Problems
+// #2023_05_21_Time_369_ms_(76.26%)_Space_90.3_MB_(16.91%)
+
+class Solution {
+    fun numEnclaves(grid: Array<IntArray>): Int {
+        val visited = Array(grid.size) {
+            BooleanArray(
+                grid[0].size
+            )
+        }
+        for (i in grid.indices) {
+            for (j in grid[0].indices) {
+                if (grid[i][j] == 1 && (i == 0 || j == 0 || i == grid.size - 1 || j == grid[0].size - 1)) {
+                    move(grid, i, j, visited)
+                }
+            }
+        }
+        var count = 0
+        for (i in 1 until visited.size - 1) {
+            for (j in 1 until visited[0].size - 1) {
+                if (!visited[i][j] && grid[i][j] == 1) count++
+            }
+        }
+        return count
+    }
+
+    companion object {
+        fun move(g: Array<IntArray>, i: Int, j: Int, b: Array<BooleanArray>) {
+            if (i < 0 || j < 0 || i == g.size || j == g[0].size || g[i][j] == 0 || b[i][j]) return
+            b[i][j] = true
+            move(g, i + 1, j, b)
+            move(g, i - 1, j, b)
+            move(g, i, j - 1, b)
+            move(g, i, j + 1, b)
+        }
+    }
+}

src/main/kotlin/g1001_1100/s1020_number_of_enclaves/readme.md

@@ -0,0 +1,36 @@
+1020\. Number of Enclaves
+
+Medium
+
+You are given an `m x n` binary matrix `grid`, where `0` represents a sea cell and `1` represents a land cell.
+
+A **move** consists of walking from one land cell to another adjacent (**4-directionally**) land cell or walking off the boundary of the `grid`.
+
+Return _the number of land cells in_ `grid` _for which we cannot walk off the boundary of the grid in any number of **moves**_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/18/enclaves1.jpg)
+
+**Input:** grid = [[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
+
+**Output:** 3
+
+**Explanation:** There are three 1s that are enclosed by 0s, and one 1 that is not enclosed because its on the boundary.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/18/enclaves2.jpg)
+
+**Input:** grid = [[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]
+
+**Output:** 0
+
+**Explanation:** All 1s are either on the boundary or can reach the boundary.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 500`
+*   `grid[i][j]` is either `0` or `1`.

src/test/kotlin/g1001_1100/s1017_convert_to_base_2/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g1001_1100.s1017_convert_to_base_2
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun baseNeg2() {
+        assertThat(Solution().baseNeg2(2), equalTo("110"))
+    }
+
+    @Test
+    fun baseNeg22() {
+        assertThat(Solution().baseNeg2(3), equalTo("111"))
+    }
+
+    @Test
+    fun baseNeg23() {
+        assertThat(Solution().baseNeg2(4), equalTo("100"))
+    }
+}