devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：IT小白 | 2024-04-27 04:42:16

赞

踩

java刷题

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

​Java面试练习题刷题记录

目录

 一、选区间

二、任务调度

三、数列的和

总结

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

 一、选区间

描述

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

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

最后程序输出经过计算后的最大值即可，不需要输出具体的区间。如给定序列 [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.length && in[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<Integer, Idea> map = new HashMap<>();
  33.         //生产线 //
  34.         PriorityQueue<Idea> createQ = new PriorityQueue<>(Comparator.comparingInt(o -> o.create));
  35.         //待完成任务 //
  36.         PriorityQueue<Idea> taskQ = new PriorityQueue<>(new Comparator<Idea>() {
  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.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/494841
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号