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

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 <bits/stdc++.h>
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# 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

    <script>
        // JavaScript code to implement the approach

        // Function to check whether given string
        // is possible to make it from empty
        // string after performing operation
        const checkString = (A, N) => {
            while (N != 0) {
                let mid = parseInt(N / 2);
                if (N % 2 == 0) {
                    if (A.substring(0, mid) == A.substring(mid)) {
                        A = A.substring(0, mid);
                        N = mid;
                    }
                    else {
                        break;
                    }
                }
                else {
                    if (A.substring(0, mid)
                        == A.substring(mid, N - 1 - mid + mid)) {
                        A = A.substring(0, mid);
                        N = mid;
                    }
                    else {
                        break;
                    }
                }
            }
            if (N == 0 || N == 1)
                document.write("Yes\n");
            else
                document.write("No\n");
        }

        // Driver Code

        let S = "xxyxxy";
        let N = S.length;

        // Function call
        checkString(S, N);

    // This code is contributed by rakeshsahni

    </script>

Output

Yes

Time Complexity: O(log₂ N), as binary search approach is used.
Auxiliary Space: O(1)

Article Tags :

DSA

Greedy

Strings

substring