1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

+-------+-------+--------+
| name  | score | kemu   |
+-------+-------+--------+
| zhang |    98 | yuwen  |
| zhang |    90 | shuxue |
| zhang |    95 | yingyu |
| li    |    94 | yuwen  |
| li    |    95 | shuxue |
| li    |    80 | yingyu |
| wang  |    87 | yuwen  |
| wang  |    97 | shuxue |
| wang  |    93 | yingyu |
+-------+-------+--------+

1

select name,kemu, max(score) as maxscore from students group by kemu;

1
2
3
4
5
6
7

+--------+----------+
| kemu   | maxscore |
+--------+----------+
| yuwen  |       98 |
| shuxue |       97 |
| yingyu |       95 |
+--------+----------+

 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

import java.util.*;


public class Main {
    public static void main(String[] args) {
//        String s="true or false and false";
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        String[] ss = s.split(" ");
        Stack<String> path = new Stack<>();
//        System.out.println(Arrays.toString(ss));
        //将字符串分别进栈操作，当栈顶为"and"时弹出并操作，保证栈中只有"true","false","or",随后再进行判断
        for (int i = 0; i < ss.length; i++) {
            String cur = ss[i];
            if (path.isEmpty()) {//如果栈为空
                if (cur.equals("and")||cur.equals("or")){//如果为and 或 or 直接输出error
                    System.out.println("error");
                    return;
                }else{
                    path.push(cur);
                }
            } else if (cur.equals("true") || cur.equals("false")) {//如果栈不为空，且cur字符串为true或false
                String top = path.peek();//栈顶字符
                if (top.equals("true") || top.equals("false")) {//如果栈顶元素为true或false，说明出现连续的true或false，直接返回error
                    System.out.println("error");
                    return;
                } else if (top.equals("and")) {//如果栈顶元素为and
                    String topdel = path.pop();//将and出栈
                    String predel = path.pop();//将and的前一个字符出栈
                    if (cur.equals("true") && predel.equals("true")) {//进行and操作,
                        path.push("true");//cur and predel -->只有两者同时为true,and的结果才为true
                    } else {
                        path.push("false");
                    }
                } else {//当栈顶元素为or,直接将cur入栈
                    path.push(cur);
                }

            } else if (cur.equals("and") || cur.equals("or")) {//如果栈不为空，且cur字符串为and或or
                String top = path.peek();
                if (top.equals("and")||top.equals("or")){//如果栈顶元素为and或or，直接输出error
                    System.out.println("error");
                    return;
                }else {
                    path.push(cur);
                }
            }
        }

        if (!path.isEmpty()&&(path.peek().equals("and")||path.peek().equals("or"))){
            System.out.println("error");//如果栈顶元素为and 或 or ，直接输出error
            return;
        }
        //此时栈中只剩下 true or false, 只要存在一个true必然输出true,否则输出false
        int flag=0;
        while (!path.isEmpty()){
            String top=path.pop();
            if (top.equals("true")){
                flag=1;
                break;
            }
        }
        if (flag==1){
            System.out.println("true");
        }else{
            System.out.println("false");
        }

    }
}

 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.*;

public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        String P=in.nextLine();
        String T=in.nextLine();
        int lenp=P.length();
        int lent=T.length();
        boolean[][] dp=new boolean[lent+1][lenp+1];
        dp[0][0]=true;
        for(int i=1;i<=lenp;i++){
            if(P.charAt(i-1)=='*'){
                dp[0][i]=true;
            }else{
                break;
            }
        }
        
        for(int i=1;i<=lent;i++){
            for(int j=1;j<=lenp;j++){
                if(P.charAt(j-1)=='*'){
                    dp[i][j]=dp[i-1][j]||dp[i][j-1];
                }
                if(P.charAt(j-1)=='?'||P.charAt(j-1)==T.charAt(i-1)){
                    dp[i][j]=dp[i-1][j-1];
                }
            }
        }
        
        if(dp[lent][lenp]==true){
            System.out.println(1);
        }else{
            System.out.println(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

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        String s=in.nextLine();
        //先判断当前字符的最后一个位置在哪,再不断的更新另一个指针使得开始指针与结尾指针中间的元素在后面不会出现。

        int i=0;
        int j=0;
        int len=s.length();
        while(j<len){
            char lastvalue=s.charAt(j);
            int lastindex=s.lastIndexOf(lastvalue);
            i=j;
            i++;
            int pre=j;
            j=lastindex;
            
            while(i<j){//为了确保开始指针和结尾指针中间的元素不会在结尾指针后面出现
                char curvalue=s.charAt(i);
                int curindex=s.lastIndexOf(curvalue);
                j=Math.max(j,curindex);
                i++;
            }
            
            j++;
            System.out.print(j-pre+" ");
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

/**
一天，小美在写英语作业时，发现了一个十分优美的字符串：
这个字符串没有任何两个字符相同。
于是，小美随手写下了一个字符串，
她想知道这个字符串的的所有子序列，有多少个是优美的。
由于答案可能会很大，输出对20210101取模后的结果。
一个字符串的子序列定义为：
原字符串删除0个或多个字符后剩下的字符保持原有顺序拼接组成的字符串为原串的子序列。
如：ab是acba的子序列，但bc则不是。在本题中。空串也为原串的子序列。
 *
 * 两个子序列不相同，当且仅当他们对应原串的下标不相同。如aab则含有两个子序列ab。
 */

 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

/*
将每个字符的次数加1，全部相乘  ？没有理解
*/
public class bean1 {
    public static void main(String[] args) {
        String s="abcb";
        int len=s.length();

        int[] cnt=new int[26];
        for (int i=0;i<s.length();i++){
            cnt[i]=s.charAt(i)-'a';//统计每个字符串的次数
        }
        int ans=1;
        for (int i=0;i<26;i++){
            ans=ans*(cnt[i]+1)%20210101;
        }
        System.out.println(ans);


//        int[] dp=new int[len+1];
//        Arrays.fill(dp,1);
//        for (int i=1;i<=len;i++){
//            if (s.substring(0,i).contains(String.valueOf(s.charAt(i)))){
//                dp[i]=dp[i]+dp[i-1];
//            }else{
//                dp[i]=dp[i]+(dp[i-1]+1);
//            }
//
//        }
//        System.out.println(dp[len]);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

/**
 * @author zhangbingbing
 * @version 1.0
 * @date 2021/4/4 10:57
今天是小美的生日，妈妈给她专门订制了一个球形的大蛋糕。
小美决定对这个蛋糕切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

/*
两个方向切，纬度切 a 刀，经度切 b 刀，那么纬度切的话是数量是 a+1，经度切的话是 b*2 ，那么最终结果就是 b*2 * (a+1)。
但是需要考虑一种特殊情况，就是经度 b == 0 时，这时最终结果就为 a+1

注意：沿经度切分的时候要经过球心！所以是b*2
*/

public class bean2 {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String s1=in.nextLine();
        int weiducount=0;
        int jingducount=0;
        while (in.hasNext()){
            String ss=in.nextLine();
//            System.out.println(ss.charAt(0));
            if (ss.charAt(0)=='0'){
                weiducount++;//维度切割的次数
            }else if (ss.charAt(0)=='1'){
                jingducount++;//经度切割的次数
            }

        }

//        int ints1=Integer.parseInt(s1);//总的次数
        System.out.println((weiducount+1)*Math.max(jingducount*2,1));


    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

/**
 * @author zhangbingbing
 * @version 1.0
 * @date 2021/4/4 11:08
 * 小美发明了一个函数：f(x)，表示将x的所有正整数因子提取出来之后从小到大排列，
再将数字拼接之后得到的数字串。例如：10的所有因子为1,2,5,10，
那么将这些因子从小到大排序之后再拼接得到的数字串为12510，即f(10)=12510。
 *
小美十分讨厌数字k，如果f(x)中含有某个子串对应的数字等于k，
那么她的不高兴度就会增加1。例如：f(8)=1248，那么其所有的子串为：1,2,4,8,12,24,48,124,248,1248，
只要k等于其中任意一个值，那么小美的不高兴度就会增加1。
对于每一个数，其不高兴度至多增加1。
 *
 * 现在，有一个长度为n的正整数序列，定义其不高兴度为序列中所有数的不高兴度的总和。
小美想要知道自己对于这个序列的总不高兴度为多少。
 */

1

//方法1 直接把所有1-20000的数字都算一遍然后加起来就行。因为k<100000所以最大有5个数字，然后暴力匹配就行了

 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

//方法2： 


public class bean3 {
    public static void main(String[] args) {
        int count=0;
        Scanner in=new Scanner(System.in);
//        String s1=in.nextLine();
        String s1="5 13";
        String[] split1 = s1.split(" ");
        String hatestr=split1[1];
//        char n=s1.charAt(0);
//        int nnum=Integer.parseInt(String.valueOf(n));
//        String s2=in.nextLine();
        String s2="13 31 10 9 20";
        String[] split = s2.split(" ");
        for (int i=0;i<split.length;i++){
            int value=Integer.parseInt(split[i]);//读取数字
            //将数字进行分解
            StringBuilder stringBuilder=new StringBuilder();
            for (int j=1;j<=value;j++){
                if (value%j==0){
                    stringBuilder.append(j);//将因子进行组合
//                    value=value/j;
                }
            }
            String toString = stringBuilder.toString();//将组合后的因子输出为字符串
            boolean contains = toString.contains(hatestr);//判断字符串中是否有讨厌的字符串
            if (contains){
                count++;
            }

        }
        System.out.println(count);

    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

/**
 * @author zhangbingbing
 * @version 1.0
 * @date 2021/4/4 11:16
小美在路上看到一些小学生在玩跳方格，她也想跟着一起玩。
这个方格被划分为n×n的小方格，即有n行n列。
每一个小方格上面都是一个1~k的正整数。小美想依次从1,2,…,k这个顺序来跳。
一开始小美可以站在任意一个小方格。
从一个方格跳到另一个方格的花费为两个方格的曼哈顿距离。
小美想知道是否可以依照该顺序一直跳到k，如果可以，最小的总花费是多少。

两个格子(x1,y1),(x2,y2)的曼哈顿距离为：|x1-x2|+|y1-y2|。
例如(3,4),(1,6)的曼哈顿距离为|3-1|+|4-6|=4。
 */

1
2
3
4
5
6

给定两个数组，连续取这两个数组中的数字使得其和最大
例如：
a=[2, 9, -7, 6]
b=[2, 3, -7, 6]

当在a中取2，9，在b中取2，3时，和是最大的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

public class Main {
    public static void main(String[] args) {
        int[] a = {2, 9, -7, 6};
        int[] b = {2, 3, -7, 6};

        int[] t1 = new int[a.length+1];
        int[] t2=new int[b.length+1];

        int max1=0;
        int max2=0;
        for (int i=0;i<a.length;i++){
            t1[i+1]=t1[i]+a[i];
            max1=Math.max(max1,t1[i+1]);
        }
        for(int i=0;i<b.length;i++){
            t2[i+1]=t2[i]+b[i];
            max2=Math.max(max2,t2[i+1]);
        }
        System.out.println(max1+max2);
    }
}