假设我们在一系列连续整数中缺少两个项目，缺少的元素位于第一个和最后一个元素之间。我写了一个完成任务的代码。但是，如果可能的话，我希望使用更少的循环来提高效率。任何帮助将不胜感激。当我们必须找到更多缺失的项目（比如接近n / 4）而不是2时，情况怎么样呢？我认为我的代码应该是高效的，因为我早先从循环中突然出现了？
def missing_elements(L,start,end,missing_num):
complete_list = range(start,end+1)
count = 0
input_index = 0
for item in complete_list:
if item != L[input_index]:
print item
count += 1
else :
input_index += 1
if count > missing_num:
break
def main():
L = [10,11,13,14,15,16,17,18,20]
start = 10
end = 20
missing_elements(L,start,end,2)
if __name__ == "__main__":
main()
答案 0 :(得分：38)
如果输入序列是排序，则可以在此处使用集合。从输入列表中获取开始和结束值：
def missing_elements(L):
start, end = L[0], L[-1]
return sorted(set(range(start, end + 1)).difference(L))
这假定Python 3;对于Python 2，使用xrange()来避免首先构建列表。
sorted()来电是可选的;如果没有它，则会返回缺少值的set()，并且您将获得一个已排序的列表。
演示：
>>> L = [10,11,13,14,15,16,17,18,20]
>>> missing_elements(L)
[12, 19]
另一种方法是检测后续数字之间的差距;使用较旧的itertools library sliding window recipe：
from itertools import islice, chain
def window(seq, n=2):
"Returns a sliding window (of width n) over data from the iterable"
" s -> (s0,s1,...s[n-1]), (s1,s2,...,sn), ... "
it = iter(seq)
result = tuple(islice(it, n))
if len(result) == n:
yield result
for elem in it:
result = result[1:] + (elem,)
yield result
def missing_elements(L):
missing = chain.from_iterable(range(x + 1, y) for x, y in window(L) if (y - x) > 1)
return list(missing)
这是一个纯粹的O（n）操作，如果你知道丢失的项目的数量，你可以确保它只生成那些然后停止：
def missing_elements(L, count):
missing = chain.from_iterable(range(x + 1, y) for x, y in window(L) if (y - x) > 1)
return list(islice(missing, 0, count))
这也将处理更大的差距;如果你在11和12缺少2个项目，它仍然可以工作：
>>> missing_elements([10, 13, 14, 15], 2)
[11, 12]
并且上面的示例只需要迭代[10, 13]来解决这个问题。
答案 1 :(得分：8)
假设L是一个没有重复的整数列表，你可以推断出start和index之间的列表部分是完全连续的，当且仅当L[index] == L[start] + (index - start)和index和end类似，如果完全连续的话并且只有L[index] == L[end] - (end - index)。这与将列表分成两个递归地结合起来给出了一个次线性解决方案。
# python 3.3 and up, in older versions, replace "yield from" with yield loop
def missing_elements(L, start, end):
if end - start <= 1:
if L[end] - L[start] > 1:
yield from range(L[start] + 1, L[end])
return
index = start + (end - start) // 2
# is the lower half consecutive?
consecutive_low = L[index] == L[start] + (index - start)
if not consecutive_low:
yield from missing_elements(L, start, index)
# is the upper part consecutive?
consecutive_high = L[index] == L[end] - (end - index)
if not consecutive_high:
yield from missing_elements(L, index, end)
def main():
L = [10,11,13,14,15,16,17,18,20]
print(list(missing_elements(L,0,len(L)-1)))
L = range(10, 21)
print(list(missing_elements(L,0,len(L)-1)))
main()
答案 2 :(得分：2)
missingItems = [x for x in complete_list if not x in L]
答案 3 :(得分：1)
from collections import Counter
dic = Counter([10, 11, 13, 14, 15, 16, 17, 18, 20])
print([i for i in range(10, 20) if dic[i] == 0])
输出：
[12, 19]
答案 4 :(得分：1)
使用scipy lib：
import math
from scipy.optimize import fsolve
def mullist(a):
mul = 1
for i in a:
mul = mul*i
return mul
a = [1,2,3,4,5,6,9,10]
s = sum(a)
so = sum(range(1,11))
mulo = mullist(range(1,11))
mul = mullist(a)
over = mulo/mul
delta = so -s
# y = so - s -x
# xy = mulo/mul
def func(x):
return (so -s -x)*x-over
print int(round(fsolve(func, 0))), int(round(delta - fsolve(func, 0)))
时间安排：
$ python -mtimeit -s "$(cat with_scipy.py)"
7 8
100000000 loops, best of 3: 0.0181 usec per loop
其他选项是：
>>> from sets import Set
>>> a = Set(range(1,11))
>>> b = Set([1,2,3,4,5,6,9,10])
>>> a-b
Set([8, 7])
时机是：
Set([8, 7])
100000000 loops, best of 3: 0.0178 usec per loop
答案 5 :(得分：0)
这是一个单行：
In [10]: l = [10,11,13,14,15,16,17,18,20]
In [11]: [i for i, (n1, n2) in enumerate(zip(l[:-1], l[1:])) if n1 + 1 != n2]
Out[11]: [1, 7]
我使用列表，切片将副本偏移一个，并使用枚举来获取缺失项目的索引。
对于长列表，这不是很好，因为它不是O（log（n）），但我认为与使用set小输入相比应该非常有效。来自itertools的izip可能会让它更快。
答案 6 :(得分：0)
我的看法是不使用循环并设置操作：
def find_missing(in_list):
complete_set = set(range(in_list[0], in_list[-1] + 1))
return complete_set - set(in_list)
def main():
sample = [10, 11, 13, 14, 15, 16, 17, 18, 20]
print find_missing(sample)
if __name__ == "__main__":
main()
# => set([19, 12])
答案 7 :(得分：0)
只需查看列表并查找非连续数字：
prev = L[0]
for this in L[1:]:
if this > prev+1:
for item in range(prev+1, this): # this handles gaps of 1 or more
print item
prev = this
答案 8 :(得分：0)
如果两个连续数字之间的差异大于1，我们发现了一个缺失值：
>>> L = [10,11,13,14,15,16,17,18,20]
>>> [x + 1 for x, y in zip(L[:-1], L[1:]) if y - x > 1]
[12, 19]
注意：Python 3.在Python 2中使用itertools.izip。
连续缺失多个值的改进版本：
>>> import itertools as it
>>> L = [10,11,14,15,16,17,18,20] # 12, 13 and 19 missing
>>> [x + diff for x, y in zip(it.islice(L, None, len(L) - 1),
it.islice(L, 1, None))
for diff in range(1, y - x) if diff]
[12, 13, 19]
答案 9 :(得分：0)
>>> l = [10,11,13,14,15,16,17,18,20]
>>> [l[i]+1 for i, j in enumerate(l) if (l+[0])[i+1] - l[i] > 1]
[12, 19]
答案 10 :(得分：0)
def missing_elements(inlist):
if len(inlist) <= 1:
return []
else:
if inlist[1]-inlist[0] > 1:
return [inlist[0]+1] + missing_elements([inlist[0]+1] + inlist[1:])
else:
return missing_elements(inlist[1:])
答案 11 :(得分：0)
首先我们应该对列表进行排序，然后检查每个元素，除了最后一个元素，如果下一个值在列表中。小心不要在列表中有重复项！
l.sort()
[l[i]+1 for i in range(len(l)-1) if l[i]+1 not in l]
答案 12 :(得分：0)
a = [1, 2, 5, 6, 10, 12]
diff = []
for i in range(a[0], len(a) - 1):
val = a[i]
val_next = a[i + 1]
if val + 1 != val_next:
diff.extend(range(val + 1, val_next))
print(diff)
>> [3, 4, 7, 8, 9, 11]
如果列表已排序，我们可以查找任何空白。然后在当前（+1）和下一个值（不包括在内）之间生成一个范围对象，并将其扩展到差异列表。
答案 13 :(得分：0)
a=[1,2,3,7,5,11,20]
b=[]
def miss(a,b):
for x in range (a[0],a[-1]):
if x not in a:
b.append(x)
return b
print (miss(a,b))
ANS：[4, 6, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19]
同样适用于sorted和unsorted的{{1}}
答案 14 :(得分：0)
我偶然发现了一种不同的效率-给出了唯一的序列号列表，可能非常稀疏， yield 是下一个可用的序列号，而没有在内存中创建整个序列集。 （想想库存中经常出入物品，但有些物品寿命很长。）
Exception has occurred: error
font not initialized
File "F:\APPVISUAL\lib\language\languageVS.py", line 55, in button
smallText = pygame.font.Font('freesansbold.ttf', 20)
File "F:\APPVISUAL\lib\language\languageVS.py", line 73, in language
button('Play', 350, 325, 100, 50, green, bright_green, spanish)
File "F:\APPVISUAL\lib\language\languageVS.py", line 85, in <module>
language()
（输入是整数的字符串表示形式的列表，yield是整数，因此不是完全通用的代码。如果超出范围，longtail将提供外推。）
a similar question也有一个答案，建议使用位数组有效地处理大整数序列。
我的某些代码版本使用了itertools中的函数，但最终我放弃了这种方法。
答案 15 :(得分：-1)
使用此代码，您可以找到序列中除最后一个数字以外的所有缺失值。只需将数据输入列名为“数字”的excel文件中即可。
import pandas as pd
import numpy as np
data = pd.read_excel("numbers.xlsx")
data_sort=data.sort_values('numbers',ascending=True)
index=list(range(len(data_sort)))
data_sort['index']=index
data_sort['index']=data_sort['index']+1
missing=[]
for i in range (len(data_sort)-1):
if data_sort['numbers'].iloc[i+1]-data_sort['numbers'].iloc[i]>1:
gap=data_sort['numbers'].iloc[i+1]-data_sort['numbers'].iloc[i]
numerator=1
for j in range (1,gap):
mis_value=data_sort['numbers'].iloc[i+1]-numerator
missing.append(mis_value)
numerator=numerator+1
print(np.sort(missing))