# 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)`

## C#

 `using` `System;`   `class` `Program {` `    ``// Function to replace characters in a string` `    ``static` `string` `ReplaceCharacters(``string` `str, ``int` `k)` `    ``{` `        ``// Create a character array to store the modified` `        ``// characters` `        ``char``[] modifiedChars = ``new` `char``[str.Length];`   `        ``// 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` `            ``modifiedChars[i]` `                ``= (``char``)asciiVal; ``// Update the character in` `                                  ``// the array` `        ``}`   `        ``// Create a new string from the modified character` `        ``// array` `        ``string` `modifiedStr = ``new` `string``(modifiedChars);`   `        ``return` `modifiedStr; ``// Return the modified string` `    ``}`   `    ``// Driver Code` `    ``static` `void` `Main()` `    ``{` `        ``string` `inputStr = ``"abc"``;` `        ``int` `kValue = 2;` `        ``string` `outputStr` `            ``= ReplaceCharacters(inputStr, kValue);` `        ``Console.WriteLine(outputStr);` `    ``}` `}`

## Javascript

 `// Function to replace characters in a string` `function` `replaceCharacters(str, k) {` `    ``// Iterate over each character in the string` `    ``for` `(let i = 0; i < str.length; i++) {` `        ``let charCode = str.charCodeAt(i);` `        ``let newCharCode = ((charCode - ``'a'``.charCodeAt(0) + k) % 26) + ``'a'``.charCodeAt(0); ``// Calculate the new character code` `        ``str = str.substring(0, i) + String.fromCharCode(newCharCode) + str.substring(i + 1); ``// Update the character` `    ``}`   `    ``return` `str; ``// Return the modified string` `}`   `// Driver Code` `let inputStr = ``"abc"``;` `let kValue = 2;` `let outputStr = replaceCharacters(inputStr, kValue);` `console.log(outputStr);`   `// This code is contributed by shivamgupta0987654321`

Output

```cde

```

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

Auxiliary Space: O(n)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next