中国石油大学（华东）C语言参考题库

目录

c语言

【研究创新型】8.1 谁能出线

背景：
电视台举办“超级学生”才艺大赛，由于报名人数狂多，所以要先进行分组预赛。按规定，每10名学生为一个预赛小组，评委打出分数（0~100分），各小组第一名可以进入下一轮；如果有多名学生得分相同都是第一名，则可同时进入下一轮。
输入：
 按顺序给出一个小组10个人的最后得分（int）。
输出：
 能够出线的学生序号（0~9）。

#include <bits/stdc++.h>

using namespace std;

int main()
{
    int score[10], max_score = 0;
    for(int i = 0;i < 10;i++)
    {
        scanf("%d", &score[i]);
        max_score = max(max_score, score[i]);
    }
    printf("能够出现的学生序号如下：\n");
    for(int i = 0;i < 10;i++)
        if(score[i] == max_score)
            printf("%d ", i);
    printf("\n");
    return 0;
}

【设计型】8.2 统计素数的个数

求出 2 到 m 之间 ( 含 m，m<=1000) 所有素数并放在数组 a 中。
输入：正整数m
输出：从小到大的所有素数，及个数（素数输出的时候用%4d来控制）
如：
输入：10
输出：2 3 5 7
4

#include <bits/stdc++.h>

using namespace std;

bool is_prime(int number)
{
    for(int i = 2;i * i <= number;i++)
        if(number % i == 0)
            return false;
    return true;
}
int main()
{
    int m, prime_cnt = 0;
    scanf("%d", &m);
    for(int i = 2;i <= m;i++)
        if(is_prime(i))
        {
            printf("%4d", i);
            prime_cnt++;
        }
    printf("\n%d\n", prime_cnt);
}

// 筛选法， 将素数的倍数筛走
int prime[NMAX], isw[NMAX], tot;

void get_prime(int n)  
{
    for(int i = 2;i <= n;i++)
	{
		if(!isw[i])
		{
		    prime[++tot] = i;
		    for(int j = 2*i;j <= n;j += i)
		        isw[j] = 1;
		}
	}
}

【设计型】8.3 数组逆序输出

问题描述
从键盘上输入一个数组（10个元素），将原数组逆序重新排列后输出。要求输出每个元素时以一个空格隔开。
提示：
用第一个与最后一个交换。

#include <bits/stdc++.h>

using namespace std;

int main()
{
    int a[10], temp;
    for(int i = 0;i < 10;i++)
        scanf("%d", &a[i]);
    puts("逆转前数组输出");
    for(int i = 0;i < 10;i++)
        printf("%d%c", a[i], i == 9?'\n':' ');
    for(int i = 0;i < 5;i++)
    {
        temp = a[i];
        a[i] = a[9 - i];
        a[9 - i] = temp;
        // c++ 可以用swap(a[i], a[9-i])交换
    }
    puts("逆转后数组输出");
    for(int i = 0;i < 10;i++)
        printf("%d%c", a[i], i == 9?'\n':' ');
    return 0;
}

【设计型】8.4 在屏幕上显示杨辉三角形

杨辉三角形，又称贾宪三角形，帕斯卡三角形，是二项式系数在三角形中的一种几何排列。
　　其实，中国古代数学家在数学的许多重要领域中处于遥遥领先的地位。中国古代数学史曾经有自己光辉灿烂的篇章，而贾宪三角的发现就是十分精彩的一页。
杨辉三角有如下性质：
1、每行数字左右对称，由1开始逐渐变大，然后变小，回到1。
2、第n行的数字个数为n个。
3、每个数字等于上一行的左右两个数字之和。
编写程序，输入正数n， 将所有数据存储到二维数组中，并在屏幕上显示对应的杨辉三角形(注意数据之间的空格）。例如:n=5  图形如下：

#include <bits/stdc++.h>

using namespace std;
const int NMAX = 25;
int c[NMAX][NMAX];
int main()
{
    c[0][0] = 1;
    int n;
    scanf("%d", &n);
    for(int i = 1;i <= n;i++)
        for(int j = 0;j <= n;j++)
            if(j == 0)
                c[i][j] = c[i-1][j];
            else
                c[i][j] = c[i-1][j] + c[i-1][j-1];
    for(int i = 0;i <= n;i++)
        for(int j = 0;j <= i;j++)
            printf("%3d%c",c[i][j], j == i?'\n':' ');
    return 0;
}

【设计型】8.5 求最大值

问题描述
要求从键盘输入10个整型数据，找出其中的最大值并显示出来。
输入范例
3  0  54  -710  27  32767  10  1  500  2
输出范例
32767
提示
先假定第一个元素时最大值，然后和其他的元素一个一个的进行比较，直到找到最大值。

#include <bits/stdc++.h>

using namespace std;
const int NMAX = 25;
int number[NMAX];
int main()
{
    int n = 10, max_idx = 0;
    for(int i = 0;i < n;i++) 
        scanf("%d", &number[i]);
    for(int i = 0;i < n;i++)
        if(number[max_idx] < number[i])
            max_idx = i;
    printf("最大值为%d\n", number[max_idx]);
    return 0;
}

【设计型】8.6 二维数组

问题描述：
程序定义了 4× 4 的二维数组，请编写程序，给二维数组赋值，并使数组下半三角元素中的值乘以n 。
例如：
       数组中的值为
\(\begin{bmatrix}1&2&3&4\\2&2&3&4\\3&2&3&4\\4&2&3&4\end{bmatrix}\)
假设n为10，则输出结果如下：（输出的数按照4位宽度来输出，即%4d）
\(\begin{bmatrix}10&2&3&4\\20&20&3&4\\30&20&30&4\\40&20&30&40\end{bmatrix}\)

#include <bits/stdc++.h>

using namespace std;
const int NMAX = 25;
int number[NMAX];
int main()
{
    int arr[4][4] = {
        1, 2, 3, 4,
        2, 2, 3, 4,
        3, 2, 3, 4,
        4, 2, 3, 4
    };
    int n;
    scanf("%d", &n);
    for(int i = 0;i < 4;i++)
        for(int j = 0;j <= i;j++)
            arr[i][j] *= n;
    for(int i = 0;i < 4;i++)
        for(int j = 0;j < 4;j++)
            printf("%4d%c", arr[i][j], j == 3?'\n':' ');
    return 0;
}

【设计型】8.11 存储并输出一个矩阵

编程，输入 n ，存储并输出如下例（ n=5 ）所示的 图形。
1 2 3 4 5
1 1 2 3 4
1 1 1 2 3
1 1 1 1 2
1 1 1 1 1

#include <bits/stdc++.h>
 
using namespace std;
const int NMAX = 3000;
 
int matrix[NMAX][NMAX];
 
void solve(int n)
{
    for(int i = 0;i < n;i++)
        for(int j = 0;j < n;j++)
            matrix[i][j] = max(1, j - i + 1);   // 通过最后一列，发现规律5，4，3，2，1
}
 
void print(int n)
{
    for(int i = 0;i < n;i++)
        for(int j = 0;j < n;j++)
            printf("%d%c", matrix[i][j], j == n-1?'\n':' ');  // 双目运算符
}
int main()
{
    int n;
    scanf("%d", &n);
    solve(n);
    print(n);
    return 0;
}

【设计型】8.7 给数组中的元素按顺序编号

对数组 a[10] 中的十个整数从小到大进行连续编号，输出各个元素的编号。要求不能改变数组 a 中元素的顺序，且相同的整数要具有相同的编号。例如数组是： A=(5,3,4,7,3,5,6,8,9,10) 则输出为：　 (4,1,3,7,1,4,6,8,9,10)

对于某个数的编号位当前数字比他小的个数+1

暴力
#include <stdio.h> 

int main() 
{
    int a[10], b[10]; 
    for(int i=0;i<10;i++) 
        scanf("%d", &a[i]); 
    for(int i=0;i<10;i++) 
    {  
        int less_cnt = 0;
        for(int j=0;j<10;j++)  
        {  
            if(a[i] > a[j]) 
                less_cnt++;
        }  
        b[i] = less_cnt + 1; 
    }  
    for(int i=0;i<10;i++) 
        printf("%d%c",b[i], i == 9?'\n':' ');
    return 0; 
}

tips: 若n很大， a[i]数字很小，可以使用差分数组

【设计型】8.8 求各位数字组成的最大数

任意输入一个自然数，输出该自然数的各位数字组成的最大数。例如，输入 1593 ，则输出为 9531 。
输入： 自然数 n
输出： 各位数字组成的最大数

可以讲自然数用字符串输入，然后进行从大到小的排序
手写排序算法 或 调用STL的sort都行

#include <bits/stdc++.h>
using namespace std;

int cmp(char a, char b)
{
    return a > b;
}
int main() 
{
    char n[100];
    int n_len;
    scanf("%s", n);
    n_len = strlen(n);
    sort(n, n + n_len, cmp);
    puts(n);
    return 0; 
}

【设计型】8.9冒泡法排序

冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。 　　由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。
编写程序，对输入的十个数按照从小到大排序

#include <bits/stdc++.h>
using namespace std;

void bubble_sort(int arr[], int n)
{
    int temp;
    bool flag = true;
    for(int i=0;flag && i<10;i++) 
    {
        flag = false;
        for(int j=9;j>i;j--) 
            if(arr[j-1] > arr[j]) 
            { 
                temp = arr[j-1]; 
                arr[j-1] = arr[j]; 
                arr[j] = temp; 
                flag = true;
            } 
    }
}
int main() 
{ 
    int a[10]; 
    for(int i=0;i<10;i++)
        scanf("%d", &a[i]); 
    bubble_sort(a, 10);
    for(int i=0;i<10;i++) 
        printf("%d%c",a[i], i == 9?'\n':' '); 
    return 0;
}

【设计型】8.10 插入法排序

如果一个数组中保存的元素是有序的（由小到大），向这个数组中插入一个数，使得插入后的数组元素依然保持有序。
定义一个数组，长度为11，初始元素为10个，按照从小到大的方式输入，然后输入一个要插入的元素，使得插入后仍然有序。

#include <bits/stdc++.h>
using namespace std;

void solve(int arr[], int &arr_len, int number)
{
    int idx = arr_len;
    while(idx && arr[idx - 1] > number)
    {
        arr[idx] = arr[idx - 1];
        idx--;
    }
    arr[idx] = number;
    arr_len++;
}

int main() 
{ 
    int arr[11], arr_len = 10, number; 
    for(int i = 0;i < arr_len;i++)
        scanf("%d", &arr[i]); 
    scanf("%d", &number);
    solve(arr, arr_len, number);
    for(int i = 0;i < arr_len;i++)
        printf("%d%c", arr[i], i == arr_len - 1?'\n':' ');
    return 0;
}

【设计型】10.1 字符转换

描述
提取一个字符串中的所有数字字符（‘0’...‘9’）将其转换为一个整数输出。
输入
一个以回车符为结束标志的字符串（少于80个字符）。
输出
把字符串中的所有数字字符（‘0’...‘9’）转换为一个整数并输出。

#include <bits/stdc++.h>
 
using namespace std;
 
int main()
{
    char str[80], number[80];
    int number_len = 0;
    gets(str); // 不建议写， 可以用c++的getline(cin, string) // cin， string类型
    bool is_cover_number = false;
    int str_len = strlen(str);
    for(int i = 0; i < str_len; ++i)   // 这可以用str[i] != '\0'作为终止条件
    {
        if(str[i] >= '0' && str[i] <= '9')
        {
            is_cover_number = true;
            if(number_len > 0 && number[0] == '0')
                number[0] = str[i];
            else
                number[number_len++] = str[i];
        }
    }
    number[number_len] = '\0';
    if(not is_cover_number)
        printf("该字符串不包含数字!!!\n");
    else
        printf("数字为%s\n", number);
    return 0;
}

【设计型】10.2 合并字符串

输入两个已经按从小到大顺序排列好的字符串，编写一个合并两个字符串的函数，使合并后的字符串，仍然是从小到 大排列。
输入：
两个已经排好顺序（升序）的字符串
输出：
一个合并在一起的有序（升序）的字符串
要求：
设计一个效率尽量高的算法，对每个字符串只扫描一遍就可以了。
如果采用先进行串连接，然后再进行排序的算法，则效率太低了。

#include <bits/stdc++.h>
using namespace std;

void merge(char str1[], char str2[], char str3[])
{
    int idx1 = 0, idx2 = 0,idx3 = 0;
    while(str1[idx1] != '\0' && str2[idx2] != '\0')
    {
        if(str1[idx1] <= str2[idx2])
            str3[idx3++] = str1[idx1++];
        else
            str3[idx3++] = str2[idx2++];
    }
    while(str1[idx1] != '\0')
        str3[idx3++] = str1[idx1++];
    while(str2[idx2] != '\0')
        str3[idx3++] = str2[idx2++];
    str3[idx3] = '\0';
}
int main() 
{ 
    char str1[20], str2[20], str3[40];
    scanf("%s%s", str1, str2);
    merge(str1, str2, str3);
    puts(str3);
    return 0;
}

【设计型】10.3 删除重复字符

背景：
输入一个长度不超过 100 的字符串，删除串中的重复字符。
输入：
输入要检查的字符串，长度不超过100个字符。例如：abacaeedabcdcd。
输出：
删除重复字符后的字符串。例如：abced。

#include <bits/stdc++.h>
using namespace std;

void unique_str(char str[], char str_unique[])
{
    bool vised[128]; // ASCII 共有128个字符
    int str_idx = 0, idx = 0;
    fill(vised, vised+128, false);
    while(str[str_idx] != '\0')
    {
        if(!vised[str[str_idx]])
        {
            str_unique[idx++] = str[str_idx];
            vised[str[str_idx]] = true; 
        }
        str_idx++;
    }
    str_unique[idx] = '\0';
} 
int main() 
{ 
    char str[100], str_unique[100];
    scanf("%s", str);
    unique_str(str, str_unique);
    puts(str_unique);
    return 0;
}

【设计型】10.4 单词有多少

用空格或换行分开的字符串称为单词。输入多行字符串，直到遇到了单词 "stop" 时才停止。最后输出单词的数量。用于分割单词的空格或换行可能多于1个。
输入： 多个字符串
输出： 单词的数量

#include <bits/stdc++.h>
using namespace std;

int main() 
{ 
    char str[20];
    int count = 0;
    scanf("%s", str);
    while(strcmp(str, "stop") != 0)
    {
        if(strcmp(str, " ") != 0 || strcmp(str, "\n") != 0)
            count++;
        scanf("%s", str);
    }
    printf("有%d个单词\n", count+1); // 加上stop这个单词
    return 0;
}

【设计型】10.5 在指定位置插入字符串

输入两个字符串 s1 、 s2 和 s1 中任意字符 k ，在 s1 中的指定字符 k 第一次出现的位置处插入字符串 s2 并输出。
输入： 两个字符串 s1 、 s2 和 s1 中任意字符 k
输出： 插入后的字符串 s1

#include <bits/stdc++.h>
using namespace std;

void solve(char str1[], char str2[], char ch)
{
	int idx1 = 0, str_len1, str_len2;
	str_len1 = strlen(str1);
	str_len2 = strlen(str2);
	str1[str_len1 + str_len2] = '\0';
	while(idx1 < str_len1 && str1[idx1] != ch)
		idx1++;
	for(int i = str_len1 - 1;i >= idx1;i--)
		str1[str_len2 + i] = str1[i];
	for(int i = 0;i < str_len2;i++)
		str1[idx1++] = str2[i];
}
int main(int argc, char const *argv[])
{
	char str1[30], str2[20], ch;
	scanf("%s%s", str1, str2);
	getchar();
	ch = getchar();
	solve(str1, str2, ch);
	puts(str1);
	return 0;
}

【研究创新型】10.6 大数相加

问题描述：
编写C程序，它能以字符串形式读入两个无符号正整数m和n，计算并输出这两个整数之和
输入格式：
输入由两行组成，第一行为无符号整数m，第二行为无符号整数n，且m和n的值最长25位
输出格式：
输出为一行，即两个无符号整数m和n之和
输入样例：
9999888888
355729288
输出样例：
10355618176

#include <bits/stdc++.h>
using namespace std;

char *number_add(char num1[], char num2[])
{
	char *num3;
	int num_len1, num_len2, num_len3;
	num_len1 = strlen(num1);
	num_len2 = strlen(num2);
	num_len3 = max(num_len1, num_len2) + 1;
	num3 = (char *)malloc(sizeof(char) * (num_len3 + 1));
	num3[num_len3] = '\0';
	int num_idx1 = num_len1, num_idx2 = num_len2, num_idx3 = num_len3;
	int carry = 0;
	while(num_idx1 || num_idx2)
	{
		int sum = carry;
		if(num_idx1)
			sum += num1[--num_idx1] - '0';
		if(num_idx2)
			sum += num2[--num_idx2] - '0';
		num3[--num_idx3] = sum % 10 + '0';
		carry = sum / 10;
	}
	if(carry)
		num3[--num_idx3] = carry + '0';
	return num3 + num_idx3;
}

int main(int argc, char const *argv[])
{
	char num1[30], num2[30], *num3;
	scanf("%s%s", num1, num2);
	num3 = number_add(num1, num2);
	puts(num3);
	return 0;
}

【设计型】10.7 找第一个只出现一次的字符

问题描述：
给定t个字符串，这个字符串只可能由26个小写字母组成，请你找到第一个仅出现一次的字符，如果没有符合要求的字符，就输出no。
输入：
第一行是t，接下来是t个字符串，每个字符串长度小于100
输出：
你的输出需要由t行组成。
对于每个字符串，输出第一个仅出现一次的字符，没有输出NO。
输入样例：
2
aabb
abcdab
输出样例：
NO
c

#include <bits/stdc++.h>
using namespace std;

int find_first_once(char str[])
{
	int cnt[26]; // 因为只有26个小写字母，用cnt充当映射，判断这26个字母出现的次数
	for(int i = 0; str[i] != '\0';i++)
		cnt[str[i] - 'a']++;
	for(int i = 0; str[i] != '\0';i++)
		if(cnt[str[i] - 'a'] == 1)
			return i;
	return -1;
}

int main(int argc, char const *argv[])
{
	char str[100];
	int t;
	scanf("%d", &t);
	while(t--)
	{
		scanf("%s", str);
		int idx = find_first_once(str);
		if(idx == -1)
			puts("NO");
		else
			printf("%c\n", str[idx]);			
	}
	return 0;
}

【设计型】10.8 首字母大写

对一个字符串中的所有单词，如果单词的首字母不是大写字母，则把单词的首字母变成大写字母。在字符串中，单词之间通过空白符分隔，空白符包括：空格(' ')、制表符('\t')、回车符('\r')、换行符('\n')。
关于输入
输入一行：待处理的字符串（长度小于80）。
关于输出
输出一行：转换后的字符串。

#include <bits/stdc++.h>
using namespace std;

bool is_letter(char ch)
{
	return ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'z';
}

void solve(char str[])
{
	bool is_upper = true;
	for(int i = 0; str[i] != '\0';i++)
		if(is_letter(str[i]))
		{
			if(is_upper && str[i] >= 'a' && str[i] <= 'z')
				str[i] = 'A' + str[i] - 'a';
			is_upper = false;
		}
		else
			is_upper = true;
}

int main(int argc, char const *argv[])
{
	char str[80];
	gets(str);
	solve(str);
	puts(str);
	return 0;
}

【设计型】10.9 字符串重排列

判断一个字符串是否可以由另一个字符串通过重排字符而得到。注意，此处区分字符大小写！
输入
输入只有一行，为两个字符串，字符串之间以一个空格分隔。
输出
如果两个字符串由同一组字符组成（且每一个字符出现次数相同），则输出“YES”；
否则输出“NO”。注意YES和NO都是大写字母！

#include <bits/stdc++.h>
using namespace std;

int solve(char str1[], char str2[])
{
	int str_len1 = strlen(str1), str_len2 = strlen(str2);
	if(str_len1 != str_len2)  
		return 0*printf("NO\n");
	int cnt[128]; // a-z, A-Z 使用其ASCII码作为唯一值，cnt为str1当前字母出现的次数
	for(int i = 0; str1[i] != '\0';i++)
		cnt[str1[i]]++;
	for(int i = 0; str2[i] != '\0';i++)
	{
		if(!cnt[str2[i]])   // 若str1中的str2[i]字母数不足，则为NO
			return 0*printf("NO\n");
		else
			cnt[str2[i]]--;
	}
	puts("YES");
	return 0;
}

int main(int argc, char const *argv[])
{
	char str1[80], str2[80];
	scanf("%s%s", str1, str2);
	solve(str1, str2);
	return 0;
}

【设计型】10.10 提取数据

输入一个字符串，长度不超过30，内有数字字符和非数字字符，统计其中包含了多少个非负整数，并输出这样的非负整数。

#include <bits/stdc++.h>
using namespace std;

void solve(char str[], int num[], int &cnt)
{
	bool is_positive = true;
	int number = 0;
	for(int i = 0;str[i] != '\0';i++)
	{
		if(str[i] < '0' || str[i] > '9')
		{
			if(is_positive && number > 0)
				num[cnt++] = number;
			is_positive = true;
			if(str[i] == '-')
				is_positive = false;
			number = 0;
		}
		else
		{
			if(is_positive)
				number = number * 10 + str[i] - '0';
		}
	}
	if(number > 0)
		num[cnt++] = number;
}

int main(int argc, char const *argv[])
{
	char str[80];
	int num[80], cnt = 0;
	scanf("%s", str);
	solve(str, num, cnt);
	printf("%d\n", cnt);
	for(int i = 0;i < cnt;i++)
		printf("%d%c",num[i], i == cnt-1?'\n':' ');
	return 0;
}

【设计型】9.5 删除指定字符

请编写函数fun，其功能是：从字符串中删除指定的字符。同一字母的大、小写按照不同的字符处理。

#include <bits/stdc++.h>
using namespace std;

void fun(char str[], char ch)
{
	int idx1 = 0, idx2 = 0;
	while(str[idx1] != '\0')
	{
		if(str[idx1] != ch)
			str[idx2++] = str[idx1];
		idx1++;
	}
	str[idx2] = '\0';
}

int main(int argc, char const *argv[])
{
	char str[80], ch;
	scanf("%s", str);
	getchar();
	ch = getchar();
	fun(str, ch);
	puts(str);	
	return 0;
}

【设计型】9.9 偶数分解

编写程序，输入若干个大于2的正整数，如果是偶数，则将其分解为两个素数（只需找出第一对素数）并输出；如果输入的奇数，则输出“××× is odd number!” ；输入为0时程序结束。只有1和它本身这两个因数的自然数叫做素数，0和1既不是素数也不是和数。
输入：整数序列，0
输出：偶数1 = 素数A + 素数B （当输入是偶数时）
         奇数1 is odd number!  （当输入是奇数时）

#include <bits/stdc++.h>
using namespace std;

bool is_prime(int number)
{
	for(int i = 2;i * i <= number;i++)
		if(number % i == 0)
			return false;
	return true;
}
int main(int argc, char const *argv[])
{
	int number;
	while(scanf("%d", &number) && number)
	{
		if(number % 2 == 0)
		{
			for(int i = 2;i <= number/2;i++)
				if(is_prime(i) && is_prime(number - i))
					printf("%d = %d + %d\n", number, i, number - i);
		}
		else
			printf("%d is odd number!\n", number);
	}	
	return 0;
}

【设计型】9.11 长整型截短

编写一个函数fun，其功能是：将形参n中，各位上为偶数的数取出，并按原来从高位到低位的顺序组成一个新的数，并作为函数值返回。

#include <bits/stdc++.h>
using namespace std;

int fun(int number)
{
	int new_number = 0, ten = 1;
	while(number)
	{
		if((number % 10)%2 == 0)
		{
			new_number = new_number + (number % 10) * ten;
			ten *= 10;
		}
		number /= 10;
	}
	return new_number;
}
int main(int argc, char const *argv[])
{
	int number, new_number;
	scanf("%d", &number);
	new_number = fun(number);
	printf("%d\n", new_number);
	return 0;
}

【设计型】7.1 数的合并

请编写函数fun，其功能是：将两个两位数的正整数a、b合并形成一个整数放在c中。合并的方式是：将a的十位和个位依次存放在c数的十位和千位上，b的十位和个位依次存放在c数的个位和百位上。
例如：当a=45，b=12，调用该函数后，c=5241。
部分源程序如下，只需要完成fun函数的编写即可。

#include <bits/stdc++.h>
using namespace std;

int fun(int a, int b)
{
	return (a%10)*1000 + (b%10)*100 + (a/10)*10 + b/10;
}
int main(int argc, char const *argv[])
{
	int a, b, c;
	scanf("%d%d", &a, &b);
	c = fun(a, b);
	printf("%d\n", c);
	return 0;
}

【设计型】7.2 数组中奇偶数

请编一个函数 fun,函数的功能是分别求出数组中所有奇数之和以及所有偶数之和。形参 n 给了数组中数据的个数：利用指针 odd 返回奇数之和，利用指针 even 返回偶数之和。
例如：数组中的值依次为： 1 ， 8 ， 2 ， 3 ， 11 ， 6 ；则利用指针 odd 返回奇数之和 15 ；利用指针 even 返回偶数之和 16 。

一级指针，fun传递的指针，必须分配地址
#include <bits/stdc++.h>
using namespace std;

void fun(int a[], int n,int *odd, int *even)
{
	*odd = 0;
	*even = 0;
	for(int i = 0;i < n;i++)
	{
		if(a[i] % 2 == 0)
			*even = *even + a[i];
		else
			*odd = *odd + a[i];
	}
}
int main(int argc, char const *argv[])
{
	int a[20], n, *odd, *even;
	odd = (int *)malloc(sizeof(int));
	even = (int *)malloc(sizeof(int));
	scanf("%d", &n);
	for(int i = 0;i < n;i++)	scanf("%d", &a[i]);
	fun(a, n, odd, even);
	printf("odd sum is %d, even sum is %d\n", *odd, *even);
	return 0;
}

二级指针
#include <bits/stdc++.h>
using namespace std;

void fun(int a[], int n,int **odd, int **even)
{
	*odd = (int *)malloc(sizeof(int));
	*even = (int *)malloc(sizeof(int));
	**odd = 0;
	**even = 0;
	for(int i = 0;i < n;i++)
	{
		if(a[i] % 2 == 0)
			**even = **even + a[i];
		else
			**odd = **odd + a[i];
	}
}
int main(int argc, char const *argv[])
{
	int a[20], n, *odd, *even;
	scanf("%d", &n);
	for(int i = 0;i < n;i++)	scanf("%d", &a[i]);
	fun(a, n, &odd, &even);
	printf("odd sum is %d, even sum is %d\n", *odd, *even);
	return 0;
}

【设计型】7.3 浮点数四舍五入

请编一个函数 void fun(double a,double *h) ，函数的功能是对变量 h 中的值保留 2 位小数，并对第三位进行四舍五入（规定 h 中的值为正数）。
例如： h 值为 8.32433 ，则函数返回 8.32 ；
h 值为 8.32533 ，则函数返回 8.33 。

#include <bits/stdc++.h>
using namespace std;

void fun(double a, double *h)
{
	a += 0.005;
	int number = a * 100;
	*h = 1.0*number / 100;
}
int main(int argc, char const *argv[])
{
	double a, *h;
	h = (double *)malloc(sizeof(double));
	scanf("%lf", &a);
	fun(a, h);
	printf("%.2lf\n", *h);
	return 0;
}

【设计型】7.4 字符移动

请编一个函数void fun(char *s) ，函数的功能是把字符串中所有的字符前移一个位置，串中的第一个字符移到最后。
例如：原有的字符串为： Mn.123xyZ ，则调用该函数后，串中的内容为： n.123xyZM 。

#include <bits/stdc++.h>
using namespace std;

void fun(char *s)
{
	char *p = s;
	char ch = *s;
	p++;
	while(*p != '\0')
	{
		*(p-1) = *p;
		*p = ch;
		p++;
	}
}
int main(int argc, char const *argv[])
{
	char str[30];
	scanf("%s", str);
	fun(str);
	puts(str);
	return 0;
}

【设计型】7.5 生成新数

给定程序中，函数fun的功能是：将形参n所指变量中，各位上为偶数的数去除,剩余的数按原来从高位到低位的顺序组成一个新的数，并通过形参指针n传回所指变量。
例如，输入一个数：27638496，新的数：为739。

#include <bits/stdc++.h>
using namespace std;

void fun(int *number)
{
	int new_number = 0, ten = 1; 
	while(*number)
	{
		if((*number % 10) % 2 != 0)
		{
			new_number = new_number + (*number % 10) * ten;
			ten *= 10;
		}
		*number /= 10;
	}
	*number = new_number;
}
int main(int argc, char const *argv[])
{
	int number;
	scanf("%d", &number);
	fun(&number);
	printf("%d\n", number);
	return 0;
}

【设计型】7.6 字符串转换成整数

请编写一个函数fun，它的功能是：将一个数字字符串转换为一个整数。例如，若输入字符串"-1234",则函数把它转换为整数值 -1234。

#include <bits/stdc++.h>
using namespace std;

int fun(char *str)
{
	int number = 0;
	bool is_positive = true;
	for(int i = 0; str[i] != '\0';i++)
	{
		if(str[i] == '-')
			is_positive = false;
		if(str[i] >= '0' && str[i] <= '9')
			number = number * 10 + str[i] - '0';
	}
	if(!is_positive)
		number *= -1;
	return number;
}
int main(int argc, char const *argv[])
{
	char str[20];
	int number;
	scanf("%s", str);
	number = fun(str);
	printf("%d\n", number);
	return 0;
}

【设计型】7.7 二维数组按列优先存放

请编写函数fun, 函数的功能是: 将M行N列的二维数组中的字符数据, 按列的顺序依次放到一个字符串中。
例如, 二维数组中的数据为:
W W W W
S   S   S  S
H  H   H  H
则字符串中的内容应是: WSHWSHWSHWSH。

#include <bits/stdc++.h>
using namespace std;
const int N = 10;
const int M = 10;

void fun(char arr[][M], int n, int m, char *str)
{
	int idx = 0;
	for(int i = 0;i < m;i++)
		for(int j = 0;j < n;j++)
			str[idx++] = arr[j][i];
	str[idx] = '\0';
}
int main(int argc, char const *argv[])
{
	char arr[N][M], str[N*M];
	int n = 3, m = 4;
	for(int i = 0;i < n;i++)
		scanf("%s", arr[i]);
	fun(arr, n, m, str);
	puts(str);
	return 0;
}

【设计型】7.8 删除字符串中指定的星号

假定输入的字符串中只包含字母和 * 号。请编写函数 fun ，它的功能是：除了尾部的 * 号之外 , 将字符串中其它 * 号全部删除。在编写函数时，不得使用 C 语言提供的字符串函数。
例如，字符串中的内容为： ABCDEFG****** ，删除后 , 字符串中的内容应当是： ABCDEFG******* 。

#include <bits/stdc++.h>
using namespace std;


void fun(char str[])
{
	int idx1 = 0, idx2 = 0;
	while(str[idx1] != '\0')
	{
		if(str[idx1] != '*')
			str[idx2++] = str[idx1];
		idx1++;
	}  // 先将不是*的字符保存在str中，与之前【设计型】9.5 删除指定字符类似操作
	while(idx1 > 0 && str[idx1-1] == '*')
	{
		str[idx2++] = '*';
		idx1--;
	} // 将最后的*保存str
	str[idx2] = '\0';
}
int main(int argc, char const *argv[])
{
	char str[50];
	scanf("%s", str);
	fun(str);
	puts(str);
	return 0;
}

【设计型】7.10 将两个串按要求形成一个新串

给定程序的函数 fun 的功能是：逐个比较 p 、 q 所指两个字符串对应位置中的字符，把 ASCII 值大或相等的字符依次存放到 c 所指数组中，形成一个新的字符串。
例如，若主函数中 a 字符串为： aBCDeFgH ，主函数中 b 字符串为：ABcd ，则 c 中的字符串应为： aBcdeFgH 。

#include <bits/stdc++.h>
using namespace std;

void fun(char str1[], char str2[], char str3[])
{
	int str_idx1 = 0, str_idx2 = 0, str_idx3 = 0;
	while(str1[str_idx1] != '\0' && str2[str_idx2] != '\0')
	{
		str3[str_idx3++] = max(str1[str_idx1], str2[str_idx2]);
		str_idx1++;
		str_idx2++;
	}
	while(str1[str_idx1] != '\0')
		str3[str_idx3++] = str1[str_idx1++];
	while(str2[str_idx2] != '\0')
		str3[str_idx3++] = str2[str_idx2++];
	str3[str_idx3] = '\0';
}
int main(int argc, char const *argv[])
{
	char str1[50], str2[50], str3[50];
	scanf("%s%s", str1, str2);
	fun(str1, str2, str3);
	puts(str3);
	return 0;
}

【设计型】7.12 按要求处理字符串函数 fun 的功能是： 将 s 所指字符串中除了下标为奇数、同时 ASCII 值也为奇数的字符之外，其余的所有字符都删除 , 串中剩余字符所形成的一个新串放在 t 所指的数组中。

例如，若 s 所指字符串中的内容为： "ABCDEFG12345", 其中字符 A 的 ASCII 码值虽为奇数，但所在元素的下标为偶数，因此必需删除；而字符 1 的 ASCII 码值为奇数，所在数组中的下标也为奇数 , 因此不应当删除，其它依此类推。最后 t 所指的数组中的内容应是： "135" 。

#include <bits/stdc++.h>
using namespace std;

void fun(char s[], char t[])
{
	int idx1 = 0, idx2 = 0;
	while(s[idx1] != '\0')
	{
		if(idx1 % 2 == 1 && s[idx1] % 2 == 1)
			t[idx2++] = s[idx1];
		idx1++;
	}
	t[idx2] = '\0';
}
int main(int argc, char const *argv[])
{
	char s[50], t[50];
	scanf("%s", s);
	fun(s, t);
	puts(t);
	return 0;
}

【设计型】7.14 求最大值及其下标

请编写函数 fun ，其功能是求出数组的最大元素在数组中的下标并存放在 k 所指的存储单元中。
例如 , 输入如下整数 : 876 675 896 101 301 401 980 431 451 777
则输出结果为 : 6, 980

#include <bits/stdc++.h>
using namespace std;

int find_max_index(int arr[], int n)
{
	int max_index = 0;
	for(int i = 0;i < n;i++)
		if(arr[max_index] < arr[i])
			max_index = i;
	return max_index;
}
int main(int argc, char const *argv[])
{
	int arr[60], n, max_index;
	scanf("%d", &n);
	for(int i = 0;i < n;i++)
		scanf("%d", &arr[i]);
	max_index = find_max_index(arr, n);
	printf("%d,%d\n", max_index, arr[max_index]);
	return 0;
}

【设计型】12.1 修改学生的各科成绩

给定程序通过定义并赋初值的方式，利用结构体变量存储了一名学生的学号、姓名和3门课的成绩。函数fun的功能是将该学生的各科成绩都乘以一个系数a。 请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。

#include  <stdio.h>
#include  <string.h>
#include <stdio.h>
typedef struct
{ 
    int num;
    char name[9];
    float score[3];
}STU;
void show(STU tt)
{ 
    int i;
    printf("%d %s : ",tt.num,tt.name);
    for(i=0; i<3; i++)
        printf("%5.1f",tt.score[i]);
    printf("\n");
}
/**********found**********/ 
void fun(___1___ *ss,float a) // void fun(STU *ss, float a)
{ 
    int i;
    for(i=0; i<3; i++)
/**********found**********/
    ss->___2___ *=a;	// ss->score[i] *= a;
}
int main(   )
{ 
    STU std={ 1,"Zhanghua",76.5,78.0,82.0 };
    float a;
    scanf("%f",&a);
/**********found**********/
    fun(___3___,a);	// fun(&std, a);
    show(std);
    return 0;
}

【设计型】12.2 修改学生信息

程序通过定义学生结构体变量，存储了学生的学号、姓名和 3 门课的成绩。函数 fun 的功能是对形参 b 所指结构体变量中的数据进行修改 , 最后在主函数中输出修改后的数据。
例如 : b 所指变量 t 中的学号、姓名、和三门课的成绩依次是 : 10002 、 "ZhangQi" 、 93 、 85 、 87 ，修改后输出 t 中的数据应为： 10004 、 " LiJie " 、 93 、 85 、 87 。
请在程序的下划线处填入正确的内容并把下划线删除 , 使程序得出正确的结果。
不得增行或删行，也不得更改程序的结构！

#include  <stdio.h>
#include  <string.h>
struct student
{
    long  sno;
    char  name[10];
    float  score[3];
};
void fun( struct student  *b)
{
/**********found**********/
    b__1__ = 10004;  // b->sno = 10004;
/**********found**********/
    strcpy(b__2__, "LiJie");  // strcpy(b->name, "LiJie");
}
int main()
{ 
    struct student  t={10002,"ZhangQi", {93, 85, 87}};
    int  i;
/**********found**********/
    fun(__3__);	// fun(&t);
    printf("No: %ld  Name: %s\nScores:",t.sno, t.name);
    for (i=0; i<3; i++)  printf("%6.2f", t.score[i]);
    printf("\n");
    return 0;
}

【设计型】12.3 学生信息的排序

程序通过定义学生结构体数组，存储了若干名学生的学号、姓名和 3 门课的成绩。函数 fun 的功能是将存放学生数据的结构体数组，按照姓名的字典序（从小到大）排序。
请在程序的下划线处填入正确的内容并把下划线删除 , 使程序得出正确的结果。

#include  <stdio.h>
#include  <string.h>
struct student 
{
    long  sno;
    char  name[10];
    float  score[3];
};
void fun(struct student  a[], int  n)
{
/**********found**********/
 __1__ t;  // struct student t;
  int  i, j;
/**********found**********/
  for (i=0; i<__2__; i++)	// for(i = 0; i < n; i++)
    for (j=i+1; j<n; j++)
/**********found**********/
      if (strcmp(__3__) > 0)	// if(strcmp(a[i].name, a[j].name) > 0)
      {  t = a[i];   a[i] = a[j];  a[j] = t;  }
}

【设计型】12.4 找出指定分数范围内的学生
学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中, 请编写函数fun，它的功能是：把指定分数范围内的学生数据放在h所指的数组中，分数范围内的学生人数由函数值返回。
例如，输入的分数是60 69, 则应当把分数在60到69的学生数据进行输出，包含60分和69分的学生数据。主函数中将把60放在low中，把69放在heigh中。

【设计型】12.5 找出分数最低的学生

学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中, 请编写函数fun，它的功能是：把分数最低的学生数据放在b所指的数组中，注意：分数最低的学生可能不止一个，函数返回分数最低的学生的人数。

【设计型】12.6 求平面上两点距离

编写程序，计算二维平面上两点p1和p2间的直线距离。
输入：两点的坐标值
输出：两点的距离
输入样例：
1 0
-1 0
输出样例：
2.000000

#include <bits/stdc++.h>
using namespace std;

struct Point{
	double x, y;
};
double get_dist(struct Point a, struct Point b)
{
	return sqrt((a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y));
}
int main(int argc, char const *argv[])
{
	Point a, b;
	scanf("%lf%lf%lf%lf", &a.x, &a.y, &b.x, &b.y);
	double dist = get_dist(a, b);
	printf("%lf\n", dist);
	return 0;
}

【设计型】12.7 加密

编写程序，按下表所示的码表将明文中指定的明码转换为暗码（其他字符不变），形成密文并输出。

明码 'a' 'b' 'd' 'z'
暗码 'd' 'z' 'a' 'b'
输入：明文
输出：与输入相对应的密文
输入样例：abort
输出：dzort 
#include <bits/stdc++.h>
using namespace std;

void decode(char str[], char out[])
{
	char map[128];  // 字符ASCII只有128个
	memset(map, 0, sizeof(char)*128);
	map['a'] = 'd';
	map['b'] = 'z';
	map['d'] = 'a';
	map['z'] = 'b';
	for(int i = 0; str[i] != '\0';i++)
	{
		if(map[str[i]] != 0)
			out[i] = map[str[i]];
		else
			out[i] = str[i];
	}
	int len = strlen(str);
	out[len] = '\0';
}
int main(int argc, char const *argv[])
{
	char str[10], out[10];
	scanf("%s", str);
	decode(str, out);
	puts(out);
	return 0;
}

【设计型】文件填空1

给定程序中,函数fun的功能是将形参中的字符串、整数、浮点数写到文本文件中，再用字符方式从此文本文件中逐个读取并显示在终端屏幕上。
请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。

#include <stdio.h>
void fun(char *s, int a, double f) 
{ 
/**********found**********/ 
__1__ fp;   // FILE* fp
char ch; 
fp = fopen("file1.txt", "__2__");  
fprintf(fp, "%s %d %f\n", s, a, f); 
fclose(fp); 
fp = fopen("file1.txt", "r"); 
ch = fgetc(fp); 
/**********found**********/ 
while (!feof(__3__)) { 
/**********found**********/ 
putchar(__4__); ch = fgetc(fp); } 
fclose(fp); 
}
int main()
{
    char a[10];
    int b;
    double c;
    scanf("%s%d%lf",a,&b,&c);
    fun(a,b,c);
    return 0;
}

【设计型】文件填空2

程序通过定义学生结构体变量，存储了学生的学号、姓名和3门课的成绩。所有学生数据均以二进制方式输出到文件中。函数fun的功能是重写形参filename所指文件中最后一个学生的数据，即用新的学生数据覆盖该学生原来的数据,其它学生的数据不变。

#include <stdio.h>
#define N 5
typedef struct student
{
    long sno;
    char name[10];
    float score[3];
} STU;
void fun(char *filename, STU n) 
{ 
    FILE *fp; 
    /**********found**********/ 
    fp = fopen(__1__, "rb+"); 
    /**********found**********/ 
    fseek(__2__, -1L*sizeof(STU), SEEK_END); 
    /**********found**********/ 
    fwrite(&n, sizeof(STU), 1, __3__); 
    fclose(fp); 
}
int main()
{
	STU t[N]={{10001,"MaChao", {91, 92, 77}},{10002,"CaoKai", {75, 60, 88}},{10003,"LiSi",{85, 70, 78}},{10004,"FangFang",{90, 82, 87}},{10005,"ZhangSan",{95, 80, 88}}};
    STU n={10006,"ZhaoSi",{55, 70, 68} },ss[N];
    int i,j; FILE *fp;
    fp = fopen("student.dat", "wb");
    fwrite(t, sizeof(STU), N, fp);
    fclose(fp);
    fp = fopen("student.dat", "rb");
    fread(ss, sizeof(STU), N, fp);
    fclose(fp);
    fun("student.dat", n);
    printf("The data after modifing :");
    fp = fopen("student.dat", "rb");
    fread(ss, sizeof(STU), N, fp);
    fclose(fp);
    for (j=0; j<N; j++)
    {
       printf("\nNo: %ld Name: %-8s Scores: ",ss[j].sno, ss[j].name);
       for (i=0; i<3; i++) printf("%.2f ", ss[j].score[i]);
    }
    printf("\n");
    return 0;
}

【设计型】文件填空3

给定程序的功能是：从键盘输入若干行文本（每行不超过80个字符），写到文件myfile4.txt中，用-1作为字符串输入结束的标志。然后将文件的内容读出显示在屏幕上。文件的读写分别由自定义函数ReadText和WriteText实现。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
/**********found**********/
void WriteText(FILE  ___1___)
{  
    char str[81];    
    gets(str);
/**********found**********/
    while(strcmp(str,"-1")___2___0) 
    {
/**********found**********/
        fputs(___3___,fw);  fputs("\n",fw);
        gets(str);
    }
}
void ReadText(FILE  *fr)
{  
    char  str[81];  
/**********found**********/  
    ___4___(str,81,fr);
/**********found**********/
    while( ___5___ ) 
    {
/**********found**********/
        printf("%s",___6___);
        fgets(str,81,fr);
    }
}
int main()
{  
    FILE  *fp;
    if((fp=fopen("myfile4.txt","w"))==NULL)
    {  printf(" open fail!!\n"); exit(0);  }
    WriteText(fp);
    fclose(fp);
    if((fp=fopen("myfile4.txt","r"))==NULL)
    {  printf(" open fail!!\n"); exit(0);  }
    ReadText(fp);
    fclose(fp);
    return 0;
}

【设计型】文件编程1（选做）

编写程序，在保存学生成绩的文本文件"student.txt"中查找指定学号的学生姓名和成绩。"student.txt"中的数据存放格式是每行对应一个学生的信息，包含学号（整型）、姓名（字符串，最长20位）和成绩（整型）3项。每个数据之间有一个空格，最后一行没有换行符。
输入：
         一个整数，表示要查找的学生的学号。
输出：
        有两行。第一行是一个字符串，表示查找到的学生的姓名；第二行是一个整数，表示查找到的学生的成绩。
输入样例：
     1101
输出样例：
    Name:ZhouPing
    Score:85
  ```c++

```
 ### 【设计型】链表编程1
N 名学生的成绩已在主函数中放入一个带头节点的链表结构中 ,h 指向链表的头节点。请编写函数 fun ，它的功能是：找出学生的最高分，由函数值返回。

【设计型】 链表填空1

给定程序中 , 函数 fun 的功能是 : 统计出带有头结点的单向链表中结点的个数 , 存放在形参 n 所指的存储单元中。
请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。

#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{  
    int data;
    struct list *next;
}SLIST;
SLIST *creatlist(int *a);
void outlist(SLIST *);
void fun( SLIST  *h, int  *n)
{  SLIST  *p;
/**********found**********/
   ___1___=0;
   p=h->next;
   while(p)
   {  (*n)++;
/**********found**********/
      p=p->___2___;
   }
}
int main()
{  SLIST  *head;
   int  a[N]={12,87,45,32,91,16,20,48}, num;
   head=creatlist(a);    outlist(head);
/**********found**********/
   fun(___3___, &num);
   printf("\nnumber=%d\n",num);
   return 0;
}

