Question

我一直在做这个javascript挑战，而且我非常接近，但有些事情已经结束。这就是挑战：

给定一个包含三种类型大括号的字符串数组：round（），square []和curly {} 您的任务是编写一个函数来检查每个字符串中的大括号是否正确匹配。如果每个字符串中的大括号匹配，则将1打印到标准输出（console.log）;如果不匹配，则打印0（每行一个结果）

我的代码是：

var infoToParse = [ ")(){}", "[]({})", "([])", "{()[]}", "([)]" ]; 

function checkBraces(infoToParse) {
    var tabChars = infoToParse;
    for (i= 0; tabChars.length - 1; i+=1) {
        if (tabChars[i].charAt(0) === tabChars[i].charAt(tabChars[i].length-1)){
            console.log(1);
        }else{
            console.log(0);
        }
    }
}

checkBraces(infoToParse);

当前数组项的输出应为Output： 0 1 1 1 0

Answer 1

正如评论中指出的那样，只有第一个和最后一个字符相同才会产生正确的解决方案。

您可以尝试以下技巧：每次遇到一个开口支架，即圆形＆＃34;（＆＃34;，方形＆＃34; [＆＃34;或卷曲＆＃34; {＆＃34 ;;将其推入堆栈），保持堆叠。现在每当你遇到一个右括号时，从堆栈中弹出一个元素。如果这两个匹配，即两者都是相同的类型，那么继续直到堆栈和字符串都是空的。如果在任何时候这些都不匹配然后打破并返回false。我会为它编写代码并尽快发布。

Answer 2

如果你可以使用正则表达式，你可以真正减少它：

var stringArray = [ ")(){}", "[]({})", "([])", "{()[]}", "([)]" ]; 

function checkBraces(infoToParse) {
    for (i = 0; i < infoToParse.length; i += 1) {
    var regX = /^\[.*\]$|^\{.*\}$|^\(.*\)$/gi;
    var str = infoToParse[i];
    console.log(str.match(regX) ? 1 : 0);
    }
}

checkBraces(stringArray);

此外，正如我在评论中所述，您的语法已关闭。哦，而不是i + = 1，你可以使用i ++来简化它。

Answer 3

我猜你可以这样做，保持一个起始位置的“树”。没有测试任何其他测试用例而不是你自己的测试用例：）

var testCases = [")(){}", "[]({})", "([])", "{()[]}", "([)]"];

var braceType = {
  round: ["(", ")"],
  curly: ["{", "}"],
  square: ["[", "]"]
};

var bracePosition = {
  start: ["{", "(", "["],
  end: ["}", ")", "]"]
};

function typeOfBraces(sign) {
  for (var property in braceType) {
    if (braceType[property].indexOf(sign) < 0) {
      continue;
    }
    if (bracePosition.start.indexOf(sign) < 0) {
      return {
        type: property,
        position: "end"
      };
    } else {
      return {
        type: property,
        position: "start"
      };
    }
  }
  throw "Sign is not a brace!";
};

function Braces(brace, parent, type) {
  this.brace = brace;
  this.parent = parent || null;
  this.type = type || {
    type: 'init',
    position: ''
  };
  this.children = [];

  this.nextBrace = function(nextSign) {
    var nextType = typeOfBraces(nextSign);
    if (nextType.position === 'start') {
      var child = new Braces(nextSign, this, nextType);
      this.children.push(child);
      return child;
    }
    if (nextType.position === 'end') {
      if (this.type.position === '') {
        throw 'Cannot start with an end tag!';
      }
      if (this.type.position === 'end' && this.parent === null) {
        throw 'Cannot end the sequence';
      }
      if (this.type.position === 'end' && this.parent.position === 'start') {
        if (this.type.type === this.parent.type) {
          var child = new Braces(nextSign, this.parent, nextType);
          this.parent.children.add(child);
          return this.parent;
        }
      }
    }
    if (this.type.position === 'start' && nextType.type === this.type.type && nextType.position === 'end') {
      return this.parent;
    }
    return new Braces(nextSign, this, nextType);
  };
}

for (var i = 0; i < testCases.length; i++) {
  var brace = new Braces(testCases[i]);
  for (var j = 0, len = testCases[i].length; j < len; j++) {
    try {
      brace = brace.nextBrace(testCases[i][j]);
    } catch (e) {
      console.log(e);
      brace = null;
      break;
    }
  }
  if (brace != null && brace.parent == null) {
    // valid entry
    console.log(brace);
    console.log(testCases[i] + " is a valid sequence");
  } else {
    // invalid entry
    console.log(testCases[i] + " is an invalid sequence");
  }
}

或者，为了使它更容易并检查括号：

function validBraces(braceSequence) {
  var stack = '',
    i, len, lastStack = -1,
    toAdd = "{([",
    toRemove = "})]",
    sign;
  for (i = 0, len = braceSequence.length; i < len; i++) {
    sign = braceSequence[i];
    if (toAdd.indexOf(sign) >= 0) {
      stack += sign;
      lastStack++;
    } else if (toRemove.indexOf(sign) >= 0) {
      if (toAdd.indexOf(stack.charAt(lastStack)) !== toRemove.indexOf(sign)) {
        // format exception
        console.warn('Format exception, didn\'t expect ' + sign + ' (current stack: ' + stack + ')');
        return false;
      } else {
        stack = stack.slice(0, -1);
        lastStack--;
      }
    } else {
      console.warn('Invalid character exception, didn\'t expect ' + sign + ' (current stack: ' + stack + ')');
      return false;
    }
  }
  return true;
}

var testCases = [")(){}", "[]({})", "([])", "{()[]}", "([)]"];

for (var i = 0; i < testCases.length; i++) {
  if (validBraces(testCases[i])) {
    console.log(testCases[i] + ' is a valid sequence');
  } else {
    console.log(testCases[i] + ' is an invalid sequence');
  }
}

如何编写一个javascript函数来检查字符串中的第一个和最后一个字符是否相等

3 个答案: