笔试强训day31

最新推荐文章于 2023-09-27 08:56:20 发布

@～007

最新推荐文章于 2023-09-27 08:56:20 发布

阅读量924

点赞数

分类专栏：笔试强训文章标签： java

本文链接：https://blog.csdn.net/weixin_58030464/article/details/124788383

版权

笔试强训专栏收录该内容

40 篇文章 9 订阅

订阅专栏

一、选择题

1、在单处理器系统中，如果同时存在有12个进程，则处于就绪队列中的进程数量最多为（）
A 1
B 9
C 10
D 11
他的回答： D (正确)
正确答案：D
2、以下关于多线程的叙述错误的是：
A 线程同步的方法包括使用临界区，互斥量，信号量等
B 两个线程同时对简单类型全局变量进行写操作也需要互斥
C 实现可重入函数时，对自动变量也要用互斥量加以保护
D 可重入函数不可以调用不可重入函数
他的回答： D (错误)
正确答案： C
目前实现线程同步的方法有很多，其中包括临界区、互斥量、事件、信号量四种方式。
临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。(临界区可以认为是操作共享资源的一段代码)
互斥量:为协调共同对一个共享资源的单独访问而设计的信号量:为控制一个具有有限数量用户资源而设计。
事件:用来通知线程有一些事件已发生，从而启动后继任务的开始

可重入函数:
主要用于多任务环境中，一个可重入的函数简单来说就是可以被中断的数，也就是说，可以在这个函数执行的任何时刻中断它，转入os调度下去执行另外一段代码，而返回捧制时不会出现什么错误:

不可重入的函数:
由于使用了一些系统资源，比如全局变量区，中断向量表等，所以它如果被中断的话，可能会出现问题，这类函数是不能运行在多任务环境下的。
自动变量:
局部作用域变量，定义的时候才被创建，承数返回时，系统回收空间:属干线程私有的
3、系统死锁的可能的原因是
A 进程死循环
B 资源循环等待
C 程序内存访问越界
D 进程释放资源
他的回答： A (错误)
正确答案： B
4、整数0x12345678，在采用bigendian中内存的排序序列是（）
A 12 34 56 78
B 78 56 34 12
C 87 65 43 21
D 21 43 65 87
他的回答： A (正确)
正确答案： A
大端模式，是指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理:地址由小向大增加，数据从高位往低位放;这和我们的阅读习惯一致。题目中的0x12345678，以大端模式保存，就是:低位地址0x12 0x34 0x56 0x78高位地址.

小端模式，是指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低。题目中的 0x12345678，以小端模式保存，就是:低位地址0x78 0x56 0x34 0x12 高位地址
5、使用C语言将一个1G字节的字符数组从头到尾全部设置为字’A’，在一台典型的当代PC上，需要花费的CPU时间的数量级最接近（）
A 0.001秒
B 1秒
C 100秒
D 2小时
他的回答： B (正确)
正确答案： B
单位之间的换算规则是:
1GB =1024MB
1MB=1024KB
1KB=1024B
1B =8bits
所以1GB=1073741824B
执行1条语句约1ns即1/100000秒(10-9)，每次赋值都要执行一次语句，所以对于1G来说大约是1秒
6、对于普通的计算机，对以下事件的平均耗时从小到大排序为____：
A.读取1KB内存数据 B.从硬盘连续读取1KB数据 C.读取一次L2缓存 D.一次磁盘寻道
A C,A,D,B
B C,D,A,B
C D,C,A,B
D D,A,C,B
他的回答： A (正确)
正确答案： A
缓存是1eve12缓存是二级缓存的意思，通过缓存直接与cpu进行数据交互，这个是最快最直接的。

第二个内存读取时间，当通过缓存寻找数据时发现数据在缓存中不存在这时需要通过，到内存中去寻找，但是内存的传输速度就没有缓存这么快了，所以，内存读取数据的时间消耗要大于缓存。

第三个从硬盘连续读取1kb，这个意思就是读取硬盘数据，其中读取硬盘数据的时间消耗主要由是寻道时间，数据传输时间，还有旋转时间三部分时间组成，所以其中的磁盘寻道时间肯定小于总的连续读取时间。
7、分页式虚拟存储管理系统中，页面的大小与可能产生的缺页中断次数（）
A 成正比
B 成反比
C 无关
D 成固定值
他的回答： B (错误)
正确答案： C
分页式虚拟存储系统:
将作业信息的副本存放在磁盘这一类辅助存储器中，当作业被调度投入运行时，并不把作业的程序和数据全部装入主存，而仅仅装入立即使用的那些页面，至少要将作业的第一页信息装入主存，在执行过程中访问到不在主存的页面时，再把它们动态地装入。

用得较多的分页式虚拟存储管理是请页式(demand Paging)，当需要执行某条指令或使用某个数据，而发现它们并不在主存时，产生一个缺页中断，系统从辅存中把该指令或数据所在的页面调入内存。

进入内存的页面内容是没有变化的。所以分页式虚拟存储管理系统中，页面的大小与可能产生的缺页中断次数关系不大。 wertAERQW123
8、关于子进程和父进程的说法，下面哪一个是正确的？（）
A 一个父进程可以创建若干个子进程，一个子进程可以从属于若干个父进程
B 父进程被撤销时，其所有子进程也被相应撤消
C 子进程被撤销时，其从属的父进程也被撤销
D 一个进程可以没有父进程或子进程
他的回答： A (错误)
正确答案： D
A:一个父进程可以创建多个子进程，但一个子进程只从属于1个父进程
B:如果父进程先退出，子进程还没退出，那么子进程将被托孤给init进程，并由init进程对它们完成状态收集工作。这时子进程的父进程就是init进程(1号进程)。init进程没有父进程。 C，子进程退出，父进程还可以继续执行
D:init进程没有父进程;一个进程，可以不创建子进程
9、关于线程和进程，下面说法正确的是（）
A 终止一个进程比终止一个线程花费的时间少
B 进程切换比同一进程内部的线程切换花费的时间少
C 线程提高了不同执行程序间的通信效率
D 进程和线程都是资源分配和调度的基本单位
他的回答： D (错误)
正确答案： C
进程的创建，切换，终止，耗时/消耗的资源，都比线程要高
10、进程调度时，下列进程状态的变化过程哪一项是不可能发生的？（）
A 阻塞挂起->阻塞
B 就绪挂起->就绪
C 就绪挂起->阻塞挂起
D 阻塞挂起->就绪挂起
他的回答： C (正确)
正确答案：C
在这里插入图片描述

二、编程题

【美国节日】
和中国的节日不同，美国的节假日通常是选择某个月的第几个星期几这种形式，因此每一年的放假日期都不相同。具体规则如下：

1月1日：元旦
1月的第三个星期一：马丁·路德·金纪念日
2月的第三个星期一：总统节
5月的最后一个星期一：阵亡将士纪念日
7月4日：美国国庆
9月的第一个星期一：劳动节
11月的第四个星期四：感恩节
12月25日：圣诞节
现在给出一个年份，请你帮忙生成当年节日的日期。
输入描述：
输入包含多组数据，每组数据包含一个正整数year（2000≤year≤9999）。
输出描述：
对应每一组数据，以“YYYY-MM-DD”格式输出当年所有的节日日期，每个日期占一行。
每组数据之后输出一个空行作为分隔。
示例1：
输入
2014\n2013
输出
2014-01-01\n2014-01-20\n2014-02-17\n2014-05-26\n2014-07-04\n2014-09-01\n2014-11-27\n2014-12-25\n\n2013-01-01\n2013-01-21\n201
3-02-18\n2013-05-27\n2013-07-04\n2013-09-02\n2013-11-28\n2013-12-25
牛客网ACM模式代码

import java.util.*;
public class Main {
    private static boolean isLeapYear(int y) {
        return (y % 400 == 0) || (y % 4 == 0 && y % 100 != 0);
    }
    private static final int[] DAYS = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
// 给定 y,m,d，返回这年过了多少天了
    private static int nDays(int y, int m, int d) {
// m: 12
// [0, 10]
        int n = d;
        for (int i = 0; i < m - 1; i++) {
            n += DAYS[i];
        }
        if (m > 2 && isLeapYear(y)) {
            n++;
        }
    return n;
    }
// 传入 y,m,d，找到从公元前 1 年12月31日开始过了多久了。求出它的 MOD 7 的同余数
    private static int diff(int y, int m, int d) {
        return (y - 1) + (y - 1) / 4 - (y - 1) / 100 + (y - 1) / 400 + nDays(y, m, d);
    }
// 根据 y,m,d 求出星期几
    private static int week(int y, int m, int d) {
        int w = diff(y, m, d) % 7;
        if (w == 0) {
            w = 7;
        }
    return w;
    }
// 根据 1 日星期 w，求第 n 个星期 e 是几号
    private static int m1(int w, int n, int e) {
        return 1 + (n - 1) * 7 + (7 - w + e) % 7;
    }
// 根据 6月1日星期 w，求5月的最后一个星期一
    private static int m2(int w) {
        int d = (w == 1 ? 7 : w - 1);
        return 32 - d;
    }
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        while (s.hasNextInt()) {
            int y = s.nextInt();
            System.out.printf("%d-01-01\n", y);
            int w;
            w = week(y, 1, 1);
            System.out.printf("%d-01-%02d\n", y, m1(w, 3, 1));
            w = week(y, 2, 1);
            System.out.printf("%d-02-%02d\n", y, m1(w, 3, 1));
            w = week(y, 6, 1);
            System.out.printf("%d-05-%02d\n", y, m2(w));
            System.out.printf("%d-07-04\n", y);
            w = week(y, 9, 1);
            System.out.printf("%d-09-%02d\n", y, m1(w, 1, 1));
            w = week(y, 11, 1);
            System.out.printf("%d-11-%02d\n", y, m1(w, 4, 4));
            System.out.printf("%d-12-25\n", y);
            System.out.println();
        }
    }
}

【分解因数】
所谓因子分解，就是把给定的正整数a，分解成若干个素数的乘积，即 a = a1 × a2 × a3 × … × an,并且 1 < a1 ≤ a2 ≤ a3 ≤ … ≤ an。其中a1、a2、…、an均为素数。先给出一个整数a，请输出分解后的因子。
输入描述：
输入包含多组数据，每组数据包含一个正整数a（2≤a≤1000000）。
输出描述：
对应每组数据，以“a = a1 * a2 * a3…”的形式输出因式分解后的结果。

示例1：
输入
10
18
输出
10 = 2 * 5
18 = 2 * 3 * 3

【解题思路】：
看到短除法后，我们很清楚的知道，要想求出它的每一个质因数，我们需要用质数去试除。90能被2整除，那就拿商继续除以2，除不尽就换3，一直到除到质数为止。基础代码框架类似判断质数，只是被判断的数字在过程中不断
被除，最终循环结束的时候，那个被处理过的数字，就是最后一个质因数。
牛客网ACM模式代码

import java.util.*;
public class Main {
    private static List<String> factorization(int a) {
        List<String> ans = new ArrayList<>();
        for (int i = 2; a > 1 && i * i <= a; i++) {
            while (a % i == 0) {
                ans.add(String.valueOf(i));
                a = a / i;
            }
        }
        if (a > 1) {
            ans.add(String.valueOf(a));
        }
    return ans;
    }
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        while (s.hasNextInt()) {
            int a = s.nextInt();
            List<String> factors = factorization(a);
            System.out.printf("%d = %s\n", a, String.join(" * ", factors));
        }
    }
}