华为机试

考试内容：数组、链表、指针、字符串、循环、枚举、排序等（从考过的同学那儿总结的可能不全）

试题结构：考试总共三道题，说是难中易，初级题（60分）、中级题（100分）、高级题（160分），最难的接近一百行，说多不多，但自己敲出来还是费了点劲，

考试时间：两个小时。平时练得少可能稍微捉鸡点。

最简单的一个

描述：10个学生考完期末考试评卷完成后，A老师需要划出及格线，要求如下：
(1) 及格线是10的倍数；
(2) 保证至少有60%的学生及格；
(3) 如果所有的学生都高于60分，则及格线为60分

输入：输入10个整数，取值0~100

输出：输出及格线，10的倍数

输入样例：61 51 49 3020 10 70 80 90 99

输出样例：50

自己编写代码简单如下：

1.  #include <stdio.h>   

2.   

3.   

4.  void bubbleSort(int arr[])   

5.  {      

6.      int i = 0;   

7.      int j = 0;   

8.      int t = 0;   

9.   

10.     for(i = 0;i < 10; i++)  

11.     {           

12.         for(j = 0; j < (9 - i); j++)  

13.         {               

14.             if(arr[j + 1] < arr[j])   

15.             {                 

16.                 t = arr[j + 1];  

17.                 arr[j + 1] = arr[j];   

18.                 arr[j] = t;  

19.             }  

20.         }  

21.     }  

22. }   

23.   

24. int getPassLine(int a[])   

25. {   

26.     int i = 0;   

27.        

28.     bubbleSort(a);  

29.      

30.     if (a[0] >= 60)   

31.     {  

32.         return 60;   

33.     }  

34.     else  

35.     {  

36.         return ((a[4] / 10) * 10);  

37.     }  

38.   

39. }   

40.   

41.   

42.   

43. int main()   

44. {   

45.     int a[10] = {0};   

46.   

47.     scanf("%d %d %d %d %d %d %d %d %d %d", &a[0],  &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7], &a[8], &a[9]);  

48.      

49.     printf("%d", getPassLine(a));   

50.      

51.   return 0;   

52. }  

描述：一条长廊里依次装有n(1 ≤ n ≤ 65535)盏电灯，从头到尾编号1、2、3、…n-1、n。每盏电灯由一个拉线开关控制。开始，电灯全部关着。

有n个学生从长廊穿过。第一个学生把号码凡是1的倍数的电灯的开关拉一下；接着第二个学生把号码凡是2的倍数的电灯的开关拉一下；接着第三个学生把号码凡是3的倍数的电灯的开关拉一下；如此继续下去，最后第n个学生把号码凡是n的倍数的电灯的开关拉一下。n个学生按此规定走完后，长廊里电灯有几盏亮着。注：电灯数和学生数一致。

输入：电灯的数量

输出：亮着的电灯数量

样例输入：3

样例输出：1

答案参考：

1.  #include <stdio.h>   

2.   

3.  #define  MAX_BULB_NUM 65535   

4.  /*  

5.  功能: n个学生按规定走完后，长廊里电灯有几盏亮着。  

6.  原型：  

7.      int GetLightLampNum(int n);  

8.   

9.  输入参数：  

10.     int n: 电灯/学生的数量。  

11.  

12. 返回值：  

13.     int: 亮着的电灯数量。  

14.  

15. */  

16.   

17. int GetLightLampNum(int n)   

18. {   

19.     char Bulb_Flag[MAX_BULB_NUM] = {0};    //0代表灯灭，1代表灯亮   

20.     unsigned int i;   

21.     unsigned int j = 1;   

22.     unsigned int Count = 0;   

23.      

24.     if ((n < 1)||(n > 65535))  

25.     {  

26.         return false;   

27.     }  

28.   

29.     while ( j <= n)   

30.     {   

31.         for (int i = 1; i <= n; i++)  

32.         {  

33.             if (0 == (i%j))   

34.             {  

35.                 Bulb_Flag[i-1] += 1;  

36.                 Bulb_Flag[i-1] = Bulb_Flag[i-1]%2 ;   //if操作用来反转满足条件的灯泡状态   

37.             }  

38.         }  

39.         j++;  

40.     }  

41.   

42.     for (i = 0; i < MAX_BULB_NUM; i++)  

43.     {  

44.         if (1 == Bulb_Flag)   

45.         {  

46.             Count++;  

47.         }  

48.     }  

49.   

50.     return Count;   

51. }   

52.   

53. int main(void)   

54. {   

55.     int input;   

56.     scanf("%d",&input);   

57.     printf("%d",GetLightLampNum(input));   

58. }  

高级题样题：地铁换乘

描述：已知2条地铁线路，其中A为环线，B为东西向线路，线路都是双向的。经过的站点名分别如下，两条线交叉的换乘点用T1、T2表示。编写程序，任意输入两个站点名称，输出乘坐地铁最少需要经过的车站数量（含输入的起点和终点，换乘站点只计算一次）。
地铁线A（环线）经过车站：A1 A2 A3 A4 A5 A6 A7 A8 A9 T1 A10 A11 A12 A13 T2 A14 A15 A16 A17 A18
地铁线B（直线）经过车站：B1 B2 B3 B4 B5 T1 B6 B7 B8 B9 B10 T2 B11 B12 B13 B14 B15

输入：输入两个不同的站名

输出：输出最少经过的站数,含输入的起点和终点，换乘站点只计算一次

输入样例：A1 A3

输出样例：3

答案参考：

1.  import java.util.*;   

2.   

3.   

4.  public class Main {   

5.        

6.      private static int INVALID_POSITION = 255;   

7.        

8.      class BusLine {   

9.          String busstop[];  

10.         String lineName;  

11.           

12.         public BusLine(String line) {  

13.             String[] stops = line.split(" ");   

14.             this.busstop = new String[stops.length];   

15.             for (int i = 0; i < stops.length; i++) {  

16.                 this.busstop = stops;   

17.                 lineName = stops[0].substring(0, 1);   

18.             }                 

19.         }  

20.           

21.         /* get the stop position from the line */  

22.         int getStopPosition (String point) {  

23.             for (int i = 0; i < busstop.length; i++) {  

24.                 if (busstop.equals(point)) {   

25.                     return i;   

26.                 }  

27.             }  

28.             return INVALID_POSITION;         

29.         }  

30.           

31.         int getDistance(String pointA, String pointB) {  

32.             int positionA = 0;   

33.             int positionB = 0;   

34.             int len = 0;   

35.               

36.             positionA = getStopPosition(pointA);  

37.             positionB = getStopPosition(pointB);  

38.               

39.             if (positionA != INVALID_POSITION && positionB != INVALID_POSITION) {  

40.                 len = Math.abs(positionA - positionB) + 1;   

41.                 if (lineName.equals("A") && len > (busstop.length - len + 2)) {   

42.                     len =  (busstop.length - len + 2);   

43.                 }  

44.                  

45.                 return len;   

46.             }  

47.   

48.             return INVALID_POSITION;   

49.         }  

50.           

51.     }  

52.      

53.      

54.     public int getRide(String pointA, String pointB) {  

55.         int i = 0;   

56.         int min = 255;   

57.         BusLine lineA = new BusLine("A1 A2 A3 A4 A5 A6 A7 A8 A9 T1 A10 A11 A12 A13 T2 A14 A15 A16 A17 A18");   

58.         BusLine lineB = new BusLine("B1 B2 B3 B4 B5 T1 B6 B7 B8 B9 B10 T2 B11 B12 B13 B14 B15");   

59.   

60.         int[] way = {255, 255, 255, 255, 255, 255, 255, 255};   

61.           

62.         way[0] =  lineA.getDistance(pointA, pointB);  

63.         way[1] =  lineB.getDistance(pointA, pointB);  

64.           

65.         way[2] =  lineA.getDistance(pointA, "T1") + lineB.getDistance(pointB, "T1") - 1;   

66.         way[3] =  lineB.getDistance(pointA, "T1") + lineA.getDistance(pointB, "T1") - 1;   

67.           

68.         way[4] =  lineA.getDistance(pointA, "T2") + lineB.getDistance(pointB, "T2") - 1;   

69.         way[5] =  lineB.getDistance(pointA, "T2") + lineA.getDistance(pointB, "T2") - 1;   

70.           

71.         way[6] =  lineB.getDistance(pointA, "T1") + lineB.getDistance(pointB, "T2") + lineA.getDistance("T1", "T2") - 2;   

72.         way[7] =  lineB.getDistance(pointA, "T2") + lineB.getDistance(pointB, "T1") + lineA.getDistance("T1", "T2") - 2;   

73.                  

74.         for (i = 0; i < 7; i++) {   

75.             if (min > way) {   

76.                 min = way;  

77.             }  

78.         }  

79.           

80.         return min;      

81.     }  

82.      

83.     public static void main(String[] args) {  

84.         Main m = new Main();   

85.         Scanner cin = new Scanner(System.in);   

86.         String inputStr = cin.nextLine();  

87.         String stops[] = inputStr.split(" ");   

88.           

89.         System.out.println(m.getRide(stops[0], stops[1]));   

90.     }  

91.   

92. }