Не удается найти решение проблемы обратного алгоритма массива

Question

У меня есть требование, при котором я должен обратить массив, не изменяя индекс «#», представленного в массиве, как в примере ниже:

• Массив [18,-4,'#',0,8,'#',5] должен возвращать [5, 8, "#", 0, -4, "#", 18], здесь числа следует поменять местами, исключая '#', сохраняя при этом тот же индекс.

Я пытался получить правильный вывод, но он кажется неправильным не во всех сценариях ios: var arr = [18, -4, '#', 0,8, '#', 5]; // даем правильный результат var arr1 = [18, -4,0, '#', 8, '#', 5]; // результат неверный

var reverse = function(numbers, start, end){
	var temp = numbers[start];
  numbers[start] = numbers[end];
  numbers[end] = temp;
}
var flip = function(numbers) {
var start = 0;
var end = numbers.length-1;
	for(var i=0;i<parseInt(numbers.length/2);i++) {
  	if(numbers[i] === '#') {
    	start = i+1;
      end = numbers.length - i - i;
      reverse(numbers, start, end);
    } else if (numbers[numbers.length - i - 1] === '#') {
    	start = i;
      end = numbers.length - i - 2;
      reverse(numbers, start, end);
    } else {
    	reverse(numbers, start, end);
    }
  }
  return numbers;
}

var arr = [18,-4,'#',0,8,'#',5];
var arr1 = [18,-4,0,'#',8,'#',5];
console.log(flip(arr));
console.log(flip(arr1));

Answer 1

Тривиальным подходом было бы удалить все '#', развернуть массив, используя встроенный метод [].reverse, а затем снова вставить '#':

let flip = numbers => {
  let removed = numbers.reduce((r, v, i) =>
          v === '#' ? r.concat(i) : r
      , []);

  let reversed = numbers.filter(v => v !== '#').reverse();

  removed.forEach(i => reversed.splice(i, 0, '#'));

  return reversed;
};

let arr = [18, -4, '#', 0, 8, '#', 5];
let arr1 = [18, -4, 0, '#', 8, '#', 5];
console.log(flip(arr));
console.log(flip(arr1));

Answer 2

Вы можете упростить функцию и использовать только два индекса: начало и конец и проверить, должно ли значение индексов оставаться, затем выбрать другой индекс для замены.

const
    swap = (array, a, b) => [array[a], array[b]] = [array[b], array[a]],
    flip = numbers => {
        var start = 0,
            end = numbers.length - 1;

        while (start < end) {
            if (numbers[start] === '#') {
                start++;
                continue;
            }
            if (numbers[end] === '#') {
                end--;
                continue;
            }
            swap(numbers, start++, end--);
        }
        return numbers;
    },
    array1 = [18, -4, '#', 0, 8, '#', 5],
    array2 = [18, -4, 0, '#', 8, '#', 5];

console.log(...flip(array1));
console.log(...flip(array2));

Answer 3

Вы можете основывать свой алгоритм на двух массивах c (массив обращенных чисел и массив с "#" сохраненными позициями)

const array = [5, 8, "#", 0, -4, "#", 18];

function flip(array) {

  const arrayNumbers = array.filter((el, index) => el !== "#").reverse();

  var counter = 0;

  return array.map(el => el === "#").map(el => {
    if (!el) {
      let num = arrayNumbers[counter];
      counter = counter + 1;
      return num;
    } else {
      return "#"
    }
  })
}

console.log(flip(array));

Answer 4

Вы можете попробовать это:

var numbers = arr.filter(a => a !== '#')
var revArr = [];
arr.forEach((currentValue) => {
    if(currentValue !== "#") {
        revArr.push(numbers.pop());
    } else {
        revArr.push("#");
    }
});

Answer 5

Вы можете сделать это так.

        int end = v.length - 1;
        int start = 0;
        for (int i = 0; i < v.length >> 1; i++) {
            if (v[start].equals("#")) {
                start++;
                continue;
            }
            if (v[end].equals("#")) {
                end--;
                continue;
            }
            Object temp = v[end];
            v[end] = v[start];
            v[start] = temp;
            end--;
            start++;

        }
        System.out.println(Arrays.toString(v));

Answer 6

var arr = [18,-4,'#',0,8,'#',5]
var stack = []

for (i=0 ; i<arr.length; i++) {
    if (arr[i] == '#') continue;
    stack.push(arr[i]);
}

for (i=0 ; i<arr.length; i++) {
    if (arr[i] != '#') {
        arr[i] = stack.pop();
    }
}

console.log(arr)

Приведенный выше код должен решить вашу проблему.
Реализация использует стек, где мы продолжаем вставлять элементы в стек до тех пор, пока не увидим «#» и не пропустим его. При создании выходного массива мы ссылаемся на исходный массив для индекса '#' и стека для обратного индекса.