各大计算机公司 笔试及面试 题目 - 华为（上机 4-6）

备注：转载于 http://blog.csdn.net/ychtt/article/details/6774184

 4.删除字符串中所有给定的子串
问题描述： 
在给定字符串中查找所有特定子串并删除，如果没有找到相应子串，则不作任何操作。
要求实现函数： 
 int delete_sub_str(const char *str, const char *sub_str, char *result_str)
【输入】 str：输入的被操作字符串
         sub_str：需要查找并删除的特定子字符串
【输出】 result_str：在str字符串中删除所有sub_str子字符串后的结果
【返回】 删除的子字符串的个数

 

view plain

1. #include <stdio.h>     
2. #include <string.h>    
3. #include "string"   
4. int delete_sub_str(const char *str, const char *sub_str, char *result_str)    
5. {    
6.     int count = 0;    
7.     int k=0;  
8.     int n=strlen(str);  
9.     for (int i=0;i<n;i++)  
10.     {  
11.         while (str[i]!=sub_str[0]&&str[i]!='\0')  
12.         {         
13.             result_str[k++]=str[i];  
14.             i++;  
15.         }  
16.         int j=0;  
17.         int temp=i;  
18.         while (str[i]==sub_str[j]&&str[i]!='\0'&&sub_str[j]!='\0')  
19.         {  
20.             i++;  
21.             j++;  
22.         }  
23.         if (sub_str[j]=='\0')  
24.         {  
25.             count++;  
26.         }  
27.         else  
28.         {  
29.             while (temp<i)  
30.             {  
31.                 result_str[k++]=str[temp];  
32.                 temp++;  
33.             }  
34.               
35.   
36.         }  
37.   
38.         i--;  
39.     }  
40.     result_str[k]='\0';  
41.     return count;  
42.       
43. }    
44.   
45. int main()    
46. {    
47.     char *str = "aadde";    
48.     char *sub = "ad";    
49.     char res[50] ="";    
50.     int count = delete_sub_str(str, sub, res);    
51.     printf("子字符串的个数是：%d\n", count);    
52.     printf("删除子字符串后：%s\n", res);    
53.     return 0;    
54. }  
55.   
56.    

 

5. 高精度整数加法
 问题描述： 
 在计算机中，由于处理器位宽限制，只能处理有限精度的十进制整数加减法，比如在32位宽处理器计算机中，
 参与运算的操作数和结果必须在-231~231-1之间。如果需要进行更大范围的十进制整数加法，需要使用特殊
 的方式实现，比如使用字符串保存操作数和结果，采取逐位运算的方式。如下：
9876543210 + 1234567890 = ?
让字符串 num1="9876543210"，字符串 num2="1234567890"，结果保存在字符串 result = "11111111100"。
-9876543210 + (-1234567890) = ?
让字符串 num1="-9876543210"，字符串 num2="-1234567890"，结果保存在字符串 result = "-11111111100"。
 要求编程实现上述高精度的十进制加法。
 要求实现函数： 
 void add (const char *num1, const char *num2, char *result)
 【输入】num1：字符串形式操作数1，如果操作数为负，则num1[0]为符号位'-'
 num2：字符串形式操作数2，如果操作数为负，则num2[0]为符号位'-'
 【输出】result：保存加法计算结果字符串，如果结果为负，则result[0]为符号位。
 注：
I、   当输入为正数时，'+'不会出现在输入字符串中；当输入为负数时，'-'会出现在输入字符串中，且一定在输入字符串最左边位置；
 II、  输入字符串所有位均代表有效数字，即不存在由'0'开始的输入字符串，比如"0012", "-0012"不会出现；
 III、       要求输出字符串所有位均为有效数字，结果为正或0时'+'不出现在输出字符串，结果为负时输出字符串最左边位置为'-'。

view plain

