每日训练-day32

MM2LYF

已于 2022-06-02 11:02:10 修改

阅读量114

点赞数

分类专栏：每日训练文章标签： java 算法

于 2022-06-01 15:32:13 首次发布

本文链接：https://blog.csdn.net/MM2LYF/article/details/125072366

版权

每日训练专栏收录该内容

31 篇文章 0 订阅

订阅专栏

day32_0531

选择题

磁盘缓冲区是硬盘与外部总线交换数据的场所，它对性能的影响大大超过缓存对性能的影响；磁盘和内存的速度差异，决定了可以将内存经常访问的文件调入磁盘缓冲区，从高速缓存中复制的访问比磁盘I/O的机械操作要快很多很多。

操作系统的主要功能有资源管理，程序控制和人机交互。

OPT：
Optimal page replacement algorithm 最佳页面替换算法。
预测哪个页面最晚出现，就替换哪个页面。
LRU：
Least Recently Used 不要译成“近期最少使用算法”，
Recently Used是“最近使用”，Least为否定词，结果就是“最远使用”，建议翻译成“最久未被使用算法”。
（很多翻译为“最近最久未被使用”，听起来也很怪，我感觉最近不用保留）
MFU：
Most Frequently Used 最常使用算法，
看这个字面意思是要替换掉“最常使用的页面”了……
LFU：
Least Frequently Used 不要翻译成“最近最不常使用算法”。
Frequently Used 是经常使用，Least是否定词，可以翻译成“最不经常使用算法”，不知道最近是哪里来的？
和MFU是相反的，替换掉最不经常使用的页面。

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

为什么只唤醒一个呢？因为等待同一个Io资源的进程们会根据请求这个资源的顺序纷纷挂起，并且形成排队序列，先来先服务懂吧，因为这资源不共享所以才排队，所以互斥使用，一次只让一个人使用！即排在队伍最前面的一个进程被唤醒

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

进程申请读磁盘操作的时候，因为要等待I/O操作完成，会把自身阻塞，此时进程就变为了阻塞状态，当I/O操作完成后，进程得到了想要的资源，就会从阻塞态转换到就绪态（这是操作系统的行为）。而降低进程优先级、分配用户内存空间和增加进程的时间片大小都不一定会发生。

并发进程相互之间可能是无关的，即它们是各自独立的，这些进程中每一个进程的执行既不依赖于其它进程也不会影响其它进程的执行。但是，有些并发进程需使用共享资源，此时就需要互斥

进程和程序的区别：

进程就是运行的程序

1、进程是动态的，程序是静态的——程序是有序代码的集合，进程是程序的执行
2、进程是暂时的，程序是永久的——进程是一个状态变化的过程，程序可以长久保存
3、进程组成包括程序、数据和进程控制块

正在运行的是程序放在内存的，

程序的数据和指令是预加载进寄存器的。

编程题

淘宝网店

这道题不是很难就是麻烦

解这道题要分成三部分来算：开始的那年挣的+中间几个整年挣的+结束的那年挣的

如果开始到结束都是在同一年：开始的那个月挣的+中间的几个月挣的+结束的月挣的

注意：例如2000 1 1 2000 1 1 返回的因该是2；

// write your code here
import java.util.Scanner;
import java.lang.Integer;
public class Main {
  public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] a = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        while (sc.hasNext()) {
            String str1 = sc.nextLine();
            String[] s = str1.split(" ");
            int[] arr = new int[6];
            for (int i = 0; i < 6; i++) {
                arr[i] = Integer.parseInt(s[i]);
            }
            int countYear = 0;
            if (arr[0] == arr[3]) {
                //判断是否在同一年
                for (int i =arr[1]; i <arr[4] ; i++) {
                    if(i==arr[1]){
                        if(Ryear(arr[0])&&i==2){
                            //从闰年的二月开是的话
                            countYear+=a[i-1]+1-arr[2]+1;
                        }else{
                            if(i!=2&&i!=3&&i!=5&&i!=7&&i!=11) {
                                //不是素月
                                countYear += (a[i - 1] - arr[2] + 1)*2;
                            }else {
                                countYear += a[i - 1] - arr[2] + 1;
                            }
                        }
                    }else {
                        if(i==2&&Ryear(arr[0])){
                            countYear++;
                        }
                        if(i!=2&&i!=3&&i!=5&&i!=7&&i!=11) {
                            countYear += (a[i- 1])*2;
                        }else {
                            countYear += a[i- 1];
                        }
                    }
                }
                if(arr[1]!=arr[4]) {
                   //如果同月
                    if (arr[4] != 2 && arr[4] != 3 && arr[4] != 5 && arr[4] != 7 && arr[4] != 11) {
                        countYear += arr[5] * 2;
                    } else {
                        countYear += arr[5];
                    }
                }else {
                    if (arr[4] != 2 && arr[4] != 3 && arr[4] != 5 && arr[4] != 7 && arr[4] != 11) {
                        countYear+=(arr[5]-arr[2]+1)*2;
                    }else {
                        countYear+=arr[5]-arr[2]+1;
                    }
                }
            } else {
                countYear = (arr[3] - arr[0] - 1) * 579;//按照平年算一年可以挣579
                int Rcount = 0;
                //在此期间有几个闰年
                for (int i = arr[0] + 1; i < arr[3]; i++) {
                    if (Ryear(i)) {
                        Rcount++;
                    }
                }
                    countYear += Rcount;//从开始的第二年1月1号到结束的那年的前一年12月31号挣的钱
                    //开始的那年
                    for (int j = arr[1]; j <= 12; j++) {
                        if(j==arr[1]){
                            if(Ryear(arr[0])&&j==2){
                                //从闰年的二月开是的话
                                countYear+=a[j-1]+1-arr[2]+1;
                            }else{
                                if(j!=2&&j!=3&&j!=5&&j!=7&&j!=11) {
                                    //不是素月
                                    countYear += (a[j - 1] - arr[2] + 1)*2;
                                }else {
                                    countYear += a[j - 1] - arr[2] + 1;
                                }
                            }
                        }else{
                            if(Ryear(arr[0])&&j==2){
                                //包含闰年整个二月
                                countYear++;
                            }
                            if(j!=2&&j!=3&&j!=5&&j!=7&&j!=11) {
                                countYear += (a[j - 1])*2;
                            }else {
                                countYear += a[j - 1];
                            }
                        }
                    }
                    //结束的那年
                    for(int k=1;k<arr[4];k++){
                        if(Ryear(arr[3])&&k==2){
                            //包含闰年整个二月
                            countYear++;
                        }
                        if(k!=2&&k!=3&&k!=5&&k!=7&&k!=11) {
                            countYear += (a[k - 1])*2;
                        }else {
                            countYear += a[k - 1];
                        }
                    }
                    if(arr[4]!=2&&arr[4]!=3&&arr[4]!=5&&arr[4]!=7&&arr[4]!=11) {
                        countYear += arr[5]*2;
                    }else {
                        countYear += arr[5];
                    }
            }
            System.out.println(countYear);
        }
    }
        public static boolean Ryear(int year){
            if(year%100==0){
                if(year%400==0){
                    return true;
                }else{
                    return false;
                }
            }
            if(year%4==0){
                return true;
            }
            return false;
        }
}

斐波那契凤尾

注意高位要补零，要从一开始就只保留六位的数

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc=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];
            arr[i]=arr[i]%1000000;
        }
        while(sc.hasNext()){
            int n=sc.nextInt();
             if(n<26) {
                System.out.printf("%d\n", arr[n]);
            }else {
                System.out.printf("%06d\n", arr[n]);
            }
        }
    }
}