笔试强训(三十二)

一、选择题

（1）处于运行状态的操作系统程序应放在(B)
A.寄存器
B.主存
C.辅存

处于运行状态的操作系统程序也就是进程，进程需要放在内存中执行
寄存器存在CPU中，容量有限，只是加载CPU执行代码行需要的数据（从主存加载到寄存器）
处于挂起状态的进程，会放到辅存中

（2）在系统中设置磁盘缓冲区的主要目的是（A）
A.减少磁盘IO次数
B.减少平均寻道时间
C.提高磁盘数据可靠性
D.实现设备无关性

CPU执行速度远高于磁盘IO的速度
为了提高速率，经常访问磁盘的数据，可以放到磁盘缓存中，提高IO速度
B选项，寻道时间是固定的，可以说是减少了寻道的次数

（3）下列选项中，会导致进程从 执行态变为就绪态的事件是（D）
A.执行P(wait)操作
B.申请内存失败
C.启动IO设备
D. 被高优先级进程抢占

A.如果当前信号量大于0，执行P操作后进程还是能够继续执行的
B. 申请内存失败，操作系统内核会以一个错误消息通知进程，由进程自己决定如何处理，一般进程会报错
C.启动IO设备，进入阻塞状态
D.被高优先级抢占，导致当前进程还没使用完时间片，就退出了，进入就绪态

（4）进程和程序的一个本质区别是什么（A）
A.前者是动态的，后者是静态的
B.前者存储在内存，后者存储在外存
C.前者在一个文件中，后者在多个文件中
D.前者分时使用CPU，后者独占CPU

B 被挂起的进程会放到外存中

（5）选择在最近的过去很久未访问的页面予以淘汰的算法称为（B）
A.OPT
B.LRU
C.MFU
D.LFU

OTP：最佳页面置换算法，预测哪个页面最晚出现，就替换哪个页面
LRU：最近最少使用页面置换算法，首先淘汰最长时间未被使用的页面
MFU：最常使用算法，替换最常使用的页面
LFU：最近最不常用页面置换算法，淘汰一定时期内被访问次数最少的页面

（6）并发进程之间（D）
A.彼此无关
B.必须同步
C.必须互斥
D.可能同步可能互斥

互斥：是指散步在不同任务之间的若干程序片段，当某个任务运行其中一个程序片段时，其他任务就不能运行他们之中的任一程序片段，只能等到该任务运行完这个程序片段后才可以运行。最基本的场景就是：一个公共资源同一时刻只能被一个进程或线程使用，多个进程或线程不能同时使用公共资源
同步：是指散步在不同任务之间的若干程序片段，他们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。最基本的场景就是：两个或两个以上的进程或线程在运行过程中协同步调，按预定的先后次序运行。比如A任务的运行依赖于B任务产生的数据
显然，同步是一种更为复杂的互斥，而互斥是一种特殊的同步

（7）一次I/O操作的结束，有可能导致（A）
A.一个进程由睡眠变就绪
B.几个进程由睡眠变就绪
C.一个进程由睡眠变运行
D.几个进程由睡眠变运行

进行I/O操作的进程进入阻塞态，I/O操作结束后变成就绪态，等到操作系统的调度

二、编程题

2.1 淘宝网店

2.1.1 题目

2.1.2 题解

思路：

代码：

import java.util.*;
public class Main{
  //判断是否时闰年
  public static boolean isLeapYear(int year){
    return (year%400==0) || (year % 4==0 && year % 100!=0 );
  }
  //判断当前月是否时素数
  public static boolean isPrime(int month){
    return month==2 || month==3 || month ==5 || month ==7||month ==11;
  }
  //计算year年的整年收益
  public static int profitOfYear(int year){
    return 2*31+
            + 1 * 28
            + 1 * 31
            + 2 * 30
            + 1 * 31
            + 2 * 30
            + 1 * 31
            + 2 * 31
            + 2 * 30
            + 2 * 31
            + 1 * 30
            + 2 * 31
      + (isLeapYear(year) ? 1 : 0);
  }
  //计算year年从1月1日到month月day日的收益
  public static int profitOfThisYear(int year,int month,int day){
    int profit=0;
    if(isPrime(month)){
      profit=day;
    }else {
      profit=2*day;
    }
    
    while(--month>0){
      switch(month){
          case 1:case 8: case 10 :case 12:
          profit+=62;
          break;
          case 3: case 5:case 7:
          profit+=31;
          break;
          case 4:case 6: case 9:
          profit+=60;
          break;
          case 11:
          profit+=30;
          break;
          default :
          profit+=(28+(isLeapYear(year)?1:0));
          break;
      }
    }
    return profit;
  }
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    int year1,month1,day1,year2,month2,day2;
    
    while(scanner.hasNextInt()){
      int profit=0;
      year1=scanner.nextInt();
      month1=scanner.nextInt();
      day1=scanner.nextInt();
      year2=scanner.nextInt();
      month2=scanner.nextInt();
      day2=scanner.nextInt();
      profit+=profitOfYear(year1)-profitOfThisYear(year1,month1,day1-1);
      profit+=profitOfThisYear(year2,month2,day2);
      if(year1==year2){//特殊情况，year1和year2相等，上面两行代码多计算了1年收益，
        profit-=profitOfYear(year1);
      }
      for(int i=year1+1;i<year2;i++){
        profit+=profitOfYear(i);
      }
      System.out.println(profit);
    }
  }
}

2.2 斐波那契凤尾

2.2.1 题目

2.2.2 题解

思路：先求斐波那契数列在100000以内的每一项的后六位，然后需要的时候直接输出数组里的对应值即可，题目输出的要求是，对于小于等于6位的斐波那契数直接输出本身，对于大于6位的斐波那契数，输出其后6位

代码：

import java.util.*;
public class Main{
  public static void main(String[] args){
    Scanner scanner =new Scanner(System.in);
    long[] arr=new long[100001];//使用long类型存储
    arr[1]=1;
    arr[2]=2;
    int boder=-1;//记录超过6位数的斐波那契额数是第几个
    for(int i=3;i<=100000;i++){
      long next=arr[i-1]+arr[i-2];
      if(boder==-1 && next>=1000000){
        boder=i;
      }
      arr[i]=next % 1000000;
    }
    while(scanner.hasNextInt()){
      int n=scanner.nextInt();
      if(n<boder){
        System.out.printf("%d\n",arr[n]);
      }else {
        System.out.printf("%06d\n",arr[n]);
      }
    }
  }
}