Given array A[] formed by the concatenation of string “ABC” one or multiple times. The task for this problem is to remove all occurrences of subsequence “ABC” by performing the following operation a minimum number of times. In one operation swap any two elements of array A[]. print the number of operations required and elements on which operations are performed in each step.
Examples:
Input: A[] = {‘A’, ‘B’, ‘C’}
Output: 1
1 3
Explanation: Swapping 1’st and 3’rd element of array A[] it becomes A[] = {‘C’, ‘B’, ‘A’} which does not contain “ABC'” as subsequence.Input: A[] = {‘A’, ‘B’, ‘C’, ‘A’, ‘B’, ‘C’};
Output: 1
1 6
Approach: To solve the problem follow the below idea:
No subsequences of string “ABC” would also mean no substrings of “ABC” in array A[]. it would be also be the lower bound for having no subsequences of string “ABC”.
Swap i-th A from start with i-th C from end for 1 <= i <= ceil(N / 6) We can see that, no substrings of “ABC” exists after performing ceil(N / 6) operations. Since we can only destroy atmost 2 substrings in one operations, ceil(N / 6) is minimum possible. Now if you see clearly, after performing above operations, there does not exist any subsequence of string ABC in original string. Hence ceil(N / 6) is also the answer for the original problem.
Below are the steps for the above approach:
- Create variable numberOfOperations.
- Create two pointers L = 1 and R = N.
- Create an array eachStep[][2] to store which elements will be replaced at which step.
- Run a while loop till L < R.
- Each step push {L, R} to eachStep[][2] then move pointer L to 3 steps forwards and R to 3 steps backward.
- After while loop ends print the numberOfOperations and eachStep[][2] array.
Below is the implementation of the above approach:
// C++ code to implement the approach #include <bits/stdc++.h> using namespace std;
// Function to remove every occurence of // subsequence ABC by peforming // minimum number of swaps void minimizeOperations( char A[], int N)
{ // Variable that stores nunber of
// operations required
int numberOfOperations = ceil (N / 2.0);
// Left and Right pointer of array
int L = 1, R = N;
// To store answer of each step
vector<pair< int , int > > eachStep;
// Store operation on each step
while (L < R) {
// L and R will be swaped
// in next step
eachStep.push_back({ L, R });
// Move pointers for next operation
L += 3;
R -= 3;
}
// Printing number of operations
cout << numberOfOperations << endl;
// Each step of operation
for ( auto ans : eachStep)
cout << ans.first << " " << ans.second << endl;
// Next line
cout << endl
<< endl;
} // Driver Code int32_t main() { // Input 1
int N = 3;
char A[] = { 'A' , 'B' , 'C' };
// Function Call
minimizeOperations(A, N);
// Input 2
int N1 = 6;
char A1[] = { 'A' , 'B' , 'C' , 'A' , 'B' , 'C' };
// Function Call
minimizeOperations(A1, N1);
return 0;
} |
// Java code to implement the approach import java.util.ArrayList;
class GFG {
// Function to remove every occurrence of
// subsequence ABC by performing
// a minimum number of swaps
static void minimizeOperations( char [] A, int N)
{
// Variable that stores the number of
// operations required
int numberOfOperations = ( int )Math.ceil(N / 2.0 );
// Left and Right pointer of the array
int L = 1 , R = N;
// To store the answer of each step
ArrayList<ArrayList<Integer> > eachStep
= new ArrayList<>();
// Store operation on each step
while (L < R) {
// L and R will be swapped
// in the next step
ArrayList<Integer> step = new ArrayList<>();
step.add(L);
step.add(R);
eachStep.add(step);
// Move pointers for the next operation
L += 3 ;
R -= 3 ;
}
// Printing the number of operations
System.out.println(numberOfOperations);
// Each step of the operation
for (ArrayList<Integer> ans : eachStep)
System.out.println(ans.get( 0 ) + " "
+ ans.get( 1 ));
// Next line
System.out.println( "\n\n" );
}
// Driver Code
public static void main(String[] args)
{
// Input 1
int N = 3 ;
char [] A = { 'A' , 'B' , 'C' };
// Function Call
minimizeOperations(A, N);
// Input 2
int N1 = 6 ;
char [] A1 = { 'A' , 'B' , 'C' , 'A' , 'B' , 'C' };
// Function Call
minimizeOperations(A1, N1);
}
} // This code is contributed by shivamgupta0987654321 |
# python code to implement the approach # Function to remove every occurrence of # subsequence ABC by performing # a minimum number of swaps def minimize_operations(A):
# Length of the array A
N = len (A)
# Variable that stores the number of operations required
number_of_operations = (N + 1 ) / / 2
# Left and Right pointer of array
L, R = 1 , N
# To store the answer of each step
each_step = []
# Store operation on each step
while L < R:
# L and R will be swapped in the next step
each_step.append((L, R))
# Move pointers for the next operation
L + = 3
R - = 3
# Printing the number of operations
print (number_of_operations)
# Each step of operation
for ans in each_step:
print (ans[ 0 ], ans[ 1 ])
# Next line
print ( "\n\n" )
# Driver Code if __name__ = = "__main__" :
# Input 1
A = [ 'A' , 'B' , 'C' ]
# Function Call
minimize_operations(A)
# Input 2
A1 = [ 'A' , 'B' , 'C' , 'A' , 'B' , 'C' ]
# Function Call
minimize_operations(A1)
|
// C# code to implement the approach using System;
using System.Collections.Generic;
class GFG
{ // Function to remove every occurrence of
// subsequence ABC by performing
// a minimum number of swaps
static void minimizeOperations( char [] A, int N)
{
// Variable that stores the number of
// operations required
int numberOfOperations = ( int )Math.Ceiling(N / 2.0);
// Left and Right pointer of the array
int L = 1, R = N;
// To store the answer of each step
List<List< int >> eachStep = new List<List< int >>();
// Store operation on each step
while (L < R)
{
// L and R will be swapped
// in the next step
List< int > step = new List< int >();
step.Add(L);
step.Add(R);
eachStep.Add(step);
// Move pointers for the next operation
L += 3;
R -= 3;
}
// Printing the number of operations
Console.WriteLine(numberOfOperations);
// Each step of the operation
foreach (List< int > ans in eachStep)
{
Console.WriteLine(ans[0] + " " + ans[1]);
}
// Next line
Console.WriteLine( "\n\n" );
}
// Driver Code
public static void Main( string [] args)
{
// Input 1
int N = 3;
char [] A = { 'A' , 'B' , 'C' };
// Function Call
minimizeOperations(A, N);
// Input 2
int N1 = 6;
char [] A1 = { 'A' , 'B' , 'C' , 'A' , 'B' , 'C' };
// Function Call
minimizeOperations(A1, N1);
}
} // This code is contributed by Utkarsh Kumar |
// Function to remove every occurence of // subsequence ABC by peforming // minimum number of swaps function minimizeOperations(A, N) {
// Variable that stores number of operations required
const numberOfOperations = Math.ceil(N / 2);
// Left and Right pointer of array
let L = 1;
let R = N;
// To store answer of each step
const eachStep = [];
// Store operation on each step
while (L < R) {
// L and R will be swapped in the next step
eachStep.push([L, R]);
// Move pointers for the next operation
L += 3;
R -= 3;
}
// Printing number of operations
console.log(numberOfOperations);
// Each step of operation
eachStep.forEach((ans) => console.log(ans[0], ans[1]));
// Next line
console.log( '\n\n' );
} // Driver Code function main() {
// Input 1
const N = 3;
const A = [ 'A' , 'B' , 'C' ];
// Function Call
minimizeOperations(A, N);
// Input 2
const N1 = 6;
const A1 = [ 'A' , 'B' , 'C' , 'A' , 'B' , 'C' ];
// Function Call
minimizeOperations(A1, N1);
} main(); |
2 1 3 3 1 6
Time Complexity: O(N)
Auxiliary Space: O(N)