Как проверить последовательность открывающих и закрывающих скобок в строке?

Question

Необходимо найти открытые и закрытые скобки, если последовательность открывающих и закрывающих скобок нарушена, а затем вернуть false.

Но если не вернуть правый массив для сравнения с левым массивом, я не будусделайте контрольные скобки здесь {[(3+1)+2]+}.И если наоборот, как сейчас, то я не могу проверить здесь [1+1]+(2*2)-{3/3}

function brackets(expression){
    let leftArr=[];
    let rightArr = [];
    for(let i=0; i<expression.length; i++){
    		if(expression[i] === '(' || expression[i] === '[' || expression[i] === "{"){
        	leftArr.push(expression[i]);
        }
        
        
        if(expression[i] === ')'){
      
        		rightArr.push("(");
        }else if(expression[i] === '}'){
        
        		rightArr.push("{");
        } else if(expression[i] === ']'){
        
        		rightArr.push("[");
        }
   }
		
   rightArr.reverse();
    
    if(leftArr.length<rightArr.length || leftArr.length>rightArr.length){
    return false;
    }
    
    for(let k=0; k<leftArr.length; k++) {
    		if(leftArr[k] != rightArr[k]){
        		return false;
        }
    }

    return true;
}



console.log(brackets('(3+{1-1)}')); // false
console.log(brackets('{[(3+1)+2]+}')); //true
console.log(brackets('[1+1]+(2*2)-{3/3}')); //true
console.log(brackets('(({[(((1)-2)+3)-3]/3}-3)')); //false

Answer 1

Вы можете использовать функцию String.prototype.replace, чтобы собрать скобки и использовать вид стека для сравнения каждого символа.Стек полезен для того, чтобы узнать, какой была последняя поставленная скобка.

let check = (e) => {
  let brackets = [],
      stack = [],
      map = {'}': '{', ']': '[', ')': '('};

  e.replace(/[\[\]\{\}\(\)]/g, (m) => m && brackets.push(m));

  for (let i = 0, {length} = brackets; i < length; i++) {
    if (['}', ']', ')'].includes(brackets[i])) {
      if (stack.pop() !== map[brackets[i]]) return false;
    } else stack.push(brackets[i]);
  }

  return !stack.length;
};
    
    
console.log(check('(3+{1-1)}')); // false
console.log(check('{[(3+1)+2]+}')); //true
console.log(check('[1+1]+(2*2)-{3/3}')); //true
console.log(check('(({[(((1)-2)+3)-3]/3}-3)')); //false

Answer 2

Прямо сейчас вы получаете каждую открытую скобку в один массив, затем вставляете открытую скобку для каждой закрывающей скобки в другой массив, а затем сравниваете их.Это немного расточительно.

Вместо этого вы можете поддерживать стек.Поместите открытый тег в стек, и если вы обнаружите закрывающую скобку - выскочите из стека

• , если в стеке нет совпадений или ничего нет, завершите с ошибкой
• если вы закончите с размером стека, равным нулю, вы добьетесь успеха

function brackets(expression) {
  let stack = [];
  let current;
  const matchLookup = {
        "(": ")", 
        "[": "]", 
        "{": "}", 
      };
                    
  for (let i = 0; i < expression.length; i++) {
    current = expression[i]; //easier than writing it over and over
    
    if (current === '(' || current === '[' || current === "{") {
      stack.push(current);
      
    } else if (current === ')' || current === ']' || current === "}") {
      const lastBracket = stack.pop();
      
      if (matchLookup[lastBracket] !== current) { //if the stack is empty, .pop() returns undefined, so this expression is still correct
      
        return false; //terminate immediately - no need to continue scanning the string
      }
    }
  }
  
  return stack.length === 0; //any elements mean brackets left open
}

console.log(brackets('(3+{1-1)}')); // false
console.log(brackets('{[(3+1)+2]+}')); //true
console.log(brackets('[1+1]+(2*2)-{3/3}')); //true
console.log(brackets('(({[(((1)-2)+3)-3]/3}-3)')); //false

Я использовал объект для поиска значений, но он не обязательно должен быть одним.Альтернативой является использование двух массивов, которые необходимо синхронизировать

opening = ["(", "[", "{"]
closing = [")", "]", "}"]

С другой стороны, если они у вас есть, вы можете сократить свои if чеки до if (open.includes(current)) и if (closing.includes(current)).

Answer 3

В кратчайшие сроки, с комментариями к строкам, которые, вероятно, сбивают вас с толку <3 </p>

function check(expr){
    let holder = []
    let openBrackets = ['(','{','[']
    let closedBrackets = [')','}',']']
    for(let letter of expr){ // loop trought all letters of expr
        if(openBrackets.includes(letter)){ // if its oppening bracket
            holder.push(letter)
        }else if(closedBrackets.includes(letter)){ // if its closing
            let openPair = openBrackets[closedBrackets.indexOf(letter)] // find his pair
            if(holder[holder.length - 1] === openPair){ // check if that pair is last element in array
                holder.splice(-1,1) //if so, remove it
            }else{ // if its not
                holder.push(letter)
                break // exit loop
            }
        }
    }
    return (holder.length === 0) // return true if length is 0, otherwise false
}
check('[[{asd}]]') /// true

Answer 4

Я надеюсь, что это решит вашу проблему ...

function brackets(expression) {
    let leftArr=[];
    
    for(let i=0; i<expression.length; i++) {
        if(expression[i] === '(' || expression[i] === '[' || expression[i] === "{") {
            leftArr.push(expression[i]);
        } 
        
        let leftArrLength = leftArr.length;
        
        if(expression[i] === ')' && leftArr[leftArrLength - 1] === '('){
            leftArr.pop();
        }else if(expression[i] === '}' && leftArr[leftArrLength - 1] === '{') {
            leftArr.pop();
        } else if(expression[i] === ']' && leftArr[leftArrLength - 1] === '[') {  
            leftArr.pop();
        }
        else if(expression[i] === ')' || expression[i] === '}' || expression[i] === ']'){
         return false;
        }
    }
	
    return leftArr.length === 0;
}



console.log(brackets('(3+{1-1)}')); // false
console.log(brackets('{[(3+1)+2]+}')); //true
console.log(brackets('[1+1]+(2*2)-{3/3}')); //true
console.log(brackets('(({[(((1)-2)+3)-3]/3}-3)')); //false
console.log(brackets('(((([[[[{{{3}}}]]]]))))')); //false