Merge branch 'TheAlgorithms:master' into master

Author: SharonIV0x86

DIRECTORY.md

@@ -161,6 +161,7 @@
 
 ## Greedy Algorithms
   * [Boruvkas Minimum Spanning Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/boruvkas_minimum_spanning_tree.cpp)
+  * [Digit Separation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/digit_separation.cpp)
   * [Dijkstra](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/dijkstra.cpp)
   * [Gale Shapley](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/gale_shapley.cpp)
   * [Huffman](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/huffman.cpp)
@@ -300,6 +301,8 @@
   * [Iterative Tree Traversals](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/others/iterative_tree_traversals.cpp)
   * [Kadanes3](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/others/kadanes3.cpp)
   * [Kelvin To Celsius](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/others/kelvin_to_celsius.cpp)
+  * [Lfu Cache](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/others/lfu_cache.cpp)
+  * [Longest Substring Without Repeating Characters](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/others/longest_substring_without_repeating_characters.cpp)
   * [Lru Cache](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/others/lru_cache.cpp)
   * [Matrix Exponentiation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/others/matrix_exponentiation.cpp)
   * [Palindrome Of Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/others/palindrome_of_number.cpp)
@@ -322,6 +325,7 @@
   * [Addition Rule](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/probability/addition_rule.cpp)
   * [Bayes Theorem](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/probability/bayes_theorem.cpp)
   * [Binomial Dist](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/probability/binomial_dist.cpp)
+  * [Exponential Dist](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/probability/exponential_dist.cpp)
   * [Geometric Dist](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/probability/geometric_dist.cpp)
   * [Poisson Dist](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/probability/poisson_dist.cpp)
   * [Windowed Median](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/probability/windowed_median.cpp)
@@ -369,6 +373,7 @@
   * [Gnome Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/gnome_sort.cpp)
   * [Heap Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/heap_sort.cpp)
   * [Insertion Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/insertion_sort.cpp)
+  * [Insertion Sort Recursive](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/insertion_sort_recursive.cpp)
   * [Library Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/library_sort.cpp)
   * [Merge Insertion Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/merge_insertion_sort.cpp)
   * [Merge Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/sorting/merge_sort.cpp)

greedy_algorithms/digit_separation.cpp

@@ -0,0 +1,142 @@
+/**
+ * @file digit_separation.cpp
+ * @brief Separates digits from numbers in forward and reverse order
+ * @see https://www.log2base2.com/c-examples/loop/split-a-number-into-digits-in-c.html
+ * @details The DigitSeparation class provides two methods to separate the
+ * digits of large integers: digitSeparationReverseOrder and
+ * digitSeparationForwardOrder. The digitSeparationReverseOrder method extracts
+ * digits by repeatedly applying the modulus operation (% 10) to isolate the
+ * last digit, then divides the number by 10 to remove it. This process
+ * continues until the entire number is broken down into its digits, which are
+ * stored in reverse order. If the number is zero, the method directly returns a
+ * vector containing {0} to handle this edge case. Negative numbers are handled
+ * by taking the absolute value, ensuring consistent behavior regardless of the
+ * sign.
+ * @author [Muhammad Junaid Khalid](https://github.com/mjk22071998)
+ */
+
+#include <algorithm>  /// For reveresing the vector
+#include <cassert>    /// For assert() function to check for errors
+#include <cmath>      /// For abs() function
+#include <cstdint>    /// For int64_t data type to handle large numbers
+#include <iostream>   /// For input/output operations
+#include <vector>     /// For std::vector to store separated digits
+
+/**
+ * @namespace
+ * @brief Greedy Algorithms
+ */
+namespace greedy_algorithms {
+
+/**
+ * @brief A class that provides methods to separate the digits of a large
+ * positive number.
+ */
+class DigitSeparation {
+ public:
+    /**
+     * @brief Default constructor for the DigitSeparation class.
+     */
+    DigitSeparation() {}
+
+    /**
+     * @brief Implementation of digitSeparationReverseOrder method.
+     *
+     * @param largeNumber The large number to separate digits from.
+     * @return A vector of digits in reverse order.
+     */
+    std::vector<std::int64_t> digitSeparationReverseOrder(
+        std::int64_t largeNumber) const {
+        std::vector<std::int64_t> result;
+        if (largeNumber != 0) {
+            while (largeNumber != 0) {
+                result.push_back(std::abs(largeNumber % 10));
+                largeNumber /= 10;
+            }
+        } else {
+            result.push_back(0);
+        }
+        return result;
+    }
+
+    /**
+     * @brief Implementation of digitSeparationForwardOrder method.
+     *
+     * @param largeNumber The large number to separate digits from.
+     * @return A vector of digits in forward order.
+     */
+    std::vector<std::int64_t> digitSeparationForwardOrder(
+        std::int64_t largeNumber) const {
+        std::vector<std::int64_t> result =
+            digitSeparationReverseOrder(largeNumber);
+        std::reverse(result.begin(), result.end());
+        return result;
+    }
+};
+
+}  // namespace greedy_algorithms
+
+/**
+ * @brief self test implementation
+ * @return void
+ */
+static void tests() {
+    greedy_algorithms::DigitSeparation ds;
+
+    // Test case: Positive number
+    std::int64_t number = 1234567890;
+    std::vector<std::int64_t> expectedReverse = {0, 9, 8, 7, 6, 5, 4, 3, 2, 1};
+    std::vector<std::int64_t> expectedForward = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
+    std::vector<std::int64_t> reverseOrder =
+        ds.digitSeparationReverseOrder(number);
+    assert(reverseOrder == expectedReverse);
+    std::vector<std::int64_t> forwardOrder =
+        ds.digitSeparationForwardOrder(number);
+    assert(forwardOrder == expectedForward);
+
+    // Test case: Single digit number
+    number = 5;
+    expectedReverse = {5};
+    expectedForward = {5};
+    reverseOrder = ds.digitSeparationReverseOrder(number);
+    assert(reverseOrder == expectedReverse);
+    forwardOrder = ds.digitSeparationForwardOrder(number);
+    assert(forwardOrder == expectedForward);
+
+    // Test case: Zero
+    number = 0;
+    expectedReverse = {0};
+    expectedForward = {0};
+    reverseOrder = ds.digitSeparationReverseOrder(number);
+    assert(reverseOrder == expectedReverse);
+    forwardOrder = ds.digitSeparationForwardOrder(number);
+    assert(forwardOrder == expectedForward);
+
+    // Test case: Large number
+    number = 987654321012345;
+    expectedReverse = {5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    expectedForward = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5};
+    reverseOrder = ds.digitSeparationReverseOrder(number);
+    assert(reverseOrder == expectedReverse);
+    forwardOrder = ds.digitSeparationForwardOrder(number);
+    assert(forwardOrder == expectedForward);
+
+    // Test case: Negative number
+    number = -987654321012345;
+    expectedReverse = {5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    expectedForward = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5};
+    reverseOrder = ds.digitSeparationReverseOrder(number);
+    assert(reverseOrder == expectedReverse);
+    forwardOrder = ds.digitSeparationForwardOrder(number);
+    assert(forwardOrder == expectedForward);
+}
+
+/**
+ * @brief main function
+ * @return 0 on successful exit
+ */
+int main() {
+    tests();  // run self test implementation
+
+    return 0;
+}

math/area.cpp

@@ -109,6 +109,18 @@ template <typename T>
 T cylinder_surface_area(T radius, T height) {
     return 2 * M_PI * radius * height + 2 * M_PI * pow(radius, 2);
 }
