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:
Implementing our Own Hash Table with Separate Chaining in Java
Next article icon

Subarray with Given Sum – Handles Negative Numbers

Last Updated : 06 Mar, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given an unsorted array of integers, find a subarray that adds to a given number. If there is more than one subarray with the sum of the given number, print any of them.

Examples:  

Input: arr[] = {1, 4, 20, 3, 10, 5}, sum = 33
Output: Sum found between indexes 2 and 4
Explanation: Sum of elements between indices 2 and 4 is 20 + 3 + 10 = 33

Input: arr[] = {2, 12, -2, -20, 10}, sum = -10
Output: Sum found between indexes 1 to 3
Explanation: Sum of elements between indices 0 and 3 is 12 – 2 – 20 = -10

Input: arr[] = {-10, 0, 2, -2, -20, 10}, sum = 20
Output: No subarray with given sum exists
Explanation: There is no subarray with the given sum

Note: We have discussed a solution that does not handle negative integers here. In this post, negative integers are also handled.

Naive Approach – O(n^2) Time and O(1) Space

A simple solution is to consider all subarrays one by one and check the sum of every subarray. The following program implements the simple solution. Run two loops: the outer loop picks a starting point I and the inner loop tries all subarrays starting from i.

Follow the given steps to solve the problem:

  • Traverse the array from start to end.
  • From every index start another loop from i to the end of the array to get all subarrays starting from i, and keep a variable sum to calculate the sum. For every index in the inner loop update sum = sum + array[j]If the sum is equal to the given sum then print the subarray.
  • For every index in the inner loop update sum = sum + array[j]
  • If the sum is equal to the given sum then print the subarray.

Below is the implementation of the above approach:

C++ 
/* A simple program to print subarray with sum as given sum */ #include <bits/stdc++.h> using namespace std;  /* Returns true if the there is a subarray of arr[] with sum equal to 'sum' otherwise returns false. Also, prints the result */ int subArraySum(int arr[], int n, int sum) {     int curr_sum, i, j;      // Pick a starting point     for (i = 0; i < n; i++) {         curr_sum = 0;          // try all subarrays starting with 'i'         for (j = i; j < n; j++) {             curr_sum = curr_sum + arr[j];              if (curr_sum == sum) {                 cout << "Sum found between indexes " << i                      << " and " << j;                 return 1;             }         }     }      cout << "No subarray found";     return 0; }  // Driver Code int main() {     int arr[] = { 15, 2, 4, 8, 9, 5, 10, 23 };     int n = sizeof(arr) / sizeof(arr[0]);     int sum = 23;      // Function call     subArraySum(arr, n, sum);     return 0; }
Java 
// Java program for the above approach import java.util.*;  class GFG {      /* Returns true if the there is a subarray     of arr[] with sum equal to 'sum' otherwise     returns false. Also, prints the result */     static int subArraySum(int arr[], int n, int sum)     {         int curr_sum, i, j;          // Pick a starting point         for (i = 0; i < n; i++) {             curr_sum = 0;              // try all subarrays starting with 'i'             for (j = i; j < n; j++) {                 curr_sum = curr_sum + arr[j];                  if (curr_sum == sum) {                     System.out.print(                         "Sum found between indexes " + i                         + " and " + j);                     return 1;                 }             }         }          System.out.print("No subarray found");         return 0;     }      // Driver Code     public static void main(String[] args)     {         int arr[] = { 15, 2, 4, 8, 9, 5, 10, 23 };         int n = arr.length;         int sum = 23;          // Function call         subArraySum(arr, n, sum);     } }  // This code is contributed by code_hunt.
Python 
# Python3 program to print subarray # with sum as given sum   # Returns true if the there is a subarray # of arr[] with sum equal to 'sum' otherwise # returns false. Also, prints the result */ def subArraySum(arr, n, sum):      # Pick a starting point     for i in range(n):         curr_sum = 0         # try all subarrays starting with 'i'         for j in range(i, n):             curr_sum += arr[j]             if (curr_sum == sum):                 print("Sum found between indexes", i, "and", j)                 return      print("No subarray found")   # Driver Code if __name__ == "__main__":     arr = [15, 2, 4, 8, 9, 5, 10, 23]     n = len(arr)     sum = 23      # Function Call     subArraySum(arr, n, sum)   # This code is contributed by phasing17
C# 
/* A simple program to print subarray with sum as given sum */  using System;  public static class GFG {     /* Returns true if the there is a subarray     of arr[] with sum equal to 'sum' otherwise     returns false. Also, prints the result */      public static int subArraySum(int[] arr, int n, int sum)     {         int curr_sum;         int i;         int j;          // Pick a starting point         for (i = 0; i < n; i++) {             curr_sum = 0;              // try all subarrays starting with 'i'             for (j = i; j < n; j++) {                 curr_sum = curr_sum + arr[j];                  if (curr_sum == sum) {                     Console.Write(                         "Sum found between indexes ");                     Console.Write(i);                     Console.Write(" and ");                     Console.Write(j);                     return 1;                 }             }         }          Console.Write("No subarray found");         return 0;     }      // Driver Code     public static void Main()     {         int[] arr = { 15, 2, 4, 8, 9, 5, 10, 23 };         int n = arr.Length;         int sum = 23;          // Function call         subArraySum(arr, n, sum);     } }  // This code is contributed by Aarti_Rathi
JavaScript 
/* JavaScript program to print subarray with sum as given sum */    /* Returns true if the there is a subarray of arr[] with sum equal to 'sum' otherwise returns false. Also, prints the result */ function subArraySum(arr, n, sum) {     var curr_sum, i, j;       // Pick a starting point     for (i = 0; i < n; i++) {         curr_sum = 0;           // try all subarrays starting with 'i'         for (j = i ; j < n; j++) {            curr_sum = curr_sum + arr[j];                        if (curr_sum == sum) {                 console.log("Sum found between indexes " + i + " and " + j);                 return;             }         }     }       console.log("No subarray found"); }   // Driver Code var arr = [ 15, 2, 4, 8, 9, 5, 10, 23 ]; var n = arr.length; var sum = 23;  //Function Call subArraySum(arr, n, sum);   //This code is contributed by phasing17

Output
Sum found between indexes 1 and 4

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

Expected Approach – Prefix Sum and Hash Map – O(n) time and O(n) Space

To solve the problem follow the below idea:

The idea is to store the sum of elements of every prefix of the array in a hashmap, i.e, every index stores the sum of elements up to that index hashmap. So to check if there is a subarray with a sum equal to target_sum, check for every index i, and sum up to that index as curr_sum. If there is a prefix with a sum equal to (curr_sum – target_sum), then the subarray with the given sum is found.

Follow the given steps to solve the problem:

  • Create a Hashmap (hm) to store a key-value pair, i.e, key = prefix sum and value = its index, and a variable to store the current sum (curr_sum = 0).
  • Traverse through the array from start to end.
  • For every element update the curr_sum, i.e curr_sum = curr_sum + arr[i]
  • If the sum is equal to target_sum then print that the subarray with the given sum is from 0 to i
  • If there is any key in the HashMap which is equal to curr_sum – target_sum then print that the subarray with the given sum is from hm[curr_sum – target_sum] + 1 to i.
  • Put the sum and index in the hashmap as a key-value pair.

Dry-run of the above approach: 


Below is the implementation of the above approach:

C++ 
// C++ program to print subarray with sum as given sum #include <bits/stdc++.h> using namespace std;  // Function to print subarray with sum as given sum void subArraySum(int arr[], int n, int sum) {     // create an empty map     unordered_map<int, int> map;      // Maintains sum of elements so far     int curr_sum = 0;      for (int i = 0; i < n; i++) {         // add current element to curr_sum         curr_sum = curr_sum + arr[i];          // if curr_sum is equal to target sum         // we found a subarray starting from index 0         // and ending at index i         if (curr_sum == sum) {             cout << "Sum found between indexes " << 0                  << " to " << i << endl;             return;         }          // If curr_sum - sum already exists in map         // we have found a subarray with target sum         if (map.find(curr_sum - sum) != map.end()) {             cout << "Sum found between indexes "                  << map[curr_sum - sum] + 1 << " to " << i                  << endl;             return;         }          map[curr_sum] = i;     }      // If we reach here, then no subarray exists     cout << "No subarray with given sum exists"; }  // Driver code int main() {     int arr[] = { 2, 12, -2, -20, 10 };     int n = sizeof(arr) / sizeof(arr[0]);     int sum = -10;      // Function call     subArraySum(arr, n, sum);      return 0; }
Java 
// Java program to print subarray with sum as given sum import java.util.*;  class GFG {      public static void subArraySum(int[] arr, int n,                                    int sum)     {         // cur_sum to keep track of cumulative sum till that         // point         int cur_sum = 0;         int start = 0;         int end = -1;         HashMap<Integer, Integer> hashMap = new HashMap<>();          for (int i = 0; i < n; i++) {             cur_sum = cur_sum + arr[i];             // check whether cur_sum - sum = 0, if 0 it             // means the sub array is starting from index 0-             // so stop             if (cur_sum - sum == 0) {                 start = 0;                 end = i;                 break;             }             // if hashMap already has the value, means we             // already             // have subarray with the sum - so stop             if (hashMap.containsKey(cur_sum - sum)) {                 start = hashMap.get(cur_sum - sum) + 1;                 end = i;                 break;             }             // if value is not present then add to hashmap             hashMap.put(cur_sum, i);         }         // if end is -1 : means we have reached end without         // the sum         if (end == -1) {             System.out.println(                 "No subarray with given sum exists");         }         else {             System.out.println("Sum found between indexes "                                + start + " to " + end);         }     }      // Driver code     public static void main(String[] args)     {         int[] arr = { 2, 12, -2, -20, 10 };         int n = arr.length;         int sum = -10;          // Function call         subArraySum(arr, n, sum);     } }
Python 
# Python3 program to print subarray with sum as given sum  # Function to print subarray with sum as given sum def subArraySum(arr, n, Sum):      # create an empty map     Map = {}      # Maintains sum of elements so far     curr_sum = 0      for i in range(0, n):          # add current element to curr_sum         curr_sum = curr_sum + arr[i]          # if curr_sum is equal to target sum         # we found a subarray starting from index 0         # and ending at index i         if curr_sum == Sum:              print("Sum found between indexes 0 to", i)             return          # If curr_sum - sum already exists in map         # we have found a subarray with target sum         if (curr_sum - Sum) in Map:              print("Sum found between indexes",                   Map[curr_sum - Sum] + 1, "to", i)              return          Map[curr_sum] = i      # If we reach here, then no subarray exists     print("No subarray with given sum exists")   # Driver code if __name__ == "__main__":      arr = [2, 12, -2, -20, 10]     n = len(arr)     Sum = -10      # Function call     subArraySum(arr, n, Sum)
C# 
using System; using System.Collections.Generic;  // C# program to print subarray with sum as given sum  public class GFG {      public static void subArraySum(int[] arr, int n,                                    int sum)     {         // cur_sum to keep track of cumulative sum till that         // point         int cur_sum = 0;         int start = 0;         int end = -1;         Dictionary<int, int> hashMap             = new Dictionary<int, int>();          for (int i = 0; i < n; i++) {             cur_sum = cur_sum + arr[i];             // check whether cur_sum - sum = 0, if 0 it             // means the sub array is starting from index 0-             // so stop             if (cur_sum - sum == 0) {                 start = 0;                 end = i;                 break;             }             // if hashMap already has the value, means we             // already             // have subarray with the sum - so stop             if (hashMap.ContainsKey(cur_sum - sum)) {                 start = hashMap[cur_sum - sum] + 1;                 end = i;                 break;             }             // if value is not present then add to hashmap             hashMap[cur_sum] = i;         }         // if end is -1 : means we have reached end without         // the sum         if (end == -1) {             Console.WriteLine(                 "No subarray with given sum exists");         }         else {             Console.WriteLine("Sum found between indexes "                               + start + " to " + end);         }     }      // Driver code     public static void Main(string[] args)     {         int[] arr = new int[] { 2, 12, -2, -20, 10 };         int n = arr.Length;         int sum = -10;          // Function call         subArraySum(arr, n, sum);     } }
JavaScript 
// Javascript program to print subarray with sum as given sum      function subArraySum(arr, n, sum) {         //cur_sum to keep track of cumulative sum till that point         let cur_sum = 0;         let start = 0;         let end = -1;         let hashMap = new Map();            for (let i = 0; i < n; i++) {             cur_sum = cur_sum + arr[i];             //check whether cur_sum - sum = 0, if 0 it means             //the sub array is starting from index 0- so stop             if (cur_sum - sum == 0) {                 start = 0;                 end = i;                 break;             }             //if hashMap already has the value, means we already              // have subarray with the sum - so stop             if (hashMap.has(cur_sum - sum)) {                 start = hashMap.get(cur_sum - sum) + 1;                 end = i;                 break;             }             //if value is not present then add to hashmap             hashMap.set(cur_sum, i);            }         // if end is -1 : means we have reached end without the sum         if (end == -1) {             console.log("No subarray with given sum exists");         }          else {             console.log("Sum found between indexes "                              + start + " to " + end);         }        }  // Driver program            let arr = [2, 12, -2, -20, 10];         let n = arr.length;         let sum = -10;         subArraySum(arr, n, sum);

Output
Sum found between indexes 1 to 3

Time complexity: O(N). If hashing is performed with the help of an array, then this is the time complexity. In case the elements cannot be hashed in an array a hash map can also be used as shown in the above code.
Auxiliary space: O(N). As a HashMap is needed, this takes linear space.
 



Next Article
Implementing our Own Hash Table with Separate Chaining in Java

A

Aditya Goel
Improve
Article Tags :
  • Arrays
  • DSA
Practice Tags :
  • Arrays

Similar Reads

  • Hashing in Data Structure
    Hashing is a technique used in data structures that efficiently stores and retrieves data in a way that allows for quick access. Hashing involves mapping data to a specific index in a hash table (an array of items) using a hash function. It enables fast retrieval of information based on its key. The
    3 min read
  • Introduction to Hashing
    Hashing refers to the process of generating a small sized output (that can be used as index in a table) from an input of typically large and variable size. Hashing uses mathematical formulas known as hash functions to do the transformation. This technique determines an index or location for the stor
    7 min read
  • What is Hashing?
    Hashing refers to the process of generating a fixed-size output from an input of variable size using the mathematical formulas known as hash functions. This technique determines an index or location for the storage of an item in a data structure. Need for Hash data structureThe amount of data on the
    3 min read
  • Index Mapping (or Trivial Hashing) with negatives allowed
    Index Mapping (also known as Trivial Hashing) is a simple form of hashing where the data is directly mapped to an index in a hash table. The hash function used in this method is typically the identity function, which maps the input data to itself. In this case, the key of the data is used as the ind
    7 min read
  • Separate Chaining Collision Handling Technique in Hashing
    Separate Chaining is a collision handling technique. Separate chaining is one of the most popular and commonly used techniques in order to handle collisions. In this article, we will discuss about what is Separate Chain collision handling technique, its advantages, disadvantages, etc. There are main
    4 min read
  • Open Addressing Collision Handling technique in Hashing
    Open Addressing is a method for handling collisions. In Open Addressing, all elements are stored in the hash table itself. So at any point, the size of the table must be greater than or equal to the total number of keys (Note that we can increase table size by copying old data if needed). This appro
    7 min read
  • Double Hashing
    Double hashing is a collision resolution technique used in hash tables. It works by using two hash functions to compute two different hash values for a given key. The first hash function is used to compute the initial hash value, and the second hash function is used to compute the step size for the
    15+ min read
  • Load Factor and Rehashing
    Prerequisites: Hashing Introduction and Collision handling by separate chaining How hashing works: For insertion of a key(K) - value(V) pair into a hash map, 2 steps are required: K is converted into a small integer (called its hash code) using a hash function.The hash code is used to find an index
    15+ min read

    • Easy problems on Hashing

    • Check if an array is subset of another array
      Given two arrays a[] and b[] of size m and n respectively, the task is to determine whether b[] is a subset of a[]. Both arrays are not sorted, and elements are distinct. Examples: Input: a[] = [11, 1, 13, 21, 3, 7], b[] = [11, 3, 7, 1] Output: true Input: a[]= [1, 2, 3, 4, 5, 6], b = [1, 2, 4] Outp
      13 min read
    • Union and Intersection of two Linked List using Hashing
      Given two singly Linked Lists, create union and intersection lists that contain the union and intersection of the elements present in the given lists. Each of the two linked lists contains distinct node values.Note: The order of elements in output lists doesn’t matter. Examples: Input:head1 : 10 -
      10 min read
    • Two Sum - Pair with given Sum
      Given an array arr[] of n integers and a target value, the task is to find whether there is a pair of elements in the array whose sum is equal to target. This problem is a variation of 2Sum problem. Examples: Input: arr[] = [0, -1, 2, -3, 1], target = -2Output: trueExplanation: There is a pair (1, -
      15+ min read
    • Max Distance Between Two Occurrences
      Given an array arr[], the task is to find the maximum distance between two occurrences of any element. If no element occurs twice, return 0. Examples: Input: arr = [1, 1, 2, 2, 2, 1]Output: 5Explanation: distance for 1 is: 5-0 = 5, distance for 2 is: 4-2 = 2, So max distance is 5. Input : arr[] = [3
      8 min read
    • Most frequent element in an array
      Given an array, the task is to find the most frequent element in it. If there are multiple elements that appear a maximum number of times, return the maximum element. Examples: Input : arr[] = [1, 3, 2, 1, 4, 1]Output : 1Explanation: 1 appears three times in array which is maximum frequency. Input :
      10 min read
    • Only Repeating From 1 To n-1
      Given an array arr[] of size n filled with numbers from 1 to n-1 in random order. The array has only one repetitive element. The task is to find the repetitive element. Examples: Input: arr[] = [1, 3, 2, 3, 4]Output: 3Explanation: The number 3 is the only repeating element. Input: arr[] = [1, 5, 1,
      15+ min read
    • Check for Disjoint Arrays or Sets
      Given two arrays a and b, check if they are disjoint, i.e., there is no element common between both the arrays. Examples: Input: a[] = {12, 34, 11, 9, 3}, b[] = {2, 1, 3, 5} Output: FalseExplanation: 3 is common in both the arrays. Input: a[] = {12, 34, 11, 9, 3}, b[] = {7, 2, 1, 5} Output: True Exp
      12 min read
    • Non-overlapping sum of two sets
      Given two arrays A[] and B[] of size n. It is given that both array individually contains distinct elements. We need to find the sum of all elements that are not common. Examples: Input : A[] = {1, 5, 3, 8} B[] = {5, 4, 6, 7}Output : 291 + 3 + 4 + 6 + 7 + 8 = 29Input : A[] = {1, 5, 3, 8} B[] = {5, 1
      9 min read
    • Check if two arrays are equal or not
      Given two arrays, a and b of equal length. The task is to determine if the given arrays are equal or not. Two arrays are considered equal if: Both arrays contain the same set of elements.The arrangements (or permutations) of elements may be different.If there are repeated elements, the counts of eac
      6 min read
    • Find missing elements of a range
      Given an array, arr[0..n-1] of distinct elements and a range [low, high], find all numbers that are in a range, but not the array. The missing elements should be printed in sorted order. Examples: Input: arr[] = {10, 12, 11, 15}, low = 10, high = 15Output: 13, 14Input: arr[] = {1, 14, 11, 51, 15}, l
      15+ min read
    • Minimum Subsets with Distinct Elements
      You are given an array of n-element. You have to make subsets from the array such that no subset contain duplicate elements. Find out minimum number of subset possible. Examples : Input : arr[] = {1, 2, 3, 4}Output :1Explanation : A single subset can contains all values and all values are distinct.I
      9 min read
    • Remove minimum elements such that no common elements exist in two arrays
      Given two arrays arr1[] and arr2[] consisting of n and m elements respectively. The task is to find the minimum number of elements to remove from each array such that intersection of both arrays becomes empty and both arrays become mutually exclusive. Examples: Input: arr[] = { 1, 2, 3, 4}, arr2[] =
      8 min read
    • 2 Sum - Count pairs with given sum
      Given an array arr[] of n integers and a target value, the task is to find the number of pairs of integers in the array whose sum is equal to target. Examples: Input: arr[] = {1, 5, 7, -1, 5}, target = 6Output: 3Explanation: Pairs with sum 6 are (1, 5), (7, -1) & (1, 5). Input: arr[] = {1, 1, 1,
      10 min read
    • Count quadruples from four sorted arrays whose sum is equal to a given value x
      Given four sorted arrays each of size n of distinct elements. Given a value x. The problem is to count all quadruples(group of four numbers) from all the four arrays whose sum is equal to x.Note: The quadruple has an element from each of the four arrays. Examples: Input : arr1 = {1, 4, 5, 6}, arr2 =
      15+ min read
    • Sort elements by frequency | Set 4 (Efficient approach using hash)
      Print the elements of an array in the decreasing frequency if 2 numbers have the same frequency then print the one which came first. Examples: Input : arr[] = {2, 5, 2, 8, 5, 6, 8, 8} Output : arr[] = {8, 8, 8, 2, 2, 5, 5, 6} Input : arr[] = {2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8} Output : arr[] = {8,
      12 min read
    • Find all pairs (a, b) in an array such that a % b = k
      Given an array with distinct elements, the task is to find the pairs in the array such that a % b = k, where k is a given integer. You may assume that a and b are in small range Examples : Input : arr[] = {2, 3, 5, 4, 7} k = 3Output : (7, 4), (3, 4), (3, 5), (3, 7)7 % 4 = 33 % 4 = 33 % 5 = 33 % 7 =
      15 min read
    • Group words with same set of characters
      Given a list of words with lower cases. Implement a function to find all Words that have the same unique character set. Example: Input: words[] = { "may", "student", "students", "dog", "studentssess", "god", "cat", "act", "tab", "bat", "flow", "wolf", "lambs", "amy", "yam", "balms", "looped", "poodl
      8 min read
    • k-th distinct (or non-repeating) element among unique elements in an array.
      Given an integer array arr[], print kth distinct element in this array. The given array may contain duplicates and the output should print the k-th element among all unique elements. If k is more than the number of distinct elements, print -1. Examples: Input: arr[] = {1, 2, 1, 3, 4, 2}, k = 2Output
      7 min read

    Intermediate problems on Hashing

    • Find Itinerary from a given list of tickets
      Given a list of tickets, find the itinerary in order using the given list. Note: It may be assumed that the input list of tickets is not cyclic and there is one ticket from every city except the final destination. Examples: Input: "Chennai" -> "Bangalore" "Bombay" -> "Delhi" "Goa" -> "Chenn
      11 min read
    • Find number of Employees Under every Manager
      Given a 2d matrix of strings arr[][] of order n * 2, where each array arr[i] contains two strings, where the first string arr[i][0] is the employee and arr[i][1] is his manager. The task is to find the count of the number of employees under each manager in the hierarchy and not just their direct rep
      9 min read
    • Longest Subarray With Sum Divisible By K
      Given an arr[] containing n integers and a positive integer k, he problem is to find the longest subarray's length with the sum of the elements divisible by k. Examples: Input: arr[] = [2, 7, 6, 1, 4, 5], k = 3Output: 4Explanation: The subarray [7, 6, 1, 4] has sum = 18, which is divisible by 3. Inp
      10 min read
    • Longest Subarray with 0 Sum
      Given an array arr[] of size n, the task is to find the length of the longest subarray with sum equal to 0. Examples: Input: arr[] = {15, -2, 2, -8, 1, 7, 10, 23}Output: 5Explanation: The longest subarray with sum equals to 0 is {-2, 2, -8, 1, 7} Input: arr[] = {1, 2, 3}Output: 0Explanation: There i
      10 min read
    • Longest Increasing consecutive subsequence
      Given N elements, write a program that prints the length of the longest increasing consecutive subsequence. Examples: Input : a[] = {3, 10, 3, 11, 4, 5, 6, 7, 8, 12} Output : 6 Explanation: 3, 4, 5, 6, 7, 8 is the longest increasing subsequence whose adjacent element differs by one. Input : a[] = {6
      10 min read
    • Count Distinct Elements In Every Window of Size K
      Given an array arr[] of size n and an integer k, return the count of distinct numbers in all windows of size k. Examples: Input: arr[] = [1, 2, 1, 3, 4, 2, 3], k = 4Output: [3, 4, 4, 3]Explanation: First window is [1, 2, 1, 3], count of distinct numbers is 3. Second window is [2, 1, 3, 4] count of d
      10 min read
    • Design a data structure that supports insert, delete, search and getRandom in constant time
      Design a data structure that supports the following operations in O(1) time. insert(x): Inserts an item x to the data structure if not already present.remove(x): Removes item x from the data structure if present. search(x): Searches an item x in the data structure.getRandom(): Returns a random eleme
      5 min read
    • Subarray with Given Sum - Handles Negative Numbers
      Given an unsorted array of integers, find a subarray that adds to a given number. If there is more than one subarray with the sum of the given number, print any of them. Examples: Input: arr[] = {1, 4, 20, 3, 10, 5}, sum = 33Output: Sum found between indexes 2 and 4Explanation: Sum of elements betwe
      13 min read
    • Implementing our Own Hash Table with Separate Chaining in Java
      All data structure has their own special characteristics, for example, a BST is used when quick searching of an element (in log(n)) is required. A heap or a priority queue is used when the minimum or maximum element needs to be fetched in constant time. Similarly, a hash table is used to fetch, add
      10 min read
    • Implementing own Hash Table with Open Addressing Linear Probing
      In Open Addressing, all elements are stored in the hash table itself. So at any point, size of table must be greater than or equal to total number of keys (Note that we can increase table size by copying old data if needed). Insert(k) - Keep probing until an empty slot is found. Once an empty slot i
      13 min read
    • Maximum possible difference of two subsets of an array
      Given an array of n-integers. The array may contain repetitive elements but the highest frequency of any element must not exceed two. You have to make two subsets such that the difference of the sum of their elements is maximum and both of them jointly contain all elements of the given array along w
      15+ min read
    • Sorting using trivial hash function
      We have read about various sorting algorithms such as heap sort, bubble sort, merge sort and others. Here we will see how can we sort N elements using a hash array. But this algorithm has a limitation. We can sort only those N elements, where the value of elements is not large (typically not above 1
      15+ min read
    • Smallest subarray with k distinct numbers
      We are given an array consisting of n integers and an integer k. We need to find the smallest subarray [l, r] (both l and r are inclusive) such that there are exactly k different numbers. If no such subarray exists, print -1 and If multiple subarrays meet the criteria, return the one with the smalle
      15 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