Java-笔试强训（Day1~12）牛客刷题带链接

已于 2024-07-13 18:33:33 修改
阅读量1.4k 收藏 10
点赞数 26
分类专栏： 笔试强训 文章标签： java 算法
于 2024-07-12 20:55:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73456341/article/details/134527147
版权

目录

Day1（JavaSE语法）

1.组队竞赛(数组.循环.公式总结)

2.删除公共字符(哈希思想)

Day2（JavaSE语法）

3.排序子序列(数组，条件循环，计数器)

4.倒置字符串(方法，循环)

Day3（JavaSE语法）

5.字符串中找出连续最长的数字串（定义两个空字符串）

6.数组中出现次数超过一半的数字（循环）（排序）（两两相消）

Day4（JavaSE语法）

7.计算糖果

8.进制转换

Day5（JavaSE语法）

9.统计回文

10.连续子数组最大和

Day6（JavaSE语法）

11.不要二

12.把字符串转换成整数

Day7（JavaSE语法）

13.合法括号序列判断

14.Fibonacci数列(循环)

Day8（JavaSE语法）

15.两种排序方法

16.求最小公倍数

求最小公倍数

Day9（JavaSE语法）

17.另类加法

18.走方格的方案数(求路径总数)

Day10（JavaSE语法）

19.井字棋

20.密码强度等级

Day11（JavaSE语法）

21.最近公共祖先

22.最大连续bit数

Day12（JavaSE语法）

23.二进制插入

24.查找组成一个偶数最接近的两个素数

 

大家好，我是普通一本的在校大学生一枚，目前在学习java。之前也学了一段时间，本人现在已经大二结束了，开学就大三了，时间过的真的很快。我会利用好这个暑假，来复习之前学过的内容，并整理好之前写过的博客进行发布。如果博客中有错误或者没有读懂的地方。热烈欢迎大家在评论区进行讨论！！！
望支持！！！！！！

哈喽，大家好，这个板块用来记录我做过的笔试题，以及编程题。我会把每一次训练过的算法编程题记录在这个专栏中,里面也记录着我的每道题的做题思路！！！大家一起努力呀！！！

语言只是工具，不能决定你好不好找工作，决定你好不好找工作的是你的能力！！！！！

学历本科及以上就够用了！！！！！！！！！！！！！！！！！！！！！！！！！！！！

Day1（JavaSE语法）

 1.

Character：是字符的包装类

String：是字符串类型，可以存放字符串常量 例如：String s = “hello word!”;故选B

StringBuffer：是字符串类型，但是不能存放字符串常量。需要new一个对象才可以存放。

Vector：是一个集合类。也不能直接存放字符串常量。

2.

构成方法重写的条件：

1）.必须要有继承关系。

2）.重写只能出现在子类中,如果没有继承关系,不存在重写,只存在重载。

3）.在子类中被重写的方法,必须和父类中的方法一致,相同的方法名,返回值类型,参数列表。

4.子类方法访问权限不能小于父类方法的访问权限。（故选D）

记忆Tips：

重载：两同一不同一无关（同类、同方法名）、（不同参数列表）、（返回值类型无关）
重写：三同一继承（同方法名，同参数列表，同返回值类型）、（有继承的父与子类）

3.

面向对象设计方法的主要特征：封装，继承，多态，组合。

结构化程序设计原则：模块化，自顶向下，逐步求精。

4.

成员变量如果没有初始化，默认是零。

6.

程序运行起来是在JVM上的，

JVM有五个区：Java虚拟机栈，本地方法栈，堆区，方法区，程序计数器。

10.

C选项

用类名去访问。除非这个方法是静态方法才可以。而很明显这个方法不是静态方法，因此C选项是错误的

1.组队竞赛(数组.循环.公式总结)

组队竞赛（数组，循环，公式总结）

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] arr = new int[3*n];
        long sum = 0;
        for(int i = 0 ; i<arr.length;i++){
            arr[i] = in.nextInt();
        }
        Arrays.sort(arr);
        for(int i = 0; i < n ; i++){
            sum+=arr[arr.length-2*(i+1)];
        }
        System.out.println(sum);
    }
}

核心公式为arr.length-2*(i+1)。

题目意在给一组3*n的数据，让你分为n组，每组3人。每人都有对应的水平值。

每组的水平值为组内每个人水平值的中位数。

并求出如何分组使得每组水平值的和最大。

将这3*n个数据进行从小到大排序。则从后往前，第偶数个数据（有几组数几个）之和，就是所求分组水平值最大和。

2.删除公共字符(哈希思想)

删除公共字符

思路：
1.利用哈希的思想，遍历第二个字符串的每一个字符，将字母放入map中
2.遍历第一个字符串，如果在对应的map中没找到对应的字母，那么就输出。

import java.util.*;
/**
思路：
1.利用哈希的思想，遍历第二个字符串的每一个字符，将字母放入map中
2.遍历第一个字符串，如果在对应的map中没找到对应的字母，那么就输出。
 */
public class Main {  
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String str1 = scan.nextLine();//They are students.
        String str2 = scan.nextLine();//aeiou
        HashMap<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < str2.length(); i++) {
            if (map.get(str2.charAt(i)) == null) {
                map.put(str2.charAt(i), 1);
            } else {
                map.put(str2.charAt(i), map.get(str2.charAt(i)) + 1);
            }
        }
        String ret = "";
        for (int i = 0; i < str1.length(); i++) {
            if (map.get(str1.charAt(i)) == null) {
                ret += str1.charAt(i);
            }
        }
        System.out.println(ret);
    }
}

Day2（JavaSE语法）

1.

可以用父类类型来实例化子类对象。实现子类对象的向上转型。

间接父类也可以。

2.

若给函数传入admin。.toLowerCase后比较，由于本身都是小写，因此没有产生新的对象结果就为true。

但是题目中的是Admin。通过.toLowerCase转换成小写了，不是在它本身上修改。此时新建了一个对象。此时对象和常量比较因此得false。

3.

由于hello是静态方法，也就是类方法，在类加载时产生，不依赖于对象。虽然题目中用空对象去引用了，但也没关系。可以编译通过。

4.

  • super()；用于调用父类的构造方法。
  • this()；用于在同一类中调用其他构造方法。
  • 两者都必须放在构造方法中的第一行。

例如：

public class Example extends ParentClass {
    private int value;

    // 子类构造方法
    public Example() {
        super(); // 调用父类构造方法，必须是第一行
        // 子类构造逻辑
    }

    // 同类其他构造方法
    public Example(int value) {
        this(); // 调用同类中的无参构造方法，必须是第一行
        this.value = value;
        // 其他构造逻辑
    }
}

5.

new Alpha();时。没写super会默认调用父类无参的构造方法因此此时会打印出base

new Base();时。也会打印base，没有换行，因此是basebase。

6.

方法中不能包含静态成员变量。它是属于类的，放在方法中的话那么就是属于方法的。因此不能方法方法中。

static在定义变量的时候，不能定义局部变量。一定是成员变量才行。也就是静态成员变量。

static定义的变量属于类的。不能放在方法中，即使是静态方法。

7.

A、abstract不能修饰字段（成员变量）

B、C、D、抽象方法不能加{}。加了反而是具体的实现了，反而就错了

8.

A、可以省略，默认提供一个不带参数的构造方法。

B、方法可以和class同名

C、正确

D、可以进行重载，因此是多个

9.

A、构成方法的重载，可以。因此A正确。

B、成员变量的计算必须放在方法里面进行

C、没有花括号，又不是抽象方法

D、是抽象方法，不能有花括号。

10.

接口用public修饰。

3.排序子序列(数组，条件循环，计数器)

思路：
1.读入整数n，创建大小为n+1的整型数组
2.有3中情况arr[i]>arr[i+1],时i++，当不大于时count++，i++
3.arr[i]=arr[i+1]，i++，count不用++
4.arr[i]<arr[i+1]，当不小于时count++，i++
5.最后要注意，在遍历到最后一个元素时i+1会越界，
并且若最后一个元素是0时不影响结果，因为大条件下i<n,比较完就会直接跳出循环了
因此要创建大小为i+1的数组。

import java.util.Scanner;
/**
思路：
1.读入整数n，创建大小为n+1的整型数组
2.有3中情况arr[i]>arr[i+1],时i++，当不大于时count++，i++
3.arr[i]=arr[i+1]，i++，count不用++
4.arr[i]<arr[i+1]，当不小于时count++，i++
5.最后要注意，在遍历到最后一个元素时i+1会越界，
并且若最后一个元素是0时不影响结果，因为大条件下i<n,比较完就会直接跳出循环了
因此要创建大小为i+1的数组。
 */
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main{
       public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int[] arr = new int[n+1];
        int count = 0;
        
        for(int i = 0; i<n; i++){
            arr[i] = scan.nextInt();
        }

        int i = 0;
        while(i<n){
            if(arr[i]<arr[i+1]){
                while(i<n && arr[i]<arr[i+1]){
                i++;
                }
                i++;
                count++;
            }else if(arr[i]==arr[i+1]){
                i++;
            }else{
                if(arr[i]>arr[i+1]){
                    while(i<n && arr[i]>arr[i+1]){
                    i++;
                    }
                count++;
                i++;
                }
            }
        }
        System.out.println(count);
    }
}

4.倒置字符串(方法，循环)

思路：（注意：StringBuffer和StringBuilder的reverse方法是不能传参数的）

1.整体进行逆置

2.每个单词进行逆置

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        char[] arr = str.toCharArray();
        int begin = 0;
        int end = arr.length;
        reverse(arr, begin, end - 1);
        int i = 0;
        while (i < end) {
            int j = i;
            while (j < end && arr[j] != ' ') {
                j++;
            }

            if (j < end) {
                reverse(arr, i, j - 1);
                i = j + 1;
            } else {
                reverse(arr, i, j - 1);
                i = j;
            }
        }
        String string = new String(arr);
        System.out.println(string);
    }

    public static void reverse(char[] arr, int begin, int end) {
        while (begin < end) {
            char temp = arr[begin];
            arr[begin] = arr[end];
            arr[end] = temp;
            begin++;
            end--;
        }
    }
}

Day3（JavaSE语法）

5.字符串中找出连续最长的数字串（定义两个空字符串）

思路：
创建两个空字符串，cur和ret。cur用来存所有数字字符串，ret用来返回最终结果

判断cur和ret的长度。若cur.length();>ret.length(); ret = cur。   
数字字符串的判断ch>='0' && ch <='9'

import java.util.Scanner;

/**
思路：
创建两个空字符串，cur和ret。cur用来存所有数字字符串，ret用来返回最终结果
数字字符串的判断ch>='0' && ch <='9'
 */

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine(); 
        String cur ="";
        String ret ="";
        for(int i = 0; i < str.length(); i++){
            char ch = str.charAt(i);
            if(ch>='0' && ch <='9'){
                cur =cur + ch+"";
                if(cur.length()>ret.length()){
                    ret = cur;
                }
            }else{
                cur = "";
            }
        }
        System.out.println(ret);
    }
}

6.数组中出现次数超过一半的数字（循环）（排序）（两两相消）

思路1：1.首先对数组进行排序
             2.若有众数，则最中间的数字为众数。
 思路2：1.两两相比，若两数不同则消去。相同则留下。则最终剩余的数为众数。

import java.util.*;
//        思路1：1.首先对数组进行排序
//              2.若有众数，则最中间的数字为众数。
//        思路2：1.两两相比，若两数不同则消去。相同则留下。则最终剩余的数为众数。

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param numbers int整型一维数组 
     * @return int整型
     */
    public int MoreThanHalfNum_Solution (int[] numbers) {
        // write code here
        if(numbers == null ||numbers.length == 0){
            return 0;
        }
        int result = numbers[0];
        int times = 1;
        for(int i = 1; i<numbers.length;i++){
            if(times != 0){
                if(result != numbers[i]){
                    --times;
                }else{
                    ++times;
                }
            }else{
                result = numbers[i];
                times = 1;
            }
        }
        int count = 0;
        for(int i = 0;i<numbers.length;i++){
            if(numbers[i] == result){
                count++;
            }
        }
        if(count>numbers.length/2){
            return result;
        }else{
            return 0;
        }
    }
}

Day4（JavaSE语法）

7.计算糖果

思路：

进行数学计算，通过A - B，B - C，A + B，B + C 这四个表达式。三个未知数
分别求出A B C的值，要知道，B有两种算法，
若两种算法得出来的B不一样，那么输出No
若一样，则分别输出A B C

import java.util.Scanner;

/**
思路：进行数学计算，通过A - B，B - C，A + B，B + C 这四个表达式。三个未知数
分别求出A B C的值，要知道，B有两种算法，
若两种算法得出来的B不一样，那么输出No
若一样，则分别输出A B C
 */
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int a = in.nextInt();
        int b = in.nextInt();
        int c = in.nextInt();
        int d = in.nextInt();
        int A = (a+c)/2;
        int B1 = (b+d)/2;
        int B2 = (c-a)/2;
        int C = (d-b)/2;
        if(B1 == B2){
        System.out.println(A+" "+B1+" "+C);
        }else{
            System.out.println("No");
        }

    }
}

8.进制转换

思路，进制转换，
（M%N）用十进制数M 模 进制数N。得到余数 为N进制数的末位
（M/N）可以将M缩小。（M%N）又会再次得到新进制数的倒数第二位数，循环往复。

import java.util.Scanner;

/**
思路，进制转换，
（M%N）用十进制数M 模 进制数N。得到余数 为N进制数的末位
（M/N）可以将M缩小。（M%N）又会再次得到新进制数的倒数第二位数，循环往复。
 */
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int m = in.nextInt();
        int n = in.nextInt();
        String table = "0123456789ABCDEF";
        StringBuilder s = new StringBuilder();
        boolean flag = false;
        if(m == 0){
            System.out.println("0");
            return;
        }
        if (m < 0) {
            m = -m;
            flag = true;
        }

        while (m != 0) {
            s.append(table.charAt(m % n));
            m = m / n;
        }
        if (flag == true) {
            s.append("-");
        }
        s.reverse();
        System.out.println(s);

    }
}

Day5（JavaSE语法）

9.统计回文

StringBuffer这个字符串类型，没有equals函数。需要toString后再调用equals方法比较

StringBuffer 需要new一个对象才可以存放。

判断回文的方法：

1.专门写一个函数来判断

2.逆置。再与原字符比较，如果相同则是回文。

import java.util.Scanner;

/**
思路：
1.插入到合适的位置
2.判断是否是回文
 */
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String A = in.nextLine();
        String B = in.nextLine();
        int len = A.length();

        int count =0;

        for(int i = 0; i <= len; i++){
            StringBuffer str = new StringBuffer(A);
            str.insert(i,B);
            StringBuffer temp = new StringBuffer(str);
            temp.reverse();
            if(temp.toString().equals(str.toString())){
                count++;
            }
        }
        System.out.println(count);
    }
}

10.连续子数组最大和

思路：
1.具有动态规划思想。

max(dp[i]) = getMax(max(dp[i-1])+arr[i],arr[i])
dp[i]以i结尾的子数组。  max(dp[i])以i结尾的子数组的最大和。
2.从i=1开始求连续子数组的最大和。
比较dp[i-1]+arr[i] 和 arr[i]的大小。 记为sum。 谁大谁就是此时的 max(dp[i])
别忘了arr[0]也可能是最大的，因此还需要和arr[0]来比较
则令 int max = arr[0]; 再将之与sum作比较。 若sum大，则max＝sum
最终max就为 连续子数组最大和 max(dp[i]) 。
 

import java.util.*;
/**
思路：
1.具有动态规划思想。max(dp[i]) = getMax(max(dp[i-1])+arr[i],arr[i])
                  dp[i]以i结尾的子数组。  max(dp[i])以i结尾的子数组的最大和。
2.从i=1开始求连续子数组的最大和。
比较dp[i-1]+arr[i] 和 arr[i]的大小。 记为sum。 谁大谁就是此时的 max(dp[i])
别忘了arr[0]也可能是最大的，因此还需要和arr[0]来比较
则令 int max = arr[0]; 再将之与sum作比较。 若sum大，则max＝sum
最终max就为 连续子数组最大和 max(dp[i]) 。
 */
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int size =in.nextInt();
        int[] arr = new int[size];

        for(int i = 0; i < size; i++){
            arr[i] = in.nextInt();
        }

        int sum = arr[0];
        int max = arr[0];

        for(int i = 1; i<size; i++){
            sum = Math.max(sum+arr[i],arr[i]);
            if(sum>max){
                max = sum;
            }
        }
        System.out.println(max);
    }
}

Day6（JavaSE语法）

11.不要二

思路：
1.遇到本题不要慌，本题可以看作一道数学题
2.可将欧几里得距离平方后求解
 解得
  当x1 = x2 时。 y1 = y2 + 2；
  当y1 = y2 时。 x1 = x2 + 2；
  也就是说在arr[i][j]位置上放了蛋糕那么在arr[i+2][j]和arr[i][j+2]就不能放了
3.这里要防止数组越界，

也就是分别加一个i + 2 < W。j + 2 < H。的条件。

import java.util.Scanner;

/**
思路：
遇到本题不要慌，本题可以看作一道数学题
可将欧几里得距离平方后求解
解得
当x1 = x2 时。 y1 = y2 + 2；
当y1 = y2 时。 x1 = x2 + 2；
也就是说在arr[i][j]位置上放了蛋糕那么在arr[i+2][j]和arr[i][j+2]就不能放了
这里要防止数组越界，也就是加一个i + 2 < W。j + 2 < H。的条件。
 */
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int W = in.nextInt();
        int H = in.nextInt();
        int[][] arr = new int[W][H];
        int count = 0;

        for (int i = 0; i < W; i++) {
            for (int j = 0; j < H; j++) {
                if (arr[i][j] == 0) {
                    count++;
                    if (i + 2 < W) {
                        arr[i + 2][j] = 1;
                    }
                    if (j + 2 < H) {
                        arr[i][j + 2] = 1;
                    }
                }

            }
        }
        System.out.println(count);
    }
}

12.把字符串转换成整数

思路：

1.首先判断字符串是否为null或者长度为0，若不为

2. 判断字符串首位元素是否为正负号。若为正令flag=1，若为负令flag=-1。并令首元素为0，不影响后续公式sum = sum*10 + ch[i]-'0'; 。          来记录正负号
3.若首位不是正负号则直接遍历字符串，判断元素是否ch[i]<'0' || ch[i]>'9'。若是则return0；若不是则利用公式sum = sum*10 + ch[i]-'0' 来累加字符串的数。

（由于字符串本质是一个用final修饰的value数组。不可被修改，令首元素为0。
因此我们需要将字符串转字符数组。）
再利用公式sum = sum*10 + ch[i]-'0';
将字符串转为整数。

import java.util.*;

/**
思路：
由于字符串本质是一个用final修饰的value数组。不可被修改
因此我们需要将字符串转字符数组。
再利用公式sum = sum*10 + ch[i]-'0';
将字符串转为整数。
 */
public class Solution {
    public int StrToInt(String str) {
        if(str == null || str.length() ==0){
            return 0;
        }
        char[] ch = str.toCharArray();
        //判断整数是正书还是负数
        int flag = 1;
        if(ch[0] == '+'){
            flag = 1;
            ch[0] = '0';
        }
        if(ch[0] == '-'){
            flag = -1;
            ch[0] = '0';
        }

        int sum = 0; 

        for(int i = 0;i<ch.length; i++){
            if(ch[i]<'0' || ch[i]>'9'){
                return 0;
            }
            sum = sum*10 + ch[i]-'0';
        }
        return sum*flag;
    }
}

Day7（JavaSE语法）

13.合法括号序列判断

思路：
1.用栈结构实现，栈中存放左括号，
2.当遇到右括号之后，检查栈中是否有左括号，
3.如果有则出栈，如果没有，则说明不匹配。
（在遇到左括号时要判断栈是否为空，为空则返回false）

import java.util.*;
/**思路：
用栈结构实现，栈中存放左括号，
当遇到右括号之后，检查栈中是否有左括号，
如果有则出栈，如果没有，
则说明不匹配。
（在遇到左括号时要判断栈是否为空，为空则返回false）
 */
public class Parenthesis {
    public boolean chkParenthesis(String A, int n) {
//如果n不为偶数则返回false
        if(n%2 != 0){    
            return false;
        }
//如果n为偶数
//创建栈
        Stack<Character> stack = new Stack<>();
        for(int i = 0; i<n; i++){
            char ch = A.charAt(i);
            if(ch == '('){
                stack.push(ch);
            }
            else if(ch == ')'){  //在遇到左括号时要判断栈是否为空，为空则返回false
                if(stack.empty()){
                    return false;
                }
                if(stack.peek() == '('){
                stack.pop();
                }
            }
            else{
                return false;
            }
        }
        return stack.empty();

    }
}

14.Fibonacci数列(循环)

思路：

1.利用循环求出斐波那契数

  f3 = f1+f2;
  f1 = f2;
  f2 = f3;

2.记left = f1，为＜N的斐波那契数

   记right = f2，为≥N的斐波那契数

3.最终返回step = Math.min(N-left,right-N); 两者的最小值

import java.util.*;
/**思路：

1.利用循环求出斐波那契数

  f3 = f1+f2;
  f1 = f2;
  f2 = f3;

2.记left = f1，为＜N的斐波那契数

   记right = f2，为≥N的斐波那契数

3.最终返回step = Math.min(N-left,right-N); 两者的最小值*/
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        int f1 = 0;
        int f2 = 1;
        int f3 = 0;
        while(f2<N){
            f3 = f1+f2;
            f1 = f2;
            f2 = f3;
        }
        int left = f1;
        int right = f2;
        int step = Math.min(N-left,right-N);
        System.out.println(step);
    }
}

Day8（JavaSE语法）

15.两种排序方法

思路：
BufferedReader 由于输入的字符串很多 为了提高读取效率，给它缓冲一下，我们使用BufferedReader类
1.利用BufferedReader来输入。从字符流中读取文本并缓存
new InputStreamReader(System.in) 将字节流转换成字符流
Integer.parseInt(bi.readLine());  将字符串类型转换成整型
2.创建两个返回值为boolen的方法，一个方法用compareTo方法来比较两字符串的字典排序
另一个方法用.length();来获取字符串长度比较字符串长度
3.利用if条件来输出对应的字符串

import java.util.*;
import java.io.*;
/**
思路：
BufferedReader 由于输入的字符串很多 为了提高读取效率，给它缓冲一下，我们使用BufferedReader类
1.利用BufferedReader来输入。从字符流中读取文本并缓存
new InputStreamReader(System.in) 将字节流转换成字符流
Integer.parseInt(bi.readLine());  将字符串类型转换成整型
2.创建两个返回值为boolen的方法，一个方法用compareTo方法来比较两字符串的字典排序
另一个方法用.length();来获取字符串长度比较字符串长度
3.利用if条件来输出对应的字符串
 */
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException{
        BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));   
        int n = Integer.parseInt(bi.readLine());  
        String[] str = new String[n];

        for(int i = 0; i < n; i++){
            str[i] = bi.readLine();
        }   

        if(isSortLength(str) && isSortZiDian(str)){
            System.out.println("both");
        }
        else if(isSortLength(str)){
            System.out.println("lengths");
        }
        else if(isSortZiDian(str)){
            System.out.println("lexicographically");
        }
        else{
            System.out.println("none");
        }
    }

    public static boolean isSortZiDian(String[] str){
        for(int i = 0; i<str.length-1;i++){
            if(str[i].compareTo(str[i+1])>0){
                return false;
            }
        }
        return true;
    }    

    public static boolean isSortLength(String[] str){
        for(int i = 0; i<str.length-1;i++){
            if(str[i].length()>str[i+1].length()){
                return false;
            }
        }
        return true;
    }
}

16.求最小公倍数

1.利用循环i叠减求最大公约数
2.在用m*n/最大公约数 求出最小公倍数

import java.util.Scanner;
/**
思路：
1.利用循环i叠减求最大公约数
2.在用m*n/最大公约数 求出最小公倍数
 */
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int m = in.nextInt();
        int n = in.nextInt();
        if(m<n){
            int temp = n;
            n = m;
            m = temp;
        }
        int GCD = 0;
        for(int i = m; i>=1;i--){
            if(m%i==0 && n%i == 0){
                GCD = i;
                break;
            }
        }
        System.out.println(m*n/GCD);
    }
}

思路：

1.利用辗转相除法求最大公约数
2.在用m*n/最大公约数 求出最小公倍数

import java.util.Scanner;
/**
思路：
1.利用辗转相除法求最大公约数
2.在用m*n/最大公约数 求出最小公倍数
 */
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int m = in.nextInt();
        int n = in.nextInt();
        int GCD = GCD(m,n);
        System.out.println(m*n/GCD);
    }
    public static int GCD(int m,int n){
        int r = 0;
        if(m == n){
            return m;
        }
        if(m<n){
            int temp = n;
            n = m;
            m = temp;
        }
        while((r = m%n) > 0){
            m = n;
            n = r;
        }
        return n;
    }
}

求最小公倍数

Day9（JavaSE语法）

17.另类加法

1.如果在二进制中，如果A & B = 0，两数相加不进位，那么sum = A+B= A^B

2.如果A & B != 0,两数相加考虑进位。那么 (A & B)<<1 之后再^sum

3.直到(A & B)<<1 = 0时,也就是A & B = 0时，sum = A + B = A ^ B;

import java.util.*;
/**
思路：
1.如果在二进制中，如果A & B = 0，两数相加不进位，那么sum = A+B= A^B
2.如果A & B != 0,两数相加考虑进位。那么 (A & B)<<1 之后再^sum
3.直到(A & B)<<1 = 0时,也就是A & B = 0时，sum = A + B = A ^ B;
 */
public class UnusualAdd {
    public int addAB(int A, int B) {
        if(B == 0){
            return A;
        }
        int sum = 0;

        while(B != 0){
            sum = A ^ B;
            B = (A&B)<<1;
            A = sum;
        }
        return A;
    }
}

18.走方格的方案数(求路径总数)

思路：
1.如果n = 1 && m = 1;那么方案数为n+m
2.如果((n == 1 && m >= 1) ||(n >= 1 && m == 1))，那么方案数为n+m
3.如果n > 1 && m > 1,
那么方案数为(n-1行，m列方格的方案数)+(n行，m-1列方格的方案数)的和

import java.util.Scanner;
/**
思路：
1.如果n = 1 && m = 1;那么方案数为n+m
2.如果((n == 1 && m >= 1) ||(n >= 1 && m == 1))，那么方案数为n+m
3.如果n > 1 && m > 1,
那么方案数为(n-1行，m列方格的方案数)+(n行，m-1列方格的方案数)的和
 */
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int n = in.nextInt();
        int m = in.nextInt();

        int route = route(n,m);
        System.out.println(route);
    }

    public static int route(int n, int m){
        if((n == 1 && m >= 1) ||(n >= 1 && m == 1)){
            return n+m;
        }
        return route((n-1),m)+route(n,(m-1));
    }
}

Day10（JavaSE语法）

19.井字棋

思路：
1.由于玩家胜的数字为1，那么如果行/列/主对角线/副对角线加起来为 board.length 那么玩家胜利
2.检查行是否加起来为 board.length。两个for双循环累加board[i][j]即可
3.检查列是否加起来为 board.length。两个for双循环累加board[j][i]即可。注意i和j互换
4.检查主对角线双循环累加board[i][i]即可
5.检查副对角线双循环累加board[i][board[j][i]-1-i]即可
若sum为board[j][i]返回true
最终返回false

import java.util.*;
/**
思路：
1.由于玩家胜的数字为1，那么如果行/列/主对角线/副对角线加起来为 board.length 那么玩家胜利
2.检查行是否加起来为 board.length。两个for双循环累加board[i][j]即可
3.检查列是否加起来为 board.length。两个for双循环累加board[j][i]即可。注意i和j互换
4.检查主对角线双循环累加board[i][i]即可
5.检查副对角线双循环累加board[i][board[j][i]-1-i]即可
若sum为board[j][i]返回true
最终返回false
 */
public class Board {
    public boolean checkWon(int[][] board) {
        // write code here
        int N = board.length;
        int sum = 0;
        int i = 0;
        int j = 0;
//检查行
        for (i = 0; i < N; i++) {
            for (j = 0; j < N; j++) {
                sum += board[i][j];
            }
            if (sum == N) {
                return true;
            }
//检查列
        }
        for (i = 0; i < N; i++) {
            for (j = 0; j < N; j++) {
                sum += board[j][i];
            }
            if (sum == N) {
                return true;
            }
        }
//检查主对角线
        for (i = 0; i < N; i++) {
            sum += board[i][i];
            if (sum == N) {
                return true;
            }
        }

//检查副对角线
        for (i = 0; i < N; i++) {
            sum += board[i][N-1-i];
            if (sum == N) {
                return true;
            }
        }
        return false;
    }
}

20.密码强度等级

思路：

1.即对于长度，字母，数字，符号单独判断，最后把所有的单项值根据题目要求相加，输出对应的安全级别。
2.得到长度分数方法就不说了很简单，
3.得到字母方法分数的函数要注意小写字母为97-122，大写字母为65-90
4.得到数字分数的方法我们可以遍历字符串后用每个字符减去'0'如果为0-9之间那么就有数字
5.对于符号，若非字母，非数字那么就为符号。
6.对于奖励先判断大小写字母，数字符号。再判断字母数字符号，再判断字母数字。
7.最终定义sum。将对应的sum1，sum2，sum3，sum4，奖励部分可以单独用sum判读，加起来。
8.得到最终分数之后就可以输出对应等级

import java.util.Scanner;
import java.io.*;
/**
思路：
1.即对于长度，字母，数字，符号单独判断，最后把所有的单项值根据题目要求相加，输出对应的安全级别。
2.得到长度分数方法就不说了很简单，
3.得到字母方法分数的函数要注意小写字母为97-122，大写字母为65-90
4.得到数字分数的方法我们可以遍历字符串后用每个字符减去'0'如果为0-9之间那么就有数字
5.对于符号，若非字母，非数字那么就为符号。
6.对于奖励先判断大小写字母，数字符号。再判断字母数字符号，再判断字母数字。
7.最终定义sum。将对应的sum1，sum2，sum3，sum4，奖励部分可以单独用sum判读，加起来。
8.得到最终分数之后就可以输出对应等级
 */
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));
        String  str = "";
        while ((str = bi.readLine()) != null) {
            int sum1 = getLen(str);
            int sum2 = getChar(str);
            int sum3 = getNum(str);
            int sum4 = getSym(str);
            int sum = 0;

            if (sum2 == 20 && sum3 >= 1 && sum4 >= 1) {
                sum = sum1 + sum2 + sum3 + sum4 + 5;
            } else if (sum2 == 10 && sum3 >= 1 && sum4 >= 1) {
                sum = sum1 + sum2 + sum3 + sum4 + 3;
            } else if (sum2 == 10 && sum3 >= 1 && sum4 == 0) {
                sum = sum1 + sum2 + sum3 + sum4 + 2;
            } else {
                sum = sum1 + sum2 + sum3 + sum4;
            }

            if (sum >= 90) {
                System.out.println("VERY_SECURE");
            } else if (sum >= 80) {
                System.out.println("SECURE");
            } else if (sum >= 70) {
                System.out.println("VERY_STRONG");
            } else if (sum >= 60) {
                System.out.println("STRONG");
            } else if (sum >= 50) {
                System.out.println("AVERAGE");
            } else if (sum >= 25) {
                System.out.println("WEAK");
            } else if (sum >= 0) {
                System.out.println("VERY_WEAK");
            }

        }
    }

    public static int getLen(String str) {
        if (str.length() <= 4) {
            return 5;
        }
        if (str.length() > 4 && str.length() <= 7) {
            return 10;
        }
        if (str.length() >= 8) {
            return 25;
        }
        return 0;
    }

    public static int getChar(String str) {
        int small = 0;
        int big = 0;
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) >= 65 && str.charAt(i) <= 90) {
                big++;
            } else if (str.charAt(i) >= 97 && str.charAt(i) <= 122) {
                small++;
            }
        }
        if (small > 0 && big > 0) {
            return 20;
        } else if (small > 0 || big > 0) {
            return 10;
        } else {
            return 0;
        }
    }
    public static int getNum(String str) {
        int num = 0;
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) - '0' >= 0 && str.charAt(i) - '0' <= 9) {
                num++;
            }
        }
        if (num > 1) {
            return 20;
        } else if (num == 1) {
            return 10;
        } else {
            return 0;
        }
    }
    public static int getSym(String str) {
        int num = 0;
        for (int i = 0; i < str.length(); i++) {
            if (!(str.charAt(i) >= 65 && str.charAt(i) <= 90) &&
                    !(str.charAt(i) >= 97 && str.charAt(i) <= 122) &&
                    !(str.charAt(i) - '0' >= 0 && str.charAt(i) - '0' <= 9)) {
                num++;
            }
        }
        if (num > 1) {
            return 25;
        } else if (num == 1) {
            return 10;
        } else {
            return 0;
        }
    }


}

Day11（JavaSE语法）

21.最近公共祖先

1.由于parent = child/2
2.如果a>b,则a/2，否则b/2知道a == b。为止，此时相等的数为公共祖先

import java.util.*;
/**
思路：
1.由于parent = child/2
2.如果a>b,则a/2，否则b/2知道a == b。为止，此时相等的数为公共祖先
 */
