Skip to content
Related Articles
Minimum number of Appends of X or Y characters from the end to the front required to obtain given string
• Difficulty Level : Easy
• Last Updated : 14 Jun, 2021

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

 `// C++ program for the above approach``#include ``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

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

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

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

## Javascript

 ``
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.  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 industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up