Open In App

# Replace every character of string by character whose ASCII value is K times more than it

Given string str consisting of lowercase letters only and an integer k, the task is to replace every character of the given string with a character whose ASCII value is k times more than it. If the ASCII value exceeds ‘z’, then start checking from ‘a’ in a cyclic manner.

Examples:

Input: str = “abc”, k = 2
Output: cde
Explanation:
a is moved by 2 times which results in character c
b is moved by 2 times which results in character d
c is moved by 2 times which results in character e

Input: str = “abc”, k = 28
Output: cde
Explanation:
a is moved 25 times, z is reached. Then 26th character will be a, 27-th b and 28-th c.
b is moved 24 times, z is reached. 28-th is d.
b is moved 23 times, z is reached. 28-th is e.

Approach: Iterate for every character in the string and perform the below steps for each character:

• Add k to the ASCII value of character str[i].
• If it exceeds 122, then perform a modulus operation of k with 26 to reduce the number of steps, as 26 is the maximum number of shifts that can be performed in a rotation.
• To find the character, add k to 96. Hence, the character with ASCII value k+96 will be a new character.

Repeat the above steps for every character of the given string.

Below is the implementation of the above approach:

## C++

 `// CPP program to move every character``// K times ahead in a given string``#include ``using` `namespace` `std;` `// Function to move string character``void` `encode(string s,``int` `k){` `    ``// changed string``    ``string newS;` `    ``// iterate for every characters``    ``for``(``int` `i=0; i 122){``            ``k -= (122-val);``            ``k = k % 26;``            ``newS += ``char``(96 + k);``        ``}``        ``else``            ``newS += ``char``(val + k);` `        ``k = dup;``    ``}` `    ``// print the new string``    ``cout<

## Java

 `// Java program to move every character``// K times ahead in a given string` `class` `GFG {` `// Function to move string character``    ``static` `void` `encode(String s, ``int` `k) {` `        ``// changed string``        ``String newS = ``""``;` `        ``// iterate for every characters``        ``for` `(``int` `i = ``0``; i < s.length(); ++i) {``            ``// ASCII value``            ``int` `val = s.charAt(i);``            ``// store the duplicate``            ``int` `dup = k;` `            ``// if k-th ahead character exceed 'z'``            ``if` `(val + k > ``122``) {``                ``k -= (``122` `- val);``                ``k = k % ``26``;``                ` `                ``newS += (``char``)(``96` `+ k);``            ``} ``else` `{``                ``newS += (``char``)(val + k);``            ``}` `            ``k = dup;``        ``}` `        ``// print the new string``        ``System.out.println(newS);``    ``}` `// Driver Code``    ``public` `static` `void` `main(String[] args) {``        ``String str = ``"abc"``;``        ``int` `k = ``28``;` `        ``// function call``        ``encode(str, k);``    ``}``}` `// This code is contributed by Rajput-JI`

## Python3

 `# Python program to move every character``# K times ahead in a given string` `# Function to move string character``def` `encode(s, k):``    ` `    ``# changed string``    ``newS ``=` `""``    ` `    ``# iterate for every characters``    ``for` `i ``in` `range``(``len``(s)):``        ` `        ``# ASCII value``        ``val ``=` `ord``(s[i])``        ` `        ``# store the duplicate``        ``dup ``=` `k``        ` `        ``# if k-th ahead character exceed 'z'``        ``if` `val ``+` `k>``122``:``            ``k ``-``=` `(``122``-``val)``            ``k ``=` `k ``%` `26``            ``newS ``+``=` `chr``(``96` `+` `k)``            ` `        ``else``:``            ``newS ``+``=` `chr``(val ``+` `k)``        ` `        ``k ``=` `dup``    ` `    ``# print the new string``    ``print` `(newS)``            ` `# driver code    ``str` `=` `"abc"``k ``=` `28` `encode(``str``, k)`

## C#

 `// C# program to move every character``// K times ahead in a given string``using` `System;``public` `class` `GFG {` `// Function to move string character``    ``static` `void` `encode(String s, ``int` `k) {` `        ``// changed string``        ``String newS = ``""``;` `        ``// iterate for every characters``        ``for` `(``int` `i = 0; i < s.Length; ++i) {``            ``// ASCII value``            ``int` `val = s[i];``            ``// store the duplicate``            ``int` `dup = k;` `            ``// if k-th ahead character exceed 'z'``            ``if` `(val + k > 122) {``                ``k -= (122 - val);``                ``k = k % 26;``                ` `                ``newS += (``char``)(96 + k);``            ``} ``else` `{``                ``newS += (``char``)(96 + k);``            ``}` `            ``k = dup;``        ``}` `        ``// print the new string``        ``Console.Write(newS);``    ``}` `// Driver Code``    ``public` `static` `void` `Main() {``        ``String str = ``"abc"``;``        ``int` `k = 28;` `        ``// function call``        ``encode(str, k);``    ``}``}` `// This code is contributed by Rajput-JI`

## Javascript

 ``

## PHP

 ` 122)``        ``{``            ``\$k` `-= (122 - ``\$val``);``            ``\$k` `= ``\$k` `% 26;``            ``\$newS` `= ``\$newS``.``chr``(96 + ``\$k``);``        ``}``        ``else``            ``\$newS` `= ``\$newS``.``chr``(``\$val` `+ ``\$k``);` `        ``\$k` `= ``\$dup``;``    ``}` `    ``// print the new string``    ``echo` `\$newS``;``}` `// Driver code` `\$str` `= ``"abc"``;``\$k` `= 28;` `// function call``encode(``\$str``, ``\$k``);` `// This code is contributed by ita_c``?>`

Output

```cde

```

Complexity Analysis:

• Time Complexity: O(N), as we are using a loop to traverse N times so it will cost us O(N) time, where N is the length of the string.
• Auxiliary Space: O(N)

### Approach: Using modular arithmetic

Steps:

• Convert the input string to a list of characters.
• Iterate over each character in the list.
• Calculate the new ASCII value by adding k to the ASCII value of the current character.
• If the new ASCII value exceeds the ASCII value of ‘z’, wrap around to ‘a’ by subtracting 26.
• Replace the current character in the list with the character corresponding to the new ASCII value.
• Convert the list of characters back to a string
• Return it as the result.

Below is the implementation of the above approach:

## C++

 `#include ``#include ``using` `namespace` `std;` `// Function to replace characters in a string``string replaceCharacters(string str, ``int` `k) {``    ``// Iterate over each character in the string``    ``for` `(``int` `i = 0; i < str.length(); ++i) {``        ``int` `asciiVal = (str[i] - ``'a'` `+ k) % 26 + ``'a'``; ``// Calculate the new ASCII value``        ``str[i] = ``static_cast``<``char``>(asciiVal); ``// Update the character``    ``}` `    ``return` `str; ``// Return the modified string``}``// Driver Code``int` `main() {``    ``string inputStr = ``"abc"``;``    ``int` `kValue = 2;``    ``string outputStr = replaceCharacters(inputStr, kValue);``    ``cout << outputStr << endl;``    ``return` `0;``}`

## Java

 `public` `class` `GFG {` `    ``public` `static` `String replaceCharacters(String str, ``int` `k) {``        ``// Convert the string to a character array``        ``char``[] charArray = str.toCharArray();` `        ``// Iterate over each character in the array``        ``for` `(``int` `i = ``0``; i < charArray.length; ++i) {``            ``int` `asciiVal = (charArray[i] - ``'a'` `+ k) % ``26` `+ ``'a'``;``            ``charArray[i] = (``char``) asciiVal;``        ``}` `        ``// Convert the character array back to a string``        ``return` `new` `String(charArray);``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``String inputStr = ``"abc"``;``        ``int` `kValue = ``2``;``        ``String outputStr = replaceCharacters(inputStr, kValue);``        ``System.out.println(outputStr);``    ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Python

 `# Python program to move every character``# K times ahead in a given string`  `def` `replace_characters(string, k):``  ` `    ``# Convert the string to a list of characters``    ``char_list ``=` `list``(string)``    ` `    ``# Iterate over each character in the list``    ``for` `i ``in` `range``(``len``(char_list)):``        ``ascii_val ``=` `(``ord``(char_list[i]) ``-` `ord``(``'a'``) ``+` `k) ``%` `26` `+` `ord``(``'a'``)``        ``char_list[i] ``=` `chr``(ascii_val)``        ` `    ``# Convert the list of characters back to a string``    ``return` `"".join(char_list)`  `# Driver Code``input_str ``=` `"abc"``k_value ``=` `2``output_str ``=` `replace_characters(input_str, k_value)``print``(output_str)`

Output

```cde

```

Time Complexity: O(n), where n is the length of the input string.

Auxiliary Space: O(n)