# 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:  DEFGBCAHExplanation:         after 1st swap: DBCAEFGH         after 2nd swap: DECABFGH         after 3rd swap: DEFABCGH         after 4th swap: DEFGBCAHInput : S = "ABCDE", B = 10, C = 6;Output : ADEBCExplanation:         after 1st swap: BACDE         after 2nd swap: BCADE         after 3rd swap: BCDAE         after 4th swap: BCDEA         after 5th swap: ACDEB         after 6th swap: CADEB         after 7th swap: CDAEB         after 8th swap: CDEAB         after 9th swap: CDEBA         after 10th swap: ADEBC`

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

## C#

 `using` `System;`   `class` `Program` `{` `    ``// Function to swap characters in a string` `    ``static` `string` `SwapCharacters(``string` `s, ``int` `B, ``int` `C)` `    ``{` `        ``int` `N = s.Length;` `        ``// If C is greater than N, take the modulo to ensure it's within bounds` `        ``C = C % N;` `        ``// Loop to swap the ith element with (i + C) % N th element` `        ``for` `(``int` `i = 0; i < B; i++)` `        ``{` `            ``int` `j = (i + C) % N; ``// Calculate the index of the character to swap with` `            ``char` `temp = s[i]; ``// Store the character at index i in a temporary variable` `            ``// Replace character at index i with the character at index j` `            ``s = s.Remove(i, 1).Insert(i, s[j].ToString());` `            ``// Replace character at index j with the character stored in temp` `            ``s = s.Remove(j, 1).Insert(j, temp.ToString());` `        ``}` `        ``return` `s;` `    ``}`   `    ``static` `void` `Main()` `    ``{` `        ``string` `s = ``"ABCDEFGH"``;` `        ``int` `B = 4;` `        ``int` `C = 3;` `        ``s = SwapCharacters(s, B, C);` `        ``Console.WriteLine(s);` `    ``}` `}`

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

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