【设计型】链表填空2

给定程序中，函数 fun 的功能是 : 计算出带有头结点的单向链表中各结点数据域中值之和作为函数值返回。

#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{  int data;
   struct list *next;
} SLIST;
SLIST *creatlist(int *);
void outlist(SLIST *);
int fun( SLIST  *h)
{  SLIST  *p;         int  s=0;
   p=h->next;
   while(p)
   {
/**********found**********/
      s+= p->___1___;
/**********found**********/
      p=p->___2___;
   }
   return s;
}
int main()
{  SLIST  *head;
   int  a[N]={12,87,45,32,91,16,20,48};
   head=creatlist(a);    outlist(head);
/**********found**********/
   printf("sum=%d\n", fun(___3___));
   return 0;
}
SLIST *creatlist(int a[])
{  
    SLIST *h,*p,*q;        
    int  i;
    h=p=(SLIST *)malloc(sizeof(SLIST));
    for(i=0; i<N; i++)
    {  
        q=(SLIST *)malloc(sizeof(SLIST));
        q->data=a[i];  p->next=q;  p=q;
    }
    p->next=0;
    return h;
}
void outlist(SLIST  *h)
{  
    SLIST *p;
    p=h->next;
    if (p==NULL)  
        printf("The list is NULL!\n");
    else
    {  
        printf("Head");
        do
        {  printf("->%d", p->data); p=p->next;  }
        while(p!=NULL);
        printf("->End\n");
    }
}

【设计型】链表填空3

给定程序中，函数 fun 的功能是 : 在带有头结点的单向链表中，查找数据域中值为 ch 的结点。找到后通过函数值返回该结点在链表中所处的顺序号；若不存在值为 ch 的结点，函数返回 0 值。

#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{  
    int data;
    struct list *next;
} SLIST;
SLIST *creatlist(char  *);
void outlist(SLIST  *);
int fun( SLIST  *h, char  ch)
{  
    SLIST  *p;        
    int  n=0;
    p=h->next;
/**********found**********/
    while(p!=___1___)
    {   
        n++;
/**********found**********/
        if (p->data==ch)  
            return ___2___;
        else  p=p->next;
    }
    return 0;
}
int main()
{  
    SLIST *head;       
    int k;      
    char ch;
    char a[N]={'m','p','g','a','w','x','r','d'};
    head=creatlist(a);
    outlist(head);
    scanf("%c",&ch);
/**********found**********/
    k=fun(___3___);
    if(k==0)   
        printf("Not found!\n");
    else       
        printf("The sequence number is : %d\n",k);
    return 0;
}
SLIST *creatlist(char *a)
{  
    SLIST *h,*p,*q;      
    int  i;
    h=p=(SLIST *)malloc(sizeof(SLIST));
    for(i=0; i<N; i++)
    {  
        q=(SLIST *)malloc(sizeof(SLIST));
        q->data=a[i];  
        p->next=q;  
        p=q;
    }
    p->next=0;
    return h;
}
void outlist(SLIST *h)
{  
    SLIST *p;
    p=h->next;
    if (p==NULL)  
        printf("\nThe list is NULL!\n");
    else
    {  
        printf("Head");
        do
        {   printf("->%c",p->data);  p=p->next;  }
        while(p!=NULL);
        printf("->End\n");
    }
}

串1中包含串2的个数

求子串函数strstr()的用法

include <string.h>

char *strstr( const char *str1, const char *str2 );
功能：函数返回一个指针，它指向字符串str2 首次出现于字符串str1中的位置，
如果没有找到，返回NULL。

大数的阶乘

判断回文数

输入一个数，判断是否为回文数
如果是，输出Yes，否则输出No.

#include <bits/stdc++.h>
using namespace std;

int get_rev_number(int number)
{
	int rev_number = 0;
	while(number)
	{
		rev_number = rev_number * 10 + number % 10;
		number /= 10;
	}
	return rev_number;
}
int main(int argc, char const *argv[])
{
	int number, rev_number;
	scanf("%d", &number);
	rev_number = get_rev_number(number);
	if(rev_number == number)
		puts("YES");
	else
		puts("NO");
	return 0;
}

字符串反转

#include <bits/stdc++.h>
using namespace std;

void reverse_str(char str[])
{
	int str_len = strlen(str);
	char temp;
	for(int i = 0;i < str_len / 2;i++)
	{
		temp = str[i];
		str[i] = str[str_len - i - 1];
		str[str_len - i - 1] = temp;
	}
}
int main(int argc, char const *argv[])
{
	char str[50];
	scanf("%s", str);
	reverse_str(str);
	puts(str);
	return 0;
}
posted @ 2021-03-17 22:42  jadelemon  阅读(1606)  评论(0)  编辑  收藏  举报