टेक्स्ट इन्वर्टर टूल क्या है?

एक टेक्स्ट इन्वर्टर (जिसे रिवर्स टेक्स्ट टूल भी कहा जाता है) टेक्स्ट में वर्णों के क्रम को उलट देता है—"Hello World" को "dlroW olleH" में बदल देता है। आप पाएंगे कि यह पैलिंड्रोम की जाँच करने से लेकर डिजाइन कार्य के लिए दर्पण पाठ बनाने तक में आश्चर्यजनक रूप से उपयोगी है।

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

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

टेक्स्ट इन्वर्टर का उपयोग कैसे करें

टेक्स्ट उलटने वाले इस टूल का उपयोग तीन सरल चरणों में किया जा सकता है:

1. अपना टेक्स्ट दर्ज करें इनपुट फ़ील्ड में—सीधे टाइप करें या क्लिपबोर्ड से पेस्ट करें
2. जादू देखें जैसे ही उलटा टेक्स्ट तुरंत नीचे दिखाई देता है (किसी बटन को क्लिक करने की आवश्यकता नहीं)
3. परिणाम कॉपी करें कॉपी बटन का उपयोग करके एक क्लिक में

टूल सब कुछ रीयल-टाइम में प्रोसेस करता है, जिसका मतलब है कि आप प्रयोग कर सकते हैं और टाइप करते ही परिणाम देख सकते हैं। किसी भी वर्ण सेट के साथ काम करता है—अंग्रेजी, इमोजी, विशेष प्रतीक, यहां तक कि जापानी या अरबी जैसी भाषाओं के यूनिकोड वर्ण।

टेक्स्ट उलटाव सूत्र और एल्गोरिदम

यहाँ गणितीय रूप से टेक्स्ट उलटाव कैसे काम करता है। $n$ लंबाई की एक स्ट्रिंग $S$ के लिए जिसमें अक्षर $S = c_1c_2c_3...c_n$ हैं, उलटी हुई स्ट्रिंग $S'$ इस प्रकार है:

$S' = c_nc_{n-1}c_{n-2}...c_1$

व्यावहारिक रूप में, प्रोग्रामर इसे तीन मुख्य दृष्टिकोणों का उपयोग करके लागू करते हैं:

1. एरे उलटाव: स्ट्रिंग को अक्षरों में विभाजित करें, एरे को उलट दें, फिर उन्हें वापस जोड़ें। सबसे सीधा और पढ़ने योग्य।
2. दो-पॉइंटर तकनीक: दोनों छोरों से शुरू करें, अक्षरों को बीच की ओर स्वैप करें। जब आप स्थान में संशोधित कर सकते हैं तो मेमोरी-कुशल।
3. स्टैक-आधारित दृष्टिकोण: अक्षरों को एक स्टैक (LIFO संरचना) पर धकेलें, फिर उन्हें पॉप करें। यह स्वाभाविक रूप से क्रम को उलट देता है—और यह डेटा संरचनाओं के लिए एक शानदार शिक्षण उदाहरण है।

प्रदर्शन विशेषताएं: टेक्स्ट उलटाव $O(n)$ समय जटिलता (रैखिक) में चलता है क्योंकि प्रत्येक अक्षर को बिल्कुल एक बार संसाधित किया जाता है। स्थान जटिलता भी $O(n)$ है क्योंकि आपको उलटी हुई स्ट्रिंग को संग्रहित करने की आवश्यकता होती है। अधिकांश व्यावहारिक उपयोगों में कुछ मेगाबाइट से कम टेक्स्ट के लिए, प्रदर्शन तत्काल होता है।

एक बात जो ध्यान देने योग्य है—यदि आप विशाल टेक्स्ट फ़ाइलों (जैसे लॉग या डेटासेट) को उलट रहे हैं, तो आप एक साथ सब कुछ मेमोरी में लोड करने से बचने के लिए स्ट्रीमिंग दृष्टिकोणों पर विचार करना चाह सकते हैं।

चरण-दर-चरण पाठ उलटने की प्रक्रिया

