JavaScript Kata #39: Equal Sides Of An Array

By YayoDrayber | Learn To Code With Me | 22 Sep 2022

If you missed the introductory post, it's here. For a list of previously solved katas, please refer to the bottom of this page.

If this is your first time seeing my post, please note - these katas are probably randomly assigned per user so please don't go into Codewars thinking we will have exactly the same user experience, I am just posting these in the order that I got them.

Kata #39

DESCRIPTION:

You are going to be given an array of integers. Your job is to take that array and find an index N where the sum of the integers to the left of N is equal to the sum of the integers to the right of N. If there is no index that would make this happen, return -1.

For example:

Let's say you are given the array {1,2,3,4,3,2,1}:
Your function will return the index 3, because at the 3rd position of the array, the sum of left side of the index ({1,2,3}) and the sum of the right side of the index ({3,2,1}) both equal 6.

Let's look at another one.
You are given the array {1,100,50,-51,1,1}:
Your function will return the index 1, because at the 1st position of the array, the sum of left side of the index ({1}) and the sum of the right side of the index ({50,-51,1,1}) both equal 1.

Last one:
You are given the array {20,10,-80,10,10,15,35}
At index 0 the left side is {}
The right side is {10,-80,10,10,15,35}
They both are equal to 0 when added. (Empty arrays are equal to 0 in this problem)
Index 0 is the place where the left side and right side are equal.

Note: Please remember that in most programming/scripting languages the index of an array starts at 0.

Input:
An integer array of length 0 < arr < 1000. The numbers in the array can be any integer positive or negative.

Output:
The lowest index N where the side to the left of N is equal to the side to the right of N. If you do not find an index that fits these rules, then you will return -1.

Note:
If you are given an array with multiple answers, return the lowest correct index.

Starting code:

function findEvenIndex(arr)
{
  //Code goes here!
}

My attempt that worked:

function findEvenIndex(arr){
  let i = 0
  let nIndex = 0
  let isEven = false
  
  for (i = 0 ; i < arr.length && isEven == false; i++){
    
    let sumLeftOfN = 0
    let sumRightOfN = 0
    
    for(iLeft = 0; iLeft < i; iLeft++){
      sumLeftOfN += +arr[iLeft]
    }
    
    for(iRight = i+1; iRight < arr.length; iRight++){
      sumRightOfN += +arr[iRight]
    }
    
    if(sumLeftOfN === sumRightOfN){
      isEven = true
      nIndex = i
    } else{
      nIndex = -1
    }
    
  }
  
  return nIndex
}

Brain-melting problem. I wanted to use the .reduce() method but I wasn't sure how to pick out the left side and the right side of the N index of the array so I went with what I have right now, but rank #1 by a measly 34 users show us how:

function findEvenIndex(arr)
{
  var left = 0, right = arr.reduce(function(pv, cv) { return pv + cv; }, 0);
  for(var i = 0; i < arr.length; i++) {
      if(i > 0) left += arr[i-1];
      right -= arr[i];
      
      if(left == right) return i;
  }
  
  return -1;
}

Rank #2 with two-liners by users rahul, AltSquich, hassan.m98, davidsonq, Travis Merrit:

const sum = (a, from, to) => a.slice(from, to).reduce((a, b) => a + b, 0)
const findEvenIndex = a => a.findIndex((el, i) => sum(a, 0, i) === sum(a, i + 1));

Rank #3 looks a lot like rank #1 and made by user d-sheep:

function findEvenIndex(arr)
{
  let left = 0;
  let right = arr.reduce((s,n) => s + n, 0);
  for (let i = 0; i < arr.length; i++) {
    right -= arr[i];
    if (left === right) return i;
    left += arr[i];
  }
  return -1;
}

Rank #4 by users petebr, ChernyshovaAlexandra, LomakoDasha, karki011:

function findEvenIndex(arr)
{
  function sum(arr){
    return arr.reduce(function(a,b){return a+b;},0);
  }

  return arr.findIndex(function(el,i,arr){
    return sum(arr.slice(0, i)) === sum(arr.slice(i+1,arr.length));
  });
}

Rank #5 by user palmertodd:

function findEvenIndex(arr){
  return arr.findIndex((e,i,a)=> a.slice(0,i).reduce((p,c)=>p+c,0)==a.slice(i+1).reduce((p,c)=>p+c,0));
}

Rank #6 by user skhamoud:

function findEvenIndex(arr){
  const sum = arr => arr.reduce((acc,cur)=> (acc+cur) ,0)
  return arr.findIndex((val,idx) => sum(arr.slice(0,idx)) === sum(arr.slice(idx+1)))
}

Rank #7 by user ellielo:

function findEvenIndex(arr){
  // LOOP THROUGH INDEX
    for (var i = 0; i < arr.length; i++) {
      var j = arr.slice(0, i);
      var l = arr.slice(i+1, arr.length);
  // ADD THE LEFT SIDE AND THE RIGHT SIDE 
      function add(a, b) {
        return a + b
      }
    var sumLeft = j.reduce(add, 0);
    
    var sumRight = l.reduce(add, 0);

  // DOES IS EQUAL THE SAME 
    if (sumLeft === sumRight) {
      return i
    };
    if (i === arr.length-1 && sumLeft!== sumRight) {
      return -1
     }
    }
}

Rank #8 made by users drewtyler, whin007, roshlarosh, mattleahy and youssefby96 also looks a bit like rank #3 and rank #1 but without using the .reduce() method:

function findEvenIndex(arr)
{
  var leftsum = 0;
  var rightsum = 0;
  for(var i = 0; i < arr.length; i++) {
    rightsum += arr[i]; 
  }
  for(i = 0; i < arr.length; i++) {
    rightsum -= arr[i];
    if(leftsum === rightsum) return i;
    leftsum += arr[i];
  }
  return -1;
}

Rank #9 by user Konstantin Modin with a one-liner:

findEvenIndex=(a,b=a=>a.reduce((a,b)=>a+b,0))=>a.findIndex((_,i)=>b(a.slice(0,i))==b(a.slice(i+1)))

Rank #10 by user SteveAquino:

function sum(a, b) { return a + b; }

function findEvenIndex(arr) {
  return arr.findIndex((_, i) =>
    arr.slice(0, i + 1).reduce(sum) === arr.slice(i).reduce(sum)
  );
}

Wanted to show all the top ten approaches just to show that my messy approach could have been tons better.

That's it for Kata #39, stay tuned for more katas to be solved!

Link to Kata #1: Square(n) Sum

Link to Kata #2: Convert a Number to a String

Link to Kata #3: DNA to RNA Conversion

Link to Kata #4: Remove First and Last Character

Link to Kata #5: MakeUpperCase

Link to Kata #6: Total amount of points

Link to Kata #7: A Needle in the Haystack

Link to Kata #8: Sum of positive

Link to Kata #9: Basic Mathematical Operations

Link to Kata #10: Beginner - Reduce but Grow