✅ 秋招备战指南 ✅

💡 学习建议：

• 先尝试独立解题
• 对照解析查漏补缺

🧸 题面描述背景等均已深度改编，做法和题目本质基本保持一致。

🍹 感谢各位朋友们的订阅，你们的支持是我们创作的最大动力

🌸 目前本专栏已经上线160+套真题改编解析，后续会持续更新的

春秋招笔试机考招合集 -> 互联网必备刷题宝典🔗

灵犀

题目一：小兰的魔法咒语编织

1️⃣：统计字符串中 A、L、I 三种字符的个数

2️⃣：按照 A→L→I 的循环顺序依次输出字符，直到所有字符用完

3️⃣：如果没有任何 A、L、I 字符则输出 -1

难度：中等

这道题目的关键在于理解循环输出的含义。不是简单地先输出所有 A，再输出所有 L，最后输出所有 I，而是按照 A→L→I 的顺序循环，每次循环最多输出一个字符。通过简单的计数和循环模拟，可以得到 O(|S|) 的高效解法。

题目二：小基的天空漫步冒险

1️⃣：从起始位置开始，每次可以向前跳 1 步或 2 步

2️⃣：使用贪心策略：优先跳 2 步，不行就跳 1 步

3️⃣：避开雷电云朵，只能降落在安全云朵上

难度：中等

这道题目是典型的贪心算法问题。关键思路是每一步都尽可能跳得更远，这样总的跳跃次数会最少。由于每次都可以选择跳 1 步或 2 步，优先选择跳 2 步不会错过任何更优解，实现 O(n) 的时间复杂度。

题目三：小柯的书籍整理计划

1️⃣：使用栈结构模拟书籍的临时存放区

2️⃣：按顺序处理每本书籍，目标书籍保留，非目标书籍立即丢弃

3️⃣：当处理完所有目标书籍后停止操作

难度：中等偏难

这道题目结合了栈的数据结构和模拟算法。关键观察是目标序列一定是递增的子序列，因此可以按照书籍编号顺序依次处理。对于非目标书籍立即丢弃，对于目标书籍保留在栈中，最终得到正确的序列。算法复杂度为 O(n)。

01. 小兰的魔法咒语编织

问题描述

小兰是一名魔法师，她正在学习编织特殊的魔法咒语。在魔法学院中，有一个特殊的魔法规则：所有的咒语必须按照特定的字母循环顺序来编织，这个顺序是 。

小兰手中有一些包含大写字母的魔法字符串，她需要从这些字符串中提取出 、、 三种字母，并按照魔法规则的循环顺序重新排列，形成新的咒语。

魔法规则如下：

• 按照 的循环顺序依次取字符
• 如果当前需要的字符已经用完，就跳过这个字符，继续下一个
• 当所有的 、、 字符都用完时，咒语编织完成
• 如果输入的字符串中没有任何 、、 字符，则输出

输入格式

第一行包含一个正整数 ，表示有多少个魔法字符串。

接下来 行，每行包含一个由大写字母组成的字符串。

输出格式

对于每个输入的魔法字符串，输出一行表示按照魔法规则编织后的咒语。

如果某个字符串无法编织出咒语（即不包含 、、 中的任何字符），则输出 。

样例输入

4
AALLLII
AAAAOOPLLIII
APOELIETYLI
E

样例输出

ALIALIL
ALIALIAIA
ALILI
-1

数据范围

• 
• 字符串长度

题解

这道题的核心思路比较简单：先统计输入字符串中 、、 三种字符的个数，然后按照 的循环顺序依次输出。

具体步骤如下：

1. 统计字符个数：遍历输入字符串，分别统计 、、 的出现次数。

2. 循环输出：按照 的顺序循环，每次循环尝试输出一个字符：

   • 如果当前字符还有剩余，就输出它并将计数减1
   • 如果当前字符已经用完，就跳过

3. 终止条件：当三种字符都用完时停止循环。

4. 特殊情况：如果最终没有输出任何字符，说明输入字符串不包含这三种字符，输出 。

这个算法的时间复杂度是 ，其中 是输入字符串的长度。因为我们需要遍历一次字符串统计字符个数，然后最多输出 个字符。

关键点在于理解循环的含义：我们不是简单地先输出所有A，再输出所有L，最后输出所有I，而是按照A、L、I的顺序循环，每次循环最多输出一个字符。

参考代码

• Python

import sys
input = lambda: sys.stdin.readline().strip()

def solve():
    n = int(input())
    pattern = "ALI"
    
    for _ in range(n):
        s = input().strip()
        
        # 统计A、L、I的个数
        cnt = [0, 0, 0]  # cnt[0]=A的个数, cnt[1]=L的个数, cnt[2]=I的个数
        for ch in s:
            if ch == 'A':
                cnt[0] += 1
            elif ch == 'L':
                cnt[1] += 1
            elif ch == 'I':
                cnt[2] += 1
        
        # 按照A->L->I的循环顺序输出
        result = []
        while cnt[0] > 0 or cnt[1] > 0 or cnt[2] > 0:
            for i in range(3):  # 0=A, 1=L, 2=I
                if cnt[i] > 0:
                    result.append(pattern[i])
                    cnt[i] -= 1
        
        # 输出结果
        if len(result) == 0:
            print(-1)
        else:
            print(''.join(result))

solve()

• Cpp

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int n;
    cin >> n;
    string chars = "ALI";
    
    while (n--) {
        string s;
        cin >> s;
        
        // 统计A、L、I的个数
        int cnt[3] = {0, 0, 0};  // cnt[0]=A, cnt[1]=L, cnt[2]=I
        for (char ch : s) {
            if (ch == 'A') cnt[0]++;
            else if (ch == 'L') cnt[1]++;
            else if (ch == 'I') cnt[2]++;
        }
        
        // 按照A->L->I循环顺序输出
        string ans = "";
        while (cnt[0] > 0 || cnt[1] > 0 || cnt[2] > 0) {
            for (int i = 0; i < 3; i++) {
                if (cnt[i] > 0) {
                    ans += chars[i];
                    cnt[i]--;
                }
            }
        }
        
        // 输出结果
        if (ans.empty()) {
            cout << -1 << "\n";
        } else {
            cout << ans << "\n";
        }
    }
    
    return 0;
}

• Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String pattern = "ALI";
        
        while (n-- > 0) {
            String s = sc.next();
            
            // 统计A、L、I的个数
            int[] count = new int[3];  // count[0]=A, count[1]=L, count[2]=I
            for (char ch : s.toCharArray()) {
                if (ch == 'A') count[0]++;
                else if (ch == 'L') count[1]++;
                else if (ch == 'I') count[2]++;
            }
            
            // 按照A->L->I循环顺序输出
            StringBuilder result = new StringBuilder();
            while (count[0] > 0 || count[1] > 0 || count[2] > 0) {
                for (int i = 0; i < 3; i++) {
                    if (count[i] > 0) {
                        result.append(pattern.charAt(i));
                        count[i]--;
                    }