Question

这是一个使情况清楚的示例。假设我们有两个包含一些名称的列表。我称它们为原始（O）和修改（M）列表。注意，M缺少名称。我没有访问O的权限，但是我有访问M的权限。我从O中获得的是一个列表，我称为O1，它具有两个条件：（1）在重复的情况下，仅应使用最新名称可以考虑（2）O1的顺序是O的LIFO。

例如，假设原始列表包含O = {n1，n2，n3，n2，n1，n3，n1，n3}，其中n1是第一个在第一，第五和第七个位置写下姓名的人。因此，我得到的是O1 = {n3，n1，n2}，这两个条件都适用。现在，修改后的列表包含M = {n2，n3，n2，n1，n3，n1}（两个名称已被删除（n1，n3）），通过遵循这两个条件，我可以创建M1 = {n1，n3， n2}。通过比较O1和M1

O1 = {n3，n1，n2}

M1 = {n1，n3，n2}

我可以找到n3作为缺少的名称，因为n3的位置在我生成的列表（M1）中已被修改。

我怎样才能将n1当作缺少的名字？

Answer 1

这可以通过使用双端队列作为LIFO来提供

from collections import deque

class lifo(): # LIFO
  """ Use lifo class to implement condition 
      2) the order of elements is a LIFO """
  def __init__(self, iterable=None):
    if iterable is None:
      self.queue = deque()
    else:
      self.queue = deque()
      for item in iterable:
        self.add(item)

  def add(self, item):
    """ Condition (1) in the case of repetition,
        only the most recent name should be 
        considered if item in self.queue: so 
        remove if item alredy in lifo """
    if item in self.queue:
      self.queue.remove(item)
    self.queue.append(item)

  def get(self):  # reverse since deque shows items in reverse order
    return reversed(self.queue)

  def __str__(self):
    return str(list(reversed([k for k in self.queue])))


O1 = ['n1','n2','n3','n2','n1','n3','n1','n3']
M = ['n2','n3','n2','n1','n3','n1']

# Place O1 & M in LIFO
q1 = lifo(O1)
q2 = lifo(M)

# Detect changes in position
changes = [x for x, y in zip(q1.get(), q2.get()) if x != y]
print(changes)
print(q1)
print(q2)

输出

changes: ['n3', 'n1'] => Missing names (change in position)
q1: ['n3', 'n1', 'n2'] => lifo(O1)
q2: ['n1', 'n3', 'n2'] => lifo(M)

Answer 2

除非您获得的信息比问题中所说明的更多，否则我认为这是不可能的。仅在与最后一个重复序列相同的情况下，才与O1进行比较时，将无法识别出O的丢失的起始元素。

例如，令M = {1,2,3}。考虑几个可能的O列表的实例。

（A）O = {1，1，2，3}，其中M缺失1
（B）O = {2，1，2，3}，其中M缺失2
（C）O = {3，1，2，3}，其中M缺少3

以上所有O列表在您的约束下都产生O1 = {3，2，1}。因此，仅给定O1和M，甚至O缺少的元素数量，就无法与上述情况区分开来，以判断缺少哪些开始元素。为A，B，C提供的输入是相同的。

从两个列表中查找丢失的名字

2 个答案: