दो स्थितियों के अनुपालन के लिए दो संख्यात्मक सरणियों की तुलना करना

Aug 18 2020

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 = गलत।

मैं ऐसा करने के लिए एक कुशल तरीका खोजने के लिए संघर्ष कर रहा हूं और कुछ सहायता की सराहना करूंगा।

जवाब

1 MadPhysicist Aug 18 2020 at 09:53

यहां यह जांचने का एक सरल तरीका है कि दो सरणियों में एक ही कॉलम में एक तत्व के अलावा एक प्रविष्टि है (केवल एक दिशा में):

(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
1 Ehsan Aug 18 2020 at 08:14

आप 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
ArundeepChohan Aug 18 2020 at 09:56

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))