Skip to content
Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Extract substrings between any pair of delimiters

  • Difficulty Level : Expert
  • Last Updated : 23 Apr, 2021

Given a string str, the task is to extract the substrings present between two delimiters, i.e. ‘[‘ and ‘]’.

Examples:

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: str = “[This is a string to be extracted]”
Output: This is a string to be extracted
Explanation: The square brackets ‘[‘ and ‘]’ serve as delimiters in the given string.



Input: str= “[This is first] ignored text [This is second]”
Output: 
This is first
This is second
Explanation: The square brackets ‘[‘ and ‘]’ serve as delimiters in the given string.

 

Stack-based Approach: Iterate over the characters of the string and insert the index of every ‘[‘ encountered into the stack. For every ‘]’ encountered, simply pop the index stored at the top of the stack and print the substring lying in between.

Below is the implementation of the above approach

C++




// C++ Program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to print strings present
// between any pair of delimeters
void printSubsInDelimeters(string str)
{
    // Stores the indices of
    stack<int> dels;
    for (int i = 0; i < str.size(); i++) {
        // If opening delimeter
        // is encountered
        if (str[i] == '[') {
            dels.push(i);
        }
 
        // If closing delimeter
        // is encountered
        else if (str[i] == ']' && !dels.empty()) {
 
            // Extract the position
            // of opening delimeter
            int pos = dels.top();
 
            dels.pop();
 
            // Length of substring
            int len = i - 1 - pos;
 
            // Extract the substring
            string ans = str.substr(
                pos + 1, len);
 
            cout << ans << endl;
        }
    }
}
 
// Driver Code
int main()
{
 
    string str = "[This is first] ignored text [This is second]";
 
    printSubsInDelimeters(str);
 
    return 0;
}

Java




// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
 
// Function to print Strings present
// between any pair of delimeters
static void printSubsInDelimeters(String str)
{
     
    // Stores the indices of
    Stack<Integer> dels = new Stack<Integer>();
    for(int i = 0; i < str.length(); i++)
    {
         
        // If opening delimeter
        // is encountered
        if (str.charAt(i) == '[')
        {
            dels.add(i);
        }
 
        // If closing delimeter
        // is encountered
        else if (str.charAt(i) == ']' &&
                 !dels.isEmpty())
        {
             
            // Extract the position
            // of opening delimeter
            int pos = dels.peek();
 
            dels.pop();
 
            // Length of subString
            int len = i - 1 - pos;
 
            // Extract the subString
            String ans = str.substring(
                pos + 1, pos + 1 + len);
 
            System.out.print(ans + "\n");
        }
    }
}
 
// Driver Code
public static void main(String[] args)
{
    String str = "[This is first] ignored text [This is second]";
 
    printSubsInDelimeters(str);
}
}
 
// This code is contributed by shikhasingrajput

Python3




# Python3 Program to implement
# the above approach
 
# Function to print strings present
# between any pair of delimeters
def printSubsInDelimeters(string) :
     
    # Stores the indices
    dels = [];
    for i in range(len(string)):
         
        # If opening delimeter
        # is encountered
        if (string[i] == '[') :
            dels.append(i);
 
        # If closing delimeter
        # is encountered
        elif (string[i] == ']' and len(dels) != 0) :
 
            # Extract the position
            # of opening delimeter
            pos = dels[-1];
            dels.pop();
 
            # Length of substring
            length = i - 1 - pos;
 
            # Extract the substring
            ans = string[pos + 1 : pos + 1 + length];
 
            print(ans);
 
# Driver Code
if __name__ == "__main__" :
 
    string = "[This is first] ignored text [This is second]";
 
    printSubsInDelimeters(string);
     
    # This code is contributed by AnkThon

C#




// C# program to implement
// the above approach
using System;
using System.Collections;
 
class GFG{
     
// Function to print strings present
// between any pair of delimeters
static void printSubsInDelimeters(string str)
{
     
    // Stores the indices of
    Stack dels = new Stack();
    for(int i = 0; i < str.Length; i++)
    {
         
        // If opening delimeter
        // is encountered
        if (str[i] == '[')
        {
            dels.Push(i);
        }
   
        // If closing delimeter
        // is encountered
        else if (str[i] == ']' && dels.Count > 0)
        {
             
            // Extract the position
            // of opening delimeter
            int pos = (int)dels.Peek();
   
            dels.Pop();
   
            // Length of substring
            int len = i - 1 - pos;
   
            // Extract the substring
            string ans = str.Substring(
                pos + 1, len);
   
            Console.WriteLine(ans);
        }
    }
}
 
// Driver Code
static void Main()
{
    string str = "[This is first] ignored text [This is second]";
     
    printSubsInDelimeters(str);
}
}
 
// This code is contributed by divyesh072019

Javascript




<script>
    // Javascript program to implement
    // the above approach
     
    // Function to print strings present
    // between any pair of delimeters
    function printSubsInDelimeters(str)
    {
 
        // Stores the indices of
        let dels = [];
        for(let i = 0; i < str.length; i++)
        {
 
            // If opening delimeter
            // is encountered
            if (str[i] == '[')
            {
                dels.push(i);
            }
 
            // If closing delimeter
            // is encountered
            else if ((str[i] == ']') &&
                     (dels.length > 0))
            {
 
                // Extract the position
                // of opening delimeter
                let pos = dels[dels.length - 1];
 
                dels.pop();
 
                // Length of substring
                let len = i - 1 - pos;
 
                // Extract the substring
                let ans;
                if(pos < len)
                {
                    ans = str.substring(pos + 1,
                                       len + 1);
                }
                else{
                    ans = str.substring(pos + 1,
                          len + pos + 1);
                }
                document.write(ans + "</br>");
            }
        }
    }
     
    let str = "[This is first] ignored text [This is second]";
      
    printSubsInDelimeters(str);
   
</script>
Output: 
This is first
This is second

 

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

Space-Efficient Approach: The idea is to use Regular Expressions to solve this problem. Create a regular expression to extract the string between two delimiters as regex = “\\[(.*?)\\]” and match the given string with the Regular Expression. Print the subsequence formed.

Below is the implementation of the above approach:

C++




// C++ program to implement
// the above approach
#include <iostream>
#include <regex>
using namespace std;
 
// Function to print Strings present
// between any pair of delimeters
void printSubsInDelimeters(string str)
{
     
    // Regex to extract the string
    // between two delimiters
    const regex pattern("\\[(.*?)\\]");
     
    for(sregex_iterator it = sregex_iterator(
        str.begin(), str.end(), pattern);
        it != sregex_iterator(); it++)
    {
         
        // flag type for determining the
        // matching behavior here it is
        // for matches on 'string' objects
        smatch match;
        match = *it;
         
        cout << match.str(1) << endl;
    }
    return;
}
 
// Driver Code
int main()
{
     
    // Input String
    string str = "[This is first] ignored text [This is second]";
     
    // Function Call
    printSubsInDelimeters(str);
     
    return 0;
}
 
// This code is contributed by yuvraj_chandra

Java




// Java program to implement
// the above approach
import java.util.regex.*;
 
class GFG{
 
// Function to print Strings present
// between any pair of delimeters
public static void printSubsInDelimeters(String str)
{
 
    // Regex to extract the string
    // between two delimiters
    String regex = "\\[(.*?)\\]";
 
    // Compile the Regex.
    Pattern p = Pattern.compile(regex);
 
    // Find match between given string
    // and regular expression
    // using Pattern.matcher()
    Matcher m = p.matcher(str);
 
    // Get the subsequence
    // using find() method
    while (m.find())
    {
        System.out.println(m.group(1));
    }
}
 
// Driver code
public static void main(String args[])
{
     
    // Input String
    String str = "[This is first] ignored text [This is second]";
 
    // Function Call
    printSubsInDelimeters(str);
}
}

Python3




# Python3 program to implement
# the above approach
import re
 
# Function to print Strings present
# between any pair of delimeters
def printSubsInDelimeters(str):
 
    # Regex to extract the string
    # between two delimiters
    regex = "\\[(.*?)\\]"
 
    # Find match between given string
    # and regular expression
    # using re.findall()
    matches = re.findall(regex, str)
 
    # Print the matches
    for match in matches:
        print(match)
 
# Driver code
 
# Input String
str = "[This is first] ignored text [This is second]"
 
# Function Call
printSubsInDelimeters(str)
 
# This code is contributed by yuvraj_chandra
Output: 
This is first
This is second

 

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

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :