一
简单说下 int、short int、float、double、long int、long long int 在 64位机申请内存的大小。
分别为4 2 4 4 8 8
二
使用 c 语言完成五种交换值的方式。
方法一
创造临时变量
int main()
{
int a,b;
scanf("%d %d", &a, &b);
printf("交换前：%d %d\n", a, b);
int tmp = a;
a = b;
b = tmp;
printf("交换后：%d %d\n", a, b);
return 0;
}
方法二
传递地址在函数内创造临时变量交换值
void swap(int* px, int* py)
{
int tmp = *px;
*px = *py;
*py = tmp;
}
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
printf("交换前：%d %d\n", a, b);
swap(&a, &b);
printf("交换后：%d %d\n", a, b);
return 0;
}
方法三
使用乘除
int main()
{
int a, b;
scanf("%d %d", &a, &b);
printf("交换前：%d %d\n", a, b);
a = a * b;
b = a / b;//b=a*b/b
a = a / b;//a=a*b/a
printf("交换后：%d %d\n", a, b);
}
方法四
使用加减
int main()
{
int a, b;
scanf("%d %d", &a, &b);
printf("交换前：%d %d\n", a, b);
a = a + b;
b = a - b;//b=a+b-b
a = a - b;//a=a+b-a
printf("交换后：%d %d\n", a, b);
}
方法五
使用异或操作符
int main()
{
int a, b;
scanf("%d %d", &a, &b);
printf("交换前：%d %d\n", a, b);
a = a ^ b;
b = a ^ b;//a^b^b = a
a = a ^ b;//a^b^a = b
printf("交换后：%d %d\n", a, b);
}
三
下面代码段将打印出多少个“=” ? 运用相关知识解释该输出。
#include <stdio.h>
int main(){
for(unsigned int i = 3;i>=0;i--){
putchar('=');
}
}
当减到0时候由
000 0000 0000 0000 0000 0000 0000 0000
变为
1000 0000 0000 0000 0000 0000 0000 0001（原码）
1111 1111 1111 1111 1111 1111 1111 1111（补码）
（ ff ff ff ff即-1补码的十六进制表示）
当i减到-1内存存储的值如上图，但i为unsigned int 类型，将其认为是无符号，此时i的值变为2的32次方减1，此时仍满足循环，再次减到0时如上述情况一致，因此死循环打印=。
四
逻辑关系的爱恨情仇。
简述这个逻辑的运算过程以及输出 answer 的值。
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;
}
将0传入函数中，进入while循环，进入switch循环，
case 0,0^ 99 ^ 88 ^ 99 ^ 88 后仍为0（异或支持交换律；一个数异或自己得0；0异或一个数仍是0）。0|10（0000 | 1010）得10（1010）.未break,进入15
case 15 10^5 (1010^0101)得15（1111）break
case 15 15^5 (1111^0101)得10（1010）break
case 10 num=7.num++后num=8 break
case 8 num=1<<8,即28 num-num++得num=1;
default 无1，进入default，1&1得1为真，num=num+1，num=2
case 2 num=1
case 5 return(1<<1) 即return 2
打印出2
五
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;
}
struct的大小内存对齐后为32
union内存大小为最大的，最大的为struct str e4，union大小为32
这里输出x1 = 32，y1 = 32\n
–x == 23不成立，&&为短路操作符，第一个表达式为0，后面不再运算，x=31
输出3G = 0
printf返回值为输出的字符数量，不包含‘\0’，这里是6
输出hello = 6
输出x1 = 31，y1 = 32
六
宏函数基础。
#include <stdio.h>
#define SQR(x) x*x
int main()
{
int i = 1, j = 2;
printf("%d\n",SQR(i+j));
}
define只进行替换
i + j * i + j 得5
七
以下程序运行结果是什么？
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("*(ptr1-1) = %d\n",*(ptr1-1));
return 0;
}
运行结果如图
*nums[0][4]+1：nums[0][4]的值是10，加1得到11。*(nums[0])+1：nums[0]的值指向二维数组第一行首元素2，解引用后加1得到3。*(nums[0]+1)：nums[0]+1的值指向num[0]的下一个元素nums[0][1]，解引用得到4。*(nums[1]+1)：nums[1]+1的值指向num[1]的下一个元素nums[1][1]，解引用得到14。*(nums + 1)：输出nums数组第二行的地址（即第一行的地址加5个int的大小）。**(nums + 1)：输出nums数组第二行的第一个元素。*(ptr2-1)：ptr2的地址指向num[1][0]，ptr2-1的值是指向num[1][0]上一个元素nums[0][4]，解引用得到10。*(ptr-1)：ptr1的值是指向整个二位数组首元素加整个数组大小乘1后的地址，ptr-1为该地址上一个元素解引用得到20。
八
上一个被欺负的指针找来了她的男朋友。
以下程序运行结果是什么？
#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);
}
int(*p)[4] = a;定义了一个数组指针，指向二维数组a第一行，解引用为二维数组第一个元素。
int* q = a[0];定义了一个指针，指向二维数组的第一行首元素地址，解引用为第一个元素。
进入for循环： i=0:*p[0]=*q+1，将第第一行首元素的值变为第一个元素值加1。
i=1,2:数组指针p加2，指向第三行。q加2指向第一行第三个元素。
printf("%d, %d\n", *((int*)p), *q);前者将数组指针转换为指针，解引用第三行首元素，后者则是解引用第一行第三个元素。
九
解释这段代码的作用，以及代码逻辑和相关用法，以及这些函数的特性与作用。
#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;
}
在mian函数中
Qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), (int (*)(void*, void*)) int_cmp);这一步将数组arr，数组元素个数，单个int定义元素在内存中大小，int_cmp函数传入Qsort函数中
void Qsort(void* base, int count, int size, int (*cmp)(void*, void*))中分别用base,count,size以及cmp函数指针接收，接着进行冒泡排序。
在if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)中，将数组相邻两元素地址转换为char类型传入int_cmp函数，再return (*(int*)p1 - *(int*)p2);返回两数差值，若左数大于右数，则进入If条件语句中，再将该两元素地址及元素在内存中大小传入_swap中，进行交换两值。
这段代码使用了函数指针，在Qsort函数中传入int_cmp函数名即地址，在void Qsort中使用int (*cmp)(void*, void*)得到比较函数的地址。
十
下面的算式中，不同的汉字表示不同的数字，相同的汉字表示相同的数字，问这个算式中每个 汉字各代表什么数字？（提示：枚举）
使用枚举法，列出四个数字所以可能，同时排除数字相对的可能。又已知即使加号两边首位都为最高位9，得出的数千位也只能为1，因此可知爱=1。其余数字枚举可得。
#include <stdio.h>
int main()
{
int a = 1;
for (int b = 0; b < 10; b++)
{
if (a != b)
{
for (int c = 0; c < 10; c++)
{
if(a!=c && b!=c)
for (int d = 0; d < 10; d++)
{
if ( a != d && b != d && c != d)
{
if (a * 1000 + b * 100 + c * 10 + d == c * 100 + d * 10 + c + a * 100 + b * 10 + c)
printf("%d %d %d %d", a, b, c, d);
}
}
}
}
}
return 0;
}
二面
1.小鱼比可爱
题目描述
人比人，气死人；鱼比鱼，难死鱼。小鱼最近参加了一个“比可爱”比赛，比的是每只鱼的可爱程度。参赛的鱼被从左到右排成一排，头都朝向左边，然后每只鱼会得到一个整数数值，表示这只鱼的可爱程度，很显然整数越大，表示这只鱼越可爱，而且任意两只鱼的可爱程度可能一样。由于所有的鱼头都朝向左边，所以每只鱼只能看见在它左边的鱼的可爱程度，它们心里都在计算，在自己的眼力范围内有多少只鱼不如自己可爱呢。请你帮这些可爱但是鱼脑不够用的小鱼们计算一下。
输入格式
第一行输入一个正整数 n n n，表示鱼的数目。
第二行内输入 n n n 个正整数，用空格间隔，依次表示从左到右每只小鱼的可爱程度 a i a_i ai。
输出格式
一行，输出 n n n 个整数，用空格间隔，依次表示每只小鱼眼中有多少只鱼不如自己可爱。
样例 #1
样例输入 #1
6
4 3 0 5 1 2
样例输出 #1
0 0 0 3 1 2
提示
对于 100 % 100\% 100% 的数据， 1 ≤ n ≤ 100 1 \leq n\leq 100 1≤n≤100， 0 ≤ a i ≤ 10 0 \leq a_i \leq 10 0≤ai≤10。
#include <stdio.h>
int main()
{
int n = 0;
int j, i = 0;
scanf("%d", &n);
//声明一个用于计数的初始化为的数组
int arr[100] = {0};
//输入每条鱼可爱程度
for (int j = 0; j < n; j++)
{
scanf("%d", &arr[j]);
}
int arr2[100] = {0};
//判断第i条鱼前各有多少可爱程度小于它的
for (i = 0; i < n; i++)
{
for (j = 0; j < i; j++)
{
if (arr[j] < arr[i])
//若成立则给用于计数的数组加一
arr2[i]++;
}
}
//输出计数数组
for (j = 0; j < n; j++)
{
printf("%d ", arr2[j]);
}
return 0;
}
2. 素数回文数的个数
题目描述
求 11 11 11 到 n n n 之间（包括 n n n），既是素数又是回文数的整数有多少个。
输入格式
一个大于 11 11 11 小于 10000 10000 10000 的整数 n n n。
输出格式
11 11 11 到 n n n 之间的素数回文数个数。
样例 #1
样例输入 #1
23
样例输出 #1
1
提示
回文数指左右对称的数，如： 11 11 11， 12121 12121 12121。
使用两个函数分别判断回文数和素数，
Isnum1用于判断素数,若为素数，返回1，否则返回0；
Isnum2用于判断回文数，若为回文数，返回1，否则返回0；
Isnum1从2开始遍历至n的开方，用n除该数，当有余数时，返回0，说明其不为素数，当遍历结束后仍未返回0，则返回一说明其为素数。
#include<stdio.h>
#include<math.h>
int IsPrime(int n)
{
for (int i = 2; i <= sqrt(n); i++)
{
if (n % i == 0)
return 0;
}
return 1;
}
int Isnum(int n)
{
int a = n;
int sum = 0;
while (n > 0)
{
int a = n % 10;
sum = sum * 10 + a;
n /= 10;
}
if (sum == a)
return 1;
else
return 0;
}
int main()
{
int n = 0;
int count = 0;
scanf("%d", &n);
for (int i = 11; i < n; i++)
{
if (IsPrime(i) && Isnum(i))
count++;
}
printf("%d", count);
return 0;
}
3.开关灯
题目描述
假设有 N N N 盏灯（ N N N 为不大于 5000 5000 5000 的正整数），从 1 1 1 到 N N N按顺序依次编号，初始时全部处于开启状态；第一个人（ 1 1 1 号）将灯全部关闭，第二个人（ 2 2 2 号）将编号为 2 2 2的倍数的灯打开，第三个人（ 3 3 3 号）将编号为 3 3 3的倍数的灯做相反处理（即，将打开的灯关闭，将关闭的灯打开）。依照编号递增顺序，以后的人都和 3 3 3号一样，将凡是自己编号倍数的灯做相反处理。问当第 N N N 个人操作完之后，有哪些灯是关闭着的？
输入格式
输入为一行，一个整数 N N N，为灯的数量。
输出格式
输出为一行，按顺序输出关着的灯的编号。编号与编号之间间隔一个空格。
样例 #1
样例输入 #1
10
样例输出 #1
1 4 9
#include<stdio.h>
int main()
{
int n = 0;
scanf("%d", &n);
//当只有一盏灯时，被一个人操作后，熄灭，直接输出1
if (n == 1)
printf("1");
//初始化为0一个数组，来记录灯的开关，1开0关，此时已经被第一个人操作，全部关闭
//因为vs不支持变长数组，所以声明一个数据范围内最大的数组
int arr[5000] = { 0 };
//对于输入的n个人都要进行操作,i表示第几个人
for (int i = 2; i < n; i++)
{
//j为数组下标，j+=i表示第i个人将编号为i的灯进行操作
for (int j = i-1; j < n; j += i)
{
//将灯做相反处理
if (arr[j] == 0)
arr[j] = 1;
else if(arr[j]==1)
arr[j] = 0;
}
}
//判断若灯为关闭状态打印出其编号，数组下标+1
for (int i = 0; i < n-1; i++)
{
if (arr[i] == 0)
printf("%d ", i + 1);
}
return 0;
}
4.确定进制
题目描述
6 × 9 = 42 6\ \times 9=42 6 ×9=42 对于十进制来说是错误的，但是对于 13 13 13 进制来说是正确的。即 6 ( 13 ) × 9 ( 13 ) = 4 2 ( 13 ) 6_{(13)}\ \times 9_{(13)}=42_{(13)} 6(13) ×9(13)=42(13)，而 4 2 ( 13 ) = 4 × 1 3 1 + 2 × 1 3 0 = 5 4 ( 10 ) 42_{(13)}=4\ \times 13^1+2\ \times 13^0=54_{(10)} 42(13)=4 ×131+2 ×130=54(10)。
你的任务是写一段程序读入三个整数 p , q p,q p,q 和 r r r，然后确定一个进制 B ( 2 ≤ B ≤ 16 ) B(2 \le B \le 16) B(2≤B≤16) 使得 p × q = r p\ \times q=r p ×q=r。如果 B B B 有很多选择，则输出最小的一个。
例如： p = 11 , q = 11 , r = 121 p=11,q=11,r=121 p=11,q=11,r=121，则有 1 1 ( 3 ) × 1 1 ( 3 ) = 12 1 ( 3 ) 11_{(3)}\ \times 11_{(3)}=121_{(3)} 11(3) ×11(3)=121(3)，因为
1 1 ( 3 ) = 1 × 3 1 + 1 × 3 0 = 4 ( 10 ) 11_{(3)}=1\ \times 3^1+1\ \times 3^0=4_{(10)} 11(3)=1 ×31+1 ×30=4(10) 和 12 1 ( 3 ) = 1 × 3 2 + 2 × 3 1 + 1 × 3 0 = 1 6 ( 10 ) 121_{(3)}=1\ \times 3^2+2\ \times 3^1+1\ \times 3^0=16_{(10)} 121(3)=1 ×32+2 ×31+1 ×30=16(10)。对于进制 10 , 10, 10, 有 1 1 ( 10 ) × 1 1 ( 10 ) = 12 1 ( 10 ) 11_{(10)}\ \times 11_{(10)}=121_{(10)} 11(10) ×11(10)=121(10)。这种情况下，应该输出 3 3 3。如果没有合适的进制，则输出 0 0 0
输入格式
一行，包含三个整数 p , q , r p,q,r p,q,r，相邻两个整数之间用单个空格隔开。
输出格式
一个整数：即使得 p × q = r p \times q=r p×q=r 成立的最小的 B B B。如果没有合适的 B B B，则输出 0 0 0。
样例 #1
样例输入 #1
6 9 42
样例输出 #1
13
提示
p , q , r p,q,r p,q,r 的所有位都是数字，并且 1 ≤ p , q , r ≤ 1 0 6 1 \le p,q,r \le 10^6 1≤p,q,r≤106。
首先要判断最小进制，比如输入2617 6805 124,那么应该从9进制开始计算，所以我们先使用find函数找到这三个数中所有位中的最大值，再加一就是他的最小成立进制。
然后从找到的进制开始遍历到16进制，在is函数中判断是否能使等式成立，判断前在zhaun函数中将其转化为当前判断进制形式下的十进制（注意要使用long long），判断完成后若成立返回1，否则返回0；
最终因为从小向大遍历，所以一旦能够成立，必然是最小成立进制，再输出该进制即可。若找不到输出0。
#include<stdio.h>
#include<math.h>
//将当前判断进制下的数转换为十进制
int zhuan(int p, int b)
{
long long sum = 0;
int i = 0;
int a;
while (p > 0)
{
a = p % 10;
sum = sum + a * pow(b, i++);
p /= 10;
}
return sum;
}
//判断是否满足题目条件
int is(int p, int q, int r, int b)
{
long long num1 = zhuan(p, b);
long long num2 = zhuan(q, b);
long long num3 = zhuan(r, b);
if (num1 * num2 == num3)
return 1;
else
return 0;
}
//找每一位中最大值作为循环最小进制
int find(int p, int q, int r)
{
int max = 2;
int a = 0;
while(p>0)
{
if (max == 9)
break;
a = p % 10;
if (a > max)
max = a;
p /= 10;
}
while(q>0)
{
if (max == 9)
break;
int a = q % 10;
if (a > max)
max = a;
q /= 10;
}
while(r>0)
{
if (max == 9)
break;
int a = r % 10;
if (a > max)
max = a;
r /= 10;
}
return max + 1;
}
int main()
{
int p, q, r;
int flag = 0;
int count = 0;
scanf("%d %d %d", &p, &q, &r);
int b = 0;
for (b = find(p, q, r); b <= 16; b++)
{
flag = is(p, q, r, b);
if (is(p, q, r, b))
{
count = b;
break;
}
}
if (flag)
printf("%d", count);
else
printf("0");
return 0;
}
5.拼数
题目描述
设有 n n n 个正整数 a 1 … a n a_1 \dots a_n a1…an，将它们联接成一排，相邻数字首尾相接，组成一个最大的整数。
输入格式
第一行有一个整数，表示数字个数 n n n。
第二行有 n n n 个整数，表示给出的 n n n 个整数 a i a_i ai。
输出格式
一个正整数，表示最大的整数
#include <stdio.h>
#include <string.h>
// 比较两种拼接方式下两个字符串的大小，用字符数组接收
int compare(const char* str1, const char* str2) {
char temp1[40], temp2[40];
strcpy(temp1, str1);
strcat(temp1, str2); // 将str1和str2拼接在一起
strcpy(temp2, str2);
strcat(temp2, str1); // 将str2和str1拼接在一起
return strcmp(temp2, temp1);
// str2和str1方式大于str1和str2就返回>0的数
}
// 冒泡排序
void bubbleSort(char arr[][20], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (compare(arr[j], arr[j + 1]) > 0) {
// 如果arr[j]+arr[j + 1]大于arr[j+1]+arr[j]，则交换它们的位置
char temp[20];
strcpy(temp, arr[j]);
strcpy(arr[j], arr[j + 1]);
strcpy(arr[j + 1], temp);
}
}
}
}
int main() {
int n;
scanf("%d", &n);
char nums[25][20]; // 定义一个二维字符数组来存储输入的字符串
for (int i = 0; i < n; i++) {
scanf("%s", nums[i]); // 逐个读取字符串并存储到数组中
}
// 排序
bubbleSort(nums, n); // 使用冒泡排序对字符串数组进行排序
// 拼接结果
char ret[200];
ret[0] = '\0'; // 初始化结果字符串为空
for (int i = 0; i < n; i++) {
strcat(ret, nums[i]); // 逐个将排序后的字符串拼接到结果字符串中
}
printf("%s\n", ret); // 输出结果字符串
return 0;
}
6.高精度减法
题目描述
高精度减法
输入格式
两个整数
a
,
b
a,b
a,b（第二个可能比第一个大）。
输出格式
结果（是负数要输出负号）。
提示
- 20 % 20\% 20% 数据 a , b a,b a,b 在 long long 范围内；
- 100 % 100\% 100% 数据 0 < a , b ≤ 1 0 10086 0<a,b\le 10^{10086} 0<a,b≤1010086。
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
int main()
{
char s1[10086], s2[10086], s3[10086];
int a[10086] = { 0 }, b[10086] = { 0 }, c[10086] = { 0 };
scanf("%s", s1);
scanf("%s", s2);
int len1 = strlen(s1);
int len2 = strlen(s2);
int flag1 = strcmp(s1, s2);
int flag2 = 1;
//flag1小于0说明s1小，要大减小，先交换两字符串，结果先输出负号
if ((len1 < len2) || ((len1 == len2) && (flag1 < 0)))
{
flag2 = 0;
strcpy(s3, s1);
strcpy(s1, s2);
strcpy(s2, s3);
}
//重新计算长度，此时len1大于len2
len1 = strlen(s1);
len2 = strlen(s2);
int len3 = len1;
//将字符转换为整数，减去字符0的ASCII码值，转换为对应的整数。
//将数字最低位存在数组最高位
int i = 0;
for (i = 0; i < len1; i++)
{
a[len1 - i] = s1[i] - '0';
}
for (i = 0; i < len2; i++)
{
b[len2 - i] = s2[i] - '0';
}
//逐位减法.如果需要借位，则进行借位处理
//小的加10减大的，并且小的前一位减1
//由于逆序存储，所以数组后以后减1,最终将结果记录在c数组
for (i = 1; i <= len3; i++)
{
if (b[i] > a[i]) {
a[i + 1]--;
a[i] = a[i] + 10;
}
c[i] = a[i] - b[i];
}
//去除前导零,当最高位为0，将该数组的长度递减
while (c[len3] == 0 && len3 > 0)
len3--;
//判断c数组相减是否为0
if (len3 == 0)
printf("0");
//flag2等于0，说明结果为负数
if (flag2 == 0)
printf("-");
for (i = len3; i > 0; i--)
printf("%d", c[i]);
return 0;
}
感谢您的阅读，如有错误望您指正
274
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