+
+/**
+ * @brief surface area of a [hemi-sphere](https://en.wikipedia.org/wiki/Surface_area) ( 3 *
+ * pi * r^2)
+ * @param radius is the radius of the hemi-sphere
+ * @tparam T datatype of radius
+ * @returns surface area of the hemi-sphere
+ */
+template <typename T>
+T hemi_sphere_surface_area(T radius) {
+    return 3 * M_PI * pow(radius, 2);
+}
 }  // namespace math
 
 /**
@@ -267,6 +279,18 @@ static void test() {
     std::cout << "Output: " << double_area << std::endl;
     assert(double_area == double_expected);
     std::cout << "TEST PASSED" << std::endl << std::endl;
+
+    // 11th test
+    double_radius = 10.0;
+    double_expected = 942.4777960769379;
+    double_area = math::hemi_sphere_surface_area(double_radius);
+
+    std::cout << "SURFACE AREA OF A HEMI-SPHERE" << std::endl;
+    std::cout << "Input Radius: " << double_radius << std::endl;
+    std::cout << "Expected Output: " << double_expected << std::endl;
+    std::cout << "Output: " << double_area << std::endl;
+    assert(double_area == double_expected);
+    std::cout << "TEST PASSED" << std::endl << std::endl;
 }
 
 /**

math/fibonacci.cpp

@@ -1,68 +1,65 @@
 /**
  * @file
- * @brief Generate fibonacci sequence
+ * @brief n-th [Fibonacci
+ * number](https://en.wikipedia.org/wiki/Fibonacci_sequence).
  *
- * Calculate the the value on Fibonacci's sequence given an
- * integer as input.
+ * @details
+ * Naive recursive implementation to calculate the n-th Fibonacci number.
  * \f[\text{fib}(n) = \text{fib}(n-1) + \text{fib}(n-2)\f]
  *
  * @see fibonacci_large.cpp, fibonacci_fast.cpp, string_fibonacci.cpp
  */
-#include <cassert>
-#include <iostream>
+#include <cassert>   /// for assert
+#include <iostream>  /// for IO operations
 
 /**
- * Recursively compute sequences
- * @param n input
- * @returns n-th element of the Fbinacci's sequence
+ * @namespace math
+ * @brief Math algorithms
+ */
+namespace math {
+/**
+ * @namespace fibonacci
+ * @brief Functions for Fibonacci sequence
+ */
+namespace fibonacci {
+/**
+ * @brief Function to compute the n-th Fibonacci number
+ * @param n the index of the Fibonacci number
+ * @returns n-th element of the Fibonacci's sequence
  */
 uint64_t fibonacci(uint64_t n) {
-    /* If the input is 0 or 1 just return the same
-       This will set the first 2 values of the sequence */
+    // If the input is 0 or 1 just return the same (Base Case)
+    // This will set the first 2 values of the sequence
     if (n <= 1) {
         return n;
     }
 
-    /* Add the last 2 values of the sequence to get next */
+    // Add the preceding 2 values of the sequence to get next
     return fibonacci(n - 1) + fibonacci(n - 2);
 }
+}  // namespace fibonacci
+}  // namespace math
 
 /**
- * Function for testing the fibonacci() function with a few
- * test cases and assert statement.
+ * @brief Self-test implementation
  * @returns `void`
-*/
+ */
 static void test() {
-    uint64_t test_case_1 = fibonacci(0);
-    assert(test_case_1 == 0);
-    std::cout << "Passed Test 1!" << std::endl;
-
-    uint64_t test_case_2 = fibonacci(1);
-    assert(test_case_2 == 1);
-    std::cout << "Passed Test 2!" << std::endl;
-
-    uint64_t test_case_3 = fibonacci(2);
-    assert(test_case_3 == 1);
-    std::cout << "Passed Test 3!" << std::endl;
-
-    uint64_t test_case_4 = fibonacci(3);
-    assert(test_case_4 == 2);
-    std::cout << "Passed Test 4!" << std::endl;
-
-    uint64_t test_case_5 = fibonacci(4);
-    assert(test_case_5 == 3);
-    std::cout << "Passed Test 5!" << std::endl;
-
-    uint64_t test_case_6 = fibonacci(15);
-    assert(test_case_6 == 610);
-    std::cout << "Passed Test 6!" << std::endl << std::endl;
+    assert(math::fibonacci::fibonacci(0) == 0);
+    assert(math::fibonacci::fibonacci(1) == 1);
+    assert(math::fibonacci::fibonacci(2) == 1);
+    assert(math::fibonacci::fibonacci(3) == 2);
+    assert(math::fibonacci::fibonacci(4) == 3);
+    assert(math::fibonacci::fibonacci(15) == 610);
+    assert(math::fibonacci::fibonacci(20) == 6765);
+    std::cout << "All tests have passed successfully!\n";
 }
 
-/// Main function
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
 int main() {
-    test();
-    int n = 0;
-    std::cin >> n;
-    assert(n >= 0);
-    std::cout << "F(" << n << ")= " << fibonacci(n) << std::endl;
+    test();  // run self-test implementations
+    return 0;
 }