华为OD机试 - 字符串摘要(Python/JS/C/C++ 2023 B卷 100分)

在这里插入图片描述

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

专栏导读

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

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

一、题目描述

给定一个字符串的摘要算法,请输出给定字符串的摘要值:

  1. 去除字符串中非字母的符号;
  2. 如果出现连续字符(不区分大小写),则输出该字符(小写)+连续出现的次数;
  3. 如果时非连续的字符(不区分大小写),则输出该字符(小写)+该字母之后字符串中出现该字符的次数;
  4. 对按照以上方式表示后的字符串进行排序,字母和紧随的数字作为一组进行排序,数字大的在前,数字相同时,按字母进行排序,字母小的在前;

二、输入描述

一行字符串。

三、输出描述

摘要字符串。

四、测试用例

测试用例1

1、输入

abcccbbaa

2、输出

c3a2a2b2b2

3、说明

如果当前字符的连续次数大于1,表示是连续字符,输出即可
如果只有1个,则要获取后面字符串中该字符的个数

abcccbbaa

  1. 第1个字符a,不连续,获取后面字符串中a的个数2 – a2;
  2. 第2个字符b,不连续,获取后面字符串中b的个数2 – b2;
  3. 第3个字符c,连续,一共3个 --c3;
  4. 第6个字符b,连续,一共2个 --b2;
  5. 第8个字符a,连续,一共2个 --a2;
  6. 变为a2b2c3b2a2;

字母和紧随的数字作为一组进行排序,数字大的在前,数字相同时,按字母进行排序,字母小的在前

输出c3a2a2b2b2

测试用例2

1、输入

abcccbbabaaccbca

2、输出

a4b4a3c3a2b2c2b1a0b0c0

3、说明

如果当前字符的连续次数大于1,表示是连续字符,输出即可
如果只有1个,则要获取后面字符串中该字符的个数

  1. 第一个字符a,不连续,后面字符串中a的个数为4,输出a4;
  2. 第二个字符b,不连续,后面字符串中b的个数为4,输出b4;
  3. 第三个字符c,连续3个,输出c3;
  4. 第6个字符b,连续2个,输出b2;
  5. 第8个字符a,不连续,后面字符串中a的个数为3,输出a3;
  6. 第9个字符b,不连续,后面字符串中b的个数为1,输出b1;
  7. 第10个字符a,连续2个,输出a2;
  8. 第12个字符c,连续2个,输出c2;
  9. 第14个字符b,不连续,后面没有b,输出b0;
  10. 第15个字符c,不连续,后面没有c,输出c0;
  11. 第16个字符a,不连续,后面没有a,输出a0;

a4b4c3b2a3b1a2c2b0c0a0

字母和紧随的数字作为一组进行排序,数字大的在前,数字相同时,按字母进行排序,字母小的在前

a4b4a3c3a2b2c2b1a0b0c0

五、解题思路

1、核心思路:

  1. 如果当前字母和上一个字母相同,该字母连续次数记为+1;
  2. 如果当前字母和上一个字母不同;
    • 如果当前字符的连续次数大于1,表示是连续字符,输出即可;
    • 如果只有1个,则要获取后面字符串中该字符的个数;
  3. 字母和紧随的数字作为一组进行排序,数字大的在前,数字相同时,按字母进行排序,字母小的在前;

2、具体思路如下:

  1. 输入一行字符串,不区分大小写;
  2. 定义一个数组chCountArr,记录字母出现的次数;
  3. 定义一个字符串,存储字符串中的字母;
  4. 定义一个集合,记录统计连续字符和非连续字符的字符和个数;
  5. 遍历输入的字符串;
  6. 如果当前字母和上一个字母相同,该字母连续次数记为+1;
  7. 如果当前字母和上一个字母不同;
    • 如果当前字符的连续次数大于1,表示是连续字符,输出即可;
    • 如果只有1个,则要获取后面字符串中该字符的个数;
    • 更新current连续次数为1;
  8. 字母和紧随的数字作为一组进行排序,数字大的在前,数字相同时,按字母进行排序,字母小的在前;
  9. 输出摘要字符串;

六、Python算法源码

def summarize_string(s):
    # 去除非字母字符并转换为小写
    s = ''.join([c.lower() for c in s if c.isalpha()])
    
    # 统计每个字符的总出现次数
    ch_count = {}
    for c in s:
        ch_count[c] = ch_count.get(c, 0) + 1
    
    # 统计连续字符和非连续字符
    char_list = []
    continuous_count = 1
    for i in range(len(s)):
        current = s[i]
        next_char = s[i + 1] if i + 1 < len(s) else ''
        ch_count[current] -= 1
        if current == next_char:
            continuous_count += 1
        else:
            num = continuous_count if continuous_count > 1 else ch_count[current]
            char_list.append((current, num))
            continuous_count = 1
    
    # 排序
    char_list.sort(key=lambda x: (-x[1], x[0]))
    
    # 构建结果字符串
    result = ''.join([f"{c}{n}" for c, n in char_list])
    return result

七、JavaScript算法源码

function summarizeString(s) {
    // 去除非字母字符并转换为小写
    s = s.toLowerCase().replace(/[^a-z]/g, '');
    
    // 统计每个字符的总出现次数
    let chCount = {};
    for (let c of s) {
        chCount[c] = (chCount[c] || 0) + 1;
    }
    
    // 统计连续字符和非连续字符
    let charList = [];
    let continuousCount = 1;
    for (let i = 0; i < s.length; i++) {
        let current = s[i];
        let nextChar = s[i + 1] || '';
        chCount[current] -= 1;
        if (current === nextChar) {
            continuousCount += 1;
        } else {
            let num = continuousCount > 1 ? continuousCount : chCount[current];
            charList.push({char: current, num: num});
            continuousCount = 1;
        }
    }
    
    // 排序
    charList.sort((a, b) => b.num - a.num || a.char.localeCompare(b.char));
    
    // 构建结果字符串
    let result = '';
    for (let item of charList) {
        result += item.char + item.num;
    }
    return result;
}

八、C算法源码

#include 
#include 
#include 
#include 

typedef struct {
    char ch;
    int num;
} CharCount;

int compare(const void *a, const void *b) {
    CharCount *x = (CharCount *)a;
    CharCount *y = (CharCount *)b;
    if (x->num != y->num) return y->num - x->num;
    return x->ch - y->ch;
}

void summarizeString(char *s) {
    // 去除非字母字符并转换为小写
    char cleaned[1000];
    int j = 0;
    for (int i = 0; s[i]; i++) {
        if (isalpha(s[i])) {
            cleaned[j++] = tolower(s[i]);
        }
    }
    cleaned[j] = '\0';
    
    // 统计每个字符的总出现次数
    int chCount[128] = {0};
    for (int i = 0; cleaned[i]; i++) {
        chCount[cleaned[i]]++;
    }
    
    // 统计连续字符和非连续字符
    CharCount charList[1000];
    int listSize = 0;
    int continuousCount = 1;
    for (int i = 0; cleaned[i]; i++) {
        char current = cleaned[i];
        char nextChar = cleaned[i + 1];
        chCount[current]--;
        if (current == nextChar) {
            continuousCount++;
        } else {
            int num = continuousCount > 1 ? continuousCount : chCount[current];
            charList[listSize++] = (CharCount){current, num};
            continuousCount = 1;
        }
    }
    
    // 排序
    qsort(charList, listSize, sizeof(CharCount), compare);
    
    // 构建结果字符串
    for (int i = 0; i < listSize; i++) {
        printf("%c%d", charList[i].ch, charList[i].num);
    }
    printf("\n");
}

九、C++算法源码

#include 
#include 
#include 
#include 

using namespace std;

struct CharCount {
    char ch;
    int num;
};

bool compare(const CharCount &a, const CharCount &b) {
    if (a.num != b.num) return a.num > b.num;
    return a.ch < b.ch;
}

void summarizeString(const string &s) {
    // 去除非字母字符并转换为小写
    string cleaned;
    for (char c : s) {
        if (isalpha(c)) {
            cleaned += tolower(c);
        }
    }
    
    // 统计每个字符的总出现次数
    int chCount[128] = {0};
    for (char c : cleaned) {
        chCount[c]++;
    }
    
    // 统计连续字符和非连续字符
    vector<CharCount> charList;
    int continuousCount = 1;
    for (size_t i = 0; i < cleaned.size(); i++) {
        char current = cleaned[i];
        char nextChar = i + 1 < cleaned.size() ? cleaned[i + 1] : '\0';
        chCount[current]--;
        if (current == nextChar) {
            continuousCount++;
        } else {
            int num = continuousCount > 1 ? continuousCount : chCount[current];
            charList.push_back({current, num});
            continuousCount = 1;
        }
    }
    
    // 排序
    sort(charList.begin(), charList.end(), compare);
    
    // 构建结果字符串
    for (const auto &item : charList) {
        cout << item.ch << item.num;
    }
    cout << endl;
}

下一篇:华为OD机试真题 - 简易内存池(Python/JS/C/C++ 2024 E卷 200分)

本文收录于,华为OD机试真题(Python/JS/C/C++)

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

在这里插入图片描述

你可能感兴趣的:(搬砖工逆袭Java架构师,华为od,python,javascript)