Added tasks 692, 693, 695, 696

Author: ThanhNIT

README.md

@@ -190,6 +190,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0695 |[Max Area of Island](src/main/kotlin/g0601_0700/s0695_max_area_of_island/Solution.kt)| |||
 
 #### Day 3 Matrix Related Problems
 
@@ -419,6 +420,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0692 |[Top K Frequent Words](src/main/kotlin/g0601_0700/s0692_top_k_frequent_words/Solution.kt)| Medium | String, Hash_Table, Sorting, Heap_Priority_Queue, Counting, Trie, Bucket_Sort | 239 | 81.10
 
 ### Level 2
 
@@ -1057,6 +1059,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0695 |[Max Area of Island](src/main/kotlin/g0601_0700/s0695_max_area_of_island/Solution.kt)| |||
 
 #### Day 8 Breadth First Search Depth First Search
 
@@ -1676,6 +1679,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | 0864 |[Shortest Path to Get All Keys](src/main/kotlin/g0801_0900/s0864_shortest_path_to_get_all_keys/Solution.kt)| Hard | Breadth_First_Search, Bit_Manipulation | 176 | 100.00
 | 0763 |[Partition Labels](src/main/kotlin/g0701_0800/s0763_partition_labels/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Greedy, Two_Pointers, Data_Structure_II_Day_7_String | 235 | 84.75
 | 0739 |[Daily Temperatures](src/main/kotlin/g0701_0800/s0739_daily_temperatures/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Stack, Monotonic_Stack, Programming_Skills_II_Day_6 | 936 | 80.54
+| 0696 |[Count Binary Substrings](src/main/kotlin/g0601_0700/s0696_count_binary_substrings/Solution.kt)| Easy | String, Two_Pointers | 222 | 100.00
+| 0695 |[Max Area of Island](src/main/kotlin/g0601_0700/s0695_max_area_of_island/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find, Algorithm_I_Day_7_Breadth_First_Search_Depth_First_Search, Graph_Theory_I_Day_2_Matrix_Related_Problems | 324 | 24.06
+| 0693 |[Binary Number with Alternating Bits](src/main/kotlin/g0601_0700/s0693_binary_number_with_alternating_bits/Solution.kt)| Easy | Bit_Manipulation | 129 | 100.00
+| 0692 |[Top K Frequent Words](src/main/kotlin/g0601_0700/s0692_top_k_frequent_words/Solution.kt)| Medium | String, Hash_Table, Sorting, Heap_Priority_Queue, Counting, Trie, Bucket_Sort, Level_1_Day_15_Heap | 239 | 81.10
 | 0691 |[Stickers to Spell Word](src/main/kotlin/g0601_0700/s0691_stickers_to_spell_word/Solution.kt)| Hard | Array, String, Dynamic_Programming, Bit_Manipulation, Backtracking, Bitmask | 249 | 100.00
 | 0690 |[Employee Importance](src/main/kotlin/g0601_0700/s0690_employee_importance/Solution.kt)| Medium | Hash_Table, Depth_First_Search, Breadth_First_Search | 255 | 100.00
 | 0689 |[Knight Probability in Chessboard](src/main/kotlin/g0601_0700/s0689_maximum_sum_of_3_non_overlapping_subarrays/Solution.kt)| Hard | Array, Dynamic_Programming | 248 | 100.00

src/main/kotlin/g0601_0700/s0692_top_k_frequent_words/Solution.kt

@@ -0,0 +1,34 @@
+package g0601_0700.s0692_top_k_frequent_words
+
+// #Medium #String #Hash_Table #Sorting #Heap_Priority_Queue #Counting #Trie #Bucket_Sort
+// #Level_1_Day_15_Heap #2023_02_21_Time_239_ms_(81.10%)_Space_37.1_MB_(70.87%)
+
+import java.util.SortedSet
+import java.util.TreeSet
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun topKFrequent(words: Array<String>, k: Int): List<String> {
+        var k = k
+        val map: MutableMap<String, Int> = HashMap()
+        for (word in words) {
+            map[word] = map.getOrDefault(word, 0) + 1
+        }
+        val sortedset: SortedSet<Map.Entry<String, Int>> = TreeSet(
+            java.util.Comparator { (key, value): Map.Entry<String, Int>, (key1, value1): Map.Entry<String, Int> ->
+                if (value != value1) {
+                    return@Comparator value1 - value
+                } else {
+                    return@Comparator key.compareTo(key1, ignoreCase = true)
+                }
+            }
+        )
+        sortedset.addAll(map.entries)
+        val result: MutableList<String> = ArrayList()
+        val iterator: Iterator<Map.Entry<String, Int>> = sortedset.iterator()
+        while (iterator.hasNext() && k-- > 0) {
+            result.add(iterator.next().key)
+        }
+        return result
+    }
+}

src/main/kotlin/g0601_0700/s0692_top_k_frequent_words/readme.md

@@ -0,0 +1,32 @@
+692\. Top K Frequent Words
+
+Medium
+
+Given an array of strings `words` and an integer `k`, return _the_ `k` _most frequent strings_.
+
+Return the answer **sorted** by **the frequency** from highest to lowest. Sort the words with the same frequency by their **lexicographical order**.
+
+**Example 1:**
+
+**Input:** words = ["i","love","leetcode","i","love","coding"], k = 2
+
+**Output:** ["i","love"]
+
+**Explanation:** "i" and "love" are the two most frequent words. Note that "i" comes before "love" due to a lower alphabetical order.
+
+**Example 2:**
+
+**Input:** words = ["the","day","is","sunny","the","the","the","sunny","is","is"], k = 4
+
+**Output:** ["the","is","sunny","day"]
+
+**Explanation:** "the", "is", "sunny" and "day" are the four most frequent words, with the number of occurrence being 4, 3, 2 and 1 respectively.
+
+**Constraints:**
+
+*   `1 <= words.length <= 500`
+*   `1 <= words[i].length <= 10`
+*   `words[i]` consists of lowercase English letters.
+*   `k` is in the range <code>[1, The number of **unique** words[i]]</code>
+
+**Follow-up:** Could you solve it in `O(n log(k))` time and `O(n)` extra space?

src/main/kotlin/g0601_0700/s0693_binary_number_with_alternating_bits/Solution.kt

@@ -0,0 +1,20 @@
+package g0601_0700.s0693_binary_number_with_alternating_bits
+
+// #Easy #Bit_Manipulation #2023_02_21_Time_129_ms_(100.00%)_Space_32.8_MB_(100.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun hasAlternatingBits(n: Int): Boolean {
+        var n = n
+        var prev = -1
+        while (n != 0) {
+            val v = n and 1
+            n = n shr 1
+            if (prev == v) {
+                return false
+            }
+            prev = v
+        }
+        return true
+    }
+}

src/main/kotlin/g0601_0700/s0693_binary_number_with_alternating_bits/readme.md

@@ -0,0 +1,33 @@
+693\. Binary Number with Alternating Bits
+
+Easy
+
+Given a positive integer, check whether it has alternating bits: namely, if two adjacent bits will always have different values.
+
+**Example 1:**
+
+**Input:** n = 5
+
+**Output:** true
+
+**Explanation:** The binary representation of 5 is: 101
+
+**Example 2:**
+
+**Input:** n = 7
+
+**Output:** false
+
+**Explanation:** The binary representation of 7 is: 111.
+
+**Example 3:**
+
+**Input:** n = 11
+
+**Output:** false
+
+**Explanation:** The binary representation of 11 is: 1011.
+
+**Constraints:**
+
+*   <code>1 <= n <= 2<sup>31</sup> - 1</code>

src/main/kotlin/g0601_0700/s0695_max_area_of_island/Solution.kt

@@ -0,0 +1,41 @@
+package g0601_0700.s0695_max_area_of_island
+
+// #Medium #Array #Depth_First_Search #Breadth_First_Search #Matrix #Union_Find
+// #Algorithm_I_Day_7_Breadth_First_Search_Depth_First_Search
+// #Graph_Theory_I_Day_2_Matrix_Related_Problems
+// #2023_02_22_Time_324_ms_(24.06%)_Space_47.2_MB_(21.92%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun maxAreaOfIsland(grid: Array<IntArray>?): Int {
+        if (grid.isNullOrEmpty()) {
+            return 0
+        }
+        val m = grid.size
+        val n = grid[0].size
+        var max = 0
+        for (i in 0 until m) {
+            for (j in 0 until n) {
+                if (grid[i][j] == 1) {
+                    val area = dfs(grid, i, j, m, n, 0)
+                    max = Math.max(area, max)
+                }
+            }
+        }
+        return max
+    }
+
+    private fun dfs(grid: Array<IntArray>, i: Int, j: Int, m: Int, n: Int, area: Int): Int {
+        var area = area
+        if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == 0) {
+            return area
+        }
+        grid[i][j] = 0
+        area++
+        area = dfs(grid, i + 1, j, m, n, area)
+        area = dfs(grid, i, j + 1, m, n, area)
+        area = dfs(grid, i - 1, j, m, n, area)
+        area = dfs(grid, i, j - 1, m, n, area)
+        return area
+    }
+}

src/main/kotlin/g0601_0700/s0695_max_area_of_island/readme.md

@@ -0,0 +1,32 @@
+695\. Max Area of Island
+
+Medium
+
+You are given an `m x n` binary matrix `grid`. An island is a group of `1`'s (representing land) connected **4-directionally** (horizontal or vertical.) You may assume all four edges of the grid are surrounded by water.
+
+The **area** of an island is the number of cells with a value `1` in the island.
+
+Return _the maximum **area** of an island in_ `grid`. If there is no island, return `0`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/05/01/maxarea1-grid.jpg)
+
+**Input:** grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
+
+**Output:** 6
+
+**Explanation:** The answer is not 11, because the island must be connected 4-directionally.
+
+**Example 2:**
+
+**Input:** grid = [[0,0,0,0,0,0,0,0]]
+
+**Output:** 0
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 50`
+*   `grid[i][j]` is either `0` or `1`.

src/main/kotlin/g0601_0700/s0696_count_binary_substrings/Solution.kt

@@ -0,0 +1,24 @@
+package g0601_0700.s0696_count_binary_substrings
+
+// #Easy #String #Two_Pointers #2023_02_21_Time_222_ms_(100.00%)_Space_36.5_MB_(55.56%)
+
+class Solution {
+    fun countBinarySubstrings(s: String): Int {
+        var start = 0
+        var ans = 0
+        val arr = s.toCharArray()
+        for (i in 1 until arr.size) {
+            if (arr[i] != arr[i - 1]) {
+                ans++
+                start = i - 1
+            } else if (start > 0 && arr[--start] != arr[i]) {
+                // if start isn't 0, we may still have a valid substring
+                ans++
+            } else {
+                // if not, then reset start to 0
+                start = 0
+            }
+        }
+        return ans
+    }
+}

src/main/kotlin/g0601_0700/s0696_count_binary_substrings/readme.md

@@ -0,0 +1,28 @@
+696\. Count Binary Substrings
+
+Easy
+
+Given a binary string `s`, return the number of non-empty substrings that have the same number of `0`'s and `1`'s, and all the `0`'s and all the `1`'s in these substrings are grouped consecutively.
+
+Substrings that occur multiple times are counted the number of times they occur.
+
+**Example 1:**
+
+**Input:** s = "00110011"
+
+**Output:** 6
+
+**Explanation:** There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01". Notice that some of these substrings repeat and are counted the number of times they occur. Also, "00110011" is not a valid substring because all the 0's (and 1's) are not grouped together.
+
+**Example 2:**
+
+**Input:** s = "10101"
+
+**Output:** 4
+
+**Explanation:** There are 4 substrings: "10", "01", "10", "01" that have equal number of consecutive 1's and 0's.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s[i]` is either `'0'` or `'1'`.

src/test/kotlin/g0601_0700/s0692_top_k_frequent_words/SolutionTest.kt

@@ -0,0 +1,31 @@
+package g0601_0700.s0692_top_k_frequent_words
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun topKFrequent() {
+        assertThat(
+            Solution()
+                .topKFrequent(arrayOf("i", "love", "leetcode", "i", "love", "coding"), 2),
+            equalTo(listOf("i", "love"))
+        )
+    }
+
+    @Test
+    fun topKFrequent2() {
+        assertThat(
+            Solution()
+                .topKFrequent(
+                    arrayOf(
+                        "the", "day", "is", "sunny", "the", "the", "the", "sunny", "is",
+                        "is"
+                    ),
+                    4
+                ),
+            equalTo(listOf("the", "is", "sunny", "day"))
+        )
+    }
+}