GFG App
Open App
Browser
Continue

# Swap characters in a String

Given a String S of length N, two integers B and C, the task is to traverse characters starting from the beginning, swapping a character with the character after C places from it, i.e. swap characters at position i and (i + C)%N. Repeat this process B times, advancing one position at a time. Your task is to find the final String after B swaps.

Examples:

```Input : S = "ABCDEFGH", B = 4, C = 3;
Output:  DEFGBCAH
Explanation:
after 1st swap: DBCAEFGH
after 2nd swap: DECABFGH
after 3rd swap: DEFABCGH
after 4th swap: DEFGBCAH

Input : S = "ABCDE", B = 10, C = 6;
Explanation:
after 1st swap: BACDE
after 3rd swap: BCDAE
after 4th swap: BCDEA
after 5th swap: ACDEB
after 7th swap: CDAEB
after 8th swap: CDEAB
after 9th swap: CDEBA

### Naive Approach:

• For large values of B, the naive approach of looping B times, each time swapping ith character with (i + C)%N-th character will result in high CPU time.
• The trick to solving this problem is to observe the resultant string after every N iterations, where N is the length of the string S.
• Again, if C is greater than or equal to the N, it is effectively equal to the remainder of C divided by N.
• Hereon, let’s consider C to be less than N.

Below is the implementation of the approach:

## C++

 `// C++ Program to Swap characters in a String` `#include ` `#include `   `using` `namespace` `std;`   `string swapCharacters(string s, ``int` `B, ``int` `C)` `{` `    ``int` `N = s.size();` `    ``// If c is greater than n` `    ``C = C % N;` `    ``// loop to swap ith element with (i + C) % n th element` `    ``for` `(``int` `i = 0; i < B; i++) {` `        ``swap(s[i], s[(i + C) % N]);` `    ``}` `    ``return` `s;` `}`   `int` `main()` `{` `    ``string s = ``"ABCDEFGH"``;` `    ``int` `B = 4;` `    ``int` `C = 3;` `    ``s = swapCharacters(s, B, C);` `    ``cout << s << endl;` `    ``return` `0;` `}`   `// This code is contributed by Susobhan Akhuli`

## Java

 `// Java Program to Swap characters in a String` `import` `java.util.*;`   `public` `class` `Main {` `    ``public` `static` `String swapCharacters(String s, ``int` `B,` `                                        ``int` `C)` `    ``{` `        ``int` `N = s.length();` `        ``// If c is greater than n` `        ``C = C % N;` `        ``// loop to swap ith element with (i + C) % n th` `        ``// element` `        ``char``[] arr = s.toCharArray();` `        ``for` `(``int` `i = ``0``; i < B; i++) {` `            ``char` `temp = arr[i];` `            ``arr[i] = arr[(i + C) % N];` `            ``arr[(i + C) % N] = temp;` `        ``}` `        ``return` `new` `String(arr);` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``String s = ``"ABCDEFGH"``;` `        ``int` `B = ``4``;` `        ``int` `C = ``3``;` `        ``s = swapCharacters(s, B, C);` `        ``System.out.println(s);` `    ``}` `}`   `// This code is contributed by Susobhan Akhuli`

## Python3

 `# Python Program to Swap characters in a String` `def` `swapCharacters(s, B, C):` `    ``N ``=` `len``(s)` `    ``# If c is greater than n` `    ``C ``=` `C ``%` `N` `    ``# loop to swap ith element with (i + C) % n th element` `    ``s ``=` `list``(s)` `    ``for` `i ``in` `range``(B):` `        ``s[i], s[(i ``+` `C) ``%` `N] ``=` `s[(i ``+` `C) ``%` `N], s[i]` `    ``return` `''.join(s)`   `# Driver code` `s ``=` `"ABCDEFGH"` `B ``=` `4` `C ``=` `3` `s ``=` `swapCharacters(s, B, C)` `print``(s)`   `# This code is contributed by Susobhan Akhuli`

