• 【刷题记录⑨】Java工程师丨字节面试真题（三）

    活动地址：CSDN21天学习挑战赛

    ​Java面试练习题刷题记录

    目录

     一、选区间

    二、任务调度

    三、数列的和

    总结

    我几乎每天都会刷题训练来使自己对各种算法随时保持一个清晰的状态。要知道眼过千遍不如手过一遍，想成为一名合格的开发工程师，更要逼迫自己养成动手的好习惯。

    我们都知道，算法的训练对程序员来说及其重要，语言和开发平台不断变化，但是万变不离其宗的是那些算法和理论，刷算法最最最直白的原因就是找一个好的工作，那刷题一定是必不可少的。

    现在算法刷题平台还是蛮多的，给大家介绍一个我认为与大厂关联最深的平台——牛客网

    2977e66c7847c01a01ced3302bba89cf.png​

    相较于其他平台，他们的题单更和工作，大厂靠拢，不光有面试必刷的101到题目，还有大量大厂真题，内容也全程免费，相较于其它会员费结算的来说 非常的友好。

    df47799cc8780cb18e244fd0c0628ce2.png​

    牛客网还支持ACM模式，没有练习过的一定要提前适应！像某团、某为，都要求自己处理输入输出，如果不提前练习会很吃亏的！

    牛客的题解更新迭代也很快，讨论区也有技巧的分享，能帮你把所有盲点扫清楚，整体来说还是非常推荐去练习的~

    传送门： 牛客网 - 找工作神器|笔试题库|面试经验|实习招聘内推，求职就业一站解决_牛客网

     一、选区间

    描述

    给定一个数组序列,需要求选出一个区间,使得该区间是所有区间中经过如下计算的值最大的一个：

    区间中的最小数*区间所有数的和

    最后程序输出经过计算后的最大值即可，不需要输出具体的区间。如给定序列 [6 2 1]则根据上述公式,可得到所有可以选定各个区间的计算值:

    [6] = 6 * 6 = 36;

    [2] = 2 * 2 = 4;

    [1] = 1 * 1 = 1;

    [6,2] = 2 * 8 = 16;

    [2,1] = 1 * 3 = 3;

    [6, 2, 1] = 1 * 9 = 9;

    从上述计算可见选定区间[6]，计算值为36， 则程序输出为36。

    区间内的所有数字都在[0, 100]的范围内;

    输入描述：

    第一行输入数组序列个数，第二行输入数组序列。

    输出描述：

    输出数组经过计算后的最大值。

    示例1

    输入：

    3
6 2 1

    输出：

    36

    题解：

    1. import java.io.BufferedReader;
    2. import java.io.IOException;
    3. import java.io.InputStreamReader;
    4. import java.util.Arrays;
    5. public class Main {
    6.     public static void main(String[] args) throws IOException{
    7.         BufferedReader buff = new BufferedReader(new InputStreamReader(System.in));
    8.         buff.readLine();
    9.         int[] in = Arrays.stream(buff.readLine().split(" ")).parallel().mapToInt(Integer::parseInt).toArray();
    10.         int res = 0;
    11.         //中心扩展法
    12.         for(int i = 0; i < in.length; i++){
    13.             int p = i, q = i - 1;
    14.             int sum = 0;
    15.             while (p=in[i]) {
    16.                 sum += in[p];
    17.                 p++;
    18.             }
    19.             while (q >= 0 && in[q]>=in[i]) {
    20.                 sum += in[q];
    21.                 q--;
    22.             }
    23.             res = Math.max(res, sum * in[i]);
    24.         }
    25.         System.out.println(res);
    26.     }
    27. }
    28.

    二、任务调度

    描述

    产品经理(PM)有很多好的idea，而这些idea需要程序员实现。现在有N个PM，在某个时间会想出一个 idea，每个 idea 有提出时间、所需时间和优先等级。对于一个PM来说，最想实现的idea首先考虑优先等级高的，相同的情况下优先所需时间最小的，还相同的情况下选择最早想出的，没有 PM会在同一时刻提出两个 idea。

    同时有M个程序员，每个程序员空闲的时候就会查看每个PM尚未执行并且最想完成的一个idea,然后从中挑选出所需时间最小的一个idea独立实现，如果所需时间相同则选择PM序号最小的。直到完成了idea才会重复上述操作。如果有多个同时处于空闲状态的程序员，那么他们会依次进行查看idea的操作。

    求每个idea实现的时间。

    输入描述：

    输入第一行三个数N、M、P，分别表示有N个PM，M个程序员，P个idea。随后有P行，每行有4个数字，分别是PM序号、提出时间、优先等级和所需时间。

    所有输入数据范围为 [1, 3000]

    输出描述：

    输出P行，分别表示每个idea实现的时间点。

    示例1

    输入：

    2 2 5
1 1 1 2
1 2 1 1
1 3 2 2
2 1 1 2
2 3 5 5

    输出：

    3
4
5
3
9

    题解：

    1. import java.io.BufferedReader;
    2. import java.io.IOException;
    3. import java.io.InputStreamReader;
    4. import java.util.*;
    5.  
    6. public class Main {
    7.  
    8.     static class Idea {
    9.         int id;  //不是pm的编号
    10.         int create;//产生时间；
    11.         int power; //优先级
    12.         int need; //需要时间
    13.         int finish;
    14.  
    15.         public Idea(int id, int create, int power, int need){
    16.             this.id = id;
    17.             this.create = create;
    18.             this.power = power;
    19.             this.need = need;
    20.             this.finish = -1;
    21.         }
    22.     }
    23.  
    24.  
    25.     public static void main(String[] args) throws IOException{
    26.         BufferedReader buff = new BufferedReader(new InputStreamReader(System.in));
    27.         String[] s0 = buff.readLine().split(" ");
    28.         int n = Integer.parseInt(s0[0]); //pm,没用上此变量
    29.         int m = Integer.parseInt(s0[1]); //程序员
    30.         int p = Integer.parseInt(s0[2]);
    31.         int[] programer = new int[m];//标记程序员还有多少时间干完活
    32.         HashMap map = new HashMap<>();
    33.         //生产线 //
    34.         PriorityQueue createQ = new PriorityQueue<>(Comparator.comparingInt(o -> o.create));
    35.         //待完成任务 //
    36.         PriorityQueue taskQ = new PriorityQueue<>(new Comparator() {
    37.             @Override public int compare(Idea o1, Idea o2){
    38.                 if(o1.power > o2.power){
    39.                     return 1;
    40.                 }else if(o1.power < o2.power){
    41.                     return -1;
    42.                 }else{
    43.                     if(o1.need > o2.need){
    44.                         return 1;
    45.                     }else if(o1.need < o2.need){
    46.                         return -1;
    47.                     }else{
    48.                         if(o1.create > o2.create){
    49.                             return 1;
    50.                         }else if(o1.create < o2.create){
    51.                             return -1;
    52.                         }else{
    53.                             return 0;
    54.                         }
    55.                     }
    56.                 }
    57.             }
    58.         });
    59.         //生产计划********************//
    60.         for(int i = 0; i < p; i++){
    61.             int[] temp = Arrays.stream(buff.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
    62.             Idea idea = new Idea(i, temp[1], temp[2], temp[3]);
    63.             map.put(i, idea);
    64.             createQ.add(idea);
    65.         }
    66.  
    67.         //两个Queue都是空时，停止
    68.         int k = 0;
    69.         while ((!taskQ.isEmpty()) || (!createQ.isEmpty())) {
    70.             while ((!createQ.isEmpty()) && createQ.peek().create == k) {
    71.                 taskQ.offer(createQ.poll());
    72.             }
    73.             int indexProgramer = 0;//遍历每一个程序员
    74.             while (indexProgramer < programer.length) {
    75.                 if(programer[indexProgramer] > 0){
    76.                     programer[indexProgramer]--; //程序员干活啦
    77.                     indexProgramer++;
    78.                 }else{//这个程序员空闲
    79.                     if(taskQ.isEmpty()){
    80.                         indexProgramer++;
    81.                     }else{//有任务做了
    82.                         Idea idea = taskQ.poll();
    83.                         idea.finish = k + idea.need;//计算完成时间
    84.                         programer[indexProgramer] = idea.need;//程序员需要消耗的时间
    85.                     }
    86.                 }
    87.             }
    88.             k++;//时间增加
    89.         }
    90.         for(int i = 0; i < p; i++){
    91.             System.out.println(map.get(i).finish);
    92.         }
    93.     }
    94. }

    三、数列的和

    描述

    数列的定义如下：数列的第一项为n，以后各项为前一项的平方根，求数列的前m项的和。

    输入描述：

    输入数据有多组，每组占一行，由两个整数n（n<10000）和m(m<1000)组成，n和m的含义如前所述。

    输出描述：

    对于每组输入数据，输出该数列的和，每个测试实例占一行，要求精度保留2位小数。

    示例1

    输入：

    81 4
2 2

    输出：

    94.73
3.41

    题解：

    1.  
    2. import java.util.Scanner;
    3.  
    4. public class Main {
    5.  
    6.     /**
    7.      * 数列 n .. 的前 m 项和
    8.      * 输入：81 4     2 2
    9.      * 输出: 94.73    3.41
    10.      */
    11.     public static void main(String[] args) {
    12.         run();
    13.     }
    14.  
    15.     private static void nSum(int n, int m) {
    16.         double res = n;
    17.         double sum = 0;
    18.         for (int i = 0; i < m; i++) {
    19.             sum += res;
    20.             res = Math.sqrt(res);
    21.         }
    22.         System.out.println(String.format("%.2f", sum));
    23.     }
    24.  
    25.     private static void run() {
    26.         Scanner sc = new Scanner(System.in);
    27.         while (sc.hasNext()) {
    28.             String[] inputs = sc.nextLine().split(" ");
    29.             int n = Integer.parseInt(inputs[0]);
    30.             int m = Integer.parseInt(inputs[1]);
    31.             nSum(n, m);
    32.         }
    33.     }
    34. }
    35.

    总结

    点击链接 进行跳转注册，开始你的保姆级刷题之路吧！

    另外这里不仅仅可以刷题，你想要的这里都会有，十分适合小白和初学者入门学习~
    1、算法篇（398题）：面试必刷100题、算法入门、面试高频榜单
    2、数据结构篇（300题）：都是非常经典的链表、树、堆、栈、队列、动态规划等
    3、语言篇（500题）：C/C++、java、python入门算法练习
    4、SQL篇（82题）：快速入门、SQL必知必会、SQL进阶挑战、面试真题
    5、大厂笔试真题：字节跳动、美团、百度、腾讯…掌握经验不在惧怕面试！
     

    7cc054e25bd74ac5ac50a80eeaa75007.png​


  • 相关阅读:
    （Research）高分辨率单细胞图谱揭示非小细胞肺癌组织驻留中性粒细胞的多样性和可塑性
    Linux系列之重定向操作
    【算法|动态规划No.8】leetcode面试题 17.16. 按摩师
    app运营：提高用户活跃度的技巧
    C语言学习笔记day2
    超市商品管理系统 毕业设计 JAVA+Vue+SpringBoot+MySQL
    灵界的科学丨六、星际通信新科技──寻找外星人
    优先级队列（堆）的详解
    冒泡排序和选择排序
    工业控制系统安全需求的变化
  • 原文地址：https://blog.csdn.net/m0_63947499/article/details/126166659