刷题日记【第十四篇】-笔试必刷题【不用加减乘除做加法+三角形+猴子分桃+反转部分单向链表】

1.用命令方式运行以下代码的运行结果是（C）

先带复习以下命令
编译命令：javac 源文件名.java
*.java -> *.class
运行命令：java主类名称要传递的参数(传给main中的args中)
java f a b c
参数是 a b c 放入args数组中，因为数组下标是从0开始，所以args[3]数组下标越界，程序运行错误

2.类方法中的this表示当前对象引用，不能调用静态域；静态方法没有对象也可以直接调用，所以在类方法中调用本类的类方法可以直接调用；如果类方法中创建了对象，仍可以通过对象来调用实例方法。

3.类的调用

已知如下类说明：

public class Test{
    private float f=1.0f;
    int m=12;
    static int n=1;
    public static void main(String args[]){
        Test t=new Test();
    }
}
如下哪些使用是正确的（）
A.t.f = 1.0
B.this.n
C.Test.m
D.Test.n

A选项，浮点类型的默认类型是double，A选项中是由精度低的float类型向高精度的double类型转型，因此会报错

B选项，this指向的是对象，而static类型的变量先于对象存在，无法通过this调用

C选项，m是实例变量，无法通过类名直接调用，需要由对象调用

D选项，被static关键字修饰的变量直属于类，可以由类名直接调用，因此正确答案为D

4.类加载过程都给干了些啥？

生成java.lang.Class对象
执行static块代码
类方法解析
至于int类型对象成员变量赋予默认值，这个在对象产生执行时，在类加载之后，并不属于类加载过程。

5.【编程题】三角形

public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextDouble() ){ // 注意 while 处理多个 case
            double a = in.nextDouble();
            double b = in.nextDouble();
            double c = in.nextDouble();
            if (a+b>c && a+c>b && b+c>a){
                System.out.println("Yes");
            }else{
                System.out.println("No");
            }
        }
    }

这道题虽然看起来可以用double来ac过去，但是double存在精度误差
math中有BigDecimal可以提高精度，而且其中的add方法和compareTo方法可以使ac简单

import java.math.BigDecimal;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext() ){ // 注意 while 处理多个 case
            BigDecimal a  = in.nextBigDecimal();
            BigDecimal b  = in.nextBigDecimal();
            BigDecimal c  = in.nextBigDecimal();
            if(a.add(b).compareTo(c)>0 && a.add(c).compareTo(b)>0  && b.add(c).compareTo(a)>0){
                System.out.println("Yes");
            }else{
                System.out.println("No");
            }
        }
    }
}

6.【编程题】不用加减乘除做加法

解题思路：

import java.util.*;
public class Solution {
    public int Add(int num1,int num2) {
        if (num2 == 0) {
            return num1;
        } else {
            return Add(num1 ^ num2, (num1 & num2) << 1);
        }
    }
}

7.监听TCP端口【服务器+客户端】方法

8.jre 判断程序是否执行结束的标准是-A

了解一下jre和jdk
jre： Java运行时环境
jdk： Java开发工具包，包含了jre

什么时候Java进程认为程序全部执行完毕；所有前台线程（用户线程）执行完毕
setDameon（true）
一般我们创建的线程都是前台线程
后台线程：靠jvm垃圾回收线程

9.短路或的应用

10.jdk1.6垃圾收集器

11.【编程题】反转部分单向链表

尾插法

import java.util.*;

public class Main {
    //首先定义单链表结点
    static class Node{
        int val;
        Node  next;
        public Node(int val){
            this.val = val;
        }
    }


    public static void main(String[] args) {
        Scanner  scanner =  new Scanner(System.in);

        int n  =scanner.nextInt();
        scanner.nextLine();//吃掉换行符

        String nodeValue = scanner.nextLine();
        String[] nodes =  nodeValue.split(" ");
        
        //进行链表的创建
        Node dummyHead = new Node(-1);
        Node tail = dummyHead;
        for (int i = 0; i < n; i++) {
            //链表的尾插法
            Node  node = new Node(Integer.parseInt(nodes[i]));
            tail.next = node;
            tail = node;
        }
        //获取左区间和右区间的范围
        String part = scanner.nextLine();
        int left = Integer.parseInt(part.split(" ")[0]);

        int right = Integer.parseInt(part.split(" ")[1]);
        
        Node  newHead = reversePartList(dummyHead.next,left,right);
        
        while (newHead!=null){
            System.out.print(newHead.val+" ");
            newHead=newHead.next;
        }

    }

    private static Node reversePartList(Node head, int left, int right) {
        Node dummyHead = new Node(-1);
        dummyHead.next = head;
        Node prev = dummyHead;
        for (int i = 1; i < left; i++) {
            prev = prev.next;
        }
        
        Node cur = prev.next;
        for (int i = left; i <right ; i++) {
            Node thrid = cur.next;
            
            cur.next = thrid.next;
            thrid.next = prev.next;
            prev.next = thrid;
        }
        return dummyHead.next;
    }
}

12.【编程题】猴子分桃

思路：因为每次分5堆都会多出来1个，所以我们借给猴子们4个，以致每次都可以刚好分成5堆
    并且，每次给老猴子的桃子都不在我们借出的那4个中，这样最后减掉4就可以得到结果。
  假设最初由x个桃子，我们借给猴子4个，则此时有x+4个，
  第一个猴子得到（x+4）/5，剩余（x+4）*（4/5）个
  第二个猴子分完后剩余（x+4）*(4/5)^2个
  第三个猴子分完后剩余（x+4）*(4/5)^3个
  依次类推，最后一个猴子分完后剩余（x+4）*（4/5）^n
  要满足最后剩余的为整数，并且x最小，则当 x+4=5^n时，满足要求
  此时，x=5^n-4;
  老猴子得到的数量为：old = （x+4）*（4/5）^n + n - 4
                    = 4^n + n - 4
  最后加n是因为不是剩余多出来的一个，而是小猴子给的，比如桃子是有6个，小猴子本身只能拿一个，我们借给4个，小猴就能拿两个，那多出来的哪一个给老猴子，和之前6个整除五余1一个道理       
  最后老猴子减4是还给我们借给它们的那4个

import java.util.*;
public class 猴子分桃 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            int n =scanner.nextInt();
            if (n==0){
                break;
            }
            long a  = (long) (Math.pow(5,n)-4);
            long b  = (long) (Math.pow(4,n)+n-4);
            System.out.println(a+" "+b);
        }
    }
}