Add recursive programs

Author: ankitpokhrel

Recursion/char_replace.c

@@ -0,0 +1,53 @@
+#include <string.h>
+#include <assert.h>
+
+/**
+ * Replace char ch with given character in a string.
+ *
+ * @param char* str
+ * @param char ch Character to replace
+ * @param char with Replacing character
+ * @param int index Current index
+ *
+ * return void
+ */
+void char_replace(char *str, char ch, char with, int index)
+{
+    if (str[index] == '\0') {
+        return;
+    }
+
+    if (str[index] == ch) {
+        str[index] = with;
+    }
+
+    char_replace(str, ch, with, index + 1);
+}
+
+int main()
+{
+    char test_str[7][120] = {
+        "ankit", "ankit pokhrel", "namaste", "This is a crazy world!", "C programming language",
+        "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
+        "Pellentesque varius, lorem id consequat elementum, elit dolor suscipit neque, vel rhoncus turpis est vitae lacus."
+    };
+
+    char test_replace[7][2] = {
+        {'n', 'e'}, {'k', 'x'}, {'a', 'p'}, {'i', 'q'},
+        {'m', 'z'}, {'m', 'y'}, {'e', 'x'}
+    };
+
+    char expected_output[7][120] = {
+        "aekit", "anxit poxhrel", "npmpste", "Thqs qs a crazy world!", "C prograzzing language",
+        "Lorey ipsuy dolor sit ayet, consectetur adipiscing elit.",
+        "Pxllxntxsqux varius, lorxm id consxquat xlxmxntum, xlit dolor suscipit nxqux, vxl rhoncus turpis xst vitax lacus."
+    };
+
+    for (int i = 0; i < 7; i++) {
+        char_replace(test_str[i], test_replace[i][0], test_replace[i][1], 0);
+
+        assert(strcmp(expected_output[i], test_str[i]) == 0);
+    }
+
+    return 0;
+}

Recursion/factorial.c

@@ -0,0 +1,22 @@
+#include <assert.h>
+
+long long factorial(int n)
+{
+    if (n < 2) {
+        return n;
+    }
+
+    return n * factorial(n - 1);
+}
+
+int main()
+{
+    assert(2 == factorial(2));
+    assert(6 == factorial(3));
+    assert(120 == factorial(5));
+    assert(3628800 == factorial(10));
+    assert(1307674368000 == factorial(15));
+    assert(2432902008176640000 == factorial(20));
+
+    return 0;
+}

Recursion/nth_fibonacci_number.c

@@ -0,0 +1,31 @@
+#include <assert.h>
+
+long int nth_fibonacci_number(unsigned int n)
+{
+    if (n == 0) {
+        return 0;
+    }
+
+    if (n <= 2) {
+        return 1;
+    }
+
+    return nth_fibonacci_number(n - 1) + nth_fibonacci_number(n - 2);
+}
+
+int main()
+{
+    int fibonacci_numbers[13] = {
+        0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 233, 75025, 102334155
+    };
+
+    unsigned int fibonacci_number_positions[13] = {
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 25, 40
+    };
+
+    for (int i = 0; i < 13; i++) {
+        assert(fibonacci_numbers[i] == nth_fibonacci_number(fibonacci_number_positions[i]));
+    }
+
+    return 0;
+}

Recursion/palindrome.c

@@ -0,0 +1,32 @@
+#include <stdbool.h>
+#include <assert.h>
+
+bool is_palindrome(char *str, int index, int size)
+{
+    if (index > size / 2) {
+        return true;
+    }
+
+    if (str[index] != str[size - index]) {
+        return false;
+    }
+
+    return is_palindrome(str, index + 1, size);
+}
+
+int main()
+{
+    assert(!is_palindrome("ankit", 0, 4));
+    assert(!is_palindrome("lirxil", 0, 5));
+    assert(!is_palindrome("kaayak", 0, 5));
+    assert(!is_palindrome("ka ya k", 0, 6));
+    assert(!is_palindrome("namasman", 0, 7));
+
+    assert(is_palindrome("liril", 0, 4));
+    assert(is_palindrome("kayak", 0, 4));
+    assert(is_palindrome("racecar", 0, 6));
+    assert(is_palindrome("rotator", 0, 6));
+    assert(is_palindrome("rottaattor", 0, 9));
+
+    return 0;
+}

Recursion/str_reverse.c

@@ -0,0 +1,100 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+char *substr(char *, size_t);
+
+/**
+ * Solution 1: By swapping elements.
+ * Will override given string.
+ *
+ * @param char* str
+ * @param int index
+ * @param int size
+ *
+ * @return void
+ */
+void str_reverse_1(char *str, int index, int size)
+{
+    if (index == size / 2) {
+        return;
+    }
+
+    char temp = str[index];
+    str[index] = str[size - index];
+    str[size - index] = temp;
+
+    str_reverse_1(str, index + 1, size);
+}
+
+/**
+ * Solution 2: By using temporary var.
+ *
+ * @param char* str
+ *
+ * @return char* reversed string
+ */
+char *str_reverse(char *str)
+{
+    size_t len = strlen(str);
+
+    static char *reverse = "";
+    static int i = 0;
+
+    if (i == 0) {
+        reverse = (char *) malloc(len * sizeof(char));
+    }
+
+    if (len < 1) {
+        reverse[i] = '\0';
+        i = 0;
+
+        return reverse;
+    }
+
+    reverse[i++] = str[len - 1];
+
+    return str_reverse(substr(str, len));
+}
+
+/**
+ * Get substring of given length.
+ *
+ * @param char* str
+ * @param size_t len
+ *
+ * @return char*
+ */
+char *substr(char *str, size_t len)
+{
+    char *temp = (char *) malloc(len * sizeof(char));
+
+    strncpy(temp, str, len - 1);
+    temp[len - 1] = '\0';
+
+    return temp;
+}
+
+int main()
+{
+    assert(strcmp("a", str_reverse("a")) == 0);
+    assert(strcmp("tikna", str_reverse("ankit")) == 0);
+    assert(strcmp("lerhkop tikna", str_reverse("ankit pokhrel")) == 0);
+    assert(strcmp(".egaugnaL gnimmargorP C", str_reverse("C Programming Language.")) == 0);
+    assert(strcmp("!dlrow yzarc a si sihT", str_reverse("This is a crazy world!")) == 0);
+    assert(strcmp(
+        ".tile gnicsipida rutetcesnoc ,tema tis rolod muspi meroL",
+        str_reverse("Lorem ipsum dolor sit amet, consectetur adipiscing elit.")
+    ) == 0);
+
+    char s[20] = "ankit";
+    str_reverse_1(s, 0, (int) strlen(s) - 1);
+    assert(strcmp("tikna", s) == 0);
+
+    strcpy(s, "ankit pokhrel");
+    str_reverse_1(s, 0, (int) strlen(s) - 1);
+    assert(strcmp("lerhkop tikna", s) == 0);
+
+    return 0;
+}

Recursion/sum_of_digits.c

@@ -0,0 +1,22 @@
+#include <assert.h>
+
+long long sum_of_digits(long long n)
+{
+    if (n <= 0) {
+        return 0;
+    }
+
+    return (n % 10) + sum_of_digits(n / 10);
+}
+
+int main()
+{
+    assert(1 == sum_of_digits(1));
+    assert(3 == sum_of_digits(12));
+    assert(6 == sum_of_digits(123));
+    assert(15 == sum_of_digits(12345));
+    assert(45 == sum_of_digits(123456789));
+    assert(59 == sum_of_digits(12345678959));
+
+    return 0;
+}

Recursion/tower_of_hanoi.c

@@ -0,0 +1,21 @@
+#include <stdio.h>
+
+void tower_of_hanoi(int disk, char from, char aux, char to)
+{
+    if (disk <= 1) {
+        printf("Move disk %d from pole %c to %c\n", disk, from, to);
+
+        return;
+    }
+
+    tower_of_hanoi(disk - 1, from, to, aux);
+    printf("Move disk %d from pole %c to %c\n", disk, from, to);
+    tower_of_hanoi(disk - 1, aux, from, to);
+}
+
+int main()
+{
+    tower_of_hanoi(3, 'A', 'B', 'C');
+
+    return 0;
+}