《C和指针》章节后编程练习解答参考——第9章

9.1

 1 #include <stdio.h>
 2 #include <ctype.h>
 3 #include <string.h>
 4
 5 #define  N  100
 6
 7 int main (void)
 8 {
 9     int i = 0;
10     char strarray[N+1]; //= "Hello world!    \t3I‘m here!";
11     char *input = strarray;
12     char ch;
13     unsigned int cont = 0;
14     int ctr=0, spc=0, num=0, low=0, upp=0, puc=0, upr=0;
15     float ctrf=0, spcf=0, numf=0, lowf=0, uppf=0, pucf=0, uprf=0;
16
17     printf("Please enter a string:\n");
18
19     while (( ch = getchar() ) != ‘\n‘)
20     {
21         *(input + i) = ch;
22         i++;
23     }
24     *(input + i) = ‘\0‘;
25     cont = strlen(input);
26
27     while (*input != ‘\0‘)
28     {
29         if (iscntrl(*input))
30             ctr++;
31         if (isspace(*input))
32             spc++;
33         if (isdigit(*input))
34             num++;
35         if (islower(*input))
36             low++;
37         if (isupper(*input))
38             upp++;
39         if (ispunct(*input))
40             puc++;
41         if (!(isprint(*input)))
42             upr++;
43         input++;
44     }
45
46     printf("\nTotle char number is: Count = %d\n", cont);
47     printf("cntrl = %d,\tspace = %d,\tdigit = %d\n", ctr, spc, num);
48     printf("lower = %d,\tupper = %d,\tpunct = %d\n", low, upp, puc);
49     printf("uprint = %d\n", upr);
50
51     ctrf = (float)ctr/(float)cont;
52     spcf = (float)spc/(float)cont;
53     numf = (float)num/(float)cont;
54     lowf = (float)low/(float)cont;
55     uppf = (float)upp/(float)cont;
56     pucf = (float)puc/(float)cont;
57     uprf = (float)upr/(float)cont;
58
59     printf("\nHere is the percent of every count:\n");
60     printf("cntrl = %.3f%%\nspace = %.3f%%\ndigit = %.3f%%\n",ctrf*100 , spcf*100, numf*100);
61     printf("lower = %.3f%%\nupper = %.3f%%\npunct = %.3f%%\n", lowf*100, uppf*100, pucf*100);
62     printf("uprnt = %.3f%%\n", uprf*100);
63
64     getchar();
65     return 0;
66 }

9.3

 1 #include <stdio.h>
 2 #include <string.h>
 3
 4 void my_strcpy(char *dst, char *src)
 5 {
 6     size_t len = 0, dstlen = 0, srclen = 0;
 7     dstlen = strlen(dst);
 8     srclen = strlen(src);
 9
10     len = ( dstlen >= srclen ? srclen : dstlen );
11     strncpy(dst, src, len);
12 }
13
14 void show_string(char *str)
15 {
16     while (*str != ‘\0‘)
17         printf("%c", *str++);
18     putchar(‘\n‘);
19 }
20
21 int main (void)
22 {
23     char dst[6] = "Hello";
24     char src[10] = "I‘m here!";
25     char *dstp = dst;
26     char *srcp = src;
27
28     my_strcpy(dstp, srcp);
29
30     show_string(dstp);
31     show_string(srcp);
32
33     getchar();
34     return 0;
35 }

9.4

 1 #include <stdio.h>
 2 #include <string.h>
 3
 4 #define  M  12
 5 #define  N  16
 6
 7 void my_strcat(char *dst, char *src)
 8 {
 9     size_t len = 0, dstlen = 0, srclen = 0, restlen = 0;
10     dstlen = strlen(dst);
11     srclen = strlen(src);
12
13     len = ( (restlen = M - dstlen - 1) > srclen ? srclen : restlen );
14     strncat(dst, src, len);
15 }
16
17 void show_string(char *str)
18 {
19     while (*str != ‘\0‘)
20         printf("%c", *str++);
21     putchar(‘\n‘);
22 }
23
24 int main (void)
25 {
26     char dst[M] = "Hello!";
27     char src[N] = "I‘m here!";
28     char *dstp = dst;
29     char *srcp = src;
30
31     my_strcat(dst, src);
32
33     show_string(dstp);
34     show_string(srcp);
35
36     getchar();
37     return 0;
38 }

