Skip to content
Related Articles

Related Articles

Improve Article
Shift all prefixes by given lengths
  • Difficulty Level : Easy
  • Last Updated : 16 Sep, 2020

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




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

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

C#




// C# implementation of the above approach 
using System;
  
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 (Char.IsUpper(S[i])) 
        
            result += (char)(((int)(S[i]) + 
                     Shift[i] - 'A') % 26 + 'A'); 
        
      
        // For lower letters 
        else if (Char.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 code
public static void Main()
    string S = "abc"
    int[] Shift = { 2, 5, 9 }; 
    int n = Shift.Length; 
      
    // Function call to print 
    // the required answer 
    Console.WriteLine(shift_S(S, Shift, n)); 
}
  
// This code is contributed by sanjoy_62
Output: 



qpl

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

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 Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :