GFG App
Open App
Browser
Continue

# Reverse a string without affecting special characters

Given a string, that contains a special character together with alphabets (‘a’ to ‘z’ and ‘A’ to ‘Z’), reverse the string in a way that special characters are not affected.

Examples:

Input:   str = “a,b\$c”
Output:  str = “c,b\$a”
Explanation: Note that \$ and , are not moved anywhere.  Only subsequence “abc” is reversed

Input:   str = “Ab,c,de!\$”
Output:  str = “ed,c,bA!\$”

Recommended Practice

Simple Solution:

1. Create a temporary character array say temp[].
2. Copy alphabetic characters from the given array to temp[].
3. Reverse temp[] using standard string reversal algorithm
4. Now traverse input string and temp in a single loop. Wherever there is an alphabetic character is input string, replace it with the current character of temp[].

Below is the implementation of above approach:

## C++

 `// C++ program to reverse string without` `// affecting it's special character`   `#include ` `using` `namespace` `std;` `void` `reverse(string s)` `{` `    ``// creating character array of size` `    ``// equal to length of string` `    ``char` `temp[s.length()];` `    ``int` `x = 0;` `    ``for` `(``int` `i = 0; i < s.length(); i++) {` `        ``if` `(s[i] >= ``'a'` `&& s[i] <= ``'z'` `            ``|| s[i] >= ``'A'` `&& s[i] <= ``'Z'``) {` `            ``// storing elements in array` `            ``temp[x] = s[i];` `            ``x++;` `        ``}` `    ``}` `    ``// reversing the character array` `    ``reverse(temp, temp + x);`   `    ``x = 0;` `    ``for` `(``int` `i = 0; i < s.length(); i++) {` `        ``if` `(s[i] >= ``'a'` `&& s[i] <= ``'z'` `            ``|| s[i] >= ``'A'` `&& s[i] <= ``'Z'``) {` `            ``// updating the original string` `            ``s[i] = temp[x];` `            ``x++;` `        ``}` `    ``}` `    ``cout << ``"reversed string is: "` `<< s;` `}` `// driver code` `int` `main()` `{` `    ``string s = ``"Ab,c,de!\$"``;` `    ``// function call` `    ``reverse(s);` `    ``return` `0;` `}`   `// this code is contributed by Machhaliya Muhammad`

## Java

 `// Java code to illustrate how to reverse a string without` `// affecting special characters.` `import` `java.util.*;`   `class` `GFG {` `    ``public` `static` `void` `rev(``char` `s[], ``int` `l, ``int` `r)` `    ``{` `        ``for` `(``int` `i = l; i < r / ``2``; i++) {` `            ``char` `temp = s[i];` `            ``s[i] = s[r - ``1` `- i];` `            ``s[r - ``1` `- i] = temp;` `        ``}` `    ``}` `    ``public` `static` `void` `reverse(``char` `s[])` `    ``{` `        ``// creating character array of size` `        ``// equal to length of string` `        ``char``[] temp = ``new` `char``[s.length];` `        ``int` `x = ``0``;` `        ``for` `(``int` `i = ``0``; i < s.length; i++) {` `            ``if` `(s[i] >= ``'a'` `&& s[i] <= ``'z'` `                ``|| s[i] >= ``'A'` `&& s[i] <= ``'Z'``) {` `                ``// storing elements in array` `                ``temp[x] = s[i];` `                ``x++;` `            ``}` `        ``}`   `        ``// reversing the character array` `        ``rev(temp, ``0``, x);`   `        ``x = ``0``;` `        ``for` `(``int` `i = ``0``; i < s.length; i++) {` `            ``if` `(s[i] >= ``'a'` `&& s[i] <= ``'z'` `                ``|| s[i] >= ``'A'` `&& s[i] <= ``'Z'``) {` `                ``// updating the origional string` `                ``s[i] = temp[x];` `                ``x++;` `            ``}` `        ``}`   `        ``String revStr = ``new` `String(s);` `        ``System.out.println(``"reversed string is: "` `+ revStr);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``String str = ``"Ab,c,de!\$"``;` `        ``char``[] charArray = str.toCharArray();` `        ``reverse(charArray);` `    ``}` `}`   `// This code is contributed by Aarti_Rathi`

