Given two strings consisting of lowercase alphabets A and B, both of the same length. Each character of both the strings is either a lowercase letter or a question mark ‘?’. The task is to find the minimum number of operations required to convert A to B, in one operation you can choose an index i, if A[i] is a vowel convert it to a consonant, and if A[i] is a consonant convert it to vowel. Prior to performing any operation you need to replace each occurrence of ‘?’ in both strings A and B with the same lowercase letter.
Note: For conversion from a consonant to a consonant, we need two steps: consonant->vowel->consonant. The same shall be true for vowel-to-vowel conversion.
Examples:
Input: A: “abcd?”, B: “acxe?”
Output: 1
Explanation: We can replace the ? character by any alphabet and the number of operations will be same.Input: A = “ab?c?”, B = “aeg?k”
Output: 4
Explanation: If each instance of ? is replaced by ‘u’ . Then A = “ab?c?”, B = “aeg?k”. The number of operations required is 4 which the least one can get.
Approach: To solve the problem follow the below idea:
The number of characters in the lowercase English alphabet is 26. This suggests that we can first replace each instance of ‘?’ in both the strings with each alphabet (a – z) at one time. Now we have two newly complete strings without any occurrence of ‘?’ we can calculate the number of operations it would take to convert A to B. Each character when placed in the location of ‘?’ for both the strings gives some number of operations. The minimum number of these operations gives the final answer.
Illustration:
It is clear from the problem statement itself that once we replace the ‘?’ in both the strings with the appropriate lowercase alphabet, then we only need to calculate the number of steps to convert from A to B.
Say A : “a?pc?”, B : “qfc?d”
Upon trying brute-force, one can observe that for the above testcase one can conclude that replacing the ‘?’ by ‘a’ takes only 6 operations.
Number of operations for each index:
- For i = 1, a -> q : 1
- i = 2, a -> f : 1
- i = 3, p -> c : 2
- i = 4, c -> a : 1
- i = 5, a -> d : 1
Hence, the total number of operations becomes 6.
The above approach simply replaces the question mark with each of the lowercase alphabet and checks for which alphabet the number of operations is minimum.
Steps to follow to implement the above approach:
- Initialize two auxiliary strings P and Q.
- Iterate for each alphabet from a – z and replace each instance of ‘?’ in both strings with that alphabet.
- Store the newly formed strings into P and Q.
- Compute the number of operations required to convert P to Q and store it in some cnt variable.
- Update the min_op if the current value of cnt is less than min_op.
- Repeat 3-5 for the next alphabet until z.
Below is the code to implement the above approach:
// C++ code for the above approach: #include <bits/stdc++.h> using namespace std;
// Checking if certain character is // vowel or consonant int isVowel( char c)
{ if (c == 'a' || c == 'e' || c == 'i' || c == 'o'
|| c == 'u' )
return true ;
else
return false ;
} // Function to compute minimum number // of required operations int solve(string A, string B)
{ // If both strings are already
// equal no. of operation required
if (A == B) {
return 0;
}
int n = A.size(), minOp = INT_MAX, cnt = 0;
// Two auxiliary strings
string P = "" , Q = "" ;
// Iterate for both the strings
// replacing the each occurrence of
// '?' with each alphabet (a-z) and
// then compute the number
// of operations
for ( int j = 0; j < 26; j++) {
// Re-initialize both P and Q and
// operation counter i.e. cnt
P = A, Q = B;
cnt = 0;
// Replace all the occurrences of
// '?' in both strings with each
// English alphabet iteratively.
for ( int i = 0; i < n; i++) {
if (P[i] == '?' )
P[i] = char ( 'a' + j);
if (Q[i] == '?' )
Q[i] = char ( 'a' + j);
}
// Calculate the number
// of operations required
for ( int i = 0; i < n; i++) {
// if both characters are
// same then no operation
// is required
if (P[i] == Q[i]) {
continue ;
}
// if both characters are
// either vowels or consonants
// we need 2 operations as
// vowel -> consonant -> vowel
else if ((isVowel(P[i]) && isVowel(Q[i]))
|| (!isVowel(P[i])
&& !isVowel(Q[i]))) {
cnt += 2;
}
// if one character is vowel
// and other is consonant
// then only one conversion
// is required
else {
cnt += 1;
}
}
// Update the variable minOp if
// number of operations for
// current alphabet is lesser
// than existing value
minOp = min(minOp, cnt);
}
// Return final answer
return minOp;
} // Driver Code int main()
{ // TestCase 1
string A = "ab?c?" , B = "aeg?k" ;
cout << solve(A, B) << endl;
// TestCase 2
A = "am??x" , B = "xd?fc" ;
cout << solve(A, B) << endl;
// TestCase 3
A = "a?pc?" , B = "qfc?d" ;
cout << solve(A, B) << endl;
return 0;
} |
def isVowel(c):
if c = = 'a' or c = = 'e' or c = = 'i' or c = = 'o' or c = = 'u' :
return True
else :
return False
def solve(A, B):
if A = = B:
return 0
n = len (A)
minOp = float ( 'inf' )
for j in range ( 26 ):
P, Q = A, B
cnt = 0
for i in range (n):
if P[i] = = '?' :
P = P[:i] + chr ( ord ( 'a' ) + j) + P[i + 1 :]
if Q[i] = = '?' :
Q = Q[:i] + chr ( ord ( 'a' ) + j) + Q[i + 1 :]
for i in range (n):
if P[i] = = Q[i]:
continue
elif ((isVowel(P[i]) and isVowel(Q[i])) or ( not isVowel(P[i]) and not isVowel(Q[i]))):
cnt + = 2
else :
cnt + = 1
minOp = min (minOp, cnt)
return minOp
# Driver Code if __name__ = = '__main__' :
# TestCase 1
A = "ab?c?"
B = "aeg?k"
print (solve(A, B))
# TestCase 2
A = "am??x"
B = "xd?fc"
print (solve(A, B))
# TestCase 3
A = "a?pc?"
B = "qfc?d"
print (solve(A, B))
|
// C# code for the above approach: using System;
public class Solution {
// Checking if certain character is vowel or consonant
public static bool isVowel( char c)
{
if (c == 'a' || c == 'e' || c == 'i' || c == 'o'
|| c == 'u' ) {
return true ;
}
else {
return false ;
}
}
// Function to compute minimum number of required
// operations
public static int solve( string A, string B)
{
// If both strings are already equal no. of
// operation required
if (A == B) {
return 0;
}
int n = A.Length, minOp = int .MaxValue, cnt = 0;
// Two auxiliary strings
string P = "" , Q = "" ;
// Iterate for both the strings replacing the each
// occurrence of '?' with each alphabet (a-z) and
// then compute the number of operations
for ( int j = 0; j < 26; j++) {
// Re-initialize both P and Q and operation
// counter i.e. cnt
P = A;
Q = B;
cnt = 0;
// Replace all the occurrences of '?' in both
// strings with each English alphabet
// iteratively.
for ( int i = 0; i < n; i++) {
if (P[i] == '?' ) {
P = P.Remove(i, 1).Insert(
i, char .ConvertFromUtf32( 'a' + j));
}
if (Q[i] == '?' ) {
Q = Q.Remove(i, 1).Insert(
i, char .ConvertFromUtf32( 'a' + j));
}
}
// Calculate the number of operations required
for ( int i = 0; i < n; i++) {
// if both characters are same then no
// operation is required
if (P[i] == Q[i]) {
continue ;
}
// if both characters are either vowels or
// consonants we need 2 operations as vowel
// -> consonant -> vowel
else if ((isVowel(P[i]) && isVowel(Q[i]))
|| (!isVowel(P[i])
&& !isVowel(Q[i]))) {
cnt += 2;
}
// if one character is vowel and other is
// consonant then only one conversion is
// required
else {
cnt += 1;
}
}
// Update the variable minOp if number of
// operations for current alphabet is lesser
// than existing value
minOp = Math.Min(minOp, cnt);
}
// Return final answer
return minOp;
}
// Main function
public static void Main()
{
// TestCase 1
string A = "ab?c?" , B = "aeg?k" ;
Console.WriteLine(solve(A, B));
// TestCase 2
A = "am??x" ;
B = "xd?fc" ;
Console.WriteLine(solve(A, B));
// TestCase 3
A = "a?pc?" ;
B = "qfc?d" ;
Console.WriteLine(solve(A, B));
}
} |
// Function to check if a given character is vowel or consonant function isVowel(c) {
if (c === 'a' || c === 'e' || c === 'i' || c === 'o' || c === 'u' ) {
return true ;
} else {
return false ;
}
} // Function to compute minimum number of required operations to convert string A to string B function solve(A, B) {
// If both strings are already equal, no operation is required
if (A === B) {
return 0;
}
// Initialize variables
let n = A.length;
let minOp = Infinity;
let cnt = 0;
let P = '' ;
let Q = '' ;
// Iterate for each English alphabet from a to z
for (let j = 0; j < 26; j++) {
// Re-initialize P, Q and cnt for each alphabet
P = A;
Q = B;
cnt = 0;
// Replace all the occurrences of '?' in both strings with each English alphabet iteratively
for (let i = 0; i < n; i++) {
if (P[i] === '?' ) {
P = P.substr(0, i) + String.fromCharCode( 'a' .charCodeAt(0) + j) + P.substr(i + 1);
}
if (Q[i] === '?' ) {
Q = Q.substr(0, i) + String.fromCharCode( 'a' .charCodeAt(0) + j) + Q.substr(i + 1);
}
}
// Compute the number of operations required to convert P to Q
for (let i = 0; i < n; i++) {
if (P[i] === Q[i]) {
// If both characters are same then no operation is required
continue ;
} else if ((isVowel(P[i]) && isVowel(Q[i])) || (!isVowel(P[i]) && !isVowel(Q[i]))) {
// If both characters are either vowels or consonants, we need 2 operations as vowel -> consonant -> vowel
cnt += 2;
} else {
// If one character is vowel and other is consonant, then only one conversion is required
cnt += 1;
}
}
// Update the variable minOp if number of operations for current alphabet is lesser than existing value
minOp = Math.min(minOp, cnt);
}
// Return final answer
return minOp;
} // Test Cases let A = 'ab?c?' , B = 'aeg?k' ;
console.log(solve(A, B)); A = 'am??x' , B = 'xd?fc' ;
console.log(solve(A, B)); A = 'a?pc?' , B = 'qfc?d' ;
console.log(solve(A, B)); |
import java.util.*;
public class Main {
// Checking if certain character is
// vowel or consonant
public static boolean isVowel( char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o'
|| c == 'u' ) {
return true ;
} else {
return false ;
}
}
// Function to compute minimum number
// of required operations
public static int solve(String A, String B) {
// If both strings are already
// equal no. of operation required
if (A.equals(B)) {
return 0 ;
}
int n = A.length(), minOp = Integer.MAX_VALUE, cnt = 0 ;
// Two auxiliary strings
String P = "" , Q = "" ;
// Iterate for both the strings
// replacing the each occurrence of
// '?' with each alphabet (a-z) and
// then compute the number
// of operations
for ( int j = 0 ; j < 26 ; j++) {
// Re-initialize both P and Q and
// operation counter i.e. cnt
P = A; Q = B;
cnt = 0 ;
// Replace all the occurrences of
// '?' in both strings with each
// English alphabet iteratively.
for ( int i = 0 ; i < n; i++) {
if (P.charAt(i) == '?' ) {
P = P.substring( 0 , i) + ( char )( 'a' + j) + P.substring(i+ 1 );
}
if (Q.charAt(i) == '?' ) {
Q = Q.substring( 0 , i) + ( char )( 'a' + j) + Q.substring(i+ 1 );
}
}
// Calculate the number
// of operations required
for ( int i = 0 ; i < n; i++) {
// if both characters are
// same then no operation
// is required
if (P.charAt(i) == Q.charAt(i)) {
continue ;
}
// if both characters are
// either vowels or consonants
// we need 2 operations as
// vowel -> consonant -> vowel
else if ((isVowel(P.charAt(i)) && isVowel(Q.charAt(i)))
|| (!isVowel(P.charAt(i))
&& !isVowel(Q.charAt(i)))) {
cnt += 2 ;
}
// if one character is vowel
// and other is consonant
// then only one conversion
// is required
else {
cnt += 1 ;
}
}
// Update the variable minOp if
// number of operations for
// current alphabet is lesser
// than existing value
minOp = Math.min(minOp, cnt);
}
// Return final answer
return minOp;
}
// Driver Code
public static void main(String[] args) {
// TestCase 1
String A = "ab?c?" , B = "aeg?k" ;
System.out.println(solve(A, B));
// TestCase 2
A = "am??x" ; B = "xd?fc" ;
System.out.println(solve(A, B));
// TestCase 3
A = "a?pc?" ; B = "qfc?d" ;
System.out.println(solve(A, B));
}
} |
4 5 6
Time Complexity: O(N*26) ~ O(N)
Auxiliary Space: O(N), auxiliary strings of size N are being used.