From 13e10f993ff888bfbafe74783d99554d8ae1f0e4 Mon Sep 17 00:00:00 2001
From: sricharan200 <148656478+sricharan200@users.noreply.github.com>
Date: Tue, 14 Nov 2023 22:05:05 -0500
Subject: [PATCH 01/11] Add files via upload

---
 sorting/radix_sort.c | 140 +++++++++++++++++++++----------------------
 1 file changed, 69 insertions(+), 71 deletions(-)

diff --git a/sorting/radix_sort.c b/sorting/radix_sort.c
index 364a3917a1..2626b6fdf4 100644
--- a/sorting/radix_sort.c
+++ b/sorting/radix_sort.c
@@ -1,71 +1,69 @@
-#include <stdio.h>
-
-int largest(int a[], int n)
-{
-    int large = a[0], i;
-    for (i = 1; i < n; i++)
-    {
-        if (large < a[i])
-            large = a[i];
-    }
-    return large;
-}
-
-void RadixSort(int a[], int n)
-{
-    int bucket[10][10], bucket_count[10];
-    int i, j, k, remainder, NOP = 0, divisor = 1, large, pass;
-
-    large = largest(a, n);
-    printf("The large element %d\n", large);
-    while (large > 0)
-    {
-        NOP++;
-        large /= 10;
-    }
-
-    for (pass = 0; pass < NOP; pass++)
-    {
-        for (i = 0; i < 10; i++)
-        {
-            bucket_count[i] = 0;
-        }
-        for (i = 0; i < n; i++)
-        {
-            remainder = (a[i] / divisor) % 10;
-            bucket[remainder][bucket_count[remainder]] = a[i];
-            bucket_count[remainder] += 1;
-        }
-
-        i = 0;
-        for (k = 0; k < 10; k++)
-        {
-            for (j = 0; j < bucket_count[k]; j++)
-            {
-                a[i] = bucket[k][j];
-                i++;
-            }
-        }
-        divisor *= 10;
-
-        for (i = 0; i < n; i++) printf("%d  ", a[i]);
-        printf("\n");
-    }
-}
-
-int main()
-{
-    int i, n, a[10];
-    printf("Enter the number of elements :: ");
-    scanf("%d", &n);
-    printf("Enter the elements :: ");
-    for (i = 0; i < n; i++)
-    {
-        scanf("%d", &a[i]);
-    }
-    RadixSort(a, n);
-    printf("The sorted elements are ::  ");
-    for (i = 0; i < n; i++) printf("%d  ", a[i]);
-    printf("\n");
-    return 0;
-}
+#include <stdio.h>
+
+// To find the largest number in the array
+int findLargestNum(int data[], int length) {
+    int largest = data[0];
+    for (int i = 1; i < length; i++)
+        if (data[i] > largest)
+            largest = data[i];
+    return largest;
+}
+
+// To perform counting sort on the array based on the specified digit
+void performCountSort(int data[], int length, int place) {
+    int output[length]; 
+    int i, freq[10] = {0};
+    for (i = 0; i < length; i++)
+        freq[(data[i] / place) % 10]++;
+    for (i = 1; i < 10; i++)
+        freq[i] += freq[i - 1];
+    for (i = length - 1; i >= 0; i--) {
+        output[freq[(data[i] / place) % 10] - 1] = data[i];
+        freq[(data[i] / place) % 10]--;
+    }
+    for (i = 0; i < length; i++)
+        data[i] = output[i];
+}
+
+// Main function for Radix Sort
+void performRadixSort(int data[], int length) {
+    int largestNum = findLargestNum(data, length);
+    for (int place = 1; largestNum / place > 0; place *= 10)
+        performCountSort(data, length, place);
+}
+void displayArray(int data[], int length) {
+    for (int i = 0; i < length; i++)
+        printf("%d ", data[i]);
+    printf("\n");
+}
+int main() {
+    int array1[] = {121, 432, 564, 23, 1, 45, 788};
+    int length1 = sizeof(array1) / sizeof(array1[0]);
+    int array2[] = {95, 90, 85, 80, 75, 70};
+    int length2 = sizeof(array2) / sizeof(array2[0]);
+    int array3[] = {333, 287, 911, 462, 786};
+    int length3 = sizeof(array3) / sizeof(array3[0]);
+    int array4[] = {5, 3, 8, 1, 2, 9, 4, 7, 6};
+    int length4 = sizeof(array4) / sizeof(array4[0]);
+    int array5[] = {12, 34, 12, 45, 67, 45, 34};
+    int length5 = sizeof(array5) / sizeof(array5[0]);
+
+    // Sorting and displaying each array
+    performRadixSort(array1, length1);
+    printf("Sorted Array 1: ");
+    displayArray(array1, length1);
+    performRadixSort(array2, length2);
+    printf("Sorted Array 2: ");
+    displayArray(array2, length2);
+    performRadixSort(array3, length3);
+    printf("Sorted Array 3: ");
+    displayArray(array3, length3);
+    performRadixSort(array4, length4);
+    printf("Sorted Array 4: ");
+    displayArray(array4, length4);
+    performRadixSort(array5, length5);
+    printf("Sorted Array 5: ");
+    displayArray(array5, length5);
+
+    return 0;
+}
\ No newline at end of file

