https://www.w3resource.
com/c-programming-exercises/
array/index.php
https://codeforwin.org/c-programming/array-programming-
exercises-and
Write a program in C to print all unique elements in an array
#include <stdio.h>
// Main function
int main()
{
int arr1[100], n, ctr = 0; // Declare an array to store integer values,
n for array size, and ctr for counting duplicates
int i, j, k; // Declare loop counters
// Prompt the user to input the number of elements to be stored in the
array
printf("\n\nPrint all unique elements of an array:\n");
printf("------------------------------------------\n");
printf("Input the number of elements to be stored in the array: ");
scanf("%d", &n);
// Prompt the user to input n elements into the array
printf("Input %d elements in the array :\n", n);
for (i = 0; i < n; i++)
{
printf("element - %d : ", i);
scanf("%d", &arr1[i]); // Read the input and store it in the array
}
// Print unique elements in the array
printf("\nThe unique elements found in the array are: \n");
for (i = 0; i < n; i++)
{
ctr = 0; // Reset the counter for each element
for (j = 0, k = n; j < k + 1; j++)
{
/* Increment the counter when the search value is duplicate. */
if (i != j)
{
if (arr1[i] == arr1[j])
{
ctr++;
}
}
}
if (ctr == 0)
{
printf("%d ", arr1[i]); // Print the unique element
}
}
printf("\n\n");
return 0; // Return 0 to indicate successful execution
}
counts the total number of duplicate elements in an
array, and provides their indices and values
#include <stdio.h>
void findDuplicates(int arr[], int size) {
int i, j, count = 0;
printf("Duplicate elements and their indices:\n");
// To keep track of visited elements
int visited[size];
for (i = 0; i < size; i++) {
visited[i] = 0; // Initialize visited array with 0
}
for (i = 0; i < size; i++) {
if (visited[i] == 1) {
continue; // Skip already visited elements
}
int duplicate = 0; // Flag to check for duplicates
for (j = i + 1; j < size; j++) {
if (arr[i] == arr[j]) {
if (duplicate == 0) {
printf("Value: %d, Index: %d\n", arr[i], i);
duplicate = 1;
count++;
}
printf("Value: %d, Index: %d\n", arr[i], j);
visited[j] = 1; // Mark element as visited
}
}
}
printf("Total number of duplicate elements: %d\n", count);
}
int main() {
int arr[] = {1, 2, 3, 2, 4, 3, 5, 6, 3};
int size = sizeof(arr) / sizeof(arr[0]);
printf("Original array: ");
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
findDuplicates(arr, size);
return 0;
}
To remove an element from the middle of an array, shift
all elements after the removed element one position to
the left
#include <iostream>
void removeElement(int arr[], int& size, int index) {
// Check if the index is within the bounds of the array
if (index < 0 || index >= size) {
std::cout << "Index out of bounds" << std::endl;
return;
}
// Shift elements to the left
for (int i = index; i < size - 1; i++) {
arr[i] = arr[i + 1];
}
// Decrease the size of the array
size--;
}
int main() {
// Define an array
int arr[] = {1, 2, 3, 4, 5};
int size = sizeof(arr) / sizeof(arr[0]);
// Index of the element to be removed
int indexToRemove = 2; // For example, removing the element at index 2
(which is '3')
std::cout << "Original array: ";
for (int i = 0; i < size; i++) {
std::cout << arr[i] << " ";
}
std::cout << std::endl;
// Remove the element at the specified index
removeElement(arr, size, indexToRemove);
std::cout << "Array after removal: ";
for (int i = 0; i < size; i++) {
std::cout << arr[i] << " ";
}
std::cout << std::endl;
return 0;
}
To print an array in reverse order
#include <iostream>
int main() {
// Define an array
int arr[] = {1, 2, 3, 4, 5};
// Calculate the size of the array
int size = sizeof(arr) / sizeof(arr[0]);
// Print the array in reverse order
std::cout << "Array in reverse order: ";
for (int i = size - 1; i >= 0; i--) {
std::cout << arr[i] << " ";
}
std::cout << std::endl;
return 0;
}
Separate odd and even from a 3D array
#include <iostream>
int main() {
// Define a 3D array of size 4x3x3
const int x = 4, y = 3, z = 3;
int arr[x][y][z] = {
{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}},
{{10, 11, 12}, {13, 14, 15}, {16, 17, 18}},
{{19, 20, 21}, {22, 23, 24}, {25, 26, 27}},
{{28, 29, 30}, {31, 32, 33}, {34, 35, 36}}
};
// Calculate the total number of elements
const int totalElements = x * y * z;
// Define arrays to store odd and even numbers
int oddNumbers[totalElements];
int evenNumbers[totalElements];
int oddIndex = 0;
int evenIndex = 0;
// Iterate through the 3D array
for (int i = 0; i < x; ++i) {
for (int j = 0; j < y; ++j) {
for (int k = 0; k < z; ++k) {
if (arr[i][j][k] % 2 == 0) {
evenNumbers[evenIndex++] = arr[i][j][k];
} else {
oddNumbers[oddIndex++] = arr[i][j][k];
}
}
}
}
// Print odd numbers
std::cout << "Odd Numbers: ";
for (int i = 0; i < oddIndex; ++i) {
std::cout << oddNumbers[i] << " ";
}
std::cout << std::endl;
// Print even numbers
std::cout << "Even Numbers: ";
for (int i = 0; i < evenIndex; ++i) {
std::cout << evenNumbers[i] << " ";
}
std::cout << std::endl;
return 0;
}
compare two 3D arrays based on user input and check if they
are identical, we need to take user input for the
dimensions of the 3D arrays and then take the elements for
both arrays. We will then compare the elements of the two
arrays. If all elements are the same, the arrays are
identical; otherwise, they are not.
#include <iostream>
using namespace std;
bool areIdentical(int*** arr1, int*** arr2, int x, int y, int z) {
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
for (int k = 0; k < z; k++) {
if (arr1[i][j][k] != arr2[i][j][k]) {
return false;
}
}
}
}
return true;
}
int*** create3DArray(int x, int y, int z) {
int*** arr = new int**[x];
for (int i = 0; i < x; i++) {
arr[i] = new int*[y];
for (int j = 0; j < y; j++) {
arr[i][j] = new int[z];
}
}
return arr;
}
void input3DArray(int*** arr, int x, int y, int z) {
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
for (int k = 0; k < z; k++) {
cin >> arr[i][j][k];
}
}
}
}
void delete3DArray(int*** arr, int x, int y) {
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
delete[] arr[i][j];
}
delete[] arr[i];
}
delete[] arr;
}
int main() {
int x, y, z;
cout << "Enter the dimensions of the 3D arrays (x y z): ";
cin >> x >> y >> z;
// Create and input the first 3D array
cout << "Enter the elements of the first 3D array:" << endl;
int*** arr1 = create3DArray(x, y, z);
input3DArray(arr1, x, y, z);
// Create and input the second 3D array
cout << "Enter the elements of the second 3D array:" << endl;
int*** arr2 = create3DArray(x, y, z);
input3DArray(arr2, x, y, z);
// Check if the two 3D arrays are identical
if (areIdentical(arr1, arr2, x, y, z)) {
cout << "The two 3D arrays are identical." << endl;
} else {
cout << "The two 3D arrays are not identical." << endl;
}
// Deallocate dynamic memory
delete3DArray(arr1, x, y);
delete3DArray(arr2, x, y);
return 0;
}
finding the average of even numbers among the non-diagonal
elements of a 2D array in C++, we will perform the
following steps:
Iterate through each element of the 2D array.
Check if the element is a non-diagonal element.
Check if the non-diagonal element is an even number.
Calculate the average of these even numbers.
#include <iostream>
using namespace std;
double findEvenNonDiagonalAverage(int** arr, int rows, int cols) {
int sum = 0;
int count = 0;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
if (i != j && i + j != cols - 1) { // Non-diagonal elements
if (arr[i][j] % 2 == 0) { // Check if even
sum += arr[i][j];
count++;
}
}
}
}
return (count == 0) ? 0 : (double)sum / count;
}
int main() {
int rows, cols;
cout << "Enter the number of rows: ";
cin >> rows;
cout << "Enter the number of columns: ";
cin >> cols;
// Dynamic memory allocation for 2D array
int** arr = new int*[rows];
for (int i = 0; i < rows; i++) {
arr[i] = new int[cols];
}
cout << "Enter the elements of the array:" << endl;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
cin >> arr[i][j];
}
}
double average = findEvenNonDiagonalAverage(arr, rows, cols);
cout << "Average of even non-diagonal elements: " << average << endl;
// Deallocate dynamic memory
for (int i = 0; i < rows; i++) {
delete[] arr[i];
}
delete[] arr;
return 0;
}
Program to reverse columns in given 2D Array (Matrix)
Given a 2D array arr[][]of integers of size M x N, where N is the number of columns and M is the
number of rows in the array. The task is to reverse every column of the given 2D array
Input: arr[][] = {{3, 2, 1}
{4, 5, 6},
{9, 8, 7}}
Output: 9 8 7
456
321
// Java implementation of the
// above approach
import java.util.*;
class GFG {
static int M = 3;
static int N = 3;
// A utility function
// for swapping two elements.
private static int[][] swap(int[][] arr, int start,
int i, int end, int j)
{
int temp = arr[start][i];
arr[start][i] = arr[end][j];
arr[end][j] = temp;
return arr;
}
// Print the arr[][]
static void printMatrix(int arr[][])
{
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
// Function to reverse
// the given 2D arr[][]
static void reverseColumnArray(int arr[][])
{
// Print the arr[][] before
// reversing every column
printMatrix(arr);
System.out.println();
// Traverse each column of arr[][]
for (int i = 0; i < N; i++) {
// Initialise start and end index
int start = 0;
int end = M - 1;
// Till start < end, swap the
// element at start and end index
while (start < end) {
// Swap the element
arr = swap(arr, start, i, end, i);
// Increment start and decrement
// end for next pair of swapping
start++;
end--;
}
}
// Print the arr[][] after
// reversing every column
printMatrix(arr);
}
// Driver Code
public static void main(String[] args)
{
int arr[][]
= { { 3, 2, 1 }, { 4, 5, 6 }, { 9, 8, 7 } };
// Function call
reverseColumnArray(arr);
}
}
// This code is contributed by 29AjayKumar
### 1. Find the Maximum and Minimum Values of Each Row in a
2D Array
void findRowMaxMin(const vector<vector<int>>& matrix) {
for (int i = 0; i < matrix.size(); ++i) {
int maxVal = INT_MIN;
int minVal = INT_MAX;
for (int j = 0; j < matrix[i].size(); ++j) {
if (matrix[i][j] > maxVal) maxVal = matrix[i][j];
if (matrix[i][j] < minVal) minVal = matrix[i][j];
}
cout << "Row " << i + 1 << " - Max: " << maxVal << ", Min: " << minVal
<< endl;
}
}
### 2. Count the Number of Prime Numbers in a 1D
Array
bool isPrime(int n) {
if (n <= 1) return false;
for (int i = 2; i <= sqrt(n); ++i) {
if (n % i == 0) return false;
}
return true;
}
int countPrimes(const vector<int>& arr) {
int count = 0;
for (int num : arr) {
if (isPrime(num)) count++;
}
return count;
}
### 3. Transpose a Matrix (2D Array)
vector<vector<int>> transpose(const vector<vector<int>>& matrix) {
int rows = matrix.size();
int cols = matrix[0].size();
vector<vector<int>> transposed(cols, vector<int>(rows));
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
transposed[j][i] = matrix[i][j];
}
}
return transposed;
}
### 4. Sum of Elements Above and Below the Main
Diagonal of a Square Matrix
void sumAboveBelowDiagonal(const vector<vector<int>>& matrix) {
int aboveSum = 0, belowSum = 0;
for (int i = 0; i < matrix.size(); ++i) {
for (int j = 0; j < matrix[i].size(); ++j) {
if (i < j) aboveSum += matrix[i][j];
if (i > j) belowSum += matrix[i][j];
}
}
cout << "Sum above diagonal: " << aboveSum << endl;
cout << "Sum below diagonal: " << belowSum << endl;
}
### 6. Rotate a Matrix 90 Degrees Clockwise
void rotateMatrix(vector<vector<int>>& matrix) {
int n = matrix.size();
for (int i = 0; i < n / 2; ++i) {
for (int j = i; j < n - i - 1; ++j) {
int temp = matrix[i][j];
matrix[i][j] = matrix[n - j - 1][i];
matrix[n - j - 1][i] = matrix[n - i - 1][n - j - 1];
matrix[n - i - 1][n - j - 1] = matrix[j][n - i - 1];
matrix[j][n - i - 1] = temp;
}
}
}
### 7. Frequency of Each Element in a 1D Array
### 8. Sum of Border Elements in a 2D Array
int sumBorderElements(const vector<vector<int>>& matrix) {
int sum = 0;
int rows = matrix.size();
int cols = matrix[0].size();
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
if (i == 0 || i == rows - 1 || j == 0 || j == cols - 1) {
sum += matrix[i][j];
}
}
}
return sum;
}
### 9. Row or Column with the Highest Sum in a 2D
Array
int rowWithHighestSum(const vector<vector<int>>& matrix) {
int maxSum = 0, maxRow = 0;
for (int i = 0; i < matrix.size(); ++i) {
int rowSum = 0;
for (int j = 0; j < matrix[i].size(); ++j) {
rowSum += matrix[i][j];
}
if (rowSum > maxSum) {
maxSum = rowSum;
maxRow = i;
}
}
return maxRow;
}
### 10. Check if a 1D Array is a Palindrome
