刷题笔记之四（Fibonacci数列+合法括号序列判断+跳石板+幸运的袋子+两种排序方式+最小公倍数）

深碍√TFBOYSˉ_ 2023-09-25 12:18 117阅读 0赞

**目录**

1. Math类是封装了常用的数学运算

2. Object类的12种常用方法

3. Fibonacci数列

4. 合法括号序列判断

5. 子类父类trycatch调用

6. 跳石板

7. 幸运的袋子

8.跳出forEach循环break

9 .java为后缀的文件中，只能有一个public修饰并且文件名相同的类

10. a++先使用后++

11. 两种排序方式

12. 最小公倍数

--------------------

## 1. Math类是封装了常用的数学运算 ##

![b16d1275eb3043dfb23aa1e5f7aad507.png][]

在Java中Math类封装了常用的数学运算，Math位于java.lang包。它的构造方法是private的，所以无法创建Math类的对象，并且Math类的所有方法都是类方法，可以直接通过类名来调用它们。

<table style="width:650px;"> 
 <thead> 
  <tr> 
   <th>Math.abs(Type number)</th> 
   <th>取绝对值，返回值是传入的类型</th> 
   <th>Math.cell(double number)</th> 
   <th>返回值是double</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Math.floor(double number)</td> 
   <td>向下取整，返回值是double</td> 
   <td>Math.round(Type number)</td> 
   <td>四舍五入</td> 
  </tr> 
  <tr> 
   <td>Math.random()</td> 
   <td>取一个大于等于0.0，小于等于1.0的随机数</td> 
   <td>Math.max(Type x,Type y)</td> 
   <td>取最大值，返回值是double</td> 
  </tr> 
  <tr> 
   <td>Math.min(Type x,Type y)</td> 
   <td>取最小值，返回值是double</td> 
   <td>Math.sqrt(double number)</td> 
   <td>计算平方根</td> 
  </tr> 
 </tbody> 
</table>

--------------------

## 2. Object类的12种常用方法 ##

![ae1fe9ef2196468a976146160180af20.png][]

Object类是所有类的祖先，在jdk1.8中Object一共有12种方法

![d9fceb44041844768b9e70c85c36aa55.png][]

根据用途可以分为6种

1.构造函数

2.hashCode和equals函数用来判断对象是否相同

3.wait() , wait(long) , wait(long , int) , notify() , notifyAll() 主要在多线程中用

4.toString()和getClass都是返回对象，toString返回String对象，getClass返回class对象

5.clone()用来另存一个当前存在的对象

6.finalize()用于垃圾回收

--------------------

## 3. Fibonacci数列 ##

**题目链接：**[Fibonacci数列\_牛客题霸\_牛客网 (nowcoder.com)][Fibonacci_ _nowcoder.com]

**题目要求：**

![23ef5b43368b45d9a2a111ab2c98f823.png][]

**题目分析：**

![b05839c5da564a00a6760c9c21e08499.png][]

**上代码**

import java.util.Scanner;
    
    
    public class Main {
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
                int n = in.nextInt();
                int f1 = 0;
                int f2 = 1;
    
                while(f2 < n) {
                    int f3 = f1 + f2;
                    f1 = f2;
                    f2 = f3;  
                }
                //循环结束 f1 < N <= f2
                int min = Math.min(n-f1,f2-n);
                System.out.println(min);
        }
    }

--------------------

## 4. 合法括号序列判断 ##

**题目链接：**[合法括号序列判断\_牛客题霸\_牛客网 (nowcoder.com)][_nowcoder.com]

**题目要求：**![210cc55acc3e4ad2bcbee397259c6fda.png][]

**题目分析：**

![1ec4026790954cf483762db592404dfb.png][]

**上代码**

public boolean chkParenthesis(String A, int n) {
            if(A.length() % 2 != 0) {
                return false;
            }
            Stack<Character> stack = new Stack<>();
            for (char c : A.toCharArray()) {
                if(c == '(') {
                    stack.push(c);
                }else if(c == ')') {
                    if(stack.isEmpty()) {
                        return false;
                    }else {
                        stack.pop();
                    }
                }else {
                    return false;
                }
            }
           return stack.isEmpty();
        }

--------------------

## 5. 子类父类trycatch调用 ##

![3fc432ebd2dc43448c37a98f47245be3.png][]

![244529f42ab844e396f7b37d84faf1fb.png][]

## 6. 跳石板 ##

**题目链接：**[跳石板\_牛客题霸\_牛客网 (nowcoder.com)][_nowcoder.com 1]

**题目要求：**

![e6e1a087fb844f9e80a1cc0d4aab67e4.png][]

![137ac562f7f048fd9629887a2d7589d8.png][]

**题目分析：**

![4d9b8171ef42420a89bb00b285282091.png][]

**上代码**

import java.util.ArrayList;
    import java.util.List;
    import java.util.Scanner;
    
    public class Main {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            int n = scan.nextInt();
            int m = scan.nextInt();
            int[] step = new int[m+1];
            for (int i = 0; i < m+1; i++) {
                step[i] = Integer.MAX_VALUE;
            }
            step[n] = 0;
            //开始跳，i代表当前石板的编号
            for (int i = n; i < m; i++) {
                if(step[i] == Integer.MAX_VALUE) {
                    //无法跳跃到这个位置
                    continue;
                }
                List<Integer> list = div(i);
                //j代表一次可以跳几块石板
                for (int j : list) {
                    if(i+j <= m && step[i+j] != Integer.MAX_VALUE) {
                        //当前石板本身的次数 和 现在刚过来的次数进行比较
                        step[i+j] = Math.min(step[i+j],step[i]+1);
                    }else if(i+j <= m) {
                        //当前石板上是默认的MAX，那刚跳过来就在上一次的基础上+1
                        step[i+j] = step[i]+1;
                    }
                }
            }
            if(step[m] == Integer.MAX_VALUE) {
                //当前m上如果为MAX，说明就没有跳过来
                System.out.println(-1);
            }else {
                System.out.println(step[m]);
            }
        }
        //求i的约数
        private static List<Integer> div(int num) {
            List<Integer> list = new ArrayList<>();
            for (int i = 2; i*i <= num; i++) {
                if(num%i == 0) {
                    list.add(i);
                    //比如16的约数4，上面已经放了4下面就不能重复放
                    //这里放大于i的约数
                    if(num/i != i) {
                        list.add(num/i);
                    }
                }
            }
            return list;
        }
    }

## 7. 幸运的袋子 ##

**题目链接：**[幸运的袋子\_牛客题霸\_牛客网 (nowcoder.com)][_nowcoder.com 2]

**题目要求：**

![4beeae670e244fdb87905b2def6feabc.png][]

![b1935f46ccdf481687e8de6a20642e08.png][]

**题目分析：**

![caf2779632d04e9fbc6a996d7a91dcd3.png][]

**上代码**

import java.util.Arrays;
    import java.util.Scanner;
    
    public class Main {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            int m = scan.nextInt();
            int[] array = new int[m];
            for (int i = 0; i < m; i++) {
                array[i] = scan.nextInt();
            }
            Arrays.sort(array);
            System.out.println(count(array,m,0,0,1));
        }
    
        public static int count(int[] a, int n, int pos, int sum, int multi) {
            int count = 0;
            for (int i = pos; i < n; i++) {
                sum += a[i];
                multi *= a[i];
                if(sum > multi) {
                    count = count + 1 + count(a,n,i+1,sum,multi);
                }else if(a[i] == 1) {
                    count = count + count(a,n,i+1,sum,multi);
                }else {
                    break;
                }
                sum = sum - a[i];
                multi = multi/a[i];
                //拥有相同号码的球是无区别的，判断下一个球和当前是否一样
                while(i < n-1 && a[i] == a[i+1]) {
                    i++;
                }
            }
            return count;
        }
    }

--------------------

## 8.跳出forEach循环break ##

![988a71bd41e54b62a34875a2f84992bc.png][]

在方法中，返回值可能为int String boolean 等，而B，C中返回一个boolean类型的，可能不是当前方法所要的返回值

而想要跳出循环，break就可以了

## 9 .java为后缀的文件中，只能有一个public修饰并且文件名相同的类 ##

![760798b8b197471582c78f6447e97112.png][]

以.java为后缀的文件中，可以包含多个类，但只能有一个public修饰并且文件名相同的类

--------------------

## 10. a++先使用后++ ##

![22b39df9a1394c45b0020f09b7c2ce5e.png][]

![a87e34d0673e4b6f9951771992011b63.png][]

--------------------

## 11. 两种排序方式 ##

