Merge branch 'master' into add/number_of_paths

Author: realstealthninja

CMakeLists.txt

@@ -27,30 +27,30 @@ if(USE_OPENMP)
     endif()
 endif()
 
-add_subdirectory(math)
-add_subdirectory(others)
-add_subdirectory(search)
-add_subdirectory(ciphers)
-add_subdirectory(hashing)
-add_subdirectory(strings)
-add_subdirectory(sorting)
-add_subdirectory(geometry)
-add_subdirectory(graphics)
-add_subdirectory(probability)
 add_subdirectory(backtracking)
 add_subdirectory(bit_manipulation)
+add_subdirectory(ciphers)
+add_subdirectory(cpu_scheduling_algorithms)
+add_subdirectory(data_structures)
+add_subdirectory(divide_and_conquer)
 add_subdirectory(dynamic_programming)
+add_subdirectory(games)
+add_subdirectory(geometry)
+add_subdirectory(graph)
+add_subdirectory(graphics)
 add_subdirectory(greedy_algorithms)
-add_subdirectory(range_queries)
-add_subdirectory(operations_on_datastructures)
-add_subdirectory(data_structures)
+add_subdirectory(hashing)
 add_subdirectory(machine_learning)
+add_subdirectory(math)
 add_subdirectory(numerical_methods)
-add_subdirectory(graph)
-add_subdirectory(divide_and_conquer)
-add_subdirectory(games)
-add_subdirectory(cpu_scheduling_algorithms)
+add_subdirectory(operations_on_datastructures)
+add_subdirectory(others)
 add_subdirectory(physics)
+add_subdirectory(probability)
+add_subdirectory(range_queries)
+add_subdirectory(search)
+add_subdirectory(sorting)
+add_subdirectory(strings)
 
 cmake_policy(SET CMP0054 NEW)
 cmake_policy(SET CMP0057 NEW)

ciphers/uint256_t.hpp

@@ -72,7 +72,7 @@ class uint256_t {
      */
     template <typename T, typename = typename std::enable_if<
                               std::is_integral<T>::value, T>::type>
-    explicit uint256_t(T low) : s(low), f(0) {}
+    explicit uint256_t(T low) : f(0), s(low) {}
 
     /**
      * @brief Parameterized constructor

data_structures/queue_using_array2.cpp

@@ -1,25 +1,24 @@
 #include <iostream>
-using namespace std;
 
 int queue[10];
 int front = 0;
 int rear = 0;
 
 void Enque(int x) {
     if (rear == 10) {
-        cout << "\nOverflow";
+        std::cout << "\nOverflow";
     } else {
         queue[rear++] = x;
     }
 }
 
 void Deque() {
     if (front == rear) {
-        cout << "\nUnderflow";
+        std::cout << "\nUnderflow";
     }
 
     else {
-        cout << "\n" << queue[front++] << " deleted";
+        std::cout << "\n" << queue[front++] << " deleted";
         for (int i = front; i < rear; i++) {
             queue[i - front] = queue[i];
         }
@@ -30,21 +29,21 @@ void Deque() {
 
 void show() {
     for (int i = front; i < rear; i++) {
-        cout << queue[i] << "\t";
+        std::cout << queue[i] << "\t";
     }
 }
 
 int main() {
     int ch, x;
     do {
-        cout << "\n1. Enque";
-        cout << "\n2. Deque";
-        cout << "\n3. Print";
-        cout << "\nEnter Your Choice : ";
-        cin >> ch;
+        std::cout << "\n1. Enque";
+        std::cout << "\n2. Deque";
+        std::cout << "\n3. Print";
+        std::cout << "\nEnter Your Choice : ";
+        std::cin >> ch;
         if (ch == 1) {
-            cout << "\nInsert : ";
-            cin >> x;
+            std::cout << "\nInsert : ";
+            std::cin >> x;
             Enque(x);
         } else if (ch == 2) {
             Deque();

data_structures/stack_using_array.cpp

@@ -25,7 +25,7 @@ class Stack {
      *
      * @param size Maximum size of the stack
      */
-    Stack(int size) : stackSize(size), stackIndex(-1), stack(new T[size]) {}
+    Stack(int size) : stack(new T[size]), stackSize(size), stackIndex(-1) {}
 
     /**
      * @brief Checks if the stack is full

data_structures/tree_234.cpp

@@ -39,9 +39,9 @@ class Node {
      * @param item the first value we insert to the node
      */
     explicit Node(int64_t item)
-        : count(1),
-          items({{item, 0, 0}}),
-          children({{nullptr, nullptr, nullptr, nullptr}}) {}
+        : items({{item, 0, 0}}),
+          children({{nullptr, nullptr, nullptr, nullptr}}),
+          count(1) {}
 
     /**
      * @brief Get the item count that current saved in the node

data_structures/trie_tree.cpp

@@ -9,6 +9,7 @@
  */
 #include <array>
 #include <cassert>
+#include <cstdint>
 #include <iostream>
 #include <memory>
 #include <string>

dynamic_programming/trapped_rainwater2.cpp

@@ -0,0 +1,111 @@
+/**
+ * @file
+ * @brief Implementation of the [Trapped Rainwater
+ * Problem](https://www.geeksforgeeks.org/trapping-rain-water/)
+ * @details
+ * This implementation calculates the total trapped rainwater using a
+ * two-pointer approach. It maintains two pointers (`left` and `right`) and
+ * tracks the maximum height seen so far from both ends (`leftMax` and
+ * `rightMax`). At each step, the algorithm decides which side to process based
+ * on which boundary is smaller, ensuring O(n) time and O(1) space complexity.
+ * @author [kanavgoyal898](https://github.com/kanavgoyal898)
+ */
+
+#include <algorithm>  /// For std::min and std::max
+#include <cassert>    /// For assert
+#include <cstddef>    /// For std::size_t
+#include <cstdint>    /// For std::uint32_t
+#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;  // Not enough walls to trap water
+
+    std::size_t left = 0, right = n - 1;
+    uint32_t leftMax = 0, rightMax = 0, trappedWater = 0;
+
+    // Traverse from both ends towards the center
+    while (left < right) {
+        if (heights[left] < heights[right]) {
+            // Water trapped depends on the tallest wall to the left
+            if (heights[left] >= leftMax)
+                leftMax = heights[left];  // Update left max
+            else
+                trappedWater +=
+                    leftMax - heights[left];  // Water trapped at current left
+            ++left;
+        } else {
+            // Water trapped depends on the tallest wall to the right
+            if (heights[right] >= rightMax)
+                rightMax = heights[right];  // Update right max
+            else
+                trappedWater +=
+                    rightMax -
+                    heights[right];  // Water trapped at current right
+            --right;
+        }
+    }
+
+    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;
+}

machine_learning/a_star_search.cpp

@@ -22,12 +22,14 @@
 #include <algorithm>   /// for `std::reverse` function
 #include <array>       /// for `std::array`, representing `EightPuzzle` board
 #include <cassert>     /// for `assert`
+#include <cstdint>     /// for `std::uint32_t`
 #include <functional>  /// for `std::function` STL
 #include <iostream>    /// for IO operations
 #include <map>         /// for `std::map` STL
 #include <memory>      /// for `std::shared_ptr`
 #include <set>         /// for `std::set` STL
 #include <vector>      /// for `std::vector` STL
+
 /**
  * @namespace machine_learning
  * @brief Machine learning algorithms