From bdbb88f7b0170ba209924aa2b1792c49c3ea15b4 Mon Sep 17 00:00:00 2001
From: sricharan200 <148656478+sricharan200@users.noreply.github.com>
Date: Tue, 14 Nov 2023 22:52:45 -0500
Subject: [PATCH 02/11] Add files via upload

---
 math/factorial_recursion.c | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 math/factorial_recursion.c

diff --git a/math/factorial_recursion.c b/math/factorial_recursion.c
new file mode 100644
index 0000000000..92f44c8cce
--- /dev/null
+++ b/math/factorial_recursion.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+
+#define MAX_LIMIT 200 
+
+unsigned long long factResults[MAX_LIMIT] = {0};
+
+unsigned long long computeFactorial(int sequenceNumber) {
+    if (sequenceNumber == 0) {
+        return 1;
+    }
+    if (factResults[sequenceNumber] != 0) {
+        return factResults[sequenceNumber];
+    }
+    factResults[sequenceNumber] = sequenceNumber * computeFactorial(sequenceNumber - 1);
+    return factResults[sequenceNumber];
+}
+
+int main() {
+    int testNumber;
+    printf("Enter a number: ");
+    scanf("%d", &testNumber);
+    if (testNumber < 0 || testNumber >= MAX_LIMIT) {
+        printf("Invalid input! Please enter a non-negative number less than %d.\n", MAX_LIMIT);
+        return 1;
+    }
+    printf("The factorial of %d is %llu\n", testNumber, computeFactorial(testNumber));
+    return 0;
+}

From 78aea46c8c3f4330e5866df5f23838265904b273 Mon Sep 17 00:00:00 2001
From: sricharan200 <148656478+sricharan200@users.noreply.github.com>
Date: Tue, 14 Nov 2023 23:02:48 -0500
Subject: [PATCH 03/11] Delete math/factorial_recursion.c

---
 math/factorial_recursion.c | 28 ----------------------------
 1 file changed, 28 deletions(-)
 delete mode 100644 math/factorial_recursion.c

diff --git a/math/factorial_recursion.c b/math/factorial_recursion.c
deleted file mode 100644
index 92f44c8cce..0000000000
--- a/math/factorial_recursion.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <stdio.h>
-
-#define MAX_LIMIT 200 
-
-unsigned long long factResults[MAX_LIMIT] = {0};
-
-unsigned long long computeFactorial(int sequenceNumber) {
-    if (sequenceNumber == 0) {
-        return 1;
-    }
-    if (factResults[sequenceNumber] != 0) {
-        return factResults[sequenceNumber];
-    }
-    factResults[sequenceNumber] = sequenceNumber * computeFactorial(sequenceNumber - 1);
-    return factResults[sequenceNumber];
-}
-
-int main() {
-    int testNumber;
-    printf("Enter a number: ");
-    scanf("%d", &testNumber);
-    if (testNumber < 0 || testNumber >= MAX_LIMIT) {
-        printf("Invalid input! Please enter a non-negative number less than %d.\n", MAX_LIMIT);
-        return 1;
-    }
-    printf("The factorial of %d is %llu\n", testNumber, computeFactorial(testNumber));
-    return 0;
-}

From 5faf1edcf5b471227f93f5a70ad86b4f14507ee3 Mon Sep 17 00:00:00 2001
From: sricharan200 <148656478+sricharan200@users.noreply.github.com>
Date: Tue, 14 Nov 2023 23:05:16 -0500
Subject: [PATCH 04/11] Add files via upload

---
 math/factorial_recursion.c | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 math/factorial_recursion.c

diff --git a/math/factorial_recursion.c b/math/factorial_recursion.c
new file mode 100644
index 0000000000..825dcfd1f9
--- /dev/null
+++ b/math/factorial_recursion.c
@@ -0,0 +1,33 @@
+#include <stdio.h>
+
+#define MAX_LIMIT 200 
+
+unsigned long long factResults[MAX_LIMIT] = {0};
+
+unsigned long long computeFactorial(int sequenceNumber) {
+    if (sequenceNumber == 0) {
+        return 1;
+    }
+    if (factResults[sequenceNumber] != 0) {
+        return factResults[sequenceNumber];
+    }
+    factResults[sequenceNumber] = sequenceNumber * computeFactorial(sequenceNumber - 1);
+    return factResults[sequenceNumber];
+}
+
+int main() {
+    int testNumber;
+    testNumber=5;
+    printf("The factorial of %d is %llu\n", testNumber, computeFactorial(testNumber));
+    testNumber=4;
+    printf("The factorial of %d is %llu\n", testNumber, computeFactorial(testNumber));
+    testNumber=6;
+    printf("The factorial of %d is %llu\n", testNumber, computeFactorial(testNumber));
+    testNumber=7;
+    printf("The factorial of %d is %llu\n", testNumber, computeFactorial(testNumber));
+    testNumber=9;
+    printf("The factorial of %d is %llu\n", testNumber, computeFactorial(testNumber));
+    testNumber=10;
+    printf("The factorial of %d is %llu\n", testNumber, computeFactorial(testNumber));
+    return 0;
+}

From d9c1639ae71377a60e8ff7aed7e8ec6b52700a61 Mon Sep 17 00:00:00 2001
From: sricharan200 <148656478+sricharan200@users.noreply.github.com>
Date: Wed, 15 Nov 2023 01:21:23 -0500
Subject: [PATCH 05/11] Delete sorting/radix_sort.c

---
 sorting/radix_sort.c | 69 --------------------------------------------
 1 file changed, 69 deletions(-)
 delete mode 100644 sorting/radix_sort.c

diff --git a/sorting/radix_sort.c b/sorting/radix_sort.c
deleted file mode 100644
index 2626b6fdf4..0000000000
--- a/sorting/radix_sort.c
+++ /dev/null
@@ -1,69 +0,0 @@
-#include <stdio.h>
-
-// To find the largest number in the array
-int findLargestNum(int data[], int length) {
-    int largest = data[0];
-    for (int i = 1; i < length; i++)
-        if (data[i] > largest)
-            largest = data[i];
-    return largest;
-}
-
-// To perform counting sort on the array based on the specified digit
-void performCountSort(int data[], int length, int place) {
-    int output[length]; 
-    int i, freq[10] = {0};
-    for (i = 0; i < length; i++)
-        freq[(data[i] / place) % 10]++;
-    for (i = 1; i < 10; i++)
-        freq[i] += freq[i - 1];
-    for (i = length - 1; i >= 0; i--) {
-        output[freq[(data[i] / place) % 10] - 1] = data[i];
-        freq[(data[i] / place) % 10]--;
-    }
-    for (i = 0; i < length; i++)
-        data[i] = output[i];
-}
-
-// Main function for Radix Sort
-void performRadixSort(int data[], int length) {
-    int largestNum = findLargestNum(data, length);
-    for (int place = 1; largestNum / place > 0; place *= 10)
-        performCountSort(data, length, place);
-}
-void displayArray(int data[], int length) {
-    for (int i = 0; i < length; i++)
-        printf("%d ", data[i]);
-    printf("\n");
-}
-int main() {
-    int array1[] = {121, 432, 564, 23, 1, 45, 788};
-    int length1 = sizeof(array1) / sizeof(array1[0]);
-    int array2[] = {95, 90, 85, 80, 75, 70};
-    int length2 = sizeof(array2) / sizeof(array2[0]);
-    int array3[] = {333, 287, 911, 462, 786};
-    int length3 = sizeof(array3) / sizeof(array3[0]);
-    int array4[] = {5, 3, 8, 1, 2, 9, 4, 7, 6};
-    int length4 = sizeof(array4) / sizeof(array4[0]);
-    int array5[] = {12, 34, 12, 45, 67, 45, 34};
-    int length5 = sizeof(array5) / sizeof(array5[0]);
-
-    // Sorting and displaying each array
-    performRadixSort(array1, length1);
-    printf("Sorted Array 1: ");
-    displayArray(array1, length1);
-    performRadixSort(array2, length2);
-    printf("Sorted Array 2: ");
-    displayArray(array2, length2);
-    performRadixSort(array3, length3);
-    printf("Sorted Array 3: ");
-    displayArray(array3, length3);
-    performRadixSort(array4, length4);
-    printf("Sorted Array 4: ");
-    displayArray(array4, length4);
-    performRadixSort(array5, length5);
-    printf("Sorted Array 5: ");
-    displayArray(array5, length5);
-
-    return 0;
-}
\ No newline at end of file

From c3d40825cd911e4391ba7f9c232401c577c897b5 Mon Sep 17 00:00:00 2001
From: sricharan200 <148656478+sricharan200@users.noreply.github.com>
Date: Wed, 15 Nov 2023 01:22:23 -0500
Subject: [PATCH 06/11] Add files via upload

---
 sorting/radix_sort.c | 69 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 sorting/radix_sort.c

diff --git a/sorting/radix_sort.c b/sorting/radix_sort.c
new file mode 100644
index 0000000000..2626b6fdf4
--- /dev/null
+++ b/sorting/radix_sort.c
@@ -0,0 +1,69 @@
+#include <stdio.h>
+
+// To find the largest number in the array
+int findLargestNum(int data[], int length) {
+    int largest = data[0];
+    for (int i = 1; i < length; i++)
+        if (data[i] > largest)
+            largest = data[i];
+    return largest;
+}
+
+// To perform counting sort on the array based on the specified digit
+void performCountSort(int data[], int length, int place) {
+    int output[length]; 
+    int i, freq[10] = {0};
+    for (i = 0; i < length; i++)
+        freq[(data[i] / place) % 10]++;
+    for (i = 1; i < 10; i++)
+        freq[i] += freq[i - 1];
+    for (i = length - 1; i >= 0; i--) {
+        output[freq[(data[i] / place) % 10] - 1] = data[i];
+        freq[(data[i] / place) % 10]--;
+    }
+    for (i = 0; i < length; i++)
+        data[i] = output[i];
+}
+
+// Main function for Radix Sort
+void performRadixSort(int data[], int length) {
+    int largestNum = findLargestNum(data, length);
+    for (int place = 1; largestNum / place > 0; place *= 10)
+        performCountSort(data, length, place);
+}
+void displayArray(int data[], int length) {
+    for (int i = 0; i < length; i++)
+        printf("%d ", data[i]);
+    printf("\n");
+}
+int main() {
+    int array1[] = {121, 432, 564, 23, 1, 45, 788};
+    int length1 = sizeof(array1) / sizeof(array1[0]);
+    int array2[] = {95, 90, 85, 80, 75, 70};
+    int length2 = sizeof(array2) / sizeof(array2[0]);
+    int array3[] = {333, 287, 911, 462, 786};
+    int length3 = sizeof(array3) / sizeof(array3[0]);
+    int array4[] = {5, 3, 8, 1, 2, 9, 4, 7, 6};
+    int length4 = sizeof(array4) / sizeof(array4[0]);
+    int array5[] = {12, 34, 12, 45, 67, 45, 34};
+    int length5 = sizeof(array5) / sizeof(array5[0]);
+
+    // Sorting and displaying each array
+    performRadixSort(array1, length1);
+    printf("Sorted Array 1: ");
+    displayArray(array1, length1);
+    performRadixSort(array2, length2);
+    printf("Sorted Array 2: ");
+    displayArray(array2, length2);
+    performRadixSort(array3, length3);
+    printf("Sorted Array 3: ");
+    displayArray(array3, length3);
+    performRadixSort(array4, length4);
+    printf("Sorted Array 4: ");
+    displayArray(array4, length4);
+    performRadixSort(array5, length5);
+    printf("Sorted Array 5: ");
+    displayArray(array5, length5);
+
+    return 0;
+}
\ No newline at end of file

From e2b34c3c1df76f264384fa1fa5df35237c8511f1 Mon Sep 17 00:00:00 2001
From: sricharan200 <148656478+sricharan200@users.noreply.github.com>
Date: Wed, 15 Nov 2023 18:11:31 -0500
Subject: [PATCH 07/11] Update factorial_recursion.c

---
 math/factorial_recursion.c | 61 ++++++++++++++++++++++++++++++++------
 1 file changed, 52 insertions(+), 9 deletions(-)

diff --git a/math/factorial_recursion.c b/math/factorial_recursion.c
index 825dcfd1f9..5248f52521 100644
--- a/math/factorial_recursion.c
+++ b/math/factorial_recursion.c
@@ -1,10 +1,35 @@
+/*
+    Algorithm: Factorial Calculation using Memoization
+
+    This C program calculates factorials of non-negative integers using a recursive algorithm with memoization.
+    Factorial of a non-negative integer 'n' is denoted as 'n!' and is defined as the product of all positive integers
+    less than or equal to 'n'. For example, 5! = 5 x 4 x 3 x 2 x 1 = 120.
+
+    Author: Sricharan Nibhanupudi
+    
+    Uses:
+    - The program provides a function 'computeFactorial' that calculates the factorial of a given non-negative integer
+      using recursive memoization. It stores previously computed factorials in an array 'factResults' to avoid redundant
+      calculations, which significantly improves performance for large values of 'n'.
+    - The 'testFactorial' function uses assertions to verify the correctness of the 'computeFactorial' function by
+      comparing its results with known factorial values.
+    - The program also demonstrates the use of standardized integer data types like 'uint64_t' from 'stdint.h' for
+      improved code portability and readability.
+
+    References:
+    - The concept of factorial: https://en.wikipedia.org/wiki/Factorial
+    - Memoization: https://www.geeksforgeeks.org/memoization-1d-2d-and-3d/
+*/
+
 #include <stdio.h>
+#include <stdint.h>
+#include <assert.h>
 
-#define MAX_LIMIT 200 
+#define MAX_LIMIT 200
 
-unsigned long long factResults[MAX_LIMIT] = {0};
+uint64_t factResults[MAX_LIMIT] = {0};
 
