【荣耀笔试题汇总】2024-05-11-荣耀春招笔试题-三语言题解(CPP/Python/Java)

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

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

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

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

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

文章目录

- 📷 01.K小姐的字符串分类
- - 问题描述
  - 输入格式
  - 输出格式
  - 样例输入
  - 样例输出
  - 数据范围
  - 题解
  - 参考代码
  - 参考代码
- 📸 02.弗洛伊德的游戏
- - 题目描述
  - 输入格式
  - 输出格式
  - 样例输入
  - 样例输出
  - 数据范围
  - 题解
  - 参考代码
- 📹 03.字符串的循环移位包含问题
- - 问题描述
  - 输入格式
  - 输出格式
  - 样例输入
  - 样例输出
  - 数据范围
  - 题解
  - 参考代码
- 写在最后
- 📧 清隆这边最近正在收集近一年互联网各厂的笔试题汇总，如果有需要的小伙伴可以关注后私信一下清隆领取，会在飞书进行同步的跟新。

📷 01.K小姐的字符串分类

问题描述

K小姐是一位热爱编程的软件工程师，她最近在处理一批字符串数据时遇到了一些问题。这些字符串包含了合法和非法字符，合法字符包括数字（0-9）、小写字母（a-z）和大写字母（A-Z）。K小姐需要你帮助她编写一个程序，将这些字符串分类为合法字符串和非法字符串，并去除重复的合法字符串。

输入格式

输入包含多行，每行一个字符串。字符串的总数不超过 100，每个字符串的长度不超过 64。

输出格式

第一行输出所有合法且无重复的字符串，字符串之间用一个空格分隔。第二行输出所有非法的字符串，可能包含重复，同样用一个空格分隔。

样例输入

abc
def
151 1
acd123
44234tjg
aga'.
ad--s
abd
123
abcdef
1234567890123456789012345678901234567890123456789012345678901234
EDFG
SDFG
ABC
DEF
CCCC
a*b=1

样例输出

abc def acd123 44234tjg abd 123 abcdef 1234567890123456789012345678901234567890123456789012345678901234 EDFG SDFG ABC DEF CCCC
aga' ad--s a*b=1

数据范围

字符串数量不超过 100。
每个字符串长度不超过 64。

题解

本题主要考察字符串处理和集合的使用。首先，我们需要判断每个字符串是否为合法字符串。合法字符串只包含数字和字母。我们可以通过遍历字符串中的每个字符，检查它是否为字母或数字来完成这一判断。对于合法的字符串，我们使用一个集合来存储，以便去除重复项。对于非法的字符串，我们直接存入另一个列表。最后，按照题目要求输出这两个列表。

参考代码

Python

def process_strings():
    import sys
    input = sys.stdin.read
    data = input().splitlines()
    
    valid_set = set()
    valid_list = []
    invalid_list = []
    
    for s in data:
        if all(c.isalnum() for c in s):
            if s not in valid_set:
                valid_list.append(s)
                valid_set.add(s)
        else:
            invalid_list.append(s)
    
    print(" ".join(valid_list))
    print(" ".join(invalid_list))

if __name__ == "__main__":
    process_strings()

Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Set<String> validSet = new HashSet<>();
        List<String> validList = new ArrayList<>();
        List<String> invalidList = new ArrayList<>();
        
        while (scanner.hasNextLine()) {
            String s = scanner.nextLine();
            boolean isValid = true;
            for (int i = 0; i < s.length(); i++) {
                char ch = s.charAt(i);
                if (!Character.isLetterOrDigit(ch)) {
                    isValid = false;
                    break;
                }
            }
            if (isValid) {
                if (!validSet.contains(s)) {
                    validList.add(s);
                    validSet.add(s);
                }
            } else {
                invalidList.add(s);
            }
        }
        
        for (int i = 0; i < validList.size(); i++) {
            if (i > 0) System.out.print(" ");
            System.out.print(validList.get(i));
        }
        System.out.println();
        for (int i = 0; i < invalidList.size(); i++) {
            if (i > 0) System.out.print(" ");
            System.out.print(invalidList.get(i));
        }
        System.out.println();
        scanner.close();
    }
}

#include <iostream>
#include <set>
#include <vector>
#include <cctype>
using namespace std;

int main() {
    set<string> validSet;
    vector<string> validList, invalidList;
    string s;
    while (cin >> s) {
        bool isValid = true;
        for (char ch : s) {
            if (!isalpha(ch) && !isdigit(ch)) {
                isValid = false;
                break;
            }
        }
        if (isValid) {
            if (validSet.find(s) == validSet.end()) {
                validList.push_back(s);
                validSet.insert(s);
            }
        } else {
            invalidList.push_back(s);
        }
    }
    for (int i = 0; i < validList.size(); i++) {
        if (i > 0) cout << " ";
        cout << validList[i];
    }
    cout << endl;
    for (int i = 0; i < invalidList.size(); i++) {
        if (i > 0) cout << " ";
        cout << invalidList[i];
    }
    cout << endl;
    return 0;
}

