Skip to content
geeksforgeeks
  • Courses
    • DSA to Development
    • Get IBM Certification
    • Newly Launched!
      • Master Django Framework
      • Become AWS Certified
    • For Working Professionals
      • Interview 101: DSA & System Design
      • Data Science Training Program
      • JAVA Backend Development (Live)
      • DevOps Engineering (LIVE)
      • Data Structures & Algorithms in Python
    • For Students
      • Placement Preparation Course
      • Data Science (Live)
      • Data Structure & Algorithm-Self Paced (C++/JAVA)
      • Master Competitive Programming (Live)
      • Full Stack Development with React & Node JS (Live)
    • Full Stack Development
    • Data Science Program
    • All Courses
  • Tutorials
    • Data Structures & Algorithms
    • ML & Data Science
    • Interview Corner
    • Programming Languages
    • Web Development
    • CS Subjects
    • DevOps And Linux
    • School Learning
  • Practice
    • Build your AI Agent
    • GfG 160
    • Problem of the Day
    • Practice Coding Problems
    • GfG SDE Sheet
  • Contests
    • Accenture Hackathon (Ending Soon!)
    • GfG Weekly [Rated Contest]
    • Job-A-Thon Hiring Challenge
    • All Contests and Events
  • DSA
  • Interview Questions on Array
  • Practice Array
  • MCQs on Array
  • Tutorial on Array
  • Types of Arrays
  • Array Operations
  • Subarrays, Subsequences, Subsets
  • Reverse Array
  • Static Vs Arrays
  • Array Vs Linked List
  • Array | Range Queries
  • Advantages & Disadvantages
Open In App
Next Article:
Searching in Array
Next article icon

Subarrays, Subsequences, and Subsets in Array

Last Updated : 15 Jan, 2024
Comments
Improve
Suggest changes
Like Article
Like
Report

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), (2), (3), (4), (1,2), (2,3), (3,4), (1,2,3), (2,3,4), and (1,2,3,4)

Subarray

What is a Subsequence?

A subsequence is a sequence that can be derived from another sequence by removing zero or more elements, without changing the order of the remaining elements.

More generally, we can say that for a sequence of size n, we can have (2n – 1) non-empty sub-sequences in total.

For the same above example, there are 15 sub-sequences. They are:

(1), (2), (3), (4), (1,2), (1,3),(1,4), (2,3), (2,4), (3,4), (1,2,3), (1,2,4), (1,3,4), (2,3,4), (1,2,3,4).

Subsequences

What is a Subset?

If a Set has all its elements belonging to other sets, this set will be known as a subset of the other set.

A Subset is denoted as “⊆“. If set A is a subset of set B, it is represented as A ⊆ B.

For example, Let Set_A = {m, n, o, p, q}, Set_ B = {k, l, m, n, o, p, q, r}

Then, A ⊆ B.

Subset

Table of Content

  • What is a Subarray?
  • What is a Subsequence?
  • What is a Subset?
  • Easy Problems on Subarray
  • Medium Problems on Subarray
  • Hard Problems on Subarray
  • Easy Problems on Subsequence
  • Medium Problems on Subsequence
  • Hard Problems on Subsequence
  • Easy Problems on Subset
  • Medium Problems on Subset
  • Hard Problems on Subset

Easy Problems on Subarray:

  • Split an array into two equal Sum subarrays
  • Check if subarray with given product exists in an array
  • Subarray of size k with given sum
  • Sort an array where a subarray of a sorted array is in reverse order
  • Count subarrays with all elements greater than K
  • Maximum length of the sub-array whose first and last elements are same
  • Check whether an Array is Subarray of another Array
  • Find array such that no subarray has xor zero or Y
  • Maximum subsequence sum such that all elements are K distance apart
  • Longest sub-array with maximum GCD
  • Count of subarrays with sum at least K
  • Length of Smallest subarray in range 1 to N with sum greater than a given value
  • Sum of all subarrays of size K
  • Split array into K disjoint subarrays such that sum of each subarray is odd.
  • Find an array of size N having exactly K subarrays with sum S
  • Find the subarray of size K with minimum XOR
  • Length of the longest alternating even odd subarray
  • Count of subarrays which start and end with the same element
  • Count of subarrays having exactly K perfect square numbers
  • Split array into two subarrays such that difference of their maximum is minimum

Medium Problems on Subarray:

  • Print all K digit repeating numbers in a very large number
  • Length of longest subarray whose sum is not divisible by integer K
  • Min difference between maximum and minimum element in all Y size subarrays
  • Longest subarray of non-empty cells after removal of at most a single empty cell
  • First subarray with negative sum from the given Array
  • Largest subarray with frequency of all elements same
  • Bitwise operations on Subarrays of size K
  • Count subarrays having sum of elements at even and odd positions equal
  • Longest Subarray consisting of unique elements from an Array
  • Minimum Decrements on Subarrays required to reduce all Array elements to zero
  • Split array into two subarrays such that difference of their sum is minimum
  • Maximize count of non-overlapping subarrays with sum K
  • Smallest subarray which upon repetition gives the original array
  • Split array into maximum subarrays such that every distinct element lies in a single subarray
  • Maximize product of subarray sum with its minimum element
  • Sum of products of all possible Subarrays
  • Check if all subarrays contains at least one unique element
  • Length of smallest subarray to be removed such that the remaining array is sorted
  • Length of longest subarray having frequency of every element equal to K
  • Length of the longest increasing subsequence which does not contain a given sequence as Subarray

Hard Problems on Subarray:

  • Length of smallest subarray to be removed to make sum of remaining elements divisible by K
  • Maximum length of same indexed subarrays from two given arrays satisfying the given condition
  • Count ways to split array into two equal sum subarrays by changing sign of any one array element
  • Longest subarray in which all elements are smaller than K
  • Maximize product of a strictly increasing or decreasing subarray
  • Sum of maximum of all subarrays by adding even frequent maximum twice
  • Longest subarray of an array which is a subsequence in another array
  • Count of subarrays having product as a perfect cube
  • Minimize difference between maximum and minimum array elements by removing a K-length subarray
  • Maximum sum submatrix
  • Minimum removal of elements from end of an array required to obtain sum K
  • Check if any subarray of length M repeats at least K times consecutively or not
  • Minimize flips on K-length subarrays required to make all array elements equal to 1
  • Split array into K subarrays such that sum of maximum of all subarrays is maximized
  • Find minimum subarray sum for each index i in subarray [i, N-1]
  • Longest subarray with GCD greater than 1
  • Longest subsegment of ‘1’s formed by changing at most k ‘0’s
  • Lexicographically smallest Permutation of Array by reversing at most one Subarray
  • Find a subsequence which upon reversing gives the maximum sum subarray
  • Minimize steps to make Array elements 0 by reducing same A[i] – X from Subarray

Easy Problems on Subsequence:

  • Longest subsequence having equal numbers of 0 and 1
  • Powers of two and subsequences
  • Longest Subsequence where index of next element is arr[arr[i] + i]
  • Number of subsequences with zero sum
  • Longest sub-sequence with maximum GCD
  • Maximum Bitwise AND value of subsequence of length K
  • Length of the longest subsequence such that xor of adjacent elements is non-decreasing
  • Maximum product of bitonic subsequence of size 3
  • Length of Smallest Subsequence such that sum of elements is greater than equal to K
  • Longest subsequence of even numbers in an Array
  • Maximum length Subsequence with alternating sign and maximum Sum
  • Count of possible subarrays and subsequences using given length of Array
  • Maximum bitwise OR value of subsequence of length K
  • Count of subsequences consisting of the same element
  • Smallest occurring element in each subsequence
  • Length of the longest subsequence consisting of distinct elements
  • Minimize elements to be added to a given array such that it contains another given array as its subsequence
  • Maximize subsequences having array elements not exceeding length of the subsequence
  • Length of longest subsequence consisting of distinct adjacent elements
  • Maximum Sum Subsequence

Medium Problems on Subsequence:

  • Minimum removals required to make a given array Bitonic
  • Check if a non-contiguous subsequence same as the given subarray exists or not
  • Minimize the number of strictly increasing subsequences in an array
  • Count of unique subsequences from given number which are power of 2
  • Minimum number of insertions required such that first K natural numbers can be obtained as sum of a subsequence of the array
  • Length of longest subsequence such that prefix sum at every element remains greater than zero
  • Check if given Array can be divided into subsequences of K increasing consecutive integers
  • Longest Subsequence such that difference between adjacent elements is either A or B
  • Count subsequences of Array having single digit integer sum K
  • Shortest Subsequence with sum exactly K
  • Printing Longest Bitonic Subsequence
  • Sorted subsequence of size 3 in linear time using constant space
  • Count of subsequences having maximum distinct elements
  • Construct array having X subsequences with maximum difference smaller than d
  • Print all subsequences of a string using ArrayList
  • Longest Subsequence with at least one common digit in every element
  • Maximum Sum Subsequence of length k
  • Sum of minimum element of all sub-sequences of a sorted array
  • Find all combinations of two equal sum subsequences
  • Minimum cost of choosing 3 increasing elements in an array of size N

Hard Problems on Subsequence:

  • Number of subsequences with positive product
  • Longest subsequence having difference atmost K
  • Find all subsequences with sum equals to K
  • Maximize product of digit sum of consecutive pairs in a subsequence of length K
  • Count of subsequences of length atmost K containing distinct prime elements
  • Sum of all subsequences of length K
  • Minimize sum of smallest elements from K subsequences of length L
  • Unique subsequences of length K with given sum
  • Smallest subsequence with sum of absolute difference of consecutive elements maximized
  • Maximize product of same-indexed elements of same size subsequences
  • Longest Increasing Subsequence having sum value atmost K
  • Longest subsequence of a number having same left and right rotation
  • Maximize length of Non-Decreasing Subsequence by reversing at most one Subarray
  • Maximum subsequence sum possible by multiplying each element by its index
  • Generate all distinct subsequences of array using backtracking
  • Maximum subsequence sum such that no K elements are consecutive
  • Print all possible K-length subsequences of first N natural numbers with sum N
  • Longest subsequence having difference between the maximum and minimum element equal to K
  • Maximize difference between sum of even and odd-indexed elements of a subsequence
  • Convert an array into another by repeatedly removing the last element and placing it at any arbitrary index

Easy Problems on Subset:

  • Find if there is any subset of size K with 0 sum in an array of -1 and +1
  • Sum of sum of all subsets of a set formed by first N natural numbers
  • Count of subsets not containing adjacent elements
  • Sum of the sums of all possible subsets
  • Find whether an array is subset of another array
  • Total number of Subsets of size at most K
  • Check if it is possible to split given Array into K odd-sum subsets
  • Partition a set into two subsets such that difference between max of one and min of other is minimized
  • Sum of all possible expressions of a numeric string possible by inserting addition operators
  • Check if it’s possible to split the Array into strictly increasing subsets of size at least K
  • Largest subset of Array having sum at least 0

Medium Problems on Subset:

  • Number of subsets with sum divisible by m
  • Fibonacci sum of a subset with all elements <= k
  • Number of possible Equivalence Relations on a finite set
  • Largest divisible pairs subset
  • Recursive program to print all subsets with given sum
  • Subset Sum Queries in a Range using Bitset
  • Find all distinct subset (or subsequence) sums of an array | Set-2
  • Sum of (maximum element – minimum element) for all the subsets of an array
  • Count no. of ordered subsets having a particular XOR value
  • Sum of subsets of all the subsets of an array
  • Perfect Sum Problem
  • Count of subsets having sum of min and max element less than K
  • Split array into two equal length subsets such that all repetitions of a number lies in a single subset
  • Nth Subset of the Sequence consisting of powers of K in increasing order of their Sum
  • Largest possible Subset from an Array such that no element is K times any other element in the Subset
  • Check if an array can be split into subsets of K consecutive elements

Hard Problems on Subset:

  • Minimize count of divisions by D to obtain at least K equal array elements
  • Split array into K-length subsets to minimize sum of second smallest element of each subset
  • Median of all non-empty subset sums
  • Minimum removals required such that sum of remaining array modulo M is X
  • Sum of length of two smallest subsets possible from a given array with sum at least K
  • Reduce sum of any subset of an array to 1 by multiplying all its elements by any value
  • Sum of all subsets whose sum is a Perfect Number from a given array
  • Minimize sum of incompatibilities of K equal-length subsets made up of unique elements
  • Maximize sum of subsets from two arrays having no consecutive values
  • Product of the maximums of all subsets of an array
  • Count ways to place ‘+’ and ‘-‘ in front of array elements to obtain sum K
  • Count ways to split array into two subsets having difference between their sum equal to K
  • Find the subset of Array with given LCM
  • Count of subsets whose product is multiple of unique primes
  • Minimum count of elements to be inserted in Array to form all values in [1, K] using subset sum
  • Maximum subset sum having difference between its maximum and minimum in range [L, R]
  • Find all unique subsets of a given set using C++ STL
  • Subset sum problem where Array sum is at most N

Related Articles:

Data Structure and Algorithms Course
Recent articles on Subarray
Recent articles on Subsequence
Recent articles on Subset


Next Article
Searching in Array

H
harendrakumar123
Improve
Article Tags :
  • DSA
  • Arrays
  • subset
  • subsequence
  • subarray
Practice Tags :
  • Arrays
  • subset

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 Content Applications of Array Data Structure:Advantages of Array Data Structure:Disadvantages of Array Dat
    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 eleme
      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[] b
      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:[GFGTABS] C++
      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: [GFGTABS] C++ // C++ program to implement binary search in sorted array #include <bits/stdc++.h> using namespace std; int binarySe
      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
      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,
      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 s
      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 en
      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] Expl
      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 5 Input: arr[] = {1, 3, 2, 4, 7, 6, 9, 10}Output: 2 4 6 10 7 1 9
      7 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) T
      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 occ
      9 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
      11 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
      11 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
      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 sorte
      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,
      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
      12 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 13 Input: arr[] = [1, 2, 4, 3, 6, 7],
      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,
      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 f
      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
    • Find maximum value of Sum( i*arr[i]) with only rotations on given array allowed
      Given an array arr[] of size N, the task is to find the maximum possible sum of i*arr[i] when the array can be rotated any number of times. Examples : Input: arr[] = {1, 20, 2, 10}Output: 72.We can get 72 by rotating array twice.{2, 10, 1, 20}20*3 + 1*2 + 10*1 + 2*0 = 72 Input: arr[] = {10, 1, 2, 3,
      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 : Prefi
      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
      10 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 Problems Second Large
    2 min read
geeksforgeeks-footer-logo
Corporate & Communications Address:
A-143, 7th Floor, Sovereign Corporate Tower, Sector- 136, Noida, Uttar Pradesh (201305)
Registered Address:
K 061, Tower K, Gulshan Vivante Apartment, Sector 137, Noida, Gautam Buddh Nagar, Uttar Pradesh, 201305
GFG App on Play Store GFG App on App Store
Advertise with us
  • Company
  • About Us
  • Legal
  • Privacy Policy
  • In Media
  • Contact Us
  • Advertise with us
  • GFG Corporate Solution
  • Placement Training Program
  • Languages
  • Python
  • Java
  • C++
  • PHP
  • GoLang
  • SQL
  • R Language
  • Android Tutorial
  • Tutorials Archive
  • DSA
  • Data Structures
  • Algorithms
  • DSA for Beginners
  • Basic DSA Problems
  • DSA Roadmap
  • Top 100 DSA Interview Problems
  • DSA Roadmap by Sandeep Jain
  • All Cheat Sheets
  • Data Science & ML
  • Data Science With Python
  • Data Science For Beginner
  • Machine Learning
  • ML Maths
  • Data Visualisation
  • Pandas
  • NumPy
  • NLP
  • Deep Learning
  • Web Technologies
  • HTML
  • CSS
  • JavaScript
  • TypeScript
  • ReactJS
  • NextJS
  • Bootstrap
  • Web Design
  • Python Tutorial
  • Python Programming Examples
  • Python Projects
  • Python Tkinter
  • Python Web Scraping
  • OpenCV Tutorial
  • Python Interview Question
  • Django
  • Computer Science
  • Operating Systems
  • Computer Network
  • Database Management System
  • Software Engineering
  • Digital Logic Design
  • Engineering Maths
  • Software Development
  • Software Testing
  • DevOps
  • Git
  • Linux
  • AWS
  • Docker
  • Kubernetes
  • Azure
  • GCP
  • DevOps Roadmap
  • System Design
  • High Level Design
  • Low Level Design
  • UML Diagrams
  • Interview Guide
  • Design Patterns
  • OOAD
  • System Design Bootcamp
  • Interview Questions
  • Inteview Preparation
  • Competitive Programming
  • Top DS or Algo for CP
  • Company-Wise Recruitment Process
  • Company-Wise Preparation
  • Aptitude Preparation
  • Puzzles
  • School Subjects
  • Mathematics
  • Physics
  • Chemistry
  • Biology
  • Social Science
  • English Grammar
  • Commerce
  • World GK
  • GeeksforGeeks Videos
  • DSA
  • Python
  • Java
  • C++
  • Web Development
  • Data Science
  • CS Subjects
@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox
Improvement
Suggest Changes
Help us improve. Share your suggestions to enhance the article. Contribute your expertise and make a difference in the GeeksforGeeks portal.
geeksforgeeks-suggest-icon
Create Improvement
Enhance the article with your expertise. Contribute to the GeeksforGeeks community and help create better learning resources for all.
geeksforgeeks-improvement-icon
Suggest Changes
min 4 words, max Words Limit:1000

Thank You!

Your suggestions are valuable to us.

What kind of Experience do you want to share?

Interview Experiences
Admission Experiences
Career Journeys
Work Experiences
Campus Experiences
Competitive Exam Experiences