Skip to content
Related Articles

Related Articles

Extract substrings between any pair of delimiters
  • Difficulty Level : Expert
  • Last Updated : 14 Jan, 2021

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

Examples:

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


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:

Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java programfor the above approach
 
import java.util.regex.*;
class GFG {
 
    // Function to extract the
    // string between two delimiters
    public static void extractString(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 str1
            = "[This is first]ignored text[This is second]";
 
        // Function Call
        extractString(str1);
    }
}

chevron_right


Output: 

This is first
This is second

 

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

 

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :