# Java Program to 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**.

**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:

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

**Output:**

CADEFGHIJKB

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

Please refer complete article on Swap characters in a String for more details!