Question

做一个课程它问这个，但做了任何涵盖这样的事情，我很难过。问题如下。我们将非常感谢您的回答。

编写一个Python函数，它接收两个列表并计算它们是否是彼此的排列。列表可以包含整数和字符串。我们定义一个排列如下：

•列表具有相同数量的元素

•列表元素在两个列表中显示的次数相同

如果列表不是彼此的排列，则函数返回False。如果它们是彼此的排列，则该函数返回由以下元素组成的元组：

•元素出现次数最多

•该元素发生的次数

•出现次数最多的元素类型

如果两个列表都为空，则返回元组（None，None，None）。如果多次出现多个元素，则可以返回任何元素。

def is_list_permutation(L1, L2):

    '''

    L1 and L2: lists containing integers and strings
    Returns False if L1 and L2 are not permutations of each other. 
            If they are permutations of each other, returns a 
            tuple of 3 items in this order: 
            the element occurring most, how many times it occurs, and its type
    '''

    # Your code here

例如，

•如果L1 = [＆＃39; a＆＃39;，＆＃39; a＆＃39;，＆＃39; b＆＃39;]和L2 = [＆＃39; a＆＃39;，＆＃ 39; b＆＃39;]然后is_list_permutation返回False

•如果L1 = [1，＆＃39; b＆＃39;，1，＆＃39; c＆＃39;，＆＃39; c＆＃39;，1]和L2 = [＆＃39; c＆＃39;，1，＆＃39; b＆＃39;，1,1，＆＃39; c＆＃39;]然后is_list_permutation返回（1,3，）因为整数1发生最多，3次，1的类型是一个整数（注意元组中的第三个元素不是字符串）。

Answer 1

您可以使用字典（dict）来存储列表中项目的出现。以下是O(n)算法。这是最好的算法

您可以这样做

首先进行基本检查，如果两个列表的长度相同，为空列表检查等
使用哈希映射存储项目以计算第一个列表的映射
使用第一个列表项的哈希值检查第二个列表

<强>代码

def is_permutation(l1,l2):
    if len(l1) != len(l2):
        return False
    if len(l1) == 0:
        return (None,None,None)
    max_item = None
    max_count = 0
    d = dict()
    for i in l1:
        d[i] = d.get(i,0) + 1
        if d[i] > max_count:
            max_count += 1
            max_item = i
    for i in l2:
        d[i] = d.get(i,0) - 1
        if d[i] == -1:
            return False
    return (max_item,max_count,type(max_item))

print ([1,2,2,"34"],["34",2,1]),is_permutation([1,2,2,"34"],["34",2,1])
print ([],["34",2,1]),is_permutation([],["34",2,1])
print ([],[]),is_permutation([],[])
print ([1,2,2,"34",2],["34",2,2,2,1]),is_permutation([1,2,2,"34",2],["34",2,2,2,1])

Answer 2

问题归结为比较multiset，Python多重集实现被称为collections.Counter()：

from collections import Counter

def is_perm(L1, L2):
    c = Counter(L1)
    if c != Counter(L2):
        return False
    if not c:
        return (None, None, None)
    value, count = c.most_common(1)[0]
    return value, count, type(value)

>>> L1 = [1, 'b', 1, 'c', 'c', 1]
>>> L2 = ['c', 1, 'b', 1, 1, 'c']
>>> is_perm(L1, L2)
(1, 3, int)
>>> is_perm([], [])
(None, None, None)
>>> is_perm(L1, [])
False

Answer 3

不确定作业的条款是否允许使用任何模块，但如果是这样，使用collections则变得非常简单：

from collections import Counter
def is_list_permutation(l1,l2):
    c1 = Counter(l1)
    c2 = Counter(l2)
    if c1 != c2:
        return False
    elif len(c1) == 0:
        return (None, None, None)
    else:
        t = c1.most_common(1)[0]
        return t + (type(t[0]),)

Answer 4

这是带有注释的代码，逐行说明：

在is_list_permutation函数中使用isPermutation作为辅助方法。这使代码更易于阅读和清理。

L1 = [1, 'b', 1, 'c', 'c', 1]
L2 = ['c', 1, 'b', 1, 1, 'c']


def isPermutation(list1,list2):
 if len(list1) != len(list2):
   return False;  #two list does not have same length so impossible being permutation of each other
 for i in range(0, len(list1)):
   if list1.count(list1[i]) != list2.count(list1[i]):
     return False

def is_list_permutation(list1,list2):
  if (isPermutation(list1,list2) == False): #use the above method isPermutation to check if they are permutation of each other
    return False #if not return false
  elif not list1:
    return (None, None, None)
  else:
    mostOccurItem = max(set(list1), key=list1.count)  
    numberOfTimes = list1.count(mostOccurItem)
    theType = type(mostOccurItem)
    return (mostOccurItem, numberOfTimes, theType)

print(is_list_permutation(L1,L2))

希望这有帮助

Answer 5

我正在学习字典理解，它对这类问题非常有用：

MyProtobufClass.from_json(logstash_event.to_json)

# And vice-versa:

LogStash::Event.from_json(my_protobuff_object.to_json)

2列出了python中的排列

5 个答案: