2024年华为笔试题done.doc

试题
选择题
1、如下程序的输出成果是： 2 0 \r\n 正确值2 0 \r转义符：回车， \n转义符：换行
#include <stdio.h>
int main()
{
int n = 4;
while (n--)
{
printf("%d ", --n);
}
printf("\r\n");
return 0;
}

2、设有如下宏定义：
#define N 4
#define Y(n) ((N+1)*n)
则执行语句：Y(5+1)为： 26 假如#define Y(n) ((N+1)*(n)) 则Y(5+1) 为30

3、
enum ENUM_A
{
x1,
y1,
z1 = 5,
a1,
b1
};
enum ENUM_A enumA = y1;
enum ENUM_A enumB = b1;
请问enumA和enumB的值是多少？1 7 x1=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、若已定义: int a[9], *p = a;并在以后的语句中未变化p的值，不能表示a[1]地址的体现式是： C a的值不能变化
A）p+1 B)a+1 C) a++ D) ++p

8、设有如下定义：
unsigned long plArray[] = {6,7,8,9,10};
unsigned long *pulPtr;
则下列程序段的输出成果是什么？ D
pulPtr = plArray;
*(pulPtr + 2) += 2;
printf("%d, %d\r\n", *pulPtr, *(pulPtr + 2));
A) 8, 10 B) 6, 8 C) 7, 9 D) 6, 10

9、如下程序运行后，输出成果是什么？ C
void main()
{
char *szStr = "abcde";
szStr += 2;
printf("%1u\r\n", szStr);
return;
}
A) cde B) 字符c的ASCII码值 C) 字符c的地址 D) 犯错

10、给出如下定义：
char X[] = "hello"; \0
char Y[] = {'h', 'e', 'l', 'l', 'o'};
则正确的论述为： C
A） 数组X和数组Y等价 B) 数组X和数组Y的长度相同
C) 数组X的长度不小于数组Y的长度 D) 数组X的长度小于数组Y的长度

11、在32位X86下，有下列程序
#include <stdio.h>
void main()
{
union
{
int k;
char i[2];
} *s, a;
s = &a;
s->i[0] = 0x39;
s->i[1] = 0x38;
printf("%x\r\n", a.k);
}
输出成果是：B 编译后的成果为CCCC3839,答案A
A) 3839 B) 3938 C) 380039 D) 不可预知

12、有如下函数定义：
unsigned long MyFunc(unsigned long ulKey)
{
return (((ulKey & 0x000000ffUL) << 24) |
((ulKey & 0x0000ff00UL) << 8) |
((ulKey & 0x00ff0000UL) >> 8) |
((ulKey & 0xff000000UL) >> 24));
}
则MyFunc(0x12345678)的返回值是： C
A) 0x12345678 B) 0x87654321 C) 0x78563412 D) 0x12563478

13、（(a>b)?a:b）代表什么含义：b
A) 代表a,b之中较小的那个值
B) 代表a,b之中较大的那个值
C) 代表a是否比b大
D) 语法错误

14、某系统总线的一个总线周期包括3个时钟周期，每个总线周期能够传送32位数据。若总线的时钟频率为33MHz， 则总线带宽为多少MB/s ？B
A） 11 B) 22 C) 33 D) 44
总线数据传输率=时钟频率/每个总线包括的时钟周期数*每个总线周期传送的字节数, 33MHZ/3*(32/8)=44MB/S,答案为D

15、如下定义，则s在内存中占多大空间？ A
union
{
struct
{
unsigned char aa:4;
unsigned char ab:4;
} a;
unsigned char c;
unsigned char d;
} s;
A) 1 byte B) 2byte C) 3byte D) 4byte

16、如下定义：
union tagAAAA
{
struct
{
char ucFirst;
short usSecond;
char ucThird;
}half_a;
long lI;
}number;
在按1字节对齐情况下，sizeof(union tagAAAA)的大小是： A
在按4字节对齐情况下，sizeof(union tagAAAA)的大小是： D ?? sizeof(a)为8byte,因此C
A) 4byte B) 6byte C) 8byte D) 12byte

17、0x12345678在采取BigEndian中内存的排列次序是 A ，在采取LittleEndian内存中的排列次序是 C 。（答案从左到右内存地址依次增加）
A) 12 34 56 78 B) 34 12 78 56 C) 78 56 34 12 D) 56 78 12 34
大端系统和小端系统

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) 4 B）7 C）应用 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、请指出下面程序的错误
unsigned char i = 10;
char b = 100;
char *p;
void f(void)
{
while(--i >= 0)
{
*(p++) = b;
}
}
while中，比较成果永远为真，死循环 定义p为野指针

2、下面函数要实现打印hello world的功效，请问程序中有何错误？
void* GetMemory()
{
char str[] = "hello world";
return str;
}
void Test()
{
char *str = NULL;
str = (char*) GetMemory();
printf(str);
}
GetMemory 中返回局部的地址

3、请问如下代码有什么错误？
#define MAX_SIZE 1000
#define NULL 0
#define TRUE 1
#define FALSE 0
struct XXX
{
unsigned short a;
unsigned short b;
};
int demo(struct XXX *p, unsigned long size)
{
struct XXX *temp;
temp=(struct XXX*)malloc(sizeof(struct XXX)*MAX_SIZE);
if (NULL == temp)
{
return FALSE;
}
memcpy(temp, p, sizeof(struct XXX)*size);

/*其他操作*/

free (temp);
return TRUE;
}
Demo

4、如下程序用于把“blue”字符串返回，请指出其中的错误。
char *GetBlue()
{
char* pcColor;
char* pcNewColor;

pcColor = "blue";
pcNewColor = (char*)malloc(strlen(pcColor));
strcpy(pcNewColor, pcColor);

return pcNewColor;
}
晕，编译能通过，没找到错的地方！！！

？？？5、请问如下程序段有什么错误？
main()
{
unsigned long i = 0, *p, *p1;
p = (unsigned long *)malloc(10000);
p1 = p;
for(i = 0; i < 9999; i++)
{
*p1 = 0x100;
p1++;
}

/*其他操作*/

free(p);
}
p1越界访问

编程题
1、 对称数判断问题
请编写一段程序，判断一个正整数是否为对称数（对称数即左右对称的数字，如3、22、121、1331、34543等），不允许利用C语言将数字转换为字符转的库函数。
int main()
{
unsigned int num;
int num1, num2;
int i,count;
bool x = false;
printf("Please input a number:\n");
scanf("%u",&num);
num1 = num;
num2 = num;
count=bit(num);
//num小于10
if(num<10)
printf("The number %u is symmetrical!\n",num);
//num位数为偶数
if(count%2==0)
{
for(i=1;i<=count/2;i++)
{

if(num1/power(count-i)!=num2%power(1))
{
num1 = num % power(count - i);
num2 = num / power(i);
x = false;
break;
}
else
{
num1 = num % power(count - i);
num2 = num / power(i);
x = true;
}
}
}
//num位数为奇数
else
{
for(i=1;i<=count/2;i++)
{
if(num1/power(count-i)!=num2%power(1))
{
num1 = num % power(count - i);
num2 = num / power(i);
x = false;
break;
}
else
{
num1 = num % power(count - i);
num2 = num / power(i);
x = true;
}
}
}
if (x)
{
printf("The number %u is symmetrical!\n",num);
}
else
{
printf("The number %u is not symmetrical!\n",num);
}
return 0;
}

最简单的措施，判断元素数据倒置后是否和原数相等：
void symmetrical(int a)
{
int sum = 0;
int temp1 = a;
while(temp1)
{
int temp = temp1 % 10;
sum = sum * 10 + temp;
temp1 = temp1 / 10;
}
cout<<sum<<endl;
if (a == sum)
{
cout<<"The number %u is symmetrical!"<<a<<endl;
}
else
{
cout<<"The number %u is not symmetrical!"<<a<<endl;
}
}

2、 排队队列问题
n个人，排成1队，（p1,p2,p3...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 <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define NULL 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
typedef int Elemtype;/*定义数据元素类型 */

typedef struct Cnode
{
Elemtype data;
struct Cnode *next;
}CNode;
CNode *joseph;/*定义一个全局变量 */

Status Create_clist(CNode *clist,int n)
{
CNode *p,*q;
int i;
clist=NULL;
for(i=n;i>=1;i--)
{
p=(CNode *)malloc(sizeof(CNode));
if(p==NULL)
return OVERFLOW; /*存储分派失败 */
p-> data=i;
p-> next=clist;
clist=p;
if(i==n)
q=p;/*用q指向链表最后一个结点 */
}

q-> next=clist; /*把链表的最后一个结点的链域指向链表的第一个结点，组成循环链表 */
joseph=clist; /*把创建好的循环链表头指针赋给全局变量 */
return OK;
} /*end */

Status Joseph(CNode *clist,int m,int n,int k)
{
int i;
CNode *p,*q;
if(m> n) return ERROR;/*起始位置错 */
if(!Create_clist(clist,n))
return ERROR; /*循环链表创建失败 */
p=joseph; /*p指向创建好的循环链表 */
for(i=1;i <m;i++)
p=p-> next; /*p指向位置的结点 */

while(p)
{
for(i=1;i <k-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 */
int main()
{
int m,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);
cin.get();
return 0 ;
} /*main */

4．求2个字符串的最大公共子串
Longest Common Subsequence最长公共子序列。基于动态规划算法求解，对于所有情况都有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 = t1.size();  
11.     int s2 = t2.size();  
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<m; i++) { 
34.         for (int j = 0; j<n; j++) { 
35.             commons[i][j]=0; 
36.             direction[i][j] = 0; 
37.         } 
38.     }*/  
39.       
40.     // find LCS  
41.     for (int i=1; i<m; i++) {  
42.         for (int j=1; j<n; 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<m; i++) {  
62.         for (int j = 0; j<n; 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.                     default: 
93.                         break; 
94.                 } 
95.             } 
96.             cout << endl <<res <<endl; 
97.         } 
98.      
99.     } 
100.     for (int c = s2; c > 0; c--) 
101.     {    
102.         res = ""; 
103.         if (commons[s1][c] >= max) 
104.         { 
105.             i = s1, j = c; 
106.             while (commons[i][j]) { 
107.                 switch (direction[i][j])  
108.                 { 
109.                     case leftup: 
110.                         res = t1[i-1] + res; 
111.                         i--; 
112.                         j--; 
113.                         break; 
114.                     case leftd: 
115.                         j--; 
116.                         break; 
117.                     case up: 
118.                         i--; 
119.                         break; 
120.                     default: 
121.                         break; 
122.                 } 
123.             } 
124.             cout << endl <<res <<endl; 
125.         } 
126.          
127.     } 
128.     */  
129.       
130.     // return 1 of LCS  
131.     i= s1, j=s2;  
132.     while (commons[i][j]) {  
133.         switch (direction[i][j])   
134.         {  
135.             case leftup:  
136.                 res = t1[i-1] + res;  
137.                 i--;  
138.                 j--;  
139.                 break;  
140.             case leftd:  
141.                 j--;  
142.                 break;  
143.             case up:  
144.                 i--;  
145.                 break;  
146.             default:  
147.                 break;  
148.         }  
149.     }  
150.           
151.     // delete array  
152.     for (int i = 0; i < m; i++) {  
153.         delete []commons[i];  
154.         delete []direction[i];  
155.     }  
156.     delete [] commons;  
157.     delete [] direction;  
158.       
159.     return res;  
160. }  
161. void t_lcs()  
162. {  
163.     string s1("abcbdab");  
164.     string s2("bdcaba");  
165.     string r = lcs(s1, s2);  
166.     cout<<endl<<"LCS:"<<r<<endl;  
167. } 
5．N个数的全排列
#define MAX_SIZE 101
void perm(int [],int,int);
main()
{
int i,n;
int list[MAX_SIZE];
printf("Please enter a number:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
list[i]=rand()%100;
printf("%d ",list[i]);
}
printf("\n");
perm(list,0,n-1);
getch();
}

void