Merge pull request #153 from BrianLusina/feat/algorithms-dynamic-programming

feat(algorithms, dynamic-programming): counting bits

Author: BrianLusina

DIRECTORY.md

@@ -55,6 +55,10 @@
       * [Test Max Profit Three](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/dynamic_programming/buy_sell_stock/test_max_profit_three.py)
       * [Test Max Profit Two](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/dynamic_programming/buy_sell_stock/test_max_profit_two.py)
       * [Test Max Profit With Fee](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/dynamic_programming/buy_sell_stock/test_max_profit_with_fee.py)
+    * Climb Stairs
+      * [Test Climb Stairs](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/dynamic_programming/climb_stairs/test_climb_stairs.py)
+    * Countingbits
+      * [Test Counting Bits](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/dynamic_programming/countingbits/test_counting_bits.py)
     * Domino Tromino Tiling
       * [Test Domino Tromino Tiling](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/dynamic_programming/domino_tromino_tiling/test_domino_tromino_tiling.py)
     * Duffle Bug Value
@@ -69,6 +73,8 @@
       * [Test Min Distance](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/dynamic_programming/min_distance/test_min_distance.py)
     * Min Path Sum
       * [Test Min Path Sum](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/dynamic_programming/min_path_sum/test_min_path_sum.py)
+    * Painthouse
+      * [Test Min Cost To Paint Houses](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/dynamic_programming/painthouse/test_min_cost_to_paint_houses.py)
     * Palindromic Substring
       * [Longest Palindromic Substring](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/dynamic_programming/palindromic_substring/longest_palindromic_substring.py)
       * [Test Longest Palindromic Substring](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/dynamic_programming/palindromic_substring/test_longest_palindromic_substring.py)
@@ -138,12 +144,16 @@
     * Spread Stones
       * [Test Minimum Moves To Spread Stones](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/greedy/spread_stones/test_minimum_moves_to_spread_stones.py)
   * Heap
+    * Kclosestelements
+      * [Test Find K Closest Elements](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/heap/kclosestelements/test_find_k_closest_elements.py)
     * Longest Happy String
       * [Test Longest Happy String](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/heap/longest_happy_string/test_longest_happy_string.py)
     * Maximal Score After K Operations
       * [Test Maximal Score](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/heap/maximal_score_after_k_operations/test_maximal_score.py)
     * Maximum Subsequence Score
       * [Test Max Subsequence Score](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/heap/maximum_subsequence_score/test_max_subsequence_score.py)
+    * Mergeksortedlists
+      * [Test Merge K Sorted Lists](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/heap/mergeksortedlists/test_merge_k_sorted_lists.py)
     * Min Cost Hire K Workers
       * [Test Min Cost To Hire Workers](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/heap/min_cost_hire_k_workers/test_min_cost_to_hire_workers.py)
     * Min Cost To Connect Sticks
