Given a string S consisting of ‘X’, ‘Y’ and ‘Z’ only, the task is to convert S to a string consisting of only a single distinct character by selecting a character and removing substrings that does not contain that character, minimum number of times.
Note: Once a character is chosen, no other character can be used in further operations.
Examples:
Input: S = “XXX”
Output: 0
Explanation: Since the given string already consists of a single distinct character, i.e. X, no removal is required. Therefore, the required count is 0.Input: S = “XYZXYZX”
Output: 2
Explanation:
Selecting the character ‘X’ and removing the substrings “YZ” in two consecutive operations reduces the string to “XXX”, which consists of a single distinct character only.
Approach: The idea is to count occurrences of each character using unordered_map and count the number of removals required for each of them and print the minimum. Follow the steps below to solve the problem:
- Initialize an unordered_map and store the indices of occurrences for each of the characters.
- Iterate over all the characters of the string S and update occurrences of the characters ‘X’, ‘Y’ and ‘Z’ in the map.
- Iterate over the Map and for each character, count the number of removals required for each character.
- After calculating for each character, print the minimum count obtained for any of the characters.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to find minimum removals // required to convert given string // to single distinct characters only int minimumOperations(string s, int n)
{ // Unordered map to store positions
// of characters X, Y and Z
unordered_map< char , vector< int > > mp;
// Update indices of X, Y, Z;
for ( int i = 0; i < n; i++) {
mp[s[i]].push_back(i);
}
// Stores the count of
// minimum removals
int ans = INT_MAX;
// Traverse the Map
for ( auto x : mp) {
int curr = 0;
int prev = 0;
bool first = true ;
// Count the number of removals
// required for current character
for ( int index : (x.second)) {
if (first) {
if (index > 0) {
curr++;
}
prev = index;
first = false ;
}
else {
if (index != prev + 1) {
curr++;
}
prev = index;
}
}
if (prev != n - 1) {
curr++;
}
// Update the answer
ans = min(ans, curr);
}
// Print the answer
cout << ans;
} // Driver Code int main()
{ // Given string
string s = "YYXYZYXYZXY" ;
// Size of string
int N = s.length();
// Function call
minimumOperations(s, N);
return 0;
} |
// Java program for the above approach import java.util.*;
class GFG
{ // Function to find minimum removals
// required to convert given string
// to single distinct characters only
static void minimumOperations(String s, int n)
{
// Unordered map to store positions
// of characters X, Y and Z
HashMap<Character, List<Integer>> mp = new HashMap<>();
// Update indices of X, Y, Z;
for ( int i = 0 ; i < n; i++)
{
if (mp.containsKey(s.charAt(i)))
{
mp.get(s.charAt(i)).add(i);
}
else
{
mp.put(s.charAt(i), new ArrayList<Integer>(Arrays.asList(i)));
}
}
// Stores the count of
// minimum removals
int ans = Integer.MAX_VALUE;
// Traverse the Map
for (Map.Entry<Character, List<Integer>> x : mp.entrySet())
{
int curr = 0 ;
int prev = 0 ;
boolean first = true ;
// Count the number of removals
// required for current character
for (Integer index : (x.getValue()))
{
if (first)
{
if (index > 0 )
{
curr++;
}
prev = index;
first = false ;
}
else
{
if (index != prev + 1 )
{
curr++;
}
prev = index;
}
}
if (prev != n - 1 )
{
curr++;
}
// Update the answer
ans = Math.min(ans, curr);
}
// Print the answer
System.out.print(ans);
}
// Driver code
public static void main(String[] args)
{
// Given string
String s = "YYXYZYXYZXY" ;
// Size of string
int N = s.length();
// Function call
minimumOperations(s, N);
}
} // This code is contributed by divyeshrabadiya07 |
# Python3 program for the above approach import sys;
INT_MAX = sys.maxsize;
# Function to find minimum removals # required to convert given string # to single distinct characters only def minimumOperations(s, n) :
# Unordered map to store positions
# of characters X, Y and Z
mp = {};
# Update indices of X, Y, Z;
for i in range (n) :
if s[i] in mp :
mp[s[i]].append(i);
else :
mp[s[i]] = [i];
# Stores the count of
# minimum removals
ans = INT_MAX;
# Traverse the Map
for x in mp :
curr = 0 ;
prev = 0 ;
first = True ;
# Count the number of removals
# required for current character
for index in mp[x] :
if (first) :
if (index > 0 ) :
curr + = 1 ;
prev = index;
first = False ;
else :
if (index ! = prev + 1 ) :
curr + = 1 ;
prev = index;
if (prev ! = n - 1 ) :
curr + = 1 ;
# Update the answer
ans = min (ans, curr);
# Print the answer
print (ans);
# Driver Code if __name__ = = "__main__" :
# Given string
s = "YYXYZYXYZXY" ;
# Size of string
N = len (s);
# Function call
minimumOperations(s, N);
# This code is contributed by AnkThon
|
// C# program for the above approach using System;
using System.Collections.Generic;
class GFG{
// Function to find minimum removals // required to convert given string // to single distinct characters only static void minimumOperations( string s, int n)
{ // Unordered map to store positions
// of characters X, Y and Z
Dictionary< char ,
List< int >> mp = new Dictionary< char ,
List< int >>();
// Update indices of X, Y, Z;
for ( int i = 0; i < n; i++)
{
if (mp.ContainsKey(s[i]))
{
mp[s[i]].Add(i);
}
else
{
mp[s[i]] = new List< int >();
mp[s[i]].Add(i);
}
}
// Stores the count of
// minimum removals
int ans = Int32.MaxValue;
// Traverse the Map
foreach (KeyValuePair< char , List< int >> x in mp)
{
int curr = 0;
int prev = 0;
bool first = true ;
// Count the number of removals
// required for current character
foreach ( int index in (x.Value))
{
if (first)
{
if (index > 0)
{
curr++;
}
prev = index;
first = false ;
}
else
{
if (index != prev + 1)
{
curr++;
}
prev = index;
}
}
if (prev != n - 1)
{
curr++;
}
// Update the answer
ans = Math.Min(ans, curr);
}
// Print the answer
Console.Write(ans);
} // Driver Code static void Main()
{ // Given string
string s = "YYXYZYXYZXY" ;
// Size of string
int N = s.Length;
// Function call
minimumOperations(s, N);
} } // This code is contributed by divyesh072019 |
<script> // JavaScript program for the above approach
// Function to find minimum removals
// required to convert given string
// to single distinct characters only
function minimumOperations(s, n)
{
// Unordered map to store positions
// of characters X, Y and Z
var mp = {};
// Update indices of X, Y, Z;
for ( var i = 0; i < n; i++) {
if (mp.hasOwnProperty(s[i])) {
mp[s[i]].push(i);
} else {
mp[s[i]] = [];
mp[s[i]].push(i);
}
}
// Stores the count of
// minimum removals
var ans = 2147483647;
// Traverse the Map
for (const [key, value] of Object.entries(mp)) {
var curr = 0;
var prev = 0;
var first = true ;
// Count the number of removals
// required for current character
for (const index of value) {
if (first) {
if (index > 0) {
curr++;
}
prev = index;
first = false ;
} else {
if (index !== prev + 1) {
curr++;
}
prev = index;
}
}
if (prev !== n - 1) {
curr++;
}
// Update the answer
ans = Math.min(ans, curr);
}
// Print the answer
document.write(ans);
}
// Driver Code
// Given string
var s = "YYXYZYXYZXY" ;
// Size of string
var N = s.length;
// Function call
minimumOperations(s, N);
// This code is contributed by rdtank.
</script>
|
3
Time Complexity: O(N)
Auxiliary Space: O(N)