public class LCA {
    public int getLCA(int a, int b) {
        while(a != b){
            if(a>b){
                a = a/2;
            }else{
                b = b/2;
            }
        }
        return a;
    }
}

22.最大连续bit数

思路：
1.通过n&1来得到二进制中末位为0还是1
2.通过n=n/2 或者n = n>>1 (将n右移一位)依次得到二进制数的末位 最终当n = 0时结束
3.将得到的二进制数进行统计，若为1则count++，为0则count = 0；
4.用Endcount记录count的最大值。
5.最后输出Endcount

import java.util.*;
import java.io.*;
/**
思路：
1.通过n&1来得到二进制中末位为0还是1
2.通过n=n/2 或者n = n>>1 (将n右移一位)依次得到二进制数的末位 最终当n = 0时结束
3.将得到的二进制数进行统计，若为1则count++，为0则count = 0；
4.用Endcount记录count的最大值。
5.最后输出Endcount
 */
public class Main{
    public static void main(String[] args) throws IOException{
        BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));
        String str = "";
        while((str = bi.readLine()) != null){
            int n = Integer.parseInt(str);

            int count = 0;
            int Endcount = 0;

            while(n!=0){
                if((n & 1) == 1){
                    count++;
                    Endcount = Math.max(count,Endcount);
                }else{
                    count = 0;
                }
                n = n>>1;
            }
            System.out.println(Endcount);
        }
    }
}

思路2：

1.先求出对应的二进制数，再遍历

2.利用计数器来统计出连续1的个数 

Day12（JavaSE语法）

23.二进制插入

思路：
1.由于n的第j到i位为0，我们先将m左移j位。那么m右边多出j个0。
2.再用n|m。由于1|0 = 1，0|0 = 0；可以保证将m插入到n的j到i位之中。

import java.util.*;
/**
思路：
1.由于n的第j到i位为0，我们先将m左移j位。那么m右边多出j个0。
2.再用n|m。由于1|0 = 1，0|0 = 0；可以保证将m插入到n的j到i位之中。
 */
public class BinInsert {
    public int binInsert(int n, int m, int j, int i) {
        // write code here
        if( j>i ){
            return 0;
        }
        m <<= j;
        return n|m;
    }
}

24.查找组成一个偶数最接近的两个素数

思路：
1.首先我们将这个偶数除以2。从中间开始，依次递增，而小的数则为n-i
2.创建一个判断是否为素数的方法，每次递增都判断一下i和n-i是否为素数
3.若为素数则依次打印出n-i和i，再break；

import java.util.Scanner;
/**
思路：
1.首先我们将这个偶数除以2。从中间开始，依次递增，而小的数则为n-i
2.创建一个判断是否为素数的方法，每次递增都判断一下i和n-i是否为素数
3.若为素数则依次打印出n-i和i，再break；
 */
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int n = in.nextInt();
        for(int i = n/2; i>0;i++){
            if(isPrime(i)&&isPrime(n-i)){
                System.out.println(n-i);
                System.out.println(i);
                break;
            }
        }
    }
    public static boolean isPrime(int n){
        for(int i = 2; i<n; i++){
            if(n%i == 0){
                return false;
            }
        }
        return true;
    }
}
祁思妙想
关注
专栏目录
牛客网刷题笔试2（java）
xqk709008281的博客
10-17 384
非纯数字的字符串转化为Integer对象会报数字格式异常 Java中对于文本文件和二进制文件，都可以当作二进制文件进行操作 运行时数据区包括：虚拟机栈区，堆区，方法区，本地方法栈，程序计数器 虚拟机栈区 ：也就是我们常说的栈区，线程私有，存放基本类型，对象的引用和 returnAddress ，在编译期间完成分配。 堆区 ， JAVA 堆，也称 GC 堆
【牛客】Java刷题记录
BeanYon的博客
08-10 232
复杂链表的复制 题目：复制一个复杂链表（每个节点有两个指针，一个指向下一个节点，一个指向任意一个节点）。 思路：先复制主链，暂时不管随机指向的指针，在复制主链的过程中，通过Map建立新旧链中每个节点的对应关系，然后再通过一次遍历，在新链中建立随机指向的指针。 public class Solution { public RandomListNode Clone(RandomListNode...
java 高级工程师一些笔试题
08-11
Java 高级工程师的一些常见笔试面试题目，比较经典，值得看看
java 高级工程师 笔试题
miaoxiongvip的专栏
02-15 140
1.设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1. 参考答案：http://zhidao.baidu.com/link?url=HH8aM4LT3rdrwmGrq0Dt6C3-a8qggeggtEKBGdDv36hXIkktnnjPMIWIyOoWvSHHy59AeMB2OF12ccdkdJxyga 方法1： public class TestThread3 { ...
最新Java笔试题及答案，java高分面试指南
最新发布
CTZL123456的博客
07-24 1260
单个redis节点的并发能力是有限的，所以为了提高并发能力，我们需要搭建redis集群，就比如：主从复制。主从复制的流程主从复制主要分为：全量同步和增量同步。全量同步：在salve请求数据同步的时候会携带application Id和offset，如果master判断出applid和自己的不一样，就认为slave是第一次进行同步，所以会进行全量同步。
Java 软件高级工程师笔试题
ndscqs的博客
04-14 360
Java 软件高级工程师笔试题 【智力部分】（30分） 1. 烧一根不均匀的绳要用一个小时，如何用它来判断半个小时？（5分） 2. 4，4，10，10，加减乘除，怎么出24点？（5分） 3. 如果你有无穷多的水，一个容积为3L的和5L的提桶，你如何准确称出 4L的水？（5分） 4. 一只蜗牛从井底爬到井口，每天白天蜗牛要睡觉，晚上才出来活动，一个晚上蜗牛可以向上爬3尺，但是白...
java高级工程师 考试_JAVA高级工程师笔试题及答案
weixin_30716641的博客
02-13 1168
JAVA高级工程师笔试题及答案Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。下面是小编收集的JAVA高级工程师笔试题及答案，欢迎大家参考!1.abstractclass和interface的区别?抽象类可以有私有方法和变量，接口中不能有私有方法和变量。抽象类可以有方法的实现，接口中不能有方法的实现并且所以的方法都需要实现。2.try{}里有一个return语句，那...
网易面试java_网易资深Java开发面试经验
weixin_39692557的博客
02-12 357
List和Set比较，各自的子类比较对比一：Arraylist与LinkedList的比较1、ArrayList是实现了基于动态数组的数据结构,因为地址连续，一旦数据存储好了，查询操作效率会比较高(在内存里是连着放的)。2、因为地址连续，ArrayList要移动数据,所以插入和删除操作效率比较低。3、LinkedList基于链表的数据结构,地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地...
2023 阿里云笔试题 研发岗 阿里笔试 0917
2301_79125431的博客
10-21 465
秋招结束华子的池子也不想泡了，字节也等不到了，一些中小厂的offer也都拒了签金山办公了，虽然金山办公sp也就北上一线大厂的白菜价，但是在武汉也是十分滋润了。计算机女，家江苏镇江。希望大家给个建议，美团平台好一点，但薪资还不如兴子给的高，（但是已经是ssp了，根据往年），兴子在南京，离家路程两小时。JVM JUC 框架 真的不配开发，现在连个实习都难找啊，小公司要啥都会，大公司要92，1.联州成都，年包28w左右，网评加班严重，卡转正学不到东西，好处离家近，生活成本低2.天津联想，年包14w左右，
Python:启程 数据分析-牛客网在线编程1-11
qq_32669453的博客
09-30 315
Python数据分析-牛客网在线编程1-11（查看数据、数据索引、逻辑运算）
量化交易系统开发步骤策略/功能需求/案例设计/源码出售/详细
2301_79125431的博客
04-26 2026
金山办公投递2023-03-19NLP算法工程师-面向24届春招笔试2024-03-2320道选择，时间线：4.6投简历，4.18做行测，4.25一面面试官很礼貌，一来就介绍了自己的岗位，部门和名字，1 美团优选，后端开发java，发的是最早的，当时就签了2 腾讯pcg大数据平台，岗位是推荐架构cp。小弟北方人，对工作地方没什么大的要求，也没有在北上定居的打算，工作几年润二线城市。暑期实习求选个人情况：之前实习全都是数据科学相关，秋招想冲算法，保数据科学，偏好建模和技术性强一点的。
java高级软件工程师面试题大全及答案 含一些公司面试题
11-18
java高级软件工程师面试题大全及答，一些公司的面试题，对于正在找工作应对面试的朋友或许有点帮助。java高级软件工程师面试题大全及答，一些公司的面试题，对于正在找工作应对面试的朋友或许有点帮助
java高级工程师-面试题及答案
12-04
java高级工程师-面试题及答案.docx
java高级工程师常见面试题_亲自收集
06-13
亲自收集的java高级程序员面试题
74道高级Java面试合集：java工程师笔试题目
碧海朝天素
07-19 550
java基础 1.1java的8种基本数据类型装箱拆箱 1.2重写重载封装继承多态 1.3 Stack Queue 1.7 Concurrent包 1.8面向对象 1.9 String StringBuffer StringBuilder hashcode equ 1.10 java文件读取 1.11 Java反射 1.12 JDK NDK JRE JNI 1.13 static和final的区别 1.14 map, list, set区别 1.16 Session和COOKIE 1.19 10 NIO B
java高级工程师面试
weixin_30566149的博客
11-15 189
https://www.cnblogs.com/java1024/p/8594784.htmlhttps://blog.csdn.net/moneyshi/article/details/52917254 转载于:https://www.cnblogs.com/veryvalley/p/9962425.html
2024Java面试笔试总结，中高级工程师Java开发
m0_60721907的博客
03-07 799
相信大家对 ZooKee点击领取2024完整开源项目《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》per 应该不算陌生。但是你真的了解 ZooKeeper 到底有啥用不？如果别人/面试官让你给他讲讲对于 ZooKeeper 的认识，你能回答到什么地步呢？拿我自己来说吧！我本人曾经使用 Dubbo 来做分布式项目的时候，使用了 ZooKeeper 作为注册中心。为了保证分布式系统能够同步访问某个资源，我还使用 ZooKeeper 做过分布式锁。
JAVA工程师 笔试题(2023)
java_zhong1990的专栏
09-18 477
使用对象：2023届软件工程专业毕业生 1 题型设计原理 1.1 题目类型分为三大类，多选题、问答题、编码题，主要检测4个能力：工具、技术、算法、基础编程 多选题 6 题：检测面试者的对编程工具的认知程度，是否匹配我们的项目工具。 问答题 20 题：检测面试者对技术的掌握情况，是否全面掌握 JAVA SE 、JAVA EE、HTML、JavaScript相关技术。(JAVA SE： 编程基础 、面向对象 、IO流 、异常处理 、多线程 、网络编程 、JDBC 、 Servlet 、JSP)
牛客刷题 jsnode 输入输出
08-25
在牛客网上刷题，使用 JavaScript 和 Node.js 进行输入输出操作是非常常见的。下面是一个简单的示例，演示如何使用 Node.js 读取标准输入并输出结果： ```javascript // 导入内置的 `readline` 模块 const readline...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

祁思妙想

你的鼓励将是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值