दो स्थितियों के अनुपालन के लिए दो संख्यात्मक सरणियों की तुलना करना
1 और 0 से मिलकर एक ही आकार, ए और बी वाले दो संख्यात्मक सरणियों पर विचार करें। एक छोटा सा उदाहरण दिखाया गया है:
A = [[1 0 0 1] B = [[0 0 0 0]
[0 0 1 0] [0 0 0 0]
[0 0 0 0] [1 1 0 0]
[0 0 0 0] [0 0 1 0]
[0 0 1 1]] [0 1 0 1]]
अब मैं दो बुलियन वेरिएबल्स test1 और test2 के मानों को इस प्रकार निर्दिष्ट करना चाहता हूं :
test1 : कम से कम एक उदाहरण है जहां एक A
कॉलम में 1 और SAME B
कॉलम में 1 में पंक्ति 1 या 2 के अंतर हैं? यदि हां, तो परीक्षण 1 = सत्य, अन्यथा गलत।
ऊपर दिए गए उदाहरण में, दोनों सरणियों के कॉलम 0 में 1s है जो 2 पंक्तियों के अलावा है, इसलिए test1 = True। (कॉलम 2 में अन्य उदाहरण भी हैं, लेकिन इससे कोई फर्क नहीं पड़ता - हमें केवल एक उदाहरण की आवश्यकता है।)
test2 : 1 में मान करते हैं A
और B
सभी अलग सरणी पते हैं? यदि हां, तो test2 = True, अन्यथा गलत।
ऊपर दिए गए उदाहरण में, दोनों सरणियों हैं [4,3] = 1
, इसलिए test2 = गलत।
मैं ऐसा करने के लिए एक कुशल तरीका खोजने के लिए संघर्ष कर रहा हूं और कुछ सहायता की सराहना करूंगा।
जवाब
यहां यह जांचने का एक सरल तरीका है कि दो सरणियों में एक ही कॉलम में एक तत्व के अलावा एक प्रविष्टि है (केवल एक दिशा में):
(A[1:, :] * B[:-1, :]).any(axis=None)
तो आप कर सकते हैं
test1 = (A[1:, :] * B[:-1, :] + A[:-1, :] * B[1:, :]).any(axis=None) or (A[2:, :] * B[:-2, :] + A[:-2, :] * B[2:, :]).any(axis=None)
दूसरा परीक्षण स्थानों को सूचकांकों में परिवर्तित करके, उन्हें एक साथ जोड़कर और np.unique
डुप्लिकेट की संख्या की गणना करके किया जा सकता है । डुप्लिकेट केवल दो सरणियों में एक ही सूचकांक से आ सकता है क्योंकि किसी सरणी में डुप्लिकेट इंडेक्स कभी नहीं होगा। हम flatnonzero
इसके बजाय का उपयोग करके गणना को और तेज कर सकते हैं nonzero
:
test2 = np.all(np.unique(np.concatenate((np.flatnonzero(A), np.flatnonzero(B))), return_counts=True)[1] == 1)
एक अधिक कुशल परीक्षण np.intersect1d
एक समान तरीके से उपयोग करेगा :
test2 = not np.intersect1d(np.flatnonzero(A), np.flatnonzero(B)).size
आप masked_arrays का उपयोग कर सकते हैं और दूसरे कार्य के लिए जो आप कर सकते हैं:
A_m = np.ma.masked_equal(A, 0)
B_m = np.ma.masked_equal(B, 0)
test2 = np.any((A_m==B_m).compressed())
और पहला काम करने का एक भोला तरीका है:
test1 = np.any((np.vstack((A_m[:-1],A_m[:-2],A_m[1:],A_m[2:]))==np.vstack((B_m[1:],B_m[2:],B_m[:-1],B_m[:-2]))).compressed())
आउटपुट:
True
True
Test2 के लिए: आप जांच सकते हैं कि उन्हें 1 के मान के लिए कोई समान इंडेक्स मिला है या नहीं।
A = np.array([[1, 0, 0, 1],[0, 0, 1, 0],[0, 0, 0, 0],[0, 0, 0, 0],[0, 0, 1, 1]])
B = np.array([[0, 0, 0, 0],[0, 0, 0, 0],[1, 1, 0, 0],[0, 0, 1, 0],[0, 1, 0, 1]])
print(len(np.intersect1d(np.flatnonzero(A==1),np.flatnonzero(B==1)))>0))