Merge branch 'master' into master

Author: realstealthninja

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();

math/factorial_memoization.cpp

@@ -1,73 +1,65 @@
 /**
  * @file
- * @brief [Factorial](https://en.wikipedia.org/wiki/Factorial) calculation using recursion and [memoization](https://en.wikipedia.org/wiki/Memoization) 
+ * @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
- * 
+ * 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.
+ *
+ * The program uses a recursive function 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
+#include <vector>   // For std::vector
 
-/// Array to store computed factorials for memoization
-std::array<uint64_t, 1000> memo{0};
+class MemorisedFactorial {
+    std::vector<std::uint64_t> known_values = {1};
 
-/**
- * @namespace math
- * @brief Math algorithms
- */
-namespace math {
+ public:
+    /**
+     * @note This function was intentionally written as recursive
+     * and it does not handle overflows.
+     * @returns factorial of n
+     */
+    std::uint64_t operator()(std::uint64_t n) {
+        if (n >= this->known_values.size()) {
+            this->known_values.push_back(n * this->operator()(n - 1));
+        }
+        return this->known_values.at(n);
+    }
+};
 
-/**
- * @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];
+void test_MemorisedFactorial_in_order() {
+    auto factorial = MemorisedFactorial();
+    assert(factorial(0) == 1);
+    assert(factorial(1) == 1);
+    assert(factorial(5) == 120);
+    assert(factorial(10) == 3628800);
 }
 
-} // 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";
+void test_MemorisedFactorial_no_order() {
+    auto factorial = MemorisedFactorial();
+    assert(factorial(10) == 3628800);
 }
 
 /**
- * @brief Main function to run test cases and interact with the user.
+ * @brief Main function to run tests
  * @returns 0 on program success
  */
 int main() {
-    // Run test cases
-    test_fact_recursion();
+    test_MemorisedFactorial_in_order();
+    test_MemorisedFactorial_no_order();
     return 0;
 }

others/postfix_evaluation.cpp

@@ -1,6 +1,7 @@
 /**
  * @file
- * @brief Evaluation of [Postfix Expression](https://en.wikipedia.org/wiki/Reverse_Polish_notation)
+ * @brief Evaluation of [Postfix
+ * Expression](https://en.wikipedia.org/wiki/Reverse_Polish_notation)
  * @author [Darshana Sarma](https://github.com/Darshana-Sarma)
  * @details
  * Create a stack to store operands (or values).
@@ -11,9 +12,10 @@
  * When the expression is ended, the number in the stack is the final answer
  */
 #include <algorithm>  // for all_of
-#include <array>      // for std::array
+#include <array>      // for array
 #include <cassert>    // for assert
 #include <iostream>   // for io operations
+#include <stack>      // for std::stack
 #include <string>     // for stof
 
 /**
@@ -26,36 +28,6 @@ namespace others {
  * @brief Functions for Postfix Expression algorithm
  */
 namespace postfix_expression {
- /**
- * @brief Creates an array to be used as stack for storing values
- */
-class Stack {
- public:
-    std::array<float, 20> stack{}; ///< Array which will be used to store numbers in the input
-    int stackTop = -1;            ///< Represents the index of the last value added to array. -1 means array is empty
-};
-
-/**
- * @brief Pushing operand, also called the number in the array to the stack
- * @param operand float value from the input array or evaluation
- * @param stack stack containing numbers
- * @returns none
- */
-void push(float operand, Stack *stack) {
-    stack->stackTop++;
-    stack->stack[stack->stackTop] = operand;
-}
-
-/**
- * @brief Popping operand, also called the number from the stack
- * @param stack stack containing numbers
- * @returns operand float on top of stack
- */
-float pop(Stack *stack) {
-    float operand = stack->stack[stack->stackTop];
-    stack->stackTop--;
-    return operand;
-}
 
 /**
  * @brief Checks if scanned string is a number
@@ -74,28 +46,29 @@ bool is_number(const std::string &s) {
  * @param stack containing numbers
  * @returns none
  */
-void evaluate(float a, float b, const std::string &operation, Stack *stack) {
+void evaluate(float a, float b, const std::string &operation,
+              std::stack<float> &stack) {
     float c = 0;
     const char *op = operation.c_str();
     switch (*op) {
         case '+':
-            c = a + b; // Addition of numbers
-            others::postfix_expression::push(c, stack);
+            c = a + b;  // Addition of numbers
+            stack.push(c);
             break;
 
         case '-':
-            c = a - b; // Subtraction of numbers
-            others::postfix_expression::push(c, stack);
+            c = a - b;  // Subtraction of numbers
+            stack.push(c);
             break;
 
         case '*':
-            c = a * b; // Multiplication of numbers
-            others::postfix_expression::push(c, stack);
+            c = a * b;  // Multiplication of numbers
+            stack.push(c);
             break;
 
         case '/':
-            c = a / b; // Division of numbers
-            others::postfix_expression::push(c, stack);
+            c = a / b;  // Division of numbers
+            stack.push(c);
             break;
 
         default:
@@ -113,31 +86,32 @@ void evaluate(float a, float b, const std::string &operation, Stack *stack) {
  */
 template <std::size_t N>
 float postfix_evaluation(std::array<std::string, N> input) {
-    Stack stack;
+    std::stack<float> stack;
     int j = 0;
 
     while (j < N) {
         std::string scan = input[j];
         if (is_number(scan)) {
-            push(std::stof(scan), &stack);
+            stack.push(std::stof(scan));
 
         } else {
-            float op2 = pop(&stack);
-            float op1 = pop(&stack);
+            const float op2 = stack.top();
+            stack.pop();
+            const float op1 = stack.top();
+            stack.pop();
 
-            evaluate(op1, op2, scan, &stack);
+            evaluate(op1, op2, scan, stack);
         }
         j++;
     }
 
-    std::cout << stack.stack[stack.stackTop] << "\n";
+    std::cout << stack.top() << "\n";
 
-    return stack.stack[stack.stackTop];
+    return stack.top();
 }
 }  // namespace postfix_expression
 }  // namespace others
 
-
 /**
  * @brief Test function 1 with input array
  * {'2', '3', '1', '*', '+', '9', '-'}
@@ -153,7 +127,7 @@ static void test_function_1() {
 
 /**
  * @brief Test function 2 with input array
- * {'1', '2', '+', '2', '/', '5', '*', '7', '+'}
+ * {'100', '200', '+', '2', '/', '5', '*', '7', '+'}
  * @returns none
  */
 static void test_function_2() {
@@ -164,13 +138,25 @@ static void test_function_2() {
     assert(answer == 757);
 }
 
+static void test_function_3() {
+    std::array<std::string, 43> input = {
+        "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1",
+        "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1",
+        "+", "+", "+", "+", "+", "+", "+", "+", "+", "+", "+",
+        "+", "+", "+", "+", "+", "+", "+", "+", "+", "+"};
+    float answer = others::postfix_expression::postfix_evaluation(input);
+
+    assert(answer == 22);
+}
+
 /**
  * @brief Main function
  * @returns 0 on exit
  */
 int main() {
     test_function_1();
     test_function_2();
+    test_function_3();
 
     std::cout << "\nTest implementations passed!\n";