Intermediate C Programming Exercises: 45 Coding Problems with Solutions

#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a; // Store value at address a
    *a = *b;       // Put value from b into address a
    *b = temp;     // Put stored value into address b
}

int main() {
    int x = 10, y = 20;

    printf("Before Swap: x = %d, y = %d\n", x, y);
    
    swap(&x, &y); // Passing addresses of x and y
    
    printf("After Swap:  x = %d, y = %d\n", x, y);
    return 0;
}Code language: C++ (cpp)

Explanation:

• swap(&x, &y): The & operator sends the memory addresses of x and y to the function.
• int temp = *a: The * (dereference) operator looks inside the memory address a to get the actual number (10) and saves it in temp.
• *a = *b: This directly changes the memory at address a to whatever is currently sitting at address b.

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

int main() {
    int n = 3;
    int *arr = (int*)malloc(n * sizeof(int));

    if (arr == NULL) return 1; // Check if allocation failed

    printf("Array allocated at Heap Address: %p\n", (void*)arr);

    for (int i = 0; i < n; i++) {
        arr[i] = (i + 1) * 100;
        printf("Value at index %d: %d\n", i, arr[i]);
    }

    free(arr); // Clean up
    printf("Memory successfully freed.\n");
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

Static arrays require a size known at compile-time.

• malloc(n * sizeof(int)): Requests a block of bytes from the Heap. Since an int is usually 4 bytes, this requests 12 bytes for 3 integers.
• if (arr == NULL): This is a safety check. If the computer is out of RAM, malloc returns NULL, and attempting to write to it would crash the program.
• free(arr): This tells the Operating System that the 12 bytes are no longer needed. If you skip this in a large program, you create a “Memory Leak.”

#include <stdio.h>

int* find_max(int *arr, int size) {
    int *max_ptr = arr;
    for (int i = 1; i < size; i++) {
        if (*(arr + i) > *max_ptr) {
            max_ptr = arr + i;
        }
    }
    return max_ptr;
}

int main() {
    int nums[] = {12, 45, 7, 99, 23};
    int *max = find_max(nums, 5);
    printf("Max value: %d\n", *max);
    return 0;
}Code language: C++ (cpp)

Explanation:

• max_ptr = arr + i: arr is the address of index 0. arr + i uses pointer arithmetic to calculate the memory address of index i.
• *(arr + i): The * dereferences the calculated address to get the number stored there for comparison.
• max - nums: Subtracting the base address of the array (nums) from the pointer to an element (max) gives the number of elements between them, which is the index.

This approach is widely used in C to allow the caller to not only read the maximum value but also modify it directly at its source memory location if needed.

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

int main() {
    char *list[] = {"Watermelon", "Apple", "Banana"};
    
    for (int i = 0; i < 2; i++) {
        if (strlen(list[i]) > strlen(list[i+1])) {
            char *temp = list[i];
            list[i] = list[i+1];
            list[i+1] = temp;
        }
    }
    printf("Shortest: %s, Longest: %s\n", list[0], list[1]);
    return 0;
}Code language: C++ (cpp)

Explanation:

An array of pointers treats strings as independent blocks of memory. Swapping two pointers is a constant-time operation (O(1)), which is significantly faster than using strcpy to move every character of a long string.

This technique is the backbone of efficient sorting algorithms in C, where we move small “handles” (pointers) to the data rather than moving the bulky data itself.

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

int main() {
    int capacity = 2, count = 0;
    int *arr = malloc(capacity * sizeof(int));

    printf("Initial Capacity: %d\n", capacity);

    for (int i = 1; i <= 5; i++) {
        if (count == capacity) {
            capacity *= 2;
            int *temp = realloc(arr, capacity * sizeof(int));
            if (temp != NULL) arr = temp;
            printf("..Capacity doubled to %d..\n", capacity);
        }
        arr[count++] = i * 10;
    }

    printf("Final Data: ");
    for (int i = 0; i < count; i++) printf("%d ", arr[i]);
    printf("\nFinal Capacity: %d\n", capacity);

    free(arr);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• capacity *= 2: We grow the array exponentially. This is an industry-standard strategy to balance performance and memory usage.
• realloc(arr, capacity * sizeof(int)): It looks for a larger block. If it can’t find one at the current address, it moves the data to a new location and returns the new address.
• arr = temp: We update our pointer to the new address provided by realloc.

#include <stdio.h>

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

int main() {
    int x = 15, y = 5;
    
    // Declare a function pointer
    int (*operation)(int, int);

    // Point to add and execute
    operation = add;
    printf("Operation: ADD | Result: %d\n", operation(x, y));

    // Point to subtract and execute
    operation = subtract;
    printf("Operation: SUB | Result: %d\n", operation(x, y));

    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• int (*operation)(int, int): This tells the compiler that operation is a pointer to a function that returns an int and takes two int parameters.
• operation = add: In C, the name of a function is essentially its memory address. Here, we store the address of the add function in our pointer.
• operation(x, y): The pointer is dereferenced to execute the code located at that memory address, behaving exactly like a direct function call.

#include <stdio.h>

int my_strlen(char *s) {
    char *p = s; // Copy of the starting address
    while (*p != '\0') {
        p++; // Move pointer forward
    }
    return p - s; // Subtract starting address from end address
}

int main() {
    char text[] = "Hello World";
    
    int length = my_strlen(text);
    
    printf("String: %s\n", text);
    printf("Calculated Length: %d\n", length);
    
    return 0;
}Code language: C++ (cpp)

Explanation:

• while (*p != '\0'): The loop continues until the character at the current address p is the “null” character, which marks the end of all C strings.
• p++: Increments the address stored in p by the size of one char (1 byte), moving us to the next character in memory.
• p - s: Subtracting two pointers of the same type results in the number of elements between them. This is more efficient than using a separate integer counter.

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

void reverse_string(char *str) {
    int len = strlen(str);
    for (int i = 0; i < len / 2; i++) {
        char temp = str[i];
        str[i] = str[len - 1 - i];
        str[len - 1 - i] = temp;
    }
}

int main() {
    char my_str[] = "C-Prog";

    printf("Before: %s\n", my_str);
    reverse_string(my_str);
    printf("After:  %s\n", my_str);

    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• len / 2: We only loop halfway. If we went the full length, we would swap the characters back to their original positions.
• str[len - 1 - i]: This calculates the “mirror” index from the end. For index 0, it targets index 5 (if length is 6).
• char my_str[]: The string must be defined as an array. If defined as char *s = "C-Prog", it is stored in read-only memory and would cause a crash if you tried to swap its characters.

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

int is_anagram(char *s1, char *s2) {
    int count[256] = {0}; // Initialize all counts to 0
    
    if (strlen(s1) != strlen(s2)) return 0;

    for (int i = 0; s1[i] != '\0'; i++) {
        count[(unsigned char)s1[i]]++; // Add for s1
        count[(unsigned char)s2[i]]--; // Subtract for s2
    }

    for (int i = 0; i < 256; i++) {
        if (count[i] != 0) return 0; // Any mismatch found
    }
    return 1;
}

int main() {
    char a[] = "silent", b[] = "listen";

    printf("String A: %s | String B: %s\n", a, b);
    
    if (is_anagram(a, b)) printf("Result: Anagrams Found\n");
    else printf("Result: Not Anagrams\n");

    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• count[(unsigned char)s1[i]]++: We use the character itself (e.g., ‘a’ = 97) as the index in our count array. If ‘a’ appears, index 97 becomes 1.
• count[...]--: By subtracting for the second string, we “cancel out” the counts. If both strings have the same letters, every index in the array will eventually return to zero.
• O(n) Time Complexity: This method is much faster than sorting both strings because it only looks at each character twice.

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

int is_palindrome(char *str) {
    char *start = str;
    char *end = str + strlen(str) - 1;

    while (end > start) {
        if (*start != *end) return 0; // Mismatch
        start++; // Move forward
        end--;   // Move backward
    }
    return 1;
}

int main() {
    char word[] = "racecar";

    printf("Testing word: %s\n", word);
    
    if (is_palindrome(word)) printf("Result: Is a Palindrome\n");
    else printf("Result: Not a Palindrome\n");

    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• char *end = str + strlen(str) - 1: Calculates the address of the very last character before the null terminator.
• while (end > start): The loop stops once the pointers meet or cross in the middle.
• *start != *end: Dereferences both pointers to compare the characters. If “r” equals “r”, the pointers move; if they didn’t match, we would exit immediately.

#include <stdio.h>
#include <ctype.h>

int count_words(char *s) {
    int count = 0, in_word = 0;

    while (*s) {
        if (isspace(*s)) {
            in_word = 0; // We are in whitespace
        } else if (in_word == 0) {
            in_word = 1; // Transition from space to letter
            count++;
        }
        s++;
    }
    return count;
}

int main() {
    char text[] = "  Intermediate C   is fun  ";
    
    printf("Sentence: \"%s\"\n", text);
    printf("Word Count: %d\n", count_words(text));

    return 0;
}Code language: C++ (cpp)

Explanation:

• isspace(*s): A helper function from <ctype.h> that checks for spaces, tabs, or newlines.
• else if (in_word == 0): This condition only triggers when we hit the first letter of a word after coming from a space. This prevents multiple spaces from being counted as multiple words.
• count++: We only increment when we “enter” a word, making the count accurate even if the sentence starts or ends with extra spaces.

#include <stdio.h>

struct Student {
    char name[50];
    int roll;
    float gpa;
};

int main() {
    struct Student class[3] = {
        {"Alice", 101, 3.8},
        {"Bob", 102, 3.9},
        {"Charlie", 103, 3.5}
    };

    int best_idx = 0;
    printf("Initial Data:\n");
    for(int i = 0; i < 3; i++) {
        printf("%s (GPA: %.1f)\n", class[i].name, class[i].gpa);
        if (class[i].gpa > class[best_idx].gpa) {
            best_idx = i;
        }
    }

    printf("\nTop Student: %s with GPA: %.1f\n", class[best_idx].name, class[best_idx].gpa);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• struct Student class[3]: This creates a contiguous block of memory large enough to hold three student “objects.”
• class[i].gpa: The dot (.) operator is used to access specific members inside a struct instance.
• best_idx = i: Instead of copying the whole struct, we just store the index of the “winner,” which is much more memory-efficient.

#include <stdio.h>

typedef struct {
    float real;
    float imag;
} Complex;

Complex add(Complex n1, Complex n2) {
    Complex result;
    result.real = n1.real + n2.real;
    result.imag = n1.imag + n2.imag;
    return result;
}

int main() {
    Complex c1 = {3.0, 4.0}, c2 = {1.0, 2.0};
    
    printf("Adding: (%.1f + %.1fi) and (%.1f + %.1fi)\n", c1.real, c1.imag, c2.real, c2.imag);
    
    Complex sum = add(c1, c2);
    
    printf("Result: %.1f + %.1fi\n", sum.real, sum.imag);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• typedef struct: This creates an alias, allowing us to use Complex as a standalone type name just like int or float.
• Complex result: A local struct is created inside the function to hold the calculated values.
• return result: In C, when a struct is returned, the entire block of memory for that struct is copied back to the calling function.

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

struct Time { int h, m, s; };

int to_seconds(struct Time t) {
    return (t.h * 3600) + (t.m * 60) + t.s;
}

int main() {
    struct Time start = {10, 30, 0};
    struct Time end = {12, 15, 30};

    int s1 = to_seconds(start);
    int s2 = to_seconds(end);
    
    printf("Time 1: %02d:%02d:%02d (%d sec)\n", start.h, start.m, start.s, s1);
    printf("Time 2: %02d:%02d:%02d (%d sec)\n", end.h, end.m, end.s, s2);
    
    int diff = abs(s2 - s1);
    printf("Difference: %d seconds\n", diff);
    
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• to_seconds(struct Time t): This helper function “flattens” the struct into a single integer, making the comparison trivial.
• %02d: This format specifier ensures that the time prints with leading zeros (e.g., “05” instead of “5”), making it look like a digital clock.
• abs(s2 - s1): This ensures that regardless of which time is “start” or “end,” you get a positive duration.

#include <stdio.h>

typedef struct { float x, y; } Point;
typedef struct { Point center; float radius; } Circle;

int main() {
    Circle myCircle = {{0.0, 0.0}, 5.0};
    
    float area = 3.14159 * myCircle.radius * myCircle.radius;
    
    printf("Circle Center: (%.1f, %.1f)\n", myCircle.center.x, myCircle.center.y);
    printf("Circle Radius: %.1f\n", myCircle.radius);
    printf("Calculated Area: %.2f\n", area);
    
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• Point center: Inside the Circle definition, we don’t just store floats; we store an actual Point type.
• {{0.0, 0.0}, 5.0}: The nested curly braces initialize the inner Point struct first, then the radius.
• myCircle.center.x: The compiler first looks into myCircle to find the center struct, then looks into center to find the x float.

#include <stdio.h>

union Data {
    int i;
    float f;
};

int main() {
    union Data d;

    d.i = 10;
    printf("Step 1: Assigned Int = %d\n", d.i);
    printf("Memory state (as float): %f\n", d.f);

    d.f = 220.5;
    printf("\nStep 2: Assigned Float = %.1f\n", d.f);
    printf("Memory state (as int): %d (Now Overwritten!)\n", d.i);

    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• union Data d: This allocates only 4 bytes of memory (enough for either one int or one float).
• Shared Memory: In Step 1, when we print d.f after assigning d.i, we see a strange decimal number. This is because the computer is trying to read the integer 10 bits as if they were a floating-point number.
• Overwriting: In Step 2, assigning d.f physically overwrites the bytes that stored 10. This shows why you must track which member of a union is currently “active.”

#include <stdio.h>

int main() {
    FILE *src = fopen("source.txt", "r");
    FILE *dest = fopen("destination.txt", "w");

    if (src == NULL || dest == NULL) {
        printf("Error: Could not open files.\n");
        return 1;
    }

    char ch;
    printf("Starting copy process...\n");

    while ((ch = fgetc(src)) != EOF) {
        fputc(ch, dest);
    }

    printf("File copied successfully.\n");

    fclose(src);
    fclose(dest);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• fopen("source.txt", "r"): Opens the file in “read” mode. If the file doesn’t exist, it returns NULL.
• while ((ch = fgetc(src)) != EOF): This is a classic C pattern. It reads a character, assigns it to ch, and checks if it’s the end of the file all in one line.
• fclose(src): Closing files is mandatory. It releases the file handle back to the Operating System and ensures all data is physically written to the disk.

#include <stdio.h>

int main() {
    FILE *fptr = fopen("data.txt", "r");
    if (fptr == NULL) return 1;

    int count = 0;
    char ch;

    while ((ch = fgetc(fptr)) != EOF) {
        if (ch == '\n') {
            count++;
        }
    }

    printf("Total Newline Characters: %d\n", count);
    printf("Estimated Total Lines: %d\n", count + 1);

    fclose(fptr);
    return 0;
}Code language: C++ (cpp)

Explanation of Solutions:

• if (ch == '\n'): This identifies the specific character used by the system to move to a new line.
• count + 1: We add one to the final count because if a file has one line of text but no newline at the end, the loop would count 0, even though a line of text exists.

#include <stdio.h>

struct Student { char name[20]; int age; };

int main() {
    struct Student out[2] = {{"User1", 20}, {"User2", 22}}, in[2];
    
    printf("--- Existing Data in Memory ---\n");
    for(int i=0; i<2; i++) printf("%s, %d\n", out[i].name, out[i].age);

    FILE *f = fopen("students.bin", "wb");
    if (!f) return 1;
    fwrite(out, sizeof(struct Student), 2, f);
    fclose(f);

    // Read back into 'in' array
    f = fopen("students.bin", "rb");
    if (!f) return 1;
    fread(in, sizeof(struct Student), 2, f);
    fclose(f);

    printf("\n--- Data Read from Binary File ---\n");
    for(int i=0; i<2; i++) printf("%s, %d\n", in[i].name, in[i].age);
    
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• fwrite(out, sizeof(struct Student), 2, f): This line tells C to take the memory address of out, measure how big one Student is, and write 2 of them directly to the file stream.
• Binary Mode ("wb", "rb"): The ‘b’ flag is crucial; it tells the OS not to translate newline characters, keeping the raw bit-pattern of the integers and strings intact.
• fread(in, ...): This performs the exact reverse of fwrite. It fills the empty in array with the bytes found in the file. Since the struct definition is the same, the data fits back into the name and age fields perfectly.

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

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

void push(struct Node **head_ref, int new_val) {
    struct Node *new_node = malloc(sizeof(struct Node));
    new_node->data = new_val;
    new_node->next = *head_ref; // New node points to old head
    *head_ref = new_node;       // Head now points to new node
}

void printList(struct Node *n) {
    while (n != NULL) { printf("%d -> ", n->data); n = n->next; }
    printf("NULL\n");
}

int main() {
    struct Node *head = malloc(sizeof(struct Node));
    head->data = 10; head->next = NULL;

    printf("Existing List: "); printList(head);
    push(&head, 20);
    printf("After Push(20): "); printList(head);
    return 0;
}Code language: C++ (cpp)

Explanation:

• malloc(sizeof(struct Node)): Allocates a block of memory on the heap large enough for one integer and one pointer.
• new_node->next = *head_ref: This “wires” our new node to the existing list. The new node’s “next” arm now holds the address of the node that used to be first.
• *head_ref = new_node: We update the head variable in main to the address of our new node. The new node is now officially the first element in the chain.

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

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

int search(struct Node *head, int key) {
    struct Node *curr = head;
    while (curr != NULL) {
        if (curr->data == key) return 1;
        curr = curr->next;
    }
    return 0;
}

int main() {
    struct Node n3 = {25, NULL}, n2 = {15, &n3}, n1 = {5, &n2};
    
    printf("Current List: 5 -> 15 -> 25 -> NULL\n");
    int found = search(&n1, 15);
    printf("Search Result for 15: %s\n", found ? "Found" : "Not Found");
    return 0;
}Code language: C++ (cpp)

Explanation:

• struct Node *curr = head: We create a temporary pointer curr so we don’t “lose” the start of the list.
• curr = curr->next: This is the engine of the search. It updates curr to hold the memory address stored in the next field of the current node, effectively jumping to the next block of data.
• while (curr != NULL): This ensures we don’t try to access memory at address 0 (NULL), which would cause a segmentation fault.

#include <stdio.h>

struct Stack { int items[5]; int top; };

void push(struct Stack *s, int val) {
    s->items[++(s->top)] = val;
}

int main() {
    struct Stack s = {{50}, 0};
    printf("Before Push: top index = %d, value = %d\n", s.top, s.items[s.top]);
    
    push(&s, 100);
    printf("After Push:  top index = %d, value = %d\n", s.top, s.items[s.top]);
    return 0;
}Code language: C++ (cpp)

Explanation:

• ++(s->top): This is a pre-increment. It changes the top value from 0 to 1 before it is used as an index.
• s->items[...] = val: The value 100 is placed into items[1].
• State Management: By keeping top inside the struct with the array, we ensure the index and the data are always passed together to any function, maintaining a clean organizational structure.

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

struct Node { int data; struct Node *next; };
struct Queue { struct Node *front, *rear; };

void enqueue(struct Queue *q, int val) {
    struct Node *temp = malloc(sizeof(struct Node));
    temp->data = val; temp->next = NULL;
    q->rear->next = temp;
    q->rear = temp;
}

int main() {
    struct Node *n1 = malloc(sizeof(struct Node));
    n1->data = 10; n1->next = NULL;
    struct Queue q = {n1, n1};

    printf("Before: Front = %d, Rear = %d\n", q.front->data, q.rear->data);
    enqueue(&q, 20);
    printf("After:  Front = %d, Rear = %d\n", q.front->data, q.rear->data);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• q->rear->next = temp: Since rear is pointing to the last node (10), we access that node’s next pointer and give it the address of our new node (20).
• q->rear = temp: We move the rear label to the new node. Now, front still points to 10, but rear points to 20.
• Result: This allows us to maintain a First-In-First-Out order, as we can always find the start via front and the end via rear instantly.

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

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

void deleteNode(struct Node **head, int key) {
    struct Node *temp = *head, *prev;
    while (temp != NULL && temp->data != key) {
        prev = temp; temp = temp->next;
    }
    prev->next = temp->next;
    free(temp);
}

int main() {
    struct Node *n3 = malloc(sizeof(struct Node)), *n2 = malloc(sizeof(struct Node)), *n1 = malloc(sizeof(struct Node));
    n1->data = 10; n1->next = n2; n2->data = 20; n2->next = n3; n3->data = 30; n3->next = NULL;

    printf("Before Deletion: 10 -> 20 -> 30\n");
    deleteNode(&n1, 20);
    printf("After Deletion:  10 -> %d\n", n1->next->data);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• while (temp != NULL && temp->data != key): This loop slides two pointers along the list. prev stays one step behind temp.
• prev->next = temp->next: This is the “bridging” step. By taking the address of the node after 20 and giving it to the node before 20, the list now flows from 10 directly to 30.
• free(temp): This is critical. It tells the operating system that the memory used by node 20 is now available for other uses, preventing a memory leak.

#include <stdio.h>

int binarySearch(int arr[], int n, int x) {
    int low = 0, high = n - 1;
    while (low <= high) {
        int mid = (low + high) / 2;
        printf("Searching between indices %d and %d\n", low, high);
        if (arr[mid] == x) return mid;
        if (arr[mid] < x) low = mid + 1;
        else high = mid - 1;
    }
    return -1;
}

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    printf("Array: 10, 20, 30, 40, 50 | Target: 40\n");
    int res = binarySearch(arr, 5, 40);
    printf("Found at index: %d\n", res);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• mid = (low + high) / 2: This finds the center of the current search bounds.
• low = mid + 1: If our target (40) is higher than our middle (30), we know the target cannot be in the lower half. We move our starting point to just past the middle.
• Logarithmic Time: Each print statement shows the range shrinking. This O(log n) efficiency is why binary search is used for massive databases.

#include <stdio.h>

void selectionSort(int arr[], int n) {
    int min_idx = 0;
    for (int j = 1; j < n; j++) 
        if (arr[j] < arr[min_idx]) min_idx = j;
    
    int temp = arr[min_idx];
    arr[min_idx] = arr[0];
    arr[0] = temp;
}

int main() {
    int arr[] = {64, 25, 12, 22, 11};
    printf("Original: 64, 25, 12, 22, 11\n");
    selectionSort(arr, 5);
    printf("After 1st swap: %d, %d, %d, %d, %d\n", arr[0], arr[1], arr[2], arr[3], arr[4]);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• Outer Search: The code scans every element to find that 11 is the absolute minimum.
• temp Swap: Standard three-step swap logic using a temporary variable to move 11 to the front and 64 to where 11 used to be.
• Result: After the first pass, the first element of the array is guaranteed to be in its final sorted position.

#include <stdio.h>

int main() {
    int num = 5;
    int pos = 1;
    printf("Initial Value: %d (Binary 0101)\n", num);
    
    num ^= (1 << pos);
    printf("After Toggling Bit 1: %d (Binary 0111)\n", num);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• 1 << pos: This takes the binary number 0001 and shifts the 1 to the left by 1 spot, resulting in 0010. This is our “mask.”
• num ^= mask: The XOR operator compares 0101 and 0010. Since the second bit is different in each, it becomes a 1.
• Decimal Change: In decimal, we changed the “2’s place” bit from 0 to 1, effectively adding 2 to the number (5 + 2 = 7).

#include <stdio.h>

void printBinary(int n) {
    for (int i = 7; i >= 0; i--) {
        int bit = (n >> i) & 1;
        printf("%d", bit);
    }
    printf("\n");
}

int main() {
    int num = 10;
    printf("Decimal: %d\n", num);
    printf("Binary (8-bit): ");
    printBinary(num);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• n >> i: This moves the bit we want to inspect all the way to the “ones” column.
• & 1: The AND operator with 1 acts like a filter. It ignores all other bits and only tells us if the current rightmost bit is a 1 or 0.
• Reversed Loop: We start the loop at 7 and go down to 0 because we read binary strings from left (most significant) to right (least significant).

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

struct Employee {
    char name[20];
    float salary;
};

void sortEmployees(struct Employee emp[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (emp[j].salary > emp[j + 1].salary) {
                struct Employee temp = emp[j];
                emp[j] = emp[j + 1];
                emp[j + 1] = temp;
            }
        }
    }
}

int main() {
    struct Employee staff[3] = {{"John", 50000}, {"Alice", 75000}, {"Bob", 45000}};

    printf("Before Sorting (Salary):\n");
    for(int i=0; i<3; i++) printf("%s: %.0f\n", staff[i].name, staff[i].salary);

    sortEmployees(staff, 3);

    printf("\nAfter Sorting (Salary):\n");
    for(int i=0; i<3; i++) printf("%s: %.0f\n", staff[i].name, staff[i].salary);
    
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• if (emp[j].salary > emp[j + 1].salary): This targets only the numerical value for comparison.
• struct Employee temp = emp[j]: By using the struct type for the temp variable, C automatically copies all internal fields (both name and salary) during the swap.
• Bubble Sort Logic: The nested loops ensure that the “heaviest” salary floats to the end of the array in each pass.

#include <stdio.h>
#include <limits.h>

int main() {
    int arr[5] = {12, 35, 1, 10, 34};
    int max = INT_MIN, secondMax = INT_MIN;

    printf("Array: 12, 35, 1, 10, 34\n");

    for (int i = 0; i < 5; i++) {
        if (arr[i] > max) {
            secondMax = max;
            max = arr[i];
        } else if (arr[i] > secondMax && arr[i] != max) {
            secondMax = arr[i];
        }
    }

    printf("Largest: %d | Second Largest: %d\n", max, secondMax);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• secondMax = max: Before we replace the “king” (max), we demote the current king to the “vice-king” (secondMax).
• arr[i] != max: This check ensures that if the largest number appears twice in the array, the secondMax still looks for a value strictly smaller than the absolute max.
• INT_MIN: This macro from <limits.h> represents the smallest possible integer, ensuring our comparisons work even if the array contains negative numbers.

#include <stdio.h>

int main() {
    int a[] = {1, 3, 5}, b[] = {2, 4, 6};
    int res[6], i = 0, j = 0, k = 0;

    printf("Array 1: 1, 3, 5 | Array 2: 2, 4, 6\n");

    while (i < 3 && j < 3) {
        if (a[i] < b[j]) res[k++] = a[i++];
        else res[k++] = b[j++];
    }

    while (i < 3) res[k++] = a[i++]; // Copy leftovers
    while (j < 3) res[k++] = b[j++];

    printf("Merged: ");
    for (int x = 0; x < 6; x++) printf("%d ", res[x]);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• while (i < 3 && j < 3): This loop runs until one of the two source arrays is completely exhausted.
• res[k++] = a[i++]: This is a compact way to assign the value and then increment both the result index and the source index.
• Leftover Loops: The final two while loops ensure that if one array (like {1, 2}) finishes but the other (like {10, 11, 12}) still has elements, those remaining elements are appended to the end.

#include <stdio.h>

int main() {
    int arr[] = {1, 2, 2, 3, 4, 4, 5};
    int n = 7, j = 0;

    printf("Original: 1, 2, 2, 3, 4, 4, 5\n");

    for (int i = 0; i < n - 1; i++) {
        if (arr[i] != arr[i + 1]) {
            arr[j++] = arr[i];
        }
    }
    arr[j++] = arr[n - 1]; // Handle the last element

    printf("Unique:   ");
    for (int i = 0; i < j; i++) printf("%d ", arr[i]);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• In-place logic: We are using the same arr to store the unique values, effectively overwriting the duplicates as we find them.
• arr[i] != arr[i + 1]: Since the array is sorted, duplicates are guaranteed to be neighbors. If the next element is different, the current one is the last occurrence of that specific value.
• Final Assignment: The loop stops before the last element, so we manually add arr[n-1] to the unique list.

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

int main() {
    char str[] = "success";
    int freq[256] = {0}, maxCount = 0;
    char result;

    for (int i = 0; str[i] != '\0'; i++) {
        freq[(unsigned char)str[i]]++;
    }

    for (int i = 0; i < 256; i++) {
        if (freq[i] > maxCount) {
            maxCount = freq[i];
            result = (char)i;
        }
    }

    printf("String: %s\n", str);
    printf("Most Frequent: '%c' (appears %d times)\n", result, maxCount);
    return 0;
}Code language: C++ (cpp)

Explanation:

• freq[(unsigned char)str[i]]++: We cast to unsigned char to ensure characters outside the standard 127 ASCII range (like accented letters) don’t produce negative indices.
• Two-Step Process: First, we build the “map” of counts. Second, we scan that map to find the “peak.” This is a highly efficient $O(n)$ solution.

#include <stdio.h>

int fibonacci(int n) {
    if (n <= 1) return n; // Base case
    return fibonacci(n - 1) + fibonacci(n - 2); // Recursive call
}

int main() {
    int terms = 10;
    printf("Fibonacci Series (10 terms): ");
    for (int i = 0; i < terms; i++) {
        printf("%d ", fibonacci(i));
    }
    printf("\n");
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• Base Case (n <= 1): Without this, the function would call itself infinitely until the program crashed.
• Recursive Step: The function calculates a value by asking itself for the two previous values. This creates a “tree” of calls that eventually reaches the base cases.
• Cost of Recursion: While elegant, this specific recursive method is actually slow for large numbers (O(2^n)) because it recalculates the same values many times. It serves as a great lesson on when to use recursion vs. iteration.

#include <stdio.h>

int main() {
    int a1[] = {1, 2, 3, 4, 5}, a2[] = {3, 4, 5, 6, 7};
    int intersect[5], k = 0;

    printf("Array 1: {1, 2, 3, 4, 5}\nArray 2: {3, 4, 5, 6, 7}\n");

    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            if (a1[i] == a2[j]) {
                intersect[k++] = a1[i];
                break; // Move to next element in a1
            }
        }
    }

    printf("Intersection: ");
    for (int i = 0; i < k; i++) printf("%d ", intersect[i]);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• Nested Loops: The outer loop picks a number from a1, and the inner loop scans a2 to see if that number exists there.
• break Statement: Once a match is found, we don’t need to keep checking the rest of a2 for that specific number, saving processing time.
• Result Storage: The k variable acts as a cursor for the intersect array, only incrementing when a common element is actually found.

#include <stdio.h>

int main() {
    int arr[] = {0, 1, 0, 3, 12};
    int n = 5, count = 0; // count tracks position for non-zero elements

    printf("Original: {0, 1, 0, 3, 12}\n");

    for (int i = 0; i < n; i++) {
        if (arr[i] != 0) {
            arr[count++] = arr[i];
        }
    }

    // Fill the rest with zeros
    while (count < n) {
        arr[count++] = 0;
    }

    printf("Modified: ");
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• First Pass: The loop effectively “squeezes” all non-zero numbers to the front of the array in their original order.
• count++: The count variable always points to where the next non-zero number should go.
• Final Padding: The while loop starts from wherever count left off and fills the rest of the array slots with zero.

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

void sortStrings(char *arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (strcmp(arr[j], arr[j + 1]) > 0) {
                char *temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    char *fruits[] = {"Zebra", "Apple", "Mango"};

    printf("Before: Zebra, Apple, Mango\n");
    sortStrings(fruits, 3);
    
    printf("After:  %s, %s, %s\n", fruits[0], fruits[1], fruits[2]);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• char *temp: Notice we are swapping char* (pointers), not the actual characters. We are just rearranging the “labels” pointing to the words.
• strcmp: This function compares ASCII values character by character. “Apple” is less than “Zebra” because ‘A’ (65) is less than ‘Z’ (90).
• Efficiency: Swapping pointers takes the same amount of time regardless of how long the strings are (e.g., swapping pointers to “A” vs “Antidisestablishmentarianism”).

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

int main() {
    char str[] = "I am learning Programming";
    int maxLen = 0, currLen = 0, startIdx = 0, maxStart = 0;

    for (int i = 0; i <= strlen(str); i++) {
        if (isspace(str[i]) || str[i] == '\0') {
            if (currLen > maxLen) {
                maxLen = currLen;
                maxStart = startIdx;
            }
            currLen = 0;
            startIdx = i + 1;
        } else {
            currLen++;
        }
    }

    printf("Sentence: %s\n", str);
    printf("Longest Word: ");
    for (int i = maxStart; i < maxStart + maxLen; i++) printf("%c", str[i]);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• isspace or \0: This identifies the boundary of a word. When a boundary is hit, the program evaluates the word just finished.
• maxStart = startIdx: We store the index where the longest word began so we can print it later.
• currLen: This resets to 0 every time a space is encountered, beginning the count for a new word.

#include <stdio.h>

int main() {
    int rows = 5, arr[5][5];

    printf("Pascal's Triangle (5 rows):\n");

    for (int i = 0; i < rows; i++) {
        // Print spaces for triangle shape
        for (int s = 0; s < rows - i; s++) printf(" ");

        for (int j = 0; j <= i; j++) {
            if (j == 0 || j == i)
                arr[i][j] = 1;
            else
                arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
            
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• arr[i][j] = arr[i-1][j-1] + arr[i-1][j]: This is the core Pascal logic. It looks at the row above (i-1) and adds the elements from the left and right positions.
• Inner Loop j <= i: In row 0, we print 1 item; in row 1, we print 2 items, and so on. This creates the triangular structure.
• Formatting: The rows - i loop prints leading spaces so the output looks like a centered pyramid rather than a left-aligned block.

#include <stdio.h>

int main() {
    int rows = 5;
    printf("Generating Hollow Triangle (Height %d):\n", rows);

    for (int i = 1; i <= rows; i++) {
        // Print leading spaces for alignment
        for (int j = i; j < rows; j++) printf(" ");

        for (int j = 1; j <= (2 * i - 1); j++) {
            // Print star only at boundaries or the last row
            if (j == 1 || j == (2 * i - 1) || i == rows) {
                printf("*");
            } else {
                printf(" ");
            }
        }
        printf("\n");
    }
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• j == 1 || j == (2 * i - 1): This checks if the current position is the very first or very last star of the current row.
• i == rows: This condition ensures that the bottom row is printed as a solid line of stars.
• 2 * i - 1: This formula determines the total width of the triangle at any given row $i$ to keep it centered.

#include <stdio.h>

int main() {
    int n = 5; // Half of diamond height
    printf("Generating Solid Diamond (Max Width %d):\n", 2*n-1);

    // Top half
    for (int i = 1; i <= n; i++) {
        for (int j = i; j < n; j++) printf(" ");
        for (int j = 1; j <= (2 * i - 1); j++) printf("*");
        printf("\n");
    }
    // Bottom half
    for (int i = n - 1; i >= 1; i--) {
        for (int j = n; j > i; j--) printf(" ");
        for (int j = 1; j <= (2 * i - 1); j++) printf("*");
        printf("\n");
    }
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• Two Main Loops: The first for loop handles the upper triangle. The second for loop is mirrored but starts from n-1 to avoid repeating the center line.
• 2 * i - 1: This ensures an odd number of stars in every row, which is required for a centered, symmetrical diamond.

#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a; *a = *b; *b = temp;
}

int main() {
    int arr[] = {-1, 2, -3, 4, 5, 6, -7, 8, 9};
    int n = 9;

    printf("Original: -1, 2, -3, 4, 5, 6, -7, 8, 9\n");

    for (int i = 0; i < n; i++) {
        // If index is even, we want a positive number
        if (i % 2 == 0 && arr[i] < 0) {
            for (int j = i + 1; j < n; j++) {
                if (arr[j] >= 0) { swap(&arr[i], &arr[j]); break; }
            }
        }
        // If index is odd, we want a negative number
        else if (i % 2 != 0 && arr[i] >= 0) {
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < 0) { swap(&arr[i], &arr[j]); break; }
            }
        }
    }

    printf("Rearranged: ");
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• i % 2 == 0: We use the modulo operator to determine if the current “slot” should be positive or negative.
• Nested Search: When a “wrong” sign is found at index i, the inner loop searches the rest of the array for a “correct” sign to swap in.
• In-Place: No extra memory is used; we only shift existing data within the array bounds.

#include <stdio.h>
#include <ctype.h>

int main() {
    FILE *fptr = fopen("stats.txt", "r");
    if (!fptr) return 1;

    int chars = 0, words = 0, lines = 0, in_word = 0;
    char ch;

    while ((ch = fgetc(fptr)) != EOF) {
        chars++;
        if (ch == '\n') lines++;
        
        if (isspace(ch)) {
            in_word = 0;
        } else if (in_word == 0) {
            in_word = 1;
            words++;
        }
    }

    printf("Characters: %d | Words: %d | Lines: %d\n", chars, words, lines + 1);
    fclose(fptr);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• in_word Flag: This prevents double-counting words when there are multiple spaces. We only increment words when we hit the start of a word.
• lines + 1: Since the last line might not end with a \n, we add 1 to the final line count to account for the content on the final line.

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

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

void findMiddle(struct Node *head) {
    struct Node *slow = head, *fast = head;

    while (fast != NULL && fast->next != NULL) {
        fast = fast->next->next; // Move 2 steps
        slow = slow->next;       // Move 1 step
    }
    printf("Middle Element: %d\n", slow->data);
}

int main() {
    struct Node *n5 = malloc(sizeof(struct Node)), *n4 = malloc(sizeof(struct Node)), 
                *n3 = malloc(sizeof(struct Node)), *n2 = malloc(sizeof(struct Node)), 
                *n1 = malloc(sizeof(struct Node));

    n1->data = 1; n1->next = n2; n2->data = 2; n2->next = n3; 
    n3->data = 3; n3->next = n4; n4->data = 4; n4->next = n5; 
    n5->data = 5; n5->next = NULL;

    printf("List: 1 -> 2 -> 3 -> 4 -> 5\n");
    findMiddle(n1);
    return 0;
}Code language: C++ (cpp)

Explanation of Solution:

• fast = fast->next->next: Because the fast pointer moves double the speed, it reaches the “finish line” twice as fast as the slow pointer.
• Relative Distance: Because the finish line for fast is the end of the list ($L$), the slow pointer will have covered exactly $L/2$ distance.
• Loop Condition: We check both fast and fast->next to ensure we don’t crash when jumping two nodes at a time in both even and odd-lengthed lists.