Python: मैट्रिक्स से अधिकतम योग वाली शीर्ष K पंक्तियाँ निकालना

Python में नेस्टेड सूची (मैट्रिक्स) से पंक्तियों के योग की गणना करके, अधिकतम योग वाली शीर्ष K पंक्तियाँ निकालना।

उदाहरण

my_list = [[2, 4, 6, 7], [2, 4, 8], [45], [1, 3, 5, 6], [8, 2, 1]]
print("मूल मैट्रिक्स:", my_list)

my_key = 3
print(f"शीर्ष K = {my_key} पंक्तियाँ")

# विधि 1: sorted() + lambda (मूल लेख)
my_result = sorted(my_list, key=lambda row: sum(row), reverse=True)[:my_key]
print("परिणाम (sorted):", my_result)

# विधि 2: heapq.nlargest (बड़े डेटा के लिए अधिक कुशल O(n log k))
import heapq
my_result2 = heapq.nlargest(my_key, my_list, key=sum)
print("परिणाम (heapq):", my_result2)

आउटपुट

मूल मैट्रिक्स: [[2, 4, 6, 7], [2, 4, 8], [45], [1, 3, 5, 6], [8, 2, 1]]
शीर्ष K = 3 पंक्तियाँ
परिणाम (sorted): [[45], [2, 4, 6, 7], [1, 3, 5, 6]]
परिणाम (heapq): [[45], [2, 4, 6, 7], [1, 3, 5, 6]]

पंक्ति योग विश्लेषण

print("पंक्ति योग:")
for i, row in enumerate(my_list):
    print(f"  पंक्ति {i}: {row} → योग = {sum(row)}")

आउटपुट

पंक्ति योग:
  पंक्ति 0: [2, 4, 6, 7] → योग = 19
  पंक्ति 1: [2, 4, 8] → योग = 14
  पंक्ति 2: [45] → योग = 45  ← सबसे अधिक
  पंक्ति 3: [1, 3, 5, 6] → योग = 15
  पंक्ति 4: [8, 2, 1] → योग = 11

फंक्शन के रूप में

def top_k_rows_by_sum(matrix, k, reverse=True):
    """
    योग के अनुसार शीर्ष/निचली k पंक्तियाँ लौटाएं
    
    Args:
        matrix: नेस्टेड सूची
        k: पंक्तियों की संख्या
        reverse: True=अधिकतम योग, False=न्यूनतम योग
    """
    if k <= 0:
        return []
    if k >= len(matrix):
        return sorted(matrix, key=sum, reverse=reverse)
    
    if reverse:
        import heapq
        return heapq.nlargest(k, matrix, key=sum)
    else:
        import heapq
        return heapq.nsmallest(k, matrix, key=sum)

# उपयोग
print("शीर्ष 2:", top_k_rows_by_sum(my_list, 2))
print("निचली 2:", top_k_rows_by_sum(my_list, 2, reverse=False))
print("शीर्ष 10 (सभी):", top_k_rows_by_sum(my_list, 10))

आउटपुट

शीर्ष 2: [[45], [2, 4, 6, 7]]
निचली 2: [[8, 2, 1], [2, 4, 8]]
शीर्ष 10 (सभी): [[45], [2, 4, 6, 7], [1, 3, 5, 6], [2, 4, 8], [8, 2, 1]]

Pandas DataFrame में उपयोग

import pandas as pd

df = pd.DataFrame({
    'A': [2, 2, 45, 1, 8],
    'B': [4, 4, 0, 3, 2],
    'C': [6, 8, 0, 5, 1],
    'D': [7, 0, 0, 6, 0]
})
print("DataFrame:\n", df)

# पंक्ति योग जोड़ें
df['row_sum'] = df.sum(axis=1)
print("\nपंक्ति योग के साथ:\n", df)

# शीर्ष 3 पंक्तियाँ
top3 = df.nlargest(3, 'row_sum')
print("\nशीर्ष 3 पंक्तियाँ:\n", top3)

# केवल मूल कॉलम
print("\nमूल कॉलम:\n", top3.drop('row_sum', axis=1))

आउटपुट

DataFrame:
    A   B  C  D
0   2   4  6  7
1   2   4  8  0
2  45   0  0  0
3   1   3  5  6
4   8   2  1  0

पंक्ति योग के साथ:
    A  B  C  D  row_sum
0   2  4  6  7       19
1   2  4  8  0       14
2  45  0  0  0       45
3   1  3  5  6       15
4   8  2  1  0       11

शीर्ष 3 पंक्तियाँ:
    A  B  C  D  row_sum
2  45  0  0  0       45
0   2  4  6  7       19
3   1  3  5  6       15

प्रदर्शन तुलना

import timeit
import random

# बड़ी मैट्रिक्स
large_matrix = [[random.randint(1, 100) for _ in range(10)] for _ in range(10000)]
k = 10

t_sorted = timeit.timeit(
    lambda: sorted(large_matrix, key=sum, reverse=True)[:k], 
    number=10
)
t_heapq = timeit.timeit(
    lambda: heapq.nlargest(k, large_matrix, key=sum), 
    number=10
)

print(f"sorted (O(n log n)): {t_sorted:.4f}s")
print(f"heapq.nlargest (O(n log k)): {t_heapq:.4f}s")
# heapq बड़े n, छोटे k के लिए तेज़

सारांश