@@ -676,8 +686,6 @@
     * [Battleship](https://github.com/BrianLusina/PythonSnips/blob/master/puzzles/battleship/battleship.py)
   * Beeramid
     * [Test Bearamid](https://github.com/BrianLusina/PythonSnips/blob/master/puzzles/beeramid/test_bearamid.py)
-  * Climb Stairs
-    * [Test Climb Stairs](https://github.com/BrianLusina/PythonSnips/blob/master/puzzles/climb_stairs/test_climb_stairs.py)
   * Find Missing Elem
     * [Test Find Missing Elem](https://github.com/BrianLusina/PythonSnips/blob/master/puzzles/find_missing_elem/test_find_missing_elem.py)
   * Hashmap

puzzles/climb_stairs/README.md …namic_programming/climb_stairs/README.mdpuzzles/climb_stairs/README.md renamed to algorithms/dynamic_programming/climb_stairs/README.md puzzles/climb_stairs/README.md renamed to algorithms/dynamic_programming/climb_stairs/README.md

@@ -0,0 +1,78 @@
+# Counting Bits
+
+Given an integer n, return an array ans of length n + 1 such that for each i (0 <= i <= n), ans[i] is the number of 1's
+in the binary representation of i.
+
+## Examples
+
+```text
+Example 1:
+
+Input: n = 2
+Output: [0,1,1]
+Explanation:
+0 --> 0
+1 --> 1
+2 --> 10
+```
+
+```
+Example 2:
+
+Input: n = 5
+Output: [0,1,1,2,1,2]
+Explanation:
+0 --> 0
+1 --> 1
+2 --> 10
+3 --> 11
+4 --> 100
+5 --> 101
+```
+
+## Constraints
+
+- 0 <= `n` <= 10^5
+
+## Solution
+
+This solution uses a bottom-up dynamic programming approach to solve the problem.
+The key to this problem lies in the fact that any binary number can be broken down into two parts: the least-significant
+(rightmost bit), and the rest of the bits. The rest of the bits can be expressed as the binary number divided by 2
+(rounded down), or `i >> 1`.
+
+For example:
+- 4 in binary = 100
+- rightmost bit = 0
+- rest of bits = 10, which is also (4 // 2) = 2 in binary.
+
+When the number is odd,
+- 5 in binary = 101
+- rightmost bit = 1
+- rest of bits = 10, which is also (5 // 2) = 2 in binary.
+
+in the binary representation of i is that number plus 1 if the rightmost bit is 1. We can tell if the last significant
+bit is 1 by checking if it is odd.
+
+As an example, we know that the number of 1's in 2 is 1. This information can be used to calculate the number of 1's in 4.
+The number of 1's in 4 is the number of 1's in 2 plus 0, because 4 is even.
+
+This establishes a recurrence relationship between the number of 1's in the binary representation of i and the number of
+1's in the binary representation of i // 2: if count[i] is the number of 1's in the binary representation of i, then
+count[i] = count[i // 2] + (i % 2).
+
+With the recurrence relationship established, we can now solve the problem using a bottom-up dynamic programming approach.
+We start with the base case dp[0] = 0, and then build up the solution for dp[i] for i from 1 to n.
+
+![Solution 1](./images/solutions/counting_bits_solution_1.png)
+![Solution 2](./images/solutions/counting_bits_solution_2.png)
+![Solution 3](./images/solutions/counting_bits_solution_3.png)
+![Solution 4](./images/solutions/counting_bits_solution_4.png)
+![Solution 5](./images/solutions/counting_bits_solution_5.png)
+![Solution 6](./images/solutions/counting_bits_solution_6.png)
+![Solution 7](./images/solutions/counting_bits_solution_7.png)
+![Solution 8](./images/solutions/counting_bits_solution_8.png)
+![Solution 9](./images/solutions/counting_bits_solution_9.png)
+![Solution 10](./images/solutions/counting_bits_solution_10.png)
+![Solution 11](./images/solutions/counting_bits_solution_11.png)
+![Solution 12](./images/solutions/counting_bits_solution_12.png)

puzzles/climb_stairs/__init__.py …mic_programming/climb_stairs/__init__.pypuzzles/climb_stairs/__init__.py renamed to algorithms/dynamic_programming/climb_stairs/__init__.py puzzles/climb_stairs/__init__.py renamed to algorithms/dynamic_programming/climb_stairs/__init__.py

@@ -0,0 +1,20 @@
+from typing import List
+
+
+def count_bits(n: int) -> List[int]:
+    """
+    Counts the number of 1 bits in the given integer provided returning a list where count[i] stores the count of '1'
+    bits in the binary form of i.
+    Args:
+        n(int): integer
+    Returns:
+        list: count of 1 bits where each index contains the count of 1 bits
+    """
+    dp = [0] * (n + 1)
+
+    for i in range(1, n + 1):
+        # this can also be solved as which is faster in Python
+        # dp[i] = dp[i >> 1] + (i & 1)
+        dp[i] = dp[i // 2] + (i % 2)
+
+    return dp