Open In App

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

Last Updated : 25 Apr, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

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 <bits/stdc++.h>
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




<script>
 
// JavaScript implementation to reverse
// the substrings of the given String
// according to the given Array of indices
 
// Function to reverse a string
function reverseStr(str, l, h)
{
    var n = h - l;
 
    // Swap character starting
    // from two corners
    for (var i = 0; i < n / 2; i++) {
        [str[i + l], str[n - i - 1 + l]] =
        [str[n - i - 1 + l], str[i + l]];
    }
    return str;
}
 
// Function to reverse the string
// with the given array of indices
function reverseString(s, A, n)
{
 
    // Reverse the string from 0 to A[0]
    s = reverseStr(s, 0, A[0]);
 
    // Reverse the string for A[i] to A[i+1]
    for (var i = 1; i < n; i++)
        s = reverseStr(s, A[i - 1], A[i]);
 
    // Reverse String for A[n-1] to length
    s = reverseStr(s, A[n - 1], s.length);
    return s;
}
 
// Driver Code
var s = "abcdefgh";
var A = [2, 4, 6];
var n = A.length;
s = reverseString(s.split(''), A, n);
document.write( s.join(''));
 
</script>


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 <iostream>
#include <vector>
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<Integer> A) {
        List<Integer> 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<Integer> 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.



Similar Reads

Reverse substrings of given string according to specified array indices
Given string str of length N and an array arr[] of integers, for array element arr[i](1-based indexing), reverse the substring in indices [arr[i], N - arr[i] + 1]. The task is to print the string after every reversal. Examples: Input: str = "GeeksforGeeks", arr[] = {2}Output: GkeeGrofskeesExplanation:For first element of the array is 2:Reverse the
7 min read
Count pairs of indices having sum of indices same as the sum of elements at those indices
Given an array arr[] consisting of N integers, the task is to find the number of pairs (i, j) whose sum of indices is the same as the sum elements at the indices. Examples: Input: arr[] = {0, 1, 7, 4, 3, 2}Output: 1Explanation: There exists only pair that satisfies the condition is {(0, 1)}. Input: arr[] = {1, 6, 2, 4, 5, 6}Output: 0 Naive Approach
9 min read
Count of indices pairs such that product of elements at these indices is equal to absolute difference of indices
Given an array arr[] consisting of N positive integers, the task is to find the number of pairs (i, j) such that i &lt; j and the product of elements at these indices is equal to the absolute difference of their indices. Examples: Input: arr[] = {1, 1, 2, 4}Output: 2Explanation:Following are the possible pairs: (0, 1): The sum of these indices is 0
10 min read
Count of unordered pair of indices such that ratio of elements at these indices is same as ratio of indices
Given an array arr[] of N integers, the task is to find the number of unordered pairs (i, j) in the array such that the ratio of elements at these indices is the same as the ratio of indices (arr[j]/arr[i] = j/i). Examples: Input: arr[] = {4, 5, 12, 10, 6}Output: 2Explanation: The pairs that follow the given condition are: (1, 3) as arr[3] / arr[1]
10 min read
Rearrange a string according to the given indices
Given a string S and an array index[], the task is to rearrange the string S by placing every character S[i] to position index[i].Example Input: S = "geeksforgeeks", index[] = {5, 6, 7, 0, 1, 2, 8, 9, 10, 3, 4, 11, 12} Output: ksfeegeeorgksInput: S = "math", index[] = {0, 1, 2, 3} Output: math Approach: To solve the problem, follow the steps given
5 min read
Reorder an Array according to given indices with repetition allowed
Given two integer arrays arr and index of size N, the task is to create a new array by inserting the elements given in the arr array at the indices given by the index array. If a particular position occur multiple time then right shift the right-side array elements and then insert element at given index. Note: It is given that all the indices that
6 min read
Check if a palindromic string can be obtained by concatenating substrings split from same indices of two given strings
Given two strings A and B of length N, the task is to check if any of the two strings formed by splitting both the strings at any index i (0 ≤ i ≤ N - 1) and concatenating A[0, i] and B[i, N - 1] or A[i, N - 1] and B[0, i] respectively, form a palindromic string or not. If found to be true, print "Yes". Otherwise, print "No". Examples: Input: A = "
21 min read
Absolute difference between sum of even elements at even indices & odd elements at odd indices in given Array
Given an array arr[] containing N elements, the task is to find the absolute difference between the sum of even elements at even indices &amp; the count of odd elements at odd indices. Consider 1-based indexing Examples: Input: arr[] = {3, 4, 1, 5}Output: 0Explanation: Sum of even elements at even indices: 4 {4}Sum of odd elements at odd indices: 4
5 min read
Maximize the difference of sum of elements at even indices and odd indices by shifting an odd sized subarray to end of given Array.
Given an array arr[] of size N, the task is to maximize the difference of the sum of elements at even indices and elements at odd indices by shifting any subarray of odd length to the end of the array. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6}Output: 3Explanation: Initially sum of elements at even indices = 1 + 3 + 5 = 9Sum of elements at odd ind
13 min read
Reverse String according to the number of words
Given a string containing a number of words. If the count of words in string is even then reverse its even position's words else reverse its odd position, push reversed words at the starting of a new string and append the remaining words as it is in order. Examples: Input: Ashish Yadav Abhishek Rajput Sunil Pundir Output: ridnuP tupjaR vadaY Ashish
6 min read