Question

我正在尝试编写一个方法来输出Groovy中的子序列列表和反向列表。

这是我目前的代码：

LinkedHashSet subsequencesAndReversedOfList(List l, Integer max = null) {
    def output = ( max == null ) ? l.subsequences() : l.subsequences().findAll { it.size() == max }
    def reversedOutput = []
    output.each { reversedOutput << it.reverse() }
    output += reversedOutput
    output
}

输入如下：

def l = ['Raisin','Fruit','Apple','Pommes','Nut','Walnut']
Integer max = 2

l = subsequencesAndReversedOfList(l, max)

println l
println l.size()

输出：

Raisin Fruit
Raisin Nut
Raisin Apple
Apple Walnut
Apple Pommes
Raisin Walnut
Fruit Walnut
Fruit Apple
Raisin Pommes
Fruit Nut
Nut Walnut
Pommes Walnut
Pommes Nut
Fruit Pommes
Apple Nut
Fruit Raisin
Nut Raisin
Apple Raisin
Walnut Apple
Pommes Apple
Walnut Raisin
Walnut Fruit
Apple Fruit
Pommes Raisin
Nut Fruit
Walnut Nut
Walnut Pommes
Nut Pommes
Pommes Fruit
Nut Apple

这是我正在寻找的输出。这是最有效的方法吗？

Answer 1

你可以这样做：

$.ajax({
        url: 'models/fetchUsers.php',    //the script to call to get data
        dataType: 'json',                //data format
        success: function(data)          //on recieve of reply
        {
            $.each($(data), function(key, value) {
                $('#itemContainer').append('<li><img src="images/profiles/'+value.user_id+'/'+value.profile_pic+'" alt="image"></li>');
            });
            $("div.holder").jPages({
               containerID: "itemContainer"
            });
        }
    });

在你不得不花费更少的时间打字的意义上哪个更有效...

你的意思是什么？效率更高＆＃34;？

Answer 2

在大型清单中，丢弃大部分元素= O（n³）

的操作成本很高

l.subsequences().findAll { it.size() == max }

您不应该使用subsequences()。您可以构建一个O（n²）实现

Answer 3

对于解决方案的第一部分，您应该替换 O（n³）复杂度表达式：

l.subsequences().findAll { it.size() == max }

以下 O（n²）计算目标是所需的组合大小，并仅计算所需的内容：

def comb
comb = { m, list ->
    def n = list.size()
    m == 0
        ? [[]]
        : (0..(n-m)).inject([]) { newlist, k ->
            newlist += comb(m-1, list[(k+1)..<n]).collect { [list[k]] + it }
        }
}

所以最终的解决方案看起来像这样：

def subsequencesAndReversedOfList = { list, max ->
    (
        max == null
            ? list.subsequences()
            : comb(max, list)
    ).with {
        max == 1
            ? it 
            : it + it*.reverse()
    }
}

这个实现确实有很大的开销，所以它不会真正与基于Groovy List.subsequences()的实现竞争，后续过滤直到两个条件发生（在不同程度上）：

最终结果中的项目数量很少（仅当max非常小或max接近基本列表的大小时才会发生这种情况）。
基本列表的大小很大。

在我的基准测试中，我的目标解决方案始终比原始过滤解决方案慢，直到列表大小达到11。此时，目标解决方案的max，1，2，3和10的{{1}}值更快，“边缘“价值观。但是，当列表大小达到11时，除了20和max之外的所有10值，目标解决方案的速度明显更快。

在Groovy中输出子序列列表和反向的最有效方法？

3 个答案: