C Programming Language || Hands On Coding

Reverse a Number Using Recursion

#include <stdio.h>

int reverse_num(int num, int reversed_num) {
    if (num == 0) {
        return reversed_num;
    }
    int remainder = num % 10;
    reversed_num = reversed_num * 10 + remainder;
    return reverse_num(num / 10, reversed_num);
}

int main() {
    int num;
    printf("Enter a number: ");
    scanf("%d", &num);
    int reversed = reverse_num(num, 0);
    printf("Reversed number: %d\n", reversed);
    return 0;
}

Sum of Digits using Recursion

#include <stdio.h>

int sumOfDigits(int n) {
  if (n == 0)
    return 0;
  return (n % 10 + sumOfDigits(n / 10));
}

int main() {
  int num;
  printf("Enter a number: ");
  scanf("%d", &num);
  int result = sumOfDigits(num);
  printf("Sum of digits: %d\n", result);
  return 0;
}

Sum of Natural Numbers (1 to N) using Recursion

#include <stdio.h>

int sum_recursive(int n) {
  if (n == 0) {
    return 0;
  }
  return n + sum_recursive(n - 1);
}

int main() {
  int num;
  printf("Enter a positive integer: ");
  scanf("%d", &num);
  if (num < 0) {
    printf("Please enter a non-negative number.\n");
    return 1;
  }
  int sum = sum_recursive(num);
  printf("Sum of natural numbers from 1 to %d is: %d\n", num, sum);
  return 0;
}

Fibonacci nth term using recursion

#include <stdio.h>

int fibonacci(int n) {
 if (n <= 1) {
 return n;
 }
 return fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
 int n = 10;
 printf("Fibonacci(%d) = %d\n", n, fibonacci(n));
 return 0;
}

Factorial of a number using recursion

#include <stdio.h>

int factorial(int n) {
  if (n == 0) {
    return 1;
  } else {
    return n * factorial(n - 1);
  }
}

int main() {
  int num = 5;
  int result = factorial(num);
  printf("Factorial of %d = %d\n", num, result);
  return 0;
}

Square of a Number Using a Function

#include <stdio.h>

int square(int n) {
  return n * n;
}

int main() {
  int num = 5;
  int result = square(num);
  printf("Square of %d is %d\n", num, result);
  return 0;
}

Functions: Message Printing with a Helper Function

#include <stdio.h>

void printMessage() {
  printf("Hello from the helper function!\n");
}

int main() {
  printMessage();
  return 0;
}

Even or Odd Checker Function

#include <stdio.h>

int isEven(int num) {
    if (num % 2 == 0) {
        return 1; 
    } else {
        return 0; 
    }
}

int main() {
    int number;
    printf("Enter an integer: ");
    scanf("%d", &number);
    
    if (isEven(number)) {
        printf("%d is even.\n", number);
    } else {
        printf("%d is odd.\n", number);
    }

    return 0;
}

Maximum of Two Numbers Using a Function

#include <stdio.h>

int findMax(int num1, int num2) {
 if (num1 > num2) {
 return num1;
 }
 return num2;
}

int main() {
 int a, b, max;
 scanf("%d %d", &a, &b);
 max = findMax(a, b);
 printf("%d", max);
 return 0;
}

Add Two Numbers with a Function

#include <stdio.h>

int add(int a, int b) {
 return a + b;
}

int main() {
 int num1 = 10;
 int num2 = 5;
 int sum = add(num1, num2);
 printf("Sum: %d\n", sum);
 return 0;
}

Get Current Year with a Function

#include <stdio.h>
#include <time.h>

int getCurrentYear() {
    time_t timer;
    struct tm* tm_info;
    time(&timer);
    tm_info = localtime(&timer);
    return tm_info->tm_year + 1900;
}

int main() {
    int year = getCurrentYear();
    printf("Current year: %d\n", year);
    return 0;
}

Functions: Returning a Fixed Value

#include <stdio.h>

int get_value() {
 return 100;
}

int main() {
 int result = get_value();
 printf("%d\n", result);
 return 0;
}

Positive or Negative Number Checker (Void Function)

#include <stdio.h>

void checkNumber(int num) {
  if (num > 0) {
    printf("Positive\n");
  } else if (num < 0) {
    printf("Negative\n");
  } else {
    printf("Zero\n");
  }
}

int main() {
  int number;
  scanf("%d", &number);
  checkNumber(number);
  return 0;
}

Print Name and Age using a Void Function

#include <stdio.h>

void printInfo(char name[], int age) {
    printf("Name: %s\n", name);
    printf("Age: %d\n", age);
}

int main() {
    char myName[] = "Alice";
    int myAge = 30;
    printInfo(myName, myAge);
    return 0;
}

Welcome Message with a Function

#include <stdio.h>

void welcomeMessage() {
    printf("Welcome to C programming!\n");
}

int main() {
    welcomeMessage();
    return 0;
}

Hello World with a Void Function

#include <stdio.h>

void printHelloWorld() {
 printf("Hello, World!\n");
}

int main() {
 printHelloWorld();
 return 0;
}

.

: `else { return n * factorial(n - 1); }`: If `n` is not 0, the function returns `n` multiplied by the factorial of `n-1`. This is where the function calls itself. Let's trace `factorial(3)`: 1. `factorial(3)` returns `3 * factorial(2)` 2. `factorial(2)` returns `2 * factorial(1)` 3. `factorial(1)` returns `1 * factorial(0)` 4. `factorial(0)` returns `1` (base case) So, the final result is `3 * 2 * 1 * 1 = 6`. **💡 Tips for Using Functions & Recursion:** - ✅ Keep functions small and focused on a single task. - ✅ Give functions descriptive names. - ✅ Comment your code to explain what each function does. - ⚠️ Be careful with recursion! Always have a base case to avoid infinite loops. - 🧠 Recursion can be elegant for some problems (like traversing trees), but iterative solutions (using loops) are often more efficient. Functions and recursion are essential tools for writing clean, organized, and reusable C code. Practice using them, and you'll become a much more proficient programmer! 👍

Let's learn about Functions and Recursion in C! 🚀 This is a fundamental concept, so let's break it down step-by-step. **What are Functions?** ⚙️ Think of functions as mini-programs within your main program. They perform specific tasks. Imagine a function that adds two numbers or a function that prints a greeting. The whole purpose of functions are to avoid rewriting the same code again and again. Functions help us to write a more modular and organized code. **1. Simple Printing Functions (The Starting Point)** 📣 Let's start with a function that just prints something on the screen.

#include <stdio.h>

void printHello() {
    printf("Hello, world!n");
}

int main() {
    printHello(); // Calling or invoking the function
    return 0;
}

- `void printHello()`: This declares a function named `printHello`. - `void`: This means the function doesn't return any value. It just does something (in this case, printing). - `printHello()`: This is the name of the function. Choose descriptive names! - `{}`: The curly braces contain the code that the function executes. - `printf("Hello, world!\n");`: This line prints "Hello, world!" to the console. `\n` adds a newline character (moves the cursor to the next line). - `main()`: This is the main function, where the program execution begins. - `printHello();`: This *calls* or *invokes* the `printHello` function. When the program reaches this line, it jumps to the `printHello` function, executes its code, and then returns to the next line in `main()`. **2. Functions with Return Types (Giving Back Results)** ↩️ Sometimes, you want a function to calculate something and give you the result. This is where return types come in.

#include <stdio.h>

int add(int a, int b) {
    int sum = a + b;
    return sum;
}

int main() {
    int result = add(5, 3);
    printf("The sum is: %dn", result);
    return 0;
}

- `int add(int a, int b)`: - `int`: This is the *return type*. It means the function will return an integer value. - `a` and `b`: These are *parameters*. They're like inputs to the function. `a` and `b` are integers. - `return sum;`: This statement sends the value of `sum` back to the calling function (`main()`). - `int result = add(5, 3);`: In `main()`, we call the `add` function with the values 5 and 3. The returned value (8) is then stored in the `result` variable. **3. Parameters (Passing Information to Functions)** ➡️ Parameters are variables that you pass into a function. They allow you to give functions different inputs each time you call them.

#include <stdio.h>

void greet(char name[]) {
    printf("Hello, %s!n", name);
}

int main() {
    greet("Alice");
    greet("Bob");
    return 0;
}

- `char name[]`: This declares a parameter named `name` which is an array of characters (a string). The function takes a string as input. - `greet("Alice")`: When we call `greet("Alice")`, the string "Alice" is passed as the value of the `name` parameter. **4. Recursion (Functions Calling Themselves)** 🔄 Recursion is a powerful technique where a function calls *itself*. It's like looking in a mirror that reflects another mirror, and so on. 🤯 You need a "base case" to stop the recursion, or it will go on forever (or until your program crashes!).

#include <stdio.h>

int factorial(int n) {
    // Base case:
    if (n == 0) {
        return 1;
    }
    // Recursive step:
    else {
        return n * factorial(n - 1);
    }
}

int main() {
    int result = factorial(5);
    printf("Factorial of 5 is: %dn", result);
    return 0;
}

- `factorial(int n)`: This function calculates the factorial of a number `n`. - Base Case: `if (n == 0) { return 1; }`: The factorial of 0 is 1. This is the base case that stops the recursion. ⚠️ Without a base case, the function would call itself infinitely! - Recursive Step

Loop Control with Bit Shifting

#include <stdio.h>

int main() {
  int i = 8;
  int count = 0;
  for (; i; i >>= 1) {
    printf("%d ", i);
    count++;
  }
  printf("\nLoop ran %d times.\n", count);
  return 0;
}