मैं आपको बिल्कुल बताता हूँ कि उलटने का एल्गोरिदम आपके पाठ को कैसे प्रोसेस करता है:

1. एक खाली परिणाम कंटेनर के साथ शुरुआत करें
2. अपने इनपुट के अंतिम अक्षर से पढ़ें, पीछे की ओर जाते हुए
3. प्रत्येक अक्षर को जाते हुए परिणाम में जोड़ें
4. जब आप पहले अक्षर तक पहुँच जाएँ तो रुक जाएँ
5. पूरा उलटा हुआ स्ट्रिंग वापस करें

व्यावहारिक उदाहरण "Hello, World!" के साथ:

1इनपुट: "Hello, World!"
2चरण 1: खाली परिणाम के साथ शुरुआत: ""
3चरण 2: अंतिम अक्षर "!" लें → परिणाम = "!"
4चरण 3: "d" लें → परिणाम = "!d"
5चरण 4: "l" लें → परिणाम = "!dl"
6चरण 5: प्रत्येक अक्षर के लिए जारी रखें...
7अंतिम आउटपुट: "!dlroW ,olleH"
8

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

आपको पता होने वाले किनारे के मामले

टेक्स्ट उलटने के साथ काम करते समय, आप कुछ दिलचस्प किनारे के मामलों का सामना करेंगे:

खाली स्ट्रिंग्स: एक खाली स्ट्रिंग को उलटने पर आपको... एक खाली स्ट्रिंग मिलती है। समझ में आता है, है ना? उलटने के लिए कुछ नहीं।

एक अक्षर: "A" को उलटें और आपको "A" मिलता है। यह अपने आप में उलटा है, जैसे सभी एकल अक्षर।

यूनिकोड और इमोजी: यहाँ चीजें दिलचस्प होती हैं। एल्गोरिदम यूनिकोड को सही ढंग से संभालता है, जिसमें इमोजी, जापानी अक्षर, अरबी लिपि और अन्य गैर-लैटिन पाठ शामिल हैं। "こんにちは 🌍" के साथ परीक्षण करें और आप देखेंगे कि यह सही काम करता है।

व्हाइटस्पेस और विशेष अक्षर: स्पेस, टैब, नई पंक्तियाँ, विराम चिह्न—सब कुछ बिल्कुल वैसे ही उलट जाता है। "Hello World" (3 स्पेस के साथ) "dlroW olleH" (अभी भी 3 स्पेस) बन जाता है।

बहुत लंबा पाठ: अत्यधिक बड़े इनपुट के लिए (मेगाबाइट्स पाठ सोचें), आप उपलब्ध मेमोरी द्वारा सीमित हैं। अधिकांश आधुनिक सिस्टम इसे कई एमबी तक ठीक से संभालते हैं, लेकिन यदि आप गीगाबाइट आकार की फाइलों को संसाधित कर रहे हैं, तो आपको सब कुछ मेमोरी में लोड करने के बजाय स्ट्रीमिंग समाधान चाहिए होगा।

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

टेक्स्ट उलटाव के वास्तविक दुनिया के उपयोग के मामले

आप आश्चर्यचकित हो सकते हैं कि टेक्स्ट उलटाव कितनी बार व्यवहार में आता है। यहां कुछ परिदृश्य हैं जहां मैंने इसका उपयोग देखा है:

प्रोग्रामिंग और विकास

पैलिंड्रोम जांच: जब आपको यह जांचने की आवश्यकता होती है कि क्या एक शब्द आगे और पीछे एक समान पढ़ा जाता है, तो आप इसे उलट कर तुलना करते हैं। जैसे "रेसकार" → "रेसकार" (मेल खाता है = पैलिंड्रोम)।

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

स्टैक कार्यान्वयन डेमो: टेक्स्ट उलटाव LIFO (लास्ट-इन-फर्स्ट-आउट) व्यवहार को सिखाने के लिए एक बिल्कुल सटीक उदाहरण है क्योंकि एक स्टैक स्वाभाविक रूप से क्रम उलटता है।

क्रिप्टोग्राफी और सुरक्षा

बुनियादी एन्कोडिंग: स्वयं में सुरक्षित नहीं, लेकिन टेक्स्ट उलटाव कभी-कभी बहु-चरण एन्कोडिंग योजनाओं में एक परत के रूप में उपयोग किया जाता है। यह वास्तविक एन्क्रिप्शन से अधिक अस्पष्टीकरण के बारे में है।

चुनौती-प्रतिक्रिया प्रणालियां: कुछ प्रमाणीकरण प्रणालियां अपनी सत्यापन प्रक्रिया के हिस्से के रूप में उलटे स्ट्रिंग का उपयोग करती हैं।

रचनात्मक और शैक्षिक अनुप्रयोग

शब्द खेल और पहेलियां: चुनौतियां बनाएं जहां खिलाड़ी उलटे शब्दों की पहचान करते हैं या संदेशों को डिकोड करते हैं। एस्केप रूम और पहेली ऐप्स में लोकप्रिय।

दर्पण लेखन प्रभाव: डिजाइनर लोगो, कलात्मक प्रभाव या प्रतिबिंब को शामिल करने वाली दृश्य डिजाइन के लिए उलटे टेक्स्ट का उपयोग करते हैं।

शिक्षण उपकरण: शुरुआती लोगों को स्ट्रिंग हेरफेर समझाते समय, टेक्स्ट उलटाव पर्याप्त सरल है ताकि समझा जा सके लेकिन पर्याप्त जटिल है ताकि पुनरावृत्ति और सरणी संचालन जैसी महत्वपूर्ण अवधारणाओं को प्रदर्शित किया जा सके।

टेक्स्ट विश्लेषण

भाषाई अनुसंधान: भाषा पैटर्न का अध्ययन करने वाले शोधकर्ता कभी-कभी संरचनात्मक विशेषताओं की पहचान करने के लिए टेक्स्ट को आगे और पीछे दोनों तरह से विश्लेषित करते हैं।

पैटर्न पहचान: टेक्स्ट में समरूपता की जांच करना या बड़े डेटासेट में एम्बेडेड उलटी गई अनुक्रमों को खोजना।

टेक्स्ट उलटाव के विभिन्न प्रकार

अक्षर-दर-अक्षर उलटाव आपका एकमात्र विकल्प नहीं है। आप जो करने की कोशिश कर रहे हैं, उस पर निर्भर करते हुए, ये वैकल्पिक विकल्प बेहतर काम कर सकते हैं:

शब्द उलटाव: प्रत्येक शब्द को अक्षुण्ण रखें लेकिन उनके क्रम को उलट दें। भाषा सीखने और कुछ टेक्स्ट प्रसंस्करण कार्यों के लिए उपयोगी।

• उदाहरण: "हैलो वर्ल्ड" → "वर्ल्ड हैलो"

वाक्य उलटाव: वाक्यों के क्रम को उलट दें जबकि प्रत्येक वाक्य के भीतर शब्द क्रम को संरक्षित रखें।

• उदाहरण: "हैलो वर्ल्ड। आप कैसे हैं?" → "आप कैसे हैं? हैलो वर्ल्ड।"

चयनात्मक उलटाव: अपने मानदंड के आधार पर केवल विशिष्ट भागों को उलट दें—शायद केवल स्वर, या केवल 5 अक्षरों से लंबे शब्द। शब्द पहेलियां या पैटर्न विश्लेषण बनाने के लिए बढ़िया।

• उदाहरण: "हैलो वर्ल्ड" में केवल स्वरों को उलटना → "होलो वेर्ल्ड"

ध्वनिक उलटाव: भाषाई अनुसंधान में उपयोग किया जाता है, यह अक्षरों के बजाय ध्वनियों को उलटता है। पहले ध्वनिक लिपि की आवश्यकता होती है।

बिट-स्तर उलटाव: अक्षरों के बाइनरी प्रतिनिधित्व को उलटता है। आप इसे कुछ क्रिप्टोग्राफिक संचालन और निम्न-स्तरीय डेटा हेरफेर में देखेंगे।

पाठ उलटने का इतिहास

पाठ उलटना आप सोच सकते हैं उससे कहीं अधिक पुराना है—प्राचीन लेखन प्रणालियों से लेकर आधुनिक कंप्यूटिंग तक।

प्राचीन लेखन और दर्पण पाठ

प्राचीन सभ्यताओं ने कंप्यूटर के अस्तित्व से पहले ही दिशात्मक लेखन के साथ प्रयोग किया। यूनानी और मिस्र के लोग कभी-कभी "बौस्ट्रोफेडोन" शैली का उपयोग करते थे, जहां पंक्तियां बदल-बदल कर दिशा बदलती थीं—बाएं से दाएं, फिर दाएं से बाएं, जैसे एक बैल खेत में हल चलाता है (जिसका अर्थ "बौस्ट्रोफेडोन" है)।

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

कंप्यूटिंग युग

जब 1950-60 के दशक में कंप्यूटर सामने आए, तो स्ट्रिंग हेरफेर एक मौलिक प्रोग्रामिंग अभ्यास बन गया। पाठ उलटना उन क्लासिक समस्याओं में से एक था जिसे हर प्रोग्रामर ने सीखा, सॉर्टिंग और सर्चिंग के साथ।

जो इसे विशेष रूप से दिलचस्प बनाता था: स्टैक डेटा संरचनाओं का विकास स्वाभाविक रूप से पाठ उलटने से जुड़ा था। एक स्टैक का LIFO (अंतिम-अंदर-पहला-बाहर) व्यवहार स्वचालित रूप से क्रम उलट देता है—"HELLO" अक्षर-दर-अक्षर स्टैक पर रखें, उन्हें बाहर निकालें, और आपको "OLLEH" मिलेगा। यह सुंदर संबंध पाठ उलटने को डेटा संरचनाएं सिखाने के लिए एक उदाहरण बना देता है।

आधुनिक अनुप्रयोग

आज, आप पाठ उलटने वाले एल्गोरिदम को पीछे के दृश्य में काम करते हुए पाएंगे:

• कंपाइलर और पार्सर: सिंटैक्स विश्लेषण और अभिव्यक्ति मूल्यांकन में उपयोग किया जाता है
• स्ट्रिंग मिलान एल्गोरिदम: बॉयर-मूर एल्गोरिदम जैसे जो पैटर्न को दाएं से बाएं संसाधित करता है
• क्रिप्टोग्राफी: अधिक जटिल एन्क्रिप्शन योजनाओं में निर्माण खंड के रूप में
• प्राकृतिक भाषा प्रसंस्करण: भाषाई पैटर्न का विश्लेषण, पैलिंड्रोम का पता लगाना, और पाठ संरचना का अध्ययन करना

एल्गोरिदम की सरलता (यह पहला है जो आप सीखते हैं) और इसकी व्यावहारिक उपयोगिता यह सुनिश्चित करती है कि यह पहली बार लागू होने के दशकों बाद भी प्रासंगिक रहता है।

कोड उदाहरण: विभिन्न भाषाओं में पाठ उलटना

लोकप्रिय प्रोग्रामिंग भाषाओं में पाठ उलटने का तरीका यहां दिया गया है। प्रत्येक उदाहरण मूल एल्गोरिदम और व्यावहारिक उपयोग दिखाता है:

1' पाठ उलटने के लिए एक्सेल VBA फ़ंक्शन
2Function InvertText(inputText As String) As String
3    Dim i As Integer
4    Dim result As String
5    
6    result = ""
7    For i = Len(inputText) To 1 Step -1
8        result = result & Mid(inputText, i, 1)
9    Next i
10    
11    InvertText = result
12End Function
13' सेल में उपयोग:
14' =InvertText("नमस्ते, दुनिया!")
15

1def invert_text(input_text):
2    """एक स्ट्रिंग में वर्णों के क्रम को उलटें।"""
3    return input_text[::-1]
4

उदाहरण उपयोग:

