বিপরীত স্ট্রিংটি ধরে রাখতে আলাদা বাফারের প্রয়োজন ছাড়াই আপনি কীভাবে সি বা সি ++ তে স্ট্রিংকে বিপরীত করবেন?
উত্তর:
স্ট্যান্ডার্ড অ্যালগরিদম হ'ল সূচনা / শেষের দিকে পয়েন্টার ব্যবহার করা এবং তাদের সাথে দেখা না করা বা মাঝখানে ক্রস না হওয়া পর্যন্ত তাদের অভ্যন্তরে হাঁটা। যেতে যেতে অদলবদল করুন।
বিপরীত ASCII স্ট্রিং, অর্থাত্ 0 টি-টার্মিনেটেড অ্যারে যেখানে প্রতিটি অক্ষর 1-তে ফিট করে char। (অথবা অন্যান্য নন-মাল্টবাইট চরিত্র সেট)।
void strrev(char *head)
{
if (!head) return;
char *tail = head;
while(*tail) ++tail; // find the 0 terminator, like head+strlen
--tail; // tail points to the last real char
// head still points to the first
for( ; head < tail; ++head, --tail) {
// walk pointers inwards until they meet or cross in the middle
char h = *head, t = *tail;
*head = t; // swapping as we go
*tail = h;
}
}// test program that reverses its args
#include <stdio.h>
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;
}একই অ্যালগোরিদম জ্ঞাত দৈর্ঘ্যের সাথে পূর্ণসংখ্যার অ্যারেগুলির জন্য কাজ tail = start + length - 1করে, শেষ-সন্ধানকারী লুপের পরিবর্তে ব্যবহার করুন।
(সম্পাদকের দ্রষ্টব্য: এই উত্তরটি মূলত এই সাধারণ সংস্করণের জন্যও এক্সওআর-অদলবস্তু ব্যবহার করেছে this এই জনপ্রিয় প্রশ্নের ভবিষ্যতের পাঠকদের সুবিধার জন্য স্থির X এক্সওআর-অদলবদলকে খুব বেশি সুপারিশ করা হয় না ; আপনার কোডটি কম দক্ষতার সাথে সংকলন করে পড়া এবং তৈরি করা কঠিন You গডবোল্ট সংকলক এক্সপ্লোরারটিতে দেখতে পাবেন যে যখন জিসিসি-ও 3 দিয়ে x86-64-এর জন্য xor-swap সংকলন করা হয় তখন asm লুপের বডিটি আরও কত জটিল)
(এটি এক্সওআর-অদলবদল জিনিস। খেয়াল রাখবেন যে আপনার নিজের সাথে স্ব্যাপিং এড়ানো অবশ্যই হবে , কারণ *pএবং যদি *qএকই অবস্থান হয় তবে এটি একটি zero a == 0 দিয়ে শূন্য করতে পারবেন X এক্সওর-অদলব দুটি পৃথক অবস্থানের উপর নির্ভর করে, এগুলি প্রতিটি অস্থায়ী সঞ্চয় হিসাবে ব্যবহার করে))
সম্পাদকের দ্রষ্টব্য: আপনি একটি টেম্প ভেরিয়েবল ব্যবহার করে একটি নিরাপদ ইনলাইন ফাংশন দিয়ে এসডাব্লুপিকে প্রতিস্থাপন করতে পারেন।
#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;
}উদাহরণ:
$ ./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;
}
}sঅবশ্যই অ্যারে আকারে ঘোষণা করা উচিত। অন্য কথায়, এর char s[] = "this is ok"পরিবর্তে char *s="cannot do this"পরবর্তী ফলাফলগুলি পরিবর্তিত হতে পারে না এমন স্ট্রিং
জায়গায় একটি স্ট্রিং বিপরীত (দৃশ্যায়ন):
স্ট্রিংটি নাল-টার্মিনেটেড charঅ্যারে হিসাবে সাধারণ ক্ষেত্রে ধরে নিয়ে অ-অশুভ সি C
#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--;
}
}int temp, এই সমাধানটি সেরা দেখাচ্ছে। +1
!(*str)যদিও থেকে (গুলি) সরিয়ে ফেলব ।
strchr()অনুসন্ধান করছে '\0'। আমি দুজনের কথা ভেবেছি। লুপের দরকার নেই।
আপনি 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);size_tকিছুটা হলেও হওয়া উচিত।
STL থেকে বিপরীত পদ্ধতিটি ব্যবহার করুন :
std::reverse(str.begin(), str.end());আপনাকে "অ্যালগরিদম" লাইব্রেরি অন্তর্ভুক্ত করতে হবে #include<algorithm>,।
নোট এসটিডি :: বিপরীত সৌন্দর্য এটি সঙ্গে কাজ করে যে char *স্ট্রিং এবং std::wstringযেমন ঠিক যেমন ভাল গুলি std::stringগুলি
void strrev(char *str)
{
if (str == NULL)
return;
std::reverse(str, str + strlen(str));
}*টাইপ করে না এবং নামটি দিয়ে দেয় see ওয়ান্ডারফুল। আমি স্বীকার করি আমি একজন পিউরিস্টের কিছু তবে আমি যতবার কোড দেখি ততবারই আমি ক্রিঞ্জ করি char* str;।
আপনি যদি নূন্যতম সমাপ্ত বাফারগুলির বিপরীত সন্ধান করছেন তবে এখানে পোস্ট করা বেশিরভাগ সমাধান ঠিক আছে। তবে, টিম ফারলে যেমন ইতিমধ্যে ইঙ্গিত করেছেন, এই আলগোরিদিমগুলি কেবল তখনই কাজ করবে যদি এটি ধরে নেওয়া বৈধ হয় যে কোনও স্ট্রিং শব্দার্থগতভাবে বাইটের একটি অ্যারে (অর্থাত্ সিঙ্গল-বাইট স্ট্রিং), যা একটি ভুল ধারণা, আমি মনে করি।
উদাহরণস্বরূপ, স্ট্রিং "আও" (স্প্যানিশ ভাষায়)।
ইউনিকোড কোড পয়েন্টগুলি 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
প্রথম বাইটটি NUL- টার্মিনেটর হিসাবে বিবেচিত হবে। কোন বিপরীত স্থান গ্রহণ করা হবে না।
ইউটিএফ -16 লিটল এন্ডিয়ান:
মূল:
0x61, 0x00, 0xf1, 0x00, 0x6f, 0x00, 0x00, 0x00
দ্বিতীয় বাইটটি NUL- টার্মিনেটর হিসাবে বিবেচিত হবে। ফলাফলটি 0x61, 0x00 হবে, একটি স্ট্রিংটিতে 'এ' অক্ষর থাকবে।
সম্পূর্ণতার স্বার্থে, এটি চিহ্নিত করা উচিত যে বিভিন্ন প্ল্যাটফর্মগুলিতে স্ট্রিংগুলির প্রতিনিধিত্ব রয়েছে যেখানে চরিত্রের উপর নির্ভর করে অক্ষর প্রতি বাইটের সংখ্যা পরিবর্তিত হয় । ওল্ড-স্কুল প্রোগ্রামাররা এটি ডিবিসিএস (ডাবল বাইট চরিত্র সেট) হিসাবে উল্লেখ করবে । আধুনিক প্রোগ্রামাররা সাধারণত ইউটিএফ -8 (পাশাপাশি ইউটিএফ -16 এবং অন্যদের) এ মুখোমুখি হয় । এছাড়াও অন্যান্য অন্যান্য এনকোডিং রয়েছে।
এই যেকোন ভেরিয়েবল-প্রস্থের এনকোডিং স্কিমগুলিতে, এখানে পোস্ট করা সাধারণ অ্যালগরিদমগুলি ( দুষ্ট , অ-মন্দ বা অন্যথায় ) সঠিকভাবে কাজ করবে না! আসলে, তারা এমনকি এনকোডিং স্কিমটিতে স্ট্রিংটিকে অবৈধ বা এমনকি একটি অবৈধ স্ট্রিংয়ের কারণ হতে পারে। কিছু ভাল উদাহরণের জন্য জুয়ান পাবলো ক্যালিফোনের উত্তর দেখুন ।
std :: বিপরীতমুখী () সম্ভাব্যভাবে এখনও এই ক্ষেত্রে কাজ করবে, যতক্ষণ না আপনার প্ল্যাটফর্মের স্ট্যান্ডার্ড সি ++ লাইব্রেরি প্রয়োগ করা হবে (বিশেষত স্ট্রিং পুনরাবৃত্তিকারী) এটি যথাযথভাবে বিবেচনায় নিয়েছে।
আরও একটি সি ++ উপায় (যদিও আমি সম্ভবত সম্ভবত স্টাড :: বিপরীত () নিজেকে :) আরও প্রকাশিত এবং দ্রুত হিসাবে ব্যবহার করব)
str = std::string(str.rbegin(), str.rend());সি উপায় (কম বা কম :)) এবং দয়া করে, অদলবদলের জন্য এক্সওআর কৌশল সম্পর্কে সতর্ক থাকুন, সংকলকরা কখনও কখনও এটি অপ্টিমাইজ করতে পারে না।
এই ক্ষেত্রে এটি সাধারণত অনেক ধীর হয়।
char* reverse(char* s)
{
char* beg = s, *end = s, tmp;
while (*end) end++;
while (end-- > beg)
{
tmp = *beg;
*beg++ = *end;
*end = tmp;
}
return s;
} // fixed: check history for details, as those are interesting onesstrlenস্ট্রিংটির শেষ সন্ধান করতে ব্যবহার করব , যদি এটি সম্ভবত দীর্ঘ হয়। একটি ভাল গ্রন্থাগার বাস্তবায়ন প্রতি পুনরাবৃত্তির জন্য 1 বাইটের চেয়ে দ্রুত অনুসন্ধান করতে সিমডি ভেক্টর ব্যবহার করবে। তবে খুব সংক্ষিপ্ত স্ট্রিংয়ের জন্য, while (*++end);একটি লাইব্রেরি ফাংশন কল অনুসন্ধান শুরু করার আগেই সম্পন্ন করা হবে।
_mm_shuffle_epi8(পিএসএইচইউএফবি) সঠিক শ্যাফল কন্ট্রোল ভেক্টরকে দিয়ে একটি 16 বি ভেক্টরের ক্রমকে বিপরীত করতে পারে। এটি সম্ভবত কিছু সাবধানী অপ্টিমাইজেশান, বিশেষত AVX2 এর সাথে প্রায় ম্যাকপি গতিতে চলতে পারে।
char* beg = s-1অপরিবর্তিত আচরণ রয়েছে (কমপক্ষে sএকটি অ্যারের প্রথম উপাদানকে নির্দেশ করে, যা সর্বাধিক সাধারণ ঘটনা)। একটি খালি স্ট্রিং while (*++end);হলে অপরিজ্ঞাত আচরণ sহয় behavior
s-1আচরণের সংজ্ঞা দিয়েছে এমনকি যদি sকোনও অ্যারের প্রথম উপাদানটির দিকেও লক্ষ্য করে, তবে আপনিই সেই ব্যক্তি, যিনি সমর্থনে মানটি উল্লেখ করতে সক্ষম হন।
#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আপনি GLib ব্যবহার করছেন এমন ক্ষেত্রে এর দুটি ফাংশন রয়েছে, g_strevers () এবং g_utf8_strrevers ()
আমি ইভজেনির কেএন্ডআর উত্তরটি পছন্দ করি। যাইহোক, পয়েন্টার ব্যবহার করে একটি সংস্করণ দেখতে ভাল লাগছে। অন্যথায়, এটি মূলত একই:
#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;
}charস্ট্যাকের দিকে ঠেলাঠেলি "জায়গায়" হিসাবে গণনা করা হয় না। বিশেষত যখন আপনি অক্ষর প্রতি 4 * 8B চাপ দিচ্ছেন না (একটি 64-বিট মেশিনে: 3 টি আর্গ + একটি ফেরতের ঠিকানা)।
আপনি যদি এটিএল / এমএফসি ব্যবহার করছেন তবে CStringকেবল কল করুন 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");
}আমার উত্তর তাদের বেশিরভাগের মতোই হবে তবে আমার কোডটি এখানে সন্ধান করুন।
//Method signature to reverse string
string reverseString(string str);
int main(void){
string str;
getline(cin, str);
str = reverseString(str);
cout << "The reveresed string is : " << str;
return 0;
}
/// <summary>
/// Reverses the input string.
/// </summary>
/// <param name="str">
/// This is the input string which needs to be reversed.
/// </param>
/// <return datatype = string>
/// This method would return the reversed string
/// </return datatype>
string reverseString(string str){
int length = str.size()-1;
char temp;
for( int i=0 ;i<(length/2);i++)
{
temp = str[i];
str[i] = str[length-i];
str[length-i] = temp;
}
return str;
}আমি মনে করি স্ট্রিংটি বিপরীত করার আরও একটি উপায় আছে। ব্যবহারকারীর কাছ থেকে ইনপুট পান এবং এটি বিপরীত করুন।
void Rev() {
char ch;
cin.get(ch);
if(ch != '\n') {
Rev();
cout.put(ch);
}
}আপনার যদি এটি সঞ্চয় করার প্রয়োজন না হয় তবে আপনি এইভাবে ব্যয় করা সময় হ্রাস করতে পারেন:
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");
}সি তে আমার এটি গ্রহণ এখানে অনুশীলনের জন্য কি এবং যথাসম্ভব সংক্ষিপ্ত হওয়ার চেষ্টা করেছিল! আপনি কমান্ড লাইনের মাধ্যমে একটি স্ট্রিং প্রবেশ করেন, যেমন ./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);
}তবে আমি মনে করি এক্সওআর সোয়াপ অ্যালগরিদম সেরা ...
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;
}strlen()লুপের শর্তে এবং লুপের শরীরে কল আসতে পারে না optim
সি ++ এ (আমার মতে) স্ট্রিংটিকে বিপরীত করার সবচেয়ে পরিষ্কার, নিরাপদ এবং সহজতম উপায়টি এখানে:
#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অতিরিক্ত কিছু করার দরকার নেই।
#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;
}এটি স্ট্রিংকে উল্টানোর জন্য সি ভাষায় অনুকূলিত কোড ... এবং এটি সহজ; কাজটি করার জন্য একটি সাধারণ পয়েন্টার ব্যবহার করুন ...