Longest Subarray With Equal Number of 0s and 1s (original) (raw)

Last Updated : 13 Jan, 2025

Try it on GfG Practice

Given an array **arr[] containing only **0s and **1s, find the longest subarray which contains equal no of **0s and **1s.

**Examples:

**Input: arr[] = [1, 0, 1, 1, 1, 0, 0]
**Output: 6
**Explanation: arr[1 ... 6] is the longest subarray with three 0s and three 1s.

**Input: arr[] = [0, 0, 1, 1, 0]
**Output: 4
**Explanation: arr[0 ... 3] or arr[1 ... 4] is the longest subarray with two 0s and two 1s.

**Input: arr[] = [0]
**Output: 0
**Explanation: There is no subarray with an equal number of 0s and 1s.

Table of Content

• [Naive Approach] Using Nested Loop - O(n^2) Time and O(1) Space
• [Expected Approach] Using Hashmap and Prefix Sum Technique - O(n) Time and O(n) Space

**[Naive Approach] Using Nested Loop - O(n^2) Time and O(1) Space

A simple approach is to generate all possible subarrays and check whether the subarray has equal number of **0s and **1s or not. To make this process easy we find **cumulative sum of the subarrays taking **0s as -1 and **1s **as +1. If the **cumulative sum is equal to 0 for any subarray then update the current maximum length with the maximum of length of current subarray and its own value.

C++ `

// C++ program to find the longest subarray with // equal number of 0s and 1s using nested loop

#include #include using namespace std;

int maxLen(vector &arr) { int res = 0;

// Pick a starting point as 's'
for (int s = 0; s < arr.size(); s++) {
    int sum = 0;

    // Consider all subarrays arr[s...e]
    for (int e = s; e < arr.size(); e++) {
          sum += (arr[e] == 0) ? -1 : 1;
      
        // Check if it's a 0-sum subarray 
        if (sum == 0) 
              // update max size
            res = max(res, e - s + 1);
    }
}
return res;

}

int main() { vector arr = { 1, 0, 0, 1, 0, 1, 1 }; cout << maxLen(arr); }

C

// C program to find the longest subarray with // equal number of 0s and 1s using nested loop

#include <stdio.h>

int maxLen(int arr[], int n) { int res = 0;

// Pick a starting point as 's'
for (int s = 0; s < n; s++) {
    int sum = 0;

    // Consider all subarrays arr[s...e]
    for (int e = s; e < n; e++) {
        sum += (arr[e] == 0) ? -1 : 1;

        // Check if it's a 0-sum subarray
        if (sum == 0)
            // Update max size
            res = (res > e - s + 1) ? res : (e - s + 1);
    }
}

return res;

}

int main() { int arr[] = {1, 0, 0, 1, 0, 1, 1}; int n = sizeof(arr) / sizeof(arr[0]); printf("%d", maxLen(arr, n)); return 0; }

Java

// Java program to find the longest subarray with // equal number of 0s and 1s using nested loop

import java.util.*; class GfG { static int maxLen(int[] arr) { int res = 0;

    // Pick a starting point as 's'
    for (int s = 0; s < arr.length; s++) {
        int sum = 0;

        // Consider all subarrays arr[s...e]
        for (int e = s; e < arr.length; e++) {
            sum += (arr[e] == 0) ? -1 : 1;

            // Check if it's a 0-sum subarray
            if (sum == 0)
                // Update max size
                res = Math.max(res, e - s + 1);
        }
    }

    return res;
}

public static void main(String[] args) {
    int[] arr = {1, 0, 0, 1, 0, 1, 1};
    System.out.println(maxLen(arr));
}

}

Python

Python program to find the longest subarray with

equal number of 0s and 1s using nested loop

def maxLen(arr): res = 0

# Pick a starting point as 's'
for s in range(len(arr)):
    sum = 0

    # Consider all subarrays arr[s...e]
    for e in range(s, len(arr)):
        sum += -1 if arr[e] == 0 else 1

        # Check if it's a 0-sum subarray
        if sum == 0:
            # Update max size
            res = max(res, e - s + 1)

return res

if name == "main": array = [1, 0, 0, 1, 0, 1, 1]

print(maxLen(array))

C#

// C# program to find the longest subarray with // equal number of 0s and 1s using nested loop

using System; using System.Collections.Generic;

class GfG { static int maxLen(int[] arr) { int res = 0;

    // Pick a starting point as 's'
    for (int s = 0; s < arr.Length; s++) {
        int sum = 0;

        // Consider all subarrays arr[s...e]
        for (int e = s; e < arr.Length; e++) {
            sum += (arr[e] == 0) ? -1 : 1;

            // Check if it's a 0-sum subarray
            if (sum == 0)
                // Update max size
                res = Math.Max(res, e - s + 1);
        }
    }

    return res;
}

static void Main() {
    int[] array = { 1, 0, 0, 1, 0, 1, 1 };

    Console.WriteLine(maxLen(array));
}

}

JavaScript

// JavaScript program to find the longest subarray with // equal number of 0s and 1s using nested loop

function maxLen(arr) { let res = 0;

// Pick a starting point as 's'
for (let s = 0; s < arr.length; s++) {
    let sum = 0;

    // Consider all subarrays arr[s...e]
    for (let e = s; e < arr.length; e++) {
        sum += arr[e] === 0 ? -1 : 1;

        // Check if it's a 0-sum subarray
        if (sum === 0) {
            // Update max size
            res = Math.max(res, e - s + 1);
        }
    }
}

return res;

}

// driver code let array = [1, 0, 0, 1, 0, 1, 1]; console.log(maxLen(array));

`