## Javascript

 `// JS Program to Swap characters in a String` `function` `swapCharacters(s, B, C) {` `    ``const N = s.length;` `    `  `    ``// If c is greater than n` `    ``C = C % N;` `    `  `    ``// loop to swap ith element with (i + C) % n th element` `    ``for` `(let i = 0; i < B; i++) {` `        ``const temp = s[i];` `        ``s = s.substring(0, i) + s[(i + C) % N] + s.substring(i + 1);` `        ``s = s.substring(0, (i + C) % N) + temp + s.substring((i + C) % N + 1);` `    ``}` `    ``return` `s;` `}`   `let s = ``"ABCDEFGH"``;` `const B = 4;` `const C = 3;` `s = swapCharacters(s, B, C);` `console.log(s);`

Output

`DEFGBCAH`

Time Complexity: O(B), to iterate B times.
Auxiliary Space: O(1)

### Efficient Approach:

• If we observe the string that is formed after every N successive iterations and swaps (let’s call it one full iteration), we can start to get a pattern.
• We can find that the string is divided into two parts: the first part of length C comprising of the first C characters of S, and the second part comprising of the rest of the characters.
• The two parts are rotated by some places. The first part is rotated right by (N % C) places every full iteration.
• The second part is rotated left by C places every full iteration.
• We can calculate the number of full iterations f by dividing B by N.
• So, the first part will be rotated left by ( N % C ) * f . This value can go beyond C and so, it is effectively ( ( N % C ) * f ) % C, i.e. the first part will be rotated by ( ( N % C ) * f ) % C places left.
• The second part will be rotated left by C * f places. Since, this value can go beyond the length of the second part which is ( N – C ), it is effectively ( ( C * f ) % ( N – C ) ), i.e. the second part will be rotated by ( ( C * f ) % ( N – C ) ) places left.
• After f full iterations, there may still be some iterations remaining to complete B iterations. This value is B % N which is less than N. We can follow the naive approach on these remaining iterations after f full iterations to get the resultant string.

Example:
s = ABCDEFGHIJK; c = 4;
parts: ABCD EFGHIJK
after 1 full iteration: DABC IJKEFGH
after 2 full iteration: CDAB FGHIJKE
after 3 full iteration: BCDA JKEFGHI
after 4 full iteration: ABCD GHIJKEF
after 5 full iteration: DABC KEFGHIJ
after 6 full iteration: CDAB HIJKEFG
after 7 full iteration: BCDA EFGHIJK
after 8 full iteration: ABCD IJKEFGH

Below is the implementation of the approach:

## C++

 `// C++ program to find new after swapping` `// characters at position i and i + c` `// b times, each time advancing one` `// position ahead` `#include ` `using` `namespace` `std;`   `string rotateLeft(string s, ``int` `p)` `{` `    `  `    ``// Rotating a string p times left is` `    ``// effectively cutting the first p` `    ``// characters and placing them at the end` `    ``return` `s.substr(p) + s.substr(0, p);` `}`   `// Method to find the required string` `string swapChars(string s, ``int` `c, ``int` `b)` `{` `    `  `    ``// Get string length` `    ``int` `n = s.size();` `    `  `    ``// If c is larger or equal to the length of` `    ``// the string is effectively the remainder of` `    ``// c divided by the length of the string` `    ``c = c % n;` `    `  `    ``if` `(c == 0)` `    ``{` `        `  `        ``// No change will happen` `        ``return` `s;` `    ``}` `    ``int` `f = b / n;` `    ``int` `r = b % n;` `    `  `    ``// Rotate first c characters by (n % c)` `    ``// places f times` `    ``string p1 = rotateLeft(s.substr(0, c),` `                  ``((n % c) * f) % c);` `                  `  `    ``// Rotate remaining character by` `    ``// (n * f) places` `    ``string p2 = rotateLeft(s.substr(c),` `                  ``((c * f) % (n - c)));` `                  `  `    ``// Concatenate the two parts and convert the` `    ``// resultant string formed after f full` `    ``// iterations to a string array` `    ``// (for final swaps)` `    ``string a = p1 + p2;` `    `  `    ``// Remaining swaps` `    ``for``(``int` `i = 0; i < r; i++)` `    ``{` `        `  `        ``// Swap ith character with` `        ``// (i + c)th character` `        ``char` `temp = a[i];` `        ``a[i] = a[(i + c) % n];` `        ``a[(i + c) % n] = temp;` `    ``}` `    `  `    ``// Return final string` `    ``return` `a;` `}`   `// Driver code` `int` `main() ` `{` `    `  `    ``// Given values` `    ``string s1 = ``"ABCDEFGHIJK"``;` `    ``int` `b = 1000;` `    ``int` `c = 3;` `    `  `    ``// Get final string print final string` `    ``cout << swapChars(s1, c, b) << endl;` `}`   `// This code is contributed by rag2127`

## Java

 `// Java Program to find new after swapping` `// characters at position i and i + c` `// b times, each time advancing one` `// position ahead`   `class` `GFG {` `    ``// Method to find the required string`   `    ``String swapChars(String s, ``int` `c, ``int` `b)` `    ``{` `        ``// Get string length` `        ``int` `n = s.length();`   `        ``// if c is larger or equal to the length of` `        ``// the string is effectively the remainder of` `        ``// c divided by the length of the string` `        ``c = c % n;`   `        ``if` `(c == ``0``) {` `            ``// No change will happen` `            ``return` `s;` `        ``}`   `        ``int` `f = b / n;` `        ``int` `r = b % n;`   `        ``// Rotate first c characters by (n % c)` `        ``// places f times` `        ``String p1 = rotateLeft(s.substring(``0``, c),` `                               ``((n % c) * f) % c);`   `        ``// Rotate remaining character by` `        ``// (n * f) places` `        ``String p2 = rotateLeft(s.substring(c),` `                               ``((c * f) % (n - c)));`   `        ``// Concatenate the two parts and convert the` `        ``// resultant string formed after f full` `        ``// iterations to a character array` `        ``// (for final swaps)` `        ``char` `a[] = (p1 + p2).toCharArray();`   `        ``// Remaining swaps` `        ``for` `(``int` `i = ``0``; i < r; i++) {`   `            ``// Swap ith character with` `            ``// (i + c)th character` `            ``char` `temp = a[i];` `            ``a[i] = a[(i + c) % n];` `            ``a[(i + c) % n] = temp;` `        ``}`   `        ``// Return final string` `        ``return` `new` `String(a);` `    ``}`   `    ``String rotateLeft(String s, ``int` `p)` `    ``{` `        ``// Rotating a string p times left is` `        ``// effectively cutting the first p` `        ``// characters and placing them at the end` `        ``return` `s.substring(p) + s.substring(``0``, p);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``// Given values` `        ``String s1 = ``"ABCDEFGHIJK"``;` `        ``int` `b = ``1000``;` `        ``int` `c = ``3``;`   `        ``// get final string` `        ``String s2 = ``new` `GFG().swapChars(s1, c, b);`   `        ``// print final string` `        ``System.out.println(s2);` `    ``}` `}`

