दिलचस्प पोस्ट
जावा एपीआई कम या बाइट के बजाय int क्यों उपयोग करता है? क्या मैं स्प्रिंग-डेटा-रेस्ट / स्प्रिंग-हैटेओज क्लाइंट के स्वरूपण को कस्टम नियंत्रक बना सकता हूँ? जीमेल के माध्यम से ईमेल भेजें PostgreSQL त्रुटि: घातक: भूमिका "उपयोगकर्ता नाम" मौजूद नहीं है चेतावनी: session_start () विफल: ऐसा कोई फ़ाइल या निर्देशिका नहीं है User.config का कस्टम पथ एक्सएमएल नामस्थान और अनप्रिफ़िक्स गुण मैं दो अलग-अलग डोमेन में कुकीज़ का उपयोग कैसे करूं? सेल के भीतर JComboBox में एक आइटम आइडेंट है, तो मैं सेलआरव कैसे प्राप्त करूं? तत्वों को स्विच करने के लिए कोई नेटी jQuery फ़ंक्शन है? कार्य में ईवेंट को परिवर्तित करने के लिए पुन: प्रयोज्य पैटर्न # डेफेंस को इंगित करना यूआरएल द्वारा रूटडेटा कैसे प्राप्त करें? त्रुटि LNK2019: फ़ंक्शन ___tmainCRTStartup में संदर्भित अनसुलझे बाहरी चिह्न _मैन एंड्रॉइड – ऑनऑप्ट्सआईटम्स के बाहर मेनू आइटम टेक्स्ट को डायनामिक रूप से कैसे बदल सकता है? चुने गए या ऑनक्रेट ऑप्शन मेन्यू

सी या सी ++ में आप स्ट्रिंग को कैसे बदलते हैं?

उलट स्ट्रिंग को रखने के लिए अलग बफर की आवश्यकता के बिना आप सी या सी ++ में एक स्ट्रिंग को कैसे उलटाते हैं?

वेब के समाधान से एकत्रित समाधान "सी या सी ++ में आप स्ट्रिंग को कैसे बदलते हैं?"

ईविल सी:

#include <stdio.h> void strrev(char *p) { char *q = p; while(q && *q) ++q; for(--q; p < q; ++p, --q) *p = *p ^ *q, *q = *p ^ *q, *p = *p ^ *q; } int main(int argc, char **argv) { do { printf("%s ", argv[argc-1]); strrev(argv[argc-1]); printf("%s\n", argv[argc-1]); } while(--argc); return 0; } 

(यह XOR- स्वैप बात है। ध्यान रखना ध्यान रखें कि आपको स्वयं के साथ गमागमन से बचना चाहिए , क्योंकि ^ ^ = 0।)


ठीक है, ठीक है, हम UTF-8 वर्ण को ठीक करते हैं …

 #include <bits/types.h> #include <stdio.h> #define SWP(x,y) (x^=y, y^=x, x^=y) void strrev(char *p) { char *q = p; while(q && *q) ++q; /* find eos */ for(--q; p < q; ++p, --q) SWP(*p, *q); } void strrev_utf8(char *p) { char *q = p; strrev(p); /* call base case */ /* Ok, now fix bass-ackwards UTF chars. */ while(q && *q) ++q; /* find eos */ while(p < --q) switch( (*q & 0xF0) >> 4 ) { case 0xF: /* U+010000-U+10FFFF: four bytes. */ SWP(*(q-0), *(q-3)); SWP(*(q-1), *(q-2)); q -= 3; break; case 0xE: /* U+000800-U+00FFFF: three bytes. */ SWP(*(q-0), *(q-2)); q -= 2; break; case 0xC: /* fall-through */ case 0xD: /* U+000080-U+0007FF: two bytes. */ SWP(*(q-0), *(q-1)); q--; break; } } int main(int argc, char **argv) { do { printf("%s ", argv[argc-1]); strrev_utf8(argv[argc-1]); printf("%s\n", argv[argc-1]); } while(--argc); return 0; } 
  • क्यों, हां, अगर इनपुट बोर्काड है, तो यह जगह के बाहर जयजयकार से स्वैप करेगा।
  • यूएनआईसीओडीए में भंग होने पर उपयोगी लिंक: http://www.macchiato.com/unicode/chart/
  • साथ ही, 0x10000 से अधिक यूटीएफ -8 अप्रयुक्त है (जैसा कि मेरे पास इसके लिए कोई फ़ॉन्ट नहीं है, न ही हेक्साडेटर का उपयोग करने के लिए धैर्य नहीं है)

