每日一题 错选择 及 编程题 周总结（三）
目录
- Week3
-
- Day1
-
- 选择题
- 参数解析
- 跳石板
- Day2
-
- 选择题
- 计算日期到天数转换
- 幸运的袋子
- Day3
-
- 选择题
- 查找输入整数二进制中1的个数
- 手套
- Day4
-
- 选择题
- 完全数计算
- 扑克牌大小
- Day5
-
- 选择题
- 杨辉三角形变形
- 超长正整数相加
- Day6
-
- 选择题
- 统计每个兔子的总数
- 字符串通配符
Week3
Day1
选择题
下面有关JVM内存，说法错误的是？
A 程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的
B Java方法执行内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
C 方法区用于存储JVM加载的类信息、常量、静态变量、即时编译器编译后的代码等数据，是线程隔离的
D 原则上讲，所有的对象都在堆区上分配内存，是线程之间共享的
正确答案： C
方法区是线程共享的，C错
以下程序的输出结果是
public class Print{
static boolean out(char c){
System.out.println©;
return true;
}
public static void main(String[] argv){
int i = 0;
for(out(‘A’);out(‘B’) && (i<2);out(‘C’)){
i++;
out(‘D’);
}
}
A ABDCBDCB
B BCDABCD
C 编译错误
D 运行错误
正确答案： A
这里调用函数后都会有boolean返回值，不会发生编译错误
再就是考察for循环的过程
下面关于程序编译说法正确的是（）
A java语言是编译型语言，会把java程序编译成二进制机器指令直接运行
B java编译出来的目标文件与具体操作系统有关
C java在运行时才进行翻译指令
D java编译出来的目标文件，可以运行在任意jvm上
正确答案： C
A:.java编译成的是字节码，再被各系统的jvm翻译成本系统可以识别的机器码，这就是java一次编程多平台应用的跨平台性
B:java源文件生成的是class文件，与系统无关
C:注意字节码和机器码不是一回事 java程序在运行时字节码才会被jvm翻译成机 器码，所以说java是解释性语言
D:注意jvm的版本，好比人穿裤子，一条裤子能被任何人穿上吗
参数解析
方法一：分割字符串
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String s = in.nextLine();
int l = 0;
int r = 0;
boolean symbol = false;
List<String> list = new ArrayList<>();
char[] arr = s.toCharArray();
while (r < arr.length) {if(arr[r] == '/') {
symbol = true;
StringBuilder str = new StringBuilder();
while (l < r) {
str.append(arr[l]);
l++;
}
if(!str.toString().trim().equals("")) {
list.add(str.toString().trim());
}
}
if(arr[r] == ':') {
symbol = true;
StringBuilder str = new StringBuilder();
while (l < r-1) {
str.append(arr[l]);
l++;
}
if(!str.toString().trim().equals("")) {
list.add(str.toString().trim());
}
}
if(arr[r] == '\"') {
symbol = true;
StringBuilder str = new StringBuilder();
while (l < r) {
str.append(arr[l]);
l++;
}
l++;
if(!str.toString().trim().equals("")) {
list.add(str.toString().trim());
}
}
r++;
}
StringBuilder str = new StringBuilder();
while (l < r) {
str.append(arr[l]);
l++;
}
if(!str.toString().trim().equals("")) {
list.add(str.toString().trim());
}
if(symbol) {
System.out.println(list.size());
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}else {
String[] res = s.trim().split(" ");
System.out.println(res.length);
for(int i = 0; i < res.length; i++) {
System.out.println(res[i]);
}
}
}
}
方法二：条件顺序打印
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String str = scanner.nextLine();
int count = 0;
for (int i = 0; i < str.length(); i++) {
if(str.charAt(i) == '"') {
do {
i++;
}while (str.charAt(i) != '"');
}
if (str.charAt(i) == ' ') {
count++;
}
}
System.out.println(count+1);
int font = 1;
for (int i = 0; i < str.length(); i++) {
if(str.charAt(i) == '"') {
font = font^1;
}
if(str.charAt(i) != '"' && str.charAt(i) != ' ') {
System.out.print(str.charAt(i));
}
if(font == 1 && str.charAt(i) == ' ') {
System.out.println();
}
if(font == 0 && str.charAt(i) == ' ') {
System.out.print(' ');
}
}
}
}
跳石板
方法一：动态规划
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int m = scanner.nextInt();
int[] arr = new int[m+1];
//初始化n-m的数据为最大值
for (int i = n; i < arr.length; i++) {
arr[i] = Integer.MAX_VALUE;
}
arr[n] = 0; //初始状态
for (int i = n; i < m; i++) {
//如果没有到达过这个位置，则下一轮循环
if (arr[i] == Integer.MAX_VALUE) {
continue;
}
//list来记录当前石板能跳的所有距离
List<Integer> list = piv(i);
//遍历当前石板所有能跳的距离
for (int j : list) {
//大前提，跳到的石板下标不能超过m，否则数组越界
if(i+j <= m) {
//如果跳到的石板之前没有跳到过，则直接+1
if(arr[i] == Integer.MAX_VALUE) {
arr[i+j] = arr[i] + 1;
}else { //否则就取跳到石板步数最小值
arr[i+j] = Math.min(arr[i+j],arr[i]+1);
}
}
}
}
//最后判断下标为m的石板的最小步数
if(arr[m] == Integer.MAX_VALUE) {
System.out.println(-1);
}else {
System.out.println(arr[m]);
}
}
//用来记录石板下标的所有约数
public static List<Integer> piv(int num) {
List<Integer> list = new ArrayList<>();
//这里只需要遍历到i*i <= num即可，因为两数相乘才得到num，小的乘数找到了，对应的大的乘数则为num/i
for (int i = 2; i*i <= num; i++) {
if(num % i == 0) {
list.add(i);
//这里有可能有i == num/i 的情况，所以只取一次i
if(i != num/i) {
list.add(num/i);
}
}
}
return list;
}
}
方法二：广度优先遍历
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
Queue<Integer> queue = new LinkedList<>();
Map<Integer,Integer> map = new HashMap<>();
map.put(n,0);
queue.add(n);
while (!queue.isEmpty()) {
int head = queue.poll();
if(head == m) {
System.out.println(map.get(head));
return;
}
List<Integer> list = yueNum(head);
for(int i = 0; i < list.size(); i++) {
int sum = head + list.get(i);
if(!map.containsKey(sum) && sum <= m) {
queue.add(sum);
map.put(sum,map.get(head)+1);
}
}
}
System.out.println(-1);
}
public static ArrayList<Integer> yueNum(int n) {
ArrayList<Integer> list = new ArrayList<>();
for (int i = 2; i <= Math.sqrt(n); i++) {
if (n % i == 0) {
list.add(i);
if (n / i != i) {
list.add(n / i);
}
}
}
return list;
}
}
Day2
选择题
____技术是一种可以使音频，视频和其他多媒体信息在 Internet 及 Intranet 上以实时的，无需下载等待的方式进行播放的技术。
A 流媒体
B 多媒体
C 复合媒体
D 音视媒体
正确答案：A
流媒体技术是一种可以使音频，视频和其他多媒体信息在 Internet 及 Intranet 上以实时的，无需下载等待的方式进行播放的技术。
下列语句正确的是：
A 形式参数可被字段修饰符修饰
B 形式参数不可以是对象
C 形式参数为方法被调用时真正被传递的参数
D 形式参数可被视为local variable
正确答案：D
A：形式参数只能被final修饰
B：形式参数可以是对象
C：形式参数被调用时被传递的是实际参数的拷贝
D：local variable：局部变量
给定代码：
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;
}
第三行将输出什么？
A value=6
B value=8
C value=3
D value=5
E value=4
正确答案：B
不加break的话，switch会从第一次进入case语句的地方，一直向下执行完。
计算日期到天数转换
import java.util.*;
public class Main{
public static int iConverDateToDay(int year,int month,int day) {
int[] monthDay = {31,28,31,30,31,30,31,31,30,31,30,31};
int sum = 0;
if(year < 0 || month < 0 || month > 12) {
return -1;
}
if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
monthDay[1] = 29;
}
if(day > monthDay[month-1]) {
return -1;
}
for(int i = 0; i < month-1; i++) {
sum += monthDay[i];
}
sum += day;
return sum;
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);while (in.hasNext()) {
int year = in.nextInt();
int month = in.nextInt();
int day = in.nextInt();
System.out.println(iConverDateToDay(year, month, day));
}
}
}
幸运的袋子
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int[] num = new int[n];
for (int i = 0; i < n; i++) {
num[i] = scanner.nextInt();
}
//排序为了简化流程
Arrays.sort(num);
System.out.println(dfs(num,0,1,0));
}
public static int dfs(int[] num,int sum,int product,int index) {
int count = 0; //幸运袋子个数
//从index位置开始遍历数组
for (int i = index; i < num.length; i++) {
sum += num[i];
product *= num[i];
if (sum > product) { //如果和比积大，则个数加一，并向下递归
count = count + 1 + dfs(num,sum,product,i+1);
}else if(num[i] == 1) { //1特例，因为数字1能提高总和值但不会提高总积值，1的个数越多，和更有可能大于积，所以给它一次机会向下递归，但不+1
count = count + dfs(num,sum,product,i+1);
}else { //如果遇到了大于的情况，则不用向后遍历，因为数组有序，往后肯定越大，不可能再比sum小了
break;
}
//回溯需要把sum和product回溯到上一递归的值。
sum = sum-num[i];
product = product/num[i];
//注意：因为题目说了，拥有相同号码的球是无区别的，所以遇到相同的，往后遍历即可
while (i+1 < num.length && num[i] == num[i+1]) {
i++;
}
}
return count;
}
}
Day3
选择题
用命令方式运行以下代码的运行结果是（）
public class f{
public static void main(String[] args){
String foo1 = args[1];
String foo2 = args[2];
String foo3 = args[3];
}
}
命令: java f a b c
A 程序编译错误
B a b c
C 程序运行错误
D f
正确答案：C
执行的是运行命令java
编译的命令是javac
而且 java f 是运行 f 文件，
真正的参数就是a，b，c，下标对应0，1，2
而题目是arg[1],arg[2],arg[3],显然数组越界
可将语句块或方法设为同步使用的语句是（）
A synchronized
B static
C abstract
D final
正确选项：A
加锁设置同步
以下哪项不属于java类加载过程？
A 生成java.lang.Class对象
B int类型对象成员变量赋予默认值
C 执行static块代码
D 类方法解析
正确选项：B
类加载包括5个阶段：加载，验证，准备，解析，初始化。
A. 生成java.lang.Class对象： 加载阶段
B. int类型对象成员变量赋予默认值：使用阶段（不属于类加载阶段）
C. 执行static块代码：初始化阶段（执行类构造器()方法）
D. 类方法解析：解析阶段
查找输入整数二进制中1的个数
import java.util.*;
public class Main {
public static int findNumberof1(int num) {
int count = 0;
while(num > 0) {
if(num%2 == 1) {
count++;
}
num = num/2;
}
return count;
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()) {int num = in.nextInt();
System.out.println(findNumberof1(num));
}
}
}
手套
import java.util.*;
public class Gloves {
public int minCount(int[] left,int[] right) {
//对应数就是 左数组和右数组下标相同的值 不为0 的数
List<Integer> l = new ArrayList<>(); //用来存放左数组的对应数
int sumL = 0; //左数组的总和
int sumR = 0; //右数组的总和
int sumDuiR = 0; //左对应数和
//遍历数组得到上述所有的值
for(int i = 0; i < left.length; i++) {
if(left[i] != 0 && right[i] != 0) {
l.add(left[i]);
sumDuiR += right[i];
}
sumL += left[i];
sumR += right[i];
}
l.sort(Integer::compareTo);
//左数组总结公式：左数组和 - 对应值最小的数 + 1
int resL = sumL - l.get(0) + 1;
//右数组总结公式：右数组和 - 右对应数和 + 1
int resR = sumR - sumDuiR + 1;
return resL + resR;
}
public int findMinimum(int n, int[] left, int[] right) {
int res1 = minCount(left,right);
int res2 = minCount(right,left);
//交换左右数组进行比较，返回最小的
if(res1 > res2) {
return res2;
}
return res1;
}
}
Day4
选择题
jre 判断程序是否执行结束的标准是（）
A 所有的前台线程执行完毕
B 所有的后台线程执行完毕
C 所有的线程执行完毕
D 和以上都无关
正确选项：A
其实这个题，就是在说守护线程和非守护（用户）线程的问题。后台线程就是守护线程，前台线程就是用户线程。
守护线程：是指在程序运行时在后台提供一种通用服务的线程，这种线程并不是必须的。同时守护线程的线程优先级都很低的。JVM中的GC线程就是一个守护线程，只要JVM启动，GC线程就启动了。
用户线程和守护线程几乎没有什么区别，唯一的区别就在于，如果用户线程都已经退出了，只剩下了守护线程，那么JVM直接就退出了。
如下语句通过算术运算和逻辑运算之后i和 j的结果是（ ）
int i=0;
int j=0;
if((++i>0)||(++j>0)){
//打印出i和j的值。
}
A i=0;j=0
B i=1;j=1
C i=0;j=1
D i=1;j=0
正确答案：B
++i先自增再运算，i++先运算在自增，所以i=1。||短路前一部分不正确就不会继续执行，所以j=0.
instanceof运算符能够用来判断一个对象是否为:
A 一个类的实例
B 一个实现指定接口的类的实例
C 全部正确
D 一个子类的实例
正确答案：C
instance是java的二元运算符，用来判断他左边的对象是否为右面类（接口，抽象类，父类）的实例
完全数计算
import java.util.*;
public class Main {
public static int count(int n) {
int count = 0;
for (int i = 2; i <= n; i++) {
if(i == sum(i)) {
count++;
}
}
return count;
}
public static int sum(int num) {
int sum = 1;
int i;
for (i = 2; i <= Math.sqrt(num); i++) {
if(num%i == 0) {
sum += i;
if(num/i != i) {
sum += num / i;
}
}
}
return sum;
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()) {
int n = in.nextInt();
System.out.println(count(n));
}
}
}
扑克牌大小
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String s = in.nextLine();
String[] both = s.split("-");
String[] left = both[0].split(" ");
String[] right = both[1].split(" ");
//判断比较性
if(left.length != right.length) {
if(left.length != 4 && right.length != 4) {
if(!both[0].equals("joker JOKER") && !both[1].equals("joker JOKER")) {
System.out.println("ERROR");
return;
}
if(both[0].equals("JOKER") && right.length != 1 || both[1].equals("JOKER") && left.length != 1) {
System.out.println("ERROR");
return;
}
if(both[0].equals("joker") && right.length != 1 || both[1].equals("joker") && left.length != 1) {
System.out.println("ERROR");
return;
}
}
}
//个子、对子、顺子、三个、
if(both[0].equals("joker JOKER") || both[1].equals("joker JOKER")) {
System.out.println("joker JOKER");
return;
}
if(left.length == 4 && right.length != 4 || right.length == 4 && left.length != 4) {
if(left.length == 4) {
System.out.println(both[0]);
return;
}else {
System.out.println(both[1]);
return;
}
}
if(both[0].equals("joker") || both[1].equals("joker")) {
System.out.println("joker");
return;
}if(both[0].equals("JOKER") || both[1].equals("JOKER")) {
System.out.println("JOKER");
return;
}
int l = change(left[0]);
int r = change(right[0]);
if(l > r) {
System.out.println(both[0]);
return;
}else {
System.out.println(both[1]);
return;
}
}
public static int change(String num) {
int l = 0;
switch (num) {
case "3":
l = 3;
break;
case "4":
l = 4;
break;
case "5":
l = 5;
break;
case "6":
l = 6;
break;
case "7":
l = 7;
break;
case "8":
l = 8;
break;
case "9":
l = 9;
break;
case "10":
l = 10;
break;
case "J":
l = 11;
break;
case "Q":
l = 12;
break;
case "K":
l = 13;
break;
case "A":
l = 14;
break;
case "2":
l = 15;
break;
}
return l;
}
}
简化
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
String[] pp = str.split("-");
String[] p1 = pp[0].split(" ");
String[] p2 = pp[1].split(" ");
String p = "34567891JQKA2";
if (pp[0].equals("joker JOKER") || pp[1].equals("joker JOKER")) {
System.out.println("joker JOKER");
}else if (p1.length == p2.length) {
if (p.indexOf(p1[0].substring(0,1)) > p.indexOf(p2[0].substring(0,1))) {
System.out.println(pp[0]);
}else {
System.out.println(pp[1]);
}
}else if (p1.length == 4) {
System.out.println(pp[0]);
}else if (p2.length == 4) {
System.out.println(pp[1]);
}else {
System.out.println("ERROR");
}
}
}
Day5
选择题
Java 语言用以下哪个类来把基本类型数据封装为对象（）
A 包装类
B Class
C Math
D Object
正确答案：A
java的数据类型分为两大类：基本类型和引用类型；
基本类型只能保存一些常量数据，引用类型除了可以保存数据，还能提供操作这些数据的功能；
为了操作基本类型的数据，java也对它们进行了封装， 得到八个类，就是java中的基本类型的封装类；他们分别是：
八种基本类型： byte short int long float double char boolean
对应的包装类 ： Byte Short Integer Long Float Double Character Boolean
杨辉三角形变形
import java.util.*;
public class Main {
public static void main(String[] args) {Scanner in = new Scanner(System.in);
while (in.hasNextInt()) {
int n = in.nextInt();
int count = 2*n-1 + 2;
int[] tmp = new int[count];
int[] res = new int[count];
int i = count/2;
res[i] = 1;
int j = 1;
while (j <= n) {
tmp = res.clone();
res[i] = tmp[i] + tmp[i-1] + tmp[i+1];
for(int k = 1; k < j; k++) {
res[i-k] = tmp[i-k] + tmp[i-k-1] + tmp[i-k+1];
res[i+k] = tmp[i+k] + tmp[i+k-1] + tmp[i+k+1];
}
j++;
}
int q;
for(q = 1; q < res.length-1; q++) {
if(res[q]%2 == 0) {
System.out.println(q);
break;
}
}
if (q >= res.length-1){
System.out.println(-1);
}
}
}
}
超长正整数相加
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
String a = in.nextLine();
String b = in.nextLine();
if(a.length() > b.length()) {
StringBuilder s = new StringBuilder();
for(int i = 0; i < a.length()-b.length(); i++) {
s.append('0');
}
b = s.toString() + b;
}else {
StringBuilder s = new StringBuilder();
for(int i = 0; i < b.length()-a.length(); i++) {
s.append('0');
}
a = s.toString() + a;
}
int i = a.length()-1;
int upOne = 0;
char[] res = new char[i+1];
while (i >= 0) {
int c = (int)a.charAt(i)-(int)'0';
int d = (int)b.charAt(i)-(int)'0';
int sum = c+d+upOne;
if(sum >= 10) {
upOne = 1;
}else {
upOne = 0;
}
res[i] = (char) (sum%10+'0');
i--;
}
String s = String.valueOf(res);
if(upOne == 1) {
s = "1" + s;
}
System.out.println(s);
}
}
}
Day6
选择题
考虑下面这个简单的例子，让我们看看reflection是如何工作的。
import java.lang.reflect.*;
public class DumpMethods{
public static void main(String[] args) {
try {
Class c=Class.forName(args[0]);
Method m[]=c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
} catch (Throwable e) {
System.err.println(e);
}
}
}
其中"c.getDeclaredMethods"的作用是:
A 取得类的公有方法对象
B 取得类的所有公有方法名称
C 取得类的所有方法对象
D 以上选项都不正确
正确选项：D
getDeclaredMethods是以数组的方式获得该类所有方法，而不是对象
java 的字符类型采用的是 Unicode 编码方案，每个 Unicode 码占用（）个比特位。
A 8
B 16
C 32
D 64
正确答案：B
占用两个字节，一个字节8个比特位，两个也就是16位
对于一个已经不被任何变量引用的对象，当垃圾回收器准备回收该对象所占用的内存时，将自动调用该对象的哪个方法（）
A finalize
B notify
C notifyAll
D hashCode
正确选项：A
finalize()是Object中的方法，当垃圾回收器将要回收对象所占内存之前被调用，即当一个对象被虚拟机宣告死亡时会先调用它finalize()方法，让此对象处理它生前的最后事情
以下代码输出的是：
public class SendValue{
public String str="6";
public static void main(String[] args) {
SendValue sv=new SendValue();
sv.change(sv.str);
System.out.println(sv.str);
}
public void change(String str) {
str="10";
}
}
A 6
B 10
C 都不对
D 16
- Java 中的基本类型，属于值传递。
- Java 中的引用类型，属于引用传递。
- Java 中的 String及包装类，属于特殊群体，作为形参时，由于每次赋值都相当于重新创建了对象，因此看起来像值传递，但是其特性已经破坏了，值传递、引用传递的定义。因此他们属于引用传递的定义，却表现为值传递。
统计每个兔子的总数
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()) {
int n = in.nextInt();
int a = 1;
int b = 1;
int count = 2;
while(count < n) {
int c = a+b;
a = b;b = c;
count++;
}
System.out.println(b);
}
}
}
字符串通配符
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
String str1 = scanner.nextLine();
String str2 = scanner.nextLine();
//进入递归函数
System.out.println(match(str1,str2,0,0));
}
}
//i为str1指向的位置，j为str2指向的位置
public static boolean match(String str1,String str2,int i,int j) {
//如果i，j刚好都到字符串最后，则true
if(i == str1.length() && j == str2.length()) {
return true;
}
//如果只有一个到达，另一个没到达，则false
if(i == str1.length() || j == str2.length()) {
return false;
}
if(str1.charAt(i) == '?') { //遇到？，则两个指针都往前走一步
return match(str1,str2,i+1,j+1);
}else if (str1.charAt(i) == '*') { //遇到*，可能*代表0个，代表1个，代表多个，依次递归
return match(str1,str2,i+1,j) || match(str1,str2,i+1,j+1) || match(str1,str2,i,j+1);
}else if (str1.charAt(i) == str2.charAt(j)) { //如果i，j下标的字符相同，则继续往后递归
return match(str1,str2,i+1,j+1);
}else { //上面条件都不满足，说明i，j下标字符不相同，则false
return false;
}
}
}