Сортировка массива в порядке неубывания с чередованием четных-нечетных чисел

Question

Необходимо отсортировать массив целых чисел в порядке неубывания с чередованием четных-нечетных чисел и наоборот. Те если наименьшее число массива - нечетное, то чередование происходит по шаблону нечетное число-четное число. Если сортировку провести можно, функция возвращает отсортированный массив или -1 в противном случае.

Примеры:

Входные данные: [3, 2, 0, 4, 5, 11], выходные данные: [0, 3, 2, 5, 4, 11]
Входные данные: [3, 2, 0, 5, 11], выходные данные: -1

Мая функция работает, но код выглядит некрасиво. Как можно решить проще?

let arr = [3,2,0,5,11];

function sortArr(arr){
    if(arr.length > 0) {
        let odd = [], even = [], sorted = [];
        for (let i of arr) {
            if ((i ^ 0) === i)
                (i & 1) ? odd.push(i) : even.push(i);
            else
                return -1;
        }
        odd.sort((a, b) => a - b);
        even.sort((a, b) => a - b);
        let min = Math.min.apply(null, arr);
        if (min & 1) {
            if ((even.length === odd.length) || (even.length === odd.length - 1)) {
                for (let j in arr) {
                    (j & 1) ? sorted.push(even.shift()) : sorted.push(odd.shift());
                }
            }
            else
                return -1;
        }
        else {
            if ((even.length === odd.length) || (odd.length === even.length - 1)) {
                for (let j in arr) {
                    (j & 1) ? sorted.push(odd.shift()) : sorted.push(even.shift());
                }
            }
            else
                return -1;
        }
        return sorted;
    }
    else
        return -1;

}

console.log(sortArr(arr));

Answer 1

Например, разобрать на четные и нечетные, отдельно их отсортировать, потом собрать обратно:

console.log( sortArr([3, 2, 0, 4, 5, 11, 6]) );
console.log( sortArr([3, 2, 0, 5, 11]) );
console.log( sortArr([]) );

function sortArr(arr) {
  if( arr.length == 0 ) return -1;
  // Не создаем лишний уровень вложенности. Если такая валидация правда нужна.
  
  let even = [];
  let odd = [];
  
  arr.forEach( num => (num % 2 == 0 ? even : odd).push(num) );
  
  if( ![0, 1].includes(even.length - odd.length) ) return -1;
  // Чередуются же: Разница их количества должна быть или 0, или 1
  
  even.sort((a,b) => a - b);
  odd.sort((a,b) => a - b);
  
  let i, result = [];
  for( i = 0; i < odd.length; i++ ) {
    result.push(even[i], odd[i]);
  }  
  if( typeof even[i] !== "undefined" ) result.push( even[i] );
  // Не потерять последний четный, если есть.
  // typeof, потому что Ноль не пройдет if( even[i] )
  
  return result;
}

БЛОГ НА HUSL

Сортировка массива в порядке неубывания с чередованием четных-нечетных чисел

Ответы (1 шт):