C++ Array Exercises

#include <iostream>

int main() {
    // 1. Declare an array of size 5
    int arr[5];
    int size = 5;

    std::cout << "Enter 5 integers:\n";

    // 2. Read input into the array
    for (int i = 0; i < size; ++i) {
        std::cout << "Element " << i + 1 << ": ";
        std::cin >> arr[i];
    }

    std::cout << "\nThe elements in the array are: ";

    // 3. Print the elements
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

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

Explanation:

This exercise demonstrates array declaration and basic traversal using a for loop.

• The first loop uses the index variable i to access and modify each element sequentially using std::cin >> arr[i];.
• The second loop then iterates over the exact same indices to read and print the stored values to the console, confirming successful initialization.

#include <iostream>

int main() {
    // Array initialized with hardcoded values
    int arr[] = {10, 20, 30, 40, 50};
    int size = sizeof(arr) / sizeof(arr[0]);
    int total_sum = 0; // Initialize sum to zero

    // Loop through the array
    for (int i = 0; i < size; ++i) {
        // Accumulate the sum
        total_sum += arr[i];
    }

    std::cout << "The sum of all elements is: " << total_sum << std::endl;

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

Explanation:

• A variable total_sum is used to store the result.
• The for loop iterate every element, and the line total_sum += arr[i]; iteratively adds the value of the current element to the running total.
• The size calculation using sizeof is a common C++ technique to determine the length of a statically-sized array.

#include <iostream>

int main() {
    int arr[] = {15, 8, 27, 4, 19};
    int size = sizeof(arr) / sizeof(arr[0]);

    // Initialize max_element with the first element of the array
    int max_element = arr[0]; 

    // Iterate starting from the second element (index 1)
    for (int i = 1; i < size; ++i) {
        if (arr[i] > max_element) {
            max_element = arr[i]; // Update if a larger element is found
        }
    }

    std::cout << "The maximum element in the array is: " << max_element << std::endl;

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

Explanation:

This exercise uses an iterative approach to solve a search problem.

• The variable max_element holds the largest value found so far. By initializing it to arr[0], we ensure a valid starting point.
• The for loop compares every subsequent element to this running maximum. The process guarantees that by the time the loop finishes, max_element will hold the absolute largest value in the entire array.

#include <iostream>

int main() {
    int arr[] = {10, 50, 30, 70, 80, 20};
    int size = sizeof(arr) / sizeof(arr[0]);
    int target;
    int found_index = -1; // -1 indicates "not found"

    std::cout << "Enter the number to search for: ";
    std::cin >> target;

    // Perform Linear Search
    for (int i = 0; i < size; ++i) {
        if (arr[i] == target) {
            found_index = i; // Store the index
            break;           // Exit the loop immediately
        }
    }

    if (found_index != -1) {
        std::cout << "Element " << target << " found at index: " << found_index << std::endl;
    } else {
        std::cout << "Element " << target << " not found in the array." << std::endl;
    }

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

Explanation:

This exercise demonstrates the Linear Search algorithm.

• It checks each element one by one from the start of the array. The variable found_index acts as a flag; it is initialized to -1 (an invalid index) and is only updated if a match is found.
• The use of break optimizes the search by preventing unnecessary iterations once the element is located. After the loop, the value of found_index is checked to determine the final output.

#include <iostream>

int main() {
    int arr[] = {1, 3, 2, 3, 4, 3, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    int target = 3;
    int count = 0; // Initialize counter

    // Iterate through the array elements
    for (int i = 0; i < size; ++i) {
        if (arr[i] == target) {
            count++; // Increment the counter when the target is found
        }
    }

    std::cout << "The number " << target << " occurs " << count << " times." << std::endl;

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

Explanation:

This is another variation of the traversal pattern where an operation (incrementing a counter) is conditionally applied.

The count variable tallies the total number of times the target value (3) is found. Unlike the Linear Search, the for loop must continue until the end of the array to ensure every instance of the target is counted.

#include <iostream>

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

    std::cout << "Original array: ";
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    std::cout << "Reversed array: ";
    // Start at the last index (size - 1) and decrement to 0
    for (int i = size - 1; i >= 0; --i) { 
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

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

Explanation:

This exercise demonstrates reverse traversal.

• Array indices run from 0 up to size - 1. To print in reverse, the for loop is initialized at i = size - 1 (the index of the last element).
• The loop condition is set to continue as long as i is greater than or equal to 0, and the step is set to --i. This prints the elements from the end to the beginning.

#include <iostream>

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

    // Declare the destination array with the same size
    int arr2[5]; 

    // Loop to copy elements from arr1 to arr2
    for (int i = 0; i < size; ++i) {
        arr2[i] = arr1[i]; // The actual copy operation
    }

    // Print arr2 to verify the copy
    std::cout << "Elements of the copied array (arr2): ";
    for (int i = 0; i < size; ++i) {
        std::cout << arr2[i] << " ";
    }
    std::cout << std::endl;

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

Explanation:

• This exercise highlights that C-style arrays in C++ do not support simple value assignment via the assignment operator (=). A deep copy requires manual element-by-element assignment.
• The for loop iterates through the corresponding indices, ensuring that the value at arr1[i] is independently copied into the memory location designated for arr2[i].

#include <iostream>

int main() {
    int arr[] = {1, 6, 3, 8, 5, 10, 7};
    int size = sizeof(arr) / sizeof(arr[0]);

    std::cout << "The even numbers in the array are: ";

    // Iterate through the array
    for (int i = 0; i < size; ++i) {
        // Check if the number is perfectly divisible by 2
        if (arr[i] % 2 == 0) {
            std::cout << arr[i] << " ";
        }
    }
    std::cout << std::endl;

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

Explanation:

This exercise introduces the concept of conditional printing during array traversal.

• The modulus operator (%) is used to find the remainder of a division. If the remainder of dividing an element by 2 is 0 (arr[i] % 2 == 0), the number is an even number, and the program executes the printing action.
• Otherwise, the number is skipped, effectively filtering the output to only show even values.

#include <iostream>

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

    std::cout << "Array BEFORE swap: ";
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    // Perform the swap
    int temp = arr[0];         // Step 1: Store the first element
    arr[0] = arr[size - 1];    // Step 2: Overwrite the first element with the last
    arr[size - 1] = temp;      // Step 3: Overwrite the last element with the stored first element

    std::cout << "Array AFTER swap: ";
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

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

Explanation:

This exercise teaches the standard variable swap technique, which is crucial for sorting algorithms and in-place array modifications.

Without the temporary variable (temp), the value of the first element would be lost when the second step is executed, as it would be immediately overwritten by the value of the last element. The temporary variable preserves the data during the three-step exchange.

#include <iostream>

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

    std::cout << "Unique elements are: ";

    // Outer loop iterates through each element to check uniqueness
    for (int i = 0; i < size; ++i) {
        bool is_unique = true;
        
        // Inner loop checks the current element (arr[i]) against all others
        for (int j = 0; j < size; ++j) {
            // Check for duplicates, but skip checking the element against itself (i != j)
            if (i != j && arr[i] == arr[j]) {
                is_unique = false;
                break; // Found a duplicate, no need to check further
            }
        }
        
        if (is_unique) {
            std::cout << arr[i] << " ";
        }
    }
    std::cout << std::endl;

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

Explanation:

This exercise introduces the use of nested loops for comparison-based array problems.

• The outer loop selects an element, and the inner loop checks the selected element against every other element in the array. The bool is_unique flag tracks the status.
• If a duplicate is found (is_unique becomes false), the inner loop is immediately terminated using break. If the inner loop completes with is_unique still being true, the element is printed.

#include <iostream>

int main() {
    int arr[] = {10, 25, 40, 55, 70};
    int size = sizeof(arr) / sizeof(arr[0]);
    int k = 2; // Index to check (value 40)

    bool result = false;

    // Check boundary conditions first
    if (k > 0 && k < size - 1) {
        // Check if arr[k] > arr[k-1] AND arr[k] < arr[k+1]
        if (arr[k] > arr[k - 1] && arr[k] < arr[k + 1]) {
            result = true;
        }
    }
    // For invalid k, result remains false

    std::cout << "The condition is: " << (result ? "True" : "False") << std::endl;

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

Explanation:

• This exercise emphasizes boundary checking and direct index access.
• The if condition ensures that the program does not attempt to access memory outside the array bounds (e.g., index -1 or index 5 in a size-5 array), which would cause a runtime error.
• The core logic then uses the logical AND operator (&&) to verify both comparison conditions simultaneously.

#include <iostream>
#include <algorithm> // Required for std::sort

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

    std::cout << "Array before sorting: ";
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    // Use the standard library sort function for ascending order
    std::sort(arr, arr + size);

    std::cout << "Array AFTER sorting (Ascending): ";
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

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

Explanation:

This exercise focuses on using the powerful Standard Library function std::sort.

• The function requires two iterators (pointers for raw arrays): one pointing to the beginning of the range (arr) and one pointing one past the end of the range (arr + size).
• By default, std::sort uses a highly optimized algorithm (typically Introsort) to arrange the elements in non-decreasing (ascending) order.

#include <iostream>
#include <algorithm>
#include <functional> // Required for std::greater

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

    // Use the standard library sort function for descending order
    // std::greater<int>() is the comparator for reverse order
    std::sort(arr, arr + size, std::greater<int>());

    std::cout << "Array AFTER sorting (Descending): ";
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

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

Explanation:

Sorting in descending order requires defining a custom comparison rule.

By passing std::greater<int>() as the third argument to std::sort, we instruct the sorting algorithm to place elements where the left operand is greater than the right operand, resulting in a reverse-sorted (descending) sequence.

#include <iostream>

int main() {
    int arr[10] = {10, 20, 30, 40, 50}; // Array with space
    int current_size = 5;
    int element_to_insert = 25;
    int position = 2; // Insertion index

    // 1. Shift elements to the right starting from the end
    for (int i = current_size; i > position; --i) {
        arr[i] = arr[i - 1];
    }

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

    // 3. Update the size
    current_size++;

    std::cout << "Array after insertion: ";
    for (int i = 0; i < current_size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

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

Explanation:

This is an exercise in array modification. Since raw arrays have fixed memory, insertion requires manual shifting.

The for loop iterates backward from the new end position down to the insertion position (position + 1). This ensures that existing data is copied before the index is overwritten, preventing data loss. After shifting, the element is placed in the position, and the array’s effective size is incremented.

#include <iostream>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int current_size = 5;
    int delete_position = 3; // Index of element 40

    if (delete_position < 0 || delete_position >= current_size) {
        std::cout << "Invalid deletion position." << std::endl;
        return 1;
    }

    // Shift elements to the left (overwrite the element to be deleted)
    for (int i = delete_position; i < current_size - 1; ++i) {
        arr[i] = arr[i + 1];
    }

    // Decrement the size
    current_size--;

    std::cout << "Array after deletion: ";
    for (int i = 0; i < current_size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

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

Explanation:

Deletion in a raw array also requires manual shifting.

• The for loop starts at the element to be deleted (i = delete_position) and copies the value of the next element (arr[i + 1]) into the current slot (arr[i]). This moves all subsequent elements one position left, effectively overwriting and removing the element at the deletion position.
• The final step is to decrement the current_size to logically exclude the last (now duplicated) element.

#include <iostream>
#include <limits> // Required for std::numeric_limits

int main() {
    int arr[] = {12, 35, 1, 10, 34, 1};
    int size = sizeof(arr) / sizeof(arr[0]);

    // Initialize largest and second_largest to the smallest possible integer value
    int largest = std::numeric_limits<int>::min();
    int second_largest = std::numeric_limits<int>::min();

    for (int i = 0; i < size; ++i) {
        if (arr[i] > largest) {
            // New largest found
            second_largest = largest; // Old largest becomes second largest
            largest = arr[i];
        } else if (arr[i] > second_largest && arr[i] < largest) {
            // Found a value smaller than largest but greater than second largest
            second_largest = arr[i];
        }
    }

    std::cout << "The second largest element is: " << second_largest << std::endl;

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

Explanation:

This efficient method uses a single traversal, making it an O(N) solution.

• It tracks the two largest numbers simultaneously. The first if block handles cases where a new absolute maximum is found.
• The else if block handles cases where the current element is smaller than the current maximum but larger than the current second maximum, thereby updating only the second_largest variable.
• Initializing the variables using std::numeric_limits<int>::min() ensures correct comparison even with negative numbers.

#include <iostream>

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

    std::cout << "Original array: ";
    for (int x : arr) {
        std::cout << x << " ";
    }
    std::cout << std::endl;

    // Loop to modify the array
    for (int i = 0; i < size; ++i) {
        if (arr[i] == 0) {
            arr[i] = -1; // Replace 0 with -1
        }
    }

    std::cout << "Modified array: ";
    for (int x : arr) {
        std::cout << x << " ";
    }
    std::cout << std::endl;

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

Explanation:

This exercise demonstrates in-place modification of an array.

The for loop iterates through the entire array. if the element meets the criteria (arr[i] == 0), its value is changed directly within the array’s memory location (arr[i] = -1). This process alters the array permanently for subsequent operations.

#include <iostream>

bool is_sorted(int arr[], int size) {
    // We only need to check up to the second-to-last element (size - 2)
    for (int i = 0; i < size - 1; ++i) {
        // If the current element is greater than the next element, it is NOT sorted ascendingly
        if (arr[i] > arr[i + 1]) {
            return false;
        }
    }
    // If the loop completes without returning false, the array is sorted
    return true;
}

int main() {
    int arr1[] = {10, 20, 30, 40};
    int size1 = sizeof(arr1) / sizeof(arr1[0]);

    std::cout << "Array 1 is sorted: " << (is_sorted(arr1, size1) ? "True" : "False") << std::endl;

    int arr2[] = {10, 30, 20, 40};
    int size2 = sizeof(arr2) / sizeof(arr2[0]);
    
    std::cout << "Array 2 is sorted: " << (is_sorted(arr2, size2) ? "True" : "False") << std::endl;

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

Explanation:

This exercise demonstrates an efficient sequential comparison check.

• To confirm ascending order, every pair of adjacent elements must satisfy the condition arr[i] <= arr[i + 1].
• The loop runs up to size - 1 comparisons. Crucially, if the condition arr[i] > arr[i + 1] is ever true, the function immediately concludes the array is not sorted and terminates early, optimizing performance.

#include <iostream>

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

    // Store the first element to be placed at the end
    int first_element = arr[0];

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

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

    std::cout << "Array after left rotation: ";
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

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

Explanation:

This exercise demonstrates cyclic array shifting. The first element is saved to prevent loss.

• The for loop efficiently moves all elements one position to the left, effectively overwriting the old first element’s position.
• The loop stops at size - 2 because the element at size - 1 (the last element) is copied into the slot at size - 2.
• Finally, the saved first_element is placed at the now-empty last index.

#include <iostream>

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

    // Store the last element to be placed at the beginning
    int last_element = arr[size - 1];

    // Shift elements one position to the right (loop backwards)
    for (int i = size - 1; i > 0; --i) {
        arr[i] = arr[i - 1];
    }

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

    std::cout << "Array after right rotation: ";
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

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

Explanation:

Right rotation involves shifting elements backward in the array indices. The backward for loop is essential here: starting from the last valid index and decrementing ensures that the element at arr[i] is copied to arr[i + 1] before arr[i] is itself overwritten in the previous iteration.

This prevents data loss during the shift, and the saved last_element correctly fills the arr[0] slot at the end.

#include <iostream>

int remove_duplicates(int arr[], int size) {
    if (size == 0) return 0;
    
    // j tracks the position of the next unique element
    int j = 1; 

    // i tracks the currently examined element
    for (int i = 1; i < size; ++i) {
        // If the current element is different from the previous unique element
        if (arr[i] != arr[j - 1]) {
            arr[j] = arr[i]; // Copy the unique element to the j position
            j++;             // Move the unique element pointer forward
        }
        // If arr[i] is a duplicate, we do nothing and let i continue
    }
    return j; // j is the new size
}

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

    // The function modifies the array in-place and returns the new size
    int new_size = remove_duplicates(arr, size);

    std::cout << "Array after removing duplicates (New Size: " << new_size << "): ";
    for (int i = 0; i < new_size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

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

Explanation:

This is an advanced exercise demonstrating in-place modification using two pointers.

• Since the array is sorted, only adjacent elements need comparison. The pointer j tracks the boundary between the unique elements (at indices 0 to j-1) and the rest of the array.
• When the element at arr[i] is unique compared to the element just before the j boundary (arr[j - 1]), it is copied into the j slot, and the unique boundary is advanced. Duplicates are effectively skipped, resulting in a compacted array.

#include <iostream>

bool is_palindrome(int arr[], int size) {
    int left = 0;
    int right = size - 1;

    while (left < right) {
        // If elements at opposite ends don't match, it's not a palindrome
        if (arr[left] != arr[right]) {
            return false;
        }
        // Move pointers inward
        left++;
        right--;
    }
    // If the loop completes without finding a mismatch, it is a palindrome
    return true;
}

int main() {
    int arr1[] = {1, 2, 3, 2, 1};
    int size1 = sizeof(arr1) / sizeof(arr1[0]);
    
    std::cout << "Array 1 is a palindrome: " << (is_palindrome(arr1, size1) ? "True" : "False") << std::endl;
    
    int arr2[] = {1, 2, 3, 4};
    int size2 = sizeof(arr2) / sizeof(arr2[0]);
    
    std::cout << "Array 2 is a palindrome: " << (is_palindrome(arr2, size2) ? "True" : "False") << std::endl;

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

Explanation:

This problem utilizes the two-pointer technique for efficient bidirectional comparison.

• The while loop condition left < right ensures that the comparison only occurs up to the middle of the array, avoiding redundant checks.
• If any element pair from opposite ends fails the equality check, the function immediately returns false. If all pairs match, the loop finishes, and the function confirms the array is a palindrome by returning true.

#include <iostream>

int main() {
    const int ROWS = 3;
    const int COLS = 3;
    int matrix[ROWS][COLS];

    std::cout << "Enter 9 integers for the 3x3 matrix:\n";

    // Input loop
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            std::cout << "Enter element [" << i << "][" << j << "]: ";
            std::cin >> matrix[i][j];
        }
    }

    std::cout << "\nThe matrix is:\n";

    // Output loop
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            std::cout << matrix[i][j] << "\t"; // Use tab for alignment
        }
        std::cout << std::endl; // Newline after each row
    }

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

Explanation:

This exercise introduces multi-dimensional arrays.

• A 3X3 matrix is represented as int matrix[3][3]. Accessing and processing elements always requires two indices: the first for the row (i) and the second for the column (j).
• Nested for loops are the standard method for traversing 2D arrays, with the outer loop controlling the row movement and the inner loop handling column movement across that row.

#include <iostream>

int main() {
    const int ROWS = 3;
    const int COLS = 3;
    int matrix[ROWS][COLS] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    int total_sum = 0;

    // Calculate sum using nested loops
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            total_sum += matrix[i][j];
        }
    }

    std::cout << "The sum of all elements in the matrix is: " << total_sum << std::endl;

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

Explanation:

• This is the 2D array equivalent of Exercise 2 (Sum of Elements). Here sum is calculated using nested loops.
• The outer loop ensures every row is processed, and the inner loop ensures every column element within that row is added to the running total_sum.

#include <iostream>

int main() {
    const int SIZE = 3; // Matrix is 3x3
    int matrix[SIZE][SIZE] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    int diagonal_sum = 0;

    // Calculate the sum of the main diagonal (where row index == col index)
    for (int i = 0; i < SIZE; ++i) {
        diagonal_sum += matrix[i][i];
    }

    std::cout << "The sum of the main diagonal elements is: " << diagonal_sum << std::endl; // 1 + 5 + 9 = 15

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

Explanation:

• This exercise optimizes traversal for a specific pattern. For a square matrix, the main diagonal elements are defined by the condition i = j.
• Because of this equality, we only need a single loop where the loop index i is used for both the row and column access, making the calculation very efficient.

#include <iostream>

int main() {
    const int ROWS = 3;
    const int COLS = 3;
    int matrix[ROWS][COLS] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    int transpose[COLS][ROWS]; // Rows and cols are conceptually swapped

    // Calculate the transpose
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            transpose[j][i] = matrix[i][j]; // Swap of indices
        }
    }

    std::cout << "Original Matrix:\n";
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            std::cout << matrix[i][j] << "\t";
        }
        std::cout << std::endl;
    }

    std::cout << "\nTransposed Matrix:\n";
    for (int i = 0; i < COLS; ++i) { // Loop uses COLS for outer and ROWS for inner for display
        for (int j = 0; j < ROWS; ++j) {
            std::cout << transpose[i][j] << "\t";
        }
        std::cout << std::endl;
    }

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

Explanation:

• The transpose operation swaps the roles of rows and columns. In the calculation loop, the key operation is transpose[j][i] = matrix[i][j]. This takes the element at row i, column j of the original matrix and places it at row j, column i of the new matrix.
• The size declaration for transpose is int transpose[COLS][ROWS], though for a 3X3 matrix, the dimensions remain 3X3.

#include <iostream>

int main() {
    const int ROWS = 3;
    const int COLS = 3;
    int A[ROWS][COLS] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
    int B[ROWS][COLS] = { {9, 8, 7}, {6, 5, 4}, {3, 2, 1} };
    int C[ROWS][COLS]; // Result matrix

    // Perform matrix addition
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            C[i][j] = A[i][j] + B[i][j];
        }
    }

    std::cout << "Result Matrix (C = A + B):\n";
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            std::cout << C[i][j] << "\t";
        }
        std::cout << std::endl;
    }

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

Explanation:

• Matrix addition is element-wise and requires that both matrices have the same dimensions.
• This program uses nested loops to ensure that for every position (i, j), the elements from matrix A and matrix B are summed and stored in the exact same position in matrix C.
• The result is a 3X3 matrix where every element is 10 (e.g., 1+9=10, 5+5=10).

#include <iostream>
#include <numeric>

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

    // Step 1: Calculate the total sum of the array
    int total_sum = 0;
    for (int x : arr) {
        total_sum += x;
    }
    
    int left_sum = 0;
    
    // Step 2: Iterate and check for equilibrium
    for (int i = 0; i < size; ++i) {
        // total_sum - left_sum - arr[i] is the right_sum
        int right_sum = total_sum - left_sum - arr[i]; 

        if (left_sum == right_sum) {
            std::cout << "Equilibrium index found at: " << i << std::endl;
        }
        
        // Update left_sum for the next iteration
        left_sum += arr[i];
    }
    
    return 0;
}Code language: C++ (cpp)

Explanation:

This approach efficiently solves the problem in O(N) time by avoiding nested loops.

By pre-calculating the total_sum, the right sum (right_sum) can be instantly derived using the formula: RightSum = TotalSum - LeftSum - CurrentElement.

The variable left_sum accumulates the sum of elements before the current index i, allowing the check to be performed at every position.

#include <iostream>

int main() {
    int arr[] = {1, 2, 4, 5};
    int n_minus_1 = sizeof(arr) / sizeof(arr[0]);
    int N = n_minus_1 + 1; // The full range goes up to N (5 in this case)

    // Step 1: Calculate the expected sum (Sum of 1 to N)
    // Formula: N * (N + 1) / 2
    long long expected_sum = (long long)N * (N + 1) / 2;

    // Step 2: Calculate the actual sum of the array elements
    long long actual_sum = 0;
    for (int x : arr) {
        actual_sum += x;
    }

    // Step 3: Find the missing number
    int missing_number = expected_sum - actual_sum;

    std::cout << "The missing number in the range 1 to " << N << " is: " << missing_number << std::endl; // Output: 3

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

Explanation:

This is an elegant O(N) solution that avoids sorting or complex data structures. It relies on the mathematical properties of the set.

By calculating the theoretical sum of the complete set of numbers (1 to N) and subtracting the actual sum of the incomplete array, the result is exactly the number that was absent. Using long long for the sums is good practice to prevent overflow, especially when N is large.

#include <iostream>

int find_majority(int arr[], int size) {
    int candidate = 0;
    int count = 0;

    // Phase 1: Find the candidate using Moore's Voting Algorithm
    for (int i = 0; i < size; ++i) {
        if (count == 0) {
            candidate = arr[i];
            count = 1;
        } else if (arr[i] == candidate) {
            count++;
        } else {
            count--;
        }
    }

    // Phase 2: Verification (optional if majority is guaranteed)
    // A second loop can be added here to count occurrences of 'candidate'
    // to rigorously prove it is the majority element.

    return candidate;
}

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

    int majority = find_majority(arr, size);

    std::cout << "The majority element is: " << majority << std::endl;

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

Explanation:

Moore’s Voting Algorithm is an advanced and highly efficient O(N) solution. It’s based on the idea that if an element appears more than n/2 times, it will always be the last element standing after all pairs of different elements are “cancelled out” (by decrementing count).

The algorithm cleverly finds the potential majority element in a single pass without needing a map or complex sorting.

#include <iostream>

int main() {
    int arr[] = {1, 5, 7, -1, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    int target_sum = 6;
    int pair_count = 0;

    // Nested loops for O(N^2) complexity
    for (int i = 0; i < size; ++i) {
        // Inner loop starts from i + 1 to avoid duplicate pairs 
        // and avoid checking an element with itself.
        for (int j = i + 1; j < size; ++j) { 
            if (arr[i] + arr[j] == target_sum) {
                pair_count++;
                std::cout << "Found pair: (" << arr[i] << ", " << arr[j] << ")" << std::endl;
            }
        }
    }

    std::cout << "\nTotal number of pairs with sum " << target_sum << " is: " << pair_count << std::endl;

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

Explanation:

This solution uses the straightforward brute-force approach with nested loops, resulting in an O(N^2) time complexity.

• The outer loop fixes the first element of the pair.
• The inner loop then checks all subsequent elements (j = i + 1) to see if the required sum is met. The starting index of the inner loop, i + 1, is critical to ensure that each pair is counted only once and that no element is paired with itself.

#include <iostream>
#include <algorithm>

int main() {
    int A[] = {1, 5, 8, 10};
    int sizeA = 4;
    int B[] = {2, 6, 9, 12, 15};
    int sizeB = 5;
    const int sizeC = sizeA + sizeB;
    int C[sizeC];

    int i = 0, j = 0, k = 0;

    // Merge until one array is exhausted
    while (i < sizeA && j < sizeB) {
        if (A[i] < B[j]) {
            C[k++] = A[i++];
        } else {
            C[k++] = B[j++];
        }
    }

    // Copy remaining elements of A, if any
    while (i < sizeA) {
        C[k++] = A[i++];
    }

    // Copy remaining elements of B, if any
    while (j < sizeB) {
        C[k++] = B[j++];
    }

    std::cout << "Merged sorted array C: ";
    for (int x : C) {
        std::cout << x << " ";
    }
    std::cout << std::endl;

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

Explanation:

• This exercise requires the two-pointer (or three-pointer) merge technique, which is the core of Merge Sort.
• By maintaining pointers for both sorted input arrays, the smallest remaining element from either A or B is determined and copied into C in O(N) time complexity.
• The subsequent while loops handle the remaining elements after one of the arrays runs out.

#include <iostream>
#include <algorithm>
#include <vector>

void reverse_array(int arr[], int start, int end) {
    while (start < end) {
        std::swap(arr[start], arr[end]);
        start++;
        end--;
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 7};
    int size = 7;
    int k = 3; 
    
    // Normalize k (rotation amount)
    k = k % size;

    // Reversal Algorithm for Right Rotation:
    
    // 1. Reverse the first (size - k) elements (e.g., {1, 2, 3, 4} -> {4, 3, 2, 1})
    reverse_array(arr, 0, size - k - 1); 

    // 2. Reverse the last k elements (e.g., {5, 6, 7} -> {7, 6, 5})
    reverse_array(arr, size - k, size - 1); 

    // 3. Reverse the entire array (e.g., {4, 3, 2, 1, 7, 6, 5} -> {5, 6, 7, 1, 2, 3, 4})
    reverse_array(arr, 0, size - 1); 

    std::cout << "Array after right rotation by " << k << ": ";
    for (int x : arr) {
        std::cout << x << " ";
    }
    std::cout << std::endl;

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

Explanation:

The reversal algorithm is the optimal in-place solution for array rotation, achieving O(N) time complexity with O(1) extra space.

The key is to realize that rotating right by K is equivalent to swapping the first N - K elements with the last K elements, which is elegantly achieved by the three reversal steps. Normalizing K with the modulus operator (k % size) ensures the rotation works correctly even if K is larger than the array size.