Check if a string can become empty by recursively deleting a given sub-string

Given a string "str" and another string "sub_str". We are allowed to delete "sub_str" from "str" any number of times. It is also given that the "sub_str" appears only once at a time. The task is to find if "str" can become empty by removing "sub_str" again and again.

Examples:

Input  : str = "GEEGEEKSKS", sub_str = "GEEKS"
Output : Yes
Explanation : In the string GEEGEEKSKS, we can first 
              delete the substring GEEKS from position 4.
              The new string now becomes GEEKS. We can 
              again delete sub-string GEEKS from position 1. 
              Now the string becomes empty.

Input  : str = "GEEGEEKSSGEK", sub_str = "GEEKS"
Output : No
Explanation : In the string it is not possible to make the
              string empty in any possible manner.

Method#1: A simple solution to solve this problem is by using inbuilt string functions find() and erase(). First input the sub-string substr for searching purpose in the original string str, then iterate the original string to find the index of the sub-string using find() which return starting index of the sub-string in the original string else -1 if not found and erase that sub-string using erase() until the length of the original string is greater than 0.

The above simple solutions work because the given substring appears only once at a time. 

// C++ Program to check if a string can be
// converted to an empty string by deleting
// given sub-string from any position, any
// number of times.
#include<bits/stdc++.h>
using namespace std;

// Returns true if str can be made empty by
// recursively removing sub_str.
bool canBecomeEmpty(string str, string sub_str)
{
    while (str.size() > 0)
    {
        // idx: to store starting index of sub-
        //      string found in the original string
        int idx = str.find(sub_str);
        if (idx == -1)
            break;

        // Erasing the found sub-string from
        // the original string
        str.erase(idx, sub_str.size());
    }

    return (str.size() == 0);
}

// Driver code
int main()
{
    string str = "GEEGEEKSKS", sub_str = "GEEKS";
    if (canBecomeEmpty(str, sub_str))
        cout<<"\nYes";
    else
        cout<<"\nNo";
    return 0;
}

//Java program to check if a string can be
// converted to an empty string by deleting
// given sub-string from any position, any
// number of times.

class GFG {

// Returns true if str can be made empty by
// recursively removing sub_str.
    static boolean canBecomeEmpty(String str, String sub_str) {
        while (str.length() > 0) {
            // idx: to store starting index of sub-
            //      string found in the original string
            int idx = str.indexOf(sub_str);
            if (idx == -1) {
                break;
            }

            // Erasing the found sub-string from
            // the original string
            str = str.replaceFirst(sub_str,"");
        }

        return (str.length() == 0);
    }

// Driver code
    public static void main(String[] args) {
        String str = "GEEGEEKSKS", sub_str = "GEEKS";
        if (canBecomeEmpty(str, sub_str)) {
            System.out.print("\nYes");
        } else {
            System.out.print("\nNo");
        }
    }
}
// This code is contributed by 29AjayKumar

# Python3 program to check if a string can be
# converted to an empty string by deleting
# given sub-string from any position, any
# number of times.

# Returns true if str can be made empty by
# recursively removing sub_str.
def canBecomeEmpty(string, sub_str):
    while len(string) > 0:

        # idx: to store starting index of sub-
        #     string found in the original string
        idx = string.find(sub_str)

        if idx == -1:
            break

        # Erasing the found sub-string from
        # the original string
        string = string.replace(sub_str, "", 1)

    return (len(string) == 0)

# Driver code
if __name__ == "__main__":
    string = "GEEGEEKSKS"
    sub_str = "GEEKS"
    if canBecomeEmpty(string, sub_str):
        print("Yes")
    else:
        print("No")

# This code is contributed by
# sanjeev2552

// C# program to check if a string can be
// converted to an empty string by deleting
// given sub-string from any position, any
// number of times.
using System;
    
class GFG 
{

    // Returns true if str can be made empty by
    // recursively removing sub_str.
    static Boolean canBecomeEmpty(String str, String sub_str) 
    {
        while (str.Length > 0)
        {
            // idx: to store starting index of sub-
            //     string found in the original string
            int idx = str.IndexOf(sub_str);
            if (idx == -1)
            {
                break;
            }

            // Erasing the found sub-string from
            // the original string
            str = str.Replace(sub_str,"");
        }

        return (str.Length == 0);
    }

    // Driver code
    public static void Main(String[] args)
    {
        String str = "GEEGEEKSKS", sub_str = "GEEKS";
        if (canBecomeEmpty(str, sub_str))
        {
            Console.Write("\nYes");
        } 
        else
        {
            Console.Write("\nNo");
        }
    }
}

// This code is contributed by 29AjayKumar

// JS Code to Check if a string can become empty by 
// recursively deleting a given sub-string 

function canBecomeEmpty(str, sub_str) {
  while (str.length > 0) {
    // idx: to store starting index of sub-
    //      string found in the original string
    let idx = str.indexOf(sub_str);
    if (idx == -1)
      break;

    // Erasing the found sub-string from
    // the original string
    str = str.slice(0, idx) + str.slice(idx + sub_str.length);
  }

  return (str.length == 0);
}

// Driver code
let str = "GEEGEEKSKS", sub_str = "GEEKS";
if (canBecomeEmpty(str, sub_str))
  console.log("Yes");
else
  console.log("No");

Yes

Time Complexity: O(N^2)

Auxiliary Space: O(N+M), where N is the length of the string and M is the length of sub-string.

Method#2: One possible solution would be to use the regular expression. Regular expressions modules are very helpful with string. The regular expression module has a search function that is used to find the patterns in the string. And replace function is used for replacing the characters of string. 

Follow are the steps for our approach:

1. Use the re.search function on a string to find the pattern in a string. 
2. Use the re.replace function to replace the sub-string from a string. 
3. Repeat steps one and two until there is a sub-string in the string after replacing it. 
4. At last if the string is empty after all replacing then it can become empty else it cannot become empty.

Example

// C++ Program to check if a string can be
// converted to an empty string by deleting
// given sub-string from any position, any
// number of times.

#include <bits/stdc++.h>

using namespace std;

// Returns true if str can be made empty by
// recursively removing sub_str.
bool canBecomeEmpty(string str1, string sub_str)
{

    regex r(sub_str);
    smatch m;
    // matches words beginning by "Geek"

    while (regex_search(str1, m, r)) {
        //     regex_replace() for replacing the match with
        //     'geek'

        str1 = regex_replace(str1, r, "");
    }

    // Returning result
    return true ? str1 == "" : false;
}

// Driver code
int main()
{
    string s = "GeeksForGeeGeeksks";
    string k = "Geeks";
    if (canBecomeEmpty(s, k)) {
        cout << "\nYes";
    }
    else {
        cout << "\nNo";
    }

    return 0;
}

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

  // Returns true if str can be made empty by
  // recursively removing sub_str.
  static boolean canBecomeEmpty(String str1, String sub_str){
    Pattern r = Pattern.compile(sub_str);
    Matcher m;

    while((m = r.matcher(str1)).find()){
      // replaceAll() for replacing the match with ""
      str1 = m.replaceAll("");
    }

    // Returning result
    return str1.equals("");
  }

  // Driver code
  public static void main(String[] args) {
    String s = "GeeksForGeeGeeksks";
    String k = "Geeks";
    if (canBecomeEmpty(s, k)){
      System.out.println("Yes");
    }
    else {
      System.out.println("No");
    }
  }
}

# Python3 program to check if a string can be
# converted to an empty string by deleting
# given sub-string from any position, any
# number of times.
 
# Returns true if str can be made empty by
# recursively removing sub_str.
import re 


def canBecomeEmpty(string, sub_str):
    # finding sub-string in string
    while sub_str in string :
        # Replacing sub-string from string
        string = re.sub(sub_str, "", string)
    # Returning result
    return True if string == "" else False
    
    
# Driver code
if __name__ == "__main__":
    string = "GeeksforGeeGeeksks"
    sub_str = "Geeks"
    if canBecomeEmpty(string, sub_str):
        print("Yes")
    else:
        print("No")
        
 
# This code is contributed by
# sanjeev2552

// C# implementation
using System;
using System.Text.RegularExpressions;

public class Program
{
    // Returns true if str can be made empty by
    // recursively removing sub_str.
    static bool CanBecomeEmpty(string str1, string sub_str)
    {
        Regex r = new Regex(sub_str);
        // matches words beginning by "Geek"
        Match m;

        while (r.IsMatch(str1))
        {
            // Replace() for replacing the match with 'geek'
            str1 = r.Replace(str1, "");
        }

        // Returning result
        return str1 == "" ? true : false;
    }

    // Driver code
    public static void Main()
    {
        string s = "GeeksForGeeGeeksks";
        string k = "Geeks";
        if (CanBecomeEmpty(s, k))
        {
            Console.WriteLine("Yes");
        }
        else
        {
            Console.WriteLine("No");
        }
    }
}

// Javascript program to check if a string can be
// converted to an empty string by deleting
// given sub-string from any position, any
// number of times.

// Returns true if str can be made empty by
// recursively removing sub_str
function canBecomeEmpty(str,sub_str)
{   
    // Regular expression for sub_string
    const regex = new RegExp(sub_str);
    // Iterating over string until it matches sub_string
    while(regex.test(str)){
        // Replacing sub-string from string
    str = str.replace(regex, '')
        
    }
    // Returning result
        return false ? str : true ;
}

// Driver code
let str = "GeeksForGeeGeeksks", sub_str = "Geeks";
if (canBecomeEmpty(str, sub_str)) {
    console.log("Yes");
} else {
    console.log("No");
}


// This code is contributed by sam snehil

No