9.5

 1 #include <stdio.h>
 2 #include <string.h>
 3
 4 #define  M  12
 5 #define  N  16
 6
 7 void my_strncat(char *dest, char *src, int dest_len)
 8 {
 9     size_t len = 0, dstlen = 0, srclen = 0, restlen = 0;
10     dstlen = strlen(dest);
11     srclen = strlen(src);
12
13     len = ( (restlen = dest_len - dstlen - 1) > srclen ? srclen : restlen );
14     strncat(dest, src, len);
15 }
16
17 void show_string(char *str)
18 {
19     while (*str != ‘\0‘)
20         printf("%c", *str++);
21     putchar(‘\n‘);
22 }
23
24 int main (void)
25 {
26     char dst[M] = "Hello!";
27     char src[N] = "I‘m here!";
28     char *dstp = dst;
29     char *srcp = src;
30
31     my_strncat(dst, src, M);
32
33     show_string(dstp);
34     show_string(srcp);
35
36     getchar();
37     return 0;
38 }

9.6

 1 #include <stdio.h>
 2 #include <string.h>
 3
 4 char *my_strcpy_end(char *dst, char *src)
 5 {
 6     int i, dstlen = 0, srclen = 0;
 7
 8     dstlen = strlen(dst);
 9     srclen = strlen(src);
10
11     if ( dstlen >= srclen )
12         strcpy(dst, src);
13     else
14         strncpy(dst, src, dstlen);
15
16     for ( i = 0; *(dst + i) != ‘\0‘; i++);
17     return dst + i;
18 }
19
20 int main (void)
21 {
22     char *p = NULL;
23     char dst[] = "Hello world";
24     //char src[] = "123456789";
25     char src[] = "123456789123456789";
26
27     p = my_strcpy_end(dst, src);
28
29     printf("%c\n", *(p - 1));
30
31     getchar();
32     return 0;
33 }

9.8

 1 #include <stdio.h>
 2 #include <string.h>
 3
 4 char *my_strnchr( char const *str, int ch, int which )
 5 {
 6     int i;
 7     char *p = NULL;
 8     p = str;
 9
10     for ( i = 0; i < which; i++)
11     {
12         if ( i != 0)
13             p++;
14         p = strchr(p, ch);
15     }
16
17     return p;
18 }
19
20 int main (void)
21 {
22     int i;
23     char str[] = "Hello world!";
24     int chr = ‘l‘;
25     int which = 2;
26
27     char *find = my_strnchr(str, chr, which);
28
29     for (i = -1; i < 2; i++)
30         printf("%c\t", *(find + i));
31     putchar(‘\n‘);
32
33     getchar();
34     return 0;
35 }

9.9

 1 #include <stdio.h>
 2 #include <string.h>
 3
 4 int count_chars(char const *str, char const *chars)
 5 {
 6     int count = 0, len = 0;
 7     char *pos = NULL;
 8     pos = str;
 9
10     while (( pos = strpbrk(pos, chars) ) != NULL )
11     {
12         count++;
13         pos++;
14     }
15
16     return count;
17 }
18
19 int main (void)
20 {
21     char str[] = "Hello world!";
22     char chars[] = "ero";
23
24     printf("%d\n", count_chars(str, chars));
25
26     getchar();
27     return 0;
28 }

