笔试时间：2024年08月12日

历史笔试传送门：2023秋招笔试合集

第一题

题目

设计一个游戏角色的装备系统，系统可以包含合成装备以及独立装备，这里的合成装备，可以继续包含独立装备以及合成装备。战力系数是装备在系统里面的嵌套合成数，装备的战力系数越高，表示战力越高，请计算出整个系统里面装备的战力和。

提示:战力=装备力*嵌套合成数。

样例输入一

[1,[4,[6]]]

样例输出一

27

说明

解释:一个嵌套合成数为1，战力为1的装备，一个嵌套合成数为2，战力为4的装备，一个嵌套合成数为3，战力为6的装备。所以1+4*2+6*3=27。

样例输入二

[[1,1],2,[1,1]]

样例输出二

10

说明

因为装备中有四个嵌套合成数为2，战力为1的装备;和一个嵌套合成数为1，战力为2的装备。

参考题解

由于读入是字符串，从前往后遍历字符串，遇到"["深度加1，遇到"]"深度减1，遍历到数字往后找到数字的右边界，然后累加当前数字乘以深度到答案上。

C++：[此代码未进行大量数据的测试，仅供参考]

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;

int main() {
    string s;
    cin >> s;
    int left_cnt = 0;
    string cur_int = "";
    int res = 0;
    for (int i = 0; i < s.length(); i++) {
        if (s[i] == '[') {
            left_cnt++;
        } else if (s[i] == ']') {

            if (cur_int == "") {
                left_cnt--;
                continue;
            }
            res += stoi(cur_int) * left_cnt;
            left_cnt--;
            cur_int = "";
        } else if (s[i] == ',') {
            if (cur_int == "") {
                continue;
            }
            res += stoi(cur_int) * left_cnt;
            cur_int = "";
        } else {
            cur_int += s[i];
        }
    }
    cout << res;
    return 0;
}

Java：[此代码未进行大量数据的测试，仅供参考]

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        int leftCnt = 0;
        String curInt = "";
        int res = 0;
        
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '[') {
                leftCnt++;
            } else if (s.charAt(i) == ']') {
                if (curInt.equals("")) {
                    leftCnt--;
                    continue;
                }
                res += Integer.parseInt(curInt) * leftCnt;
                leftCnt--;
                curInt = "";
            } else if (s.charAt(i) == ',') {
                if (curInt.equals("")) {
                    continue;
                }
                res += Integer.parseInt(curInt) * leftCnt;
                curInt = "";
            } else {
                curInt += s.charAt(i);
            }
        }
        
        System.out.println(res);
        scanner.close();
    }
}

Python：[此代码未进行大量数据的测试，仅供参考]

def main():
    s = input()
    left_cnt = 0
    cur_int = ""
    res = 0
    
    for i in range(len(s)):
        if s[i] == '[':
            left_cnt += 1
        elif s[i] == ']':
            if cur_int == "":
                left_cnt -= 1
                continue
            res += int(cur_int) * left_cnt
            left_cnt -= 1
            cur_int = ""
        elif s[i] == ',':
            if cur_int == "":
                continue
            res += int(cur_int) * left_cnt
            cur_int = ""
        else:
            cur_int += s[i]
    
    print(res)

if __name__ == "__main__":
    main()

第二题

题目

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会白动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下，今晚能够偷窃到的最高金额。

请按照如下代码模板格式编写代码：

class Solution {
    public int rob(int[] nums) {

    }
}

样例输入一

nums =[2, 3, 2]

样例输出一

3

解释:

你不能先偷窃1号房屋(金额=2)，然后偷窃3号房屋(金额=2),因为他们是相邻的。

样例输入二

nums =[1, 2, 3, 1]

样例输出二

4

解释:

你可以先偷窃1号房屋(金额=1)，然后偷窃3号房屋(金额= 3)偷窃到的最高金额为1+3=4。

参考题解

打家劫舍，leetcode原题。

C++:[此代码未进行大量数据的测试，仅供参考]

#include <vector>
#include <algorithm>
using namespace std;

class Solution {
public:
    int rob(vector<int>& nums) {
        int length = nums.size();
        if (length == 1) {
            return nums[0];
        } else if (length == 2) {
            return max(nums[0], nums[1]);
        }
        return max(robRange(nums, 0, length - 2), robRange(nums, 1, length - 1));
    }

private:
    int robRange(vector<int>& nums, int start, int end) {
        int first = nums[start];
        int second = max(nums[start], nums[start + 1]);
        for (int i = start + 2; i <= end; i++) {
            int temp = second;
            second = max(first + nums[i], second);
            first = temp;
        }
        return second;
    }
};

Java：[此代码未进行大量数据的测试，仅供参考]

class Solution {
    public int rob(int[] nums) {
        int length = nums.length;
        if (length == 1) {
            return nums[0];
        } else if (length == 2) {
            return Math.max(nums[0], nums[1]);
        }
        return Math.max(robRange(nums, 0, length - 2), robRange(nums, 1, length - 1));
    }

    public int robRange(int[] nums, int start, int end) {
        int first = nums[start], second = Math.max(nums[start], nums[start + 1]);
        for (int i = start + 2; i <= end; i++) {
            int temp = second;
            second = Math.max(first + nums[i], second);
            first = temp;
        }
        return second;
    }
}

Python：[此代码未进行大量数据的测试，仅供参考]

class Solution:
    def rob(self, nums: List[int]) -> int:
        length = len(nums)
        if length == 1:
            return nums[0]
        elif length == 2:
            return max(nums[0], nums[1])
        return max(self.rob_range(nums, 0, length - 2), self.rob_range(nums, 1, length - 1))

    def rob_range(self, nums: List[int], start: int, end: int) -> int:
        first = nums[start]
        second = max(nums[start], nums[start + 1])
        for i in range(start + 2, end + 1):
            temp = second
            second =