C语言典型例题.doc

2.寻找特殊偶数
成绩
10
开启时间
2014年11月4日 星期二 08:00
折扣
0.8
折扣时间
2014年11月19日 星期三 08:00
允许迟交
否
关闭时间
2014年11月26日 星期三 08:00
背景
有一种特殊偶数，它每一位上的数字都两两不相同。我们现在需要找出四位数中某一区间内的这类偶数。
输入
所要寻找的四位偶数的范围。每组输入有两个数字：第一个数字是最小范围；第二个数字是最大范围。如果输入遇到0，输入结束。
输出
列出此范围内的所有特殊偶数，并且列出此范围内特殊偶数的个数。

测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例 1
以文本方式显示
1. 3000  3020↵
2. 6040  6090↵
3. 0 0↵
以文本方式显示
1. 3012  3014  3016  3018  ↵
2. counter=4↵
3. 6042  6048  6052  6054  6058  6072  6074  6078  6082  6084  ↵
4. counter=10↵
1秒
64M
0
测试用例 2
以文本方式显示
1. 9  101↵
2. 87 -1↵
3. 0 0↵
以文本方式显示
1. Error↵
2. Error↵
1秒
64M
0
Code：
#include
int main()
{
int maxnum, minnum, n, g, s, b, q, count = 0;
while(1){
scanf("%d%d",&minnum,&maxnum);
if(minnum == 0 && maxnum == 0) return 0;
if((minnum > 999 && minnum < 10000) && (maxnum > 999 && maxnum < 10000) && (maxnum >= minnum))
{
for(n = minnum; n <= maxnum; n++)
{
if(n % 2 == 0){
q = n / 1000;
b = n % 1000 / 100;
s = n % 100 / 10;
g = n % 10;
if(q != b && q != s && q != g && b != s && b != g && s != g)
{
count++;
printf("%d ",n);
}
}
}
printf("\n");
printf("counter=%d\n",count);
count = 0;
}
else
printf("Error\n");
}
return 0;
}
3.求最小 m 值
成绩
10
开启时间
2014年11月4日 星期二 08:05
折扣
0.8
折扣时间
2014年11月19日 星期三 08:05
允许迟交
否
关闭时间
2014年11月26日 星期三 08:05
求满足下列不等式的最小 m。
    1 + 2 + 3 + 4 + ...... + m ≥ n
例如：n=100，当 m =14 时，满足：1+2+3+4+...+13=91<100，而 1
+2+3+4+......+14=105>100。
输入：n
输出：m

测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例 1
以文本方式显示
1. 100↵
以文本方式显示
1. 14↵
1秒
64M
0
Code：
#include
int main()
{
int max, i = 0, sum = 0;
scanf("%d",&max);
while(sum < max)
{
i++;
sum += i;
}
printf("%d\n",i);
}
邮票组合
成绩
10
开启时间
2014年11月12日 星期三 06:20
折扣
0.8
折扣时间
2014年11月26日 星期三 06:20
允许迟交
否
关闭时间
2014年12月3日 星期三 06:20
背景：
        我们寄信都要贴邮票，在邮局有一些小面值的邮票，通过这些小面值邮票中的一张或几张的组合，可以满足不同邮件的不同的邮资。
        现在，邮局有4种不同面值的邮票。在每个信封上最多能贴5张邮票，面值可相同，可不同。
输入：
        四种邮票的面值。
输出：
        用这四种面值组成的邮资最大的从1开始的一个连续的区间。
说明：
        如结果为10，则表明使用4张邮票可组合出1、2、3、4、5、6、7、8、9、10这些邮资。
名词解释：
        邮资：就是你寄东西需要花多少钱。
        邮票面额：是由国家发行的具有固定价格的花纸片，被称为邮票。
如果你寄东西，邮局称了重量，告诉你要240分。这样你就要贴邮票了。如果现在邮局的邮票有面值为80分、50分、20分和10分的四种，你就可以采用不同的组合得到240的邮资，例如：采用3张80分的可以凑出240分；或者24张10分的凑起来240分也可以。显然不同邮票的组合都可以得到同样一种邮资。

测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例 1
以文本方式显示
1. 1 4 12 21↵
以文本方式显示
1. The max is 71.↵
1秒
64M
0
测试用例 2
以文本方式显示
1. 1 3 7 12↵
以文本方式显示
1. The max is 46.↵
1秒
64M
0
Code:
#include
int main()
{
int i[5],t[3126],n,n1,n2,n3,n4,temp = 0;
i[0] = 0;
for(n = 1; n < 5; n++)
scanf("%d",&i[n]);
for(n = 0; n < 3126; n++)
t[n] = 0;
for(n = 0; n < 5; n++)
{
for(n1 = 0; n1 < 5; n1++)
{
for(n2 = 0; n2 < 5; n2++)
{
for(n3 = 0; n3 < 5; n3++)
{
for(n4 = 0; n4 < 5; n4++)
{
t[temp] = i[n] + i[n1] + i[n2] + i[n3] + i[n4];
temp++;
}
}
}
}
}
for(n = 0; n < 3124; n++)
{
for(n1 = n; n1 < 3125; n1++)
{
if(t[n] > t[n1])
{
temp = t[n];
t[n] = t[n1];
t[n1] = temp;
}
}
}

temp = 0;
for(n = 0; n < 3125; n++)
{
if(t[n] < t[n + 1] )
temp++;
if(temp != t[n + 1])
break;
}

printf("The max is %d.\n",temp - 1);
return 0;
}
程序讲解示例：整数排排序
成绩
0
开启时间
2014年10月19日 星期日 03:15
折扣
0.8
折扣时间
2014年12月31日 星期三 03:15
允许迟交
否
关闭时间
2014年12月31日 星期三 03:15
有一组整数，要将它们从小到大排序，去掉其中重复的数值。
输入：
第1行，输入整数N，表明接下来将有N（<=100）个整数读入。
第2~N行，输入N个这个数。
输出：排序后的整数（去掉重复的数值）
例如：
输入：
3（回车）
7 5 7（回车）
输出：5 7（回车）

测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例 1
以文本方式显示
1. 3↵
2. 7 5 5↵
以文本方式显示
1. 5 7↵
1秒
64M
0
测试用例 2
以文本方式显示
1. 5↵
2. 1 0 0 2 2↵
以文本方式显示
1. 0 1 2↵
1秒
64M
0
Code:
#include
int main()
{
int n, m, l, i[100], temp;
scanf("%d",&n);
for(m = 0; m < n; m++)
scanf("%d",&i[m]);
for(m = 0; m < n - 1; m++)
for(l = m + 1; l < n; l++)
{
if(i[m] > i[l])
{
temp = i[m];
i[m] = i[l];
i[l] = temp;
}
}

printf("%d",i[0]);
temp = i[0];
for(m = 1; m < n; m++)
{
if(temp < i[m])
{
printf(" %d",i[m]);
temp = i[m];
}
}
printf("\n");
}

临时题
1.单词排序
成绩
10
开启时间
2014年11月27日 星期四 02:55
折扣
0.8
折扣时间
2014年12月10日 星期三 02:55
允许迟交
否
关闭时间
2014年12月17日 星期三 02:55
输入 5 个单词，将它们按从大到小的顺序排列后输出。
输入：
    5个单词
输出：
    排序后的顺序

测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例 1
以文本方式显示
1. BASIC↵
2. C++↵
3. Pascal↵
4. C↵
5. Fortran↵
以文本方式显示
1. Pascal↵
2. Fortran↵
3. C++↵
4. C↵
5. BASIC↵
1秒
64M
0
测试用例 2
以文本方式显示
1. BASIC↵
2. C++↵
3. C↵
4. Fortran↵
5. Pascal↵
以文本方式显示
1. Pascal↵
2. Fortran↵
3. C++↵
4. C↵
5. BASIC↵
1秒
64M
0
Code：
#include
#include
int main()
{
char s[5][100], t[100];
int i, n;
for(i = 0; i < 5; i++)
scanf("%s",s[i]);
for(i = 0; i < 4; i++)
{
for(n = i + 1; n < 5; n++)
{
if(strcmp(s[i],s[n]) < 0)
{
strcpy(t,s[i]);
strcpy(s[i],s[n]);
strcpy(s[n],t);
}
}
}
for(i = 0; i < 5; i++)
printf("%s\n",s[i]);
return 0;
}
2.寻找矩阵的鞍点
成绩
10
开启时间
2014年11月27日 星期四 03:00
折扣
0.8
折扣时间
2014年12月10日 星期三 03:00
允许迟交
否
关闭时间
2014年12月17日 星期三 03:00
二维数组中的鞍点，即该位置上的元素是所在行上的最大值，是所在列上的最小值。
二维数组也可能没有鞍点。
输入一个二维数组的行数n，列数m，二维数组的诸元素值；输出数组的鞍点，以及鞍点所在的行列号。
输入：第一行为矩阵的行数和列数，从第二行开始，为矩阵本身（假设输入的矩阵只有0和1个鞍点）
    3 4
    1 3 5 3
    2 3 4 1
    3 2 6 7
输出：
     Point: a[1][2] == 4   (下标从0开始)

测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例 1
以文本方式显示
1. 3 4↵
2. 1 3 5 3↵
3. 2 3 4 1↵
4. 3 2 6 7↵
以文本方式显示
1. Point:a[1][2]==4↵
1秒
64M
0
测试用例 2
以文本方式显示
1. 3 4↵
2. 1 2 3 4↵
3. 8 4 3 6↵
4. 9 4 5 1↵
以文本方式显示
1. No Point↵
1秒
64M
0
Code：
#include
#include
int main()
{
int i[100][100], m, n, x, y, temp, log = 0;
scanf("%d%d",&m,&n);
for(y = 0; y < m; y++)
{
for(x = 0; x < n; x++)
{
scanf("%d",&i[y][x]);
}
}

//将每行的最大值放入每行的最后；
for(y = 0; y < m; y++)
{
temp = 0;
for(x = 0; x < n; x++)
{
if(i[y][x] > temp)
temp = i[y][x];
}
i[y][n] = temp;
}

//将每列的最小值放入每列的最后
for(x = 0; x < n x++)
{
temp = 0x7fffffff;
for(y = 0; y < m; y++)
{
if(i[y][x] < temp)
temp = i[y][x];
}
i[m][x] = temp;
}

for(y = 0; y < m; y++)
{
for(x = 0; x < n; x++)
{
if((i[y][x] == i[m][x]) && (i[y][x] == i[y][n]))
{printf("Point:a[%d][%d]==%d\n",y,x,i[y][x]);log = 1;}
}
}
if(log == 0)
printf("No Point\n");
return 0;
}
3.身份证的奥秘
成绩
10
开启时间
2014年11月27日 星期四 03:05
折扣
0.8
折扣时间
2014年12月10日 星期三 03:05
允许迟交
否
关闭时间
2014年12月17日 星期三 03:05
背景
18位身份证标准在国家质量技术监督局于1999年7月1日实施的GB11643-1999《公民身份号码》中做了明确的规定。 GB11643-1999《公民身份号码》为GB11643-1989《社会保障号码》的修订版，其中指出将原标准名称"社会保障号码"更名为"公民身份号码"，另外GB11643-1999《公民身份号码》从实施之日起代替GB11643-1989。GB11643-1999《公民身份号码》主要内容如下：
一、范围
该标准规定了公民身份号码的编码对象、号码的结构和表现形式，使每个编码对象获得一个唯一的、不变的法定号码。
二、编码对象
公民身份号码的编码对象是具有中华人民共和国国籍的公民。
三、号码的结构和表示形式
1、号码的结构
公民身份号码是特征组合码，由十七位数字本体码和一位校验码组成。排列顺序从左至右依次为：六位数字地址码，八位数字出生日期码，三位数字顺序码和一位数字校验码。
2、地址码
表示编码对象常住户口所在县(市、旗、区)的行政区划代码，按GB/T2260的规定执行。
3、出生日期码
表示编码对象出生的年、月、日，按GB/T7408的规定执行，年、月、日代码之间不用分隔符。
4、顺序码
表示在同一地址码所标识的区域范围内，对同年、同月、同日出生的人编定的顺序号，顺序码的奇数分配给男性，偶数分配给女性。
5、校验码
（1）十七位数字本体码加权求和公式
S = Sum(Ai * Wi), i = 0, ... , 16 ，先对前17位数字的权求和 
Ai: 表示第i位置上的身份证号码数字值 
Wi: 表示第i位置上的加权因子 
Wi: 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2
（2）计算模
Y = mod(S, 11) Y = S % 11
（3）通过模得到对应的校验码
Y: 0 1 2 3 4 5 6 7 8 9 10 
校验码: 1 0 X 9 8 7 6 5 4 3 2
四、举例如下：
北京市朝阳区: 11010519491231002X 
广东省汕头市: 440524188001010014
15位的身份证号升级办法：
15位的身份证号：dddddd yymmdd xx p
18位的身份证号：dddddd yyyymmdd xx p y
o 其中dddddd为地址码（省地县三级）
o yyyymmdd yymmdd 为出生年月日
o xx顺号类编码
o p性别
15 位的 yy 年升为 18 位后，变成 19yy年，但对于百岁以上老人， 则为 18yy 年，此时，他们的最后三位顺序码为996, 997, 998 或 999 来标记。
输入
输入n组身份证号码，第一行为个数，以后每行为身份证号码。
输出
如果输入的身份证号码为15位，则将其升级为18位后显示输出；否则判断其是否为合法身份证号，并逐行输出。

测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例 1
以文本方式显示
1. 4↵
2. 350622197904130331↵
3. 11010519491231002X↵
4. 110105491231002↵
5. 110105491231996↵
以文本方式显示
1. Invalid↵
2. Valid↵
3. 11010519491231002X↵
4. 110105184912319965↵
1秒
64M
0
Code：
#include
#include
int main()
{
int n, i, m, j, sumt, y;
char s[100][19], temp[19], t;
scanf("%d",&n);
for(i = 0; i < n; i++)
scanf("%s",s[i]);

for(i = 0; i < n; i++)
{
m = 0;
while(s[i][m] != '\0')
{
m++;
}
if( m != 15 && m != 18)
{
printf("Invalid\n");
}
if( m == 15)
{
for(j = 0; j < 6; j++)
temp[j] = s[i][j];
if(s[i][12] == '9' && s[i][13] == '9' && s[i][14] > '5')
{
temp[6] = '1'; temp[7] = '8';
}
else
{
temp[6] = '1'; temp[7] = '9';
}
for(j = 6; j < 16; j++)
temp[j + 2] = s[i][j];
strcpy(s[i],temp);
sumt = (s[i][0] - '0') * 7 + (s[i][1]- '0') * 9 + (s[i][2] - '0') * 10 + (s[i][3] - '0') * 5 + (s[i][4] - '0') * 8 + (s[i][5] - '0') * 4 + (s[i][6]-'0') * 2 + (s[i][7]-'0') * 1 + (s[i][8]-'0') * 6 + (s[i][9]-'0') * 3 + (s[i][10]-'0') * 7 + (s[i][11]-'0') * 9 + (s[i][12]-'0') * 10 + (s[i][13]-'0') * 5 + (s[i][14]-'0') * 8 + (s[i][15]-'0') * 4 + (s[i][16]-'0') * 2;
//sumt = atoi(s[i][0]) * 7 + atoi(s[i][1]) * 9 + atoi(s[i][2]) * 10 + atoi(s[i][3]) * 5 +atoi(s[i][4]) * 8 + atoi(s[i][5]) * 4 + atoi(s[i][6]) * 2 + atoi(s[i][7]) * 1 + atoi(s[i][8]) * 6 + atoi(s[i][9]) * 3 + atoi(s[i][10]) * 7 + atoi(s[i][11]) * 9 + atoi(s[i][12]) * 10 + atoi(s[i][13]) * 5 + atoi(s[i][14]) * 8 + atoi(s[i][15]) * 4 + atoi(s[i][16]) * 2;
y = sumt % 11;
switch (y)
{
case 0: s[i][17] = '1'; break;
case 1: s[i][17] = '0'; break;
case 2: s[i][17] = 'X'; break;
case 3: s[i][17] = '9'; break;
case 4: s[i][17] = '8'; break;
case 5: s[i][17] = '7'; break;
case 6: s[i][17] = '6'; break;
case 7: s[i][17] = '5'; break;
case 8: s[i][17] = '4'; break;
case 9: s[i][17] = '3'; break;
case 10: s[i][17] = '2'; break;
}
s[i][18] = '\0';
printf("%s\n",s[i]);
}
if(m == 18)
{
sumt = (s[i][0] - '0') * 7 + (s[i][1]- '0') * 9 + (s[i][2] - '0') * 10 + (s[i][3] - '0') * 5 + (s[i][4] - '0') * 8 + (s[i][5] - '0') * 4 + (s[i][6]-'0') * 2 + (s[i][7]-'0') * 1 + (s[i][8]-'0') * 6 + (s[i][9]-'0') * 3 + (s[i][10]-'0') * 7 + (s[i][11]-'0') * 9 + (s[i][12]-'0') * 10 + (s[i][13]-'0') * 5 + (s[i][14]-'0') * 8 + (s[i][15]-'0') * 4 + (s[i][16]-'0') * 2;
y = sumt % 11;
switch (y)
{
case 0: t = '1'; break;
case 1: t = '0'; break;
case 2: t = 'X'; break;
case 3: t = '9'; break;
case 4: t = '8'; break;
case 5: t = '7'; break;
case 6: t = '6'; break;
case 7: t = '5'; break;
case 8: t = '4'; break;
case 9: t = '3'; break;
case 10: t = '2'; break;
}
if(t == s[i][17])
printf("Valid\n");
else
printf("Invalid\n");
}
}
return 0;
}
4.安全的密码（选做）
成绩
0
开启时间
2014年11月27日 星期四 03:10
折扣
0.8
折扣时间
2014年12月10日 星期三 03:10
允许迟交
否
关闭时间
2014年12月17日 星期三 03:10
随着电子设备的广泛运用，密码也渐渐融入每个人的生活。保护好密码，不仅关系到个人隐私，更关系到个人的财产和安全。一个安全的密码，最好由大小写字母、数字或符号组成。包含越多种类的字符，其安全性就越高。同时密码还需要有一定的长度，通常至少要由六个以上的字符组成。
并不是每个人都喜欢这样复杂的密码，很多人在设置密码的时候，喜欢使用自己的名字或者生日，但这是很大的安全隐患。
任务
林晓炜正在设计一个网络交易系统，为了保证用户的密码安全，他需要一个程序，判断用户自己设置的密码是否安全，如果不安全，则给出提示。现在他向你求助，请你帮忙设计一个程序来解决这个问题。
应当按照以下的规则来判断密码是否安全：
1. 如果密码长度小于 6 位，则不安全
2. 如果组成密码的字符只有一类，则不安全
3. 如果组成密码的字符有两类，则为中度安全
4. 如果组成密码的字符有三类或以上，则为安全
通常，可以认为数字、大写字母、小写字母和其它符号为四类不同的字符。
输入
输入的第一行是一个整数 N，表明后面有多少组密码。随后的 N 行输入包括 N 个密码，每个密码的长度均小于 20 个字符。
输出
针对每一个密码判断并输出它是否安全。对于不安全的密码输出 "Not Safe"，对于中度安全的密码输出 "Medium Safe"，对于安全的密码输出 "Safe"
输入样例
4
1234
abcdef
ABC123
1#c3Gh
输出样例
Not Safe
Not Safe
Medium
Safe Safe

