Implementing Factorial using recursion

math/factorial_recursion.c

@@ -0,0 +1,76 @@
+/*
+    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
+
+uint64_t factResults[MAX_LIMIT] = {0};
+
+uint64_t computeFactorial(int sequenceNumber) {
+    if (sequenceNumber == 0) {
+        return 1;
+    }
+    if (factResults[sequenceNumber] != 0) {
+        return factResults[sequenceNumber];
+    }
+    factResults[sequenceNumber] = sequenceNumber * computeFactorial(sequenceNumber - 1);
+    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;
+    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;
+}

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;
+}