Skip to content
Related Articles
Modify a string by performing given shift operations
• Difficulty Level : Basic
• Last Updated : 12 Jun, 2021

Given a string S containing lowercase English alphabets, and a matrix shift[][] consisting of pairs of the form{direction, amount}, where the direction can be 0 (for left shift) or 1 (for right shift) and the amount is the number of indices by which the string S is required to be shifted. The task is to return the modified string that can be obtained after performing the given operations.
Note: A left shift by 1 refers to removing the first character of S and append it to the end. Similarly, a right shift by 1 refers to removing the last character of S and insert at the beginning.

Examples

Input: S = “abc”, shift[][] = {{0, 1}, {1, 2}}
Output: cab
Explanation:
[0, 1] refers to shifting  S to the left by 1. Therefore, the string S modifies from “abc” to “bca”.
[1, 2] refers to shifting  S to the right by 1. Therefore, the string S modifies from “bca”to “cab”.

Input: S = “abcdefg”, shift[][] = { {1, 1}, {1, 1}, {0, 2}, {1, 3} }
Output: efgabcd
Explanation:
[1, 1] refers to shifting S to the right by 1. Therefore, the string S modifies from “abcdefg” to “gabcdef”.
[1, 1] refers to shifting S to the right by 1. Therefore, the string S modifies from “gabcdef” to “fgabcde”.
[0, 2] refers to shifting S to the left by 2. Therefore, the string S modifies from “fgabcde” to “abcdefg”.
[1, 3] refers to shifting S to the right by 3. Therefore, the string S modifies from “abcdefg” to “efgabcd”.

Naive Approach: The simplest approach to solve the problem is to traverse the matrix shift[][] and shift S by amount number of indices in the specified direction. After completing all shift operations, print the final string obtained.
Time Complexity: O(N2)
Auxiliary space: O(N)

Efficient Approach: To optimize the above approach, follow the steps below:

• Initialize a variable, say val, to store the effective shifts.
• Traverse the matrix shift[][] and perform the following operations on every ith row:
• If shift[i] = 0 (left shift), then decrease val by -shift[i].
• Otherwise (left shift), increase val by shift[i].
• Update val =  val % len (for further optimizing the effective shifts).
• Initialize a string, result = “”, to store the modified string.
• Now, check if val > 0. If found to be true, then perform the right rotation on the string by val.
• Otherwise, perform left rotation of the string by |val| amount.
• Print the result.

Below is the implementation of the above approach:

## C++

 `// C++ implementataion``// of above approach``#include ``using` `namespace` `std;` `// Function to find the string obtained``// after performing given shift operations``void` `stringShift(string s,``                 ``vector >& shift)``{` `    ``int` `val = 0;` `    ``for` `(``int` `i = 0; i < shift.size(); ++i)` `        ``// If shift[i] = 0, then left shift``        ``// Otherwise, right shift``        ``val += shift[i] == 0``                   ``? -shift[i]``                   ``: shift[i];` `    ``// Stores length of the string``    ``int` `len = s.length();` `    ``// Effective shift calculation``    ``val = val % len;` `    ``// Stores modified string``    ``string result = ``""``;` `    ``// Right rotation``    ``if` `(val > 0)``        ``result = s.substr(len - val, val)``                 ``+ s.substr(0, len - val);` `    ``// Left rotation``    ``else``        ``result``            ``= s.substr(-val, len + val)``              ``+ s.substr(0, -val);` `    ``cout << result;``}` `// Driver Code``int` `main()``{``    ``string s = ``"abc"``;``    ``vector > shift = {``        ``{ 0, 1 },``        ``{ 1, 2 }``    ``};` `    ``stringShift(s, shift);` `    ``return` `0;``}`

## Java

 `// Java implementataion``// of above approach``import` `java.io.*;``class` `GFG``{` `  ``// Function to find the string obtained``  ``// after performing given shift operations``  ``static` `void` `stringShift(String s, ``int``[][] shift)``  ``{``    ``int` `val = ``0``;``    ``for` `(``int` `i = ``0``; i < shift.length; ++i)` `      ``// If shift[i] = 0, then left shift``      ``// Otherwise, right shift``      ``if` `(shift[i][``0``] == ``0``)``        ``val -= shift[i][``1``];``    ``else``      ``val += shift[i][``1``];` `    ``// Stores length of the string``    ``int` `len = s.length();` `    ``// Effective shift calculation``    ``val = val % len;` `    ``// Stores modified string``    ``String result = ``""``;` `    ``// Right rotation``    ``if` `(val > ``0``)``      ``result = s.substring(len - val, (len - val) + val)``      ``+ s.substring(``0``, len - val);` `    ``// Left rotation``    ``else``      ``result = s.substring(-val, len + val)``      ``+ s.substring(``0``, -val);` `    ``System.out.println(result);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``String s = ``"abc"``;``    ``int``[][] shift``      ``= ``new` `int``[][] {{ ``0``, ``1` `}, { ``1``, ``2` `}};` `    ``stringShift(s, shift);``  ``}``}` `// This code is contributed by Dharanendra L V`

## C#

 `// C# implementataion``// of above approach``using` `System;` `public` `class` `GFG``{` `  ``// Function to find the string obtained``  ``// after performing given shift operations``  ``static` `void` `stringShift(String s, ``int``[,] shift)``  ``{``    ``int` `val = 0;``    ``for` `(``int` `i = 0; i < shift.GetLength(0); ++i)` `      ``// If shift[i,0] = 0, then left shift``      ``// Otherwise, right shift``      ``if` `(shift[i,0] == 0)``        ``val -= shift[i, 1];``    ``else``      ``val += shift[i, 1];` `    ``// Stores length of the string``    ``int` `len = s.Length;` `    ``// Effective shift calculation``    ``val = val % len;` `    ``// Stores modified string``    ``String result = ``""``;` `    ``// Right rotation``    ``if` `(val > 0)``      ``result = s.Substring(len - val, val)``      ``+ s.Substring(0, len - val);` `    ``// Left rotation``    ``else``      ``result = s.Substring(-val, len)``      ``+ s.Substring(0, -val);` `    ``Console.WriteLine(result);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``String s = ``"abc"``;``    ``int``[,] shift``      ``= ``new` `int``[,] {{ 0, 1 }, { 1, 2 }};` `    ``stringShift(s, shift);``  ``}``}` `// This code contributed by shikhasingrajput`

## Javascript

 ``

Output:
`cab`

Time Complexity: O(N)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up