मूल_पाठ = "नमस्ते, दुनिया!" उल्टा_पाठ = पाठ_उलटें(मूल_पाठ) प्रिंट(f"मूल: {मूल_पाठ}") प्रिंट(f"उल्टा: {उल्टा_पाठ}")

यूनिकोड वर्णों को संभालना

यूनिकोड_पाठ = "こんにちは世界! 🌍" उल्टा_यूनिकोड = पाठ_उलटें(यूनिकोड_पाठ) प्रिंट(f"मूल यूनिकोड: {यूनिकोड_पाठ}") प्रिंट(f"उल्टा यूनिकोड: {उल्टा_यूनिकोड}")

1
2

javascript function पाठ_उलटें(इनपुट_पाठ) { return इनपुट_पाठ.split('').reverse().join(''); }

// उदाहरण उपयोग: const मूल_पाठ = "नमस्ते, दुनिया!"; const उल्टा_पाठ = पाठ_उलटें(मूल_पाठ); console.log(मूल: ${मूल_पाठ}); console.log(उल्टा: ${उल्टा_पाठ});

// खाली स्ट्रिंग को संभालना console.log(खाली स्ट्रिंग उल्टा: "${पाठ_उलटें("")}");

// यूनिकोड को संभालना const यूनिकोड_पाठ = "こんにちは世界! 🌍"; console.log(मूल यूनिकोड: ${यूनिकोड_पाठ}); console.log(उल्टा यूनिकोड: ${पाठ_उलटें(यूनिकोड_पाठ)});

1
2

java public class पाठ_उलटने_वाला { public static String पाठ_उलटें(String इनपुट_पाठ) { return new StringBuilder(इनपुट_पाठ).reverse().toString(); }

public static void main(String[] args) {
    String मूल_पाठ = "नमस्ते, दुनिया!";
    String उल्टा_पाठ = पाठ_उलटें(मूल_पाठ);
    
    System.out.println("मूल: " + मूल_पाठ);
    System.out.println("उल्टा: " + उल्टा_पाठ);
    
    // यूनिकोड वर्णों को संभालना
    String यूनिकोड_पाठ = "こんにちは世界! 🌍";
    String उल्टा_यूनिकोड = पाठ_उलटें(यूनिकोड_पाठ);
    System.out.println("मूल यूनिकोड: " + यूनिकोड_पाठ);
    System.out.println("उल्टा यूनिकोड: " + उल्टा_यूनिकोड);
}

}

1
2

r पाठ_उलटें <- function(इनपुट_पाठ) {

वर्ण सदिश में बदलें, उलटें और जोड़ें

paste(rev(strsplit(इनपुट_पाठ, "")[[1]]), collapse = "") }

उदाहरण उपयोग

मूल_पाठ <- "नमस्ते, दुनिया!" उल्टा_पाठ <- पाठ_उलटें(मूल_पाठ) cat("मूल:", मूल_पाठ, "\n") cat("उल्टा:", उल्टा_पाठ, "\n")

1
2

matlab function उल्टा_पाठ = पाठ_उलटें(इनपुट_पाठ) % पाठ में वर्णों के क्रम को उलटने के लिए फ़ंक्शन उल्टा_पाठ = इनपुट_पाठ(end:-1:1); end

% उदाहरण उपयोग मूल_पाठ = 'नमस्ते, दुनिया!'; उल्टा_पाठ = पाठ_उलटें(मूल_पाठ); fprintf('मूल: %s\n', मूल_पाठ); fprintf('उल्टा: %s\n', उल्टा_पाठ);

1
2

cpp #include #include #include

std::string पाठ_उलटें(const std::string& इनपुट_पाठ) { std::string परिणाम = इनपुट_पाठ; std::reverse(परिणाम.begin(), परिणाम.end()); return परिणाम; }

int main() { std::string मूल_पाठ = "नमस्ते, दुनिया!"; std::string उल्टा_पाठ = पाठ_उलटें(मूल_पाठ);

std::cout << "मूल: " << मूल_पाठ << std::endl;
std::cout << "उल्टा: " << उल्टा_पाठ << std::endl;

// खाली स्ट्रिंग को संभालना
std::cout << "खाली स्ट्रिंग उल्टा: \"" << पाठ_उलटें("") << "\"" << std::endl;

return 0;

}

