Специальные символы сравнения строк в javascript

Question

Строка ввода для следующей функции: "()[]{}"

var isValid = function(s) {
  if ((s.length == 2 && s[0] == s[1]) || s.trim().length == 0) {
    return true;
  }
  if (s.length % 2 != 0) {
    return false;
  }
  for (let i = s.length / 2, j = i - 1; i < s.length && j >= 0; i++, j--) {
    console.log(s[j], s[i])
    if (s[i].charCodeAt(0) !== s[j].charCodeAt(0)) {
      console.log("false", s[j].length, s[i].length)
      return false;
    }
  }
  return true;
};

, когда она сравнивает [и], она входит в условие if внутри for для l oop и возвращает false.

Я попытался сравнить s[i] != s[j], но та же проблема.

description:

Задана строка, содержащая только символы '(', ')', '{', '}' , '[' и ']' определяют допустимость входной строки.

Входная строка действительна, если:

Open brackets must be closed by the same type of brackets.
Open brackets must be closed in the correct order.

Обратите внимание, что пустая строка также считается действительной.

Example 1:

Input: "()"
Output: true

Example 2:

Input: "()[]{}"
Output: true

Example 3:

Input: "(]"
Output: false

Example 4:

Input: "([)]"
Output: false

Answer 1

Использование Regex значительно упрощает проверку. проверка проверит наличие / (() | {} | []) / g , а при обнаружении (), {} или [] удалит его из строки до строка пуста.

допустим, у нас есть эта строка "([]) {} {[]} ()" , поэтому функция будет продолжать удалять (), {} или [] , пока не удалите всю строку. если строка не была пустой после окончания l oop, это означает, что есть дополнительные (, {или [. Функция не видит (), {} или [ ] когда они внешние, просто продолжайте удалять внутреннее, пока внешнее существо не будет внутренним.

function validParentheses(parens) {
  while(/(\(\)|\{\}|\[\])/g.test(parens)) parens = parens.replace(/(\(\)|\{\}|\[\])/g, '');
  return parens ? false : true;
}

console.log(validParentheses('(([{}]){}[])()'));

Answer 2

Для простых тестовых случаев это так же просто, как зацикливание массива по двое и проверка соответствия символов

var oppBracket = {
  '(': ')',
  '{': '}',
  '[': ']'
}

function test(str) {
  // loop over the array by twos
  for (var i = 0; i < str.length; i += 2) {
    // grab the closing bracket that matches the opening bracket
    var opp = oppBracket[str[i]]
    // if we do not have a closing bracket it is false
    // if the next index does not match the closing we found, it fails
    if (!opp || opp !== str[i + 1]) return false
  }
  // if we get here, all the pairs matched
  return true
}

console.log(test("()"))
console.log(test("()[]{}"))
console.log(test("()[]}{"))

В реальных тестовых случаях он может быть вложенным, и этот метод завершится ошибкой. Так что это просто поп и пу sh

var openBracket = {
  '(': ')',
  '{': '}',
  '[': ']'
}

function test(str) {
  // opens will hold all the brackets that are not matched
  var opens = []
  // Loop over all the characters in the string
  for (var i = 0; i < str.length; i++) {
    // grab the current character
    var current = str[i]
    // see if it is an opening bracket
    var open = openBracket[current]
    if (open) {
      // if it is push the closing character onto the stack of unclosed brackets
      opens.push(open)
    } else {
      // if it is pop off the last open bracket
      var expecting = opens.pop()
      // see if the current closing bracket matches the last open
      if (current !== expecting) {
        // if it does not the test fails
        return false
      }
    }
  }
  // if we make it here, all the brackets were closed if array is empty
  return opens.length === 0
}

console.log(test("()"))
console.log(test("()[]{}"))
console.log(test("()[]}{"))
console.log(test("(((([]{}))))"))
console.log(test("(((((((((("))

Answer 3

Здесь ввод строки может быть пустым "" или комбинацией '(', ')', '{', '}', '[', ']'. Итак, сначала возьмите пустой массив . начать итерацию всех символов входной строки в al oop, когда открытый символ прибывает pu sh в массив. Позже, когда любой закрытый символ прибывает первым, проверьте, существует ли открытый символ этой записи ( например '[' открытый символ записи ']' ) или нет в массиве, и это должна быть последняя запись массив. Если найдено pop it. После проверки всех итераций, если массив пуст, верните true в противном случае false

var isValid = function(s){
    var arr = [];
    for(var i = 0; i<s.length; i++){
        if(s[i] === '(' || s[i] === '{' || s[i] === '[') arr.push(s[i]);
        else{
                if(arr.length === 0) return false;
                switch(s[i]){
                case ')':
                    if(arr[arr.length-1]  === '(') arr.pop();
                    break;
                case '}':
                    if(arr[arr.length-1]  === '{') arr.pop();
                    break;
                case ']':
                    if(arr[arr.length-1]  === '[') arr.pop();
                    break;
            }
        }
    }
    if(arr.length === 0) return true;
    return false;
}

Answer 4

Вы можете попробовать вот так. Здесь я удалил многие части вашего написанного кода и заставил его работать.

Примечание: Поскольку объект JavaScript очень быстрый в случае поиска, поэтому я использовал для отображения связанные скобки. Код просто прост, поэтому я не добавил комментарии.

Вы также можете проверить приведенный ниже код на https://rextester.com/CJMZ17507.

//nodejs v4.2.6
var brackets = {
    "(": ")",
    "[": "]",
    "{": "}"
}

var isValid = function(s) {
    var valid = false
    var index = 0

    if(s.length % 2 !== 0)
        return false

    while(index < s.length -1){
        ch = s[index]
        if(ch in brackets) {
            if(brackets[ch] === s[index + 1]) {
                index += 2
                valid = true
                continue
            } else {
                valid = false
                break
            }
        } else {
            valid = false
            break
        }
    }

    if(valid === false && s.length === 0) {
        valid = true
    }

    return valid;
};

console.log(isValid("[]{}()")) // true
console.log(isValid("[]")) // true
console.log(isValid("")) // true
console.log(isValid("[]{})")) // false
console.log(isValid("[]}{")) // false
console.log(isValid("[]{}(())")) // false
console.log(isValid("([)]")) // false
console.log(isValid("(]")) // false