Skip to content
Related Articles

Related Articles

Python3 Program for Swap characters in a String

View Discussion
Improve Article
Save Article
  • Last Updated : 25 Jan, 2022

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:

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


Output: 

CADEFGHIJKB

 

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

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


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!