Skip to content
Related Articles

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
Previous
TRANSLATE() Function in SQL Server
Next

RSA and Digital Signatures
Recommended Articles
Page :
Reverse substrings between each pair of parenthesis
23, Dec 19
Count pair of strings whose concatenation of substrings form a palindrome
20, Jun 20
Count pairs of substrings from a string S such that S1 does not occur after S2 in each pair
04, Jan 21
Longest substring between any pair of occurrences ōf similar characters
20, Oct 20
Rearrange a string to maximize the minimum distance between any pair of vowels
29, Jan 21
Maximize partitions such that no two substrings have any common character
25, Jun 20
Count of quadruples with product of a pair equal to the product of the remaining pair
08, Feb 21
Modify a Binary String by flipping characters such that any pair of indices consisting of 1s are neither co-prime nor divisible by each other
02, Mar 21
Minimize flips required such that string does not any pair of consecutive 0s
03, Feb 21
Check if any pair of consecutive 1s can be separated by at most M 0s by circular rotation of a Binary String
25, Mar 21
Print all possible palindromic string formed using any pair of given strings
09, Jul 20
String matching with * (that matches with any) in any of the two strings
11, Nov 18
Check if any K ranges overlap at any point
28, Oct 19
Check if a numeric string can be split into substrings having difference between consecutive numbers equal to K
18, Jun 21
Program to extract words from a given String
15, Jun 17
Extract maximum numeric value from a given string | Set 1 (General approach)
26, Jun 17
Extract maximum numeric value from a given string | Set 2 (Regex approach)
03, Jul 17
Extract all integers from string in C++
26, Aug 17
Python Regex to extract maximum numeric value from a string
28, Nov 17
Extract all capital words from Dataframe in Pandas
22, Dec 20
Extract all integers from the given string in Java
14, Oct 19
Extract and print words separately from a given Camel Case string
26, Jun 20
Java Program to Extract a Image From a PDF
15, Nov 20
How to extract frequency associated with fft values in Python?
25, Dec 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
prashant_srivastava
@prashant_srivastava
Vote for difficulty
Current difficulty :
Expert





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox