2014美团网笔试题目（总结）

http://blog.csdn.net/wzy_1988/article/details/12438143

前言

总结一下美团网笔试题目，明天可能去参加美团笔试

题目

1、一堆硬币，一个机器人，如果是反的就翻正，如果是正的就抛掷一次，无穷多次后，求正反的比例

解答：是不是题目不完整啊，我算的是3：1

2、一个汽车公司的产品，甲厂占40%，乙厂占60%，甲的次品率是1%，乙的次品率是2%，现在抽出一件汽车时次品，问是甲生产的可能性

解答：典型的贝叶斯公式，p(甲|废品) = p(甲 && 废品) / p(废品) = （0.4 × 0.01） /（0.4 × 0.01 + 0.6 × 0.02） = 0.25

3、k链表翻转。给出一个链表和一个数k，比如链表1→2→3→4→5→6，k=2，则翻转后2→1→4→3→6→5，若k=3,翻转后3→2→1→6→5→4，若k=4，翻转后4→3→2→1→5→6，用程序实现

解答：非递归可运行代码

[cpp]  view plain copy print ?

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <string.h>  
4.   
5. typedef struct node {  
6.     struct node *next;  
7.     int data;  
8. } node;  
9.   
10. void createList(node **head, int data)  
11. {  
12.     node *pre, *cur, *new;  
13.   
14.     pre = NULL;  
15.     cur = *head;  
16.   
17.     while (cur != NULL) {  
18.         pre = cur;  
19.         cur = cur->next;  
20.     }  
21.   
22.     new = (node *)malloc(sizeof(node));  
23.     new->data = data;  
24.     new->next = cur;  
25.   
26.     if (pre == NULL)      
27.         *head = new;  
28.     else  
29.         pre->next = new;       
30. }  
31.   
32. void printLink(node *head)  
33. {  
34.     while (head->next != NULL) {  
35.         printf("%d ", head->data);  
36.         head = head->next;  
37.     }  
38.     printf("%d\n", head->data);  
39. }  
40.   
41. int linkLen(node *head)  
42. {  
43.     int len = 0;  
44.       
45.     while (head != NULL) {  
46.         len ++;  
47.         head = head->next;  
48.     }  
49.   
50.     return len;  
51. }  
52.   
53. node* reverseK(node *head, int k)  
54. {  
55.     int i, len, time, now;  
56.       
57.     len = linkLen(head);  
58.   
59.     if (len < k) {  
60.         return head;  
61.     } else {  
62.         time = len / k;  
63.     }  
64.   
65.     node *newhead, *prev, *next, *old, *tail;  
66.   
67.     for (now = 0, tail = NULL; now < time; now ++) {  
68.         old = head;  
69.   
70.         for (i = 0, prev = NULL; i < k; i ++) {  
71.             next = head->next;  
72.             head->next = prev;  
73.             prev = head;  
74.             head = next;  
75.         }  
76.   
77.         if (now == 0) {  
78.             newhead = prev;  
79.         }  
80.           
81.         old->next = head;  
82.   
83.         if (tail != NULL) {  
84.             tail->next = prev;  
85.         }  
86.   
87.         tail = old;  
88.     }  
89.   
90.     if (head != NULL) {  
91.         tail->next = head;  
92.     }  
93.   
94.     return newhead;  
95. }  
96.   
97.   
98. int main(void)  
99. {  
100.     int i, n, k, data;  
101.     node *head, *newhead;  
102.   
103.     while (scanf("%d %d", &n, &k) != EOF) {   
104.         for (i = 0, head = NULL; i < n; i ++) {  
105.             scanf("%d", &data);  
106.             createList(&head, data);  
107.         }  
108.   
109.         printLink(head);  
110.   
111.         newhead = reverseK(head, k);      
112.   
113.         printLink(newhead);  
114.     }  
115.   
116.     return 0;  
117. }  

5、利用两个stack模拟queue

解答：剑指offer上的原题，九度oj有专门的练习，这里贴一下我的ac代码

[cpp]  view plain copy print ?

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <string.h>  
4.    
5. typedef struct stack {  
6.     int top;  
7.     int seq[100000];  
8. } stack;  
9.    
10. /** 
11.  * 入队操作 
12.  * 
13.  * T = O(1) 
14.  * 
15.  */  
16. void pushQueue(stack *s1, int data)  
17. {  
18.     s1->seq[s1->top ++] = data;  
19. }  
20.    
21. /** 
22.  * 出队操作 
23.  * 
24.  * T = O(n) 
25.  * 
26.  */  
27. void popQueue(stack *s1, stack *s2)  
28. {  
29.     if (s2->top > 0) {  
30.         printf("%d\n", s2->seq[-- s2->top]);  
31.     } else {  
32.         while (s1->top > 0) {  
33.             s2->seq[s2->top ++] = s1->seq[-- s1->top];  
34.         }  
35.    
36.         if (s2->top > 0)   
37.             printf("%d\n", s2->seq[-- s2->top]);  
38.         else  
39.             printf("-1\n");  
40.     }  
41.    
42. }  
43.    
44.    
45. int main(void)  
46. {  
47.     int data, n;  
48.     stack *s1, *s2;  
49.     char str[5];  
50.    
51.     while (scanf("%d", &n) != EOF) {  
52.         // 初始化    
53.         s1 = (stack *)malloc(sizeof(stack));  
54.         s2 = (stack *)malloc(sizeof(stack));  
55.         s1->top = s2->top = 0;  
56.    
57.         while (n --) {  
58.             scanf("%s", str);  
59.    
60.             if (strcmp(str, "PUSH") == 0) { // 入队列  
61.                 scanf("%d", &data);  
62.                 pushQueue(s1, data);  
63.             } else {    // 出队列  
64.                 popQueue(s1, s2);  
65.             }  
66.         }  
67.    
68.         free(s1);  
69.         free(s2);  
70.     }  
71.    
72.     return 0;  
73. }  

6、一个m*n的矩阵，从左到右从上到下都是递增的，给一个数elem，求是否在矩阵中，给出思路和代码

解答：杨氏矩阵，简单题目 

[cpp]  view plain copy print ?

1. #include <stdio.h>  
2. #include <stdlib.h>  
3.   
4. /** 
5.  * 有序矩阵查找 
6.  * 
7.  * T = O(n + n) 
8.  * 
9.  */  
10. void findKey(int **matrix, int n, int m, int key)  
11. {  
12.     int row, col;  
13.   
14.     for (row = 0, col = m - 1; row < n && col >= 0;) {  
15.         if (matrix[row][col] == key) {  
16.             printf("第%d行，第%d列\n", row + 1, col + 1);  
17.             break;  
18.         } else if (matrix[row][col] > key) {  
19.             col -= 1;  
20.         } else {  
21.             row += 1;  
22.         }  
23.     }  
24.     printf("不存在!\n");  
25. }  
26.   
27. int main(void)  
28. {  
29.     int i, j, key, n, m, **matrix;  
30.   
31.     // 构造矩阵  
32.     scanf("%d %d", &n, &m);  
33.     matrix = (int **)malloc(sizeof(int *) * n);  
34.     for (i = 0; i < n; i ++)  
35.         matrix[i] = (int *)malloc(sizeof(int) * m);  
36.   
37.     for (i = 0; i < n; i ++) {  
38.         for (j = 0; j < m; j ++)  
39.             scanf("%d", &matrix[i][j]);  
40.     }  
41.   
42.     // 查询数据  
43.     while (scanf("%d", &key) != EOF) {  
44.         findKey(matrix, n, m, key);       
45.     }  
46.   
47.     return 0;  
48. }  

7、编写函数，获取两段字符串的最长公共子串的长度，例如：
S1 = GCCCTAGCCAGDE
S2 = GCGCCAGTGDE
这两个序列的最长公共字串为GCCAG，也就是说返回值为5

解答：简单的动态规划题目，设dp[i][j]表示以s1[i]和s2[j]结尾的最长公共子串的长度，则状态转移方程为：

代码如下：

[cpp]  view plain copy print ?

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <string.h>  
4.   
5. #define N 100  
6.   
7. int dp[N][N];  
8.   
9. void lcsLen(char *s1, char *s2, int len1, int len2)  
10. {  
11.     int i, j, max, index;  
12.   
13.     memset(dp, 0, sizeof(dp));  
14.   
15.     max = index = 0;  
16.   
17.     for (i = 1; i <= len1; i ++) {  
18.         for (j = 1; j <= len2; j ++) {  
19.             if (s1[i] == s2[j]) {  
20.                 dp[i][j] = dp[i - 1][j - 1] + 1;  
21.   
22.                 if (dp[i][j] > max) {  
23.                     max = dp[i][j];  
24.                     index = i - max + 1;  
25.                 }  
26.             } else {  
27.                 dp[i][j] = 0;  
28.             }  
29.         }  
30.     }  
31.   
32.     printf("最大长度为%d\n", max);  
33.   
34.     for (i = 0; i < max; i ++) {  
35.         printf("%c ", s1[i + index]);  
36.     }  
37.     printf("\n");  
38. }  
39.   
40.   
41. int main(void)  
42. {  
43.     char s1[N], s2[N];  
44.     int i, len1, len2;  
45.   
46.     while (scanf("%d %d", &len1, &len2) != EOF) {  
47.         for (i = 1; i <= len1; i ++) {  
48.             scanf("%c", &s1[i]);  
49.         }  
50.         for (i = 1; i <= len2; i ++) {  
51.             scanf("%c", &s2[i]);  
52.         }  
53.   
54.         lcsLen(s1, s2, len1, len2);  
55.   
56.     }  
57.   
58.     return 0;  
59. }  

8、有一个函数“int f(int n)”，请编写一段程序测试函数f(n)是否总是返回0，并添加必要的注释和说明

解答：博主对测试一向没有太大的兴趣，这道题让我考虑就是int从-2147483648-2147483647去遍历f的返回值，flag为标志位，不写代码了，太简单