Как написать код правильно для всех условий

x=[2,3,9,0,1,7]; //на выходе: true
//x=[1,2,3,0];     на выходе: true
//x=[1,0]      на выходе: false
//x=[1,3,4,0,0,8]   на выходе: true
  function solution(x){
       let newArr = [];
   for(let i=0;i<x.length;i++){
       if (i % 2 == 0){
           let temp = x[i] + x[i+1];
           newArr.push(temp);
       }
       if(newArr[i]===newArr[i+1]){
           return true
       } 
           return false
        
   }
  }
   console.log(solution(x))

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

Шалом.

const solution = (arr) => {
if (!Array.isArray(arr)) {
    return;
}

return arr.reduce((accumulator, currentValue, index, array) => {
    return index % 2 === 0 ? [...accumulator, array[index + 1] + currentValue] : [...accumulator];
}, []).every((currentValue, index, array) => {
    return currentValue === array[0];
});}

Тут не должно быть на выходе true. Где-то описка.


Направление мышления верное. Нужно поправить детали:

let temp = x[i] + x[i+1]

x[i+1] будет быть undefined для массивов с нечетной длиной. Я бы писал так:

let temp = x[i] + x[i+1] || 0;

x[i+1] || 0 вычислится или в значение x[i+1] или в 0 если значение у x[i+1] undefined.

А вот эту проверку нужно сделать в отдельном цикле после того как заполнишь newArr значениями. При том нужно подумать как именно проверить что “все элементы массива равны друг другу”.


У задачи есть короче путь решения. Будет время - напишу его.

function areAllPairSumsEqual(arr) {
	let prevSum = 0
	let currSum = 0
	for (let i = 0; i < arr.length; i += 2) {
		currSum = arr[i] + (arr[i+1] || 0)
		if (i > 0) {
			if (prevSum !== currSum) {
				return false
			}
		}
		prevSum = currSum
	}
	return true
}

Логика такая что мы делаем 1 проход. Итерируем по индексам с шагом 2. Запоминаем предыдущую сумму пар и сравниваем с текущей суммой пар. Если встречаем хотя бы одно неравенство сумм, то сразу прекращаем итерировать и возвращаем false.

Алгоритм более запутанный на мой вкус чем с промежуточным массивом. Зато более оптимальный.