最新华为OD机试真题-字符串分隔(二)(100分)

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

✨ 本系列打算持续跟新华为OD-D卷的三语言AC题解

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

📎在线评测链接

=> 字符串分隔(二)(100分) <=

🌍 评测功能需要 =>订阅专栏<= 后联系清隆解锁～

🍓OJ题目截图

🫔 字符串分隔(二)

问题描述

K小姐有一个由可见字符组成的字符串 ，长度为 。现在她需要对字符串进行如下处理：

1. 将字符串 按照 - 分隔成若干个子串，保证第一个子串不为空。
2. 对于除第一个子串外的每个子串，将其按照每 个字符一组进行划分（最后一组可能不足 个字符）。
3. 对于每一组字符，如果其中小写字母的数量大于大写字母的数量，则将这一组字符全部转换为小写；如果其中大写字母的数量大于小写字母的数量，则将这一组字符全部转换为大写；如果大小写字母数量相等，则不进行转换。
4. 将转换后的所有子串重新用 - 连接起来，得到处理后的字符串。

现在给定字符串 和正整数 ，请你帮助K小姐完成字符串的转换。

输入格式

第一行包含一个正整数 ，表示每组字符的长度。

第二行包含一个由可见字符组成的字符串 。

输出格式

输出一行，表示处理后的字符串。

样例输入1

3
12abc-abcABC-4aB@

样例输出1

12abc-abc-ABC-4aB-@

样例输入2

12
12abc-abCABc-4aB@

样例输出2

12abc-abCABc4aB@

数据范围

题解

对于给定的字符串 ，首先使用 - 分割成多个子串。第一个子串保留原样，对于后续的子串，我们将它们合并后再按照长度为 进行分割。对每个分割后的子串，我们统计其大写和小写字母的数量，根据数量多少进行相应的转换。最终，我们将所有处理过的子串和组用 - 重新连接，得到最终的结果字符串。

参考代码

• Python

def transform_string(k, s):
    parts = s.split('-')
    result = [parts[0]]  # 第一个子串保留
    
    remaining = ''.join(parts[1:])  # 合并剩余的子串
    
    transformed = []
    for i in range(0, len(remaining), k):
        chunk = remaining[i:i+k]
        lower_count = sum(1 for c in chunk if c.islower())
        upper_count = sum(1 for c in chunk if c.isupper())
        
        if lower_count > upper_count:
            transformed.append(chunk.lower())
        elif upper_count > lower_count:
            transformed.append(chunk.upper())
        else:
            transformed.append(chunk)
    
    result.extend(transformed)
    return '-'.join(result)

k = int(input().strip())
s = input().strip()
print(transform_string(k, s))

• Java

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static String transformString(int k, String s) {
        String[] parts = s.split("-");
        List<String> transformed = new ArrayList<>();
        
        StringBuilder remaining = new StringBuilder();
        for (int i = 1; i < parts.length; i++) {
            remaining.append(parts[i]);
        }
        
        StringBuilder result = new StringBuilder(parts[0]);
        for (int i = 0; i < remaining.length(); i += k) {
            String chunk = remaining.substring(i, Math.min(i + k, remaining.length()));
            int lowerCount = 0, upperCount = 0;
            for (char c : chunk.toCharArray()) {
                if (Character.isLowerCase(c)) {
                    lowerCount++;
                } else if (Character.isUpperCase(c)) {
                    upperCount++;
                }
            }
            
            if (lowerCount > upperCount) {
                chunk = chunk.toLowerCase();
            } else if (upperCount > lowerCount) {
                chunk = chunk.toUpperCase();
            }
            
            transformed.add(chunk);
        }
        
        for (String part : transformed) {
            result.append("-").append(part);
        }
        
        return result.toString();
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int k = scanner.nextInt();
        scanner.nextLine();  // 消耗换行符
        String s = scanner.nextLine();

        System.out.println(transformString(k, s));
    }
}

• Cpp

#include <bits/stdc++.h>

using namespace std;

string transformString(int k, const string& s) {
    vector<string> parts;
    string current;
    for (char c : s) {
        if (c == '-') {
            parts.push_back(current);
            current.clear();
        } else {
            current += c;
        }
    }
    parts.push_back(current);  // 添加最后一个子串

    string result = parts[0];  // 第一个子串保留

    string remaining;
    for (int i = 1; i < parts.size(); ++i) {
        remaining += parts[i];  // 合并剩余的子串
    }

    vector<string> transformed;
    for (int i = 0; i < remaining.size(); i += k) {
        string chunk = remaining.substr(i, k);
        int lowerCount = 0, upperCount = 0;
        for (char c : chunk) {
            if (islower(c)) {
                ++lowerCount;
            } else if (isupper(c)) {
                ++upperCount;
            }
        }

        if (lowerCount > upperCount) {
            transform(chunk.begin(), chunk.end(), chunk.begin(), ::tolower);
        } else if (upperCount > lowerCount) {
            transform(chunk.begin(), chunk.end(), chunk.begin(), ::toupper);
        }

        transformed.push_back(chunk);
    }

    for (const string& part : transformed) {
        result += '-' + part;
    }

    return result;
}

int main() {
    int k;
    cin >> k;
    cin.ignore();  // 消耗换行符
    string s;
    getline(cin, s);

    cout << transformString(k, s) << endl;

    return 0;
}