1. #include "string.h"  
2. #include "iostream"  
3. using namespace std;  
4. void reverse(char *str)  
5. {  
6.     int i=0;  
7.     int len=strlen(str);  
8.     int temp=0;  
9.     while (i<(len+1)/2)  
10.     {  
11.         temp=str[i];  
12.         str[i]=str[len-1-i];  
13.         str[len-1-i]=temp;  
14.         i++;  
15.     }  
16. }  
17.   
18. void sub (const char *num1, const char *num2, char *result)  //num1-num2  
19. {  
20.     int num1len=strlen(num1)-1;  
21.     int num2len=strlen(num2)-1;  
22.     int t1=0;  
23.     int t2=0;  
24.     if (num1[0]=='-')  
25.         t1=1;  
26.     else  
27.         t2=1;  
28.     int k=0;  
29.     int t=0;  
30.     int *subnum1=new int[num1len+1];    借位  
31.     memset(subnum1,0,(num1len+1)*sizeof(int));  
32.     while (num1len>=t1&&num2len>=t2)  
33.     {  
34.         if (num1[num1len]+subnum1[num1len]<num2[num2len])  
35.         {  
36.             int q=num1len-1;  
37.             while (num1[q]=='0')  
38.             {  
39.                 subnum1[q]=9;           //借位  
40.                 q--;  
41.             }  
42.             subnum1[q]-=1;  
43.             result[k++]=(num1[num1len]-'0')+subnum1[num1len]+10-(num2[num2len]-'0')+'0';  
44.         }  
45.         else  
46.             result[k++]=(num1[num1len]-'0')+subnum1[num1len]-(num2[num2len]-'0')+'0';  
47.         num1len--;  
48.         num2len--;  
49.     }  
50.   
51.     while (num1len>=t1)  
52.     {  
53.         result[k++]=num1[num1len]+subnum1[num1len];  
54.         num1len--;  
55.     }  
56.     k--;  
57.     while (result[k]-'0'==0)  
58.     {  
59.         k--;  
60.     }  
61. k++;  
62.     if (num1[0]=='-')  
63.         result[k++]=num1[0];  
64.     result[k]='\0';  
65.   
66. }  
67.   
68.   
69. void add (const char *num1, const char *num2, char *result)  
70. {  
71.     int num1len=strlen(num1)-1;  
72.     int num2len=strlen(num2)-1;  
73.     int t=0;                   //进位  
74.     int k=0;  
75.     if (num1[0]=='-'&&num2[0]=='-'||(num1[0]!='-'&&num2[0]!='-'))   //作加法运算  
76.     {  
77.         int t1=num1len;  
78.         int t2=num2len;  
79.         int t11=0;  
80.         if (num1[0]=='-'&&num2[0]=='-')  
81.             t11=1;  
82.         while (t1>=t11&&t2>=t11)  
83.         {  
84.             result[k++]=((num1[t1]-'0')+(num2[t2]-'0')+t)%10+'0';  
85.             t=((num1[t1]-'0')+(num2[t2]-'0')+t)/10;  
86.             t1--;  
87.             t2--;  
88.         }  
89.         while (t2>=t11)  
90.         {  
91.             result[k++]=((num2[t2]-'0')+t)%10+'0';  
92.             t=((num2[t2]-'0')+t)/10;  
93.             t2--;  
94.         }  
95.           
96.         while (t1>=t11)  
97.         {  
98.             result[k++]=((num1[t1]-'0')+t)%10+'0';  
99.             t=((num1[t1]-'0')+t)/10;  
100.             t1--;  
101.         }  
102.           
103.         if (t!=0)  
104.             result[k++]=t+'0';  
105.         if (num1[0]=='-'&&num2[0]=='-')  
106.         {  
107.             result[k++]='-';  
108.         }  
109.         result[k]='\0';  
110.         reverse(result);      
111.     }  
112.     else   
113.     {  
114.         if (num1[0]=='-')  
115.         {  
116.             if (num1len==num2len+1)  
117.             {  
118.                 int j=0;  
119.                 while (j<num1len)  
120.                 {  
121.                     if (num1[j+1]>num2[j])  
122.                     {  
123.                         sub(num1,num2, result);  
124.                         reverse(result);  
125.                         break;  
126.                     }  
127.                     else if(num1[j+1]<num2[j])  
128.                     {  
129.                         sub(num2,num1, result);  
130.                         reverse(result);  
131.                         break;  
132.                     }  
133.                     else  
134.                         j++;                  
135.                 }  
136.   
137.             }  
138.             else if(num1len>num2len+1)  
139.             {  
140.                 sub(num1,num2, result);  
141.                 reverse(result);  
142.             }  
143.             else if(num1len<num2len+1)  
144.             {  
145.                 sub(num2,num1, result);  
146.                 reverse(result);  
147.             }  
148.   
149.         }  
150.         else if (num2[0]=='-')  
151.         {  
152.             if (num1len+1==num2len)  
153.             {  
154.                 int j=0;  
155.                 while (j<num2len)  
156.                 {  
157.                     if (num1[j]>num2[j+1])  
158.                     {  
159.                         sub(num1,num2, result);  
160.                         reverse(result);  
161.                         break;  
162.                     }  
163.                     else if(num1[j+1]<num2[j])  
164.                     {  
165.                         sub(num2,num1, result);  
166.                         reverse(result);  
167.                         break;  
168.                     }  
169.                     else  
170.                         j++;                  
171.                 }  
172.                   
173.             }  
174.             else if(num1len+1>num2len)  
175.             {  
176.                 sub(num1,num2, result);  
177.                 reverse(result);  
178.             }  
179.             else if(num1len+1<num2len)  
180.             {  
181.                 sub(num2,num1, result);  
182.                 reverse(result);  
183.             }  
184.               
185.         }  
186.           
187.           
188.     }  
189. }  
190.   
191. int main()    
192. {    
193.     char *a = "-10000";    
194.     char *b = "33";   
195.     char res[200];    
196.     add(a, b, res);    
197.     printf("%s\n", res);    
198.     return 0;    
199. }    

