Playground: Paréntesis Válido

Clase 27 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

Alvaro Diego Pérez Vázquez

student•

my code in java, solved in leetcode


   
    
  
    public boolean isValid(String s) {
        Stack<Character> pila = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            //Valid incorrect case
            if(s.charAt(i) == ')'){
                if(pila.empty() || pila.peek() != '('){
                    return false;
                }
                pila.pop();
                
            }else if(s.charAt(i) == ']'){
                if(pila.empty() || pila.peek() != '['){
                    return false;
                }
                pila.pop();
            }else if(s.charAt(i) == '}'){
                if(pila.empty() || pila.peek() != '{'){
                    return false;
                }
                pila.pop();
            }else{
                if(s.charAt(i) == '('){
                 pila.push(s.charAt(i));
                }if(s.charAt(i) == '['){
                    pila.push(s.charAt(i));
                }if(s.charAt(i) == '{'){
                    pila.push(s.charAt(i));
                } 
            }
        }
        return pila.empty();
    }

Pedro Vega Estrada

student•

Este fue mi código, sí consideran que se puede optimizar les agradecería el aporte :)

def isValid(string):
   stack = []
   for s in string: 
      try:
         if s == '(':
            stack.append(s)
         if s == ')':
            stack.pop()
      except:
         return False
   if len(stack) > 0 : return False
   return True

Gabriel Revelo

student•

en lugar de if len(stack) > 0 : return False return True puede ir
return len(stack)==0

John Eduard Meneses González

student•

My solution!

Cristian Camilo Vargas Peña

student•

Carlos Hernandez

student•

Mi solución en Python:

def isValid(s):
   length = len(s)
   open_counter, close_counter = 0, 0

   for char in s:
      if char == '(':
        open_counter += 1
      if char == ')':
         close_counter += 1
         if close_counter > open_counter:
            return False
   
   return open_counter == close_counter
```Y en Javascript:

```js
const validParenthesis = (searchString) => {
    const length = searchString.length;

    let openCounter = 0, closeCounter = 0;

    for (let index = 0; index < length; index++) {
        const currentChar = searchString[index];
        
        if (currentChar === '(') {
            openCounter++;
        }

        if (currentChar === ')') {
            closeCounter++;
            if (closeCounter > openCounter) return false;
        }
    }

    return openCounter === closeCounter;
}

Miguel Angel Reyes Moreno

student•

def isValid(s): 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

Juan Pablo Reina Gutierrez

student•

Mi respuesta:

Rafael Estiven Uribe Álvarez

student•

Mi respuesta:

Nicolas Alpargatero

student•

Said Josue Calixtro Maldonado

student•

Este es mi código del mismo problema en Leetcode pero usando llaves, corchetes y paréntesis.

class Solution:
    def isValid(self, s: str) -> bool:
        pairs = {
            '{': '}',
            '(': ')',
            '[': ']'
        }
        parentheses = []
        # Iterar en cada letra de la string
        for a in s:
            # Si encontramos uno de apertura lo añadimos al stack
            if a in pairs.keys():
                parentheses.append(a)
            # Si encontramos uno de cierre entonces
            elif a in pairs.values():
                if not parentheses:
                    return False
                if pairs[parentheses[-1]] == a:
                    parentheses.pop()
                else:
                    return False
        return not parentheses

   
    
  
    public boolean isValid(String s) {
        Stack<Character> pila = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            //Valid incorrect case
            if(s.charAt(i) == ')'){
                if(pila.empty() || pila.peek() != '('){
                    return false;
                }
                pila.pop();
                
            }else if(s.charAt(i) == ']'){
                if(pila.empty() || pila.peek() != '['){
                    return false;
                }
                pila.pop();
            }else if(s.charAt(i) == '}'){
                if(pila.empty() || pila.peek() != '{'){
                    return false;
                }
                pila.pop();
            }else{
                if(s.charAt(i) == '('){
                 pila.push(s.charAt(i));
                }if(s.charAt(i) == '['){
                    pila.push(s.charAt(i));
                }if(s.charAt(i) == '{'){
                    pila.push(s.charAt(i));
                } 
            }
        }
        return pila.empty();
    }

def isValid(string):
   stack = []
   for s in string: 
      try:
         if s == '(':
            stack.append(s)
         if s == ')':
            stack.pop()
      except:
         return False
   if len(stack) > 0 : return False
   return True
   

def isValid(s):
   length = len(s)
   open_counter, close_counter = 0, 0

   for char in s:
      if char == '(':
        open_counter += 1
      if char == ')':
         close_counter += 1
         if close_counter > open_counter:
            return False
   
   return open_counter == close_counter
```Y en Javascript:

```js
const validParenthesis = (searchString) => {
    const length = searchString.length;

    let openCounter = 0, closeCounter = 0;

    for (let index = 0; index < length; index++) {
        const currentChar = searchString[index];
        
        if (currentChar === '(') {
            openCounter++;
        }

        if (currentChar === ')') {
            closeCounter++;
            if (closeCounter > openCounter) return false;
        }
    }

    return openCounter === closeCounter;
}

class Solution:
    def isValid(self, s: str) -> bool:
        pairs = {
            '{': '}',
            '(': ')',
            '[': ']'
        }
        parentheses = []
        # Iterar en cada letra de la string
        for a in s:
            # Si encontramos uno de apertura lo añadimos al stack
            if a in pairs.keys():
                parentheses.append(a)
            # Si encontramos uno de cierre entonces
            elif a in pairs.values():
                if not parentheses:
                    return False
                if pairs[parentheses[-1]] == a:
                    parentheses.pop()
                else:
                    return False
        return not parentheses

Playground: Paréntesis Válido

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