Javascript 数组的数组谁'；s对象'；指数逐渐增长

简化版

为了

ar = [
        {"element":"a","index":0},
        {"element":"b","index":1},
        {"element":"e","index":4},
        {"element":"d","index":3}
];

应该返回

 ans = [[
        {"element":"a","index":0},
        {"element":"b","index":1},
        {"element":"e","index":4}],

       [{"element":"a","index":0},
        {"element":"b","index":1},
        {"element":"d","index":3}]
 ];

它可以返回只包含{“element”：“e”，“index”：4}和只包含{“element”：“d”，“index”：3}的数组，因为后面没有任何内容，但这不是必需的

原创 我有这个元素数组

ar = [
        {"element":"c","index":2},
        {"element":"a","index":0},
        {"element":"b","index":1},
        {"element":"e","index":4},
        {"element":"d","index":3}
];

我想返回一个数组，其中包含每个对象的“索引”逐渐增长的序列，并且具有最大数量的对象，这些对象的

obj1[index]

i、 它应该会回来

[
    [{"element":"c","index":2}, {"element":"e","index":4}], 
    [{"element":"c","index":2}, {"element":"d","index":3}],
    [{"element":"a","index":0}, {"element":"b","index":1}, {"element":"d","index":3}], 
    [{"element":"a","index":0}, {"element":"b","index":1}, {"element":"e","index":4}]
    [{"element":"d","index":3}],
    [{"element":"e","index":4}]
]

---

我尝试过使用ar.reduce，但对它不太熟悉，也不知道它是否适用于此实例。

不确定为什么您的示例中没有列出这些

[{ element="a", index=0}, { element="e", index=4}]
[{ element="a", index=0}, { element="d", index=3}]
[{ element="b", index=1}, { element="e", index=4}]
[{ element="b", index=1}, { element="d", index=3}]

但这里有可能产生类似的结果

var ar = [
        {"element":"c","index":2},
        {"element":"a","index":0},
        {"element":"b","index":1},
        {"element":"e","index":4},
        {"element":"d","index":3}
];

var results = [];

traverse([], 0);

function traverse(r, startIdx)
{
    if (startIdx >= ar.length){
        console.log(r);
        return;
    }

    for (var i = startIdx; i < ar.length ; i++){
        if ((startIdx == 0) || (r[r.length - 1].index) <= ar[i].index) {        
            rCopy = r.slice(0);
            rCopy.push(ar[i]);

            traverse(rCopy, i + 1);
        }
        else if (r.length > 0) {
            console.log(r);
        }
    }
}

var-ar=[
{“元素”：“c”，“索引”：2}，
{“元素”：“a”，“索引”：0}，
{“元素”：“b”，“索引”：1}，
{“元素”：“e”，“索引”：4}，
{“元素”：“d”，“索引”：3}
];
var结果=[]；
导线测量（[]，0）；
函数遍历（r，startIdx）
{
如果（startIdx>=ar.length）{
控制台日志（r）；
返回；
}
对于（var i=startIdx；i

,

var-ar=[
{“元素”：“c”，“索引”：2}，
{“元素”：“a”，“索引”：0}，
{“元素”：“b”，“索引”：1}，
{“元素”：“e”，“索引”：4}，
{“元素”：“d”，“索引”：3}
];
var结果=[]；
导线测量（[]，0）；
崩溃（结果）；
//控制台日志（结果）；
对于（var i=results.length-1；i>=0；i--）{
console.log（结果[i]）；
}
函数遍历（r，startIdx）{
如果（startIdx>=ar.length）{
结果：push（r）；
返回；
}
对于（var i=startIdx；i=0；i--）{
对于（var j=results.length-1；j>=0；j--）{
如果（（i！==j）&&（包含（结果[i]，结果[j]））{
结果[i].remove=true；
}
}
}
对于（var i=results.length-1；i>=0；i--）{
如果（结果[i]。删除）{
结果：剪接（i，1）；
}
}
}
//检查set1是否包含在set2中
函数包含（set1、set2）{
对于（变量i=0；i

---

1）“元素”扮演什么角色（如果有的话）？2） 在有5个元素的示例中，总共有31（=2^5-1）个非空子集包含递增序列，您仅显示了其中的4个。为什么仅仅是这4个？我认为索引为3和4的OBJ也应该包括在内。元素不起作用。我不想要所有的子集。只有一个索引在增加（不是子集的所有变化），只有它在增加的最大值。2 < 4, 2 < 3, 0 < 1 < 3, 0 < 1 < 4. 例如，不要只返回ind为0和1的obj，因为后面还有一个索引更高的obj，这很难解释，如果你有问题请告诉我Hey amit，原因是我们想打印出最大连续元素，而不是所有可能的元素。例如，因为[{element=“a”，index=0}，{element=“e”，index=4}]可以包含另一个元素，看起来像[{element:“a”，“index”：0}，{element:“b”，“index”：1}，{“element:“e”，“index”：4}]，所以我们不关心集合的较小版本

var ar = [
        {"element":"c","index":2},
        {"element":"a","index":0},
        {"element":"b","index":1},
        {"element":"e","index":4},
        {"element":"d","index":3}
];

var results = [];

traverse([], 0);
collapse(results);

//console.log(results);

for (var i = results.length - 1; i >= 0; i--) {
    console.log(results[i]);
}

function traverse(r, startIdx) {
    if (startIdx >= ar.length) {
        results.push(r);
        return;
    }

    for (var i = startIdx; i < ar.length ; i++) {
        if ((startIdx == 0) || (r[r.length - 1].index) <= ar[i].index) {
            rCopy = r.slice(0);
            rCopy.push(ar[i]);

            traverse(rCopy, i + 1);
        }
        else if (r.length > 0) {
            results.push(r);
        }
    }
}

function collapse() {
    for (var i = results.length - 1; i >= 0; i--) {
        for (var j = results.length - 1; j >= 0; j--) {
            if ((i !== j) && (contains(results[i], results[j]))) {
                results[i].remove = true;
            }
        }
    }

    for (var i = results.length - 1; i >= 0; i--) {
        if (results[i].remove) {
            results.splice(i, 1);
        }
    }
}

// Checks if set1 is contained within set2
function contains(set1, set2) {
    for (var i = 0; i < set1.length; i++) {
        var found = false;

        for (var j = 0; j < set2.length; j++) {
            if (set1[i].index === set2[j].index) {
                found = true;
                break;
            }
        }

        if (!found) {
            return false;
        }
    }

    return true;
}