XDOJ字符串类

用简单的代码简单的思想解决问题

应该合理使用字符串处理函数

---

寻找最长行

标题	
寻找最长的行

类别
字符串
	
时间限制	
1S

内存限制	
1000Kb

问题描述	
寻找若干行文本中最长的一行

输入说明	
输入为多个字符串(每个字符串长度不超过100个字符)，每个字符串占一行，输入的行为“***end***”时表示输入结束

输出说明	
输出其中最长的一行长度后换行再输出最长行的内容，如果最长行不止一个，则输出其中的第一行。

输入样例	
abce
abdf dlfd
***end***

输出样例	
9
abdf dlfd 

#include 
#include 
int main()
{
     
    char s[200],s1[200];
 	int n,max=0;
 	while(1)
 {
     
        gets(s);
  		if(strcmp(s,"***end***")==0)
   			 break;
  		n=strlen(s);
  		if(n>max)
  		{
     
            max=n;strcpy(s1,s);//把最长行的长度和最长行保存下来
  		}

}
 printf("%d\n%s\n",max,s1);
 return 0;
}
//strcpy(s1,s) 后面的复制到前面
//strcmp(s,"***end***")==0 字符串比较，相等为0 前大于后，则大于0

字符串压缩

问题描述	
有一种简单的字符串压缩算法，对于字符串中连续出现的同一个英文字符，用该字符加上连续出现的次数来表示（连续出现次数小于3时不压缩）。
例如，字符串aaaaabbbabaaaaaaaaaaaaabbbb可压缩为a5b3aba13b4。
请设计一个程序，将采用该压缩方法得到的字符串解压缩，还原出原字符串并输出。

输入说明	
输入数据为一个字符串（长度不大于50，只包含字母和数字），表示压缩后的字符串

输出说明	
在一行上输出解压缩后的英文字符串（长度不超过100），最后换行。

输入样例	
a5b3aba13b4

输出样例	
aaaaabbbabaaaaaaaaaaaaabbbb

//压缩字符串
//字符加上出现次数来表示压缩方式
//输入一个字符串
//输出解压后的字符串 
# include 
int main()
{
     
	int i = 0, sum, count, k;
	//i用来全局遍历，sum用来 
	char s[50], temp;
	gets(s);
	while(s[i])//对字符串进行遍历 
	{
     
		printf("%c", s[i]);
		temp = s[i];
		i ++;sum = 0;count = 0;
		//sum用来看数字到底是几
		//i++代表看字符串的下一位 
		while(s[i] >= '0'&&s[i] <= '9')//如果当前项是数字
		{
     
			sum = sum * 10 + s[i] - '0';//把字符转化成数字累加，为输出次数 
			i ++;//i是用来统计位数的 
			count ++; 
		 } 
		 for(k = 0; k < sum - 1; k ++) printf("%c", temp); 
	}
	return 0;
}

括号匹配

标题	
括号匹配

类别	
字符串处理

时间限制	
2S
内存限制	
1000Kb

问题描述	
表达式中的合法括号为“(”、“)”、“[”、“]”、“{”、“}”，这三种括号可以按照任意的次序嵌套使用。
请写一个程序，判断给定表达式中的括号是否匹配，既左右括号顺序和数量都匹配。

输入说明	
输入为一个表达式字符串，长度不超过50。

输出说明	
对输入的表达式，若其中的括号是匹配的，则输出“yes”，否则输出“no”。

输入样例	
样例1输入
[(d+f)*{}2]
样例2输入
[(2+3))

输出样例	
样例1输出
yes
样例2输出
no