1
2

ruby def पाठ_उलटें(इनपुट_पाठ) इनपुट_पाठ.reverse end

उदाहरण उपयोग

मूल_पाठ = "नमस्ते, दुनिया!" उल्टा_पाठ = पाठ_उलटें(मूल_पाठ) puts "मूल: #{मूल_पाठ}" puts "उल्टा: #{उल्टा_पाठ}"

यूनिकोड वर्णों को संभालना

यूनिकोड_पाठ = "こんにちは世界! 🌍" उल्टा_यूनिकोड = पाठ_उलटें(यूनिकोड_पाठ) puts "मूल यूनिकोड: #{यूनिकोड_पाठ}" puts "उल्टा यूनिकोड: #{उल्टा_यूनिकोड}"

1
2

php

1
2

rust fn पाठ_उलटें(इनपुट_पाठ: &str) -> String { इनपुट_पाठ.chars().rev().collect() }

fn main() { let मूल_पाठ = "नमस्ते, दुनिया!"; let उल्टा_पाठ = पाठ_उलटें(मूल_पाठ);

println!("मूल: {}", मूल_पाठ);
println!("उल्टा: {}", उल्टा_पाठ);

// यूनिकोड वर्णों को संभालना
let यूनिकोड_पाठ = "こんにちは世界! 🌍";
let उल्टा_यूनिकोड = पाठ_उलटें(यूनिकोड_पाठ);
println!("मूल यूनिकोड: {}", यूनिकोड_पाठ);
println!("उल्टा यूनिकोड: {}", उल्टा_यूनिकोड);

}

1
2

csharp using System;

class पाठ_उलटने_वाला { public static string पाठ_उलटें(string इनपुट_पाठ) { char[] वर्ण_सरणी = इनपुट_पाठ.ToCharArray(); Array.Reverse(वर्ण_सरणी); return new string(वर्ण_सरणी); }

static void Main()
{
    string मूल_पाठ = "नमस्ते, दुनिया!";
    string उल्टा_पाठ = पाठ_उलटें(मूल_पाठ);
    
    Console.WriteLine($"मूल: {मूल_पाठ}");
    Console.WriteLine($"उल्टा: {उल्टा_पाठ}");
    
    // खाली स्ट्रिंग को संभालना
    Console.WriteLine($"खाली स्ट्रिंग उल्टा: \"{पाठ_उलटें("")}\"");
    
    // यूनिकोड वर्णों को संभालना
    string यूनिकोड_पाठ = "こんにちは世界! 🌍";
    string उल्टा_यूनिकोड = पाठ_उलटें(यूनिकोड_पाठ);
    Console.WriteLine($"मूल यूनिकोड: {यूनिकोड_पाठ}");
    Console.WriteLine($"उल्टा यूनिकोड: {उल्टा_यूनिकोड}");
}

}

1
2

go package main

import ( "fmt" )

func पाठ_उलटें(इनपुट_पाठ string) string { रूने := []rune(इनपुट_पाठ) for i, j := 0, len(रूने)-1; i < j; i, j = i+1, j-1 { रूने[i], रूने[j] = रूने[j], रूने[i] } return string(रूने) }

func main() { मूल_पाठ := "नमस्ते, दुनिया!" उल्टा_पाठ := पाठ_उलटें(मूल_पाठ)

fmt.Printf("मूल: %s\n", मूल_पाठ)
fmt.Printf("उल्टा: %s\n", उल्टा_पाठ)

// यूनिकोड वर्णों को संभालना
यूनिकोड_पाठ := "こんにちは世界! 🌍"
उल्टा_यूनिकोड := पाठ_उलटें(यूनिकोड_पाठ)
fmt.Printf("मूल यूनिकोड: %s\n", यूनिकोड_पाठ)
fmt.Printf("उल्टा यूनिकोड: %s\n", उल्टा_यूनिकोड)

}

