Java面向对象编程

下列关于线程的说法错误的是（）

A. 耗时的操作使用线程，提高程序响应

B. 耗内存的操作使用线程，提高内存利用率

C. 多CPU的系统使用线程，提高CPU利用率

D. 并行操作使用线程，如c/s架构中服务端程序为每个客户端请求创建一个线程来响应

答案：B

如果将固定块大小的文件系统中的块大小设置大一些，会造成（）。

A. 更好的磁盘吞吐量和更差的磁盘空间利用率

B. 更好的磁盘吞吐量和更好的磁盘空间利用率

C. 更差的磁盘吞吐量和更好的磁盘空间利用率

D. 更差的磁盘吞吐量和更差的磁盘空间利用率

答案：A

在下列进程的四个特征中，最基本的特征是（）

A. 并发性

B. 动态性

C. 独立性

D. 异步性

答案：B

进程调度是从（）选择一个进程投入运行。 A. 就绪队列 B. 等待队列 C. 作业后备队列 D. 提交队列 答案：A

下面有关Cache的说法哪一个是不正确的（） A. 设置Cache的目的，是解决CPU和主存之间的速度匹配问题 B. 设置Cache的理论基础，是程序访问的局部性原理 C. Cache与主存统一编址，Cache的地址空间属于主存的一部分 D. Cache的功能均由硬件实现，对程序员是透明的 答案：C

什么是内存抖动（Thrashing）（ ）

A. 非常频繁的换页活动

B. 非常高的CPU执行活动

C. 一个极长的执行进程

D. 一个极大的虚拟内存

答案：A

在所有非抢占CPU调度算法中，系统平均响应时间最优的是（ ）

A. 实时调度算法

B. 短任务优先算法

C. 时间片轮转算法

D. 先来先服务算法

答案：B

假设如下代码中，若t1线程在t2线程启动之前已经完成启动。代码的输出是？

A. Thread 1 wake up Thread 2 sent notify.

B. Thread 2 sent notify. Thread 1 wake up

C. A、B皆有可能

D. 程序无输出卡死

答案：B

以下哪句的说法是正确的？

A. 在页式存储管理中，用户应将自己的程序划分为若干个相等的页

B. 所有的进程都挂起时，系统将陷入死锁

C. 执行系统调用可以被中断

D. 进程优先数是进程调度的重要依据，必须根据进程运行情况动态改变

答案：C

下列方法中，____不可以用来程序调优？

A. 改善数据访问方式以提升缓存命中率

B. 使用多线程的方式提高 I/O 密集型操作的效率

C. 利用数据库连接池替代直接的数据库访问

D. 利用迭代替代递归

E. 合并多个远程调用批量发送

F. 共享冗余数据提高访问效率

答案：B

Rational Arithmetic (20)

链接：Rational Arithmetic (20)__牛客网
来源：牛客网
 

For two rational numbers, your task is to implement the basic arithmetics, that is, to calculate their sum, difference,
product and quotient.

 

输入描述:

Each input file contains one test case, which gives in one line the two rational numbers in the format "a1/b1 a2/b2". 
The numerators and the denominators are all in the range of long int. If there is a negative sign, it must appear only in 
front of the numerator. The denominators are guaranteed to be non-zero numbers.

 

输出描述:

For each test case, print in 4 lines the sum, difference, product and quotient of the two rational numbers, respectively. The format of each 
line is "number1 operator number2 = result". Notice that all the rational numbers must be in their simplest form "k a/b", where k is 
the integer part, and a/b is the simplest fraction part. If the number is negative, it must be included in a pair of parentheses. If the 
denominator in the division is zero, output "Inf" as the result. It is guaranteed that all the output integers are in the range of long int.

示例1

输入

5/3 0/6

输出

1 2/3 + 0 = 1 2/3
1 2/3 - 0 = 1 2/3
1 2/3 * 0 = 0
1 2/3 / 0 = Inf

这种题目，思路越简单（想的越快）写的越多，思路越巧（不容易想）写的越少，所以还是要积累大神的写法，然后背下来；我的方法属于想得快、写的多的，思路仅供参考。

1. 构造函数：通分+处理分母为0+形成输出string

2. 加法：分为同号和异号两种情况，异号“左正右负”与“右正左负”只需递归切换顺序即可，故只考虑“左正右负”情况，该情况只需再分为“左绝对值大”与“右绝对值大”两种情况即可；主函数体不通分，上交构造函数通分

3. 减法：实际通过加一个负数实现，上交加法实现

4. 乘法：实际为四个元素相加，上交加法实现

5. 除法：实际为两个元素相乘，上交乘法实现

6. 重点：本法处理分母为0其实很简单，分母=0（其他部分随意）的分数不会干扰到任何一种运算；算法的最底层部分在于加法的异号处理和通分，其余算法都在这基础之上

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            
            String l = sc.next();
            String r = sc.next();
            
            int lLine = findLine(l);
            int rLine = findLine(r);
            
            Fraction fl = new Fraction(getMolecular(l,lLine),getDenominator(l,lLine));
            Fraction fr = new Fraction(getMolecular(r,rLine),getDenominator(r,rLine));
            
            add(fl,fr);
            
            sub(fl,fr);
            
            mul(fl,fr);
            
            div(fl,fr);
        }
    }
    
    private static void div(Fraction l,Fraction r){
        if(r.up == 0){
            print(l,r,0,0,'/',true);
        }else{
            mul(l,r.down,r.up,'/');
        }
    }
    
    private static void mul(Fraction l,Fraction r){
        mul(l,r.up,r.down,'*');
    }
    
    private static void mul(Fraction l,long rUp,long rDown,char ch){
        long down = l.down * rDown;
        long up = l.up * rUp;
        if(down < 0){
            down *= -1;
            up *= -1;
        }
        if(ch == '/'){
            long temp = rUp;
            rUp = rDown;
            rDown = temp;
        }
        print(l,new Fraction(rUp,rDown),up,down,ch,false);
    }
    
    private static void sub(Fraction l,Fraction r){
        add(l,r,-1);
    }
    
    private static void add(Fraction l,Fraction r){
        add(l,r,1);
    }
    
    private static void add(Fraction l,Fraction r,int n){
        long down = l.down * r.down;
        long up = l.up * r.down + (r.up * l.down) * n;
        print(l,r,up,down,n == 1 ? '+' : '-',false);
    }
    
    private static void print(Fraction l,Fraction r,long up,long down,char ch,boolean isInf){
        System.out.println(doSimple(l.up,l.down)+" "+ch+" "+doSimple(r.up,r.down)+" = "+(isInf ? "Inf" : doSimple(up,down)));
    }
    
    private static String doSimple(long up,long down){
        if(up == 0){
            return "0";
        }
        if(up % down == 0){
            long temp = up / down;
            return temp > 0 ? temp + "" : "("+temp+')';
        }
        boolean isNeg = false;
        if(up < 0){
            up *= -1;
            isNeg = true;
        }
        long common = maxCommon(up,down);
        if(common != -1){
            up /= common;
            down /= common;
        }
        if(up > down){
            long temp = up / down;
            up %= down;
            if(isNeg){
                return "(-"+temp+" "+up+'/'+down+')';
            }
            return temp+" "+up+'/'+down;
        }
        if(isNeg){
            return "(-"+up+'/'+down+')';
        }
        return up + "/" + down;
    }
    
    private static long maxCommon(long up,long down){
        long common = -1;
        if(up > down){
            long temp = up;
            up = down;
            down = temp;
        }
        for(long i = up;i >1;i--){
            if(down % i == 0 && up % i == 0){
                common = i;
                break;
            }
        }
        return common;
    }
    
    private static class Fraction{
        private long up;
        private long down;
        public Fraction(long up,long down){
            this.up = up;
            this.down = down;
        }
    }
    
    private static int findLine(String str) {
        int i = 0;
        for(;i < str.length();i++){
            if(str.charAt(i) == '/'){
                break;
            }
        }
        return i;
    }
    private static long getMolecular(String str,int index){
        int molecular = 0;
        for(int i = index - 1;i >= 0;i--){
            char ch = str.charAt(i);
            if(ch >= '0' && ch <= '9'){
                molecular = molecular * 10 + (ch - '0');
            }else{
                if(ch == '-'){
                    molecular *= -1;
                }
                break;
            }
        }
        return molecular;
    }
    private static long getDenominator(String str,int index){
        int denominator = 0;
        for(int i = index + 1;i < str.length();i++){
            char ch = str.charAt(i);
            if(ch >= '0' && ch <= '9'){
                denominator = denominator * 10 + (ch - '0');
            }else{
                break;
            }
        }
        return denominator;
    }
}