Python: सूची की सूची से समान अंतर वाली पंक्तियाँ निकालना

Python में नेस्टेड सूची से उन पंक्तियों को निकालना जहां लगातार तत्वों का अंतर समान हो (arithmetic progression), इसके लिए लूप और फ्लैग वेरिएबल का उपयोग किया जाता है।

समस्या

दी गई नेस्टेड सूची में से वे उप-सूचियाँ चुनें जहां प्रत्येक लगातार जोड़ी का अंतर समान हो।

उदाहरण

my_list = [[31, 27, 10], [8, 11, 12], [11, 12, 13], [6, 9, 10]]
print("मूल सूची:", my_list)

my_result = []
for row in my_list:
    # कम से कम 2 तत्व होने चाहिए
    if len(row) < 2:
        continue
    
    # पहला अंतर निकालें
    diff = row[1] - row[0]
    is_arithmetic = True
    
    # बाकी जोड़ियों की जांच करें
    for i in range(1, len(row) - 1):
        if row[i + 1] - row[i] != diff:
            is_arithmetic = False
            break
    
    if is_arithmetic:
        my_result.append(row)

print("समान अंतर वाली पंक्तियाँ:", my_result)

आउटपुट

मूल सूची: [[31, 27, 10], [8, 11, 12], [11, 12, 13], [6, 9, 10]]
समान अंतर वाली पंक्तियाँ: [[11, 12, 13]]

व्याख्या

संक्षिप्त संस्करण (all() + जनरेटर)

def is_arithmetic_progression(seq):
    """जांचें कि अनुक्रम अंकगणितीय प्रगति है या नहीं"""
    if len(seq) < 2:
        return False
    diff = seq[1] - seq[0]
    return all(seq[i+1] - seq[i] == diff for i in range(len(seq)-1))

# उपयोग
my_list = [[31, 27, 10], [8, 11, 12], [11, 12, 13], [6, 9, 10]]
result = [row for row in my_list if is_arithmetic_progression(row)]
print(result)  # [[11, 12, 13]]

NumPy के साथ (बड़े डेटा के लिए)

import numpy as np

def find_arithmetic_rows_numpy(nested_list):
    results = []
    for row in nested_list:
        arr = np.array(row)
        if len(arr) >= 2:
            diffs = np.diff(arr)
            if np.all(diffs == diffs[0]):
                results.append(row)
    return results

print(find_arithmetic_rows_numpy(my_list))

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

def extract_arithmetic_rows(matrix):
    """नेस्टेड सूची से अंकगणितीय प्रगति वाली पंक्तियाँ निकालें"""
    return [
        row for row in matrix 
        if len(row) >= 2 and all(row[i+1] - row[i] == row[1] - row[0] for i in range(len(row)-1))
    ]

# टेस्ट केस
test_cases = [
    [[1, 2, 3], [5, 10, 15], [2, 4, 7]],      # [1,2,3] और [5,10,15]
    [[10], [20, 30], [5, 5, 5]],               # [20,30] और [5,5,5]
    [[1, 3, 5, 7], [2, 4, 8]],                 # [1,3,5,7]
    []                                          # खाली
]

for i, case in enumerate(test_cases):
    print(f"टेस्ट {i+1}: {extract_arithmetic_rows(case)}")

आउटपुट

टेस्ट 1: [[1, 2, 3], [5, 10, 15]]
टेस्ट 2: [[20, 30], [5, 5, 5]]
टेस्ट 3: [[1, 3, 5, 7]]
टेस्ट 4: []

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

• खाली सूची: परिणाम खाली सूची
• एकल तत्व वाली पंक्ति: आमतौर पर False (कम से कम 2 तत्व चाहिए)
• दो तत्व वाली पंक्ति: हमेशा True (केवल एक अंतर)
• सभी समान तत्व: True (अंतर 0)
• ऋणात्मक अंतर: ठीक काम करता है (उदा. [10, 7, 4, 1] → अंतर -3)