• 数据结构解决相关问题


    Que1:两个字符串中的字符相同,出现的次数也相同,但是出现的顺序不同则认为这两个字符串是兄弟字符串。(eg:“ADB”和“DBA”就是兄弟字符串)现在提供一对字符串,如何确定他们是否是兄弟字符串?

    采用散列表的方式来解决这个问题,由于不考虑排列的问题,所以只需要记录出现的次数就可以了!详细的程序如下所示:

     1 #include <stdio.h>
     2 #include <string.h>
     3 #include <stdlib.h>
     4 #include <stdbool.h>
     5 
     6 bool StringBrother(const char *str0, const char *str1);
     7 
     8 int main()
     9 {
    10     char *str0 = malloc(sizeof(char)*100);
    11     char *str1 = malloc(sizeof(char)*100);
    12     scanf("%s",str0);
    13     scanf("%s",str1);
    14     if(StringBrother(str0,str1))
    15     {
    16         printf("GOOD BROTHER!
    ");
    17     }
    18     else
    19     {
    20         printf("NOT BROTHER!
    ");
    21     }
    22     return 0;
    23 }
    24 bool StringBrother(const char *str0, const char *str1)
    25 {
    26     int len0,len1,i,pos,param[26]={0};
    27     len0 = strlen(str0);
    28     len1 = strlen(str1);
    29     if(len0 != len1) return false;
    30     printf("String's content:
    ");
    31     for(i=0;i<len0;i++)
    32     {
    33         pos = *(str0+i) - 'A';
    34         param[pos] += 1;
    35         pos = *(str1+i) - 'A';
    36         param[pos] -= 1;
    37         printf("The param0[%d] is:%d
    ",pos,param[pos]);
    38     }
    39     for(i=0;i<26;i++)
    40     {
    41         if(param[i] != 0) return false;
    42     }
    43     return true;
    44 }

    输出测试结果如下所示:

    Que2:数字转字符串C语言函数实现方法,任意一个int整数类型的数据转换为string类型

     1 int num2str(char *str,int num) // 返回len
     2 {
     3     int temp, i = 0, j;
     4     while (1) {  // Transform the number
     5         temp = num % 10;
     6         str[i] = char(temp + 48);
     7         i++;
     8         num /= 10;
     9         if (num == 0) break;
    10     }
    11     for (j = 0; j < i / 2; j++) { // reverse the number
    12         temp = str[j];
    13         str[j] = str[i - j - 1];
    14         str[i - j - 1] = temp;
    15     }
    16     return i;
    17 }

    char *str为保存字符串数据的地址空间

    int num为需要转换的整型数据

    Que3: 随机输入四个数字,求解满足数字通过加减乘除的方式得到24,求解成功输出计算的算式:

      1 /* 导入头文件 */
      2 #include <stdio.h>
      3 #include <stdlib.h>
      4 #include <libgen.h>
      5 #include <string.h>
      6 
      7 /* 宏定义基本的加减乘除运算 */
      8 #define sub(A,B) A>B?A-B:B-A
      9 #define div(A,B) A>B?A/B:B/A
     10 #define mul(A,B) A*B
     11 #define sum(A,B) A+B
     12 
     13 /* 函数声明过程 方便调用 */
     14 int four_calc_try(float p1,float p2, float A, float B, float C, float D, char o, char p);
     15 int all_seq_try(float A,float B,float C,float D);
     16 int Get_Methed_Func(float *N);
     17 
     18 
     19 /* 主函数main */
     20 int main ( int argc, char *argv[] )
     21 {
     22     float X[4] = {0}; // 定义并初始化数字变量X
     23     if(argc < 2){ // 判读main文件运行的方式 直接参数方式或者手动循环输入方式
     24         while(1){
     25             printf("Please enter four number:");
     26             scanf("%f %f %f %f",X+0,X+1,X+2,X+3); // 输入参数
     27             printf("The number you input:%.1f %.1f %.1f %.1f
    ",X[0],X[1],X[2],X[3]); // 打印数字参数
     28             if(!Get_Methed_Func(X)) { printf("No Result!
    "); } // 调用计算函数 并返回运算结果
     29         }
     30     }
     31     else{
     32         X[0] = atof(argv[1]); // 输入参数转化为浮点数
     33         X[1] = atof(argv[2]); // 输入参数转化为浮点数
     34         X[2] = atof(argv[3]); // 输入参数转化为浮点数
     35         X[3] = atof(argv[4]); // 输入参数转化为浮点数
     36         printf("The number you input:%.1f %.1f %.1f %.1f
    ",X[0],X[1],X[2],X[3]); // 参数打印
     37         if(!Get_Methed_Func(X)) { printf("No Result!
    "); } // 计算结果
     38     }
     39     return 1;
     40 }
     41 
     42 /* 具体的函数方法实现 */
     43 
     44 /* 尝试两个part之间的不同算式的运算情况(+-x/) 判断计算的结果是否满足24 并退出*/
     45 int four_calc_try(float p1,float p2, float A, float B, float C, float D, char o, char p)
     46 {
     47     float R;
     48     R = sum(p1,p2); if(R == 24){printf("(%.1f%c%.1f)+(%.1f%c%.1f)=%.1f
    ",A,o,B,C,p,D,R); return 1;} // 加法判断
     49     R = sub(p1,p2); if(R == 24){if(p1>p2){printf("(%.1f%c%.1f)-(%.1f%c%.1f)=%.1f
    ",A,o,B,C,p,D,R);}else{printf("(%.1f%c%.1f)-(%.1f%c%.1f)=%.1f
    ",C,p,D,A,o,B,R);} return 1;} // 减法判断
     50     if(p1 < 0 && p2 > 0 || p1 > 0 && p2 < 0) return 0; // 乘法和除法的提前判断,如果一正一负则不用再计算乘除!(提高效率)
     51     R = mul(p1,p2); if(R == 24){printf("(%.1f%c%.1f)*(%.1f%c%.1f)=%.1f
    ",A,o,B,C,p,D,R); return 1;} // 计算判断乘法
     52     R = div(p1,p2); if(R == 24){if(p1>p2){printf("(%.1f%c%.1f)/(%.1f%c%.1f)=%.1f
    ",A,o,B,C,p,D,R);}else{printf("(%.1f%c%.1f)-(%.1f%c%.1f)=%.1f
    ",C,p,D,A,o,B,R);} return 1;} // 计算判断除法
     53     return 0;
     54 }
     55 
     56 /* 调用part1|part2计算函数,并暴力完成part1和part2所有组合方式的枚举 */
     57 int all_seq_try(float A,float B,float C,float D)
     58 {
     59     float p1;
     60     float p21 = C+D; if(p21 == 0) { p21 = 0.001; } // 计算不同的part2
     61     float p22 = C-D; if(p22 == 0) { p22 = 0.001; }
     62     float p23 = D-C; if(p23 == 0) { p23 = 0.001; }
     63     float p24 = C*D; if(p24 == 0) { p24 = 0.001; }
     64     float p25 = C/D; if(p25 == 0) { p25 = 0.001; }
     65     float p26 = D/C; if(p26 == 0) { p26 = 0.001; }
     66 
     67     // printf("A+B
    ");
     68     p1 = A+B; if(p1 == 0) { p1 = 0.001; } // 计算part1 并规避为0的程序Bug
     69     if(four_calc_try(p1,p21,A,B,C,D,'+','+')) {return 1;} // 测试part1和part2 当前状态下的情况
     70     if(four_calc_try(p1,p22,A,B,C,D,'+','-')) {return 1;}
     71     if(four_calc_try(p1,p23,A,B,D,C,'+','-')) {return 1;}
     72     if(four_calc_try(p1,p24,A,B,C,D,'+','*')) {return 1;}
     73     if(four_calc_try(p1,p25,A,B,C,D,'+','/')) {return 1;}
     74     if(four_calc_try(p1,p26,A,B,D,C,'+','/')) {return 1;}
     75 
     76     // printf("A-B
    ");
     77     p1 = A-B; if(p1 == 0) { p1 = 0.001; }
     78     if(four_calc_try(p1,p21,A,B,C,D,'-','+')) {return 1;}
     79     if(four_calc_try(p1,p22,A,B,C,D,'-','-')) {return 1;}
     80     if(four_calc_try(p1,p23,A,B,D,C,'-','-')) {return 1;}
     81     if(four_calc_try(p1,p24,A,B,C,D,'-','*')) {return 1;} // 2 4 2 11 (-2,22)
     82     if(four_calc_try(p1,p25,A,B,C,D,'-','/')) {return 1;}
     83     if(four_calc_try(p1,p26,A,B,D,C,'-','/')) {return 1;}
     84 
     85     // printf("A*B
    ");
     86     p1 = A*B; if(p1 == 0) { p1 = 0.001; }
     87     if(four_calc_try(p1,p21,A,B,C,D,'*','+')) {return 1;}
     88     if(four_calc_try(p1,p22,A,B,C,D,'*','-')) {return 1;}
     89     if(four_calc_try(p1,p23,A,B,D,C,'*','-')) {return 1;}
     90     if(four_calc_try(p1,p24,A,B,C,D,'*','*')) {return 1;}
     91     if(four_calc_try(p1,p25,A,B,C,D,'*','/')) {return 1;}
     92     if(four_calc_try(p1,p26,A,B,D,C,'*','/')) {return 1;}
     93 
     94 
     95     // printf("A/B
    ");
     96     if(B==0) {p1 = 1000000;} else{p1 = A/B;} if(p1 == 0) { p1 = 0.001; }
     97     if(four_calc_try(p1,p21,A,B,C,D,'/','+')) {return 1;}
     98     if(four_calc_try(p1,p22,A,B,C,D,'/','-')) {return 1;}
     99     if(four_calc_try(p1,p23,A,B,D,C,'/','-')) {return 1;}
    100     if(four_calc_try(p1,p24,A,B,C,D,'/','*')) {return 1;}
    101     if(four_calc_try(p1,p25,A,B,C,D,'/','/')) {return 1;}
    102     if(four_calc_try(p1,p26,A,B,D,C,'/','/')) {return 1;}
    103 
    104     // printf("B-A
    ");
    105     p1 = B-A; if(p1 == 0) { p1 = 0.001; }
    106     if(four_calc_try(p1,p21,B,A,C,D,'-','+')) {return 1;}
    107     if(four_calc_try(p1,p22,B,A,C,D,'-','-')) {return 1;}
    108     if(four_calc_try(p1,p23,B,A,D,C,'-','-')) {return 1;}
    109     if(four_calc_try(p1,p24,B,A,C,D,'-','*')) {return 1;}
    110     if(four_calc_try(p1,p25,B,A,C,D,'-','/')) {return 1;}
    111     if(four_calc_try(p1,p26,B,A,D,C,'-','/')) {return 1;}
    112 
    113     // printf("B/A
    ");
    114     if(A==0) {p1 = 1000000;} else{p1 = B/A;} if(p1 == 0) { p1 = 0.001; }
    115     if(four_calc_try(p1,p21,B,A,C,D,'/','+')) {return 1;}
    116     if(four_calc_try(p1,p22,B,A,C,D,'/','-')) {return 1;}
    117     if(four_calc_try(p1,p23,B,A,D,C,'/','-')) {return 1;}
    118     if(four_calc_try(p1,p24,B,A,C,D,'/','*')) {return 1;}
    119     if(four_calc_try(p1,p25,B,A,C,D,'/','/')) {return 1;}
    120     if(four_calc_try(p1,p26,B,A,D,C,'/','/')) {return 1;}
    121 
    122     return 0;
    123 }
    124 
    125 /* 
    126 任何数字的基本运算都可以分割成为基本的双目运算,这是计算的基本性质,据此,我们将4个数字的运算分解为两个part的运算。
    127 被分割之后的运算又是两个数字的计算,因此,枚举出所有的双目运算的全部情况,就可以完成数据的判断和计算。
    128  */
    129 int Get_Methed_Func(float *N)
    130 {
    131     float A=N[0],B=N[1],C=N[2],D=N[3];
    132     // Mothed-0:(X0,X1)|(X2,X3)
    133     // printf("Mothed-0
    ");
    134     if(all_seq_try(A,B,C,D)) {return 1;} // AB组合 CD组合 情景1
    135     // Mothed-1:(X0,X2)|(X1,X3)
    136     // printf("Mothed-1
    ");
    137     if(all_seq_try(A,C,B,D)) {return 1;} // AC组合 BD组合 情景2
    138     // Mothed-2:(X0,X3)|(X1,X2)
    139     // printf("Mothed-2
    ");
    140     if(all_seq_try(A,D,B,C)) {return 1;} // AD组合 BD组合 情景3
    141     return 0;
    142 }

    运行方式1:

    运行方式2: 

  • 相关阅读:
    iOS优化篇之App启动时间优化
    我是如何从一个小哈喽进阶为高级iOS的?
    windows创建bat文件进行截图
    利用certbot-auto生成证书
    修改Linux的环境变量
    常用的Linux命令(好记性不如烂笔头)
    常用的服务端配置文件(Tomcat、MySQL)
    【极致丝滑】利用postcss-px2vw-pv彻底摆脱编辑器插件,灵活可控地转换px至vw
    np.mgrid函数
    快速了解匈牙利算法
  • 原文地址:https://www.cnblogs.com/uestc-mm/p/8998207.html
Copyright © 2020-2023  润新知