6.数组比较 
问题描述：
 比较两个数组，要求从数组最后一个元素开始逐个元素向前比较，如果2个数组长度不等，则只比较较短长度数组个数元素。请编程实现上述比较，并返回比较中发现的不相等

元素的个数
 比如：
 数组{1,3,5}和数组{77,21,1,3,5}按题述要求比较，不相等元素个数为0
数组{1,3,5}和数组{77,21,1,3,5,7}按题述要求比较，不相等元素个数为3
 要求实现函数：
 int array_compare(int len1, int array1[], int len2, int array2[])
 【输入】 int len1：输入被比较数组1的元素个数； 
 int array1[]：输入被比较数组1； 
 int len2：输入被比较数组2的元素个数； 
 int array2[]：输入被比较数组2；
 【输出】  无 
 【返回】  不相等元素的个数，类型为int
 示例
 1）  输入：int array1[] = {1,3,5}，int len1 = 3，int array2[] = {77,21,1,3,5}，int len2 = 5
 函数返回：0
 2）  输入：int array1[] = {1,3,5}，int len1 = 3，int array2[] = {77,21,1,3,5,7}，int len2 = 6
 函数返回：3

view plain

1. #include <stdio.h>     
2. #include <string.h>    
3. #include "string"   
4. #include "assert.h"   
5. int array_compare(int len1, int array1[], int len2, int array2[])   
6. {  
7.     assert(array1!=NULL&&array1!=NULL);  
8.     int count=0;  
9.     while (len1!=0&&len2!=0)  
10.     {  
11.         if (array1[len1-1]!=array2[len2-1])  
12.         {  
13.             count++;  
14.         }  
15.         len1--;  
16.         len2--;  
17.     }  
18.     return count;  
19.   
20. }  
21.   
22. int main()    
23. {   
24.     int array1[] = {1,3,5};  
25.     int len1 = 3;  
26.     int array2[] = {77,21,1,3,5};  
27.     int len2 = 5;  
28.     printf("%d",array_compare(len1, array1,len2, array2));  
29.     int array3[] = {1,3,5};  
30.     len1 = 3;  
31.     int array4[] = {77,21,1,3,5,7};  
32.      len2 = 6;  
33.      printf("%d",array_compare(len1, array3,len2, array4));  
34. }