0%

字符串练习题

发表于 更新于 分类于

字符串练习题

基础练习

1.编写程序，对任意输入的字符串，统计其中的大写字母和小写字母的个数。例如， 输入字符 串: AAaaBBb123CCccccd ，则应输出结果:upper = 6， lower = 8。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include "stdio.h"
#include <string.h>
void jc1(char zifu[],int i,int upper,int lower);
void jc1(char zifu[],int i,int upper,int lower)
{
    while (i<=strlen(zifu)) {
        if (zifu[i]>=65&&zifu[i]<=90) {
            upper++;
        }
        else if (zifu[i]>=97&&zifu[i]<=122){
            lower++;
        }
        i++;
    }
    printf("upper:%d,lower:%d\n",upper,lower);
}

int main()
{
    char zifu1[]={"Hello the world"};
    jc1(zifu1,0,0,0);
    char zifu2[]={"Python is the best LANGUAGE!"};
    jc1(zifu2,0,0,0);
}
/*输出结果为
upper:1,lower:12
upper:9,lower:14
Program ended with exit code: 0	*/

2. 用字符数组存储任意输入的一串字符，求其最大字符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//基础2
#include "stdio.h"
#include <string.h>
void jc2(char zifu[],int i,char max);//声明函数
void jc2(char zifu[],int i,char max)//定义函数，其中定义了字符数组zifu,整型变量i，字符型变量max
{   max=zifu[0];                    //初始化字符型变量max等于字符数组中第一个字符,并认为其为最大字符
    while (i<=strlen(zifu)-1) {           //限制循环次数，防止下标越界
        if (max<zifu[i]) {          //判断max这个字符是否小于后一个字符
            max=zifu[i];            //如果比后一个字符小，就让后一个字符称为max
        }
        i++;
    }
    printf("最大的字符是：%c\n",max);//输出max字符的值
}

int main()                          //调用函数
{
    char zifu1[]={"Hello the world"};
    jc2(zifu1,1,'\0');
    char zifu2[]={"Python is the best LANGUAGE!"};
    jc2(zifu2,1,'\0');
}
/*输出结果为：
 最大的字符是：w
 最大的字符是：y
 Program ended with exit code: 0*/

3. 编写一个程序，将字符数组s2中的全部字符复制到字符数组s1中，不用 strcpy 函数。注意，复 制时，’ \0’ 也要复制过去。‘ \0’ 后面的字符不复制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//基础3
#include "stdio.h"
#include "string.h"
void copy(char zifu1[],int i,int j);//声明函数
void copy(char zifu1[],int i,int j){//定义函数，其中包括三个参数：字符数组zifu1,整型变量i，整型变量j.
    char zifu2[strlen(zifu1)+1];//定义一个长度和zifu1相同的空字符数组
    while (i<=strlen(zifu1)) {//执行循环，控制次数
        zifu2[i]=zifu1[i];//将zufu1原样复制到zifu2
        i++;
    }
    while (j<=strlen(zifu2)-1) {//这里-1是为了输出不包括末尾的f'\0'
        printf("%c",zifu2[j]);//执行输出1
        j++;
    }
    printf("\n");            //换行
    j=0;                     //重新初始化j
    while (j<=strlen(zifu2)) {//这里没有-1，是为了和输出1做比较
        printf("%c",zifu2[j]);//执行输出2
        j++;
    }
    printf("\n");           //换行
}                           //输出结果1和2相同，说明zifu1末尾的'\0'也复制到了zifu2当中
int main()                  //执行函数，完成任务
{
    char zifu1[]={"Hello the world"};
    copy(zifu1,0,0);
}
//输出结果为：
//Hello the world
//Hello the world
//Program ended with exit code: 0

4. 对字符串 a 中的字符由小到大排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
//基础4
#include "stdio.h"
#include "string.h"
void  px(char zifu[],int i,int j,char exchange);        //声明函数
void  px(char zifu[],int i,int j,char exchange){        //定义函数，其中包括四个参数
    printf("原来的字符串是：\n%s\n",zifu);
    for (i=0;i<=strlen(zifu)-1;i++) {                   //执行两个循环，使用冒泡排序法对字符串中的字符按照从小到大的顺序排列
        for (j=0; j<=strlen(zifu)-1-i; j++) {
            if (zifu[j]>zifu[j+1]) {
                exchange=zifu[j+1];
                zifu[j+1]=zifu[j];
                zifu[j]=exchange;
            }
            exchange='\0';
        }
    }
    i=0;                                            //让i重新等于0，避免呢过多的变量定义
    printf("重新排序后的字符数组是：\n");
    while (i<=strlen(zifu)+1) {                     //执行循环，输出字符串
        printf("%c",zifu[i]);
        i++;
    }
    printf("\n");                                   //为了多个测试结果的美观，多输出两个换行
    printf("\n");
}
int main()                                          //调用函数，实现多组测试
{
    char zifu1[]="bcadefzrea?!#%^";
    px(zifu1,0,0,'\0');
    char zifu2[]="987654321123456789";
       px(zifu2,0,0,'\0');
}

