华为笔试题.docx

华为笔试题.docx

《华为笔试题.docx》由会员分享，可在线阅读，更多相关《华为笔试题.docx（22页珍藏版）》请在冰豆网上搜索。

华为笔试题

试题

选择题

1、以下程序的输出结果是：

20\r\n正确值20\r转义符：

回车，\n转义符：

换行

#include<>

intmain（）

{

intn=4;

while（n--）

{

printf（"%d",--n）;

}

printf（"\r\n"）;

return0;

}

2、设有以下宏定义：

#defineN4

#defineY（n）（（N+1）*n）

则执行语句：

Y（5+1）为：

26如果#defineY（n）（（N+1）*（n））则Y（5+1）为30

3、

enumENUM_A

{

x1,

y1,

z1=5,

a1,

b1

};

enumENUM_AenumA=y1;

enumENUM_AenumB=b1;

请问enumA和enumB的值是多少？

17x1=0,y1=1,a1=6,b1=7

4、若有函数max（a,b），并且函数指针变量p已经指向函数，当调用该函数时正确的调用方法是：

（*p）（,）

5、对栈S进行下列操作：

push

（1）,push（5）,pop（）,push

（2）,pop（）,pop（）,则此时栈顶元素是：

NULL

6、在一个32位的操作系统中，设void*p=malloc（100），请问sizeof（p）的结果是：

4

7、若已定义:

inta[9],*p=a;并在以后的语句中未改变p的值，不能表示a[1]地址的表达式是：

Ca的值不能改变

A）p+1B）a+1C）a++D）++p

8、设有如下定义：

unsignedlongplArray[]={6,7,8,9,10};

unsignedlong*pulPtr;

则下列程序段的输出结果是什么？

D

pulPtr=plArray;

*（pulPtr+2）+=2;

printf（"%d,%d\r\n",*pulPtr,*（pulPtr+2））;

A）8,10B）6,8C）7,9D）6,10

9、以下程序运行后，输出结果是什么？

C

voidmain（）

{

char*szStr="abcde";

szStr+=2;

printf（"%1u\r\n",szStr）;

return;

}

A）cdeB）字符c的ASCII码值C）字符c的地址D）出错

10、给出以下定义：

charX[]="hello";\0

charY[]={'h','e','l','l','o'};

则正确的叙述为：

C

A）数组X和数组Y等价B）数组X和数组Y的长度相同

C）数组X的长度大于数组Y的长度D）数组X的长度小于数组Y的长度

11、在32位X86下，有下列程序

#include<>

voidmain（）

{

union

{

intk;

chari[2];

}*s,a;

s=&a;

s->i[0]=0x39;

s->i[1]=0x38;

printf（"%x\r\n",;

}

输出结果是：

B编译后的结果为CCCC3839,答案A

A）3839B）3938C）380039D）不可预知

12、有如下函数定义：

unsignedlongMyFunc（unsignedlongulKey）

{

return（（（ulKey&0x000000ffUL）<<24）|

（（ulKey&0x0000ff00UL）<<8）|

（（ulKey&0x00ff0000UL）>>8）|

（（ulKey&0xff000000UL）>>24））;

}

则MyFunc（0x）的返回值是：

C

A）0xB）0xC）0xD）0x

13、（（a>b）?

a:

b）代表什么含义：

b

A）代表a,b之中较小的那个值

B）代表a,b之中较大的那个值

C）代表a是否比b大

D）语法错误

14、某系统总线的一个总线周期包含3个时钟周期，每个总线周期可以传送32位数据。

若总线的时钟频率为33MHz，则总线带宽为多少MB/s？

B

A）11B）22C）33D）44

总线数据传输率=时钟频率/每个总线包含的时钟周期数*每个总线周期传送的字节数,33MHZ/3*（32/8）=44MB/S,答案为D

15、如下定义，则s在内存中占多大空间？

A

union

{

struct

{

unsignedcharaa:

4;

unsignedcharab:

4;

}a;

unsignedcharc;

unsignedchard;

}s;

A）1byteB）2byteC）3byteD）4byte

16、如下定义：

uniontagAAAA

{

struct

{

charucFirst;

shortusSecond;

charucThird;

}half_a;

longlI;

}number;

在按1字节对齐情况下，sizeof（uniontagAAAA）的大小是：

A

在按4字节对齐情况下，sizeof（uniontagAAAA）的大小是：

D?

?

sizeof（a）为8byte,所以C

A）4byteB）6byteC）8byteD）12byte

17、0x在采用BigEndian中内存的排列顺序是A，在采用LittleEndian内存中的排列顺序是C。

（答案从左到右内存地址依次增加）

A）12345678B）34127856C）78563412D）56781234

大端系统和小端系统

18、关于静态变量，下面说法“不正确”的有：

A

A）静态变量在堆栈中分配

B）静态变量的作用域一定是局部的，例如在一个文件内或一个函数内

C）静态变量可分为静态局变量和静态全局部变量

D）静态变量存在于数据段中

静态全局变量是位于数据段并且在程序开始运行的时候被加。

程序的动态的局部变量则分配在堆栈里面。

19、下面正确的有A

A）在中断中，不能同步获取信号量，但是可以释放信号量

B）在中断中，可以使用系统调用sleep函数来等待一会儿

C）每一个进程有自己的独立地址空间，每一个线程程序也有自己的独立地址空间（共享进程空间）

D）CPU占用率为60%，意思是CPU有60%的时间在运行指令40%的时间没有运行指令

20、设有如下定义：

int（*ptr）（）；则以下叙述中正确的是：

C

A）ptr是指向一维数组的指针变量

B）ptr是指向int型数据的指针变量

C）ptr是指向函数的指针，该函数返回一个int型数据

D）ptr是一个函数名，该函数的返回值是指向int型数据的指针

21、在Windows95环境下，定义数组：

int**a[2][4];则数组a所占用的内存单元为：

D

A）8字节B）32字节C）64字节D）不确定

数组a中元素为8个指针，一个指针为4个字节，8*4=32字节，答案为B

22、有国际标准化组织（ISO）和国际电信联盟（ITU-T）共同提出的开放系统互联（OSI）参考模型中共有B层，参考模型的最高层则为C层。

A）4B）7C）应用D）会话

23、关于以太网中的ARP协议，描述错误的是：

A

A）根据IP地址查询其对应的MAC地址

B）根据MAC地址查询其对应的IP地址，便于IP通信

C）通过ARP协议产生的IP和MAC地址的映射，超时会淘汰

D）ARP请求中的MAC地址为广播地址

24、关于TCP、UDP及其上层的应用，描述错误的是：

B

A）TCP协议面向连接的，UDP协议是面向无连接的

B）UDP不保证数据的可靠传送，而文件的传递时要求必须无错传送的，因而所有基于文件传递的应用都不能基于UDP，如：

TFTP

C）telnet是基于TCP的终端应用，连续输入的多个字符可能会被封装到一个TCP包中

D）在同一个节点上，基于TCP和UDP的应用端口号可以重叠

改错题

1、请指出下面程序的错误

unsignedchari=10;

charb=100;

char*p;

voidf（void）

{

while（--i>=0）

{

*（p++）=b;

}

}

while中，比较结果永远为真，死循环定义p为野指针

2、下面函数要实现打印helloworld的功能，请问程序中有何错误？

void*GetMemory（）

{

charstr[]="helloworld";

returnstr;

}

voidTest（）

{

char*str=NULL;

str=（char*）GetMemory（）;

printf（str）;

}

GetMemory中返回局部的地址

3、请问如下代码有什么错误？

#defineMAX_SIZE1000

#defineNULL0

#defineTRUE1

#defineFALSE0

structXXX

{

unsignedshorta;

unsignedshortb;

};

intdemo（structXXX*p,unsignedlongsize）

{

structXXX*temp;

temp=（structXXX*）malloc（sizeof（structXXX）*MAX_SIZE）;

if（NULL==temp）

{

returnFALSE;

}

memcpy（temp,p,sizeof（structXXX）*size）;

/*其他操作*/

free（temp）;

returnTRUE;

}

Demo

4、如下程序用于把“blue”字符串返回，请指出其中的错误。

char*GetBlue（）

{

char*pcColor;

char*pcNewColor;

pcColor="blue";

pcNewColor=（char*）malloc（strlen（pcColor））;

strcpy（pcNewColor,pcColor）;

returnpcNewColor;

}

晕，编译能通过，没找到错的地方！

！

！

？

？

？

5、请问如下程序段有什么错误？

main（）

{

unsignedlongi=0,*p,*p1;

p=（unsignedlong*）malloc（10000）;

p1=p;

for（i=0;i<9999;i++）

{

*p1=0x100;

p1++;

}

/*其他操作*/

free（p）;

}

p1越界访问

编程题

1、对称数判断问题

请编写一段程序，判断一个正整数是否为对称数（对称数即左右对称的数字，如3、22、121、1331、34543等），不允许利用C语言将数字转换为字符转的库函数。

intmain（）

{

unsignedintnum;

intnum1,num2;

inti,count;

boolx=false;

printf（"Pleaseinputanumber:

\n"）;

scanf（"%u",&num）;

num1=num;

num2=num;

count=bit（num）;

.pn）从第一个人开始从1报数，报数到3的人离开队列，队列里的下一个人继续从1开始报数，以此反复，当数到队列尾时，从队列头部继续报数，这样周而复始，知道队列剩一人。

给一个简单的例：

报数结果如下：

1，2，4，5，7，第一轮，3、6离开队列，7报数1，然后从队列头部继续报数，那么第一个人报数2，如此1，4，5，这样第二轮，位置2和位置7离开队列，并且从队列头部继续报数，第一个人报数1，因为队列尾部的7恰好报数到3.

1，4，这样第三轮，5被淘汰；

然后开始位置1的人报数1，最后位置1正好报数3，于是离开队列，最后剩下的人是4。

这样给定7个人，原始位置4的人是剩下的人。

请实现一个简单程序，实现上述问题，程序输入n，输出那个最后剩下的人的原始位置。

#include<>

#include<>

#include<>

#defineNULL0

#defineOK1

#defineERROR0

#defineOVERFLOW-2

typedefintStatus;

typedefintElemtype;/*定义数据元素类型*/

typedefstructCnode

{

Elemtypedata;

structCnode*next;

}CNode;

CNode*joseph;/*定义一个全局变量*/

StatusCreate_clist（CNode*clist,intn）

{

CNode*p,*q;

inti;

clist=NULL;

for（i=n;i>=1;i--）

{

p=（CNode*）malloc（sizeof（CNode））;

if（p==NULL）

returnOVERFLOW;/*存储分配失败*/

p->data=i;

p->next=clist;

clist=p;

if（i==n）

q=p;/*用q指向链表最后一个结点*/

}

q->next=clist;/*把链表的最后一个结点的链域指向链表的第一个结点，构成循环链表*/

joseph=clist;/*把创建好的循环链表头指针赋给全局变量*/

returnOK;

}/*end*/

StatusJoseph（CNode*clist,intm,intn,intk）

{

inti;

CNode*p,*q;

if（m>n）returnERROR;/*起始位置错*/

if（!

Create_clist（clist,n））

returnERROR;/*循环链表创建失败*/

p=joseph;/*p指向创建好的循环链表*/

for（i=1;i

p=p->next;/*p指向位置的结点*/

while（p）

{

for（i=1;i

p=p->next;/*找出第k个结点*/

q=p->next;

printf（"%d",q->data）;/*输出应出列的结点*/

if（p->next==p）

p=NULL;/*删除最后一个结点*/

else{p->next=q->next;

p=p->next;

free（q）;

}

}/*while*/

clist=NULL;

}/*end*/

intmain（）

{

intm,n,k,i;

CNode*clist;

clist=NULL;/*初始化clist*/

printf（"\n请输入围坐在圆桌周围的人数n:

"）;

cin>>n;

printf（"\n请输入第一次开始报数人的位置m:

"）;

cin>>m;

printf（"\n你希望报数到第几个数的人出列?

"）;

cin>>k;;

Create_clist（clist,n）;/*创建一个有n个结点的循环链表clist*/

printf（"\n出列的顺序如下?

：

\n"）;

Joseph（clist,m,n,k）;

（）;

return0;

}/*main*/

4．求2个字符串的最大公共子串CommonSubsequence最长公共子序列。

基于动态规划算法求解，对于所有情况都有O（n^2）的算法，对于稀疏情况还有更优的算法。

1.typedef enum  

2.{  

3.    up = 1,  

4.    leftd,  

5.    leftup  

6.} Direct;  

7.string lcs（string& t1,string& t2）  

8.{  

9.    string res;  

10.    int s1 = （）;  

11.    int s2 = （）;  

12.    int m = s1+1;  

13.    int n = s2 + 1;  

14.    // init temp M*N array for length  

15.    int **commons = new int*[m];  

16.    int **direction = new int*[m];  

17.    for （int i = 0; i < m; i++） {  

18.        commons[i] = new int[n];  

19.        direction[i] = new int[n];  

20.    }  

21.    //int commons[10][10];  

22.    //int direction[10][10];  

23.    for （int i = 0; i < m; i++） {  

24.        commons[i][0] = 0;  

25.        direction[i][0] = 0;  

26.    }  

27.    for （int i = 0; i < n; i++） {  

28.        commons[0][i] = 0;  

29.        direction[0][i] = 0;  

30.    }  

31.      

32.    /* 

33.    for （int i =0; i

34.        for （int j = 0; j

35.            commons[i][j]=0; 

36.            direction[i][j] = 0; 

37.        } 

38.    }*/  

39.      

40.    // find LCS  

41.    for （int i=1; i

42.        for （int j=1; j

43.            if （t1[i-1] == t2[j-1]）  

44.            {  

45.                commons[i][j] = commons[i-1][j-1] + 1;  

46.                direction[i][j] = leftup;  

47.            }  

48.            else if （commons[i-1][j] >= commons[i][j-1]）   

49.            {  

50.                commons[i][j] = commons[i-1][j];  

51.                direction[i][j] = up;  

52.            }  

53.            else  

54.            {  

55.                commons[i][j] = commons[i][j-1];  

56.                direction[i][j] = leftd;  

57.            }  

58.        }  

59.    }  

60.    // output temp array  

61.    for （int i = 0; i

62.        for （int j = 0; j

63.            cout << commons[i][j] << ",";  

64.        }  

65.        cout << endl;  

66.    }  

67.      

68.    int max = commons[s1][s2];  

69.    int i,j;  

70.    /* 

71.    // return all LCS, maybe duplicated 

72.    for （int l = s1-1; l > 0; l--） 

73.    {    

74.        res =""; 

75.        if （commons[l][s2] >= max） 

76.        { 

77.            i = l, j = s2; 

78.            while （commons[i][j]） { 

79.                switch （direction[i][j]）  

80.                { 

81.                    case leftup:

82.                        res = t1[i-1] + res; 

83.                        i--; 

84.                        j--; 

85.                        break; 

86.                    case leftd:

87.                        j--; 

88.                        break; 

89.                    case up:

90.                        i--; 

91.                        break; 

92.