Паровые комбинации массива в Javascript

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

 function pairwise(list) {
  if (list.length < 2) { return []; }
  var first = list[0],
      rest  = list.slice(1),
      pairs = rest.map(function (x) { return [first, x]; });
  return pairs.concat(pairwise(rest));
}

var result = pairwise(['a', 'b', 'c', 'd', 'e']);
console.log(result);
document.getElementById('output').innerHTML = JSON.stringify(result);

 <pre id="output"></pre>

Кроме того, если вы хотите использовать внешнюю библиотеку, это эквивалентное решение, использующее Lo-Dash. Это идентичный алгоритм, но он может помочь с читабельностью использовать библиотеку, предназначенную для функционального программирования.

 function pairwise(list) {
  if (list.length < 2) { return []; }
  var first = _.first(list),
      rest  = _.rest(list),
      pairs = _.map(rest, function (x) { return [first, x]; });
  return _.flatten([pairs, pairwise(rest)], true);
}

var result = pairwise(['a', 'b', 'c', 'd', 'e']);
console.log(result);
document.getElementById('output').innerHTML = JSON.stringify(result);

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

<pre id="output"></pre>

Сочетание сочетаний, подобных этому, является очень распространенным явлением на любом языке. Существует очень «идиоматический» способ выполнить этот тип операции:

for (int i = 0; i < length; i++) {
    for (int j = i + 1; j < length; j++) {
        // do something with pair (i,j)
    }
}

Вы увидите и узнаете этот шаблон где угодно.

Поскольку этот шаблон настолько узнаваем, я предпочитаю его видеть, а не нарезать и нарезать ваш код.

Кроме того, поскольку формула для количества итераций настолько доступна, имеет смысл предварительно настроить выходной массив, который вы используете. Предварительная калибровка выходного массива приведет к существенной разнице в производительности.

Кроме того, хотя здесь используется «классический» цикл, производительность будет прекрасной. Другие системы, требующие срезов или карт подмножеств списка, потребуют дополнительной работы, которая, несмотря на «идиоматику», не обязательно будет быстрее:

 function pairwise(list) {

    var pairs = new Array((list.length * (list.length - 1)) / 2),
        pos = 0;

    for (var i = 0; i < list.length; i++) {
        for (var j = i + 1; j < list.length; j++) {
            pairs[pos++] = [list[i], list[j]];
        }
    }
    return pairs;
}

var result = pairwise(['a', 'b', 'c', 'd', 'e']);
document.getElementById('output').innerHTML = JSON.stringify(result);  

 <pre id="output"></pre>

Спасибо за оба очень интересных и содержательных ответа ниже, я многому научился с вашей помощью.

Я пошел с рекурсивным решением, так как я так сильно подчеркнул удобочитаемость в вопросе. Я нахожу ответ Алексиса Кинга удивительно ясным:

function pairwise(list) {
  if (list.length < 2) { return []; }
  var first = list[0],
      rest  = list.slice(1),
      pairs = rest.map(function (x) { return [first, x]; });
  return pairs.concat(pairwise(rest));
}

(Лично я считаю, что это гораздо более читаемый, чем вариант lodash /underscore.)

Тем не менее, в производстве я, вероятно, использовал бы решение rolfl, учитывая очень убедительное сравнение производительности. Я стараюсь избегать циклов, но не потому, что думаю, что они плохие, а потому, что мне очень трудно держать индексы прямо в голове.

Одна заметка по вопросу о предварительном распределении массива: я не уверен, что увеличивает скорость. В jsperf, добавленном rolfl, метод for-loop был самым быстрым, но я добавил еще один тест без предварительного использования, и он был еще быстрее: http://jsperf.com/pairwise/2

Takehomes для меня:

• для циклов может быть не так хорошо, как функциональные подходы, но они быстры.
• преимущества скорости при превалировании массива не обязательно очевидны.
• рекурсия красивая, но медленная
• читаемость сравнима с опытом (я уверен, что пример for loop гораздо читабельнее для более опытных программистов, чем для меня).