Skip to content
Related Articles

Related Articles

Improve Article

Swap characters in a String

  • Difficulty Level : Hard
  • Last Updated : 05 Jul, 2021

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;
Output : ADEBC
Explanation:
         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

Javascript




<script>
// Javascript Program to find new after swapping
// characters at position i and i + c
// b times, each time advancing one
// position ahead
 
function swapChars(s, c, b)
{
 
    // Get string length
        let 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;
        }
  
        let f = Math.floor(b / n);
        let r = b % n;
  
        // Rotate first c characters by (n % c)
        // places f times
        let p1 = rotateLeft(s.substring(0, c),
                               ((n % c) * f) % c);
  
        // Rotate remaining character by
        // (n * f) places
        let 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)
        let a = (p1 + p2).split("");
  
        // Remaining swaps
        for (let i = 0; i < r; i++) {
  
            // Swap ith character with
            // (i + c)th character
            let temp = a[i];
            a[i] = a[(i + c) % n];
            a[(i + c) % n] = temp;
        }
  
        // Return final string
        return (a).join("");
}
 
function rotateLeft(s,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
// Given values
let s1 = "ABCDEFGHIJK";
let b = 1000;
let c = 3;
 
// get final string
let s2 = swapChars(s1, c, b);
 
// print final string
document.write(s2);
     
// This code is contributed by ab2127
</script>
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :