Question

更新（任务详细说明）：我们有一个由数字0和1组成的字符串，除以运算符|，^或＆amp ;.任务是创建所有完全括号的表达式。所以最终的表达方式应分为＆＃34; 2部分＆＃34;

例如

0^1 -> (0)^(1) but not extraneously: 0^1 -> (((0))^(1))

表达式1 | 0＆amp; 1：

的示例

(1)|((0)&(1))
((1)|(0))&(1)

正如您所看到的，上面的两个表达式都已离开并写入部分：

left: (1); right: ((0)&(1))
left: ((1)|(0)); right: (1)

我尝试了以下代码，但它无法正常工作（请参阅输出）：

// expression has type string
// result has type Array (ArrayList in Java)
function setParens(expression, result) {
  if (expression.length === 1) return "(" + expression + ")";


  for (var i = 0; i < expression.length; i++) {
    var c = expression[i];
    if (c === "|" || c === "^" || c === "&") {
        var left  = expression.substring(0, i);
        var right = expression.substring(i + 1);

         leftParen = setParens(left, result);
         rightParen = setParens(right, result);
         var newExp = leftParen + c + rightParen;
         result.push(newExp);
    }
  }
  return expression;    
}

function test() {
  var r = [];
  setParens('1|0&1', r);
  console.log(r);
}

test();

code output: ["(0)&(1)", "(0)|0&1", "(1)|(0)", "1|0&(1)"]

Answer 1

假设输入表达式尚未部分括号，并且您只想要完全括号结果：

FullyParenthesize(expression[1...n])

    result = {}

    // looking for operators
    for p = 1 to n do

        // binary operator; parenthesize LHS and RHS
        // parenthesize the binary operation
        if expression[p] is a binary operator then
            lps = FullyParenthesize(expression[1 ... p - 1])
            rps = FullyParenthesize(expression[p + 1 ... n])
            for each lp in lps do
                for each rp in rps do
                    result = result U {"(" + lp + expression[p] + rp + ")"}

    // no binary operations <=> single variable
    if result == {} then
        result = {"(" + expression + ")")}

    return result

示例：1 | 2＆amp; 3

FullyParenthesize("1|2&3")
    result = {}
    binary operator | at p = 2;
    lps = FullyParenthesize("1")
              no operators
              result = {"(" + "1" + ")"}
              return result = {"(1)"}
    rps = Parenthesize("2&3")
              result = {"2&3", "(2&3)"}
              binary operator & at p = 2
                  lps = Parenthesize("2")
                            no operators
                            result = {"(" + "2" + ")"}
                            return result = {"(2)"}
                  rps = Parenthesize("3")
                            no operators
                            result = {"(" + "3" + ")"}
                            return result = {"(3)"}
                  lp = "(2)"
                      rp = "(3)"
                          result = result U {"(" + "(2)" + "&" + "(3)" + ")"}
                  return result = {"((2)&(3))"}
    lp = "(1)"
        rp = "((2)&(3))"
            result = result U {"(" + "(1)" + "|" + "((2)&(3))" + ")"}

    binary operator & at p = 4
    ...
            result = result U {"(" + "((1)|(2))" + "&" + "(3)" + ")"}

    return result {"((1)|((2)&(3)))", "(((1)|(2))&(3))"}

给定带有k个二元运算符的输入表达式，您将拥有2 ^ k个唯一的完全带括号的表达式（没有重复的括号）。

生成N对括号的所有有效组合

1 个答案: