Question

我正在通过传递一系列等距方向（N，S，E，W）的编程工作。目的是将给定的数组简化为一组更有效的方向。例如：最终给定array ["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() {

  }
}

为了确定新数组应该是什么，我使用了switch语句来计算每个方向对象。在编写if语句之前，我对这种方法还不错。我想避免使用过多的条件，因为这似乎是一个繁重的解决方案。如果dx为正，则从newArr中删除West，但是如果dx为负，则将删除East。如果dx = 0，则将newArr中的East和West删除。类似的条件将应用于N / S对象。 如何在不使用太多条件的情况下生成新数组？

Answer 1

一种非常直接，易于理解的方法是简单地计算每个方向出现的次数，然后从s中减去n，从e中减去w。然后根据这些数字创建一个新的数组。例如：

let arr = ['n', 'n', 's', 'e', 'w', 'n', 's', 'e', 'e', 'e', 'w']

let counts = arr.reduce((a, c) => (a[c]++, a), {n:0, s:0, w:0, e:0})
let ns = counts.n - counts.s // will be negative if overall south, positive if north.
let ew = counts.w - counts.e
// make array
let result = [...Array(Math.abs(ns)).fill(ns > 0 ? 'n' : 's'), ...Array(Math.abs(ew)).fill(ew > 0 ? 'w' : 'e')]
console.log(result)

如果所有方向都保持平衡（即您返回到起点），则会导致数组为空。

Answer 2

如果是关于条件语法的，则可以使用基于Reduce的{{1}}而不是function。

switch/case

Answer 3

docker run -d -p 8000:22 --name docker image
scp -P 8000 username@myserver.com:/root/file.txt ~/file.txt

Answer 4

可以使用对象映射来代替switch语句。扫描的复杂性不仅仅是对象映射

function dirReduc(arr) {
  var dx = 0;
  var dy = 0;
  var newArr = ["NORTH", "SOUTH", "EAST", "WEST"];
  switchObj = {
    NORTH: function() {
      console.log('north')
      dy++;
    },
    SOUTH: function() {
      console.log('SOUTH')
      dy--;
    },
    EAST: function() {
      console.log('EAST')
      dx++;
    },
    WEST: function() {
      console.log('WEST')
      dx--;
    }

  }
  for (var i = 0; i < arr.length; i++) {
    switchObj[arr[i]]();
  }
  //if () {}
}

dirReduc(["NORTH", "SOUTH", "EAST", "WEST"])

Answer 5

您可以使用方向作为属性名称来创建对象，并且值是具有2个元素[x, y]的数组。使用reduce汇总数组。

function dirReduc(arr) {
  var d = {NORTH: [0, 1],SOUTH: [0, -1],EAST: [1, 0],WEST: [-1, 0]}
  return arr.reduce(([x, y], v) => [x + d[v][0], y + d[v][1]], [0, 0]);
}

var result1 = dirReduc(['NORTH', 'SOUTH', 'NORTH', 'SOUTH']);
console.log('Result 1', result1);

var result2 = dirReduc(['NORTH', 'SOUTH', 'EAST', 'EAST','SOUTH']);
console.log('Result 2', result2);

更新：

function dirReduc(arr) {
  var d = {NORTH: [0, 1],SOUTH: [0, -1],EAST: [1, 0],WEST: [-1, 0]}


  return arr.reduce(([x, y], v) => [x + d[v][0], y + d[v][1]], [0, 0])
    .reduce((x, y) => [x > 0 ? 'EAST' : (x < 0 ? 'WEST' : 0), y > 0 ? 'NORTH' : (y < 0 ? 'SOUTH' : 0)]);
}

var result1 = dirReduc(['NORTH', 'SOUTH', 'NORTH', 'SOUTH']);
console.log('Result 1', result1);

var result2 = dirReduc(['NORTH', 'SOUTH', 'EAST', 'EAST', 'SOUTH']);
console.log('Result 2', result2);

Answer 6

const map = {
  NORTH: ([x, y]) => [x, y + 1],
  SOUTH: ([x, y]) => [x, y - 1],
  EAST: ([x, y]) => [x + 1, y],
  WEST: ([x, y]) => [x - 1, y],
};

const walk = coords => coords.reduce((tmp, x) => map[x](tmp), [0, 0])

const removeLoops = steps => {
  let loops = []
  for (var i = 0; i < steps.length; i++) {
    for (var j = i + 1; j < steps.length; j++) {
      if (walk(steps.slice(i, j+1)) == '0,0') {
        loops.push([i, j])
        i = j
        break;
      }
    }
  }
  let newSteps = Array.from(steps)
  loops.reverse().forEach(([from, to]) => {
    newSteps.splice(from, to - from + 1)
  })
  return newSteps
}

console.log(removeLoops([
  'NORTH',
  'NORTH',
  'NORTH',
  'SOUTH',
]));

Answer 7

这在起作用

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)

减少方向指示以提高效率

7 个答案: