Python में व्हाइटस्पेस बदले बिना शब्दों के पहले अक्षर को बड़ा करें

जानें कैसे स्ट्रिंग में केवल शब्दों के पहले अक्षर को सुरक्षित रूप से बड़ा करें, व्हाइटस्पेस को बिल्कुल जस का तस रखते हुए। Python आधारित सरल, भरोसेमंद एल्गोरिदम।

नामों के पहले अक्षर को बड़ा करना तुच्छ लगता है, लेकिन जैसे ही कड़े नियम जोड़ते हैं—इनपुट में मौजूद हर स्पेस को ज्यों‑का‑त्यों रखना और ऐसे टोकन, जो किसी गैर‑अक्षर से शुरू होते हैं, उन्हें बिना छेड़े छोड़ देना—काम तुरंत मुश्किल हो जाता है। इससे आम सहायक तरीकों का उपयोग लगभग बाहर हो जाता है और “3g” का “3G” बन जाना या कई स्पेस का एक में सिमट जाना जैसे किनारी मामले सामने आ जाते हैं। नीचे व्हाइटस्पेस को सामान्यीकृत किए बिना ऐसे परीक्षणों में सफल होने वाले भरोसेमंद हल तक पहुँचने का एक व्यावहारिक तरीका दिया गया है।

समस्या की रूपरेखा

इनपुट स्पेस से अलग किए गए टोकन की एक स्ट्रिंग है, जैसे “alex mcqueen”, “timothy karl logan” और “12abcd”। प्रत्येक शब्द का केवल पहला वर्ण तभी बड़ा किया जाए जब वह अक्षर हो। जो टोकन किसी अंक या किसी भी गैर‑अक्षर से शुरू होते हैं, उन्हें अपरिवर्तित रहना चाहिए, इसलिए “12abcd” जैसा है वैसा ही रहेगा। मूल स्पेसिंग जस‑की‑तस बनी रहनी चाहिए।

जहाँ साधारण तरीका चूक जाता है

आम तौर पर लोग स्पेस पर स्ट्रिंग को बाँटते हैं, हर हिस्से को सुधारते हैं और फिर उसे जोड़कर नई स्ट्रिंग बनाते हैं। नीचे दिया गया फ़ंक्शन उसी सोच को दिखाता है और यह भी कि यह तरीका नाज़ुक क्यों है: यह सटीक स्पेसिंग खो देता है और दोबारा बनाते समय अंत में अतिरिक्त स्पेस भी जोड़ सकता है।

def reformat_tokens(src):
    acc = ""
    chunks = src.split(" ")
    for part in chunks:
        if part and part[0].isalpha():
            head = part[0].upper()
            acc += head
            for j in range(1, len(part)):
                acc += str(part[j])
        else:
            for j in range(0, len(part)):
                acc += str(part[j])
    total = len(chunks)
    seen = 0
    out = ""
    for pos in range(len(acc)):
        if pos != 0 and acc[pos].isupper() and seen != total:
            out += " "
            out += acc[pos]
            seen += 1
        else:
            pass
    return out

शाब्दिक स्पेस पर विभाजन करके और फिर अपरकेस सीमाओं के आधार पर स्पेस वापस डालने की कोशिश में यह पैटर्न मूल लेआउट से भटक जाता है। इसी वजह से अंत में अनचाहे अतिरिक्त स्पेस दिखाई देते हैं।

बिल्ट‑इन सीधे हल क्यों नहीं देते

मानक फ़ंक्शन अपनाने की प्रवृत्ति स्वाभाविक है, पर दो व्यवहार आड़े आते हैं। पहला, टाइटल केस लगाने पर किसी भी गैर‑अक्षर के बाद आने वाला अक्षर बड़ा हो जाता है; इसलिए “3g”.title() का परिणाम “3G” होगा, जो “12abcd” को अपरिवर्तित रखने की शर्त का उल्लंघन करता है। दूसरा, ऐसे हेल्पर से शब्द‑वार कैपिटलाइज़ करना जो व्हाइटस्पेस पर टोकनाइज़ करता है, स्पेस को सामान्यीकृत कर सकता है। उदाहरण के लिए, “john smith” को कैपिटलाइज़ करने पर “John Smith” बन सकता है, जहाँ दो लगातार स्पेस एक में सिमट जाते हैं यदि सेपरेटर स्पष्ट रूप से न दिया जाए। वैकल्पिक सेपरेटर आर्ग्युमेंट न बताने पर व्यवहार इच्छानुरूप नहीं होता; एकल स्पेस जैसे सेपरेटर को स्पष्ट करना अलग बात है। इसलिए यहाँ अक्षर‑स्तर पर काम करना अधिक सुरक्षित है।

सब कुछ सुरक्षित रखते हुए एक मज़बूत तरीका

जिस नियम की वास्तव में ज़रूरत है, वह सीधा है: अक्षर को तभी बड़ा करें जब वह स्ट्रिंग का पहला वर्ण हो या किसी स्पेस के तुरंत बाद आए। बाकी सब कुछ जैसा है वैसा ही कॉपी करें। इससे व्हाइटस्पेस बिल्कुल वैसे ही बने रहते हैं और जो टोकन गैर‑अक्षर से शुरू होते हैं, वे बिना बदलाव के रहते हैं।

def capitalize_words(raw):
    if len(raw) == 0:
        return raw
    buf = raw[0].upper() if raw[0].isalpha() else raw[0]
    for ch in raw[1:]:
        if buf[-1].isspace() and ch.isalpha():
            buf += ch.upper()
        else:
            buf += ch
    return buf

यह लॉजिक उसी पल पर केन्द्रित है जो मायने रखता है: स्पेस से अक्षर की ओर संक्रमण। यह दोबारा टोकनाइज़ करने से बचता है, इसलिए आंतरिक स्पेसिंग कभी नहीं बदलती और गैर‑अक्षर से शुरू होने वाले टोकन वैसे ही रहते हैं।

यह क्यों मायने रखता है

प्रतिस्पर्धी प्रोग्रामिंग और स्वचालित परीक्षणों में बहुत छोटे अंतर—जैसे एक अतिरिक्त स्पेस या किसी अंक के बाद अनपेक्षित अपरकेस—असफलता का कारण बन जाते हैं। व्हाइटस्पेस को रीफ़्लो करने या व्यापक टाइटल‑केस नियम लागू करने वाले हेल्पर पर निर्भरता डेटा को चुपचाप बदल सकती है। अक्षर‑दर‑अक्षर पास निर्धारक, पारदर्शी होता है और समस्या विवरण से हू‑ब‑हू मेल खाता है।

मुख्य सीख

जब विनिर्देशन मूल लेआउट को बचाए रखने की माँग करे, तो स्पेस पर बाँटकर फिर जोड़ने से बचें। ध्यान रखें कि टाइटल‑शैली के हेल्पर अंक के बाद आने वाले अक्षरों को भी बड़ा कर सकते हैं और कैपिटलाइज़ करने वाले यूटिलिटी, यदि अलग से न बताएं, तो कई स्पेस को समेट सकती हैं। इस तरह के कार्यों के लिए स्ट्रिंग पर न्यूनतम पास—सिर्फ़ स्पेस के बाद आने वाले अक्षरों को बड़ा करना—सरल भी है और भरोसेमंद भी।