9.10

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <string.h>
 4 #include <ctype.h>
 5
 6 int palindrome( char *string )
 7 {
 8     int i, j = 0;
 9     int len = strlen(string);
10     char *strcopy = NULL;
11     strcopy = malloc((len + 1)* sizeof(char));
12     for (i = 0; i < len; i++)            //将源字符串中的非字母字符去掉,并将剩下的字母转换为小写
13     {
14         if (isalpha(*(string + i)))
15         {
16             *(strcopy + j) =  tolower( *(string + i) );
17             j++;
18         }
19     }
20     *(strcopy + j) = ‘\0‘;
21
22     len = strlen(strcopy);
23     for (i = 0; i < (len / 2); i++)
24     {
25         if ( (*(strcopy + i)) != (*(strcopy + (len - i - 1) ) ) )
26             return 0;
27     }
28
29     return 1;
30 }
31
32 int main (void)
33 {
34     char string[] = "Madam, I‘m Adam!";
35     int result = 0;
36
37     result = palindrome(string);
38     printf("%d\n", result);
39
40     getchar();
41     return 0;
42 }

9.11

 1 #include <stdio.h>
 2 #include <string.h>
 3
 4 int main (void)
 5 {
 6     char input[101];
 7     char chars[] = "the";
 8     int i = 0, count = 0;
 9     char *pos = NULL;
10
11     printf("Please enter some words: \n");
12     scanf("%s", input);
13     printf("%s\n", input);
14
15     pos = input;
16     while ((pos = strstr(pos, chars)) != NULL)
17     {
18         pos++;
19         count++;
20     }
21
22     printf("There are %d \"%s\"!", count, chars);
23
24     getchar();
25     getchar();
26     return 0;
27 }

9.12  9.13  9.14

  1 #include <stdio.h>
  2 #include <string.h>
  3 #include <ctype.h>
  4
  5 char *init_alp(char *temp)
  6 {
  7     int i;
  8     char alp = ‘A‘;
  9
 10     for (i = 0; i < 26; i++)
 11     {
 12
 13         *(temp + i) = alp;
 14         alp++;
 15     }
 16     *(temp + i) = ‘\0‘;
 17
 18     return temp;
 19 }
 20
 21 int prepare_key( char *key )                        //生成key
 22 {
 23     int i = 0, j = 0, k = 0;
 24     char alp[27];
 25     char *temp = alp;
 26
 27     char *p = NULL;
 28
 29     if (key == NULL)                                        //key为空,退出
 30         return 0;
 31
 32     for (i = 0; *(key + i) != ‘\0‘; i++)
 33         if (!(isalpha(*(key + i))))                    //key中含有非字母字符,退出)
 34             return 0;
 35
 36     for (i = 0; *(key + i) != ‘\0‘; i++)
 37     {
 38         if (*(key + i) != ‘ ‘)                                //删除所有的空格
 39         {
 40             for (j = i + 1; *(key + j) != ‘\0‘; j++)        //将重复的字母赋值为空格
 41             {
 42                 if ( *(key + i) == *(key + j) )
 43                     *(key + j) = ‘ ‘;
 44             }
 45             *(key + k) = toupper(*(key + i));
 46             k++;
 47         }
 48     }
 49     *(key + k) = ‘\0‘;
 50
 51     temp = init_alp(temp);                                //初始化为大写字母表
 52     p = temp;
 53     while ((p = (strpbrk(p, key))) != NULL)                //将字母表中含有key中的字母设置为空格
 54     {
 55         *p = ‘ ‘;
 56         p++;
 57     }
 58
 59     for (i = 0, k = 0; *(temp + i) != ‘\0‘; i++)        //删除所有的空格
 60     {
 61         if (*(temp + i) != ‘ ‘)
 62         {
 63             *(temp + k) = *(temp + i);
 64             k++;
 65         }
 66     }
 67     *(temp + k) = ‘\0‘;
 68
 69     key = strcat(key, temp);
 70
 71     return 1;
 72 }
 73
 74 void encrypt( char *data, char const *key )            //给数据加密
 75 {
 76     int i, state;
 77     char temp[27];
 78     char *init = NULL;
 79     char *p = NULL;
 80     char chg;
 81
 82     init = init_alp(temp);
 83
 84     for (i = 0; *(data + i) != ‘\0‘; i++)
 85     {
 86         if (isalpha(*(data + i)))
 87         {
 88             if (isupper(*(data + i)))
 89                 state = 1;
 90             else
 91             {
 92                 *(data + i) = toupper(*(data + i));
 93                 state = 0;
 94             }
 95             p = strchr(init, *(data + i));
 96             chg = *(key + (p - init));
 97             *(data + i) = state ? chg : tolower(chg);
 98         }
 99     }
100 }
101
102 void decrypt( char *data, char const *key )            //给数据解密
103 {
104     int i, state;
105     char temp[27];
106     char *init = NULL;
107     char *p = NULL;
108     char chg;
109
110     init = init_alp(temp);
111
112     for (i = 0; *(data + i) != ‘\0‘; i++)
113     {
114         if (isalpha(*(data + i)))
115         {
116             if (isupper(*(data + i)))
117                 state = 1;
118             else
119             {
120                 *(data + i) = toupper(*(data + i));
121                 state = 0;
122             }
123             p = strchr(key, *(data + i));
124             chg = *(init + (p - key));
125             *(data + i) = state ? chg : tolower(chg);
126         }
127     }
128 }
129
130 int main (void)
131 {
132     char key[28] = "Hellomnnnnab";
133     char temp[28];
134     char *key_m = temp;
135     char data[] = "Hello world!";
136
137     key_m = init_alp(key_m);
138     printf("%s\n", key);                //显示输入的key
139
140     if (prepare_key(key))
141     {
142         printf("\nAlpha: \n");            //显示大写字母表
143         printf("%s\n", key_m);
144         printf("\nKey: \n");            //显示生成的key秘钥
145         printf("%s\n", key);
146
147         printf("\nEncode: \n");
148         printf("%s\n", data);
149         encrypt(data, key);                //加密
150         printf("%s\n", data);
151
152         printf("\nDecode: \n");
153         printf("%s\n", data);
154         decrypt(data, key);                //解密
155         printf("%s\n", data);
156     }
157     else
158         printf("Key error!\n");
159
160
161     getchar();
162     return 0;
163 }

9.15

  1 #include <stdio.h>
  2 #include <string.h>
  3 #include <ctype.h>
  4
  5 void dollars(char *dest, char const *src)
  6 {
  7     int i, j, srclen = 0, offset = 0, state = 0;
  8     int a = 0, b = 0;
  9     char *destbak = NULL;
 10     destbak = dest;
 11
 12         srclen = strlen(src);
 13         *dest++ = ‘$‘;
 14
 15     if (srclen >= 3)
 16     {
 17         a = (srclen - 2) / 3;
 18         b = (srclen - 2) % 3;
 19
 20         for (i = 0; (i < a); i++)
 21         {
 22             if ( i == 0 )
 23             {
 24                 for (j = 0; j < b; j++)
 25                 {
 26                     *(dest++) = *(src++);
 27                 }
 28             }
 29
 30             if (b != 0)
 31                 *(dest++) = ‘,‘;
 32
 33             for (j = 0; j < 3; j++)
 34                 *(dest++) = *(src++);
 35         }
 36
 37         if ((a == 0) && (b != 0))
 38         {
 39             for (j = 0; j < b; j++)
 40             {
 41                 *(dest++) = *(src++);
 42             }
 43         }
 44         *((dest++)) = ‘.‘;
 45
 46         for ( ; *(src) != ‘\0‘;dest++, src++)
 47             *(dest) = *(src);
 48         *(dest) = ‘\0‘;
 49     }
 50     else
 51     {
 52         memset(dest, ‘0‘, 4);
 53         *(++dest) = ‘.‘;
 54         dest++;
 55         for (i = 0; i < 2 - srclen; i++)
 56             *(dest++) = ‘0‘;
 57
 58         for (i = 0; i < srclen; i++)
 59             *(dest + i) = *(src + i);
 60     }
 61 }
 62
 63 int dollchk(char *src)                            //检查要处理的数据中是否有非数字字符
 64 {
 65     int i;
 66     for (i = 0; *(src + i) != ‘\0‘; i++)
 67     {
 68         if (!isdigit(*(src + i)))
 69         {
 70             return 0;
 71         }
 72     }
 73     return 1;
 74 }
 75
 76 int main (void)
 77 {
 78     char temp[20] = { 0 };                //目标缓存
 79     char dollar[20];
 80     char *dest = temp;
 81     int state = 0;
 82
 83     printf("Please enter some numbers: \n");
 84     scanf("%s", dollar);
 85
 86     state = dollchk(dollar);
 87     if (!state)                            //检查要处理的数据中含有非数字字符,报错,退出
 88     {
 89         printf("Data error!\n");
 90         getchar();
 91         getchar();
 92         return 0;
 93     }
 94
 95     printf("%s\n", dest);
 96     printf("%s\n", dollar);
 97
 98     dollars(dest, dollar);
 99     if (*dest != ‘\0‘)
100         printf("%s\n", dest);
101
102     getchar();
103     getchar();
104     return 0;
105 }

9.16

 1 #include <stdio.h>
 2 #include <string.h>
 3
 4 int format( char *format_string, char const *digit_string )
 5 {
 6     int formatlen = strlen(format_string);
 7     int digitlen = strlen(digit_string);
 8     int i, j, k;
 9     char *p = NULL;
10
11     if (formatlen < digitlen)
12         return 0;
13     if ((*digit_string) == ‘\0‘)
14         return 0;
15
16     if ((p = strchr(format_string, ‘.‘)) != NULL)
17     {
18         if ((k = formatlen - (p - format_string)) > digitlen)
19         {
20             for (i = formatlen, j = digitlen; j >= 0; i--, j--, k--)
21             {
22                 *(format_string + i) = *(digit_string + j);
23             }
24
25             for (; k > 0; i--, k--)
26             {
27                 *(format_string + i) = ‘0‘;
28             }
29
30             if ( (*(format_string + i) == ‘.‘) )
31             {
32                 i--;
33                 *(format_string + i) = ‘0‘;
34             }
35
36             for (i--; i >= 0; i--)
37             {
38                 *(format_string + i) = ‘ ‘;
39             }
40         }
41         else
42         {
43             for (i = formatlen, j = digitlen; j >= 0; i--, j--)
44             {
45                 if ( (*(format_string + i) == ‘,‘)
46                     || (*(format_string + i) == ‘.‘) )
47                     i--;
48                 *(format_string + i) = *(digit_string + j);
49             }
50             for (; i >= 0; i--)
51                 *(format_string + i) = ‘ ‘;
52         }
53     }
54
55     return 1;
56 }
57
58 int main (void)
59 {
60     char formats[] = "###,###.#####";
61     char const digits[] = "123";
62
63     printf("%s\n", formats);
64     printf("%s\n", digits);
65     if (format(formats, digits))
66         printf("%s\n", formats);
67     else
68         printf("Data error!\n");
69
70     getchar();
71     return 0;
72 }

9.17

时间: 2024-10-09 01:44:49

《C和指针》章节后编程练习解答参考——第9章的相关文章

《C和指针》章节后编程练习解答参考——第10章

10.1 1 #include <stdio.h> 2 3 typedef struct 4 { 5 unsigned char QuHao[5]; 6 unsigned char Exchange[10]; 7 unsigned char StnNum[10]; 8 }TelphoneNumber; 9 10 typedef struct 11 { 12 unsigned char date[10]; 13 unsigned char time[10]; 14 TelphoneNumber

《C和指针》章节后编程练习解答参考——6.3

<C和指针>——6.3 题目: 编写一个函数,把参数字符串中的字符反向排列. 函数原型: void reverse_string(char *string); 要求: 使用指针而不是数组下标 不要使用任何C函数库中用于操纵字符串的函数 不要声明一个局部数组来临时存储参数字符串 解答代码: #include <stdio.h> void reverse_string(char *string) { int i, n=0; while (*(string+n) != '\0') //计

上海华为的一道关于指针方面的编程题(C/C++)

int A[nSize],其中隐藏着若干0,其余非0整数,写一个函数int Func(int* A, int nSize),使A把0移至后面,非0整数移至数组前面并保持有序,返回值为原数据中第一个元素为0的下标. 尽可能不使用辅助空间且考虑效率及异常问题,注释规范且给出设计思路 注:我的方法的复杂度为O(n),大家如果有其它方法希望可以交流一下. /* author: jiangxin Blog: http://blog.csdn.net/jiangxinnju */ #include <ios

Java指针详解___案例解答

大家先看看下面的这个程序:--------->相信初级程序员就能看得懂 int k1=1; int k2=k1; k2+=8; System.out.println("k1:"+k1); 大声回答,k1等于几? 输出: k1:1 这是为什么呢?不是明明k2已经指向了k1,然后k2的值发生改变,k1就要发生改变吗? 刚开始:k1 ,k2指向同一个内存地址: 当发生语句:k2+=8的时候,我们这么看:k2=k2+8,第一步:k2+8,很简单啊,等于9呗,这时候,内存空间会自动分配一个

《Unix环境高级编程》读书笔记 第7章-进程环境

1. main函数 int main( int argc, char *argv[] ); argc是命令行参数的数目,包括程序名在内 argv是指向参数的各个指针所构成的数组,即指针数组 当内核执行C程序时(使用exec函数),在调用main前先调用一个特殊的启动例程.可执行程序文件将此启动例程指定为程序的起始地址——这是由连接器设置的,而连接器则是由C编译器调用.启动例程从内核取得命令行参数和环境变量值,然后按上述方式调用main函数做好安排. 2. 进程终止 有8种方式使进程终止,其中5种

《Unix环境高级编程》读书笔记 第3章-文件I/O

1. 引言 Unix系统的大多数文件I/O只需用到5个函数:open.read.write.lseek以及close 本章描述的函数经常被称为不带缓冲的I/O.术语不带缓冲指的是在用户的进程中对其不会自动缓冲,每个read和write都调用内核中的一个系统调用.但是,所有磁盘I/O都要经过内核的块缓存区(也称为内核的缓冲区高速缓存).唯一例外的是对原始磁盘设备的I/O. 2. 文件描述符 对于内核而言,所有打开的文件都通过文件描述符引用.文件描述符是一个非负整数,其变化范围是0~OPEN_MAX

C和指针 (pointers on C)——第十五章:输入输出函数

第十五章 输入输出函数 这一章读完的第一感觉就是"呵呵". 如果说上过C语言课,基本上scanf()/printf()算是用的比较熟练了.尤其是那些抽象的格式说明.还有scanf()为什么要加括号. 读过本书前面的内容的话,getchar(),putchar(),gets(),puts()这些应该也问题不大. 再如果的话,你学过计算机图形学,你玩过OpenGL,听说过双缓存机制,那么fflush()也肯定弄明白了. 再加上FILE的操作,输入输出定位刷新删除改名,流的概念. 这一章就会

《Java并发编程实战》第十五章 原子变量与非阻塞同步机制 读书笔记

一.锁的劣势 锁定后如果未释放,再次请求锁时会造成阻塞,多线程调度通常遇到阻塞会进行上下文切换,造成更多的开销. 在挂起与恢复线程等过程中存在着很大的开销,并且通常存在着较长时间的中断. 锁可能导致优先级反转,即使较高优先级的线程可以抢先执行,但仍然需要等待锁被释放,从而导致它的优先级会降至低优先级线程的级别. 二.硬件对并发的支持 处理器填写了一些特殊指令,例如:比较并交换.关联加载/条件存储. 1 比较并交换 CAS的含义是:"我认为V的值应该为A,如果是,那么将V的值更新为B,否则不需要修

Python核心编程(第二版) 第二章习题答案 未完待续

2-2.程序输出.阅读下面的Python脚本.#!/usr/bin/env python1 + 2 * 4(a)你认为这段脚本是用来做什么的?(b)你认为这段脚本会输出什么?(c)输入以上代码,并保存为脚本,然后运行它,它所做的与你的预期一样吗?为什么一样/不一样?(d)这段代码单独执行和在交互解释器中执行有何不同?试一下,然后写出结果.(e)如何改进这个脚本,以便它能和你想象的一样工作?答:(a)这段脚本是用来计算表达式的值(b)脚本会输出9(c)保存为脚本,运行后没有输出.和自己预期不一样.