**题目链接：**[两种排序方法\_牛客题霸\_牛客网 (nowcoder.com)][_nowcoder.com 3]

**题目要求：**

![2199f145f9cf41c0b6c4ea9ac14db089.png][]

![9cbed0471fd0490c8f2a0633494fa868.png][]

**题目分析：**

这道题是两种排序方式：按照字典顺序排列单词；按照单词长度排列单词

综合根据两种排序方式，输出对应语句

所以可以考虑将两张排序方式，单独写两个方法

isSortZidian()：如果给方法中传的参数是字符串数组的话，那么比较时直接在循环里用comparTo()比较两个单词就可以

isSortLength()：如果给方法中传的参数是字符串数组的话，那么比较时直接在循环里比较两个字符串的长度就可以了

所以我们最好在前面输入时，将输入的每一行字符放进字符串数组中去

也就是每一行读取，放入字符串数组中，这里可以考虑使用BufferedReader

> BufferedReader是从缓冲区之中读取内容，所有的输入的字节数据都将放在缓冲区之中。
> 
> 主要是因为BufferedReader中有一个方法readLine（），使用起来特别方便，每次读回来的都是一行，但System.in本身表示的是InputSteam（字节流），现在要求接收的是一个字符流，这里就需要将字节流转为字符流就可以了用InputStreamReader
> 
>  **BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));**

**上代码**

import java.util.Scanner;
    import java.io.*;
    
    public class Main {
        public static void main(String[] args) throws IOException{
            BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));
            //每次读一行 readLine
            int n = Integer.parseInt(bi.readLine());
            String[] str = new String[n];
            for(int i = 0; i < n; i++) {
                str[i] = bi.readLine();
            }
            //判断
             if(isSortZidian(str) && !isSortLength(str)) {
                System.out.println("lexicographically");
            }else if(!isSortZidian(str) && isSortLength(str)) {
                System.out.println("lengths");
            }else if(isSortZidian(str) && isSortLength(str)) {
                System.out.println("both");
            }else {
                System.out.println("none");
            }
        }
    
        private static boolean isSortZidian(String[] str) {
            for(int i = 0; i < str.length-1; i++) {
                if(str[i].compareTo(str[i+1]) > 0) {
                    return false;
                }
            }
            return true;
        } 
         private static boolean isSortLength(String[] str) {
            for (int i = 0; i < str.length-1; i++) {
                if(str[i].length() > str[i+1].length()) {
                    return false;
                }
            }
            return true;
        }
    }

--------------------

## 12. 最小公倍数 ##

**题目链接：**[求最小公倍数\_牛客题霸\_牛客网 (nowcoder.com)][_nowcoder.com 4]

**题目要求：**

![abcac7a0818e409b94c62e0c16604dd7.png][]

**题目分析：**

**AB最小公倍数 = A\*B / (AB最大公约数)**

AB最大公约数用辗转相除法

记住这个公式，下次写**辗转相除法照着这个写 gcd（a，b）=gcd（b，a%b）**

还是感觉递归的这个对照这个公式好写

![36f9f18770594caa9d0a48047597e48a.png][]

**上代码**

import java.util.Locale;
    import java.util.Scanner;
    
    public class Main {
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            int n = scan.nextInt();
            int m = scan.nextInt();
            System.out.println(n*m/gcd(n,m));
        }
    
        //辗转相除法求最大公约数
        private static int gcd(int a, int b ) {
            if(b == 0){
                return a;
            }
            int r = a%b;
            return gcd(b,r);
        }
    }

--------------------

[b16d1275eb3043dfb23aa1e5f7aad507.png]: https://img-blog.csdnimg.cn/b16d1275eb3043dfb23aa1e5f7aad507.png
[ae1fe9ef2196468a976146160180af20.png]: https://img-blog.csdnimg.cn/ae1fe9ef2196468a976146160180af20.png
[d9fceb44041844768b9e70c85c36aa55.png]: https://img-blog.csdnimg.cn/d9fceb44041844768b9e70c85c36aa55.png
[Fibonacci_ _nowcoder.com]: https://www.nowcoder.com/practice/18ecd0ecf5ef4fe9ba3f17f8d00d2d66?tpId=85&&tqId=29846&rp=1&ru=/activity/oj&qru=/ta/2017test/question-ranking
[23ef5b43368b45d9a2a111ab2c98f823.png]: https://img-blog.csdnimg.cn/23ef5b43368b45d9a2a111ab2c98f823.png
[b05839c5da564a00a6760c9c21e08499.png]: https://img-blog.csdnimg.cn/b05839c5da564a00a6760c9c21e08499.png
[_nowcoder.com]: https://www.nowcoder.com/practice/d8acfa0619814b2d98f12c071aef20d4?tpId=8&&tqId=11039&rp=1&ru=/activity/oj&qru=/ta/cracking-the-coding-interview/question-ranking
[210cc55acc3e4ad2bcbee397259c6fda.png]: https://img-blog.csdnimg.cn/210cc55acc3e4ad2bcbee397259c6fda.png
[1ec4026790954cf483762db592404dfb.png]: https://img-blog.csdnimg.cn/1ec4026790954cf483762db592404dfb.png
[3fc432ebd2dc43448c37a98f47245be3.png]: https://img-blog.csdnimg.cn/3fc432ebd2dc43448c37a98f47245be3.png
[244529f42ab844e396f7b37d84faf1fb.png]: https://img-blog.csdnimg.cn/244529f42ab844e396f7b37d84faf1fb.png
[_nowcoder.com 1]: https://www.nowcoder.com/practice/4284c8f466814870bae7799a07d49ec8?tpId=122&tqId=33674&ru=/exam/oj
[e6e1a087fb844f9e80a1cc0d4aab67e4.png]: https://img-blog.csdnimg.cn/e6e1a087fb844f9e80a1cc0d4aab67e4.png
[137ac562f7f048fd9629887a2d7589d8.png]: https://img-blog.csdnimg.cn/137ac562f7f048fd9629887a2d7589d8.png
[4d9b8171ef42420a89bb00b285282091.png]: https://img-blog.csdnimg.cn/4d9b8171ef42420a89bb00b285282091.png
[_nowcoder.com 2]: https://www.nowcoder.com/practice/a5190a7c3ec045ce9273beebdfe029ee?tpId=122&tqId=33661&ru=/exam/oj
[4beeae670e244fdb87905b2def6feabc.png]: https://img-blog.csdnimg.cn/4beeae670e244fdb87905b2def6feabc.png
[b1935f46ccdf481687e8de6a20642e08.png]: https://img-blog.csdnimg.cn/b1935f46ccdf481687e8de6a20642e08.png
[caf2779632d04e9fbc6a996d7a91dcd3.png]: https://img-blog.csdnimg.cn/caf2779632d04e9fbc6a996d7a91dcd3.png
[988a71bd41e54b62a34875a2f84992bc.png]: https://img-blog.csdnimg.cn/988a71bd41e54b62a34875a2f84992bc.png
[760798b8b197471582c78f6447e97112.png]: https://img-blog.csdnimg.cn/760798b8b197471582c78f6447e97112.png
[22b39df9a1394c45b0020f09b7c2ce5e.png]: https://img-blog.csdnimg.cn/22b39df9a1394c45b0020f09b7c2ce5e.png
[a87e34d0673e4b6f9951771992011b63.png]: https://img-blog.csdnimg.cn/a87e34d0673e4b6f9951771992011b63.png
[_nowcoder.com 3]: https://www.nowcoder.com/practice/839f681bf36c486fbcc5fcb977ffe432?tpId=85&&tqId=29844&rp=1&ru=/activity/oj&qru=/ta/2017test/question-ranking
[2199f145f9cf41c0b6c4ea9ac14db089.png]: https://img-blog.csdnimg.cn/2199f145f9cf41c0b6c4ea9ac14db089.png
[9cbed0471fd0490c8f2a0633494fa868.png]: https://img-blog.csdnimg.cn/9cbed0471fd0490c8f2a0633494fa868.png
[_nowcoder.com 4]: https://www.nowcoder.com/practice/22948c2cad484e0291350abad86136c3?tpId=37&&tqId=21331&rp=1&ru=/activity/oj&qru=/ta/huawei/question-ranking
[abcac7a0818e409b94c62e0c16604dd7.png]: https://img-blog.csdnimg.cn/abcac7a0818e409b94c62e0c16604dd7.png
[36f9f18770594caa9d0a48047597e48a.png]: https://img-blog.csdnimg.cn/36f9f18770594caa9d0a48047597e48a.png