华为OD机试真题 - 字符串分割转换（Python/JS/C/C++ 2024 E卷 100分）

华为OD机试 2024E卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

给定一个非空字符串 Q S，其被 N 个‘;’分隔成 N+1 个子串，给定正整数数组 K，要求除第一个子串外，其余的子串每 K 个字符组成新的子串，并‘-’分隔。

对于新组成的每一个子串，如果它含有的小写字母比大写字母多，则将这个子串的所有大写字母转换为小写 Q 字母；
反之，如果它含有的大写字母比小写字母多，则将这个子串的所有小写字母转换为大写字母；大小写字母的数量相等时，不做转换。

二、输入描述

输入为两行，第一行为参数 K，第二行为字符串 S。

三、输出描述

输出转换后的字符串。

四、测试用例

测试用例1：

1、输入

3
12abc-abCABc-4aB@

2、输出

12abc-abc-ABC-4aB-@

3、说明

子串为 12abc、abCABc、4aB@，第一个子串保留，
后面的子串每 3 个字符一组为 abC、ABC、4aB、@，
abC 中小写字母较多，转换为 abc，
ABC 中大写字母较多，转换为 ABC，
4aB 中大小写字母都为 1 个，不做转换，
@ 中没有字母，连起来即 12abc-abc-ABC-4aB-@

测试用例2：

1、输入

12
12abc-abCABc-4aB@

2、输出

12abc-abCABc4aB@

3、说明

子串为 12abc、abCABc、4aB@，第一个子串保留，
后面的子串每 12 个字符一组为 abCABc4aB@，
这个子串中大小写字母都为 4 个，不做转换，
连起来即 12abc-abCABc4aB@

五、解题思路

1. 读取两个输入参数 K 和 S，其中 K 表示每个子串的长度，S 是要处理的字符串。
2. 将字符串 S 按 ‘-’ 拆分成多个子串。保留第一个子串（one），然后将其余子串拼接成一个大字符串。
3. 根据给定的长度 K，将拼接后的字符串重新划分成多个子串，使用 ‘-’ 作为分隔符。
4. 对每个新划分的子串统计大写和小写字母的数量，并根据数量决定是否转换为全大写或全小写，或保持不变。
5. 将转换后的子串重新拼接成一个完整的字符串，并输出最终结果。

六、Python算法源码

def main():
    # 读取输入
    K = int(input().strip())  # 读取K值
    S = input().strip()  # 读取字符串S

    # 按'-'分割字符串
    arr = S.split('-')
    one = arr[0]  # 保留第一个子串

    # 拼接除第一个子串外的其他子串
    builder = ''.join(arr[1:])

    # 将拼接后的字符串按每K个字符分割并插入'-'
    builder2 = []
    for i in range(len(builder)):
        builder2.append(builder[i])
        if (i + 1) % K == 0 and (i + 1) != len(builder):
            builder2.append('-')

    # 将结果转换为字符串并再次按'-'分割
    arr2 = ''.join(builder2).split('-')

    # 处理每个子串，转换大小写
    builder3 = []
    for str_part in arr2:
        upperCase = sum(1 for c in str_part if c.isupper())  # 计算大写字母数量
        lowerCase = sum(1 for c in str_part if c.islower())  # 计算小写字母数量

        if upperCase > lowerCase:
            builder3.append(str_part.upper())  # 如果大写字母多，转换为大写
        elif lowerCase > upperCase:
            builder3.append(str_part.lower())  # 如果小写字母多，转换为小写
        else:
            builder3.append(str_part)  # 如果大小写字母相等，不做转换

    # 拼接最终结果并输出
    postfix = '-'.join(builder3)
    print(one + '-' + postfix)

if __name__ == "__main__":
    main()

七、JavaScript算法源码

function main() {
    // 读取输入
    const readline = require('readline');
    const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout
    });

    const input = [];
    
    rl.on('line', (line) => {
        input.push(line.trim());
    });

    rl.on('close', () => {
        const K = parseInt(input[0], 10);  // 读取K值
        const S = input[1];  // 读取字符串S

        // 按'-'分割字符串
        const arr = S.split('-');
        const one = arr[0];  // 保留第一个子串

        // 拼接除第一个子串外的其他子串
        let builder = arr.slice(1).join('');

        // 将拼接后的字符串按每K个字符分割并插入'-'
        let builder2 = [];
        for (let i = 0; i < builder.length; i++) {
            builder2.push(builder[i]);
            if ((i + 1) % K === 0 && (i + 1) !== builder.length) {
                builder2.push('-');
            }
        }

        // 将结果转换为字符串并再次按'-'分割
        const arr2 = builder2.join('').split('-');

        // 处理每个子串，转换大小写
        let builder3 = [];
        for (let str of arr2) {
            const upperCase = (str.match(/[A-Z]/g) || []).length;  // 计算大写字母数量
            const lowerCase = (str.match(/[a-z]/g) || []).length;  // 计算小写字母数量

            if (upperCase > lowerCase) {
                builder3.push(str.toUpperCase());  // 如果大写字母多，转换为大写
            } else if (lowerCase > upperCase) {
                builder3.push(str.toLowerCase());  // 如果小写字母多，转换为小写
            } else {
                builder3.push(str);  // 如果大小写字母相等，不做转换
            }
        }

        // 拼接最终结果并输出
        const postfix = builder3.join('-');
        console.log(one + '-' + postfix);
    });
}

