2021年华为面试编程题.doc

华为软件校园招聘编程测验

类别：软件C语言

编程题（共2题，第一题40分，第二题60分，共100分。请上机编写程序，按题目规定提交文献。[详见考试阐明]

本试题采用自动测试用例进行评分，测试用例不对考生公开，凡不满足提交规定导致不能运营或用例不通过，不予评分）。

1. 删除字符串中所有给定子串（40分）

问题描述：
在给定字符串中查找所有特定子串并删除，如果没有找到相应子串，则不作任何操作。

规定实现函数：
int delete_sub_str(const char *str，const char *sub_str，char *result_str)

【输入】 str：输入被操作字符串

sub_str：需要查找并删除特定子字符串

【输出】 result_str：在str字符串中删除所有sub_str子字符串后成果

【返回】 删除子字符串个数

注：

I、 子串匹配只考虑最左匹配状况，即只需要从左到右进行字串匹配状况。例如：

在字符串"abababab"中，采用最左匹配子串"aba",可以匹配2个"aba"字串。如果

匹配出从左到右位置2开始"aba"，则不是最左匹配，且只能匹配出1个"aba"字串。

II、 输入字符串不会超过100 Bytes，请不用考虑超长字符串状况。

示例
输入：str = "abcde123abcd123"

sub_str = "123"

输出：result_str = "abcdeabcd"

返回：2

输入：str = "abcde123abcd123"

sub_str = "1234"

输出：result_str = "abcde123abcd123"

返回：0

view plaincopy to clipboardprint?
01.#include <stdio.h>
02.#include <string.h>
03.#include <stdlib.h>
04.
05./*删除字串函数，在src中删除sub子串，并将成果保存在result字符串中*/
06.int delSubStr(char * src,char * sub,char * result)
07.{
08. char * src_p=src；
09. char * sub_p=sub；
10. char * res_p=result；
11. int count=0;//记录包括子串个数
12. int sub_len=strlen(sub);//记录子串长度
13. char * temp;//暂时保存子串副本
14. temp=(char *)malloc(sub_len+1)；
15. memset(temp,'\0',sub_len+1)；
16. while(*src_p)
17. {
18. memcpy(temp,src_p,sub_len)；
19.
20. /*原串中包括与sub完全匹配子串*/
21. if(!strcmp(temp,sub))
22. {
23. count++；
24. src_p+=sub_len；
25. }
26. else
27. *res_p++=*src_p++；
28. *res_p='\0'；
29. free(temp)；
30. return count;//返回包括子串个数
31.}
32.
33.void main()
34.{
35. char result[100]；
36. int count=delSubStr("abcdefgde","de",result)；
37. printf("The new string is:")；
38. printf("%s\n",result)；
39. printf("count is:")；
40. printf("%d\n",count)；
41.}

2. 高精度整数加法（60分）

问题描述：
在计算机中，由于解决器位宽限制，只能解决有限精度十进制整数加减法，例如在32位宽解决器计算机中，

参加运算操作数和成果必要在-231~231-1之间。如果需要进行更大范畴十进制整数加法，需要使用特殊

方式实现，例如使用字符串保存操作数和成果，采用逐位运算方式。如下：

+ = ?

让字符串 num1=""，字符串 num2=""，成果保存在字符串 result = ""。

- + (-) = ?

让字符串 num1="-"，字符串 num2="-"，成果保存在字符串 result = "-"。

规定编程实现上述高精度十进制加法。

规定实现函数：
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时'+'不出当前输出字符串，成果为负时输出字符串最左边位置为'-'。

示例
输入：num1 = "580"

num2 = "-50"

输出：result = "530"

输入：num1 = "580"

num2 = "-600"

输出：result = "-20"

程序代码（C语言）：

01.#include <stdio.h>
02.#include <string.h>
03.
04./*判断字符串整数与否合法，合法返回'1'，否则返回'0'*/
05.int isLegalNum(const char * num)
06.{
07. const char * num_p=num；
08. int num_len;//记录整数长度（不包括符号位和结束符'\0'）
09.
10. /*字符串指针为空，不是合法整数，返回'0'*/
11. if(num_p==NULL)
12. return 0；
13. if(*num_p=='-')
14. num_p++；
15. num_len=strlen(num)；
16.
17. /*不合法整数，返回'0'*/
18. if(*num_p<=48||*num_p>57)
19. return 0；
20. int i；
21. for(i=0;i<num_len;i++)
22. {
23. /*不合法整数，返回'0'*/
24. if(*num_p>57||*num_p<48)
25. return 0；
26. }
27. return 1；
28.}
29.
30./*将字符串逆序*/
31.void reverseStr(char * result)
32.{
33. int i；
34. char temp；
35. int res_len=strlen(result)；
36. for(i=0;i<res_len/2;i++)
37. {
38. temp=result[i]；
39. result[i]=result[res_len-i-1]；
40. result[res_len-i-1]=temp；
41. }
42.}
43.
44./*加法函数，用于将两个字符串形式整数相加，成果保存在 char * result 中*/
45.void add (const char * num1，const char * num2，char * result)
46.{
47. /*判断两个字符串整数 num1 和 num2 与否合法，如果不合法则规定顾客重新输入*/
48. if(!(isLegalNum(num1)&&isLegalNum(num2)))
49. {
50. strcpy(result,"对不起，您输入字符串整数不是合法十进制整数，请您检查后重新输入，谢谢合伙!")；
51. return；
52. }
53. int count=0;//记录进位或借位
54. const char * num1_p;//记录第一种数字符串起始地址
55. const char * num2_p;//记录第二个数字符串起始地址
56. char * res_p=result;//记录成果字符串起始地址
57. int num1_len=strlen(num1);//第一种数长度
58. int num2_len=strlen(num2);//第二个数长度
59. num1_p=num1+num1_len-1;//num1_p指向第一种数最后一位
60. num2_p=num2+num2_len-1;//num2_p指向第二个数最后一位
61.
62. /*加法运算，此时两个数符号相似*/
63. if((*num1!='-'&&*num2!='-')||(*num1=='-'&&*num2=='-'))
64. {
65. /*两个负数相加*/
66. if(*num1=='-'&&*num2=='-')
67. {
68. num1_len--；
69. num2_len--；
70. int i；
71. for(i=0;i<(num2_len>num1_len?num1_len:num2_len);i++)
72. {
73. *res_p++=(*num1_p-'0'+*num2_p-'0'+count)%10+'0'；
74. count=(*num1_p-'0'+*num2_p-'0'+count)/10；
75. num1_p--；
76. num2_p--；
77. }
78.
79. /*如果第一种数长度不不大于第二个数*/
80. if(num1_len>num2_len)
81. {
82. for(i=0;i<num1_len-num2_len;i++)
83. {
84. *res_p++=(*num1_p-'0'+count)%10+'0'；
85. count=(*num1_p-'0'+count)/10；
86. num1_p--；
87. }
88. }
89.
90. /*如果第一种数长度不大于第二个数*/
91. else if(num1_len<num2_len)
92. {
93. for(i=0;i<num2_len-num1_len;i++)
94. {
95. *res_p++=(*num2_p-'0'+count)%10+'0'；
96. count=(*num2_p-'0'+count)/10；
97. num2_p--；
98. }
99. }
100.
101. /*向最高位进一位*/
102. if(count==1)
103. *res_p++='1'；
104. *res_p++='-'；
105. *res_p='\0'；
106. reverseStr(result)；
107. }
108.
109. /*两个正数相加*/
110. if(*num1!='-'&&*num2!='-')
111. {
112. int i；
113. for(i=0;i<(num2_len>num1_len?num1_len:num2_len);i++)
114. {
115. *res_p++=(*num1_p-'0'+*num2_p-'0'+count)%10+'0'；
116. count=(*num1_p-'0'+*num2_p-'0'+count)/10；
117. num1_p--；
118. num2_p--；
119. }
120.
121. /*如果第一种数长度不不大于第二个数*/
122. if(num1_len>num2_len)
123. {
124. for(i=0;i<num1_len-num2_len;i++)
125. {
126. *res_p++=(*num1_p-'0'+count)%10+'0'；
127. count=(*num1_p-'0'+count)/10；
128. num1_p--；
129. }
130. }
131.
132. /*如果第一种数长度不大于第二个数*/
133. else if(num1_len<num2_len)
134. {
135. for(i=0;i<num2_len-num1_len;i++)
136. {
137. *res_p++=(*num2_p-'0'+count)%10+'0'；
138. count=(*num2_p-'0'+count)/10；
139. num2_p--；
140.
141. }
142. }
143.
144. /*向最高位进一位*/
145. if(count==1)
146. *res_p++='1'；
147. *res_p='\0'；
148. reverseStr(result)；
149. }
150. }
151.
152. /*减法运算，此时两个数符号不同*/
153. else
154. {
155. int temp=1;//记录num1和num2哪一种是负数，默认以为num1为负数
156.
157. /*num1为负数*/
158. if(*num1=='-')
159. {
160. num1++；
161. num1_len--；
162. }
163.
164. /*num2为负数*/
165. else
166. {
167. temp=2；
168. num2++；
169. num2_len--；
170. }
171.
172. /*num1绝对值大*/
173. if(num1_len>num2_len||num1_len==num2_len&&strcmp(num1,num2)>0)
174. {
175. int i；
176. for(i=0;i<num2_len;i++)
177. {
178. /*不借位*/
179. if(*num1_p-count>=*num2_p)
180. {
181. *res_p++=(*num1_p-*num2_p-count)%10+'0'；
182. count=0；
183. }
184.
185. /*借位*/
186. else if(*num1_p-count<*num2_p)
187. {
188. *res_p++=(*num1_p+10-*num2_p-count)%10+'0'；
189. count=1；
190. }
191. num1_p--；
192. num2_p--；
193. }
194. for(i=0;i<num1_len-num2_len;i++)
195. {
196. /*不借位*/
197. if(*num1_p-'0'-count>=0)
198. {
199. *res_p++=(*num1_p-'0'-count)%10+'0'；
200. count=0；
201. }
202.
203. /*借位*/
204. else if(*num1_p-'0'-count<0)
205. {
206. *res_p++=(*num1_p+10-'0'-count)%10+'0'；
207. count=1；
208. }
209. num1_p--；
210. }
211. do
212. {
213. res_p--；
214. }
215. while(*res_p=='0')；
216.
217. /*num1是负数且绝对值大，因此此时成果为负数*/
218. if(temp==1)
219. {
220. res_p++；
221. *res_p++='-'；
222. *res_p='\0'；
223. reverseStr(result)；
224. }
225.
226. /*num1是正数且绝对值大，因此此时成果为正数*/
227. else if(temp==2)
228. {
229. res_p++；
230. *res_p='\0'；
231. reverseStr(result)；
232. }
233. }
234.
235. /*num2绝对值大*/
236. else if(num1_len<num2_len||num1_len==num2_len&&strcmp(num1,num2)<0)
237. {
238. int i；
239. for(i=0;i<num1_len;i++)
240. {
241. /*不借位*/
242. if(*num2_p-count>=*num1_p)
243. {
244. *res_p++=(*num2_p-*num1_p-count)%10+'0'；
245. count=0；
246. }
247. /*借位*/
248. else if(*num2_p-count<*num1_p)
249. {
250. *res_p++=(*num2_p+10-*num1_p-count)%10+'0'；
251. count=1；
252. }
253. num1_p--；
254. num2_p--；
255. }
256. for(i=0;i<num2_len-num1_len;i++)
257. {
258. /*不借位*/
259. if(*num2_p-'0'-count>=0)
260. {
261. *res_p++=(*num2_p-'0'-count)%10+'0'；
262. count=0；
263. }
264.
265. /*借位*/
266. else if(*num2_p-'0'-count<0)
267. {
268. *res_p++=(*num2_p+10-'0'-count)%10+'0'；
269. count=1；
270. }
271. num2_p--；
272. }
273. do
274. {
275. res_p--；
276. }
277. while(*res_p=='0')；
278.
279. /*num1是负数且绝对值小，因此此时成果为正数*/
280. if(temp==1)
281. {
282. res_p++；
283. *res_p='\0'；
284. reverseStr(result)；
285. }
286.
287. /*num1是正数且绝对值小，因此此时成果为负数*/
288. else if(temp==2)
289. {
290. res_p++；
291. *res_p++='-'；
292. *res_p='\0'；
293. reverseStr(result)；
294. }
295. }
296. /*num1和num2绝对值相等且异号，因此成果为'0'*/
297. else
298. {
299. *res_p++='0'；
300. *res_p='\0'；
301. }
302. }
303.}
304.
305.void main()
306.{
307. char result[100];//保存成果字符串
308. char num1[100]；
309. char num2[100]；
310. printf("请输入两个整数(整数之间用空格作为间隔符):")；
311. scanf("%s %s",num1,num2)；
312. add(num1,num2,result)；
313. printf("The result is:")；
314. printf("%s\n",result)；
315.}