pat乙级难度少量习题总结

Ranbo_

最近在练习pat乙级模拟题，感觉复试机试难度也就和pat乙级难度差不多了，难度挺低的，我这种初学者都能无压力ac。

一、有花生植株整齐地排列成矩形网格。有经验的多多一眼就能看出，每棵花生植株下的花生有多少。为了训练多多的算术，鲁宾逊先生说:“你先找出花生最多的植株，去采摘它的花生;然后再找出剩下的植株里花生最多的，去采摘它的花生;依此类推，不过你一定要在我限定的时间内回到路边。”
我们假定多多在每个单位时间内,可以做下列四件事情中的一件：
1. 从路边跳到最靠近路边（即第一行）的某棵花生植株；
2. 从一棵植株跳到前后左右与之相邻的另一棵植株；
3. 采摘一棵植株下的花生；
4. 从最靠近路边（即第一行）的某棵花生植株跳回路边。
现在给定一块花生田的大小和花生的分布，请问在限定时间内，多多最多可以采到多少个花生？
注意可能只有部分植株下面长有花生，假设这些植株下的花生个数各不相同。例如花生田里只有位于(2, 5), (3, 7), (4, 2), (5, 4)的植株下长有花生，个数分别为 13, 7, 15, 9。多多在 21 个单位时间内，只能经过(4, 2)、(2, 5)、(5, 4)，最多可以采到 37 个花生。

输入：

1. 包含多组数据，每组数据第一行包括三个整数 M（1≤M≤20）、N（1≤N≤20）和 K（0≤K≤1000），用空格隔开；表示花生田的大小为 M * N，多多采花生的限定时间为 K个单位时间。
   
2. 
   
3. 紧接着 M 行，每行包括 N 个自然数 P（0≤P≤500），用空格隔开；表示花生田里植株下花生的数目，并且除了0（没有花生），其他所有植株下花生的数目都不相同。

复制代码

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef struct hs
   
5. {
   
6.     int num;//花生数量
   
7.     int hs_x;
   
8.     int hs_y;//所在位置
   
9. }HS;
   
10. 
    
11. int cmp(const void* a, const void* b)
    
12. {
    
13.     HS *h1 = (HS*) a;
    
14.     HS *h2 = (HS*) b;
    
15.     return (h2 -> num - h1 -> num);
    
16. }//从大到小排列
    
17. 
    
18. HS hs[400];
    
19. 
    
20. int main()
    
21. {
    
22.     int m, n, t;
    
23.     while(~scanf("%d %d %d", &m, &n, &t))
    
24.     {
    
25.         //int field[20][20] = {0};//田里花生的矩阵
    
26.         int i, j;
    
27.         int ammount = m*n;//田地面积
    
28.         int count = 0;
    
29.         for(i = 0; i < m; i++)
    
30.             for(j = 0; j < n; j++)
    
31.             {
    
32.                 hs[count].hs_x = i;
    
33.                 hs[count].hs_y = j;
    
34.                 scanf("%d", &(hs[count].num));
    
35.                 count++;
    
36.             }
    
37.         if(ammount < 400)    hs[ammount].num = 0;//最后一个元素置为0
    
38.         qsort(hs, ammount, sizeof(hs[0]), cmp);
    
39.         int x, y;
    
40.         x = -1;            y = hs[0].hs_y;
    
41.         int sum = 0;
    
42.         i = 0;
    
43.         while(x+1 < t && hs[i].num)//x,y>=t时必须返回，若有花生的地方全部采摘完毕也必须返回
    
44.         {
    
45.             if(hs[i].hs_x == x && hs[i].hs_y == y)
    
46.             {
    
47.                 sum += hs[i].num;
    
48.                 i++;
    
49.                 t--;
    
50.                 continue;
    
51.             }
    
52.             
    
53.             if(hs[i].hs_x > x)//目标花生在多多右边
    
54.             {
    
55.                 x++;
    
56.                 t--;
    
57.                 continue;
    
58.             }
    
59.             else if(hs[i].hs_x < x)//目标花生在多多左边
    
60.             {
    
61.                 x--;
    
62.                 t--;
    
63.                 continue;
    
64.             }
    
65.             
    
66.             if(hs[i].hs_y > y)//目标花生在多多上边
    
67.             {
    
68.                 y++;
    
69.                 t--;
    
70.                 continue;
    
71.             }
    
72.             else if(hs[i].hs_y < y)//目标花生在多多下边
    
73.             {
    
74.                 y--;
    
75.                 t--;
    
76.                 continue;
    
77.             }
    
78.         }
    
79.         printf("%d\n", sum);
    
80.     }
    
81. }
    

复制代码

二、对于斐波那契数列Fibonacci(m)，输入一个数n，若Fibonacci(n)少于六位数，则直接输出，否则只输出最后六位数。
//对于多于七位数的数，要注意尾数为0开头的数。

输入：

1. 输入有多组数据。
   
2. 
   
3. 每组数据一行，包含一个整数n (1≤n≤100000)。

复制代码

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. int fib[100000] = {1, 2, 3, 5};//动态补充fib数列的内容
   
5. 
   
6. int main()
   
7. {
   
8.     int n;
   
9.     int temp = 0;
   
10.     int start = 4;//初始时从fib[4]开始没有数据
    
11.     int target = -1;
    
12.     while(~scanf("%d", &n))
    
13.     {
    
14.         int i = 4;
    
15.         while((!temp) && fib[i])
    
16.         {
    
17.             if(target > 0)
    
18.                 break;
    
19.             if((fib[i-1] + fib[i-2]) != fib[i])//产生了进位
    
20.             {
    
21.                 target = i;
    
22.                 temp = 1;
    
23.                 break;
    
24.             }
    
25.             i++;
    
26.         }//找到第一个大于1000000的fibonacci数（第i个）
    
27.         if(n > start)
    
28.         {
    
29.             for(i = start; i < n; i++)
    
30.             {
    
31.                 fib[i] = fib[i-1] + fib[i-2];
    
32.                 if(fib[i] >= 1000000)
    
33.                 {
    
34.                     fib[i] = fib[i] % 1000000;//取最后六位
    
35.                 }
    
36.             }
    
37.             start = n;
    
38.         }
    
39.         if(target > 0 && n > target)
    
40.         {
    
41.             if(fib[n-1] < 10)         //只剩一位
    
42.             {printf("00000");}
    
43.             else if(fib[n-1] < 100)   //两位
    
44.             {printf("0000"); }
    
45.             else if(fib[n-1] < 1000)  //三位
    
46.             {printf("000");  }
    
47.             else if(fib[n-1] < 10000) //四位
    
48.             {printf("00");   }
    
49.             else if(fib[n-1] < 100000)//五位
    
50.             {printf("0");    }
    
51.             }
    
52.         printf("%d\n", fib[n-1]);
    
53.     }
    
54. }
    

复制代码

三、有一头母牛，它每年年初生一头小母牛。每头小母牛从第四个年头开始，每年年初也生一头小母牛。请编程实现在第n年的时候，共有多少头母牛？

输入：

1. 由多个测试实例组成，每个测试实例占一行，包括一个整数n(0<n<55)，n的含义如题目中描述。

复制代码

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. int main()
   
5. {
   
6.     //c0记录可以产子的牛，c1,c2记录养了1，2天的牛
   
7.     long long int c0[55] = {1, 1, 1, 2, 3}, c1[55] = {0, 1, 1, 1, 2}, c2[55] = {0, 0, 1, 1, 1};
   
8.     long long int sum[55] = {1, 2, 3, 4, 6};
   
9.     int n;
   
10.     int start = 5;
    
11.     while(~scanf("%d", &n))
    
12.     {
    
13.         if(n > start)
    
14.         {
    
15.             for(int i = start; i < n; i++)
    
16.             {
    
17.                 c0[i] = c2[i-1] + c0[i-1];
    
18.                 c2[i] = c1[i-1];
    
19.                 c1[i] = c0[i-1];
    
20.                 sum[i] = c0[i] + c1[i] + c2[i];
    
21.             }
    
22.             start = n;
    
23.         }
    
24.         printf("%ld\n", sum[n-1]);
    
25.     }
    
26. }
    

复制代码

四、对于表达式n^2+n+41，当n在（x,y）范围内取整数值时（包括x,y）(-39<=x<50),判定该表达式的值是否为素数

输入：

1. 输入数据有多组，每组占一行，由两个整数x，y组成，当x=0,y=0时，表示输入结束，该行不做处理。

复制代码

输出：

1. 对于每个给定范围内的取值，如果表达式的值都为素数，则输出"OK",否则请输出“Sorry”,每组输出占一行。
   

复制代码

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <math.h>
   
4. 
   
5. int is_prime(int n)
   
6. {
   
7.     if(n == 2)
   
8.         return 1;
   
9.     int m = sqrt(n);
   
10.     for(int i = 2; i <= m; i++)
    
11.     {
    
12.         if(n % i == 0)
    
13.             return 0;
    
14.     }
    
15.     return 1;
    
16. }
    
17. 
    
18. int main()
    
19. {
    
20.     int x, y;
    
21.     int temp;
    
22.     while(1)
    
23.     {
    
24.         scanf("%d %d", &x, &y);
    
25.         if(x == 0 && y == 0)
    
26.             break;
    
27.         int target;
    
28.         temp = 1;
    
29.         for(int i = x; i <= y; i++)
    
30.         {
    
31.             target = i*i + i + 41;
    
32.             if(is_prime(target))
    
33.                 continue;
    
34.             else
    
35.             {
    
36.                 temp = 0;
    
37.                 break;
    
38.             }
    
39.         }
    
40.         if(temp)
    
41.             printf("OK\n");
    
42.         else
    
43.             printf("Sorry\n");
    
44.     }
    
45. }
    

