2023 移动应用开发实验室纳新面试题

愿相知

已于 2023-11-06 14:56:54 修改

阅读量123

点赞数 2

文章标签： c语言算法排序算法数据结构

于 2023-11-04 21:25:32 首次发布

本文链接：https://blog.csdn.net/2303_79296612/article/details/134223664

版权

2023 移动应用开发实验室纳新面试题

1.简单说下 int、short int、float、double、long int、long long int 在 64 位机申请内存的大小。

int型：4；
short int型：2；
float型：4；
double型：8；
long int：8；
long long int ：8；

参考：

2.使用 c 语言完成五种交换值的方式。

1.使用加减法：

int a = 5，b = 10;
a = a + b;
b = a - b;
a = a - b;

2.使用乘除法：
这种方式类似于加减法，只是将加法和减法替换为乘法和除法。

int a = 5，b = 10;
a = a * b;
b = a / b;
a = a / b;

3.使用异或法：

int a = 5，b = 10;
a = a ^ b;
b = a ^ b;
a = a ^ b;

4.使用临时变量法：

int a = 5，b = 10，temp;
temp = a;
a = b;
b = temp;

5.使用指针交换值：

int a = 5，b = 10;
int *p1 = &a;
int *p2 = &b;
int temp;
temp = *p1;
*p1 = *p2;
*p2 = temp;

3.下面代码段将打印出多少个“=” ? 运用相关知识解释该输出。

#include <stdio.h>
int main()
{
 for(unsigned int i = 3;i>=0;i--){
 putchar('=');
 }
}

无数个‘=’，这是个for循环，它的条件是i>=0,i初始值为3,循环迭代条件是i–，

看似没问题，实际上，i的数据类型是unsigned
int,当i减到0后，再进行一次自减，会变为其最大值。没有负值，永远大于0.所以会打印出无数个‘=’。（无类型的int范围是0—2的32次方-1）

4.逻辑关系的爱恨情仇。

简述这个逻辑的运算过程以及输出 answer 的值。

#include <stdio.h>
int count = 100;// 简述逻辑
int process(int num) {
 while (1)
 switch (num) {
 case 0: 
 num = num ^ 99 ^ 88 ^ 99 ^ 88 | 10;
 case 15: 
 num = num ^ 5; 
 break; 
 case 8:
 num = 1 << num;
 num -= num++;
 break; 
 case 10: 
 num = num + - 3; 
 count = count + num++; 
 break; 
 case 2: 
 --num; 
 case 5: 
 return (1 << num); 
 default: 
 num = num & 1 ? num + 1 : num;
 }
}
int main() {
 int start = 0;
 int answer = process(start); // 输出结果
 printf("answer == %d\n", answer);
 return 0;
}

1.定义了一个整型变量count，并初始化为100；一个名为process的函数，该函数接受一个整型参数num。

2.在process函数中，使用了一个无限循环while(1)。

3.在循环内部，使用了switch语句，根据num的值进行不同的操作。

1.当num的值为0时，执行case 0。

num进行了一系列的异或运算，相当于没有变。再进行或运算，并将结果赋值给num。

2.当num的值为15时，执行case 15。

num进行一次异或运算，并将结果赋值给num。

3.当num的值为8时，执行case 8。

num进行一次左移运算和自减运算，并依次将结果赋值给num。

4.当num的值为10时，执行case 10。

num加-3，再进行自增运算，并将结果赋值给num。count加上num自增前的结果，并将结果赋值给count。

5.当num的值为2时，执行case 2。

num进行一次自减运算。

6.当num的值为5时，执行case 5。

返回1左移num位的结果。

7.如果num的值不匹配任何case，执行default。

三目运算符，将num与1进行与运算（效果等同于判断奇偶性），若结果为真则执行num+1赋值给num，否则执行num赋值给num。

在本程序中

1.第一次，num = 0，执行case 0，一次按位或，得到num = 10，没有break语句，向下进入case 15，异或运算5，得到num = 15。

2.第二次，因为num=15，进入case15，异或5等于10。

3.第三次，因为num=10，进入case10，加-3，所以得到num=7，后缀自增，所以count为7，而后num=8。

4.第四次，num=8，进入case8，将1向左移八位，相当于乘2的8次方，num=256。下一句，num-num赋值给num，此时num=0，再进行自增，num
= 1。

5.第五次，num=1，进入default，三目运算符，第一个表达式为真，则num=num+1。

最终答案为answer == 2

。

5.struct 与 union 的故事。

#include <stdio.h>
typedef struct str {
 short e1;
 char e2;
 char e3[6];
 double e5;
 int e6;
}str;
typedef union uni {
 short e1;
 char e2; 
 char e3[6];
 struct str e4;
 double e5;
 int e6;
}uni;
int main(){
 int x = sizeof(str);
 int y = sizeof(uni);
 printf("x = %d，y = %d\n", x,y);
 printf("hello = %d\n", printf("3G = %d\n", --x == 23 && x-- == 22 && ++y == 9));
 printf("x1 = %d，y1 = %d\n", x,y);
 return 0;
}

输出结果：

x = 32，y = 32
3G = 0
hello = 7
x1 = 31，y1 = 32

本题考查内存对齐；

内存对齐计算：
要学会计算内存对齐，首先要了解内存对齐的规则：

1.在任何一个平台下都有一个默认对齐数，vs中默认对齐数是8
2.结构体每个成员变量又有一个自己独立的对齐数，就是成员变量类型的大小
3.实际成员变量的对齐数是成员自己独立的对齐数与默认对齐数中较小的那个
4.每个成员变量都应该对齐到这个对齐数的整数倍处
5.结构体的总大小，应该是实际最大对齐数的整数倍大小，不足则补位
6.如果成员变量也是结构体变量,则这个结构体变量的对齐数，为自己结构内部的实际最大对齐数

结构体的大小是所有成员变量占用空间的总和，而联合体的大小是最大成员变量占用空间的大小。

结构体内存对齐。short为2，char为1，char的数组为6，double为8，int为4，所以short和char占8个，char数组占8个，double占8个，int占8个。故第一个结构体占32。

共用体内存对齐。short为1，char为1，char的数组为6，结构体为32，double为8，int为4.故共用体占32。

所以x，y为32。

下来考察printf函数返回值，返回值为打印出的字符位数。

逻辑与，只要一个为假后面将不再继续。–x == 23为假，直接运算出结果为0。并且只有x减少1。

此处输出 3G = 0\n 共7字符，所以结果为7

6.宏函数基础。

#include <stdio.h>
#define SQR(x) x*x
int main()
{
int i = 1, j = 2;
printf("%d\n",SQR(i+j));
}

宏定义仅仅为字面替换，故printf引用的值为 i + j * i + j。

所以输出结果为5.

7.小雪今天也有学习指针。

//以下程序运行结果是什么？
int main()
{
 int nums[2][5]={{2, 4, 6, 8, 10},{12,14,16,18,20}};
 int *ptr1=(int*)(&nums+1);
 int *ptr2=(int*)(&nums[0]+1);
 printf("*nums[0][4]+1 = %d\n",nums[0][4]+1);
 printf("*(nums[0])+1 = %d\n",*(nums[0])+1);
 printf("*(nums[0]+1) = %d\n",*(nums[0]+1));
 printf("*(nums[1]+1) = %d\n",*(nums[1]+1));
 printf("*(nums+1) = %d\n",*(nums+1));
 printf("*(ptr2-1) = %d\n",*(ptr2-1));
 printf("*(ptr-1) = %d\n",*(ptr1-1));
 return 0;
}

第一行：先找出nums[0] [4]的值再加1，nums[0] [4]是数组第一行第五列的元素，即10，并对其加一，输出结果为11

第二行;先找出nums[0]的值再加1，nums[0]等效于数组首元素的地址，对其解引用则是表示一维数组的首元素，即2，加一等于3

第三行：访问该二维数组的首个一维数组，找到其首元素的下一个元素，是4

第四行：找到该二维数组的第二个一维数组，再找其第二个元素为14

第五行：nums表示一整个二维数组的首元素地址，对其加一指向该数组后第一个元素，解引用一次则为其地址，故此处打印一个随机的地址值（指该地址分配随机，同一个电脑多次打印该值相同）

第六行：ptr2中存储该二维数组第二个一维数组首元素地址，减一再解引用则为第一个一维数组最后一个元素值

第七行：ptr1中存储该二维数组整体之后的，下一个元素的地址，减一再解引用则为该二维数组最后一个元素值

