华为机试题解

发表于 | 分类于 |

华为机试练习

近似取值

描述

写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。

输入描述：

输入一个正浮点数值

输出描述：

输出该数值的近似整数值

1
2
3
4
5
6
7
8
9
10
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        double num = sc.nextDouble();
        //对输入+0.5强转int
        System.out.println((int)(num + 0.5));
    }
}

求int型正整数在内存中存储时1的个数

描述

输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。

输入描述：

输入一个整数（int类型）

输出描述：

这个数转换成2进制后，输出1的个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        //接收一个int
        int num = new Scanner(System.in).nextInt();
        //创建一个res保存结果
        int res = 0;
        while(num != 0){
            //自己和自己-1相与能将二进制最后一位1变成0
            num = num & (num - 1);
            res++;
        }
        
        System.out.println(res);
    }
}

数字颠倒

描述

输入一个整数，将这个整数以字符串的形式逆序输出

程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001

输入描述：

输入一个int整数

输出描述：

将这个整数以字符串的形式逆序输出

1
2
3
4
5
6
7
8
9
10
11
import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        //输入一个整数
        int num = new Scanner(System.in).nextInt();
        //将整数转换为字符串
        StringBuilder sb = new StringBuilder(""+num);
        //反转字符串
        System.out.println(sb.reverse());
    }
}

字符串反转

描述

接受一个只包含小写字母的字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）

输入描述：

输入一行，为一个只包含小写字母的字符串。

输出描述：

输出该字符串反转后的字符串。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        //接收一个字符串
        String src = new Scanner(System.in).nextLine();
        //获得一个字符串数组
        char[] ch = src.toCharArray();
        //交换字符串数组字符
        for(int i = 0; i < (ch.length >> 1); i++){
            char temp = ch[i];
            ch[i] = ch[ch.length - 1 - i];
            ch[ch.length - 1 - i] = temp;
        }
        
        System.out.println(new String(ch));
    }
}

求最小公倍数

描述

正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。

输入描述：

输入两个正整数A和B。

输出描述：

输出A和B的最小公倍数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        //获取两个整数
        Scanner sc = new Scanner(System.in);
        int numA = sc.nextInt();
        int numB = sc.nextInt();
        //获取两个数的最大公约数
        int gc = gcd(numA, numB);
        //最小公倍数为两数之积除以两数最大公约数
        System.out.println(numA * numB / gc);
        //关闭流
        sc.close();
    }    
    
    //最小公约数
    private static int gcd(int numA, int numB){
        //辗转相除法
        return numB == 0 ? numA : gcd(numB, numA%numB);
    }
}

汽水瓶

描述

有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？

输入描述：

输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。

输出描述：

对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        //获取命令行输入
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            //接收一个输入
            int num = sc.nextInt();
            //若num为0则退出程序
            if(num == 0){
                break;
            }
            
            //可以直接换的个数
            int drink = num / 3;
            //存放结果的变量
            int res = drink;
            //还剩下的瓶盖
            int empty = num % 3;
            //总共的瓶盖
            int sum = empty + drink;
            //循环迭代
            while((sum / 3) >= 1){
                drink = sum / 3;
                res += drink;
                empty = sum % 3;
                sum = drink + empty;
            }
            //若最后剩下两个瓶盖还能再喝一瓶
            if(sum == 2){
                res++;
            }
            
            System.out.println(res);
        }
        sc.close();
    }
}

统计每个月兔子的总数

描述

有一只兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子，假如兔子都不死，问每个月的兔子总数为多少？

本题有多组数据。

输入描述：

输入int型表示month

输出描述：

输出兔子总数int型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        //定义初始第一个月的兔子数为1， 第二个月兔子数为2，第三个月兔子数为3
        while(sc.hasNext()){
            //输入月数
            int month = sc.nextInt();
            int oneMonth = 1, twoMonth = 0, threeMonth = 0;

            while(--month > 0){
                //大于等于三个月的兔子等于之前三个月兔子数+两个月的兔子数
                threeMonth = threeMonth + twoMonth;
                //两个月的兔子数为之前一个月的兔子数
                twoMonth = oneMonth;
                //一个月的兔子数为之前三个月的兔子数
                oneMonth = threeMonth;
            }

            System.out.println(threeMonth + twoMonth + oneMonth);
        }
        sc.close();
    }
}

杨辉三角的变形

描述

以上三角形的数阵，第一行只有一个数1，以下每行的每个数，是恰好是它上面的数，左上角数到右上角的数，3个数之和（如果不存在某个数，认为该数就是0）。

求第n行第一个偶数出现的位置。如果没有偶数，则输出-1。例如输入3,则输出2，输入4则输出3。

输入n(n <= 1000000000)

本题有多组输入数据，输入到文件末尾，请使用while(cin>>)等方式读入

输入描述：

输入一个int整数

输出描述：

输出返回的int值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        //输入
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            //接收输入的整数
            int num = sc.nextInt();
            //规律：第一行和第二行没有偶数
            if(num == 1 || num == 2){
                System.out.println(-1);
                //以后按照2324输出。即-1 -1 2 3 2 4 2 3 2 4 ...
            }else if((num-2) % 4 == 1 || (num-2) % 4 == 3){
                System.out.println(2);
            }else if((num-2) % 4 == 2){
                System.out.println(3);
            }else{
                System.out.println(4);
            }
        }
    }
}

完全数计算

描述

完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。

它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。

例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。s

输入n，请输出n以内(含n)完全数的个数。计算范围, 0 < n <= 500000

本题输入含有多组样例。

输入描述：

输入一个数字n

输出描述：

输出不超过n的完全数的个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        //获取输入
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            //获取输入
            int num = sc.nextInt();
            
            //定义一个变量用于保存结果
            int res = 0;
            //第一个for循环用来遍历所有的数
            for(int i = 1; i <= num; i++){
                int sum = 0;
                //第二个for循环用来判断是否为完全数
                for(int j = 1; j < i; j++){
                    if(i % j == 0){
                        sum += j;
                    }
                }
                if(sum == i){
                    res++;
                }
            }
            
            System.out.println(res);
        }
        
        sc.close();
    }
}

字符逆序

描述

将一个字符串str的内容颠倒过来，并输出。str的长度不超过100个字符。

输入描述：

输入一个字符串，可以有空格

输出描述：

输出逆序的字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        //获取输入
        String str = sc.nextLine();
        
        //获取字符串数组
        char[] ch = str.toCharArray();
        //遍历字符串数组进行反转
        for(int i = 0; i < (ch.length >> 1); i++){
            char temp = ch[i];
            ch[i] = ch[ch.length - 1 - i];
            ch[ch.length - 1 - i] = temp;
        }
        
        System.out.println(new String(ch));
        
        sc.close();
    }
}

等差数列

描述

功能:等差数列 2，5，8，11，14。。。。

输入:正整数N >0

输出:求等差数列前N项和

本题为多组输入，请使用while(cin>>)等形式读取数据

输入描述：

输入一个正整数。

输出描述：

输出一个相加后的整数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        //获取输入
        while(sc.hasNext()){
            int num = sc.nextInt();

            //获取末项
            int end = 2 + 3 * (num - 1);

            //等差数列求和：(首项+末项)*项数/2
            System.out.println((2 + end) * num / 2);
        }
        
        sc.close();
    }
}

查找输入整数二进制1的个数

描述

输入一个正整数，计算它在二进制下的1的个数。

注意多组输入输出！！！！！！

输入描述：

输入一个整数

输出描述：

计算整数二进制中1的个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            //获取整数
            int num = sc.nextInt();
            
            //定义一个变量保存结果
            int res = 0;
            while(num != 0){
                //num & num-1 将二进制最后一个1变为0
                num &= (num - 1);
                res++;
            }
            
            System.out.println(res);
        }
        
        sc.close();
    }
}

求最大连续bit数

描述

求一个byte数字对应的二进制数字中1的最大连续数，例如3的二进制为00000011，最大连续2个1

本题含有多组样例输入。

输入描述：

输入一个byte数字

输出描述：

输出转成二进制之后连续1的个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import java.util.Scanner;
import java.math.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            //获取输入
            int num = sc.nextInt();
            
            //创建一个变量用于存放结果
            int res = 0;
            //创建一个临时计数器
            int count = 0;
            
            //对输入的数字每个位置判断是否为1,是则count++，res取res，count的Max，否则重置count
            for(int i = 0; i < 32; i++){
                if(((num >>> i) & 1) == 1){
                    count++;
                    res = Math.max(res, count);
                }else{
                    count = 0;
                }
            }
            
            System.out.println(res);
        }
        
        sc.close();
    }
}

统计大写字母个数

描述

找出给定字符串中大写字符(即’A’-‘Z’)的个数。

输入描述：

本题含有多组样例输入
对于每组样例，输入一行，代表待统计的字符串

输出描述：

对于每组样例，输出一个整数，代表字符串中大写字母的个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            //获取输入
            String str = sc.nextLine();
            
            //创建一个变量用于存储结果
            int res = 0;
            //遍历字符串数组
            for(char ch : str.toCharArray()){
                if('A' <= ch && ch <= 'Z'){
                    res++;
                }
            }
            
            System.out.println(res);
        }
        
        sc.close();
    }
}

尼科彻斯定理

描述

验证尼科彻斯定理，即：任何一个整数m的立方都可以写成m个连续奇数之和。

例如：

1^3=1

2^3=3+5

3^3=7+9+11

4^3=13+15+17+19

输入一个正整数m（m≤100），将m的立方写成m个连续奇数之和的形式输出。

本题含有多组输入数据。

输入描述：

输入一个int整数

输出描述：

输出分解后的string

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            //获取输入
            int num = sc.nextInt();
            
            if(num == 1){
                System.out.println("1");
                continue;
            }
            
            //获取初始值
            int pre = num * num - (num - 1);
            //创建一个StringBuilder用于存储结果
            StringBuilder res = new StringBuilder();
            for(int i = 0; i < num; i++){
                //序列为+2的序列
                int temp = pre + 2 * (i);
                if(i < num - 1){
                    res.append(temp).append("+");
                }else{
                    res.append(temp);
                }
            }
            
            System.out.println(res);
            
            
        }
        
        sc.close();
    }
}

最长回文字串

描述

给定一个仅包含小写字母的字符串，求它的最长回文子串的长度。

所谓回文串，指左右对称的字符串。

所谓子串，指一个字符串删掉其部分前缀和后缀（也可以不删）的字符串

（注意：记得加上while处理多个测试用例）

输入描述：

输入一个仅包含小写字母的字符串

输出描述：

返回最长回文子串的长度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            //获取输入
            String str = sc.nextLine();
            //获取str的长度
            int n = str.length();
            //创建一个变量用于存储结果
            int res = 0;
            //创建一个二维数组用于db
            boolean[][] dp = new boolean[n][n];
            
            for(int i = 0; i < n; i++){
                for(int j = 0; j <= i; j++){
                    //j - i 位置是否为回文，取决于j i 两个字符串是否相同，且 j+1 - i-1字符串是否回文
                    dp[j][i] = (str.charAt(j) == str.charAt(i)) && ((i - j <= 2) || dp[j+1][i-1]);
                    //判断j - i是否回文
                    if(dp[j][i]){
                        //若回文长度大于之前的结果则覆盖结果
                        if(i - j + 1 > res){
                            res = i - j + 1;
                        }
                    }
                }
            }
            
            System.out.println(res);
        }
        
        sc.close();
    }
}

放苹果

描述

题目描述

把m个同样的苹果放在n个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？（用K表示）5，1，1和1，5，1 是同一种分法。

数据范围：0<=m<=10，1<=n<=10。

本题含有多组样例输入。

输入描述：

输入两个int整数

输出描述：

输出结果，int型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            //获取输入
            int m = sc.nextInt();
            int n = sc.nextInt();
            
            System.out.println(computer(m, n));
            
        }
        
        sc.close();
    }
    
    private static int computer(int m ,int n){
        //递归出口为:当苹果数小于等于1或盘子数为1时仅有一种方法
        if(m <= 1 || n == 1){
            return 1;
        }
        
        //当盘子数多于苹果数时，多余的盘子用不到
        if(n > m){
            return computer(m, m);
        }else{
            //结果为1：至少有一个盘子用不到的情况 + 2:每个位置上都有苹果
            return computer(m, n-1) + computer(m-n, n);
        }
    }
}

