48天笔试训练错题——day32

ミカミミミ

于 2024-05-21 19:00:46 发布

阅读量437

点赞数 5

分类专栏： 48天笔试训练错题合集文章标签： 48天笔试强训 Java

本文链接：https://blog.csdn.net/weixin_74085729/article/details/137910868

版权

48天笔试训练错题合集专栏收录该内容

32 篇文章 0 订阅

订阅专栏

选择题

1.

操作系统程序就是进程。

进程在运行时会首先加载在内存中，所以选主存。

寄存器的容量是有限的，只是加载 cpu 执行代码行需要的数据（从主存加载到寄存器）

如果进程处于挂起状态，进程就会保存在辅存中。

2.

cpu 执行速度比磁盘 io 速度要快很多，为了提高效率，经常访问的磁盘数据，就可以使用磁盘缓存加快 io 速度。(减少寻道次数)

3.

4.

进程 io 操作完成之后，会从阻塞状态变成就绪状态。

BCD 三个选项与 io 操作无关。

5.

cpu 的处理速度与 cpu 的核心数有关。

6.

进程是运行中的程序，程序是保存在硬盘中的静态的可执行文件。

进程在挂起状态，是存储在外存中。程序没运行起来，没法独占 cpu。

7.

一次 io 操作结束后，一个进程会从阻塞状态转变为就绪状态。

等到操作系统调度到之后，才会从就绪变成运行状态。

8.

9.

编程题

1. 淘宝网店

思路如下：

代码实现：

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int year1 = in.nextInt();
            int month1 = in.nextInt();
            int day1 = in.nextInt();
            int year2 = in.nextInt();
            int month2 = in.nextInt();
            int day2 = in.nextInt();

            // 先计算 year1 剩下的部分
            int profit = profitOfYear(year1) - profitOfThisYear(year1, month1, day1 - 1);
            // 再计算 year2 的部分
            profit += profitOfThisYear(year2, month2, day2);
            // 如果是同一年，则需要特殊处理
            if (year1 == year2) {
                profit -= profitOfYear(year1);
            }
            // 再计算 year1 + 1 到 year2 - 1 的年份收益
            for (int y = year1 + 1; y < year2; y++) {
                profit += profitOfYear(y);
            }
            System.out.println(profit);
        }
    }

    // 计算某年的全年收益
    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);
    }

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

    // 判断范围为 [1,12] 的 n 是否是素数
    public static boolean isPrime(int n) {
        if (n == 2 || n == 3 || n == 5 || n == 7 || n == 11) {
            return true;
        }
        return false;
    }

    // 计算从 year 的 1 月 1 日到 year 的 month 月 day 日的收益
    public static int profitOfThisYear(int year, int month, int day) {
        int profit = 0;
        if (!isPrime(month)) {
            profit += 2 * day;
        } else {
            profit += day;
        }
        // 闰年的情况
        if (isLeapYear(year) && month > 2) profit += 1;
        for (int i = 1; i < month; i++) {
            switch (i) {
                case 1: case 8: case 10: case 12:
                    profit += 2 * 31;
                    break;
                case 2:
                    profit += 1 * 28;
                    break;
                case 3: case 5: case 7:
                    profit += 1 * 31;
                    break;
                case 4: case 6: case 9:
                    profit += 2 * 30;
                    break;
                case 11:
                    profit += 1 * 30;
                    break;
            }
        }
        return profit;
    }
}

2. 斐波那契凤尾

可能存在 10000000 这样的斐波那契数，超过 6 位输出最后 6 位，那就是预期输出 000000，所以需要考虑这种情况，所以超过 6 位数的输出最后 6 位不足 6 位就需要补 0.而数本身就小于 6 位的就输出数，所以也需要判断什么时候小于 6 位。就可以用 flg 来纪录第一个大于 6 位数的斐波那契数，如果输入的 n 大于等于 flg，就要补0，否则就正常输出即可。

代码实现：

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        long[] hash = new long[100000];
        hash[0] = 1;
        hash[1] = 2;
        int flg = -1;
        for (int i = 2; i < hash.length; i++) {
            hash[i] = hash[i - 1] + hash[i - 2];
            // 记录首次超过 6 位数值的下标
            if (flg == -1 && hash[i] >= 1000000 ) {
                flg = i;
            }
            hash[i] %= 1000000;
        }

        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int n = in.nextInt();
            if (n - 1 >= flg) {
                // 说明 n 大于 6位数，如果不够 6 位就需要补 0 
                System.out.printf("%06d\n", hash[n - 1]);
            } else {
                // 其他正常输出即可。
                System.out.println(hash[n - 1]);
            }
        }
    }



}