• C++

  • B4262 [GESP202503 三级] 词频统计

  • @ 2025-5-5 18:15:28

B4262 [GESP202503 三级] 词频统计

题目描述

在文本处理中，统计单词出现的频率是一个常见的任务。现在，给定 nn 个单词，你需要找出其中出现次数最多的单词。在本题中，忽略单词中字母的大小写（即 Apple、apple、APPLE、aPPle 等均视为同一个单词）。

请你编写一个程序，输入 nn 个单词，输出其中出现次数最多的单词。

输入格式

第一行，一个整数 nn，表示单词的个数；

接下来 nn 行，每行包含一个单词，单词由大小写英文字母组成。

输入保证，出现次数最多的单词只会有一个。

输出格式

输出一行，包含出现次数最多的单词（输出单词为小写形式）。

输入输出样例 #1

输入 #1

6
Apple
banana
apple
Orange
banana
apple

输出 #1

apple

说明/提示

对于所有测试点，1≤n≤1001\leq n\leq 100，每个单词的长度不超过 3030，且仅由大小写字母组成。

6 条评论

  • @ 2025-5-7 9:10:47

    在 C++ 里，auto 是一个关键字，自 C++11 标准起引入，它能够让编译器自动推导变量的类型。下面从多个方面详细介绍 auto 的用途和特点。

    基本用法

    auto 最常见的用途是在变量声明时，根据初始化表达式的类型自动推导变量的类型。这样可以简化代码，特别是在处理复杂类型时。

    #include <iostream>
#include <vector>

int main() {
    auto num = 10;  // 编译器自动推导 num 为 int 类型
    auto str = "Hello";  // 编译器自动推导 str 为 const char* 类型

    std::vector<int> vec = {1, 2, 3};
    auto it = vec.begin();  // 编译器自动推导 it 为 std::vector<int>::iterator 类型

    std::cout << "num: " << num << std::endl;
    std::cout << "str: " << str << std::endl;
    std::cout << "First element of vec: " << *it << std::endl;

    return 0;
}

    在上述代码中，num 被初始化为整数 10，编译器自动将其类型推导为 int；str 被初始化为字符串字面量 "Hello"，编译器将其类型推导为 const char*；it 是 std::vector<int> 的迭代器，使用 auto 可以避免写出冗长的类型名。

    用于范围 for 循环

    在范围 for 循环中，auto 可以让代码更简洁，特别是在处理容器元素时。

    #include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    for (auto element : vec) {
        std::cout << element << " ";
    }
    std::cout << std::endl;

    return 0;
}

    在这个例子中，auto 让编译器自动推导 element 的类型为 int，避免了手动指定类型。

    用于函数返回类型推导（C++14 及以后）

    从 C++14 开始，auto 可以用于函数返回类型的推导。

    #include <iostream>

auto add(int a, int b) {
    return a + b;
}

int main() {
    auto result = add(3, 5);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

    在这个代码里，add 函数的返回类型由 auto 自动推导为 int，因为函数体中返回的是两个 int 类型相加的结果。

    注意事项

    • 必须初始化：使用 auto 声明变量时，必须对变量进行初始化，因为编译器需要根据初始化表达式来推导变量的类型。
    auto x;  // 错误，未初始化
auto y = 10;  // 正确
    • 可能丢失顶层 const 和引用信息：在某些情况下，auto 推导的类型可能会丢失顶层 const 和引用信息。
    const int a = 10;
auto b = a;  // b 的类型是 int，而不是 const int

    总的来说，auto 关键字可以使代码更简洁，提高代码的可读性和可维护性，尤其在处理复杂类型时优势明显。

    • @ 2025-5-5 19:38:20 
      #include <iostream>
#include <map>
#include <string>
using namespace std;
map<string, int> myMap;
int main() {
	
	//pair<string,int>   p1("ccc",9);
	//myMap.insert(p1);
	
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		string tt;
		cin>>tt;
		for (int j = 0; j < (int)tt.size(); j++) { 
			// 如果字符是大写字母（这里原代码条件判断有误，应补充完整判断是否在A-Z之间）
			//if (words[i][j] >= 'A' && words[i][j] <= 'Z') { //tolower()  toupper()
			//	words[i][j] += 32; // 将大写字母转换为小写字母，通过ASCII码值的差值来实现
			//}
			tt[j] = tolower(tt[j]);
		}
		myMap[tt] += 1;
	}
	int MaxSize = 0;
	string tttt="";
	for(pair<string,int> it:myMap){//for(auto it:myMap){
		//cout << "Type of it: " << typeid(it).name() << endl;
		//cout << "Type of it: " << typeid(it).name() << endl;
		if( it.second > MaxSize){
			MaxSize = it.second;
			tttt = it.first;
		}
	}
	cout<<tttt;
	/*for(pair<string,int>::iterator it:myMap){
	
	}*/
	return 0;
}
      • @ 2025-5-5 18:25:42 
        language
```

#include<iostream>
#include <cctype>    // std::tolower
using namespace std;

// 用于存储输入的单词，最多可存储200个单词
string words[200]; 

int main() {
	int n;
	// 读取单词的个数
	cin >> n; 
	int MaxSize = 0; 
	string str = "";
	
	// 循环读取n个单词
	for (int i = 1; i <= n; i++) { 
		cin >> words[i];
		// 遍历每个单词的字符，将大写字母转换为小写字母
		for (int j = 0; j < (int)words[i].size(); j++) { 
			// 如果字符是大写字母（这里原代码条件判断有误，应补充完整判断是否在A-Z之间）
			//if (words[i][j] >= 'A' && words[i][j] <= 'Z') { //tolower()  toupper()
			//	words[i][j] += 32; // 将大写字母转换为小写字母，通过ASCII码值的差值来实现
			//}
			words[i][j] = tolower(words[i][j]);
		}
	}
	
	// 外层循环遍历每个单词，用于统计当前单词的出现次数
	for (int i = 1; i <= n; i++) { 
		int cnt = 0; 
		// 内层循环遍历所有单词，统计当前单词（words[i]）出现的次数
		for (int j = 1; j <= n; j++) { 
			if (words[i] == words[j]) { 
				cnt += 1;
			}
		}
		// 如果当前单词的出现次数大于已记录的最大出现次数
		if (cnt > MaxSize) { 
			MaxSize = cnt; // 更新最大出现次数
			str = words[i]; // 更新出现次数最多的单词
		}
	}
	// 输出出现次数最多的单词
	cout << str << endl; 
	return 0;
}

```
        • @ 2025-5-5 18:18:04

          在C++中，如果你想将一个 std::string 转换为全小写或全大写，你可以使用标准库中的函数来逐个字符进行转换。下面是一些示例代码，展示了如何实现这一点：

          将字符串转换为小写

          #include <algorithm> // std::for_each
#include <cctype>    // std::tolower
#include <string>    // std::string

void toLowerCase(std::string& str) {
    std::for_each(str.begin(), str.end(), [](char& c) {
        c = std::tolower(static_cast<unsigned char>(c));
    });
}

          将字符串转换为大写

          #include <algorithm> // std::for_each
#include <cctype>    // std::toupper
#include <string>    // std::string

void toUpperCase(std::string& str) {
    std::for_each(str.begin(), str.end(), [](char& c) {
        c = std::toupper(static_cast<unsigned char>(c));
    });
}

          在上述例子中，我们使用了 <algorithm> 头文件中的 std::for_each 函数来遍历字符串的每个字符，并应用了 <cctype> 中定义的 std::tolower 或者 std::toupper 函数来转换字符的大小写。注意，在调用这些函数之前，我们将字符强制转换为 unsigned char 类型，这是为了避免当处理某些具有负值的字符编码时可能出现的问题。

          使用方法

          你可以在你的程序中这样使用这两个函数：

          #include <iostream>
#include <string>

int main() {
    std::string myStr = "Hello, World!";
    
    toLowerCase(myStr);
    std::cout << "Lower case: " << myStr << std::endl;
    
    toUpperCase(myStr);
    std::cout << "Upper case: " << myStr << std::endl;

    return 0;
}

          这段代码首先会输出转换为小写后的字符串，然后再次将其转换为大写并输出。请注意，对同一个字符串对象调用这两个函数会导致其内容被修改。如果你不想改变原始字符串，可以先创建它的副本再进行转换。

          • @ 2025-5-5 18:16:30 
            #include<iostream>
using namespace std;

// 用于存储输入的单词，最多可存储200个单词
string words[200]; 

int main() {
    int n;
    // 读取单词的个数
    cin >> n; 
    int MaxSize = 0; 
    string str = "";

    // 循环读取n个单词
    for (int i = 1; i <= n; i++) { 
        cin >> words[i];
        // 遍历每个单词的字符，将大写字母转换为小写字母
        for (int j = 0; j < (int)words[i].size(); j++) { 
            // 如果字符是大写字母（这里原代码条件判断有误，应补充完整判断是否在A-Z之间）
            if (words[i][j] >= 'A' && words[i][j] <= 'Z') { 
                words[i][j] += 32; // 将大写字母转换为小写字母，通过ASCII码值的差值来实现
            }
        }
    }

    // 外层循环遍历每个单词，用于统计当前单词的出现次数
    for (int i = 1; i <= n; i++) { 
        int cnt = 0; 
        // 内层循环遍历所有单词，统计当前单词（words[i]）出现的次数
        for (int j = 1; j <= n; j++) { 
            if (words[i] == words[j]) { 
                cnt += 1;
            }
        }
        // 如果当前单词的出现次数大于已记录的最大出现次数
        if (cnt > MaxSize) { 
            MaxSize = cnt; // 更新最大出现次数
            str = words[i]; // 更新出现次数最多的单词
        }
    }
    // 输出出现次数最多的单词
    cout << str << endl; 
    return 0;
}
            • @ 2025-5-5 18:15:39 
              #include<iostream>
using namespace std;
string words[200];
int main() {
	int n;
	cin >> n;
	int MaxSize = 0;
	string str="";
	for(int i=1;i<=n;i++){
		cin>>words[i];
		for(int j=0;j<(int)words[i].size();j++){
			if(words[i][j] <= 'Z'){//words[i][j] >= 'A' && 
				words[i][j]+=32;
			}
		}
	}
	
	for(int i = 1;i <= n;i++){// A B C B
		int cnt = 0;
		for(int j = 1;j <= n;j++){// A B C B
			if(words[i]==words[j]){
				cnt += 1;
			}
		}
		if(cnt > MaxSize){
			MaxSize = cnt;
			str = words[i];
		}
	}
	cout<<str<<endl;
	return 0;
}
              • 1
              428
              已通过
              0
              题解被赞
              1. 关于
              2. 联系我们
              3. 隐私
              4. 服务条款
              5. 版权申诉
              6. Language
              7. 兼容模式
              8. 主题
              4. 在线咨询
              5. Worker 0, 30ms
              6. Powered by Hydro v4.13.3 Community