Python 使用XOR运算符确定整数列表中是否存在重复项

我有一个数字列表：

a = [1,2,3,4,5,19,22,25,17,6,73,72,71,77,899,887,44,124, ...]
#this is an abbreviated version of the list

我需要确定列表中是否有重复项，或者不使用XOR（“^”）运算符

有人能给我一些提示吗？我是个新手，以前从未遇到过这个问题或使用过XOR运算符

我尝试过几种方法（相当于在黑暗中盲目刺杀）。最后一个是：

MyDuplicatesList = [1,5,12,156,166,2656,6,4,5,9] #changed the list to make it easer
for x in MyDuplicatesList:
    if x^x:
    print("True")

我意识到我问这样一个开放式的问题可能违反了协议，但我完全被难住了。

为什么要问XOR

# true if there are duplicates
print len(set(a)) != len(a)

好的，这是蟒蛇式的。它会找到所有的副本并列出它们

a = [1,2,3,4,5,19,22,25,17,6,73,72,71,77,899,887,44,124,1]
b = [a[i] for i in range(len(a)) for j in range(i+1,len(a)) if i ^ j > 0 if a[i] ^ a[j] < 1]

print b

到目前为止，我的位索引思想是最快的（因为我想这是一种单通算法，不是多对多算法）

为什么是XOR

# true if there are duplicates
print len(set(a)) != len(a)

好的，这是蟒蛇式的。它会找到所有的副本并列出它们

a = [1,2,3,4,5,19,22,25,17,6,73,72,71,77,899,887,44,124,1]
b = [a[i] for i in range(len(a)) for j in range(i+1,len(a)) if i ^ j > 0 if a[i] ^ a[j] < 1]

print b

---

到目前为止，我的位索引思想是最快的（因为我想这是一种单通算法，不是多对多）

异或将一个数字的二进制重新表示，然后逐位与另一个进行比较，如果两个位不同，则输出1，否则输出0。示例：1^2=3，因为二进制中1是01，2是10，所以逐位比较我们得到11或3。将一个数字与其自身进行XOR运算总是得到0，因此我们可以使用此属性检查两个数字是否相同。与使用XOR相比，有很多更好的方法来检查列表中的重复项，但是如果您想/需要这样做，希望上面的信息能让您知道从哪里开始

异或取一个数字的二进制重新表示，然后逐位与另一个进行比较，如果两位不同，则输出1，否则输出0。示例：1^2=3，因为二进制中1是01，2是10，所以逐位比较我们得到11或3。将一个数字与其自身进行XOR运算总是得到0，因此我们可以使用此属性检查两个数字是否相同。与使用XOR相比，有很多更好的方法来检查列表中的重复项，但是如果您想/需要这样做，希望上面的信息能让您知道从哪里开始

对两个相同的数字进行异或运算，得到0。你应该知道

from operator import xor

def check (lst):
    dup = 0
    for x in lst:
        for y in lst:
            dup += xor(x, y)!=0
    l = len(lst)
    return dup!=(l**2 -l)

c = check([0,1,2,3,4,5,4,3,5])

if c:
    print "There are duplicates!"
else:
    print "There are no duplicates!"

顺便说一句，这是非常愚蠢的做法。XORing很快，但O（n**2）（始终贯穿整个集合）是不必要的损失。 首先，当遇到第一个重复时，应该停止迭代。 另一方面，这确实应该使用set（）或dict（）来完成。 但是你可以得到这个想法

此外，使用xor（）函数而不是按位运算符“^”会使速度减慢一点。我这样做是为了清晰，因为我把其余的代码复杂化了。让人们知道它是作为一种替代品存在的

下面是一个如何做得更好的例子。 这是对Organi在评论中建议的代码的轻微修改

def check (lst):
    l = len(lst)
    # I skip comparing first with first and last with last
    # to prevent 4 unnecessary iterations. It's not much, but it makes sense.
    for x in xrange(1, l):
        for y in xrange(l-1):
            # Skip elements on same position as they will always xor to 0  :D
            if x!=y: # Can be (if you insist): if x^y != 0:...
                if (lst[x] ^ lst[y])==0:
                    return 1 # Duplicate found
    return 0 # No duplicates

c = check([0,1,2,3,4,5,4,3,5])

if c:
    print "There are duplicates!"
else:
    print "There are no duplicates!"

重复一下，XOR不能用于比较，至少在高级编程语言中不能。出于某种原因，您可能需要在汇编中使用类似的东西，但eq在任何地方都可以很好地工作。如果我们只是在这里使用==的话，我们就能够在包含任何内容的列表中检查重复项，而不仅仅是整数

---

XOR在其他方面也很有用，比如普通的位处理（屏蔽、取消屏蔽、更改位…），所以在加密系统和类似的东西中也是如此。

当你对两个相同的数字进行XOR时，得到的是0。你应该知道

from operator import xor

def check (lst):
    dup = 0
    for x in lst:
        for y in lst:
            dup += xor(x, y)!=0
    l = len(lst)
    return dup!=(l**2 -l)

c = check([0,1,2,3,4,5,4,3,5])

if c:
    print "There are duplicates!"
else:
    print "There are no duplicates!"

顺便说一句，这是非常愚蠢的做法。XORing很快，但O（n**2）（始终贯穿整个集合）是不必要的损失。 首先，当遇到第一个重复时，应该停止迭代。 另一方面，这确实应该使用set（）或dict（）来完成。 但是你可以得到这个想法

此外，使用xor（）函数而不是按位运算符“^”会使速度减慢一点。我这样做是为了清晰，因为我把其余的代码复杂化了。让人们知道它是作为一种替代品存在的

下面是一个如何做得更好的例子。 这是对Organi在评论中建议的代码的轻微修改

def check (lst):
    l = len(lst)
    # I skip comparing first with first and last with last
    # to prevent 4 unnecessary iterations. It's not much, but it makes sense.
    for x in xrange(1, l):
        for y in xrange(l-1):
            # Skip elements on same position as they will always xor to 0  :D
            if x!=y: # Can be (if you insist): if x^y != 0:...
                if (lst[x] ^ lst[y])==0:
                    return 1 # Duplicate found
    return 0 # No duplicates

c = check([0,1,2,3,4,5,4,3,5])

if c:
    print "There are duplicates!"
else:
    print "There are no duplicates!"

重复一下，XOR不能用于比较，至少在高级编程语言中不能。出于某种原因，您可能需要在汇编中使用类似的东西，但eq在任何地方都可以很好地工作。如果我们只是在这里使用==的话，我们就能够在包含任何内容的列表中检查重复项，而不仅仅是整数

---

XOR在其他方面的用途也很奇特，比如普通的位扫描（屏蔽、取消屏蔽、更改位…），在加密系统和类似的东西中也是如此。

那么，让我们使用列表项作为位索引：

def dupliXor(source):
    bigs = 0

    for x in source:
        b = 1<<x
        nexts = bigs ^ b

        # if xor removes the bit instead
        # of adding it then it is duplicate
        if nexts < bigs:
            print True
            return

        bigs = nexts

    print False

a = [1,2,3,4,5,19,22,25,17,6,73,72,71,77,899,887,44,124,1]

dupliXor(a) # True

a = [1,2,3,4,5,19,22,25,17,6,73,72,71,77,899,887,44,124]

dupliXor(a) # False

def dupliXor（源代码）：
bigs=0
对于源中的x：
b=1那么，让我们使用列表项作为位索引：

def dupliXor(source):
    bigs = 0

    for x in source:
        b = 1<<x
        nexts = bigs ^ b

        # if xor removes the bit instead
        # of adding it then it is duplicate
        if nexts < bigs:
            print True
            return

        bigs = nexts

    print False

a = [1,2,3,4,5,19,22,25,17,6,73,72,71,77,899,887,44,124,1]

dupliXor(a) # True

a = [1,2,3,4,5,19,22,25,17,6,73,72,71,77,899,887,44,124]

dupliXor(a) # False

def dupliXor（源代码）：
bigs=0
对于源中的x：
b=1到目前为止你试过什么？给你一个开始：如果你有一个数字x，那么x^x是0，x^0是x。这意味着x^x^x是x。我发现的另一个XOR问题涉及使用这些属性来查找单个元素，当其他元素出现偶数次时，该元素出现奇数次。但这意味着在列表上运行XOR不会告诉您是否有重复项，如果有多个重复项。请澄清：[1,2,3]应该报告没有重复项，而[1,2,4,7]应该报告是，而[1,2,1]应该报告是，因为[1,2,1,2]。@synchronizer我刚刚编辑了我的原始问题，以显示我尝试的最新代码。别笑——正如我说的，我是一个完全的初学者。FWIW，如果允许你对列表进行排序，这会容易得多。到目前为止，你做了哪些尝试？给你一个开始：如果你有一个数字x，那么x^x是0，x^0是x。这意味着x^x^x是x。我发现的另一个XOR问题涉及使用这些属性来查找单个元素，当其他元素出现偶数次时，该元素出现奇数次。但这意味着在列表上运行XOR不会告诉您是否有重复项（如果有多个重复项），