C Programming

C is a general-purpose language developed in 1972 by Dennis M. Ritchie, used for operating systems, databases, and more.

PROGRAMS

ODD OR EVEN

Check whether a given number is odd or even.

PRIME NUMBER

Check if a number is prime.

FACTORIAL

Calculate the factorial of a number.

PALINDROME

Check if a number is a palindrome.

SUM OF N NATURAL NUMBERS

Find the sum of the first N natural numbers.

FIBONACCI SERIES

Generate the Fibonacci series up to a certain number of terms.

REVERSE A NUMBER

Reverse the digits of an integer.

GCD OF TWO NUMBERS

Find the Greatest Common Divisor (GCD) of two numbers.

ARMSTRONG NUMBER

Check if a number is an Armstrong number.

LINEAR SEARCH

Implement the linear search algorithm.

BINARY SEARCH

Implement the binary search algorithm.

BUBBLE SORT

Sort an array using Bubble Sort.

MERGE SORT

Sort an array using Merge Sort.

INSERTION SORT

Sort an array using Insertion Sort.

QUICK SORT

Sort an array using Quick Sort.

SELECTION SORT

Sort an array using Selection Sort.

STACK

Implement a basic stack data structure.

QUEUE

Implement a basic queue using a linked list.

LINKED LIST

Implement a basic singly linked list.

#include <stdio.h>
int main() {
    int num;
    printf("Enter an integer: ");
    scanf("%d", &num);
    if (num % 2 == 0)
        printf("%d is even.", num);
    else
        printf("%d is odd.", num);
    return 0;
}

#include <stdio.h>
int main() {
    int n, i, flag = 0;
    printf("Enter a positive integer: ");
    scanf("%d", &n);
    if (n == 0 || n == 1)
        flag = 1;
    for (i = 2; i <= n / 2; ++i) {
        if (n % i == 0) {
            flag = 1;
            break;
        }
    }
    if (flag == 0)
        printf("%d is a prime number.", n);
    else
        printf("%d is not a prime number.", n);
    return 0;
}

#include<stdio.h>
int main() {
    int i, fact = 1, number;
    printf("Enter a number: ");
    scanf("%d", &number);
    for (i = 1; i <= number; i++) {
        fact = fact * i;
    }
    printf("Factorial of %d is: %d", number, fact);
    return 0;
}

#include <stdio.h>
int main() {
    int n, reversed = 0, remainder, original;
    printf("Enter an integer: ");
    scanf("%d", &n);
    original = n;
    while (n != 0) {
        remainder = n % 10;
        reversed = reversed * 10 + remainder;
        n /= 10;
    }
    if (original == reversed)
        printf("%d is a palindrome.", original);
    else
        printf("%d is not a palindrome.", original);
    return 0;
}

#include <stdio.h>
int main() {
    int num, i, sum = 0;
    printf("Enter a positive number: ");
    scanf("%d", &num);
    for (i = 1; i <= num; ++i) {
        sum += i;
    }
    printf("Sum = %d", sum);
    return 0;
}

#include <stdio.h>
int main() {
    int i, n;
    int t1 = 0, t2 = 1;
    int nextTerm = t1 + t2;
    printf("Enter the number of terms: ");
    scanf("%d", &n);
    printf("Fibonacci Series: %d, %d, ", t1, t2);
    for (i = 3; i <= n; ++i) {
        printf("%d, ", nextTerm);
        t1 = t2;
        t2 = nextTerm;
        nextTerm = t1 + t2;
    }
    return 0;
}

#include <stdio.h>
int main() {
    int n, reverse = 0, rem;
    printf("Enter a number: ");
    scanf("%d", &n);
    while (n != 0) {
        rem = n % 10;
        reverse = reverse * 10 + rem;
        n /= 10;
    }
    printf("Reversed Number: %d", reverse);
    return 0;
}

#include <stdio.h>
int main() {
    int n1, n2, i, gcd;
    printf("Enter two integers: ");
    scanf("%d %d", &n1, &n2);
    for (i = 1; i <= n1 && i <= n2; ++i) {
        if (n1 % i == 0 && n2 % i == 0)
            gcd = i;
    }
    printf("G.C.D of %d and %d is %d", n1, n2, gcd);
    return 0;
}

#include <stdio.h>
int main() {
    int num, originalNum, remainder, result = 0;
    printf("Enter a three-digit integer: ");
    scanf("%d", &num);
    originalNum = num;
    while (originalNum != 0) {
        remainder = originalNum % 10;
        result += remainder * remainder * remainder;
        originalNum /= 10;
    }
    if (result == num)
        printf("%d is an Armstrong number.", num);
    else
        printf("%d is not an Armstrong number.", num);
    return 0;
}

#include <stdio.h>
int linearSearch(int arr[], int size, int key) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == key) {
            return i;
        }
    }
    return -1;
}
int main() {
    int arr[] = { 3, 4, 1, 7, 5, 8, 11 };
    int size = sizeof(arr) / sizeof(arr[0]);
    int key = 7;
    int index = linearSearch(arr, size, key);
    if (index == -1) {
        printf("Element not present.");
    } else {
        printf("Element present at index %d.", index);
    }
    return 0;
}

#include <stdio.h>
int binarySearch(int a[], int low, int high, int key) {
    while (low <= high) {
        int mid = low + (high - low) / 2;
        if (a[mid] == key) return mid;
        if (a[mid] < key) low = mid + 1;
        else high = mid - 1;
    }
    return -1;
}
int main() {
    int a[] = { 12, 13, 21, 36, 40 };
    int n = sizeof(a) / sizeof(a[0]);
    int key = 21;
    int result = binarySearch(a, 0, n - 1, key);
    (result == -1) ? printf("Element not present")
                   : printf("Element present at index %d", result);
    return 0;
}

#include <stdio.h>
void bubble_sort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

#include <stdio.h>
#include <stdlib.h>
void merge(int arr[], int l, int m, int r) {
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;
    int *L = malloc(n1 * sizeof(int));
    int *R = malloc(n2 * sizeof(int));
    for (i = 0; i < n1; i++) L[i] = arr[l + i];
    for (j = 0; j < n2; j++) R[j] = arr[m + 1 + j];
    i = 0; j = 0; k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) arr[k++] = L[i++];
        else arr[k++] = R[j++];
    }
    while (i < n1) arr[k++] = L[i++];
    while (j < n2) arr[k++] = R[j++];
    free(L); free(R);
}
void mergeSort(int arr[], int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
        merge(arr, l, m, r);
    }
}

#include <stdio.h>
void insertionSort(int arr[], int n) {
    int i, key, j;
    for (i = 1; i < n; i++) {
        key = arr[i];
        j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

#include <stdio.h>
void swap(int *a, int *b) {
    int t = *a; *a = *b; *b = t;
}
int partition(int array[], int low, int high) {
    int pivot = array[high];
    int i = (low - 1);
    for (int j = low; j < high; j++) {
        if (array[j] <= pivot) {
            i++;
            swap(&array[i], &array[j]);
        }
    }
    swap(&array[i + 1], &array[high]);
    return (i + 1);
}
void quickSort(int array[], int low, int high) {
    if (low < high) {
        int pi = partition(array, low, high);
        quickSort(array, low, pi - 1);
        quickSort(array, pi + 1, high);
    }
}

#include <stdio.h>
void selectionSort(int arr[], int n) {
    int i, j, min_idx, temp;
    for (i = 0; i < n-1; i++) {
        min_idx = i;
        for (j = i+1; j < n; j++)
          if (arr[j] < arr[min_idx])
            min_idx = j;
        temp = arr[min_idx];
        arr[min_idx] = arr[i];
        arr[i] = temp;
    }
}

#include <stdio.h>
#define MAXSIZE 8
int stack[MAXSIZE];
int top = -1;
int isempty() { return top == -1; }
int isfull() { return top == MAXSIZE - 1; }
int peek() { return stack[top]; }
int pop() {
    if (!isempty()) return stack[top--];
    printf("Stack is empty.\\n");
    return -1;
}
void push(int data) {
    if (!isfull()) stack[++top] = data;
    else printf("Stack is full.\\n");
}

#include<stdio.h>
#include <stdlib.h>
struct Node {
    int data;
    struct Node* next;
};
struct Node* front = NULL;
struct Node* rear = NULL;
void enqueue(int element) {
    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
    new_node->data = element;
    new_node->next = NULL;
    if (rear == NULL) {
        front = rear = new_node;
        return;
    }
    rear->next = new_node;
    rear = new_node;
}
int dequeue() {
    if (front == NULL) return -1; // Queue is empty
    struct Node* temp = front;
    int element = temp->data;
    front = front->next;
    if (front == NULL) rear = NULL;
    free(temp);
    return element;
}

#include <stdio.h>
#include <stdlib.h>
struct Node {
    int data;
    struct Node *next;
};
void insert(struct Node** head_ref, int new_data) {
    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->next = (*head_ref);
    (*head_ref) = new_node;
}
void printList(struct Node *node) {
    while (node != NULL) {
        printf(" %d ", node->data);
        node = node->next;
    }
}