Помогите с задачей
 

You are given an integer array nums. You can choose exactly one index (0-indexed) and remove the element. Notice that the index of the elements may change after the removal.

For example, if nums = [6,1,7,4,1]:

Choosing to remove index 1 results in nums = [6,7,4,1].
Choosing to remove index 2 results in nums = [6,1,4,1].
Choosing to remove index 4 results in nums = [6,1,7,4].
An array is fair if the sum of the odd-indexed values equals the sum of the even-indexed values.

Return the number of indices that you could choose such that after the removal, nums is fair.
Пример:
Ввод: nums = [2,1,6,4]
Выход: 1
Пояснение:
Убрать индекс 0: [1,6,4] -> Четная сумма: 1 + 4 = 5. Нечетная сумма: 6. Нечестно.
Убрать индекс 1: [2,6,4] -> Четная сумма: 2 + 4 = 6. Нечетная сумма: 6. Справедливая.
Убрать индекс 2: [2,1,4] -> Четная сумма: 2 + 4 = 6. Нечетная сумма: 1. Нечестно.
Убрать индекс 3: [2,1,6] -> Четная сумма: 2 + 6 = 8. Нечетная сумма: 1. Нечестно.
Есть 1 указатель, который можно удалить, чтобы количество было справедливым.

Решил сделать в функциональном стиле, вот что у меня получилось, но ответ не верный, помогите найти, что я сделал не правильно

const sumOdd = function(nums) {
    return nums.map((num, i) => i % 2 ? 0 : num).reduce((num1, num2) => num1 + num2, 0)
}

const removeIndex = function(nums, ind) {
    return nums.slice(0, ind).concat(nums.slice(ind + 1))
}

const waysToMakeFair = function(nums) {
    const indexes = [...Array(nums.length).keys()]
    return indexes.filter(ind => sumOdd(removeIndex(nums, ind)) % 2 == 0).length
};

Вариант, работающий за линейное время

function waysToMakeFair(arr) {
  if (!arr || !arr.length) {
    return 0;
  }
  let fullDelta = 0;
  const deltas = new Array(arr.length);
  for (let i = 0; i < arr.length; ++i) {
    fullDelta += i % 2 ? -arr[i] : arr[i];
    deltas[i] = fullDelta;
  }
  let count = 0;
  for (let i = 0; i < arr.length; ++i) {
    const prevDelta = i > 0 ? deltas[i - 1] : 0
    const nextDelta = fullDelta - deltas[i]
    if (prevDelta - nextDelta === 0) {
      count++
    }
  }
  return count
}

alert(waysToMakeFair([2,1,6,4]));

кстати, можно переиспользовать переданный массив, чтобы не понадобился вспомогательный :)

function waysToMakeFair(arr) {
  if (!arr || !arr.length) {
    return 0;
  }
  let fullDelta = 0;
  for (let i = 0; i < arr.length; ++i) {
    fullDelta += i % 2 ? -arr[i] : arr[i];
    arr[i] = fullDelta;
  }
  let count = 0;
  for (let i = 0; i < arr.length; ++i) {
    const prevDelta = i > 0 ? arr[i - 1] : 0
    const nextDelta = fullDelta - arr[i]
    if (prevDelta - nextDelta === 0) {
      count++
    }
  }
  // восстанавливаем стартовые значения
  for (let i = arr.length - 1; i > 0; --i) {
    arr[i] = i % 2 ? -arr[i] + arr[i-1] : arr[i] - arr[i-1];
  }
  return count
}

Alexandroppolus,
спасибо за решение, но это не то что я хотел. мне нужно решить, чтобы было как в моем коде, несколько функций которые отвечают за своё и без циклов

ох уж эти ФП-шники ))

function makeDeltas(arr) {
  let fullDelta = 0;
  return arr.map((num, i) => fullDelta += i % 2 ? -num : num);
}

const calc = (deltas) => deltas.reduce((count, d, i, arr) => 
    (i > 0 ? arr[i - 1] : 0) + d - arr[arr.length - 1] ? count : count + 1, 0)

const waysToMakeFair = (arr) => !arr || !arr.length ? 0 : calc(makeDeltas(arr))

alert(waysToMakeFair([2,1,6,4]));

vurdalak21,

const sumOdd = function(nums) {
    return !nums.reduce((balance, num, i) => balance +=  i % 2 ? num : -num, 0)
}

const removeIndex = function(nums, ind) {
    nums = nums.slice(0);
    nums.splice(ind, 1);
    return nums
}

const waysToMakeFair = function(nums) {
    return Object.keys(nums).filter(ind => sumOdd(removeIndex(nums, ind)))
};
alert(waysToMakeFair( [2,1,6,4]));

рони,
то что нужно, спасибо

vurdalak21,
убрал умножение

balance +=  i % 2 ? num : -num