Javascript 减少方向阵列以提高效率

我正在进行一个编程练习，该练习通过一组等距方向（N、S、E、W）。目标是将给定的阵列减少为一组更有效的方向。例如：给定一个

数组[“N”、“S”、“N”、“S]”，

最终，我们将回到原点。为了最大限度地减少浪费，新阵列将不会移动或归零

方法：

function dirReduc(arr) {
  var dx = 0;
  var dy = 0;
  var newArr = ["NORTH", "SOUTH", "EAST", "WEST"];

  for(var i = 0; i <= arr.length; i++) {
    switch(arr[i]) {
      case 'NORTH': dy++;
        break;
      case 'SOUTH': dy--;
        break;
      case 'EAST': dx++;
        break;
      case 'WEST': dx--;
        break;
     }
  }
  if() {

  }
}

函数dirreduce（arr）{
var-dx=0；
var-dy=0；
var newArr=[“北”、“南”、“东”、“西”]；
对于（var i=0；i如果它是关于条件语法的，那么可以使用基于
函数的
Reduce
而不是
开关/case


函数dirreduce（arr）{
常数映射={
北：（[x，y]）=>[x，y+1]，
南：（[x，y]）=>[x，y-1]，
东：（[x，y]）=>[x+1，y]，
西：（[x，y]）=>[x-1，y]，
};
log（arr.reduce（（tmp，x）=>map[x]（tmp），[0，0]）；
}
dirreduce([
"北",，
"北",，
"北",，
“南方”，
])；
用于（；dx>0；dx--）{result.append（'EAST'）；}
对于（；dx<0；dx++）{result.append（'WEST'）；}
对于（；dy>0；dy--）{result.append（'NORTH'）；}
对于（；dy<0；dy++）{result.append（'SOUTH'）；}
您可以使用对象映射来代替switch语句。swirh的复杂性不仅仅是对象映射


函数dirreduce（arr）{
var-dx=0；
var-dy=0；
var newArr=[“北”、“南”、“东”、“西”]；
开关对象={
北：函数（）{
console.log（'north'）
dy++；
},
南方：职能（）{
console.log（'SOUTH'））
dy--；
},
东部：职能（）{
console.log（'EAST'））
dx++；
},
韦斯特：职能（）{
console.log（'WEST'））
dx--；
}
}
对于（变量i=0；iDirReduce（[“北”、“南”、“东”、“西”]）
您可以创建一个方向为属性名称的对象，其值是包含两个元素的数组
[x，y]
。使用
reduce
对数组进行汇总


函数dirreduce（arr）{
变量d={北：[0,1]，南：[0，-1]，东：[1,0]，西：[-1,0]}
返回arr.reduce（（[x，y]，v）=>[x+d[v][0]，y+d[v][1]，[0，0]）；
}
var result1=dirreduce（['NORTH'，'SOUTH'，'NORTH'，'SOUTH']）；
console.log（'Result 1'，result1）；
var result2=dirreduce（[‘北’、‘南’、‘东’、‘东’、‘南’]）；
console.log（'Result 2'，result2）；
常量映射={
北：（[x，y]）=>[x，y+1]，
南：（[x，y]）=>[x，y-1]，
东：（[x，y]）=>[x+1，y]，
西：（[x，y]）=>[x-1，y]，
};
const walk=coords=>coords.reduce（（tmp，x）=>map[x]（tmp），[0，0]）
const removeLoops=步骤=>{
让循环=[]
对于（var i=0；i{
新步骤拼接（从，到-从+1）
})
返回新闻步骤
}
控制台日志（removeLoops）([
"北",，
"北",，
"北",，
“南方”，
]))
一种非常直接、易于理解的方法是简单地计算每个方向出现的次数，然后从s中减去n，从e中减去w。然后根据这些数字创建一个新数组。例如：


让arr=['n'，'n'，'s'，'e'，'w'，'n'，'s'，'e'，'e'，'e'，'w']
让计数=arr.reduce（（a，c）=>（a[c]++，a），{n:0，s:0，w:0，e:0}）
设ns=counts.n-counts.s//如果总体向南，则为负；如果向北，则为正。
设ew=counts.w-counts.e
//制作数组
让结果=[…数组（Math.abs（ns））.fill（ns>0？'n'：'s'），…数组（Math.abs（ew））.fill（ew>0？'w'：'e'）]
console.log（结果）
这里有一些有用的东西

const arr = ['NORTH', 'SOUTH', 'WEST', 'NORTH', 'EAST', 'WEST', 'NORTH', 'SOUTH', 'EAST', 'WEST', 'NORTH', 'EAST', 'WEST'];

const os = {
  'EAST': 'WEST',
  'WEST': 'EAST',
  'NORTH': 'SOUTH',
  'SOUTH': 'NORTH'
}

const dc = arr.reduce((ds, d) => ({
  ...ds,
  [d]: (ds[d] || 0) + 1,
  [os[d]]: ds[os[d]] - 1
}), {});

const result = Object.keys(dc).filter(key => dc[key] > 0);

console.log(result)

这一切都是有道理的；但是，为了满足挑战，结果数组需要采用字符串的形式，而不是[x，y]坐标。您可以像
var x=result1[0]；
和
var y=result1[1]；
您更喜欢返回值的格式是什么？@wellington该格式应该与在dirreduce中传递的数组相同（）.Ex:['North'，'West']在reduce方法中[0,0]代表什么？
const arr = ['NORTH', 'SOUTH', 'WEST', 'NORTH', 'EAST', 'WEST', 'NORTH', 'SOUTH', 'EAST', 'WEST', 'NORTH', 'EAST', 'WEST'];

const os = {
  'EAST': 'WEST',
  'WEST': 'EAST',
  'NORTH': 'SOUTH',
  'SOUTH': 'NORTH'
}

const dc = arr.reduce((ds, d) => ({
  ...ds,
  [d]: (ds[d] || 0) + 1,
  [os[d]]: ds[os[d]] - 1
}), {});

const result = Object.keys(dc).filter(key => dc[key] > 0);

console.log(result)