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++ 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 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 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# 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 |
<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> |
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++ 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 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 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# 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 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. |
This is first This is second
Time Complexity: O(N)
Auxiliary Space: O(1)