1
2

swift func पाठ_उलटें(_ इनपुट_पाठ: String) -> String { return String(इनपुट_पाठ.reversed()) }

// उदाहरण उपयोग let मूल_पाठ = "नमस्ते, दुनिया!" let उल्टा_पाठ = पाठ_उलटें(मूल_पाठ)

print("मूल: (मूल_पाठ)") print("उल्टा: (उल्टा_पाठ)")

// यूनिकोड वर्णों को संभालना let यूनिकोड_पाठ = "こんにちは世界! 🌍" let उल्टा_यूनिकोड = पाठ_उलटें(यूनिकोड_पाठ) print("मूल यूनिकोड: (यूनिकोड_पाठ)") print("उल्टा यूनिकोड: (उल्टा_यूनिकोड)")

## प्रदर्शन अनुकूलन टिप्स

यदि आप उत्पादन कोड में टेक्स्ट उलटने के साथ काम कर रहे हैं, तो यहां कुछ प्रदर्शन कारक हैं जिन पर विचार करने योग्य हैं:

**मेमोरी उपयोग**: एक उलटी हुई प्रति बनाने के लिए आपके इनपुट के आकार के बराबर मेमोरी की आवश्यकता होती है। छोटे से मध्यम आकार के स्ट्रिंग्स (1 एमबी से कम) के लिए, यह नगण्य है। बड़े टेक्स्ट के लिए, आप अस्थायी रूप से मेमोरी उपयोग को दोगुना कर रहे हैं।

**स्थान पर उलटना**: C, C++, और Rust जैसी भाषाएँ आपको एक नई प्रति बनाए बिना सीधे मेमोरी में वर्ण सरणियों को उलटने की अनुमति देती हैं। यह मेमोरी उपयोग को आधा कर देता है, लेकिन केवल परिवर्तनीय स्ट्रिंग्स के साथ काम करता है। कई भाषाएँ (Python, JavaScript, Java) अपरिवर्तनीय स्ट्रिंग्स का उपयोग करती हैं, इसलिए आपको एक नई बनानी पड़ती है।

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