-unsigned long long computeFactorial(int sequenceNumber) {
+uint64_t computeFactorial(int sequenceNumber) {
     if (sequenceNumber == 0) {
         return 1;
     }
@@ -15,19 +40,37 @@ unsigned long long computeFactorial(int sequenceNumber) {
     return factResults[sequenceNumber];
 }
 
+void testFactorial() {
+    assert(computeFactorial(0) == 1);
+    assert(computeFactorial(1) == 1);
+    assert(computeFactorial(2) == 2);
+    assert(computeFactorial(3) == 6);
+    assert(computeFactorial(4) == 24);
+    assert(computeFactorial(5) == 120);
+    assert(computeFactorial(6) == 720);
+    assert(computeFactorial(7) == 5040);
+    assert(computeFactorial(8) == 40320);
+    assert(computeFactorial(9) == 362880);
+    assert(computeFactorial(10) == 3628800);
+    
+}
+
 int main() {
+    testFactorial();
+    
     int testNumber;
-    testNumber=5;
+    testNumber = 5;
     printf("The factorial of %d is %llu\n", testNumber, computeFactorial(testNumber));
-    testNumber=4;
+    testNumber = 4;
     printf("The factorial of %d is %llu\n", testNumber, computeFactorial(testNumber));
-    testNumber=6;
+    testNumber = 6;
     printf("The factorial of %d is %llu\n", testNumber, computeFactorial(testNumber));
-    testNumber=7;
+    testNumber = 7;
     printf("The factorial of %d is %llu\n", testNumber, computeFactorial(testNumber));
-    testNumber=9;
+    testNumber = 9;
     printf("The factorial of %d is %llu\n", testNumber, computeFactorial(testNumber));
-    testNumber=10;
+    testNumber = 10;
     printf("The factorial of %d is %llu\n", testNumber, computeFactorial(testNumber));
+    
     return 0;
 }

From 909c3eb59fe96ec82d2cca1c146b53b61dcbb11a Mon Sep 17 00:00:00 2001
From: sricharan200 <148656478+sricharan200@users.noreply.github.com>
Date: Thu, 16 Nov 2023 08:12:08 -0500
Subject: [PATCH 08/11] Delete sorting/radix_sort.c

---
 sorting/radix_sort.c | 69 --------------------------------------------
 1 file changed, 69 deletions(-)
 delete mode 100644 sorting/radix_sort.c

diff --git a/sorting/radix_sort.c b/sorting/radix_sort.c
deleted file mode 100644
index 2626b6fdf4..0000000000
--- a/sorting/radix_sort.c
+++ /dev/null
@@ -1,69 +0,0 @@
-#include <stdio.h>
-
-// To find the largest number in the array
-int findLargestNum(int data[], int length) {
-    int largest = data[0];
-    for (int i = 1; i < length; i++)
-        if (data[i] > largest)
-            largest = data[i];
-    return largest;
-}
-
-// To perform counting sort on the array based on the specified digit
-void performCountSort(int data[], int length, int place) {
-    int output[length]; 
-    int i, freq[10] = {0};
-    for (i = 0; i < length; i++)
-        freq[(data[i] / place) % 10]++;
-    for (i = 1; i < 10; i++)
-        freq[i] += freq[i - 1];
-    for (i = length - 1; i >= 0; i--) {
-        output[freq[(data[i] / place) % 10] - 1] = data[i];
-        freq[(data[i] / place) % 10]--;
-    }
-    for (i = 0; i < length; i++)
-        data[i] = output[i];
-}
-
-// Main function for Radix Sort
-void performRadixSort(int data[], int length) {
-    int largestNum = findLargestNum(data, length);
-    for (int place = 1; largestNum / place > 0; place *= 10)
-        performCountSort(data, length, place);
-}
-void displayArray(int data[], int length) {
-    for (int i = 0; i < length; i++)
-        printf("%d ", data[i]);
-    printf("\n");
-}
-int main() {
-    int array1[] = {121, 432, 564, 23, 1, 45, 788};
-    int length1 = sizeof(array1) / sizeof(array1[0]);
-    int array2[] = {95, 90, 85, 80, 75, 70};
-    int length2 = sizeof(array2) / sizeof(array2[0]);
-    int array3[] = {333, 287, 911, 462, 786};
-    int length3 = sizeof(array3) / sizeof(array3[0]);
-    int array4[] = {5, 3, 8, 1, 2, 9, 4, 7, 6};
-    int length4 = sizeof(array4) / sizeof(array4[0]);
-    int array5[] = {12, 34, 12, 45, 67, 45, 34};
-    int length5 = sizeof(array5) / sizeof(array5[0]);
-
-    // Sorting and displaying each array
-    performRadixSort(array1, length1);
-    printf("Sorted Array 1: ");
-    displayArray(array1, length1);
-    performRadixSort(array2, length2);
-    printf("Sorted Array 2: ");
-    displayArray(array2, length2);
-    performRadixSort(array3, length3);
-    printf("Sorted Array 3: ");
-    displayArray(array3, length3);
-    performRadixSort(array4, length4);
-    printf("Sorted Array 4: ");
-    displayArray(array4, length4);
-    performRadixSort(array5, length5);
-    printf("Sorted Array 5: ");
-    displayArray(array5, length5);
-
-    return 0;
-}
\ No newline at end of file

From b26ddb8bf678942535c5f3ef6e717e5b7c7d3a54 Mon Sep 17 00:00:00 2001
From: sricharan200 <148656478+sricharan200@users.noreply.github.com>
Date: Thu, 16 Nov 2023 08:24:52 -0500
Subject: [PATCH 09/11] Update factorial_recursion.c

---
 math/factorial_recursion.c | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/math/factorial_recursion.c b/math/factorial_recursion.c
index 5248f52521..68d2c2ac40 100644
--- a/math/factorial_recursion.c
+++ b/math/factorial_recursion.c
@@ -22,13 +22,19 @@
 */
 
 #include <stdio.h>
-#include <stdint.h>
-#include <assert.h>
+#include <stdint.h> /// Standardized integer data types for improved portability.
+#include <assert.h> /// Assertions for testing purposes.
+#include <header.h> /// Request to use header files
 
 #define MAX_LIMIT 200
 
 uint64_t factResults[MAX_LIMIT] = {0};
 
+/**
+ * @brief Computes the factorial of a non-negative integer using memoization.
+ * @param sequenceNumber The non-negative integer for which to compute the factorial.
+ * @return The factorial of the input integer.
+ */
 uint64_t computeFactorial(int sequenceNumber) {
     if (sequenceNumber == 0) {
         return 1;
@@ -40,6 +46,9 @@ uint64_t computeFactorial(int sequenceNumber) {
     return factResults[sequenceNumber];
 }
 
+/**
+ * @brief Tests the 'computeFactorial' function by comparing its results with known factorial values.
+ */
 void testFactorial() {
     assert(computeFactorial(0) == 1);
     assert(computeFactorial(1) == 1);
@@ -52,9 +61,12 @@ void testFactorial() {
     assert(computeFactorial(8) == 40320);
     assert(computeFactorial(9) == 362880);
     assert(computeFactorial(10) == 3628800);
-    
 }
 
+/**
+ * @brief Main function to test the factorial calculation.
+ * @return 0 on success.
+ */
 int main() {
     testFactorial();
     

From 6c6c480b0b2c57379dd08184339454ebb4d89b52 Mon Sep 17 00:00:00 2001
From: sricharan200 <148656478+sricharan200@users.noreply.github.com>
Date: Thu, 16 Nov 2023 08:28:20 -0500
Subject: [PATCH 10/11] Update factorial_recursion.c

---
 math/factorial_recursion.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/math/factorial_recursion.c b/math/factorial_recursion.c
index 68d2c2ac40..979d128da6 100644
--- a/math/factorial_recursion.c
+++ b/math/factorial_recursion.c
@@ -24,7 +24,6 @@
 #include <stdio.h>
 #include <stdint.h> /// Standardized integer data types for improved portability.
 #include <assert.h> /// Assertions for testing purposes.
-#include <header.h> /// Request to use header files
 
 #define MAX_LIMIT 200
 

From 205c10ef4660839573163c8444c57913a79fb5f5 Mon Sep 17 00:00:00 2001
From: sricharan200 <148656478+sricharan200@users.noreply.github.com>
Date: Thu, 16 Nov 2023 08:30:34 -0500
Subject: [PATCH 11/11] Update factorial_recursion.c

---
 math/factorial_recursion.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/math/factorial_recursion.c b/math/factorial_recursion.c
index 979d128da6..2098ab414c 100644
--- a/math/factorial_recursion.c
+++ b/math/factorial_recursion.c
@@ -21,7 +21,7 @@
     - Memoization: https://www.geeksforgeeks.org/memoization-1d-2d-and-3d/
 */
 
-#include <stdio.h>
+#include <stdio.h> /// Perform Input and Output operations
 #include <stdint.h> /// Standardized integer data types for improved portability.
 #include <assert.h> /// Assertions for testing purposes.