PTA补题(一)

PTA补题(一)

1.以下定义了一个一维数组str,该数组可以存放81个字符型数据。 T,’\0’也算一个字符

1
char str[81];

2.数组定义后,数组名表示该数组所分配连续内存空间中第一个单元的地址,即首地址。 T

3.数组定义后,只能引用单个的数组元素,而不能一次引用整个数组。 T

数组名只代表首个元素,更多时候是通过遍历来实现对数组的引用。

4.在以下描述中,( ABE )是正确的。

A.

1
int a[5] = {1, 2, 3, 4, 5};

定义了数组a,并对数组元素赋初值。此时,a[0]为1,a[1]为2,a[2]为3,a[3]为4,a[4]为5。

B.

1
static int b[10];

定义了静态数组b,且10个数组元素的初值都为0。

C.

1
int fib[45];

定义了数组fib,且45个数组元素的值都为0。****自动变量可能为任何数字

D.

1
static int week[7] = {1, 2, 3};

定义了静态数组week,并对数组 week 的前3个元素week[0]~week[2]赋初值,week[3]~week[6]值都是不确定的。****静态变量未初始化时固定为0

E.

1
int cnt[10] = {1};

定义了数组cnt,并对cnt[0]赋初值1,其余元素的初值为0。

5."a"'a'是等价的。 F,前者代表字符串,后者代表字符

6.调用strcmp函数比较字符串大小时,通常较长的字符串会较大。 F

调用strcmp函数比较字符串大小时,是按照字典序而不是字符串长度来判断的。

7.如果函数定义出现在函数调用之前,可以不必加函数原型声明。 F

需要的

9.C语言中函数不能嵌套定义 T

10.静态变量的作用域是整个文件。 F

如果在函数中出现,只在函数中有效

11.当变量的存储类型定义缺省时,系统默认为变量的存储类型为auto类型,分配在静态区。

分配在栈区

12.全局变量只能定义在程序的最前面,即第一个函数的前面。 F,任何位置a

13.静态局部变量如果没有赋值,其存储单元中将是随机值。 F,为0

14.约瑟夫环

用数组的方法的缺点是必须知道测试点在什么范围,用动态分配内存就可以解决这个问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <stdio.h>

int josephus(int n, int m) {
   int monkeys[300];  // 定义足够大的数组来存放猴子状态,假设最多300只猴子,可根据实际情况调整大小
   for (int i = 0; i < n; i++) {
       monkeys[i] = i + 1;  // 初始化猴子编号,从1开始
  }
   int count = n;  // 剩余猴子数量
   int index = 0;  // 当前报数位置索引
   int num = 0;  // 当前报数数字

   while (count > 1) {
       if (monkeys[index] > 0) {
           num++;
           if (num == m) {
               monkeys[index] = -1;  // 将报到m的猴子标记为已淘汰(这里用 -1 标记)
               num = 0;
               count--;
          }
      }
       index++;                     //轮到下一个猴子报数。
       if (index == n) {            //索引越界时重置为0
           index = 0;
      }
  }

   for (int i = 0; i < n; i++) {
       if (monkeys[i] > 0) {
           return monkeys[i];  // 返回剩下猴子的编号,也就是猴王编号
      }
  }
   return -1;  // 正常情况不会执行到这里,只是为了语法完整性
}

int main() {
   int n, m;
   while (scanf("%d %d", &n, &m)!= EOF && (n!= 0 || m!= 0)) {
       int result = josephus(n, m);
       printf("%d\n", result);
  }
   return 0;
}

15.矩阵相乘

相乘时的元素遍历需要注意。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <stdio.h>

#define MAX_SIZE 100

// 计算矩阵乘法的函数
void matrixMultiply(int matrixA[][MAX_SIZE], int ra, int ca, int matrixB[][MAX_SIZE], int rb, int cb) {
   if (ca!= rb) {
       printf("Error: %d!= %d\n", ca, rb);
       return;
  }
   int result[MAX_SIZE][MAX_SIZE];
   for (int i = 0; i < ra; i++) {            //左矩阵的行数遍历
       for (int j = 0; j < cb; j++) {        //右矩阵列数遍历
           result[i][j] = 0;                
           for (int k = 0; k < ca; k++) {    //双矩阵元素乘法的元素遍历
               result[i][j] += matrixA[i][k] * matrixB[k][j];
          }
      }
  }
   // 输出结果矩阵
   printf("%d %d\n", ra, cb);
   for (int i = 0; i < ra; i++) {
       for (int j = 0; j < cb; j++) {
           printf("%d", result[i][j]);
           if (j < cb - 1) {
               printf(" ");
          }
      }
       printf("\n");
  }
}

int main() {
   int ra, ca;
   scanf("%d %d", &ra, &ca);
   int matrixA[MAX_SIZE][MAX_SIZE];
   for (int i = 0; i < ra; i++) {
       for (int j = 0; j < ca; j++) {
           scanf("%d", &matrixA[i][j]);
      }
  }

   int rb, cb;
   scanf("%d %d", &rb, &cb);
   int matrixB[MAX_SIZE][MAX_SIZE];
   for (int i = 0; i < rb; i++) {
       for (int j = 0; j < cb; j++) {
           scanf("%d", &matrixB[i][j]);
      }
  }
   matrixMultiply(matrixA, ra, ca, matrixB, rb, cb);
   return 0;
}

16.卷积

就是成倍数输出数组,我当时想太多了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>

#define MAX_SIZE 10

int main() {
   int n, k;
   scanf("%d %d", &n, &k);
   int image[MAX_SIZE][MAX_SIZE];  // 存储原始图像像素信息的二维数组

   // 读取原始图像像素信息
   for (int i = 0; i < n; i++) {
       for (int j = 0; j < n; j++) {
           scanf("%d", &image[i][j]);
      }
  }

   // 按照倍数放大图像并输出
   for (int row = 0; row < n * k; row++) {
       for (int col = 0; col < n * k; col++) {
           int originRow = row / k;
           int originCol = col / k;
           printf("%d ", image[originRow][originCol]);
      }
       printf("\n");
  }

   return 0;
}