检查数组左侧的总和是否等于 o(n) 中数组的右侧

Question

I was given an array of numbers (integer) and I need to return the element if the sum of numbers in his right side equals to the sum of numbers in his left size in o(n).

For example the array {1,2,2,9,3,2} the program should print 9 because 1+2+2 = 5 and 3+2=5

I attached my code but it's not o(n) complexity. appreciate your help.

Thanks.

public class Program {
    public static void checkIfEqualOption1(int[] arr){
        int sumRight = 0;
        int sumLeft=0;
        //sumRight+=numbers[0];
        for (int i=0; i < arr.length; i++){
            if (i>0){
                sumRight+=arr[i-1];
                for (int j=i+1; j<arr.length; j++){
                    sumLeft+=arr[j];
                }
                if (sumRight==sumLeft){
                    System.out.println("\nFound = "+arr[i]);
                    break;
                }
            }
        }

    }

    public static void print(int[] arr){
        for (int i=0; i < arr.length; i++){
            System.out.print(arr[i] + " ");
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("Hi");
        int[] numbers = {1,2,2,9,3,2};
        System.out.println("Array numbers:");
        for (int i=0; i < numbers.length; i++){
            System.out.print(numbers[i] + " ");
        }
        System.out.println("\n");
        checkIfEqualOption1(numbers);
    }
}

Answer 1

Start with the observation that for each i

arraySum(0, i) + arraySum(i+1, n) == arrayTotal

so

arraySum(i+1, n) == arrayTotal - arraySum(0, i);
^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^^^^^
Sum on the right                 Sum on the left

Compute the arrayTotal in the first pass; then walk the array from the left, computing the partial sum. Stop once you reach a position where

partialSum == arrayTotal - partialSum

Answer 2

This should work in O(n) , you don't need to sort the array:

public class Program {

    public static void checkIfEqualOption1(int[] arr){

        int sumTotal=0;
        for (int i=0; i < arr.length; i++){ // O(arr.length)
            sumTotal += arr[i];
        }

        int sumRight = 0;
        int sumLeft=0;
        for (int i=1; i < arr.length-1; i++){ // O(arr.length)
            sumLeft += arr[i-1];
            sumRight = sumTotal - arr[i] - sumLeft;
            if (sumRight == sumLeft){
                System.out.println("\nFound = "+arr[i]);
                break;
            }
        }
   }


   public static void main(String[] args) {

     int[] numbers = {1,2,2,9,3,2};
     System.out.println("Array numbers:");
     for (int i=0; i < numbers.length; i++){
          System.out.print(numbers[i] + " ");
     }
     System.out.println("\n");
     checkIfEqualOption1(numbers);
   }

}

This outputs:

Array numbers:
1 2 2 9 3 2


Found = 9

Answer 3

I came up with this solution which calculates both sums by increments from left and right positions ( posFromLeft and posFromRight in the code below), until the positions have "crossed" each other ( posFromRight > posFromLeft is not being satisfied anymore):

public class Program {

public static void checkIfEqualOption1(int[] arr){
    int sumRight = 0;
    int sumLeft=0;
    int arrayLength=arr.length;
    for (int posFromLeft=0; posFromLeft < arrayLength; posFromLeft++){
        int posFromRight=arrayLength-posFromLeft-1;
        if (posFromRight > posFromLeft){

        sumRight+=arr[posFromRight];
        sumLeft+=arr[posFromLeft];
        }
    }
System.out.println("right sum: "+sumRight);
System.out.println("left sum: "+sumLeft);
}


public static void main(String[] args) {


    int[] numbers = {1,2,2,9,3};
    System.out.println("Array numbers:");
    for (int i=0; i < numbers.length; i++){
        System.out.print(numbers[i] + " ");
    }

    checkIfEqualOption1(numbers);
}
}

Answer 4

I have written below code to check the equality of sum of the LHS and RHS array items. getMidIndex() will return the array index where it found the equality....

public class Concepts {

public static int getMidIndex(int[] elements) throws Exception {
    int endIndex = elements.length - 1;
    int startIndex = 0, sumL = 0, sumR = 0;

    while (true) {
        if (sumL > sumR)
            sumR += elements[endIndex--];
        else
            sumL += elements[startIndex++];
        System.out.println("StartIndex: " + startIndex + " Endindex: " + endIndex + " SumLeft: " + sumL
                + " SumRight: " + sumR);
        if (sumL == sumR)
            break;
        if (startIndex > endIndex) {
            System.out.println("Invalid Array");
            break;
        }
    }
    return endIndex;
}

public static void main(String[] args) throws Exception {
    int[] array = { 1, 2, 2, 9, 3, 2 };
    int midVal = getMidIndex(array);
    System.out.println("Mid index: " + midVal + " Value: " + array[midVal]);
}

}

Answer 5

 void balanceArray(int[] arr){
    int[] leftArray;
    int[] rightArray;
    for(int i=0; i<arr.length; i++){

        leftArray=Arrays.copyOfRange(arr,0, i+1);
        rightArray = Arrays.copyOfRange(arr,i+1, arr.length);
        int sumofLeft= sumOfArray(leftArray);
        int sumofRight = sumOfArray(rightArray);

        if(sumofLeft==sumofRight  && sumofLeft!=0){
            int L=leftArray.length;
            int R=rightArray.length;
            return;
        }

    }

sumOfArray(...) method is as follow.

 private int sumOfArray(int[] arr){
    int sum=0;
    for(int no:arr){
        sum+=no;
    }
    return sum;
}

Answer 6

public void printMiddleIndex(int[] arr) {
    int endidx = arr.length-1; // End index
    int startidx = 0; // Start index
    int ssum =arr[0]; // sum from left end 'start sum'
    int esum =arr[endidx]; // sum from right end 'end sum'

    while(true) {
        System.out.println("Ssum : "+ssum+" Esum : "+esum+"  Sindex : "+startidx+"  Eindex  : "+endidx);
        if(ssum>esum) 
            esum += arr[--endidx];
        else if(ssum<esum) 
            ssum += arr[++startidx];
        else if(ssum==esum) {
            if(startidx == endidx-1) {
                System.out.println("MiddleIndex : "+endidx);
                break;
            }
            ssum += arr[++startidx];
        }
        else if(startidx > endidx-1) {
            System.out.println("Array is not good");
        }
    }
}

Answer 7

Here's a solution in Python. I have used list slicing. This is having least space complexity running in O(n). Here "l" is the input array.

for i in range(len(l)-1):
if sum(l[0:i+1])==sum(l[i+2:]):
    print(l[i+1])

Answer 8

Implemented in Javascript but same logic applies. This is O(n) solution:

//returns the index or -1 if not equal sides
function findIndexIfArrayHasEqualSides(arr) {
  const sum = arr.reduce((acc, num) => acc += num);
  let sumLeft = 0;
  let sumRight = 0;

  for (let i = 0; i < arr.length; i++) {
    const currentVal = arr[i];
    sumRight = sum - sumLeft - currentVal;

    if (sumLeft === sumRight) {
      return i;
    }

    sumLeft += currentVal;
  }

  return -1;
}