Shift all prefixes by given lengths

Given a string S containing letters and digits, and an integer array Shift where, 1 \leq S.length()=length(Shift) \leq 10^{5} and for each element of Shift array 0 \leq Shift[i] \leq 10^{9}. 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++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // CPP implementation of above approach
    #include <bits/stdc++.h>
    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

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # 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

    chevron_right

    
    

    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.