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:

## C++

`// C++ program to find new after swapping` `// characters at position i and i + c` `// b times, each time advancing one` `// position ahead` `#include <bits/stdc++.h>` `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` |

**Output:**

CADEFGHIJKB

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.