[Expected Approach] Using Hash Map and Prefix Sum Technique - O(n) Time and O(n) Space

If we consider every **0 as -1, then this problem become same as the longest subarray with 0 sum problem.

We traverse the array and compute the prefix sum

1. If current **prefix sum == 0, it means that subarray from index ****(0)** till present index has equal number of **0's and 1's.
2. If we encounter a prefix sum value which we have already encountered before, which means that subarray from the **previous index+1 till the **present index has equal number of 0's and 1's as they give a **cumulative sum of 0.

In a nutshell this problem is equivalent to finding two indexes **i & j in arr[], such that prefix sums till i and j are same, and (j - i) is maximum. To store the first occurrence of each unique cumulative sum value we use a **hash map where if we get that value again we can find the subarray size and compare it with the **maximum size found till now.

C++ `

// C++ program to find longest subarray with equal // number of 0's and 1's Using Hashmap and Prefix Sum

#include #include #include using namespace std;

int maxLen(vector &arr) { unordered_map<int, int> mp;

int preSum = 0; 
int res = 0; 

// Traverse through the given array
for (int i = 0; i < arr.size(); i++) {
  
    // Add current element to sum
      // if current element is zero, add -1
    preSum += (arr[i] == 0) ? -1 : 1;

    // To handle sum = 0 at last index
    if (preSum == 0) 
        res = i + 1;

    // If this sum is seen before, then update 
      // result with maximum
    if (mp.find(preSum) != mp.end())
        res = max(res, i - mp[preSum]);
    
    // Else put this sum in hash table
    else 
        mp[preSum] = i;
}

return res;

}

int main() { vector arr = {1, 0, 0, 1, 0, 1, 1};

cout << maxLen(arr) << endl;
return 0;

}

Java

// Java program to find longest subarray with equal // number of 0's and 1's Using HashMap and Prefix Sum import java.util.HashMap;

class GfG { static int maxLen(int[] arr) { HashMap<Integer, Integer> mp = new HashMap<>();

    int preSum = 0;
    int res = 0;

    // Traverse through the given array
    for (int i = 0; i < arr.length; i++) {

        // Add current element to sum
        // if current element is zero, add -1
        preSum += (arr[i] == 0) ? -1 : 1;

        // To handle sum = 0 at last index
        if (preSum == 0)
            res = i + 1;

        // If this sum is seen before, then update 
          // result with maximum
        if (mp.containsKey(preSum))
            res = Math.max(res, i - mp.get(preSum));

        // Else put this sum in hash table
        else
            mp.put(preSum, i);
    }

    return res;
}

public static void main(String[] args) {
    int[] arr = {1, 0, 0, 1, 0, 1, 1};

    System.out.println(maxLen(arr));
}

}

Python

Python program to find longest subarray with equal

number of 0's and 1's Using HashMap and Prefix Sum

def maxLen(arr): mp = {}

preSum = 0
res = 0

# Traverse through the given array
for i in range(len(arr)):

    # Add current element to sum
    # if current element is zero, add -1
    preSum += -1 if arr[i] == 0 else 1

    # To handle sum = 0 at last index
    if preSum == 0:
        res = i + 1

    # If this sum is seen before, then update 
      # result with maximum
    if preSum in mp:
        res = max(res, i - mp[preSum])

    # Else put this sum in hash table
    else:
        mp[preSum] = i

return res

if name == "main": arr = [1, 0, 0, 1, 0, 1, 1] print(maxLen(arr))

C#

// C# program to find longest subarray with equal // number of 0's and 1's Using Dictionary and Prefix Sum using System; using System.Collections.Generic;

class GfG { static int MaxLen(int[] arr) { Dictionary<int, int> mp = new Dictionary<int, int>();

    int preSum = 0;
    int res = 0;

    // Traverse through the given array
    for (int i = 0; i < arr.Length; i++) {
        // Add current element to sum
        // if current element is zero, add -1
        preSum += (arr[i] == 0) ? -1 : 1;

        // To handle sum = 0 at last index
        if (preSum == 0)
            res = i + 1;

        // If this sum is seen before, then update 
          // result with maximum
        if (mp.ContainsKey(preSum))
            res = Math.Max(res, i - mp[preSum]);

        // Else put this sum in hash table
        else
            mp[preSum] = i;
    }

    return res;    
}

static void Main() {
    int[] arr = {1, 0, 0, 1, 0, 1, 1};
    Console.WriteLine(MaxLen(arr));
}

}

JavaScript

// JavaScript program to find longest subarray with equal // number of 0's and 1's Using HashMap and Prefix Sum

function maxLen(arr) { let mp = new Map();

let preSum = 0;
let res = 0;

// Traverse through the given array
for (let i = 0; i < arr.length; i++) {

    // Add current element to sum
    // if current element is zero, add -1
    preSum += (arr[i] === 0) ? -1 : 1;

    // To handle sum = 0 at last index
    if (preSum === 0)
        res = i + 1;

    // If this sum is seen before, then update 
      // result with maximum
    if (mp.has(preSum))
        res = Math.max(res, i - mp.get(preSum));

    // Else put this sum in hash table
    else
        mp.set(preSum, i);
}

return res;

}

// Driver Code const arr = [1, 0, 0, 1, 0, 1, 1]; console.log(maxLen(arr));

`

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 mainl 3 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: trueInput: a[]= [1, 2, 3, 4, 5, 6], b = [1, 2, 4] Output 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, -3 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 : a 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, 2, 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 Expla 11 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 each 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}, lo 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.In 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, 9 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" -> "Chennai" 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.Input: 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 is n 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 elemen 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 betwee 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 is 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 14 min read