Programando Paréntesis Válido con C++

Clase 28 de 41 • Curso de Algoritmos Avanzados: Estructuras de Datos Lineales

Contenido del curso

Introducción

1
¿Ya tomaste el Curso Avanzado de Algoritmos: Patrones de Arrays y Strings?
00:52 min

Lista Enlazada

Pilas y colas

Colas de prioridad

Próximos pasos

41
Toma el Curso Avanzado de Algoritmos: Grafos y Árboles
00:33 min

Tomar examen

Comentarios

John Eduard Meneses González

student•

My solution!!

REYNALDO FABIAN NORIEGA ZAMBRANO

student•

//solucion en C++ sin usar un arry extra
bool isValid(string s){

	int stack = 0;
	for(auto character : s){
		if(stack < 0) return false;
		if(character == '(') stack++;
		else if(character == ')') stack--;
	}
	
	if (stack > 0) return false;

	return true;

};

Miguel Angel Reyes Moreno

student•

con Python:

class Solution:

def isValid(self, s: str) -> bool:

stack = []

mapping = {

')': '(',

'}': '{',

']': '['

}

for char in s:

if char in mapping:

top_element = stack.pop() if stack else '#'

if mapping[char] != top_element:

return False

else:

stack.append(char)

return not stack

Luis Angel Flores Galindo

student•

En javapublic class Pila {

public static void main(String[] args) { String cadena = "((a)*d)"; // true boolean validCharacter = isValidString(cadena);

System.out.println("La cadena : '" + cadena + "' es " + validCharacter); }

public static boolean isValidString(String cadena) { Stack<String> pila = new Stack<>();

for (String character : cadena.split("")) { if (character.equals(")")) { if (pila.isEmpty()) { return false; }

pila.pop(); } else if (character.equals("(")) { pila.push("("); } }

System.out.println("Pila: " + pila);

return pila.empty(); }

}

public class Pila {

    public static void main(String[] args) {
        String cadena = "((a)*d)"; // true
        boolean validCharacter = isValidString(cadena);

        System.out.println("La cadena : '" + cadena + "' es " + validCharacter);
    }

    public static boolean isValidString(String cadena) {
        Stack<String> pila = new Stack<>();

        for (String character : cadena.split("")) {
            if (character.equals(")")) {
                if (pila.isEmpty()) {
                    return false;
                }

                pila.pop();
            } else if (character.equals("(")) {
                pila.push("(");
            }
        }

        System.out.println("Pila: " + pila);

        return pila.empty();
    }

}

Luis Angel Flores Galindo

student•

En java 

public class Pila {

    public static void main(String[] args) {
        String cadena = "((a)*d)"; // true
        boolean validCharacter = isValidString(cadena);

        System.out.println("La cadena : '" + cadena + "' es " + validCharacter);
    }

    public static boolean isValidString(String cadena) {
        Stack<String> pila = new Stack<>();

        for (String character : cadena.split("")) {
            if (character.equals(")")) {
                if (pila.isEmpty()) {
                    return false;
                }

                pila.pop();
            } else if (character.equals("(")) {
                pila.push("(");
            }
        }

        System.out.println("Pila: " + pila);

        return pila.empty();
    }

}

Nicolas Alpargatero

student•

Comparto código de la profesora en Python, por cursos anteriores que he tomado llegue a creer que stacks siempre era mejor con Nodos.

//solucion en C++ sin usar un arry extra
bool isValid(string s){

	int stack = 0;
	for(auto character : s){
		if(stack < 0) return false;
		if(character == '(') stack++;
		else if(character == ')') stack--;
	}
	
	if (stack > 0) return false;

	return true;

};

public class Pila {

    public static void main(String[] args) {
        String cadena = "((a)*d)"; // true
        boolean validCharacter = isValidString(cadena);

        System.out.println("La cadena : '" + cadena + "' es " + validCharacter);
    }

    public static boolean isValidString(String cadena) {
        Stack<String> pila = new Stack<>();

        for (String character : cadena.split("")) {
            if (character.equals(")")) {
                if (pila.isEmpty()) {
                    return false;
                }

                pila.pop();
            } else if (character.equals("(")) {
                pila.push("(");
            }
        }

        System.out.println("Pila: " + pila);

        return pila.empty();
    }

}

En java 

public class Pila {

    public static void main(String[] args) {
        String cadena = "((a)*d)"; // true
        boolean validCharacter = isValidString(cadena);

        System.out.println("La cadena : '" + cadena + "' es " + validCharacter);
    }

    public static boolean isValidString(String cadena) {
        Stack<String> pila = new Stack<>();

        for (String character : cadena.split("")) {
            if (character.equals(")")) {
                if (pila.isEmpty()) {
                    return false;
                }

                pila.pop();
            } else if (character.equals("(")) {
                pila.push("(");
            }
        }

        System.out.println("Pila: " + pila);

        return pila.empty();
    }

}

Programando Paréntesis Válido con C++

Introducción

¿Ya tomaste el Curso Avanzado de Algoritmos: Patrones de Arrays y Strings?

Lista Enlazada

Estructura de datos: Lista Enlazada

Programando listas enlazadas con Java

Cómo Invertir una Lista Enlazada

Odd Even Linked List: análisis del problema

Solución de Odd Even Linked List

Playground: Odd Even Liked List

Programando Odd Even Linked List con C++

Linked List Cycle: análisis del problema

Solución de Linked List Cycle

Playground: Linked List Cycle

Programando Linked List Cycle con Python

Palindrome Linked List: análisis del problema

Solución de Palindrome Linked List

Playground: Palindrome Linked List

Programando Palindrome Linked List con Java

Reorder List: análisis del problema

Solución de Reorder List

Programando Reorder List con JavaScript

Playground: Reorder List Without Repeated Values

Reto: LRU Caché

Ejercicios Prácticos con Listas Enlazadas y Historial de Navegador

Operaciones con Listas Enlazadas: Suma, Intercambio y Navegador

Pilas y colas

Estructura de datos: Pilas y Colas

Paréntesis Válido: análisis del problema

Solución de Paréntesis Válido

Playground: Paréntesis Válido