华为OD机试 - 密钥格式化（Python/JS/C/C++ 2024 E卷 100分）

哪 吒2024-09-28 11:38

华为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个字符。

五、解题思路

  1. 分割字符串：首先根据 '-' 将输入字符串分割成多个子串。
  2. 处理第一个子串：保留第一个子串，但将其中的小写字母转换为大写。
  3. 处理剩余子串：
    • 将剩余的子串连接成一个连续的字符串。
    • 将该字符串中的小写字母转换为大写。
    • 根据给定的正整数 K，每 K 个字符插入一个 '-' 作为分隔符。
  4. 组合结果：将处理后的第一个子串和剩余子串组合起来，中间用 '-' 连接。

六、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在线答疑。

相关推荐
Change is good13 分钟前
python： 数字类型的一些函数
开发语言·python·算法
RaidenQ1 小时前
2024.9.27 Python面试八股文
linux·开发语言·python
2301_796982143 小时前
在pycharm中怎样debug一个网页程序
ide·python·pycharm
cndes4 小时前
元组（tuple）和列表（list）的区别及应用场合
数据结构·python
学步_技术4 小时前
Python编码系列—Python模板方法模式：定义算法骨架，让子类实现细节
python·算法·模板方法模式
MrBlackmzq4 小时前
Datawhale Leecode基础算法篇 task04：贪心算法
python·算法·贪心算法
唯余木叶下弦声4 小时前
Python连接Kafka收发数据等操作
大数据·分布式·python·kafka
洛小豆5 小时前
前端开发必备：三种高效定位动态类名元素的 JavaScript 技巧
开发语言·前端·javascript·面试
FreakStudio6 小时前
全网最适合入门的面向对象编程教程：54 Python字符串与序列化-字符串格式化与format方法
python·嵌入式·面向对象·电子diy
写bug如流水6 小时前
【Python】Python闭包的妙用与注意事项
开发语言·python·spring
热门推荐
01【案例教程】LoadRunner订票系统WebTours部署02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04RAG 实践- Ollama+RagFlow 部署本地知识库05yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07Ubuntu24.04安装中文输入法08软件工程从理论到实践客观题汇总(头歌第一章至第八章)09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10YoloV9改进策略：下采样改进|自研下采样模块（独家改进）|疯狂涨点|附结构图