import java.util.HashMap;

public class LongestSubarray {

    public static int findMaxLength(int[] nums) {
        // HashMap to store the first occurrence of the prefix sum
        HashMap<Integer, Integer> map = new HashMap<>();
        
        // Initialize the prefix sum and the result
        int prefixSum = 0;
        int maxLength = 0;
        
        // Iterate through the array
        for (int i = 0; i < nums.length; i++) {
            // If the element is 0, treat it as -1 (this helps balance the 0s and 1s)
            prefixSum += (nums[i] == 0) ? -1 : 1;
            
            // If prefixSum is 0, it means the subarray from index 0 to i has equal 0s and 1s
            if (prefixSum == 0) {
                maxLength = i + 1;
            } 
            // If the prefixSum has been seen before, it means there is a subarray with equal 0s and 1s
            else if (map.containsKey(prefixSum)) {
                // Update the max length with the length of the subarray found
                maxLength = Math.max(maxLength, i - map.get(prefixSum));
            } else {
                // Store the first occurrence of the prefix sum
                map.put(prefixSum, i);
            }
        }
        
        return maxLength;
    }

    public static void main(String[] args) {
        int[] nums = {0, 1, 0, 1, 1, 0};
        System.out.println("Longest subarray with equal 0s and 1s: " + findMaxLength(nums));
    }
}
============================================================================

//{ Driver Code Starts
//Initial Template for Java

import java.util.*;
import java.lang.*;
import java.lang.*;
import java.io.*;
class Driverclass
 {
	public static void main (String[] args) {
	   
	   Scanner in = new Scanner(System.in);
	   int t= in.nextInt();
	   while(t-->0){
	       
	       int n = in.nextInt();
	       int [] arr= new int[n];
	       for(int i=0;i<n;i++) {
	           arr[i] = in.nextInt();
	       }
	       System.out.println(new Solution().countSubarrWithEqualZeroAndOne(arr, n));
	   
System.out.println("~");
}
	 }
}

https://www.geeksforgeeks.org/problems/largest-subarray-of-0s-and-1s/1?itm_source=geeksforgeeks&itm_medium=article&itm_campaign=practice_card

// } Driver Code Ends


//User function Template for Java

class Solution
{
    //Function to count subarrays with 1s and 0s.
    static int countSubarrWithEqualZeroAndOne(int arr[], int n)
    {
        // add your code here
        for(int i=0;i<arr.length;i++){
            if(arr[i]==0){
                arr[i]=-1;
            }
        }
        
        HashMap<Integer,Integer> hm=new HashMap<>();
        hm.put(0,1);
        int count=0;
        int sum=0;
        for(int i=0;i<arr.length;i++){
            sum=sum+arr[i];
            if(hm.containsKey(sum)){
                count=count+hm.get(sum);
                int f=hm.get(sum);
                f++;
                hm.put(sum,f);
            }else{
                hm.put(sum,1);
            }
            
            
        }
        return count;
       
    }
}


========================================================================
https://www.geeksforgeeks.org/problems/largest-subarray-of-0s-and-1s/1?itm_source=geeksforgeeks&itm_medium=article&itm_campaign=practice_card


//{ Driver Code Starts
import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        // Create BufferedReader for efficient input reading
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // Read number of test cases
        int T = Integer.parseInt(br.readLine());

        // Process each test case
        while (T-- > 0) {
            // Read the entire line containing the array elements
            String line = br.readLine();

            // Split the line into an array of strings, then parse them as integers
            String[] tokens = line.split("\\s+");
            int[] a = new int[tokens.length];
            for (int i = 0; i < tokens.length; i++) {
                a[i] = Integer.parseInt(tokens[i]);
            }

            // Create the Solution object
            Solution obj = new Solution();

            // Call maxLen function and print the result
            System.out.println(obj.maxLen(a));
        }
    }
}
// } Driver Code Ends


class Solution {
    public int maxLen(int[] arr) {
        // Your code here
       
       HashMap<Integer,Integer> hm=new HashMap<>();
        for(int i=0;i<arr.length;i++){
            if(arr[i]==0){
                arr[i]=-1;
            }
        }
        
        int maxlen=0;
        int sum=0;
        for(int i=0;i<arr.length;i++){
            
           sum=sum+arr[i];
           if(sum==0){
               maxlen=i+1;
           }
           
           if(hm.containsKey(sum)){
               int len=i-hm.get(sum);
               if(len>maxlen){
                   maxlen=len;
               }
           }else{
               hm.put(sum,i);
           }
            
        }
        return maxlen;
        
        
        
        
    }
}
===================================================================