Playground: Paréntesis Válido

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();
    }

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
   

My solution! 


Mi solución en Python: ```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; } ```

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

Mi respuesta: 

Mi respuesta: 

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