2024-01-29_数组名理解等_作业

作业标题(1265)

下面代码关于数组名描述不正确的是（ ）

int main()
{
  int arr[10] = {0};
  return 0;
}

作业内容

A.数组名arr和&arr是一样的

B.sizeof(arr)，arr表示整个数组

C.&arr，arr表示整个数组

D.除了sizeof(arr)和&arr中的数组名，其他地方出现的数组名arr，都是数组首元素的地址。

答案解析(提交后可在已完成作业列表查看答案)

A选项错误明显。arr的类型是int [10]，而&arr的类型是int (*)[10]，根本不是一个类型，不可能是一样的。而在 sizeof(arr)和&arr中，arr都是看成整体的，而一般它代表一个数组的首地址。

作业标题(713)

使用指针打印数组内容

作业内容

写一个函数打印arr数组的内容，不使用数组下标，使用指针。

arr是一个整形一维数组。

#include <stdio.h>
int main() {
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr,i;
	for (i = 0; i < 10; i++) {
		printf("%d ", *p);
		p++;
	}
}

作业标题(698)

冒泡排序

作业内容

实现一个对整形数组的冒泡排序

#include <stdio.h>
int main() {
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i, h;
	for (i = 0; i < 9; i++) {
		for (h = 0; h < 9 - i; h++) {
			if (arr[h] < arr[h+ 1]) {
				int temp = arr[h];
				arr[h] = arr[h + 1];
				arr[h + 1] = temp;
			}
		}
	}
	for (i = 0; i < 10; i++) {
		printf("%d ", arr[i]);
	}
}

作业标题(719)

关于二级指针描述描述正确的是：（ ）

作业内容

A.二级指针也是指针，只不过比一级指针更大

B.二级指针也是指针，是用来保存一级指针的地址

C.二级指针是用来存放数组的地址

D.二级指针的大小是4个字节

答案解析：

A：错误，二级指针是指针，不能说起比一级指针大，只能说二级指针指向的空间中存储的也是一个地址

B：正确

C：错误，数组的地址一般用一级指针存储，或者用数组指针接收

D：二级指针是指针，但是否占4个字节不一定，要看具体的系统

因此：选择B

作业标题(1252)

如何定义一个int类型的指针数组，数组元素个数为10个：( )

作业内容

A.int a[10]

B.int (*a)[10]

C.int *a[10];

D.int (*a[10])(int);

题目要int的指针数组，A为int数组，B为int数组的指针，C为int的指针数组，D为int(*)(int)函数指针的数组，故选C

作业标题(720)

下面哪个是指针数组：（ ）

作业内容

A. int* arr[10];

B.int * arr[];

C.int **arr;

D.int (*arr)[10];

答案解析：

指针数组是一个数组，该数组的每个元素是一个指针

A：正确，定义了一个数组，该数组中有10个元素，每个元素都是int*的指针类型

B：错误，编译失败，定义数组时，要给出空间的大小，如果没有给时，必须要给出初始化结果

C：错误，定义了一个二级指针

D：错误，*和arr先结合，说明arr不是数组。实际上arr是一个指针，一个指向数组的指针。

因此：选择A

作业标题(1127)

下面关于"指针"的描述不正确的是：（ ）

作业内容

A.当使用free释放掉一个指针内容后,指针变量的值被置为NULL

B.32位系统下任何类型指针的长度都是4个字节

C.指针的数据类型声明的是指针实际指向内容的数据类型

D.野指针是指向未分配或者已经释放的内存地址

答案解析

A选项目前还没学，目前只需要了解free不会更改指针的指向。

B选项强调了32位系统，所以没问题。

CD选项是定义本身。

所以排除法也可以确定是A。

作业标题(1173)

关于下面代码描述正确的是：（ ）

char* p = "hello bit";

作业内容

A.把字符串hello bit存放在p变量中

B.把字符串hello bit的第一个字符存放在p变量中

C.把字符串hello bit的第一个字符的地址存放在p变量中

D.*p等价于hello bit

答案解析

双引号引起来的这一段是一个常量字符串，本质是一个常量字符数组类型，赋给一个指针，相当于把一个数组的首地址赋给指针，即第一个元素h的地址。

只有选项C提到了第一个字符的地址，故选C

作业标题(1247)

下面代码的执行结果是（ ）

#include <stdio.h>
int main()
{
  char str1[] = "hello bit.";
  char str2[] = "hello bit.";
  char *str3 = "hello bit.";
  char *str4 = "hello bit.";
  if(str1 == str2)
    printf("str1 and str2 are same\n");
  else
    printf("str1 and str2 are not same\n");

  if(str3 == str4)
    printf("str3 and str4 are same\n");
  else
    printf("str3 and str4 are not same\n");

  return 0; 
}

作业内容

A.str1 and str2 are same str3 and str4 are same

B.str1 and str2 are same str3 and str4 are not same

C.str1 and str2 are not same str3 and str4 are same

D.str1 and str2 are not same str3 and str4 are not same

答案解析

str1和str2是两个数组，数组的操作方式是将右边常量字符串的内容拷贝进来，所以他们是两个空间，只是内容相同，所以str1 != str2。而str3和str4是两个指针，编译器在处理的时候，会将相同的常量字符串做成同一个地址，所以，str3和str4指向的是同一个常量字符串，所以str3 == str4，故选C。

作业标题(1363)

字符串旋转结果

作业内容

写一个函数，判断一个字符串是否为另外一个字符串旋转之后的字符串。

例如：给定s1 =AABCD和s2 = BCDAA，返回1

给定s1=abcd和s2=ACBD，返回0.

AABCD左旋一个字符得到ABCDA

AABCD左旋两个字符得到BCDAA

AABCD右旋一个字符得到DAABC

不想动脑代码：

#include <stdio.h>
#include <string.h>


int isRotation(char* str, char* str1) {
    int length = strlen(str);
    int length1 = strlen(str1);
    int i, h, count = 0;
    if (length != length1) {
        return 0;
    }
    else {
        for (i = 0; i < length; i++) {
            char temp = str[0];
            for (int j = 0; j < length - 1; j++) {
                str[j] = str[j + 1];
            }
            str[length - 1] = temp;
            count = 1;
            for (h = 0; h < length; h++) {
                if (str[h] != str1[h]) {
                    count = 0;
                    break;
                }
            }
            if (count == 1) {
                return 1;
            }
        }
    }
    return 0;
}


int main() {
    char s1[] = "AABCD";
    char s2[] = "BCDAA";
    printf("%d\n", isRotation(s1, s2)); // 输出1


    char s3[] = "abcd";
    char s4[] = "ACBD";
    printf("%d\n", isRotation(s3, s4)); // 输出0


    return 0;
}

 

作业标题(1325)

杨氏矩阵

作业内容

有一个数字矩阵，矩阵的每行从左到右是递增的，矩阵从上到下是递增的，请编写程序在这样的矩阵中查找某个数字是否存在。

要求：时间复杂度小于O(N);

#include <stdio.h>


int searchInMatrix(int matrix[4][4], int target, int rows, int cols) {
    int row = 0;
    int col = cols - 1;


    while (row < rows && col >= 0) {
        if (matrix[row][col] == target) {
            return 1;  // 找到目标数字
        }
        else if (matrix[row][col] > target) {
            col--;  // 目标数字可能在当前列的左边
        }
        else {
            row++;  // 目标数字可能在当前行的下面
        }
    }


    return 0;  // 没有找到目标数字
}


int main() {
    int matrix[4][4] = {
        {1, 4, 7, 11},
        {2, 5, 8, 12},
        {3, 6, 9, 16},
        {10, 13, 14, 17}
    };


    int target1 = 5;
    int target2 = 20;


    printf("%d\n", searchInMatrix(matrix, target1, 4, 4));  // 输出1，表示找到了5
    printf("%d\n", searchInMatrix(matrix, target2, 4, 4));  // 输出0，表示没有找到20


    return 0;
}

作业标题(1102)

猜凶手

作业内容

日本某地发生了一件谋杀案，警察通过排查确定杀人凶手必为4个嫌疑犯的一个。

以下为4个嫌疑犯的供词:

A说：不是我。

B说：是C。

C说：是D。

D说：C在胡说

已知3个人说了真话，1个人说的是假话。

现在请根据这些信息，写一个程序来确定到底谁是凶手。

简单无脑代码：

#include <stdio.h>
int main()
{
	int A=0,B=0,C=0,D=0;
	int FD;//因为c和d的供词刚好对立 表示对立的
	int i;
	for(i=1; i<=4; i++)
	{
		
		if(i==1)//A说的假
		{
			A=1;C=1;FD=1;D=0;
		}
		if(i==2)//B说的假
		{
			A=0;C=0;FD=1;D=0;
		}
		if(i==3)//C说的假
		{
			A=0;C=1;FD=0;D=0;
		}
		if(i==4)//D的说的假
		{
			A=0;C=1;FD=1;D=0;
		}
		if(A+B+C+D+FD==1&&FD==D)//只有一个人是凶手 当和为1时一个凶手出现  因为CD供词推出的都是D是不是 与上FD==D是为了排除D是D不是的情况 
			printf("A=%d B=%d C=%d D=%d\n",A,B,C,D);  
	}
	return 0;
}

动脑：

#include <stdio.h>

int main()
{
	char killer;
	for (killer = 'A'; killer <= 'D'; killer++)//巧妙地利用ASCII 从A-D进行循环和比较
	{
		//下面分别对应每个人都供词  不是A 是C     是D    不是D
		if (((killer != 'A') + (killer == 'C') + (killer == 'D') + (killer != 'D')) == 3)  //这里等于3表示 有三个人说了真话
		{
			printf("%c是凶手\n", killer);
			break;
		}
	}
	return 0;
}

 

作业标题(1105)

杨辉三角

作业内容

在屏幕上打印杨辉三角。

1

1 1

1 2 1

1 3 3 1

……

void yangHuiTriangle(int n)
{
	int data[30][30] = { 1 }; //第一行直接填好，播下种子

	int i, j;

	for (i = 1; i < n; i++) //从第二行开始填
	{
		data[i][0] = 1; //每行的第一列都没有区别，直接给1，保证不会越界。
		for (j = 1; j <= i; j++) //从第二列开始填
		{
			data[i][j] = data[i - 1][j] + data[i - 1][j - 1]; //递推方程
		}
	}

	for (i = 0; i < n; i++) //填完打印
	{
		for (j = 0; j <= i; j++)
		{
			printf("%d ", data[i][j]);
		}
		putchar('\n');
	}
}