Longest Span with same Sum in two Binary arrays

// A Simple Java program to find longest common
// subarray of two binary arrays with same sum

class Test
{
    static int a[] = new int[]{0, 1, 0, 1, 1, 1, 1};
    static int b[] = new int[]{1, 1, 1, 1, 1, 0, 1};
    
    // Returns length of the longest common sum in a[]
    // and b[]. Both are of same size n.
    static int longestCommonSum(int n)
    {
        // Initialize result
        int maxLen = 0;
     
        // One by one pick all possible starting points
        // of subarrays
        for (int i=0; i<n; i++)
        {
           // Initialize sums of current subarrays
           int sum1 = 0, sum2 = 0;
     
           // Consider all points for starting with arr[i]
           for (int j=i; j<n; j++)
           {
               // Update sums
               sum1 += a[j];
               sum2 += b[j];
     
               // If sums are same and current length is
               // more than maxLen, update maxLen
               if (sum1 == sum2)
               {
                 int len = j-i+1;
                 if (len > maxLen)
                    maxLen = len;
               }
           }
        }
        return maxLen;
    }
    
    // Driver method to test the above function
    public static void main(String[] args) 
    {
        System.out.print("Length of the longest common span with same sum is ");
        System.out.println(longestCommonSum(a.length));
    }
}

// A O(n) and O(n) extra space Java program to find
// longest common subarray of two binary arrays with
// same sum

class Test
{
    static int a[] = new int[]{0, 1, 0, 1, 1, 1, 1};
    static int b[] = new int[]{1, 1, 1, 1, 1, 0, 1};
    
    // Returns length of the longest common sum in a[]
    // and b[]. Both are of same size n.
    static int longestCommonSum(int n)
    {
        // Initialize result
        int maxLen = 0;
     
        // Initialize prefix sums of two arrays
        int preSum1 = 0, preSum2 = 0;
     
        // Create an array to store starting and ending
        // indexes of all possible diff values. diff[i]
        // would store starting and ending points for
        // difference "i-n"
        int diff[] = new int[2*n+1];
     
        // Initialize all starting and ending values as -1.
        for (int i = 0; i < diff.length; i++) {
            diff[i] = -1;
        }
     
        // Traverse both arrays
        for (int i=0; i<n; i++)
        {
            // Update prefix sums
            preSum1 += a[i];
            preSum2 += b[i];
     
            // Compute current diff and index to be used
            // in diff array. Note that diff can be negative
            // and can have minimum value as -1.
            int curr_diff = preSum1 - preSum2;
            int diffIndex = n + curr_diff;
     
            // If current diff is 0, then there are same number
            // of 1's so far in both arrays, i.e., (i+1) is
            // maximum length.
            if (curr_diff == 0)
                maxLen = i+1;
     
            // If current diff is seen first time, then update
            // starting index of diff.
            else if ( diff[diffIndex] == -1)
                diff[diffIndex] = i;
     
            // Current diff is already seen
            else
            {
                // Find length of this same sum common span
                int len = i - diff[diffIndex];
     
                // Update max len if needed
                if (len > maxLen)
                    maxLen = len;
            }
        }
        return maxLen;
    }
    
    // Driver method to test the above function
    public static void main(String[] args) 
    {
        System.out.print("Length of the longest common span with same sum is ");
        System.out.println(longestCommonSum(a.length));
    }
}

// Java program to find largest subarray 
// with equal number of 0's and 1's. 
import java.io.*;
import java.util.*;

class GFG 
{

    // Returns largest common subarray with equal 
    // number of 0s and 1s
    static int longestCommonSum(int[] a, int[] b, int n)
    {
        // Find difference between the two
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) 
            arr[i] = a[i] - b[i];

        // Creates an empty hashMap hM 
        HashMap<Integer, Integer> hM = new HashMap<>();

        int sum = 0;     // Initialize sum of elements 
        int max_len = 0; // Initialize result 

        // Traverse through the given array 
        for (int i = 0; i < n; i++) 
        { 
            // Add current element to sum 
            sum += arr[i]; 

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

            // If this sum is seen before, 
            // then update max_len if required 
            if (hM.containsKey(sum)) 
                max_len = Math.max(max_len, i - hM.get(sum)); 
            
            else // Else put this sum in hash table 
                hM.put(sum, i); 
        }
        return max_len; 
    } 

    // Driver code
    public static void main(String args[])
    {
            int[] a = {0, 1, 0, 1, 1, 1, 1}; 
            int[] b = {1, 1, 1, 1, 1, 0, 1};
            int n = a.length;
            System.out.println(longestCommonSum(a, b, n)); 
    }
}

// This code is contributed by rachana soma