C Programming Codes

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
    int num_args = argc;

    if (num_args == 1) {
        printf("No command-line arguments provided.n");
    } else {
        printf("Number of command-line arguments: %dn", num_args);
        printf("Program name: %sn", argv[0]);

        // Dynamically allocate memory to store the arguments
        char **args = (char **)malloc((num_args - 1) * sizeof(char *));
        if (args == NULL) {
            printf("Memory allocation failed.n");
            return 1;
        }

        printf("Other arguments:n");
        for (int i = 1; i < num_args; i++) {
            int arg_len = 0;
            while (argv[i][arg_len] != '0') {
                arg_len++;
            }

            args[i - 1] = (char *)malloc((arg_len + 1) * sizeof(char));

            if (args[i - 1] == NULL) {
                printf("Memory allocation failed.n");
                // Free previously allocated memory
                for(int j = 0; j < i - 1; j++) {
                    free(args[j]);
                }
                free(args);
                return 1;
            }

            int j = 0;
            while (argv[i][j] != '0') {
                args[i - 1][j] = argv[i][j];
                j++;
            }
            args[i - 1][j] = '0';

            printf("Argument %d: %sn", i, args[i - 1]);
        }

        // Free the dynamically allocated memory
        for (int i = 0; i < num_args - 1; i++) {
            free(args[i]);
        }
        free(args);
    }

    return 0;
}

Number of command-line arguments: 4
Program name: ./program
Other arguments:
Argument 1: hello
Argument 2: world
Argument 3: 123

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    int numStrings;

    printf("Enter the number of strings: ");
    scanf("%d", &numStrings);
    getchar();

    char **stringArray = (char **)malloc(numStrings * sizeof(char *));

    if (stringArray == NULL) {
        printf("Memory allocation failed.n");
        return 1;
    }

    for (int i = 0; i < numStrings; i++) {
        int stringLength;
        printf("Enter the length of string %d: ", i + 1);
        scanf("%d", &stringLength);
        getchar();

        stringArray[i] = (char *)malloc((stringLength + 1) * sizeof(char));

        if (stringArray[i] == NULL) {
            printf("Memory allocation failed for string %d.n", i + 1);
            for (int j = 0; j < i; j++) {
                free(stringArray[j]);
            }
            free(stringArray);
            return 1;
        }

        printf("Enter string %d: ", i + 1);
        fgets(stringArray[i], stringLength + 1, stdin);
        stringArray[i][strcspn(stringArray[i], "n")] = 0;
    }

    printf("nEntered strings:n");
    for (int i = 0; i < numStrings; i++) {
        printf("String %d: %sn", i + 1, stringArray[i]);
    }

    for (int i = 0; i < numStrings; i++) {
        free(stringArray[i]);
    }
    free(stringArray);

    return 0;
}

Input: 2
Input: 5
Input: hello
Input: 3
Input: bye
Output: Enter the number of strings: Enter the length of string 1: Enter string 1: Enter the length of string 2: Enter string 2:
Entered strings:
String 1: hello
String 2: bye

#include <stdio.h>
#include <stdlib.h>

struct Person {
    char name[50];
    int age;
};

int main() {
    struct Person *personPtr;

    personPtr = (struct Person *)malloc(sizeof(struct Person));

    if (personPtr == NULL) {
        printf("Memory allocation failed!n");
        return 1;
    }

    printf("Enter name: ");
    scanf("%s", personPtr->name);

    printf("Enter age: ");
    scanf("%d", &personPtr->age);

    printf("Name: %s, Age: %dn", personPtr->name, personPtr->age);

    free(personPtr);

    return 0;
}

Input: John
Input: 30
Output: Enter name: Enter age: Name: John, Age: 30

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define POOL_SIZE 1024
#define BLOCK_SIZE 32

typedef struct Block {
    bool is_free;
    struct Block *next;
} Block;

char memory_pool[POOL_SIZE];
Block *free_list;

void initialize_pool() {
    int num_blocks = POOL_SIZE / BLOCK_SIZE;
    Block *current_block = (Block *)memory_pool;

    for (int i = 0; i < num_blocks; i++) {
        current_block->is_free = true;
        current_block->next = (Block *)((char *)current_block + BLOCK_SIZE);
        current_block = current_block->next;
    }

    ((Block *)((char *)current_block - BLOCK_SIZE))->next = NULL;
    free_list = (Block *)memory_pool;
}

void *allocate_memory() {
    if (free_list == NULL) {
        printf("Memory pool is empty.n");
        return NULL;
    }

    Block *allocated_block = free_list;
    free_list = free_list->next;
    allocated_block->is_free = false;
    return (void *)((char *)allocated_block + sizeof(Block));
}

void deallocate_memory(void *ptr) {
    if (ptr == NULL) return;

    Block *block_to_free = (Block *)((char *)ptr - sizeof(Block));
    block_to_free->is_free = true;
    block_to_free->next = free_list;
    free_list = block_to_free;
}

int main() {
    initialize_pool();

    int *num1 = (int *)allocate_memory();
    if (num1 != NULL) {
        *num1 = 42;
        printf("Allocated memory: %dn", *num1);
    }

    int *num2 = (int *)allocate_memory();
    if (num2 != NULL) {
        *num2 = 99;
        printf("Allocated memory: %dn", *num2);
    }

    deallocate_memory(num1);
    deallocate_memory(num2);

    return 0;
}

Allocated memory: 42
Allocated memory: 99

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MEMORY_SIZE 1024

static char memory[MEMORY_SIZE];
static bool memory_map[MEMORY_SIZE];

void* my_malloc(size_t size) {
    if (size <= 0 || size > MEMORY_SIZE) {
        return NULL;
    }

    for (int i = 0; i <= MEMORY_SIZE - size; i++) {
        bool found = true;
        for (int j = 0; j < size; j++) {
            if (memory_map[i + j]) {
                found = false;
                break;
            }
        }

        if (found) {
            for (int j = 0; j < size; j++) {
                memory_map[i + j] = true;
            }
            return (void*)&memory[i];
        }
    }

    return NULL;
}

void my_free(void* ptr, size_t size) {
    if (ptr == NULL) {
        return;
    }

    char* start = (char*)memory;
    char* current = (char*)ptr;

    if (current < start || current >= start + MEMORY_SIZE) {
        return;
    }

    size_t offset = current - start;

    for (int i = 0; i < size; i++) {
        memory_map[offset + i] = false;
    }
}

int main() {
    int* ptr1 = (int*)my_malloc(sizeof(int) * 5);
    if (ptr1 == NULL) {
        printf("Memory allocation failed!n");
        return 1;
    }

    for (int i = 0; i < 5; i++) {
        ptr1[i] = i * 2;
    }

    printf("Allocated memory at: %pn", (void*)ptr1);
    for (int i = 0; i < 5; i++) {
        printf("ptr1[%d] = %dn", i, ptr1[i]);
    }

    my_free(ptr1, sizeof(int) * 5);

    printf("Memory freed.n");

    return 0;
}

Allocated memory at: 0x602000000000
ptr1[0] = 0
ptr1[1] = 2
ptr1[2] = 4
ptr1[3] = 6
ptr1[4] = 8
Memory freed.

#include <stdio.h>
#include <stdlib.h>

int main() {
  int *ptr;

  ptr = (int *)malloc(sizeof(int));

  if (ptr == NULL) {
    printf("Memory allocation failed!n");
    return 1;
  }

  printf("Memory allocated at address: %pn", (void *)ptr);
  printf("Enter an integer value: ");
  scanf("%d", ptr);
  printf("Value stored: %dn", *ptr);
  // free(ptr); //Uncomment this to prevent memory leak
  ptr = NULL; //Setting to NULL after free is a good practice

  return 0;
}

Memory allocated at address: 0x12345678
Enter an integer value: 10
Value stored: 10

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr;
    int size = 2;
    int count = 0;
    int num;

    arr = (int *)malloc(size * sizeof(int));

    if (arr == NULL) {
        printf("Memory allocation failed.n");
        return 1;
    }

    printf("Enter numbers (enter -1 to stop):n");

    while (1) {
        scanf("%d", &num);

        if (num == -1) {
            break;
        }

        if (count == size) {
            size *= 2;
            arr = (int *)realloc(arr, size * sizeof(int));
            if (arr == NULL) {
                printf("Memory reallocation failed.n");
                return 1;
            }
        }

        arr[count] = num;
        count++;
    }

    printf("The numbers you entered are:n");
    for (int i = 0; i < count; i++) {
        printf("%d ", arr[i]);
    }
    printf("n");

    free(arr);
    return 0;
}

