zoukankan html css js c++ java

经典算法_字符串

二维数组：用于字符串顺序固定的情况，同时字符串需要修改的情况。地址不可以变化，数据可以变化。不修改地址的情况下管理数据。比如：某人改名

char a[m][n] sizeof()为 m*n

指针数组：用于字符串不需要修改，顺序可以调整的情况。指向的数据不可以变化，地址可以变化。不修改数据的情况下数据查看。比如：a-z，z-a

char *b[n] sizeof()为 4*n

1 写出函数，相当于_strlwr，相当于_strupr

2 写出函数，相当于_strrev

3 写出函数，相当于_strset

4 写出函数，相当于memset

5 写出函数，相当于strcat

6 写出函数，相当于strchr

7 写出函数，相当于strcmp

8 写出函数，相当于strcpy

9 写出函数，相当于strlen

递归实现strlen

10 写出函数，相当于strncat

11 写出函数，相当于strncpy

12 写出函数，相当于strstr

13 根据字符串，转换成数字

14 根据数字，转换成字符串

15 根据提供的字符串和特定字符，删除字符串中的特定字符，保留原来的字符串，新的字符串另外保存

16 模拟输入密码，最多3次输入错误密码，提示你还有多少次机会

17 字符串数组排序

18 使用指针数组，对一个字符串数组排序，不移动字符串

19 字符串指针，翻译潜台词

20 有一行字符，统计其中的单词个数（单词之间以空格分隔），并将每一个单词的第一个字母改为大写

21 写一函数完成将无符号十进制整数转换成十六进制字符表示并存于字符串数组中。

22 大数计算（20分）

题目内容：

很大的数就没办法用int或是long long这样的类型直接计算了，用double则无法保证精度什么的，所以，得自己写程序来算。你的程序要读入两个很大的数，范围在

内，然后你的程序要计算它们的和、差及积并输出。

输入格式:

两行，每行一个数字。

输出格式：

三行，每行一个数字，依次表示输入的数字的和、差及积。

输入样例：

1853244628050278

506996688545785164

输出样例：

508849933173835442

-505143443917734886

939588889486756266731803978475592

时间限制：1000ms内存限制：64000kb

23 编写将一个十进制数M转化成N进制数（2≤N≤16）的程序。提示：转化成N进制数的各位数可以分别放在数组的各个元素中。

注意：进制N超过10时, 用A表示10，B表示11,…，F表示15。

24 巧填运算符。

在下式的方块中填上加号或减号，使等式成立，共有多少种填法? 把每种填法的式子打印出来。

1 写出函数，相当于_strlwr，相当于_strupr

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 #include<string.h>
 6 
 7 void tobig(char *p)
 8 {
 9     int i;
10     int length = strlen(p);
11 
12     for (i = 0;i < length - 1;i++)
13     {
14         if (p[i] >= 'a'&&p[i] <= 'z')
15         {
16             p[i] -= 32;
17         }
18     }
19 }
20 
21 void tosmall(char *p)
22 {
23     int i;
24     int length = strlen(p);
25 
26     for (i = 0;i < length - 1;i++)
27     {
28         if (p[i] >= 'A'&&p[i] <= 'Z')
29         {
30             p[i] += 32;
31         }
32     }
33 }
34 
35 main()
36 {
37     char str[20] = "NOTEpad";
38     
39     puts(str);
40 
41     tobig(str);
42 
43     puts(str);
44 
45     tosmall(str);
46 
47     puts(str);
48 
49     system("pause");
50 }

2 写出函数，相当于_strrev

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 #include<string.h>
 6 
 7 void mystrrev(char *p)
 8 {
 9     int i;
10     int length = strlen(p);
11     char t;
12 
13     for (i = 0;i < length / 2;i++)
14     {
15         t = p[i];
16         p[i] = p[length - 1 - i];
17         p[length - 1 - i] = t;
18     }
19 }
20 
21 main()
22 {
23     char str[20] = "hello8848";
24     
25     puts(str);
26 
27     mystrrev(str);
28 
29     puts(str);
30 
31     system("pause");
32 }

3 写出函数，相当于_strset

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 
 6 void mystrset(char *str, char ch)
 7 {
 8     while (*str != '')//遍历字符串
 9     {
10         *str = ch;//赋值字符
11         str++;//字符串指针不断向前
12     }
13 }
14 
15 main()
16 {
17     char str[20] = "hello8848";
18     
19     puts(str);
20 
21     mystrset(str, '8');
22 
23     puts(str);
24     
25     system("pause");
26 };

4 写出函数，相当于memset

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 #include<string.h>
 6 
 7 void *mymemset(void *p, int num, int length)
 8 {
 9     char *px = (char *)p;//创建一个字符指针接受空指针的地址
10     if (p == NULL)
11     {
12         return px;
13     }
14 
15     while (length > 0)//长度不为0，就继续执行赋值字符
16     {
17         *px = (char)num;//逐个赋值字符
18         px++;//指针一直向前
19         length--;//前进一步，步数计数器减1
20     }
21     return p;//返回起始地址
22 }
23 
24 main()
25 {
26     char str[40] = "china is great";
27     int num[5] = { 1,2,3,4,5 };
28     float fl[5] = { 1.0,2.0,3.0,4.0,5.0 };
29     int i;
30 
31     puts(str);
32     for (i = 0;i < 5;i++)
33     {
34         printf("%d ", num[i]);
35     }
36     printf("
");
37     for (i = 0;i < 5;i++)
38     {
39         printf("%f ", fl[i]);
40     }
41 
42     mymemset(str, '', 40);
43     mymemset(num, 0, 20);
44     mymemset(fl, 0, 20);
45 
46     puts(str);
47     for (i = 0;i < 5;i++)
48     {
49         printf("%d ", num[i]);
50     }
51     printf("
");
52     for (i = 0;i < 5;i++)
53     {
54         printf("%f ", fl[i]);
55     }
56     
57     system("pause");
58 };

5 写出函数，相当于strcat

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 
 6 void mystrcat(char *s, char *t)
 7 {
 8     if (s == NULL || t == NULL)
 9     {
10         return NULL;
11     }
12     else
13     {
14         char *p = s;//保存首地址
15 
16         while (*s != '')//循环到s的尾部
17         {
18             s++;
19         }
20 
21         while (*t != '')//字符串复制
22         {
23             *s = *t;
24             s++;
25             t++;
26         }
27 
28         *s = '';//字符串最后加上
29 
30         return p;//返回首地址
31     }
32 }
33 
34 main()
35 {
36     char str1[100] = "note";
37 
38     char str2[100] = "pad";
39 
40     puts(str1);
41 
42     mystrcat(str1, str2);
43 
44     puts(str1);
45 
46     system("pause");
47 }

6 写出函数，相当于strchr

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 
 6 char *mystrchr(char *s, char ch)
 7 {
 8     if (s == NULL)
 9     {
10         return NULL;
11     }
12     else
13     {
14         while (*s != '')
15         {
16             if (*s == ch)
17             {
18                 return s;
19             }
20             s++;
21         }
22 
23         return NULL;
24     }
25 }
26 
27 main()
28 {
29     char str[100] = "note";
30 
31     char ch = 't';
32 
33     char *p = mystrchr(str, ch);
34 
35     if (p == NULL)
36     {
37         printf("not found");
38     }
39     else
40     {
41         printf("%c %x
", *p, &p);
42     }
43     
44     system("pause");
45 }

7 写出函数，相当于strcmp

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<stdlib.h>

int mystrcmp(char *s, char *t)
{
    while (*s == *t&&*s != '')
    {
        s++;
        t++;
    }

    return *s - *t;
}

main()
{
    char str1[100] = "abc";
    
    char str2[100] = "bcd";

    printf("%d
", mystrcmp(str1, str2));
    
    system("pause");
}

8 写出函数，相当于strcpy

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 
 6 void mystrcpy(char *s, char *t)
 7 {
 8     int i = 0;
 9     while ((*s++ = *t++) != '');
10 }
11 
12 main()
13 {
14     char str1[100] = "notepad";
15 
16     char str[100];
17 
18     mystrcpy(str, str1);
19 
20     puts(str);
21     
22     system("pause");
23 }

9 写出函数，相当于strlen

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 #include<string.h>
 6 
 7 int mystrlen(char *p)
 8 {
 9     int length = 0;//长度
10 
11     while (*p != '')//检索字符串是否结束
12     {
13         length++;//继续计数
14         p++;//指针继续前进
15     }
16 
17     return length;
18 }
19 
20 main()
21 {
22     char str[100] = "i love you";
23 
24     char *p = "i love you";
25 
26     printf("%d,%d
", mystrlen(str), mystrlen(p));
27     
28     system("pause");
29 }

递归实现strlen

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 
 4 int mystrlen(char *str)
 5 {
 6     if (*str == '')
 7     {
 8         return 0;
 9     }
10     else
11     {
12         return mystrlen(str + 1) + 1;
13     }
14 }
15 
16 void main()
17 {
18     char str[100] = "abcdefg";
19     
20     printf("%d
", mystrlen(str));
21 
22     system("pause");
23 }

10 写出函数，相当于strncat

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 #include<string.h>
 6 
 7 void mystrncat(char *bc, char *c, int length)
 8 {
 9     if (bc == NULL || c == NULL)
10     {
11         return NULL;
12     }
13     else
14     {
15         int i;
16         char *p = bc;
17         while (*p != '')
18         {
19             p++;
20         }
21         //p指向了字符串的末端''
22         for (i = 0;i < length;i++)//前进length个字符
23         {
24             *p = c[i];//赋值
25             p++;//指针前进，遍历
26         }
27     }
28 }
29 
30 main()
31 {
32     char str[30] = "task";
33     char str1[30] = "list8848";
34 
35     puts(str);
36 
37     mystrncat(str, str1, 4);
38 
39     puts(str);
40 
41     system(str);
42 
43     system("pause");
44 }

11 写出函数，相当于strncpy

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include <stdio.h>
 4 #include <stdlib.h>
 5 #include <string.h>
 6 
 7 main()
 8 {
 9     char *str = "abcdefghijklmnopqrstuvwxyz";
10     puts(str);
11 
12     int len = strlen(str);//字符串长度
13     printf("%d
", len);
14 
15     char *ch = (char *)malloc(sizeof(char)*len);//动态数组
16     int i;
17 
18     int n;//复制字符串的前 N个子字符
19     scanf("%d", &n);
20 
21     for (i = 0; i < n; i++)
22     {
23         ch[i] = *(str + i);
24     }
25 
26     ch[i] = '';//字符串最后
27 
28     puts(ch);
29 
30     free(ch);//malloc对应free
31 
32     system("pause");
33 }

12 写出函数，相当于strstr

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 #include<string.h>
 6 
 7 char *mystrstr(char *s, char *t)
 8 {
 9     char *p = NULL;
10 
11     if (s == NULL || t == NULL)
12     {
13         return p;
14     }
15 
16     int slength = strlen(s);//母串长度
17     int tlength = strlen(t);//子串长度
18     int i, j;
19     int flag = 1;//默认字符串相等
20 
21     for (i = 0;i <= slength - tlength;i++)
22     {
23         flag = 1;
24 
25         for (j = 0;j < tlength;j++)
26         {
27             if (s[i + j] != t[j])//有一个字符不等
28             {
29                 flag = 0;//0代表不等
30                 break;//有一个不等跳出循环
31             }
32         }
33 
34         if (flag == 1)
35         {
36             return (s + i);//返回找到的地址
37         }
38     }
39     return p;
40 }
41 
42 main()
43 {
44     char str1[40] = "i love iphone";
45 
46     char str2[10] = "iphone";
47     
48     char *p = mystrstr(str1, str2);
49 
50     if (p == NULL)
51     {
52         printf("没有找到");
53     }
54     else
55     {
56         printf("值%c,地址%x", *p, p);
57     }
58 
59     
60     system("pause");
61 }

13 根据字符串，转换成数字

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 
 6 int tonum(char *str)
 7 {
 8     char *istr = str;//副本，指针将会变化，所以需要副本
 9     int wei = 0;//求出位数
10     int i;
11     int res = 0;//最后结果
12     int n;//每次取出的数字
13     
14     while (*str != '')
15     {
16         if ((*str) < '0' || (*str) > '9')//如果不是数字，返回-1
17         {
18             return -1;
19         }
20         str++;
21         wei++;
22     }
23 
24     for (i = 0;i < wei;i++)
25     {
26         res *= 10;
27         n = istr[i] - 48;//需要副本
28         res += n;
29     }
30 
31     return res;
32 }
33 
34 main()
35 {
36     char str[10] = "12345";
37 
38     printf("%d", tonum(str));
39 
40     system("pause");
41 }

14 根据数字，转换成字符串

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 
 6 int getwei(int num)
 7 {
 8     if (num < 10)
 9     {
10         return 1;
11     }
12     else
13     {
14         return getwei(num / 10) + 1;
15     }
16 }
17 
18 void tostr(int num, char *str)
19 {
20     int wei = getwei(num);
21     int i = wei - 1;
22 
23     while (num)
24     {
25         str[i] = num % 10 + 48;//每次取出最后一位，从后到前保存到字符串
26         num /= 10;//去掉最后一位
27         i--;
28     }
29 }
30 
31 main()
32 {
33     int num = 1234567;
34 
35     char str[50] = { 0 };
36 
37     tostr(num, str);
38     
39     puts(str);
40 
41     system("pause");
42 }

15 根据提供的字符串和特定字符，删除字符串中的特定字符，保留原来的字符串，新的字符串另外保存

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 #include<string.h>
 6 
 7 main()
 8 {
 9     char str[30] = "helllo c, hello cpp";
10     char ch = 'c';
11     char laststr[30] = { 0 };//创建一个空字符串
12     int i = 0;
13 
14     char *p = str;//指针存储str的首地址
15 
16     while (*p != '')
17     {
18         if (*p != ch)//如果不等于该字符
19         {
20             laststr[i] = *p;//赋值的动作
21             i++;//下标向前移动
22         }
23         else
24         {
25             //不操作
26         }
27         p++;//指针向前移动，遍历字符串的必要条件
28     }
29 
30     puts(laststr);
31 
32     system("pause");
33 };

16 模拟输入密码，最多3次输入错误密码，提示你还有多少次机会

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 #include<string.h>
 6 
 7 main()
 8 {
 9     char realpass[30] = "password";//正确密码
10     int i;
11 
12     for (i = 0;i < 3;i++)
13     {
14         char stringput[30];//输入的密码
15         gets(stringput);
16         if (strcmp(stringput, realpass) == 0)
17         {
18             printf("correct
");
19             break;
20         }
21         else
22         {
23             printf("wrong. you got %d chance
", 2 - i);
24             if (i == 2)
25             {
26                 printf("3 wrong. account will be locked
");
27             }
28         }
29     }
30 
31     system("pause");
32 };

17 字符串数组排序

（要使用strcpy，不能直接赋值，注意和指针数组区别）

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 #include<string.h>
 6 
 7 main()
 8 {
 9     char str[10][20] = { "apple","google","ibm","intel","microsoft","facebook","oracle" ,"cisco","hp","amd" };
10     //一个字符二维数组
11     //一个一维数组，每一个元素又是一个字符数组，有20个字符的缓冲区
12     int i, j;
13     char temp[20];
14 
15     printf("排序前
");
16 
17     for (i = 0;i < 10;i++)
18     {
19         puts(str[i]);
20     }
21 
22     for (i = 0;i < 10 - 1;i++)//冒泡，从第一个开始，只剩下一个就不需要排序，所以i < 10 - 1
23     {
24         for (j = 0;j < 10 - 1 - i;j++)//字符串排序，从i + 1开始循环
25         {
26             if (strcmp(str[i], str[j])>0)
27             {
28                 strcpy(temp, str[i]);
29                 strcpy(str[i], str[j]);
30                 strcpy(str[j], temp);
31             }
32         }
33     }
34 
35     printf("排序后
");
36 
37     for (i = 0;i < 10;i++)
38     {
39         puts(str[i]);
40     }
41 
42     system("pause");
43 };

18 使用指针数组，对一个字符串数组排序，不移动字符串

（要直接赋值，不能使用strcpy，注意和字符串数组区别）

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 
 6 main()
 7 {
 8     char *p[5] = { "calc","notepad","tasklist","mspaint","wrinte" };//创建一个指针数组，每一个元素都存储一个常量字符串的地址
 9     printf("%d
", sizeof(p));
10     int i, j;
11     char *t;
12 
13     printf("排序以前
");
14     for (i = 0;i < 5;i++)
15     {
16         printf("%s,%c
", p[i], *p[i]);//*p[i]是字符串的首字母
17     }
18 
19     for (i = 0;i < 5 - 1;i++)
20     {
21         for (j = 0;j < 5 - 1 - i;j++)
22         {
23             if (*p[j] > *p[j + 1])
24             {
25                 t = p[j];
26                 p[j] = p[j + 1];
27                 p[j + 1] = t;
28             }
29         }
30     }
31 
32     printf("排序以后
");
33     for (i = 0;i < 5;i++)
34     {
35         printf("%s,%c
", p[i], *p[i]);//*p[i]是字符串的首字母
36     }
37 
38     system("pause");
39 };

19 字符串指针，翻译潜台词

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include <stdio.h>
 4 #include <string.h>
 5 
 6 char *word[] = { "我们还是当朋友好了","我想我真的不适合你","其实你人很好" };//字符串指针，存储了常量字符串的地址
 7 
 8 char *realword[] = { "其实你还是有多余的利用价值","我根本就不喜欢你","还没好到我想要的程度" };
 9 
10 main()
11 {
12     char str[100];
13     int i;
14     int flag = -1;
15     int num;
16 
17     gets(str);
18     printf("你需要翻译的潜台词是
");
19     puts(str);
20 
21     num = sizeof(word) / sizeof(char *);
22 
23     for (i = 0;i < num;i++)
24     {
25         if (strcmp(word[i], str) == 0)
26         {
27             flag = 1;
28             break;
29         }
30     }
31 
32     if (flag == -1)
33     {
34         printf("找不到字符串
");
35         printf("我们只收录了以下潜台词
");
36         for (i = 0;i < num;i++)
37         {
38             printf("%s->%s
", word[i], realword[i]);
39         }
40     }
41     else
42     {
43         printf("潜台词是
");
44         puts(realword[i]);
45     }
46         
47     system("pause");
48 }

20 有一行字符，统计其中的单词个数（单词之间以空格分隔），并将每一个单词的第一个字母改为大写

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include <stdio.h>
 4 #include <stdlib.h>
 5 #include <string.h>
 6 
 7 main()
 8 {
 9     char str[100];//字符串
10     gets(str);//接收字符串输入
11     puts(str);
12 
13     int num = 0;//单词个数
14     char *ps = str;//指针指向字符串
15     int flag = 1;//1还没有到字符串结尾，0到字符串结尾
16 
17     while (*ps == ' ')//跳过开头的空格
18     {
19         ps++;
20     }
21 
22     while (*ps != '')//外循环，直到字符串结尾
23     {
24         if (*ps >= 'a'&& *ps <= 'z')//如果开头是小写字母
25         {
26             *ps -= 32;//将每一个单词的第一个字母改为大写。
27             num++;//统计单词个数
28         }
29 
30         while (*ps != ' ' && *ps != '')//度过单词，直到空格或者字符串结尾
31         {
32             if (*ps == '')//如果到达字符串结尾
33             {
34                 flag = 0;//1还没有到字符串结尾，0到字符串结尾
35                 break;//跳出循环
36             }
37             else
38             {
39                 ps++;//指针移动
40             }
41         }
42 
43         if (flag == 0)//1还没有到字符串结尾，0到字符串结尾
44         {
45             break;
46         }
47 
48         while (*ps == ' ')//跳过空格
49         {
50             ps++;
51         }
52     }
53 
54     puts(str);
55     printf("%d
", num);
56 
57     system("pause");
58 }

21 写一函数完成将无符号十进制整数转换成十六进制字符表示并存于字符串数组中。

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include <stdio.h>
 4 #include <stdlib.h>
 5 
 6 char str[100] = { 0 };//初始化字符串
 7 
 8 void print(char *str)//打印字符串
 9 {
10     int i = 0;//保存字符串长度
11 
12     while (*str != 0)//循环字符串
13     {
14         str++;//指针移动
15         i++;//长度+1
16     }
17     str--;//最后指向''，因此需要向左一位
18 
19     for (i; i > 0; i--)
20     {
21         printf("%c", *str);
22         str--;//指针移动
23     }
24 }
25 
26 void ten2sixteen(int num)//将无符号十进制整数转换成十六进制字符
27 {
28     int i = 0;//数组下标
29 
30     while (num)
31     {
32         switch (num % 16)
33         {
34         case 0:
35         case 1:
36         case 2:
37         case 3:
38         case 4:
39         case 5:
40         case 6:
41         case 7:
42         case 8:
43         case 9:
44             str[i] = (num % 16) + 48;//ASCII码
45             break;
46         case 10:str[i] = 'A';
47             break;
48         case 11:str[i] = 'B';
49             break;
50         case 12:str[i] = 'C';
51             break;
52         case 13:str[i] = 'D';
53             break;
54         case 14:str[i] = 'E';
55             break;
56         case 15:str[i] = 'F';
57             break;
58         }
59 
60         num /= 16;
61         i++;
62     }
63 }
64 
65 void main()
66 {
67     int num = 1234;
68 
69     ten2sixteen(num);//将无符号十进制整数转换成十六进制字符
70 
71     print(str);//打印字符串
72 }

22 大数计算（20分）

题目内容：

内，然后你的程序要计算它们的和、差及积并输出。

输入格式:

两行，每行一个数字。

输出格式：

三行，每行一个数字，依次表示输入的数字的和、差及积。

输入样例：

1853244628050278

506996688545785164

输出样例：

508849933173835442

-505143443917734886

939588889486756266731803978475592

时间限制：1000ms内存限制：64000kb

中软最难10K

　　　　　　1　　2　　3　　4　　5

*　　　　　　　　　　　　　1　　9

-----------------------------------------

　　　　　　9　 18　 27　 36　 45

+　　1　　 2　 3 　 4　　5

-----------------------------------------

　　　1　　11　21　31　　41　45

-----------------------------------------

　　　2　　3　　4　　5　　5　　5

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <string.h>
  4 
  5 void jia(char *dataa, char *datab);//字符串相加
  6 void cheng(char *dataa, char *datab);//字符串相乘
  7 
  8 int main()
  9 {
 10     char str1[100] = "1853244628050278";
 11     char str2[100] = "506996688545785164";
 12 
 13     jia(str1, str2);//字符串相加
 14     cheng(str1, str2);//字符串相乘
 15 
 16     return 0;
 17 }
 18 
 19 void jia(char *dataa, char *datab)//字符串相加
 20 {
 21     int lengtha = strlen(dataa);//第一个字符串长度
 22     int lengthb = strlen(datab);//第二个字符串长度
 23     int length = lengtha > lengthb ? lengtha : lengthb;//获取两个字符串长度的最大值
 24 
 25     int * arr = (int *)malloc(sizeof(int)*(length + 1));//创建动态数组，数组元素的数据类型是int，元素个数是两个字符串长度的最大值+1
 26     int i;//数组下标
 27     int j;//数组下标
 28 
 29     memset(arr, 0, sizeof(int)*(length + 1));//初始化字符串
 30 
 31     if (lengtha > lengthb)//如果第一个字符串的长度大于第二个字符串的长度。第一步，字符串转换为数字
 32     {
 33         j = lengthb - 1;//这是第二个字符串的长度-1，由于数组下标从0开始，因此-1
 34 
 35         for (i = lengtha - 1; i >= 0; i--)//循环最长的字符串，即是第一个字符串，由于数组下标从0开始，因此-1
 36         {
 37             if (j >= 0)//如果第二个字符串下标还没有到0（包括0）
 38             {
 39                 arr[i + 1] = (dataa[i] - 48) + (datab[j] - 48);//两个字符串相加
 40                 j--;//第二个字符串向前移动
 41             }
 42             else//如果第二个字符串下标已经小于0，那么只剩下第一个字符串
 43             {
 44                 arr[i + 1] = dataa[i] - 48;
 45             }
 46         }
 47     }
 48     else//如果第一个字符串的长度小于等于第二个字符串的长度
 49     {
 50         i = lengtha - 1;//这是第一个字符串的长度-1，由于数组下标从0开始，因此-1
 51 
 52         for (j = lengthb - 1; j >= 0; j--)//循环最长的字符串，即是第二个字符串，由于数组下标从0开始，因此-1
 53         {
 54             if (i >= 0)//如果第一个字符串下标还没有到0（包括0）
 55             {
 56                 arr[j + 1] = (dataa[i] - 48) + (datab[j] - 48);//两个字符串相加
 57                 i--;//第一个字符串向前移动
 58             }
 59             else//如果第一个字符串下标已经小于0，那么只剩下第二个字符串
 60             {
 61                 arr[j + 1] = datab[j] - 48;
 62             }
 63         }
 64     }
 65 
 66     for (i = length; i >= 0; i--)//第二步，数组中>9的元素进位
 67     {
 68         if (arr[i] > 9)//大于9，需要进位
 69         {
 70             arr[i - 1] += arr[i] / 10;//先进位
 71             arr[i] %= 10;//后取出个位数
 72         }
 73     }
 74 
 75     i = 0;
 76     while (arr[i] == 0)//跳过0
 77     {
 78         i++;//到达不为0的位置
 79     }
 80 
 81     char * str = (char *)malloc(sizeof(char)*(length + 1));//创建动态数组，数组元素的数据类型是char，元素个数是两个字符串长度的最大值+1
 82     memset(str, 0, sizeof(char)*(length + 1));//初始化字符串
 83 
 84     for (j = 0; i < length + 1; i++, j++)//第三步，数字转换为字符串
 85     {
 86         str[j] = arr[i] + 48;//数字转换为字符串+48
 87     }
 88 
 89     str[j] = '';//字符串最后元素是''
 90 
 91     puts(str);//打印结果
 92 }
 93 
 94 void cheng(char *dataa, char *datab)//字符串相乘
 95 {
 96     int lengtha = strlen(dataa);//第一个字符串长度
 97     int lengthb = strlen(datab);//第二个字符串长度
 98     int * arr = (int *)malloc(sizeof(int)*(lengtha + lengthb));//创建动态数组，数组元素的数据类型是int，元素个数是两个字符串长度之和
 99     int i;//数组下标
100     int j;//数组下标
101 
102     memset(arr, 0, sizeof(int)*(lengtha + lengthb));//初始化字符串
103 
104     for (i = 0; i < lengtha; i++)//第一步，字符串转换为数字
105     {
106         for (j = 0; j < lengthb; j++)
107         {
108             arr[i + j + 1] += (dataa[i] - 48)*(datab[j] - 48);
109             //之所以是pres[i + j + 1]，因为可能需要进位，所以预留最前面pres[0]=0;
110             //字符串转换为数字-48
111         }
112     }
113 
114     for (i = lengtha + lengthb - 1; i >= 0; i--)//第二步，数组中>9的元素进位
115     {
116         if (arr[i] > 9)//大于9，需要进位
117         {
118             arr[i - 1] += arr[i] / 10;//先进位
119             arr[i] %= 10;//后取出个位数
120         }
121     }
122 
123     i = 0;
124     while (arr[i] == 0)//跳过0
125     {
126         i++;//到达不为0的位置
127     }
128 
129     char * str = (char *)malloc(sizeof(char)*(lengtha + lengthb));//创建动态数组，数组元素的数据类型是char，元素个数是两个字符串长度之和
130     memset(str, 0, sizeof(char)*(lengtha + lengthb));//初始化字符串
131 
132     for (j = 0; i < lengtha + lengthb; i++, j++)//第三步，数字转换为字符串
133     {
134         str[j] = arr[i] + 48;//数字转换为字符串+48
135     }
136 
137     str[j] = '';//字符串最后元素是''
138 
139     puts(str);//打印结果
140 }

23 编写将一个十进制数M转化成N进制数（2≤N≤16）的程序。提示：转化成N进制数的各位数可以分别放在数组的各个元素中。

注意：进制N超过10时, 用A表示10，B表示11,…，F表示15。

 1 #include <stdio.h>
 2 
 3 void jinzhi(int m, int n, char *str)//转换进制并打印
 4 {
 5     int count = 0;//计数器
 6     int i;//数组下标
 7 
 8     while (m)
 9     {
10         if (m%n < 10)//取出余数
11         {
12             str[count] = m%n + 48;//0的ASCII是48
13         }
14         else
15         {
16             str[count] = m%n + 65 - 10;//A的ASCII是65
17         }
18         
19         count++;//计数器+1
20         m /= n;//不断除数
21     }
22 
23     for (i = count - 1; i >= 0; i--)//打印
24     {
25         printf("%c", str[i]);
26     }
27 }
28 
29 void main()
30 {
31     int m = 998;//十进制数
32     int n = 16;//需要转换的进制
33     char str[100] = { 0 };//保存在字符串
34 
35     jinzhi(m, n, str);//转换进制并打印
36 }

24 巧填运算符。

在下式的方块中填上加号或减号，使等式成立，共有多少种填法? 把每种填法的式子打印出来。

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include <stdlib.h>
 4 
 5 void main()
 6 {
 7     char str[9] = { 0 };//字符串，8个方块中填上加号+或减号-，所以一共有2^8==256种可能，从0到255，255的二进制是11111111，8个1，因此字符串9个即可
 8     int i;//用于循环
 9     int j;//用于循环
10     int sum;//结果
11 
12     for (i = 0; i <= 255; i++)//8个方块中填上加号+或减号-，所以一共有2^8==256种可能
13     {
14         sum = 1;//结果
15         _itoa(i, str, 2);//把整数转换成二进制到字符串
16         for (j = 2; j < 10; j++)//从2到9
17         {
18             if (str[j - 2] == '1')//二进制，如果是1，+
19             {
20                 sum += j;
21             }
22             else//二进制，如果是0，-
23             {
24                 sum -= j;
25             }
26         }
27 
28         if (sum == 9)//如果结果是9
29         {
30             printf("1");
31             for (j = 2; j < 10; j++)//从2到9
32             {
33                 if (str[j - 2] == '1')
34                 {
35                     printf(" + ");
36                 }
37                 else
38                 {
39                     printf(" - ");
40                 }
41                 printf("%d", j);
42             }
43 
44             printf(" = 9
");
45         }
46     }
47 }

查看全文

相关阅读:
Go语言十六进制转十进制
 Go语言中底层数组和切片的关系以及数组扩容规则
 Golang超时机制--2秒内某个函数没被调用就认为超时
 约瑟夫环问题（猴子选大王）
冒泡排序优化
 斐波那契数列
 Linux下使用acme.sh （Let's Encrypt）配置https 免费证书
 git 本地分支指定对应的远程分支
 Git分支开发 -- 利用git pull命令将远程指定仓库的分支拉取到本地
 phpStorm 之本地开发，Linux上跑项目（连接远端服务器开发）

原文地址：https://www.cnblogs.com/denggelin/p/5507395.html