笔试强训(十八)

一、选择题

（1）如下SQL语句中，（D）可能返回null值
(1) select count(*) from t1;
(2)select max(col1) from t1;
(3)select concat(‘max’=,max(col1)) from t1;
A.（1）可能，（2)(3)不可能
B.（2）可能，（1)(3)不可能
C.（3）可能，（2)(1)不可能
D.（1）不可能，（2)(3)可能

count(*)一定可以返回数值，如果t1中没有数据，返回0
max返回null的两种情况：1.t1中没有数据 2.col1字段值全都为null
concat为字符串拼接的函数，上面我们分析得到max(col1)的结果可能为null，字符串拼接的规则是，当两个字符串中有其中一个为null，最后结果为null

（2）下面哪一句从表TABLE_NAME中提取前10条记录（B）
A.select * from TABLE_NAME where rowcount=10
B.select TOP 10 * from TABLE_NAME
C…select TOP of 10 * from TABLE_NAME
D.select * from TABLE_NAME where rowcount<10

top是SQL Server中的关键字，用于求前n条数据
语法：select top n from 表名

（3）电话号码表t_phonebook中含有100万条数据，其中号码字段PhoneNo上创建了唯一索引，且电话号码全部由数字组成，要统计号码头为321的电话号码的数量，下面写法执行速度最慢的是（C）
A.select count( * ) from t_phonebook where phoneno>=‘321’ and phoneno<‘321A’
B.select count( * ) from t_phonebook where phoneno like ‘321%’
C.select count( * ) from t_phonebook where substr(phoneno ,1,3)=‘321’
D.一样快

A、B选项都能触发索引，C选项使用了函数就不会触发索引了

（4）以下不是RDBMS的是（D）
A.mysql
B.postgreSql
C.oracle
D.hadoop

RDBMS表示关系型数据库

二、编程题

2.1 统计每个月兔子的总数

2.1.1 题目

2.1.2 题解

思路：通过列举前几个月，每月兔子的数目，发现规律，某月兔子的总数为前两个月兔子总数之和，和斐波纳切数列的规律是一样的

代码：

public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int first=1;
    int second=1;
    for(int i=3;i<=n;i++){
       int sum=first+second;
       first=second;
       second=sum;
    }
    
    System.out.println(second);
}

2.2 字符串通配符(动态规划)

2.2.1 题目

2.2.2 题解

解法一：递归

思路：从前向后一次匹配，遇到相同字符，都向后移动一个字符，如果通配符遇到“?”，则不需匹配，自动跳过一个字符，如果通配符遇到"*"，则可以匹配任意多个字符，包括0个，此时可以有三种选择，
1，匹配0个，通配符向后移动一个字符，字符串不动。
2，匹配1个，通配符和字符串都向后移动一个字符。
3，匹配多个，通配符不动，字符串向后移动一个字符。
递归的终止条件：通配符或者字符串遇到’\0’。当他们同时结束。
代码：

    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        String str1=scanner.nextLine();
        String str2=scanner.nextLine();
        str1=str1.toLowerCase();
        str2=str2.toLowerCase();
        char[] s1=str1.toCharArray();
        char[] s2=str2.toCharArray();
       boolean ret= process(s1,s2,0,0);
       System.out.println(ret);
    }
    public static boolean process(char[] s1,char[] s2,int i,int j){
         if(i==s1.length && j==s2.length) return true;
         if(i==s1.length || j==s2.length) return false;
         if(s1[i]==s2[j]){
             return process(s1,s2,i+1,j+1);
         }else if(s1[i]=='?' && check(s2[j])){
             return process(s1,s2,i+1,j+1);
         }else if(s1[i]=='*' && check(s2[j])){
             return process(s1,s2,i,j+1) ||
             process(s1,s2,i+1,j) ||
             process(s1,s2,i+1,j+1);
         }
        return false;
    }
    public static boolean check(char c){
        if((c>='0' && c<='9') ||
         (c>='a' && c<='z')||
         (c>='A' && c<='Z')){
             return true;
         }
      return false;
    }

解法二：动态规划

思路：根据递归将代码思路实现动态规划，dp[i][j]的含义是通配符字符串s1的前i个字符是否和字符串s2的前j个字符匹配。
对于一些边界情况我们可以通过遍历字符串后先填好：
dp[0][0] 为true
dp[i][0] 需要分情况讨论，因为只有*能匹配空字符，所以只有s1的前i个字符均为 * 时，dp[i][0]才为true

转移方程：对于dp[i][j]来说，需要分情况讨论

（1）如果s1[i-1]和s2[j-1]都为普通字符，那么只有s1[i-1]==s2[j-1]，二者才能继续向后匹配,此时dp[i][j]的结果依赖于dp[i-1][j-1]
dp[i][j]=dp[i-1][j-1];
（2）如果s1[i-1]为’?‘，那么对于s2[j-1]来说么有要求,此时dp[i][j]的结果依赖于dp[i-1][j-1]
dp[i][j]=dp[i-1][j-1];
（3）如果 s1[i-1]为’* '，那么对于s2[j-1]来说也没有要求，同时*可以匹配0或任意个字母或数字字符
dp[i][j]= dp[i][j-1] || dp[i-1][j] || dp[i-1][j-1];

代码：

   public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        String str1=scanner.nextLine();
        String str2=scanner.nextLine();
        str1=str1.toLowerCase();
        str2=str2.toLowerCase();
        char[] s1=str1.toCharArray();
        char[] s2=str2.toCharArray();
        int n=s1.length;
        int m=s2.length;
        boolean[][] dp=new boolean[n+1][m+1];
        dp[0][0]=true;
        for(int i=1;i<=n;i++){
            if (s1[i-1] == '*') {
                dp[i][0] = true;
            } else {
                break;
            }
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(s1[i-1]==s2[j-1]){
                    dp[i][j]=dp[i-1][j-1];
                }
                if(s1[i-1]=='?' && check(s2[j-1])){
                    dp[i][j]=dp[i-1][j-1];
                }else if(s1[i-1]=='*' && check(s2[j-1])){
                    dp[i][j]= dp[i][j-1] || dp[i-1][j] || dp[i-1][j-1];
                }
            }
        }
        System.out.println(dp[n][m]);
    }
    public static boolean check(char c){
        if((c>='0' && c<='9') ||
                (c>='a' && c<='z')||
                (c>='A' && c<='Z')){
            return true;
        }
        return false;
    }