华为OD机试 2024E卷题库疯狂收录中，刷题++点这里++
专栏导读
本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。
一、题目描述
给定一个非空字符串Q S，其被N个'-'分隔成N+1的子串，给定正整数K，要求除第一个子串外，其余的串每K个用'-'分隔，并将小写字母转换为大写。
二、输入描述
正整数K和'-'分割的字符串，如：
2
25G3C-abc-d
三、输出描述
转换后的字符串
四、测试用例
测试用例1：
1、输入
4
5F3Z-2e-9-w
2、输出
5F3Z-2E9W
3、说明
字符串S被分成了两个部分，每部分4个字符；注意，两个额外的破折号需要删掉。
测试用例2：
1、输入
2
2-5g-3-J
2、输出
2-5G-3J
3、说明
字符串S被分成了3个部分，第一部分的字符可以少于给定的数量，其余部分为2个字符。
五、解题思路
- 分割字符串：首先根据 '-' 将输入字符串分割成多个子串。
- 处理第一个子串：保留第一个子串，但将其中的小写字母转换为大写。
- 处理剩余子串：
- 将剩余的子串连接成一个连续的字符串。
- 将该字符串中的小写字母转换为大写。
- 根据给定的正整数 K，每 K 个字符插入一个 '-' 作为分隔符。
- 组合结果：将处理后的第一个子串和剩余子串组合起来，中间用 '-' 连接。
六、Python算法源码
python
# 导入sys模块以读取标准输入
import sys
def to_upper_case_string(s):
"""
将字符串中的小写字母转换为大写。
:param s: 输入字符串
:return: 转换后的字符串
"""
return s.upper()
def split_by_k(s, K):
"""
根据给定的K值，将字符串每K个字符分隔一次。
:param s: 输入字符串
:param K: 分隔长度
:return: 分隔后的字符串
"""
parts = [] # 存储分隔后的部分
length = len(s) # 获取字符串长度
for i in range(0, length, K):
# 确保不会越界
if i + K > length:
parts.append(s[i:]) # 添加剩余的子串
else:
parts.append(s[i:i+K]) # 添加K个字符的子串
# 使用'-'连接分隔后的部分
return '-'.join(parts)
def main():
# 读取所有输入并按行分割
input_lines = sys.stdin.read().splitlines()
if len(input_lines) < 2:
print("") # 如果输入不足两行，输出空字符串
return
K = int(input_lines[0].strip()) # 读取K值并转换为整数
S = input_lines[1].strip() # 读取字符串S并去除首尾空白
# 使用'-'分割字符串S
substrings = S.split('-')
if len(substrings) == 0:
# 如果没有子串，输出空字符串
print("")
return
# 处理第一个子串，将小写字母转换为大写
first_part = to_upper_case_string(substrings[0])
if len(substrings) == 1:
# 只有一个子串，直接输出
print(first_part)
return
# 处理剩余子串，连接并转换为大写
remaining = ''.join(substrings[1:]) # 连接剩余子串
remaining_upper = to_upper_case_string(remaining) # 转换为大写
# 按K分隔
processed_remaining = split_by_k(remaining_upper, K)
# 组合结果，使用'-'连接
result = first_part + '-' + processed_remaining
print(result) # 输出结果
if __name__ == "__main__":
main()七、JavaScript算法源码
javascript
// 使用Node.js的readline模块读取标准输入
const readline = require('readline');
// 创建接口实例
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
terminal: false
});
let inputLines = []; // 存储输入的每一行
// 监听每一行输入
rl.on('line', function(line){
inputLines.push(line.trim()); // 去除首尾空白并存储
if(inputLines.length === 2){
rl.close(); // 如果已经读取了两行，关闭接口
}
}).on('close', function(){
// 处理输入
if(inputLines.length < 2){
console.log(""); // 如果输入不足两行，输出空字符串
process.exit(0);
}
let K = parseInt(inputLines[0]); // 读取K值并转换为整数
let S = inputLines[1]; // 读取字符串S
// 分割字符串S
let substrings = S.split('-');
if(substrings.length === 0){
// 如果没有子串，输出空字符串
console.log("");
return;
}
// 处理第一个子串，转换为大写
let firstPart = substrings[0].toUpperCase();
if(substrings.length === 1){
// 只有一个子串，直接输出
console.log(firstPart);
return;
}
// 处理剩余子串，连接并转换为大写
let remaining = substrings.slice(1).join(''); // 连接剩余子串
let remainingUpper = remaining.toUpperCase(); // 转换为大写
// 按K分隔
let processedRemaining = splitByK(remainingUpper, K);
// 组合结果
let result = firstPart + '-' + processedRemaining;
console.log(result); // 输出结果
});
// 定义splitByK函数
function splitByK(s, K){
let parts = []; // 存储分隔后的部分
let length = s.length; // 获取字符串长度
for(let i = 0; i < length; i += K){
if(i + K > length){
parts.push(s.substring(i)); // 添加剩余的子串
}
else{
parts.push(s.substring(i, i + K)); // 添加K个字符的子串
}
}
// 使用'-'连接分隔后的部分
return parts.join('-');
}八、C算法源码
c
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
// 定义最大字符串长度
#define MAX_LEN 1000
// 将字符串中的小写字母转换为大写
void to_upper_case_string(char *s) {
for(int i = 0; s[i] != '\0'; i++) {
if(islower(s[i])) {
s[i] = toupper(s[i]); // 转换为大写
}
}
}
// 根据给定的K值，将字符串每K个字符分隔一次
void split_by_k(char *s, int K, char *result) {
int len = strlen(s); // 获取字符串长度
int count = 0; // 计数器
result[0] = '\0'; // 初始化结果字符串为空
for(int i = 0; i < len; i++) {
// 追加当前字符到结果
strncat(result, &s[i], 1);
count++;
// 如果已经添加了K个字符，并且不是最后一个字符
if(count == K && i != len -1){
strcat(result, "-"); // 添加'-'作为分隔符
count = 0; // 重置计数器
}
}
}
int main(){
int K;
char S[MAX_LEN];
// 读取K值
if(scanf("%d", &K) != 1){
// 如果读取失败，退出程序
printf("\n");
return 0;
}
// 读取字符串S
scanf(" %[^\n]", S); // 读取一行，包括空格
// 分割字符串S
char *substrings[MAX_LEN];
int count = 0;
char *token = strtok(S, "-"); // 使用'-'分割
while(token != NULL && count < MAX_LEN){
substrings[count++] = token; // 存储子串
token = strtok(NULL, "-"); // 继续分割
}
if(count == 0){
// 如果没有子串，输出空字符串
printf("\n");
return 0;
}
// 处理第一个子串，转换为大写
to_upper_case_string(substrings[0]);
if(count == 1){
// 只有一个子串，直接输出
printf("%s\n", substrings[0]);
return 0;
}
// 处理剩余子串，连接并转换为大写
char remaining[MAX_LEN] = "";
for(int i = 1; i < count; i++){
strcat(remaining, substrings[i]); // 连接子串
}
to_upper_case_string(remaining); // 转换为大写
// 按K分隔
char processed_remaining[MAX_LEN] = "";
split_by_k(remaining, K, processed_remaining);
// 组合结果
printf("%s-%s\n", substrings[0], processed_remaining); // 输出结果
return 0;
}九、C++算法源码
cpp
#include <iostream>
#include <vector>
#include <string>
#include <cctype>
using namespace std;
// 将字符串中的小写字母转换为大写
string to_upper_case_string(string s) {
for(char &c : s){
if(islower(c)){
c = toupper(c); // 转换为大写
}
}
return s;
}
// 根据给定的K值，将字符串每K个字符分隔一次
string split_by_k(string s, int K){
vector<string> parts; // 存储分隔后的部分
int length = s.length(); // 获取字符串长度
for(int i = 0; i < length; i += K){
if(i + K > length){
parts.push_back(s.substr(i)); // 添加剩余的子串
}
else{
parts.push_back(s.substr(i, K)); // 添加K个字符的子串
}
}
// 使用'-'连接分隔后的部分
string result = "";
for(int i = 0; i < parts.size(); i++){
result += parts[i];
if(i != parts.size() -1){
result += "-";
}
}
return result;
}
int main(){
int K;
string S;
// 读取K值
cin >> K;
// 读取字符串S
cin >> ws; // 清除前导空白
getline(cin, S);
// 分割字符串S
vector<string> substrings;
string token = "";
for(char c : S){
if(c == '-'){
if(!token.empty()){
substrings.push_back(token); // 存储子串
token = "";
}
}
else{
token += c; // 构建子串
}
}
if(!token.empty()){
substrings.push_back(token); // 存储最后一个子串
}
if(substrings.empty()){
// 如果没有子串，输出空字符串
cout << "" << endl;
return 0;
}
// 处理第一个子串，转换为大写
string first_part = to_upper_case_string(substrings[0]);
if(substrings.size() == 1){
// 只有一个子串，直接输出
cout << first_part << endl;
return 0;
}
// 处理剩余子串，连接并转换为大写
string remaining = "";
for(int i = 1; i < substrings.size(); i++){
remaining += substrings[i]; // 连接子串
}
string remaining_upper = to_upper_case_string(remaining); // 转换为大写
// 按K分隔
string processed_remaining = split_by_k(remaining_upper, K);
// 组合结果
string result = first_part + "-" + processed_remaining;
cout << result << endl; // 输出结果
return 0;
}🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）
🏆本文收录于，华为OD机试真题（Python/JS/C/C++）
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。