## Python3

 `# Python3 program to find new after swapping ` `# characters at position i and i + c ` `# b times, each time advancing one ` `# position ahead `   `# Method to find the required string ` `def` `swapChars(s, c, b):` `    `  `    ``# Get string length ` `    ``n ``=` `len``(s)` `    `  `    ``# If c is larger or equal to the length of ` `    ``# the string is effectively the remainder of ` `    ``# c divided by the length of the string ` `    ``c ``=` `c ``%` `n` `    `  `    ``if` `(c ``=``=` `0``):` `        `  `        ``# No change will happen ` `        ``return` `s` `        `  `    ``f ``=` `int``(b ``/` `n)` `    ``r ``=` `b ``%` `n` `    `  `    ``# Rotate first c characters by (n % c) ` `    ``# places f times ` `    ``p1 ``=` `rotateLeft(s[``0` `: c], ((c ``*` `f) ``%` `(n ``-` `c)))` `    `  `    ``# Rotate remaining character by ` `    ``# (n * f) places ` `    ``p2 ``=` `rotateLeft(s[c:], ((c ``*` `f) ``%` `(n ``-` `c)))` `    `  `    ``# Concatenate the two parts and convert the ` `    ``# resultant string formed after f full ` `    ``# iterations to a character array ` `    ``# (for final swaps) ` `    ``a ``=` `p1 ``+` `p2` `    ``a ``=` `list``(a)` `    `  `    ``# Remaining swaps ` `    ``for` `i ``in` `range``(r):` `        `  `        ``# Swap ith character with ` `        ``# (i + c)th character ` `        ``temp ``=` `a[i]` `        ``a[i] ``=` `a[(i ``+` `c) ``%` `n]` `        ``a[(i ``+` `c) ``%` `n] ``=` `temp`   `    ``# Return final string ` `    ``return` `str``("".join(a))`   `def` `rotateLeft(s, p):` `    `  `    ``# Rotating a string p times left is ` `    ``# effectively cutting the first p ` `    ``# characters and placing them at the end ` `    ``return` `s[p:] ``+` `s[``0` `: p]`   `# Driver code `   `# Given values ` `s1 ``=` `"ABCDEFGHIJK"` `b ``=` `1000` `c ``=` `3`   `# Get final string ` `s2 ``=` `swapChars(s1, c, b)`   `# Print final string ` `print``(s2)`   `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# Program to find new after swapping` `// characters at position i and i + c` `// b times, each time advancing one` `// position ahead` `using` `System;`   `class` `GFG` `{` `    ``// Method to find the required string` `    ``String swapChars(String s, ``int` `c, ``int` `b)` `    ``{` `        ``// Get string length` `        ``int` `n = s.Length;`   `        ``// if c is larger or equal to the length of` `        ``// the string is effectively the remainder of` `        ``// c divided by the length of the string` `        ``c = c % n;`   `        ``if` `(c == 0)` `        ``{` `            ``// No change will happen` `            ``return` `s;` `        ``}`   `        ``int` `f = b / n;` `        ``int` `r = b % n;`   `        ``// Rotate first c characters by (n % c)` `        ``// places f times` `        ``String p1 = rotateLeft(s.Substring(0, c),` `                            ``((n % c) * f) % c);`   `        ``// Rotate remaining character by` `        ``// (n * f) places` `        ``String p2 = rotateLeft(s.Substring(c),` `                            ``((c * f) % (n - c)));`   `        ``// Concatenate the two parts and convert the` `        ``// resultant string formed after f full` `        ``// iterations to a character array` `        ``// (for readonly swaps)` `        ``char` `[]a = (p1 + p2).ToCharArray();`   `        ``// Remaining swaps` `        ``for` `(``int` `i = 0; i < r; i++) ` `        ``{`   `            ``// Swap ith character with` `            ``// (i + c)th character` `            ``char` `temp = a[i];` `            ``a[i] = a[(i + c) % n];` `            ``a[(i + c) % n] = temp;` `        ``}`   `        ``// Return readonly string` `        ``return` `new` `String(a);` `    ``}`   `    ``String rotateLeft(String s, ``int` `p)` `    ``{` `        `  `        ``// Rotating a string p times left is` `        ``// effectively cutting the first p` `        ``// characters and placing them at the end` `        ``return` `s.Substring(p) + s.Substring(0, p);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String []args)` `    ``{` `        ``// Given values` `        ``String s1 = ``"ABCDEFGHIJK"``;` `        ``int` `b = 1000;` `        ``int` `c = 3;`   `        ``// get readonly string` `        ``String s2 = ``new` `GFG().swapChars(s1, c, b);`   `        ``// print readonly string` `        ``Console.WriteLine(s2);` `    ``}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`CADEFGHIJKB`

Time Complexity: O(n)
Space Complexity: O(n)

My Personal Notes arrow_drop_up