Python: समान दूरी वाले लगातार वर्णों वाली स्ट्रिंग्स खोजना

Python में उन स्ट्रिंग्स को खोजना जिनके लगातार वर्णों के ASCII/Unicode कोड पॉइंट्स में समान अंतर (equal distance) हो। जैसे "abc" (अंतर 1), "mpsv" (अंतर 3)।

समस्या

स्ट्रिंग में प्रत्येक लगातार वर्ण जोड़ी का अंतर समान होना चाहिए: ord(s[i+1]) - ord(s[i]) == constant सभी i के लिए।

उदाहरण

my_list = ["abc", "egfg", "mpsv", "abed", "xzbd", "agms"]
print("मूल सूची:", my_list)

# विधि 1: all() + ord() + list comprehension (मूल लेख)
my_result = [
    sub for sub in my_list 
    if all(ord(sub[i+1]) - ord(sub[i]) == ord(sub[1]) - ord(sub[0]) for i in range(len(sub)-1))
]
print("परिणाम:", my_result)

# विधि 2: फंक्शन के रूप में (अधिक पठनीय)
def is_equidistant(s):
    """जांचें कि स्ट्रिंग के वर्ण समान दूरी पर हैं"""
    if len(s) < 2:
        return True  # 0 या 1 वर्ण हमेशा समान दूरी
    diff = ord(s[1]) - ord(s[0])
    return all(ord(s[i+1]) - ord(s[i]) == diff for i in range(len(s)-1))

result2 = [s for s in my_list if is_equidistant(s)]
print("परिणाम (फंक्शन):", result2)

आउटपुट

मूल सूची: ['abc', 'egfg', 'mpsv', 'abed', 'xzbd', 'agms']
परिणाम: ['abc', 'mpsv', 'agms']
परिणाम (फंक्शन): ['abc', 'mpsv', 'agms']

व्याख्या

विविधताएं

1. केस-इनसेंसिटिव (बड़े/छोटे अक्षर नजरअंदाज)

def is_equidistant_ci(s):
    s = s.lower()  # या upper()
    if len(s) < 2:
        return True
    diff = ord(s[1]) - ord(s[0])
    return all(ord(s[i+1]) - ord(s[i]) == diff for i in range(len(s)-1))

print([s for s in ["AbC", "aCe", "XyZ"] if is_equidistant_ci(s)])  # ['AbC', 'aCe', 'XyZ']

2. केवल अक्षर (A-Z, a-z) के लिए, रैप-अराउंड के साथ

def is_equidistant_alpha_wrap(s):
    """केवल अक्षर, Z के बाद A आना (मॉड्यूलो 26)"""
    s = s.lower()
    if len(s) < 2:
        return True
    # केवल a-z जांचें
    if not all('a' <= c <= 'z' for c in s):
        return False
    diff = (ord(s[1]) - ord(s[0])) % 26
    return all((ord(s[i+1]) - ord(s[i])) % 26 == diff for i in range(len(s)-1))

print([s for s in ["xyz", "zab", "ace", "az"] if is_equidistant_alpha_wrap(s)])  # ['xyz', 'zab', 'ace']

3. अंतर भी लौटाएं

def get_equidistant_info(strings):
    """स्ट्रिंग और उसका अंतर दोनों लौटाएं"""
    result = []
    for s in strings:
        if len(s) < 2:
            result.append((s, 0, True))
            continue
        diff = ord(s[1]) - ord(s[0])
        is_eq = all(ord(s[i+1]) - ord(s[i]) == diff for i in range(len(s)-1))
        result.append((s, diff, is_eq))
    return result

for s, diff, is_eq in get_equidistant_info(my_list):
    status = "✓" if is_eq else "✗"
    print(f"  {status} {s}: अंतर = {diff}")

आउटपुट

  ✓ abc: अंतर = 1
  ✗ egfg: अंतर = 2
  ✓ mpsv: अंतर = 3
  ✗ abed: अंतर = 1
  ✗ xzbd: अंतर = 2
  ✓ agms: अंतर = 6

NumPy के साथ वेक्टराइज़्ड दृष्टिकोण

import numpy as np

def is_equidistant_numpy(s):
    if len(s) < 2:
        return True
    codes = np.array([ord(c) for c in s])
    diffs = np.diff(codes)
    return np.all(diffs == diffs[0])

# टेस्ट
print([s for s in my_list if is_equidistant_numpy(s)])

आवेदन: सीज़र सिफर पहचान

# समान दूरी वाली स्ट्रिंग्स सीज़र सिफर हो सकती हैं
cipher_candidates = ["bcd", "cde", "xyz", "zab", "nop"]
for s in cipher_candidates:
    if is_equidistant(s):
        diff = ord(s[1]) - ord(s[0])
        print(f"संभावित सीज़र सिफर: {s} (शिफ्ट={diff})")