• 刷题笔记之十二(快到碗里来+跳台阶+变态跳台阶+不用加减乘除做加法+三角形+猴子分桃+反转部分单向链表)

    目录

    1. 快到碗里来

    2. 跳台阶

    3. 变态跳台阶

    4. ConcurrentHashMap使用lock关键字保证线程安全;Arrays.asList返回值是List接口对象

    5. 字符串对象比较相等,使用equals比较内容;使用== 比较的是地址

    6. 编译命令: javac 源文件名称.java; 运行命令: java 主类名称 要传递的参数

    7.  int类型对象成员变量赋予默认值是在,对象产生时执行,在类加载之后,不属于类加载过程

    8. 不用加减乘除做加法

    9. 三角形

    10. 猴子分桃

    11. 反转部分单向链表

    12. 当所有前台线程(用户线程)执行完毕,java进程就认为程序全部执行完毕

    13.Serial.parNew.CMS这三个收集器在JDK1的时候就有;G1收集器是在JDK7才出现的

    14. instanceof运算符用于：判断该运算符前面引用类型变量指向的对象是否是后面类，或者其子类、接口实现类创建的对象。

    1. 快到碗里来

    题目链接：快到碗里来__牛客网 (nowcoder.com)

    题目要求：

     题目分析：

    计算机周长:c = 2*3.14*r

    这道题需要注意的是 输入的范围[1,2^128]  

    如果使用int和long的话,都不满足这个范围,

    如果使用double的话,计算会受精度影响(不过这个题对精度问题要求不高也可以使用)

    最好的还是使用BigDecimal

    初始化BigDecimal对象,可以传两种参数

    BigDecimal(String val)        new BigDecimal("3.14");//注意带上双引号

    BigDecimal(double val)    同样不能使用double作为构造参数

    解决了用什么来接收输入的问题,下面就直接就是根据题意比较输出了 

     上代码

    这个是用double来接收的,对于这道题double还是可以的

    1. import java.util.*;
    2. public class Main{
    3.         public static void main(String[] args) {
    4.         Scanner scan = new Scanner(System.in);
    5.         while(scan.hasNext()) {
    6.             double n = scan.nextDouble();
    7.             double r = scan.nextDouble();
    8.             if(n > 2*3.14*r) {//放不进去
    9.                 System.out.println("No");
    10.             }else {
    11.                 System.out.println("Yes");
    12.             }
    13.         }
    14.     }
    15. }

    使用BigDecimal

    1. import java.util.*;
    2. import java.math.*;
    3. public class Main{
    4.         public static void main(String[] args) {
    5.         Scanner scan = new Scanner(System.in);
    6.         while(scan.hasNext()) {
    7.             BigDecimal n = scan.nextBigDecimal();
    8.             BigDecimal r = scan.nextBigDecimal();
    9.             BigDecimal len = new BigDecimal("6.28").multiply(r);
    10.             System.out.println(n.compareTo(len) == 1 ? "No" : "Yes");
    11.         }
    12.     }
    13. }

    2. 跳台阶

    题目链接：跳台阶_牛客题霸_牛客网 (nowcoder.com)

    题目要求：

     题目分析：

    上代码

    1. import java.lang.*;
    2. public class Solution {
    3.     public int jumpFloor(int target) {
    4.         if(target <= 1) {
    5.             return 1;
    6.         }
    7.         int a = 1,b = 1;
    8.         for(int i = 2; i <= target; ++i) {
    9.             int temp = a + b;
    10.             a = b;
    11.             b = temp;
    12.         }
    13.         return b;
    14.     }
    15. }

    3. 变态跳台阶

    题目要求：

    要求时间复杂度和空间复杂度均为O(1) 

     题目分析：

    上代码

    1.     public int jumpFloorII (int number) {
    2.         return (int)Math.pow(2,number-1);
    3.     }
    1.     public int jumpFloorII (int number) {
    2.         return 1 << --number;
    3.     }

    4. ConcurrentHashMap使用lock关键字保证线程安全;Arrays.asList返回值是List接口对象

    在java7中,下列哪个说法是正确的(D)

    A. ConcurrentHashMap使用Synchronized关键字保证线程安全

    B. HashMap实现了Collection接口

    C. Arrays.asList方法返回java.util.ArrayList对象

    D. SimpleDateFormat对象是线程不安全的

    ConcurrentHashMap使用lock关键字保证线程安全  A错

    Collection接口是线性表的顶级接口,HashMap实现的是Map接口    B错

    Arrays.asList返回值是List接口对象    C错

    public static List asList(T..a) {

                return newArrayList<(a)

    }

    5. 字符串对象比较相等,使用equals比较内容;使用== 比较的是地址

    关于以下程序段,正确的说法是:(C)

    String s1 = "abc" + "def";//1

    String s2 = new String(s1);//2

    if(s1.equals(s2))//3

    System.out.println(".equals succeeded");//4

    if(s1 == s2)

    System.out.println("==succeeded");//6 

    A. 行4,行6都不执行

    B. 行6执行,行4不执行

    C. 行4执行,行6不执行

    D. 行4,行6都执行

    字符串对象比较相等,使用equals比较内容

    使用== 比较的是地址   选C

    6. 编译命令: javac 源文件名称.java; 运行命令: java 主类名称 要传递的参数

    用命令方式运行以下代码的运行结果是(C)

     命令: java f a b c

    A. 程序编译错误    B. a b c     C. 程序运行错误      D. f

    编译命令: javac 源文件名称.java

    *.java -> *.class

    运行命令: java 主类名称 要传递的参数(传递给main的args中)

    java f a b c   ------>       args{a,b,c}注意传入三个参数,下标是0-2

    而代码中访问args[3]  很明显数组访问越界,所以是程序运行错误,选C

    7.  int类型对象成员变量赋予默认值是在,对象产生时执行,在类加载之后,不属于类加载过程

    以下哪项不属于java类加载过程    (B)

    A. 生成java.lang.Class对象

    B. int类型对象成员变量赋予默认值

    C. 执行static块代码

    D. 类方法解析

    B选项是,对象产生时执行,在类加载之后,不属于类加载过程

    8. 不用加减乘除做加法

    题目链接：不用加减乘除做加法_牛客题霸_牛客网 (nowcoder.com)

    题目要求：

     题目分析：

     上代码

    1. public class Solution {
    2.     public int Add(int num1,int num2) {
    3.         while(num2 != 0) {
    4.             int sum = num1^num2;
    5.             int carray = (num1&num2) << 1;
    6.             num1 = sum;
    7.             num2 = carray;
    8.         }
    9.         return num1;
    10.     }
    11. }

    9. 三角形

    题目链接：三角形__牛客网 (nowcoder.com)

    题目要求：

     题目分析：

    判断三条边是否可以组成一个三角形

    要么使用"任意两边之和,大于第三边" ;   要么使用"任意两边之差,小于第三边"来进行判断

    但这道题还有个问题时 三个边的长度范围是[1,10^100]

    所以用int 和long来接收这三条边肯定是不可以的

    使用double的话,虽然范围满足了,但又会存在精度丢失的问题(这道题不影响)

    所以要学会使用BigDecimal

    初始化BigDecimal对象,它的构造方法传参有两种

    BigDecimal(String val)          BigDecimal(double val)

    如果需要精度高的BigDecimal,还是不能使用double来作为构造参数

    要传入一个字符串,才可以

    对于BigDecimal做加法: add(BigDecimal)

                                 减法: subtract(BigDecimal)

                                 乘法: multiply(BigDecimal)

                                 除法: divide(BigDecimal)

    上代码(使用double来接收三条边)

    1. import java.util.*;
    2. public class Main {
    3.     public static void main(String[] args) {
    4.         Scanner scan = new Scanner(System.in);
    5.         while(scan.hasNext()) {
    6.             double a = scan.nextDouble();
    7.             double b = scan.nextDouble();
    8.             double c = scan.nextDouble();
    9.             if((a+b) > c && (a+c) > b && (b+c) > a) {
    10.                 System.out.println("Yes");
    11.             }else {
    12.                 System.out.println("No");
    13.             }
    14.         }
    15.     }
    16. }

    使用BigDecimal来接收三条边 

    1. import java.util.*;
    2. import java.math.*;
    3. public class Main {
    4.     public static void main(String[] args) {
    5.         Scanner scan = new Scanner(System.in);
    6.         while(scan.hasNext()) {
    7.             BigDecimal a = scan.nextBigDecimal();
    8.             BigDecimal b = scan.nextBigDecimal();
    9.             BigDecimal c = scan.nextBigDecimal();
    10.             if(a.add(b).compareTo(c)>0 && a.add(c).compareTo(b)>0 && b.add(c).compareTo(a)>0) {
    11.                 System.out.println("Yes");
    12.             }else {
    13.                 System.out.println("No");
    14.             }
    15.         }
    16.     }
    17. }

    10. 猴子分桃

    题目链接：猴子分桃__牛客网 (nowcoder.com)

    题目要求：

    题目分析：

     上代码

    1. import java.util.*;
    2. public class Main{
    3.     public static void main(String[] args) {
    4.         Scanner scan = new Scanner(System.in);
    5.         while(scan.hasNext()) {
    6.         long n = scan.nextLong();
    7.         if(n == 0) {
    8.             break;
    9.         }
    10.         long a = (long)Math.pow(5,n);
    11.         long b = (long)Math.pow(4,n);
    12.         System.out.println((a-4) + " " + (n + b - 4));
    13.         }
    14.     }
    15. }

    11. 反转部分单向链表

    题目链接：反转部分单向链表__牛客网 (nowcoder.com)

    题目要求：

     

    题目分析：

    上代码

    1.  
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.IOException;
    5. import java.io.InputStreamReader;
    6. import java.util.Scanner;
    7.  
    8.  
    9.  
    10. public class Main{
    11.     static class Node {
    12.         int val;
    13.         Node next;
    14.         public Node(int val) {
    15.             this.val = val;
    16.         }
    17.     }
    18.     public static void main(String[] args) throws IOException {
    19.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    20.         int n = Integer.parseInt(br.readLine());
    21.         String[] nodes = br.readLine().trim().split(" ");
    22.         Node dummyHead = new Node(-1);
    23.         Node tail = dummyHead;
    24.         for(int i = 0; i < n; i++ ) {
    25.             //在链表中进行尾插
    26.             Node node = new Node(Integer.parseInt(nodes[i]));
    27.             tail.next = node;
    28.             tail = node;
    29.         }
    30.         String[] part = br.readLine().split(" ");
    31.         int left = Integer.parseInt(part[0]);
    32.         int right = Integer.parseInt(part[1]);
    33.  
    34. //        Scanner scan = new Scanner(System.in);
    35. //        int n = scan.nextInt();
    36. //        //去除掉nextInt后面的 \n
    37. //        scan.nextLine();
    38. //        //"1 2 3 4"
    39. //        String nodeValue = scan.nextLine();
    40. //        String[] nodes = nodeValue.split(" ");
    41. //        //创建虚拟头结点
    42. //        Node dummyHead = new Node(-1);
    43. //        Node tail = dummyHead;
    44. //        for(int i = 0; i < n; i++ ) {
    45. //            //在链表中进行尾插
    46. //            Node node = new Node(Integer.parseInt(nodes[i]));
    47. //            tail.next = node;
    48. //            tail = node;
    49. //        }
    50. //        //输入左右反转区间
    51. //        String part = scan.nextLine();
    52. //        int left = Integer.parseInt(part.split(" ")[0]);
    53. //        int right = Integer.parseInt(part.split(" ")[1]);
    54.  
    55.         Node newHead = reversepartList(dummyHead.next,left,right);
    56.         //进行打印
    57.         while(newHead != null) {
    58.             System.out.print(newHead.val + " ");
    59.             newHead = newHead.next;
    60.         }
    61.     }
    62.  
    63.     private static Node reversepartList(Node head, int left, int right) {
    64.         Node dummyHead = new Node(-1);
    65.         dummyHead.next = head;
    66.         Node prev = dummyHead;
    67.         //走到left的前一个位置
    68.         for(int i = 0; i < left-1; i++) {
    69.             prev = prev.next;
    70.         }
    71.         //保存prev的下一个位置,进行头插
    72.         Node cur = prev.next;
    73.         for(int i = left; i < right; i++) {
    74.             //保存cur的下一个节点
    75.             Node node = cur.next;
    76.             //断开cur和node的连接
    77.             cur.next = node.next;
    78.             //再把node结点插入到prev之后
    79.             node.next = prev.next;
    80.             prev.next = node;
    81.         }
    82.         return dummyHead.next;
    83.     }
    84. }
    85.

    12. 当所有前台线程(用户线程)执行完毕,java进程就认为程序全部执行完毕

    jre判断程序是否执行结束的标准是 ( A )

    A. 所有的前台线程执行完毕

    B. 所有的后台线程执行完毕

    C. 所有的线程执行完毕

    D. 和以上都无关

    JRE: java运行时环境

    JDK: java开发工具包,包含了JRE

    当所有前台线程(用户线程)执行完毕,java进程就认为程序全部执行完毕

    setDameon(true)   一般我们创建的线程都是前台线程

    后台线程: JVM垃圾回收机制     所以答案选A

    13.Serial.parNew.CMS这三个收集器在JDK1的时候就有;G1收集器是在JDK7才出现的

    下列哪项不属于jdk1.6垃圾收集器 (D)

    A. Serial收集器      B. parNew收集器      C. CMS收集器       D. G1收集器

    Serial.parNew.CMS这三个收集器在JDK1的时候就有了

    而G1收集器是在JDK7才出现的,所以选D

    14. instanceof运算符用于：判断该运算符前面引用类型变量指向的对象是否是后面类，或者其子类、接口实现类创建的对象。

    instanceof运算符能够用来判断一个对象是否为:   (C)

    A. 一个类的实例        B. 一个实现指定接口的类的实例

    C. 全部正确               D. 一个子类的实例

    instanceof 运算符用于：判断该运算符前面引用类型变量指向的对象是否是后面类，或者其子类、接口实现类创建的对象。如果是则返回true，否则返回false，

    使用方法

    引用类型变量 instanceof （类、抽象类或接口）   所以答案选C

  • 相关阅读:
    Spring依赖注入之@autowire注解详解
    计算机网络-第4章 网络层
    【菜鸡读论文】Learning-based Video Motion Magnification
    预约挂号系统技术点详解(一)
    基于语义分割的相机外参标定
    centos7安装Nginx
    `算法知识` 欧拉定理, 费马小定理
    2022-09-20 mysql列存储引擎-POC-调用自定义函数-参数赋值
    OpenAI 推出ChatGPT Edu，为高校定制版本
    人工智能聊天机器人如何满足企业和客户不断变化的需求？
  • 原文地址：https://blog.csdn.net/m0_58761900/article/details/127859672