测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例 1
以文本方式显示
1. 10↵
2. abcDEF↵
3. ABC↵
4. qw↵
5. `↵
6. ABCDEFGHIJKLMNOPQRST↵
7. 12345678901234567890↵
8.           1aB↵
9. 1 B↵
10. a X   ↵
11. qwe123%^&ABC↵
以文本方式显示
1. Medium Safe↵
2. Not Safe↵
3. Not Safe↵
4. Not Safe↵
5. Not Safe↵
6. Not Safe↵
7. Safe↵
8. Not Safe↵
9. Safe↵
10. Safe↵
1秒
64M
0
Code：
#include
#include
int main()
{
int n, i, j, m, log1, log2, log3, log4;
char s[100][21], t[10];
scanf("%d",&n);
gets(t);
for(i = 0; i < n; i++)
gets(s[i]);

for(i = 0; i < n; i++)
{
j = 0;
while(s[i][j] != '\0')
{
j++;
}
if(j < 6)
{
printf("Not Safe\n");
continue;
}
j = 0;
log1 = 0;
log2 = 0;
log3 = 0;
log4 = 0;
while(s[i][j] != '\0')
{
if(s[i][j] >= '0' && s[i][j] <= '9') log1 = 1;
if(s[i][j] >= 'a' && s[i][j] <= 'z') log2 = 1;
if(s[i][j] >= 'A' && s[i][j] <= 'Z') log3 = 1;
if(!(s[i][j] >= '0' && s[i][j] <= '9') && !(s[i][j] >= 'a' && s[i][j] <= 'z') && !(s[i][j] >= 'A' && s[i][j] <= 'Z')) log4 =1;
j++;
}
m = 0;
if(log1 == 1) m++;
if(log2 == 1) m++;
if(log3 == 1) m++;
if(log4 == 1) m++;
if(m == 1) printf("Not Safe\n");
if(m == 2) printf("Medium Safe\n");
if(m >= 3) printf("Safe\n");
}
return 0;

}
期中考试测试题
2.回文数
成绩
10
开启时间
2014年11月20日 星期四 02:50
折扣
0.8
折扣时间
2014年12月4日 星期四 02:50
允许迟交
否
关闭时间
2014年12月11日 星期四 02:50
输出所有不超过ｎ(取n<256)的、其平方具有对称性质的正整数（也称为回文数）。
如：  1*1=1； 2*2=4；3*3=9；11*11=121

测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例 1
以文本方式显示
1. 3↵
以文本方式显示
1. 1↵
2. 2↵
1秒
64M
0
测试用例 2
以文本方式显示
1. 25↵
以文本方式显示
1. 1↵
2. 2↵
3. 3↵
4. 11↵
5. 22↵
6. ↵
1秒
64M
0
Code：
#include
int main()
{
int n, m, square, i, temp, log;
char s[6];
scanf("%d",&n);
for(m = 1; m < n; m++)
{
i = 0;
square = m * m;
log = 1;
while(square != 0)
{
temp = square % 10;
s[i] = '0' + temp;
i++;
square /= 10;
}
for(temp = 0; temp < i / 2; temp++)
{
if(s[temp] != s[i - 1 - temp]) log = 0;
}
if(log)
printf("%d\n",m);
}
return 0;
}
3.洗牌
成绩
10
开启时间
2014年11月20日 星期四 03:00
折扣
0.8
折扣时间
2014年12月31日 星期三 23:55
允许迟交
否
关闭时间
2014年12月31日 星期三 23:55
    假设我们有 2n 张牌，它们以 1, 2, ..., n, n+1, ..., 2n 编号并在开始时保持着这种顺序。一次洗牌就是将牌原来的次序变为 n+1, 1, n+2, 2, ..., 2n, n，也就是将原来的前 n 张牌放到位置 2, 4, ..., 2n，并且将余下的 n 张牌按照他们原来的次序放到奇数位置 1, 3, ..., 2n-1。已经证明对于任何一个自然数 n，这 2n 张牌经过一定次数的洗牌就回到原来的次序。但我们不知道对于一个特定的 n，需要几次洗牌才能将牌洗回原来的次序。
输入：
    牌张数的一半n，即初始情况下一共有2n张牌，n为int型整数
输出：
    将牌洗回原来的次序所需要的洗牌次数

测试输入
期待的输出
时间限制
内存限制
额外进程
测试用例 1
以文本方式显示
1. 10↵
以文本方式显示
1. 6↵
1秒
64M
0
测试用例 2
以文本方式显示
1. 20↵
以文本方式显示
1. 20↵
1秒
64M
0
Code：
#include
int main()
{
int a[10000],tmp1[5000],tmp2[5000], i, m, n = 0, log = 0, total = 0;
scanf("%d",&i);
//
for(m = 0; m < 2* i; m++)
a[m] = m;
do{
for(m = 0; m < i; m++)
{
tmp1[m] = a[m];
tmp2[m] = a[m + i];
}
n = 0;
for(m = 0; m < i; m++)
{
a[n] = tmp2[m];