main();

八、C算法源码

#include <stdio.h>
#include <string.h>
#include <ctype.h>

int main() {
    int K;
    char S[1000]; // 假设输入字符串不会超过1000个字符

    // 读取输入
    scanf("%d", &K); // 读取整数K
    scanf("%s", S); // 读取字符串S

    // 按 '-' 分割字符串并处理子串
    char *arr[100]; // 假设分割后的子串不会超过100个
    char *token = strtok(S, "-");
    int index = 0;

    // 处理第一个子串
    arr[index++] = token;

    // 存储除第一个子串外的拼接结果
    char builder[1000] = ""; // 用于存储拼接后的字符串
    token = strtok(NULL, "-");
    while (token != NULL) {
        strcat(builder, token);
        token = strtok(NULL, "-");
    }

    // 按K长度划分拼接结果并插入 '-'
    char builder2[1000] = ""; // 用于存储每K个字符插入'-'后的字符串
    int len = strlen(builder);
    for (int i = 0; i < len; i++) {
        strncat(builder2, &builder[i], 1);
        if ((i + 1) % K == 0 && (i + 1) != len) {
            strcat(builder2, "-");
        }
    }

    // 按 '-' 分割处理后的字符串
    char *arr2[100]; // 假设再次分割后的子串不会超过100个
    token = strtok(builder2, "-");
    int index2 = 0;

    while (token != NULL) {
        arr2[index2++] = token;
        token = strtok(NULL, "-");
    }

    // 处理每个子串，转换大小写
    char builder3[1000] = ""; // 用于存储最终结果
    for (int i = 0; i < index2; i++) {
        char *str = arr2[i];
        int upperCase = 0, lowerCase = 0;
        int len = strlen(str);

        // 计算大写和小写字母的数量
        for (int j = 0; j < len; j++) {
            if (isupper(str[j])) upperCase++;
            if (islower(str[j])) lowerCase++;
        }

        // 根据大写和小写字母数量进行转换
        if (upperCase > lowerCase) {
            for (int j = 0; j < len; j++) {
                str[j] = toupper(str[j]);
            }
        } else if (lowerCase > upperCase) {
            for (int j = 0; j < len; j++) {
                str[j] = tolower(str[j]);
            }
        }

        strcat(builder3, str);
        strcat(builder3, "-");
    }

    // 去掉最后一个多余的 '-'
    builder3[strlen(builder3) - 1] = '\0';

    // 输出最终结果
    printf("%s-%s\n", arr[0], builder3);

    return 0;
}

九、C++算法源码

#include <iostream>
#include <string>
#include <vector>
#include <cctype>

using namespace std;

int main() {
    int K;
    string S;

    // 读取输入
    cin >> K;        // 读取整数K
    cin >> S;        // 读取字符串S

    // 按 '-' 分割字符串
    vector<string> arr;
    size_t pos = 0;
    while ((pos = S.find('-')) != string::npos) {
        arr.push_back(S.substr(0, pos));
        S.erase(0, pos + 1);
    }
    arr.push_back(S);  // 将最后一个子串加入数组

    string one = arr[0];  // 保留第一个子串

    // 拼接除第一个子串外的其他子串
    string builder;
    for (int i = 1; i < arr.size(); i++) {
        builder += arr[i];
    }

    // 将拼接后的字符串按每K个字符分割并插入 '-'
    string builder2;
    for (int i = 0; i < builder.length(); i++) {
        builder2 += builder[i];
        if ((i + 1) % K == 0 && (i + 1) != builder.length()) {
            builder2 += '-';
        }
    }

    // 按 '-' 再次分割处理后的字符串
    vector<string> arr2;
    pos = 0;
    while ((pos = builder2.find('-')) != string::npos) {
        arr2.push_back(builder2.substr(0, pos));
        builder2.erase(0, pos + 1);
    }
    arr2.push_back(builder2);  // 将最后一个子串加入数组

    // 处理每个子串，转换大小写
    string builder3;
    for (string str : arr2) {
        int upperCase = 0, lowerCase = 0;
        for (char c : str) {
            if (isupper(c)) upperCase++;  // 计算大写字母数量
            if (islower(c)) lowerCase++;  // 计算小写字母数量
        }

        // 根据大写和小写字母数量进行转换
        if (upperCase > lowerCase) {
            for (char &c : str) {
                c = toupper(c);
            }
        } else if (lowerCase > upperCase) {
            for (char &c : str) {
                c = tolower(c);
            }
        }

        builder3 += str + "-";
    }

    // 去掉最后一个多余的 '-'
    builder3.pop_back();

    // 输出最终结果
    cout << one << "-" << builder3 << endl;

    return 0;
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。