Input: 1
Input: 2
Input: 3
Input: 4
Input: 5
Input: -1
Output: Enter numbers (enter -1 to stop):
The numbers you entered are:
1 2 3 4 5

#include <stdio.h>
#include <stdlib.h>

struct Node {
  int data;
  struct Node *left;
  struct Node *right;
};

struct Node *createNode(int data) {
  struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
  newNode->data = data;
  newNode->left = NULL;
  newNode->right = NULL;
  return newNode;
}

void inorderTraversal(struct Node *root) {
  if (root != NULL) {
    inorderTraversal(root->left);
    printf("%d ", root->data);
    inorderTraversal(root->right);
  }
}

int main() {
  struct Node *root = createNode(1);
  root->left = createNode(2);
  root->right = createNode(3);
  root->left->left = createNode(4);
  root->left->right = createNode(5);

  printf("Inorder traversal of the binary tree is: ");
  inorderTraversal(root);
  printf("n");

  return 0;
}

Inorder traversal of the binary tree is: 4 2 5 1 3

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int *data;
    int front;
    int rear;
    int capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* queue = (Queue*)malloc(sizeof(Queue));
    queue->capacity = capacity;
    queue->front = 0;
    queue->rear = -1;
    queue->data = (int*)malloc(queue->capacity * sizeof(int));
    return queue;
}

int isFull(Queue* queue) {
    return (queue->rear == queue->capacity - 1);
}

int isEmpty(Queue* queue) {
    return (queue->front > queue->rear);
}

void enqueue(Queue* queue, int item) {
    if (isFull(queue)) {
        printf("Queue is fulln");
        return;
    }
    queue->rear = queue->rear + 1;
    queue->data[queue->rear] = item;
    printf("%d enqueued to queuen", item);
}

int dequeue(Queue* queue) {
    if (isEmpty(queue)) {
        printf("Queue is emptyn");
        return -1;
    }
    int item = queue->data[queue->front];
    queue->front = queue->front + 1;
    return item;
}

int main() {
    Queue* queue = createQueue(5);

    enqueue(queue, 10);
    enqueue(queue, 20);
    enqueue(queue, 30);
    enqueue(queue, 40);
    enqueue(queue, 50);

    printf("%d dequeued from queuen", dequeue(queue));
    printf("%d dequeued from queuen", dequeue(queue));
    printf("%d dequeued from queuen", dequeue(queue));

    free(queue->data);
    free(queue);

    return 0;
}

10 enqueued to queue
20 enqueued to queue
30 enqueued to queue
40 enqueued to queue
50 enqueued to queue
10 dequeued from queue
20 dequeued from queue
30 dequeued from queue

#include <stdio.h>
#include <stdlib.h>

struct Stack {
    int *array;
    int top;
    unsigned capacity;
};

struct Stack* createStack(unsigned capacity) {
    struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
    stack->capacity = capacity;
    stack->top = -1;
    stack->array = (int*)malloc(stack->capacity * sizeof(int));
    return stack;
}

int isFull(struct Stack* stack) {
    return stack->top == stack->capacity - 1;
}

int isEmpty(struct Stack* stack) {
    return stack->top == -1;
}

void push(struct Stack* stack, int item) {
    if (isFull(stack))
        return;
    stack->array[++stack->top] = item;
    printf("%d pushed to stackn", item);
}

int pop(struct Stack* stack) {
    if (isEmpty(stack))
        return -1;
    return stack->array[stack->top--];
}

int peek(struct Stack* stack) {
    if (isEmpty(stack))
        return -1;
    return stack->array[stack->top];
}

int main() {
    struct Stack* stack = createStack(10);

    push(stack, 10);
    push(stack, 20);
    push(stack, 30);

    printf("%d popped from stackn", pop(stack));
 printf("Top element is %dn", peek(stack));
    return 0;
}

10 pushed to stack
20 pushed to stack
30 pushed to stack
30 popped from stack
Top element is 20

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node *next;
};

int main() {
    struct Node *head = NULL;
    struct Node *temp = NULL;
    int choice, value;

    while (1) {
        printf("1. Insert at beginningn");
        printf("2. Displayn");
        printf("3. Exitn");
        printf("Enter your choice: ");
        scanf("%d", &choice);

        if (choice == 1) {
            printf("Enter the value to insert: ");
            scanf("%d", &value);

            struct Node *newNode = (struct Node*)malloc(sizeof(struct Node));
            newNode->data = value;
            newNode->next = head;
            head = newNode;

        } else if (choice == 2) {
            temp = head;
            printf("Linked List: ");
            while (temp != NULL) {
                printf("%d ", temp->data);
                temp = temp->next;
            }
            printf("n");
        } else if (choice == 3) {
            break;
        } else {
            printf("Invalid choice.n");
        }
    }

    temp = head;
    while (temp != NULL) {
        struct Node *next = temp->next;
        free(temp);
        temp = next;
    }
    head = NULL;

    return 0;
}

1. Insert at beginning
2. Display
3. Exit
Enter your choice: 1
Enter the value to insert: 10
1. Insert at beginning
2. Display
3. Exit
Enter your choice: 1
Enter the value to insert: 20
1. Insert at beginning
2. Display
3. Exit
Enter your choice: 2
Linked List: 20 10
1. Insert at beginning
2. Display
3. Exit
Enter your choice: 1
Enter the value to insert: 30
1. Insert at beginning
2. Display
3. Exit
Enter your choice: 2
Linked List: 30 20 10
1. Insert at beginning
2. Display
3. Exit
Enter your choice: 3

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    char *str1 = NULL, *str2 = NULL, *combinedStr = NULL;
    int len1, len2;

    printf("Enter the length of the first string: ");
    scanf("%d", &len1);
    str1 = (char *)malloc((len1 + 1) * sizeof(char));
    if (str1 == NULL) {
        printf("Memory allocation failedn");
        return 1;
    }
    printf("Enter the first string: ");
    scanf(" %[^n]", str1);

    printf("Enter the length of the second string: ");
    scanf("%d", &len2);
    str2 = (char *)malloc((len2 + 1) * sizeof(char));
    if (str2 == NULL) {
        printf("Memory allocation failedn");
        free(str1);
        return 1;
    }
    printf("Enter the second string: ");
    scanf(" %[^n]", str2);

    combinedStr = (char *)malloc((len1 + len2 + 1) * sizeof(char));
    if (combinedStr == NULL) {
        printf("Memory allocation failedn");
        free(str1);
        free(str2);
        return 1;
    }

    strcpy(combinedStr, str1);
    strcat(combinedStr, str2);

    printf("Combined string: %sn", combinedStr);

    free(str1);
    free(str2);
    free(combinedStr);

    return 0;
}

Input: 5
Input: Hello
Input: 3
Input: World
Output: Enter the length of the first string: Enter the first string: Enter the length of the second string: Enter the second string: Combined string: HelloWorld

#include <stdio.h>
#include <stdlib.h>

int main() {
    int rows, cols;
    int i, j;

    printf("Enter the number of rows: ");
    scanf("%d", &rows);

    printf("Enter the number of columns: ");
    scanf("%d", &cols);

    int **matrix = (int **)malloc(rows * sizeof(int *));
    if (matrix == NULL) {
        printf("Memory allocation failed.n");
        return 1;
    }

    for (i = 0; i < rows; i++) {
        matrix[i] = (int *)malloc(cols * sizeof(int));
        if (matrix[i] == NULL) {
            printf("Memory allocation failed.n");
            // Free previously allocated memory
            for (j = 0; j < i; j++) {
                free(matrix[j]);
            }
            free(matrix);
            return 1;
        }
    }

    printf("Enter the elements of the matrix:n");
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            scanf("%d", &matrix[i][j]);
        }
    }

    printf("The matrix is:n");
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("n");
    }

    // Free the allocated memory
    for (i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);

    return 0;
}

Input: 2
Input: 3
Input: 1
Input: 2
Input: 3
Input: 4
Input: 5
Input: 6
Output: Enter the number of rows: Enter the number of columns: Enter the elements of the matrix:
The matrix is:
1 2 3
4 5 6

#include <stdio.h>
#include <stdlib.h>

