“MapQuest”编码挑战 - 消除相互抵消的“方向”

Question

这个想法是消除在一系列方向上的无意义旅行：

'N' = 北

'S' = 南

'E' = 东

'W' = 西

因此，如果我们有数组 ['S', 'E', 'W', 'W']，我们希望 mapQuest 函数返回：

['S', 'W']

由于East和West彼此相邻，因此它们会相互抵消。

*注意方向必须在数组中彼此相邻才能被抵消。

此外，数组应该继续减少，直到最终数组不包含任何对立面 - 即它处理“复杂情况”：

['W', 'N', 'S', 'E', 'N']

应该返回

['N']

因为['W', 'N', 'S', 'E', 'N'] => ['W', 'E', 'N'] => ['N']

这个挑战的一部分是我必须使用reduce 方法。

根据我对.reduce()的理解，我的想法是：

function mapQuest (array) {
	return array.reduce((accumulator, current, i) => {
		if ((array[i] === 'S' && array[i + 1] !== 'N' && array[i - 1] !== 'N')) {
			accumulator.push(array[i]);
		}

		if ((array[i] === 'N' && array[i + 1] !== 'S' && array[i - 1] !== 'S')) {
			accumulator.push(array[i]);
		}
		
		if ((array[i] === 'E' && array[i + 1] !== 'W' && array[i - 1] !== 'W')) {
			accumulator.push(array[i]);
		}

		if ((array[i] === 'W' && array[i + 1] !== 'E' && array[i - 1] !== 'E')) {
			accumulator.push(array[i]);
		}
		
		return accumulator;
	}, []);
}

console.log(mapQuest(['S', 'E', 'W', 'W']));

工作但没有通过最后的测试规范 - 处理复杂的情况。

期望['N', 'N', 'E', 'W', 'S', 'S', 'E', 'W', 'N', 'N', 'W', 'S', 'E'] 等于['N', 'N', 'W', 'S', 'E']

Answer 1

一种解决方案，虽然不是很健壮，但是将缩减后的数组分配给一个变量，然后缩减该数组：

function mapQuest (array) {
	let first = array.reduce((accumulator, current, i) => {
		if ((array[i] === 'S' && array[i + 1] !== 'N' && array[i - 1] !== 'N')) {
			accumulator.push(array[i]);
		}

		if ((array[i] === 'N' && array[i + 1] !== 'S' && array[i - 1] !== 'S')) {
			accumulator.push(array[i]);
		}
		
		if ((array[i] === 'E' && array[i + 1] !== 'W' && array[i - 1] !== 'W')) {
			accumulator.push(array[i]);
		}

		if ((array[i]=== 'W' && array[i + 1] !== 'E' && array[i - 1] !== 'E')) {
			accumulator.push(array[i]);
		}
		
		return accumulator;
	}, []);
	let second = first.reduce((final, current, index) => {
		if ((first[index] === 'S' && first[index + 1] !== 'N' && first[index - 1] !== 'N')) {
			final.push(first[index]);
		}

		if ((first[index] === 'N' && first[index + 1] !== 'S' && first[index - 1] !== 'S')) {
			final.push(first[index]);
		}
		
		if ((first[index] === 'E' && first[index + 1] !== 'W' && first[index - 1] !== 'W')) {
			final.push(first[index]);
		}

		if ((first[index] === 'W' && first[index + 1] !== 'E' && first[index - 1] !== 'E')) {
			final.push(first[index]);
		}
		
		return final;
	}, []);
	return second;
}
console.log(mapQuest(['N', 'N', 'E', 'W', 'S', 'S', 'E', 'W', 'N', 'N', 'W', 'S', 'E']));

通过所有测试规范。

Answer 2

我为您提供此代码 sn-p 作为可能的答案。这是我所做的：

1. 我使用标准比较而不是match
2. 我添加了额外的reduce 参数
3. 我使用递归格式来确保最终答案发生缩减
4. 我使用了一种非常规的方法来删除这些对，将它们标记为删除'X'，然后将它们过滤掉

function mapQuest(quest, last) {

  if (JSON.stringify(quest) === JSON.stringify(last)) return quest;

  var initialQuest = quest.map(x => x);

  var newest = quest.reduce((accumulator, current, index, array) => {
    if ((current === 'S' && array[index + 1] === 'N') ||
      (current === 'N' && array[index + 1] === 'S')) {
      accumulator[index] = 'X';
      accumulator[index + 1] = 'X';
    }
    if ((current === 'E' && array[index + 1] === 'W') ||
      (current === 'W' && array[index + 1] === 'E')) {
      accumulator[index] = 'X';
      accumulator[index + 1] = 'X';
    }
    return accumulator;
  }, initialQuest);

  var filtered = newest.filter(i => i !== 'X');

  return mapQuest(filtered, initialQuest);
}
var tests = [];
tests.push({
  input: ['S', 'E', 'W', 'W'],
  expected: ['S', 'W']
});
tests.push({
  input: ['W', 'N', 'S', 'E', 'N'],
  expected: ['N']
});
tests.push({
  input: ['N', 'N', 'E', 'W', 'S', 'S', 'E', 'W', 'N', 'N', 'W', 'S', 'E'],
  expected: ['N', 'N', 'W', 'S', 'E']
});

tests.forEach(test => {
  var output = mapQuest(test.input, []);
  var passed = JSON.stringify(test.expected) === JSON.stringify(output) ? 'passed' : 'failed';
  console.log(`${test.input} => ${output} : ${passed}`);
});