Merge branch 'master' into ctest

Author: realstealthninja

.github/workflows/awesome_workflow.yml

@@ -1,6 +1,7 @@
 name: Awesome CI Workflow
 on: [push, pull_request]
 permissions:
+  pull-requests: write
   contents: write
 
 jobs:
@@ -13,10 +14,10 @@ jobs:
           fetch-depth: 0
       - uses: actions/setup-python@v4
       - name: requirements
-        run: | 
+        run: |
           sudo apt-get -qq update
           sudo apt-get -qq install clang-tidy clang-format
-        # checks are passing with less errors when used with this version. 
+        # checks are passing with less errors when used with this version.
         # The default installs v6.0 which did not work out well in my tests
       - name: Setup Git Specs
         run: |
@@ -33,8 +34,8 @@ jobs:
           git diff --diff-filter=dr --name-only origin/master > git_diff.txt
           echo "Files changed-- `cat git_diff.txt`"
       - name: Configure for static lint checks
-        # compiling first gives clang-tidy access to all the header files and settings used to compile the programs. 
-        # This will check for macros, if any, on linux and not for Windows. But the use of portability checks should 
+        # compiling first gives clang-tidy access to all the header files and settings used to compile the programs.
+        # This will check for macros, if any, on linux and not for Windows. But the use of portability checks should
         # be able to catch any errors for other platforms.
         run: cmake -B build -S . -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
       - name: Lint modified files

README.md

@@ -1,4 +1,5 @@
 # The Algorithms - C++ # {#mainpage}
