Related Articles

# Flip the String by either swapping given characters or rotating it horizontally for Q queries

• Last Updated : 30 Jun, 2021

Given a string S of length 2N and Q Queries containing three integers T, A, and B each, where queries can be of the following two types:

• T=1: Swap the Ath and Bth characters in S.(In 1-based indexing)
• T=2: Swap the first N characters with the last N characters i.e “ABCD” becomes “CDAB”

The task is to find the final string after applying the Q Queries to it.

Examples:

Input: S=”ABCD”, N=2, Q={{2, 0, 0}, {1, 1, 3}, {2, 0, 0}}
Output:
Explanation:
After 1st query:   S=”CDAB”

Input: S=”GEEK”, N=2, Q={{2, 0, 0}, {1, 1, 2}, {1, 2, 3}, {1, 3, 4}, {2, 0, 0}}
Output:
EEKG

Naive Approach: Follow the steps below to solve the problem:

1. Traverse the Queries array, and for each current index i, do the following:
1. Extract T, A and B as T=Q[i], A=Q[i] and B=Q[i].
2. Decrement A and B both to make them 0-indexed.
3. If T is equal to 1, swap the characters at index A and B respectively.
4. Otherwise, Traverse the string from 0 to N-1 and swap each A[j] with A[j+N].
2. Print the string S

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find final string``// after applying all Queries on it``void` `solve(string S, ``int` `N,``           ``vector > Queries,``           ``int` `Q)``{``    ``// Traverse the Queries array``    ``for` `(``int` `i = 0; i < Q; i++) {``        ``int` `T = Queries[i], A = Queries[i],``            ``B = Queries[i];``        ``// convert A, B to zero indexing``        ``A--;``        ``B--;``        ``// Query of 1st type``        ``if` `(T == 1) {``            ``// swap ath and bth characters``            ``swap(S[A], S[B]);``        ``}``        ``// Query of 2nd type``        ``else` `{``            ``// swap first N characters``            ``// with last N characters``            ``for` `(``int` `j = 0; j < N; j++) {``                ``swap(S[j], S[j + N]);``            ``}``        ``}``    ``}``    ``// Print answer``    ``cout << S << endl;``}``// Driver code``int` `main()``{``    ``// Input``    ``string S = ``"ABCD"``;``    ``int` `N = S.length() / 2;``    ``vector > Queries``        ``= { { 2, 0, 0 }, { 1, 1, 3 }, { 2, 0, 0 } };``    ``int` `Q = Queries.size();` `    ``// Function call``    ``solve(S, N, Queries, Q);` `    ``return` `0;``}`

## Python3

 `# Python3 program for the above approach` `# Function to find final string``# after applying all Queries on it``def` `solve(S, N, Queries, Q):``    ` `    ``# Traverse the Queries array``    ``S ``=` `list``(S)``    ``for` `i ``in` `range``(Q):``        ``T ``=` `Queries[i][``0``]``        ``A ``=` `Queries[i][``1``]``        ``B ``=` `Queries[i][``2``]``        ` `        ``# Convert A, B to zero indexing``        ``A ``-``=` `1``        ``B ``-``=` `1``        ` `        ``# Query of 1st type``        ``if` `(T ``=``=` `1``):``            ` `            ``# Swap ath and bth characters``            ``temp ``=` `S[A]``            ``S[A] ``=` `S[B]``            ``S[B] ``=` `temp` `        ``# Query of 2nd type``        ``else``:``            ` `            ``# Swap first N characters``            ``# with last N characters``            ``for` `j ``in` `range``(N):``                ``temp ``=` `S[j]``                ``S[j] ``=` `S[j ``+` `N]``                ``S[j ``+` `N] ``=` `temp``            ` `    ``S ``=` `''.join(S)``            ` `    ``# Print answer``    ``print``(S)``    ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Input``    ``S ``=` `"ABCD"``    ``N ``=` `len``(S) ``/``/` `2``    ``Queries ``=` `[ [ ``2``, ``0``, ``0` `],``                ``[ ``1``, ``1``, ``3` `],``                ``[ ``2``, ``0``, ``0` `] ]``    ``Q ``=` `len``(Queries)` `    ``# Function call``    ``solve(S, N, Queries, Q)``    ` `# This code is contributed by ipg2016107`
Output
`CBAD`

Time Complexity: O(N*Q)
Auxiliary Space: O(1)

Efficient Approach: There is no need to actually swap first N characters with last N characters for every query of type 2. This can be done once at the end by keeping track of how many times this is done in a separate variable. Follow the steps below to solve the problem:

1. Initialize a variable flip to 0, which keeps track of how many times a query of type 2 is performed on S.
2. Traverse the Queries array, and for each current index i, do the following:
1. Extract T, A and B as T=Q[i], A=Q[i] and B=Q[i].
2. Decrement A and B both to make them 0-indexed.
3. If T is equal to 1, do the following:
1. Check if flip is even. If it is, simply swap the Ath and Bth characters in S
2. Otherwise, update the values of A and B accordingly (as the string is flipped )by adding N to them and then, taking their modulus with 2N. Then swap the Ath and Bth characters in S.
4. Otherwise, increment flip
3. Check if flip is even. If it is, print S as it is.
4. Otherwise, S is flipped, so print the last N characters of S first and then, the first N characters of S.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find final string``// after applying all Queries on it``void` `solve(string S, ``int` `N,``           ``vector > Queries,``           ``int` `Q)``{``    ``int` `flip = 0;``    ``// Traverse the Queries array``    ``for` `(``int` `i = 0; i < Q; i++) {``        ``int` `T = Queries[i], A = Queries[i],``            ``B = Queries[i];``        ``// convert A, B to zero indexing``        ``A--;``        ``B--;``        ``// Query of 1st type``        ``if` `(T == 1) {``            ``// simply swap the character at``            ``// Ath and Bth index``            ``if` `(flip % 2 == 0)``                ``swap(S[A], S[B]);``            ``else` `{``                ``// add N to A, B as string starts at nth``                ``// index(0 indexing) and take mod with size``                ``// of string (2*N) and swap the character at``                ``// Ath and Bth index calculated.``                ``A = (A + N) % (2 * N);``                ``B = (B + N) % (2 * N);``                ``swap(S[A], S[B]);``            ``}``        ``}``        ``// Query of 2nd type``        ``else` `{``            ``// increment flip``            ``flip++;``        ``}``    ``}``    ``// Print answer``    ``if` `(flip % 2 == 0)``        ``cout << S << endl;``    ``else` `{``        ``// string starts at Nth index;``        ``for` `(``int` `i = N; i < 2 * N; i++)``            ``cout << S[i];``        ``for` `(``int` `i = 0; i < N; i++)``            ``cout << S[i];``        ``cout << endl;``    ``}``}``// Driver code``int` `main()``{``    ``// Input``    ``string S = ``"ABCD"``;``    ``int` `N = S.length() / 2;``    ``vector > Queries``        ``= { { 2, 0, 0 }, { 1, 1, 3 }, { 2, 0, 0 } };``    ``int` `Q = Queries.size();` `    ``// Function call``    ``solve(S, N, Queries, Q);` `    ``return` `0;``}`
Output
`CBAD`

Time Complexity: O(N+Q)
Auxiliary Space: O(1)

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