उदाहरण:

 $ ./strrev Räksmörgås ░▒▓○◔◑◕● ░▒▓○◔◑◕● ●◕◑◔○▓▒░ Räksmörgås sågrömskäR ./strrev verrts/. 
 #include <algorithm> std::reverse(str.begin(), str.end()); 

सी ++ में यह सबसे आसान तरीका है

केर्नघन और रिची पढ़ें

 #include <string.h> void reverse(char s[]) { int length = strlen(s) ; int c, i, j; for (i = 0, j = length - 1; i < j; i++, j--) { c = s[i]; s[i] = s[j]; s[j] = c; } } 

जगह में एक स्ट्रिंग उल्टा (विज़ुअलाइज़ेशन):

जगह में एक स्ट्रिंग उल्टा

गैर-बुरा सी, सामान्य मामला संभालने जहां स्ट्रिंग एक निरर्थक char सरणी है:

 #include <stddef.h> #include <string.h> /* PRE: str must be either NULL or a pointer to a * (possibly empty) null-terminated string. */ void strrev(char *str) { char temp, *end_ptr; /* If str is NULL or empty, do nothing */ if( str == NULL || !(*str) ) return; end_ptr = str + strlen(str) - 1; /* Swap the chars */ while( end_ptr > str ) { temp = *str; *str = *end_ptr; *end_ptr = temp; str++; end_ptr--; } } 

आप सी ++ स्टैंडर्ड लाइब्रेरी से std::reverse एल्गोरिदम का उपयोग करते हैं।

यह कुछ समय हो गया है और मुझे याद नहीं है कि किस पुस्तक ने मुझे यह एल्गोरिथम सिखाया है, लेकिन मैंने सोचा कि यह काफी सरल और सरल है:

 char input[] = "moc.wolfrevokcats"; int length = strlen(input); int last_pos = length-1; for(int i = 0; i < length/2; i++) { char tmp = input[i]; input[i] = input[last_pos - i]; input[last_pos - i] = tmp; } printf("%s\n", input); 

ध्यान दें कि std :: रिवर्स की सुंदरता यह है कि यह char * स्ट्रिंग्स और std::wstring साथ ही साथ ही std::wstring s के साथ काम करता है

 void strrev(char *str) { if (str == NULL) return; std::reverse(str, str + strlen(str)); } 

एसटीएल से स्टड :: रिवर्स विधि का प्रयोग करें:

 std::reverse(str.begin(), str.end()); 

आपको "एल्गोरिथम" लाइब्रेरी को शामिल करना होगा, #include<algorithm>

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

उदाहरण के लिए, स्ट्रिंग "एनो" (स्पेनिश में वर्ष) ले लो।

यूनिकोड कोड अंक 0x61, 0xf1, 0x6f हैं

सबसे अधिक उपयोग किए गए एन्कोडिंग में से कुछ पर विचार करें:

लैटिन 1 / आईएसओ -8859-1 (एकल बाइट एन्कोडिंग, 1 वर्ण 1 बाइट और इसके विपरीत है):

मूल:

0x61, 0xf1, 0x6f, 0x00

उल्टा:

0x6f, 0xf1, 0x61, 0x00

परिणाम ठीक है

UTF-8:

मूल:

0x61, 0xc3, 0xb1, 0x6f, 0x00

उल्टा:

0x6f, 0xb1, 0xc3, 0x61, 0x00

नतीजा निकम्मा और अवैध यूटीएफ -8 अनुक्रम है

यूटीएफ -16 बिग एंडियन:

मूल:

0x00, 0x61, 0x00, 0xf1, 0x00, 0x6f, 0x00, 0x00

पहले बाइट को एनयूएल टर्मिनेटर के रूप में माना जाएगा। कोई उलट नहीं होगा

यूटीएफ -16 लिटिल एंडियन:

मूल:

0x61, 0x00, 0xf1, 0x00, 0x6f, 0x00, 0x00, 0x00

दूसरी बाइट को एनयूएल-टर्मिनेटर के रूप में माना जाएगा। परिणाम 0x61, 0x00, एक स्ट्रिंग जिसमें 'a' वर्ण होगा।

पूर्णता के हित में, यह इंगित किया जाना चाहिए कि विभिन्न प्लेटफार्मों पर स्ट्रिंग का प्रतिनिधित्व है जिसमें वर्ण के अनुसार प्रत्येक चरित्र बाइट्स की संख्या में भिन्न होता है । ओल्ड-स्कूल प्रोग्रामर इसका उल्लेख डीबीसीएस (डबल बाइट कैरेक्टर सेट) के रूप में करेंगे। आधुनिक प्रोग्रामर सामान्यतः यूटीएफ -8 (साथ ही साथ यूटीएफ -16 और अन्य) में इसका सामना करते हैं। ऐसे अन्य एन्कोडिंग भी हैं

इनमें से किसी भी चर-चौड़ाई वाली एन्कोडिंग योजनाओं में, यहां पोस्ट किए गए सरल एल्गोरिदम ( बुराई , गैर-बुराई या अन्यथा ) बिल्कुल सही ढंग से काम नहीं करेंगे! वास्तव में, वे स्ट्रिंग को उस एन्कोडिंग स्कीम में अस्पष्ट या यहां तक ​​कि अवैध स्ट्रिंग के कारण भी पैदा कर सकते हैं। कुछ अच्छे उदाहरणों के लिए जुआन पाब्लो कैलिफानो के उत्तर देखें

std :: reverse () संभावित रूप से अभी भी इस मामले में काम करेगा, जब तक कि मानक प्लेटफार्म सी + + लाइब्रेरी (विशेष रूप से, स्ट्रिंग इटेरेटर्स) के आपके प्लेटफॉर्म का कार्यान्वयन ठीक से इस खाते में ले लिया।

 #include <cstdio> #include <cstdlib> #include <string> void strrev(char *str) { if( str == NULL ) return; char *end_ptr = &str[strlen(str) - 1]; char temp; while( end_ptr > str ) { temp = *str; *str++ = *end_ptr; *end_ptr-- = temp; } } int main(int argc, char *argv[]) { char buffer[32]; strcpy(buffer, "testing"); strrev(buffer); printf("%s\n", buffer); strcpy(buffer, "a"); strrev(buffer); printf("%s\n", buffer); strcpy(buffer, "abc"); strrev(buffer); printf("%s\n", buffer); strcpy(buffer, ""); strrev(buffer); printf("%s\n", buffer); strrev(NULL); return 0; } 

यह कोड इस आउटपुट का उत्पादन करता है:

 gnitset a cba 

अगर आप जीएलआईबी का उपयोग कर रहे हैं, तो उसके लिए दो कार्य हैं, g_strreverse () और g_utf8_strreverse ()

एक अन्य सी + + तरीका (हालांकि मैं शायद std :: reverse () का उपयोग अपने आप को 🙂 अधिक अभिव्यंजक और तेज होने के नाते)

 str = std::string(str.rbegin(), str.rend()); 

सी रास्ता (अधिक या कम :)) और कृपया, गमागमन के लिए एक्सओआर चाल के बारे में सावधान रहें, आम तौर पर संकलक आमतौर पर इसका अनुकूलन नहीं कर सकते।

ऐसे मामले में यह आमतौर पर बहुत धीमी है।

 char* reverse(char* s) { char* beg = s-1, *end = s, tmp; while (*++end); while (end-- > ++beg) { tmp = *beg; *beg = *end; *end = tmp; } return s; } 

मुझे एव्जेनी के के एंड आर का उत्तर पसंद है I हालांकि, पॉइंटर्स का उपयोग करके संस्करण देखना अच्छा है अन्यथा, यह अनिवार्य रूप से समान है:

 #include <stdio.h> #include <string.h> #include <stdlib.h> char *reverse(char *str) { if( str == NULL || !(*str) ) return NULL; int i, j = strlen(str)-1; char *sallocd; sallocd = malloc(sizeof(char) * (j+1)); for(i=0; j>=0; i++, j--) { *(sallocd+i) = *(str+j); } return sallocd; } int main(void) { char *s = "a man a plan a canal panama"; char *sret = reverse(s); printf("%s\n", reverse(sret)); free(sret); return 0; } 

जगह में एक स्ट्रिंग रिवर्स करने के लिए रिकर्सिव फ़ंक्शन (कोई अतिरिक्त बफ़र, मॉलोक) नहीं।

लघु, सेक्सी कोड खराब, खराब स्टैक उपयोग

 #include <stdio.h> /* Store the each value and move to next char going down * the stack. Assign value to start ptr and increment * when coming back up the stack (return). * Neat code, horrible stack usage. * * val - value of current pointer. * s - start pointer * n - next char pointer in string. */ char *reverse_r(char val, char *s, char *n) { if (*n) s = reverse_r(*n, s, n+1); *s = val; return s+1; } /* * expect the string to be passed as argv[1] */ int main(int argc, char *argv[]) { char *aString; if (argc < 2) { printf("Usage: RSIP <string>\n"); return 0; } aString = argv[1]; printf("String to reverse: %s\n", aString ); reverse_r(*aString, aString, aString+1); printf("Reversed String: %s\n", aString ); return 0; } 

अपना कोड साझा करें एक सी ++ शिक्षार्थी के रूप में, स्वैप () का उपयोग करने के विकल्प के रूप में, मैं नम्रता से टिप्पणियों के लिए पूछ रहा हूं

 void reverse(char* str) { int length = strlen(str); char* str_head = str; char* str_tail = &str[length-1]; while (str_head < str_tail) swap(*str_head++, *str_tail--); } 

यदि आप एटीएल / एमएफसी CString::MakeReverse() का उपयोग कर रहे हैं, तो बस CString::MakeReverse() कॉल करें।

अभी तक एक और:

 #include <stdio.h> #include <strings.h> int main(int argc, char **argv) { char *reverse = argv[argc-1]; char *left = reverse; int length = strlen(reverse); char *right = reverse+length-1; char temp; while(right-left>=1){ temp=*left; *left=*right; *right=temp; ++left; --right; } printf("%s\n", reverse); } 
 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdbool.h> unsigned char * utf8_reverse(const unsigned char *, int); void assert_true(bool); int main(void) { unsigned char str[] = "mañana mañana"; unsigned char *ret = utf8_reverse(str, strlen((const char *) str) + 1); printf("%s\n", ret); assert_true(0 == strncmp((const char *) ret, "anãnam anañam", strlen("anãnam anañam") + 1)); free(ret); return EXIT_SUCCESS; } unsigned char * utf8_reverse(const unsigned char *str, int size) { unsigned char *ret = calloc(size, sizeof(unsigned char*)); int ret_size = 0; int pos = size - 2; int char_size = 0; if (str == NULL) { fprintf(stderr, "failed to allocate memory.\n"); exit(EXIT_FAILURE); } while (pos > -1) { if (str[pos] < 0x80) { char_size = 1; } else if (pos > 0 && str[pos - 1] > 0xC1 && str[pos - 1] < 0xE0) { char_size = 2; } else if (pos > 1 && str[pos - 2] > 0xDF && str[pos - 2] < 0xF0) { char_size = 3; } else if (pos > 2 && str[pos - 3] > 0xEF && str[pos - 3] < 0xF5) { char_size = 4; } else { char_size = 1; } pos -= char_size; memcpy(ret + ret_size, str + pos + 1, char_size); ret_size += char_size; } ret[ret_size] = '\0'; return ret; } void assert_true(bool boolean) { puts(boolean == true ? "true" : "false"); } 

यदि आपको इसे स्टोर करने की आवश्यकता नहीं है, तो आप इस तरह बिताए समय को कम कर सकते हैं:

 void showReverse(char s[], int length) { printf("Reversed String without storing is "); //could use another variable to test for length, keeping length whole. //assumes contiguous memory for (; length > 0; length--) { printf("%c", *(s+ length-1) ); } printf("\n"); } 

सी ++ लैम्ब्डा के साथ:

  auto reverse = [](std::string& s) -> std::string { size_t start = 0, end = s.length() -1; char temp; while (start < end) { temp = s[start]; s[start++] = s[end]; s[end--] = temp; } return s; }; 

यहाँ सी पर मेरे लिए यह ले रहा है। यह अभ्यास के लिए किया और संभव के रूप में संक्षिप्त होने की कोशिश की! आप कमांड लाइन के माध्यम से एक स्ट्रिंग डालते हैं, अर्थात ./program_name "यहां स्ट्रिंग प्रविष्ट करें"

 #include <stdio.h> #include <string.h> void reverse(int s,int e,int len,char t,char* arg) { for(;s<len/2;t=arg[s],arg[s++]=arg[e],arg[e--]=t); } int main(int argc,char* argv[]) { int s=0,len=strlen(argv[1]),e=len-1; char t,*arg=argv[1]; reverse(s,e,len,t,arg); for(s=0,e=0;e<=len;arg[e]==' '||arg[e]=='\0'?reverse(s,e-1,e+s,t,arg),s=++e:e++); printf("%s\n",arg); } 

लेकिन मुझे लगता है कि XOR स्वैप एल्गोरिथ्म सबसे अच्छा है …

 char str[]= {"I am doing reverse string"}; char* pStr = str; for(int i = 0; i != ((int)strlen(str)-1)/2; i++) { char b = *(pStr+i); *(pStr+i) = *(pStr+strlen(str)-1-i); *(pStr+strlen(str)-1-i) = b; } 
 #include<stdio.h> #include<conio.h> int main() { char *my_string = "THIS_IS_MY_STRING"; char *rev_my_string = my_string; while (*++rev_my_string != '\0') ; while (rev_my_string-- != (my_string-1)) { printf("%c", *rev_my_string); } getchar(); return 0; } 

यह स्ट्रिंग को पीछे करने के लिए सी भाषा में कोड को अनुकूलित किया जाता है … और यह सरल है; बस काम करने के लिए एक साधारण सूचक का उपयोग करें …

सी ++ (मेरी राय में) में एक स्ट्रिंग रिवर्स करने का सबसे आसान, सबसे सुरक्षित, सबसे आसान तरीका यह है:

 #include <string> void swap(std::string& str, int index1, int index2) { char temp = str[index1]; str[index1] = str[index2]; str[index2] = temp; } void reverse(std::string& str) { for (int i = 0; i < str.size() / 2; i++) swap(str, i, str.size() - i - 1); } 

एक विकल्प std::swap का उपयोग करना है, लेकिन मुझे अपने कार्यों को परिभाषित करना पसंद है – यह एक दिलचस्प अभ्यास है और आपको अतिरिक्त कुछ भी include करने की आवश्यकता नहीं है

 /** I am a boy -> boy a am I */ int main() { int i, j, n, temp, temp_i, cnt; //char *array = "Samsung"; char array[1000]; char newarr[strlen(array)]; printf("Enter The String: \n"); gets(array); for(i = (strlen(array)-1), n = 0, j = 0; i >= 0; i--) { if( array[i] != ' ') { n++; } else { temp = n; temp_i = i; for(n = 0; n <= temp; n++) { // i = i + 1; newarr[j++] = array[i++]; } i = temp_i; n = 0; } if(i == 0) { newarr[j++] = ' '; temp = n; temp_i = i; for(n = 0; n <= temp; n++) { // i = i + 1; newarr[j++] = array[i++]; } i = temp_i; n = 0; } //newarr[j++] = array[i]; } newarr[j] = '\0'; cnt = 0; for(j = 0; j <= (strlen(newarr)-1); j++)//This is not required just do some R n D { newarr[j] = newarr[++cnt]; } // printf("The first element is %c \n", newarr[1]); puts(newarr); return 0; }