Merge branch 'master' into patch-8

Author: Panquesito7

CONTRIBUTING.md

@@ -113,7 +113,7 @@ bool func(int param1, T param2) {
  * @returns void
  */
 static void test() {
-    /* desciptions of the following test */
+    /* descriptions of the following test */
     assert(func(...) == ...); // this ensures that the algorithm works as expected
 
     // can have multiple checks

DIRECTORY.md

@@ -8,9 +8,11 @@
   * [Nqueen Print All Solutions](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/backtracking/nqueen_print_all_solutions.cpp)
   * [Rat Maze](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/backtracking/rat_maze.cpp)
   * [Subarray Sum](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/backtracking/subarray_sum.cpp)
+  * [Subset Sum](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/backtracking/subset_sum.cpp)
   * [Sudoku Solve](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/backtracking/sudoku_solve.cpp)
 
 ## Bit Manipulation
+  * [Count Of Set Bits](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/bit_manipulation/count_of_set_bits.cpp)
   * [Hamming Distance](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/bit_manipulation/hamming_distance.cpp)
 
 ## Ciphers
@@ -74,6 +76,7 @@
   * [Egg Dropping Puzzle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/egg_dropping_puzzle.cpp)
   * [Fibonacci Bottom Up](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/fibonacci_bottom_up.cpp)
   * [Floyd Warshall](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/floyd_warshall.cpp)
+  * [House Robber](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/house_robber.cpp)
   * [Kadane](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/kadane.cpp)
   * [Kadane2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/kadane2.cpp)
   * [Longest Common String](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/longest_common_string.cpp)
@@ -269,6 +272,7 @@
   * [Linear Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/linear_search.cpp)
   * [Median Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/median_search.cpp)
   * [Saddleback Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/saddleback_search.cpp)
+  * [Sublist Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/sublist_search.cpp)
   * [Ternary Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/ternary_search.cpp)
   * [Text Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/text_search.cpp)
 
@@ -299,6 +303,7 @@
   * [Quick Sort 3](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/quick_sort_3.cpp)
   * [Radix Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/radix_sort.cpp)
   * [Radix Sort2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/radix_sort2.cpp)
+  * [Random Pivot Quick Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/random_pivot_quick_sort.cpp)
   * [Recursive Bubble Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/recursive_bubble_sort.cpp)
   * [Selection Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/selection_sort.cpp)
   * [Shell Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/shell_sort.cpp)
@@ -307,6 +312,7 @@
   * [Strand Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/strand_sort.cpp)
   * [Swap Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/swap_sort.cpp)
   * [Tim Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/tim_sort.cpp)
+  * [Wave Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/wave_sort.cpp)
   * [Wiggle Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/wiggle_sort.cpp)
 
 ## Strings

backtracking/graph_coloring.cpp

@@ -30,11 +30,11 @@ namespace backtracking {
      */
     template <size_t V>
     void printSolution(const std::array <int, V>& color) {
-        std::cout << "Following are the assigned colors\n";
+        std::cout << "Following are the assigned colors" << std::endl;
         for (auto &col : color) {
             std::cout << col;
         }
-        std::cout << "\n";
+        std::cout << std::endl;
     }
 
     /** A utility function to check if the current color assignment is safe for

backtracking/subset_sum.cpp

@@ -0,0 +1,106 @@
+/**
+ * @file
+ * @brief Implementation of the [Subset
+ * Sum](https://en.wikipedia.org/wiki/Subset_sum_problem) problem.
+ * @details
+ * We are given an array and a sum value. The algorithm finds all
+ * the subsets of that array with sum equal to the given sum and return such
+ * subsets count. This approach will have exponential time complexity.
+ * @author [Swastika Gupta](https://github.com/Swastyy)
+ */
+
+#include <cassert>   /// for assert
+#include <iostream>  /// for IO operations
+#include <vector>    /// for std::vector
+
+/**
+ * @namespace backtracking
+ * @brief Backtracking algorithms
+ */
+namespace backtracking {
+/**
+ * @namespace Subsets
+ * @brief Functions for the [Subset
+ * Sum](https://en.wikipedia.org/wiki/Subset_sum_problem) problem.
+ */
+namespace subset_sum {
+/**
+ * @brief The main function implements count of subsets
+ * @param sum is the required sum of any subset
+ * @param in_arr is the input array
+ * @returns count of the number of subsets with required sum
+ */
+uint64_t number_of_subsets(int32_t sum, const std::vector<int32_t> &in_arr) {
+    int32_t nelement = in_arr.size();
+    uint64_t count_of_subset = 0;
+
+    for (int32_t i = 0; i < (1 << (nelement)); i++) {
+        int32_t check = 0;
+        for (int32_t j = 0; j < nelement; j++) {
+            if (i & (1 << j)) {
+                check += (in_arr[j]);
+            }
+        }
+        if (check == sum) {
+            count_of_subset++;
+        }
+    }
+    return count_of_subset;
+}
+}  // namespace subset_sum
+}  // namespace backtracking
+
+/**
+ * @brief Test implementations
+ * @returns void
+ */
+static void test() {
+    // 1st test
+    std::cout << "1st test ";
+    std::vector<int32_t> array1 = {-7, -3, -2, 5, 8};  // input array
+    assert(backtracking::subset_sum::number_of_subsets(0, array1) ==
+           2);  // first argument in subset_sum function is the required sum and
+                // second is the input array
+    std::cout << "passed" << std::endl;
+
+    // 2nd test
+    std::cout << "2nd test ";
+    std::vector<int32_t> array2 = {1, 2, 3, 3};
+    assert(backtracking::subset_sum::number_of_subsets(6, array2) ==
+           3);  // here we are expecting 3 subsets which sum up to 6 i.e.
+                // {(1,2,3),(1,2,3),(3,3)}
+    std::cout << "passed" << std::endl;
+
+    // 3rd test
+    std::cout << "3rd test ";
+    std::vector<int32_t> array3 = {1, 1, 1, 1};
+    assert(backtracking::subset_sum::number_of_subsets(1, array3) ==
+           4);  // here we are expecting 4 subsets which sum up to 1 i.e.
+                // {(1),(1),(1),(1)}
+    std::cout << "passed" << std::endl;
+
+    // 4th test
+    std::cout << "4th test ";
+    std::vector<int32_t> array4 = {3, 3, 3, 3};
+    assert(backtracking::subset_sum::number_of_subsets(6, array4) ==
+           6);  // here we are expecting 6 subsets which sum up to 6 i.e.
+                // {(3,3),(3,3),(3,3),(3,3),(3,3),(3,3)}
+    std::cout << "passed" << std::endl;
+
+    // Test 5
+    std::cout << "5th test ";
+    std::vector<int32_t> array5 = {};
+    assert(backtracking::subset_sum::number_of_subsets(6, array5) ==
+           0);  // here we are expecting 0 subsets which sum up to 6 i.e. we
+                // cannot select anything from an empty array
+    std::cout << "passed" << std::endl;
+}
+
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
+int main() {
+    test();  // run self-test implementations
+    return 0;
+}

bit_manipulation/count_of_set_bits.cpp

@@ -0,0 +1,80 @@
+/**
+ * @file
+ * @brief Implementation to [count sets
+ * bits](https://www.geeksforgeeks.org/count-set-bits-in-an-integer/) in an
+ * integer.
+ *
+ * @details
+ * We are given an integer number. Let’s say, number. The task is to first
+ * calculate the binary digit of a number and then calculate the total set bits
+ * of a number.
+ *
+ * Set bits in a binary number is represented by 1. Whenever we calculate the
+ * binary number of an integer value it is formed as the combination of 0’s and
+ * 1’s. So digit 1 is known as a set bit in computer terms.
+ * Time Complexity: O(log n)
+ * Space complexity: O(1)
+ * @author [Swastika Gupta](https://github.com/Swastyy)
+ */
+
+#include <cassert>   /// for assert
+#include <iostream>  /// for io operations
+#include <vector>    /// for std::vector
+
+/**
+ * @namespace bit_manipulation
+ * @brief Bit manipulation algorithms
+ */
+namespace bit_manipulation {
+/**
+ * @namespace count_of_set_bits
+ * @brief Functions for the [count sets
+ * bits](https://www.geeksforgeeks.org/count-set-bits-in-an-integer/)
+ * implementation
+ */
+namespace count_of_set_bits {
+/**
+ * @brief The main function implements set bit count
+ * @param n is the number whose set bit will be counted
+ * @returns the count of the number set bit in the binary representation of `n`
+ */
+std::uint64_t countSetBits(int n) {
+    int count = 0;  // "count" variable is used to count number of 1's in binary
+                    // representation of the number
+    while (n != 0) {
+        count += n & 1;
+        n = n >> 1;  // n=n/2
+    }
+    return count;
+}
+}  // namespace count_of_set_bits
+}  // namespace bit_manipulation
+
+/**
+ * @brief Self-test implementations
+ * @returns void
+ */
+static void test() {
+    // n = 4 return 1
+    assert(bit_manipulation::count_of_set_bits::countSetBits(4) == 1);
+    // n = 6 return 2
+    assert(bit_manipulation::count_of_set_bits::countSetBits(6) == 2);
+    // n = 13 return 3
+    assert(bit_manipulation::count_of_set_bits::countSetBits(13) == 3);
+    // n = 9 return 2
+    assert(bit_manipulation::count_of_set_bits::countSetBits(9) == 2);
+    // n = 15 return 4
+    assert(bit_manipulation::count_of_set_bits::countSetBits(15) == 4);
+    // n = 25 return 3
+    assert(bit_manipulation::count_of_set_bits::countSetBits(25) == 3);
+    std::cout << "All test cases successfully passed!" << std::endl;
+}
+
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
+int main() {
+    test();  // run self-test implementations
+    return 0;
+}

dynamic_programming/house_robber.cpp

@@ -0,0 +1,114 @@
+/**
+ * @file
+ * @brief Implementation of [House Robber
+ * Problem](https://labuladong.gitbook.io/algo-en/i.-dynamic-programming/houserobber)
+ * algorithm
+ * @details
+ * Solution of House robber problem uses a dynamic programming concept that
+ * works in \f$O(n)\f$ time and works in \f$O(1)\f$ space.
+ * @author [Swastika Gupta](https://github.com/Swastyy)
+ */
+
+#include <cassert>   /// for assert
+#include <climits>   /// for std::max
+#include <iostream>  /// for io operations
+#include <vector>    /// for std::vector
+
+/**
+ * @namespace dynamic_programming
+ * @brief Dynamic Programming algorithms
+ */
+namespace dynamic_programming {
+/**
+ * @namespace house_robber
+ * @brief Functions for the [House
+ * Robber](https://labuladong.gitbook.io/algo-en/i.-dynamic-programming/houserobber)
+ * algorithm
+ */
+namespace house_robber {
+/**
+ * @brief The main function that implements the House Robber algorithm using
+ * dynamic programming
+ * @param money array containing money in the ith house
+ * @param n size of array
+ * @returns maximum amount of money that can be robbed
+ */
+std::uint32_t houseRobber(const std::vector<uint32_t> &money,
+                          const uint32_t &n) {
+    if (n == 0) {  // if there is no house
+        return 0;
+    }
+    if (n == 1) {  // if there is only one house
+        return money[0];
+    }
+    if (n == 2) {  // if there are two houses, one with the maximum amount of
+                   // money will be robbed
+        return std::max(money[0], money[1]);
+    }
+    uint32_t max_value = 0;  // contains maximum stolen value at the end
+    uint32_t value1 = money[0];
+    uint32_t value2 = std::max(money[0], money[1]);
+    for (uint32_t i = 2; i < n; i++) {
+        max_value = std::max(money[i] + value1, value2);
+        value1 = value2;
+        value2 = max_value;
+    }
+
+    return max_value;
+}
+}  // namespace house_robber
+}  // namespace dynamic_programming
+
+/**
+ * @brief Self-test implementations
+ * @returns void
+ */
+static void test() {
+    // Test 1
+    // [1, 2, 3, 1] return 4
+    std::vector<uint32_t> array1 = {1, 2, 3, 1};
+    std::cout << "Test 1... ";
+    assert(
+        dynamic_programming::house_robber::houseRobber(array1, array1.size()) ==
+        4);  // here the two non-adjacent houses that are robbed are first and
+             // third with total sum money as 4
+    std::cout << "passed" << std::endl;
+
+    // Test 2
+    // [6, 7, 1, 3, 8, 2, 4] return 19
+    std::vector<uint32_t> array2 = {6, 7, 1, 3, 8, 2, 4};
+    std::cout << "Test 2... ";
+    assert(
+        dynamic_programming::house_robber::houseRobber(array2, array2.size()) ==
+        19);  // here the four non-adjacent houses that are robbed are first,
+              // third, fifth and seventh with total sum money as 19
+    std::cout << "passed" << std::endl;
+
+    // Test 3
+    // [] return 0
+    std::vector<uint32_t> array3 = {};
+    std::cout << "Test 3... ";
+    assert(
+        dynamic_programming::house_robber::houseRobber(array3, array3.size()) ==
+        0);  // since there is no house no money can be robbed
+    std::cout << "passed" << std::endl;
+
+    // Test 4
+    // [2,7,9,3,1] return 12
+    std::vector<uint32_t> array4 = {2, 7, 9, 3, 1};
+    std::cout << "Test 4... ";
+    assert(
+        dynamic_programming::house_robber::houseRobber(array4, array4.size()) ==
+        12);  // here the three non-adjacent houses that are robbed are first,
+              // third and fifth with total sum money as 12
+    std::cout << "passed" << std::endl;
+}
+
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
+int main() {
+    test();  // run self-test implementations
+    return 0;
+}