Merge branch 'master' into floyd_warshall-into-graph

Author: realstealthninja

.github/workflows/awesome_workflow.yml

@@ -61,7 +61,7 @@ jobs:
           submodules: true
       - run: |
           cmake -B ./build -S .
-          cmake --build build
+          cmake --build build --parallel 4
       - name: Label on PR fail
         uses: actions/github-script@v6
         if: ${{ failure() && matrix.os == 'ubuntu-latest' && github.event_name == 'pull_request' }}

.github/workflows/gh-pages.yml

@@ -25,8 +25,8 @@ jobs:
           clean: false
       - name: Move & Commit files
         run: |
-          git config --global user.name github-actions
-          git config --global user.email '${GITHUB_ACTOR}@users.noreply.github.com'
+          git config --global user.name "$GITHUB_ACTOR"
+          git config --global user.email "$[email protected]"
           git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
           rm -rf d* && rm *.html && rm *.svg && rm *.map && rm *.md5 && rm *.png && rm *.js && rm *.css
           git add .

DIRECTORY.md

@@ -119,6 +119,7 @@
   * [Searching Of Element In Dynamic Array](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/dynamic_programming/searching_of_element_in_dynamic_array.cpp)
   * [Shortest Common Supersequence](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/dynamic_programming/shortest_common_supersequence.cpp)
   * [Subset Sum](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/dynamic_programming/subset_sum.cpp)
+  * [Trapped Rainwater](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/dynamic_programming/trapped_rainwater.cpp)
   * [Tree Height](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/dynamic_programming/tree_height.cpp)
   * [Word Break](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/dynamic_programming/word_break.cpp)
 
@@ -161,7 +162,7 @@
   * [Boruvkas Minimum Spanning Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/boruvkas_minimum_spanning_tree.cpp)
   * [Dijkstra](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/dijkstra.cpp)
   * [Huffman](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/huffman.cpp)
-  * [Jumpgame](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/jumpgame.cpp)
+  * [Jump Game](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/jump_game.cpp)
   * [Knapsack](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/knapsack.cpp)
   * [Kruskals Minimum Spanning Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/kruskals_minimum_spanning_tree.cpp)
   * [Prims Minimum Spanning Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/greedy_algorithms/prims_minimum_spanning_tree.cpp)

data_structures/stack_using_array.cpp

@@ -1,62 +1,179 @@
-#include <iostream>
+#include <cassert>    /// For std::assert
+#include <iostream>   /// For std::cout
+#include <memory>     /// For std::unique_ptr
+#include <stdexcept>  /// For std::out_of_range
 
