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

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

7.约瑟夫问题
 问题描述：
 输入一个由随机数组成的数列（数列中每个数均是大于0的整数，长度已知），和初始计数值m。从数列首位置开始计数，计数到m后，将数列该位置数值替换计数值m，并将数列

该位置数值出列，然后从下一位置从新开始计数，直到数列所有数值出列为止。如果计数到达数列尾段，则返回数列首位置继续计数。请编程实现上述计数过程，同时输出数

值出列的顺序
 比如：         输入的随机数列为：3,1,2,4，初始计数值m=7，从数列首位置开始计数（数值3所在位置） 
第一轮计数出列数字为2，计数值更新m=2，出列后数列为3,1,4，从数值4所在位置从新开始计数 
第二轮计数出列数字为3，计数值更新m=3，出列后数列为1,4，从数值1所在位置开始计数
 第三轮计数出列数字为1，计数值更新m=1，出列后数列为4，从数值4所在位置开始计数
 最后一轮计数出列数字为4，计数过程完成。
 输出数值出列顺序为：2,3,1,4。

要求实现函数：
 void array_iterate(int len, int input_array[], int m, int output_array[])
【输入】  int len：输入数列的长度；
 int intput_array[]：输入的初始数列
 int m：初始计数值
 【输出】  int output_array[]：输出的数值出列顺序
 【返回】  无
示例
 输入：int input_array[] = {3,1,2,4}，int len = 4， m=7
输出：output_array[] = {2,3,1,4}

view plain

1. #include "iostream"  
2. using namespace std;  
3. struct Node  
4. {  
5.     int data;  
6.     Node *next;   
7. };  
8. void array_iterate(int len, int input_array[], int m, int output_array[])  
9. {  
10.     if (NULL==input_array||0==m||0==len)  
11.         return 0;  
12.     Node *node=new Node;  
13.     Node *head=new Node;  
14.     head->data=input_array[0];  
15.     Node *p=head;  
16.     int k=0;  
17.     for (int i=1;i<len;i++)  
18.     {  
19.         node=new Node;  
20.         node->data=input_array[i];  
21.         p->next=node;  
22.         p=node;  
23.     }  
24.     p->next=head;  
25.     p=head;  
26.     Node *q=new Node;  
27.     int count;  
28.     while (p->next!=p)  
29.     {  
30.         count=1;  
31.         while (count<m)  
32.         {  
33.             q=p;  
34.             p=p->next;  
35.             count++;  
36.         }  
37.         m=p->data;  
38.         output_array[k++]=m;  
39.         q->next=p->next;  
40.         p=q->next;  
41.     }  
42.     output_array[k]=p->data;  
43. }  
44. void main()  
45. {  
46.     int a[]={3,1,2,4};  
47.     int b[4];  
48.     memset(b,0,4*sizeof(int));  
49.     array_iterate(4, a, 7,b);  
50.     printf("%d,%d,%d,%d",b[0],b[1],b[2],b[3]);  
51. }  

8. 简单四则运算
 问题描述：
输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值
 注：   1、表达式只含 +, -, *, / 四则运算符，不含括号
       2、表达式数值只包含个位整数(0-9)，且不会出现0作为除数的情况
 3、要考虑加减乘除按通常四则运算规定的计算优先级
 4、除法用整数除法，即仅保留除法运算结果的整数部分。比如8/3=2。输入表达式保证无0作为除数情况发生
 5、输入字符串一定是符合题意合法的表达式，其中只包括数字字符和四则运算符字符，除此之外不含其它任何字符，不会出现计算溢出情况
 要求实现函数：
 int calculate(int len,char *expStr) 
 【输入】  int len: 字符串长度； 
 char *expStr: 表达式字符串； 
 【输出】  无
【返回】  计算结果
 示例
1）  输入：char *expStr = “1+4*5-8/3”
 函数返回：19 
 2）  输入：char *expStr = “8/3*3”
 函数返回：6

 

view plain

1. #include <stdio.h>     
2. #include <string.h>    
3. #include "string"   
4. #include "assert.h"   
5. struct stack{        //存放后续排列的表达式，模拟栈  
6.    char str[80];  
7.    int top;  
8. };  
9. struct sstack{       //存放计算表达式的值，模拟栈  
10.     int str[80];  
11.     int top;  
12. };  
13. int calculate(int len,char *expStr)  
14. {  
15.     char *postexp=new char[len+1];  
16.     stack opstack;  
17.     sstack calstack;  
18.     calstack.top=-1;  
19.     opstack.top=-1;  
20.     int i=0;  
21.     int k=0;  
22.     while(expStr[i]!='\0')  
23.     {  
24.         if (expStr[i]>='0'&&expStr[i]<='9')  
25.         {  
26.             postexp[k++]=expStr[i];  
27.         }  
28.         else if (expStr[i]=='+'||expStr[i]=='-')  
29.         {  
30.             while (opstack.top>=0)  
31.             {  
32.                 postexp[k++]=opstack.str[opstack.top--];  
33.             }  
34.             opstack.top++;  
35.             opstack.str[opstack.top]=expStr[i];  
36.   
37.         }  
38.         else if (expStr[i]=='*'||expStr[i]=='/')  
39.         {  
40.             while (opstack.top>=0&&(opstack.str[opstack.top]=='*'||opstack.str[opstack.top]=='/'))  
41.             {  
42.                 postexp[k++]=opstack.str[opstack.top--];  
43.             }  
44.             opstack.top++;  
45.             opstack.str[opstack.top]=expStr[i];  
46.         }  
47.   
48.         i++;          
49.     }  
50.     while (opstack.top>=0)  
51.     {  
52.         postexp[k++]=opstack.str[opstack.top--];  
53.     }  
54.     int temp1=0;  
55.     int temp2=0;  
56.     for (i=0;i<len;i++)  
57.     {  
58.         if (postexp[i]>='0'&&postexp[i]<='9')  
59.         {  
60.             calstack.top++;  
61.             calstack.str[calstack.top]=postexp[i]-'0';  
62.         }  
63.         else if (postexp[i]=='+')  
64.         {  
65.             temp1=calstack.str[calstack.top--];  
66.             temp2=calstack.str[calstack.top];  
67.             calstack.str[calstack.top]=temp2+temp1;  
68.         }  
69.         else if (postexp[i]=='-')  
70.         {  
71.             temp1=calstack.str[calstack.top--];  
72.             temp2=calstack.str[calstack.top];  
73.             calstack.str[calstack.top]=temp2-temp1;  
74.         }  
75.         else if (postexp[i]=='*')  
76.         {  
77.             temp1=calstack.str[calstack.top--];  
78.             temp2=calstack.str[calstack.top];  
79.             calstack.str[calstack.top]=temp2*temp1;  
80.         }  
81.         else if (postexp[i]=='/')  
82.         {  
83.             temp1=calstack.str[calstack.top--];  
84.             temp2=calstack.str[calstack.top];  
85.             calstack.str[calstack.top]=temp2/temp1;  
86.         }  
87.     }  
88.     printf("%d",calstack.str[calstack.top]);  
89.     return  calstack.str[calstack.top];  
90.   
91. }  
92. int main()    
93. {   
94.     char *expStr = "1+4*5-8/3";  
95.     int len=strlen(expStr);  
96.     calculate(len,expStr);  
97.   
98. }  

 9.
 一副牌中发五张扑克牌给你：让你判断数字的组成：
 有以下几种情况：
 1：四条：即四张一样数值的牌（牌均不论花色）

 2：三条带 一对
 3：三条带两张不相同数值的牌
 4：两对
 5：顺子  包括 10，J，Q，K，A
6：什么都不是
 7：只有一对

view plain

1. void sort(int data[],int n)  
2. {  
3.     int temp=0;  
4.     for(int i=0;i<n;i++ )  
5.     {  
6.         for (int j=i+1;j<n;j++)  
7.         {  
8.             if (data[i]<data[j])  
9.             {  
10.                 temp=data[i];  
11.                 data[i]=data[j];  
12.                 data[j]=temp;  
13.             }  
14.         }  
15.     }  
16. }  
17.   
18. void test(int a[],int len)  
19. {  
20.     int *b=new int[len];  
21.     int count=0;  
22.     bool temp=false;  
23.     for (int i=0;i<len;i++)  
24.     {  
25.         b[i]=a[i];  
26.     }  
27.     sort(b,5);  
28.     for (i=0;i<len-1;i++)  
29.     {  
30.         if (b[i]==b[i+1])  
31.             count++;  
32.     }  
33.     switch (count)  
34.     {  
35.     case 0:  
36.         if (b[0]-b[4]==4||(b[0]-b[3]==3&&b[4]==1))  
37.         {  
38.             printf("顺子");  
39.         }  
40.         else  
41.             printf("什么都不是");  
42.         break;  
43.     case 1:  
44.         printf("只有一对");  
45.         break;  
46.     case 2:  
47.         for (i=0;i<3;i++)  
48.         {  
49.             if (b[i]==b[i+2])  
50.             {  
51.                 printf("三条带两张不相同数值的牌");  
52.                 temp=true;  
53.                 break;  
54.             }  
55.         }  
56.         if (!temp)  
57.         {  
58.             printf("两对");  
59.         }     
60.         break;  
61.     case 3:  
62.         if (b[1]==b[3])  
63.             printf("四条：即四张一样数值的牌");  
64.         else  
65.             printf("三条带 一对");  
66.   
67.         break;  
68.   
69.     }  
70. }  
71.   
72. int main()    
73. {   
74.     int a[5]={1,10,11,12,13};  
75.     test(a,5);  
76. }