Сортировка массива: все возможные последовательности

Question

У меня есть массив:

[
    [3, 1],
    [3, 3],
    [2, 2],
    [0, 0],
    [1, 3]
]

Когда я сортирую этот массив по (i [0] + i [1]), я получаю это:

[
    [3, 3],
    [3, 1],
    [2, 2],
    [1, 3],
    [0, 0]
]

Я хочувзять первые 2 элемента из этого массива, но, как вы можете видеть, на самом деле нет различий между ч / б [3, 1], [2, 2] и [1, 3].Единственная причина, по которой [3, 1] был отсортирован как 2-й, заключается в том, что он имеет меньший индекс в исходном массиве.Поэтому я хочу все возможные сортировки (6 массивов в этом случае), каждый из которых имеет свой элемент на 2-м месте.

Как я могу сделать это возможным?

Редактировать:

Функция сортировки:

(a,b) => (b[0]+b[1]) - (a[0]+a[1]));

Ожидаемый результат:

[
    [
        [3, 3],
        [3, 1],
        [2, 2],
        [1, 3],
        [0, 0]
    ],
    [
        [3, 3],
        [3, 1],
        [1, 3],
        [2, 2],
        [0, 0]
    ],
    [
        [3, 3],
        [2, 2],
        [1, 3],
        [3, 1],
        [0, 0]
    ],
    [
        [3, 3],
        [2, 2],
        [3, 1],
        [1, 3],
        [0, 0]
    ],
    [
        [3, 3],
        [1, 3],
        [2, 2],
        [3, 1],
        [0, 0]
    ],
    [
        [3, 3],
        [1, 3],
        [3, 1],
        [2, 2],
        [0, 0]
    ],
]

Answer 1

Вы можете

• сначала создать группы с одинаковыми весами сортировки,
• построить перестановки из тех же групп и
• , а затем получить декартово произведение из массивов.

function permutation(array) {
    function p(array, temp) {
        var i, x;
        if (!array.length) {
            result.push(temp);
        }
        for (i = 0; i < array.length; i++) {
            x = array.splice(i, 1)[0];
            p(array, temp.concat([x]));
            array.splice(i, 0, x);
        }
    }

    var result = [];
    p(array, []);
    return result;
}

function cartesian(array) {
    function c(part, index) {
        array[index].forEach(function (a) {
            var p = part.concat([a]);
            if (p.length === array.length) {
                return r.push(p);
            }
            c(p, index + 1);
        });
    }

    var r = [];
    c([], 0);
    return r;
}

var array = [[3, 1], [3, 3], [2, 2], [0, 0], [1, 3]],
    groups = Object
        .values(array.reduce(
            (r, a) => ((r[a[0] + a[1]] = r[a[0] + a[1]] || []).push(a), r),
            Object.create(null)
        ))
        .reverse()
        .map(permutation),
    result = cartesian(groups).map(c => c.reduce((a, b) => a.concat(b), []));
    
console.log(result.map(a => a.map(b => b.join())));
console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }