Given a string S containing letters and digits, and an integer array Shift where,
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 backward to know the 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.
Below is the implementation of the above approach:
// 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 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 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# 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 |
<script> // JavaScript implementation of above approach // Function to find S after shifting // each letter function shift_S(S, Shift, n){
// update shift array for
// each element
for (let i = n - 2;i>=0;i--){
Shift[i] = Shift[i] + Shift[i + 1]
}
// finding the new shifted string
let result = ""
// traverse S and shift letters
// according to shift array
for (let i=0;i<S.length;i++){
// For upper letters
if (S.charCodeAt(i) >= 65 && S.charCodeAt(i) <= 90)
result = result + String.fromCharCode((S.charCodeAt(i) + Shift[i] - 'A' .charCodeAt(0)) % 26 + 'A' .charCodeAt(0))
// For lower letters
else if (S.charCodeAt(i) >= 97 && S.charCodeAt(i) <= 122)
result = result + String.fromCharCode((S.charCodeAt(i) + Shift[i] - 'a' .charCodeAt(0)) % 26 + 'a' .charCodeAt(0))
// For digits
else
result = result + String.fromCharCode((S.charCodeAt(i) + Shift[i] - '0' .charCodeAt(0)) % 26 + '0' .charCodeAt(0))
}
// Return the shifted string
return result
} // Driver Code let S = "abc"
let Shift = [2, 5, 9] let n = Shift.length // Function call to print the required answer document.write(shift_S(S, Shift, n)) // This code is contributed // by Shinjanpatra </script> |
Output:
qpl
Time Complexity: O(N), where N is the length of string S.
Auxiliary Space: O(N)