Fair Array Removal Indices

Problem statement

Consider this problem as selecting specific indices in the array such that removing the element at those indices transforms the array into a fair array. Find the count of such indices to achieve a fair distribution of even and odd-indexed sums.

For instance, if nums = [2,1,6,4], you need to identify the number of indices you can remove to make the array fair. The output would be 1, as removing index 1 results in a fair array.

Java Implementation

Approach 1

import java.util.Scanner;
public class FairArray {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the size of the array: ");
        int n = scanner.nextInt();
        int[] nums = new int[n];
        System.out.println("Enter the elements of the array:");
        for (int i = 0; i < n; i++) {
            nums[i] = scanner.nextInt();
        }
        int result = waysToMakeFair(nums);
        System.out.println("Number of ways to make the array fair: " + result);
        scanner.close();
    }
    public static int waysToMakeFair(int[] nums) {
        int n = nums.length, result = 0;
        int evenL = 0, evenR = 0, oddL = 0, oddR = 0;
        for (int i = 0; i < n; i++)
            if (i % 2 == 0)
                evenR += nums[i];
            else
                oddR += nums[i];
        for (int i = 0; i < n; i++) {
            if (i % 2 == 0)
                evenR -= nums[i];
            else
                oddR -= nums[i];
            if (evenL + oddR == oddL + evenR)
                result++;
            if (i % 2 == 0)
                evenL += nums[i];
            else
                oddL += nums[i];
        }
        return result;
    }
}

Output:

Enter the size of the array: 4
Enter the elements of the array:
2 1 6 4
Number of ways to make the array fair: 1

Code Explanation:

The code determines the number of ways to make an array fair by iteratively removing elements and checking if the array becomes fair. It uses two pairs of variables (evenL, oddL) and (evenR, oddR) to maintain the running sums of even and odd-indexed elements on the left and right sides of the current index, respectively.

The first loop initializes the right-side sums (evenR and oddR).

The second loop iterates through each index, updating the sums and checking if removing the current index makes the array fair.

The result is incremented whenever a fair array is found.

Time Complexity:

The time complexity is O(N), where N is the length of the input array. The code iterates through the array twice, each time performing constant-time operations.

Space Complexity:

The space complexity is O(1). The algorithm uses a constant amount of extra space, regardless of the input size. The space used for variables (evenL, oddL, evenR, oddR, result, i, n) remains constant.

Approach 2 Using Prefix sums

Java Code

import java.util.Scanner;
public class FairArray {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the size of the array: ");
        int n = scanner.nextInt();
        int[] nums = new int[n];
        System.out.println("Enter the elements of the array:");
        for (int i = 0; i < n; i++) {
            nums[i] = scanner.nextInt();
        }
        int result = waysToMakeFair(nums);
        System.out.println("Number of ways to make the array fair: " + result);
        scanner.close();
    }
    public static int waysToMakeFair(int[] nums) {
        int n = nums.length;
        // Calculate prefix sums for even and odd indices
        int[] prefixEven = new int[n + 1];
        int[] prefixOdd = new int[n + 1];
        for (int i = 0; i < n; i++) {
            prefixEven[i + 1] = prefixEven[i] + (i % 2 == 0 ? nums[i] : 0);
            prefixOdd[i + 1] = prefixOdd[i] + (i % 2 == 1 ? nums[i] : 0);
        }
        int result = 0;
        for (int i = 0; i < n; i++) {
            int sumEven = prefixEven[i] + (prefixOdd[n] - prefixOdd[i + 1]);
            int sumOdd = prefixOdd[i] + (prefixEven[n] - prefixEven[i + 1]);
            if (sumEven == sumOdd) {
                result++;
            }
        }
        return result;
    }
}

Output:

Enter the size of the array: 4
Enter the elements of the array:
2 1 6 4
Number of ways to make the array fair: 1

Code Explanation

Implements an alternative approach to calculate the number of ways to make the array fair by utilizing prefix sums for even and odd indices.. Two arrays (prefixEven and prefixOdd) are created to store prefix sums for even and odd indices separately.The program calculates the prefix sums by iterating through the array.

A loop iterates through each index, calculating the sum of even and odd-indexed elements on the left and right. If these two sums are equal, the result is incremented.The program outputs the number of ways to make the array fair based on the alternative approach.

Time Complexity

The time complexity is O(N), where N is the length of the input array. Calculating the prefix sums and iterating through the array are both linear operations.

Space Complexity:

The space complexity is O(N), as additional space is used for the prefix sum arrays (prefixEven and prefixOdd). The space required scales linearly with the input size.

Next TopicFind the Absolute Difference between the Right View Sum of two Binary Trees

← prev next →