Python: मैट्रिक्स को पेलिंड्रोम गिनती के अनुसार सॉर्ट करना

Python में नेस्टेड सूची (स्ट्रिंग्स की मैट्रिक्स) को प्रत्येक पंक्ति में पेलिंड्रोम (palindrome) स्ट्रिंग्स की संख्या के अनुसार सॉर्ट करना।

पेलिंड्रोम परिभाषा

एक स्ट्रिंग पेलिंड्रोम है यदि वह आगे और पीछे से समान पढ़ी जाए: s == s[::-1]

उदाहरण

def get_palindrome_count(row):
    """पंक्ति में पेलिंड्रोम स्ट्रिंग्स की गिनती लौटाएं"""
    return sum(1 for element in row if element == element[::-1])

my_list = [
    ["abcba", "hdgfue", "abc"],      # 1 पेलिंड्रोम (abcba)
    ["peep"],                        # 1 पेलिंड्रोम (peep)
    ["py", "is", "best"],            # 0 पेलिंड्रोम
    ["sees", "level", "non", "noon"] # 4 पेलिंड्रोम (सभी)
]

print("मूल मैट्रिक्स:")
for i, row in enumerate(my_list):
    count = get_palindrome_count(row)
    palindromes = [e for e in row if e == e[::-1]]
    print(f"  पंक्ति {i}: {row} → पेलिंड्रोम: {palindromes} (गिनती: {count})")

# पेलिंड्रोम गिनती के अनुसार सॉर्ट (आरोही)
my_list.sort(key=get_palindrome_count)
print("\nसॉर्ट के बाद (आरोही):")
for row in my_list:
    print(f"  {row} (गिनती: {get_palindrome_count(row)})")

आउटपुट

मूल मैट्रिक्स:
  पंक्ति 0: ['abcba', 'hdgfue', 'abc'] → पेलिंड्रोम: ['abcba'] (गिनती: 1)
  पंक्ति 1: ['peep'] → पेलिंड्रोम: ['peep'] (गिनती: 1)
  पंक्ति 2: ['py', 'is', 'best'] → पेलिंड्रोम: [] (गिनती: 0)
  पंक्ति 3: ['sees', 'level', 'non', 'noon'] → पेलिंड्रोम: ['sees', 'level', 'non', 'noon'] (गिनती: 4)

सॉर्ट के बाद (आरोही):
  ['py', 'is', 'best'] (गिनती: 0)
  ['abcba', 'hdgfue', 'abc'] (गिनती: 1)
  ['peep'] (गिनती: 1)
  ['sees', 'level', 'non', 'noon'] (गिनती: 4)

मूल लेख के कोड में सुधार

मूल लेख में '' .join(list(reversed(element))) == element का उपयोग किया गया है जो element == element[::-1] से कम कुशल है।

अवरोही क्रम (सबसे अधिक पेलिंड्रोम पहले)

# reverse=True जोड़ें
my_list.sort(key=get_palindrome_count, reverse=True)
print("अवरोही क्रम:")
for row in my_list:
    print(f"  {row} (गिनती: {get_palindrome_count(row)})")

आउटपुट

अवरोही क्रम:
  ['sees', 'level', 'non', 'noon'] (गिनती: 4)
  ['abcba', 'hdgfue', 'abc'] (गिनती: 1)
  ['peep'] (गिनती: 1)
  ['py', 'is', 'best'] (गिनती: 0)

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

def sort_matrix_by_palindrome_count(matrix, reverse=False):
    """मैट्रिक्स को पंक्ति प्रति पेलिंड्रोम गिनती के अनुसार सॉर्ट करें"""
    def count_palindromes(row):
        return sum(1 for s in row if isinstance(s, str) and s == s[::-1])
    
    # मूल मैट्रिक्स को न बदलें, नई सॉर्ट की गई सूची लौटाएं
    return sorted(matrix, key=count_palindromes, reverse=reverse)

# उपयोग
matrix = [
    ["abcba", "hdgfue", "abc"],
    ["peep"],
    ["py", "is", "best"],
    ["sees", "level", "non", "noon"]
]

print("आरोही:", sort_matrix_by_palindrome_count(matrix))
print("अवरोही:", sort_matrix_by_palindrome_count(matrix, reverse=True))

उन्नत: केस-इनसेंसिटिव, अल्फान्यूमेरिक पेलिंड्रोम

import re

def is_palindrome_advanced(s):
    """केस-इनसेंसिटिव, केवल अल्फान्यूमेरिक"""
    if not isinstance(s, str):
        return False
    cleaned = re.sub(r'[^a-zA-Z0-9]', '', s).lower()
    return cleaned == cleaned[::-1] and len(cleaned) > 0

def count_palindromes_advanced(row):
    return sum(1 for s in row if is_palindrome_advanced(s))

# टेस्ट
test_row = ["A man, a plan, a canal: Panama", "racecar", "hello", "Madam"]
print(f"उन्नत गिनती: {count_palindromes_advanced(test_row)}")  # 3

Pandas DataFrame में उपयोग

import pandas as pd

df = pd.DataFrame({
    'text': [
        "abcba hdgfue abc",
        "peep",
        "py is best",
        "sees level non noon"
    ]
})

# प्रत्येक सेल में पेलिंड्रोम गिनें (स्पेस से अलग)
def count_palindromes_in_text(text):
    words = str(text).split()
    return sum(1 for w in words if w == w[::-1])

df['palindrome_count'] = df['text'].apply(count_palindromes_in_text)
print(df.sort_values('palindrome_count'))

आउटपुट

                    text  palindrome_count
2           py is best                 0
0  abcba hdgfue abc                 1
1                  peep                 1
3  sees level non noon                 4