My project on Recursion

Author: tpauldike

0x08-recursion/0-puts_recursion.c

@@ -0,0 +1,17 @@
+#include "main.h"
+
+/**
+ * _puts_recursion - Prints a string, followed by a new line.
+ * @s: The string.
+ */
+void _puts_recursion(char *s)
+{
+	if (*s)
+	{
+		_putchar(*s);
+		_puts_recursion(s + 1);
+	}
+
+	else
+		_putchar('\n');
+}

0x08-recursion/1-print_rev_recursion.c

@@ -0,0 +1,14 @@
+#include "main.h"
+
+/**
+ * _print_rev_recursion - Prints a string in reverse.
+ * @s: The string to be printed.
+ */
+void _print_rev_recursion(char *s)
+{
+	if (*s)
+	{
+		_print_rev_recursion(s + 1);
+		_putchar(*s);
+	}
+}

0x08-recursion/100-is_palindrome.c

@@ -0,0 +1,62 @@
+#include "main.h"
+
+int find_strlen(char *s);
+int check_palindrome(char *s, int len, int index);
+int is_palindrome(char *s);
+
+/**
+ * find_strlen - Returns the length of a string.
+ * @s: The string to be measured.
+ *
+ * Return: The length of the string.
+ */
+int find_strlen(char *s)
+{
+	int len = 0;
+
+	if (*(s + len))
+	{
+		len++;
+		len += find_strlen(s + len);
+	}
+
+	return (len);
+}
+
+/**
+ * check_palindrome - Checks if a string is a palindrome.
+ * @s: The string to be checked.
+ * @len: The length of s.
+ * @index: The index of the string to be checked.
+ *
+ * Return: If the string is a palindrome - 1.
+ *         If the string is not a palindrome - 0.
+ */
+int check_palindrome(char *s, int len, int index)
+{
+	if (s[index] == s[len / 2])
+		return (1);
+
+	if (s[index] == s[len - index - 1])
+		return (check_palindrome(s, len, index + 1));
+
+	return (0);
+}
+
+/**
+ * is_palindrome - Checks if a string is a palindrome.
+ * @s: The string to be checked.
+ *
+ * Return: If the string is a palindrome - 1.
+ *         If the string is not a palindrome - 0.
+ */
+int is_palindrome(char *s)
+{
+	int index = 0;
+	int len = find_strlen(s);
+
+	if (!(*s))
+		return (1);
+
+	return (check_palindrome(s, len, index));
+}

0x08-recursion/101-wildcmp.c

@@ -0,0 +1,95 @@
+#include "main.h"
+
+int strlen_no_wilds(char *str);
+void iterate_wild(char **wildstr);
+char *postfix_match(char *str, char *postfix);
+int wildcmp(char *s1, char *s2);
+
+/**
+ * strlen_no_wilds - Returns the length of a string,
+ *                   ignoring wildcard characters.
+ * @str: The string to be measured.
+ *
+ * Return: The length.
+ */
+int strlen_no_wilds(char *str)
+{
+	int len = 0, index = 0;
+
+	if (*(str + index))
+	{
+		if (*str != '*')
+			len++;
+
+		index++;
+		len += strlen_no_wilds(str + index);
+	}
+
+	return (len);
+}
+
+/**
+ * iterate_wild - Iterates through a string located at a wildcard
+ *                until it points to a non-wildcard character.
+ * @wildstr: The string to be iterated through.
+ */
+void iterate_wild(char **wildstr)
+{
+	if (**wildstr == '*')
+	{
+		(*wildstr)++;
+		iterate_wild(wildstr);
+	}
+}
+
+/**
+ * postfix_match - Checks if a string str matches the postfix of
+ *                 another string potentially containing wildcards.
+ * @str: The string to be matched.
+ * @postfix: The postfix.
+ *
+ * Return: If str and postfix are identical - a pointer to the null byte
+ *                                            located at the end of postfix.
+ *         Otherwise - a pointer to the first unmatched character in postfix.
+ */
+char *postfix_match(char *str, char *postfix)
+{
+	int str_len = strlen_no_wilds(str) - 1;
+	int postfix_len = strlen_no_wilds(postfix) - 1;
+
+	if (*postfix == '*')
+		iterate_wild(&postfix);
+
+	if (*(str + str_len - postfix_len) == *postfix && *postfix != '\0')
+	{
+		postfix++;
+		return (postfix_match(str, postfix));
+	}
+
+	return (postfix);
+}
+
+/**
+ * wildcmp - Compares two strings, considering wildcard characters.
+ * @s1: The first string to be compared.
+ * @s2: The second string to be compared - may contain wildcards.
+ *
+ * Return: If the strings can be considered identical - 1.
+ *         Otherwise - 0.
+ */
+int wildcmp(char *s1, char *s2)
+{
+	if (*s2 == '*')
+	{
+		iterate_wild(&s2);
+		s2 = postfix_match(s1, s2);
+	}
+
+	if (*s2 == '\0')
+		return (1);
+
+	if (*s1 != *s2)
+		return (0);
+
+	return (wildcmp(++s1, ++s2));
+}