int main() {
    int rows, cols, i, j;
    int **arr;

    printf("Enter number of rows: ");
    scanf("%d", &rows);
    printf("Enter number of columns: ");
    scanf("%d", &cols);

    arr = (int **)malloc(rows * sizeof(int *));
    if (arr == NULL) {
        printf("Memory allocation failedn");
        return 1;
    }

    for (i = 0; i < rows; i++) {
        arr[i] = (int *)malloc(cols * sizeof(int));
        if (arr[i] == NULL) {
            printf("Memory allocation failedn");
             for (j = 0; j < i; j++) {
                free(arr[j]);
            }
            free(arr);
            return 1;
        }
    }

    printf("Enter elements of the array:n");
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            scanf("%d", &arr[i][j]);
        }
    }

    printf("The array is:n");
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("n");
    }

    for (i = 0; i < rows; i++) {
        free(arr[i]);
    }
    free(arr);

    return 0;
}

Input: 2
Input: 3
Input: 1
Input: 2
Input: 3
Input: 4
Input: 5
Input: 6
Output: Enter number of rows: Enter number of columns: Enter elements of the array:
The array is:
1 2 3
4 5 6

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr;
    int size, i;

    printf("Enter the size of the array: ");
    scanf("%d", &size);

    arr = (int *)malloc(size * sizeof(int));

    if (arr == NULL) {
        printf("Memory allocation failed!n");
        return 1;
    }

    printf("Enter the elements of the array:n");
    for (i = 0; i < size; i++) {
        scanf("%d", &arr[i]);
    }

    printf("The elements of the array are:n");
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("n");

    free(arr);

    return 0;
}

Input: 5
Input: 10
Input: 20
Input: 30
Input: 40
Input: 50
Output: Enter the size of the array: Enter the elements of the array:
The elements of the array are:
10 20 30 40 50

#include <stdio.h>

int findMaxRecursive(int arr[], int size) {
    if (size == 1) {
        return arr[0];
    } else {
        int maxRest = findMaxRecursive(arr, size - 1);
        if (arr[size - 1] > maxRest) {
            return arr[size - 1];
        } else {
            return maxRest;
        }
    }
}

int main() {
    int size, i;

    printf("Enter the size of the array: ");
    scanf("%d", &size);

    int arr[size];

    printf("Enter the elements of the array:n");
    for (i = 0; i < size; i++) {
        scanf("%d", &arr[i]);
    }

    int max = findMaxRecursive(arr, size);

    printf("Maximum element in the array is: %dn", max);

    return 0;
}

Input: 5
Input: 10
Input: 5
Input: 20
Input: 15
Input: 25
Output: Maximum element in the array is: 25

Input: 3
Input: -5
Input: 0
Input: 5
Output: Maximum element in the array is: 5

Input: 1
Input: 100
Output: Maximum element in the array is: 100

#include <stdio.h>

void towerOfHanoi(int n, char from_rod, char to_rod, char aux_rod) {
    if (n == 1) {
        printf("Move disk 1 from rod %c to rod %cn", from_rod, to_rod);
        return;
    }
    towerOfHanoi(n - 1, from_rod, aux_rod, to_rod);
    printf("Move disk %d from rod %c to rod %cn", n, from_rod, to_rod);
    towerOfHanoi(n - 1, aux_rod, to_rod, from_rod);
}

int main() {
    int num_disks;

    printf("Enter the number of disks: ");
    scanf("%d", &num_disks);

    towerOfHanoi(num_disks, 'A', 'C', 'B'); // A, B and C are names of rods

    return 0;
}

Input: 3
Output: Enter the number of disks: Move disk 1 from rod A to rod C
Move disk 2 from rod A to rod B
Move disk 1 from rod C to rod B
Move disk 3 from rod A to rod C
Move disk 1 from rod B to rod A
Move disk 2 from rod B to rod C
Move disk 1 from rod A to rod C

#include <stdio.h>

int countDigits(int n) {
    if (n == 0) {
        return 0;
    } else {
        return 1 + countDigits(n / 10);
    }
}

int main() {
    int num;

    printf("Enter an integer: ");
    scanf("%d", &num);

    int digitCount = countDigits(num);

    printf("Number of digits: %dn", digitCount);

    return 0;
}

Input: 12345
Output: Enter an integer: Number of digits: 5

Input: 0
Output: Enter an integer: Number of digits: 0

Input: 99
Output: Enter an integer: Number of digits: 2

Input: -123
Output: Enter an integer: Number of digits: 3