Related Articles

# Replace even-indexed characters of minimum number of substrings to convert a string to another

• Difficulty Level : Hard
• Last Updated : 23 Aug, 2021

Given two strings, str1 and str2 of length N, the task is to convert the string str1 to string str2 by selecting a substring and replacing all characters present at even indices of the substring by any possible characters, even number of times.

Examples:

Input: str1 = “abcdef”, str2 = “ffffff”
Output:
Explanation:
Selecting the substring {str1, …, str} and replacing all the even indices of the substring by ‘f’ modifies str1 to “fbfdff”.
Selecting the substring {str1, …, str} and replacing all the even indices of the substring by ‘f’ modifies str1 to “ffffff”, which is the same as str2.
Therefore, the required output is 2.

Input: str1 = “rtrtyy”, str2 = “wtwtzy”
Output:
Explanation:
Selecting the substring {str1, …, str} and replacing str1 by ‘w’, str1[ by ‘w’ and str by ‘t’ modifies str1 to “wtwtzy”, which is same as str2. Therefore, the required output is 1.

Approach: The problem can be solved using Greedy technique. Follow the steps below to solve the problem:

• Initialize a variable, say cntOp, to store the minimum count of given operations required to convert the string str1 to str2.
• Iterate over the characters of the string. For every ith index, check if str1[i] and str2[i] are same or not. If found to be different, then find the longest substring possible that contains different characters at even indices in both the strings. Replace even indexed characters of that substring of str1 and increment the value of cntOp by 1.
• Finally, print the value of cntOp.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to count the minimum number of``// substrings of str1 such that replacing``// even-indexed characters of those substrings``// converts the string str1 to str2``int` `minOperationsReq(string str1, string str2)``{``    ``// Stores length of str1``    ``int` `N = str1.length();` `    ``// Stores minimum count of operations``    ``// to convert str1 to str2``    ``int` `cntOp = 0;` `    ``// Traverse both the given string``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// If current character in``        ``// both the strings are equal``        ``if` `(str1[i] == str2[i]) {``            ``continue``;``        ``}` `        ``// Stores current index``        ``// of the string``        ``int` `ptr = i;` `        ``// If current character in both``        ``// the strings are not equal``        ``while` `(ptr < N && str1[ptr] != str2[ptr]) {` `            ``// Replace str1[ptr]``            ``// by str2[ptr]``            ``str1[ptr] = str2[ptr];` `            ``// Update ptr``            ``ptr += 2;``        ``}` `        ``// Update cntOp``        ``cntOp++;``    ``}` `    ``return` `cntOp;``}` `// Driver Code``int` `main()``{``    ``string str1 = ``"abcdef"``;``    ``string str2 = ``"ffffff"``;` `    ``cout << minOperationsReq(str1, str2);``    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach` `import` `java.io.*;` `class` `GFG {` `    ``// Function to count the minimum number of``    ``// substrings of str1 such that replacing``    ``// even-indexed characters of those substrings``    ``// converts the string str1 to str2``    ``static` `int` `min_Operations(String str1,``                              ``String str2)``    ``{``        ``// Stores length of str1``        ``int` `N = str1.length();` `        ``// Convert str1 to character array``        ``char``[] str = str1.toCharArray();` `        ``// Stores minimum count of operations``        ``// to convert str1 to str2``        ``int` `cntOp = ``0``;` `        ``// Traverse both the given string``        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``// If current character in both``            ``// the strings are equal``            ``if` `(str[i] == str2.charAt(i)) {``                ``continue``;``            ``}` `            ``// Stores current index``            ``// of the string``            ``int` `ptr = i;` `            ``// If current character in both the``            ``// string are not equal``            ``while` `(ptr < N && str[ptr] != str2.charAt(ptr)) {` `                ``// Replace str1[ptr]``                ``// by str2[ptr]``                ``str[ptr] = str2.charAt(ptr);` `                ``// Update ptr``                ``ptr += ``2``;``            ``}` `            ``// Update cntOp``            ``cntOp++;``        ``}` `        ``return` `cntOp;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String str1 = ``"abcdef"``;``        ``String str2 = ``"ffffff"``;``        ``System.out.println(``            ``min_Operations(str1, str2));``    ``}``}`

## Python3

 `# Python3 program to implement``# the above approach`` ` `# Function to count the minimum number of``# substrings of str1 such that replacing``# even-indexed characters of those substrings``# converts the str1 to str2``def` `minOperationsReq(str11, str22):``    ` `    ``str1 ``=` `list``(str11)``    ``str2 ``=` `list``(str22)``        ` `    ``# Stores length of str1``    ``N ``=` `len``(str1)`` ` `    ``# Stores minimum count of operations``    ``# to convert str1 to str2``    ``cntOp ``=` `0`` ` `    ``# Traverse both the given string``    ``for` `i ``in` `range``(N):`` ` `        ``# If current character in``        ``# both the strings are equal``        ``if` `(str1[i] ``=``=` `str2[i]):``            ``continue``        ` `        ``# Stores current index``        ``# of the string``        ``ptr ``=` `i`` ` `        ``# If current character in both``        ``# the strings are not equal``        ``while` `(ptr < N ``and` `str1[ptr] !``=` `str2[ptr]):`` ` `            ``# Replace str1[ptr]``            ``# by str2[ptr]``            ``str1[ptr] ``=` `str2[ptr]`` ` `            ``# Update ptr``            ``ptr ``+``=` `2``        ` `        ``# Update cntOp``        ``cntOp ``+``=` `1``    ` `    ``return` `cntOp` `# Driver Code``str1 ``=` `"abcdef"``str2 ``=` `"ffffff"`` ` `print``(minOperationsReq(str1, str2))` `# This code is contributed by code_hunt`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG``{` `    ``// Function to count the minimum number of``    ``// substrings of str1 such that replacing``    ``// even-indexed characters of those substrings``    ``// converts the string str1 to str2``    ``static` `int` `min_Operations(String str1,``                              ``String str2)``    ``{``      ` `        ``// Stores length of str1``        ``int` `N = str1.Length;` `        ``// Convert str1 to character array``        ``char``[] str = str1.ToCharArray();` `        ``// Stores minimum count of operations``        ``// to convert str1 to str2``        ``int` `cntOp = 0;` `        ``// Traverse both the given string``        ``for` `(``int` `i = 0; i < N; i++)``        ``{` `            ``// If current character in both``            ``// the strings are equal``            ``if` `(str[i] == str2[i])``            ``{``                ``continue``;``            ``}` `            ``// Stores current index``            ``// of the string``            ``int` `ptr = i;` `            ``// If current character in both the``            ``// string are not equal``            ``while` `(ptr < N && str[ptr] != str2[ptr])``            ``{` `                ``// Replace str1[ptr]``                ``// by str2[ptr]``                ``str[ptr] = str2[ptr];` `                ``// Update ptr``                ``ptr += 2;``            ``}` `            ``// Update cntOp``            ``cntOp++;``        ``}` `        ``return` `cntOp;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``String str1 = ``"abcdef"``;``        ``String str2 = ``"ffffff"``;``        ``Console.WriteLine(``            ``min_Operations(str1, str2));``    ``}``}` `// This code contributed by gauravrajput1`

## Javascript

 ``
Output:
`2`

Time complexity: O(N)
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