# Check if String can be generated by concatenating character or String itself

• Last Updated : 22 Aug, 2022

Given a target string S consisting of lowercase alphabets, the task is to make this string by performing some operation on an empty string such that:

• The first operation is to append a lower case alphabet to string S and
• The second operation is to append a copy of S to itself.

Note: The first operation cannot be used continuously two times.

Examples:

Input: S = “xxyxxy”
Output: Yes
Explanation: First append ‘x’ to the empty string S. Now S = ”x”.
Use second operation. The string will be S = “xx”.
Append ‘y’ with the string. Then current string is “xxy”.
At last perform operation 2 to get the given string which is “xxyxxy”
Hence it is possible to make the given string S after performing operations.

Input: S = ”bee”
Output: No

Approach: The problem can be solved based on the following observation:

Observations:

• The first type of operation can be applied when the string is empty or immediately after an operation of the second type has been performed on the string.
• After every operation of the second type, the length of the resulting string is even. Therefore the operation of the first type can only be applied when the length of the string is even and finally results in an odd length string.
• This means if the length of the string is even then the last operation performed on it has to be of the second type otherwise if the length of the string is odd the last operation performed on it has to be of the first type.

Follow the steps mentioned below to implement the above idea:

• Start with the given string and keep on moving until the string becomes empty:
• If the size of the present string is odd,
• Remove the last character of the string (operation of the first type).
• If the size of the present string is even,
• Check whether this string is the copy of two equal strings (operation of the second type) and reduce the size of the string by half.
• If the present string can’t be obtained by a single operation of the second type then stop iterating.
• If the string is empty at the end then it can be constructed using these operations otherwise it cannot be built using these operations.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the approach` `#include ` `using` `namespace` `std;`   `// Function to check whether given string` `// is possible to make it from empty` `// string after performing operation` `void` `checkString(string A, ``int` `N)` `{` `    ``while` `(N != 0) {` `        ``int` `mid = N / 2;` `        ``if` `(N % 2 == 0) {` `            ``if` `(A.substr(0, mid) == A.substr(mid)) {` `                ``A = A.substr(0, mid);` `                ``N = mid;` `            ``}` `            ``else` `{` `                ``break``;` `            ``}` `        ``}` `        ``else` `{` `            ``if` `(A.substr(0, mid)` `                ``== A.substr(mid, N - 1 - mid)) {` `                ``A = A.substr(0, mid);` `                ``N = mid;` `            ``}` `            ``else` `{` `                ``break``;` `            ``}` `        ``}` `    ``}` `    ``if` `(N == 0 || N == 1)` `        ``cout << ``"Yes\n"``;` `    ``else` `        ``cout << ``"No\n"``;` `}`   `// Driver Code` `int` `main()` `{` `    ``string S = ``"xxyxxy"``;` `    ``int` `N = S.length();`   `    ``// Function call` `    ``checkString(S, N);` `    ``return` `0;` `}`   `// This code is contributed by Rohit Pradhan`

## Java

 `// Java code to implement the approach`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to check whether given string` `    ``// is possible to make it from empty` `    ``// string after performing operation` `    ``public` `static` `void` `checkString(String A, ``int` `N)` `    ``{` `        ``while` `(N != ``0``) {` `            ``int` `mid = N / ``2``;` `            ``if` `(N % ``2` `== ``0``) {` `                ``if` `(A.substring(``0``, mid).equals(` `                        ``A.substring(mid))) {` `                    ``A = A.substring(``0``, mid);` `                    ``N = mid;` `                ``}` `                ``else` `{` `                    ``break``;` `                ``}` `            ``}` `            ``else` `{` `                ``if` `(A.substring(``0``, mid).equals(` `                        ``A.substring(mid, N - ``1``))) {` `                    ``A = A.substring(``0``, mid);` `                    ``N = mid;` `                ``}` `                ``else` `{` `                    ``break``;` `                ``}` `            ``}` `        ``}` `        ``if` `(N == ``0` `|| N == ``1``)` `            ``System.out.println(``"Yes"``);` `        ``else` `            ``System.out.println(``"No"``);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``String S = ``"xxyxxy"``;` `        ``int` `N = S.length();`   `        ``// Function call` `        ``checkString(S, N);` `    ``}` `}`

## Python3

 `# Function to check whether given string` `# is possible to make it from empty` `# string after performing operation` `def` `checkString(A, N):` `    ``while` `N !``=` `0``:` `        ``mid ``=` `N ``/``/` `2` `        ``if` `N ``%` `2` `=``=` `0``:` `            ``if` `A[``0``:mid] ``=``=` `A[mid:]:` `                ``A ``=` `A[``0``:mid]` `                ``N ``=` `mid` `            ``else``:` `                ``break` `        ``else``:` `            ``if` `A[``0``:mid] ``=``=` `A[mid:N``-``1``]:` `                ``A ``=` `A[``0``:mid]` `                ``N ``=` `mid` `            ``else``:` `                ``break` `    ``if` `N ``=``=` `0` `or` `N ``=``=` `1``:` `        ``print``(``"Yes"``)` `    ``else``:` `        ``print``(``"No"``)`     `# Driver Code` `S ``=` `"xxyxxy"` `N ``=` `len``(S)`   `# Function call` `checkString(S, N)`   `# This code is contributed by Tapesh(tapeshdua420)`

## C#

 `// C# program to of the above approach` `using` `System;` `using` `System.Linq;` `using` `System.Collections;` `using` `System.Collections.Generic;`   `class` `GFG {`   `  ``// Function to check whether given string` `  ``// is possible to make it from empty` `  ``// string after performing operation` `  ``public` `static` `void` `checkString(``string` `A, ``int` `N)` `  ``{` `    ``while` `(N != 0) {` `      ``int` `mid = N / 2;` `      ``if` `(N % 2 == 0) {` `        ``if` `(A.Substring(0, mid).Equals(` `          ``A.Substring(mid))) {` `          ``A = A.Substring(0, mid);` `          ``N = mid;` `        ``}` `        ``else` `{` `          ``break``;` `        ``}` `      ``}` `      ``else` `{` `        ``if` `(A.Substring(0, mid).Equals(` `          ``A.Substring(mid, N - 1))) {` `          ``A = A.Substring(0, mid);` `          ``N = mid;` `        ``}` `        ``else` `{` `          ``break``;` `        ``}` `      ``}` `    ``}` `    ``if` `(N == 0 || N == 1)` `      ``Console.Write(``"No"``);` `    ``else` `      ``Console.Write(``"Yes"``);` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main()` `  ``{` `    ``string` `S = ``"xxyxxy"``;` `    ``int` `N = S.Length;`   `    ``// Function call` `    ``checkString(S, N);` `  ``}` `}`   `// This code is contributed by sanjoy_62.`

## Javascript

 ``

Output

`Yes`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :