Related Articles

Related Articles

Minimum number of Appends of X or Y characters from the end to the front required to obtain given string
  • Last Updated : 16 Nov, 2020

Given a string S and two positive integers X and Y, the task is to find the minimum number of operations required to obtain the original string. In each operation, append X or Y characters from the end of the string to the front of the string respectively in each operation.

Examples:

Input: S = “GeeksforGeeks”, X = 5, Y = 3
Output: 3
Explanation:
Below are the operations performed:
Operation 1: Append 5 characters from the back of the string S to the front of the string S. Now the updated string is “GeeksGeeksfor”.
Operation 2: Append 3 characters from the back of the string S to the front of the string S. Now the updated string is “forGeeksGeeks”.
Operation 3: Append 5 characters from the back of the string S to the front of the string S. Now the updated string is “GeeksforGeeks”.
Therefore, the minimum count of operations required is 3.

Input: S = “AbcDef”, X = 1, Y = 2
Output: 4
Explanation:
Below are the operations performed:
Operation 1: Append 1 characters from the back of the string S to the front of the string S. Now the updated string is “fAbcDe”.
Operation 2: Append 2 characters from the back of the string S to the front of the string S. Now the updated string is “fDeAbc”.
Operation 3: Append 1 characters from the back of the string S to the front of the string S. Now the updated string is “cfDeAb”.
Operation 4: Append 2 characters from the back of the string S to the front of the string S. Now the updated string is “AbcDef”.
Therefore, the minimum count of operations required is 4.

 

Approach: The idea is to append X and Y characters from the given string to the front of the string respectively and keep the track of the count of operations while performing operations. Below are the steps:



  • Initialize the count as 0 that stores the minimum operations.
  • Store the given string S in another string(say newString) where operation needs to be performed.
  • Now perform the following operation on the newString till it is equal to S:
    • Append the X character from the end of the string newString and increment the count by 1.
    • If newString is the same as the string S.
    • Append the Y character from the end of the string newString and increment the count by 1.
    • If newString is the same as the string S.
  • After the above steps, print the value of the count as the minimum number of operations required.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
#include <iostream>
using namespace std;
 
// Function to find the minimum operations
// required to get the given string after
// appending m or n characters from the end
// to the front of the string in each operation
int minimumOperations(string orig_str, int m, int n)
{
     
    // Store the original string
    string orig = orig_str;
     
    // Stores the count of operations
    int turn = 1;
    int j = 1;
 
    // Traverse the string
    for(auto i : orig_str)
    {
         
        // Cut m letters from end
        string m_cut = orig_str.substr(
            orig_str.length() - m);
 
        orig_str.erase(orig_str.length() - m);
 
        // Add cut m letters to beginning
        orig_str = m_cut + orig_str;
 
        // Update j
        j = j + 1;
 
        // Check if strings are the same
        if (orig != orig_str)
        {
            turn = turn + 1;
 
            // Cut n letters from end
            string n_cut = orig_str.substr(
                orig_str.length() - n);
            orig_str.erase(orig_str.length() - n);
 
            // Add cut n letters to beginning
            orig_str = n_cut + orig_str;
 
            // Update j
            j = j + 1;
        }
 
        // Check if strings are the same
        if (orig == orig_str)
        {
            break;
        }
 
        // Update the turn
        turn = turn + 1;
    }
    cout << turn;
}
 
// Driver Code
int main()
{
     
    // Given string S
    string S = "GeeksforGeeks";
 
    int X = 5, Y = 3;
 
    // Function Call
    minimumOperations(S, X, Y);
    return 0;
}
 
// This code is contributed by akhilsaini

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG{
 
// Function to find the minimum operations
// required to get the given string after
// appending m or n characters from the end
// to the front of the string in each operation
static void minimumOperations(String orig_str,
                              int m, int n)
{
     
    // Store the original string
    String orig = orig_str;
 
    // Stores the count of operations
    int turn = 1;
    int j = 1;
 
    // Traverse the string
    for(int i = 0; i < orig_str.length(); i++)
    {
         
        // Cut m letters from end
        String m_cut = orig_str.substring(
            orig_str.length() - m);
 
        orig_str = orig_str.substring(
            0, orig_str.length() - m);
 
        // Add cut m letters to beginning
        orig_str = m_cut + orig_str;
 
        // Update j
        j = j + 1;
 
        // Check if strings are the same
        if (!orig.equals(orig_str))
        {
            turn = turn + 1;
 
            // Cut n letters from end
            String n_cut = orig_str.substring(
                orig_str.length() - n);
            orig_str = orig_str.substring(
                0, orig_str.length() - n);
 
            // Add cut n letters to beginning
            orig_str = n_cut + orig_str;
 
            // Update j
            j = j + 1;
        }
 
        // Check if strings are the same
        if (orig.equals(orig_str))
        {
            break;
        }
 
        // Update the turn
        turn = turn + 1;
    }
    System.out.println( turn );
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given string S
    String S = "GeeksforGeeks";
 
    int X = 5, Y = 3;
 
    // Function Call
    minimumOperations(S, X, Y);
}
}
 
// This code is contributed by akhilsaini

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python program for the above approach
 
# Function to find the minimum operations
# required to get the given string after
# appending m or n characters from the end
# to the front of the string in each operation
def minimumOperations(orig_str, m, n):
 
    # Store the original string
    orig = orig_str
     
    # Stores the count of operations
    turn = 1
    j = 1
     
    # Traverse the string
    for i in orig_str:
 
        # Cut m letters from end
        m_cut = orig_str[-m:]
         
        orig_str = orig_str.replace(' ', '')[:-m]
 
        # Add cut m letters to beginning
        orig_str = m_cut + orig_str
 
        # Update j
        j = j + 1
 
        # Check if strings are the same
        if orig != orig_str:
            turn = turn + 1
 
            # Cut n letters from end
            n_cut = orig_str[-n:]
            orig_str = orig_str.replace(' ', '')[:-n]
 
            # Add cut n letters to beginning
            orig_str = n_cut + orig_str
     
            # Update j
            j = j + 1
 
        # Check if strings are the same
        if orig == orig_str:
            break
 
        # Update the turn
        turn = turn + 1
 
    print(turn)
 
 
# Driver Code
 
# Given string S
S = "GeeksforGeeks"
 
X = 5
Y = 3
 
# Function Call
minimumOperations(S, X, Y)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
 
class GFG{
 
// Function to find the minimum operations
// required to get the given string after
// appending m or n characters from the end
// to the front of the string in each operation
static void minimumOperations(string orig_str, int m,
                              int n)
{
     
    // Store the original string
    string orig = orig_str;
 
    // Stores the count of operations
    int turn = 1;
    int j = 1;
 
    // Traverse the string
    for(int i = 0; i < orig_str.Length; i++)
    {
         
        // Cut m letters from end
        string m_cut = orig_str.Substring(
            orig_str.Length - m);
 
        orig_str = orig_str.Substring(
            0, orig_str.Length - m);
 
        // Add cut m letters to beginning
        orig_str = m_cut + orig_str;
 
        // Update j
        j = j + 1;
 
        // Check if strings are the same
        if (!orig.Equals(orig_str))
        {
            turn = turn + 1;
 
            // Cut n letters from end
            String n_cut = orig_str.Substring(
                orig_str.Length - n);
            orig_str = orig_str.Substring(
                0, orig_str.Length - n);
 
            // Add cut n letters to beginning
            orig_str = n_cut + orig_str;
 
            // Update j
            j = j + 1;
        }
 
        // Check if strings are the same
        if (orig.Equals(orig_str))
        {
            break;
        }
 
        // Update the turn
        turn = turn + 1;
    }
    Console.WriteLine(turn);
}
 
// Driver Code
public static void Main()
{
     
    // Given string S
    string S = "GeeksforGeeks";
 
    int X = 5, Y = 3;
 
    // Function Call
    minimumOperations(S, X, Y);
}
}
 
// This code is contributed by akhilsaini

chevron_right


Output: 

3



 

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :