# 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 to the left by some places. The first part is rotated by
**(N % C)**places every full iteration. - The second part is rotated 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); ` ` ` `} ` `} ` |

*chevron_right*

*filter_none*

**Output:**

CADEFGHIJKB

**Time Complexity**: O(n)

**Space Complexity**: O(n)

## Recommended Posts:

- C program to swap adjacent characters of a String
- Swap all occurrences of two characters to get lexicographically smallest string
- Java program to swap first and last characters of words in a sentence
- Rearrange the characters of the string such that no two adjacent characters are consecutive English alphabets
- Permutation of a string with maximum number of characters greater than its adjacent characters
- Min flips of continuous characters to make all characters same in a string
- String with k distinct characters and no same characters adjacent
- Lexicographically smallest string formed by appending a character from the first K characters of a given string
- Minimal moves to form a string by adding characters or appending string itself
- Create a new string by alternately combining the characters of two halves of the string in reverse
- Lexicographically smallest string formed by appending a character from first K characters of a string | Set 2
- Minimum deletions from string to reduce it to string with at most 2 unique characters
- Count of times second string can be formed from the characters of first string
- Find the smallest window in a string containing all characters of another string
- Length of longest consecutive ones by at most one swap in a Binary String

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.