/*原来的字符串是：
bcadefzrea?!#%^
重新排序后的字符数组是：
!#%?^aabcdeefrz

原来的字符串是：
987654321123456789
重新排序后的字符数组是：
112233445566778899

Program ended with exit code: 0*/

6.下面程序输入一字符串，并将其中的大写字母改变成小写字母，完成程序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
int main()                                 
{
    int i=0;
    char s[120];
    printf("Enter a string.\n");
    scanf("%s",s);              
    while (i<=119) {
        if (s[i]>='A'&&s[i]<='Z') {
            s[i]=s[i]-'A'+'a';
        }
        i++;
    }
    printf("%s\n",s);
}

答案为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
int main()                                  //因为是填空题，所以只进行了一组测试
{
    int i=0;
    char s[120];
    printf("Enter a string.\n");
    scanf("%[^\n]%*c",s);              //scanf函数获取含空格字符串不能使用%s,因此这里改为了%[^\n]%*c
    while (i<=119) {
        if (s[i]>='A'&&s[i]<='Z') {
            s[i]=s[i]-'A'+'a';
        }
        i++;
    }
    printf("%s\n",s);
}
/*输出结果为：
 Enter a string.
 I LOVE pyhton!
 i  love pyhton!
 */

进阶

1.设计并测试一个函数，其功能是输出输入行(长度 <=1024 )里所有的单词，并丢掉该行中其 他的字符。一个单词的定义是一串字符，其中不含空格、制表符和换行符等其它字符。例如， 输入行: 1234word?_12number +234 输出: word number

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//进阶1
#include <stdio.h>
#include "string.h"
void jj1(char zifu[],int i);                        //声明函数
void jj1(char zifu[],int i){                        //定义一个无返回类型且包含两个形参的函数
    while (i<=strlen(zifu)-1) {                     //执行循环，控制次数，其中用strlen函数获取字符串的长度
        if ((zifu[i]>='A'&&zifu[i]<+'Z')||(zifu[i]>='a'&&zifu[i]<+'z')) {//使用if判断字符数组中的每一个字符是否在字母表中
            printf("%c",zifu[i]);                                        //如果是，则依次输出每个字符
        }
       else{                                                             //否则，输出一个空格，确保不同单词之间的间隔
                  printf(" ");
              }
        i++;
    }
    printf("\n");                                                       //函数末尾输出一个空格，确保完成一次函数后换行再执行下一次
}
int main(){                                                             //在主函数中，执行自定义函数jj1
    char zifu1[]={"happy2019cqut*&^%$world}+)@™"};
    jj1(zifu1,0);
    char zifu2[]={"1234word?_12number _+_234"};
    jj1(zifu2,0);
}
/*输出结果为：
 happy    cqut     world
    word    number
Program ended with exit code: 0
 */