-int *stack;
-int stack_idx = 0, stack_size;
+/**
+ * @namespace
+ * @brief data_structures
+ */
+namespace data_structures {
+/**
+ * @brief Class representation of a stack
+ * @tparam T The type of the elements in the stack
+ */
+template <typename T>
+class Stack {
+ private:
+    std::unique_ptr<T[]> stack;  ///< Smart pointer to the stack array
+    int stackSize;               ///< Maximum size of the stack
+    int stackIndex;  ///< Index pointing to the top element of the stack
 
-void push(int x) {
-    if (stack_idx == stack_size) {
-        std::cout << "\nOverflow";
-    } else {
-        stack[stack_idx++] = x;
+ public:
+    /**
+     * @brief Constructs a new Stack object
+     *
+     * @param size Maximum size of the stack
+     */
+    Stack(int size) : stackSize(size), stackIndex(-1), stack(new T[size]) {}
+
+    /**
+     * @brief Checks if the stack is full
+     *
+     * @return true if the stack is full, false otherwise
+     */
+    bool full() const { return stackIndex == stackSize - 1; }
+
+    /**
+     * @brief Checks if the stack is empty
+     * @return true if the stack is empty, false otherwise
+     */
+    bool empty() const { return stackIndex == -1; }
+
+    /**
+     * @brief Pushes an element onto the stack
+     *
+     * @param element Element to push onto the stack
+     */
+    void push(T element) {
+        if (full()) {
+            throw std::out_of_range("Stack overflow");
+        } else {
+            stack[++stackIndex] = element;
+        }
     }
-}
 
-void pop() {
-    if (stack_idx == 0) {
-        std::cout << "\nUnderflow";
-    } else {
-        std::cout << "\n" << stack[--stack_idx] << " deleted";
+    /**
+     * @brief Pops an element from the stack
+     *
+     * @return The popped element
+     * @throws std::out_of_range if the stack is empty
+     */
+    T pop() {
+        if (empty()) {
+            throw std::out_of_range("Stack underflow");
+        }
+        return stack[stackIndex--];
+    }
+
+    /**
+     * @brief Displays all elements in the stack
+     */
+    void show() const {
+        for (int i = 0; i <= stackIndex; i++) {
+            std::cout << stack[i] << "\n";
+        }
     }
-}
 
-void show() {
-    for (int i = 0; i < stack_idx; i++) {
-        std::cout << stack[i] << "\n";
+    /**
+     * @brief Displays the topmost element of the stack
+     *
+     * @return The topmost element of the stack
+     * @throws std::out_of_range if the stack is empty
+     */
+    T topmost() const {
+        if (empty()) {
+            throw std::out_of_range("Stack underflow");
+        }
+        return stack[stackIndex];
     }
-}
 
-void topmost() { std::cout << "\nTopmost element: " << stack[stack_idx - 1]; }
-void bottom() { std::cout << "\nBottom element: " << stack[0]; } // If we need access to first element without using pop command 
-int main() {
-    std::cout << "\nEnter stack_size of stack : ";
-    std::cin >> stack_size;
-    stack = new int[stack_size];
-    int ch, x;
-    do {
-        std::cout << "\n0. Exit";
-        std::cout << "\n1. Push";
-        std::cout << "\n2. Pop";
-        std::cout << "\n3. Print";
-        std::cout << "\n4. Print topmost element:";
-        std::cout << "\n5. Print Bottom element:";
-        std::cout << "\nEnter Your Choice : ";
-        std::cin >> ch;
-        if (ch == 1) {
-            std::cout << "\nInsert : ";
-            std::cin >> x;
-            push(x);
-        } else if (ch == 2) {
-            pop();
-        } else if (ch == 3) {
-            show();
-        } else if (ch == 4) {
-            topmost();
-        } else if(ch == 5) {
-            bottom();
+    /**
+     * @brief Displays the bottom element of the stack
+     *
+     * @return The bottom element of the stack
+     * @throws std::out_of_range if the stack is empty
+     */
+    T bottom() const {
+        if (empty()) {
+            throw std::out_of_range("Stack underflow");
         }
-    } while (ch != 0);
+        return stack[0];
+    }
+};
+}  // namespace data_structures
+
+/**
+ * @brief Self-test implementations
+ * @returns void
+ */
+static void test() {
+    data_structures::Stack<int> stack(5);
+
+    // Test empty and full operations
+    assert(stack.empty());
+    assert(!stack.full());
 
-    delete[] stack;
+    // Test pushing elements and checking topmost
+    stack.push(10);
+    assert(stack.topmost() == 10);
 
+    stack.push(20);
+    assert(stack.topmost() == 20);
+
+    stack.push(30);
+    stack.push(40);
+    stack.push(50);
+    assert(stack.full());
+
+    // Test stack overflow
+    try {
+        stack.push(60);
+    } catch (const std::out_of_range& e) {
+        assert(std::string(e.what()) == "Stack overflow");
+    }
+
+    // Test popping elements
+    assert(stack.pop() == 50);
+    assert(stack.pop() == 40);
+    assert(stack.pop() == 30);
+
+    // Check topmost and bottom elements
+    assert(stack.topmost() == 20);
+    assert(stack.bottom() == 10);
+
+    assert(stack.pop() == 20);
+    assert(stack.pop() == 10);
+
+    assert(stack.empty());
+    assert(!stack.full());
+
+    // Test stack underflow
+    try {
+        stack.pop();
+    } catch (const std::out_of_range& e) {
+        assert(std::string(e.what()) == "Stack underflow");
+    }
+
+    try {
+        stack.topmost();
+    } catch (const std::out_of_range& e) {
+        assert(std::string(e.what()) == "Stack underflow");
+    }
+
+    try {
+        stack.bottom();
+    } catch (const std::out_of_range& e) {
+        assert(std::string(e.what()) == "Stack underflow");
+    }
+}
+
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
+int main() {
+    test();  // run self-test implementations
+    std::cout << "All tests passed!" << std::endl;
     return 0;
 }

dynamic_programming/trapped_rainwater.cpp

@@ -0,0 +1,104 @@
+/**
+ * @file
+ * @brief Implementation of the [Trapped Rainwater
+ * Problem](https://www.geeksforgeeks.org/trapping-rain-water/)
+ * @details
+ * This implementation calculates the amount of rainwater that can be trapped
+ * between walls represented by an array of heights.
+ * @author [SOZEL](https://github.com/TruongNhanNguyen)
+ */
+
+#include <algorithm>  /// For std::min and std::max
+#include <cassert>    /// For assert
+#include <cstddef>    /// For std::size_t
+#include <cstdint>    /// For integral typedefs
+#include <vector>     /// For std::vector
+
+/*
+ * @namespace
+ * @brief Dynamic Programming Algorithms
+ */
+namespace dynamic_programming {
+/**
+ * @brief Function to calculate the trapped rainwater
+ * @param heights Array representing the heights of walls
+ * @return The amount of trapped rainwater
+ */
+uint32_t trappedRainwater(const std::vector<uint32_t>& heights) {
+    std::size_t n = heights.size();
+    if (n <= 2)
+        return 0;  // No water can be trapped with less than 3 walls
+
+    std::vector<uint32_t> leftMax(n), rightMax(n);
+
+    // Calculate the maximum height of wall to the left of each wall
+    leftMax[0] = heights[0];
+    for (std::size_t i = 1; i < n; ++i) {
+        leftMax[i] = std::max(leftMax[i - 1], heights[i]);
+    }
+
+    // Calculate the maximum height of wall to the right of each wall
+    rightMax[n - 1] = heights[n - 1];
+    for (std::size_t i = n - 2; i < n; --i) {
+        rightMax[i] = std::max(rightMax[i + 1], heights[i]);
+    }
+
+    // Calculate the trapped rainwater between walls
+    uint32_t trappedWater = 0;
+    for (std::size_t i = 0; i < n; ++i) {
+        trappedWater +=
+            std::max(0u, std::min(leftMax[i], rightMax[i]) - heights[i]);
+    }
+
+    return trappedWater;
+}
+
+}  // namespace dynamic_programming
+
+/**
+ * @brief Self-test implementations
+ * @returns void
+ */
+static void test() {
+    std::vector<uint32_t> test_basic = {0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1};
+    assert(dynamic_programming::trappedRainwater(test_basic) == 6);
+
+    std::vector<uint32_t> test_peak_under_water = {3, 0, 2, 0, 4};
+    assert(dynamic_programming::trappedRainwater(test_peak_under_water) == 7);
+
+    std::vector<uint32_t> test_bucket = {5, 1, 5};
+    assert(dynamic_programming::trappedRainwater(test_bucket) == 4);
+
+    std::vector<uint32_t> test_skewed_bucket = {4, 1, 5};
+    assert(dynamic_programming::trappedRainwater(test_skewed_bucket) == 3);
+
+    std::vector<uint32_t> test_empty = {};
+    assert(dynamic_programming::trappedRainwater(test_empty) == 0);
+
+    std::vector<uint32_t> test_flat = {0, 0, 0, 0, 0};
+    assert(dynamic_programming::trappedRainwater(test_flat) == 0);
+
+    std::vector<uint32_t> test_no_trapped_water = {1, 1, 2, 4, 0, 0, 0};
+    assert(dynamic_programming::trappedRainwater(test_no_trapped_water) == 0);
+
+    std::vector<uint32_t> test_single_elevation = {5};
+    assert(dynamic_programming::trappedRainwater(test_single_elevation) == 0);
+
+    std::vector<uint32_t> test_two_point_elevation = {5, 1};
+    assert(dynamic_programming::trappedRainwater(test_two_point_elevation) ==
+           0);
+
+    std::vector<uint32_t> test_large_elevation_map_difference = {5, 1, 6, 1,
+                                                                 7, 1, 8};
+    assert(dynamic_programming::trappedRainwater(
+               test_large_elevation_map_difference) == 15);
+}
+
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
+int main() {
+    test();  // run self-test implementations
+    return 0;
+}