## Python3

 `# Python3 program to reverse string without` `# affecting it's special character` `def` `rev(s, l, r) :` `    ``while` `l``=` `'a'` `and` `s[i] <``=` `'z'` `or` `s[i] >``=` `'A'` `and` `s[i] <``=` `'Z'` `:` `            ``# storing elements in array` `            ``temp[x] ``=` `s[i]` `            ``x ``+``=` `1` `    `  `    ``# reversing the character array        ` `    ``rev(temp, ``0``, x)` `    `  `    ``lst ``=` `list``(s)` `    ``x ``=` `0` `    `  `    ``for` `i ``in` `range``(``len``(s)) :` `        ``if` `s[i] >``=` `'a'` `and` `s[i] <``=` `'z'` `or` `s[i] >``=` `'A'` `and` `s[i] <``=` `'Z'` `:` `            ``# updating the origional string` `            ``lst[i] ``=` `temp[x]` `            ``x ``+``=` `1` `    `  `    ``revStr ``=` `""` `    ``for` `i ``in` `range``(``len``(s)) :` `        ``revStr ``+``=` `lst[i]` `        `  `    ``print``(``"reverse string is :"``,revStr);` `    `  `# Driver Code` `if` `__name__ ``=``=` `"__main__"` `:` `    `  `    ``s``=``"Ab,c,de!\$"` `    `  `    ``reverse(s)` `    `  `# This code is contributed by aditya942003patil`

## C#

 `// C# code to illustrate how to reverse an array without` `// affecting special characters.` `using` `System;`   `public` `class` `GFG{`   `    ``public` `static` `void` `rev(``char``[] s, ``int` `l, ``int` `r)` `    ``{` `        ``for` `(``int` `i = l; i < r / 2; i++) {` `            ``char` `temp = s[i];` `            ``s[i] = s[r - 1 - i];` `            ``s[r - 1 - i] = temp;` `        ``}` `    ``}` `    ``public` `static` `void` `reverse(``char``[] s)` `    ``{` `        ``// creating character array of size` `        ``// equal to length of string` `        ``char``[] temp = ``new` `char``[s.Length];` `        ``int` `x = 0;` `        ``for` `(``int` `i = 0; i < s.Length; i++) {` `            ``if` `((s[i] >= ``'a'` `&& s[i] <= ``'z'``)` `                ``|| (s[i] >= ``'A'` `&& s[i] <= ``'Z'``)) {` `                ``// storing elements in array` `                ``temp[x] = s[i];` `                ``x++;` `            ``}` `        ``}` ` `  `        ``// reversing the character array` `        ``rev(temp,0,x);` `        ``x = 0;` `        ``for` `(``int` `i = 0; i < s.Length; i++) {` `            ``if` `(s[i] >= ``'a'` `&& s[i] <= ``'z'` `                ``|| s[i] >= ``'A'` `&& s[i] <= ``'Z'``) {` `                ``// updating the origional string` `                ``s[i] = temp[x];` `                ``x++;` `            ``}` `        ``}` ` `  `        ``string` `revStr = ``new` `string``(s);` `        ``Console.WriteLine(``"reversed string is: "` `+ revStr);` `    ``}` ` `  `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``string` `str = ``"Ab,c,de!\$"``;` `        ``char``[] charArray = str.ToCharArray();` `        ``reverse(charArray);` `    ``}` `}` `// This code is contributed by Srj_27`

## Javascript

 `// Javascript program to reverse string without` `// affecting it's special character`   `function` `reverse(s)` `{` `    ``// creating character array of size` `    ``// equal to length of string` `    ``let temp=``new` `Array(s.length);` `    ``let x = 0;` `    ``for` `(let i = 0; i < s.length; i++) {` `        ``if` `(s[i] >= 'a``' && s[i] <= '``z``'` `            ``|| s[i] >= '``A``' && s[i] <= '``Z``') {` `            ``// storing elements in array` `            ``temp[x] = s[i];` `            ``x++;` `        ``}` `    ``}` `    ``// reversing the character array` `    ``//reverse(temp, temp + x);` `    ``let str="";` `    ``for(let i=x-1; i>=0; i--)` `    ``{` `        ``str+=temp[i];` `    ``}`   `    ``x = 0;` `    ``let ans=""` `    ``for (let i = 0; i < s.length; i++) {` `        ``if (s[i] >= '``a``' && s[i] <= '``z``'` `            ``|| s[i] >= '``A``' && s[i] <= '``Z') {` `            ``// updating the original string` `            ``ans+= str[x];` `            ``x++;` `        ``}` `        ``else` `            ``ans+=s[i];` `    ``}` `    ``document.write(``"reversed string is: "` `+ ans);` `}` `// driver code` `    ``let s = ``"Ab,c,de!\$"``;` `    ``// function call` `    ``reverse(s);`

Output

`reversed string is: ed,c,bA!\$`

Time Complexity: O(N) where N is the length of the string.
Auxiliary Space: O(N) where N is the length of the string.

Efficient Solution:

The time complexity of the above solution is O(n), but it requires extra space, and it does two traversals of an input string.
We can reverse with one traversal and without extra space. Below is the algorithm.

```1) Let input string be 'str[]' and length of string be 'n'
2) l = 0, r = n-1
3) While l is smaller than r, do following
a) If str[l] is not an alphabetic character, do l++
b) Else If str[r] is not an alphabetic character, do r--
c) Else swap str[l] and str[r]```

Below are implementations of the above algorithm.

## C++

 `// C++ program to reverse a string  with special characters` `#include ` `using` `namespace` `std;`   `// Returns true if x is an alphabetic character, false` `// otherwise` `bool` `isAlphabet(``char` `x)` `{` `    ``return` `((x >= ``'A'` `&& x <= ``'Z'``) || (x >= ``'a'` `&& x <= ``'z'``));` `}`   `void` `reverse(``char` `str[])` `{` `    ``// Initialize left and right pointers` `    ``int` `r = ``strlen``(str) - 1, l = 0;`   `    ``// Traverse string from both ends until 'l' and 'r'` `    ``while` `(l < r) {` `        ``// Ignore special characters` `        ``if` `(!isAlphabet(str[l]))` `            ``l++;` `        ``else` `if` `(!isAlphabet(str[r]))` `            ``r--;`   `        ``else` `// Both str[l] and str[r] are not special` `        ``{` `            ``swap(str[l], str[r]);` `            ``l++;` `            ``r--;` `        ``}` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``char` `str[] = ``"a!!!b.c.d,e'f,ghi"``;` `    ``cout << ``"Input string: "` `<< str << endl;` `    ``reverse(str);` `    ``cout << ``"Output string: "` `<< str << endl;` `    ``return` `0;` `}`   `// This code is contributed by Sania Kumari Gupta`

## C

 `// C program to reverse a string with special characters` `#include ` `#include ` `#include ` `// Returns true if x is an alphabetic character, false` `// otherwise` `bool` `isAlphabet(``char` `x)` `{` `    ``return` `((x >= ``'A'` `&& x <= ``'Z'``) || (x >= ``'a'` `&& x <= ``'z'``));` `}`   `void` `reverse(``char` `str[])` `{` `    ``// Initialize left and right pointers` `    ``int` `r = ``strlen``(str) - 1, l = 0;`   `    ``// Traverse string from both ends until 'l' and 'r'` `    ``while` `(l < r) {` `        ``// Ignore special characters` `        ``if` `(!isAlphabet(str[l]))` `            ``l++;` `        ``else` `if` `(!isAlphabet(str[r]))` `            ``r--;` `        ``// Both str[l] and str[r] are not special` `        ``else` `{` `            ``char` `temp = str[l];` `            ``str[l] = str[r];` `            ``str[r] = temp;` `            ``// swap(str[l], str[r]);` `            ``l++;` `            ``r--;` `        ``}` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``char` `str[] = ``"a!!!b.c.d,e'f,ghi"``;` `    ``printf``(``"Input string: %s\n"``, str);` `    ``reverse(str);` `    ``printf``(``"Output string: %s\n"``, str);` `    ``return` `0;` `}`   `// This code is contributed by Sania Kumari Gupta`

## Java

 `// Java code to illustrate how to reverse an array without` `// affecting special characters.` `import` `java.io.*;` `class` `GFG {` `    ``public` `static` `void` `reverse(``char` `str[])` `    ``{` `        ``// Initialize left and right pointers` `        ``int` `r = str.length - ``1``, l = ``0``;`   `        ``// Traverse string from both ends until 'l' and 'r'` `        ``while` `(l < r) {` `            ``// Ignore special characters` `            ``if` `(!Character.isAlphabetic(str[l]))` `                ``l++;` `            ``else` `if` `(!Character.isAlphabetic(str[r]))` `                ``r--;`   `            ``// Both str[l] and str[r] are not spacial` `            ``else` `{` `                ``char` `tmp = str[l];` `                ``str[l] = str[r];` `                ``str[r] = tmp;` `                ``l++;` `                ``r--;` `            ``}` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``String str = ``"a!!!b.c.d,e'f,ghi"``;` `        ``char``[] charArray = str.toCharArray();`   `        ``System.out.println(``"Input string: "` `+ str);` `        ``reverse(charArray);` `        ``String revStr = ``new` `String(charArray);`   `        ``System.out.println(``"Output string: "` `+ revStr);` `    ``}` `}`   `// This code is contributed by Sania Kumari Gupta`

## Python3

 `def` `reverseString(text):` `    ``index ``=` `-``1`   `    ``# Loop from last index until half of the index     ` `    ``for` `i ``in` `range``(``len``(text)``-``1``, ``int``(``len``(text)``/``2``), ``-``1``):`   `        ``# match character is alphabet or not         ` `        ``if` `text[i].isalpha():` `            ``temp ``=` `text[i]` `            ``while` `True``:` `                ``index ``+``=` `1` `                ``if` `text[index].isalpha():` `                    ``text[i] ``=` `text[index]` `                    ``text[index] ``=` `temp` `                    ``break` `    ``return` `text` `    `  `# Driver code` `string ``=` `"a!!!b.c.d,e'f,ghi"` `print` `(``"Input string: "``, string)` `string ``=`  `reverseString(``list``(string))` `print` `(``"Output string: "``, "".join(string))` ` `  `# This code is contributed by shiva9610`

## C#

 `// C# code to illustrate how to reverse ` `// an array without affecting special characters.` `using` `System;` `public` `class` `GFG ` `{ ` `    ``public` `static` `void` `reverse(``char` `[]str) ` `    ``{ ` `        ``// Initialize left and right pointers ` `        ``int` `r = str.Length - 1, l = 0; `   `        ``// Traverse string from both ends until ` `        ``// 'l' and 'r' ` `        ``while` `(l < r) ` `        ``{ ` `            ``// Ignore special characters ` `            ``if` `(!``char``.IsLetter(str[l])) ` `                ``l++; ` `            ``else` `if``(!``char``.IsLetter(str[r])) ` `                ``r--; `   `            ``// Both str[l] and str[r] are not spacial ` `            ``else` `            ``{ ` `                ``char` `tmp = str[l]; ` `                ``str[l] = str[r]; ` `                ``str[r] = tmp; ` `                ``l++; ` `                ``r--; ` `            ``} ` `        ``} ` `    ``} `   `    ``// Driver Code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``String str = ``"a!!!b.c.d,e'f,ghi"``; ` `        ``char``[] charArray = str.ToCharArray(); `   `        ``Console.WriteLine(``"Input string: "` `+ str); ` `                            ``reverse(charArray); ` `        ``String revStr = ``new` `String(charArray); `   `        ``Console.WriteLine(``"Output string: "` `+ revStr); ` `    ``} ` `} `   `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output

```Input string: a!!!b.c.d,e'f,ghi
Output string: i!!!h.g.f,e'd,cba```

Time Complexity: O(N) where N is the length of the string.
Auxiliary Space: O(1).

My Personal Notes arrow_drop_up