C++ प्रोग्रामिंग में एक स्ट्रिंग को उलटने की तकनीकें
हमारे द्वारा विकसित किए जा रहे कोड विनिर्देशों के आधार पर, C++ प्रोग्रामिंग में स्ट्रिंग रिवर्सल को लागू करने के लिए कई तकनीकें मौजूद हैं। ये तकनीकें हैं:
- 'रिवर्स()' विधि का उपयोग करना
- 'strrev()' विधि का उपयोग करना
- 'फॉर' लूप का उपयोग करना
- 'जबकि' लूप का उपयोग करना
- कंस्ट्रक्टर का उपयोग करना
उदाहरण 1:
सबसे पहले, हम तीन अलग-अलग हेडर फ़ाइलें आयात करते हैं जो 'एल्गोरिदम', 'आईओस्ट्रीम' और 'स्ट्रिंग' हैं। हमें इन हेडर फ़ाइलों को शामिल करना होगा ताकि हम उनमें परिभाषित कार्यों का उपयोग कर सकें। 'एल्गोरिदम' हेडर फ़ाइल में खोजने, सॉर्ट करने, गिनने, संशोधित करने आदि के लिए कई अंतर्निहित फ़ंक्शन शामिल हैं जो हमारे लिए उपलब्ध हैं।
फिर, 'iostream' डेटा को इनपुट या आउटपुट करने के लिए फ़ंक्शन प्रदान करता है, और 'स्ट्रिंग' हेडर फ़ाइल को शामिल किया जाता है क्योंकि यह स्ट्रिंग डेटा के साथ काम करते समय आवश्यक फ़ंक्शन प्रदान करता है। इन हेडर फ़ाइलों के नीचे, हम 'std' नेमस्पेस जोड़ते हैं। यहां, हम 'मुख्य()' फ़ंक्शन को लागू करते हैं।
फिर, हम 'स्ट्रिंग' डेटा प्रकार रखते हैं और कुछ स्ट्रिंग डेटा के साथ यहां 'ओरिजिनलStr' को आरंभ करते हैं। फिर, हम उस स्ट्रिंग को प्रिंट करते हैं। इसके बाद, हम 'रिवर्स()' विधि का उपयोग करते हैं जो स्ट्रिंग को उलटने में सहायता करती है। इस 'रिवर्स()' विधि में, हम 'originalStr' वेरिएबल के साथ 'begin()' और 'end()' जोड़ते हैं। अब, हम इस उलटी हुई स्ट्रिंग को भी प्रिंट करते हैं जो हमें 'रिवर्स()' विधि लागू करने के बाद मिलती है।
कोड 1:
#<एल्गोरिदम>शामिल करें
#शामिल
#शामिल<स्ट्रिंग>
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( )
{
स्ट्रिंग मूलStr = 'सी++ प्रोग्रामिंग में स्ट्रिंग रिवर्स' ;
अदालत << 'मूल स्ट्रिंग!' << अंतः ;
अदालत << मूलStr << अंतः << अंतः ;
रिवर्स ( मूलStr. शुरू ( ) , मूलस्ट्र. अंत ( ) ) ;
अदालत << 'उल्टी स्ट्रिंग!' << अंतः ;
अदालत << मूलStr ;
वापस करना 0 ;
}
आउटपुट:
हमारे कोड में 'रिवर्स ()' विधि लागू करने के बाद हमें जो उलटी स्ट्रिंग मिलती है, वह अब मूल स्ट्रिंग के साथ प्रस्तुत की जाती है।
उदाहरण 2:
हम पहले हेडर फ़ाइलें शामिल करते हैं और फिर 'नेमस्पेस एसटीडी' डालते हैं। फिर, 'मेन()' विधि में, हम 'चार' डेटा प्रकार को 'ऑर्ग_स्ट्र' वेरिएबल नाम के साथ रखकर कैरेक्टर ऐरे को आरंभ करते हैं और यहां वह स्ट्रिंग टाइप करते हैं जिसे हम रिवर्स करना चाहते हैं। फिर, हम इस 'Org_str' को 'cout' की सहायता से प्रस्तुत करते हैं।
इसके तहत, हम स्ट्रिंग को उलटने और इस फ़ंक्शन में पैरामीटर के रूप में 'Org_str' को पास करने के लिए 'strrev()' विधि का उपयोग करते हैं। अब, यहाँ स्ट्रिंग उलटी है। इसके बाद, हम 'काउट' की सहायता से उलटी स्ट्रिंग को भी प्रस्तुत करते हैं।
कोड 2:
#शामिल#शामिल
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( )
{
चार संगठन_स्ट्र [ ] = 'स्ट्रिंग रिवर्स प्रोग्राम' ;
अदालत << संगठन_स्ट्र << अंतः << अंतः ;
strrev ( संगठन_स्ट्र ) ;
अदालत << 'उल्टी स्ट्रिंग' << अंतः ;
अदालत << संगठन_स्ट्र ;
वापस करना 0 ;
}
आउटपुट:
यहां, मूल और उलटी हुई स्ट्रिंग्स को प्रस्तुत किया गया है जो हमने अपने कोड में 'strrev()' विधि का उपयोग करके प्राप्त की थीं।
उदाहरण 3:
इस मामले में, हेडर फ़ाइलें 'नेमस्पेस एसटीडी' जोड़ने से पहले शामिल की जाती हैं। फिर, 'मुख्य ()' को लागू किया जाता है और स्ट्रिंग वेरिएबल को 'myOrgStr' नाम के साथ जोड़ा जाता है और स्ट्रिंग डेटा के साथ आरंभ किया जाता है।
इसके बाद, हम 'int' वेरिएबल 'a' भी घोषित करते हैं और 'cout' का उपयोग करके 'myOrgStr' स्ट्रिंग को प्रस्तुत करते हैं। इसके नीचे, हम 'for' लूप का उपयोग करते हैं जहां हम 'a' वेरिएबल को 'myOrgStr.length() - 1' के साथ प्रारंभ करते हैं और फिर एक शर्त रखते हैं जो कि 'a >= 0' है और इसे 'a' के मान में घटाते हैं। ”। यह हमारी स्ट्रिंग को उलट देता है और इसे 'myOrgStr[a]' में संग्रहीत करता है और इसे तब भी प्रदर्शित करता है जब हम 'myOrgStr[a]' को 'cout' के अंदर रखते हैं।
कोड 3:
#शामिल#शामिल<स्ट्रिंग>
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( )
{
स्ट्रिंग myOrgStr = 'हैलो वर्ल्ड!' ;
int यहाँ ए ;
अदालत << myOrgStr << अंतः << अंतः ;
अदालत << 'उल्टी स्ट्रिंग' <= 0 ; ए -- )
{
अदालत << myOrgStr [ ए ] ;
}
वापस करना 0 ;
}
आउटपुट:
यह मूल और उलटी दोनों स्ट्रिंग्स को प्रस्तुत करता है जो हमें 'फॉर' लूप विधि का उपयोग करके हमारे कोड के माध्यम से मिलीं।
उदाहरण 4:
यहां, हम 'बिट्स/stdc++.h' हेडर फ़ाइल आयात करते हैं, इसलिए हमें अन्य हेडर फ़ाइलों को आयात करने की आवश्यकता नहीं है क्योंकि इस हेडर फ़ाइल में सभी फ़ंक्शन की परिभाषाएँ शामिल हैं। फिर, हम 'नेमस्पेस एसटीडी' टाइप करते हैं। यहां, हम “Rev()” नाम से एक फ़ंक्शन बनाते हैं जिसमें हम इस फ़ंक्शन के तर्क के रूप में “string& myString” पास करते हैं। हम स्ट्रिंग को उलटने के लिए यहां यह फ़ंक्शन बनाते हैं।
इस फ़ंक्शन में, हम 'int' डेटा प्रकार के 'S_len' वेरिएबल को रखते हैं और इसके साथ 'myString' रखकर इसे 'लंबाई ()' फ़ंक्शन के साथ आरंभ करते हैं। फिर, हमारे पास एक और वेरिएबल है जो 'int' डेटा प्रकार का 'नहीं' है और इसे 'S_len-1' से प्रारंभ करें।
इसके नीचे, एक और वेरिएबल इनिशियलाइज़ किया गया है जिसे 'int' डेटा प्रकार का 'a' नाम दिया गया है। यहां, हम 'जबकि ()' लूप का उपयोग करते हैं और शर्त के रूप में 'ए <= नहीं' जोड़ते हैं। फिर, हम 'स्वैप()' विधि का उपयोग करते हैं। यह 'स्वैप ()' विधि स्ट्रिंग डेटा को स्वैप करने में सहायता करती है और फिर 'नहीं' को 'नहीं -1' से प्रारंभ करती है। हम 'a' को 'a+1' से भी प्रारंभ करते हैं।
फिर हम यहां 'मुख्य()' को लागू करते हैं जिसमें हम स्ट्रिंग डेटा के साथ 'myString' वेरिएबल को प्रारंभ करते हैं और उस स्ट्रिंग को प्रिंट करते हैं। इसके बाद, हम 'Rev()' फ़ंक्शन को कॉल करते हैं जिसे हमने इस कोड में बनाया है और इस फ़ंक्शन के पैरामीटर के रूप में 'myString' डालते हैं जो स्ट्रिंग को उलट देता है और फिर उलटी स्ट्रिंग को प्रदर्शित करता है।
कोड 4:
#शामिल हैका उपयोग करते हुए नाम स्थान कक्षा ;
खालीपन फिरना ( डोरी & मेरी डोरी )
{
int यहाँ S_len = मेरी डोरी. लंबाई ( ) ;
int यहाँ नहीं = S_len - 1 ;
int यहाँ ए = 0 ;
जबकि ( ए <= नहीं ) {
बदलना ( मेरी डोरी [ ए ] ,माईस्ट्रिंग [ नहीं ] ) ;
नहीं = नहीं - 1 ;
ए = ए + 1 ;
}
}
int यहाँ मुख्य ( )
{
स्ट्रिंग मायस्ट्रिंग = 'मुझे प्रोग्रामिंग पसंद है' ;
अदालत << मेरी डोरी << अंतः ;
अदालत << ' \एन उलटा स्ट्रिंग' << अंतः ;
फिरना ( मेरी डोरी ) ;
अदालत << मेरी डोरी ;
वापस करना 0 ;
}
आउटपुट:
यहां, हम मूल स्ट्रिंग और उलटी स्ट्रिंग दोनों प्रस्तुत करते हैं जो हमें हमारे कोड में बनाए गए फ़ंक्शन के अंदर 'जबकि()' लूप और 'स्वैप()' विधि का उपयोग करके प्राप्त हुई थी।
उदाहरण 5:
हम सभी फ़ंक्शन परिभाषाओं के साथ 'बिट्स/stdc++.h' हेडर फ़ाइल आयात करते हैं। इसलिए, हमें किसी अन्य हेडर फ़ाइल को आयात करने की आवश्यकता नहीं है। इसके बाद, हम 'नेमस्पेस एसटीडी' दर्ज करते हैं और यहां 'मेन()' कॉल करते हैं। फिर, हमारे पास 'स्ट्रिंग' डेटा प्रकार का एक वैरिएबल 'डेटा' है और इसे उस स्ट्रिंग से आरंभ करें जिसे हम उलटना चाहते हैं।
हम 'डेटा' वेरिएबल को 'काउट' में रखकर इस मूल स्ट्रिंग को उलटने से पहले प्रस्तुत करते हैं। इसके नीचे, हम एक और वेरिएबल प्रारंभ करते हैं जो समान 'स्ट्रिंग' डेटा प्रकार का 'revStr' है। फिर, हम 'rbegin()' और 'rend()' का उपयोग करते हैं जो रिवर्स इटरेटर हैं जिन्हें हम यहां स्ट्रिंग को उलटने के लिए जोड़ते हैं। उलटी हुई स्ट्रिंग अब 'revStr' वेरिएबल में सहेजी गई है जिसे यहां उलटी हुई स्ट्रिंग को प्रिंट करने के लिए 'cout' में रखा गया है।
कोड 5:
#शामिल करनाका उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( )
{
स्ट्रिंग डेटा = 'C++ सर्वोत्तम प्रोग्रामिंग भाषा है' ;
अदालत << डेटा << अंतः << अंतः ;
स्ट्रिंग RevStr = डोरी ( डेटा। rbegin ( ) , डेटा। बनाता है ( ) ) ;
अदालत << RevStr << अंतः ;
वापस करना 0 ;
}
आउटपुट:
हमने कोड में जो स्ट्रिंग जोड़ी है, उसे सबसे पहले यहां प्रस्तुत किया गया है। फिर, रिवर्स इटरेटर्स का उपयोग करके हमने जो उलटी स्ट्रिंग प्राप्त की, वह निम्नलिखित में प्रदर्शित होती है:
निष्कर्ष
C++ प्रोग्रामिंग में 'स्ट्रिंग रिवर्स' अवधारणा पर इस लेख में चर्चा की गई है जहां हमने स्ट्रिंग को रिवर्स करने के लिए कई तकनीकों की खोज की है। हमने उन सभी तरीकों का विस्तार से पता लगाया जो C++ में स्ट्रिंग को उलटने में मदद करते हैं और हमारे C++ कोड में स्ट्रिंग को उलट देते हैं। इस लेख में, हमने अपने कोड में मूल और उलटे तार दिखाए हैं।