0x08-recursion/2-strlen_recursion.c

@@ -0,0 +1,20 @@
+#include "main.h"
+
+/**
+ * _strlen_recursion - Returns the length of a string.
+ * @s: The string to be measured.
+ *
+ * Return: The length of the string.
+ */
+int _strlen_recursion(char *s)
+{
+	int len = 0;
+
+	if (*s)
+	{
+		len++;
+		len += _strlen_recursion(s + 1);
+	}
+
+	return (len);
+}

0x08-recursion/3-factorial.c

@@ -0,0 +1,23 @@
+#include "main.h"
+
+/**
+ * factorial - Returns the factorial of a given number.
+ * @n: The number to find the factorial of.
+ *
+ * Return: If n > 0 - the factorial of n.
+ *         If n < 0 - 1 to indicate an error.
+ */
+int factorial(int n)
+{
+	int result = n;
+
+	if (n < 0)
+		return (-1);
+
+	else if (n >= 0 && n <= 1)
+		return (1);
+
+	result *= factorial(n - 1);
+
+	return (result);
+}

0x08-recursion/4-pow_recursion.c

@@ -0,0 +1,23 @@
+#include "main.h"
+
+/**
+ * _pow_recursion - Returns the value of x raised to the power of y.
+ * @x: The number to be raised.
+ * @y: The power.
+ *
+ * Return: The value of x raised to the power of y.
+ */
+int _pow_recursion(int x, int y)
+{
+	int result = x;
+
+	if (y < 0)
+		return (-1);
+
+	else if (y == 0)
+		return (1);
+
+	result *= _pow_recursion(x, y - 1);
+
+	return (result);
+}

0x08-recursion/5-sqrt_recursion.c

@@ -0,0 +1,43 @@
+#include "main.h"
+
+int find_sqrt(int num, int root);
+int _sqrt_recursion(int n);
+
+/**
+ * find_sqrt - Finds the natural square root of an inputted number.
+ * @num: The number to find the square root of.
+ * @root: The root to be tested.
+ *
+ * Return: If the number has a natural square root - the square root.
+ *         If the number does not have a natural square root - -1.
+ */
+int find_sqrt(int num, int root)
+{
+	if ((root * root) == num)
+		return (root);
+
+	if (root == num / 2)
+		return (-1);
+
+	return (find_sqrt(num, root + 1));
+}
+
+/**
+ * _sqrt_recursion - Returns the natural square root of a number.
+ * @n: The number to return the square root of.
+ *
+ * Return: If n has a natural square root - the natural square root of n.
+ *         If n does not have a natural square root - -1.
+ */
+int _sqrt_recursion(int n)
+{
+	int root = 0;
+
+	if (n < 0)
+		return (-1);
+
+	if (n == 1)
+		return (1);
+
+	return (find_sqrt(n, root));
+}

0x08-recursion/6-is_prime_number.c

@@ -0,0 +1,43 @@
+#include "main.h"
+
+int is_divisible(int num, int div);
+int is_prime_number(int n);
+
+/**
+ * is_divisible - Checks if a number is divisible.
+ * @num: The number to be checked.
+ * @div: The divisor.
+ *
+ * Return: If the number is divisible - 0.
+ *         If the number is not divisible - 1.
+ */
+int is_divisible(int num, int div)
+{
+	if (num % div == 0)
+		return (0);
+
+	if (div == num / 2)
+		return (1);
+
+	return (is_divisible(num, div + 1));
+}
+
+/**
+ * is_prime_number - Checks if a number is prime.
+ * @n: The number to be checked.
+ *
+ * Return: If the integer is not prime - 0.
+ *         If the number is prime - 1.
+ */
+int is_prime_number(int n)
+{
+	int div = 2;
+
+	if (n <= 1)
+		return (0);
+
+	if (n >= 2 && n <= 3)
+		return (1);
+
+	return (is_divisible(n, div));
+}

0x08-recursion/README.md

@@ -0,0 +1,3 @@
+0x08. C - Recursion
+
+The project that introduced me to recursion under the auspieces of ALX while I was training as a Software Engineer.

0x08-recursion/main.h

@@ -0,0 +1,15 @@
+#ifndef main_h
+#define main_h
+
+int _putchar(char c);
+void _puts_recursion(char *s);
+void _print_rev_recursion(char *s);
+int _strlen_recursion(char *s);
+int factorial(int n);
+int _pow_recursion(int x, int y);
+int _sqrt_recursion(int n);
+int is_prime_number(int n);
+int wildcmp(char *s1, char *s2);
+int is_palindrome(char *s);
+
+#endif