Open In App
Related Articles

Extract substrings between any pair of delimiters

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

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

// C++ Program to implement
// the above approach
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to print strings present
// between any pair of delimiters
void printSubsInDelimiters(string str)
{
    // Stores the indices of
    stack<int> dels;
    for (int i = 0; i < str.size(); i++) {
        // If opening delimiter
        // is encountered
        if (str[i] == '[') {
            dels.push(i);
        }
  
        // If closing delimiter
        // is encountered
        else if (str[i] == ']' && !dels.empty()) {
  
            // Extract the position
            // of opening delimiter
            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]";
  
    printSubsInDelimiters(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 delimiters
static void printSubsInDelimiters(String str)
{
      
    // Stores the indices of
    Stack<Integer> dels = new Stack<Integer>();
    for(int i = 0; i < str.length(); i++)
    {
          
        // If opening delimiter
        // is encountered
        if (str.charAt(i) == '[')
        {
            dels.add(i);
        }
  
        // If closing delimiter
        // is encountered
        else if (str.charAt(i) == ']' &&
                 !dels.isEmpty())
        {
              
            // Extract the position
            // of opening delimiter
            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]";
  
    printSubsInDelimiters(str);
}
}
  
// This code is contributed by shikhasingrajput

                    

Python3

# Python3 Program to implement
# the above approach
  
# Function to print strings present
# between any pair of delimiters
def printSubsInDelimiters(string) :
      
    # Stores the indices 
    dels = [];
    for i in range(len(string)): 
          
        # If opening delimiter
        # is encountered
        if (string[i] == '[') :
            dels.append(i);
  
        # If closing delimiter
        # is encountered
        elif (string[i] == ']' and len(dels) != 0) :
  
            # Extract the position
            # of opening delimiter
            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]";
  
    printSubsInDelimiters(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 delimiters 
static void printSubsInDelimiters(string str) 
      
    // Stores the indices of 
    Stack dels = new Stack(); 
    for(int i = 0; i < str.Length; i++) 
    {
          
        // If opening delimiter 
        // is encountered 
        if (str[i] == '['
        {
            dels.Push(i); 
        
    
        // If closing delimiter 
        // is encountered 
        else if (str[i] == ']' && dels.Count > 0)
        
              
            // Extract the position 
            // of opening delimiter 
            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]"
      
    printSubsInDelimiters(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 delimiters
    function printSubsInDelimiters(str)
    {
  
        // Stores the indices of
        let dels = [];
        for(let i = 0; i < str.length; i++)
        {
  
            // If opening delimiter
            // is encountered
            if (str[i] == '[')
            {
                dels.push(i);
            }
  
            // If closing delimiter
            // is encountered
            else if ((str[i] == ']') && 
                     (dels.length > 0))
            {
  
                // Extract the position
                // of opening delimiter
                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]";
       
    printSubsInDelimiters(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 delimiters
void printSubsInDelimiters(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
    printSubsInDelimiters(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 delimiters
public static void printSubsInDelimiters(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
    printSubsInDelimiters(str);
}
}

                    

Python3

# Python3 program to implement
# the above approach
import re
  
# Function to print Strings present
# between any pair of delimiters
def printSubsInDelimiters(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
printSubsInDelimiters(str)
  
# This code is contributed by yuvraj_chandra

                    

C#

// C# program to implement
// the above approach
using System;
using System.Text.RegularExpressions;
  
class GFG{
  
// Function to print Strings present
// between any pair of delimiters
public static void printSubsInDelimiters(string str)
{
  
    // Regex to extract the string
    // between two delimiters
    string regex = "\\[(.*?)\\]";
  
    // Compile the Regex.
    Regex p = new Regex(regex);
  
    // Find match between given string
    // and regular expression
    // using Pattern.matcher()
    Match m = p.Match(str);
  
    // Get the subsequence
    // using find() method
    while (m.Success)
    {
        Console.WriteLine(m.Value);
        m=m.NextMatch();
    }
}
  
// Driver code
public static void Main()
{
      
    // Input String
    string str = "[This is first] ignored text [This is second]";
  
    // Function Call
    printSubsInDelimiters(str);
}
}
  
// This code is contributed by Aman Kumar.

                    

Javascript

// Javascript program to implement
// the above approach
  
// Function to print Strings present
// between any pair of delimiters
function printSubsInDelimiters(str)
{
  
    // Regex to extract the string
    // between two delimiters
    let regex = "\\[(.*?)\\]";
      
    // Find match between given string
    // and regular expression
    // using str.matchAll
    let matches = [...str.matchAll(regex)];
  
    // Print the matches
    for(let match in matches)
        {
            console.log(matches[(match][1])+"<br>");
        }
}
  
// Driver code
      
    // Input String
    let str = "[This is first] ignored text [This is second]";
  
    // Function Call
    printSubsInDelimiters(str);
  
// This code is contributed by Pushpesh Raj.

                    

Output: 
This is first
This is second

 

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


 



Last Updated : 24 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads