Extraer substrings entre cualquier par de delimitadores

Dada una string str , la tarea es extraer las substrings presentes entre dos delimitadores, es decir, ‘[‘ y ‘]’ .

Ejemplos:

Entrada: str = “[Esta es una string para extraer]”
Salida: Esta es una string para extraer
Explicación: Los corchetes ‘[‘ y ‘]’ sirven como delimitadores en la string dada.

Entrada: str= “[Esto es primero] texto ignorado [Esto es segundo]”
Salida: 
Esto es primero
Esto es segundo
Explicación: Los corchetes ‘[‘ y ‘]’ sirven como delimitadores en la string dada.

Enfoque basado en la pila : iterar sobre los caracteres de la string e insertar el índice de cada ‘[‘ encontrado en la pila. Para cada ‘]’ encontrado, simplemente extraiga el índice almacenado en la parte superior de la pila e imprima la substring que se encuentra en el medio.

A continuación se muestra la implementación del enfoque anterior.

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

Complejidad temporal: O(N)
Espacio auxiliar: O(N)

Enfoque de uso eficiente del espacio: la idea es usar expresiones regulares para resolver este problema. Cree una expresión regular para extraer la string entre dos delimitadores como regex = «\\[(.*?)\\]» y haga coincidir la string dada con la expresión regular. Imprime la subsecuencia formada.

A continuación se muestra la implementación del enfoque anterior:

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

This is first
This is second

Complejidad temporal: O(N)
Espacio auxiliar: O(1)