E卷-(100分)字符串分割转换

字符串分割转换

问题描述

给定一个非空字符串 ，它被 个 '-' 分隔成 个子串。现在给定一个正整数 ，要求对 进行如下处理：

1. 保留第一个子串不变。
2. 对于剩余的子串，每 个字符组成一个新的子串，用 '-' 分隔。
3. 对于每个新组成的子串，进行以下转换：
   • 如果小写字母数量多于大写字母，将所有大写字母转换为小写字母。
   • 如果大写字母数量多于小写字母，将所有小写字母转换为大写字母。
   • 如果大小写字母数量相等，不进行转换。

请输出处理后的字符串。

输入格式

输入包含两行： 第一行为一个正整数 。 第二行为字符串 。

输出格式

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

样例输入

3
12abc-abCABc-4aB@

样例输出

12abc-abc-ABC-4aB-@

样例解释

原始子串为 "12abc"、"abCABc"、"4aB@"。第一个子串 "12abc" 保留不变。剩余部分每 3 个字符一组，得到 "abC"、"ABc"、"4aB"、"@"。

• "abC" 中小写字母较多，转换为 "abc"。
• "ABc" 中大写字母较多，转换为 "ABC"。
• "4aB" 中大小写字母数量相等，保持不变。
• "@" 中没有字母，保持不变。

最后用 '-' 连接所有部分，得到 "12abc-abc-ABC-4aB-@"。

样例输入

12
12abc-abCABc-4aB@

样例输出

12abc-abCABc4aB@

样例解释

原始子串为 "12abc"、"abCABc"、"4aB@"。第一个子串 "12abc" 保留不变。剩余部分作为一个整体 "abCABc4aB@"，其中大小写字母数量相等，因此不做转换。最后用 '-' 连接，得到 "12abc-abCABc4aB@"。

数据范围

• 
• ，其中 表示字符串 的长度。
• 中只包含大小写英文字母、数字和 '-'。

题解

这道题目的核心在于字符串的处理和转换。

解题思路如下：

1. 首先，将输入的字符串 按 '-' 分割成子串数组。
2. 保留第一个子串，将剩余子串合并成一个字符串。
3. 对合并后的字符串每 个字符进行分组。
4. 对每个分组进行大小写字母数量统计和转换。
5. 最后，将处理后的所有部分用 '-' 连接起来。

参考代码

• Python

def process_string(k, s):
    # 将字符串按'-'分割成子串
    parts = s.split('-')
    
    # 保留第一个子串作为结果的开始
    result = [parts[0]]
    
    # 合并剩余的所有子串
    remaining = ''.join(parts[1:])
    
    # 处理剩余部分
    for i in range(0, len(remaining), k):
        # 每k个字符取一个chunk
        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:
            # 小写字母多，全部转换为小写
            result.append(chunk.lower())
        elif upper_count > lower_count:
            # 大写字母多，全部转换为大写
            result.append(chunk.upper())
        else:
            # 大小写字母数量相等，保持原样
            result.append(chunk)
    
    # 用'-'连接处理后的所有部分，并返回结果
    return '-'.join(result)

# 读取输入
k = int(input())  # 读取整数k
s = input()  # 读取字符串s

# 调用函数处理字符串并输出结果
print(process_string(k, s))

• C

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

void process_string(int k, const char *s, char *result) {
    int result_index = 0;
    char remaining[100001] = "";  // 剩余部分
    int part_index = 0;          // 记录处理的子串索引

    // 遍历字符串，找到第一个'-'之前的部分
    while (s[part_index] != '-' && s[part_index] != '\0') {
        result[result_index++] = s[part_index++];
    }

    // 跳过'-'并保留后续部分
    while (s[part_index] != '\0') {
        if (s[part_index] != '-') {
            strncat(remaining, &s[part_index], 1);
        }
        part_index++;
    }

    // 处理剩余部分
    int remaining_len = strlen(remaining);
    for (int i = 0; i < remaining_len; i += k) {
        result[result_index++] = '-';  // 每个分块前添加'-'

        // 获取k长度的子串（chunk）
        char chunk[101];  // chunk最大长度为100
        int chunk_len = (i + k < remaining_len) ? k : (remaining_len - i);
        strncpy(chunk, &remaining[i], chunk_len);
        chunk[chunk_len] = '\0';  // 确保子串是合法的C字符串

        int lower_count = 0, upper_count = 0;

        // 统计大小写字母数量
        for (int j = 0; j < chunk_len; j++) {
            if (islower(chunk[j])) lower_count++;
            if (isupper(chunk[j])) upper_count++;
        }

        // 根据数量决定大小写转换
        if (lower_count > upper_count) {
            for (int j = 0; j < chunk_len; j++) {
                chunk[j] = tolower(chunk[j]);
            }
        } else if (upper_count > lower_count) {
            for (int j = 0; j < chunk_len; j++) {
                chunk[j] = toupper(chunk[j]);
            }
        }

        // 将处理好的chunk追加到结果中
        strncpy(&result[result_index], chunk, chunk_len);
        result_index += chunk_len;
    }

    result[result_index] = '\0';  // 确保结果字符串以null结尾
}

