C Programming Arrays Exercises

#include <stdio.h>

int main() {
    int size;
    // 1. Get array size
    printf("Enter the number of elements (size of array): ");
    scanf("%d", &size);

    // 2. Declare the array (using VLA feature)
    int arr[size];
    int i;

    // 3. Read elements
    printf("Enter %d integers:\n", size);
    for (i = 0; i < size; i++) {
        printf("Element %d: ", i + 1);
        scanf("%d", &arr[i]);
    }

    // 4. Print elements
    printf("\nElements stored in the array are: ");
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

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

Explanation:

• The program starts by taking the desired size of the array from the user. An integer array arr is then declared using this size.
• The first for loop iterates from i=0 up to i<size. In each iteration, scanf("%d", &arr[i]); reads an integer from the standard input and stores it at the current index i of the array.
• The second for loop is identical in structure but uses printf() to retrieve and display the value stored at arr[i].

#include <stdio.h>

int main() {
    int size = 5;
    int arr[5] = {10, 20, 30, 40, 50};
    int sum = 0;
    int i;
    float average;

    // 1. Calculate sum
    for (i = 0; i < size; i++) {
        sum += arr[i]; // sum = sum + arr[i]
    }

    // 2. Calculate average using type casting
    average = (float)sum / size;

    printf("\nSum of array elements: %d\n", sum);
    printf("Average of array elements: %.2f\n", average);

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

Explanation:

• The variable sum is initialized to 0 to ensure an accurate starting point for calculation.
• The for loop traverses the array, and the line sum += arr[i]; adds the value of the current element to the running total.
• To compute the average, we divide sum by size. The critical step is (float)sum / size;, which performs explicit type casting. This converts the integer sum into a floating-point number before division, ensuring the division result is a precise floating-point number, which is then stored in the float variable average.

#include <stdio.h>

int main() {
    int size = 6;
    int arr[6] = {55, 12, 89, 4, 30, 77};
    int i;
    int max, min;

    // Initialize max and min with the first element of the array
    max = arr[0];
    min = arr[0];

    // Iterate from the second element (index 1)
    for (i = 1; i < size; i++) {
        // Check for Maximum
        if (arr[i] > max) {
            max = arr[i];
        }

        // Check for Minimum
        if (arr[i] < min) {
            min = arr[i];
        }
    }

    printf("Array elements: 55, 12, 89, 4, 30, 77\n");
    printf("Maximum element in the array: %d\n", max);
    printf("Minimum element in the array: %d\n", min);

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

Explanation:

The program initializes max and min to arr[0]. This guarantees the starting values are within the range of the array’s elements. The for loop then begins at index i=1. Inside the loop, two independent if statements perform the comparisons:

1. If the current element arr[i] is greater than the current max, max is updated.
2. If the current element arr[i] is less than the current min, min is updated.

By the end of the single traversal, max holds the largest value and min holds the smallest.

#include <stdio.h>

int main() {
    int size = 8;
    int arr[8] = {1, 4, 7, 12, 15, 20, 3, 10};
    int even_count = 0;
    int odd_count = 0;
    int i;

    printf("Array: 1, 4, 7, 12, 15, 20, 3, 10\n");

    for (i = 0; i < size; i++) {
        // Check if the remainder when divided by 2 is 0 (Even)
        if (arr[i] % 2 == 0) {
            even_count++;
        }
        // If the remainder is not 0 (Odd)
        else {
            odd_count++;
        }
    }

    printf("Total even elements: %d\n", even_count);
    printf("Total odd elements: %d\n", odd_count);

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

Explanation:

The core logic relies on the modulo operator (%).

• If the remainder is 0 (i.e., arr[i] % 2 == 0), the number is perfectly divisible by 2 and is counted as even.
• If the remainder is 1 (or any non-0 value in the case of negative numbers, though here we assume positive inputs), the number is not perfectly divisible by 2 and is counted as odd.

The program uses a single for loop to check every element once, making the process efficient.

#include <stdio.h>

int main() {
    int size = 7;
    int arr[7] = {10, 20, 30, 40, 50, 60, 70};
    int temp; // Temporary variable for swapping
    int i;

    printf("Original array: ");
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // Loop only up to size / 2
    for (i = 0; i < size / 2; i++) {
        // Swap arr[i] with arr[size - 1 - i]
        // 1. Store the value of the element from the end
        temp = arr[size - 1 - i];
        
        // 2. Replace the element from the end with the element from the start
        arr[size - 1 - i] = arr[i];
        
        // 3. Replace the element from the start with the stored value (original end element)
        arr[i] = temp;
    }

    printf("Reversed array: ");
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

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

Explanation:

The key to in-place reversal is the swapping mechanism and limiting the loop to half the array size.

1. Index Pair: For an array of size, the index i (from the start) is paired with the index size−1−i (from the end).
2. Swapping: A temporary variable (temp) is mandatory to hold one of the values during the swap operation.
   • The value at the end index (arr[size - 1 - i]) is stored in temp.
   • The value at the start index (arr[i]) is copied to the end index.
   • The value saved in temp (the original end value) is copied to the start index.
3. Loop Limit: The loop runs only up to size / 2 (e.g., for size 7, i runs from 0 to 2, performing 3 swaps: (0,6), (1,5), (2,4)). This prevents the elements from being swapped twice, which would return them to their original order.

#include <stdio.h>

int main() {
    int size = 5;
    int source_arr[5] = {1, 2, 3, 4, 5};
    int dest_arr[5]; // Destination array
    int i;

    printf("Source array elements: ");
    for (i = 0; i < size; i++) {
        printf("%d ", source_arr[i]);
    }
    printf("\n");

    // Loop to copy elements
    for (i = 0; i < size; i++) {
        dest_arr[i] = source_arr[i];
    }

    printf("Destination array elements (after copy): ");
    for (i = 0; i < size; i++) {
        printf("%d ", dest_arr[i]);
    }
    printf("\n");

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

Explanation:

This is the most straightforward array manipulation technique.

• The program uses a for loop that iterates from the first index (0) to the last index (size−1).
• Inside the loop, the assignment statement dest_arr[i] = source_arr[i]; explicitly copies the value stored at index i of the source array into the same index i of the destination array. This ensures an exact, element-by-element replication of the source array’s content.

#include <stdio.h>

int main() {
    int size = 5;
    // Initial size is 5, capacity for 6
    int arr[6] = {10, 20, 30, 40, 50}; 
    int element = 35;
    int position = 4; // Position 4 (index 3)
    int i;

    printf("Initial array (size %d): 10, 20, 30, 40, 50\n", size);

    // Position is 1-based, convert to 0-based index
    int index = position - 1; 

    if (index < 0 || index > size) {
        printf("Invalid position for insertion.\n");
        return 1;
    }
    
    // 1. Shift elements one position to the right (starting from the end)
    for (i = size; i > index; i--) {
        arr[i] = arr[i - 1];
    }

    // 2. Insert the new element
    arr[index] = element;

    // 3. Increment the size of the array
    size++;

    printf("Array after inserting %d at position %d (index %d):\n", element, position, index);
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

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

Explanation:

Array insertion requires two main steps:

1. Shifting (The Critical Step): The loop for (i = size; i > index; i--) starts from the new logical end of the array (size) and moves backward until it reaches the insertion point (index). Inside, arr[i] = arr[i - 1]; copies the element at the preceding index (i-1) to the current index (i). This creates a duplicate of the element at index, effectively making space.
2. Insertion: Once space is made, the new element is placed at arr[index] = element;.
3. Size Update: Finally, the logical size of the array (size) is incremented to reflect the new element count. (Note: Arrays in C have a fixed physical size; this process is only possible if the array was declared with extra capacity).

#include <stdio.h>

int main() {
    int size = 6;
    int arr[6] = {10, 20, 30, 40, 50, 60}; 
    int position = 3; // Position 3 (index 2)
    int i;

    printf("Initial array (size %d): 10, 20, 30, 40, 50, 60\n", size);

    // Position is 1-based, convert to 0-based index
    int index = position - 1; 

    if (index < 0 || index >= size) {
        printf("Invalid position for deletion.\n");
        return 1;
    }
    
    // 1. Shift elements one position to the left (starting from the deletion index)
    // This overwrites the element at 'index'
    for (i = index; i < size - 1; i++) {
        arr[i] = arr[i + 1];
    }

    // 2. Decrement the size of the array
    size--;

    printf("Array after deleting element at position %d (index %d):\n", position, index);
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

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

Explanation:

Array deletion is essentially the reverse of insertion:

1. Shifting (The Critical Step): The loop for (i = index; i < size - 1; i++) starts at the index where the deletion is to occur (index). Inside the loop, arr[i] = arr[i + 1]; copies the element at the next index (i+1) into the current index (i). This action immediately overwrites the element being deleted and shifts all subsequent elements to the left.
2. Size Update: The logical size of the array (size) is decremented. Although the array element at the last physical position remains (it’s a duplicate of the previous element), it is now outside the logical bounds of the array and will not be printed in the output loop.

#include <stdio.h>
#include <limits.h> // For INT_MIN and INT_MAX

int main() {
    int size = 7;
    int arr[7] = {10, 50, 20, 80, 40, 90, 30};
    int i;
    
    // Initialize max1 and max2 to the smallest possible integer value
    int max1 = INT_MIN;
    int max2 = INT_MIN;
    
    // Initialize min1 and min2 to the largest possible integer value
    int min1 = INT_MAX;
    int min2 = INT_MAX;

    printf("Array elements: 10, 50, 20, 80, 40, 90, 30\n");

    for (i = 0; i < size; i++) {
        // Finding Max1 and Max2
        if (arr[i] > max1) {
            max2 = max1; // Current max1 becomes the second max
            max1 = arr[i]; // Current element becomes the new max1
        } else if (arr[i] > max2 && arr[i] != max1) {
            max2 = arr[i]; // Update max2 if element is between max1 and max2
        }

        // Finding Min1 and Min2
        if (arr[i] < min1) {
            min2 = min1; // Current min1 becomes the second min
            min1 = arr[i]; // Current element becomes the new min1
        } else if (arr[i] < min2 && arr[i] != min1) {
            min2 = arr[i]; // Update min2 if element is between min1 and min2
        }
    }

    printf("First Largest (Max1): %d\n", max1);
    printf("Second Largest (Max2): %d\n", max2);
    printf("First Smallest (Min1): %d\n", min1);
    printf("Second Smallest (Min2): %d\n", min2);

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

Explanation:

This solution uses a single loop to find both pairs simultaneously.

1. Initialization: max1 and max2 are initialized to INT_MIN (the smallest possible integer) to ensure any array element will be larger. Conversely, min1 and min2 are initialized to INT_MAX (the largest possible integer).
2. Max Logic:
   • If arr[i] is greater than max1, it means we found a new largest element. We promote the old max1 to max2, and set arr[i] as the new max1.
   • If arr[i] is not the largest (max1), but it is greater than max2 and not equal to max1 (handling duplicates), then it is the new second largest (max2).
3. Min Logic: The logic for min1 and min2 follows the same structure but with reversed comparison operators (<). This single-pass method is more efficient than sorting the entire array first.

#include <stdio.h>

int main() {
    int size = 9;
    int arr[9] = {15, -5, 20, 0, -10, 30, -25, 5, 0};
    long long pos_sum = 0; // Use long long for potential large sums
    long long neg_sum = 0;
    int i;

    printf("Array elements: 15, -5, 20, 0, -10, 30, -25, 5, 0\n");

    for (i = 0; i < size; i++) {
        if (arr[i] > 0) {
            // Positive numbers
            pos_sum += arr[i];
        } else if (arr[i] < 0) {
            // Negative numbers
            neg_sum += arr[i];
        }
        // If arr[i] == 0, it is ignored
    }

    printf("Sum of all positive numbers: %lld\n", pos_sum);
    printf("Sum of all negative numbers: %lld\n", neg_sum);

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

Explanation:

This program uses a conditional approach within a single traversal loop.

1. Initialization: Two separate variables, pos_sum and neg_sum, are initialized to 0. We use long long for the sums to safely handle large possible totals.
2. Conditional Check:
   • The if (arr[i] > 0) block handles positive numbers, adding them to pos_sum.
   • The else if (arr[i] < 0) block handles negative numbers, adding them to neg_sum. Note that when adding a negative number, the sum effectively decreases.
3. Zero Handling: Since there is no else block to catch arr[i] == 0, any zero elements are naturally skipped and do not affect either pos_sum or neg_sum.

#include <stdio.h>

int linear_search(int arr[], int size, int target) {
    int i;
    for (i = 0; i < size; i++) {
        // Check if the current element matches the target
        if (arr[i] == target) {
            return i; // Return the index immediately upon finding the element
        }
    }
    return -1; // Return -1 if the loop completes without finding the target
}

int main() {
    int arr[] = {10, 50, 30, 70, 80, 20, 90, 40};
    int size = sizeof(arr) / sizeof(arr[0]);
    int search_element = 70;
    int index;

    index = linear_search(arr, size, search_element);

    if (index != -1) {
        printf("Element %d found at index %d.\n", search_element, index);
    } else {
        printf("Element %d not found in the array.\n", search_element);
    }

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

Explanation:

• Linear search is the simplest search algorithm. It sequentially checks every element in the array until a match is found.
• The linear_search function iterates using a for loop. If arr[i] equals the target, the loop is terminated early by returning the index i. If the loop completes without finding a match, it means the element is not present, and the function returns −1 (a conventional indicator for “not found”).
• The time complexity of this algorithm is O(n).

#include <stdio.h>

int count_frequency(int arr[], int size, int target) {
    int i;
    int count = 0;

    for (i = 0; i < size; i++) {
        if (arr[i] == target) {
            count++;
        }
    }
    return count;
}

int main() {
    int arr[] = {1, 5, 2, 8, 5, 1, 5, 9};
    int size = sizeof(arr) / sizeof(arr[0]);
    int search_element = 5;
    int freq;

    freq = count_frequency(arr, size, search_element);

    printf("Element %d appears %d times in the array.\n", search_element, freq);
    
    return 0;
}Code language: C++ (cpp)

Explanation:

This is another linear scan problem with O(n) complexity.

The function count_frequency iterates through the array element by element. It uses a simple equality check (arr[i] == target). Every time a match is found, the count variable is incremented. The final value of count represents the total occurrences of the target element.

#include <stdio.h>

int binary_search(int arr[], int size, int target) {
    int low = 0;
    int high = size - 1;
    int mid;

    while (low <= high) {
        mid = low + (high - low) / 2; // Prevent integer overflow for very large arrays

        if (arr[mid] == target) {
            return mid; // Element found
        } else if (arr[mid] < target) {
            low = mid + 1; // Search in the right half
        } else {
            high = mid - 1; // Search in the left half
        }
    }
    return -1; // Element not found
}

int main() {
    // Binary search requires a SORTED array
    int arr[] = {10, 20, 30, 40, 50, 60, 70, 80};
    int size = sizeof(arr) / sizeof(arr[0]);
    int search_element = 50;
    int index;

    index = binary_search(arr, size, search_element);

    if (index != -1) {
        printf("Element %d found at index %d.\n", search_element, index);
    } else {
        printf("Element %d not found.\n", search_element);
    }

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

Explanation:

Binary search operates on the principle of divide and conquer. It uses a while (low <= high) loop to continue searching as long as the segment is valid. In each step, it calculates the midpoint mid.

• If the element at mid is the target, the index is returned.
• If the target is larger, the search space is narrowed to the right half by setting low = mid + 1.
• If the target is smaller, the search space is narrowed to the left half by setting high = mid - 1. Because it eliminates half of the remaining elements in each step, its time complexity is O(logn), making it vastly superior to linear search for large, sorted datasets.

#include <stdio.h>

int main() {
    int arr[] = {5, 2, 8, 5, 1, 2, 9, 8, 4};
    int n = sizeof(arr) / sizeof(arr[0]);
    int i, j, is_unique;

    printf("Array: ");
    for (i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\nUnique elements are: ");

    for (i = 0; i < n; i++) {
        is_unique = 1; // Assume the element is unique

        // Check the element against all other elements
        for (j = 0; j < n; j++) {
            // Check for duplicates, but skip comparing the element with itself (i != j)
            if (i != j && arr[i] == arr[j]) {
                is_unique = 0; // Found a duplicate, so it is NOT unique
                break;         // No need to check further for this element
            }
        }

        // If the flag is still 1, no duplicate was found
        if (is_unique == 1) {
            printf("%d ", arr[i]);
        }
    }
    printf("\n");
    return 0;
}Code language: C++ (cpp)

Explanation:

• The program iterates through the array using the outer loop (i). For each element arr[i], a flag is_unique is set to 1 (true).
• The inner loop (j) checks if arr[i] matches any other element arr[j]. The condition i != j ensures an element isn’t compared to itself. If a match is found, is_unique is set to 0 (false), and the inner loop breaks.
• If, after the inner loop completes, is_unique remains 1, the element arr[i] is printed as it has no duplicates, meaning it appeared exactly once.

#include <stdio.h>

int main() {
    int arrA[] = {10, 20, 30};
    int nA = sizeof(arrA) / sizeof(arrA[0]);

    int arrB[] = {40, 50, 60, 70};
    int nB = sizeof(arrB) / sizeof(arrB[0]);

    int nC = nA + nB; // Total size of the merged array
    int arrC[nC];
    int i;

    // 1. Copy elements of arrA into arrC
    for (i = 0; i < nA; i++) {
        arrC[i] = arrA[i];
    }

    // 2. Copy elements of arrB into arrC, starting at index nA
    // The index for arrC is (nA + i)
    for (i = 0; i < nB; i++) {
        arrC[nA + i] = arrB[i];
    }

    // 3. Print the merged array arrC
    printf("Merged array C: ");
    for (i = 0; i < nC; i++) {
        printf("%d ", arrC[i]);
    }
    printf("\n");
    return 0;
}Code language: C++ (cpp)

Explanation:

• The program first determines the size of the third array, nC = nA + nB.
• The first for loop copies the elements of arrA into the first nA positions of arrC.
• The second for loop handles the merging of arrB.
• Crucially, to place the elements of arrB after those of arrA, the destination index in arrC is calculated as nA + i.
• As i goes from 0 to nB-1, the destination indices are nA, nA+1, …, nC-1, successfully appending the second array.

#include <stdio.h>

int is_array_palindrome(int arr[], int n) {
    int start = 0;
    int end = n - 1;

    while (start < end) {
        if (arr[start] != arr[end]) {
            return 0; // Not a palindrome
        }
        start++;
        end--;
    }
    return 1; // It is a palindrome
}

int main() {
    int arr1[] = {1, 2, 3, 2, 1}; // Palindrome
    int n1 = sizeof(arr1) / sizeof(arr1[0]);

    int arr2[] = {1, 2, 3, 4, 5}; // Not a palindrome
    int n2 = sizeof(arr2) / sizeof(arr2[0]);

    if (is_array_palindrome(arr1, n1)) {
        printf("Array 1 is a palindrome.\n");
    } else {
        printf("Array 1 is NOT a palindrome.\n");
    }

    if (is_array_palindrome(arr2, n2)) {
        printf("Array 2 is a palindrome.\n");
    } else {
        printf("Array 2 is NOT a palindrome.\n");
    }

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

Explanation:

• The function is_array_palindrome uses the two-pointer approach. Pointers start and end are initialized to the first and last indices, respectively. The while (start < end) loop continues checking pairs of elements from the outside inward.
• If any pair arr[start] and arr[end] are unequal, the function immediately returns 0 (false). If the loop completes without finding any unequal pairs (meaning start has met or passed end), the array is a palindrome, and the function returns 1 (true).

#include <stdio.h>

void bubble_sort(int arr[], int size) {
    int i, j, temp;
    int swapped;

    // Outer loop for passes (size - 1 passes)
    for (i = 0; i < size - 1; i++) {
        swapped = 0; // Flag to detect if any swap occurred (optimization)
        
        // Inner loop for comparison and swapping
        // Iterates up to the last unsorted element
        for (j = 0; j < size - 1 - i; j++) {
            // Compare adjacent elements for ascending order
            if (arr[j] > arr[j + 1]) {
                // Swap arr[j] and arr[j+1]
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = 1;
            }
        }
        
        // If no two elements were swapped in inner loop, array is sorted
        if (swapped == 0) {
            break;
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int size = sizeof(arr) / sizeof(arr[0]);
    int i;

    bubble_sort(arr, size);

    printf("Array sorted in ascending order: ");
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

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

Explanation:

Bubble sort compares and swaps adjacent elements.

• The outer loop ensures the process repeats until the entire array is sorted. The inner loop’s condition (arr[j] > arr[j + 1]) checks for ascending order. If the condition is true, the elements are swapped using a temporary variable temp.
• The complexity is O(n2) in the worst and average cases. The swapped flag provides a slight optimization: if a pass completes with no swaps, the array is already sorted, and the outer loop can break early.

#include <stdio.h>
#include <stdbool.h> // Include for using bool type (optional, can use int/0/1)

// Returns 1 (true) if sorted, 0 (false) otherwise
int is_sorted(int arr[], int size) {
    int i;
    
    // Only need to check up to the second-to-last element (size - 2)
    for (i = 0; i < size - 1; i++) {
        // If the current element is greater than the next element, it is NOT sorted
        if (arr[i] > arr[i + 1]) {
            return 0; // Not sorted
        }
    }
    return 1; // Loop completed, no violation found
}

int main() {
    int sorted_arr[] = {10, 20, 30, 40, 50};
    int unsorted_arr[] = {10, 30, 20, 40, 50};
    int size = 5;

    printf("Array 1 is sorted: %s\n", is_sorted(sorted_arr, size) ? "True" : "False");
    printf("Array 2 is sorted: %s\n", is_sorted(unsorted_arr, size) ? "True" : "False");

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

Explanation:

• This function is highly efficient with O(n) time complexity. It only requires a single pass through the array.
• The loop iterates from i=0 up to i<size−1. This ensures that when we check arr[i+1], we do not go out of bounds. The condition arr[i] > arr[i + 1] is the definition of unsorted (in ascending order). As soon as this condition is met, the function immediately terminates and returns 0.
• If the entire loop finishes, it means every adjacent pair was correctly ordered, and the function returns 1

#include <stdio.h>

void selection_sort_descending(int arr[], int size) {
    int i, j, max_idx, temp;

    // Outer loop runs from 0 up to size - 2
    for (i = 0; i < size - 1; i++) {
        // Assume the first element of the unsorted subarray is the maximum
        max_idx = i;
        
        // Inner loop finds the true maximum element in the remaining unsorted array
        for (j = i + 1; j < size; j++) {
            // Find the index of the maximum element for descending order
            if (arr[j] > arr[max_idx]) {
                max_idx = j;
            }
        }

        // Swap the found maximum element with the element at position i
        if (max_idx != i) {
            temp = arr[i];
            arr[i] = arr[max_idx];
            arr[max_idx] = temp;
        }
    }
}

int main() {
    int arr[] = {64, 25, 12, 22, 11};
    int size = sizeof(arr) / sizeof(arr[0]);
    int i;

    selection_sort_descending(arr, size);

    printf("Array sorted in descending order: ");
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

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

Explanation:

Selection sort is characterized by minimizing the number of swaps (one per pass). For descending order, the goal of each pass is to find the largest remaining element.

1. The outer loop controls the boundary between the sorted and unsorted parts.
2. The inner loop finds the index (max_idx) of the largest element in the unsorted segment.
3. After the inner loop finishes, the largest element (at max_idx) is swapped with the element at the beginning of the unsorted segment (arr[i]). This places the maximum value in its correct descending position. Its time complexity is always O(n2) because it always performs the full nested loop comparisons, regardless of the initial order.

#include <stdio.h>

void insertion_sort(int arr[], int size) {
    int i, key, j;
    
    // Outer loop iterates from the second element (start of unsorted section)
    for (i = 1; i < size; i++) {
        key = arr[i]; // The element to be inserted into the sorted sub-array
        j = i - 1;    // Start comparison from the last element of the sorted sub-array

        // Inner loop: Move elements of the sorted sub-array that are greater than key, 
        // to one position ahead of their current position
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        
        // Place the key element in its correct position
        arr[j + 1] = key;
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6};
    int size = sizeof(arr) / sizeof(arr[0]);
    int i;

    insertion_sort(arr, size);

    printf("Array sorted using Insertion Sort: ");
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

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

Explanation:

Insertion sort excels when the array is nearly sorted.

1. The outer loop (i) iterates through the unsorted elements, picking the key.
2. The key is compared backward (j) against the elements in the already sorted subarray.
3. If an element arr[j] is larger than the key, it is shifted right (arr[j + 1] = arr[j]).
4. This shifting continues until an element smaller than or equal to the key is found, or the beginning of the array is reached.
5. Finally, the key is placed into the empty spot created by the shifts (arr[j + 1] = key). Its best-case time complexity is O(n) (when already sorted), but its worst-case complexity remains O(n2).

#include <stdio.h>

void merge_sorted_arrays(int arr1[], int size1, int arr2[], int size2, int arr3[]) {
    int i = 0; // Pointer for arr1
    int j = 0; // Pointer for arr2
    int k = 0; // Pointer for arr3 (merged array)

    // 1. Traverse both arrays and compare elements
    while (i < size1 && j < size2) {
        if (arr1[i] < arr2[j]) {
            arr3[k++] = arr1[i++];
        } else {
            arr3[k++] = arr2[j++];
        }
    }

    // 2. Copy remaining elements of arr1 (if any)
    while (i < size1) {
        arr3[k++] = arr1[i++];
    }

    // 3. Copy remaining elements of arr2 (if any)
    while (j < size2) {
        arr3[k++] = arr2[j++];
    }
}

int main() {
    int arr1[] = {10, 30, 50, 70};
    int size1 = 4;
    int arr2[] = {20, 40, 60, 80, 90};
    int size2 = 5;
    
    // The merged array must be large enough to hold all elements
    int size3 = size1 + size2;
    int arr3[size3]; 
    int i;

    merge_sorted_arrays(arr1, size1, arr2, size2, arr3);

    printf("Merged sorted array: ");
    for (i = 0; i < size3; i++) {
        printf("%d ", arr3[i]);
    }
    printf("\n");

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

Explanation:

This efficient merging process has a time complexity of O(n+m) where n and m are the sizes of the input arrays.

1. Main Loop: The first while loop runs as long as there are elements in both source arrays. It compares the current elements (arr1[i] vs arr2[j]) and copies the smaller one to the merged array (arr3[k]), incrementing both the source pointer and the merge pointer.
2. Cleanup Loops: The two subsequent while loops handle the case where one array has run out of elements but the other still has some remaining. Since the remaining elements of the non-exhausted array are already sorted, they can be directly appended to the merged array.

#include <stdio.h>
#include <stdlib.h> // For qsort

// Comparison function for qsort (ascending order)
int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

// Function to remove duplicates (modifies the array and returns new size)
int remove_duplicates(int arr[], int size) {
    if (size == 0 || size == 1) {
        return size;
    }

    // 1. Sort the array so duplicates are adjacent
    qsort(arr, size, sizeof(int), compare);

    int i, j = 0; // j is the index of the last unique element written

    // 2. Traverse the sorted array
    for (i = 1; i < size; i++) {
        // If the current element is NOT equal to the last unique element (arr[j])
        if (arr[i] != arr[j]) {
            j++; // Move the unique index forward
            arr[j] = arr[i]; // Copy the new unique element
        }
        // If arr[i] == arr[j], it's a duplicate and is skipped
    }

    // New size is j + 1
    return j + 1;
}

int main() {
    int arr[] = {10, 20, 20, 30, 10, 40, 50, 50, 40};
    int size = sizeof(arr) / sizeof(arr[0]);
    int new_size;
    int i;

    printf("Original array (size %d): ", size);
    for (i = 0; i < size; i++) { printf("%d ", arr[i]); }
    printf("\n");

    new_size = remove_duplicates(arr, size);

    printf("Array after removing duplicates (new size %d): ", new_size);
    // Print only up to the new size
    for (i = 0; i < new_size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

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

Explanation:

The most practical approach involves two steps:

1. Sorting: The qsort library function is used to sort the array. This places all duplicates next to each other. The time complexity is dominated by the sorting, which is typically O(nlogn).
2. In-Place Removal: We use a pointer j to track the position where the next unique element should be written, and i to read all elements. The condition arr[i] != arr[j] ensures that only unique values are copied to the front of the array. The final number of unique elements is j+1, which is returned as the new effective size of the array. The elements after this new size are logically considered removed.

#include <stdio.h>
#include <stdlib.h> // For qsort

// Comparison function for qsort (ascending order)
int compare_qsort(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

void count_all_frequencies(int arr[], int size) {
    int i, j;
    int count;

    // 1. Sort the array
    qsort(arr, size, sizeof(int), compare_qsort);
    
    printf("Frequencies:\n");

    // 2. Iterate through the sorted array and count consecutive duplicates
    for (i = 0; i < size; i++) {
        // If the current element is different from the previous one, start a new count
        if (i == 0 || arr[i] != arr[i - 1]) {
            count = 1;
            // Inner loop to count consecutive occurrences
            for (j = i + 1; j < size; j++) {
                if (arr[j] == arr[i]) {
                    count++;
                } else {
                    break; // Stop counting when a different element is found
                }
            }
            // Print the result for the unique element arr[i]
            printf("Element %d: %d times\n", arr[i], count);
        }
    }
}

int main() {
    int arr[] = {2, 5, 2, 8, 5, 1, 5, 9, 1, 2};
    int size = sizeof(arr) / sizeof(arr[0]);

    count_all_frequencies(arr, size);

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

Explanation:

This technique leverages sorting to group identical elements, simplifying the counting process.

1. Sorting: The array is sorted (O(nlogn)).
2. Outer Loop (i): Iterates through the entire array. The condition if (i == 0 || arr[i] != arr[i - 1]) ensures that we only start a new count when we encounter a unique element for the first time in the sorted sequence.
3. Inner Loop (j): This loop efficiently counts how many elements immediately following arr[i] are identical.
4. Printing: Once the inner loop breaks (due to finding a different element), the frequency is printed for the element at index i. Because the outer loop only processes the first occurrence of a unique element, we avoid redundant counting and printing.

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

// Comparison function for qsort (ascending order)
int compare_qsort_mf(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int find_most_frequent(int arr[], int size) {
    if (size == 0) return -1; // Handle empty array

    // 1. Sort the array
    qsort(arr, size, sizeof(int), compare_qsort_mf);

    int max_count = 0;
    int most_frequent_element = arr[0];
    int current_count;
    int i, j;

    // 2. Traverse the sorted array
    for (i = 0; i < size; i++) {
        // Start count only for the first occurrence of a unique element
        if (i == 0 || arr[i] != arr[i - 1]) {
            current_count = 1;
            
            // Count consecutive occurrences (inner loop is not strictly necessary, 
            // but keeps the logic simple after sorting)
            for (j = i + 1; j < size; j++) {
                if (arr[j] == arr[i]) {
                    current_count++;
                } else {
                    break;
                }
            }
            
            // 3. Update maximum frequency
            if (current_count > max_count) {
                max_count = current_count;
                most_frequent_element = arr[i];
            }
        }
    }

    return most_frequent_element;
}

int main() {
    int arr[] = {2, 5, 2, 8, 5, 1, 5, 9, 1, 2, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    int result;

    result = find_most_frequent(arr, size);
    printf("The most frequent element is: %d\n", result);

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

Explanation:

This solution uses the same O(nlogn) sorting approach as the previous exercise, adding a simple comparison to find the maximum frequency.

1. Sorting: The array is sorted.
2. Tracking Max: We maintain max_count and most_frequent_element.
3. Counting & Comparison: As we iterate and count the occurrences of each unique element (current_count), we compare it against max_count. If current_count is higher, the max variables are updated. Since the elements are already sorted, the first one encountered that matches the max_count will be the one stored. If multiple elements have the same highest frequency, the one that appeared first in the sorted array is returned.

#include <stdio.h>

// Returns 1 (equal) or 0 (not equal)
int are_arrays_equal(int arr1[], int size1, int arr2[], int size2) {
    int i;

    // 1. Check if the sizes are equal
    if (size1 != size2) {
        return 0; // Not equal if sizes differ
    }

    // 2. Check elements one by one
    for (i = 0; i < size1; i++) {
        if (arr1[i] != arr2[i]) {
            return 0; // Not equal if any element mismatch
        }
    }

    // 3. If sizes are same and no mismatch found
    return 1; // Arrays are equal
}

int main() {
    int arr_a[] = {10, 20, 30, 40};
    int arr_b[] = {10, 20, 30, 40}; // Equal to A
    int arr_c[] = {10, 20, 30, 41}; // Mismatch in last element
    int arr_d[] = {10, 20, 30};     // Different size

    int size_a = 4;
    int size_b = 4;
    int size_c = 4;
    int size_d = 3;

    // Test cases
    printf("A and B are equal: %s\n", are_arrays_equal(arr_a, size_a, arr_b, size_b) ? "True" : "False");
    printf("A and C are equal: %s\n", are_arrays_equal(arr_a, size_a, arr_c, size_c) ? "True" : "False");
    printf("A and D are equal: %s\n", are_arrays_equal(arr_a, size_a, arr_d, size_d) ? "True" : "False");

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

Explanation:

• The function first ensures the two arrays have the same number of elements. If they do, it proceeds to the single for loop, which iterates from i=0 up to the common size. In this loop, if a mismatch is found (arr1[i] != arr2[i]), the function immediately returns 0 (false).
• If the loop finishes without finding any mismatch, it confirms that all corresponding elements are identical, and the function returns 1 (true). The time complexity is dominated by the linear scan, O(n), where n is the size of the arrays.

#include <stdio.h>

int main() {
    int arr[] = {10, 15, 22, 27, 34, 41, 50};
    int n = sizeof(arr) / sizeof(arr[0]);

    // Declare two new arrays and their respective counters
    int even_arr[n], odd_arr[n];
    int even_count = 0;
    int odd_count = 0;
    int i;

    // 1. Separate the elements
    for (i = 0; i < n; i++) {
        if (arr[i] % 2 == 0) {
            // Even number
            even_arr[even_count] = arr[i];
            even_count++;
        } else {
            // Odd number
            odd_arr[odd_count] = arr[i];
            odd_count++;
        }
    }

    // 2. Print the original array
    printf("Original array: ");
    for (i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // 3. Print the even array
    printf("Even array: ");
    for (i = 0; i < even_count; i++) {
        printf("%d ", even_arr[i]);
    }
    printf("\n");

    // 4. Print the odd array
    printf("Odd array: ");
    for (i = 0; i < odd_count; i++) {
        printf("%d ", odd_arr[i]);
    }
    printf("\n");

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

Explanation:

The program iterates through the original array arr. Inside the loop, arr[i] % 2 checks the remainder when the element is divided by 2.

• If the remainder is 0, the number is even, and it is copied to the even_arr at index even_count, and even_count is incremented.
• If the remainder is not 0, the number is odd, and it is copied to the odd_arr at index odd_count, and odd_count is incremented.
• The final printing loops use even_count and odd_count (rather than the full size n) to ensure only the valid elements are displayed

#include <stdio.h>

void rotate_left_one(int arr[], int n) {
    if (n <= 1) return; // No rotation needed for 0 or 1 element

    int first_element = arr[0]; // Store the first element

    // Shift all elements one position left
    for (int i = 0; i < n - 1; i++) {
        arr[i] = arr[i + 1];
    }

    // Place the stored first element at the end
    arr[n - 1] = first_element;
}

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

    printf("Original array: 1 2 3 4 5\n");
    rotate_left_one(arr, n);
    
    printf("Array after left rotation by 1: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]); // Output: 2 3 4 5 1
    }
    printf("\n");

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

Explanation: The rotation is done in three steps:

• The value of the first element (arr[0]) is saved in first_element.
• A loop runs from index 0 up to n-2. In each iteration, the element at the current index (arr[i]) is overwritten by the element at the next index (arr[i+1]). This effectively shifts all elements left by one.
• The loop stops when the second-to-last element has been moved to the last index. The saved first_element is then placed into the empty last index (arr[n-1]).

#include <stdio.h>

void rotate_right_one(int arr[], int n) {
    if (n <= 1) return; // No rotation needed

    int last_element = arr[n - 1]; // Store the last element

    // Shift all elements one position right, starting from the end
    for (int i = n - 1; i > 0; i--) {
        arr[i] = arr[i - 1];
    }

    // Place the stored last element at the beginning
    arr[0] = last_element;
}

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

    printf("Original array: 1 2 3 4 5\n");
    rotate_right_one(arr, n);
    
    printf("Array after right rotation by 1: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]); // Output: 5 1 2 3 4
    }
    printf("\n");

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

Explanation: This rotation is similar to the left rotation but reversed.

• The value of the last element (arr[n-1]) is saved.
• A loop runs backward, from n-1 down to 1. In each step, the element at arr[i] receives the value from arr[i-1]. This ensures we don’t overwrite the previous element before moving it.
• When the loop finishes, the value at arr[1] has been moved to arr[2], and the original value at arr[0] is now at arr[1].
• The saved last_element is placed into the empty first position (arr[0]).

#include <stdio.h>

// Helper function from exercise 26
void rotate_left_one(int arr[], int n) {
    if (n <= 1) return;
    int first = arr[0];
    for (int i = 0; i < n - 1; i++) {
        arr[i] = arr[i + 1];
    }
    arr[n - 1] = first;
}

void rotate_left_k(int arr[], int n, int k) {
    // Normalize k: rotation by n positions is the same as 0 rotation
    k = k % n; 

    for (int i = 0; i < k; i++) {
        rotate_left_one(arr, n);
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 7};
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 3; // Rotate left by 3 positions

    printf("Original array: 1 2 3 4 5 6 7\n");
    rotate_left_k(arr, n, k);
    
    printf("Array after left rotation by %d: ", k);
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]); // Output: 4 5 6 7 1 2 3
    }
    printf("\n");

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

Explanation: This solution utilizes the previous single-rotation logic.

• First, the rotation count k is normalized using the modulo operator: k = k % n. This handles cases where k is greater than or equal to the array size (e.g., rotating an array of size 7 by 10 positions is the same as rotating it by 10%7 = 3 positions).
• A loop then calls the rotate_left_one function exactly k times, performing the overall multi-position shift

#include <stdio.h>

// Helper function from exercise 27
void rotate_right_one(int arr[], int n) {
    if (n <= 1) return;
    int last = arr[n - 1];
    for (int i = n - 1; i > 0; i--) {
        arr[i] = arr[i - 1];
    }
    arr[0] = last;
}

void rotate_right_k(int arr[], int n, int k) {
    // Normalize k
    k = k % n; 

    for (int i = 0; i < k; i++) {
        rotate_right_one(arr, n);
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 7};
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 3; // Rotate right by 3 positions

    printf("Original array: 1 2 3 4 5 6 7\n");
    rotate_right_k(arr, n, k);
    
    printf("Array after right rotation by %d: ", k);
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]); // Output: 5 6 7 1 2 3 4
    }
    printf("\n");

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

Explanation: The solution uses the single right rotation function repeatedly.

• The number of rotations k is first normalized using k = k % n.
• The loop then calls rotate_right_one k times.
• Note: For an array of size N, rotating right by k positions is equivalent to rotating left by N – k positions.
• If efficiency is critical, one can check if k < N/2 to decide whether to rotate right or left for fewer operations.

#include <stdio.h>

int remove_duplicates(int arr[], int n) {
    if (n == 0 || n == 1) {
        return n; // No duplicates if 0 or 1 element
    }

    int j = 0; // Index for the new array (last unique element found)

    // Compare arr[i] with arr[j]. If different, copy arr[i] to arr[++j]
    for (int i = 0; i < n - 1; i++) {
        if (arr[i] != arr[i + 1]) {
            arr[j] = arr[i];
            j++;
        }
    }
    // The last element of the original array is always unique in the new unique array
    arr[j] = arr[n - 1];
    j++;

    return j; // New length of the array
}

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

    printf("Original array: 1 1 2 2 2 3 4 4 5\n");
    int new_n = remove_duplicates(arr, n);

    printf("Array after removing duplicates (new size %d): ", new_n);
    for (int i = 0; i < new_n; i++) {
        printf("%d ", arr[i]); // Output: 1 2 3 4 5
    }
    printf("\n");

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

Explanation: The two-pointer technique efficiently removes duplicates in-place because the array is sorted.

• The outer loop compares arr[i] with the next element arr[i+1].
• If arr[i] != arr[i+1], it means arr[i] is the end of a unique sequence. This unique value is copied to arr[j], and the unique pointer j is incremented to point to the next free slot.
• If arr[i] == arr[i+1], we skip arr[i], effectively ignoring the duplicate.
• The loop stops at the second-to-last element. The last element, arr[n-1], must be added separately because the loop condition i < n - 1 prevents it from being compared against arr[i+1]. The final value of j is the new size.

#include <stdio.h>

int remove_duplicates_unsorted(int arr[], int n) {
    int i, j, k;

    for (i = 0; i < n; i++) {
        for (j = i + 1; j < n; j++) {
            // Duplicate found
            if (arr[i] == arr[j]) {
                // Shift all subsequent elements one position left
                for (k = j; k < n - 1; k++) {
                    arr[k] = arr[k + 1];
                }
                n--; // Decrease the array size
                j--; // Recheck the element at the current 'j' index
            }
        }
    }
    return n; // New length
}

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

    printf("Original array: 4 2 4 1 5 2 3 1\n");
    int new_n = remove_duplicates_unsorted(arr, n);

    printf("Array after removing duplicates (new size %d): ", new_n);
    for (int i = 0; i < new_n; i++) {
        printf("%d ", arr[i]); // Output: 4 2 1 5 3 
    }
    printf("\n");

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

Explanation:

The outer loop (i) picks a unique element candidate and the inner loop (j) checks all elements after arr[i].

If a duplicate (arr[i] == arr[j]) is found:

• A third loop (k) performs a shift operation, moving every element from index j+1 one position left to fill the gap left by the duplicate.
• The effective array size n is decremented.
• The inner loop index j is decremented (j--) because the element that just shifted into arr[j] (which was originally at arr[j+1]) needs to be checked in the next iteration against arr[i] for potential duplication.

#include <stdio.h>

void reverse_portion(int arr[], int start, int end) {
    int temp;

    // Use a while loop to swap elements from the outside-in
    while (start < end) {
        // Swap arr[start] and arr[end]
        temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;

        // Move pointers towards the middle
        start++;
        end--;
    }
}

int main() {
    int arr[] = {10, 20, 30, 40, 50, 60, 70};
    int n = sizeof(arr) / sizeof(arr[0]);
    int start_index = 2; // Element 30
    int end_index = 5;   // Element 60

    printf("Original array: 10 20 30 40 50 60 70\n");

    // Reverse portion from index 2 to 5 (30, 40, 50, 60)
    reverse_portion(arr, start_index, end_index);
    
    printf("Array after reversing indices %d to %d: ", start_index, end_index);
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]); // Output: 10 20 60 50 40 30 70
    }
    printf("\n");

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

Explanation:

The reverse_portion function uses two parameters, start and end, which define the sub-array to be reversed.

• The while (start < end) loop controls the process, ensuring elements are swapped only once.
• Inside the loop, the element at arr[start] is swapped with the element at arr[end] using a temporary variable temp.
• The pointers are then adjusted: start increases and end decreases. This moves the pointers closer together, narrowing the un-reversed section until the entire portion is reversed.

#include <stdio.h>

// Function to calculate the sum of 1 to N
long long expected_sum(int N) {
    // Uses the arithmetic series sum formula
    return (long long)N * (N + 1) / 2;
}

int find_missing_number(int arr[], int n) {
    // The sequence is from 1 to N. Since the array has n elements, N = n + 1
    int N = n + 1; 
    long long total_sum = expected_sum(N);
    long long actual_sum = 0;

    // Calculate the sum of elements present in the array
    for (int i = 0; i < n; i++) {
        actual_sum += arr[i];
    }

    // The missing number is the difference
    return (int)(total_sum - actual_sum);
}

int main() {
    // Array contains numbers from 1 to 9, so N=10. Missing is 6.
    int arr[] = {1, 2, 3, 4, 5, 7, 8, 9, 10};
    int n = sizeof(arr) / sizeof(arr[0]);

    int missing = find_missing_number(arr, n);

    printf("The missing number in the sequence 1 to %d is: %d\n", n + 1, missing); // Output: 6
    
    return 0;
}Code language: C++ (cpp)

Explanation:

This problem is solved using a simple mathematical property of arithmetic series.

• The array size n means the full sequence should contain N = n + 1 numbers.
• The function expected_sum(N) calculates the total sum if no number were missing (i.e., 1+2+…+N).
• The main function calculates the actual_sum of the elements currently in the array.
• The difference: Missing Number = Expected Sum - Actual Sum gives the single missing integer. This approach is highly efficient (O(n)).

#include <stdio.h>

int main() {
    int matrix[3][3];
    int i, j;

    // 1. Read elements
    printf("Enter the elements of the 3x3 matrix:\n");
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 3; j++) {
            printf("Element [%d][%d]: ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }

    // 2. Print elements
    printf("\nThe matrix is:\n");
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 3; j++) {
            printf("%d\t", matrix[i][j]);
        }
        printf("\n"); // Newline after each row
    }
    return 0;
}Code language: C++ (cpp)

Explanation:

• A 2D array, matrix[3][3], is declared.
• The first set of nested loops handles input. The element is stored at matrix[i][j] where i is the row index and j is the column index.
• The second set of nested loops prints the matrix. The \t (tab) creates clean spacing between column elements, and the \n (newline) after the inner loop ensures that each new row starts on a new line, displaying the matrix correctly.

#include <stdio.h>

int main() {
    int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}}; // 2x3 matrix
    int rows = 2, cols = 3;
    int i, j;
    int total_sum = 0;

    printf("Matrix:\n1 2 3\n4 5 6\n");

    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            total_sum += matrix[i][j]; // Add current element to sum
        }
    }

    printf("\nSum of all elements in the matrix: %d\n", total_sum); // Expected: 21
    return 0;
}Code language: C++ (cpp)

Explanation:

• The variable total_sum accumulates the value.
• The nested for loops ensure that the indices i (rows) and j (columns) cover every single element in the matrix exactly once.
• The statement total_sum += matrix[i][j]; performs the accumulation.

#include <stdio.h>

int main() {
    int matrix[3][2] = {{10, 20}, {30, 40}, {50, 60}}; // 3x2 matrix
    int rows = 3, cols = 2;
    int i, j;

    printf("Original Matrix:\n10 20\n30 40\n50 60\n");
    printf("\nElements in reverse order: ");

    // Outer loop: Iterate rows backwards
    for (i = rows - 1; i >= 0; i--) {
        // Inner loop: Iterate columns backwards
        for (j = cols - 1; j >= 0; j--) {
            printf("%d ", matrix[i][j]);
        }
    }
    printf("\n"); // Output: 60 50 40 30 20 10
    return 0;
}Code language: C++ (cpp)

Explanation: To achieve reverse order, the iteration direction is flipped.

• The outer loop starts at i = rows - 1 and decreases until 0, ensuring we start from the last row.
• The inner loop starts at j = cols - 1 and decreases until 0, ensuring we print elements from right to left within each row.

#include <stdio.h>

int main() {
    int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int rows = 3, cols = 3;
    int i, j;
    int col_sum[cols]; // Array to store column sums

    // Initialize column sum array to 0
    for(i = 0; i < cols; i++) {
        col_sum[i] = 0;
    }

    // 1. Calculate Row Sums and accumulate Column Totals
    for (i = 0; i < rows; i++) {
        int row_sum = 0; // Reset row sum for each new row
        for (j = 0; j < cols; j++) {
            row_sum += matrix[i][j];    // Accumulate row sum
            col_sum[j] += matrix[i][j]; // Accumulate column total
        }
        printf("Sum of Row %d: %d\n", i + 1, row_sum);
    }

    // 2. Print Column Sums
    printf("\n");
    for (j = 0; j < cols; j++) {
        printf("Sum of Column %d: %d\n", j + 1, col_sum[j]);
    }
    return 0;
}Code language: C++ (cpp)

Explanation:

An array col_sum is used to accumulate the totals for each column simultaneously with calculating the row sums.

• Row Sums: The row_sum variable is defined and reset to 0 inside the outer loop (which controls the row i). This ensures a fresh calculation for every row.
• Column Sums: The col_sum array has a size equal to the number of columns. The statement col_sum[j] += matrix[i][j]; adds the element to the correct column total regardless of the row i.

#include <stdio.h>

int main() {
    int A[2][2] = {{1, 2}, {3, 4}};
    int B[2][2] = {{5, 6}, {7, 8}};
    int C[2][2]; // Resultant matrix
    int rows = 2, cols = 2;
    int i, j;

    // 1. Perform addition
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            C[i][j] = A[i][j] + B[i][j];
        }
    }

    // 2. Print the resultant matrix C
    printf("Matrix A + Matrix B (Matrix C):\n");
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            printf("%d\t", C[i][j]); // Expected C: {{6, 8}, {10, 12}}
        }
        printf("\n");
    }
    return 0;
}Code language: C++ (cpp)

Explanation:

• Matrix addition is straightforward element-wise.
• The nested loops ensure that the same row index i and column index j are used across all three matrices (A, B, and C).
• The statement C[i][j] = A[i][j] + B[i][j]; directly implements the mathematical definition of matrix addition for corresponding cells.

#include <stdio.h>

int main() {
    int A[2][2] = {{10, 20}, {30, 40}};
    int B[2][2] = {{1, 2}, {3, 4}};
    int C[2][2]; // Resultant matrix
    int rows = 2, cols = 2;
    int i, j;

    // 1. Perform subtraction
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            C[i][j] = A[i][j] - B[i][j];
        }
    }

    // 2. Print the resultant matrix C
    printf("Matrix A - Matrix B (Matrix C):\n");
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            printf("%d\t", C[i][j]); // Expected C: {{9, 18}, {27, 36}}
        }
        printf("\n");
    }
    return 0;
}Code language: C++ (cpp)

Explanation:

• The program iterates through both matrices using nested loops.
• The subtraction C[i][j] = A[i][j] - B[i][j]; is performed element-wise.
• This simple structure applies because matrix subtraction, like addition, is only defined for matrices of identical dimensions.