+
 <!-- the suffix in the above line is required for doxygen to consider this as the index page of the generated documentation site -->
 
 [![Gitpod Ready-to-Code](https://img.shields.io/badge/Gitpod-Ready--to--Code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/TheAlgorithms/C-Plus-Plus)
@@ -18,13 +19,13 @@ This repository is a collection of open-source implementation of a variety of al
 
 ## Features
 
-* The repository provides implementations of various algorithms in one of the most fundamental general purpose languages - [C++](https://en.wikipedia.org/wiki/C%2B%2B).
-* Well documented source code with detailed explanations provide a valuable resource for educators and students alike.
-* Each source code is atomic using [STL classes](https://en.wikipedia.org/wiki/Standard_Template_Library) and _no external libraries_ are required for their compilation and execution. Thus, the fundamentals of the algorithms can be studied in much depth.
-* Source codes are [compiled and tested](https://github.com/TheAlgorithms/C-Plus-Plus/actions?query=workflow%3A%22Awesome+CI+Workflow%22) for every commit on the latest versions of three major operating systems viz., Windows, MacOS, and Ubuntu (Linux) using MSVC 19 2022, AppleClang 14.0.0, and GNU 11.3.0 respectively. 
-* Strict adherence to [C++17](https://en.wikipedia.org/wiki/C%2B%2B17) standard ensures portability of code to embedded systems as well like [ESP32](https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/cplusplus.html#c-language-standard), [ARM Cortex](https://developer.arm.com/documentation/101458/2404/Standards-support/Supported-C-C---standards-in-Arm-C-C---Compiler), etc. with little to no changes.
-* Self-checks within programs ensure correct implementations with confidence.
-* Modular implementations and OpenSource licensing enable the functions to be utilized conveniently in other applications.
+- The repository provides implementations of various algorithms in one of the most fundamental general purpose languages - [C++](https://en.wikipedia.org/wiki/C%2B%2B).
+- Well documented source code with detailed explanations provide a valuable resource for educators and students alike.
+- Each source code is atomic using [STL classes](https://en.wikipedia.org/wiki/Standard_Template_Library) and _no external libraries_ are required for their compilation and execution. Thus, the fundamentals of the algorithms can be studied in much depth.
+- Source codes are [compiled and tested](https://github.com/TheAlgorithms/C-Plus-Plus/actions?query=workflow%3A%22Awesome+CI+Workflow%22) for every commit on the latest versions of three major operating systems viz., Windows, MacOS, and Ubuntu (Linux) using MSVC 19 2022, AppleClang 15.0.15, and GNU 13.3.0 respectively.
+- Strict adherence to [C++17](https://en.wikipedia.org/wiki/C%2B%2B17) standard ensures portability of code to embedded systems as well like [ESP32](https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/cplusplus.html#c-language-standard), [ARM Cortex](https://developer.arm.com/documentation/101458/2404/Standards-support/Supported-C-C---standards-in-Arm-C-C---Compiler), etc. with little to no changes.
+- Self-checks within programs ensure correct implementations with confidence.
+- Modular implementations and OpenSource licensing enable the functions to be utilized conveniently in other applications.
 
 ## Documentation
 

bit_manipulation/check_even_odd.cpp

@@ -0,0 +1,93 @@
+/**
+ * @file
+ * @brief Implementation to [Check if a number is Even or Odd using Bitwise Operator]
+ * (https://www.log2base2.com/c-examples/bitwise/odd-or-even-program-in-c-using-bitwise-operator.html)
+ *
+ * @details
+ * Given an integer N, determine whether it is even or odd using bitwise manipulation.
+ * The least significant bit (LSB) of a binary number determines its parity:
+ * - If the LSB is 0, the number is even.
+ * - If the LSB is 1, the number is odd.
+ *
+ * This can be checked efficiently using the bitwise AND operator (&) with 1.
+ * - If (N & 1) == 0, N is even.
+ * - If (N & 1) == 1, N is odd.
+ *
+ * Example:
+ * Consider 8-bit binary representations of two numbers:
+ *     Number: 10 (decimal) -> 00001010 (binary)
+ *       LSB = 0 -> Even number
+ * 
+ *     Number: 13 (decimal) -> 00001101 (binary)
+ *       LSB = 1 -> Odd number
+ *
+ * In both cases, evaluating (N & 1) isolates the LSB:
+ * - For 10: 00001010 & 00000001 = 0  (Even)
+ * - For 13: 00001101 & 00000001 = 1  (Odd)
+ *
+ * Worst Case Time Complexity: O(1)
+ * Space Complexity: O(1)
+ *
+ * @author [Vedant Mukhedkar](https://github.com/git5v)
+ */
+
+#include <cassert>   /// for assert
+#include <cstdint>   /// for uint32_t
+#include <iostream>  /// for IO operations
+#include <string>    /// for std::string
+
+/**
+ * @namespace bit_manipulation
+ * @brief Bit manipulation algorithms
+ */
+namespace bit_manipulation {
+/**
+ * @namespace even_odd
+ * @brief Functions for checking if a number is even or odd using bitwise operations
+ */
+namespace even_odd {
+
+/**
+ * @brief Checks if a number is even or odd using bitwise AND.
+ * @param N The number to check.
+ * @returns "Even" if N is even, "Odd" if N is odd.
+     */
+        bool is_even(std::int64_t N) {
+            return (N & 1) == 0 ? true : false;
+        }
+
+    }  // namespace even_odd
+}  // namespace bit_manipulation
+
+/**
+ * @brief Self-test implementations
+ * @returns void
+ */
+static void test() {
+    using bit_manipulation::even_odd::is_even;
+
+    // Test Even numbers
+    assert(is_even(0) == true);
+    assert(is_even(2) == true);
+    assert(is_even(100) == true);
+    assert(is_even(-4) == true);
+    assert(is_even(-1000) == true);
+
+    // Test Odd numbers
+    assert(is_even(1) == false);
+    assert(is_even(3) == false);
+    assert(is_even(101) == false);
+    assert(is_even(-5) == false);
+    assert(is_even(-999) == false);
+
+    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;
+}

bit_manipulation/count_of_set_bits.cpp

@@ -36,11 +36,19 @@ namespace count_of_set_bits {
  * @returns total number of set-bits in the binary representation of number `n`
  */
 std::uint64_t countSetBits(
-    std ::int64_t n) {  // int64_t is preferred over int so that
+    std ::uint64_t n) {  // uint64_t is preferred over int so that
                         // no Overflow can be there.
+                        //It's preferred over int64_t because it Guarantees that inputs are always non-negative, 
+                        //which matches the algorithmic problem statement.
+                        //set bit counting is conceptually defined only for non-negative numbers.
+                        //Provides a type Safety: Using an unsigned type helps prevent accidental negative values,
+
+    std::uint64_t count = 0;  // "count" variable is used to count number of set-bits('1')
+                            // in binary representation of number 'n'
+                            //Count is uint64_t because it Prevents theoretical overflow if someone passes very large integers.
+                            //  Behavior stays the same for all normal inputs.
+                            // Safer for edge cases.
 
-    int count = 0;  // "count" variable is used to count number of set-bits('1')
-                    // in binary representation of number 'n'
     while (n != 0) {
         ++count;
         n = (n & (n - 1));

ciphers/uint128_t.hpp

@@ -350,7 +350,7 @@ class uint128_t {
      * @brief operator -- (post-decrement)
      * @returns decremented value of this
      */
-    inline uint128_t operator--(int p) {
+    inline uint128_t operator--(int) {
         --*this;
         return *this;
     }

ciphers/uint256_t.hpp

@@ -319,7 +319,7 @@ class uint256_t {
      * @brief operator -- (post-decrement)
      * @returns decremented value of this
      */
-    inline uint256_t operator--(int p) {
+    inline uint256_t operator--(int) {
         --*this;
         return *this;
     }

data_structures/cll/cll.h

@@ -1,5 +1,5 @@
 /*
- * Simple data structure CLL (Cicular Linear Linked List)
+ * Simple data structure CLL (Circular Linear Linked List)
  * */
 #include <cctype>
 #include <cstdlib>

graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp

@@ -27,8 +27,7 @@ class Graph {
         visited.reset();
         std::queue<int> q;
         q.push(source);
-        bool is_path_found = false;
-        while (q.empty() == false && is_path_found == false) {
+        while (q.empty() == false) {
             int current_node = q.front();
             visited.set(current_node);
             q.pop();

graph/number_of_paths.cpp

@@ -0,0 +1,151 @@
+/**
+ * @file
+ * @brief Algorithm to count paths between two nodes in a directed graph using DFS
+ * @details
+ * This algorithm implements Depth First Search (DFS) to count the number of 
+ * possible paths between two nodes in a directed graph. It is represented using 
+ * an adjacency matrix. The algorithm recursively traverses the graph to find 
+ * all paths from the source node `u` to the destination node `v`.
+ * 
+ * @author [Aditya Borate](https://github.com/adi776borate)
+ * @see https://en.wikipedia.org/wiki/Path_(graph_theory)
+ */
+
+#include <vector>   /// for std::vector
+#include <iostream> /// for IO operations
+#include <cassert>  /// for assert
+#include <cstdint>  /// for fixed-size integer types (e.g., std::uint32_t)
+
+/**
+ * @namespace graph
+ * @brief Graph algorithms
+ */
+namespace graph {
+
+    /**
+     * @brief Helper function to perform DFS and count the number of paths from node `u` to node `v`
+     * @param A adjacency matrix representing the graph (1: edge exists, 0: no edge)
+     * @param u the starting node
+     * @param v the destination node
+     * @param n the number of nodes in the graph
+     * @param visited a vector to keep track of visited nodes in the current DFS path
+     * @returns the number of paths from node `u` to node `v`
+     */
+    std::uint32_t count_paths_dfs(const std::vector<std::vector<std::uint32_t>>& A, 
+                              std::uint32_t u, 
+                              std::uint32_t v, 
+                              std::uint32_t n, 
+                              std::vector<bool>& visited) {
+        if (u == v) {
+            return 1;  // Base case: Reached the destination node
+        }
+
+        visited[u] = true;  // Mark the current node as visited
+        std::uint32_t path_count = 0;  // Count of all paths from `u` to `v`
+
+        for (std::uint32_t i = 0; i < n; i++) {
+            if (A[u][i] == 1 && !visited[i]) {  // Check if there is an edge and the node is not visited
+                path_count += count_paths_dfs(A, i, v, n, visited);  // Recursively explore paths from `i` to `v`
+            }
+        }
+
+        visited[u] = false;  // Unmark the current node as visited (backtracking)
+        return path_count;
+    }
+
+
+    /**
+     * @brief Counts the number of paths from node `u` to node `v` in a directed graph
+     * using Depth First Search (DFS)
+     * 
+     * @param A adjacency matrix representing the graph (1: edge exists, 0: no edge)
+     * @param u the starting node
+     * @param v the destination node
+     * @param n the number of nodes in the graph
+     * @returns the number of paths from node `u` to node `v`
+     */
+    std::uint32_t count_paths(const std::vector<std::vector<std::uint32_t>>& A, 
+                          std::uint32_t u, 
+                          std::uint32_t v, 
+                          std::uint32_t n) {
+        // Check for invalid nodes or empty graph
+        if (u >= n || v >= n || A.empty() || A[0].empty()) {
+            return 0;  // No valid paths if graph is empty or nodes are out of bounds
+        }
+
+        std::vector<bool> visited(n, false);  // Initialize a visited vector for tracking nodes
+        return count_paths_dfs(A, u, v, n, visited);  // Start DFS
+    }
+
+} // namespace graph
+
+/**
+ * @brief Self-test implementations
+ * @returns void
+ */
+static void test() {
+    // Test case 1: Simple directed graph with multiple paths
+    std::vector<std::vector<std::uint32_t>> graph1 = {
+        {0, 1, 0, 1, 0}, 
+        {0, 0, 1, 0, 1}, 
+        {0, 0, 0, 0, 1}, 
+        {0, 0, 1, 0, 0}, 
+        {0, 0, 0, 0, 0}  
+    };
+    std::uint32_t n1 = 5, u1 = 0, v1 = 4;
+    assert(graph::count_paths(graph1, u1, v1, n1) == 3);  // There are 3 paths from node 0 to 4
+
+    // Test case 2: No possible path (disconnected graph)
+    std::vector<std::vector<std::uint32_t>> graph2 = {
+        {0, 1, 0, 0, 0}, 
+        {0, 0, 0, 0, 0}, 
+        {0, 0, 0, 0, 1}, 
+        {0, 0, 1, 0, 0}, 
+        {0, 0, 0, 0, 0}  
+    };
+    std::uint32_t n2 = 5, u2 = 0, v2 = 4;
+    assert(graph::count_paths(graph2, u2, v2, n2) == 0);  // No path from node 0 to 4
+
+    // Test case 3: Cyclic graph with multiple paths
+    std::vector<std::vector<std::uint32_t>> graph3 = {
+        {0, 1, 0, 0, 0}, 
+        {0, 0, 1, 1, 0}, 
+        {1, 0, 0, 0, 1}, 
+        {0, 0, 1, 0, 1}, 
+        {0, 0, 0, 0, 0}  
+    };
+    std::uint32_t n3 = 5, u3 = 0, v3 = 4;
+    assert(graph::count_paths(graph3, u3, v3, n3) == 3);  // There are 3 paths from node 0 to 4
+
+    // Test case 4: Single node graph (self-loop)
+    std::vector<std::vector<std::uint32_t>> graph4 = {
+        {0}
+    };
+    std::uint32_t n4 = 1, u4 = 0, v4 = 0;
+    assert(graph::count_paths(graph4, u4, v4, n4) == 1);  // There is self-loop, so 1 path from node 0 to 0
+
+    // Test case 5: Empty graph (no nodes, no paths)
+    std::vector<std::vector<std::uint32_t>> graph5 = {{}};
+    int n5 = 0, u5 = 0, v5 = 0;
+    assert(graph::count_paths(graph5, u5, v5, n5) == 0);  // There are no paths in an empty graph
+
+    // Test case 6: Invalid nodes (out of bounds)
+    std::vector<std::vector<std::uint32_t>> graph6 = {
+        {0, 1, 0}, 
+        {0, 0, 1}, 
+        {0, 0, 0}
+    };
+    int n6 = 3, u6 = 0, v6 = 5;  // Node `v` is out of bounds (n = 3, so valid indices are 0, 1, 2)
+    assert(graph::count_paths(graph6, u6, v6, n6) == 0);  // Should return 0 because `v = 5` is invalid
+
+    std::cout << "All tests have successfully passed!\n";
+}
+
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
+int main() {
+    test(); // Run self-test implementations
+    return 0;
+}