SSE刷题集合
3.10
-
彩球问题： 在一个袋子里装三色彩球，其中红色球有3个，白色球也有3个，黑色球有6个，问当从袋子中取出8个球时，共有多少种可能的方案。编程序将所有可能的方案编号输出在屏幕上。 **输入信息与格式：无 **输出信息与格式： "plan:%d\t red:%d\t white:%d\t black:%d\n"
#include <stdio.h>
int main()
{
int plan = 8;
int red;
int RedTotal = 3;
int WhiteTotal = 3;
int BlackTotal = 6;
int white;
int black;
for (red = 0; red <= RedTotal; red++)
{
for (white = 0; white <= WhiteTotal; white++)
{
for (black = 0; black <= BlackTotal; black++)
{
if (red + white + black == plan)
{
printf("plan:%d\t red:%d\t white:%d\t black:%d\n", plan, red, white, black);
}
}
}
}
}
#include <stdio.h>
#define N 10
int FindMax(int num[], int n, int* pMaxPos);
int main()
{
int num[N];
int maxValue, maxPos, i;
int n = N;
printf("Input %d numbers:\n", n);
for (i = 0; i < n; i++)
{
scanf_s("%d", &num[i]);
}
maxValue = FindMax(num, n, &maxPos);
printf("Max=%d, Position=%d\n", maxValue, maxPos);
}
int FindMax(int num[], int n,int* pMaxPos)
{
int i, max = num[0];
*pMaxPos = 0;//不要忘记最大值下标的初始化，否则第一个数若为最大值则输出错误
for (i = 1; i < n; i++)
{
if (num[i] > max)
{
max = num[i];
*pMaxPos = i;
}
}
return max;
}
下面程序使用指针做函数参数编程实现字符串连接函数strcat()的功能。
#include <stdio.h>
#define N 80
void MyStrcat(char* dstStr, char* srcStr);
main() {
char s[N], t[N];
printf("Input a string:\n");
gets(s);
printf("Input another string:\n");
gets(t);
MyStrcat(s[N], t[N]);
printf("Concatenate results:%s\n", s);
}
void MyStrcat(char* dstStr, char* srcStr) {
while (*dstStr != '\0');
{
dstStr++;
}
while (*srcStr != '\0');
{
dstStr = srcStr;
srcStr++;
dstStr++;
}
}
修改后的程序为:
#include <stdio.h>
#define N 80
void MyStrcat(char* dstStr, char* srcStr);
int main() {
char s[N], t[N];
printf("Input a string:\n");
gets(s);
printf("Input another string:\n");
gets(t);
MyStrcat(s, t);//数组名即为数组的首地址
printf("Concatenate results:%s\n", s);
}
void MyStrcat(char* dstStr, char* srcStr) {
while (*dstStr != '\0')//while后去掉分号
{
dstStr++;
}
while (*srcStr != '\0')
{
*dstStr = *srcStr;//字符赋值
srcStr++;
dstStr++;
}
*dstStr = '\0';//字符串以'\0'作为结束标志
}
用二分法求方程2x^3-4x^2+3x-6=0在(-10, 10)之间的根。
**输入格式要求："%f,%f" 提示信息："请输入x1，x2的值："
**输出格式要求："方程的根=%6.2f\n"
程序的运行示例如下：
请输入x1，x2的值：-10,10
方程的根= 2.00
#include <stdio.h>
#include <math.h>
float Fun(float x);
int main()
{
float x1, x2;
printf("请输入x1,x2的值:");
scanf_s("%f,%f", &x1, &x2);
float fa = Fun(x1);
float fb = Fun(x2);
float x = (x1 + x2) / 2;
while (fabs(Fun(x) - 0) >= 1e-6) //认为找到了根
{
float fx = Fun(x);
if (fx == 0)
{
break;
}
else if (fx * fb < 0)
{
x1 = x;
fa = fx;
}
else
{
x2 = x;
fb = fx;
}
x = (x1 + x2) / 2;
}
printf("方程的根为:%f", x);
}
float Fun(float x)
{
float res = 2 * pow(x, 3) - 4 * pow(x, 2) + 3 * x - 6;
return res;
}
写一个程序读入你的姓名，然后每个字母间加一个空格后输出。例如，姓名John显示为J o h n。
**输入格式要求："%s" 提示信息："请输入你的姓名："
#include <stdio.h>
#include <string.h>
#define N 80
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int main()
{
char name[N];
char temp[2 * N];
printf("请输入你的姓名:");
scanf("%s", name);
int i = 0;
int j = 0;
while (name[i] != '\0') {
temp[j] = name[i];
j++;
temp[j] = ' ';
i++;
j++;
}
temp[j] = '\0';
strcpy(name, temp);
puts(name);
}
//采用指针的方式进行修改
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#define N 80
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int main()
{
char name[N];
printf("请输入你的姓名:");
scanf("%s", name);
char* p = name;
for (int i = strlen(name); i > 0; i--)
{
*(p + 2 * i) = *(p + i);
*(p + 2 * i - 1) = ' ';
}
puts(name);
}
#include <stdio.h>
#include<string.h>
#define MAX_LEN 10
#define N 150
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
void SortString(char* ptr[], int n);
main()
{
int i, n;
char* pStr[N];
char sss[N][MAX_LEN];
printf("How many countries?\n");
scanf("%d", &n);
getchar();//输入n后缓冲区里有回车，为了防止之后将回车读入，所以利用getchar读入回车
printf("Input their names:\n");
for (i = 0; i < n; i++)
{
pStr[i] = sss[i];//指针数组中的每个指针需要初始化
gets(pStr[i]);
}
SortString(pStr, n);
printf("Sorted results:\n");
for (i = 0; i < n; i++)
{
puts(pStr[i]);
}
}
void SortString(char* ptr[], int n)
{
int i, j;
char temp[10];
for (i = 0; i < n - 1; i++)
{
for (j = i + 1; j < n; j++)
{
if (strcmp(ptr[j], ptr[i]) > 0) //ptr为指针数组
{
strcpy(temp, ptr[i]);
strcpy(ptr[i], ptr[j]);
strcpy(ptr[j], temp);
}
}
}
}
从键盘上输入一个4位数的整数n，编写程序将其拆分为两个2位数的整数a和b，计算并输出拆分后的两个数的加、减、乘、除和求余运算的结果。例如n = -2304，设拆分后的两个整数为a和b，则a = -23，b = -4。要求除法运算结果精确到小数点后2位。求余和除法运算需要考虑除数为0的情况，如果拆分后b = 0，则输出提示信息"The second operator is zero!"。
输入提示信息："Input n:"
输入数据格式："%d"
输出数据格式和提示信息：
"sum=%d,sub=%d,multi=%d\n"
"dev=%.2f,mod=%d\n"
"The second operator is zero!\n"
逆序数拆分后的输出格式："%d,%d\n"
程序运行结果示例1：
Input n : 1200↙
12, 0
sum = 12, sub = 12, multi = 0
The second operator is zero!
程序运行结果示例2：
Input n : -2304↙
- 23, -4
sum = -27, sub = -19, multi = 92
dev = 5.75, mod = -3
#include <stdio.h>
#include<string.h>
#define MAX_LEN 10
#define N 150
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int main()
{
printf("Input n:");
int n;
scanf("%d", &n);
int a, b, c, d;
a = n / 1000;
b = (n - 1000 * a) / 100;
c = (n - 1000 * a - 100 * b) / 10;
d = n % 10;
int firstOperator = a * 10 + b;
int secondOperator = c * 10 + d;
int sum = firstOperator + secondOperator;
int sub = firstOperator - secondOperator;
int multi = firstOperator * secondOperator;
printf("%d,%d\n", firstOperator, secondOperator);
printf("sum=%d,sub=%d,multi=%d\n", sum, sub, multi);
if (secondOperator == 0) {
printf("The second operator is zero!");
}
else
{
double dev = (double)firstOperator / secondOperator;
int mod = firstOperator % secondOperator;
printf("dev=%.2f,mod=%d\n", dev, mod);
}
}
#include <stdio.h>
#include<string.h>
#define MAX_LEN 10
#define N 150
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
void Sort(int* p, int n);
int main ()
{
int waybill[6][7];
int i, j;
for (i = 0; i < 7; i++)
{
printf("请输入该日快递员1--6号的运单量:\n");
for (j = 0; j < 6; j++)
{
scanf("%d", &waybill[j][i]);
}
getchar();
}
int sum[6] = {0,0,0,0,0,0};//数组要初始化为0
int bonus[] = { 250,250,150,150,100,100 };
for (i = 0; i < 6; i++)
{
for (j = 0; j < 7; j++) {
sum[i] += waybill[i][j];
}
}
Sort(sum, 6);
printf("一周业绩排行榜：\n");
for (i = 1; i <= 6; i++)
{
printf("第%d名：周送单量：%d件 获得奖金：%d元\n", i, sum[i - 1], bonus[i - 1]);
}
}
void Sort(int* p, int n) {
int i, j;
for (i = 0; i < n - 1; i++)
{
for (j = i + 1; j < n; j++) {
if (*(p + j) > *(p + i))
{
int temp = *(p + j);
*(p + j) = *(p + i);
*(p + i) = temp;
}
}
}
}
定义一个结构体变量（包括年、月、日）。计算该日在本年中是第几天？注意闰年问题。
输入格式要求："请输入日期（年，月，日）\n"
输出格式要求："%d月%d日是%d年的第%d天\n"
程序的运行示例如下：
请输入日期（年，月，日）
1990,2,14↙
2月14日是1990年的第45天。
#include <stdio.h>
#include<string.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
struct Date
{
int year;
int month;
int day;
};
int main()
{
printf("请输入日期（年，月，日）\n");
struct Date date;
scanf("%d,%d,%d", &date.year, &date.month, &date.day);
int days[2][12] = { {31,28,31,30,31,30,31,31,30,31,30,31},{31,29,31,30,31,30,31,31,30,31,30,31} };
int leap = ((date.year % 4 == 0 && date.year % 100 != 0) || date.year % 400 == 0) ? 1 : 0;
int i;
int day1 = 0;
for (i = 0; i < date.month - 1; i++)
{
day1 += days[leap][i];
}
day1 += date.day;
printf("%d月%d日是%d年的第%d天\n", date.month, date.day, date.year, day1);
}
#include <stdio.h>
int main()
{
int i,j,k;
for (i = 1; i <= 4; i++)
{
for (j = 1; j <= 4 - i; j++) {
printf(" ");
}
for (k = 0; k < 6; k++)
{
printf("*");
}
printf("\n");
}
}
- 11.利用穷举法找到最大公约数
按如下函数原型，采用穷举法编写计算最大公约数的函数Gcd()，在主函数中调用该函数计算并输出从键盘任意输入的两整数的最大公约数。穷举法的基本思想是：先找到a和b中的较小者t，然后从t开始逐次减1尝试每种可能，即检验t到1之间的所有整数，第一个满足公约数条件的t，就是a和b的最大公约数。
/* 函数功能：计算a和b的最大公约数，输入负数时返回-1 */
int Gcd(int a, int b)
#include <stdio.h>
#include<string.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int God(int a, int b);
int main()
{
int a, b;
printf("Input a,b:");
scanf("%d,%d", &a, &b);
int res = God(a, b);
if (res == -1)
{
printf("Input number should be positive!\n");
}
else
{
printf("Greatest Common Divisor of %d and %d is %d \n", a, b, res);
}
}
int God(int a,int b)
{
int res;
if (a < 0 || b < 0)
{
return -1;
}
else
{
int t = a < b ? a : b;
while (t != 0)
{
if (a % t == 0 && b % t == 0) {
res = t;
break;
}
t--;
}
}
return res;
}
3.11
一辆卡车违反了交通规则，撞人后逃逸。现场有三人目击该事件，但都没有记住车号，只记住车号的一些特征。甲说：车号的前两位数字是相同的；乙说：车号的后两位数字是相同的，但与前两位不同；丙是位数学家，他说：4位的车号正好是一个整数的平方。现在请根据以上线索帮助警方找出车号以便尽快破案。
**输出格式要求："The number is:%d\n"
#include <stdio.h>
#include<string.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int main()
{
int num;
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
if (i != j) {
num = 1000 * i + 100 * i + 10 * j + j;
for (int k = 3; k * k <= num; k++)//最小车牌为0011
{
if (num == k * k) {
printf("The number is:%d\n", num);
}
}
}
}
}
}
-
- 定义结构体输出学生信息
#include <stdio.h>
#include<string.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
#define N 80
void Input(struct student students[], int n);
void Print(struct student* p, int n);
struct student Search(struct student students[], int n, char name[]);
struct student {
char name[N];
char studentID[N];
char jiguan[N];
char ID[N];
int age;
char address[N];
char sex;
char phone[N];
};
int main()
{
struct student students[N];
int n;
printf("请输入学生的个数:");
scanf("%d", &n);
Input(students, n);
Print(students, n);
char searchName[N];
printf("\n请输入想要查找的学生姓名:");
scanf("%s", searchName);
int* flag;
*flag = 0;
struct student stu = Search(students, n, searchName, flag);
if (*flag == 1)
{
printf("%-8s%-12s%-10s%-20s%-4d%-10s%-3c%-10s\n", stu.name, stu.studentID, stu.jiguan, stu.studentID, stu.age, stu.address, stu.sex, stu.phone);
}
else
{
printf("没有该学生的信息！\n\n");
}
}
void Input(struct student students[],int n)
{
for (int i = 0; i < n; i++)
{
printf("请输入第%d个学生的信息:\n", i +1);
printf("姓名:\t");
getchar();
scanf("%s",&students[i].name);
getchar();
printf("学号:\t");
scanf("%s", &students[i].studentID);
getchar();
printf("籍贯:\t");
scanf("%s", &students[i].jiguan);
getchar();
printf("身份证号:\t");
scanf("%s", &students[i].ID);
getchar();
printf("年龄:\t");
scanf("%d", &students[i].age);
getchar();
printf("家庭住址:\t");
scanf("%s", &students[i].address);
getchar();
printf("性别(M/F):\t");
scanf("%c", &students[i].sex);
getchar();
printf("电话:\t");
scanf("%s", &students[i].phone);
printf("\n");
}
}
void Print(struct student *p,int n)
{
printf("姓名学号 籍贯 身份证号 年龄地址 性别电话\n");
for (int i = 0; i < n; i++)
{
printf("%-8s%-12s%-10s%-20s%-4d%-10s%-3c%-10s\n", p->name, p->studentID, p->jiguan, p->ID, p->age, p->address, p->sex, p->phone);
p++;
}
}
struct student Search(struct student students[], int n,char name[],int *flag)
{
for (int i = 0; i < n; i++)
{
if (strcmp(students[i].name, name) == 0)
{
*flag = 1;
return students[i];
}
}
}
创建动态链表并打印链表内容。要求通过键盘读入学生的学号和分数，当输入的学号为0时表示链表创建结束，并将读入的学生学号和成绩打印输出。下面程序中存在比较隐蔽的错误，请通过分析和调试程序，发现并改正程序中的错误。改错时不能改变程序原有的意图。
注意：将修改后的完整的源程序写在答题区内。
创建动态链表并打印链表内容。要求通过键盘读入学生的学号和分数，当输入的学号为0时表示链表创建结束，并将读入的学生学号和成绩打印输出。下面程序中存在比较隐蔽的错误，请通过分析和调试程序，发现并改正程序中的错误。改错时不能改变程序原有的意图。
注意：将修改后的完整的源程序写在答题区内。
#include <stdio.h>
#define SIZE sizeof(struct node)
struct node
{
long num;
float score;
struct node *next;
}
int main()
{
int n = 0;
struct node *head = NULL, *p1, *p2;
p1 = p2 = (struct node*)malloc(SIZE);
printf("Input %d node data:\n", n + 1);
scanf("%d%f", &p1->num, &p1->score);
while (p1->num != 0)
{
if (++n == 1)
head = p1;
else
p2->next = p1;
p1 = p2;
p1 = (struct node*)malloc(SIZE);
printf("Input %d node data:\n", n + 1);
scanf("%d%f", &p1->num, &p1->score);
}
free(p1);
printf("Prit list:\n");
p2->next = NULL;
if (head != NULL)
{
p2=head;
while (p1 != NULL)
{
printf("num:%d\tscore:%.2f\n", p1->num, p1->score);
p1 = p1->next;
}
}
return 0;
}
- 改错后：
#include <stdio.h>
#include<stdlib.h>
#define SIZE sizeof(struct node)
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
struct node
{
long num;
float score;
struct node* next;
};//结构体的声明以;号作为结束
int main()
{
int n = 0;
struct node* head = NULL, * p1, * p2;
p1 = p2 = (struct node*)malloc(SIZE);
printf("Input %d node data:\n", n + 1);
scanf("%ld,%f", &p1->num, &p1->score);//注意要用取地址符，因为p1->num指的是结构体成员变量的值
while (p1->num != 0)
{
if (++n == 1)
head = p1;
else
p2->next = p1;
p2 = p1;//p2指向p1的位置
p1 = (struct node*)malloc(SIZE);//重新向p1中输入数据
printf("Input %d node data:\n", n + 1);
scanf("%d,%f", &p1->num, &p1->score);//输入的时候以逗号作为分隔
}
free(p1);
printf("Prit list:\n");
p2->next = NULL;//指针的结尾变为NULL
if (head != NULL)
{
p2 = head;//p2指向头指针来遍历整个链表,p1已经被free不能再使用
while (p2 != NULL)
{
printf("num:%d\tscore:%.2f\n", p2->num, p2->score);
p2 = p2->next;
}
}
free(p2);//别忘记malloc的p2 也要free
return 0;
}
超长正整数的加法
请设计一个算法完成两个超长正整数的加法。
**输出格式要求：" s1=" " s2=" "s1+s2="
程序运行示例如下：
3488934387589
374849389
s1=3488934387589
s2=374849389
s1+s2=3489309236978
- 16.计算三角形面积
#include <stdio.h>
#include <math.h>
#include<stdlib.h>
#define SIZE sizeof(struct node)
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int main()
{
printf("Input a,b,c:");
float a, b, c;
scanf("%f,%f,%f", &a, &b, &c);
double s = (a + b + c) / 2;
double area = sqrt(s * (s - a) * (s - b) * (s - c));
printf("area = %.2f\n", area);
}
#include <stdio.h>
#define N 40
int ReadScore(int income[], long num[]);
int BinSearch(long num[], long x, int n);
int main()
{
int income[N], n, pos;
long num[N], x;
n = ReadScore(income, num);
printf("Total number is %d\n", n);
printf("Input the searching ID:");
scanf("%d", &x);
pos = BinSearch(num, x, n);
if (pos != -1)
{
printf("income = %d\n", income[pos]);
}
else
{
printf("Not found!\n");
}
return 0;
}
int ReadScore(int income[], long num[])
{
int i ;
do
{
i++;
printf("Input person's ID and income:");
scanf("%d%d", num[i], income[i]);
} while (num[i] >0 || income[i] >= 0);
return i;
}
int BinSearch(long num[], long x, int n)
{
int low, high, mid;
low = 0;
high = n ;
while (low < high)
{
mid = (high + low) / 2;
if (x > num[mid])
{
low = mid + 1;
}
else if (x < num[mid])
{
high = mid - 1;
}
else
{
return (mid);
}
}
return(-1);
}
- 改错后：
#include <stdio.h>
#define N 40
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int ReadScore(int income[], long num[]);
int BinSearch(long num[], long x, int n);
int main()
{
int income[N], n, pos;
long num[N], x;
n = ReadScore(income, num);
printf("Total number is %d\n", n);
printf("Input the searching ID:");
scanf("%d", &x);
pos = BinSearch(num, x, n);
if (pos != -1)
{
printf("income = %d\n", income[pos]);
}
else
{
printf("Not found!\n");
}
return 0;
}
int ReadScore(int income[], long num[])
{
int i = 0;//i未初始化
do
{
i++;
printf("Input person's ID and income:");
scanf("%d %d", &num[i], &income[i]);//scanf 向变量的内存中输入值
} while (num[i] > 0 && income[i] >= 0); // 都>=0的情况下进入循环
return i - 1; //总数应该为i - 1因为第一个数据存在了num[1]中 最后一个数据为不合法数据，所以为i-1
}
int BinSearch(long num[], long x, int n)
{ //int BinSearch(long num[], long x, int n)
{
int low, high, mid;
low = 1;//因为索引是从1开始存的
high = n;
while (low <= high)//二分查找 进入循环的条件是low <= high
{
mid = (high + low) / 2;
if (x > num[mid])
{
low = mid + 1;
}
else if (x < num[mid])
{
high = mid - 1;
}
else
{
return mid;
}
}
return -1;
}
- 18.将一个字符串中的元音字母复制到另一个字符串
#include <stdio.h>
#include <string.h>
#define N 40
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int main()
{
char str[N];
printf("\n输入字符串：");
gets(str);
int len = strlen(str);
int i = 0;
int j = 0;
char strcopy[N];
while (str[i] != '\0')
{
if (str[i] == 'e' || str[i] == 'o') {
strcopy[j] = str[i];
i++;
j++;
}
i++;
}
strcopy[j] = '\0'; //别忘记了字符串的结尾要添加上‘\0’
printf("\n字符串中的元音字母是%s", strcopy);
}
药品的总数量有total克，total为整数类型，其数值由用户从键盘输入。total数量的药品用天平来称量，砝码只有1g, 2g, 5g三种，若要求加的砝码总数为30个，有几种不同的加法？用穷举法编程求解，先输出各个方案，然后输出方案的总数。
**输入提示信息和格式：无
**输入格式要求：
scanf("%d", &total);
**输出方案的格式："%2d,%2d,%2d\n"
**输出方案总数的格式："%d\n"
例如：输入 50↙
则，程序输出结果如下：
10,20, 0↙
13,16, 1↙
16,12, 2↙
19, 8, 3↙
22, 4, 4↙
25, 0, 5↙
6↙
#include <stdio.h>
int main()
{
int total;
scanf("%d", &total);
int i, j, k;
int count = 0;
for (i = 0; i < total; i++)
{
for (j = 0; j < total / 2; j++) {
for (k = 0; k < total / 5; k++)
{
if ((i + j + k == 30) && (i * 1 + j * 2 + k * 5 == total))
{
count++;
printf("%2d,%2d,%2d\n", i, j, k);
}
}
}
}
printf("%d\n", count);
}
对输入的8个字符串(每个字符串长度不超过20)按照字典顺序进行排序并输出。不限定排序方法，不能使用goto语句。
输入输出格式：
输入：%s
输出：%s\n
输入：多个字符串用空格分隔
输出：排序好的字符串，每行一个字符串，末尾有空行。
输入输出样例：
输入：
diankuang liuxu sui fengwu qingbo taohua zhu shuiliu
输出：
diankuang
fengwu
liuxu
qingbo
shuiliu
sui
taohua
zhu
#include <stdio.h>
#include <string.h>
void Sort(char str[][20], int n);
int main()
{
char str[8][20];
int i;
for (i = 0; i < 8; i++)
{
scanf("%s", str[i]);
}
Sort(str, 8);
for (i = 0; i < 8; i++)
{
printf("%s\n", str[i]);
}
}
void Sort(char str[][20],int n)
{
char temp[20];
for (int i = 0; i < n - 1; i++)
{
for (int j = i + 1; j < n; j++)
{
if (strcmp(str[i],str[j]) > 0)
{
strcpy(temp, str[i]);
strcpy(str[i], str[j]);
strcpy(str[j], temp);
}
}
}
}
- 21：重点题
编程用链表方法实现堆栈数据结构。堆栈（Strack）是指这样一段内存，它可以理解为一个筒结构，先放进筒中的数据被后放进筒中的数据“压住”，只有后放进筒中的数据都取出后，先放进去的数据才能被取出，称为“后进先出”。堆栈的长度可随意增加。堆栈结构可用链表实现。设计一个链表结构需包含两个成员：一个存放数据，一个为指向下一个节点的指针。当每次有一个新数据要放入堆栈时，称为“压入堆栈”，这时动态建立一个链表的节点，并连接到链表的结尾；当每次从堆栈中取出一个数据时，称为“弹出堆栈”，这意味着从链表的最后一个节点中取出该节点的数据成员，同时删除该节点，释放该节点所占的内存。
请将下面程序补全。
#include <stdio.h>
#include <string.h>
#define N 40
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
typedef struct stack
{
int data;
struct stack* next;
} STACK;
STACK* head, * pr;
int nodeNum = 0; /* 堆栈节点数寄存器 */
STACK* CreateNode(int num);
STACK* PushStack(int num);
int PopStack(void);
int main()
{
int pushNum[5] = { 111, 222, 333, 444, 555 }, popNum[5], i;
for (i = 0; i < 5; i++)
{
PushStack(pushNum[i]);
printf("Push %dth Data:%d\n", i + 1, pushNum[i]);
}
for (i = 0; i < 5; i++)
{
popNum[i] = PopStack();
printf("Pop %dth Data:%d\n", 5 - i, popNum[i]);
}
return 0;
}
/* 函数功能：生成一个新的节点，并为该节点赋初值，返回指向新的节点的指针 */
STACK* CreateNode(int num)
{
STACK* p;
p = (STACK*)malloc(sizeof(STACK));
if (p == NULL) {
printf("No enough memory!\n");
exit(0);
}
p->next = NULL;
p->data = num;
return p;
}
/* 函数功能：将整型变量num的值压入堆栈，返回指向链表新节点的指针 */
STACK* PushStack(int num)
{
if (nodeNum == 0) /* 若为首个节点，则保留该节点地址在head中*/
{
head = CreateNode(num);
pr = head;
nodeNum++;
}
else//新建节点连到链表的结尾处
{
pr->next = CreateNode(num);
pr = pr->next;
nodeNum++;
}
return pr;
}
/* 函数功能：将当前栈顶的数据弹出堆栈，返回从堆栈中弹出的数据 */
int PopStack(void)
{
STACK* p = head;
int result;
while (p->next != NULL)
{
pr = p;//记录最后一个节点的前一个节点的地址
p = p->next;
}
nodeNum--;
pr->next = NULL;
result = p->data;
free(p);
return result;
}
- 22.：重点题
满足特异条件的数列。输入m和n（20≥m≥n≥0），求出满足以下方程式的正整数数列i1,i2,…,in，使得i1+i2+…+in=m，且i1≥i2≥…≥in。例如：
当n=4，m=8时，将得到如下5个数列：
5 1 1 1 4 2 1 1 3 3 1 1 3 2 2 1 2 2 2 2
**输入格式要求："%d" 提示信息："Please enter requried terms (<=10):"
" their sum:"
**输出格式要求："There are following possible series:\n" "[%d]:" "%d"
程序运行示例1：
Please enter requried terms (<=10): 4 8
their sum:There are following possible series:
[1]:5111
[2]:4211
[3]:3311
[4]:3221
[5]:2222
程序运行示例2：
Please enter requried terms (<=10):4 10
their sum:There are following possible series:
[1]:7 1 1 1
[2]:6 2 1 1
[3]:5 3 1 1
[4]:4 4 1 1
[5]:5 2 2 1
[6]:4 3 2 1
[7]:3 3 3 1
[8]:4 2 2 2
[9]:3 3 2 2
#include <stdio.h>
#include <string.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
#define NUM 10 //允许分解的最大元素数量
int main()
{
int i[NUM];//记录分解出的数值的数组
int sum, n, total, k, flag, count;
count = 0;
printf("Please enter requried terms (<=10):");
scanf("%d %d", &n, &total);
sum = 0;//从后往前k个元素的和
k = n;//从后往前正在处理的元素下标
i[n] = 1;//将最后一个元素的值置为1作为初始值
printf("There are following posiible series:\n");
while (1)
{
if (sum + i[k] < total) {//若后k位的和小于指定的total
if (k <= 1)//要处理的是第一个元素
{
i[1] = total - sum;
flag = 1;
}
else
{
sum += i[k--];
i[k] = i[k + 1];
continue;//继续向前处理其他元素
}
}
else if (sum + i[k] > total || k != 1)//若和已超过total或不是第一个元素
{
sum -= i[++k];
flag = 0;//k向后退一个元素
}
else
{
flag = 1;/*sum + i[k] = total && k = 1 则设置flag 标记*/
}
if (flag)
{
printf("[%d]:", ++count);
for (flag = 1; flag <= n; flag++)
{
printf("%d", i[flag]);
}
printf("\n");
}
if (++k > n)//已经修改到最后一个元素了，跳出循环
break;
sum -= i[k];//要修改i[k]，重新计算sum
i[k]++;
}
}
3.12
某班期末考试科目为数学（MT）、英语（EN）和物理（PH），有最多不超过40人参加考试。请编程计算：（1）每个学生的总分和平均分；（2）每门课程的总分和平均分。
**输入格式要求："%d" "%ld"(学号) 提示信息："Input the total number of the students(n<40):" "Input student’s ID and score as: MT EN PH:\n"
**输出格式要求："Counting Result:\n" "Student’s ID\t MT \t EN \t PH \t SUM \t AVER\n" "%12ld\t"(打印学号) "%4d\t"（打印每门课成绩）"%4d\t%5.1f\n"（打印总分和平均分） "SumofCourse \t" "%4d\t"(打印每门课的总分) "\nAverofCourse\t" "%4.1f\t"(每门课的平均分)
#include <stdio.h>
#define N 40
void CountSum(struct student stu[], int sum[], int n);
struct student {
long ID;
int MT;
int EN;
int PH;
};
int main()
{
int n;
printf("Input the total number of the students(n < 40):");
scanf("%d", &n);
getchar();
printf("Input student's ID and score as:MT EN PH:\n");
int sum[N];
double ave[N];
struct student students[N];
for (int i = 0; i < n; i++)
{
scanf("%d %d %d %d", &students[i].ID, &students[i].MT, &students[i].EN, &students[i].PH);
getchar();
}
CountSum(students, sum, n);
for (int i = 0; i < n; i++)
{
ave[i] = (double)sum[i] / 3;
}
int SumofCourse[3] = { 0,0,0 };
for (int i = 0; i < n; i++)
{
SumofCourse[0] += students[i].MT;
}
for (int i = 0; i < n; i++)
{
SumofCourse[1] += students[i].EN;
}
for (int i = 0; i < n; i++)
{
SumofCourse[2] += students[i].PH;
}
double AverofCourse[3];
for (int i = 0; i < 3; i++)
{
AverofCourse[i] = (double)SumofCourse[i] / n;
}
printf("Conuting Result:\n");
printf("Student’s ID\t MT \t EN \t PH \t SUM \t AVER\n");
for (int i = 0; i < n; i++)
{
printf("%12ld\t,%4d\t,%4d\t,%4d\t,%4d\t,%5.1f\n", students[i].ID, students[i].MT, students[i].EN, students[i].PH, sum[i], ave[i]);
}
printf("SumofCourse \t");
for (int i = 0; i < 3; i++)
{
printf("%4d\t", SumofCourse[i]);
}
printf("\n");
printf("AverofCourse\t");
for (int i = 0; i < 3; i++)
{
printf("%4.1f\t", AverofCourse[i]);
}
}
void CountSum(struct student stu[],int sum[],int n)
{
for (int i = 0; i < n; i++)
{
sum[i] = 0;
sum[i] += stu[i].MT;
sum[i] += stu[i].EN;
sum[i] += stu[i].PH;
}
}
- 24.关于字符串的改错
#include <stdio.h>
#include <string.h>
main( )
{
int cases, sum[10], i, max;
char str[1000];
scanf("%d", case);
while (cases > 0)
{
scanf("%c", str);
for( i = 0; i < 10; i++)
sum[i] = 0;
for(i < 0; i < strlen(str); i++)
++sum[str[i] – 0];
max = 0;
for (i = 1; i < 10; i++)
if(sum[i] >＝ sum[max]) max = i;
printf("%c %d\n", max + '0', sum[0]);
cases --;
}
}
#include <stdio.h>
#include <string.h>
main()
{
int cases, sum[10], i, max;
char str[1000];
scanf("%d", &cases);//读入的是内存的地址
while (cases > 0)
{
scanf("%s", str);//输入的是一行字符，应该存在字符串中
for (i = 0; i < 10; i++)
sum[i] = 0;
int len = strlen(str);
for (i = 0; i < len; i++)
sum[str[i] - '0']++;//减去的是字符0，因为是ASCII码值 之间的比较
max = 0;
for (i = 1; i < 10; i++)
if (sum[i] > sum[max]) max = i;//因为多个字符次数相同输出ASCII较小的，所以只用大于
printf("%c %d\n", max + '0', sum[max]);
cases--;
}
}
- 25.穷举法求最大公约数
#include <stdio.h>
#include <string.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int God(int a, int b);
int main()
{
printf("Input a,b：");
int a, b;
scanf("%d,%d", &a, &b);
int t = God(a, b);
if (t == -1)
{
printf("Input number should be positive\n");
}
else
{
printf("Greatest Common Divisor of %d and %d is %d\n", a, b, t);
}
}
int God(int a, int b)
{
int t = a < b ? a : b;
if (a <= 0 || b <= 0)
{
return -1;
}
for (; t > 0; t--)
{
if (a % t == 0 && b % t == 0)
break;
}
return t;
}
- 26.数组旋转
- 重点：
b[j][M - 1 - i] = a[i][j]
- 重点：
数组旋转：
编写程序将如下的一个固定大小的整数数组a[2][3]向右旋转90度，构成新的数组b[3][2]，并打印出来。
例如：a=1 2 3
4 5 6
旋转后
b=4 1
5 2
6 3
**输入提示信息："Array a:\n"
**输入格式要求："%d"
**输出格式要求： "Array b:\n"
输出时每个元素的大小为"%4d"
程序运行示例如下：
Array a:
1 2 3
4 5 6
Array b:
4 1
5 2
6 3
#include <stdio.h>
#define M 2
#define N 3
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
main()
{
int a[M][N] = { {1,2,3},{4,5,6} };
int b[N][M], i, j;
printf("Array a:\n");
for (i = 0; i < M; i++)
{
for (j = 0; j < N; j++)
{
printf("%4d", a[i][j]);
b[j][M - 1 - i] = a[i][j]; //把行旋转到列上
}
printf("\n");
}
printf("Array b:\n");
for (i = 0; i < N; i++)
{
for (j = 0; j < M; j++)
{
printf("%4d", b[i][j]);
}
printf("\n");
}
}
- 27.用二维数组作函数参数，编程计算并输出n*n阶矩阵的转置矩阵
- 注意转置的时候是行列互换，两个整型变量的交换，需要借助临时变量temp
- 另外注意j应该从i开始
#include <stdio.h>
#define N 10
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
void Transpose(int a[][N], int n);
void InputMatrix(int a[][N], int n);
void PrintMatrix(int a[][N], int n);
int main()
{
int n;
printf("Input n:\n");
scanf("%d", &n);
int a[N][N];
InputMatrix(a, n);
printf("Array is:\n")
PrintMatrix(a, n);
Transpose(a, n);
printf("Transpose Array is :\n");
PrintMatrix(a, n);
}
void Transpose(int a[][N],int n)
{
for (int i = 0; i < n; i++)
{
for (int j = i; j < n; j++)
{
int temp = a[i][j];
a[i][j] = a[j][i];
a[j][i] = temp;
}
}
}
void InputMatrix(int a[][N],int n)
{
int i, j;
printf("Input %d * %d matrix:\n", n, n);
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
scanf("%d", &a[i][j]);
}
}
}
void PrintMatrix(int a[][N], int n) {
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
printf("%d\t", a[i][j]);
}
printf("\n");
}
}
3.13
- 28.通过遍历整个数组，记录最大值的索引和最小值的索引即可，最后进行交换
从键盘输入n个整数，用函数编程实现最大值和最小值的交换，并打印结果。
**输入格式要求："%d"
提示信息："Input n(n<=10):" "Input %d numbers:"
**输出结果格式要求："%5d"
提示信息："Exchange results:"
#include <stdio.h>
#define N 10
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int main()
{
int nums[N];
int n;
printf("Input n(n<=10)：");
scanf("%d", &n);
printf("Input %d numbers:", n);
for (int i = 0; i < n; i++) {
scanf("%d", &nums[i]);
}
int max = nums[0];
int min = nums[0];
int minIndex = 0;
int maxIndex = 0;
for (int i = 1; i < n; i++) {
if (nums[i] > max)
{
max = nums[i];
maxIndex = i;
}
if (nums[i] < min)
{
min = nums[i];
minIndex = i;
}
}
nums[maxIndex] = min;
nums[minIndex] = max;
printf("Exchange results:");
for (int i = 0; i < n; i++)
{
printf("%d,", nums[i]);
}
}
从键盘输入每小时登录网络的用户数到一个有24个整型元素的数组中。写一个程序以如下格式显示一个报告：
时间 登录人数 所占比例
0:00 – 1:00 1 0.3
1:00 – 2:00 2 0.7
…
10:00 - 11:00 27 9.0
11:00 - 12:00 28 9.3
…
23:00 - 24:00 8 2.7
最大登录人数28发生在11：00到12：00之间
最小登录人数 1发生在 0：00到 1：00之间(两个时间段登录人数相同时，取排在前面的时间)
注意：比例后面的%省略，无需输出%，只输出%前面的数即可。
**输入格式要求："%d" 提示信息："请输入在%d:00和%d:00之间登录的用户数："
**输出格式要求：
" 时间 登录人数 所占比例\n"
"%2d:00 - %2d:00 %15d %25.1f\n"
"最大登录人数%d发生在%2d：00到%2d：00之间\n"
"最小登录人数%d发生在%2d：00到%2d：00之间\n"
#include <stdio.h>
#define N 10
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int main()
{
int nums[24];
for (int i = 0; i < 24; i++)
{
printf("请输入在%d:00和%d:00之间登录的用户数：", i, i + 1);
scanf("%d", &nums[i]);
}
int sum = 0;
for (int i = 0; i < 24; i++)
{
sum += nums[i];
}
double rate[24];
for (int i = 0; i < 24; i++)
{
rate[i] = (double)nums[i] / sum;
}
int maxIndex = 0;
int minIndex = 0;
for (int i = 1; i < 24; i++)
{
if (nums[i] > nums[maxIndex]) {
maxIndex = i;
}
if (nums[i] < nums[minIndex])
{
minIndex = i;
}
}
printf(" 时间 登录人数 所占比例\n");
for (int i = 0; i < 24; i++)
{
printf("%2d:00 - %2d:00 %15d %25.1f\n", i, i + 1, nums[i], rate[i] * 100);
}
printf("最大登录人数%d发生在%2d：00到%2d：00之间\n", nums[maxIndex], maxIndex, maxIndex + 1);
printf("最小登录人数%d发生在%2d：00到%2d：00之间\n", nums[minIndex], minIndex, minIndex + 1);
}
- 29.程序模拟运算器
程序模拟简单运算器的工作：输入一个算式（没有空格），遇等号'='说明输入结束，输出结果。假设计算器只能进行加、减、乘、除运算，运算数和结果都是整数，4种运算符的优先级相同，按从左到右的顺序计算。例如输入"1+2*10-10/2="后，输出10。
**输出格式要求："%d" 出错提示信息："错误的运算符：%c"
程序运行示例如下：
1+2*10-10/2= <===此行为输入
10 <===此行为输出
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int num, num1, op;
char ch;
num = 0;
num1 = 0;
op = '+';
do
{
ch = getchar();
if (ch >= '0' && ch <= '9')
{
num1 = num1 * 10 + (ch - '0');
}
else
{
if (op == '+')
{
num = num + num1;
}
else if (op == '-')
{
num = num - num1;
}
else if (op == '*')
{
num = num * num1;
}
else if (op == '/')
{
num = num / num1;
}
else
{
printf("错误的运算符：%c", op);
exit(0);
}
op = ch;
num1 = 0;
}
}
while (ch != '=');
printf("%d", num);
return 0;
}
- 30：计算学生成绩
在主函数中从键盘输入某班学生某门课程的成绩(已知班级人数最多不超过40人，具体人数由键盘输入),试编程计算其平均分，并计算出成绩高于平均分的学生的人数。
要求：调用函数aver()，计算n名学生的平均成绩返回给主函数，然后在主函数中输出学生的平均成绩。
函数原型：float aver(int score[],int n);
***输入提示信息：无
***输入格式：输入学生人数用"%d"，输入学生成绩用"%d"
***输出平均成绩提示信息和格式："Average score is %10.2f\n"
***输出平均分以上的学生人数提示信息和格式:"The number of students in more than average %d\n"
注：（1）不能使用指针、结构体、共用体、文件、goto、枚举类型进行编程。
（2）用纯C语言编程，所有变量必须在第一条可执行语句前定义。
#include <stdio.h>
#define N 40
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
float aver(int score[], int n);
int main()
{
int score[N];
int num;
scanf("%d", &num);
for (int i = 0; i < num; i++)
{
scanf("%d", &score[i]);
}
float res = aver(score, num);
printf("Average score is %10.2f\n", res);
int overaver = 0;
for (int i = 0; i < num; i++)
{
if(score[i] > res)
{
overaver++;
}
}
printf("The number of students in more than average %d\n", overaver);
}
float aver(int score[],int n)
{
int sum = 0;
for (int i = 0; i < n; i++)
{
sum += score[i];
}
return (float)sum / n;
}
- 30.改错
程序改错-3
从键盘任意输入两个符号各异的整数，直到输入的两个整数满足要求为止，然后打印这两个数。请通过测试找出下面这个程序存在的问题（不止一个问题哦），并改正。同时用下面给出的运行结果示例检查修改后的程序。
#include <stdio.h>``int` `main()``{`` ``int` `x1, x2;`` ``do`` ``{`` ``printf``(``"Input x1, x2:"``);`` ``scanf``(``"%d,%d"``, &x1, &x2);`` ``}`` ``while` `(x1 * x2 > 0);`` ``printf``(``"x1=%d,x2=%d\n"``, x1, x2);`` ``return` `0;``}
程序正确的运行结果示例：
Input x1, x2:
a,s↙
Input x1, x2:
a,1↙
Input x1, x2:
2,s↙
Input x1, x2:
1,2↙
Input x1, x2:
-1,-2↙
Input x1, x2:
0,3↙
Input x1, x2:
1.2,3.4↙
Input x1, x2:
1.2,5↙
Input x1, x2:
-1,3↙
x1=-1,x2=3
输入格式: "%d,%d"
输入提示信息："Input x1, x2:\n"
输出格式："x1=%d,x2=%d\n"
#include <stdio.h>
#define N 40
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int main()
{
int x1, x2;
int ret;
char ch;
do
{
printf("Input x1, x2:\n");
scanf("%d,%d", &x1, &x2);
while(getchar() != '\n')
continue;//通过清理缓冲区
} while (x1 * x2 >= 0);
printf("x1=%d,x2=%d\n", x1, x2);
return 0;
}
- 31
输入一个整形数，然后按汉语的习惯，将其读出来并输出。如1052，读作：一千零五十二。
输入样例：
1052
输出样例：
一千零五十二
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
const char shuzi[10][4] = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
const char weishu[5][4] = { "十", "百", "千", "万", "亿" };
//储存中文数字
void read(char* str);
int count = 0, len;
int main()
{
char str[11] = { '0' };//初始化字符串
scanf("%s", str + 1);
len = strlen(str);
read(str + 1);
return 0;
}
void read(char* str)
{
if (strlen(str) == 0)
{
return;
}
else
{
switch (str[0])//分别判断每一位的读法
{
case '0':
if (str[1] != '0' && strlen(str) >= 2)
printf("%s", shuzi[0]);
//0的情况比较特殊，多个0位只读一遍
break;
case '1':
if (strlen(str) != 2 && strlen(str) != 6)
printf("%s", shuzi[1]);
else if (*(str - 1) != '0')
printf("%s", shuzi[1]);
break;
case '2':
printf("%s", shuzi[2]);
break;
case '3':
printf("%s", shuzi[3]);
break;
case '4':
printf("%s", shuzi[4]);
break;
case '5':
printf("%s", shuzi[5]);
break;
case '6':
printf("%s", shuzi[6]);
break;
case '7':
printf("%s", shuzi[7]);
break;
case '8':
printf("%s", shuzi[8]);
break;
case '9':
printf("%s", shuzi[9]);
break;
default:
return;
}
switch (strlen(str))
{
case 9:
printf("%s", weishu[4]);
break;
case 8:
if (str[0] != '0')
printf("%s", weishu[2]);
break;
case 7:
if (str[0] != '0')
printf("%s", weishu[1]);
break;
case 6:
if (str[0] != '0')
printf("%s", weishu[0]);
break;
case 5:
break;
case 4:
if (str[0] != '0')
printf("%s", weishu[2]);
break;
case 3:
if (str[0] != '0')
printf("%s", weishu[1]);
break;
case 2:
if (str[0] != '0')
printf("%s", weishu[0]);
break;
case 1:
break;
default:
return;
}
count++;
if ((len - count == 5) && (len > 4))
printf("%s", weishu[3]);
read(++str);//继续判断下一位
}
}
- 32
有这样一个小游戏，你可以按照下面的步骤一步一步地完成：
（1）你一般一个星期中哪一天最忙呢？如果是星期一，则选1，如果是星期二，则选2，依此类推，从1、2、3、4、5、6、7中选一个数字；
（2）将这个数字乘2；
（3）如果你是男生，则将得到的结果加4，如果你是女生，则将得到的结果加8；
（4）将得到的结果乘以50；
（5）如果你是在1~6月出生，则将得到的结果加2002，如果你是在7~12月出生，则将得到的结果加3002；
（6）将得到的结果减去你出生的年份（例如1988）；
（7）取结果的后两位，得到一个两位数，将这个两位数加10。
你一定会感到惊奇，最后得到的结果竟然是你现在的年龄。请编程实现上述游戏的计算过程，并输出年龄的计算结果。(要求对不符合要求的输入提示"Invalid input." 并不再继续执行以下程序)
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int guessAge(int busyday, char gender, char birthday[]);
int main()
{
int day;
char gender;
char birthday[20];
printf("Please input your busiest day.\n");
scanf("%d", &day);
if (day > 7 || day < 1) {
printf("Invalid input.\n");
exit(0);
}
getchar();
printf("Please input your gender.\n");
scanf("%c", &gender);
if (gender != 'm' && gender != 'f') {
printf("Invalid input.\n");
exit(0);
}
getchar();
printf("Please input your birthday.\n");
scanf("%s", birthday);
int age = guessAge(day, gender, birthday);
if (age == -1) {
printf("Invalid input.\n");
}
else {
printf("Your age is:%d\n", age);
}
}
int guessAge(int busyday,char gender,char birthday[])
{
if (busyday > 7 || busyday < 1)
return -1;
if (gender != 'f' && gender != 'm')
return - 1;
int temp = busyday * 2;
int res;
if (gender == 'm')
{
temp += 4;
}
if (gender == 'f')
{
temp += 8;
}
temp *= 50;
int year, month, day;
char str[3][10];//输入的是字符串如何获得年月日
int i = 0;
int j = 0;
int count = 0;
while (birthday[i] != '\0')
{
if (birthday[i] != '-')
{
str[count][j] = birthday[i];
j++;
}
else
{
count++;
j = 0;
}
i++;
}
year = atoi(str[0]);
month = atoi(str[1]);
day = atoi(str[2]);
if (month == 2 && day == 29 && !((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
{
return -1;
}
if(month >= 1 && month <= 6)
{
temp += 2002;
}
else
{
temp += 3002;
}
temp -= year;
int a, b, c;
a = temp / 100;
b = (temp - a * 100) / 10;
c = temp % 10;
temp = b * 10 + c + 10;
res = temp;
return res;
}
- 33
- 利用变量保存最长长度以及最长长度的最后一位索引值，我们就可以利用这两个条件找出最长单词的起始位置
写一个函数，输入一行字符，将此字符串中最长的单词输出。
输入提示信息："输入一行文本：\n"
用gets()输入一行字符
输出提示信息："\n最长的单词是："
输出字符用"%c"
输出所有字符后用"\n"
程序的运行示例如下：
输入一行文本：I am a student.
最长的单词是：student
#include<stdio.h>
#include<string.h>
void longestWord(char str[]);
int main()
{
printf("输入一行文本：\n");
char str[100];
gets(str);
printf("\n最长的单词是：");
longestWord(str);
}
void longestWord(char str[])
{
int sum = 0;//用于比较每个单词的长度
int i = 0;
int m = 0;
int n = 0;
while (str[i] != '.')
{
if (str[i] != ' ')
{
sum++;
}
else
{
if (m < sum)
{
m = sum;
n = i - 1;记录长度最长的单词的最后一位，m是最长的单词的长度
}
sum = 0;
}
i++;
}
if(m < sum)
{
m = sum;
n = i - 1;
}
for (i = n - m + 1; i <= n; i++)
{
printf("%c", str[i]);
}
}
-
- 猴子吃桃程序
- 主要是利用getchar()：清理缓冲区中非法输入的字符
- 计算前一天的数目：先加1，再乘2
猴子吃桃程序_扩展2
猴子第一天摘了若干个桃子，吃了一半，不过瘾，又多吃了1个。第二天早上将剩余的桃子又吃掉一半，并且又多吃了1个。此后每天都是吃掉前一天剩下的一半零一个。到第n天再想吃时，发现只剩下1个桃子，问第一天它摘了多少桃子？为了加强交互性，由用户输入不同的天数n进行递推，即假设第n天的桃子数为1。同时还要增加对用户输入数据的合法性验证（如:不允许输入的天数是0和负数）
程序运行结果示例：
Input days:
0↙
Input days:
-5↙
Input days:
a↙
Input days:
3↙
x=10
输入格式:"%d"
输出格式：
输入提示信息："Input days:\n"
输出："x=%d\n"
#include<stdio.h>
int main()
{
int n;
do
{
printf("Input days:\n");
scanf("%d", &n);
getchar();
} while (n <= 0);
int count = 1;
for (int i = 1; i < n; i++)
{
count = (count + 1) * 2;
}
printf("x=%d\n", count);
}
-
- 冒泡排序改错题
给下面程序改错。程序功能是输入10个数，按从小到大顺序排序。
#include <stdio.h>
#define SIZE 10;
main()
{
int i, j, t, a[SIZE];
printf("input 10 numbers: \n");
for (i = 1; i <= SIZE; i++)
scanf("%d", a[i]);//数组的索引从0开始长度为10，索引为0到9，这里会发生越界，scanf需要取地址符号&
printf("\n");
for (i = 0; i < SIZE; i++)
for (j = SIZE - 1; j >= i + 1; j--)
if (a[j] > a[j - 1])//从小到大要换成小于号
{
t = a[j]; //这里的交换有问题
a[j - 1] = a[j];
a[j] = t;
}
for (i = 0; i < SIZE; i++)
printf("%d\n", a[i]);
}
注意：
（1）请将修改正确后的完整源程序拷贝粘贴到答题区内。
（2）对于没有错误的语句，请不要修改，修改原本正确的语句也要扣分。
（3）当且仅当错误全部改正，且程序运行结果调试正确，才给加5分。
（4）改错时不能改变程序原有的意图，也不要改变代码的输入输出格式。
#include <stdio.h>
#define SIZE 10
#include<string.h>
#include<stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
main()
{
int i, j, t, a[SIZE];
printf("input 10 numbers: \n");
for (i = 0; i < SIZE; i++)
scanf("%d", &a[i]);
printf("\n");
for (i = 0; i < SIZE; i++)
for (j = SIZE - 1; j >= i + 1; j--)
if (a[j] < a[j - 1])
{
t = a[j];
a[j] = a[j - 1];
a[j - 1] = t;
}
for (i = 0; i < SIZE; i++)
printf("%d\n", a[i]);
}
-
- 如何分割字符和数字，并将数字先作为字符保存在字符数组中，之后利用atoi函数转为数字，之后进行输出
编写一个程序，将用户输入的由数字字符和非数字字符组成的字符串中的数字提取出来（例如：输入asd123,34fgh_566kkk789，则产生的数字分别是123、34、789）。
**输入格式要求：提示信息："Please enter a string:"
**输出格式要求："the result of output:\n" "%10d\n"
程序运行示例如下：
Please enter a string:
abc123def456ghi111bbbccc99go100
the result of output:
123
456
111
99
100
#include <stdio.h>
#define N 100
#include<string.h>
#include<stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int main()
{
char str[N][N];
printf("Please enter a string:\n");
char string[N];
scanf("%s", string);
int i = 0;
int index = 0;
int j = 0;
while (string[i] != '\0')
{
if (string[i] >= 'a' && string[i] <= 'z')
{
i++;
}
else if(string[i] >= '0' && string[i] <= '9' && !(string[i + 1] >= 'a' && string[i + 1] <= 'z'))
{
str[index][j] = string[i];
i++;
j++;
}
else
{
str[index][j] = string[i];
index++;
i++;
j = 0;
}
}
int num[N];
for (i = 0; i <= index; i++)
{
num[i] = atoi(str[i]);
}
printf("the result of output:\n");
for (i = 0; i <= index; i++)
{
printf("%10d\n", num[i]);
}
}
-
- 简单的比较问题
按如下函数原型计算n名职工的最高收入：
float FindMax(float income[],int n);
在主函数中从键盘输入某单位n名职工的月收入(最多不超过30人，具体人数n由键盘输入)，调用函数FindMax()计算职工的最高月收入返回给主函数，然后在主函数中输出职工的最高月收入。
**输入提示信息：无
**输入格式：输入职工人数用"%d"，输入职工工资用"%f"
**输出提示信息和格式："The highest income is %10.2f\n"
注：（1）不能使用指针、结构体、共用体、文件、goto、枚举类型进行编程。
（2）用纯C语言编程，所有变量必须在第一条可执行语句前定义。
#include <stdio.h>
#define N 30
#include<string.h>
#include<stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
float FindMax(float income[], int n);
int main()
{
float income[N];
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
{
scanf("%f", &income[i]);
}
float max = FindMax(income, n);
printf("The highest income is %10.2f\n", max);
}
float FindMax(float income[],int n)
{
double max = income[0];
for (int i = 1; i < n; i++)
{
if (income[i] > max)
{
max = income[i];
}
}
return max;
}
-
- 比较简单的问题
输入2个学生5门课的成绩，分别用函数求：（1）每个学生的平均分；（2）每门课的平均分；（3）找出最高的分数所对应的学生和课程；（4）求出各同学的平均分方差：
(1/n)(∑xi2) - （（∑xi）/ n）2
输入格式和提示信息：
"\n输入学生%4d的5个成绩：\n"
"%f"
输出格式和提示信息：
"\n 序号 课程1 2 3 4 5 平均分\n"
"\n NO%2d"
"%8.2f"
"\n课平均"
"%8.2f"
"\n\n最高分%8.2f是%d号学生的第%d门课\n"
"\n方差 %8.2f"
-
- 在写swap函数时候要用Int型变量记录值
输入3个数x,y,z，按从小到大顺序排序后输出。
要求：利用指针方法实现两数互换，函数原型为：void swap(int *p1,int *p2);
输入提示：printf("please input 3 number x,y,z");
输入格式："%d,%d,%d"
输出格式：printf("the sorted numbers are:%d,%d,%d\n", );
#include <stdio.h>
#define N 30
#include<string.h>
#include<stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
void swap(int* p1, int* p2);
int main()
{
int x, y, z;
printf("please input 3 number x,y,z");
scanf("%d,%d,%d", &x, &y, &z);
int num[3];
num[0] = x;
num[1] = y;
num[2] = z;
for (int i = 0; i < 2; i++)
{
for(int j = i + 1;j < 3;j++)
{
if (num[j] < num[i])
{
swap(&num[j], &num[i]);
}
}
}
printf("the sorted numbers are:%d,%d,%d\n", num[0], num[1], num[2]);
}
void swap(int *p1,int *p2)
{
int temp = *p1;//注意这里不能使用指针，因为 指针指向的值发生变化，他也会发生变化
*p1 = *p2;
*p2 = temp;
}
- 40.反向输出链表
#include <stdio.h>
#define N 30
#include<string.h>
#include<stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
struct LNode* add(struct LNode* head, int data);
struct LNode* reverse(struct LNode* head);
struct LNode {
int data;
struct LNode* next;
};
int main()
{
struct LNode* head = NULL;
struct LNode* p;
int i, data;
printf("\nplease input 5 data==>\n");
for (int i = 0; i < 5; i++)
{
scanf("%d", &data);
head = add(head, data);
}
head = reverse(head);
for (int i = 0; i < 5; i++)
{
printf("The value is ==>%d\n", head->data);
head = head->next;
}
}
struct LNode* add(struct LNode *head,int data)
{
struct LNode* p, * pr;
p = (struct LNode*)malloc(sizeof(struct LNode));
if (p == NULL)
{
printf("no enough memory");
exit(0);
}
pr = head;
if (head == NULL)
{
head = p;
}
else
{
while (pr -> next != NULL)
{
pr = pr->next;
}
pr->next = p;
}
p->next = NULL;
p->data = data;
return head;
}
void reverse(struct LNode *head)
{
if (head ->next != NULL)
{
reverse(head->next);
}
printf("The value is ==>%d\n", head->data);
/*带头节点的利用头插法进行链表的逆置
if (head == NULL || head->next == NULL)
{
return head;
}
struct LNode* p = NULL;
struct LNode* s = head;
head = NULL;
while (s != NULL)
{
p = s;
s = s->next;
p->next = head;
head = p;
}
return head;
*/
}
3.16
41.字符数组逆序：利用双指针的思想
利用一个字符数组作函数参数,实现字符串（最大长度为80个字符 ）的逆序存放。
要求如下：
(1)在子函数Inverse中实现字符串的逆序存放。函数原型为：
void Inverse(char str[]);
(2)在主函数中
从键盘输入字符串(使用gets函数)
然后，调用Inverse函数，
最后，输出逆序后的字符串。
(3)**输入提示信息："Input a string:\n"
**输出提示信息："Inversed results:\n"
**输出格式："%s\n"
#include <stdio.h>
#define N 80
#include<string.h>
void Inverse(char str[]);
int main()
{
printf("Input a string:\n");
char str[N];
gets(str);
Inverse(str);
printf("Inversed results:\n");
printf("%s\n", str);
}
void Inverse(char str[])
{
int len = strlen(str);
int left = 0;
int right = len - 1;
char ch;
while (left < right)
{
ch = str[left];
str[left] = str[right];
str[right] = ch;
left++;
right--;
}
}
42.程序改错题
请用指针数组编程实现按奥运会参赛国的国名在字典中的顺序对其入场次序进行排序。
假设参赛国不超过150个，参赛国的国名不超过9个字符。
下面程序中存在比较隐蔽的错误，请通过分析和调试程序，发现并改正程序中的错误。
#include <stdio.h>
#define MAX_LEN 10
#define N 150
void SortString(char *ptr[], int n);
main()
{
int i, n;
char *pStr[N];
printf("How many countries?\n");
scanf("%d",&n);
printf("Input their names:\n");//使用Getchar读入回车符
for (i=0; i<n; i++)
{
gets(pStr[i]);//指针数组未初始化就使用，声明一个二维数组，将指针指向二维数组的行
}
SortString(pStr[i], n);//传递指针数组，与传递数组一样，直接传递数组名即为地址
printf("Sorted results:\n");
for (i=0; i<n; i++)
{
puts(pStr[i]);
}
}
void SortString(char *ptr[], int n)
{
int i, j;
char temp;//这里要用指针，因为ptr为一个指针数组
for (i=0; i<n-1; i++)
{
for (j = i+1; j<n; j++)
{
if (ptr[j] < ptr[i]);//比较的是字符串要用strcmp，注意strcmp中的参数为const char *
{
temp = ptr[i];
ptr[j] = ptr[i];//ptr[i] = ptr[j]
ptr[j] = temp;
}
}
}
}
- 修改后的程序为：
#include <stdio.h>
#include<string.h>
#include<stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
#define MAX_LEN 10
#define N 150
void SortString(char* ptr[], int n);
main()
{
int i, n;
char* pStr[N];
char str[N][MAX_LEN];
printf("How many countries?\n");
scanf("%d", &n);
getchar();//getcahr()读取输入n以后的回车符，清空缓冲区
printf("Input their names:\n");
for (i = 0; i < n; i++)
{
pStr[i] = str[i];
gets(pStr[i]);
}
SortString(pStr, n);
printf("Sorted results:\n");
for (i = 0; i < n; i++)
{
puts(pStr[i]);
}
}
void SortString(char* ptr[], int n)
{
int i, j;
char *temp;
for (i = 0; i < n - 1; i++)
{
for (j = i + 1; j < n; j++)
{
if (strcmp(ptr[j],ptr[i]) < 0)
{
temp = ptr[i];
ptr[i] = ptr[j];
ptr[j] = temp;
}
}
}
}
输入字符串，包含：字母、数字、标点符号，以及空格字符，并将其逆序输出。
例如，当输入字符串为“I am a student.”,输出为“.tneduts a ma I”，假设字符数组最大长度为30。
输入提示信息："Please Enter String1:\n"
输入格式：gets()
输出格式："Result is:\n%s\n"
#include <stdio.h>
#include<string.h>
#include<stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
#define N 30
int main()
{
char str[N];
printf("Please Enter String1:\n");
gets(str);
int len = strlen(str);
int left = 0;
int right = len - 1;
char ch;
while (left < right)
{
ch = str[left];
str[left] = str[right];
str[right] = ch;
left++;
right--;
}
printf("Result is:\n%s\n", str);
}
输入一个字符串保存到数组str中，将str中的数字字符存储到数组tOrigin中，并将其转换为整数输出，用k记录字符串中数字字符的个数。例如：用户输入字符串1243abc3,则将12433取出以整数形式输出。阅读程序，找出其中的错误，并改正之（允许改变数据类型）。
#include <math.h>
#include <stdio.h>
void fun(char *s, char *t, int k)//用指针接收参数
{
int i;
k = 0;//*k = 0
for (i = 0; s[i]; i++)
if (0 <= s[i] && s[I] <= 9)//是字符而不是数字
{
t[*k] = s[i];//传入的t是char型指针 *t = s[i],t++;
*k += 1;
}
}
void main()
{
char str[100], tOrigin[9];
long int n;
int i, k;
printf("Please enter string s:");
scanf("%s", str);
fun(str, tOrigin, &k);//传入的k是地址要用指针接收
for (i = 0; i < k; i++)
n += (tOrigin [k - 1 - i] - '0') * pow(10, i);
printf("The result is: %d", n);
}
- 改正后的程序为：
#include <stdio.h>
#include<string.h>
#include<stdlib.h>
#include <math.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
void fun(char* s, char* t, int *k)
{
int i;
*k = 0;
for (i = 0; s[i] != '\0'; i++)
if ('0' <= s[i] && s[i] <= '9')
{
*t = s[i];
*k += 1;
t++;
}
}
void main()
{
char str[100], tOrigin[9];
long int n = 0;
int i, k;
printf("Please enter string s:");
scanf("%s", str);
fun(str, tOrigin, &k);
for (i = 0; i < k; i++)
n += (tOrigin[k - 1 - i] - '0') * pow(10, i);
printf("The result is: %d", n);
}
编程计算a%1 + aa%2 + aaa%3 + ... + aa...a%n(最后一项是n个a对n求余)
的值，然后输出这个值。
（要求存储累加项及总和的变量定义为长整型,a与n定义为整型），
其中n和a的值由键盘输入。
**要求：
**输入提示信息格式为："Enter n,a:\n"
**输入格式为："%d,%d"
**输出格式为："Sum=%ld\n"
**请严格按照以上要求输入输出，除了以上指定输出结果外，
不允许有其他临时输出
#include<string.h>
#include<stdlib.h>
#include <math.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int main()
{
int n, a;
printf("Enter n,a:\n");
scanf("%d,%d", &n, &a);
long temp, sum;
int m = a;//保存a的值用于生成下一个数字a
temp = a % 1;
for (int i = 1; i < n; i++)
{
a = a * 10 + m;//计算下一个a的值
temp += (a % (i + 1));
}
sum = temp;
printf("Sum=%ld\n", sum);
}
- Tips：
- 要用str[i] - 'a’作为数组的索引
- 用i + ‘a’作为字符进行输出
从键盘输入1行字符串（每行最多输入80个字符），
统计字符串中所包含的各个英文小写字符及其对应的数量。
**输入格式要求：不要有任何提示信息，直接输入1行字符。
**输出格式要求：按字母顺序输出统计结果，"%c=%d\n"
每行输出一个字母的统计信息。
如果某个字母没有出现，则不输出该字母的统计信息。
如：输入字符串：
abc2ed a7bcdcd
则输出：
a=2
b=2
c=3
d=3
e=1
#include <stdio.h>
#include<string.h>
#include<stdlib.h>
#include <math.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
#define N 80
int main()
{
char str[N];
int count[26] = {0};
gets(str);
int i = 0;
while (str[i] != '\0')
{
if (str[i] >= 'a' && str[i] <= 'z')
{
count[str[i] - 'a']++;
}
i++;
}
for (int i = 0; i < 26; i++)
{
if (count[i] != 0) {
printf("%c=%d\n", i + 'a', count[i]);
}
}
}
对输入的字符串进行长度验证，保证输入的字符串的长度在指定的范围内，如果不在指定的范围内，则一直提示用户输入，直到输入合法长度的字符串为止。
程序的示例运行如下：
请输入一个字符串(长度为[3..5]个字符)：a
请输入一个字符串(长度为[3..5]个字符)：ab
请输入一个字符串(长度为[3..5]个字符)：abcdef
请输入一个字符串(长度为[3..5]个字符)：abc
你输入的字符串为：abc
#include <stdio.h>
#include<string.h>
#include<stdlib.h>
#include <math.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
#define N 80
int main()
{
char str[N];
do
{
printf("请输入一个字符串(长度为[3..5]个字符)：");
gets(str);//gets会将回车符读入，并将回车符读为NULL，作为字符串结束的标志
} while (strlen(str) < 3 || strlen(str) > 5);
printf("你输入的字符串为：%s", str);
}
- 先找行最大元素，在判断这个最大元素是否是列最小，利用flag记录是否找到，利用break退出循环
找出一个二维数组中的鞍点，即该位置上的元素在该行最大，在该列上最小。也可能没有鞍点。
**输入数据格式：
"\n输入行数："
"%d"
"\n输入列数："
"%d"
"第%d行？\n"
"%d"
**输出格式要求：
"%5d"
"\n第%d行，第%d列的%d是鞍点\n"
"\n矩阵中无鞍点!\n"
程序的运行示例1如下：
输入行数：3
输入列数：3
第0行？
1 2 3
第1行？
4 5 6
第2行？
7 8 9
1 2 3
4 5 6
7 8 9
第0行，第2列的3是鞍点
程序的运行示例2如下：
输入行数：2
输入列数：2
第0行？
1 2
第1行？
4 1
1 2
4 1
矩阵中无鞍点!
#include <stdio.h>
#include<string.h>
#include<stdlib.h>
#include <math.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
#define N 80
int main()
{
int m;
int n;
printf("\n输入行数:");
scanf("%d", &m);
printf("\n输入列数:");
scanf("%d", &n);
int matrix[N][N];
for (int i = 0; i < m; i++)
{
printf("第%d行？\n", i);
for (int j = 0; j < n; j++)
{
scanf("%d", &matrix[i][j]);
}
}
for(int i = 0;i < m;i++)
{
for (int j = 0; j < n; j++)
{
printf("%5d", matrix[i][j]);
}
printf("\n");
}
int max;
int maxRow = 0;
int minCol = 0;
int flag = 1;
//先找到一行中最大的在判断他是不是这个列最小的
for (int i = 0; i < m; i++)
{
flag = 1;
max = matrix[i][0];
maxRow = i;
minCol = 0;
for(int j = 0;j < n;j++)
{
if (matrix[i][j] > max)
{
max = matrix[i][j];
maxRow = i;
minCol = j;
}
}
for (int k = 0; k < m; k++)
{
if(matrix[k][minCol] < max)
{
flag = 0;
break;
}
}
if (flag == 1) {
break;
}
}
if (flag == 0) {
printf("矩阵中无鞍点");
}
else
{
printf("\n第%d行，第%d列的%d是鞍点\n", maxRow, minCol, matrix[maxRow][minCol]);
}
}
从键盘任意输入一个数n（0<n<=10），编程计算并输出S=1!+2!+...+n!的末6位数字（不含前导0）。若S超过6位数字，则只输出其末6位数字。若S不足6位数字，则直接输出S，不输出前导0，不输出前导0的含义是，如果末6位为001234，则只输出1234即可。如果输入的n不在1到10之间，则输出“Input error!”。
请安如下函数原型编写程序：
//函数功能：计算1!+2!+...+n!的末6位数
int Func(int n);
输入数据提示信息："Input n:"
输入数据格式："%d"
输出数据格式："%d"
输入数据不在合法范围时，输出"Input error!\n"
程序运行示例1：
Input n:5↙
153
程序运行示例2：
Input n:10↙
37913
#include <stdio.h>
#include<string.h>
#include<stdlib.h>
#include <math.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
#define N 80
int main()
{
printf("Input n:");
int n;
scanf("%d", &n);
if (n < 1 || n > 10)
{
printf("Input error!\n");
exit(0);
}
int res = Func(n);
if (res > 999999)
{
int a = res / 1000000;//如果是七位数就把第七位找到之后减去就剩末六位数了
res = res - a * 1000000;
}
printf("%d", res);
}
int Func(int n)
{
int sum = 0;
int temp = 1;
sum += temp;
for (int i = 2; i <= n; i++)
{
temp *= i;
sum += temp;
}
return sum;
}
用指针编程实现3X4的二维数组的元素读入以及求此二维数组的最大值及最大值下标
请用以下函数实现：
void Input(int *p,int m, int n); /*数组元素读入函数*/
int FindMax(int *p, int m, int n, int *pRow, int *pCol); /*求最大值及下标函数*/
若存在若干个相同最大元素，则按照第一次出现的最大值的下标输出。
***输入提示信息："Please input your data:\n"
***输入格式要求：无格式要求
***输出格式要求："The maximum is %d, which is in row %d, colum %d\n"
样例：
Please input your data:
**输入样例：
3 5 2 7 1 6 12 11 4 10 8 9
**输出样例：
The maximum is 12, which is in row 1, colum 2
#include <stdio.h>
void Input(int* p, int m, int n); /*数组元素读入函数*/
int FindMax(int* p, int m, int n, int* pRow, int* pCol); /*求最大值及下标函数*/
int main()
{
printf("Please input your data:\n");
int matrix[3][4];
Input(*matrix, 3, 4);
int Row, Col;
int max = FindMax(*matrix, 3, 4, &Row, &Col);
printf("The maximum is %d,which is in row %d,colum %d\n", max, Row, Col);
}
void Input(int* p, int m, int n)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
scanf("%d", &p[i * n + j]);
}
}
}
int FindMax(int* p, int m, int n, int* pRow, int* pCol)
{
*pRow = 0;
*pCol = 0;
int max = p[0];
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (p[i * n + j] > max) {
max = p[i * n + j];
*pRow = i;
*pCol = j;
}
}
}
return max;
}
50 .
检验并打印幻方矩阵。在下面的5×5阶幻方矩阵中，每一行、每一列、每一对角线上的元素之和都是相等的，试编写程序将这些幻方矩阵中的元素读到一个二维整型数组中，然后检验其是否为幻方矩阵，并将其按如下格式显示到屏幕上。
17 24 1 8 15
23 5 7 14 16
4 6 13 20 22
10 12 19 21 3
11 18 25 2 9
输出提示信息："It is a magic square!\n"
输出格式："%4d"（换行使用"\n"）
- 检查行
- 检查列
- 检查对角线
#include <stdio.h>
#include<string.h>
#include<stdlib.h>
#include <math.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
int main()
{
int matrix[5][5] = { {17,24,1,8,15},{23,5,7,14,16},{4,6,13,20,22},{10,12,19,21,3},{11,18,25,2,9} };
int sum = 0;
for (int i = 0; i < 5; i++)
{
sum += matrix[0][i];
}
int temp = 0;
for (int i = 1; i < 5; i++)
{
temp = 0;
for(int j = 0;j < 5;j++)
{
temp += matrix[i][j];
}
if (temp != sum)
{
exit(0);
}
}
for (int i = 0; i < 5; i++)
{
temp = 0;
for (int j = 0; j < 5; j++)
{
temp += matrix[j][i];
}
if(temp != sum)
{
exit(0);
}
}
temp = 0;
for (int i = 0; i < 5; i++)
{
temp += matrix[i][i];
}
if (temp != sum) {
exit(0);
}
temp = 0;
for (int i = 0; i < 5; i++)
{
temp += matrix[i][4 - i];
}
if (temp != sum)
{
exit(0);
}
printf("It is a magic square!\n");
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++) {
printf("%4d", matrix[i][j]);
}
printf("\n");
}
}
写一函数，输入一个十六进制数，输出相应的十进制数。
程序的运行示例如下：
输入十六进制数：
3a
十进制数58
继续吗？
y
输入十六进制数：
2f
十进制数47
继续吗？
n
- 用字符数组存储输入的十六进制数，利用十六进制转换为10进制的规则，注意a~f利用10 + str[i] - ‘a’
#include <stdio.h>
#include <math.h>
#include <string.h>
#include<stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
#define N 80
int main()
{
char a[10];
int n, i, num = 0;
char ch;
do {
printf("输入十六进制数:\n");
gets(a); //输入十六进制数
n = strlen(a);
num = 0;
for (i = n - 1; i >= 0; i--)
{
if (a[i] >= '0' && a[i] <= '9')
num += (a[i] - '0') * pow(16, n - 1 - i);
else if (a[i] >= 'A' && a[i] <= 'F')
num += (10 + (a[i] - 'A')) * pow(16, n - 1 - i);
else if (a[i] >= 'a' && a[i] <= 'f')
num += (10 + (a[i] - 'a')) * pow(16, n - 1 - i);
}
printf("十进制数%d\n",num);
printf("继续吗？\n");
scanf("%c", &ch);
getchar();
} while (ch == 'y');
return 0;
}
- 链表的初始化、删除指定元素的问题
将一个链表中元素值为x的结点删除。（链表数据域为整数，初始长为6个元素）
程序运行示例如下：
输入数组6个元素的值。
11 22 33 44 55 66
此链表各个结点的数据域为：11 22 33 44 55 66
输入要删除的数据x: 33
删除后链表各个结点的数据域为：11 22 44 55 66
输入提示：
"输入数组6个元素的值。\n"
"输入要删除的数据x: "
输入格式：%d "
输出提示："此链表各个结点的数据域为："
"删除后链表各个结点的数据域为："
输出格式："%d "
"\n"
- 我的代码：
- 注意头插法和尾插法的使用
- 注意删除指定元素后用break跳出循环
- 注意初始化链表时，每次都要申请内存来保存一个节点
#include <stdio.h>
#include <math.h>
#include <string.h>
#include<stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
struct LNode* InitLinkList(struct LNode* head, int a[], int length);
void OutLinkList(struct LNode* head);
struct LNode* Remove(struct LNode* head, int delete);
struct LNode {
int data;
struct LNode* next;
};
int main()
{
int a[6];
printf("输入数组6个元素的值。\n");
for (int i = 0; i < 6; i++)
{
scanf("%d", &a[i]);
}
printf("此链表各个结点的数据域为：");
struct LNode* head = (struct LNode*)malloc(sizeof(struct LNode));
if (head == NULL)
{
printf("No enough memory");
}
head->next = NULL;
head = InitLinkList(head, a, 6);
OutLinkList(head);
int delete;
printf("输入要删除的数据x：");
scanf("%d", &delete);
head = Remove(head, delete);
printf("删除后链表各个结点的数据域为:");
OutLinkList(head);
}
struct LNode* InitLinkList(struct LNode* head, int a[], int length)
{
//for (int i = 0; i < 6; i++)
//{
// struct LNode* p = (struct LNode*)malloc(sizeof(struct LNode));
// p->data = a[5 - i];
// p->next = head->next;
// head->next = p;
//}
//return head;
//带头节点的尾插法，如果不带头节点那么就进行一次判断，判断链表是否为空，如果为空，那么malloc得到的节点即为头节点，否则在进行插入
struct LNode* q = head;
for (int i = 0; i < length; i++)
{
struct LNode* p = (struct LNode*)malloc(sizeof(struct LNode));
p->data = a[i];
p->next = NULL;
q->next = p;
q = p;
}
return head;
}
struct LNode* Remove(struct LNode* head, int delete)
{
struct LNode* p = head->next;
struct LNode* q = head;
while (p != NULL)
{
if (p-> data == delete)
{
q->next = p->next;//注意删除之后要break，不然后面节点也会发生变化
break;
}
else
{
p = p->next;
q = q->next;
}
}
return head;
}
void OutLinkList(struct LNode* head)
{
struct LNode* p = head->next;
while (p != NULL)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
- 参考代码：
参考代码
```c
#include <stdio.h>
#include <stdlib.h>
#define N 6
struct LNode
{
int data;
struct LNode *next;
} ;
struct LNode* create_rear(int a[], int n);
void output(struct LNode *h) ;
struct LNode* delete_node(struct LNode* h, int x);
int main(int argc, char *argv[])
{
int a[N], i, x;
struct LNode* head;
printf("输入数组%d个元素的值。\n", N);
for (i = 0; i < N; i++)
scanf("%d", &a[i]);
/*创建链表head,其结点的值依次为数组a元素的值*/
head = create_rear(a, N);
/*删除前输出链表head*/
printf("此链表各个结点的数据域为：");
output(head);
printf("输入要删除的数据x: ");
scanf("%d", &x);
head = delete_node(head, x); /*调用删除函数*/
printf("删除后链表各个结点的数据域为：");
output(head); /*删除后输出链表head*/
return 0;
}
struct LNode* create_rear(int a[], int n)
{
/*新建一个链表h，每个结点依次插入到链尾，将链表的头指针返回 */
struct LNode *h = NULL;
struct LNode *s, *r; /*用s指向要插入结点，r指向链表的尾结点*/
int i;
for (i = 0; i < n; i++)
{
s = (struct LNode *) malloc(sizeof(struct LNode));
s->data = a[i];
s->next = NULL;
if (h == NULL)
h = s; /*如果链表为空，则头指针h指向s */
else
r->next = s; /*否则将s链接到尾结点r之后 */
r = s; /*将r指向尾结点 */
}
return h; /*返回链表的头指针*/
}
void output(struct LNode *h)
{
/*将链表h的各个结点的数据域依次输出，即遍历该链表*/
struct LNode *p = h;/*从第一个结点开始，用p依次指向各个结点*/
while (p)
{
/*只要p是一个非空结点，则输出其数据域，然后将p后移*/
printf("%d ", p->data);
p = p->next; //将p后移
}
printf("\n");
}
struct LNode* delete_node(struct LNode* h, int x)
{
/*将链表h中值为x的结点第一个结点删除，并返回头指针。*/
struct LNode *pre, *p;/*pre所指结点为p所指结点的前驱*/
p = h;
while (p && x != p->data)
{
/*如果p不空，且x不等于p所指结点的数据域,p后移，pre为p的前驱*/
pre = p;
p = p->next;
}
if (p)
{
/*在链表中找到了要删除的结点p，即p->data为x*/
if (p == h)
{
/*p为链首结点，由于p没有前驱，删除后p的后继结点成为链首，需修改头指针*/
h = p->next;
}
else
{
/*删除的p非链首结点，则p有前驱pre，删除时需将pre后面链接到p的后继结点*/
pre->next = p->next;
}
}
return h;
}
- 2.字符串中小写字母到大写字母的转换
- 如果输入的字符串中要用到空格，要使用gets函数读入字符串
- 小写字母的ASCII值比大写字母的ASCII值大32
int main()
{
char string[N];
printf("please input a string：");
gets(string);//读入带有空格 或 换行的字符串要用gets函数
Change(string);
printf("changed string is %s\n", string);
}
void Change(char string[])
{
int i = 0;
while (string[i] != '\0')
{
if (string[i] >= 'a' && string[i] <= 'z') {
string[i] = string[i] - 32;
}
i++;
}
}
- 3.改错题
- 重点题
- scanf读入后，回车符仍然在缓冲区，如果下面要接着读入字符，需要用getchar()将回车符清除缓冲区
- 指针数组要初始化才能被使用
- 在sort函数中对于字符串的比较要用strcmp，进行交换时要使用指针
编写程序对读入的国家名称按字典顺序排序（最多20个国名，且长度不超过40）。要求：需排序的国家个数在主函数读入，调用Input函数读入需排序的国名，调用Sort函数对国名按字典顺序排序，调用Print函数打印按字典顺序排序的国名。Input、Sort、Print函数原型如下：
void Input(char *p[], int n);
void Sort(char *p[], int n);
void Print(char *p[], int n);
下面程序中存在比较隐蔽的错误，请通过分析和调试程序，发现并改正程序中的错误。
#include<stdio.h>
void Input(char *p[], int n);
void Sort(char *p[], int n);
void Print(char *p[], int n);
int main()
{
char str[40][20];
int i, n;
printf("Input n(n<=20):\n");
scanf("%d", &n);
Input(str, n);
Sort(str, n);
printf("Results:\n");
Print(str, n);
return 0;
}
void Input(char *p[], int n)
{
int i;
for (i = 0; i < n; i++)
{
gets(p[i]);
}
}
void Sort(char *p[], int n)
{
char t;
int i, j;
for (i = 0; i < n - 1; i++)
{
for (j = 1; j < n; j++)
{
if (p[j] < p[i]) )
{
t = p[i];
p[i] = p[j];
p[j] = t;
}
}
}
}
void Print(char *p[], int n);
{
int i;
for (i = 0; i < n; i++)
{
printf("%s\n", p[i]);
}
}
注意：
（1）请将修改正确后的完整源程序拷贝粘贴到答题区内
（2）对于没有错误的语句，请不要修改，修改原本正确的语句也要扣分
（3）当且仅当错误全部改正，且程序运行结果调试正确，才给加分
（4）改错时不能改变程序原有的意图，也不要改变代码的输入输出格式
#include<stdio.h>
#include<string.h>
void Input(char *p[], int n);
void Sort(char *p[], int n);
void Print(char *p[], int n);
int main()
{
char str[20][40];
char *pstr[20];
int i, n;
printf("Input n(n<=20):\n");
scanf("%d", &n);
getchar();
for (i = 0; i < n; i++)
{
pstr[i] = str[i]; //2
}
Input(pstr, n);
Sort(pstr, n);
printf("Results:\n");
Print(pstr, n);
return 0;
}
void Input(char *p[], int n)
{
int i;
for (i = 0; i < n; i++)
{
gets(p[i]);
}
}
void Sort(char *p[], int n)
{
char *t; //1
int i, j;
for (i = 0; i < n - 1; i++)
{
for (j = i + 1; j < n; j++)
{
if (strcmp(p[j], p[i]) < 0) //2
{
t = p[i];
p[i] = p[j];
p[j] = t;
}
}
}
}
void Print(char *p[], int n)
{
int i;
for (i = 0; i < n; i++)
{
printf("%s\n", p[i]);
}
}
- 4.字符串部分逆序
- 注意从第m个字符开始，连续n个字符
- 左指针为m-1，右指针为m + n - 2
请按给定的函数原型编程实现将字符数组中的字符串的第m个字符开始的n个字符逆序存放。要求在主函数读入字符串，且逆序存放后的字符串也在主函数打印。函数原型：
void inverse(char str[],int m,int n);
输入要求: 输入的一行字符串，应包含字母，数字以及空格字符
友情提示:
在执行输入字符串的函数之前,请用getchar();把输入缓冲区中的换行符读出!!!
****输入提示信息和格式要求为：
"input m,n:"
"%d,%d"
"input the string:"
****输出格式为:"the inverse string:%s"
int main()
{
printf("input m,n:");
int m, n;
scanf("%d,%d", &m, &n);
getchar();
printf("input the string:");
char str[N];
gets(str);
inverse(str, m, n);
printf("the inverse string:%s", str);
}
void inverse(char str[], int m, int n)
{
int left = m - 1;
int right = m + n - 2;
char ch;
while (left < right)
{
ch = str[left];
str[left] = str[right];
str[right] = ch;
left++;
right--;
}
}
- 5.八进制字符串转换为十进制数字
- 数字的ASCII从48开始所以转换为真实数字要减去48
- 使用一个静态变量num来保存结果
程序中函数 fun()的功能: 将一个由八进制数字字符组成的字符串转换为与其值相等的十进制整数。规定输入的字符串最多只能包含5位八进制数字字符。
**输入格式要求：gets 提示信息："输入一个八进制字符串（5位）:" "错误：字符串太长\n\n" "错误:%c 不是一个八进制字符\n\n"
**输出格式要求："输入的八进制字符串为" "\n%s 转换成十进制整数为：%d\n"
程序运行示例如下：
输入一个八进制字符串（5位）:234
输入的八进制字符串为234
234 转换成十进制整数为：156
#include <stdio.h>
#include <string.h>
#include <math.h>
int i = 1;
void fun(char* a,long len)//将一个由八进制数字字符组成的字符串转换为与其值相等的十进制整数
{
static int num = 0;//静态局部变量
for(long j = 0;j != len;j++)
{
num += ((*(a+j)-48) * pow(8,len-j-1));
// 这是一个字符，需要进行转换才是int型数字
}
printf("\n\n%s 转换成十进制整数为：%d\n",a,num);
}
int main ( )
{
printf("输入一个八进制字符串（5位）:");
char a [10];
gets(a);
if (strlen(a) > 5) {
printf("错误：字符串太长\n\n");
}
for(long j = strlen(a) - 1;j != 0;j--)
if (!(*(a+j) < '8' && '0' <= *(a+j))) {
printf("错误:%c 不是一个八进制字符\n\n",*(a+j));
}
printf("输入的八进制字符串为%s",a);
fun(a,strlen(a));
}
//第二种解法
#include <stdio.h>
#include <math.h>
#include <string.h>
#include<stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
#define N 80
int fun(char str[], int n);
int main()
{
printf("输入一个八进制字符串（5位）:");
char str[N];
scanf("%s", str);
if (strlen(str) > 5)
{
printf("错误：字符串太长\n\n");
exit(0);
}
int len = strlen(str);
for (int i = 0; i < len; i++)
{
if (str[i] >= '8' || str[i] <= '0')
{
printf("错误:%c 不是一个八进制字符\n\n", str[i]);
exit(0);
}
}
int res = fun(str, len);
printf("\n%s 转换成十进制整数为：%d\n", str, res);
}
int fun(char str[],int n)
{
static int num = 0;
for (int i = 0; i < n; i++)
{
num += ((str[i] - 48) * pow(8, n - i - 1));
}
return num;
}
- 6.链表逆序问题
- 链表初始化
- struct LNode* head = (struct LNode*) malloc(sizeof(struct LNode));
- head ->next = NULL;
- 链表逆序
- struct LNode* p = head->next;
- struct LNode* q;
- head->next = NULL;
- while(p != NULL)
- 链表初始化
#include <stdio.h>
#include <math.h>
#include <string.h>
#include<stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)
#define N 80
struct LNode* Reverse(struct LNode* head);
struct LNode* InitLink(struct LNode* head, int a[], int len);
void OutputLink(struct LNode* head);
struct LNode {
int data;
struct LNode* next;
};
int main()
{
printf("请输入链表（非数表示结束）\n");
int a[N];
int i = 0;
int ret;
do
{
printf("结点值：");
ret = scanf("%d", &a[i]);
i++;
getchar();
} while (ret == 1);
struct LNode* head = (struct LNode*) malloc(sizeof(struct LNode));
head->next = NULL;
head = InitLink(head, a, i - 1);
OutputLink(head);
Reverse(head);
OutputLink(head);
}
struct LNode* InitLink(struct LNode* head,int a[],int len)
{
struct LNode* q = head;
for (int i = 0; i < len; i++)
{
struct LNode* p = (struct LNode*)malloc(sizeof(struct LNode));
p->data = a[i];
p->next = NULL;
q->next = p;
q = p;
}
return head;
}
void OutputLink(struct LNode* head)
{
struct LNode* p = head->next;
while (p != NULL)
{
printf("\t%d", p->data);
p = p->next;
}
printf("\n");
}
struct LNode* Reverse(struct LNode* head)
{
struct LNode* p = head->next;
struct LNode* q;
head->next = NULL;
while (p != NULL)
{
q = p;
p = p->next;
q->next = head->next;
head->next = q;
}
}
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