**बड़ी फाइलों के लिए स्ट्रीमिंग**: यदि आप गीगाबाइट आकार के लॉग फाइलों या डेटासेट को उलट रहे हैं, तो सब कुछ मेमोरी में न लोड करें। एक स्ट्रीमिंग दृष्टिकोण का उपयोग करें—अंत से चंक पढ़ें, जैसे-जैसे लिखें। [यूनिकोड तकनीकी मानक #18](https://unicode.org/reports/tr18/) के अनुसार, ग्राफीम क्लस्टर हैंडलिंग के लिए सही टेक्स्ट सीमा पहचान की विशेष ध्यान देने की आवश्यकता होती है।

**समानांतरता**: अत्यधिक लंबी स्ट्रिंग्स के लिए, आप सैद्धांतिक रूप से उलटने को समानांतर कर सकते हैं (चंक में विभाजित करें, प्रत्येक को उलटें, जोड़ें)। व्यवहार में, ओवरहेड आमतौर पर इसके लायक नहीं होता जब तक कि आप विशाल डेटासेट से निपट रहे हों और कंप्यूट संसाधन उपलब्ध न हों।

## अक्सर पूछे जाने वाले प्रश्न

### मैं ऑनलाइन टेक्स्ट को कैसे उलटता हूँ?

बस ऊपर के इनपुट फ़ील्ड में अपना टेक्स्ट पेस्ट या टाइप करें। टूल इसे स्वचालित रूप से रीयल-टाइम में उलट देता है—किसी बटन को क्लिक करने की आवश्यकता नहीं। एक क्लिक में परिणाम कॉपी करें।

### टेक्स्ट उलटने और शब्द उलटने में क्या अंतर है?

टेक्स्ट उलटना (वर्ण उलटना) व्यक्तिगत वर्णों को उलटता है: "Hello World" → "dlroW olleH"। शब्द उलटना प्रत्येक शब्द को अक्षुण्ण रखता है लेकिन उनके क्रम को उलट देता है: "Hello World" → "World Hello"। यह टूल वर्ण उलटने का काम करता है।

### क्या यह टूल इमोजी और यूनिकोड वर्णों को संभाल सकता है?

हाँ। टूल सभी यूनिकोड वर्णों को सही ढंग से संभालता है जिसमें इमोजी, चीनी/जापानी/कोरियाई टेक्स्ट, अरबी लिपि, विशेष प्रतीक और संयोजन वर्ण शामिल हैं। "こんにちは 🌍" के साथ स्वयं देखें।

### क्या उलटा टेक्स्ट दर्पण लेखन के समान है?

वे संबंधित हैं लेकिन समान नहीं। वर्ण उलटना (जो यह टूल करता है) बस वर्ण क्रम को उलट देता है। दर्पण लेखन वर्णों को क्षैतिज रूप से उलट देता है ताकि वे दर्पण प्रतिबिंब के रूप में दिखें। दर्पण लेखन को पढ़ने के लिए, आपको वास्तविक दर्पण या क्षैतिज उलटन की आवश्यकता होती है।

### मुझे टेक्स्ट उलटने की आवश्यकता क्यों होगी?

सामान्य उपयोग में शामिल हैं: पैलिंड्रोम की जाँच, पहेलियों के लिए सरल एन्कोडिंग, प्रोग्रामिंग के लिए परीक्षण डेटा, कलात्मक टेक्स्ट प्रभाव, स्ट्रिंग एल्गोरिदम सिखाना, और टेक्स्ट प्रोसेसिंग कोड डीबग करना।

### क्या टेक्स्ट को दो बार उलटने से मूल टेक्स्ट वापस मिल जाता है?

हाँ। टेक्स्ट उलटना अपना स्वयं का विपरीत संचालन है। यदि आप "Hello" को "olleH" में उलटते हैं, फिर "olleH" को उलटते हैं, तो आपको फिर से "Hello" मिलता है। गणितीय रूप से, इसे एक अविलोम कहा जाता है।

### टेक्स्ट उलटना कितना तेज़ है?

यह बहुत तेज़ है—रैखिक समय जटिलता O(n) जहाँ n टेक्स्ट की लंबाई है। सामान्य टेक्स्ट (कुछ अनुच्छेद) के लिए, प्रोसेसिंग तत्काल होती है। बहुत लंबे टेक्स्ट (हजारों शब्द) के लिए भी, आधुनिक कंप्यूटर इसे मिलीसेकंड में संभालते हैं।

### क्या मैं एक्सेल या गूगल शीट्स में टेक्स्ट उलट सकता हूँ?

हाँ, लेकिन आपको एक कस्टम फ़ंक्शन की आवश्यकता होगी क्योंकि कोई अंतर्निहित उलटने का फ़ंक्शन नहीं है। एक्सेल VBA और अन्य प्रोग्रामिंग कार्यान्वयन के लिए ऊपर के कोड उदाहरण अनुभाग की जाँच करें।

## तकनीकी संदर्भ

1. नुथ, डी. ई. (1997). *कंप्यूटर प्रोग्रामिंग की कला, खंड 1: मौलिक एल्गोरिदम* (3रा संस्करण). एडिसन-वेस्ली पेशेवर.

2. सेजविक, आर., & वेन, के. (2011). *एल्गोरिदम* (4था संस्करण). एडिसन-वेस्ली पेशेवर.

3. यूनिकोड कंसोर्टियम. *यूनिकोड तकनीकी मानक #18: यूनिकोड नियमित अभिव्यक्तियां*. उपलब्ध: https://unicode.org/reports/tr18/

4. MDN वेब डॉक्स. *स्ट्रिंग विधियों का संदर्भ*. मोज़िला डेवलपर नेटवर्क. उपलब्ध: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String

5. कॉरमेन, टी. एच., लीसरसन, सी. ई., रिवेस्ट, आर. एल., & स्टीन, सी. (2009). *एल्गोरिदम का परिचय* (3रा संस्करण). एमआईटी प्रेस.