In this lecture, I have explained more 10 programming on arrays in C programming. In your previous class, you learned about the basic features of the array with some basic programming. In this article, I am going to explain more complex array programs.
1. Program to Remove Duplicates from an Array
#include <stdio.h>
int main() {
int arr[10], n, i, j, k;
printf(“Enter the number of elements: “);
scanf(“%d”, &n);
printf(“Enter %d integers: “, n);
for (i = 0; i < n; i++) {
scanf(“%d”, &arr[i]);
}
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
if (arr[i] == arr[j]) {
for (k = j; k < n – 1; k++) {
arr[k] = arr[k + 1];
}
n–;
j–;
}
}
}
printf(“Array after removing duplicates: “);
for (i = 0; i < n; i++) {
printf(“%d “, arr[i]);
}
return 0;
}
DRY-RUN:
| Step | i (Outer Loop) | j (Inner Loop) | arr[] | Action Taken |
| 1 | 0 | 1 | [1, 2, 2, 3, 4, 4, 5] | Compare arr[0] with arr[1], no change. |
| 2 | 0 | 2 | [1, 2, 2, 3, 4, 4, 5] | Compare arr[0] with arr[2], remove duplicate 2. |
| 3 | 0 | 3 | [1, 2, 3, 4, 4, 5] | Compare arr[0] with arr[3], no change. |
| 4 | 0 | 4 | [1, 2, 3, 4, 4, 5] | Compare arr[0] with arr[4], remove duplicate 4. |
| 5 | 0 | 5 | [1, 2, 3, 4, 5] | Compare arr[0] with arr[5], no change. |
| 6 | 1 | 2 | [1, 2, 3, 4, 5] | Compare arr[1] with arr[2], no change. |
| 7 | 1 | 3 | [1, 2, 3, 4, 5] | Compare arr[1] with arr[3], no change. |
| 8 | 1 | 4 | [1, 2, 3, 4, 5] | Compare arr[1] with arr[4], no change. |
| 9 | 1 | 5 | [1, 2, 3, 4, 5] | Compare arr[1] with arr[5], no change. |
| 10 | 2 | 3 | [1, 2, 3, 4, 5] | Compare arr[2] with arr[3], no change. |
| 11 | 2 | 4 | [1, 2, 3, 4, 5] | Compare arr[2] with arr[4], no change. |
| 12 | 2 | 5 | [1, 2, 3, 4, 5] | Compare arr[2] with arr[5], no change. |
| 13 | 3 | 4 | [1, 2, 3, 4, 5] | Compare arr[3] with arr[4], no change. |
| 14 | 3 | 5 | [1, 2, 3, 4, 5] | Compare arr[3] with arr[5], no change. |
| 15 | 4 | 5 | [1, 2, 3, 4, 5] | Compare arr[4] with arr[5], no change. |
| 16 | End | End | [1, 2, 3, 4, 5] | Final array after removing duplicates. |
2. Program to Rotate an Array to the Right
#include <stdio.h>
int main() {
int arr[5], i, j, temp;
printf(“Enter 5 integers: “);
for (i = 0; i < 5; i++) {
scanf(“%d”, &arr[i]);
}
temp = arr[4];
for (i = 4; i > 0; i–) {
arr[i] = arr[i – 1];
}
arr[0] = temp;
printf(“Array after right rotation: “);
for (i = 0; i < 5; i++) {
printf(“%d “, arr[i]);
}
return 0;
}
DRY-RUN:
| Step | i | arr[] | temp | Action Taken |
| 1 | 0 | [1, 2, 3, 4, 5] | Input: arr[0] = 1, arr[1] = 2, arr[2] = 3, arr[3] = 4, arr[4] = 5 | |
| 2 | 1 | [1, 2, 3, 4, 5] | Loop input complete, last element (arr[4]) is stored in temp = 5 | |
| 3 | 2 | [1, 2, 3, 4, 5] | 5 | Shift arr[4] to arr[3]: arr[4] = arr[3], arr[] becomes [1, 2, 3, 4, 4] |
| 4 | 3 | [1, 2, 3, 4, 4] | 5 | Shift arr[3] to arr[2]: arr[3] = arr[2], arr[] becomes [1, 2, 3, 3, 4] |
| 5 | 4 | [1, 2, 3, 3, 4] | 5 | Shift arr[2] to arr[1]: arr[2] = arr[1], arr[] becomes [1, 2, 2, 3, 4] |
| 6 | 5 | [1, 2, 2, 3, 4] | 5 | Shift arr[1] to arr[0]: arr[1] = arr[0], arr[] becomes [1, 1, 2, 3, 4] |
| 7 | 6 | [5, 2, 2, 3, 4] | 5 | arr[0] is set to temp = 5, final array becomes [5, 1, 2, 3, 4] |
| 8 | End | [5, 1, 2, 3, 4] | The array after rotation is printed. Output: 5 1 2 3 4 |
3. Program to Count Occurrences of a Specific Element in an Array
#include <stdio.h>
int main() {
int arr[5], target, count = 0;
printf(“Enter 5 integers: “);
for (int i = 0; i < 5; i++) {
scanf(“%d”, &arr[i]);
}
printf(“Enter the number to count: “);
scanf(“%d”, &target);
for (int i = 0; i < 5; i++) {
if (arr[i] == target) {
count++;
}
}
printf(“The number %d appears %d times.”, target, count);
return 0;
}
DRY-RUN:
| Step | i | arr[] | target | count | Action Taken |
| 1 | 0 | [1, 2, 3, 2, 4] | 2 | 0 | Input: arr[0] = 1, arr[1] = 2, arr[2] = 3, arr[3] = 2, arr[4] = 4 |
| 2 | 1 | [1, 2, 3, 2, 4] | 2 | 0 | arr[0] = 1 is not equal to target = 2, so count remains 0. |
| 3 | 2 | [1, 2, 3, 2, 4] | 2 | 0 | arr[1] = 2 is equal to target = 2, so increment count to 1. |
| 4 | 3 | [1, 2, 3, 2, 4] | 2 | 1 | arr[2] = 3 is not equal to target = 2, so count remains 1. |
| 5 | 4 | [1, 2, 3, 2, 4] | 2 | 1 | arr[3] = 2 is equal to target = 2, so increment count to 2. |
| 6 | 5 | [1, 2, 3, 2, 4] | 2 | 2 | arr[4] = 4 is not equal to target = 2, so count remains 2. |
| 7 | End | [1, 2, 3, 2, 4] | 2 | 2 | The final count is printed: “The number 2 appears 2 times.” |
4. Program to Find the Second Largest Element in an Array
#include <stdio.h>
int main() {
int arr[5], largest, second_largest;
printf(“Enter 5 integers: “);
for (int i = 0; i < 5; i++) {
scanf(“%d”, &arr[i]);
}
largest = second_largest = arr[0];
for (int i = 1; i < 5; i++) {
if (arr[i] > largest) {
second_largest = largest;
largest = arr[i];
} else if (arr[i] > second_largest && arr[i] != largest) {
second_largest = arr[i];
}
}
printf(“Second largest element: %d”, second_largest);
return 0;
}
DRY-RUN:
| Step | i | arr[] | largest | second_largest | Action Taken |
| 1 | 0 | [10, 20, 4, 45, 30] | 10 | 10 | Input: arr[0] = 10, arr[1] = 20, arr[2] = 4, arr[3] = 45, arr[4] = 30 |
| 2 | 1 | [10, 20, 4, 45, 30] | 10 | 10 | arr[1] = 20 is greater than largest = 10, so update: largest = 20, second_largest = 10. |
| 3 | 2 | [10, 20, 4, 45, 30] | 20 | 10 | arr[2] = 4 is smaller than both largest and second_largest, no change. |
| 4 | 3 | [10, 20, 4, 45, 30] | 20 | 10 | arr[3] = 45 is greater than largest = 20, so update: largest = 45, second_largest = 20. |
| 5 | 4 | [10, 20, 4, 45, 30] | 45 | 20 | arr[4] = 30 is smaller than both largest and second_largest, no change. |
| 6 | End | [10, 20, 4, 45, 30] | 45 | 20 | The second largest element is 20, which is printed. |
5. Program to Check If an Array is Palindrome
#include <stdio.h>
int main() {
int arr[5], i, is_palindrome = 1;
printf(“Enter 5 integers: “);
for (i = 0; i < 5; i++) {
scanf(“%d”, &arr[i]);
}
for (i = 0; i < 5 / 2; i++) {
if (arr[i] != arr[5 – i – 1]) {
is_palindrome = 0;
break;
}
}
if (is_palindrome) {
printf(“The array is a palindrome.”);
} else {
printf(“The array is not a palindrome.”);
}
return 0;
}
DRY-RUN:
| Step | i | arr[] | is_palindrome | Action Taken |
| 1 | 0 | [1, 2, 3, 4, 5] | 1 | Input: arr[0] = 1, arr[1] = 2, arr[2] = 3, arr[3] = 4, arr[4] = 5 |
| 2 | 0 | [1, 2, 3, 4, 5] | 1 | Check: arr[0] = 1, arr[4] = 5 → they don’t match, set is_palindrome = 0 and break. |
| 3 | End | [1, 2, 3, 4, 5] | 0 | The final output: “The array is not a palindrome.” |
6. Program to Find the Frequency of Each Element in an Array
#include <stdio.h>
int main() {
int arr[5], freq[5] = {0}, i, j;
printf(“Enter 5 integers: “);
for (i = 0; i < 5; i++) {
scanf(“%d”, &arr[i]);
}
for (i = 0; i < 5; i++) {
if (freq[i] == 0) {
freq[i] = 1;
for (j = i + 1; j < 5; j++) {
if (arr[i] == arr[j]) {
freq[i]++;
}
}
}
}
printf(“Element frequencies: “);
for (i = 0; i < 5; i++) {
if (freq[i] > 0) {
printf(“%d occurs %d times\n”, arr[i], freq[i]);
}
}
return 0;
}
DRY-RUN:
| Step | i | arr[] | freq[] | j | Action Taken |
| 1 | 0 | [1, 2, 2, 3, 1] | [0, 0, 0, 0, 0] | – | Input the array values: arr[0] = 1, arr[1] = 2, arr[2] = 2, arr[3] = 3, arr[4] = 1 |
| 2 | 0 | [1, 2, 2, 3, 1] | [1, 0, 0, 0, 0] | 1 | For arr[0] = 1, start checking. freq[0] becomes 1. |
| 3 | 1 | [1, 2, 2, 3, 1] | [1, 1, 0, 0, 0] | 2 | For arr[1] = 2, start checking. freq[1] becomes 1. |
| 4 | 1 | [1, 2, 2, 3, 1] | [1, 2, 0, 0, 0] | 3 | arr[1] = 2, arr[2] = 2 (match) → freq[1] increments to 2. |
| 5 | 2 | [1, 2, 2, 3, 1] | [1, 2, 0, 0, 0] | – | Continue, no match needed. freq[2] remains 0. |
| 6 | 3 | [1, 2, 2, 3, 1] | [1, 2, 0, 1, 0] | – | For arr[3] = 3, no further match needed. freq[3] becomes 1. |
| 7 | 4 | [1, 2, 2, 3, 1] | [2, 2, 0, 1, 0] | – | For arr[4] = 1, arr[0] = 1 (match) → freq[0] increments to 2. |
| 8 | End | [1, 2, 2, 3, 1] | [2, 2, 0, 1, 0] | – | Final frequencies: 1 occurs 2 times, 2 occurs 2 times, 3 occurs 1 time. |
| 9 | Final Output | – | – | Output: “Element frequencies:1 occurs 2 times,2 occurs 2 times, 3 occurs 1 time.” |
7. Program to Insert an Element at a Specific Position
#include <stdio.h>
int main() {
int arr[6], i, pos, element;
printf(“Enter 5 integers: “);
for (i = 0; i < 5; i++) {
scanf(“%d”, &arr[i]);
}
printf(“Enter position and element to insert: “);
scanf(“%d %d”, &pos, &element);
for (i = 5; i >= pos; i–) {
arr[i] = arr[i – 1];
}
arr[pos – 1] = element;
printf(“Array after insertion: “);
for (i = 0; i < 6; i++) {
printf(“%d “, arr[i]);
}
return 0;
}
DRY-RUN:
| Step | i | arr[] | pos | element | Action Description |
| 1 | – | [1, 2, 3, 4, 5] | – | – | Input the original array: 1, 2, 3, 4, 5 |
| 2 | 0 | [1, 2, 3, 4, 5] | 3 | 99 | Input position = 3, element to insert = 99. |
| 3 | 4 | [1, 2, 3, 4, 5] | – | – | Start shifting elements starting from position 5: arr[5] = arr[4]. arr becomes [1, 2, 3, 4, 5, 5] |
| 4 | 3 | [1, 2, 3, 4, 5, 5] | – | – | arr[4] = arr[3]. arr becomes [1, 2, 3, 4, 4, 5] |
| 5 | 2 | [1, 2, 3, 4, 4, 5] | – | – | arr[3] = arr[2]. arr becomes [1, 2, 3, 3, 4, 5] |
| 6 | 1 | [1, 2, 3, 3, 4, 5] | – | – | arr[2] = arr[1]. arr becomes [1, 2, 2, 3, 4, 5] |
| 7 | 0 | [1, 2, 2, 3, 4, 5] | – | – | arr[1] = arr[0]. arr becomes [1, 1, 2, 3, 4, 5] |
| 8 | – | [1, 2, 99, 3, 4, 5] | – | – | Insert element 99 at position 3: arr[2] = 99 |
| 9 | Final | [1, 2, 99, 3, 4, 5] | – | – | Output: “Array after insertion: 1 2 99 3 4 5” |
8. Program to Delete an Element from an Array
#include <stdio.h>
int main() {
int arr[5], i, pos;
printf(“Enter 5 integers: “);
for (i = 0; i < 5; i++) {
scanf(“%d”, &arr[i]);
}
printf(“Enter the position to delete: “);
scanf(“%d”, &pos);
for (i = pos – 1; i < 4; i++) {
arr[i] = arr[i + 1];
}
printf(“Array after deletion: “);
for (i = 0; i < 4; i++) {
printf(“%d “, arr[i]);
}
return 0;
}
DRY-RUN:
| Step | i | arr[] | pos | Action Description |
| 1 | – | [1, 2, 3, 4, 5] | – | Input the original array: 1, 2, 3, 4, 5 |
| 2 | – | – | 3 | Input position to delete: position = 3 |
| 3 | 2 | [1, 2, 3, 4, 5] | – | Start shifting elements starting from position 3: arr[2] = arr[3]. arr becomes [1, 2, 4, 4, 5] |
| 4 | 3 | [1, 2, 4, 4, 5] | – | arr[3] = arr[4]. arr becomes [1, 2, 4, 5, 5] |
| 5 | Final | [1, 2, 4, 5, 5] | – | Last element (5) is effectively removed as array shrinks to 4 elements. |
| 6 | Final | [1, 2, 4, 5] | – | Output: “Array after deletion: 1 2 4 5” |
9. Program to Check If Two Arrays Are Equal
#include <stdio.h>
int main() {
int arr1[5], arr2[5], equal = 1;
printf(“Enter 5 integers for first array: “);
for (int i = 0; i < 5; i++) {
scanf(“%d”, &arr1[i]);
}
printf(“Enter 5 integers for second array: “);
for (int i = 0; i < 5; i++) {
scanf(“%d”, &arr2[i]);
}
for (int i = 0; i < 5; i++) {
if (arr1[i] != arr2[i]) {
equal = 0;
break;
}
}
if (equal) {
printf(“Arrays are equal.”);
} else {
printf(“Arrays are not equal.”);
}
return 0;
}
DRY-RUN:
| Step | i | arr1[] | arr2[] | equal | Action Description |
| 1 | – | [1, 2, 3, 4, 5] | – | – | Input first array: 1 2 3 4 5 |
| 2 | – | – | [1, 2, 3, 4, 6] | – | Input second array: 1 2 3 4 6 |
| 3 | 0 | [1, 2, 3, 4, 5] | [1, 2, 3, 4, 6] | 1 | Compare arr1[0] = arr2[0] (1 == 1), continue loop |
| 4 | 1 | [1, 2, 3, 4, 5] | [1, 2, 3, 4, 6] | 1 | Compare arr1[1] = arr2[1] (2 == 2), continue loop |
| 5 | 2 | [1, 2, 3, 4, 5] | [1, 2, 3, 4, 6] | 1 | Compare arr1[2] = arr2[2] (3 == 3), continue loop |
| 6 | 3 | [1, 2, 3, 4, 5] | [1, 2, 3, 4, 6] | 1 | Compare arr1[3] = arr2[3] (4 == 4), continue loop |
| 7 | 4 | [1, 2, 3, 4, 5] | [1, 2, 3, 4, 6] | 0 | Compare arr1[4] = arr2[4] (5 != 6), set equal to 0 and break loop |
| 8 | – | – | – | 0 | Print “Arrays are not equal.” |
10. Program to Sum Two Arrays Element-Wise
#include <stdio.h>
int main() {
int arr1[5], arr2[5], sum[5];
printf(“Enter 5 integers for first array: “);
for (int i = 0; i < 5; i++) {
scanf(“%d”, &arr1[i]);
}
printf(“Enter 5 integers for second array: “);
for (int i = 0; i < 5; i++) {
scanf(“%d”, &arr2[i]);
}
for (int i = 0; i < 5; i++) {
sum[i] = arr1[i] + arr2[i];
}
printf(“Sum of two arrays: “);
for (int i = 0; i < 5; i++) {
printf(“%d “, sum[i]);
}
return 0;
}
DRY-RUN:
| Step | i | arr1[] | arr2[] | sum[] | Action Description |
| 1 | – | [1, 2, 3, 4, 5] | [5, 4, 3, 2, 1] | [0, 0, 0, 0, 0] | Input both arrays |
| 2 | 0 | [1, 2, 3, 4, 5] | [5, 4, 3, 2, 1] | [6, 0, 0, 0, 0] | sum[0] = 1 + 5 = 6 |
| 3 | 1 | [1, 2, 3, 4, 5] | [5, 4, 3, 2, 1] | [6, 6, 0, 0, 0] | sum[1] = 2 + 4 = 6 |
| 4 | 2 | [1, 2, 3, 4, 5] | [5, 4, 3, 2, 1] | [6, 6, 6, 0, 0] | sum[2] = 3 + 3 = 6 |
| 5 | 3 | [1, 2, 3, 4, 5] | [5, 4, 3, 2, 1] | [6, 6, 6, 6, 0] | sum[3] = 4 + 2 = 6 |
| 6 | 4 | [1, 2, 3, 4, 5] | [5, 4, 3, 2, 1] | [6, 6, 6, 6, 6] | sum[4] = 5 + 1 = 6 |
| 7 | – | – | – | [6, 6, 6, 6, 6] | Output: “Sum of two arrays: 6 6 6 6 6” |