📸 02.弗洛伊德的游戏

题目描述

K小姐和A先生在玩一个有趣的游戏。游戏在一个 $\times m$ 的矩阵上进行，矩阵的每个元素都是一个复数。K小姐先写下一个 $\times 2$ 的矩阵 $U$ ，每一行表示一个复数，第一列为实部，第二列为虚部。接下来轮到A先生，他需要写下 $m$ 个 $\times 2$ 的矩阵 $V_1, V_2, \ldots, V_m$ ，每个矩阵的形式与 $U$ 相同。

游戏的目标是找到一个与 $U$ 的内积最小的矩阵 $V_i$ ，其中内积的定义为：

$\langle U, V_i \rangle = \sum\limits_{j=1}^n (U_{j1}V_{ij1} - U_{j2}V_{ij2}) + i(U_{j1}V_{ij2} + U_{j2}V_{ij1})$

其中 $i$ 为虚数单位， $U_{jk}$ 表示矩阵 $U$ 第 $j$ 行第 $k$ 列的元素， $V_{ijk}$ 表示矩阵 $V_i$ 第 $j$ 行第 $k$ 列的元素。

现在给定矩阵 $U$ 和 $V_1, V_2, \ldots, V_m$ ，请你帮助K小姐找到答案。

输入格式

第一行包含两个正整数 $n, m$ ，分别表示 $U$ 的行数和 $V$ 的个数。

接下来 $n$ 行，每行包含两个实数，表示 $U$ 中的一行。

接下来 $m$ 个 $\times 2$ 的矩阵，每个矩阵的格式与 $U$ 相同，表示 $V_1, V_2, \ldots, V_m$ 。

输出格式

输出一个整数，表示答案矩阵 $V_i$ 的编号（从 $0$ 开始编号）。

样例输入

2 3
1.0 0
0.9 -0.3
0.6 0.3
0.8 -0.1
0.5 0.2
0.3 -0.2
2 -0.6
0.5 -0.9
0.5 0.8
0 -0.6
0.9 -0.5
0.8 -0.9

样例输出

数据范围

$\leq n,m \leq 1000$
$\leq$ 矩阵元素的绝对值 $\leq 1000$

题解

这道题可以直接暴力求解。我们枚举每一个矩阵 $V_i$ ，计算其与 $U$ 的内积，取内积最小的矩阵编号作为答案即可。

计算内积的时候，我们可以直接根据公式展开计算。设 $U$ 的第 $j$ 行为 $a_j, b_j)$ ， $V_i$ 的第 $j$ 行为 $c_j, d_j)$ ，那么：

$a_j+b_ji)(c_j+d_ji)=a_jc_j-b_jd_j+(a_jd_j+b_jc_j)i$

将所有的实部求和即为内积的实部，虚部求和即为内积的虚部。最后取复数模长的平方作为内积的大小。

时间复杂度 $O (nm)$ ，空间复杂度 $O (n)$ 。

参考代码

Python

n, m = map(int, input().split())
u = [list(map(float, input().split())) for _ in range(n)]

ans = 0
min_prod = float("inf")
for i in range(m):
    v = [list(map(float, input().split())) for _ in range(n)]
    real = sum(u[j][0]*v[j][0] - u[j][1]*v[j][1] for j in range(n))
    imag = sum(u[j][0]*v[j][1] + u[j][1]*v[j][0] for j in range(n))
    prod = real*real + imag*imag
    if prod < min_prod:
        min_prod = prod
        ans = i

print(ans)

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(), m = sc.nextInt();
        double[][] u = new double[n][2];
        for (int i = 0; i < n; i++) {
            u[i][0] = sc.nextDouble();
            u[i][1] = sc.nextDouble();
        }

        int ans = 0;
        double minProd = Double.POSITIVE_INFINITY;
        for (int i = 0; i < m; i++) {
            double[][] v = new double[n][2];
            for (int j = 0; j < n; j++) {
                v[j][0] = sc.nextDouble();
                v[j][1] = sc.nextDouble();
            }

            double real = 0, imag = 0;
            for (int j = 0; j < n; j++) {
                real += u[j][0] * v[j][0] - u[j][1] * v[j][1];
                imag += u[j][0] * v[j][1] + u[j][1] * v[j][0];
            }

            double prod = real * real + imag * imag;
            if (prod < minProd) {
                minProd = prod;
                ans = i;
            }
        }

        System.out.println(ans);
    }
}

