刷题日记【第十三篇】-笔试必刷题【数根+星际密码+跳台阶扩展问题+快到碗里来】

刷题日记【第十三篇】-笔试必刷题【数根+星际密码+跳台阶扩展问题+快到碗里来】

1.方法区在JVM中也是一个非常重要的区域，它与堆一样，是被【线程共享】的区域。

下面有关JVM内存，说法错误的是？(c)
A.程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，
是线程隔离的
B.Java方法执行内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，
是线程隔离的
C.方法区用于存储JVM加载的类信息、常量、静态变量、即时编译器编译后的代码等数据，
是线程隔离的
D.原则上讲，所有的对象都在堆区上分配内存，是线程之间共享的
1
2
3
4
5
6
7
8

JVM运行时，数据区包含：虚拟机栈，堆，方法区，本地方法栈，程序计数器，其中，堆和方法区是线程共享的，虚拟机栈和程序计数器是线程私有的。

2.以下程序的输出结果是

public class Print{
	static boolean out(char c){
		System.out.print(c);
		return true;
	}
	public static void main(String[] argv){
		int i = 0;
		for(out('A');out('B') && (i<2);out('C')){
			i++;
			out('D');
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

3.给定代码：

public class SwitchTest{//1
	public static void main(String[] args) {//2
		System.out.println("value="+switchit(4));//3
	}//4
	public static int switchit(int x) {
		int j=1;
		switch (x) {
		case 1:j++;
		case 2:j++;
		case 3:j++;
		case 4:j++;
		case 5:j++;
		default:j++;
		}
		return j+x;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

第三行将输出什么？

switch代码块中没有break，从case 4开始一直执行到最后，j自加3次变成了4，结果返回8

4.线程安全

A.ConcurrentHashMap 使用 synchronized 关键字保证线程安全
B.HashMap 实现了 Collection 接口
C.Arrays.asList 方法返回 java.util.ArrayList 对象
D.SimpleDateFormat 对象是线程不安全的
1
2
3
4

ConcurrentHashMap使用通过volatile修饰符和后插入后特殊的算法实现读不加锁.

HashMap实现了Map接口

Array.asList返回的ArrayList不是util包中的ArrayList，而是Arrays类的一个继承了AbstractList内部类

SimpleDateFormat查看Java源码可以看到，它的方法都不是Synchronized的，也没有采用其他的同步措施

数根

import java.util.*;
class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        while(scan.hasNext()) {
            String str = scan.nextLine();
            while(str.length() != 1) {
                int sum = 0;
                for(int i = 0; i < str.length(); i++) {
                    sum += str.charAt(i) - '0';
                }
                str= String.valueOf(sum);
            }
            System.out.println(str);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

星际密码

这道题其实也是有规律的，首先接收多组测试用例，
每组用例：
输入第一行：正数n
第二行：n个数值xi
输出：每一个xi进行计算，f（xi），所有的结果拼接1为字符串
提前准备好f（xi）斐波那契的数据。

import java.util.*;
public class Main{
    public static void main(String []args){
        int[] nums = new int[10001];
        nums[1] = 1;
        nums[2] = 2;
        for(int i = 3;i<10001;i++){
            nums[i] = nums[i-1] + nums[i-2];
            nums[i] = nums[i] % 10000; //左上角的元素不能超过4位
        }
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()){
            StringBuilder sb = new StringBuilder();
            int n = scanner.nextInt();
            for(int i = 0;i<n;i++){
                int xi = scanner.nextInt();
                sb.append(String.format("%04d",nums[xi])); //对左上角的不满4位的元素进行格式化
            }
            System.out.println(sb);
        }
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

跳台阶扩展问题

下面是我第一次的做法，它遵循一个规律就是 2的（n-1）次方。

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param number int整型 
     * @return int整型
     */
    public int jumpFloorII (int number) {
        // write code here
        
        return (int)Math.pow(2,number-1);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

看到还有一种解法就是：用二进制0-1来表示跳或者不跳。（第n个台阶必须是1）
求总共有多少种跳法，就是求0-(n-1)位二进制数最大值的个数（从0开始循环到++，每次循环的值都是一种跳法）也就是2的（n-1）次方
2的（n-1）次方 = 1*2的（n-1）次方 = 1<<(n-1) =1<<–n

一行代码就可以解决！！！

public class Solution {
    public int jumpFloorII(int target) {
        return 1<<--target;
    }
}
1
2
3
4
5

快到碗里来

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextDouble()){
            double n = scanner.nextDouble();
            double r = scanner.nextDouble();
            if (n<=(2*r*3.14)){
                System.out.println("Yes");
            }else {
                System.out.println("No");
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这道题看似简单，但是用double来取值可能会存在误差，这里我们使用BigDecimal的方法来完成，非常清晰简单！！！

import java.util.Scanner;
import  java.math.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            BigDecimal n = in.nextBigDecimal();
            BigDecimal r = in.nextBigDecimal();
            BigDecimal len = new BigDecimal("6.28").multiply(r);
            System.out.println(n.compareTo(len)==1?"No":"Yes");

        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16