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

    Java面试练习题刷题记录

    目录

     一、附加题

    二、编程题1

    三、编程题2

    四、字母交换

    总结

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

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

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

    2977e66c7847c01a01ced3302bba89cf.png​

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

    df47799cc8780cb18e244fd0c0628ce2.png​

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

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

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

     一、附加题

    描述

    二阶魔方又叫小魔方，是2*2*2的立方形结构。每一面都有4个块，共有24个块。每次操作可以将任意一面逆时针或者顺时针旋转90°，如将上面逆时针旋转90°操作如下。

    1cf19fcef3f54b169c603ae7b32f5664.png

    Nero在小魔方上做了一些改动，用数字替换每个块上面的颜色，称之为数字魔方。魔方上每一面的优美度就是这个面上4个数字的乘积，而魔方的总优美度就是6个面优美度总和。
    现在Nero有一个数字魔方，他想知道这个魔方在操作不超过5次的前提下能达到的最大优美度是多少。

    魔方展开后每一块的序号如下图：

    db89f567660148fab960ebf9a1afa268.png

    输入描述：

    输入一行包含24个数字，按序号顺序给出魔方每一块上面的数字。所有数大小范围为[-100,100]。

    输出描述：

    输出一行包含一个数字，表示最大优美度。

    示例1

    输入：

    2 -3 -2 3 7 -6 -6 -7 9 -5 -9 -3 -2 1 4 -9 -1 -10 -5 -5 -10 -4 8 2

    输出：

    8281

    题解：

    1. import java.util.*;
    2.  
    3. public class Main {
    4.     /**
    5.      * 记录三种旋转需要变动的下标，共三组下标
    6.      * 每组下标里，每4个下标形成一个轮回
    7.      */
    8.     private static int[][] map = new int[][]{
    9.         {0,1,3,2,7,5,22,9,6,4,23,8},
    10.         {6,7,13,12,2,8,17,11,3,14,16,5},
    11.         {4,5,11,10,0,6,16,20,2,12,18,22}
    12.     };
    13.  
    14.     /**
    15.      * main
    16.      * @param args 命令行参数
    17.      */
    18.     public static void main(String[] args) {
    19.         // 读取输入
    20.         Scanner sc = new Scanner(System.in);
    21.         int[] n = new int[24];
    22.         for (int i = 0; i < 24; i++) {
    23.             n[i] = sc.nextInt();
    24.         }
    25.  
    26.         // 输出结果
    27.         System.out.println(resolve(n, -1, 5));
    28.     }
    29.  
    30.     /**
    31.      * 分析当前状态
    32.      * @param n 当前状态
    33.      * @param type 达到当前状态时的最后一个操作类型
    34.      * @param remain 剩余操作数
    35.      * @return 可以达到的最大优美度
    36.      */
    37.     private static int resolve(int[] n, int type, int remain) {
    38.         // 非法状态
    39.         if (remain < 0) return Integer.MIN_VALUE;
    40.         // 当前状态优美度
    41.         int max = compute(n);
    42.         // 尝试转动，不可与type类型相同
    43.         if (type != 0) max = Math.max(max, turn(n, 0, remain));
    44.         if (type != 1) max = Math.max(max, turn(n, 1, remain));
    45.         if (type != 2) max = Math.max(max, turn(n, 2, remain));
    46.         return max;
    47.     }
    48.  
    49.     /**
    50.      * 按照类型转动魔方多次并分析
    51.      * @param n 当前状态
    52.      * @param type 转动类型
    53.      * @param remain 剩余操作数
    54.      * @return 转动可以达到的最大优美度
    55.      */
    56.     private static int turn(int[] n, int type, int remain) {
    57.         // 转动一次
    58.         turn(n, type);
    59.         int max = resolve(n, type, remain-1);
    60.         // 转动两次
    61.         turn(n, type);
    62.         max = Math.max(max, resolve(n, type, remain-2));
    63.         // 转动三次，相当于逆向转动一次
    64.         turn(n, type);
    65.         max = Math.max(max, resolve(n, type, remain-1));
    66.         // 转动四次，还原初始状态
    67.         turn(n, type);
    68.         return max;
    69.     }
    70.  
    71.     /**
    72.      * 转动操作
    73.      * @param n 当前状态
    74.      * @param type 转动类型
    75.      */
    76.     private static void turn(int[] n, int type) {
    77.         // 每四个下标一轮回
    78.         for (int i = 0, tmp = 0; i < 12; i++) {
    79.             if (i % 4 == 0) tmp = n[map[type][i]];
    80.             if (i % 4 == 3) n[map[type][i]] = tmp;
    81.             else n[map[type][i]] = n[map[type][i+1]];
    82.         }
    83.     }
    84.  
    85.     /**
    86.      * 计算当前状态的优美度
    87.      * @param n 当前状态
    88.      * @return 优美度
    89.      */
    90.     private static int compute(int[] n) {
    91.         return n[0]*n[1]*n[2]*n[3] +
    92.                n[6]*n[7]*n[12]*n[13] +
    93.                n[4]*n[5]*n[10]*n[11] +
    94.                n[8]*n[9]*n[14]*n[15] +
    95.                n[16]*n[17]*n[18]*n[19] +
    96.                n[20]*n[21]*n[22]*n[23];
    97.     }
    98. }

    二、编程题1

    描述

    有一个推箱子的游戏, 一开始的情况如下图:

    18e52373c94040b7b9ecd3f2b3d4fe93.png

     

    上图中, '.' 表示可到达的位置, '#' 表示不可到达的位置，其中 S 表示你起始的位置, 0表示初始箱子的位置, E表示预期箱子的位置，你可以走到箱子的上下左右任意一侧, 将箱子向另一侧推动。如下图将箱子向右推动一格;

    ..S0.. -> ...S0.

    注意不能将箱子推动到'#'上, 也不能将箱子推出边界;

    现在, 给你游戏的初始样子, 你需要输出最少几步能够完成游戏, 如果不能完成, 则输出-1。

    输入描述：

    第一行为2个数字,n, m, 表示游戏盘面大小有n 行m 列(5< n, m < 50);
    后面为n行字符串,每行字符串有m字符, 表示游戏盘面;

    输出描述：

    一个数字,表示最少几步能完成游戏,如果不能,输出-1;

    示例1

    输入：

    3 6