6.输入一个字符串，统计各字母出现的次数，并按字母出现的多少输出(先输出字母出现多的， 次数相同的按字母表顺序输出，不出现的字母不输出)。 例:输入: 5b3a+4-hdeh5dh? 输出: h 3 d 2 a 1 b 1 e 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
//进阶6                                     //本题没有进行多组测试，因为要计算每一个字母的个数m，这本身就是一种测试
#include "stdio.h"
#include "string.h"
int main(){
    int letter[26];int i=0;int j=0;int h=0;;unsigned long m=0;
    while (h<=25) {                         //执行循环，初始化整型数组letter，使其每一个数s都为0
        letter[h]=0;
        h++;
    }
    char zifu[]="hhhddabefgasifgagfaffgagcnmaohgvzf";//初始化字符串
    m=strlen(zifu);
    while (i<=strlen(zifu)-1) {            //执行循环，统计26个字母出现的次数
        if (zifu[i]=='A'||zifu[i]=='a') {
            letter[0]++;
        }
        if (zifu[i]=='B'||zifu[i]=='b') {
            letter[1]++;
        }
        if (zifu[i]=='C'||zifu[i]=='c') {
            letter[2]++;
        }
        if (zifu[i]=='D'||zifu[i]=='d') {
            letter[3]++;
        }
        if (zifu[i]=='E'||zifu[i]=='e') {
            letter[4]++;
        }
        if (zifu[i]=='F'||zifu[i]=='f') {
            letter[5]++;
        }
        if (zifu[i]=='G'||zifu[i]=='g') {
            letter[6]++;
        }
        if (zifu[i]=='H'||zifu[i]=='h') {
            letter[7]++;
        }
        if (zifu[i]=='I'||zifu[i]=='i') {
            letter[8]++;
        }
        if (zifu[i]=='J'||zifu[i]=='j') {
            letter[9]++;
        }
        if (zifu[i]=='K'||zifu[i]=='k') {
            letter[10]++;
        }
        if (zifu[i]=='L'||zifu[i]=='l') {
            letter[11]++;
        }
        if (zifu[i]=='M'||zifu[i]=='m') {
            letter[12]++;
        }
        if (zifu[i]=='N'||zifu[i]=='n') {
            letter[13]++;
        }
        if (zifu[i]=='O'||zifu[i]=='o') {
            letter[14]++;
        }
        if (zifu[i]=='P'||zifu[i]=='p') {
            letter[15]++;
        }
        if (zifu[i]=='Q'||zifu[i]=='q') {
            letter[16]++;
        }
        if (zifu[i]=='R'||zifu[i]=='r') {
            letter[17]++;
        }
        if (zifu[i]=='S'||zifu[i]=='s') {
            letter[18]++;
        }
        if (zifu[i]=='T'||zifu[i]=='t') {
            letter[19]++;
        }
        if (zifu[i]=='U'||zifu[i]=='u') {
            letter[20]++;
        }
        if (zifu[i]=='V'||zifu[i]=='v') {
            letter[21]++;
        }
        if (zifu[i]=='W'||zifu[i]=='w') {
            letter[22]++;
        }
        if (zifu[i]=='X'||zifu[i]=='x') {
            letter[23]++;
        }
        if (zifu[i]=='Y'||zifu[i]=='y') {
            letter[24]++;
        }
        if (zifu[i]=='Z'||zifu[i]=='z') {
            letter[25]++;
        }
        
        i++;
    }
    while (m>=1) {j=0;          //执行循环控制次数，以确保只输出字母个数超过1的
        while (j<=25) {         //执行熏黄，从高到低比较字母个数
            if (letter[j]==m) {
                printf("%c:%d\n",j+97,letter[j]);//输出字母个数和
            }
            j++;
        }
        m=m-1;
    }
}
/*运行结果为：:6
f:6
g:6
h:4
d:2
b:1
c:1
e:1
i:1
m:1
n:1
o:1
s:1
v:1
z:1
Program ended with exit code: 0*/

7. 有一篇文章，共有 3 行文字，每行有80个字符。要求分别统计出其中英文大写字母、小写字母、 数字、空格以及其它字符的个数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <stdio.h>                  //Name:雷博闻 Student ID：11923040207
#include "string.h"                 //进阶7
int main(){
    char zifu[3][80]={                                                                      //c定义一个多维字符数组并初始化
        "Its name might sound a little plain, but the grey-headed albatross is the most e",
        "Not only a majestic bird, the grey-headed albatross is a literal a world recoreq",
        "In 2003, The Guinness Book of Records gave them the title of world’s fastest h"
                        };
            int i=0,j=0,upper=0,lower=0,numbers=0,others=0;
    while (i<=2) {j=0;                                                                      //外循环，控制行数。j=0是为了重新初始化k列数
        while (j<=79) {                                                                     //内循环，控制列数
            if((zifu[i][j]>='A')&&(zifu[i][j]<='Z')){                                       //判断该字符是否是大写字母，是则upper+1，不是则进行下一判断
                upper++;
            }
            else if ((zifu[i][j]>='a')&&(zifu[i][j]<='z')){                                 //判断该字符是否是小写字母，是则lower+1，不是则进行下一判断
                lower++;
            }
            else if ((zifu[i][j]>='0')&&(zifu[i][j]<='9')){                                 //判断该字符是否是数字，是则numbers+1，不是则进行下一判断
                numbers++;
            }
            else{
                others++;
                //都不满足，则others+1
            }
            j++;
        }
        i++;
    }
    printf("大写字母的个数是：%d\n小写字母的个数是：%d\n数字的个数是在：%d\n其他字符的个数是：%d\n",upper,lower,numbers,others);
    //分别输出upper，lower，numbers和others的值
    printf("%d\n",upper+lower+numbers+others);//输出upper，lower，numbers和others值的综合，总和为240，则程序正确
}
/*输出结果：
 大写字母的个数是：7
 小写字母的个数是：180
 数字的个数是在：4
 其他字符的个数是：49
 240
 Program ended with exit code: 0*/