int main() {
    int k;
    char s[100001];  // 最大字符串长度为10000，加1是为了null结尾
    char result[200001];  // 结果字符串大小足够容纳分块后的结果

    scanf("%d", &k);  // 读取整数k
    scanf("%s", s);   // 读取字符串s

    process_string(k, s, result);

    printf("%s\n", result);  // 输出处理后的结果

    return 0;
}

• Javascript

// 部分通过✅
function processString(k, s) {
    let parts = s.split('-');
    let result = parts[0];  // 保留第一个子串
    let remaining = parts.slice(1).join('');  // 合并剩余的子串
    
    for (let i = 0; i < remaining.length; i += k) {
        result += '-';  // 添加'-'
        
        let chunk = remaining.slice(i, i + k);
        
        // 统计小写和大写字母数量
        let lowerCount = 0, upperCount = 0;
        for (let char of chunk) {
            if (char === char.toLowerCase()) lowerCount++;
            if (char === char.toUpperCase()) upperCount++;
        }
        
        // 根据字母数量进行转换
        if (lowerCount > upperCount) {
            chunk = chunk.toLowerCase();
        } else if (upperCount > lowerCount) {
            chunk = chunk.toUpperCase();
        }
        
        result += chunk;
    }
    
    return result;
}

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

rl.question('', (kInput) => {
    rl.question('', (s) => {
        const k = parseInt(kInput);
        console.log(processString(k, s));
        rl.close();
    });
});

• Java

import java.util.Scanner;

public class Main {
    public static String processString(int k, String s) {
        // 将字符串按'-'分割成子串数组
        String[] parts = s.split("-");
        StringBuilder result = new StringBuilder(parts[0]);  // 保留第一个子串
        
        // 合并剩余的所有子串
        String remaining = String.join("", java.util.Arrays.copyOfRange(parts, 1, parts.length));
        
        // 处理剩余部分
        for (int i = 0; i < remaining.length(); i += k) {
            result.append("-");  // 除第一个子串外，其他子串前加'-'
            // 每k个字符取一个chunk
            String chunk = remaining.substring(i, Math.min(i + k, remaining.length()));
            // 统计小写字母数量
            long lowerCount = chunk.chars().filter(Character::isLowerCase).count();
            // 统计大写字母数量
            long upperCount = chunk.chars().filter(Character::isUpperCase).count();
            
            // 根据大小写字母数量进行转换
            if (lowerCount > upperCount) {
                result.append(chunk.toLowerCase());  // 转小写
            } else if (upperCount > lowerCount) {
                result.append(chunk.toUpperCase());  // 转大写
            } else {
                result.append(chunk);  // 保持原样
            }
        }
        
        return result.toString();  // 返回处理后的字符串
    }
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int k = scanner.nextInt();  // 读取整数k
        scanner.nextLine();  // 消耗换行符
        String s = scanner.nextLine();  // 读取字符串s
        
        System.out.println(processString(k, s));  // 处理字符串并输出结果
        
        scanner.close();
    }
}

• Cpp

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

string process_string(int k, string s) {
    vector<string> parts;
    size_t pos = 0;
    string token;
    // 将字符串按'-'分割成子串
    while ((pos = s.find('-')) != string::npos) {
        token = s.substr(0, pos);
        parts.push_back(token);
        s.erase(0, pos + 1);
    }
    parts.push_back(s);
    
    string result = parts[0];  // 保留第一个子串
    string remaining;
    // 合并剩余的所有子串
    for (size_t i = 1; i < parts.size(); i++) {
        remaining += parts[i];
    }
    
    // 处理剩余部分
    for (size_t i = 0; i < remaining.length(); i += k) {
        result += "-";  // 除第一个子串外，其他子串前加'-'
        // 每k个字符取一个chunk
        string chunk = remaining.substr(i, k);
        // 统计小写字母数量
        int lower_count = count_if(chunk.begin(), chunk.end(), ::islower);
        // 统计大写字母数量
        int upper_count = count_if(chunk.begin(), chunk.end(), ::isupper);
        
        // 根据大小写字母数量进行转换
        if (lower_count > upper_count) {
            transform(chunk.begin(), chunk.end(), chunk.begin(), ::tolower);  // 转小写
        } else if (upper_count > lower_count) {
            transform(chunk.begin(), chunk.end(), chunk.begin(), ::toupper);  // 转大写
        }
        result += chunk;
    }
    
    return result;  // 返回处理后的字符串
}

int main() {
    int k;
    string s;
    
    cin >> k;  // 读取整数k
    cin >> s;  // 读取字符串s
    
    cout << process_string(k, s) << endl;  // 处理字符串并输出结果
    
    return 0;
}