精华内容
下载资源
问答
  • 今天面试做了一道狠可爱的题目,判断一个字符串的括号自否闭合(包括大小中括号) 当时没马上做出来,只是说了大概的思路 一开始的思路就是判断每种括号的开闭数量是否相等,其实虽然也能实现但是搞得太复杂了;...

    今天去面试做了一道狠可爱的题目,判断一个字符串的括号自否闭合(包括大小中括号)

    当时没马上做出来,只是说了大概的思路

    一开始的思路就是判断每种括号的开闭数量是否相等,其实虽然也能实现但是搞得太复杂了;

    回来后查了下发现很多都是利用堆栈实现的,

    下面是不用栈实现的方式:

    只需设一个常量,

    开+1,

    闭-1,

    闭合的话为0,

    没闭合的话不为0,

    出现<0即为顺序不对

     1     public static void main(String[] args){
     2         String str = "{123}[23](11{231)}";
     3         countBrackets(str);
     4     }
     5     /**
     6      * 判断括号是否关闭
     7      * 遍历字符串
     8      * 左括号时+1,右括号时-1
     9      * 当出现小于0的情况时,括号顺序不对
    10      * 最后不等于0的话说明没关闭
    11      * @param str
    12      */
    13     public static void  countBrackets(String str){
    14         int da=0,zh=0,xi=0;
    15         for(int i=0;i<str.length();i++){
    16             char s = str.charAt(i);
    17             if(s=='{'){
    18                 da+=1;
    19             }
    20             if(s=='['){
    21                 zh+=1;
    22             }
    23             if(s=='('){
    24                 xi+=1;
    25             }
    26             if(s=='}'){
    27                 da-=1;
    28             }
    29             if(s==']'){
    30                 zh-=1;
    31             }
    32             if(s==')'){
    33                 xi-=1;
    34             }
    35             if(da<0||zh<0||xi<0){
    36                 break;
    37             }
    38         }
    39         if(da!=0||zh!=0||xi!=0){
    40             System.out.println("error");
    41         }else{
    42             System.out.println("ok");
    43         }
    44     }

     

    转载于:https://www.cnblogs.com/dadaxin/p/6838854.html

    展开全文
  • Java中的方法

    2021-03-19 20:05:00
    方法就是将一个功能抽取出来,把代码单独定义在一对大括号内,形成一个单独功能。当我们需要这个功能时候,就可以调用。这样即实现了代码复用性,也解决了代码冗余问题。 方法定义: 定义一个方法格式...

    Java中的方法

    方法的概述:

    方法就是将一个功能抽取出来,把代码单独定义在一对大括号内,形成一个单独的功能。当我们需要这个功能的时候,就可以去调用。这样即实现了代码的复用性,也解决了代码冗余的问题。

    方法的定义:

    定义一个方法的格式:

    /*初学的基本格式*/
    public static void 方法名称(){
        方法体
    }
    /*
    方法变量的命名规则和变量一样,使用小驼峰命名法
    方法体:大括号内可以包含任意条语句
    */
    
    

    注意事项:

    1.方法定义的先后顺序无所谓。

    2.方法的定义不能有嵌套包含关系(即在一个方法中定义一个新的方法)

    错误示例:

    public static void one(){
        System.out.printf("这是方法一");
        public static void two(){
            System.out.printf("这是方法而")
        }
    }
    /*这是错误的写法 错误的 错误的 错误的  重要事情说三遍*/
    

    ​ 如果方法里想写方法 就必须在方法里创建一个类 在类里面写方法

    3.方法定义好了之后,需要调用才会执行。

    方法的调用:

    /*
    调用方法的格式:
    方法名称();
    */
    
    public class Demo{
        public static void main(String[] args){
            first();
        }
        
        /*创建一个方法一*/
        public static void first(){
            System.out.println("成功调用方法一");
        }
    }
    

    运行结果:

    在这里插入图片描述

    展开全文
  • 形参和实参:跟绝部分编程语言一样,形参指是函数创建和定义过程中小括号参数,而实参指是函数在调用过程传递进去参数。 关键字参数:是指函数在调用时候,带上参数名字指定具体调用是哪个...

    知识点

    1. 形参和实参:跟绝大部分编程语言一样,形参指的是函数创建和定义过程中小括号里的参数,而实参指的是函数在调用过程中传递进去的参数。
    2. 关键字参数:是指函数在调用的时候,带上参数的名字去指定具体调用的是哪个参数,从而可以不用按照参数的顺序调用函数。
    >>> def SaySome(name, words):
            print(name + '->' + words)
    >>> SaySome(words='让编程改变世界!', name='小甲鱼')
    
    1. 默认参数与关键字参数的区别:
    • 关键字参数是在函数调用的时候,通过参数名制定需要赋值的参数,这样做就不怕因为搞不清参数的顺序而导致函数调用出错。
    • 而默认参数是在参数定义的过程中,为形参赋初值,当函数调用的时候,不传递实参,则默认使用形参的初始值代替。

    编程题

    1. 请问这个函数有多少个参数?
    def MyFun((x, y), (a, b)):
    return x * y - a * b
    

    答:由于小括号表示元组,而函数定义时括号里需要的是变量,元组最大的特点就是不可改变,所以该函数定义错误,没有参数,应该为:

    >>> def MyFun(x, y):
        return x[0] * x[1] - y[0] * y[1]
    
    >>> MyFun((3, 4), (1, 2))
    10
    
    1. 编写一个函数power()模拟内建函数pow(),即power(x, y)为计算并返回x的y次幂的值。
      答:代码如下,运行结果正确:
    def power(x,y):
        a = x
        if y==1:
            return a
        else:
            for i in range(1,y):
                a=x*a
            return a
    print(power(3,1))
    

    参考答案:

    def power(x,y):
        result = x**y
        return result
        
    print(power(2, 8))
    

    python中**号表示幂运算
    3. 编写一个函数,利用欧几里得算法求最大公约数,例如gcd(x, y)返回值为参数x和参数y的最大公约数。
    欧几里得算法:

    • 欧几里德算法又称辗转相除法,是指用于计算两个正整数a,b的最大公约数。应用领域有数学和计算机两个方面。计算公式gcd(a,b) = gcd(b,a mod b)。

    • 欧几里德算法是用来求两个正整数最大公约数的算法。是由古希腊数学家欧几里德在其著作《The Elements》中最早描述了这种算法,所以被命名为欧几里德算法。

    • 假如需要求 1997 和 615 两个正整数的最大公约数,用欧几里德算法,是这样进行的:
      1997 / 615 = 3 (余 152)
      615 / 152 = 4(余7)
      152 / 7 = 21(余5)
      7 / 5 = 1 (余2)
      5 / 2 = 2 (余1)
      2 / 1 = 2 (余0)
      至此,最大公约数为1

    • 以除数和余数反复做除法运算,当余数为 0 时,取当前算式除数为最大公约数,所以就得出了 1997 和 615 的最大公约数 1。

     #欧几里得算法,又名辗转相除法,用于求最大公约数
    def ojld(x,y):
        chushu=y
        yushu=x%y
        while yushu!=0:
            beichushu=chushu
            chushu=yushu
            yushu=beichushu%chushu
        return chushu
    print(ojld(77,22))
    

    参考答案:

    def gcd(x,y):
        while y:
            t = x % y
            x = y
            y = t
        return x
    print(gcd(18,9))
    

    参考答案更为简单,因为辗转相除过程中,被除数为上一步除数,除数为上一步余数,而在最开始时,除数也不能为0,故可以将余数为零的条件变成下一步除数为零,答案更为聪明。
    4. 编写一个函数findstr(),该函数统计一个长度为2的子字符串在另一个字符串中出现的次数。例如:假定输入的字符串为"You cannot improve your past, but you can improve your future. Once time is wasted, life is wasted.",子字符串为"im",函数执行后打印“子字母串在目标字符串中共出现3次”。

    展开全文
  • java -方法入门 流程

    2020-02-22 17:48:11
    方法: 将一个功能抽取出来,把代码单独定义在一个大括号中,形成一个单独功能 当我们需要这个功能时候,就可以调用,这样既实现了代码复用性,也解决了代码冗余问题 定义: 修饰符 返回值类型 方法名 ...

    方法入门

    • 方法: 将一个功能抽取出来,把代码单独定义在一个大括号中,形成一个单独的功能
      当我们需要这个功能的时候,就可以去调用,这样既实现了代码的复用性,也解决了代码的冗余问题
    • 定义:
    修饰符 返回值类型 方法名 (参数) {
    	代码...
    	return;
    }
    

    方法名称的命名规则和变量名一样,使用小驼峰
    方法体:也就是大括号中的,可以包含多条语句

    注意事项:
    1. 方法定义的先后顺序无所谓
    2. 方法的定义不能产生嵌套包含关系 (定义一个方法中不能再定义一个方法,python可以)
    3. 方法定义好后不会执行,如果需要执行,一定要进行方法的调用

    • 调用
      1. 格式:
    方法名称();
    

    JShell脚本工具

    jdk9.0以上才有
    进入 cmd中输入JShell
    退出: /exit
    类似于 python的命令行输入语句后可以直接获取结果,不用编译

    流程

    顺序结构: 从上往下执行
    public class Demo01Sequence{
    	public static void main(String[] args){
    		System.out.println("1");
    		System.out.println("2");
    		System.out.println("3");
    		System.out.println("4");
    	}
    	
    }
    

    在这里插入图片描述

    判断结构
    • if语句
    1. 单if 语句
      java if (关系表达式){ 语句体; }
      流程图
      在这里插入图片描述

      public class Demo02If {
      	public static void main(String[] args){
      	System.out.println("看见网吧");
      	int age =16;
      	if (age >= 18){
      		System.out.println("玩游戏");
      	}
      	System.out.println("回家");
      	}
      	}
      	```
      
      
    2. if… else…

      if(关系表达式){
      	语句1;
      }else{
      	语句2;
      }
      

      执行流程:如果关系表达式为true,则执行语句1,否则执行语句2

      public class Demo03IfElse {
      	public static void main(String[] args){
      		int num =13;
      		if (num%2==0) {
      			System.out.println("偶数");
      		}else{
      			System.out.println("奇数");
      		}
      	}
      }
      
    3. if … else if … else

      if (条件判断1) {
      	执行语句1;
      }else if (判断条件2) {
      	执行语句2;
      }
      ...
      } else if (判断条件n){
      	执行语句n;
      } else {
      	执行语句n+1;
      }
      

      执行流程:
      当判断条件1满足是,则执行语句1,如果不满足则向下顺序判断执行,只能执行一个执行语句;如果所有的判断条件都为false,那么执行else语句,执行语句n+1
      在这里插入图片描述

      /*
      x和y的关系如下:
      如果x>=3,则 y=2x+1
      如果 -1<x<3,则y=2x;
      如果x<=-1,那么y=2x-1
      
      */
      
      
      public class Demo04IfElseExt {
      	public static void main(String[] args){
      		int x=10;
      		int y;
      		if (x>=3){
      			y = 2*x+1;
      		} else if (x>-1 && x<3) {
      			y = 2*x;
      		} else {
      			y = 2*x-1;
      		}
      		System.out.println("结果是"+y);  // 结果是21
      	}
      }
      
    • switch语句

      switch(表达式) {
      	case 常量值1:
      		语句体1;
      		break;
      	case 常量值2:
      		语句体2;
      		break;
      	...
      	default:
      		语句体n+1;
      		break;
      }
      
      

      switch case 执行时,首先计算出表达式的值,然后进行case依次匹配,匹配成功返回当前 case 的值,再根据是否有 break,判断是否继续输出,或是跳出判断。如果没有case符合,那么使用default的中语句。
      当变量的值与 case 语句的值相等时,那么 case 语句之后的语句开始执行,直到 break 语句出现才会跳出 switch 语句。
      当遇到 break 语句时,switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现,程序会继续执行下一条 case 语句,直到出现 break 语句。

      public class Demo07Switch{
      	public static void main(String[] args){
      		int num=1;
      		
      		switch(num){
      			case 1:
      				System.out.println("周一");
      				break;
      			case 2:
      				System.out.println("周二");
      				break;
      			case 3:
      				System.out.println("周三");
      				break;
      			case 4:
      				System.out.println("周四");
      				break;
      			case 5:
      				System.out.println("周五");
      				break;
      			case 6:
      				System.out.println("周六");
      				break;
      			case 7:
      				System.out.println("周天");
      				break;
      			default:
      				System.out.println("数据错误");
      				break;  // 可以省略,但是不建议省略
      		}
      	}
      }
      

      注意事项:
      1. 多个case后面的数值不可以重复;
      2. switch后面小括号当中的只能是下列数据类型:
      基本数据类型:byte/short/char/int 只有这四种
      引用数据类型:String字符串, enum枚举
      3. switch语句格式可以很灵活,前后顺序可以颠倒,而且break语句可以省略
      匹配哪一个case就从哪一个位置向下执行,直到遇到break或者整体结束为止
      可以看示例代码

    循环结构

    在满足循环条件的情况下,反复执行某一段代码,这段被重复执行的代码成为循环体语句

    • for循环

      for(初始化表达式【A】; 布尔表达式【B】; 步进表达式【C】){
      	循环体【D】;
      }
      

      初始化语句: 在循环开始最初执行,而且只做唯一一次
      条件判断:如果成立,则循环继续,如果不成立,则循环退出
      循环体:重复做的事情内容,若干行语句;
      步进语句:每次循环之后都要进行的扫尾工作,每次循环结构都要执行一次
      ABCD->BCD -> BCD ->… ->B

      public class Demo09For {
      	public static void main(String[] args){
      		for (int i =1;i<=100;i++){
      			System.out.println("重复"+i);
      		}
      	}
      }
      
    • while循环

      while (条件判断){
      	循环体;
      }
      

      扩展格式:

      	初始化语句;
      	while (条件判断){
      		循环体;
      		步进语句;
      	}
      

      将上面的for循环的例子转为 while的

      public class Demo10While {
      	public static void main(String[] args){
      		int i = 1;
      		while (i<=100){
      			System.out.println("重复"+i);
      			i++;
      		}
      	}
      }
      
    • do…while 循环

      do {
      	循环体
      } while (条件判断);
      

      先无条件执行循环体一次,然后进行对while条件判断是否循环

      初始化语句;
      do {
      	循环体;
      	步进语句;
      } while (条件判断);    //  此处必须要有;
      
      public class Demo11DoWhile{
      	public static void main(String[] args){
      		int i = 1;
      		do {
      			System.out.println("重复"+i);
      			i++;
      		} while (i<=100);
      	}
      }
      
    三种循环的区别
    1. 如果条件从来没有满足过,那么for循环和while循环将会执行0次,但是dowhile循环会执行一次
    2. for循环的变量在小括号当中定义,只有循环内部才能使用,while循环和dowhile循环的初始化语句本来就在外面,所以可以继续使用

    小建议:
    凡是次数确定的场景多用for,否则多用while

    break关键字
    1. 可以在switch语句中,一旦执行,整个switch语句立刻结束
    2. 还可以在循环语句当中,一旦执行,整个循环语句立刻结束,打断循环
    public class Demo14Break {
    	public static void main(String[] args){
    		for (int i = 1; i<=10;i++){
    			if (i==4){ // 如果当前是第四层;
    				break;  // 停止
    			}
    			System.out.println(i+"层到了");
    		}
    	}
    }
    
    continue

    一旦执行,立刻跳过当前次循环剩余内容,马上开始下一次循环。

    public class Demo15Continue {
    	public static void main(String[] args){
    		for (int i = 1; i<=10;i++){
    			if (i==4){ // 如果当前是第四层;
    				continue;  // 则跳过当前次循环,马上开始下一次循环
    			}
    			System.out.println(i+"层到了");
    		}
    	}
    }
    
    死循环

    停不下来的循环

    while (true){
    	循环体;
    }
    
    循环的嵌套
    public class Demo17LoopHourAndMinute {
    	public static void main(String[] args){
    		for (int i =1;i<=24; i++){
    			for (int j = 1; j<=60;j++){
    				System.out.println("time=="+i+":"+j);
    			}
    		}
    	}
    }
    
    展开全文
  • 你必须知道495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    3.5 可否用显式括号来强制执行我所需要计算顺序并控制相关副作用?就算括号不行,操作符优先级是否能够控制计算顺序呢? 3.6 可是&&和||操作符呢?我看到过类似while((c=getchar())!=EOF&&c!='\n')代码……...
  • 019Day-正则、算法

    2020-08-30 22:01:15
    组号是根据向右的小括号的顺序号来确定的。 可以根据 RegExp 的静态变量 $+组号的方法来获得对应组匹配到的内容。 一定要先调用test,然后再获得组对应的匹配的内容。 分组最大的意义:根据分组来获得不同组号匹配的...
  • 方法体:也就是大括号中可以包含任意条语句。 注意事项: 1.方法定义先后顺序无所谓。 2.方法定义不能产生嵌套包含关系。。 3.方法定义好了以后,不会执行,如果想要执行,一定要进行方法
  • 判断条件,如果成立,就执行该if所带的大括号中的代码,如果不成立,则继续向下判断, 如果每个if所带判断条件都不成立,就看当前这个if else-if结构中是否存在else。 如果有else话,则执行else中所带代码,...
  • 《你必须知道495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    3.5 可否用显式括号来强制执行我所需要计算顺序并控制相关副作用?就算括号不行,操作符优先级是否能够控制计算顺序呢? 35  3.6 可是&&和||操作符呢?我看到过类似while((c = getchar()) != EOF && c != '\...
  • 3.5 可否用显式括号来强制执行我所需要计算顺序并控制相关副作用?就算括号不行,操作符优先级是否能够控制计算顺序呢? 35  3.6 可是&&和||操作符呢?我看到过类似while((c = getchar()) != EOF && c != '\...
  • 点分治可以使用“不扣重复答案”的写法,只不过,要先将每个点的子树按照从小到大的顺序排序,防止复杂度出错。(此题不需要,因为统计一个子树的贡献的时候,时间复杂度最多只与当前子树的大小有关,与之前的无关...
  • 10.25 方法入门

    2019-10-25 11:43:42
    方法概念:就是将一个功能抽取出来,把代码单独定义在一个大括号中,形成一个单独功能。需要时就调用。 好处: 实现了代码复用性,也解决了代码冗余现象。 方法命名规则和变量一样,驼峰式 方法体: 可以...
  • 一个单独对象一般不十分有用,而作为一员出现在包含有许多其他对象的大程序或应 用程序之,通过这些对象相互作用,程序员可实现高层次操作和更负责功能。某此 对象通过向其他对象发送消息与其他对象进行...
  • 通配符与正则表达式

    千次阅读 2018-05-18 20:50:38
    \ 转义,将特殊符号特殊意义去除 用于shell中的通配符 符号 意义 ... 内有-表示在编码顺序所有字符,如所有小写 大写 大小写 数字: [a-z] [A-Z] [a-zA-Z] [0-9] [^] 相当于取反 ...
  • LINGO软件学习

    2009-08-08 22:36:50
    集名字必须严格符合标准命名规则:以拉丁字母或下划线(_)为首字符,其后由拉丁字母(A—Z)、下划线、阿拉伯数字(0,1,…,9)组成总长度不超过32个字符字符串,且不区分大小写。 注意:该命名规则同样适用...
  • vue语法.rar

    2019-08-16 11:03:43
    三个点后面是一个类数组,它作用是把这个类数组转成真正数组,但是它需要放到一对中括号里面 2.三个点后面是一个真正数组,它作用是把数组转成一个普通集合数据,不需要加中括号 十七、Symbol介绍 新增...
  • 9.我们可以看见工程中的所有文件都出现在列表了。我们可以直接按下下面 绿色run 按钮或者按下Ctrl+R 快捷键运行程序。 10.程序运行会出现空白对话框,如下图。 11.我们双击文件列表dialog.ui 文件,便出现...
  • 顺序表将元素一个接一个存入一组连续存储单元,在内存物理上是连续。如下图: <img alt="" src="http://my.csdn.net/uploads/201204/26/1335449295_2066.png" /><br /> 顺序表存储密度较...
  • 使用小括号指定一个子表达式后,匹配这个子表达式文本(也就是此分组捕获内容)可以在表达式或其它程序作进一步处理。默认情况下,每个分组会自动拥有一个组号,规则是:从左向右,以分组左括号为标志,...
  • 你必须知道495个C语言问题(PDF)

    热门讨论 2009-09-15 10:25:47
    3.5 我可否用括号来强制执行我所需要计算顺序? . . . . . . . . . . 14 3.6 可是&& 和|| 运算符呢?我看到过类似while((c = getchar()) != EOF && c != ’nn’) 代码⋯⋯ . . . . . . . . . . . . . . . . . . ...
  • Code Compl 代码大全

    2011-05-26 12:09:22
     按照数轴的顺序编写数值表达式  与0比较的指导原则  布尔表达式的常见问题  19.2 复合语句(块)  19.3 空语句  19.4 驯服危险的深层嵌套  对减少嵌套层次的技术的总结  19.5 编程基础:结构化编程  结构...

空空如也

空空如也

1 2 3 4 5
收藏数 89
精华内容 35
关键字:

去大括号中括号小括号的顺序