Added tasks 188, 190, 191, 192.

Author: ThanhNIT

README.md

@@ -368,6 +368,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0191 |[Number of 1 Bits](src/main/kotlin/g0101_0200/s0191_number_of_1_bits/Solution.kt)| Easy | Top_Interview_Questions, Bit_Manipulation | 237 | 68.44
 
 #### Day 3 Conditional Statements
 
@@ -1057,6 +1058,8 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0191 |[Number of 1 Bits](src/main/kotlin/g0101_0200/s0191_number_of_1_bits/Solution.kt)| Easy | Top_Interview_Questions, Bit_Manipulation | 237 | 68.44
+| 0190 |[Rotate Array](src/main/kotlin/g0101_0200/s0190_reverse_bits/Solution.kt)| Easy | Top_Interview_Questions, Bit_Manipulation, Divide_and_Conquer | 198 | 81.82
 | 0338 |[Counting Bits](src/main/kotlin/g0301_0400/s0338_counting_bits/Solution.kt)| Easy | Top_100_Liked_Questions, Dynamic_Programming, Bit_Manipulation | 186 | 99.26
 | 0029 |[Divide Two Integers](src/main/kotlin/g0001_0100/s0029_divide_two_integers/Solution.kt)| Medium | Top_Interview_Questions, Math, Bit_Manipulation | 281 | 31.67
 
@@ -1381,11 +1384,13 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0191 |[Number of 1 Bits](src/main/kotlin/g0101_0200/s0191_number_of_1_bits/Solution.kt)| Easy | Top_Interview_Questions, Bit_Manipulation | 237 | 68.44
 
 #### Day 14 Bit Manipulation
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0190 |[Rotate Array](src/main/kotlin/g0101_0200/s0190_reverse_bits/Solution.kt)| Easy | Top_Interview_Questions, Bit_Manipulation, Divide_and_Conquer | 198 | 81.82
 | 0136 |[Single Number](src/main/kotlin/g0101_0200/s0136_single_number/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Bit_Manipulation | 344 | 83.63
 
 ### Algorithm II
@@ -1566,7 +1571,11 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | 0200 |[Number of Islands](src/main/kotlin/g0101_0200/s0200_number_of_islands/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find, Algorithm_II_Day_6_Breadth_First_Search_Depth_First_Search, Graph_Theory_I_Day_1_Matrix_Related_Problems, Level_1_Day_9_Graph/BFS/DFS, Udemy_Graph | 252 | 95.41
 | 0199 |[Binary Tree Right Side View](src/main/kotlin/g0101_0200/s0199_binary_tree_right_side_view/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Data_Structure_II_Day_16_Tree, Level_2_Day_15_Tree | 194 | 92.89
 | 0198 |[House Robber](src/main/kotlin/g0101_0200/s0198_house_robber/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Algorithm_I_Day_12_Dynamic_Programming, Dynamic_Programming_I_Day_3, Level_2_Day_12_Dynamic_Programming, Udemy_Dynamic_Programming | 156 | 92.24
+| 0192 |[Word Frequency](src/main/kotlin/g0101_0200/s0192_word_frequency/script.sh)| Medium | Shell | 114 | 73.60
+| 0191 |[Number of 1 Bits](src/main/kotlin/g0101_0200/s0191_number_of_1_bits/Solution.kt)| Easy | Top_Interview_Questions, Bit_Manipulation, Algorithm_I_Day_13_Bit_Manipulation, Programming_Skills_I_Day_2_Operator, Udemy_Bit_Manipulation | 237 | 68.44
+| 0190 |[Rotate Array](src/main/kotlin/g0101_0200/s0190_reverse_bits/Solution.kt)| Easy | Top_Interview_Questions, Bit_Manipulation, Divide_and_Conquer, Algorithm_I_Day_14_Bit_Manipulation, Udemy_Bit_Manipulation | 198 | 81.82
 | 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, Algorithm_I_Day_2_Two_Pointers, Udemy_Arrays | 483 | 86.95
+| 0188 |[Best Time to Buy and Sell Stock IV](src/main/kotlin/g0101_0200/s0188_best_time_to_buy_and_sell_stock_iv/Solution.kt)| Hard | Array, Dynamic_Programming | 293 | 68.31
 | 0187 |[Repeated DNA Sequences](src/main/kotlin/g0101_0200/s0187_repeated_dna_sequences/Solution.kt)| Medium | String, Hash_Table, Bit_Manipulation, Sliding_Window, Hash_Function, Rolling_Hash, Data_Structure_II_Day_9_String, Udemy_Strings | 319 | 79.03
 | 0185 |[Department Top Three Salaries](src/main/kotlin/g0101_0200/s0185_department_top_three_salaries/script.sql)| Hard | Database | 757 | 87.06
 | 0184 |[Department Highest Salary](src/main/kotlin/g0101_0200/s0184_department_highest_salary/script.sql)| Medium | Database | 637 | 76.01

src/main/kotlin/g0101_0200/s0188_best_time_to_buy_and_sell_stock_iv/Solution.kt

@@ -0,0 +1,22 @@
+package g0101_0200.s0188_best_time_to_buy_and_sell_stock_iv
+
+// #Hard #Array #Dynamic_Programming #2022_10_18_Time_293_ms_(68.31%)_Space_34.9_MB_(84.15%)
+
+class Solution {
+    fun maxProfit(k: Int, prices: IntArray): Int {
+        val n = prices.size
+        val dp = IntArray(k + 1)
+        val maxdp = IntArray(k + 1)
+        for (i in 0..k) {
+            maxdp[i] = Int.MIN_VALUE
+        }
+        for (i in 1..n) {
+            maxdp[0] = Math.max(maxdp[0], dp[0] - prices[i - 1])
+            for (j in k downTo 1) {
+                maxdp[j] = Math.max(maxdp[j], dp[j] - prices[i - 1])
+                dp[j] = Math.max(maxdp[j - 1] + prices[i - 1], dp[j])
+            }
+        }
+        return dp[k]
+    }
+}

src/main/kotlin/g0101_0200/s0188_best_time_to_buy_and_sell_stock_iv/readme.md

@@ -0,0 +1,31 @@
+188\. Best Time to Buy and Sell Stock IV
+
+Hard
+
+You are given an integer array `prices` where `prices[i]` is the price of a given stock on the <code>i<sup>th</sup></code> day, and an integer `k`.
+
+Find the maximum profit you can achieve. You may complete at most `k` transactions.
+
+**Note:** You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).
+
+**Example 1:**
+
+**Input:** k = 2, prices = [2,4,1]
+
+**Output:** 2
+
+**Explanation:** Buy on day 1 (price = 2) and sell on day 2 (price = 4), profit = 4-2 = 2.
+
+**Example 2:**
+
+**Input:** k = 2, prices = [3,2,6,5,0,3]
+
+**Output:** 7
+
+**Explanation:** Buy on day 2 (price = 2) and sell on day 3 (price = 6), profit = 6-2 = 4. Then buy on day 5 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
+
+**Constraints:**
+
+*   `1 <= k <= 100`
+*   `1 <= prices.length <= 1000`
+*   `0 <= prices[i] <= 1000`

src/main/kotlin/g0101_0200/s0190_reverse_bits/Solution.kt

@@ -0,0 +1,23 @@
+package g0101_0200.s0190_reverse_bits
+
+// #Easy #Top_Interview_Questions #Bit_Manipulation #Divide_and_Conquer
+// #Algorithm_I_Day_14_Bit_Manipulation #Udemy_Bit_Manipulation
+// #2022_10_18_Time_198_ms_(81.82%)_Space_32.8_MB_(73.86%)
+
+class Solution {
+    // you need treat n as an unsigned value
+    fun reverseBits(n: Int): Int {
+        var n = n
+        var ret = 0
+        // because there are 32 bits in total
+        for (i in 0..31) {
+            ret = ret shl 1
+            // If the bit is 1 we OR it with 1, ie add 1
+            if (n and 1 > 0) {
+                ret = ret or 1
+            }
+            n = n ushr 1
+        }
+        return ret
+    }
+}

src/main/kotlin/g0101_0200/s0190_reverse_bits/readme.md

@@ -0,0 +1,42 @@
+189\. Rotate Array
+
+Medium
+
+Given an array, rotate the array to the right by `k` steps, where `k` is non-negative.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4,5,6,7], k = 3
+
+**Output:** [5,6,7,1,2,3,4]
+
+**Explanation:** 
+
+rotate 1 steps to the right: [7,1,2,3,4,5,6] 
+
+rotate 2 steps to the right: [6,7,1,2,3,4,5] 
+
+rotate 3 steps to the right: [5,6,7,1,2,3,4]
+
+**Example 2:**
+
+**Input:** nums = [-1,-100,3,99], k = 2
+
+**Output:** [3,99,-1,-100]
+
+**Explanation:** 
+
+rotate 1 steps to the right: [99,-1,-100,3] 
+
+rotate 2 steps to the right: [3,99,-1,-100]
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+*   <code>0 <= k <= 10<sup>5</sup></code>
+
+**Follow up:**
+
+*   Try to come up with as many solutions as you can. There are at least **three** different ways to solve this problem.
+*   Could you do it in-place with `O(1)` extra space?

src/main/kotlin/g0101_0200/s0191_number_of_1_bits/Solution.kt

@@ -0,0 +1,12 @@
+package g0101_0200.s0191_number_of_1_bits
+
+// #Easy #Top_Interview_Questions #Bit_Manipulation #Algorithm_I_Day_13_Bit_Manipulation
+// #Programming_Skills_I_Day_2_Operator #Udemy_Bit_Manipulation
+// #2022_10_18_Time_237_ms_(68.44%)_Space_33.8_MB_(52.46%)
+
+class Solution {
+    fun hammingWeight(n: Int): Int {
+        val str = Integer.toBinaryString(n).filter { it == '1' }
+        return str.length
+    }
+}

src/main/kotlin/g0101_0200/s0191_number_of_1_bits/readme.md

@@ -0,0 +1,40 @@
+191\. Number of 1 Bits
+
+Easy
+
+Write a function that takes an unsigned integer and returns the number of '1' bits it has (also known as the [Hamming weight](http://en.wikipedia.org/wiki/Hamming_weight)).
+
+**Note:**
+
+*   Note that in some languages, such as Java, there is no unsigned integer type. In this case, the input will be given as a signed integer type. It should not affect your implementation, as the integer's internal binary representation is the same, whether it is signed or unsigned.
+*   In Java, the compiler represents the signed integers using [2's complement notation](https://en.wikipedia.org/wiki/Two%27s_complement). Therefore, in **Example 3**, the input represents the signed integer. `-3`.
+
+**Example 1:**
+
+**Input:** n = 00000000000000000000000000001011
+
+**Output:** 3
+
+**Explanation:** The input binary string **00000000000000000000000000001011** has a total of three '1' bits.
+
+**Example 2:**
+
+**Input:** n = 00000000000000000000000010000000
+
+**Output:** 1
+
+**Explanation:** The input binary string **00000000000000000000000010000000** has a total of one '1' bit.
+
+**Example 3:**
+
+**Input:** n = 11111111111111111111111111111101
+
+**Output:** 31
+
+**Explanation:** The input binary string **11111111111111111111111111111101** has a total of thirty one '1' bits.
+
+**Constraints:**
+
+*   The input must be a **binary string** of length `32`.
+
+**Follow up:** If this function is called many times, how would you optimize it?

src/main/kotlin/g0101_0200/s0192_word_frequency/readme.md

@@ -0,0 +1,30 @@
+192\. Word Frequency
+
+Medium
+
+Write a bash script to calculate the frequency of each word in a text file `words.txt`.
+
+For simplicity sake, you may assume:
+
+*   `words.txt` contains only lowercase characters and space `' '` characters.
+*   Each word must consist of lowercase characters only.
+*   Words are separated by one or more whitespace characters.
+
+**Example:**
+
+Assume that `words.txt` has the following content:
+
+    the day is sunny the the
+    the sunny is is 
+
+Your script should output the following, sorted by descending frequency:
+
+    the 4
+    is 3
+    sunny 2
+    day 1 
+
+**Note:**
+
+*   Don't worry about handling ties, it is guaranteed that each word's frequency count is unique.
+*   Could you write it in one-line using [Unix pipes](http://tldp.org/HOWTO/Bash-Prog-Intro-HOWTO-4.html)?

src/main/kotlin/g0101_0200/s0192_word_frequency/script.sh

@@ -0,0 +1,3 @@
+# Read from the file words.txt and output the word frequency list to stdout.
+# #Medium #Shell #2022_10_18_Time_114_ms_(73.60%)_Space_3.8_MB_(32.09%)sed -e 's/ /\n/g' words.txt |
+sed -e '/^$/d' | sort | uniq -c | sort -r | awk '{print $2" "$1}'

src/test/kotlin/g0101_0200/s0188_best_time_to_buy_and_sell_stock_iv/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0101_0200.s0188_best_time_to_buy_and_sell_stock_iv
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun maxProfit() {
+        assertThat(Solution().maxProfit(2, intArrayOf(2, 4, 1)), equalTo(2))
+    }
+
+    @Test
+    fun maxProfit2() {
+        assertThat(Solution().maxProfit(2, intArrayOf(3, 2, 6, 5, 0, 3)), equalTo(7))
+    }
+}