Question

给定一个数组Shape，顺序配对每个项目的最有效方法是什么，如下所示：Shape？

我一直在尝试使用p1 = subprocess.Popen(["head", "-n5" ], stdin=p0.stdout, stdout=subprocess.PIPE) data = p1.communicate()[0] string = data.decode('utf-8')方法，但无济于事，想要一些优雅的东西。

Answer 1

使用简单的for loop

var data = [1, 2, 3, 4, 5];
var res = [];

for (var i = 0; i < data.length-1; i++) {
 res.push(data.slice(i, i+2));
}

console.log(res);

使用 Array#reduce 方法

console.log(
  [1, 2, 3, 4, 5].reduce(function(a, b, i) {
    if (i == 1) return [[a, b]];
    a.push([a[a.length - 1][1], b]);
    return a
  })
)

使用 Array#reduce 方法，初始值为空数组

console.log(
  [1, 2, 3, 4, 5].reduce(function(a, b, i, arr) {
    arr[i + 1] !== undefined && a.push([b, arr[i + 1]])
    return a
  }, [])
)

Answer 2

回答“优雅”位......;）

let pairwise = function *(it) {
    var
        a = it[Symbol.iterator](),
        b = it[Symbol.iterator]();

    b.next();

    for (var x of b) {
        yield [a.next().value, x]
    }
};

console.log(Array.from(pairwise([1,2,3,4,5])))

Answer 3

将lodash用于给定的array：

var result = _.chunk( _.sortBy(array.concat(_.slice(array, 1, array.length - 1))), 2);

检查jsfiddle

因此，如果array = [1,2,3,4,5]我们有步骤：

_.slice(array, 1, array.length - 1)              

      // = [2,3,4]

array.concat(_.slice(array, 1, array.length - 1) 

      // = [1,2,3,4,5].concat([2,3,4]) = [1,2,3,4,5,2,3,4]

_.sortBy(array.concat(_.slice(array, 1, array.length - 1))  

      // _sortBy([1,2,3,4,5,2,3,4]) = [1,2,2,3,3,4,4,5]

_.chunk( _.sortBy(array.concat(_.slice(array, 1, array.length - 1))), 2)

      // _chunk([1,2,2,3,3,4,4,5],2) = [[1,2],[2,3],[3,4],[4,5]]

Answer 4

使用Array.forEach和Array.push函数的另一个简短解决方案：

var arr = [1, 2, 3, 4, 5], pairs = [];
arr.forEach((v, k, arr) => arr[k+1] && pairs.push([v, arr[k+1]]));

console.log(JSON.stringify(pairs));  // [[1,2],[2,3],[3,4],[4,5]]

Answer 5

使用reduce：

    const res = [1, 2, 3, 4, 5].reduce(
      ([b, acc], a) => [a, acc.concat([[b, a]])]
    , [null, []])[1].slice(1)

    console.log(res)

reduce的种子是两个项目的元组：[null, []]。 null表示数组中的当前元素，[]是结果。

在reduce的第一次迭代中：

([b, acc], a) => ... b = null和acc = []

该函数产生一个新元组，元组中的第一项是数组的当前元素，第二项是结果。在第二次迭代中：

([b, acc], a) => ...，b = 1和acc = [[null, 1]]

第二次迭代会将（concat）[1, 2]添加到结果（acc）。

在第三次迭代中：

([b, acc], a) => ...，b = 2和acc = [[null, 1], [1, 2]]

等等：

const trace = (x, y) => {
  console.log(x);
  return y;
}

const json = x => JSON.stringify(x)

const res = [1, 2, 3, 4, 5].reduce(
  ([b, acc], a) => trace(
       `a = ${a}, b = ${b} acc = ${json(acc)} ++ ${json([[b, a]])}`
     , [a, acc.concat([[b, a]])]
  )
  , [null, []]) // seed
  // the result is a tuple `[currentElement, finalResult], we extract finalResult here
  [1]
  // -1 element of the original array was null (check the seed), let's remove it from the result
  .slice(1) 

console.log(res)

我们可以用另一种方式思考问题：我们将相同数组的元素彼此连接成元组。使用Ramda zip函数很优雅但是性能权衡因为我们通过列表两次：

const arr = [1, 2, 3, 4, 5]
const res = R.zip(arr, R.drop(1, arr))
console.log(res)

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.21.0/ramda.min.js"></script>

Answer 6

减少是最优雅的方式。

[1,2,3,4,5].reduce((a,b,c) => {
  a.push([c,b]);
  return a;
}, [])

按顺序配对数组中的项目

6 个答案: