# Reverse the substrings of the given String according to the given Array of indices

Last Updated : 25 Apr, 2023

Given a string S and an array of indices A[], the task is to reverse the substrings of the given string according to the given Array of indices.
Note: A[i] ? length(S), for all i.
Examples:

Input: S = “abcdef”, A[] = {2, 5}
Output: baedcf
Explanation:

Input: S = “abcdefghij”, A[] = {2, 5}
Output: baedcjihgf

Approach: The idea is to use the concept of reversing the substrings of the given string.

• Sort the Array of Indices.
• Extract the substring formed for each index in the given array as follows:
• For the first index in the array A, the substring formed will be from index 0 to A[0] (exclusive) of the given string, i.e. [0, A[0])
• For all other index in the array A (except for last), the substring formed will be from index A[i] to A[i+1] (exclusive) of the given string, i.e. [A[i], A[i+1])
• For the last index in the array A, the substring formed will be from index A[i] to L (inclusive) where L is the length of the string, i.e. [A[i], L]
• Reverse each substring found in the given string

Below is the implementation of the above approach.

## C++

 `// C++ implementation to reverse` `// the substrings of the given String` `// according to the given Array of indices`   `#include ` `using` `namespace` `std;`   `// Function to reverse a string` `void` `reverseStr(string& str,` `                ``int` `l, ``int` `h)` `{` `    ``int` `n = h - l;`   `    ``// Swap character starting` `    ``// from two corners` `    ``for` `(``int` `i = 0; i < n / 2; i++) {` `        ``swap(str[i + l], str[n - i - 1 + l]);` `    ``}` `}`   `// Function to reverse the string` `// with the given array of indices` `void` `reverseString(string& s, ``int` `A[], ``int` `n)` `{`   `    ``// Reverse the string from 0 to A[0]` `    ``reverseStr(s, 0, A[0]);`   `    ``// Reverse the string for A[i] to A[i+1]` `    ``for` `(``int` `i = 1; i < n; i++)` `        ``reverseStr(s, A[i - 1], A[i]);`   `    ``// Reverse String for A[n-1] to length` `    ``reverseStr(s, A[n - 1], s.length());` `}`   `// Driver Code` `int` `main()` `{` `    ``string s = ``"abcdefgh"``;` `    ``int` `A[] = { 2, 4, 6 };` `    ``int` `n = ``sizeof``(A) / ``sizeof``(A[0]);`   `    ``reverseString(s, A, n);` `    ``cout << s;`   `    ``return` `0;` `}`

## Java

 `// Java implementation to reverse` `// the subStrings of the given String` `// according to the given Array of indices` `class` `GFG` `{`   `static` `String s;`   `// Function to reverse a String` `static` `void` `reverseStr(``int` `l, ``int` `h)` `{` `    ``int` `n = h - l;`   `    ``// Swap character starting` `    ``// from two corners` `    ``for` `(``int` `i = ``0``; i < n / ``2``; i++) ` `    ``{` `        ``s = swap(i + l, n - i - ``1` `+ l);` `    ``}` `}`   `// Function to reverse the String` `// with the given array of indices` `static` `void` `reverseString(``int` `A[], ``int` `n)` `{`   `    ``// Reverse the String from 0 to A[0]` `    ``reverseStr(``0``, A[``0``]);`   `    ``// Reverse the String for A[i] to A[i+1]` `    ``for` `(``int` `i = ``1``; i < n; i++)` `        ``reverseStr(A[i - ``1``], A[i]);`   `    ``// Reverse String for A[n-1] to length` `    ``reverseStr(A[n - ``1``], s.length());` `}` `static` `String swap(``int` `i, ``int` `j) ` `{ ` `    ``char` `ch[] = s.toCharArray(); ` `    ``char` `temp = ch[i]; ` `    ``ch[i] = ch[j]; ` `    ``ch[j] = temp; ` `    ``return` `String.valueOf(ch); ` `} `   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``s = ``"abcdefgh"``;` `    ``int` `A[] = { ``2``, ``4``, ``6` `};` `    ``int` `n = A.length;`   `    ``reverseString(A, n);` `    ``System.out.print(s);` `}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 implementation to reverse` `# the substrings of the given String` `# according to the given Array of indices`   `# Function to reverse a string` `def` `reverseStr(``str``, l, h):` `    ``n ``=` `h ``-` `l`   `    ``# Swap character starting` `    ``# from two corners` `    ``for` `i ``in` `range``(n``/``/``2``):` `        ``str``[i ``+` `l], ``str``[n ``-` `i ``-` `1` `+` `l] ``=` `str``[n ``-` `i ``-` `1` `+` `l], ``str``[i ``+` `l]`   `# Function to reverse the string` `# with the given array of indices` `def` `reverseString(s, A, n):`   `    ``# Reverse the from 0 to A[0]` `    ``reverseStr(s, ``0``, A[``0``])`   `    ``# Reverse the for A[i] to A[i+1]` `    ``for` `i ``in` `range``(``1``, n):` `        ``reverseStr(s, A[i ``-` `1``], A[i])`   `    ``# Reverse String for A[n-1] to length` `    ``reverseStr(s, A[n ``-` `1``], ``len``(s))`   `# Driver Code` `s ``=` `"abcdefgh"` `s ``=` `[i ``for` `i ``in` `s]` `A ``=` `[``2``, ``4``, ``6``]` `n ``=` `len``(A)`   `reverseString(s, A, n)` `print``("".join(s))`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# implementation to reverse` `// the subStrings of the given String` `// according to the given Array of indices` `using` `System;`   `class` `GFG` `{`   `static` `String s;`   `// Function to reverse a String` `static` `void` `reverseStr(``int` `l, ``int` `h)` `{` `    ``int` `n = h - l;`   `    ``// Swap character starting` `    ``// from two corners` `    ``for` `(``int` `i = 0; i < n / 2; i++) ` `    ``{` `        ``s = swap(i + l, n - i - 1 + l);` `    ``}` `}`   `// Function to reverse the String` `// with the given array of indices` `static` `void` `reverseString(``int` `[]A, ``int` `n)` `{`   `    ``// Reverse the String from 0 to A[0]` `    ``reverseStr(0, A[0]);`   `    ``// Reverse the String for A[i] to A[i+1]` `    ``for` `(``int` `i = 1; i < n; i++)` `        ``reverseStr(A[i - 1], A[i]);`   `    ``// Reverse String for A[n-1] to length` `    ``reverseStr(A[n - 1], s.Length);` `}`   `static` `String swap(``int` `i, ``int` `j) ` `{ ` `    ``char` `[]ch = s.ToCharArray(); ` `    ``char` `temp = ch[i]; ` `    ``ch[i] = ch[j]; ` `    ``ch[j] = temp; ` `    ``return` `String.Join(``""``,ch); ` `} `   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``s = ``"abcdefgh"``;` `    ``int` `[]A = { 2, 4, 6 };` `    ``int` `n = A.Length;`   `    ``reverseString(A, n);` `    ``Console.Write(s);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`badcfehg`

Time Complexity: O(l * n), where l is the length of the given string and n is the size of the given array.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

Approach:

The task of the reverse_substring() function is to reverse the substrings of a given string s at the indices specified in the list A. Here’s how the algorithm works:

1. Convert the string s into a list of characters so that it can be modified in-place.
2. Add 0 and the length of the string s as the first and last elements to the list A respectively, to account for the reversal of the substrings at the beginning and end of the string.
3. Loop through the indices in the list A starting from the second index (since we’ve already added the first index).
4. For each index, determine the start and end indices of the substring to be reversed by subtracting the previous and current index values in A respectively. For example, if A is [2, 4, 6], and the current index is 1, then the start and end indices are 0 and 1 respectively, since 2-0=2 and 4-0=4, and we need to reverse the substring starting at index 0 and ending at index 1.
5. Reverse the substring between the start and end indices using a two-pointer approach. This is done by swapping the characters at the start and end indices, and then incrementing the start index and decrementing the end index until they meet in the middle.
6. Join the characters in the modified list back into a string and return it.

Below is the implementation of the above approach.

## C++

 `#include ` `#include ` `using` `namespace` `std;`   `string reverseSubstring(string s, vector<``int``> A) {` `    ``A.insert(A.begin(), 0);` `    ``A.push_back(s.length());` `    ``for` `(``int` `i = 1; i < A.size(); i++) {` `        ``int` `l = A[i-1], r = A[i]-1;` `        ``while` `(l < r) {` `            ``swap(s[l], s[r]);` `            ``l++;` `            ``r--;` `        ``}` `    ``}` `    ``return` `s;` `}`   `// Driver code` `int` `main() {` `    ``string s = ``"abcdefgh"``;` `    ``vector<``int``> A = {2, 4, 6};` `    ``cout << reverseSubstring(s, A);` `    ``return` `0;` `}`

## Java

 `import` `java.util.*;`   `public` `class` `Main {` `    ``public` `static` `String reverseSubstring(String s, List A) {` `        ``List indices = ``new` `ArrayList<>(A);` `        ``indices.add(``0``, ``0``);` `        ``indices.add(s.length());` `        ``char``[] chars = s.toCharArray();` `        ``for` `(``int` `i = ``1``; i < indices.size(); i++) {` `            ``int` `l = indices.get(i-``1``), r = indices.get(i)-``1``;` `            ``while` `(l < r) {` `                ``char` `temp = chars[l];` `                ``chars[l] = chars[r];` `                ``chars[r] = temp;` `                ``l++;` `                ``r--;` `            ``}` `        ``}` `        ``return` `new` `String(chars);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args) {` `        ``String s = ``"abcdefgh"``;` `        ``List A = Arrays.asList(``2``, ``4``, ``6``);` `        ``System.out.println(reverseSubstring(s, A));  ``// Output: "abfedchhg"` `    ``}` `}`

## Python3

 `def` `reverse_substring(s, A):` `    ``s ``=` `list``(s)` `    ``A ``=` `[``0``] ``+` `A ``+` `[``len``(s)]` `    ``for` `i ``in` `range``(``1``, ``len``(A)):` `        ``l, r ``=` `A[i``-``1``], A[i]``-``1` `        ``while` `l < r:` `            ``s[l], s[r] ``=` `s[r], s[l]` `            ``l ``+``=` `1` `            ``r ``-``=` `1` `    ``return` `''.join(s)`   `# Driver code` `s ``=` `"abcdefgh"` `A ``=` `[``2``, ``4``, ``6``]` `print``(reverse_substring(s, A))`

## C#

 `//GFG` `//C# implementation of the given approach` `using` `System;` `using` `System.Collections.Generic;` `using` `System.Linq;`   `public` `class` `Program` `{` `    ``public` `static` `string` `ReverseSubstring(``string` `s, List<``int``> A)` `    ``{` `        ``List<``int``> indices = ``new` `List<``int``>(A);` `        ``indices.Insert(0, 0);` `        ``indices.Add(s.Length);` `        ``char``[] chars = s.ToCharArray();` `        ``for` `(``int` `i = 1; i < indices.Count; i++)` `        ``{` `            ``int` `l = indices[i - 1], r = indices[i] - 1;` `            ``while` `(l < r)` `            ``{` `                ``char` `temp = chars[l];` `                ``chars[l] = chars[r];` `                ``chars[r] = temp;` `                ``l++;` `                ``r--;` `            ``}` `        ``}` `        ``return` `new` `string``(chars);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``string` `s = ``"abcdefgh"``;` `        ``List<``int``> A = ``new` `List<``int``> { 2, 4, 6 };` `        ``Console.WriteLine(ReverseSubstring(s, A)); ``// Output: "abfedchhg"` `    ``}` `}`   `//This code is written by Sundaram`

## Javascript

 `function` `reverseSubstring(s, A) {` `    ``A.unshift(0);` `    ``A.push(s.length);` `    ``let chars = s.split(``""``);` `    ``for` `(let i = 1; i < A.length; i++) {` `        ``let l = A[i-1], r = A[i]-1;` `        ``while` `(l < r) {` `            ``[chars[l], chars[r]] = [chars[r], chars[l]];` `            ``l++;` `            ``r--;` `        ``}` `    ``}` `    ``return` `chars.join(``""``);` `}`   `// Driver code` `let s = ``"abcdefgh"``;` `let A = [2, 4, 6];` `console.log(reverseSubstring(s, A));  ``// Output: "abfedchhg"`

Output

`badcfehg`

The time complexity of this algorithm is O(n), where n is the length of the string s, since we loop through the indices in list A and reverse the substrings in place.
The Auxiliary space is also O(n) since we convert the string s into a list of characters.

Article Tags :
Practice Tags :