用友集团2023届秋招Java笔试-B卷 代码题答案

用友集团2023届秋招Java笔试-B卷

题目来源：牛客网公司真题_免费模拟题库_企业面试|笔试真题 (nowcoder.com)

23题

数字缩圈

将从1开始依次增加的n个整数（n为[1,52]之间的整数），以给定的顺序顺时针围成一个圆圈。在这个圆圈中找到数字1并将其移出圆圈，然后顺时针寻找下一个除4余2的数字并将其移出圆圈，然后顺时针寻找下一个除4余3的数字并将其移出圆圈，然后顺时针寻找下一个能被4整除的数字并将其移出圆圈，然后顺时针寻找下一个除4余1的数字并将其移出圆圈……最后“圆圈”只会剩下一个数字，返回这个数字的值。

示例1

输入例子：

[2,4,1,3]

输出例子：

4

示例2

输入例子：

[9,8,7,6,5,4,3,2,1]

输出例子：

9

答案

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param circle int整型一维数组
     * @return int整型
     */
    public int shrinkCircle(int[] circle) {
        List<Integer> list = new ArrayList<>();
        for (int num : circle) {
            list.add(num);
        }
        int i = 0;
        int flag = 0;
        while (list.size() > 1) {
            switch (flag) {
                case 0:
                    if (list.size() == circle.length) {
                        for (int j = 0; j < list.size(); j++, i = (i + 1) % list.size()) {
                            if (list.get(i) == 1) {
                                list.remove(i);
                                if (i == list.size()) {
                                    i = 0;
                                }
                                break;
                            }
                        }
                    } else {
                        for (int j = 0; j < list.size(); j++, i = (i + 1) % list.size()) {
                            if (list.get(i) % 4 == 1) {
                                list.remove(i);
                                if (i == list.size()) {
                                    i = 0;
                                }
                                break;
                            }
                        }
                    }
                    flag++;
                    break;
                case 1:
                    for (int j = 0; j < list.size(); j++, i = (i + 1) % list.size()) {
                        if (list.get(i) % 4 == 2) {
                            list.remove(i);
                            if (i == list.size()) {
                                i = 0;
                            }
                            break;
                        }
                    }
                    flag++;
                    break;
                case 2:
                    for (int j = 0; j < list.size(); j++, i = (i + 1) % list.size()) {
                        if (list.get(i) % 4 == 3) {
                            list.remove(i);
                            if (i == list.size()) {
                                i = 0;
                            }
                            break;
                        }
                    }
                    flag++;
                    break;
                case 3:
                    for (int j = 0; j < list.size(); j++, i = (i + 1) % list.size()) {
                        if (list.get(i) % 4 == 0) {
                            list.remove(i);
                            if (i == list.size()) {
                                i = 0;
                            }
                            break;
                        }
                    }
                    flag = 0;
                    break;
                default:
            }
        }
        return list.get(0);
    }
}

24题

统计所有可行路径的数目

在一个三维直角坐标系中，有一只蚂蚁从原点 (0, 0, 0) 开始，向目标点 (l, m, n) 前进，蚂蚁的前进规则如下：

1、l, m, n >= 0，且 l + m + n > 0；

2、蚂蚁每次只能沿X/Y/Z轴的方向前进一个单位，比如，当前蚂蚁在点(x0, y0, z0)，下一步只能前进到下面三个点中的任意一个：(x0 + 1, y0, z0)，或(x0, y0 + 1, z0)，或(x0, y0, z0 + 1)。

返回所有可以从原点 (0, 0, 0) 到目标点 (l, m, n) 的可行路径数量。

说明：代码中所有的数值最大不会超过Long.MAX_VALUE。

示例1

输入例子：

1,0,0

输出例子：

1

例子说明：

原点 (0, 0, 0) 到目标点 (1, 0, 0)的所有可行路径只有1条：
1、(0, 0, 0) -> (1, 0, 0)

示例2

输入例子：

1,1,0

输出例子：

2

例子说明：

原点 (0, 0, 0) 到目标点 (1, 1, 0)的所有可行路径有2条：
1、(0, 0, 0) -> (1, 0, 0) -> (1, 1, 0)
2、(0, 0, 0) -> (0, 1, 0) -> (1, 1, 0)

示例3

输入例子：

1,1,1

输出例子：

6

例子说明：

原点 (0, 0, 0) 到目标点 (1, 1, 1)的所有可行路径有6条：
1、(0, 0, 0) -> (1, 0, 0) -> (1, 1, 0) -> (1, 1, 1)
2、(0, 0, 0) -> (0, 1, 0) -> (1, 1, 0) -> (1, 1, 1)

3、(0, 0, 0) -> (1, 0, 0) -> (1, 0, 1) -> (1, 1, 1)
4、(0, 0, 0) -> (0, 0, 1) -> (1, 0, 1) -> (1, 1, 1)

5、(0, 0, 0) -> (0, 0, 1) -> (0, 1, 1) -> (1, 1, 1)
6、(0, 0, 0) -> (0, 1, 0) -> (0, 1, 1) -> (1, 1, 1)

答案

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 在一个三维直角坐标系中，有一只蚂蚁从原点 (0, 0, 0) 开始，向目标点 (l, m, n) 前进，蚂蚁的前进规则如下：
    1、l, m, n >= 0，且 l + m + n > 0；
    2、蚂蚁每次只能沿X/Y/Z轴的方向前进一个单位，比如，当前蚂蚁在点(x0, y0, z0)，下一步只能前进到下面三个点中的任意一个：(x0 + 1, y0, z0)，或(x0, y0 + 1, z0)​，或(x0, y0, z0 + 1)​。

    返回所有可以从​原点 (0, 0, 0) 到目标点 (l, m, n) 的​可行路径数量。
     * @param x int整型 目标点的X坐标
     * @param y int整型 目标点的Y坐标
     * @param z int整型 目标点的Z坐标
     * @return long长整型
     */
    public long countPaths(int x, int y, int z) {
        long[][][] dp = new long[x + 1][y + 1][z + 1];
        dp[0][0][0] = 1L;
        for (int i = 0; i <= x; i++) {
            for (int j = 0; j <= y; j++) {
                for (int k = 0; k <= z; k++) {
                    if (i > 0) {
                        dp[i][j][k] += dp[i - 1][j][k];
                    }
                    if (j > 0) {
                        dp[i][j][k] += dp[i][j - 1][k];
                    }
                    if (k > 0) {
                        dp[i][j][k] += dp[i][j][k - 1];
                    }
                }
            }
        }
        return dp[x][y][z];
    }
}

25题

使用动态规划的思想最长上升子序列的长度

给定一个无序的整数数组，找到其中最长上升子序列的长度。

示例:
输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。
说明:
可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。

示例1

输入例子：

[10,9,2,5,3,7,101,18]

输出例子：

4

答案

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param nums int整型一维数组
     * @return int整型
     */
    public int lengthOfList(int[] nums) {
        int[] dp = new int[nums.length];
        int ans = 1;
        Arrays.fill(dp, 1);
        for (int i = 1; i < nums.length; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            ans = Math.max(ans, dp[i]);
        }
        return ans;
    }
}