Extract substrings between any pair of delimiters

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)