Question

我最好用一个例子来解释假设，我有一个清单[6,3,5,1,4,2]。

从索引0开始，找到比该索引处的值更小（尚未标记）的所有项目。

Index 0: [6,3,5,1,4,2]  
Elements less than 6: 5{3,5,1,4,2} 
Visited array: [1 0 0 0 0 0]

Index 1: [6,3,5,1,4,2]  
Elements less than 3: 2 {1,2}
Visited array: [1 1 0 0 0 0]

Index 2: [6,3,5,1,4,2]  
Elements less than 5: 3 {1,4,2}
Visited array: [1 1 1 0 0 0]

Index 3: [6,3,5,1,4,2]  
Elements less than 1: 0 {NULL}
Visited array: [1 1 1 1 0 0]

Index 4: [6,3,5,1,4,2]  
Elements less than 4: 1 {2}
Visited array: [1 1 1 1 1 0]

This yields an array as [5 2 3 0 1 0]

目前正在使用，

def get_diff(lis):
    ans=[]
    for index,elem in enumerate(lis):
        number_of_smaller=len(filter(lambda x:x<elem ,lis[index+1:]))
        ans.append(number_of_smaller)
    return ans

但是，我觉得这样效率不高。我如何使它值得一个巨大的名单？我闻到前缀总和吗？谢谢，

Answer 1

您可以在dict理解中简单地使用列表推导来将项目保留为键，将项目小于值作为值（并使用collections.OrderedDict来保留订单）：

>>> from collections import OrderedDict
>>> def get_diff(lis):
...        return OrderedDict((item,[i for i in lis if i<item]) for item in lis)

由于您的条件为<，因此无需排除该项目本身，因为在比较中删除项目的成本高于包含该项目的成本。

此外，如果您想保留索引，可以使用enumerate循环列表：

def get_diff(lis):
       return OrderedDict((item,index),[i for i in lis if i<item]) for index,item in enumerate(lis))

如果你想计算那些项目的数量，你可以在sum函数中使用生成器表达式：

>>> from collections import OrderedDict
>>> def get_diff(lis):
...        return OrderedDict((item,sum(1 for i in lis if i<item)) for item in lis)

注意：如果您想要计算项目之后的任何项目（索引较大），您只需在循环中使用索引：

>>> def get_diff(lis):
...        return OrderedDict((item,sum(1 for i in lis[index:] if i<item)) for index,item in enumerate(lis))
... 
>>> get_diff(l).values()
[5, 2, 3, 0, 1, 0]

Answer 2

my_list = [6,3,5,1,4,2] 

def get_diff(lis):
    result = []
    for visited, i in enumerate(range(len(lis))):
        limit = lis[i]
        elem = filter(None, [x if x < limit else None for x in lis][visited + 1:])
        result.append(len(elem))
    return result

print get_diff(my_list)
#[5, 2, 3, 0, 1, 0]

使列表中的最小元素小于特定元素的最快方法

2 个答案: