Java经典笔试题—day13

哔卟哔卟_: )

于 2023-05-25 18:25:44 发布

阅读量1.1k

点赞数 9

分类专栏： Java经典笔试题文章标签： java 数据库开发语言

本文链接：https://blog.csdn.net/m0_74365243/article/details/130773540

版权

Java经典笔试题专栏收录该内容

14 篇文章 0 订阅

订阅专栏

Java经典笔试题—day13

🔎选择题
🔎编程题
- 🍭参数解析
- 🍭跳石板
🔎结尾

🔎选择题

(1)一个关系数据库文件中的各条记录（）

A. 前后顺序不能任意颠倒，一定要按照输入的顺序排列
B. 前后顺序可以任意颠倒，不影响库中的数据关系
C. 前后顺序可以任意颠倒，但排列顺序不同，统计处理的结果就可能不同
D. 前后顺序不能任意颠倒，一定要按照关键字字段值的顺序排列

B

关系数据库的逻辑性强而物理性弱
物理性表示数据存储在硬盘上的顺序
关系型数据库依赖的是逻辑性, 意味着对于存储在硬盘上的数据, 只要不影响查询结果即可(前后顺序可以颠倒)

(2)一名员工可以使用多台计算机，每台计算机只能由一名员工使用，则实体员工和计算机间的联系是 ( )

A. 一对多
B. 多对多
C. 多对一
D. 一对一

A

一名员工可以使用多台计算机(1 : n)
每台计算机只能由一名员工使用(1 : 1)
实体员工与计算机之间的关系(1 : n)

(3)下列关于视图的说法错误的是：

A. 视图是从一个或多个基本表导出的表，它是虚表
B. 视图一经定义就可以和基本表一样被查询、删除和更新
C. 某一用户可以定义若干个视图
D. 视图可以用来定义新的视图

B

视图是指计算机数据库中的视图, 是一个虚拟表
视图同真实的表一样, 包含一系列带有名称的列和行, 行和列数据用于自定义视图的查询, 删除
视图一经定义无法更新(修改)
用户可以定义若干视图
视图可以用来定义新的视图
定义视图 name1 (create view name1 as select …)
利用视图 name1 定义新的视图 newName (create view newName as select … from name1)

(4)在 SQL Server 中，订单表 ( 订单号，雇员代号，地区代号，订购日期 ) 中订单号为主键，要删除订单中前三年以前的信息， SQL 为：

A. delete from 订单表 where 订购日期<getdate()+3
B. delete from 订单表 where 订购日期<DATEADD(yy,3,getdate())
C. delete from 订单表 where 订购日期<getdate()-3
D. delete from 订单表 where 订购日期<DATEADD(yy,-3,getdate())

D

DATEADD() 表示函数在日期中添加或减去指定的时间间隔
DATEADD(datepart, number, date)
datapart 参数的取值范围是 {yy/yyyy, mm/m, dd/d}
number 要添加的间隔数
date 合法的日期表达式

GETDATE() 表示返回当前的时间和日期

排除A, C, 返回当前的日期 + / - 3, 无法判断当前日期 + / - 3年还是3月还是3天
B. 利用 getdate() 返回当前的日期和时间, yy 表示年, 因此表示函数在日期中添加3年, 题目要求是3年之前

(5)负责数据库中查询操作的数据库语言是（）

A. 数据定义语言
B. 数据管理语言
C. 数据操纵语言
D. 数据控制语言

C

A. 数据定义语言(DDL), 用于创建数据库中的各种对象: 表, 视图, 索引, 同义词…
C. 数据操纵语言(DML), 主要负责数据的基本操作(增加, 删除, 修改, 查询…)
D. 数据控制语言(DCL), 用于授权或回收访问数据库的某种特权, 并控制数据库操纵事务发生的时间及效果, 对数据库实行监视等

(6)数据库管理系统是（）

A. 操作系统的一部分
B. 在操作系统支持下的系统软件
C. 一种编译系统
D. 一种操作系统

B

数据库属于系统软件

(7)SQL 语句中修改表结构的命令是（）

A. MODIFY TABLE
B. MODIFY STRUCTURE
C. ALTER TABLE
D. ALTER STRUCTURE

C

修改表结构的关键字是 ALTER TABLE

例如
添加表字段 alter table 表名称 add 字段名称字段类型
删除表字段 alter table 表名称 drop 字段名称
修改表字段 alter table 表名称 change 旧字段名称新字段名称字段类型
修改表字段 alter table 表名称 modify 字段名称字段类型

(8)在sql数据库中，哪个语句能校验整数列 i 的值不小于 1 不大于 10 ？

A. i BETWEEN 1 AND 10
B. i BETWEEN 0 AND 11
C. i IN INTERVAL(0,11)
D. i IN INTERVAL(1,10)

A

B. [0, 11]
C, D. INTERVAL() 表示比较函数
例如 INTERVAL(4, 0, 1, 2, 3 ,4 ,5 ,6) , 以第一个数字 4 作为被比较数, 后面的0, 1, 2, 3, 4, 5, 6 作为比较数, 分别与第一个数字4进行比较, 返回小于等于4的个数

(9)在学生表 Student 的系别 (Sdept) 属性中查询信息系 (IS) 、数学系 (MA) 和计算机系 (CS) 的学生姓名 (Sname) 和性别 (Ssex) ，正确的命名格式应为：

A. SELECT Student FROM Sname, Ssex WHERE Sdept IN (‘IS’, ’MA’, ‘CS’)
B. SELECT Sname, Ssex FROM Student WHERE Sdept IN (‘IS’, ’MA’, ‘CS’)
C. SELECT Sname, Ssex FROM Student WHERE Sdept (IS, MA, CS)
D. SELECT Sname, Ssex FROM Student WHERE Sdept LIKE IS, MA, CS

B

查询学生表(Stundent)中的学生姓名(Sname), 性别(Ssex) SELECT Sname, Ssex FROM Student
条件是系别(Sdept)来自信息系(IS), 数学系(MA), 计算机系(CS) WHERE Sdept IN ('IS', 'MA', 'CS')
组合在一起 SELECT Sname, Ssex FROM Student WHERE Sdept IN ('IS', 'MA', 'CS')

(10)SQL 查询语句中 WHERE 、 GROUP BY 、 HAVING 这些关键字区别和用法总结错误的是（）

A. HAVING在查询语句中必须依赖于GROUP BY
B. WHERE子句用来限制SELECT语句从表中指定选取的行
C. GROUP BY子句用来分组WHERE子句的输出结果集
D. HAVING子句用来从分组的结果中筛选列

D

条件: WHERE, HAVING
WHERE 在分组之前使用, HAVING 在分组之后使用
分组: GROUP BY
A. HAVING 在分组之后才能使用, 因此 HAVING 依赖于 GROUP BY 进行分组
B. WHERE 条件筛选的是行
C. GROUP BY 用于分组
D. HAVING 条件筛选的是行

🔎编程题

🍭参数解析

题目描述

在命令行输入如下命令：

xcopy /s c:\ d:\e，

各个参数如下：

参数1：命令字xcopy

参数2：字符串/s

参数3：字符串c:\

参数4: 字符串d:\e

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

解析规则：

1.参数分隔符为空格

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

3.参数不定长

4.输入由用例保证，不会出现不符合要求的输入

数据范围：
字符串长度：1≤s≤1000
进阶：时间复杂度：O(n) ，空间复杂度：O(n)

输入描述

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

输出描述

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

在这里插入图片描述

解题思路

根据题意进行简单模拟即可

注意
对于用""包含起来的参数，如果中间有空格，不能解析为多个参数

list.add(s.substring(begin + 1,i - 1)) 处理 “” 包裹的内容(例如 “ab” )
list.add(s.substring(begin,i)) 处理未被 “” 包裹的内容(例如 ab )

//参数解析
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);
        String s = scan.nextLine();

        print(s);
    }
    private static void print(String s) {
        int n = s.length();
        // flg 判断是否处在 "" 中
        int flg = 1;
        // begin 截取字符串的起始位置
        int begin = 0;
        List<String> list = new ArrayList<>();

        char[] chs = s.toCharArray();
        for (int i = 0; i < n; i++) {
            if(chs[i] == '"') {
                flg = ~flg + 1;
            }
            if(chs[i] == ' ' && flg == 1) {
                if(chs[i - 1] == '"') {
                    list.add(s.substring(begin + 1,i - 1));
                } else {
                    list.add(s.substring(begin,i));
                }
                begin = i + 1;
            }
        }

        if(chs[n - 1] == '"') {
            list.add(s.substring(begin + 1,n - 1));
        } else {
            list.add(s.substring(begin,n));
        }

        System.out.println(list.size());

        for (String str : list) {
            System.out.println(str);
        }
    }
}

📢题目链接
链接:link

🍭跳石板

题目描述

小易来到了一条石板路前，每块石板上从1挨着编号为：1、2、3…
这条石板路要根据特殊的规则才能前进：对于小易当前所在的编号为K的石板，小易单次只能往前跳K的一个约数(不含1和K)步，即跳到K+X(X为K的一个非1和本身的约数)的位置。小易当前处在编号为N的石板，他想跳到编号恰好为M的石板去，小易想知道最少需要跳跃几次可以到达。

例如：
N = 4，M = 24：
4->6->8->12->18->24
于是小易最少需要跳跃5次，就可以从4号石板跳到24号石板

输入描述

输入为一行，有两个整数N，M，以空格隔开。 (4 ≤ N ≤ 100000) (N ≤ M ≤ 100000)

输出描述

输出小易最少需要跳跃的步数,如果不能到达输出-1

在这里插入图片描述

解题思路

定义整型数组 int[] steps, 下标表示石板的编号, 对应的值表示到达第 i 块石板的最小步数
从第 n 块石板跳跃到第 n 块石板所需的步数为0, steps[n] = 0
将 steps[] 的其他位置初始化为 Integer.MAX_VALUE, 值为 Integer.MAX_VALUE 表示无法到达该石板
从第 i(i = n) 块石板出发, 根据题意计算出当前石板的约数
- j 表示当前石板的约数
- 判断第 i + j 块石板是否为 Integer.MAX_VALUE
  - 如果是, 在前一块的石板的步数上 + 1, 表示从前一块石板跳跃到当前石板的步数为1步
  - 如果不是, 表示第 i + j 块石板可以被其他的 i + j 组合到达, 比较 steps[i + j] 与 steps[i] + 1的值即可

//跳石板
import java.util.List;
import java.util.Scanner;
import java.util.ArrayList;
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int m = scan.nextInt();

        calc(n, m);
    }

    private static void calc(int n,int m) {
        // 定义石板(下标表示石板编号, 值表示到达第 i 块石板的最小步数)
        int[] steps = new int[m + 1];
        // 初始化
        for(int i = 0; i < m + 1; i++) steps[i] = Integer.MAX_VALUE;
        // 定义第 n 块石板值为0(到达第 n 块石板的最小步数为0 --> 初始就站在第 n 块石板)
        steps[n] = 0;
        // 从第 n 块石板开始跳跃
        for(int i = n; i < m; i++) {
            // Integer.MAX_VALUE 表示无法跳跃到该位置
            if(steps[i] == Integer.MAX_VALUE) continue;

            List<Integer> temp = getPrime(i);
            // i --> 当前石板的编号
            // j --> 一次可以跳多少块石板
            for(int j : temp) {
                if(i + j <= m && steps[i + j] != Integer.MAX_VALUE) {
                    steps[i + j] = Math.min(steps[i] + 1, steps[i + j]);
                } else if(i + j <= m) {
                    steps[i + j] = steps[i] + 1;
                }
            }
        }
        System.out.println(steps[m] == Integer.MAX_VALUE ? -1 : steps[m]);
    }
    // 求约数
    private static List<Integer> getPrime(int num) {
        List<Integer> temp = new ArrayList<>();
        // num = 24
        // num % 4 == 0 temp.add(4)
        // num / 4 = 6 6 != 4 temp.add(6)
        // num = 9
        // num % 3 == 0 temp.add(3)
        // num / 3 = 3 3 == 3
        for(int i = 2; i * i <= num; i++) {
            if(num % i == 0) {
                temp.add(i);
                if(num / i != i) temp.add(num / i);
            }
        }
        return temp;
    }
}