精华内容
下载资源
问答
  • LaTeX大括号公式和一般括号总结

    万次阅读 多人点赞 2017-12-04 19:14:23
    功能 语法 显示 不好看 \frac{1}{2} (12)( \frac{1}{2} ) 好一点 \left( \frac{1}{2} \right)(12)\left ( \frac{1}{2} \right ) 您可以使用\left和\right来...圆括号,小括号 \left( \frac{a}{b} \right)(ab)\left

    大括号显示

    $$
    \left\{  
                 \begin{array}{**lr**}  
                 x=\dfrac{3\pi}{2}(1+2t)\cos(\dfrac{3\pi}{2}(1+2t)), &  \\  
                 y=s, & 0\leq s\leq L,|t|\leq1.\\  
                 z=\dfrac{3\pi}{2}(1+2t)\sin(\dfrac{3\pi}{2}(1+2t)), &    
                 \end{array}  
    \right.  
    

    { x = 3 π 2 ( 1 + 2 t ) cos ⁡ ( 3 π 2 ( 1 + 2 t ) ) , y = s , 0 ≤ s ≤ L , ∣ t ∣ ≤ 1. z = 3 π 2 ( 1 + 2 t ) sin ⁡ ( 3 π 2 ( 1 + 2 t ) ) , \left\{ \begin{array}{lr} x=\dfrac{3\pi}{2}(1+2t)\cos(\dfrac{3\pi}{2}(1+2t)), & \\ y=s, & 0\leq s\leq L,|t|\leq1.\\ z=\dfrac{3\pi}{2}(1+2t)\sin(\dfrac{3\pi}{2}(1+2t)), & \end{array} \right. x=23π(1+2t)cos(23π(1+2t)),y=s,z=23π(1+2t)sin(23π(1+2t)),0sL,t1.
    对比括号一

    \left\{  
    \begin{array}{**rcl**}
        IF_{k}(\hat{t}_{k,m})=IF_{m}(\hat{t}_{k,m}), & \\
        IF_{k}(\hat{t}_{k,m}) \pm h= IF_{m}(\hat{t}_{k,m}) \pm h  , &\\
        \left |IF'_{k}(\hat{t}_{k,m} - IF'_{m}(\hat{t}_{k,m} \right |\geq d , &   
    \end{array}
    \right.  
    

    { I F k ( t ^ k , m ) = I F m ( t ^ k , m ) , I F k ( t ^ k , m ) ± h = I F m ( t ^ k , m ) ± h , ∣ I F k ′ ( t ^ k , m − I F m ′ ( t ^ k , m ∣ ≥ d , \left\{ \begin{array}{rcl} IF_{k}(\hat{t}_{k,m})=IF_{m}(\hat{t}_{k,m}), & \\ IF_{k}(\hat{t}_{k,m}) \pm h= IF_{m}(\hat{t}_{k,m}) \pm h , &\\ \left |IF'_{k}(\hat{t}_{k,m} - IF'_{m}(\hat{t}_{k,m} \right |\geq d , & \end{array} \right. IFk(t^k,m)=IFm(t^k,m),IFk(t^k,m)±h=IFm(t^k,m)±h,IFk(t^k,mIFm(t^k,md,
    常用的三种大括号写法

    $$ f(x)=\left\{
    \begin{aligned}
    x & = & \cos(t) \\
    y & = & \sin(t) \\
    z & = & \frac xy
    \end{aligned}
    \right.
    $$
    

    f ( x ) = { x = cos ⁡ ( t ) y = sin ⁡ ( t ) z = x y f(x)=\left\{ \begin{aligned} x & = & \cos(t) \\ y & = & \sin(t) \\ z & = & \frac xy \end{aligned} \right. f(x)=xyz===cos(t)sin(t)yx

    
    
    $$ F^{HLLC}=\left\{
    \begin{array}{rcl}
    F_L       &      & {0      <      S_L}\\
    F^*_L     &      & {S_L \leq 0 < S_M}\\
    F^*_R     &      & {S_M \leq 0 < S_R}\\
    F_R       &      & {S_R \leq 0}
    \end{array} \right. $$
    

    F H L L C = { F L 0 < S L F L ∗ S L ≤ 0 < S M F R ∗ S M ≤ 0 < S R F R S R ≤ 0 F^{HLLC}=\left\{ \begin{array}{rcl} F_L & & {0 < S_L}\\ F^*_L & & {S_L \leq 0 < S_M}\\ F^*_R & & {S_M \leq 0 < S_R}\\ F_R & & {S_R \leq 0} \end{array} \right. FHLLC=FLFLFRFR0<SLSL0<SMSM0<SRSR0

    $$f(x)=
    \begin{cases}
    0& \text{x=0}\\
    1& \text{x!=0}
    \end{cases}$$
    \end{CJK*}
    \end{document}
    

    f ( x ) = { 0 x=0 1 x!=0 f(x)= \begin{cases} 0& \text{x=0}\\ 1& \text{x!=0} \end{cases} f(x)={01x=0x!=0

    $$
    \begin{gathered}
    \begin{matrix} 0 & 1 \\ 1 & 0 \end{matrix}
    \quad
    \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix}
    \quad
    \begin{bmatrix} 0 & -1 \\ 1 & 0 \end{bmatrix}
    \quad
    \begin{Bmatrix} 1 & 0 \\ 0 & -1 \end{Bmatrix}
    \quad
    \begin{vmatrix} a & b \\ c & d \end{vmatrix}
    \quad
    \begin{Vmatrix} i & 0 \\ 0 & -i \end{Vmatrix}
    \end{gathered}
    $$
    

    0 1 1 0 ( 0 − i i 0 ) [ 0 − 1 1 0 ] { 1 0 0 − 1 } ∣ a b c d ∣ ∥ i 0 0 − i ∥ \begin{gathered} \begin{matrix} 0 & 1 \\ 1 & 0 \end{matrix} \quad \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix} \quad \begin{bmatrix} 0 & -1 \\ 1 & 0 \end{bmatrix} \quad \begin{Bmatrix} 1 & 0 \\ 0 & -1 \end{Bmatrix} \quad \begin{vmatrix} a & b \\ c & d \end{vmatrix} \quad \begin{Vmatrix} i & 0 \\ 0 & -i \end{Vmatrix} \end{gathered} 0110(0ii0)[0110]{1001}acbdi00i
    功能 语法 显示
    不好看

    \frac{1}{2} 
    

    ( 1 2 ) ( \frac{1}{2} ) (21)
    好一点

    \left( \frac{1}{2} \right)
    

    $\left ( \frac{1}{2} \right ) $
    您可以使用\left和\right来显示不同的括号:
    功能 语法 显示
    圆括号,小括号

    \left( \frac{a}{b} \right)
    

    ( a b ) \left( \frac{a}{b} \right) (ba)
    方括号,中括号

    \left[ \frac{a}{b} \right]
    
    展开全文
  • shell中各种括号的作用()、(())、[]、[[]]、{}

    万次阅读 多人点赞 2014-09-26 11:13:40
    一、小括号,园括号() 1、单小括号 () ①命令组。括号中的命令将会新开一个子shell顺序执行,所以括号中的变量不能够被脚本余下的部分使用。括号中多个命令之间用分号隔开,最后一个命令可以没有分号,各命令和...

    一、小括号,圆括号()

    1、单小括号 ()

       ①命令组。括号中的命令将会新开一个子shell顺序执行,所以括号中的变量不能够被脚本余下的部分使用。括号中多个命令之间用分号隔开,最后一个命令可以没有分号,各命令和括号之间不必有空格。
       ②命令替换。等同于`cmd`,shell扫描一遍命令行,发现了$(cmd)结构,便将$(cmd)中的cmd执行一次,得到其标准输出,再将此输出放到原来命令。有些shell不支持,如tcsh。
        ③用于初始化数组。如:array=(a b c d)
     
     

     2、双小括号 (( ))

        ①整数扩展。这种扩展计算是整数型的计算,不支持浮点型。((exp))结构扩展并计算一个算术表达式的值,如果表达式的结果为0,那么返回的退出状态码为1,或者 是"假",而一个非零值的表达式所返回的退出状态码将为0,或者是"true"。若是逻辑判断,表达式exp为真则为1,假则为0。
        ②只要括号中的运算符、表达式符合C语言运算规则,都可用在$((exp))中,甚至是三目运算符。作不同进位(如二进制、八进制、十六进制)运算时,输出结果全都自动转化成了十进制。如:echo $((16#5f)) 结果为95 (16进位转十进制)
        ③单纯用 (( )) 也可重定义变量值,比如 a=5; ((a++)) 可将 $a 重定义为6
        ④常用于算术运算比较,双括号中的变量可以不使用$符号前缀。括号内支持多个表达式用逗号分开。 只要括号中的表达式符合C语言运算规则,比如可以直接使用for((i=0;i<5;i++)), 如果不使用双括号, 则为for i in `seq 0 4`或者for i in {0..4}。再如可以直接使用if (($i<5)), 如果不使用双括号, 则为if [ $i -lt 5 ]。

    二、中括号,方括号[]

      1、单中括号 []

        ①bash 的内部命令,[和test是等同的。如果我们不用绝对路径指明,通常我们用的都是bash自带的命令。if/test结构中的左中括号是调用test的命令标识,右中括号是关闭条件判断的。这个命令把它的参数作为比较表达式或者作为文件测试,并且根据比较的结果来返回一个退出状态码。if/test结构中并不是必须右中括号,但是新版的Bash中要求必须这样。
        ②Test和[]中可用的比较运算符只有==和!=,两者都是用于字符串比较的,不可用于整数比较,整数比较只能使用-eq,-gt这种形式。无论是字符串比较还是整数比较都不支持大于号小于号。如果实在想用,对于字符串比较可以使用转义形式,如果比较"ab"和"bc":[ ab \< bc ],结果为真,也就是返回状态为0。[ ]中的逻辑与和逻辑或使用-a 和-o 表示。
        ③字符范围。用作正则表达式的一部分,描述一个匹配的字符范围。作为test用途的中括号内不能使用正则。
        ④在一个array 结构的上下文中,中括号用来引用数组中每个元素的编号。
     
     

     2、双中括号[[ ]]

        ①[[是 bash 程序语言的关键字。并不是一个命令,[[ ]] 结构比[ ]结构更加通用。在[[和]]之间所有的字符都不会发生文件名扩展或者单词分割,但是会发生参数扩展和命令替换。
        ②支持字符串的模式匹配,使用=~操作符时甚至支持shell的正则表达式。字符串比较时可以把右边的作为一个模式,而不仅仅是一个字符串,比如[[ hello == hell? ]],结果为真。[[ ]] 中匹配字符串或通配符,不需要引号。
        ③使用[[ ... ]]条件判断结构,而不是[ ... ],能够防止脚本中的许多逻辑错误。比如,&&、||、<和> 操作符能够正常存在于[[ ]]条件判断结构中,但是如果出现在[ ]结构中的话,会报错。比如可以直接使用if [[ $a != 1 && $a != 2 ]], 如果不适用双括号, 则为if [ $a -ne 1] && [ $a != 2 ]或者if [ $a -ne 1 -a $a != 2 ]。
        ④bash把双中括号中的表达式看作一个单独的元素,并返回一个退出状态码。
    例子:
        if ($i<5)      此处有问题,改为if (($i<5))
        if [ $i -lt 5 ]  
        if [ $a -ne 1 -a $a != 2 ]  
        if [ $a -ne 1] && [ $a != 2 ]  
        if [[ $a != 1 && $a != 2 ]]  
           
        for i in $(seq 0 4);do echo $i;done  
        for i in `seq 0 4`;do echo $i;done  
        for ((i=0;i<5;i++));do echo $i;done  
        for i in {0..4};do echo $i;done  

    三、大括号、花括号 {}

    1、常规用法

        ①大括号拓展。(通配(globbing))将对大括号中的文件名做扩展。在大括号中,不允许有空白,除非这个空白被引用或转义。第一种:对大括号中的以逗号分割的文件列表进行拓展。如 touch {a,b}.txt 结果为a.txt b.txt。第二种:对大括号中以点点(..)分割的顺序文件列表起拓展作用,如:touch {a..d}.txt 结果为a.txt b.txt c.txt d.txt
        # ls {ex1,ex2}.sh  
        ex1.sh  ex2.sh  
        # ls {ex{1..3},ex4}.sh  
        ex1.sh  ex2.sh  ex3.sh  ex4.sh  
        # ls {ex[1-3],ex4}.sh  
        ex1.sh  ex2.sh  ex3.sh  ex4.sh  
        ②代码块,又被称为内部组,这个结构事实上创建了一个匿名函数 。与小括号中的命令不同,大括号内的命令不会新开一个子shell运行,即脚本余下部分仍可使用括号内变量。括号内的命令间用分号隔开,最后一个也必须有分号。{}的第一个命令和左括号之间必须要有一个空格。
     
     

      2、几种特殊的替换结构

    ${var:-string},${var:+string},${var:=string},${var:?string}

          ①${var:-string}和${var:=string}:若变量var为空,则用在命令行中用string来替换${var:-string},否则变量var不为空时,则用变量var的值来替换${var:-string};对于${var:=string}的替换规则和${var:-string}是一样的,所不同之处是${var:=string}若var为空时,用string替换${var:=string}的同时,把string赋给变量var: ${var:=string}很常用的一种用法是,判断某个变量是否赋值,没有的话则给它赋上一个默认值。
          ② ${var:+string}的替换规则和上面的相反,即只有当var不是空的时候才替换成string,若var为空时则不替换或者说是替换成变量 var的值,即空值。(因为变量var此时为空,所以这两种说法是等价的) 
          ③${var:?string}替换规则为:若变量var不为空,则用变量var的值来替换${var:?string};若变量var为空,则把string输出到标准错误中,并从脚本中退出。我们可利用此特性来检查是否设置了变量的值。
          补充扩展:在上面这五种替换结构中string不一定是常值的,可用另外一个变量的值或是一种命令的输出。

     3、四种模式匹配替换结构

    模式匹配记忆方法:
    # 是去掉左边(在键盘上#在$之左边)
    % 是去掉右边(在键盘上%在$之右边)
    #和%中的单一符号是最小匹配,两个相同符号是最大匹配。

    ${var%pattern},${var%%pattern},${var#pattern},${var##pattern}

         第一种模式:${variable%pattern},这种模式时,shell在variable中查找,看它是否一给的模式pattern结尾,如果是,就从命令行把variable中的内容去掉右边最短的匹配模式
         第二种模式: ${variable%%pattern},这种模式时,shell在variable中查找,看它是否一给的模式pattern结尾,如果是,就从命令行把variable中的内容去掉右边最长的匹配模式
         第三种模式:${variable#pattern} 这种模式时,shell在variable中查找,看它是否一给的模式pattern开始,如果是,就从命令行把variable中的内容去掉左边最短的匹配模式
         第四种模式: ${variable##pattern} 这种模式时,shell在variable中查找,看它是否一给的模式pattern结尾,如果是,就从命令行把variable中的内容去掉右边最长的匹配模式
         这四种模式中都不会改变variable的值,其中,只有在pattern中使用了*匹配符号时,%和%%,#和##才有区别。结构中的pattern支持通配符,*表示零个或多个任意字符,?表示仅与一个任意字符匹配,[...]表示匹配中括号里面的字符,[!...]表示不匹配中括号里面的字符
        # var=testcase  
        # echo $var  
        testcase  
        # echo ${var%s*e} 
        testca  
        # echo $var  
        testcase 
        # echo ${var%%s*e} 
        te
        # echo ${var#?e}  
        stcase
        # echo ${var##?e}  
        stcase
        # echo ${var##*e}  
    
        # echo ${var##*s}  
        e  
        # echo ${var##test}  
        case  

     

     4、字符串提取和替换

    ${var:num},${var:num1:num2},${var/pattern/pattern},${var//pattern/pattern}

           第一种模式:${var:num},这种模式时,shell在var中提取第num个字符到末尾的所有字符。若num为正数,从左边0处开始;若num为负数,从右边开始提取字串,但必须使用在冒号后面加空格或一个数字或整个num加上括号,如${var: -2}、${var:1-3}或${var:(-2)}。        
            第二种模式:${var:num1:num2},num1是位置,num2是长度。表示从$var字符串的第$num1个位置开始提取长度为$num2的子串。不能为负数。
           第三种模式:${var/pattern/pattern}表示将var字符串的第一个匹配的pattern替换为另一个pattern。。        
           第四种模式:${var//pattern/pattern}表示将var字符串中的所有能匹配的pattern替换为另一个pattern。
    [root@centos ~]# var=/home/centos
    [root@centos ~]# echo $var
    /home/centos
    [root@centos ~]# echo ${var:5}
    /centos
    [root@centos ~]# echo ${var: -6}
    centos
    [root@centos ~]# echo ${var:(-6)}
    centos
    [root@centos ~]# echo ${var:1:4}
    home
    [root@centos ~]# echo ${var/o/h}
    /hhme/centos
    [root@centos ~]# echo ${var//o/h}
    /hhme/cenths

     

    四、符号$后的括号

    (1)${a} 变量a的值, 在不引起歧义的情况下可以省略大括号。

    (2)$(cmd) 命令替换,和`cmd`效果相同,结果为shell命令cmd的输,过某些Shell版本不支持$()形式的命令替换, 如tcsh。

    (3)$((expression)) 和`exprexpression`效果相同, 计算数学表达式exp的数值, 其中exp只要符合C语言的运算规则即可, 甚至三目运算符和逻辑表达式都可以计算。

    五、使用

    1、多条命令执行

    (1)单小括号,(cmd1;cmd2;cmd3) 新开一个子shell顺序执行命令cmd1,cmd2,cmd3, 各命令之间用分号隔开, 最后一个命令后可以没有分号。

    (2)单大括号,{ cmd1;cmd2;cmd3;} 在当前shell顺序执行命令cmd1,cmd2,cmd3, 各命令之间用分号隔开, 最后一个命令后必须有分号, 第一条命令和左括号之间必须用空格隔开。
    对{}和()而言, 括号中的重定向符只影响该条命令, 而括号外的重定向符影响到括号中的所有命令。

     

    展开全文
  • python语言最常见的括号有三种,分别是:小括号( )、中括号[ ]和大括号也叫做花括号{ }。这篇文章主要介绍了python 中大括号括号括号的区分,需要的朋友可以参考下
  • bash 括号(小括号,双小括号,中括号,双中括号,大括号).pdf
  • PHP使用正则表达式提取字符串中尖括号<>、小括号()、中括号[]、大括号{}中的字符示例,需要的朋友可以参考下
  • 【LeetCode】括号(有效括号括号生成、最长有效括号······) 括号★★ LeetC面试题 08.09. 括号 【题目】括号。设计一种算法,打印n对括号的所有合法的(例如,开闭一一对应)组合。 说明:解集不能包含重复...


    括号★★

    LeetC面试题 08.09. 括号

    题目】括号。设计一种算法,打印n对括号的所有合法的(例如,开闭一一对应)组合。

    说明:解集不能包含重复的子集。

    示例

    输入:n = 3
    [
      "((()))",
      "(()())",
      "(())()",
      "()(())",
      "()()()"
    ]
    

    解题思路】使用递归来生成括号

    • 若在生成过程中右括号数量大于左括号数量则终止递归,或者左括号超过限定数目n则终止递归

    • 若左括号等于右括号等于n,则添加至结果集并且终止递归

    class Solution {
        List<String> res;
        public List<String> generateParenthesis(int n) {
            res = new ArrayList<String>();
            helper("", n, n);
            return res;
        }
        private void helper(String str, int le, int ri) {
            if(le > ri || le < 0) return;
            if(le == 0 && ri == 0) {
                res.add(new String(str));
                return;
            }
            helper(str + "(", le - 1, ri);
            helper(str + ")", le, ri - 1);
        }
    }
    

    有效的括号★

    LeetCode20. 有效的括号

    题目】给定一个只包括 ‘(’,’)’,’{’,’}’,’[’,’]’ 的字符串,判断字符串是否有效。

    有效字符串需满足:

    • 左括号必须用相同类型的右括号闭合。
    • 左括号必须以正确的顺序闭合。

    注意空字符串可被认为是有效字符串

    示例

    ----输入: "()[]{}"
    输出: true
    ----输入: "([)]"
    输出: false
    

    解题思路

    方法一:使用栈模拟,遍历字符串

    • 若为左括号则入栈
    • 若为右括号则判断栈顶元素,若栈为空则返回false,若栈顶元素是与之对应的左括号则出栈,否则返回false
    • 最后若栈为空,则返回true,否则返回false
    class Solution {
        public boolean isValid(String s) {
            Stack<Character> stack = new Stack<Character>();
            for(char c : s.toCharArray()) {
                if(c == '(' || c == '[' || c == '{') {
                    stack.push(c);
                }else if(!stack.isEmpty()){
                    if(c == ')' && stack.peek() == '(' || 
                       c == ']' && stack.peek() == '[' ||
                       c == '}' && stack.peek() == '{') {
                        stack.pop();
                    }else {
                        return false;
                    }
                }else {
                    return false;
                }
            }
            return stack.isEmpty();
        }
    }
    

    方法二:使用String类的函数,用""替换所有的()[]{},最后判断字符串是否为空即可

    class Solution {
        public boolean isValid(String s) {
            while(!s.equals("")) {
                String str = s.replace("()", "").replace("[]", "").replace("{}", "");
                if(str.equals(s)) return false;
                s = str;
            }
            return true;
        }
    }
    

    最长有效括号★★★

    LeetCode32. 最长有效括号

    题目】给你一个只包含 '('')' 的字符串,找出最长有效(格式正确且连续)括号子串的长度。

    示例

    输入:s = ")()())"
    输出:4
    解释:最长有效括号子串是 "()()"
    

    解题思路】使用栈保存左括号下标,栈初始化为(-1)

    • 对于左括号,入栈对应下标
    • 对于右括号,出栈一个下标(表示出栈下标对应的左括号对应当前右括号)
      • 若栈为空,则说明不能构成有效括号,入栈当前下标(已遍历最右端不能构成有效括号的下标
      • 若栈不为空,则说明出栈下标对应为有效括号,更新res = Math.max(res, i - stack.peek())
    class Solution {
        public int longestValidParentheses(String s) {
            Stack<Integer> stack = new Stack<>();
            stack.push(-1);
            int res = 0;
            for(int i = 0; i < s.length(); i++) {
                if(s.charAt(i) == '(') {
                    stack.push(i);
                }else {
                    stack.pop();
                    if(stack.isEmpty()) {
                        stack.push(i);
                    }else {
                        res = Math.max(res, i - stack.peek());
                    }
                }
            }
            return res;
        }
    }
    

    有效的括号字符串★★

    LeetCode678. 有效的括号字符串

    题目】给定一个只包含三种字符的字符串:*,写一个函数来检验这个字符串是否为有效字符串。有效字符串具有如下规则:

    • 任何左括号 ( 必须有相应的右括号 )
    • 任何右括号 ) 必须有相应的左括号 (
    • 左括号 ( 必须在对应的右括号之前 )
    • *可以被视为单个右括号 ) ,或单个左括号 ( ,或一个空字符串
    • 一个空字符串也被视为有效字符串

    **注意:**字符串大小将在 [1,100] 范围内。

    示例

    ---输入: "()"
    输出: True
    ---输入: "(*))"
    输出: True
    

    解题思路

    方法一:双栈模拟,栈left保存左括号下标,栈star保存*下标,遍历字符串

    • 若当前字符为,则将下标i进栈left
    • 若当前字符为*,则将其下标i进栈start
    • 若当前字符为,若left不为空,优先配对出栈;若left为空且star不为空,则star出栈(表示当前出栈的下标处*可以表示一个左括号);若leftstar均为空,则没有与其配对的,返回false

    然后再来看leftstar中元素,此时表示*代替右括号来配对left栈中剩余的左括号

    • left栈顶元素大于star栈顶元素,表示*下标处于左括号下标左边,返回false
    • 否则均出栈一个元素,表示配对

    最后若left不为空,表示剩余左括号无法配对,返回false,若为空,返回true

    class Solution {
        public boolean checkValidString(String s) {
            Stack<Integer> left = new Stack<Integer>();
            Stack<Integer> star = new Stack<Integer>();
            for(int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                if(c == '(') {
                    left.push(i);
                }else if(c == '*') {
                    star.push(i);
                }else {
                    if(!left.isEmpty()) {
                        left.pop();
                    }else if(!star.isEmpty()) {
                        star.pop();
                    }else {
                        return false;
                    }
                }
            }
            while(!left.isEmpty() && !star.isEmpty()) {
                if(left.pop() > star.pop()) return false;
            }
            return left.isEmpty();
        }
    }
    

    方法二:使用两个变量lohi分别表示未匹配左括号的上界和下界

    class Solution {
        public boolean checkValidString(String s) {
            int lo = 0, hi = 0;    //未匹配左括号数量的范围
            for(char c : s.toCharArray()) {
                if(c == '(') {
                    lo++;
                    hi++;
                }else if(c == ')') {
                    lo = Math.max(0, lo - 1);
                    hi--;
                    if(hi < 0) return false;    //右括号多于左括号且不能匹配
                }else {
                    lo = Math.max(0, lo - 1);
                    hi++;
                }
            }
            return lo == 0;
        }
    }
    

    使括号有效的最少添加★★

    LeetCode使括号有效的最少添加

    题目】给定一个由 ‘(’ 和 ‘)’ 括号组成的字符串 S,我们需要添加最少的括号( ‘(’ 或是 ‘)’,可以在任何位置),以使得到的括号字符串有效。

    从形式上讲,只有满足下面几点之一,括号字符串才是有效的:

    • 它是一个空字符串,或者
    • 它可以被写成 AB (A 与 B 连接), 其中 A 和 B 都是有效字符串,或者
    • 它可以被写作 (A),其中 A 是有效字符串。

    给定一个括号字符串,返回为使结果字符串有效而必须添加的最少括号数。

    示例

    ---输入:"((("
    输出:3
    ---输入:"()))(("
    输出:4
    

    解题思路】最少添加至每个括号刚好匹配,即补充括号使不匹配的括号匹配

    方法一:遍历统计,使用countLeft标记左括号的个数,leastAdd记录添加个数

    • 若为左括号,则countLeft++
    • 若为右括号,若countLeft值大于0,则表示当前右括号有相应左括号与其配对,若countLeft值等于0,则表示没有与之对应的左括号配对,即需要添加一个(leastAdd++

    最后返回leastAdd + countLeft,此时countLeft表示没有与之配对的右括号的数量

    class Solution {
        public int minAddToMakeValid(String S) {
            int countLeft = 0;   //标记左括号的个数
            int leastAdd = 0;    //最少添加个数
            for(char c : S.toCharArray()){
                if(c == '(') {
                    countLeft++;
                }else {
                    if(countLeft == 0) {
                        leastAdd++;
                    }else {
                        countLeft--;
                    }
                }
            }   
            return leastAdd + countLeft;
        }
    }
    

    方法二:使用空字符串替换所有的(),最后剩余字符串的长度就是其未匹配的括号数量

    class Solution {
        public int minAddToMakeValid(String S) {
            while(S.contains("()")) {
                S = S.replace("()", "");
            }
            return S.length();
        }
    }
    

    有效括号的嵌套深度★★

    LeetCode有效括号的嵌套深度

    题目有效括号字符串 定义:对于每个左括号,都能找到与之对应的右括号,反之亦然。详情参见题末「有效括号字符串」部分。

    嵌套深度 depth 定义:即有效括号字符串嵌套的层数,depth(A) 表示有效括号字符串 A 的嵌套深度。详情参见题末**「嵌套深度」**部分。

    有效括号字符串类型与对应的嵌套深度计算方法如下图所示:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hyBBnVS8-1610270685893)(…\LeetCode\great\有效括号嵌套深度.png)]

    给你一个「有效括号字符串」 seq,请你将其分成两个不相交的有效括号字符串,AB,并使这两个字符串的深度最小。

    • 不相交:每个 seq[i] 只能分给 AB 二者中的一个,不能既属于 A 也属于 B
    • AB 中的元素在原字符串中可以不连续。
    • A.length + B.length = seq.length
    • 深度最小:max(depth(A), depth(B)) 的可能取值最小。

    划分方案用一个长度为 seq.length 的答案数组 answer 表示,编码规则如下:

    • answer[i] = 0seq[i] 分给 A
    • answer[i] = 1seq[i] 分给 B

    如果存在多个满足要求的答案,只需返回其中任意 一个 即可。

    示例

    ----输入:seq = "(()())"
    输出:[0,1,1,1,1,0]
    ----输入:seq = "()(())()"
    输出:[0,0,0,1,1,0,1,1]
    解释:本示例答案不唯一。
    按此输出 A = "()()", B = "()()", max(depth(A), depth(B)) = 1,它们的深度最小。
    像 [1,1,1,0,0,1,1,1],也是正确结果,其中 A = "()()()", B = "()", max(depth(A), depth(B)) = 1 
    

    解题思路

    对于示例:( ( ) ( ( ) ) ( ) )
    嵌套深度:1 2 2 2 3 3 2 2 2 1
    分配方案:A B B B A A B B B A
    可见奇数的嵌套深度分配给A,偶数的嵌套深度分配给B
    
    class Solution {
        public int[] maxDepthAfterSplit(String seq) {
            int[] res = new int[seq.length()];
            int deep = 0;
            for(int i = 0; i < seq.length(); i++) {
                if(seq.charAt(i) == '(') {
                    deep++;
                    res[i] = deep & 1;
                }else {
                    res[i] = deep & 1;
                    deep--;
                }
            }
            return res;
        }
    }
    

    反转每对括号间的子串★★

    1190. 反转每对括号间的子串

    题目】给出一个字符串 s(仅含有小写英文字母和括号)。

    请你按照从括号内到外的顺序,逐层反转每对匹配括号中的字符串,并返回最终的结果。

    注意:您的结果中不应包含任何括号。

    提示:

    • 0 <= s.length <= 2000
    • s 中只有小写英文字母和括号
    • 我们确保所有括号都是成对出现的

    示例

    输入:s = "(u(love)i)"
    输出:"iloveu"
    ----------------------------------
    输入:s = "(ed(et(oc))el)"
    输出:"leetcode"
    

    解题思路

    每匹配一对括号就将对应区间内的字符反转

    class Solution {
        public String reverseParentheses(String s) {
            StringBuffer sb = new StringBuffer();
            char[] cs = s.toCharArray();
            Stack<Integer> stack = new Stack<>();
    
            for (int i = 0; i < cs.length; i++) {
                if (cs[i] == '(') {
                    stack.push(i);
                } else if (cs[i] == ')') {
                    reverse(cs, stack.pop() + 1, i - 1);
                }
            }
            for (char c : cs) {
                if (c != '(' && c != ')') {
                    sb.append(c);
                }
            }
    
            return sb.toString();
        }
    
        private void reverse(char[] cs, int le, int ri) {
            while (le < ri) {
                char c = cs[le];
                cs[le++] = cs[ri];
                cs[ri--] = c;
            }
        }
    }
    

    🎈

    2021/5/27新增题目“反转每对括号间的子串”

    展开全文
  • 主要介绍了JS使用正则表达式获取小括号、中括号及花括号内容的方法,涉及javascript针对三种括号正则匹配的相关操作技巧,需要的朋友可以参考下
  • 括号匹配

    千次阅读 多人点赞 2018-10-13 09:58:37
    栈的应用,括号匹配。 经典做法是,遇左括号压入,遇右括号判断,和栈顶配对就继续,不配对或者栈空就错了。最后判断是否为空。 代码有些麻烦。   我是遇左括号压对应的右括号,最后判断代码就会很简单:相等...

    栈的应用,括号匹配。

    经典做法是,遇左括号压入,遇右括号判断,和栈顶配对就继续,不配对或者栈空就错了。最后判断是否为空。

    代码有些麻烦。

     

    我是遇左括号压对应的右括号,最后判断代码就会很简单:相等即可。

    class Solution {
    public:
        bool isValid(string s) {
            int len=s.size();
            stack<char> st;
            for(int i=0;i<len;i++){
                if(s[i]=='(')st.push(')');
                else if(s[i]=='[')st.push(']');
                else if(s[i]=='{')st.push('}');
                else if(st.empty())return false;
                else if(st.top()!=s[i])return false;
                else st.pop();
            }
            return st.empty();
        }
    };

     

    展开全文
  • 括号匹配使用栈实现括号匹配.cpp
  • 主要介绍了正则表达式(括号)、[中括号]、{大括号}的区别小结,本文用(s*)[s*]{s*}做例子,需要的朋友可以参考下
  • 在Python语言中最常见的括号有三种,分别是:小括号()、中括号[]、花括号{};其作用也不相同,分别用来代表不同的Python基本内置数据类型。 小括号() Python中的小括号(): 代表tuple元祖数据类型,元祖是一种...
  • 括号双击匹配括号 括号扩展以通过双击括号来选择匹配括号内的块
  • 在使用python做项目的过程中发现这种语言使用了很多种类型的括号来表达数据类型,常见的有四种,分别是:小括号( )、中括号[ ]和大括号,也叫做花括号{ },还有尖括号<>,其作用也各不相同,分别用来代表不同...
  • python 大括号括号括号的区分

    万次阅读 2019-03-03 20:39:07
    python语言最常见的括号有三种,分别是:小括号( )、中括号[ ]和大括号也叫做花括号{ }。其作用也各不相同,分别用来代表不同的python基本内置数据类型。 1.python中的小括号( ):代表tuple元组数据类型,元组是一种...
  • 缺少左括号 缺少右括号 括号数目相等但不匹配 等等 用栈实现
  • 下面小编就为大家带来一篇使用JS正则表达式 替换括号,尖括号等。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了json_encode值中大括号与花括号区别,具体的看下实例说明,需要的朋友参考下
  • 写在前面:最近做的一个项目用是很久之前的,在维护项目中就无法使用vue等技术来操作,所以一些方法用的是原生来写的,在绑定点击方法时,方法名没加括号,就没生效,加了括号就生效了,当时有疑惑的点是在之前做vue...
  • 详细描述python如何去除括号括号中的内容,无论内容是中文、英文、数字,均可以达到要求。
  • 括号匹配C语言

    2018-12-05 20:55:34
    3利用栈的操作实现括号匹配的检验。 .括号匹配算法思想 (1)出现的凡是“左括号”,则进栈; (2)出现的是“右括号”, 首先检查栈是否空? 若栈空,则表明该“右括号”多余 否则和栈顶元素比较? 若相...
  • 括号与花括号括号与花括号

    千次阅读 2016-05-05 17:22:29
    scala雾中风景(2): 小括号与花括号 2条回复 下面的问题,表面上看是小括号与花括号的问题。 // map方法这样写不能编译通过 scala> List(2).map( case 2 => "OK" ) // 换做花括号就可以了 scala> List(2)....
  • 这是整理发布的一款《去括号与添括号》课件PPT,PPT主要以初中数学课程为主,适合老师及学生使...该文档为《去括号与添括号》PPT课件2,是一份很不错的参考资料,具有较高参考价值,感兴趣的可以下载看看
  • 最近在学习Shell脚本编程时,发现别人程序的 if-then代码块 中if的条件语句中存在 双括号(())、双中括号[[]] 的使用,因而查阅了相关资料,同时也看到了一篇不错的博文,对Shell脚本中括号的使用作出了总结,特此...
  • 括号匹配问题

    2016-04-10 13:33:44
    假设表达式中允许包含3种括号:圆括号,方括号和大括号。设计一个算法采用顺序栈判断表达式中的括号是否正确配对。
  • 括号匹配C++

    2015-12-05 00:41:15
    括号匹配:判断一段字符串括号是否匹配,就是左括号是否与右括号搭配,且括号类型要相同,且有空字符串,括号括号等特殊情况。
  • 易语言括号匹配算法源码,括号匹配算法,括号是否匹配

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,108,037
精华内容 443,214
关键字:

括号