[已解决]我这个程序怎么加快运行速度啊

Gordon1

1. #include<iostream>
   
2. using namespace std;
   
3. int main()
   
4. {
   
5.         int ch,a=0,b=0,c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,t=0,u=0,v=0,w=0,x=0,y=0,z=0;
   
6.        
   
7.         while((ch=getchar())!='\n')
   
8.         {
   
9.                 if(ch==97){
   
10.                         a+=1;
    
11.                         continue;}       
    
12.                 if(ch==98){
    
13.                         b+=1;       
    
14.                         continue;}       
    
15.                 if(ch==99){
    
16.                         c+=1;
    
17.                         continue;}       
    
18.                 if(ch==100){
    
19.                         d+=1;
    
20.                         continue;}
    
21.                 if(ch==101){
    
22.                         e+=1;
    
23.                         continue;}
    
24.                 if(ch==102){
    
25.                         f+=1;
    
26.                         continue;}
    
27.                 if(ch==103){
    
28.                         g+=1;
    
29.                         continue;}
    
30.                 if(ch==104){
    
31.                         h+=1;
    
32.                         continue;
    
33.                 }
    
34.                 if(ch==105){
    
35.                         i+=1;
    
36.                         continue;}
    
37.                 if(ch==106){
    
38.                         j+=1;
    
39.                         continue;}                
    
40.                 if(ch==107){
    
41.                         k+=1;
    
42.                         continue;}
    
43.                 if(ch==108){
    
44.                         l+=1;
    
45.                         continue;}
    
46.                 if(ch==109){
    
47.                         m+=1;
    
48.                         continue;}
    
49.                 if(ch==110){
    
50.                         n+=1;
    
51.                         continue;}
    
52.                 if(ch==111){
    
53.                         o+=1;
    
54.                         continue;}
    
55.                 if(ch==112){
    
56.                         p+=1;
    
57.                         continue;}
    
58.                 if(ch==113){
    
59.                         q+=1;
    
60.                         continue;}
    
61.                 if(ch==114){
    
62.                         r+=1;
    
63.                         continue;}
    
64.                 if(ch==115){
    
65.                         s+=1;
    
66.                         continue;}
    
67.                 if(ch==116){
    
68.                         t+=1;
    
69.                         continue;}
    
70.                 if(ch==117){
    
71.                         u+=1;
    
72.                         continue;}
    
73.                 if(ch==118){
    
74.                         v+=1;
    
75.                         continue;}
    
76.                 if(ch==119){
    
77.                         w+=1;
    
78.                         continue;}
    
79.                 if(ch==120){
    
80.                         x+=1;
    
81.                         continue;}
    
82.                 if(ch==121){
    
83.                         y+=1;
    
84.                         continue;}
    
85.                 if(ch==122){
    
86.                         z+=1;
    
87.                         continue;}
    
88.         }
    
89.        
    
90.         if(a&1==1)
    
91.                 cout<<"a";
    
92.         if(b&1==1)
    
93.                 cout<<"b";
    
94.         if(c&1==1)
    
95.                 cout<<"c";
    
96.         if(d&1==1)
    
97.                 cout<<"d";
    
98.         if(e&1==1)
    
99.                 cout<<"e";
    
100.         if(f&1==1)
     
101.                 cout<<"f";
     
102.         if(g&1==1)
     
103.                 cout<<"g";
     
104.         if(h&1==1)
     
105.                 cout<<"h";
     
106.         if(i&1==1)
     
107.                 cout<<"i";
     
108.         if(j&1==1)
     
109.                 cout<<"j";
     
110.         if(k&1==1)
     
111.                 cout<<"k";
     
112.         if(l&1==1)
     
113.                 cout<<"l";
     
114.         if(m&1==1)
     
115.                 cout<<"m";
     
116.         if(n&1==1)
     
117.                 cout<<"n";
     
118.         if(o&1==1)
     
119.                 cout<<"o";
     
120.         if(p&1==1)
     
121.                 cout<<"p";
     
122.         if(q&1==1)
     
123.                 cout<<"q";
     
124.         if(r&1==1)
     
125.                 cout<<"r";
     
126.         if(s&1==1)
     
127.                 cout<<"s";
     
128.         if(t&1==1)
     
129.                 cout<<"t";
     
130.         if(u&1==1)
     
131.                 cout<<"u";
     
132.         if(v&1==1)
     
133.                 cout<<"v";
     
134.         if(w&1==1)
     
135.                 cout<<"w";
     
136.         if(x&1==1)
     
137.                 cout<<"x";
     
138.         if(y&1==1)
     
139.                 cout<<"y";
     
140.         if(z&1==1)
     
141.                 cout<<"z";
     
142.        
     
143.         return 0;       
     
144. }

复制代码

问题：编写一个程序，输入一组字符（只包含字母，且长度小于100，回车结束输入），该字符数组中只有一个字符出现的次数为奇数，其他字符出现的次数均为偶数，输出出现次数为奇数的字符。

最佳答案

月排行榜 / 总排行榜

FishC

2024-2-2 11:34:46

这段代码中，你使用了26个变量来记录字母出现的次数，并在循环中逐个判断字符属于哪个字母并累加计数。这种方式不仅代码冗长且重复，还降低了程序的效率。

要加快程序的运行速度，可以使用一个数组来代替这些变量，然后根据字符的ASCII码值来直接累加数组元素。

下面是一个修改后的示例代码：

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. int main()
   
5. {
   
6.     int counts[26] = {0};  // 用数组来记录每个字母出现的次数
   
7.    
   
8.     char ch;
   
9.     while ((ch = getchar()) != '\n')
   
10.     {
    
11.         if (ch >= 'a' && ch <= 'z')  // 只统计小写字母
    
12.             counts[ch - 'a'] += 1;  // 根据字符的ASCII码值来累加对应的数组元素
    
13.     }
    
14.    
    
15.     for (int i = 0; i < 26; ++i)
    
16.     {
    
17.         if (counts[i] > 0)
    
18.         {
    
19.             cout << static_cast<char>(i + 'a') << ": " << counts[i] << endl;
    
20.         }
    
21.     }
    
22.    
    
23.     return 0;
    
24. }

复制代码

在这个修改后的代码中，我们使用一个长度为26的整型数组`counts`来记录每个字母的出现次数。在循环中，我们只统计小写字母，并通过字符的ASCII码值减去字符'a'的ASCII码值来获取数组的索引，并累加对应的数组元素。最后，我们遍历数组，输出非零元素，即每个字母出现的次数。

相比原来的代码，这个修改后的代码效率更高，因为它使用了一个数组来一次性处理所有的字母，不再需要逐个判断和累加。同时，由于只统计小写字母，也节省了一些不必要的判断条件。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

跳转到最佳答案楼层

FishC

这段代码中，你使用了26个变量来记录字母出现的次数，并在循环中逐个判断字符属于哪个字母并累加计数。这种方式不仅代码冗长且重复，还降低了程序的效率。

要加快程序的运行速度，可以使用一个数组来代替这些变量，然后根据字符的ASCII码值来直接累加数组元素。

下面是一个修改后的示例代码：

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. int main()
   
5. {
   
6.     int counts[26] = {0};  // 用数组来记录每个字母出现的次数
   
7.    
   
8.     char ch;
   
9.     while ((ch = getchar()) != '\n')
   
10.     {
    
11.         if (ch >= 'a' && ch <= 'z')  // 只统计小写字母
    
12.             counts[ch - 'a'] += 1;  // 根据字符的ASCII码值来累加对应的数组元素
    
13.     }
    
14.    
    
15.     for (int i = 0; i < 26; ++i)
    
16.     {
    
17.         if (counts[i] > 0)
    
18.         {
    
19.             cout << static_cast<char>(i + 'a') << ": " << counts[i] << endl;
    
20.         }
    
21.     }
    
22.    
    
23.     return 0;
    
24. }

复制代码

在这个修改后的代码中，我们使用一个长度为26的整型数组`counts`来记录每个字母的出现次数。在循环中，我们只统计小写字母，并通过字符的ASCII码值减去字符'a'的ASCII码值来获取数组的索引，并累加对应的数组元素。最后，我们遍历数组，输出非零元素，即每个字母出现的次数。

相比原来的代码，这个修改后的代码效率更高，因为它使用了一个数组来一次性处理所有的字母，不再需要逐个判断和累加。同时，由于只统计小写字母，也节省了一些不必要的判断条件。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

zhangchenyvn

没学过Cpp，试一下改else if？

Gordon1

还是超时怎么办

Gordon1

FishC 发表于 2024-2-2 11:34
这段代码中，你使用了26个变量来记录字母出现的次数，并在循环中逐个判断字符属于哪个字母并累加计数。这种 ...

还是超时怎么办

FishC

Gordon1 发表于 2024-02-02 12:16
还是超时怎么办

如果你的程序仍然超时，可能需要进一步优化算法或采用更高效的数据结构。以下是一些可能的优化策略：

1. 减少循环次数：尽量避免不必要的循环。例如，在字符串处理中，可以使用双指针技巧来减少循环次数。

2. 使用适当的数据结构：根据实际情况选择适当的数据结构。有时候，使用哈希表、二叉树等数据结构可以更高效地解决问题。

3. 使用算法优化：对于一些常见的问题，常常有一些经典的算法优化技巧，例如动态规划、贪心算法等。你可以查找相关的算法优化技巧，尝试应用到自己的代码中。

4. 并行计算：如果你的机器具备多核处理能力，可以考虑使用多线程或并行计算来加速程序运行。

5. 优化I/O操作：I/O操作往往是程序运行速度的瓶颈之一。尽量减少读写操作次数，可以使用缓冲区技术、异步IO等方法优化。

6. 避免重复计算：如果你的程序中存在重复计算的部分，可以考虑使用缓存或记忆化搜索等技术避免重复计算。

7. 使用编译器优化选项：合理使用编译器提供的优化选项，例如gcc的-O2或者-Ofast选项。

最后，如果以上方法仍然无法满足需求，可能需要考虑重新设计算法或使用更高性能的计算资源。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

Gordon1

FishC 发表于 2024-2-2 12:16
如果你的程序仍然超时，可能需要进一步优化算法或采用更高效的数据结构。以下是一些可能的优化策略：
...

双指针技巧是什么

FishC

Gordon1 发表于 2024-02-02 12:20
双指针技巧是什么

双指针技巧是一种常用的算法优化技巧，特别适用于需要在数组或字符串中进行查找、比较或处理的问题。该技巧使用两个指针分别指向不同的位置，通过移动指针来迭代处理元素，从而避免了不必要的重复计算和循环。

常见的双指针技巧有以下几种：

1. 对撞指针（Two Pointers Approach）：两个指针分别从数组的两侧开始向中间移动。在某些情况下，这可以帮助我们快速找到满足特定条件的元素或区间。例如，判断一个数组中是否存在两个数之和等于目标值。

2. 快慢指针（Fast-Slow Pointers）：一个指针移动速度较快，另一个指针移动速度较慢。通常用于解决链表相关的问题，如判断链表是否有环，找到链表的中间节点等。

3. 左右指针（Left-Right Pointers）：两个指针分别从数组的左右两端开始向中间移动。常用于对数组进行排序或查找问题。例如，快速排序算法中使用的分治思想就是基于左右指针的。

4. 滑动窗口（Sliding Window）：使用一个窗口来滑动遍历数组或字符串，以解决子串或子数组相关的问题。滑动窗口通常通过移动左右指针来调整窗口大小。例如，找到最长的连续子串，满足某种条件。

这些双指针技巧在算法问题中非常常见，并且可以在一定程度上提高代码的效率和简洁性。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

Gordon1

FishC 发表于 2024-2-2 12:20
双指针技巧是一种常用的算法优化技巧，特别适用于需要在数组或字符串中进行查找、比较或处理的问题。该 ...

1. #include<iostream>
   
2. using namespace std;
   
3. int main()
   
4. {
   
5.         int ch;
   
6.         int count[26]={0};
   
7.         while ((ch = getchar()) != '\n')
   
8.     {
   
9.                 count[ch - 'a'] += 1;
   
10.     }
    
11.         int i=0,j=25;
    
12.         while(i<j)
    
13.         {
    
14.                 if(count[i]%2==1)
    
15.                 {
    
16.                         printf("%c",i+97);
    
17.                         break;
    
18.                 }
    
19.                 if(count[j]%2==1)
    
20.                 {
    
21.                         printf("%c",j+97);
    
22.                         break;
    
23.                 }
    
24.                 i++;
    
25.                 j--;
    
26.         }
    
27.         return 0;       
    
28. }

复制代码

这样还是超时怎么办

FishC

Gordon1 发表于 2024-02-02 19:34
#include
using namespace std;
int main()
{
        in ...

在你的代码中，你使用了一个数组来记录每个字母出现的次数，并且使用了两个指针i和j分别指向数组的开头和结尾。然后，在一个循环中，你尝试将数组的元素从两端进行比较，直到两个指针相遇为止。

然而，这种方法并不能满足我们通常所说的双指针技巧。双指针技巧通常应用于更复杂的问题，例如查找指定数字、判断字符串是否回文等。

如果你想对字符数组进行反转操作，可以使用下面的示例代码：

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. void reverseString(char* s, int length) {
   
5.     int left = 0;
   
6.     int right = length - 1;
   
7.    
   
8.     while (left < right) {
   
9.         char temp = s[left];
   
10.         s[left] = s[right];
    
11.         s[right] = temp;
    
12.         
    
13.         left++;
    
14.         right--;
    
15.     }
    
16. }
    
17. 
    
18. int main() {
    
19.     char str[] = "Hello, World!";
    
20.     int length = sizeof(str) - 1;  // 需要减去末尾的空字符
    
21.    
    
22.     reverseString(str, length);
    
23.    
    
24.     cout << str << endl;
    
25.    
    
26.     return 0;
    
27. }

复制代码

在上述示例代码中，`reverseString`函数接收一个字符数组和数组的长度作为参数，然后使用双指针技巧，即左右指针来交换数组中的元素，实现字符串的反转操作。最后，在`main`函数中调用`reverseString`函数并输出结果。

希望这个示例可以帮助你理解双指针技巧的应用。如果你还有其他关于双指针或其他编程问题的疑问，请随时提问。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

Gordon1

FishC 发表于 2024-2-2 19:35
在你的代码中，你使用了一个数组来记录每个字母出现的次数，并且使用了两个指针i和j分别指向数组的开头 ...

我想快速找到数组里面哪个数是可以用双指针技巧吗

FishC

Gordon1 发表于 2024-02-02 19:42
我想快速找到数组里面哪个数是可以用双指针技巧吗

是的，双指针技巧可以帮助你在数组中快速找到目标数。双指针技巧适用于一些特定的问题，例如查找两个数之和等于目标数、查找数组中是否存在重复元素等。

例如，我们来看一个示例代码，在一个已排序的数组中查找两个数之和等于目标数的情况：

1. #include <iostream>
   
2. #include <vector>
   
3. using namespace std;
   
4. 
   
5. vector<int> twoSum(vector<int>& nums, int target) {
   
6.     vector<int> result;
   
7.     int left = 0;
   
8.     int right = nums.size() - 1;
   
9.    
   
10.     while (left < right) {
    
11.         int sum = nums[left] + nums[right];
    
12.         if (sum == target) {
    
13.             // 找到了目标数对，将两个数的索引加入结果数组中
    
14.             result.push_back(left);
    
15.             result.push_back(right);
    
16.             break;
    
17.         } else if (sum < target) {
    
18.             // 当前和小于目标数，左指针向右移动
    
19.             left++;
    
20.         } else {
    
21.             // 当前和大于目标数，右指针向左移动
    
22.             right--;
    
23.         }
    
24.     }
    
25.    
    
26.     return result;
    
27. }
    
28. 
    
29. int main() {
    
30.     vector<int> nums = {2, 7, 11, 15};
    
31.     int target = 9;
    
32.    
    
33.     vector<int> result = twoSum(nums, target);
    
34.     if (result.size() == 2) {
    
35.         cout << "两个数的索引分别为：" << result[0] << ", " << result[1] << endl;
    
36.     } else {
    
37.         cout << "未找到符合条件的数对" << endl;
    
38.     }
    
39.    
    
40.     return 0;
    
41. }

复制代码

上述示例代码中，我们使用了两个指针left和right，分别指向数组的开头和结尾。通过不断调整指针的位置，当找到两个数之和等于目标数时，即可返回结果。这种方式可以快速找到目标数，同时避免使用嵌套循环的低效率解法。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。