百钱买买鸡问题

描述

公元前五世纪，我国古代数学家张丘建在《算经》一书中提出了“百鸡问题”：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？

详细描述：

接口说明

原型：

int GetResult(vector &list)

输入参数：

无

输出参数（指针指向的内存区域保证有效）：

list 鸡翁、鸡母、鸡雏组合的列表

返回值：

-1 失败

0 成功

输入描述：

输入任何一个整数，即可运行程序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            int num = sc.nextInt();
            int x = 0, y = 0;
            //确保z为3的倍数进行遍历
            for(int z = 0; z < 100; z+=3){
                x = 4 * z / 3 - 100;
                y = 200 - (7 * z / 3);
                if(0 <= x && x <= 100 && 0 <= y && y <= 100){
                    System.out.println(x + " " + y + " " + z);
                }
            }
        }
        
        sc.close();
    }
}

配置文件恢复

描述

有6条配置命令，它们执行的结果分别是：

为了简化输入，方便用户，以“最短唯一匹配原则”匹配：
1、若只输入一字串，则只匹配一个关键字的命令行。例如输入：r，根据该规则，匹配命令reset，执行结果为：reset what；输入：res，根据该规则，匹配命令reset，执行结果为：reset what；
2、若只输入一字串，但本条命令有两个关键字，则匹配失败。例如输入：reb，可以找到命令reboot backpalne，但是该命令有两个关键词，所有匹配失败，执行结果为：unknown command
3、若输入两字串，则先匹配第一关键字，如果有匹配但不唯一，继续匹配第二关键字，如果仍不唯一，匹配失败。例如输入：r b，找到匹配命令reset board 和 reboot backplane，执行结果为：unknown command。

4、若输入两字串，则先匹配第一关键字，如果有匹配但不唯一，继续匹配第二关键字，如果唯一，匹配成功。例如输入：b a，无法确定是命令board add还是backplane abort，匹配失败。
5、若输入两字串，第一关键字匹配成功，则匹配第二关键字，若无匹配，失败。例如输入：bo a，确定是命令board add，匹配成功。
6、若匹配失败，打印“unknown command”

输入描述：

多行字符串，每行字符串一条命令

输出描述：

执行结果，每条命令输出一行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);

        //构建一个Map集合保存命令与执行
        Map<String, String> map = new HashMap<>();
        map.put("reset", "reset what");
        map.put("reset board", "board fault");
        map.put("board add", "where to add");
        map.put("board delete", "no board at all");
        map.put("reboot backplane", "impossible");
        map.put("backplane abort", "install first");
        map.put("nomach", "unknown command");

        //构建一个set集合用于保存Map_key构建的字符串数组
        Set<String[]> set = new HashSet<>();
        for(String s : map.keySet()){
            set.add(s.split(" "));
            }

        
        while(sc.hasNext()){
            //获取输入
            String str = sc.nextLine();
            //将输入字符串转为字符串数组
            String[] input = str.split(" ");
            //构建一个计数器用于检测能匹配几个命令
            int count = 0;
            //初始字符串为nomach
            String res = "nomach";
            //遍历set集合
            for(String[] s : set){
                //判断输入字符串数组长度
                if(input.length == 1){
                    if(s.length == 2){
                        continue;
                    }else{
                        //检验前缀是否相同
                        if(s[0].startsWith(input[0])){
                            res = s[0];
                        }
                    }
                }
                if(input.length == 2){
                    if(s.length == 1){
                        continue;
                    }else{
                        if(s[0].startsWith(input[0]) && s[1].startsWith(input[1])){
                            res = s[0] + " " + s[1];
                        }
                    }
                }
            }
            
            System.out.println(count > 1 ? "unknown command" : map.get(res));
        }
    }
}

计算日期到天数转换

描述

根据输入的日期，计算是这一年的第几天。

输入描述：

输入一行，每行空格分割，分别是年，月，日

输出描述：

输出是这一年的第几天

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        //获取输入
        int y = sc.nextInt(), m = sc.nextInt(), d = sc.nextInt();
        
        //创建一个Map集合保存月份对应的天数
        Map<Integer, Integer> map = new HashMap<>();
        
        map.put(1, 31);
        //闰年二月
        if(y % 4 == 0 && y % 100 != 0){
            map.put(2, 29);
        }else{
            map.put(2, 28);
        }
        map.put(3, 31);
        map.put(4, 30);
        map.put(5, 31);
        map.put(6, 30);
        map.put(7, 31);
        map.put(8, 31);
        map.put(9, 30);
        map.put(10, 31);
        map.put(11, 30);
        map.put(12, 31);
        
        //构建一个变量用于保存结果
        int res = 0;
        for(int i = 1; i < m ; i++){
            res += map.get(i);
        }
        System.out.println(res + d);
    }
}

参数解析

描述

在命令行输入如下命令：

xcopy /s c:\ d:\，

各个参数如下：

参数1：命令字xcopy

参数2：字符串/s

参数3：字符串c:\

参数4: 字符串d:\

请编写一个参数解析程序，实现将命令行各个参数解析出来。

解析规则：

1.参数分隔符为空格
2.对于用””包含起来的参数，如果中间有空格，不能解析为多个参数。比如在命令行输入xcopy /s “C:\program files” “d:\”时，参数仍然是4个，第3个参数应该是字符串C:\program files，而不是C:\program，注意输出参数时，需要将””去掉，引号不存在嵌套情况。
3.参数不定长
4.输入由用例保证，不会出现不符合要求的输入

输入描述：

输入一行字符串，可以有空格

输出描述：

输出参数个数，分解后的参数，每个参数都独占一行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        //创建一个List用于保存结果
        List<String> res = new ArrayList<>();
            //获取输入
        String str = sc.nextLine();
        str.trim();
        //遍历字符串
        for(int i = 0; i < str.length(); i++){
           //若当前i处不为“，则记录开始
            if(str.charAt(i) != '"'){
                //记录初始
                int start = i;
                //继续遍历直到为空格
                while(i < str.length() && str.charAt(i) != ' '){
                    i++;
                }
                res.add(str.substring(start, i));
            }else{
                //遇到引号则跳过
                int start = ++i;
                while(i < str.length() && str.charAt(i) != '"'){
                    i++;
                }
                res.add(str.substring(start, i));
                //跳过引号
                i++;
            }
        }
        
        System.out.println(res.size());
        for(String s : res){
            System.out.println(s);
        }
    }
}

公共字串计算

描述

给定两个只包含小写字母的字符串，计算两个字符串的最大公共子串的长度。

注：子串的定义指一个字符串删掉其部分前缀和后缀（也可以不删）后形成的字符串。

输入描述：

输入两个只包含小写字母的字符串

输出描述：

输出一个整数，代表最大公共子串的长度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        //获取输入
        while(sc.hasNext()){
            String str1 = sc.nextLine();
            String str2 = sc.nextLine();
            System.out.println(findSubLength(str1, str2));
        }
        sc.close();
    }
    
    private static int findSubLength(String str1, String str2){
        //获取两个字符串的长度
        int length1 = str1.length();
        int length2 = str2.length();
        
        //构建一个二维dp数组
        int[][] dp = new int[length1+1][length2+1];
        
        //遍历两个字符串
        for(int i = 1; i <= length1; i++){
            for(int j = 1; j <= length2; j++){
                //若字符串的最后一位相同，则最长字串长度+1
                if(str1.charAt(i-1) == str2.charAt(j-1)){
                    dp[i][j] = dp[i-1][j-1] + 1;
                }else{
                    //否则为
                    dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
                }
            }
        }
        
        return dp[length1][length2];
    }
}

密码强度

描述

密码按如下规则进行计分，并根据不同的得分为密码进行安全等级划分。

一、密码长度:

5 分: 小于等于4 个字符

10 分: 5 到7 字符

25 分: 大于等于8 个字符

二、字母:

0 分: 没有字母

10 分: 全都是小（大）写字母

20 分: 大小写混合字母

三、数字:

0 分: 没有数字

10 分: 1 个数字

20 分: 大于1 个数字

四、符号:

0 分: 没有符号

10 分: 1 个符号

25 分: 大于1 个符号

五、奖励:

2 分: 字母和数字

3 分: 字母、数字和符号

5 分: 大小写字母、数字和符号

最后的评分标准:

>= 90: 非常安全

>= 80: 安全（Secure）

>= 70: 非常强

>= 60: 强（Strong）

>= 50: 一般（Average）

>= 25: 弱（Weak）

>= 0: 非常弱

对应输出为：

VERY_SECURE

SECURE,

VERY_STRONG,

STRONG,

AVERAGE,

WEAK,

VERY_WEAK

输入描述：

本题含有多组输入样例。
每组样例输入一个string的密码

输出描述：

每组样例输出密码等级

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            
            //获取输入
            String str = sc.nextLine();
            
            //获取结果res
            int res = 0;
            
            //保存小写字母数,大写字母数
            int low = 0, hi = 0;
            //保存数字数
            int number = 0;
            //保存字符数
            int symbol = 0;
            
            //遍历字符串
            for(int i = 0; i < str.length(); i++){
                char ch = str.charAt(i);
                if('a' <= ch && ch <= 'z'){
                    low++;
                }else if('A' <= ch && ch <= 'Z'){
                    hi++;
                }else if('0' <= ch && ch <= '9'){
                    number++;
                }else{
                    symbol++;
                }
            }
            
            if(str.length() <= 4){
                res = res + 5;
            }else if(str.length() <= 7){
                res = res + 10;
            }else{
                res = res + 25;
            }
            
            if(low == 0 && hi == 0){
                res = res + 0;
            }else if(low * hi == 0){
                res = res + 10;
            }else{
                res = res + 20;
            }
            
            if(number == 0){
                res = res + 0;
            }else if(number == 1){
                res = res + 10;
            }else{
                res = res + 20;
            }
            
            if(symbol == 0){
                res = res + 0;
            }else if(symbol == 1){
                res = res + 10;
            }else{
                res = res + 25;
            }
            
            if(low * hi * number * symbol > 0){
                res = res + 5;
            }else if((low + hi) * number * symbol > 0){
                res = res + 3;
            }else if((low + hi) * number > 0){
                res = res + 2;
            }
            
            f(res);
        }
    }
        
    public static void f(int grade) {
        if (grade >= 90) {
            System.out.println("VERY_SECURE");
        } else if (grade >= 80 && grade < 90) {
            System.out.println("SECURE");
        } else if (grade >= 70 && grade < 80) {
            System.out.println("VERY_STRONG");
        } else if (grade >= 60 && grade < 70) {
            System.out.println("STRONG");
        } else if (grade >= 50 && grade < 60) {
            System.out.println("AVERAGE");
        } else if (grade >= 25 && grade < 50) {
            System.out.println("WEAK");
        } else if (grade >= 0 && grade < 25) {
            System.out.println("VERY_WEAK");
        }
    }
}

走方格的方案数

描述

请计算n*m的棋盘格子（n为横向的格子数，m为竖向的格子数）沿着各自边缘线从左上角走到右下角，总共有多少种走法，要求不能走回头路，即：只能往右和往下走，不能往左和往上走。

本题含有多组样例输入。

输入描述：

每组样例输入两个正整数n和m，用空格隔开。(1≤n,m≤8)

输出描述：

每组样例输出一行结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            
            //获取输入
            String[] str = sc.nextLine().split(" ");
            int m = Integer.parseInt(str[0]) + 1;
            int n = Integer.parseInt(str[1]) + 1;
            
            //创建一个dp数组
            int[][] dp = new int[m][n];
            dp[0][0] = 1;
            for(int i = 0; i < m; i++){
                for(int j = 0; j < n; j++){
                    if(i > 0 && j > 0){
                        dp[i][j] = dp[i-1][j] + dp[i][j-1];
                    }else if(i > 0){
                        dp[i][j] = dp[i-1][j];
                    }else if(j > 0){
                        dp[i][j] = dp[i][j-1];
                    }
                }
            }
            
            System.out.println(dp[m-1][n-1]);
            
        }
    }
}
Donate comment here