Question

编写一个函数commonElements（a1，a2），它接受2个元组作为参数，并返回一个包含在两个元组中找到的元素的已排序元组。

我的任务是：

    >>> commonElements((1, 2, 3), (2, 5, 1))
    (1, 2)
    >>> commonElements((1, 2, 3, 'p', 'n'), (2, 5 ,1, 'p'))
    (1, 2, 'p')
    >>> commonElements((1, 3, 'p', 'n'), ('a', 2 , 5, 1, 'p'))
    (1, 'p')

我试着这样做。

def commonElements(a1, a2):
    return tuple(set(a1).intersection( set(a2) ))

任何人都知道我的错误是什么？我无法通过。

Answer 1

def commonElements(a1, a2):
     return tuple(sorted(set(a1).intersection( set(a2) )))

Answer 2

您忘记了分类要求了吗？

修改

显然，set按升序对元素进行排序，但这可能是一个实现细节。如果你被要求把这个函数写成测试，也许你需要实现整个事情而不是委托设置？

编辑2

为了完整性，应该满足要求的实现：

def commonElements(a1, a2): common = [] for x in a1: if x in a2: common.append(x) common.sort() return tuple(common)

Answer 3

未订购套装。所以结果的顺序可能是任意的。我想出类似的东西：

def commonElements(a1, a2):
    L = []
    for el in a1:
        if el in a2:
            L.append(el)
    return tuple(L)

请注意，这种解决问题的方法是将输出元素排序为元组a1。因此，正如评论中所提到的，调用它的更正确的方法是“排序”，而不是“排序”。此外，它的复杂度为O(n*m)，其中n和m分别是列表a1和a2的长度。

如果O(n*log(m))模块用于访问第二元组bisect的元素（应该在进行之前进行排序），则可以在这种情况下实现

a2。

如果需要以通用方式进行排序，我会坚持使用您的代码，稍作修改：

def commonElements(a1, a2):
    return tuple(sorted(set(a1).intersection(set(a2))))

平均而言，由于intersection，其复杂度为O(min(m+n)*log(min(n+m)))（由于排序），而最差情况为O(n*m)。

如果代码需要在不使用set的情况下实现（例如用于研究目的），则代码如下：

def commonElements(a1, a2):
    L = []
    for el in a1:
        if el in a2:
            L.append(el)
    L.sort()
    return tuple(L)

复杂性为O(n*m)。

使用bisect时，代码会这样：

from bisect import bisect_left
def commonElements(a1, a2):
   L = []
   a2.sort() #sort a2 to be able to use binary search in the internal loop thus changing the complexity from O(n^2) to O(n*log(n)) (assuming n and m are rather equal).
   a2_len = len(a2)
   for el in a1:
       i = bisect_left(a2, el)
       if i != a2_len and a2[i] == el:
           L.append(x)
   # L.sort() #uncomment this line if the list in sorted order is needed (not just ordered as the first lits; it's possible to sort a1 in the very beginning of the function, but that would be slower on the average since L is smaller on the average than a1 or a2 (since L is their intersection).
   return tuple(L)

复杂性为O(n*log(m))。

Answer 4

该计划似乎对我有用。蟒-2.7.1 +。

但是，要提及的是，根据定义，这些集合是“无序的”。因此，“交叉点”产生的集合也将是无序的。

要将其转换为元素排序的元组，需要额外的代码。

可能与

有关

def commonElements(a1, a2):
    intersection = list(set(a1).intersection(set(a2)))
    intersection.sort()
    return tuple(intersection)

http://docs.python.org/library/sets.html，

Answer 5

另一个简短的示例解决方案。这就是我写它的方式。最短的解决方案？

def commonElements(a1, a2):
     return tuple(sorted([x for x in a1 if x in a2]))

如何找到两个其他列表中的每个元素？

5 个答案: