Array Sorting Practice Problems (original) (raw)

Last Updated : 24 Sep, 2024

**Sorting an array means arranging the elements of the array in a certain order. Generally sorting in an array is done to arrange the elements in increasing or decreasing order.

**Problem statement: Given an array of integers arr, the task is to sort the array in ascending order and return it, **without using any built-in functions.

**Example:

**Input: arr = [5, 2, 4, 3, 1]
**Output: [1, 2, 3, 4, 5]

**Input: arr = [1, 2, 2, 1, 3, 5, 4]
**Output: [1, 1, 2, 2, 3, 4, 5]

Popular Sorting Algorithms:

1. **Bubble Sort****:** Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in the wrong order. This algorithm is not suitable for large arrays as its average and worst-case time complexity is quite high.
2. **Selection Sort****:** Selection sort is another sorting technique in which we find the minimum element in every iteration and place it in the array beginning from the first index. Thus, a selection sort also gets divided into a sorted and unsorted subarray.
3. **Insertion Sort****:** Insertion sort similarly to the way we sort playing cards in our hands. The array is virtually split into a sorted and an unsorted part. Values from the unsorted part are picked and placed in the correct position in the sorted part.
4. **Merge Sort****:** It is a sorting algorithm that is based on the Divide and Conquer paradigm. In this algorithm, the array is repeatedly divided into two equal halves and then they are combined in a sorted manner.
5. **Quick Sort****:** This is a sorting algorithm based on the divide and conquer approach where an array is divided into subarrays by selecting a pivot element (element selected from the array).
6. **Heap Sort****:** Heap sort is a comparison-based sorting technique based on Binary Heap data structure. It is similar to the selection sort where we first find the minimum element and place the minimum element at the beginning. Repeat the same process for the remaining elements.
7. **Counting Sort****:** Counting sort is a sorting technique based on keys between a specific range. It works by counting the number of elements having distinct key values (kind of hashing). Then do some arithmetic to calculate the position of each element in the output sequence.

To learn more about all other types of Sorting Algorithms, refer to the below articles:

• Introduction to Sorting Techniques - Data Structure and Algorithm Tutorials
• Sorting Algorithms

Comparison of Sorting Algorithms:

Implementing of Sorting Algorithm:

Below is a simple implementation of Bubble Sort Algorithms to sort the Array:

C++ `

#include <bits/stdc++.h> using namespace std;

// Function to sort the array using Bubble Sort void sortArray(vector& arr){ int n = arr.size();

for (int i = 0; i < n - 1; i++) {
    bool swapped = false;

    // Last i elements are already in place
    for (int j = 0; j < n - i - 1; j++) {
        if (arr[j] > arr[j + 1]) {
            swap(arr[j], arr[j + 1]);
            swapped = true;
        }
    }

    // If no two elements were swapped by inner loop,
    // then break
    if (!swapped)
        break;
}

}

void print(const vector& arr){ for(int num : arr) cout << num << " "; cout << endl; }

int main(){ vector arr = {64, 34, 25, 12, 22, 11, 90}; sortArray(arr); cout << "Sorted array: \n"; print(arr); return 0; }

C

#include <stdio.h>

// Function to sort the array using Bubble Sort void sortArray(int arr[], int n) {

// Outer loop to traverse the array
for (int i = 0; i < n - 1; i++) {
 
    int swapped = 0;  

    // Last i elements are already in place
    for (int j = 0; j < n - i - 1; j++) {
      
        // If the current element is greater than the next element
        if (arr[j] > arr[j + 1]) {
          
            // Swap the elements
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
            swapped = 1; 
        }
    }

    // If no two elements were swapped by inner loop,
    // then break the loop
    if (!swapped)
        break;
}

}

void printArray(int arr[], int size) { for (int i = 0; i < size; i++) printf("%d ", arr[i]); printf("\n"); }

int main() { int arr[] = {64, 34, 25, 12, 22, 11, 90}; int N = sizeof(arr) / sizeof(arr[0]); sortArray(arr, N); printf("Sorted array: \n"); printArray(arr, N); return 0; }

Java

import java.util.Arrays;

class GfG {

// Function to sort the array using Bubble Sort
static void sortArray(int[] arr) {
    int n = arr.length;      

    // Outer loop to traverse the array
    for (int i = 0; i < n - 1; i++) {
        boolean swapped = false;

        // Last i elements are already in place
        for (int j = 0; j < n - i - 1; j++) {
          
            // If the current element is greater
            // than the next element
            if (arr[j] > arr[j + 1]) {
              
                // Swap the elements
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true; // Set swapped to true
            }
        }

        // If no two elements were swapped by inner loop,
        // then break the loop
        if (!swapped)
            break;
    }
}

public static void main(String[] args) {
    int[] arr = {64, 34, 25, 12, 22, 11, 90};
    sortArray(arr);
    System.out.println("Sorted array: " + Arrays.toString(arr));
}

}

Python

Function to sort the array using Bubble Sort

def sortArray(arr): n = len(arr)

# Outer loop to traverse the array
for i in range(n - 1):
    swapped = False 
    
    # Last i elements are already in place
    for j in range(n - i - 1):
      
        # If the current element is greater
        # than the next element
        if arr[j] > arr[j + 1]:
          
            # Swap the elements
            arr[j], arr[j + 1] = arr[j + 1], arr[j]
            swapped = True 

    # If no two elements were swapped by inner loop,
    # then break the loop
    if not swapped:
        break

Driver code

arr = [64, 34, 25, 12, 22, 11, 90] sortArray(arr) print("Sorted array:", arr)

C#

using System;

class GfG {

// Function to sort the array using Bubble Sort
static void SortArray(int[] arr) {
    int n = arr.Length;

    // Outer loop to traverse the array
    for (int i = 0; i < n - 1; i++) {
        bool swapped = false; 
      
        // Last i elements are already in place
        for (int j = 0; j < n - i - 1; j++) {
          
            // If the current element is greater
            // than the next element
            if (arr[j] > arr[j + 1]) {
              
                // Swap the elements
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true; 
            }
        }

        // If no two elements were swapped by inner loop,
        // then break the loop
        if (!swapped)
            break;
    }
}

static void Main(string[] args) {
    int[] arr = { 64, 34, 25, 12, 22, 11, 90 };
    SortArray(arr);
    Console.WriteLine("Sorted array: " + string.Join(" ", arr));
}

}

JavaScript

// Function to sort the array using Bubble Sort function sortArray(arr) { let n = arr.length;

// Outer loop to traverse the array
for (let i = 0; i < n - 1; i++) {
    let swapped = false;

    // Last i elements are already in place
    for (let j = 0; j < n - i - 1; j++) {
    
        // If the current element is greater
        // than the next element
        if (arr[j] > arr[j + 1]) {
        
            // Swap the elements
            let temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
            swapped = true; 
        }
    }

    // If no two elements were swapped by inner loop,
    // then break the loop
    if (!swapped)
        break;
}

}

// Driver code let arr = [64, 34, 25, 12, 22, 11, 90]; sortArray(arr); console.log("Sorted array:", arr.join(" "));

`

Output

Sorted array: 11 12 22 25 34 64 90

**Complexity Analysis to Sort an Array using Bubble Sort:

**Time Complexity: O(N2)
**Auxiliary Space: O(1)

Important Terminologies in Array Sorting:

Here we will see several algorithms used for array sorting. But before that let us see some important terminologies related to sorting:

• **In-Place Sorting****:** In-place sorting means arranging the elements without using any extra space other than the given array.
• **Stability of Sorting****:** A sorting algorithm is said to be stable if the relative order of the same valued elements is preserved in the final sorted array i.e., the relative order of the same valued elements in the sorted array is the same as in the original array.

Practice Problems on Array Sorting

You can improve your understanding of array sorting by solving different problems based on their difficulty level.

**Easy Problems:

• Program to check if an array is sorted or not (Iterative and Recursive)
• Print sorted distinct elements of array in C++
• Print All Distinct Elements of a given integer array
• Alternative Sorting
• Sort an array in wave form
• Sort on the basis of number of factors using STL
• Sort an array which contain 1 to n values
• Sort 1 to N by swapping adjacent elements
• Sort elements by frequency | Set 1
• Sort an array containing two types of elements
• Sort an array according to absolute difference with given value
• Sorting all array elements except one
• Minimum product pair an array of positive Integers
• Minimum adjacent swaps required to Sort Binary array
• Pairs with Difference less than K

**Medium Problems:

• Sort a nearly sorted (or K sorted) array
• Count Inversions in an array | Set 1 (Using Merge Sort)
• Union and Intersection of two sorted arrays
• Sort an array of 0s, 1s and 2s
• Check if reversing a sub array make the array sorted
• Merge 3 Sorted Arrays
• Sorting array except elements in a subarray
• Count all distinct pairs with difference equal to k
• Construct an array from its pair-sum array
• Ropes left after every removal of smallest
• Check if any interval completely overlaps the other
• Maximizing Unique Pairs from two arrays

**Hard Problems:

• Minimum number of swaps required to sort an array
• Find the Minimum length Unsorted Subarray, sorting which makes the complete array sorted
• Median in a stream of integers (running integers)
• Merge two sorted arrays with O(1) extra space
• Minimum De-arrangements present in array of AP (Arithmetic Progression)
• Divide an array into k segments to maximize maximum of segment minimums
• Maximum number of partitions that can be sorted individually to make sorted
• Rank of all elements in an array
• Merging two unsorted arrays in sorted order
• Sort an array after applying the given equation
• Minimum swaps to make two arrays consisting unique elements identical

**Quick Links :

• 'Practice Problems' on Arrays
• 'Quizzes' on Arrays
• 'Video Tutorials' on Arrays

Similar Reads

• Array Data Structure Complete Guide to ArraysLearn more about Array in DSA Self Paced CoursePractice Problems on ArraysTop Quizzes on Arrays What is Array?An array is a collection of items stored at contiguous memory locations. The idea is to store multiple items of the same type together. This makes it easier to calcul 3 min read
• What is Array? Array is a linear data structure where all elements are arranged sequentially. It is a collection of elements of same data type stored at contiguous memory locations. For simplicity, we can think of an array as a flight of stairs where on each step is placed a value (let's say one of your friends). 2 min read
• Getting Started with Array Data Structure Array is a collection of items of the same variable type that are stored at contiguous memory locations. It is one of the most popular and simple data structures used in programming. Basic terminologies of ArrayArray Index: In an array, elements are identified by their indexes. Array index starts fr 14 min read
• Applications, Advantages and Disadvantages of Array Array is a linear data structure that is a collection of data elements of same types. Arrays are stored in contiguous memory locations. It is a static data structure with a fixed size.Table of ContentApplications of Array Data Structure:Advantages of Array Data Structure:Disadvantages of Array Data 2 min read
• Subarrays, Subsequences, and Subsets in Array What is a Subarray?A subarray is a contiguous part of array, i.e., Subarray is an array that is inside another array. In general, for an array of size n, there are n*(n+1)/2 non-empty subarrays. For example, Consider the array [1, 2, 3, 4], There are 10 non-empty sub-arrays. The subarrays are: (1), 10 min read

Basic operations in Array

• Searching in Array Searching is one of the most common operations performed in an array. Array searching can be defined as the operation of finding a particular element or a group of elements in the array. There are several searching algorithms. The most commonly used among them are: Linear Search Binary Search Ternar 4 min read

• Array Reverse - Complete Tutorial Given an array arr[], the task is to reverse the array. Reversing an array means rearranging the elements such that the first element becomes the last, the second element becomes second last and so on.Examples: Input: arr[] = {1, 4, 3, 2, 6, 5} Output: {5, 6, 2, 3, 4, 1}Explanation: The first elemen 15+ min read

• Rotate an Array by d - Counterclockwise or Left Given an array of integers arr[] of size n, the task is to rotate the array elements to the left by d positions.Examples:Input: arr[] = {1, 2, 3, 4, 5, 6}, d = 2Output: {3, 4, 5, 6, 1, 2}Explanation: After first left rotation, arr[] becomes {2, 3, 4, 5, 6, 1} and after the second rotation, arr[] bec 15+ min read

• Print array after it is right rotated K times Given an Array of size N and a value K, around which we need to right rotate the array. How do you quickly print the right rotated array?Examples : Input: Array[] = {1, 3, 5, 7, 9}, K = 2.Output: 7 9 1 3 5Explanation:After 1st rotation - {9, 1, 3, 5, 7}After 2nd rotation - {7, 9, 1, 3, 5} Input: Arr 15+ min read

• Search, Insert, and Delete in an Unsorted Array | Array Operations In this post, a program to search, insert, and delete operations in an unsorted array is discussed.Search Operation:In an unsorted array, the search operation can be performed by linear traversal from the first element to the last element. Coding implementation of the search operation:C++// C++ prog 15+ min read

• Search, Insert, and Delete in an Sorted Array | Array Operations How to Search in a Sorted Array?In a sorted array, the search operation can be performed by using binary search.Below is the implementation of the above approach:C++// C++ program to implement binary search in sorted array #include <bits/stdc++.h> using namespace std; int binarySearch(int arr[ 15+ min read

• Array Sorting - Practice Problems Sorting an array means arranging the elements of the array in a certain order. Generally sorting in an array is done to arrange the elements in increasing or decreasing order. Problem statement: Given an array of integers arr, the task is to sort the array in ascending order and return it, without u 9 min read

• Generating All Subarrays Given an array arr[], the task is to generate all the possible subarrays of the given array.Examples: Input: arr[] = [1, 2, 3]Output: [ [1], [1, 2], [2], [1, 2, 3], [2, 3], [3] ]Input: arr[] = [1, 2]Output: [ [1], [1, 2], [2] ]Iterative ApproachTo generate a subarray, we need a starting index from t 8 min read

Easy problems on Array

• Largest three distinct elements in an array Given an array arr[], the task is to find the top three largest distinct integers present in the array.Note: If there are less than three distinct elements in the array, then return the available distinct numbers in descending order.Examples :Input: arr[] = [10, 4, 3, 50, 23, 90]Output: [90, 50, 23] 6 min read

• Second Largest Element in an Array Given an array of positive integers arr[] of size n, the task is to find second largest distinct element in the array.Note: If the second largest element does not exist, return -1. Examples:Input: arr[] = [12, 35, 1, 10, 34, 1]Output: 34Explanation: The largest element of the array is 35 and the sec 14 min read

• Move all zeros to end of array Given an array of integers arr[], the task is to move all the zeros to the end of the array while maintaining the relative order of all non-zero elements.Examples: Input: arr[] = [1, 2, 0, 4, 3, 0, 5, 0]Output: arr[] = [1, 2, 4, 3, 5, 0, 0, 0]Explanation: There are three 0s that are moved to the end 15 min read

• Rearrange array such that even positioned are greater than odd Given an array arr[], sort the array according to the following relations: arr[i] >= arr[i - 1], if i is even, ∀ 1 <= i < narr[i] <= arr[i - 1], if i is odd, ∀ 1 <= i < nFind the resultant array.[consider 1-based indexing]Examples: Input: arr[] = [1, 2, 2, 1]Output: [1 2 1 2] Expla 9 min read

• Rearrange an array in maximum minimum form using Two Pointer Technique Given a sorted array of positive integers, rearrange the array alternately i.e first element should be a maximum value, at second position minimum value, at third position second max, at fourth position second min, and so on. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6, 7} Output: arr[] = {7, 1, 6, 2 6 min read

• Segregate even and odd numbers using Lomuto’s Partition Scheme Given an array arr[] of integers, segregate even and odd numbers in the array such that all the even numbers should be present first, and then the odd numbers.Examples: Input: arr[] = {7, 2, 9, 4, 6, 1, 3, 8, 5}Output: 2 4 6 8 7 9 1 3 5Input: arr[] = {1, 3, 2, 4, 7, 6, 9, 10}Output: 2 4 6 10 7 1 9 3 6 min read

• Reversal algorithm for Array rotation Given an array arr[] of size N, the task is to rotate the array by d position to the left. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6, 7}, d = 2Output: 3, 4, 5, 6, 7, 1, 2Explanation: If the array is rotated by 1 position to the left, it becomes {2, 3, 4, 5, 6, 7, 1}.When it is rotated further by 1 15 min read

• Print left rotation of array in O(n) time and O(1) space Given an array of size n and multiple values around which we need to left rotate the array. How to quickly print multiple left rotations?Examples : Input : arr[] = {1, 3, 5, 7, 9}k1 = 1k2 = 3k3 = 4k4 = 6Output : 3 5 7 9 17 9 1 3 59 1 3 5 73 5 7 9 1Input : arr[] = {1, 3, 5, 7, 9}k1 = 14 Output : 9 1 15+ min read

• Sort an array which contain 1 to n values We are given an array that contains 1 to n elements, our task is to sort this array in an efficient way. We are not allowed to simply copy the numbers from 1 to n.Examples : Input : arr[] = {2, 1, 3};Output : {1, 2, 3}Input : arr[] = {2, 1, 4, 3};Output : {1, 2, 3, 4} Native approach - O(n Log n) Ti 7 min read

• Count Possible Triangles Given an unsorted array of positive integers, the task is to find the number of triangles that can be formed with three different array elements as three sides of triangles. For a triangle to be possible from 3 values as sides, the sum of the two values (or sides) must always be greater than the thi 15+ min read

• Print all Distinct (Unique) Elements in given Array Given an integer array arr[], print all distinct elements from this array. The given array may contain duplicates and the output should contain every element only once.Examples: Input: arr[] = {12, 10, 9, 45, 2, 10, 10, 45}Output: {12, 10, 9, 45, 2}Input: arr[] = {1, 2, 3, 4, 5}Output: {1, 2, 3, 4, 11 min read

• Unique Number I Given an array of integers, every element in the array appears twice except for one element which appears only once. The task is to identify and return the element that occurs only once.Examples: Input: arr[] = [2, 3, 5, 4, 5, 3, 4]Output: 2 Explanation: Since 2 occurs once, while other numbers occu 8 min read

• Leaders in an array Given an array arr[] of size n, the task is to find all the Leaders in the array. An element is a Leader if it is greater than or equal to all the elements to its right side. Note: The rightmost element is always a leader. Examples: Input: arr[] = [16, 17, 4, 3, 5, 2]Output: [17 5 2]Explanation: 17 10 min read

• Subarray with Given Sum Given a 1-based indexing array arr[] of non-negative integers and an integer sum. You mainly need to return the left and right indexes(1-based indexing) of that subarray. In case of multiple subarrays, return the subarray indexes which come first on moving from left to right. If no such subarray exi 10 min read

Intermediate problems on Array

• Rearrange an array such that arr[i] = i Given an array of elements of length n, ranging from 0 to n - 1. All elements may not be present in the array. If the element is not present then there will be -1 present in the array. Rearrange the array such that arr[i] = i and if i is not present, display -1 at that place.Examples: Input: arr[] = 13 min read

• Alternate Rearrangement of Positives and Negatives An array contains both positive and negative numbers in random order. Rearrange the array elements so that positive and negative numbers are placed alternatively. A number of positive and negative numbers need not be equal. If there are more positive numbers they appear at the end of the array. If t 11 min read

• Reorder an array according to given indexes Given two integer arrays of the same length, arr[] and index[], the task is to reorder the elements in arr[] such that after reordering, each element from arr[i] moves to the position index[i]. The new arrangement reflects the values being placed at their target indices, as described by index[] arra 15+ min read

• Find the smallest missing number Given a sorted array of n distinct integers where each integer is in the range from 0 to m-1 and m > n. Find the smallest number that is missing from the array. Examples: Input: {0, 1, 2, 6, 9}, n = 5, m = 10 Output: 3 Input: {4, 5, 10, 11}, n = 4, m = 12 Output: 0 Input: {0, 1, 2, 3}, n = 4, m = 15 min read

• Difference Array | Range update query in O(1) You are given an integer array arr[] and a list of queries. Each query is represented as a list of integers where:[1, l, r, x]: Adds x to all elements from arr[l] to arr[r] (inclusive).[2]: Prints the current state of the array.You need to perform the queries in order.Examples : Input: arr[] = [10, 10 min read

• Stock Buy and Sell – Max 2 Transactions Allowed In the stock market, a person buys a stock and sells it on some future date. Given the stock prices of n days in an array prices[ ]. Find out the maximum profit a person can make in at most 2 transactions. A transaction is equivalent to (buying + selling) of a stock and a new transaction can start o 15+ min read

• Smallest subarray with sum greater than a given value Given an array arr[] of integers and a number x, the task is to find the smallest subarray with a sum strictly greater than x.Examples:Input: x = 51, arr[] = [1, 4, 45, 6, 0, 19]Output: 3Explanation: Minimum length subarray is [4, 45, 6]Input: x = 100, arr[] = [1, 10, 5, 2, 7]Output: 0Explanation: N 15+ min read

• Count Inversions of an Array Given an integer array arr[] of size n, find the inversion count in the array. Two array elements arr[i] and arr[j] form an inversion if arr[i] > arr[j] and i < j.Note: Inversion Count for an array indicates that how far (or close) the array is from being sorted. If the array is already sorted 15+ min read

• Merge Two Sorted Arrays Without Extra Space Given two sorted arrays a[] and b[] of size n and m respectively, the task is to merge both the arrays and rearrange the elements such that the smallest n elements are in a[] and the remaining m elements are in b[]. All elements in a[] and b[] should be in sorted order.Examples: Input: a[] = [2, 4, 15+ min read

• Majority Element You are given an array arr, and your task is to find the majority element an element that occurs more than half the length of the array (i.e., arr.size() / 2). If such an element exists return it, otherwise return -1, indicating that no majority element is present.Examples : Input : arr[] = [1, 1, 2 15+ min read

• Two Pointers Technique Two pointers is really an easy and effective technique that is typically used for Two Sum in Sorted Arrays, Closest Two Sum, Three Sum, Four Sum, Trapping Rain Water and many other popular interview questions. Given a sorted array arr (sorted in ascending order) and a target, find if there exists an 11 min read

• 3 Sum - Triplet Sum in Array Given an array arr[] of size n and an integer sum, the task is to check if there is a triplet in the array which sums up to the given target sum.Examples: Input: arr[] = [1, 4, 45, 6, 10, 8], target = 13Output: true Explanation: The triplet [1, 4, 8] sums up to 13Input: arr[] = [1, 2, 4, 3, 6, 7], t 15 min read

• Equilibrium Index Given an array arr[] of size n, the task is to return an equilibrium index (if any) or -1 if no equilibrium index exists. The equilibrium index of an array is an index such that the sum of all elements at lower indexes equals the sum of all elements at higher indexes. Note: When the index is at the 15 min read

Hard problems on Array

• MO's Algorithm (Query Square Root Decomposition) | Set 1 (Introduction) Let us consider the following problem to understand MO's Algorithm. We are given an array and a set of query ranges, we are required to find the sum of every query range.Example: Input: arr[] = {1, 1, 2, 1, 3, 4, 5, 2, 8}; query[] = [0, 4], [1, 3] [2, 4]Output: Sum of arr[] elements in range [0, 4] 15+ min read

• Square Root (Sqrt) Decomposition Algorithm Square Root Decomposition Technique is one of the most common query optimization techniques used by competitive programmers. This technique helps us to reduce Time Complexity by a factor of sqrt(N) The key concept of this technique is to decompose a given array into small chunks specifically of size 15+ min read

• Sparse Table Sparse table concept is used for fast queries on a set of static data (elements do not change). It does preprocessing so that the queries can be answered efficiently.Range Minimum Query Using Sparse TableYou are given an integer array arr of length n and an integer q denoting the number of queries. 15+ min read

• Range sum query using Sparse Table We have an array arr[]. We need to find the sum of all the elements in the range L and R where 0 <= L <= R <= n-1. Consider a situation when there are many range queries. Examples: Input : 3 7 2 5 8 9 query(0, 5) query(3, 5) query(2, 4) Output : 34 22 15Note : array is 0 based indexed and q 8 min read

• Range LCM Queries Given an array arr[] of integers of size N and an array of Q queries, query[], where each query is of type [L, R] denoting the range from index L to index R, the task is to find the LCM of all the numbers of the range for all the queries.Examples: Input: arr[] = {5, 7, 5, 2, 10, 12 ,11, 17, 14, 1, 4 15+ min read

• Jump Game - Minimum Jumps to Reach End Given an array arr[] of non-negative numbers. Each number tells you the maximum number of steps you can jump forward from that position.For example:If arr[i] = 3, you can jump to index i + 1, i + 2, or i + 3 from position i.If arr[i] = 0, you cannot jump forward from that position.Your task is to fi 15+ min read

• Space optimization using bit manipulations There are many situations where we use integer values as index in array to see presence or absence, we can use bit manipulations to optimize space in such problems.Let us consider below problem as an example.Given two numbers say a and b, mark the multiples of 2 and 5 between a and b using less than 12 min read

• Maximum value of Sum(i*arr[i]) with array rotations allowed Given an array arr[], the task is to determine the maximum possible value of the expression i*arr[i] after rotating the array any number of times (including zero).Note: In each rotation, every element of the array shifts one position to the right, and the last element moves to the front.Examples : I 12 min read

• Construct an array from its pair-sum array Given a pair-sum array construct the original array. A pair-sum array for an array is the array that contains sum of all pairs in ordered form, i.e., pair[0] is sum of arr[0] and arr[1], pair[1] is sum of arr[0] and arr[2] and so on. Note that if the size of input array is n, then the size of pair a 5 min read

• Maximum equilibrium sum in an array Given an array arr[]. Find the maximum value of prefix sum which is also suffix sum for index i in arr[].Examples : Input : arr[] = {-1, 2, 3, 0, 3, 2, -1}Output : 4Explanation : Prefix sum of arr[0..3] = Suffix sum of arr[3..6]Input : arr[] = {-3, 5, 3, 1, 2, 6, -4, 2}Output : 7Explanation : Prefix 11 min read

• Smallest Difference Triplet from Three arrays Three arrays of same size are given. Find a triplet such that maximum - minimum in that triplet is minimum of all the triplets. A triplet should be selected in a way such that it should have one number from each of the three given arrays. If there are 2 or more smallest difference triplets, then the 9 min read

• Top 50 Array Coding Problems for Interviews Array is one of the most widely used data structure and is frequently asked in coding interviews to the problem solving skills. The following list of 50 array coding problems covers a range of difficulty levels, from easy to hard, to help candidates prepare for interviews.Easy ProblemsSecond Largest 2 min read