# Shift all prefixes by given lengths

Given a string S containing letters and digits, and an integer array Shift where, and for each element of Shift array . The task is, for each Shift[i] = X, you have to shift the first i+1 letters of S, X times. Return the final string after all applying all such shift to S.

Note : Shift means cyclically increment ASCII value.

Examples:

Input: S = “abc789”, Shift = [2, 5, 9]
Output: “qpl706”
Explanation: Starting with “abc”.
After shifting the first 1 letters of S by 2, we have “cbc”.
After shifting the first 2 letters of S by 5, we have “hgc”.
After shifting the first 3 letters of S by 9, we have “qpl”.

Input : S = “geeksforgeeks”, Shift[] = [ 11, 10000, 9999999 ]
Output : qdnyulaufkuug

Approach: The i-th character of S is shifted Shift[i] + Shift[i+1] + … + Shift[Shift.length – 1] times.
So we update the Shift array backwards to know exact number of shifts to be applied to each element of string S.

Now,

• Traverse the given text (S) one character at a time .
• For each character, transform the given character as per the rule, i:e apply shift, Shift[i] times .
• Return the new string generated.
• ## C++

 // CPP implementation of above approach  #include  using namespace std;     // Function to find S after shifting each letter  string shift_S(string S, int Shift[], int n)  {      // update shift array for each element      for (int i = n - 2; i >= 0; --i)          Shift[i] += Shift[i + 1];         // finding the new shifted string      string result = "";         // traverse S and shift letters according to shift array      for (int i = 0; i < S.length(); i++) {             // For upper letters          if (isupper(S[i])) {              result += char((int(S[i]) + Shift[i] - 'A') % 26 + 'A');          }             // For lower letters          else if (islower(S[i])) {                          result += char((int(S[i]) + Shift[i] - 'a') % 26 + 'a');          }             // For digits          else {                          result += char((int(S[i]) + Shift[i] - '0') % 10 + '0');          }      }         // Return the shifted string      return result;  }     // Driver program  int main()  {      string S = "abc";      int Shift[] = { 2, 5, 9 };         int n = sizeof(Shift) / sizeof(Shift[0]);         // function call to print required answer      cout << shift_S(S, Shift, n);         return 0;  }     // This code is written by Sanjit_Prasad

## Java

 // Java implementation of the above approach      public class GfG{                 // Function to find S after shifting each letter       public static String shift_S(String S, int Shift[], int n)       {           // update shift array for each element           for (int i = n - 2; i >= 0; --i)               Shift[i] += Shift[i + 1];                    // finding the new shifted string           String result = "";                    // traverse S and shift letters according to shift array           for (int i = 0; i < S.length(); i++) {                        // For upper letters               if (Character.isUpperCase(S.charAt(i))) {                   result += (char)(((int)(S.charAt(i)) + Shift[i] - 'A') % 26 + 'A');               }                        // For lower letters               else if (Character.isLowerCase(S.charAt(i))) {                               result += (char)(((int)(S.charAt(i)) + Shift[i] - 'a') % 26 + 'a');               }                        // For digits               else {                               result += (char)(((int)(S.charAt(i)) + Shift[i] - '0') % 10 + '0');               }           }                    // Return the shifted string           return result;       }           public static void main(String []args){                     String S = "abc";           int Shift[] = { 2, 5, 9 };           int n = Shift.length;                     // Function call to print the required answer           System.out.println(shift_S(S, Shift, n));       }  }       // This code is contributed by Rituraj Jain

## Python3

 # Python3 implementation of above approach     # Function to find S after shifting  # each letter  def shift_S(S, Shift, n):             # update shift array for       # each element      for i in range(n - 2, -1, -1):          Shift[i] = Shift[i] + Shift[i + 1]             # finding the new shifted string      result = ""             # traverse S and shift letters      # according to shift array      for i in range(len(S)):                     # For upper letters          if(S[i].isupper()):              result = result + chr((ord(S[i]) + Shift[i] -                                     ord('A')) % 26 + ord('A'))                         # For lower letters          elif (S[i].islower()):              result = result + chr((ord(S[i]) + Shift[i] -                                     ord('a')) % 26 + ord('a'))                     # For digits          else:              result = result + chr((ord(S[i]) + Shift[i] -                                     ord('0')) % 10 + ord('0'))                 # Return the shifted string      return result      # Driver Code  S = "abc" Shift = [2, 5, 9]  n = len(Shift)     # Function call to print the required answer  print(shift_S(S, Shift, n))     # This code is contributed   # by Shashank_Sharma

Output:

qpl


Time Complexity: O(N), where N is the length of string S.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.