Day32

 分析：操纵系统页面淘汰算法:
(1)OPT(Optimal page replacement algorithm):最佳页面替换算法.该算法的核心事思想为从主存中移除永远不需要的页面
(2)LRU(Least Recently Used):最近最久未使用算法.该算法的核心思想为总是选择在最近一段时间内最久不用的页面予以淘汰
(3)MFU(Most Frequently Used):最常使用算法:每次替换掉最常使用的页面
(4)LFU(Least Frequently Used):最近最不常用算法:缺页时，置换访问次数最少的页面

 

这里应该考虑系统是单核还是多核，若是单核，并发只能互斥运行，若是多核，可以采用同步的方式运行。

 

操作系统的主要功能是资源管理， 程序控制和人机交互 等。
计算机系统的资源可分为设备资源和信息资源两大类。
设备资源指的是组成计算机的硬件设备，如**处理器（对应A），主存储器， 磁盘存储器（对应B），打印机，磁带存储器，显示器，键盘输入设备和鼠标等。信息资源指的是存放于计算机内的各种数据，如文件，程序库，知识库，系统软件和应用软件等。

 

从设备的共享属性上，分为两类：

1）独占设备，进程间互斥的访问这类设备，设备一旦被分配给某个进程，便由该进程独占。比如，打印机、磁带机。I/O操作后自然只有这个进程由等待进入就绪。

2）共享设备，一段时间内允许多个进程同时访问的设备。如磁带。多个进程进行读写时可以交叉进行。但注意此时在一个极小的时间内，I/O操作只对一个进程进行服务，对I/O设备的访问是并发，而不是并行。一次I/O操作的结束，只是其对应的进程I/O操作的结束，只会唤醒这一个进程。

---

进程状态有三个，等待（阻塞），就绪，运行。等待状态是等待时间的发生，比如输入的指令，如果i/o操作结束，则表示某个进程进行的可能的输入输出，这可能会是某一个进程的事件触发，从而导致该进程有等待转到就绪，然后等待cpu分配的时间片到来，如果时间片到来则进入运行态。

有睡眠不能直接进入运行，因为需要先转换到就绪状态。

 

 正在运行的是程序放在内存的，程序的数据和指令是预加载进寄存器的。

寄存器一般由于容量太小，相当于内存和cpu之间的桥梁，数据和指令都预先从内存中取出放至寄存器，随后cpu可以直接从寄存器中取指运行。

 为了缓和CPU和I/O设备速度不匹配的矛盾，提高CPU和I/O设备的 并行性，在现代操作系统中，几乎所有的I/O设备在与处理机交换数据时都用了缓冲区，并提供获得和释放缓冲区的手段。总结来说，缓冲区技术用到了缓冲区， 而缓冲区的引入是为了缓和CPU和I/O设备的不匹配，减少对CPU的中断频率，提高CPU和I/O设备的并行性。   

 “进程是动态的,程序是静态的;进程是独立性的,能并发执行,程序不能并发执行;程序与进程无一一对应关系;进程异步进行,会相互制约,程序不具备此特征。而本质上的区别是进程是动态的,程序是静态的。”

 

磁盘和内存的速度差异，决定了可以将内存经常访问的文件调入磁盘缓冲区，从高速缓存中复制的访问比磁盘   I/O   的机械操作要快很多很多。

 

进程申请读磁盘操作的时候，因为要等待I/O完成，将自身阻塞，进入阻塞态。当 I/O完成之后，从阻塞进入就绪态。

 

NowCoder在淘宝上开了一家网店。他发现在月份为素数的时候，当月每天能赚1元；否则每天能赚2元。
现在给你一段时间区间，请你帮他计算总收益有多少。

 

输入描述:

输入包含多组数据。

每组数据包含两个日期from和to (2000-01-01 ≤ from ≤ to ≤ 2999-12-31)。

日期用三个正整数表示，用空格隔开：year month day。

 

输出描述:

对应每一组数据，输出在给定的日期范围（包含开始和结束日期）内能赚多少钱。

示例1

输入

2000 1 1 2000 1 31
2000 2 1 2000 2 29

输出

62
29

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int fromYear = scanner.nextInt();
            int fromMonth = scanner.nextInt();
            int fromDay = scanner.nextInt();
            int toYear = scanner.nextInt();
            int toMonth = scanner.nextInt();
            int toDay = scanner.nextInt();
            int ret=0;
            //先处理第一年 参差不齐的时间收入
            ret=yearRet(fromYear)-sofatYear(fromYear,fromMonth,fromDay-1);
            //处理结束这一年 参差不齐的收入
            ret+=sofatYear(toYear,toMonth,toDay);
            //如果起止年份是同一年 就要把这一整年的收入减掉 不加这一整年，只看起止月日
            if(fromYear==toYear){
                ret-=yearRet(fromYear);
            }
            for (int i = fromYear+1; i < toYear ; i++) {
                ret+=yearRet(i);
            }
            System.out.println(ret);
        }
    }

    /**
     * 这一年 到现在这个日期为止 收入
     * @param fromYear
     * @param fromMonth
     * @param fromDay
     * @return
     */
    public static int sofatYear(int fromYear, int fromMonth, int fromDay) {
        int ret=0;
        if(isPrime(fromMonth)){
            ret=fromDay;
        }else {
            ret=fromDay*2;
        }
        while (--fromMonth>0){
            switch(fromMonth){
                case 1:case 8:case 10:case 12:
                    ret+=62;
                    break;
                case 3:case 5:case 7:
                    ret+=31;
                    break;
                case 4:case 6:case 9:
                    ret+=60;
                    break;
                case 11:
                    ret+=30;
                    break;
                default:
                    ret+=(28+(isLeapYear(fromYear)?1:0));
                    break;
            }
        }
        return ret;
    }


    /**
     * 这一年的收入
     * @param year
     * @return
     */
    private static int yearRet(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);
    }

    //判断是否为闰年
    public static boolean isLeapYear(int year){
        return (year%4==0&&year%100!=0)||year%400==0;
    }

    //判断素数月份
    private static boolean isPrime(int mouth) {
        return mouth==2||mouth==3||mouth==5||mouth==7||mouth==11;
    }
}

NowCoder号称自己已经记住了1-100000之间所有的斐波那契数。
为了考验他，我们随便出一个数n，让他说出第n个斐波那契数。当然，斐波那契数会很大。因此，如果第n个斐波那契数不到6位，则说出该数；否则只说出最后6位。

 

输入描述:

输入有多组数据。
每组数据一行，包含一个整数n (1≤n≤100000)。

 

输出描述:

对应每一组输入，输出第n个斐波那契数的最后6位。

示例1

输入

1<br/>2<br/>3<br/>4<br/>100000

输出

1<br/>2<br/>3<br/>5<br/>537501

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] arr = new int[100001];
        arr[0] = 1;
        arr[1] = 1;
        for (int i = 2; i < arr.length; i++) {
            arr[i] = (arr[i-1] + arr[i-2])%1000000;
        }
        while (scanner.hasNext()){
            int num = scanner.nextInt();
            if(num < 26){
                System.out.println(arr[num]);
            }else{
                System.out.printf("%06d\n",arr[num]);
            }
        }
    }
}

 注：小于26，斐波那契值为五位数，不用补0，超过6位，如果%1000000不足六位，要给高位补0。（printf的format）