Python: दो मैट्रिक्स की पंक्तियों में सामान्य तत्व जांचना

Python में दो मैट्रिक्स (नेस्टेड सूचियाँ) की संगत पंक्तियों (same index) में कम से कम एक सामान्य तत्व है या नहीं जांचना।

समस्या

दो मैट्रिक्स my_list_1 और my_list_2 दी गई हैं। प्रत्येक पंक्ति i के लिए, जांचें कि my_list_1[i] और my_list_2[i] में कम से कम एक सामान्य तत्व है या नहीं। सभी पंक्तियों के लिए यह सत्य होना चाहिए।

उदाहरण

my_list_1 = [[3, 16, 1], [2, 4], [4, 31, 31]]
my_list_2 = [[42, 16, 12], [42, 8, 12], [31, 7, 10]]

print("पहली मैट्रिक्स:", my_list_1)
print("दूसरी मैट्रिक्स:", my_list_2)

# विधि 1: लूप और फ्लैग (मूल लेख)
my_result = True
for idx in range(len(my_list_1)):
    temp = False
    for element in my_list_1[idx]:
        if element in my_list_2[idx]:
            temp = True
            break
    if not temp:
        my_result = False
        break

if my_result:
    print("सभी पंक्तियों में सामान्य तत्व हैं")
else:
    print("कुछ पंक्तियों में सामान्य तत्व नहीं हैं")

आउटपुट

पहली मैट्रिक्स: [[3, 16, 1], [2, 4], [4, 31, 31]]
दूसरी मैट्रिक्स: [[42, 16, 12], [42, 8, 12], [31, 7, 10]]
कुछ पंक्तियों में सामान्य तत्व नहीं हैं

पंक्ति-दर-पंक्ति विश्लेषण

पंक्ति 1 में सामान्य तत्व नहीं है, इसलिए समग्र परिणाम False है।

संक्षिप्त और पायथनिक तरीके

1. set intersection + all()

def all_rows_have_common(matrix1, matrix2):
    """सभी संगत पंक्तियों में कम से कम एक सामान्य तत्व है?"""
    if len(matrix1) != len(matrix2):
        return False
    return all(set(row1) & set(row2) for row1, row2 in zip(matrix1, matrix2))

print(all_rows_have_common(my_list_1, my_list_2))  # False

# टेस्ट केस जहां सभी पंक्तियों में सामान्य तत्व हैं
m1 = [[1, 2], [3, 4], [5, 6]]
m2 = [[2, 9], [4, 8], [6, 0]]
print(all_rows_have_common(m1, m2))  # True

2. किसी भी पंक्ति में सामान्य तत्व न होने पर इंडेक्स लौटाएं

def find_rows_without_common(matrix1, matrix2):
    """सामान्य तत्व न होने वाली पंक्तियों के इंडेक्स लौटाएं"""
    return [
        i for i, (row1, row2) in enumerate(zip(matrix1, matrix2))
        if not (set(row1) & set(row2))
    ]

print("सामान्य तत्व रहित पंक्तियाँ:", find_rows_without_common(my_list_1, my_list_2))  # [1]

3. NumPy के साथ (बड़े मैट्रिक्स के लिए)

import numpy as np

def all_rows_common_numpy(m1, m2):
    # असमान लंबाई की पंक्तियों के लिए ऑब्जेक्ट सरणी
    arr1 = np.array(m1, dtype=object)
    arr2 = np.array(m2, dtype=object)
    
    if len(arr1) != len(arr2):
        return False
    
    for i in range(len(arr1)):
        set1 = set(arr1[i])
        set2 = set(arr2[i])
        if not (set1 & set2):
            return False
    return True

# समान लंबाई की पंक्तियों के लिए वेक्टराइज़्ड (2D सरणी)
m1_arr = np.array([[1, 2], [3, 4], [5, 6]])
m2_arr = np.array([[2, 9], [4, 8], [6, 0]])

# ब्रॉडकास्टिंग के साथ तुलना (केवल समान आकार के लिए)
# यह जटिल है, लूप बेहतर है

किनारे के मामले

def robust_common_check(m1, m2):
    """मजबूत संस्करण"""
    # लंबाई जांच
    if len(m1) != len(m2):
        raise ValueError("मैट्रिक्स में पंक्तियों की संख्या समान होनी चाहिए")
    
    for i, (row1, row2) in enumerate(zip(m1, m2)):
        # खाली पंक्तियाँ
        if not row1 or not row2:
            print(f"चेतावनी: पंक्ति {i} खाली है")
            return False
        
        if not (set(row1) & set(row2)):
            return False, i  # False और पंक्ति इंडेक्स
    return True, -1

# टेस्ट
print(robust_common_check([[1], [2]], [[1], [3]]))      # (False, 1)
print(robust_common_check([[], [2]], [[1], [2]]))       # चेतावनी + False
print(robust_common_check([[1,2]], [[2,3]]))            # (True, -1)

सामान्य तत्वों की गिनती प्रति पंक्ति

def common_count_per_row(m1, m2):
    """प्रति पंक्ति सामान्य तत्वों की संख्या"""
    return [
        len(set(row1) & set(row2)) 
        for row1, row2 in zip(m1, m2)
    ]

print("प्रति पंक्ति सामान्य तत्व:", common_count_per_row(my_list_1, my_list_2))
# [1, 0, 1]

सारांश

• set(row1) & set(row2) - सेट इंटरसेक्शन (सामान्य तत्व)
• bool(set1 & set2) - True यदि कम से कम एक सामान्य तत्व
• all(... for row1, row2 in zip(m1, m2)) - सभी पंक्तियों के लिए जांच
• समय जटिलता: O(N * M) जहां N=पंक्तियाँ, M=औसत पंक्ति लंबाई