//括号匹配
//()[]{}
//判断给定表达式中 左右括号的顺序和数量是不是都匹配
//输入一个字符串表达式
//输出yes代表匹配，no代表不匹配
#include 
#include 
int main()
{
     
	int a= 0, b = 0, c = 0, i, flag;
	//a,b,c用来表示三种括号
	//flag表示当有右括号先出现的时候，就不用继续判断了
	//i用来遍历字符串 
	char str[100];
	scanf("%s", str);
	for(i = 0;i < strlen(str); i ++)
	{
     
		if(str[i] == '(') a ++;
		else if(str[i] == '[') b ++;
		else if(str[i] == '{') c ++;
		else if(str[i] == ')')
		{
     
			a --;
			if(a < 0)
			{
     
				flag = 1;
				break;
			}
		}
		else if(str[i] == ']')
		{
     
			b --;
			if(b < 0)
			{
     
				flag = 1;
				break;
			}
		}
		else if(str[i] == '}')
		{
     
			c --;
			if(c < 0) 
			{
     
				flag = 1;
				break;
			}
		}
		if(flag == 1) break;
	}
	if(flag == 1) printf("no");
	else if(flag == 0 && a == 0 && b == 0 && c == 0) printf("yes");
	else printf("no");
}

表达式求值

标题	
表达式求值

类别
字符串处理

时间限制	
1S

内存限制	
256Kb

问题描述	
表达式由两个非负整数x，y和一个运算符op构成，求表达式的值。
这两个整数和运算符的顺序是随机的，可能是”x op y”， “op x y”或者 “x y op”，例如，“25 + 3”表示25加3，“5 30 *” 表示5乘以30，“/ 600 15”表示600除以15。

输入说明	
输入为一个表达式，表达式由两个非负整数x，y和一个运算符op构成，x，y和op之间以空格分隔，但顺序不确定。
x和y均不大于10000000，op可以是+，-,*，/，%中的任意一种，分表表示加法，减法，乘法，除法和求余。
除法按整数除法求值，输入数据保证除法和求余运算的y值不为0。

输出说明	
输出表达式的值。

输入样例	
样例1输入
5 20 *
样例2输入
4 + 8
样例3输入
/ 8 4

输出样例	
样例1输出
100
样例2输出
12
样例3输出
2

//表达式求值
//字符串处理
//表达式由两个非负整数x,y,和一个运算符op
//但是三个字符的位置不确定
//op有+,-,*,/,%
//
# include 
int main()
{
     
	char s[20], c;
	gets(s);
	//注意这里如何遍历字符串
	//如果字符元素是数字，注意保存方式
	//如果是运算字符，保存运算字符 
	int i = 0;
	int sum1 = 0, sum2 = 0;
	int flag = 0;//用来看是存储第一个数字还是第二个数字 
	while(s[i] != '\0') 
	{
     
		if(s[i] == '+' || s[i] == '-' ||s[i] == '*' ||s[i] == '/' ||s[i] == '%') c = s[i]; 
		if(s[i] >= '0' && s[i] <= '9')
		{
     
			if(flag == 0) 
			{
     
				sum1 = sum1*10 + (s[i] - '0'); 
				if(s[i + 1] < '0' || s[i + 1] > '9') 
				{
     
					flag = 1;
				}
			}
			else
			{
     
				sum2 = sum2*10 + (s[i] - '0');
			}
			
		}
		i ++;	
		
	}
	int res;
	if(c == '+') res = sum1 + sum2;
	else if(c == '-') res = sum1 - sum2;
	else if(c == '*') res = sum1 * sum2;
	else if(c == '/') res = sum1 / sum2;
	else if(c == '%') res = sum1 % sum2;
	printf("%d",res);
	return 0; 
}

字符统计

标题	
字符统计

类别
字符串处理

时间限制	
1S

内存限制	
256Kb

问题描述	
给出一个字符C和一行文字S，统计在这行文字S中字符C出现的次数。
程序还需要支持大小写敏感选项：
  当选项打开时，表示同一个字母的大写和小写看作不同的字符；
  当选项关闭时，表示同一个字母的大写和小写看作相同的字符。

输入说明	
输入数据由两行构成。
第一行包含一个字符C和一个数字n。字符C为大小或小写英文字母。数字n表示大小写敏感选项，当数字n为0时表示大小写不敏感，当数字n为1时表示大小写敏感。字符C和数字n之间用空格分隔。
第二行为一个字符串S，字符串由大小写英文字母组成，不含空格和其他字符。字符串S长度不超过100。

输出说明	
输出字符C在字符串S中出现的次数。

输入样例
样例1输入
L 1
HELLOWorld
样例2输入
L 0
HELLOWorld

输出样例
样例1输出	
2
样例2输出
3

# include 
# include 
int main()
{
     
	char s[100], c;
	int state;
	scanf("%c %d ", &c, &state);
	gets(s);
	if(state == 1) count1(s,c);
	else if(state == 0) count2(s,c);
	return 0;
}
//大小写敏感 
void count1(char s[], char c)
{
     
	int i = 0, res = 0;
	while(s[i] != '\0')
	{
     
		if(s[i] == c) res++;	
		i++;
	}	
	printf("%d", res);
} 
void count2(char s[], char c)
{
     
	int i = 0, res = 0;
	while(s[i] != '\0')
	{
     
		if(c >= 'a' && c <= 'z')
		{
     
			if(s[i] == c || s[i] == c - 32) res++;
		}
		else if(c >= 'A' && c <= 'Z')
		{
     
			if(s[i] == c || s[i] == c + 32) res++;
		}
		i ++;
	}	
	printf("%d", res);
} 

字符串查找

合理使用字符串操作函数

标题	
字符串查找

类别
字符串处理

时间限制	
2S

内存限制	
256Kb

问题描述	
给出一个字符串和多行文字，输出在这些文字中出现了指定字符串的行。
程序还需要支持大小写敏感选项：
    当选项打开时，表示同一个字母的大写和小写看作不同的字符；
    当选项关闭时，表示同一个字母的大写和小写看作相同的字符。

输入说明	
输入数据第一行包含一个字符串s，由大小写英文字母组成，长度不超过100。
第二行包含一个数字，表示大小写敏感选项。当数字为0时表示大小写不敏感，当数字为1时表示大小写敏感。
第三行包含一个整数n，表示给出的文字行数。
接下来n行，每行包含一个字符串，字符串由大小写英文字母组成，不含空格和其他字符。每个字符串长度不超过100。

输出说明	
输出多行，每行包含一个字符串，按出现的顺序依次给出那些包含了字符串s的行。

输入样例	
Hello
1
5
HelloWorld
HiHiHelloHiHi
GrepIsAGreatTool
HELLO
HELLOisNOTHello

输出样例	
HelloWorld
HiHiHelloHiHi
HELLOisNOTHello

#include
#include
#define N 100
 
int main()
{
     
	char key[N+1],s[N+1],lowerkey[N+1],lowers[N+1];
	int option,n;
	scanf("%s %d %d",key,&option,&n);
	strcpy(lowerkey,key);
	strlwr(lowerkey);
	for(int i=1;i<=n;i++){
     
		scanf("%s",s);
		if(option==0){
      //大小写不敏感，把匹配和带匹配的字符都转换成小写 
			strcpy(lowers,s);
		    strlwr(lowers);
		    if(strstr(lowers,lowerkey))//查找函数 strstr 
		      printf("%s\n",s);
		}
		else{
     
			if(strstr(s,key))
			  printf("%s\n",s);
		}
	}
	return 0;
}

字符串相似度

标题	
字符串相似度

类别
字符串处理
	
时间限制	
1S

内存限制	
256Kb

问题描述	
最长公共子串指给定的两个字符串之间最长的相同子字符串（忽略大小写），最长公共子串长度可用来定义字符串相似度。
现给出两个字符串S1和S2，S1的长度为Len1，S2的长度为Len2，假设S1和S2的最长公共子串长度为LCS，则两个字符串的相似度定义为2*LCS/(Len1+Len2)。
例如：S1=”App”，S2=”apple”，S1长度为3，S2长度为5，它们的最长公共子串为”App”，长度为3，则相似度为2*3/(3+5)=0.75。
现给出两个字符串，请计算它们的相似度结果保留3位小数。

输入说明	
输入为两行，分别表示两个字符串S1和S2，每个字符串长度不超过100个字符，所有字符均为可打印字符，包括大小写字母，标点符号和空格。

输出说明	
输出两个字符串的相似度，结果四舍五入保留3位小数。

输入样例	
App
Apple

输出样例	
0.750

# include 
# include 
# include 
int main()
{
     
	char s1[101],s2[101],t[101];
	int i, j;
	float len1,len2,max = 0.0;
	int a[100][100] = {
     0};//中间数组
	float res;
	gets(s1);
	gets(s2);
	len1 = strlen(s1);
	len2 = strlen(s2);
	
	for(i = 0; i < len1; i ++)
	{
     
		for(j = 0; j < len2; j ++)
		{
     
			if(s1[i] == s2[j] || abs(s1[i] - s2[j]) == 32)//该位置匹配上了 
			{
     
				if(i != 0 && j != 0) a[i][j] = a[i - 1][j - 1] + 1;
				else a[i][j] = 1; 
			}
		}
	}
	for(i = 0; i < len1; i ++)
	{
     
		for(j = 0; j < len2; j ++)
		{
     
			if(a[i][j] > max) max = a[i][j];
		}
	}
	res = 2.0 * max / (len1 + len2);
	printf("%.3f", res);
}

ISBN号码

标题	
ISBN号码

类别
字符串处理
	
时间限制	
1S

内存限制	
256Kb

问题描述	
每一本正式出版的图书都有一个ISBN号码与之对应，ISBN码包括9位数字、1位识别码和3位分隔符，其规定格式如"x-xxx-xxxxx-x"，
其中符号“-”是分隔符（键盘上的减号），最后一位是识别码，例如0-670-82162-4就是一个标准的ISBN码。
ISBN码的首位数字表示书籍的出版语言，例如0代表英语；
第一个分隔符“-”之后的三位数字代表出版社，例如670代表维京出版社；
第二个分隔之后的五位数字代表该书在出版社的编号；
最后一位为识别码。识别码的计算方法如下：
首位数字乘以1加上次位数字乘以2……以此类推，用所得的结果mod 11，所得的余数即为识别码，如果余数为10，则识别码为大写字母X。
例如ISBN号码0-670-82162-4中的识别码4是这样得到的：
对067082162这9个数字，从左至右，分别乘以1，2，…，9，再求和，即0×1+6×2+……+2×9=158，然后取158 mod 11的结果4作为识别码。
编写程序判断输入的ISBN号码中识别码是否正确，如果正确，则仅输出“Right”；如果错误，则输出正确的ISBN号码。

输入说明	
输入只有一行，是一个字符序列，表示一本书的ISBN号码（保证输入符合ISBN号码的格式要求）。

输出说明	
输出一行，假如输入的ISBN号码的识别码正确，那么输出“Right”，否则，按照规定的格式，输出正确的ISBN号码（包括分隔符“-”）。

输入样例	
样例输入1
0-670-82162-4
样例输入2
0-670-82162-0

输出样例	
样例输出1
Right
样例输出2
0-670-82162-4

#include
int main()
{
     
    char ch[100]={
     0};
    int sum,i;
    while(scanf("%s",ch)!=EOF)
    {
     
        i=0;
        sum=0;
        sum=sum+(ch[i]-'0');
        for(i=2;i<5;i++)
        {
     
            sum=sum+((ch[i]-'0')*i);
        }
        for(i=6;i<11;i++)
        {
     
            sum=sum+((ch[i]-'0')*(i-1));
        }
        sum=sum%11;
        if(sum==10)
        {
     
            if(ch[12]=='X')
                printf("Right\n");
            else{
     
                    ch[12]='X';
            printf("%s\n",ch) ;
             }
        }
       else if(sum==(ch[12]-'0'))
        printf("Right\n");
        else
        {
     
            ch[12]=(char)(sum+'0');
            printf("%s\n",ch);
 
        }
    }return 0;
}

字符统计

标题
字符统计

描述
定义一个一维字符数组string[100]，输入一个字符串，含N个字符（N≤100），定义一个整形数组num[5]，用于存放统计结果数据，编写函数count()统计字符串中大写字母、小写字母、空格、数字以及其他字符的个数，使用指针完成地址传递，主函数完成数组输入和统计结果输出。
   
时间限制
1	

内存限制
10000	

类别
1

输入说明
输入一行字符串，100个以内。

输出说明
格式输出：输出大写字母、小写字母、空格、数字以及其他字符的个数信息，数据之间空一格。


输入样例
A 3cp &! 91 tD M

输出样例
3 3 5 3 2

提示
使用指针作形参，实现地址传递，输出数据之间空一格。

字符串长度判断

题目：字符串长度判断 
时间限制：1S
内存限制：10000Kb

问题描述：
写一个函数，求一个字符串的长度。在main函数中输入字符串，并输出其长度。

输入说明：
输入一个字符串
输出说明：
输出该字符串中元素的个数。
输入样例：
boy
输出样例：
3

#include
void func(char q[])
{
     
	int i = 0;
	while(q[i] != '\0')
	{
     
		i++;
	}
	printf("%d", i);
}
int main()
{
     
	char q[100];
	gets(q);
	func(q);
	return 0;
}

单词统计

\标题
单词统计

描述
输入字符串string[N]（N≤100），各个单词以空格隔开，单词长度小于等于8，输入单词word[M]（M≤8），在
string中查找出相同的单词并统计该单词出现的次数信息，输出单词和出现次数的信息， 数据之间空一格空格。主函数输入字符串和待统计单词，编写函数count()实现统计和信息输出。

时间限制
1	
内存限制
10000	
类别
1

输入说明
输入一行字符以空格隔开各个单词，输入要统计的单词。

输出说明
格式输出：输出单词及其出现的次数信息，数据之间空一格。

输入样例
dog cat dog dog the abc dog hahe
dog

输出样例
dog 4

提示
采用重循环结构实现计算过程，输出数据之间空一格。

#include
#include
#include
int main(void) {
     
	char array[100][9];//
	char str[1000];
	char flag[9];
	int i,num,index,count;
	gets(str);
	gets(flag);
	//提取单词
	num=index=0;
	for(i=0; i<strlen(str); i++) {
     
		if(str[i]!=' ') {
     
			array[num][index]=str[i];
			index++;
		} else {
      //碰到空格即为一个单词
			array[num][index]='\0';
			num++;
			index=0;
		}
	}
	array[num][index]='\0';//最后一个单词没有空格
	//统计次数
	count=0;
	for(i=0; i<=num; i++) {
     
		if(strcmp(array[i],flag)==0) {
     
			count++;
		}
	}
	printf("%s %d",flag,count);
	return 0;
	转自 https://blog.csdn.net/yingmu__/article/details/108040190
}

字符删除

标题
字符删除

描述
主函数中输入一个一维字符数组str[N]（N≤50）和待删除字符ch，调用函数dele()完成内容：1、删除字符数组中的每个待删除字符；2、其它字符依次迁移；3、数组末尾加'\0'结束。
   
时间限制
1	

内存限制
10000	

类别
1

输入说明
输入一个一维字符数组和待删除字符。

输出说明
格式输出：输出处理后字符串。

输入样例
There are three men.
e
输出样例
Thr ar thr mn.

提示
字符串输入函数gets()，头文件string.h。

//206 - 210
#include 
void dele(char str[], char c)
{
     
    int j, k;
    for (j = k = 0; str[j] != '\0'; j++)
        if (str[j] != c)
            str[k++] = str[j];
    str[k] = '\0';
    printf("\n%s", str);
}
int main()
{
     
    char str[100], c;
    gets(str);
    c = getchar();
    dele(str,c);
    return 0;
    
}

单词排序

标题
单词排序

描述
定义一个二维字符数组str[10][20]，行号表示单词序号，列号表示单词最大长度，输入一个正整数N（N≤10），表示单词数，使用函数wd_sort()完成单词的排序，按字母顺序从小到大排列单词，使用指针完成地址传递，主函数完成数组输入和输出。

时间限制
1	

内存限制
10000	

类别
1

输入说明
输入一个二维字符数组str和一个正整数N，行号表示单词序号，列号表示单词最大长度。

输出说明
格式输出：单词之间空一行。

输入样例
3
word fish egg
输出样例
egg
fish
word

提示
使用指针作形参，实现地址传递。
数组定义后初始化。
使用strcmp()、strcpy()和strlen()函数，头文件string.h。

#include 
#include 
int main(void)
{
     
    char array[10][20];
    char str[21];
    int n, i, j, len, num, index;
    scanf("%d", &n);
    for (i = 0; i < n; i++)
    {
     
        scanf("%s", &array[i]);
    }

    for (i = 1; i < n; i++)
    {
     
        for (j = i; j > 0 && (strcmp(array[j], array[j - 1]) < 0); j--)
        {
     
            strcpy(str, array[j]);
            strcpy(array[j], array[j - 1]);
            strcpy(array[j - 1], str);
        }
    }

    for (i = 0; i < n; i++)
    {
     
        printf("%s\n", array[i]);
    }
    return 0;
}

字符拷贝

标题
字符拷贝

描述
定义一个一维字符数组str[50]，输入一串字符，输入整数位置信息M(M<50)，调用函数char_cp()把指定位置M之后的内容，拷贝到新字符数组ch[50]中，使用指针完成地址传递，主函数完成数组输入和输出。
   
时间限制
1	

内存限制
10000	

类别
1

输入说明
输入一个字符串和整形位置信息，位置M≥0。

输出说明
格式输出：输出处理后字符串ch。

输入样例
There are three men.
6

输出样例
re three men.

提示
使用指针作形参，实现地址传递，位置从0开始。

# include 
# include 
void char_cp(char str[], char ch[], int M)
{
     
    int i = 0, j = 0, k = 0;
    for(j = M + 1; str[j] != '\0'; j ++) 
    {
     
        ch[k] = str[j];
        k ++;
    } 
}
int main()
{
     
    char str[50], ch[50];
    gets(str);
    int M, i;
    scanf("%d", &M);
    char_cp(str, ch, M);
    puts(ch);
    return 0;
}

转换排序

标题
转换排序

描述
输入一维字符数组str[N]（N≤80），查找出其中小写字母并转换成大写字母，按下面方式排序：1、只对大写字母进行排序；2、其他字符原位保持不动；3、转换后的各大写字母由小到大排序。输出排序后的结果。

时间限制
1	
内存限制
10000	
类别
1

输入说明
输入一行字符数据str[N]（N≤80）。

输出说明
格式输出：输出仅对转换后的大写字母排序结果，其他字符原位不动输出。

输入样例
xA3T7p

输出样例
AP3T7X

提示
注意转换方式和排序要求。

1. 遍历一边字符数组，原地小写变大写
2. 把需要排序的所有大写字母放入中间数组
3. 对中间数组进行排序
4. 排序后的中间数组与原数组进行比较整合，替换原数组中的大写字母

#include
int main()
{
     
	
	char str[80], temp[80], t;
	gets(str);
	int i = 0, j = 0, num = 0;
	while(str[i] != '\0')
	{
     
		if(str[i] >= 'a' && str[i] <= 'z') str[i] -= 32;
		
		if(str[i] >= 'A' && str[i] <= 'Z')
		{
     
			temp[num] = str[i];
			num ++;
		}
		i ++;
	}
	for(i = 0; i < num - 1; i ++)
		for(j = 0; j < num - i - 1; j ++)
		{
     
			if(temp[j] > temp[j + 1])
			{
     
				t = temp[j];
				temp[j] = temp[j + 1];
				temp[j + 1] = t;
			}
		}
		i = 0;
		j = 0;
	while(str[i] != '\0')
	{
     
		if(str[i] >= 'A' && str[i] <= 'Z') 
		{
     
			str[i] = temp[j];
			j ++;
		}
		i ++;
	}
	puts(str);
	return 0;
		
}

字符逆序排放

题目：字符逆序排放 
时间限制：1S
内存限制：10000Kb
问题描述：

写一个函数，使输入的字符按照反序排放，在主函数中输入和输出字符。
输入说明：
输入一个字符串。
输出说明：
输出上述字符串的逆序排列。
输入样例：
animal
输出样例：
lamina

• 思路：将数组的第1个字符和第n个字符交换位置，第二个和第n-1个交换

#include 
#include 
void Reverse(char str[]);
int main()
{
     
    char str[100];
    gets(str);
    Reverse(str);
    printf("%s\n", str);
}
void Reverse(char str[])
{
     
    int n = strlen(str);
    int i;
    char temp;
    for (i = 0; i < (n / 2); i++)
    {
     
        temp = str[i];
        str[i] = str[n - i - 1];
        str[n - i - 1] = temp;
    }
}

字符串统计

题目：字符串元素统计
时间限制：1S
内存限制：10000Kb
问题描述：

编写一个函数，由实参传来一个字符串，统计字符串中字母，数字的个数，在主函数中输入字符及输出上述结果。
输入说明：
随机输入一个字符串。
输出说明：
依次输出该字符串中字母，数字的个数。
输入样例
abc123
输出样例：
3,3

• 注意数组作为函数的参数的一些常见方式

#include 
#include 
void func(char *q)
{
     
    int i, x1 = 0, x2 = 0;
    while (*q != '\0')
    {
     
        if (*q >= 'a' && *q <= 'z' || *q >= 'A' && *q <= 'Z')
            x1++;
        else if (*q >= '0' && *q <= '9')
            x2++;
        q++;
    }
    printf("%d,%d", x1, x2);
}
int main()
{
     
    char q[30];
    gets(q);
    func(q);
    return 0;
}

#include 
#include 
void func(char q[])
{
     
    int i, x1 = 0, x2 = 0;
    int n = strlen(q);
    for(i = 0; i < n; i++)
    {
     
        if (q[i] >= 'a' && q[i] <= 'z' || q[i] >= 'A' && q[i] <= 'Z')
            x1++;
        else if (q[i] >= '0' && q[i] <= '9')
            x2++;
    }
    printf("%d,%d", x1, x2);
}
int main()
{
     
    char q[30];
    gets(q);
    func(q);
    return 0;
}

字符串查找

编写一个函数fun，求一个字符串中的英文字母的个数。
主函数中输入字符串，调用函数，输出英文字母个数

输入说明：共一行，输入字符串

输出说明：输出一个整数，为英文字母个数

输入示例：aBc456

输出示例：3

#include 
#include 
void func(char q[])
{
     
    int i, x1 = 0, x2 = 0;
    int n = strlen(q);
    for (i = 0; i < n; i++)
    {
     
        if (q[i] >= 'a' && q[i] <= 'z' || q[i] >= 'A' && q[i] <= 'Z')
            x1++;
    }
    printf("%d", x1);
}
int main()
{
     
    char q[30];
    gets(q);
    func(q);
    return 0;
}

字符串筛选

编写函数fun，其功能是将字符串s下标为奇数的字符删除，字符串中剩余字符形成的新字符串放在数组t中。
主函数中输入字符串s，调用函数，输出字符数组t。

输入说明：共一行，输入字符串s

输出说明：共一行，输出字符串t

输入示例：abcd1234

输出示例：ac13

• C语言中字符串即为字符数组

#include 
#include 
void fun(char s[])
{
     
    int n = strlen(s);
    int i;
    for (i = 0; i < n; i = i + 2)
    {
     
        printf("%c", s[i]);
    }
}
int main()
{
     
    char s[30];
    gets(s);
    fun(s);
    return 0;
}

字符串连接

编写一个函数fun实现字符串连接功能（不使用strcat函数）。
主函数输入两个字符串，调用函数，输出连接后的字符串

输入说明：共两行，每一行输入一个字符串

输出说明：共一行,输出连接后的字符串

输入示例：abcd
          1234

输出示例：abcd1234

#include 
#include 
void fun(char s[],char t[])
{
     
	int slen=strlen(s);
	int k=0;
	while(t[k]!='\0'){
     
		s[slen++]=t[k++];
	}
	s[slen]='\0';
}
int main() {
     
	char s[20];
	char t[20];
	
	gets(s);
	gets(t);
	fun(s,t);
	printf("%s",s);
	return 0;
}