Open In App

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

Last Updated : 10 Jan, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

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#

// 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(log2 N), as binary search approach is used.
Auxiliary Space: O(1)


Similar Reads

Check whether given string can be generated after concatenating given strings
Given three strings str, A and B. The task is to check whether str = A + B or str = B + A where + denotes concatenation. Examples: Input: str = "GeeksforGeeks", A = "Geeksfo", B = "rGeeks" Output: Yes str = A + B = "Geeksfo" + "rGeeks" = "GeeksforGeeks"Input: str = "Delhicapitals", B = "Delmi", C = "capitals" Output: No Approach: If len(str) != len
11 min read
Longest increasing sub-sequence formed by concatenating array to itself N times
Given an array arr[] of size N, the task is to find the length of the longest increasing subsequence in the array formed by the concatenation of the arr[] to itself at the end N times.Examples: Input: arr[] = {3, 2, 1}, N = 3 Output: 3 Explanation: The array formed by the concatenation - {3, 2, 1, 3, 2, 1, 3, 2, 1} The longest increasing subsequenc
5 min read
Count of valid pairs (X, Y) from given strings such that concatenating X with itself yields Y
Given an array arr[] of N strings. Let X and Y be two strings, X and Y are said to be valid pairs if the rearrangement of the resultant string from the concatenation of X with X (i.e., X+X) gives Y. The task is to count the number of such valid pairs. Examples: Input: N = 4, arr[] = {“hacker”, ”ackerhackerh”, ”int”, ”iittnn”, ”long”}Output: 2 Expla
7 min read
Count number in given range generated by concatenating two Array elements
Given an array arr[] of size N and integers L and R defining the given range, the task is to find the number of elements in the given range that can be generated by concatenating any two elements of the array. Examples: Input: N = 2, L = 10, R = 52, arr = {2, 5}Output: 3Explanation: All pairs available (2, 2) =&gt; 22 (10 ≤ 22 ≤ 52)(2, 5) =&gt; 25
11 min read
Check whether a binary string can be formed by concatenating given N numbers sequentially
Given a sequence of 'n' numbers (without leading zeros), the task is to find whether it is possible to create a binary string by concatenating these numbers sequentially. If possible, then print the binary string formed, otherwise print "-1". Examples : Input: arr[] = {10, 11, 1, 0, 10} Output: 10111010 All the numbers contain the digits '1' and '0
8 min read
Check if a Palindromic String can be formed by concatenating Substrings of two given Strings
Given two strings str1 and str2, the task is to check if it is possible to form a Palindromic String by concatenation of two substrings of str1 and str2. Examples: Input: str1 = "abcd", str2 = "acba"Output: YesExplanation:There are five possible cases where concatenation of two substrings from str1 and str2 gives palindromic string:"ab" + "a" = "ab
6 min read
Check if a palindromic string can be obtained by concatenating substrings split from same indices of two given strings
Given two strings A and B of length N, the task is to check if any of the two strings formed by splitting both the strings at any index i (0 ≤ i ≤ N - 1) and concatenating A[0, i] and B[i, N - 1] or A[i, N - 1] and B[0, i] respectively, form a palindromic string or not. If found to be true, print "Yes". Otherwise, print "No". Examples: Input: A = "
21 min read
String generated by typing given string in a keyboard having the button of given character faulty
Given a string str and a character ch, where the button of character ch is not working correctly. After pressing that key, it toggles the Caps Lock instead of that letter. The task is to print the string generated after typing str on such a faulty keyboard. Note: The string may contain both upper and lower case characters. Examples: Input: str = "T
8 min read
N-th character in the string made by concatenating natural numbers
Given an integer N, the task is to find the N-th character in the string made by concatenating natural numbers (Integers beginning from 1). The starting string will be "12345678910111213..". Examples: Input: N = 3 Output: 3 3rd character in the string "12345678910111213.." is 3. Input: N = 11 Output: 0 11th character in the string "1234567891011121
11 min read
Pairs of strings which on concatenating contains each character of "string"
Given an array of strings arr[]. The task is to find the count of unordered pairs of strings (arr[i], arr[j]), which in concatenation includes each character of the string "string" at least once. Examples: Input: arr[] = { "s", "ng", "stri"} Output: 1 (arr[1], arr[2]) is the only pair which on concatenation will contain every character of the strin
9 min read
Article Tags :
Practice Tags :