48天笔试训练错题——day13

目录

选择题

1.

2.

3.

4.

5.

6.

7.

8.

编程题

1. 参数解析

2. 跳石板

---

选择题

1.

关系型数据库中存储的数据，我们只是依赖它们的逻辑性，关系是一定的，查询出来的结果就是确定的，记录前后顺序的颠倒不影响它们之间的关系。

2.

视图是指计算机数据库中的视图，是一个虚拟表，其内容由查询定义。

            test
create view 视图名字 as select....  -- 可以通过查表来定义视图
 
-- 可以由视图来定义新的视图
create view test2 as select .... from test

视图和真实的表类似，视图包含一系列带有名称的行和列数据。

但是，视图并不在数据库中以存储的数据值集形式存在。

行和列数据来自由定义视图查询所引用的表，并且在引用视图时动态生成。

视图一经定义就无法修改。视图的使用跟普通表差不多。

3.

4.

5.

有关字段的操作使用的都是 alter table

6.

between and 是闭区间。

7.

in () 表示在 xxx 范围里查询。

8.

where 是分组前的条件过滤，group by 是分组，having 是分组后的过滤，过滤都是针对行来进行的。

编程题

1. 参数解析

这题也不难，说了参数间隔是空格，被 "" 引用的内容中的空格不算，所以可以遍历这个字符串，先判断是否为 " ,如果是引号，就计数器++，然后 i 一直往后走直到遇到下一个引号，然后跳过引号和空格，如果不是引号，说明是正常的参数，那么就 i 一直往后走直到遇到空格，说明又是一个参数，count++，i++ 跳过空格，打印的时候也是按照上面思路来。

代码实现：

import java.util.Scanner;
 
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String str = in.nextLine();
            print(str);
        }
    }
 
    public static void print(String str) {
        int i = 0;
        int len = str.length();
        // count 是用来记录参数个数的
        int count = 0;
        while (i < len) {
            if (str.charAt(i) == '"') {
                count++;
                // 此时说明遇到了一个被""括起来的命令
                i++;// 跳过 "
                while (i < len && str.charAt(i) != '"') {
                    i++;
                }
                i += 2; // 跳过"
            } else {
                while (i < len && str.charAt(i) != ' ') {
                    i++;
                }
                count++;
                i++;// 跳过空格
            }
        }
 
 
        System.out.println(count);
        i = 0;
        while (i < len) {
            if (str.charAt(i) == '"') {
                // 此时说明遇到了一个被""括起来的命令
                i++;// 跳过 "
                while (i < len && str.charAt(i) != '"') {
                    System.out.print(str.charAt(i));
                    i++;
                }
                i += 2; // 跳过"
                System.out.println();
            } else {
                while (i < len && str.charAt(i) != ' ') {
                    System.out.print(str.charAt(i));
                    i++;
                }
                i++;// 跳过空格
                System.out.println();
            }
        }
    }
}

2. 跳石板

可以用动态规划来解。

根据上图，就可以写代码了。

代码实现：

import java.util.*;
 
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int n = in.nextInt();
            int m = in.nextInt();
            int count = getCount(n, m);
            if (count == Integer.MAX_VALUE) {
                // 说明到达不了 m
                System.out.println(-1);
            } else {
                System.out.println(count);
            }
        }
    }
 
 
    public static int getCount(int n, int m) {
        int[] dp = new int[m + 1];
        // 将dp的每个元素初始化为最大值
        for (int i = 0; i < dp.length; i++) {
            dp[i] = Integer.MAX_VALUE;
        }
        // 初始化
        dp[n] = 0;
        for (int k = n; k <= m; k++) {
            if (dp[k] == Integer.MAX_VALUE) {
                // 说明这里是到达不了的地方
                continue;
            }
            // 获取 k 的约数
            List<Integer> list = div(k);
            // 遍历约数
            for (int x : list) {
                // 首先判断是否是已经存在值了
                if (k + x <= m && dp[k + x] != Integer.MAX_VALUE) {
                    dp[k + x] = Math.min(dp[k + x], dp[k] + 1);
                } else if (k + x <= m) {
                    dp[k + x] = dp[k] + 1;
                }
            }
        }
        return dp[m];
    }
 
    // 获取约数
    public static List<Integer> div(int n) {
        List<Integer> ret = new ArrayList<>();
        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (n % i == 0) {
                ret.add(i);
                if (n / i != i) {
                    ret.add(n / i);
                }
            }
        }
 
        return ret;
    }
}