🍭 大家好这里是清隆学长 ，一枚热爱算法的程序员

✨ 本系列打算持续跟新荣耀近期的春秋招笔试题汇总～

💻 ACM银牌🥈| 多次AK大厂笔试 ｜ 编程一对一辅导

👏 感谢大家的订阅➕ 和 喜欢💗

📧 清隆这边最近正在收集近一年互联网各厂的笔试题汇总，如果有需要的小伙伴可以关注后私信一下 清隆领取，会在飞书进行同步的跟新。

🚗 01.K小姐的数字游戏

题目描述

K小姐非常喜欢玩数字游戏。这一次，她想要判断给定的数字序列是否满足特定的规则。

存在多个数字序列，每个数字序列由 $N$ 个正整数组成，数字之间以空格隔开，并且这些数字都大于 $0$ 小于 $100$。

规则如下：

1. 如果相邻的数字是两位数和一位数交替出现，则该序列是合法的。
2. 如果序列中第一个和最后一个数是两位数，且中间数字都是一位数，则序列是合法的。
3. 如果序列中第一个和最后一个是一位数，且中间数字都是两位数，则序列是合法的。

输入格式

输入多个数字序列，每个数字序列独占一行。每个数字序列由 $N$ 个正整数组成，所有整数都大于 $0$ 小于 $100$，每个整数之间由空格分隔，$2\le N\le 100$。输入保证合法。

输出格式

校验多个数字序列是否合法，合法时返回 true，不合法时返回 false。校验结果用空格分开，行末无多余空格。

样例输入

1 23 3 42 3 56
44 1 5 71 9 35

样例输出

true false

数据范围

$2\le N\le 100$，序列中的数字均为大于 $0$ 小于 $100$ 的正整数。

题解

本题可以通过遍历序列，判断相邻数字的位数是否满足题目要求来解决。具体思路如下：

1. 遍历整个序列，判断相邻数字的位数是否交替出现。如果出现相邻数字位数相同的情况，则将 flg[0] 置为 $0$，表示不满足规则 $1$。
2. 统计序列中每个数字的位数，并使用 Counter 统计不同位数的数量。
3. 判断序列的第一个和最后一个数字的位数是否相同，且该位数在序列中只出现了两次。如果满足条件，则将 flg[1] 置为 $1$，表示满足规则 $2$ 或规则 $3$。
4. 最后，如果 flg 中存在 $1$，则说明序列合法，返回 true；否则返回 false。

参考代码

• Python

from collections import Counter

while True:
    try:
        s = list(map(str, input().split()))
        
        def check(s):
            n = len(s)
            flg = [1, 0]
            
            for i in range(n - 1):
                a, b = s[i], s[i + 1]
                if len(a) == len(b):
                    flg[0] = 0
                    break
            
            sz = [len(val) for val in s]
            d = Counter(sz)
            
            if sz[0] == sz[-1] and d[sz[0]] == 2:
                flg[1] = 1
            
            return max(flg) >= 1
        
        print('true' if check(s) else 'false', end=' ')
    except:
        break

• Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        while (sc.hasNextLine()) {
            String[] s = sc.nextLine().split(" ");
            boolean res = check(s);
            System.out.print(res ? "true " : "false ");
        }
    }
    
    private static boolean check(String[] s) {
        int n = s.length;
        int[] flg = {1, 0};
        
        for (int i = 0; i < n - 1; i++) {
            String a = s[i], b = s[i + 1];
            if (a.length() == b.length()) {
                flg[0] = 0;
                break;
            }
        }
        
        int[] sz = new int[n];
        for (int i = 0; i < n; i++) {
            sz[i] = s[i].length();
        }
        
        Map<Integer, Integer> d = new HashMap<>();
        for (int num : sz) {
            d.put(num, d.getOrDefault(num, 0) + 1);
        }
        
        if (sz[0] == sz[n - 1] && d.get(sz[0]) == 2) {
            flg[1] = 1;
        }
        
        return Math.max(flg[0], flg[1]) >= 1;
    }
}

• Cpp

#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
using namespace std;

bool check(vector<string>& s) {
    int n = s.size();
    int flg[2] = {1, 0};
    
    for (int i = 0; i < n - 1; i++) {
        string a = s[i], b = s[i + 1];
        if (a.length() == b.length()) {
            flg[0] = 0;
            break;
        }
    }
    
    vector<int> sz(n);
    for (int i = 0; i < n; i++) {
        sz[i] = s[i].length();
    }
    
    unordered_map<int, int> d;
    for (int num : sz) {
        d[num]++;
    }
    
    if (sz[0] == sz[n - 1] && d[sz[0]] == 2) {
        flg[1] = 1;
    }
    
    return max(flg[0], flg[1]) >= 1;
}

int main() {
    string line;
    while (getline(cin, line)) {
        vector<string> s;
        int pos = 0;
        while ((pos = line.find(" ")) != string::npos) {
            s.push_back(line.substr(0, pos));
            line.erase(0, pos + 1);
        }
        s.push_back(line);
        
        bool res = check(s);
        cout << (res ? "true " : "false ");
    }
    
    return 0;
}

本题考察对数字序列的判断和统计。通过遍历序列并判断相邻数字的位数关系，再结合对序列中数字位数的统计，可以判断序列是否满足题目给定的规则。题目难度不大，是一道比较基础的字符串处理和统计题目。

🚕 02.K小姐的在线学习系统

题目描述

K小姐的学校有一个在线学习系统，每门课程由 $N(0<N\le 10000)$ 个页面组成，学生需要从第一页开始按顺序学习到最后一页，然后提交学习记录。

系统会记录每个页面停留的时间（单位：秒），当学生提交时会分析时间是否满足要求。分析规则如下：每分钟（60秒）之内学完的页面数不能大于4页。

例如，系统记录到某学生页面停留时间如下：
10 120 10 20 10 10 50
该学生第1分钟学完1页，第2分钟学完0页，第3分钟学完5页，第4分钟学完1页，则判定为不满足要求。

请你帮助K小姐完成检查学生学习时间是否满足要求的程序。

输入格式

第一行包含一个整数 $T$，表示测试数据组数。

对于每组测试数据：
第一行包含一个整数 $N$，表示课程页面数。
第二行包含 $N$ 个整数，表示每个页面的停留时间，以空格分隔。

输出格式

对于每组测试数据，输出一行，如果满足要求则输出1，否则输出0。

样例输入

5
2 10 10
4 10 15 20 30
5 10 10 10 10 10
6 10 20 20 70 10 10
8 10 120 10 10 10 10 10 10

样例输出

1
1
0
1
0

数据范围

• $1\le T\le 10$
• $1\le N\le 10000$
• 每个页面的停留时间不超过 $1000$ 秒。

题解

可以使用一个哈希表来记录每一分钟内学习的页面数量。遍历每个页面的停留时间，累加当前页面的时间，计算出当前页面属于第几分钟，然后在哈希表中将对应分钟的页面数加一。如果发现某一分钟的页面数超过了4，就说明不满足要求，直接返回0。如果遍历完所有页面后没有出现超过4页的情况，则说明满足要求，返回1。

参考代码

• Python

def check_learning_time():
    n = int(input())
    times = list(map(int, input().split()))
    
    page_counts = {}
    cur_time = 0
    
    for time in times:
        cur_time += time
        minute = (cur_time - 1) // 60
        page_counts[minute] = page_counts.get(minute, 0) + 1
        if page_counts[minute] > 4:
            return 0
    
    return 1

t = int(input())
for _ in range(t):
    print(check_learning_time())

• Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = scanner.nextInt();
        
        while (t-- > 0) {
            int n = scanner.nextInt();
            int[] times = new int[n];
            for (int i = 0; i < n; i++) {
                times[i] = scanner.nextInt();
            }
            
            System.out.println(checkLearningTime(times));
        }
    }
    
    private static int checkLearningTime(int[] times) {
        Map<Integer, Integer> pageCounts = new HashMap<>();
        int curTime = 0;
        
        for (int time : times) {
            curTime += time;
            int minute = (curTime - 1) / 60;
            pageCounts.put(minute, pageCounts.getOrDefault(minute, 0) + 1);
            if (pageCounts.get(minute) > 4) {
                return 0;
            }
        }
        
        return 1;
    }
}

• Cpp

#include <iostream>
#include <unordered_map>
using namespace std;

int checkTime() {
    int n;
    cin >> n;
    
    unordered_map<int, int> pageCount;
    int curTime = 0;
    
    for (int i = 0; i < n; i++) {
        int time;
        cin >> time;
        curTime += time;
        int minute = (curTime - 1) / 60;
        pageCount[minute]++;
        if (pageCount[minute] > 4) {
            return 0;
        }
    }
    
    return 1;
}

int main() {
    int t;
    cin >> t;
    
    while (t--) {
        cout << checkTime() << endl;
    }
    
    return 0;
}

🚙 03.元素圈的奇妙组合

题目描述

在 K小姐的魔法世界中，每个法师可以控制多种元素，通过将这些元素排列成一个圈来释放强大的魔法。一个由 $m$ 个元素组成的圈可以通过旋转或翻转得到多种不同的排列，但这些排列在法师看来是等效的。现在给定 $n$ 种不同的元素，要求计算出由这些元素组成的长度为 $m$ 的圈能有多少种本质不同的组合方式。由于结果可能非常大，请输出结果对 $1000000007$ 取模后的值。

输入格式

输入包含两个整数 $n$ 和 $m$。

输出格式

输出一个整数，表示本质不同的组合方式的数量模 $1000000007$。

样例输入

3 3

样例输出

10

数据范围

• $1\le n\le 20000$
• $1\le m\le 10000$

题解

题目可以转化成完全背包求方案数，从 $n$ 个物品中选，每个物品最多选 $m$ 个，求恰好装满容积为 $m$ 的背包的方案数，由于物品的体积为 1 ，所以这里可以看成每个物品可以无限选，即可直接等价为完全背包求方案数。

参考代码

• Cpp

#include<bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n, m;
    cin >> n >> m;
    vector<int> f(m + 1, 0);
    f[0] = 1;
    for (int i = 0; i < n; i++)
        for (int j = 1; j <= m; j++) {
            f[j] += f[j - 1];
            if (f[j] >= MOD) f[j] -= MOD;
        }
    cout << f[m] << "\n";
    return 0;
}

• Python

MOD = 1000000007

def main():
    import sys
    input = sys.stdin.read
    n, m = map(int, input().split())
    f = [0] * (m + 1)
    f[0] = 1
    for _ in range(n):
        for j in range(1, m + 1):
            f[j] = (f[j] + f[j - 1]) % MOD
    print(f[m])

if __name__ == "__main__":
    main()

• Java

import java.util.*;
import java.io.*;

public class Main {
    static final int MOD = 1000000007;

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String[] tokens = reader.readLine().split(" ");
        int n = Integer.parseInt(tokens[0]);
        int m = Integer.parseInt(tokens[1]);
        int[] f = new int[m + 1];
        f[0] = 1;
        for (int i = 0; i < n; i++) {
            for (int j = 1; j <= m; j++) {
                f[j] = (f[j] + f[j - 1]) % MOD;
            }
        }
        System.out.println(f[m]);
    }
}

写在最后

📧 清隆这边最近正在收集近一年互联网各厂的笔试题汇总，如果有需要的小伙伴可以关注后私信一下 清隆领取，会在飞书进行同步的跟新。