.S#..E
.#.0..
......

    输出：

    11

    题解：

    1. import java.util.LinkedList;
    2. import java.util.Queue;
    3. import java.util.Scanner;
    4. public class Main {
    5.  
    6.     public static void main(String[] args){
    7.         Scanner sc=new Scanner(System.in);
    8.         int n=sc.nextInt();
    9.         int m=sc.nextInt();
    10.         char[][] chas=new char[n][m];
    11.         // 人的起始位置S 以及箱子的位置
    12.         int startX=0,startY=0,boxX=0,boxY=0;
    13.         // 判断位置 ，即人要先找到箱子，再推着箱子往前走
    14.         for(int i=0;i&lt;n;i++){   
    15.             String string=sc.next();
    16.             for(int j=0;j&lt;m;j++){
    17.                 chas[i][j]=string.charAt(j);
    18.                 if(chas[i][j]==&#39;S&#39;){
    19.                     startX=i;
    20.                     startY=j;
    21.                 }
    22.                 if(chas[i][j]==&#39;0&#39;){
    23.                     boxX=i;
    24.                     boxY=j;
    25.                 }
    26.             }
    27.         }
    28.         System.out.println(solve(chas,startX,startY,boxX,boxY));
    29.     }
    30.  
    31.     public static class Node{
    32.         int px;  // 人的位置
    33.         int py;
    34.         int bx;  //箱子的位置
    35.         int by;
    36.         int step;  //从初始位置到现在节点所走的步数
    37.         public Node(int px,int py,int bx,int by){
    38.             this.px=px;
    39.             this.py=py;
    40.             this.bx=bx;
    41.             this.by=by;
    42.         }
    43.     }
    44.  
    45.  
    46.     private static int solve(char[][] chas,int startX, int startY,int boxX,int boxY) {
    47.         Node start=new Node(startX, startY,boxX,boxY);
    48.         int n=chas.length;
    49.         int m=chas[0].length;
    50.         // iswalked四维数组，可以用来存储走过的路径以防重复。
    51.         int[][][][] iswalked=new int[n][m][n][m];
    52.         // 每个节点都有dir4个方向的移动，分别是  下右上左   
    53.         int[][] movedir=new int[][]{{1,0},{0,1},{-1,0},{0,-1}};  
    54.  
    55.         Queue&lt;Node&gt; que=new LinkedList&lt;&gt;();  //利用队列实现BFS
    56.         start.step=0;
    57.         que.add(start);
    58.  
    59.         //开始BFS广度搜索最短路径
    60.         while(!que.isEmpty()){
    61.             Node cur=que.poll();
    62.             int newBx=cur.bx;
    63.             int newBy=cur.by;
    64.             for(int i=0;i&lt;4;i++){  // 向4个方向走
    65.  
    66.                 //人在箱子左边或右边
    67.                 if(cur.px==cur.bx){
    68.  
    69.                      if (cur.py+movedir[i][1]==cur.by){
    70.                          newBy = cur.by+movedir[i][1];
    71.                      }else{
    72.                          newBy = cur.by;
    73.                      }
    74.  
    75.                 }  
    76.  
    77.               //人在箱子上面或下面 
    78.                 if(cur.py==cur.by){
    79.                     if(cur.px+movedir[i][0]==cur.bx){
    80.                         newBx = cur.bx+movedir[i][0];
    81.                     }else{
    82.                         newBx = cur.bx;
    83.                     }
    84.                }
    85.  
    86.  
    87.                 // 箱子找到了要随人往4个方向动；没找到则箱子不动人动
    88.                 Node next=new Node(cur.px+movedir[i][0], cur.py+movedir[i][1],newBx,newBy); 
    89.                 //不能让人在没找到箱子之前出地图或者自己提前到目的地
    90.                 if(next.px&lt;0||next.px&gt;=n||next.py&lt;0||next.py&gt;=m||chas[next.px][next.py]==&#39;#&#39;   
    91.                         ||next.bx&lt;0||next.bx&gt;=n||next.by&lt;0||next.by&gt;=m
    92.                         ||chas[next.bx][next.by]==&#39;#&#39;){
    93.                     continue;
    94.                 }
    95.  
    96.                 // 0说明这条路径没有走过
    97.                 if(iswalked[next.px][next.py][next.bx][next.by]==0){  
    98.                     iswalked[next.px][next.py][next.bx][next.by]=1;
    99.                     next.step=cur.step+1;
    100.                     if(chas[next.bx][next.by]==&#39;E&#39;){   //此时把箱子推到终点了
    101.                         return next.step;  // 最先到终点的就是最短路径
    102.                     }
    103.                     que.add(next);
    104.                 }
    105.             }
    106.         }
    107.         return -1;
    108.     }
    109.  
    110.  
    111. }

    三、编程题2

    描述

    有n个房间，现在i号房间里的人需要被重新分配，分配的规则是这样的：先让i号房间里的人全都出来，接下来按照 i+1, i+2, i+3, ... 的顺序依此往这些房间里放一个人，n号房间的的下一个房间是1号房间，直到所有的人都被重新分配。

    现在告诉你分配完后每个房间的人数以及最后一个人被分配的房间号x，你需要求出分配前每个房间的人数。数据保证一定有解，若有多解输出任意一个解。

    输入描述：

    第一行两个整数n, x (2<=n<=10^5, 1<=x<=n)，代表房间房间数量以及最后一个人被分配的房间号；
    第二行n个整数 a_i(0<=a_i<=10^9) ，代表每个房间分配后的人数。

    输出描述：

    输出n个整数，代表每个房间分配前的人数。

    示例1

    输入：

    3 1
6 5 1

    输出：

    4 4 4

    题解：

    1. import java.util.Scanner;
    2.  
    3. public class Main {
    4.     public static void main(String[] args) {
    5.         Scanner scanner = new Scanner(System.in);
    6.         int n = scanner.nextInt();
    7.         int x = scanner.nextInt() - 1;
    8.         long[] room = new long[n];
    9.         long min = Long.MAX_VALUE;
    10.         for (int i = 0; i < n; i++) {
    11.             room[i] = scanner.nextInt();
    12.             if (room[i] < min)
    13.                 min = room[i];
    14.         }
    15.         //get min_index
    16.         int minIndex = x;
    17.         while (room[minIndex] != min) {
    18.             minIndex = minIndex > 0 ? minIndex - 1 : n - 1;
    19.         }
    20.         // remove the round number.
    21.         for (int i = 0; i < n; i++) {
    22.             room[i] -= min;
    23.         }
    24.         // remove the tail
    25.         int remain = 0;
    26.         for (int i = x; i != minIndex; i = i > 0 ? i - 1 : n - 1) {
    27.             room[i] -= 1;
    28.             remain += 1;
    29.         }
    30.         room[minIndex] += remain + n * min;
    31.         //print the result
    32.         for (int i = 0; i < n; i++) {
    33.             System.out.print(room[i] + " ");
    34.         }
    35.     }
    36. }

    四、字母交换

    描述

    【编码题】字符串S由小写字母构成，长度为n。定义一种操作，每次都可以挑选字符串中任意的两个相邻字母进行交换。询问在至多交换m次之后，字符串中最多有多少个连续的位置上的字母相同？

     

    输入描述：

    第一行为一个字符串S与一个非负整数m。(1 <= |S| <= 1000, 1 <= m <= 1000000)

    输出描述：

    一个非负整数，表示操作之后，连续最长的相同字母数量。

    示例1

    输入：

    abcbaa 2

    输出：

    2

    说明：

    使2个字母a连续出现，至少需要3次操作。即把第1个位置上的a移动到第4个位置。
