Question

我有两个清单：

A = [0,0,0,1,0,1]
B = [0,0,1,1,1,1]

我想在两个列表中找到相同位置的1的数量。

这些数组的答案是2。

Answer 1

有点短，希望更多的pythonic方式：

>>> A=[0,0,0,1,0,1]
>>> B=[0,0,1,1,1,1]

x = sum(1 for a,b in zip(A,B) if (a==b==1))
>>> x
2

Answer 2

Drakosha的变化稍微短一些：

>>> A = [0,0,0,1,0,1]
>>> B = [0,0,1,1,1,1] 
>>> sum(a*b for a, b in zip(A, B) )
2

Answer 3

我不是Python的专家，但是从第一个数组的开始到结束的简单循环有什么问题？

在C＃中，我会做类似的事情：

int match=0;

for (int cnt=0; cnt< A.Count;cnt++)
{
    if ((A[cnt]==B[cnt]==1)) match++;
}

用你的语言可以吗？

Answer 4

由于需要有悖常理，我提供以下解决方案：

A = [0,0,0,1,0,1]
B = [0,0,1,1,1,1]

print len(set(i for i, n in enumerate(A) if n == 1) &
          set(i for i, n in enumerate(B) if n == 1))

（Drakosha的建议是解决这个问题的更合理的方法。这只是表明人们经常可以用不同的方式看待同一个问题。）

Answer 5

使用SciPy：

>>> from scipy import array
>>> A=array([0,0,0,1,0,1])
>>> B=array([0,0,1,1,1,1])

>>> A==B
array([ True,  True, False,  True, False,  True], dtype=bool)
>>> sum(A==B)
4

>>> A!=B
array([False, False,  True, False,  True, False], dtype=bool)
>>> sum(A!=B)
2

Answer 6

这是另一个利用数组只包含0和1的事实的方法。

两个向量x和y的标量乘积是sum（x（i）* y（i）），产生非零结果的唯一情况是x（i）== y（i）== 1因此使用numpy例如

from numpy import *
x = array([0,0,0,1,0,1])
y = array([0,0,1,1,1,1])
print dot(x,y)

简单又好看。这种方法进行n次乘法并增加n-1次，但是使用SSE，GPGPU，矢量化（在这里添加你喜欢的词）的快速实现用于点积（标量积）

我为这个方法计时numpy-method：

sum(1 for a,b in zip(x,y) if (a==b==1))

并发现对于1000000循环，numpy版本在2121ms完成它并且zip方法在9502ms完成它因此numpy版本更快

我对效果进行了更好的分析并发现了这一点对于数组中的n个元素，zip方法花了t1 ms，点积乘以t2 ms进行一次迭代

elements      zip       dot
1          0.0030    0.0207
10         0.0063    0.0230
100        0.0393    0.0476
1000       0.3696    0.2932
10000      7.6144    2.7781
100000   115.8824   30.1305

根据这些数据，可以得出这样的结论：如果预期阵列中的元素数量（平均值）超过350（或者说1000），则应考虑使用点积法。

Answer 7

[A[i]+B[i] for i in range(min([len(A), len(B)]))].count(2)

基本上这只会创建一个新列表，其中包含其他两个元素的所有元素。你知道如果总和为2，则有两个1（假设列表中只有0和1）。因此，只需在2上执行计数操作。

找到两个数组中相同位置的1的数量

7 个答案: