Java笔试模拟试题（二）_class test extends a-CSDN博客

本文链接：https://blog.csdn.net/weixin_47514459/article/details/123832360

一，继承类笔试题，请回答下面代码的输出

public class Test extends A {
    B b = new B();
    Test(){
        System.out.println("test");
    }
    public static void main(String[] args) {
      new Test();
    }

}
class A{
    B y = new B();
    A(){
        System.out.println("A");
    }
}
class B{
    B(){
        System.out.println("B");
    }
}

原因：首先Test继承了A，所以下看A类，A类newB，所以先输出B，Bnew完后，输出A，进入Test中，先new了B，输出B，到构造器输出test。

二，（华为笔试题）给定一个n*2的二维数组，表示n个任务，一个信息表示是任务能够开始这的时间，另一个表示任务的结束期限，（开始时间一定小于结束时间，并且数值上一定都是正数），你作为单线程人，不能并行处理任务，但是每一个任务都需要一个单位时间来完成。你需要将所有的任务时间，位于开始做时间与最后期限之间的返回结果。

图片解析：

解法：

代码实现：

import java.util.Arrays;
import java.util.PriorityQueue;

public class Test extends A {
    //开始时间
    public int time;
    public int end; //结束时间
    public boolean add ;  //判断时间的状态（ture添加到堆中）

    //封装一个对象
    public  Test(int t, int e ,boolean a){
        time = t;
        end = e;
        add = a;
    }

    public static boolean canDo(int[][] jobs){
        if(jobs == null || jobs.length < 2){
            return true;
        }
        int n = jobs.length;
        Test[] arr = new Test[n << 1];
        for (int i = 0; i < n ; i++) { //一个任务二个状态
            arr[i] = new Test(jobs[i][0],jobs[i][1],true);
            arr[i+n]= new Test(jobs[i][1],jobs[i][1],false);
        }
        Arrays.sort(arr,(a,b)->a.time-b.time); //排序
        PriorityQueue<Integer> heap = new PriorityQueue<>();  //创建堆

        for (int i = 0,lastTime = arr[0].time ; i < arr.length;i++) { //lastTime 上一个时刻，来计算时间差
            if (arr[i].add){
                heap.add(arr[i].end); //增加
            } else {  //检查时间
                int curTime = arr[i].time;
                for (int j = lastTime; j < curTime ; j++) {
                    if (heap.isEmpty()){
                        break;
                    }
                    heap.poll(); //抛出任务
                }
                if(heap.peek() <= curTime){  //堆顶时间<=当前时刻
                    return false;
                }
            }

        }
        return true
    }
}

三，二维数组查找整数

剑指 Offer 04. 二维数组中的查找

在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

public boolean findNumberIn2DArray(int[][] matrix, int target) {
        if(matrix == null || matrix.length == 0 || matrix[0].length == 0 ){
            return false;
        }
        int lines = matrix.length-1;
        int columns = matrix[0].length-1;

        int line = 0;
        int column = columns;

        while (line <= lines && column >= 0 ) {
                if (target == matrix[line][column]){
                    return true;
                }else if (target > matrix[line][column]){
                    line++;
                }else if(target < matrix[line][column]){
                    column--;
                }
        } 
        return false;
    }

小编方法二：

public boolean findNumberIn2DArray(int[][] matrix, int target) {
        if(matrix == null || matrix.length == 0 || matrix[0].length == 0 ){
            return false;
        }
        int lines = matrix.length-1;
        int columns = matrix[0].length-1;

        int line = 0;
        int column = 0;

        while (line <= lines && column <= columns ) {
                if (target == matrix[line][column]){
                    return true;
                }else if ( target < matrix[line][column] || column == columns){
                    line++;
                    column = 0 ;
                }else if(target > matrix[line][column]){
                   column++;
                }
        } 
        return false;
    }

四，替换空格

剑指 Offer 05. 替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：

输入：s = "We are happy."
输出："We%20are%20happy."

public String replaceSpace(String s) {
        int len = s.length();
        int count = 0;
        for(int i = 0 ; i < len ; i++ ){
            if(s.charAt(i) == ' '){
                count++;
            }
        }
        int newLen = len + count*2;
        char arr[] = new char[newLen];
        for(int i = len-1; i >= 0 ; i--){
            if(s.charAt(i) ==  ' '){
                arr[--newLen] = '0';
                arr[--newLen] = '2';
                arr[--newLen] = '%';
                len--;
            }else{
                arr[--newLen] = s.charAt(--len);
            }
            
        }
        return new String(arr);
    }

美团面试题

双色球，题目红色球和蓝色球的一个长度为n的排列，样例是rrbbr，其中r表示红色球，b表示蓝色球。以及小美现在口袋里还有a个红球，b个蓝球。现在往排列里插入球，使得相邻的球颜色不同，如果口袋里的球能满足，请输出插入球后的排列的最小长度，否则输出还需要多少个红球和蓝球。

给一个数组，是一些数字的排列，如果能够从中间某个位置分开，使得前面的数组严格递增，后面的严格递减，就称这个数组是好数组、完美数组什么的。现在给你一个数组1,2,1,2,1，问你这些数字最少加几能够成完美数组，示例的答案显然是2，把最中间的1变成3就行了。

 public static int middle_num(int[] arr){
        int middle = 0;
        int len  = arr.length -1;
        int val = 0;
        for (int i = 0; i < len; i++) {
            if (middle < arr[i]){
                middle = arr[i];
            }else{
                val = arr[i];
                middle = middle+arr[i];
                break;
            }
        }
        return middle - val;
    }