Merge branch 'TheAlgorithms:master' into compilers

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

math/factorial_memoization.cpp

@@ -0,0 +1,73 @@
+/**
+ * @file
+ * @brief [Factorial](https://en.wikipedia.org/wiki/Factorial) calculation using recursion and [memoization](https://en.wikipedia.org/wiki/Memoization) 
+ * @details
+ * This program computes the factorial of a non-negative integer using recursion
+ * with memoization (top-down dynamic programming). It stores intermediate results
+ * to avoid redundant calculations for improved efficiency.
+ * 
+ * Memoization is a form of caching where the result to an expensive function call
+ * is stored and returned.
+ * Example:
+ * Input: n = 5
+ * Output: 120
+ * 
+ * Explanation: 5! = 5 × 4 × 3 × 2 × 1 = 120
+ * 
+ * The program uses a recursive function fact_recursion which caches computed 
+ * results in a memo array to avoid recalculating factorials for the same numbers.
+ *
+ * Time Complexity: O(n)
+ * Space Complexity: O(n)
+ * @author [Vedant Mukhedkar](https://github.com/git5v)
+ */
+
+#include <iostream> // for std::cout
+#include <cassert>  // For test cases
+#include <array>    // For std::array
+#include <cstdint>  // For uint64_t
+
+/// Array to store computed factorials for memoization
+std::array<uint64_t, 1000> memo{0};
+
+/**
+ * @namespace math
+ * @brief Math algorithms
+ */
+namespace math {
+
+/**
+ * @brief Computes the factorial of a non-negative integer using recursion and memoization.
+ * @param n The integer whose factorial is to be computed
+ * @returns The factorial of n
+ */
+uint64_t fact_recursion(uint64_t n) {
+    if (n == 0) return 1;        // Base case: 0! = 1
+    if (memo[n] != 0) return memo[n]; // Return already computed value
+    memo[n] = n * fact_recursion(n - 1);    // Store and return the computed value
+    return memo[n];
+}
+
+} // namespace math
+/**
+ * @brief Self-test implementations for the fact_recursion function.
+ * @returns void
+ */
+void test_fact_recursion() {
+    // Test cases for factorial computation
+    assert(math::fact_recursion(0) == 1);
+    assert(math::fact_recursion(1) == 1);
+    assert(math::fact_recursion(5) == 120);
+    assert(math::fact_recursion(10) == 3628800);
+    std::cout << "All test cases passed!\n";
+}
+
+/**
+ * @brief Main function to run test cases and interact with the user.
+ * @returns 0 on program success
+ */
+int main() {
+    // Run test cases
+    test_fact_recursion();
+    return 0;
+}