字符串中最长的连续出现的字符

lsmCC

1. #include <bits/stdc++.h>
   
2. using namespace std;
   
3. char b[201];
   
4. int main()
   
5. {
   
6.     int n;
   
7.     string a;
   
8.     while(n--)
   
9.     {
   
10.         cin>>a;
    
11.         for(auto i:a)
    
12.         {
    
13.             b[i]++;
    
14.         }
    
15.         
    
16.         for(int j=1;j<strlen(b),j++)
    
17.         {
    
18.            if(b[j-1]>b[j])
    
19.            {
    
20.                
    
21.            }
    
22.         }
    
23.         
    
24.     }
    
25. }

复制代码

修改代码，题目链接：https://www.acwing.com/problem/content/773/，想一半没有思路了

isdkz

你好！根据题目要求，我们需要找出字符串中最长的连续出现的字符。下面是修改后的代码：

1. #include <bits/stdc++.h>
   
2. using namespace std;
   
3. 
   
4. int main()
   
5. {
   
6.     int n;
   
7.     cin >> n;
   
8.     while (n--)
   
9.     {
   
10.         string a;
    
11.         cin >> a;
    
12.         int maxLen = 1;  // 最长连续出现字符的长度
    
13.         int curLen = 1;  // 当前连续出现字符的长度
    
14. 
    
15.         for (int i = 1; i < a.length(); i++)
    
16.         {
    
17.             if (a[ i] == a[i-1])
    
18.             {
    
19.                 curLen++;
    
20.                 maxLen = max(maxLen, curLen);
    
21.             }
    
22.             else
    
23.             {
    
24.                 curLen = 1;
    
25.             }
    
26.         }
    
27. 
    
28.         cout << maxLen << endl;
    
29.     }
    
30. 
    
31.     return 0;
    
32. }
    

复制代码

这段代码的思路是遍历输入的字符串，当当前字符与前一个字符相同时，当前连续出现字符的长度加1，并更新最长连续出现字符的长度。当当前字符与前一个字符不同时，将当前连续出现字符的长度重置为1。最后输出最长连续出现字符的长度。

希望能帮到你！如果还有其他问题，请随时提问。

陶远航

你的代码有一些问题，我会帮你修改并提供一个解决方案。这个问题的关键是找到字符串中最长的连续字符。我们可以通过遍历字符串，比较当前字符和前一个字符是否相同，如果相同，我们就增加计数器，否则我们就重置计数器。同时，我们需要一个变量来保存最长的连续字符长度和对应的字符。

以下是修改后的代码：

1. #include <bits/stdc++.h>
   
2. using namespace std;
   
3. 
   
4. int main() {
   
5.     int n;
   
6.     cin >> n;
   
7.     while(n--) {
   
8.         string a;
   
9.         cin >> a;
   
10.         int maxCount = 0;
    
11.         char maxChar = a[0];
    
12.         int currentCount = 1;
    
13.         for(int i = 1; i < a.size(); i++) {
    
14.             if(a[ i] == a[i-1]) {
    
15.                 currentCount++;
    
16.             } else {
    
17.                 currentCount = 1;
    
18.             }
    
19.             if(currentCount > maxCount) {
    
20.                 maxCount = currentCount;
    
21.                 maxChar = a[ i];
    
22.             }
    
23.         }
    
24.         cout << "The longest consecutive character is " << maxChar << " with length " << maxCount << endl;
    
25.     }
    
26.     return 0;
    
27. }
    

复制代码

这段代码首先读取测试用例的数量，然后对每个测试用例，读取字符串并遍历。如果当前字符和前一个字符相同，就增加计数器，否则重置计数器。如果当前计数器的值大于最大计数器的值，就更新最大计数器和对应的字符。最后，输出最长的连续字符和对应的长度。

注意，这段代码假设输入的字符串至少有一个字符，并且只包含小写字母。如果输入可能包含大写字母或其他字符，或者可能为空，你可能需要修改代码以适应这些情况。
请注意，本回答来自GPT-4
如果问题已经解决，请设置最佳答案

Mike_python小

你的代码中存在一些问题。下面是修改后的代码：

2. #include <iostream>
3. #include <cstring>
4. using namespace std;
6. int main() {
7.     int n;
8.     cin >> n;
9.    
10.     while (n--) {
11.         string a;
12.         cin >> a;
13.         
14.         int b[26]{0}; // 用一个数组来记录每个字母出现的次数
15.         
16.         for (auto c : a) {
17.             b[c - 'a']++;
18.         }
19.         
20.         int maxCount = 0; // 最大连续出现次数
21.         char maxChar = ' '; // 最长连续出现的字符
22.         
23.         int count = 1; // 当前字符连续出现的次数
24.         
25.         for (int i = 1; i < a.length(); i++) {
26.             if (a[i] == a[i - 1]) {
27.                 count++;
28.             } else {
29.                 if (count > maxCount) {
30.                     maxCount = count;
31.                     maxChar = a[i - 1];
32.                 }
33.                 count = 1;
34.             }
35.         }
36.         
37.         // 检查最后一个字符
38.         if (count > maxCount) {
39.             maxCount = count;
40.             maxChar = a[a.length() - 1];
41.         }
42.         
43.         cout << maxChar << " " << maxCount << endl;
44.     }
45.    
46.     return 0;
47. }

复制代码

修改后的代码使用了一个大小为26的整型数组b，用来记录每个字母出现的次数。遍历字符串a中的每个字符，然后根据字符-'a'的值将其对应的次数加1。

接下来，使用一个循环来查找最长连续出现的字符。使用变量count来记录当前字符连续出现的次数。当遇到不同的字符时，将count与maxCount进行比较，更新最大连续出现次数和最长连续出现的字符。

最后，输出最长连续出现的字符和次数。

希望这样的修改可以帮助到你。如果还有其他问题，请随时提问。

球一个最佳答案谢谢啦！这对我非常重要！

jackz007

1. #include <bits/stdc++.h>
   
2. using namespace std                           ;
   
3. 
   
4. int main()
   
5. {
   
6.         char c , g                            ;
   
7.         int b , i , k , m                     ;
   
8.         string a                              ;
   
9.         cin >> a                              ;
   
10.         if(a[0]) {
    
11.                 for(b = i = m = 1 , c = g = a[0] ; a[i] ; i ++) {
    
12.                         if(a[i] == c) {          // 字符连续相同
    
13.                                 b ++          ;  // 连续相同字符计数
    
14.                         } else {                 // 字符改变
    
15.                                 if(b > m) {      // 判定当前已统计字符是否属于出现次数最多
    
16.                                         m = b ;  // 是，记录出现次数
    
17.                                         g = c ;  // 记录该字符
    
18.                                 }
    
19.                                 b = 1         ;  // 初始化连续出现字符计数器为 1
    
20.                                 c = a[i]      ;  // 更换记录字符以便继续比较
    
21.                         }
    
22.                 }
    
23.         }
    
24.         cout << g << " : " << m << endl       ;
    
25. }

复制代码

        编译、运行实况：

1. D:\[exercise]\C>g++ -o a a.c
   
2. 
   
3. D:\[exercise]\C>a
   
4. abcdeaaaxxyyzzqrstttttttabctt
   
5. t : 7
   
6. 
   
7. D:\[exercise]\C>

复制代码