Python: सूची के तत्वों को जोड़कर K-अंक वाले पूर्णांक बनाना

Python में सूची के सभी तत्वों को स्ट्रिंग में जोड़कर, फिर उसे K-अंक वाले पूर्णांकों में विभाजित करना।

एल्गोरिदम

सभी तत्वों को स्ट्रिंग में बदलकर जोड़ें: ''.join(str(x) for x in list)
परिणामी स्ट्रिंग को K आकार के टुकड़ों में काटें
प्रत्येक टुकड़े को पूर्णांक में बदलें

उदाहरण

my_list = [231, 67, 232, 1, 238, 31, 793]
print("मूल सूची:", my_list)

K = 3
print(f"K = {K}")

# चरण 1: सभी तत्वों को जोड़कर एक स्ट्रिंग बनाएं
temp = ''.join(str(ele) for ele in my_list)
print(f"जुड़ी हुई स्ट्रिंग: '{temp}'")  # '23167232123831793'

# चरण 2: K आकार के टुकड़ों में काटें
my_result = []
for i in range(0, len(temp), K):
    chunk = temp[i:i+K]
    my_result.append(int(chunk))

print("परिणाम:", my_result)

आउटपुट

मूल सूची: [231, 67, 232, 1, 238, 31, 793]
K = 3
जुड़ी हुई स्ट्रिंग: '23167232123831793'
परिणाम: [231, 672, 321, 238, 317, 93]

चरण-दर-चरण विभाजन


स्ट्रिंग: 2 3 1 6 7 2 3 2 1 2 3 8 3 1 7 9 3
इंडेक्स:  0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

K=3 टुकड़े:
[0:3]   = "231"  → 231
[3:6]   = "672"  → 672
[6:9]   = "321"  → 321
[9:12]  = "238"  → 238
[12:15] = "317"  → 317
[15:18] = "93"   → 93 (अंतिम टुकड़ा छोटा हो सकता है)

संक्षिप्त संस्करण (List Comprehension)

def reform_k_digits(lst, k):
    """सूची के तत्वों को जोड़कर k-अंक वाले पूर्णांक बनाएं"""
    joined = ''.join(map(str, lst))
    return [int(joined[i:i+k]) for i in range(0, len(joined), k)]

# उपयोग
print(reform_k_digits([231, 67, 232, 1, 238, 31, 793], 3))
print(reform_k_digits([1, 2, 3, 4, 5], 2))       # [12, 34, 5]
print(reform_k_digits([10, 20, 30], 4))          # [1020, 30]
print(reform_k_digits([], 3))                    # []

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

def safe_reform_k_digits(lst, k):
    """सुरक्षित संस्करण"""
    if k <= 0:
        raise ValueError("K धनात्मक होना चाहिए")
    if not lst:
        return []
    
    joined = ''.join(str(x) for x in lst)
    if not joined:
        return []
    
    return [int(joined[i:i+k]) for i in range(0, len(joined), k)]

# टेस्ट
print(safe_reform_k_digits([0, 0, 0], 2))      # [0, 0]
print(safe_reform_k_digits([-1, 2], 2))        # ValueError: invalid literal for int() with base 10: '-12'
# नोट: ऋणात्मक संख्याओं के लिए विशेष हैंडलिंग चाहिए

ऋणात्मक संख्याओं को संभालना

def reform_k_digits_signed(lst, k):
    """ऋणात्मक संख्याओं को संभालने वाला संस्करण"""
    # विकल्प 1: निरपेक्ष मान लें
    joined = ''.join(str(abs(x)) for x in lst)
    chunks = [int(joined[i:i+k]) for i in range(0, len(joined), k)]
    # चिह्न जानकारी खो जाती है, इसलिए यह सीमित है
    
    # विकल्प 2: चिह्न को अलग स्ट्रिंग में एन्कोड करें
    return chunks

# बेहतर: केवल गैर-ऋणात्मक के लिए उपयोग करें

व्यावहारिक अनुप्रयोग

यह तकनीक उपयोगी है:

बड़े पूर्णांकों को छोटे टुकड़ों में तोड़ना (क्रिप्टोग्राफी, एन्कोडिंग)
डेटा संपीड़न / सीरियलाइज़ेशन
फिक्स्ड-विड्थ फॉर्मेट में डेटा तैयार करना
चेकसम / हैश गणना के लिए ब्लॉक बनाना

उल्टा ऑपरेशन: K-अंक पूर्णांकों से मूल सूची पुनर्निर्माण

def reconstruct_from_chunks(chunks, original_lengths):
    """मूल लंबाई जानकर पुनर्निर्माण (सामान्य मामले में असंभव)"""
    joined = ''.join(str(c) for c in chunks)
    result = []
    idx = 0
    for length in original_lengths:
        result.append(int(joined[idx:idx+length]))
        idx += length
    return result

# यदि मूल लंबाई पता हो
original = [231, 67, 232, 1, 238, 31, 793]
lengths = [len(str(x)) for x in original]  # [3, 2, 3, 1, 3, 2, 3]
chunks = reform_k_digits(original, 3)
print("चंक्स:", chunks)
print("पुनर्निर्मित:", reconstruct_from_chunks(chunks, lengths))