#include <iostream>
#include <vector>
#include <array>
using namespace std;

int main() {
    int n, m;
    cin >> n >> m;
    vector<array<double, 2>> u(n);
    for (int i = 0; i < n; i++) {
        cin >> u[i][0] >> u[i][1];
    }

    int ans = 0;
    double minProd = 1e18;
    for (int k = 0; k < m; k++) {
        vector<array<double, 2>> v(n);
        for (int i = 0; i < n; i++) {
            cin >> v[i][0] >> v[i][1];
        }

        double real = 0, imag = 0;
        for (int i = 0; i < n; i++) {
            real += u[i][0] * v[i][0] - u[i][1] * v[i][1];
            imag += u[i][0] * v[i][1] + u[i][1] * v[i][0];
        }

        double prod = real * real + imag * imag;
        if (prod < minProd) {
            minProd = prod;
            ans = k;
        }
    }
    cout << ans << endl;
    return 0;
}

📹 03.字符串的循环移位包含问题

问题描述

K小姐非常喜欢字符串游戏。最近，她发明了一种新的字符串操作方法：“循环移位”。

对于一个字符串，每执行一次"循环移位"操作，就会将字符串的第一个字符移动到最后一个字符的位置，其他字符的相对顺序保持不变。例如，对于字符串 $A b cD$ ，执行一次"循环移位"操作后，它将变成 $b cD A$ 。如果继续执行"循环移位"操作，字符串将依次变成 $cD A b$ 、 $D A b c$ 和 $A b cD$ 。

现在，K小姐有两个字符串 $S$ （源字符串）和 $T$ （目标字符串）。她想知道，源字符串 $S$ 经过若干次"循环移位"操作后，是否可以得到一个包含目标字符串 $T$ 的字符串。

输入格式

输入共 $6$ 行，包含三组测试数据，每组数据占两行。

对于每组测试数据：

第一行为源字符串 $S$ ；
第二行为目标字符串 $T$ 。

输出格式

输出共一行，包含三个数字，表示每组测试数据的答案。

对于每组测试数据：

如果源字符串 $S$ 经过若干次"循环移位"操作后，可以得到一个包含目标字符串 $T$ 的字符串，则输出 $1$ ；
否则，输出 $0$ 。

样例输入

AABCD
CDAA
AABCD
ABCD
AABCD
CFS

样例输出

数据范围

字符串 $S$ 和 $T$ 的长度均不超过 $100$ 。
字符串中只包含大写英文字母。

题解

本题可以通过字符串匹配的方法来解决。具体思路如下：

对于每组测试数据，首先判断目标字符串 $T$ 的长度是否大于源字符串 $S$ 的长度。如果大于，则源字符串 $S$ 无论经过多少次"循环移位"操作，都无法得到一个包含目标字符串 $T$ 的字符串，直接输出 $0$ 。
如果目标字符串 $T$ 的长度不大于源字符串 $S$ 的长度，则将源字符串 $S$ 复制一份，拼接在原字符串的后面，得到一个新的字符串 $S^{'}$ 。
在新字符串 $S^{'}$ 中查找目标字符串 $T$ ，如果能够找到，则说明源字符串 $S$ 经过若干次"循环移位"操作后，可以得到一个包含目标字符串 $T$ 的字符串，输出 $1$ ；否则，输出 $0$ 。

时间复杂度： $O (n)$ ，其中 $n$ 为源字符串 $S$ 的长度。
空间复杂度： $O (n)$ ，需要额外的空间存储新字符串 $S^{'}$ 。

参考代码

Python

n = 3
res = ''

for i in range(n):
    a = input().strip()
    b = input().strip()
    
    if len(b) > len(a):
        res += '0'
        continue
    
    a += a
    if b in a:
        res += '1'
    else:
        res += '0'

print(res)

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = 3;
        StringBuilder res = new StringBuilder();

        for (int i = 0; i < n; i++) {
            String a = sc.nextLine();
            String b = sc.nextLine();

            if (b.length() > a.length()) {
                res.append('0');
                continue;
            }

            a += a;
            if (a.contains(b)) {
                res.append('1');
            } else {
                res.append('0');
            }
        }

        System.out.println(res.toString());
    }
}

#include <iostream>
#include <string>

using namespace std;

int main() {
    int n = 3;
    string res = "";

    for (int i = 0; i < n; i++) {
        string a, b;
        cin >> a >> b;

        if (b.size() > a.size()) {
            res += '0';
            continue;
        }

        a += a;
        if (a.find(b) != string::npos) {
            res += '1';
        } else {
            res += '0';
        }
    }

    cout << res << endl;

    return 0;
}