8.上一个被欺负的指针找来了她的男朋友。

//以下程序运行结果是什么？
#include<stdio.h>
int main() {
 int a[3][4] = {{1,2,3,4}, {3,4,5,6}, {5,6,7,8}};
 int i;
 int(*p)[4] = a,*q = a[0];
 for (i = 0; i < 3; i++) {
 if (i == 0)
 (*p)[i + i / 2] = *q + 1;
 else
 p++,++q;
 }
 for (i = 0; i < 3; i++) {
 printf("a[%d][%d] = %d\n",i,i, a[i][i]);
 }
 printf("%d, %d\n", *((int*)p), *q);
}

程序首先定义了一个二维数组a

然后使用指针p和q分别指向数组a的首地址和第一个元素的地址

接下来，通过循环对数组a进行操作

当i等于0时，将§[i + i / 2]的值修改为q + 1，即将a[0][0]的值修改为2

当i不等于0时，分别将指针p和q向后移动一位

初始 * ( ( int* )p)=1, *q=1

i=0 * ( ( int* )p)=2 *q=2,

i=1 * ( ( int* )p)=3,*q=2,

i=2 * ( ( int* )p)=5,*q=3

最后，通过循环打印出数组a的对角线元素和指针p和q的值

9.那就简单排个序吧

解释这段代码的作用，以及代码逻辑和相关用法，以及这些函数的特性与作用。

#include <stdio.h>
int int_cmp(const void * p1, const void * p2)
{
 return (*( int *)p1 - *(int *) p2);
}
void _swap(void *p1, void * p2, int size)
{
 int i = 0;
 for (i = 0; i< size; i++)
 {
 char tmp = *((char *)p1 + i);
 *(( char *)p1 + i) = *((char *) p2 + i);
 *(( char *)p2 + i) = tmp;
 }
}
void Qsort(void *base, int count, int size, int (*cmp)(void *, void *)) {
 int i = 0;
 int j = 0;
 for (i = 0; i< count - 1; i++)
 {
 for (j = 0; j<count-i-1; j++)
 {
 if (cmp ((char *) base + j*size , (char *)base + (j + 1)*size) > 0)
 {
 _swap(( char *)base + j*size, (char *)base + (j + 1)*size, size);
 }
 }
 }
}
int main()
{
 int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
 int i = 0;
 Qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), (int (*)(void *, void *))
int_cmp);
 for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
 {
 printf( "%d ", arr[i]);
 }
 printf("\n");
 return 0;
}

使用了 C 标准库函数 qsort 的原理来实现自定义的 Qsort 函数

代码首先定义了一个整型数组arr，并初始化了一组无序的数字。

然后调用了Qsort函数，该函数使用冒泡排序算法对数组进行排序。

Qsort函数中的循环嵌套用于比较相邻元素的大小，并根据需要进行交换，以实现排序的目的。

使用冒泡排序对数组进行排序。冒泡排序是一种简单但效率较低的排序算法，它通过多次比较和交换相邻元素的方式将较大的元素逐渐"冒泡"到数组的末尾

最后，代码使用循环打印出排序后的数组元素。

10.我爱学数学

**下面的算式中，不同的汉字表示不同的数字，相同的汉字表示相同的数字，问这个算式中每个汉字各代表什么数字？（提示：枚举）
（使用 C 语言向学长学姐解释解题思路及代码，请提前准备好代码，如果不会也没关系可以向学长学姐讲述一下自己的想法）
爱 = （）数 = （）学 = （）啊 = （）

使用穷举法，找出所有可能的数字组合。把四个字各自以一个变量表示。枚举出所有情况，并用所给出等式表示。**

#include <stdio.h>
int main()
{	for (int a = 0; a <= 9; a++) { 
        for (int b = 0; b <= 9; b++) { 
            for (int c = 0; c <= 9; c++) { 
                for (int d = 0; d <= 9; d++) { 
                    int aba = a * 100 + b * 10 + a * 1; 
                    int csa = c * 100 + d * 10 + a * 1 ; 
                    	if (aba + csa == c *1000+d*100+a*10+b)
                        {
                        	printf("学=%d, 啊=%d, 爱=%d, 数=%d\n", a, b, c, d);
                    }
                }
            }
        }
    }
    return 0;
}