Minimum number of Appends of X or Y characters from the end to the front required to obtain given string

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++ 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

// 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

# 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)

// 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

<script>
    // Javascript 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
    function minimumOperations(orig_str, m, n)
    {

        // Store the original string
        let orig = orig_str;

        // Stores the count of operations
        let turn = 1;
        let j = 1;

        // Traverse the string
        for(let i = 0; i < orig_str.length; i++)
        {

            // Cut m letters from end
            let 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 != orig_str)
            {
                turn = turn + 1;

                // Cut n letters from end
                let 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 == orig_str)
            {
                break;
            }

            // Update the turn
            turn = turn + 1;
        }
        document.write(turn);
    }
    
    // Given string S
    let S = "GeeksforGeeks";
 
    let X = 5, Y = 3;
 
    // Function Call
    minimumOperations(S, X, Y);

// This code is contributed by vaibhavrabadiya117.
</script>

3

Time Complexity: O(N)
Auxiliary Space: O(1)