复制代码

五、计算机中采用浮点数表示所有实数，但这意味着精度丢失。请实现一套分数的计算器。分子分母在[1, 30]之间。

输入示例：

1. 1/3 2/3 +
   
2. 1/5 1/4 -
   
3. 1/2 1/3 *
   
4. 2/3 4/3 /

复制代码

输出：

1. 1/1
   
2. -1/20
   
3. 1/6
   
4. 1/2

复制代码

无非就是化简分式的问题。可以用辗转相除法，但是因为要求范围较小，我用的是直接找分子分母是否有公约数。

1. //30以内的质数只有2，3，5，7，11，13，17，19，23，29
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. 
   
5. int prime[10] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
   
6. 
   
7. int is_relative(int a, int b)
   
8. {
   
9.     for(int i = 0; i < 10; i++)
   
10.     {
    
11.         if(a % prime[i] == 0 && b % prime[i] == 0)
    
12.                 return prime[i];//不互质,有因数prime[i]
    
13.     }
    
14.     return 1;//互质
    
15. }
    
16. 
    
17. int main()
    
18. {
    
19.     int a1, b1, a2, b2;
    
20.     char sign;
    
21.     int temp1, temp2;
    
22.     while(~scanf("%d/%d %d/%d %c", &a1, &b1, &a2, &b2, &sign))
    
23.     {
    
24.         int x;
    
25.         if(sign == '+')
    
26.         {
    
27.             temp2 = b1 * b2;
    
28.             temp1 = a1*b2 + a2*b1;
    
29.         }
    
30.         else if(sign == '-')
    
31.         {
    
32.             temp2 = b1 * b2;
    
33.             temp1 = a1*b2 - a2*b1;
    
34.         }
    
35.         else if(sign == '*')
    
36.         {
    
37.             temp2 = b1 * b2;
    
38.             temp1 = a1 * a2;
    
39.         }
    
40.         else
    
41.         {
    
42.             temp2 = a2 * b1;
    
43.             temp1 = a1 * b2;
    
44.         }
    
45.         if(temp1 == temp2)
    
46.             temp1 = temp2 = 1;
    
47.         while((x = is_relative(temp1, temp2)) != 1)
    
48.         {
    
49.             temp1 = temp1/x;
    
50.             temp2 = temp2/x;
    
51.         }
    
52.         
    
53.         printf("%d/%d\n", temp1, temp2);
    
54.     }
    
55. }
    

复制代码

六、因式分解。把给定的正整数a，分解成若干个素数的乘积，即 a = a1 × a2 × a3 × ... × an,并且 1 < a1 ≤ a2 ≤ a3 ≤ ... ≤ an。其中a1、a2、...、an均为素数。先给出一个整数a，请输出分解后的因子。

输入：

1. 输入包含多组数据，每组数据包含一个正整数a（2≤a≤1000000）。

复制代码

输出：

1. 对应每组数据，以“a = a1 * a2 * a3...”的形式输出因式分解后的结果。

复制代码

1. //和上一个题思路一样，这个题实现起来更方便，唯一要注意的是*不能输出多了，且最后不能有空格。
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <math.h>
   
5. #define MAX 1000000
   
6. 
   
7. int is_composite(int n);
   
8. 
   
9. int main()
   
10. {
    
11.     int n;
    
12.     while(~scanf("%d", &n))
    
13.     {
    
14.         printf("%d = ", n);
    
15.         int x = is_composite(n);
    
16.         int temp = 0;
    
17.         if(x != 0)
    
18.         {
    
19.             printf("%d", x);
    
20.             n = n/x;
    
21.             temp = 1;
    
22.         }
    
23.         else
    
24.             printf("%d", n);
    
25.         while((x = is_composite(n)))
    
26.         {
    
27.             printf(" * %d", x);
    
28.             n = n/x;
    
29.         }
    
30.         if(temp)
    
31.             printf(" * %d", n);
    
32.         printf("\n");
    
33.     }
    
34. }
    
35. 
    
36. int is_composite(int n)
    
37. {
    
38.     if(n == 2)
    
39.         return 0;
    
40.     int s = sqrt(n);
    
41.     for(int i = 2; i <= s; i++)
    
42.     {
    
43.         if(n % i == 0)
    
44.             return i;//有因数i
    
45.     }
    
46.     return 0;
    
47. }
    

复制代码

还有很多模拟题，不过大都是斐波那契数列的变形或者是其他我之前记录过的类似的题目，这里就没写了。反正时间还很久，继续学习，争取今年复试上机拿个满分~