Java面向对象编程

在支持多线程的系统中，进程P创建的若干个线程不能共享的是（ ）

A. 进程 P 的代码段

B. 进程 P 中打开的文件

C. 进程 P 的全局变量

D. 进程 P 中某线程的栈指针

答案：D

操作系统中关于竞争和死锁的关系下面描述正确的是？

A. 竞争一定会导致死锁

B. 死锁一定由竞争引起

C. 竞争可能引起死锁

D. 预防死锁可以防止竞争

答案：C

并发是并行的不同表述，其原理相同。

A. 错

B. 对

答案：A

线程的切换会引起进程的切换。

A. 错

B. 对

答案：A

操作系统的所有程序是常驻内存的。

A. 错

B. 对

答案：A

把逻辑地址转换程物理地址称为（）

A. 地址分配

B. 地址映射

C. 地址保护

D. 地址越界

答案：B

在Unix系统中，处于()状态的进程最容易被执行。

A. 辅存睡眠

B. 内存睡眠

C. 内存就绪

D. 辅存就绪

答案：C

进程的控制信息和描述信息存放在()。

A. JCB

B. PCB

C. AFT

D. SFT

答案：B

在（）情况下，系统出现死锁。

A. 若干进程因竞争资源而无休止地相互等待对方释放已占有的资源

B. 有多个封锁的进程同时存在

C. 计算机系统发生重大故障

D. 资源数大大小于进程数或进程同时申请的资源数大大超过资源总数

答案：A

当系统发生抖动（thrashing）时，可以采取的有效措施是（ ）

Ⅰ．撤销部分进程

Ⅱ．增加磁盘交换区的容量

Ⅲ．提高用户进程的优先级

A. 仅Ⅰ

B. 仅Ⅱ

C. 仅Ⅲ

D. 仅Ⅰ， Ⅱ

答案：A

年会抽奖

题目描述：今年公司年会的奖品特别给力，但获奖的规矩却很奇葩： 

1. 首先，所有人员都将一张写有自己名字的字条放入抽奖箱中； 

2. 待所有字条加入完毕，每人从箱中取一个字条； 

3. 如果抽到的字条上写的就是自己的名字，那么“恭喜你，中奖了！” 

现在告诉你参加晚会的人数，请你计算有多少概率会出现无人获奖？ 

输入描述：输入包含多组数据，每组数据包含一个正整数n（2≤n≤20）。 

输出描述：对应每一组数据，以“xx.xx%”的格式输出发生无人获奖的概率。

输入：2

输出：50%

public class Main57 {

    //年会抽奖

    public static void main(String[] args) {

        long[] d=new long[100];

        d[0]=0;

        d[1]=0;

        d[2]=1;

        long[] f=new long[100];

        f[0]=1;

        f[1]=1;

        f[2]=2;



        for (int i = 3; i <=21 ; i++) {

            d[i]=(i-1)*(d[i-1] + d[i-2]);

            f[i]=f[i-1]*i;

        }

        Scanner scanner=new Scanner(System.in);

        while (scanner.hasNextInt()){

            int n=scanner.nextInt();

            System.out.printf("%.2f%%\n",100.0*d[n]/f[n]);



        }

    }

}

抄送列表

题目描述：NowCoder每天要处理许多邮件，但他并不是在收件人列表中，有时候只是被抄送。他认为这些抄送的邮件重要性比自己在收件人列表里的邮件低，因此他要过 滤掉这些次要的邮件，优先处理重要的邮件。 

现在给你一串抄送列表，请你判断目标用户是否在抄送列表中。 

输入描述：输入有多组数据，每组数据有两行。 

第一行抄送列表，姓名之间用一个逗号隔开。如果姓名中包含空格或逗号，则姓名包含在双引号里。总长度不超过512个字符。 

第二行只包含一个姓名，是待查找的用户的名字（姓名要完全匹配）。长度不超过16个字符。 

输出描述：如果第二行的名字出现在收件人列表中，则输出“Ignore”，表示这封邮件不重要；否则，输出“Important!”，表示这封邮件需要被优先处理。

//抄送列表

public class Main58 {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        while (sc.hasNextLine()) {

            String s = sc.nextLine();

            String name = sc.nextLine();

            char[] ch = s.toCharArray();

            List<String> list = new ArrayList<>();

            int flag = 0;

            String res = "";