所以在至多操作2次的情况下，最多只能使2个b或2个a连续出现。

    题解：

    1. import java.util.*;
    2.  
    3. public class Main{
    4.     static int res = 1;
    5.     public static void main(String[] args){
    6.         
    7.         Scanner scanner = new Scanner(System.in);
    8.         String input = scanner.nextLine();
    9.         String str = input.split(" ")[0];
    10.         int m = Integer.parseInt(input.split(" ")[1]);
    11.         
    12.         HashMap> map = new HashMap<>();
    13.         char[] chars = str.toCharArray();
    14.         int len = chars.length;
    15.         
    16.         for(int i = 0; i < len; i++){
    17.             List list = map.getOrDefault(chars[i], new ArrayList<>());
    18.             list.add(i);
    19.             map.put(chars[i], list);
    20.         }
    21.         
    22.         for(int i = 0; i < len; i++){
    23.             char c = chars[i];
    24.             List list = map.get(c);
    25.             moveTogether(list, i, m);
    26.             /*
    27.             int lessCount = 0;
    28.             for(int num : list){
    29.                 if(num < i){
    30.                     lessCount++;
    31.                 }
    32.                 else{
    33.                     break;
    34.                 }
    35.             }
    36.             int greatCount = list.size()-1-lessCount;
    37.             for(int j = 0; j < lessCount; i++){
    38.                 int cur = list.get(j);
    40.                 // 现在这个节点的位置在cur,要移动到          （0 1 j 3 4 ... lessCount-1）i
    41.                 // lesscount-2的时候对应i-2
    42.                 // lesscount-1的时候对应i-1
    43.                 int target = i + j - lessCount;
    44.                 int times = 
    45.             }
    46.         }
    47. */
    48.         
    49.         
    50.         
    51.     }
    52.                 System.out.println(res);
    53.         
    54.   
    55.     
    56.         
    57.     }
    58.             // 在times步内，尽可能把list里面的数字移动到mid周围
    59.         public static void moveTogether(List list, int mid, int times){
    60.             int len = list.size();
    61.             int mid_index = 0;
    62.             for(int i = 0; i < len; i++){
    63.                 if(list.get(i) == mid){
    64.                     mid_index = i;
    65.                     break;
    66.                 }
    67.             }
    68.             int left_index = mid_index-1;
    69.             int right_index = mid_index+1;
    70.             int count = 1;
    71.             // mid为中心的左右边界
    72.             int left_mid = mid-1;
    73.             int right_mid = mid+1;
    74.             while(times > 0){
    75.                 if(left_index < 0 && right_index >= len){
    76.                     break;
    77.                 }
    78.                 
    79.                 // 看一下左边和右边哪个更近一点
    80.                 int left_dist;
    81.                 if(left_index < 0)    
    82.                     left_dist = Integer.MAX_VALUE / 2;
    83.                 else    
    84.                     left_dist = left_mid - list.get(left_index);
    85.                 int right_dist;
    86.                 if(right_index >= len)   {
    87.                     right_dist = Integer.MAX_VALUE / 2;
    88.                 } 
    89.                 else {
    90.                     right_dist = list.get(right_index) - right_mid; 
    91.                 }    
    92.                    
    93.                 if(left_dist > right_dist){
    94.                     // 右边靠更加近一点
    95.                     if(times < right_dist)    break;
    96.                     times -= right_dist;
    97.                     right_mid++;
    98.                     count++;
    99.                     right_index++;
    100.                 }
    101.                 else{
    102.                     if(times < left_dist)    break;
    103.                     times -= left_dist;
    104.                     left_mid--;
    105.                     left_index--;
    106.                     count++;
    107.                 }
    108.             }
    109.             res = Math.max(count, res);
    110.         }
    111.   
    112. }

    总结

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

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

    7cc054e25bd74ac5ac50a80eeaa75007.png​


    3f4a7ec59ab74179aee554dc3ed7a166.jpeg

     

     

     

  • 相关阅读:
    十四、应用监控（1）
    「程序员必须掌握的算法」动态规划「上篇」
    串口通信-USART和UART的区别
    【Hello Algorithm】贪心算法
    Java实现byte数组与Hex互转
    大模型分布式训练并行技术（一）-概述
    fatal error: exception: No such file or directory
    INVETA peer-stream 自述文件
    11-golang流程控制
    MySQL数据库之用户管理
  • 原文地址：https://blog.csdn.net/m0_63947499/article/details/125951072