            for (int i = 0; i < ch.length; i ++ ) {

                if (flag == 0 && ch[i] == '"') {

                    flag = 1;

                    list.add(res);

                    res = "";

                } else if (flag == 1 && ch[i] == '"') {

                    flag = 0;

                    list.add(res);

                    res = "";

                } else if (flag == 1) {

                    res += ch[i];

                } else if (flag == 0 && ch[i] != ',') {

                    res += ch[i];

                }

            }

            list.add(res);

            boolean isFinded = false;

            for (String string : list) {

                if (name.equals(string)) {

                    isFinded = true;

                    break;

                }

            }

            if (isFinded) System.out.println("Ignore");

            else System.out.println("Important!");

        }

    }

}

数据库连接池

题目描述：Web系统通常会频繁地访问数据库，如果每次访问都创建新连接，性能会很差。为了提高性能，架构师决定复用已经创建的连接。当收到请求，并且连接池中没 有剩余可用的连接时，系统会创建一个新连接，当请求处理完成时该连接会被放入连接池中，供后续请求使用。 

现在提供你处理请求的日志，请你分析一下连接池最多需要创建多少个连接。

输入描述：输入包含多组数据，每组数据第一行包含一个正整数n（1≤n≤1000），表示请求的数量。 

紧接着n行，每行包含一个请求编号id（A、B、C……、Z）和操作（connect或disconnect）。 

输出描述：对应每一组数据，输出连接池最多需要创建多少个连接。

 

public class Main59 {

    //数据库连接池

    public static void main(String[] args) {

        Scanner scanner=new Scanner(System.in);

        while (scanner.hasNext()){

            int n=scanner.nextInt();

            String id,op;

            int maxCon=0;

            Set<String> s=new HashSet<>();

            for (int i = 0; i < n; i++) {

                id=scanner.next();

                op=scanner.next();



                if (op.equals("connect")){

                    s.add(id);

                }else {

                    s.remove(id);

                }

                maxCon=Math.max(maxCon,s.size());

            }

            System.out.println(maxCon);

        }

    }

}

Mkdir

题目描述：工作中，每当要部署一台新机器的时候，就意味着有一堆目录需要创建。例如要创建目录“/usr/local/bin”，就需要此次创建“/usr”、“/usr/local”以 及“/usr/local/bin”。好在，Linux下mkdir提供了强大的“-p”选项，只要一条命令“mkdir -p /usr/local/bin”就能自动创建需要的上级目录。 现在给你一些需要创建的文件夹目录，请你帮忙生成相应的“mkdir -p”命令。 

输入描述：输入包含多组数据。 

每组数据第一行为一个正整数n(1≤n≤1024)。 

紧接着n行，每行包含一个待创建的目录名，目录名仅由数字和字母组成，长度不超过200个字符。 

输出描述：对应每一组数据，输出相应的、按照字典顺序排序的“mkdir -p”命令。 

每组数据之后输出一个空行作为分隔。

 

public class Main60 {

    //Mkdir

    public static void main(String[] args) {

        //循环接收多组测试用列

        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {

            //接收一组测试用列

            int n = scanner.nextInt();

            String[] path = new String[n];

            for (int i = 0; i < n; i++) {

                path[i] = scanner.next();

            }

            //按照字典的方式对所有的目录进行排序

            Arrays.sort(path);



            //过滤目录：相同目录 || 子目录

            //伪删法：标记

            boolean[] flag = new boolean[n];

            for (int i = 0; i < n - 1; ++i) {

                //相同目录

                if (path[i].equals(path[i + 1])) {

                    flag[i] = true;

                } else if (path[i].length() < path[i + 1].length() &&

                        path[i + 1].contains(path[i]) && path[i + 1].charAt(path[i].length()) == '/') {

                    flag[i] = true;

                }

            }

            //拼接要输出的结果

            for (int i = 0; i < n; i++) {

                if (!flag[i]) {

                    System.out.println("mkdir -p " + path[i]);

                }

            }

            System.out.println();

        }

    }

}

方法2：

//mkdir

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        while (sc.hasNext()) {

            int n = sc.nextInt();

            String[] arr = new String[n];

            for (int i = 0; i < arr.length; i++) {

                arr[i] = sc.next();

            }

            Arrays.sort(arr);

            List<String> res = new ArrayList<>();

            for (int i = 1; i < arr.length; i++) {

                if (!arr[i].startsWith(arr[i - 1] + "/")) res.add(arr[i - 1]);

            }

            res.add(arr[n - 1]);

            for (String s : res) {

                System.out.println("mkdir -p " + s);

            }

            System.out.println();

        }

    }

}