Fork me on GitHub

CCF 命令行选项

题目原文

问题描述（题目链接登陆账号有问题，要从这个链接登陆，然后点击“模拟考试”，进去找本题目）
 
试题编号： 201403-3
试题名称： 命令行选项
时间限制： 1.0s
内存限制： 256.0MB
问题描述：
问题描述
　　请你写一个命令行分析程序,用以分析给定的命令行里包含哪些选项。每个命令行由若干个字符串组成,它们之间恰好由一个空格分隔。这些字符串中的第一个为该命令行工具的名字,由小写字母组成,你的程序不用对它进行处理。在工具名字之后可能会包含若干选项,然后可能会包含一 些不是选项的参数。
　　选项有两类:带参数的选项和不带参数的选项。一个合法的无参数选项的形式是一个减号后面跟单个小写字母,如"-a" 或"-b"。而带参数选项则由两个由空格分隔的字符串构成,前者的格式要求与无参数选项相同,后者则是该选项的参数,是由小写字母,数字和减号组成的非空字符串。
　　该命令行工具的作者提供给你一个格式字符串以指定他的命令行工具需要接受哪些选项。这个字符串由若干小写字母和冒号组成,其中的每个小写字母表示一个该程序接受的选项。如果该小写字母后面紧跟了一个冒号,它就表示一个带参数的选项,否则则为不带参数的选项。例如, "ab:m:" 表示该程序接受三种选项,即"-a"(不带参数),"-b"(带参数), 以及"-m"(带参数)。
　　命令行工具的作者准备了若干条命令行用以测试你的程序。对于每个命令行,你的工具应当一直向后分析。当你的工具遇到某个字符串既不是合法的选项,又不是某个合法选项的参数时,分析就停止。命令行剩余的未分析部分不构成该命令的选项,因此你的程序应当忽略它们。
 
输入格式
　　输入的第一行是一个格式字符串,它至少包含一个字符,且长度不超过 52。格式字符串只包含小写字母和冒号,保证每个小写字母至多出现一次,不会有两个相邻的冒号,也不会以冒号开头。
　　输入的第二行是一个正整数 N(1 ≤ N ≤ 20),表示你需要处理的命令行的个数。
　　接下来有 N 行,每行是一个待处理的命令行,它包括不超过 256 个字符。该命令行一定是若干个由单个空格分隔的字符串构成,每个字符串里只包含小写字母,数字和减号。
 
输出格式
　　输出有 N 行。其中第 i 行以"Case i:" 开始,然后应当有恰好一个空格,然后应当按照字母升序输出该命令行中用到的所有选项的名称,对于带参数的选项,在输出它的名称之后还要输出它的参数。如果一个选项在命令行中出现了多次,只输出一次。如果一个带参数的选项在命令行中出 现了多次,只输出最后一次出现时所带的参数。
 
样例输入
albw:x
4
ls -a -l -a documents -b
ls
ls -w 10 -x -w 15
ls -a -b -c -d -e -l
 
样例输出
Case 1: -a -l
Case 2:
Case 3: -w 15 -x
Case 4: -a -b

 

题目大意

但是

 

解题思路：

 

 

附录：

 

 

读题读了半老天，智商不够就时间弥补吧。。

 

 

我对于

既不是合法的选项,又不是某个合法选项的参数时，

分析就停止。命令行剩余的未分析部分不构成该命令的选项,因此你的程序应当忽略它们。

的理解和第一个case数据

albw:x

ls -a -l -a documents -b

Case 1: -a -l

还有这句条件

然后应当按照字母升序输出该命令行中用到的所有选项的名称

反复琢磨理解力好久，我纠结点在于，首先我按照上述条件，认为 ls -a -l -a documents -b 的Case输出，先排个顺序，-a -a documents -b -l，然后发现到达-a documents就不符合了，因为a后面没有冒号，是一个无参数的，所以应该停止输出才对，所以最终结果应该是只输出一个 -a ，后面都停止执行了。

 

特意查了“既...又....”关系，并列关系，还有一直漏掉的字眼，“某个”。

既不是合法的选项,又不是某个合法选项的参数时

相当于

if(不是合法选项)

　　if(也不是某个合法选项的参数)

　　　　跳过后面的，停止继续输出，转向下一个Case；

也就是说，在推进到-a documents的时候，连第一个case都没进去，虽然把无参数的-a加了个参数，但是却是合法选项，所以按照这句话

然后应当按照字母升序输出该命令行中用到的所有选项的名称,

也就是选项对了，不触发停止分析的条件，但是由于用到了-a正确的选项，所以只是不输出而已。

 

突然想起，acm那会说的：这个题我不会，但是AC还是没有问题的。这个题的条件有些理解不了，甚至不知道在说什么，不可理喻，但是A掉应该没问题。

 

 

题目理解明白了，但是很不好写啊，写不出来，我想的很好，

遍历，对于任意一行来说，

先对本行所有的选项排序，然后遍历对每一个选项做判断

如果是ls，跳过，

如果是选项没有在给定的格式字符串出现过直接终止，不再继续分析，

如果出现过但是参数的有无不匹配，跳过此处选项继续分析，

如果出现在给定的格式字符串当中的就输出，并且还要有一个flag的标记，再出现不做处理（无参数的）

如果是有参数的就输出最后一个参数

 但是实际写起来好费劲，细枝末节的变量和混乱的思维感觉无从下手，改的时候也会很痛苦。

其实

先对本行所有的选项排序，然后遍历对每一个选项做判断

这里我就卡住了，怎样将以回车为结尾的一行记录出选项数目并存储在数组中，感觉像之前那种统计一句话单词数的方法有点笨。。感觉这里应该考察的不是这个点吧。。。因为统计单词数已经算单独的一道题目了。查统计单词的时候遇到的略叼的博客刷题平台

 

思前想去，第一次写出来的代码

 1 #include<algorithm>
 2 #include<cstring>
 3 #include<cstdio>
 4 
 5 #define M 130//最多差不多130个选项（256/2）
 6 #define len 260//每个选项最长260
 7 
 8 using namespace std;
 9 char box[53];//格式字符串不超过52
10 
11 int appear_from_box[30];//26个字母，作为一个标记记号
12 
13 char str[M][len];//将一行存入二维数组
14 int cmp1(const void *a, const void*b)
15 {
16     char *s1 = (char *)a;
17     char *s2 = (char *)b;
18     return strcmp(s1, s2);
19 }
20 int main()
21 {
22     int N;
23     scanf("%s", &box);
24     int boxlen = strlen(box);
25     for(int i = 0; i < boxlen; i ++){
26         appear_from_box[box[i] - 97] = 1;//无参数为1
27         if(box[i + 1] == ':')
28             appear_from_box[box[i] - 97] = 2;//有参数为2
29             //没出现在格式字符串中的为0
30     }
31 
32     scanf("%d", &N);
33     for (int i = 0; i < N; i++)
34     {
35         for(int  j = 0; j < M; j ++)
36             memset(str[j], 0, sizeof(str));//二维数组初始化
37         gets(str[i]);
38         int x = 0;
39         int y = 0;
40         int p = 0;
41         int number_option = 1;//一行当中选项的个数
42         while(str[p] != '\n'){
43             str[x][y ++] = str[p ++];
44             if(str[p] == ' ' && str[p + 1] == '-'){
45                 x ++;
46                 number_option ++;
47                 p ++;
48             }
49         }
50 
51         qsort(str, number_option, sizeof(char)*len, cmp1);
52 
53         for(int j = 0; j < number_option; j ++)
54         {
55             printf("%c", str[j]);
56         }
57     }
58 }

我本身想的是，ls -a -l -a documents -b 这样一段字符，存入str数组中，共有N行，那对于第N行来说，整行存到str[N-1]中，而用p作为“指针”，从str【N-1】头开始，往后移动，根据空格、‘是否是-’来判断是否是新的一个选项，如果是，我这里用str来充当二维数组的存储内存，装进str的下一行，具体就是 ls存入str[0]，-a存入str[1]，-l存入str[2]，-a documents存入str[3]，-b存入str[4]，存完排序，再进行附录下面的那段分析输出，这样本行就结束了，memset初始化，进行下一行的判断。

然而.............

 

错误1：这个运行报错是42/43/44行，主要是str[]属于一个指针，而‘\n’判断。

看来还要开一个数组来存储。

 

错误2：另外，这个代码，编译时候，42/43/44过不了编译。

而35/36行，

二维数组初始化的问题。？？？？？？？？？？？？难道是memset(str, 0, sizeof(str))???先搁置，这里用的是save了

 

for(int j = 0; j < M; j ++)
　　 memset(str[j], 0, sizeof(str);

 会导致死循环？反正就是鼠标转圈，然后return结束了。

 

错误3：还有，这里的冒号asc为五十多，26行会出现问题，也会导致过编译但是转圈return

 

 

 

转用save的代码

 1 #include<algorithm>
 2 #include<cstring>
 3 #include<cstdio>
 4 
 5 #define M 130//最多差不多130个选项（256/2）
 6 #define len 260//每个选项最长260
 7 
 8 using namespace std;
 9 char box[53];//格式字符串不超过52
10 
11 int appear_from_box[30];//26个字母，作为一个标记记号
12 char save[len];
13 char str[M][len];//将一行存入二维数组
14 int cmp1(const void *a, const void*b)
15 {
16     char *s1 = (char *)a;
17     char *s2 = (char *)b;
18     return strcmp(s1, s2);
19 }
20 int main()
21 {
22     int N;
23     scanf("%s", &box);
24     int boxlen = strlen(box);
25     for(int i = 0; i < boxlen; i ++){
26         if(box[i] != ':')
27             appear_from_box[box[i] - 97] = 1;//无参数为1
28         if(box[i + 1] == ':')
29             appear_from_box[box[i] - 97] = 2;//有参数为2
30             //没出现在格式字符串中的为0
31     }
32     scanf("%d", &N);
33     for (int i = 0; i < N; i++)
34     {
35         memset(save, 0, sizeof(save));//二维数组初始化
36         gets(save);
37         int x = 0;
38         int y = 0;
39         int p = 0;
40         int number_option = 1;//一行当中选项的个数
41         while(save[p] != '\n'){
42             str[x][y ++] = save[p ++];
43 //            if(save[p] == ' ' && save[p + 1] == '-'){
44 //                x ++;
45 //                number_option ++;
46 //                p ++;
47 //            }
48         }
49 //
50         qsort(str, number_option, sizeof(char)*len, cmp1);
51 
52         for(int j = 0; j < number_option; j ++)
53         {
54             printf("%c", str[j]);
55         }
56     }
57 }

这里不知道为什么，对于刚输入

albw:x
4

的样例，42行注释掉没问题，不注释掉就会转圈死循环？？？是我编译器换掉了？？？？第二天起来再运行就没事了。。。。

 

 

调试代码：

 1 #include<algorithm>
 2 #include<cstring>
 3 #include<cstdio>
 4 
 5 #define M 130//最多差不多130个选项（256/2）
 6 #define len 260//每个选项最长260
 7 
 8 using namespace std;
 9 char box[53];//格式字符串不超过52
10 
11 int appear_from_box[30];//26个字母，作为一个标记记号
12 char save[len];
13 char str[M][len];//将一行存入二维数组
14 int cmp1(const void *a, const void*b)
15 {
16     char *s1 = (char *)a;
17     char *s2 = (char *)b;
18     return strcmp(s1, s2);
19 }
20 int main()
21 {
22     int N;
23     scanf("%s", &box);
24     int boxlen = strlen(box);
25     for(int i = 0; i < boxlen; i ++){
26         if(box[i] != ':')
27             appear_from_box[box[i] - 97] = 1;//无参数为1
28         if(box[i + 1] == ':')
29             appear_from_box[box[i] - 97] = 2;//有参数为2
30             //没出现在格式字符串中的为0
31     }
32 //    getchar();
33     scanf("%d", &N);
34     getchar();
35     for (int i = 0; i < N; i++)
36     {
37         memset(save, 0, sizeof(save));//二维数组初始化
38         gets(save);
39 //        printf("%s\n", save);
40 //        printf("%c\n", save[0]);
41         int x = 0;
42         int y = 0;
43         int p = 0;
44         int number_option = 1;//一行当中选项的个数
45         while(save[p] != '\0'){//这里我一开始用的是'\n'我认为最后的结束符是回车，但其实是字符串结束符'\0'，一开始的'\n'就导致了下一行是无限循环的输出
46             printf("%c %d\n", save[p], p);
47             str[x][y] = save[p ++];
48             if(save[p] == ' ' && save[p + 1] == '-'){
49                 x ++;
50                 number_option ++;
51                 p ++;
52             }
53         }
54 printf("##%c##", str[0][0]);//怎么会是s呢
55         qsort(str, number_option, sizeof(char)*len, cmp1);
56 //        for(int j = 0; j < number_option; j ++)
57 //        {
58 //            printf("%s ", str[j]);
59 //        }
60     }
61 }
62 
63 //上述代码问题注释用到的是下面的输入
64 //albw:x
65 //4
66 //ls -a -l -a documents -b

问题都注释出来了，写到这一步，感觉思路还比较清晰，代码也比较清爽。先存一下

 

 

 

这是什么情况，改了半天，为啥输入

albw:x
4
ls -a -l -a documents -b

再回车能输出一堆东西##s##那些，难道在缓存里？需要getchar()吃一下？也不对啊，都吃完了啊。（哦，后来意识到，N是4，输入回车就是回车。还有就是gets(save)之后，不用getchar(); ）

但是！！为什么代码56写的输出应该是'l'，实际却不输出第一个字符'l'，我第48行代码输出验证了已经，str[0][0]就是'l'啊，黑框控制台的第四行也对的，可是为啥最后str[0][0]没东西了。。。？？？

哎，没人讨论，只好自言自语，把思路记录下来。。

 

 

 代码

 1 #include<algorithm>
 2 #include<cstring>
 3 #include<cstdio>
 4 
 5 #define M 130//最多差不多130个选项（256/2）
 6 #define len 260//每个选项最长260
 7 
 8 using namespace std;
 9 char box[53];//格式字符串不超过52
10 
11 int appear_from_box[30];//26个字母，作为一个标记记号
12 char save[len];
13 char str[M][len];//将一行存入二维数组
14 int cmp1(const void *a, const void*b)
15 {
16     char *s1 = (char *)a;
17     char *s2 = (char *)b;
18     return strcmp(s1, s2);
19 }
20 int main()
21 {
22     int N;
23     scanf("%s", &box);
24     int boxlen = strlen(box);
25     for(int i = 0; i < boxlen; i ++){
26         if(box[i] != ':')
27             appear_from_box[box[i] - 97] = 1;//无参数为1
28         if(box[i + 1] == ':')
29             appear_from_box[box[i] - 97] = 2;//有参数为2
30             //没出现在格式字符串中的为0
31     }
32 //    getchar();
33     scanf("%d", &N);
34     getchar();
35     for (int i = 0; i < N; i++)
36     {
37         memset(save, 0, sizeof(save));//二维数组初始化
38         gets(save);
39 //        printf("%s\n", save);
40 //        printf("%c\n", save[0]);
41         int x = 0;
42         int y = 0;
43         int p = 0;
44         int number_option = 1;//一行当中选项的个数
45         while(save[p] != '\0'){//这里我一开始用的是'\n'我认为最后的结束符是回车，但其实是字符串结束符'\0'，一开始的'\n'就导致了下一行是无限循环的输出
46             printf("%c p:%d——", save[p], p);
47             str[x][y] = save[p ++];
48             printf("%c p:%d x:%d y:%d\n", str[x][y], p, x, y);
49             if(save[p] == ' ' && save[p + 1] == '-'){
50                 x ++;
51                 number_option ++;
52                 p ++;
53             }
54         }
55         getchar();
56 printf("##%c##", str[0][0]);//怎么会是s呢
57 //        qsort(str, number_option, sizeof(char)*len, cmp1);
58 //        for(int j = 0; j < number_option; j ++)
59 //        {
60 //            printf("%s ", str[j]);
61 //        }
62     }
63 }
64 
65 //上述代码问题注释用到的是下面的输入
66 //albw:x
67 //4
68 //ls -a -l -a documents -b

 

艹，最后发现是y没有++，本来写的挺好的，调试的时候y++删了++没改回来。

 

附一下代码，包好printf来调试的步骤

 1 #include<algorithm>
 2 #include<cstring>
 3 #include<cstdio>
 4 
 5 #define M 130//最多差不多130个选项（256/2）
 6 #define len 260//每个选项最长260
 7 
 8 using namespace std;
 9 char box[53];//格式字符串不超过52
10 
11 int appear_from_box[30];//26个字母，作为一个标记记号
12 char save[len];
13 char str[M][len];//将一行存入二维数组
14 int cmp1(const void *a, const void*b)
15 {
16     char *s1 = (char *)a;
17     char *s2 = (char *)b;
18     return strcmp(s1, s2);
19 }
20 int main()
21 {
22     int N;
23     scanf("%s", &box);
24     int boxlen = strlen(box);
25     for(int i = 0; i < boxlen; i ++){
26         if(box[i] != ':')
27             appear_from_box[box[i] - 97] = 1;//无参数为1
28         if(box[i + 1] == ':')
29             appear_from_box[box[i] - 97] = 2;//有参数为2
30             //没出现在格式字符串中的为0
31     }
32 //    getchar();
33     scanf("%d", &N);
34     getchar();
35     for (int i = 0; i < N; i++)
36     {
37         memset(save, 0, sizeof(save));//二维数组初始化
38         gets(save);
39 //        printf("%s\n", save);
40 //        printf("%c\n", save[0]);
41         int x = 0;
42         int y = 0;
43         int p = 0;
44         int number_option = 1;//一行当中选项的个数
45         while(save[p] != '\0'){//重要！！！这里我一开始用的是'\n'我认为最后的结束符是回车，但其实是字符串结束符'\0'，一开始的'\n'就导致了下一行是无限循环的输出
46             printf("%c p:%d——", save[p], p);
47             str[x][y ++] = save[p ++];
48             printf("%c p:%d x:%d y:%d\n", str[x][y], p, x, y);
49             if(save[p] == ' ' && save[p + 1] == '-'){
50                 x ++;
51                 number_option ++;
52                 p ++;
53             }
54 
55         }
56 //        getchar();
57 //printf("OVER");
58 printf("##%c##", str[0][0]);//怎么会是s呢
59 //printf("OVER");
60 //        qsort(str, number_option, sizeof(char)*len, cmp1);
61 //        for(int j = 0; j < number_option; j ++)
62 //        {
63 //            printf("%s ", str[j]);
64 //        }
65     }
66 }
67 
68 //上述代码问题注释用到的是下面的输入
69 //albw:x
70 //4
71 //ls -a -l -a documents -b

 

 

 

新问题，为啥下面打开注释，63行不输出东西啊，只有ls，验证了一下，确实是5个number_option

有了，我在50行下面，输出的str[x-1]是什么字符串就知道哪里出问题了，具体就不贴出来了。罗列一下问题吧

y一直++，其实新起一行应该重新赋0的。

 

到此为止，都正确存入了str中了，这么简单的东西，写起来你可真费劲。

考试3小时，到你这里，能写一年。。。。

 

 

 

简单修改了一下，输入

albw:x

4

ls -a -l -a documents -b

输出有问题，

为什么都memset了，只输入第一个数据后面都是回车，还会输出-a？？？

不应该是

回车

回车

回车

回车

回车

回车

么？？？

 1 #include<algorithm>
 2 #include<cstring>
 3 #include<cstdio>
 4 
 5 #define M 130//最多差不多130个选项（256/2）
 6 #define len 260//每个选项最长260
 7 
 8 using namespace std;
 9 char box[53];//格式字符串不超过52
10 
11 int appear_from_box[30];//26个字母，作为一个标记记号
12 int actual_input_have_parameters[30];//实际输入有参数的
13 char save[len];
14 char str[M][len];//将一行存入二维数组
15 
16 int cmp1(const void *a, const void*b)
17 {
18     char *s1 = (char *)a;
19     char *s2 = (char *)b;
20     return strcmp(s1, s2);
21 }
22 int main()
23 {
24     int N;
25     scanf("%s", &box);
26     int boxlen = strlen(box);
27     for(int i = 0; i < boxlen; i ++){
28         if(box[i] != ':')
29             appear_from_box[box[i] - 97] = 1;//无参数为1
30         if(box[i + 1] == ':')
31             appear_from_box[box[i] - 97] = 2;//有参数为2
32             //没出现在格式字符串中的为0
33     }
34 //    getchar();
35     scanf("%d", &N);
36     getchar();
37     for (int i = 0; i < N; i++)
38     {
39         memset(save, 0, sizeof(save));//二维数组初始化
40         gets(save);
41 //        printf("%s\n", save);
42 //        printf("%c\n", save[0]);
43         int x = 0;
44         int y = 0;
45         int p = 3;
46         int number_option = 1;//一行当中选项的个数
47         while(save[p] != '\0'){//重要！！！这里我一开始用的是'\n'我认为最后的结束符是回车，但其实是字符串结束符'\0'，一开始的'\n'就导致了下一行是无限循环的输出
48 //            printf("%c p:%d——", save[p], p);
49 
50             str[x][y ++] = save[p ++];
51 //            printf("%c p:%d x:%d y:%d\n", str[x][y], p, x, y);
52             if(save[p] == ' ' && save[p + 1] != '-')//有参数
53                 actual_input_have_parameters[str[x][0]] = 2;
54             if(save[p] == ' ' && save[p + 1] == '-'){
55                 actual_input_have_parameters[str[x][0]] = 1;
56                 x ++;
57                 number_option ++;
58                 p ++;
59 //                printf("%s\n", str[x - 1]);
60                 y = 0;
61 
62             }
63 
64         }
65 //        printf("%s\n", str[4]);
66         qsort(str, number_option, sizeof(char)*len, cmp1);
67         for(int j = 0; j < number_option; j ++)
68         {
69             if(str[j] == "ls")
70                 continue;
71 //            if(appear_from_box[str[j][1]] == 0)
72 //                break;
73 //            if(appear_from_box[str[j][1]] != actual_input_have_parameters[str[x][0]])
74 //                continue;
75 
76             printf("%s\n", str[j]);
77         }
78     }
79 }
80 //上述代码问题注释用到的是下面的输入

 

 

 

 

我测试输入

albw:x
4
ls -a -l -a documents -b

按回车，之后什么也不输入，接着按仨回车。

如果是memset里的赋值是0，仨回车每个都是输出-a

如果是memset里的赋值是'0'，仨回车每个都是输出2行多几个0

如果是memset里的赋值是'\0'，仨回车每个都是输出-a

如果是memset里的赋值是' '，仨回车每个都是输出2行多几个空格

如果是memset里的赋值是'n'，仨回车每个都是输出2行多几个n

如果是memset里的赋值是0x00，仨回车每个都是输出-a
如果是memset里的赋值是NULL，仨回车每个都是输出-a

 

会不会是这样：

由于我设的是save[len]，len是260，这里memset的时候相当于占满了260字符，（其实应该用动态开数组？）。

这里输出好几行的会不会是好几个（260个）对应字符？如果待处理命令行不是输入回车，而是实际有内容的字符串，会自动加'\0'结束符，也就是第一个一样对正确输出，而什么都没有，只是回车，初始化memset就把260都用上了？所以才会输出这么奇怪？

 

我进一步实验

 

https://blog.csdn.net/lqy971966/article/details/105391125/

 发现很奇怪好像是memset没有重置清除干净似得？？？

而且输入sdffd按回车，只输出了一行fd光标新起一行，我再按回车，又输出fd才结束的，感觉缓存里面很不干净。。。？？？？

再次实验（这两次用的都是memset 0）

 

 

 啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊！！！卡死了！！！！！！！！到底怎么回事啊？？？

哎！

 

 

！！，知道了，我清空save却没有memset str。memset一下str就好了，靠这么半天，我在干嘛？？怎么简单的错误，哎

但是还有一个问题，我输入ls -....可以，但是如果随便输入，sdfsdfbdfvcxv之类的，都会输出错误，长的输出会短了许多，短的什么也不输出

 

 

我测试了一下

 

我用53行和61行printf测试得知此信息。

PS：最后有仨回车，前两个是输入回车，输出回车，N为4，输入4个后，printf带了一个回车。

看的不清晰，改了一个printf的内容

 

 

 输入

albw:x
4
ls -a -l -a documents -b

输出一直到白色那，

输入hgg.....输出为白色

后面是sdf可见什么都没输出。

 

（就跟魔怔精神病似得，这个根本不是正确输入考虑他干嘛？但是我写的这个应该完整输出啊，这里没完整输出，有必要找出问题所在的）

 

问题所在：

卧槽！！！我真是大傻子，自己给自己找事！！我用正确的输入去printf

 

 发现也不能正常输出，是从-a开始的，仔细一看才发现。。。。我之前为了跳过ls，p是3，本身就是从半截开始的。。。。。。哎，热晕乎了。。

 

 

突然发现写之前写一下这种简单的思维思路总计划总纲比较好。

 

 

 

 

继续把最后的判断输出写完，那个有参数的需要输出最后一个（且是一个字符串，不一定是数字，其他选项是排序输出的），写的我直心熟（shou），心直翻个！！！

 

先写大头，条件，再补小细节。

 

 

 

刚写完估计样例如果对了，提交时候就可以一次AC，因为细节应该都考虑了，只是基础、标准形式改改。

写的太心累了，如果隔一天，我自己都不愿意再回头看这代码。但估计是对的。

先贴一下

  1 #include<algorithm>
  2 #include<cstring>
  3 #include<cstdio>
  4 
  5 #define M 130//最多差不多130个选项（256/2）
  6 #define len 260//每个选项最长260
  7 
  8 using namespace std;
  9 char box[53];//格式字符串不超过52
 10 
 11 int appear_from_box[30];//26个字母，作为一个标记记号,格式字符串用的
 12 int actual_input_have_parameters[30];//实际输入有参数的，每个待处理命令行用的
 13 char save[len];
 14 char str[M][len];//将一行存入二维数组
 15 
 16 int cmp1(const void *a, const void*b)
 17 {
 18     char *s1 = (char *)a;
 19     char *s2 = (char *)b;
 20     return strcmp(s1, s2);
 21 }
 22 struct node{
 23     int is_appeared1;//倒数第二个for用来确认是不是第一次遇见有参数的选项
 24     int is_appeared2;//最后一个for确认是不是第一次遇见有参数的选项
 25     char s[260];
 26 };
 27 
 28 int main()
 29 {
 30     memset(appear_from_box, 0, sizeof(appear_from_box));
 31     memset(actual_input_have_parameters, 0, sizeof(actual_input_have_parameters));
 32     int N;
 33     scanf("%s", &box);
 34     int boxlen = strlen(box);
 35     for(int i = 0; i < boxlen; i ++)
 36     {
 37         if(box[i] != ':')
 38             appear_from_box[box[i] - 97] = 1;//无参数为1
 39         if(box[i + 1] == ':')
 40             appear_from_box[box[i] - 97] = 2;//有参数为2
 41         //没出现在格式字符串中的为0
 42     }
 43 
 44 
 45 //    getchar();
 46     scanf("%d", &N);
 47     getchar();
 48     for (int i = 0; i < N; i++)
 49     {
 50         int appeared_nopar[30];//给最后的for用的
 51         memset(appeared_nopar, 0, sizeof(appeared_nopar));
 52 
 53         memset(save, 0, sizeof(save));//二维数组初始化   格式字符串的空间
 54         memset(str, 0, sizeof(str));//二维数组初始化    待处理字符串的空间
 55 
 56 
 57         struct node appeared_par[30];
 58         memset(appeared_par, 0, sizeof(appeared_par));//怎样初始值空的  结构体？？？？？？？？？？？这样就算赋值成功了？？？？？？？怎么感觉成员没有赋呢
 59 
 60 
 61         gets(save);
 62         int x = 0;
 63         int y = 0;
 64         int p = 3;
 65         int number_option = 1;//一行当中选项的个数
 66         while(save[p] != '\0') //重要！！！这里我一开始用的是'\n'我认为最后的结束符是回车，但其实是字符串结束符'\0'，一开始的'\n'就导致了下一行是无限循环的输出
 67         {
 68             str[x][y ++] = save[p ++];
 69             if(save[p] == ' ' && save[p + 1] != '-')//有参数
 70                 actual_input_have_parameters[str[x][1] - 97] = 2;
 71             if(save[p] == ' ' && save[p + 1] == '-')
 72             {
 73                 actual_input_have_parameters[str[x][1] - 97] = 1;
 74 //            printf("$$$%s\n" ,str[x]);
 75                 x ++;
 76                 number_option ++;
 77                 p ++;
 78 //                printf("%s\n", str[x - 1]);
 79                 y = 0;
 80             }
 81         }
 82 
 83 
 84 
 85         //提取有参数的最后一个
 86         for(int j = number_option - 1; j >= 0; j --){
 87             int p = 0;
 88             if(appear_from_box[str[j][1] - 97] == 2 && appeared_par[str[j][1] - 97].is_appeared1 == 0){
 89                 appeared_par[str[j][1] - 97].is_appeared1 = 1;
 90 //                strncpy(appeared_nopar[str[j][1] - 97].s, str[j]);//指针不能赋值给字符串
 91 //                appeared_nopar[str[j][1] - 97].s =  ;
 92                 while(str[j][p] != '\0'){
 93                     appeared_par[str[j][1] - 97].s[p] = str[j][p];
 94                     p ++;
 95                 }
 96             }
 97         }
 98 
 99         qsort(str, number_option, sizeof(char)*len, cmp1);
100 
101         for(int j = 0; j < number_option; j ++)
102         {
103             if(appear_from_box[str[j][1] - 97] == 0){//遇到没出现过的选项，停止分析
104                 j = number_option;
105                 continue;
106             }//                       printf("__%c:%d   %c:%d__\n", str[j][1], appear_from_box[str[j][1] - 97], str[x][1], actual_input_have_parameters[str[j][1] - 97]);
107 
108             if(appear_from_box[str[j][1] - 97] != actual_input_have_parameters[str[j][1] - 97])//选项不对，跳过
109                 continue;
110 
111             if(appear_from_box[str[j][1] - 97] == 1 && appeared_nopar[str[j][1] - 97] == 0){//无参数则只输出一次
112                 appeared_nopar[str[j][1] - 97] = 1;
113                 printf("%s\n", str[j]);
114             }
115             if(appear_from_box[str[j][1] - 97] == 2 && appeared_par[str[j][1] - 97].is_appeared2 == 0){//有参数输出最后的一个！！！！！！写到这里卡住了，最后快结束了，发现
116                     //如果一个带参数的选项在命令行中出 现了多次,只输出最后一次出现时所带的参数。
117                     //那我不应该对有参数的排序。
118                 appeared_par[str[j][1] - 97].is_appeared2 == 1;
119                 printf("%s\n", appeared_par[j].s);
120             }
121 
122 
123 
124         }
125     }
126 }
127 //上述代码问题注释用到的是下面的输入
128 //albw:x
129 //4
130 //ls -a -l -a documents -b

albw:x
4
ls -a -l -a documents -b
ls
ls -w 10 -x -w 15
ls -a -b -c -d -e -l

第三个样例有点小问题，处理一下

 

 

 

要会学习，像这样搞了一天的东西，写完脑子里很有AC快感，但是不花时间回头看，再写都不一定写的出来，更别说考试ccf/机试现场/或者面试面对面说了。要有一个题目整体的框架。别写完就拉倒了看都不看，也不温习，这就是你为什么19/20现在21还在ky...初一初二底子...高中高二高三什么都不行了...还有大一大二大三大四学啊学.....还有两次ccf/两次蓝桥杯/两次pat得了那么点破分....

 

 

第一次提交给服务器

 

  1 #include<algorithm>
  2 #include<cstring>
  3 #include<cstdio>
  4 
  5 #define M 130//最多差不多130个选项（256/2）
  6 #define len 260//每个选项最长260
  7 
  8 using namespace std;
  9 char box[53];//格式字符串不超过52
 10 
 11 int appear_from_box[30];//26个字母，作为一个标记记号,格式字符串用的
 12 int actual_input_have_parameters[30];//实际输入有参数的，每个待处理命令行用的
 13 char save[len];
 14 char str[M][len];//将一行存入二维数组
 15 
 16 int cmp1(const void *a, const void*b)
 17 {
 18     char *s1 = (char *)a;
 19     char *s2 = (char *)b;
 20     return strcmp(s1, s2);
 21 }
 22 struct node{
 23     int is_appeared1;//倒数第二个for用来确认是不是第一次遇见有参数的选项
 24     int is_appeared2;//最后一个for确认是不是第一次遇见有参数的选项
 25     char s[260];
 26 };
 27 
 28 int main()
 29 {
 30     memset(appear_from_box, 0, sizeof(appear_from_box));
 31     memset(actual_input_have_parameters, 0, sizeof(actual_input_have_parameters));
 32     int N;
 33     scanf("%s", &box);
 34     int boxlen = strlen(box);
 35     for(int i = 0; i < boxlen; i ++)
 36     {
 37         if(box[i] != ':')
 38             appear_from_box[box[i] - 97] = 1;//无参数为1
 39         if(box[i + 1] == ':')
 40             appear_from_box[box[i] - 97] = 2;//有参数为2
 41         //没出现在格式字符串中的为0
 42     }
 43 
 44 
 45 //    getchar();
 46     scanf("%d", &N);
 47     getchar();
 48     for (int i = 0; i < N; i++)
 49     {
 50         int appeared_nopar[30];//给最后的for用的
 51         memset(appeared_nopar, 0, sizeof(appeared_nopar));
 52 
 53         memset(save, 0, sizeof(save));//二维数组初始化   格式字符串的空间
 54         memset(str, 0, sizeof(str));//二维数组初始化    待处理字符串的空间
 55 
 56 
 57         struct node appeared_par[30];
 58         memset(appeared_par, 0, sizeof(appeared_par));//怎样初始值空的  结构体？？？？？？？？？？？这样就算赋值成功了？？？？？？？怎么感觉成员没有赋呢
 59 
 60 
 61         gets(save);
 62         int x = 0;
 63         int y = 0;
 64         int p = 3;
 65         int number_option = 1;//一行当中选项的个数
 66         while(save[p] != '\0') //重要！！！这里我一开始用的是'\n'我认为最后的结束符是回车，但其实是字符串结束符'\0'，一开始的'\n'就导致了下一行是无限循环的输出
 67         {
 68             str[x][y ++] = save[p ++];
 69             if(save[p] == ' ' && save[p + 1] != '-')//有参数
 70                 actual_input_have_parameters[str[x][1] - 97] = 2;
 71             if(save[p] == ' ' && save[p + 1] == '-')
 72             {
 73                 actual_input_have_parameters[str[x][1] - 97] = 1;
 74 //            printf("$$$%s\n" ,str[x]);
 75                 x ++;
 76                 number_option ++;
 77                 p ++;
 78 //                printf("%s\n", str[x - 1]);
 79                 y = 0;
 80             }
 81         }
 82 
 83 
 84 
 85         //提取有参数的最后一个
 86         for(int j = number_option - 1; j >= 0; j --){
 87             int p = 0;
 88             if(appear_from_box[str[j][1] - 97] == 2 && appeared_par[str[j][1] - 97].is_appeared1 == 0){
 89                 appeared_par[str[j][1] - 97].is_appeared1 = 1;
 90 //                strncpy(appeared_nopar[str[j][1] - 97].s, str[j]);//指针不能赋值给字符串
 91 //                appeared_nopar[str[j][1] - 97].s =  ;
 92                 while(str[j][p] != '\0'){
 93                     appeared_par[str[j][1] - 97].s[p] = str[j][p];
 94                     p ++;
 95                 }
 96 //                printf("__%s__\n", appeared_par[str[j][1] - 97].s);
 97             }
 98         }
 99 
100         qsort(str, number_option, sizeof(char)*len, cmp1);
101 
102             printf("Case %d:", i);
103         for(int j = 0; j < number_option; j ++)
104         {
105 
106             if(appear_from_box[str[j][1] - 97] == 0){//遇到没出现过的选项，停止分析
107                 j = number_option;
108                 continue;
109             }//                       printf("__%c:%d   %c:%d__\n", str[j][1], appear_from_box[str[j][1] - 97], str[x][1], actual_input_have_parameters[str[j][1] - 97]);
110 
111             if(appear_from_box[str[j][1] - 97] != actual_input_have_parameters[str[j][1] - 97])//选项不对，跳过
112                 continue;
113 
114             if(appear_from_box[str[j][1] - 97] == 1 && appeared_nopar[str[j][1] - 97] == 0){//无参数则只输出一次
115                 appeared_nopar[str[j][1] - 97] = 1;
116                 printf(" %s", str[j]);
117 
118             }
119             if(appear_from_box[str[j][1] - 97] == 2 && appeared_par[str[j][1] - 97].is_appeared2 == 0){//有参数输出最后的一个！！！！！！写到这里卡住了，最后快结束了，发现
120                     //如果一个带参数的选项在命令行中出 现了多次,只输出最后一次出现时所带的参数。
121                     //那我不应该对有参数的排序。
122                 appeared_par[str[j][1] - 97].is_appeared2 = 1;
123                     printf(" %s", appeared_par[str[j][1] - 97].s);
124             }
125         }
126         printf("\n");
127     }
128 }
129 //上述代码问题注释用到的是下面的输入
130 //albw:x
131 //4
132 //ls -a -l -a documents -b

 

 

 ？？？运行错误？？？？

 

 

逐渐把代码里面用到str[x][1] - 97的都注释掉发现显示错误了，不运行错误了，猜测应该是这里出现了非小写字母也进去减了，且asc码小于97

可是不应该啊，按照条件asc码小于97的也进不去这里啊？？？？？

 

 

 

审题发现

接下来有 N 行,每行是一个待处理的命令行,它包括不超过 256 个字符。该命令行一定是若干个由单个空格分隔的字符串构成,每个字符串里只包含小写字母,数字和减号。

 也就是说，可能存在

ls -a -l -3 documents -3

这种需要跳过的-3，而我默认这里都是小写了，所以，改了一下（加了一个控制条件）。还有Case输出的时候i+1，Case1，而不是Case0开始

可是却显示错误，一个点都没对啊？？？

 却忘记了参数为数字开头，这样的写法相当于没参数了。。

 

我输入这组数据（重复样例）

 

albw:x
7
ls -a -l -a documents -b
ls
ls -w 10 -x -w 15
ls -a -b -c -d -e -l
ls -a -l -a documents -b
ls
ls -w 10 -x -w 15

发现居然是缓存不干净

 

 

 卧槽？？？？？？？？？？？？？？？！！！！！！！！！！！！！！！！！

我懵了！！！

我在干什么？？看似Case5错了，但其实是Case1本身就不对啊！，我当初怎么写的？读题的时候怎么没有反应过来啊，而且还居然写对了？？难道题目我理解错了？？？

 

 

 

 

 

 

改到这里明白了67~82行

  1 #include<algorithm>
  2 #include<cstring>
  3 #include<cstdio>
  4 
  5 #define M 130//最多差不多130个选项（256/2）
  6 #define len 260//每个选项最长260
  7 
  8 using namespace std;
  9 char box[53];//格式字符串不超过52
 10 
 11 int appear_from_box[30];//26个字母，作为一个标记记号,格式字符串用的
 12 int actual_input_have_parameters[30];//实际输入有参数的，每个待处理命令行用的
 13 char save[len];
 14 char str[M][len];//将一行存入二维数组
 15 
 16 int cmp1(const void *a, const void*b)
 17 {
 18     char *s1 = (char *)a;
 19     char *s2 = (char *)b;
 20     return strcmp(s1, s2);
 21 }
 22 struct node{
 23     int is_appeared1;//倒数第二个for用来确认是不是第一次遇见有参数的选项
 24     int is_appeared2;//最后一个for确认是不是第一次遇见有参数的选项
 25     char s[260];
 26 };
 27 
 28 int main()
 29 {
 30     memset(appear_from_box, 0, sizeof(appear_from_box));
 31     memset(actual_input_have_parameters, 0, sizeof(actual_input_have_parameters));
 32     int N;
 33     scanf("%s", &box);
 34     int boxlen = strlen(box);
 35     for(int i = 0; i < boxlen; i ++)
 36     {
 37         if(box[i] != ':' && (box[i] - 97) >= 0)
 38             appear_from_box[box[i] - 97] = 1;//无参数为1
 39         if(box[i + 1] == ':' && (box[i] - 97) >= 0)
 40             appear_from_box[box[i] - 97] = 2;//有参数为2
 41         //没出现在格式字符串中的为0
 42     }
 43 
 44     printf("%d\n", appear_from_box[1]);
 45 
 46 
 47 //    getchar();
 48     scanf("%d", &N);
 49     getchar();
 50     for (int i = 0; i < N; i++)
 51     {
 52         int appeared_nopar[30];//给最后的for用的
 53         memset(appeared_nopar, 0, sizeof(appeared_nopar));
 54 
 55         memset(save, 0, sizeof(save));//二维数组初始化   格式字符串的空间
 56         memset(str, 0, sizeof(str));//二维数组初始化    待处理字符串的空间
 57 
 58         struct node appeared_par[30];
 59         memset(appeared_par, 0, sizeof(appeared_par));//怎样初始值空的  结构体？？？？？？？？？？？这样就算赋值成功了？？？？？？？怎么感觉成员没有赋呢
 60 
 61 
 62         gets(save);
 63         int x = 0;
 64         int y = 0;
 65         int p = 3;
 66         int number_option = 1;//一行当中选项的个数
 67         while(save[p] != '\0') //重要！！！这里我一开始用的是'\n'我认为最后的结束符是回车，但其实是字符串结束符'\0'，一开始的'\n'就导致了下一行是无限循环的输出
 68         {
 69             str[x][y ++] = save[p ++];
 70             if(save[p] == ' ' && save[p + 1] != '-' && (str[x][1] - 97) >= 0)//有参数
 71                 actual_input_have_parameters[str[x][1] - 97] = 2;
 72             if(save[p] == ' ' && save[p + 1] == '-' && (str[x][1] - 97) >= 0)
 73             {
 74                 actual_input_have_parameters[str[x][1] - 97] = 1;
 75 //            printf("$$$%s\n" ,str[x]);
 76                 x ++;
 77                 number_option ++;
 78                 p ++;
 79 //                printf("%s\n", str[x - 1]);
 80                 y = 0;
 81             }
 82         }
 83 
 84         //提取有参数的最后一个
 85         for(int j = number_option - 1; j >= 0; j --){
 86             int p = 0;
 87             if(appear_from_box[str[j][1] - 97] == 2 && appeared_par[str[j][1] - 97].is_appeared1 == 0){
 88                 appeared_par[str[j][1] - 97].is_appeared1 = 1;
 89 //                strncpy(appeared_nopar[str[j][1] - 97].s, str[j]);//指针不能赋值给字符串
 90 //                appeared_nopar[str[j][1] - 97].s =  ;
 91                 while(str[j][p] != '\0'){
 92                     appeared_par[str[j][1] - 97].s[p] = str[j][p];
 93                     p ++;
 94                 }
 95 //                printf("__%s__\n", appeared_par[str[j][1] - 97].s);
 96             }
 97         }
 98 
 99         qsort(str, number_option, sizeof(char)*len, cmp1);
100 
101         for(int j = 0; j < number_option; j ++){
102             printf("###%s %d###\n", str[j], actual_input_have_parameters[str[j][1] - 97]);
103         }
104 
105 //for(int j = 0; j < number_option; j ++)
106 //    printf("%s\n", str[j]);
107 //
108         printf("Case %d:", i+1);
109 //        printf("##%d\n", appear_from_box[1]);
110         for(int j = 0; j < number_option; j ++)
111         {
112 
113             if(appear_from_box[str[j][1] - 97] == 0){//遇到没出现过的选项，停止分析
114                 j = number_option;
115                 continue;
116             }//                       printf("__%c:%d   %c:%d__\n", str[j][1], appear_from_box[str[j][1] - 97], str[x][1], actual_input_have_parameters[str[j][1] - 97]);
117 
118             if(appear_from_box[str[j][1] - 97] != actual_input_have_parameters[str[j][1] - 97])//选项不对，跳过
119                 continue;
120 
121             if(appear_from_box[str[j][1] - 97] == 1 && appeared_nopar[str[j][1] - 97] == 0){//无参数则只输出一次
122                 appeared_nopar[str[j][1] - 97] = 1;
123                 printf(" %s", str[j]);
124 
125             }
126             if(appear_from_box[str[j][1] - 97] == 2 && appeared_par[str[j][1] - 97].is_appeared2 == 0){//有参数输出最后的一个！！！！！！写到这里卡住了，最后快结束了，发现
127                     //如果一个带参数的选项在命令行中出 现了多次,只输出最后一次出现时所带的参数。
128                     //那我不应该对有参数的排序。
129                 appeared_par[str[j][1] - 97].is_appeared2 = 1;
130                     printf(" %s", appeared_par[str[j][1] - 97].s);
131             }
132         }
133         printf("\n");
134     }
135 }
136 //上述代码问题注释用到的是下面的输入
137 //albw:x
138 //4
139 //ls -a -l -a documents -b
140 
141 
142 //albw:x
143 //7
144 //ls -a -l -a documents -b
145 //ls
146 //ls -w 10 -x -w 15
147 //ls -a -b -c -d -e -l
148 //ls -a -l -a documents -b
149 //ls
150 //ls -w 10 -x -w 15

 

 

 

 

 

 

 

对此修改，主要看82行

  1 #include<algorithm>
  2 #include<cstring>
  3 #include<cstdio>
  4 
  5 #define M 130//最多差不多130个选项（256/2）
  6 #define len 260//每个选项最长260
  7 
  8 using namespace std;
  9 char box[53];//格式字符串不超过52
 10 
 11 int appear_from_box[30];//26个字母，作为一个标记记号,格式字符串用的
 12 int actual_input_have_parameters[30];//实际输入有参数的，每个待处理命令行用的
 13 char save[len];
 14 char str[M][len];//将一行存入二维数组
 15 
 16 int cmp1(const void *a, const void*b)
 17 {
 18     char *s1 = (char *)a;
 19     char *s2 = (char *)b;
 20     return strcmp(s1, s2);
 21 }
 22 struct node{
 23     int is_appeared1;//倒数第二个for用来确认是不是第一次遇见有参数的选项
 24     int is_appeared2;//最后一个for确认是不是第一次遇见有参数的选项
 25     char s[260];
 26 };
 27 
 28 int main()
 29 {
 30     memset(appear_from_box, 0, sizeof(appear_from_box));
 31     memset(actual_input_have_parameters, 0, sizeof(actual_input_have_parameters));
 32     int N;
 33     scanf("%s", &box);
 34     int boxlen = strlen(box);
 35     for(int i = 0; i < boxlen; i ++)
 36     {
 37         if(box[i] != ':' && (box[i] - 97) >= 0)
 38             appear_from_box[box[i] - 97] = 1;//无参数为1
 39         if(box[i + 1] == ':' && (box[i] - 97) >= 0)
 40             appear_from_box[box[i] - 97] = 2;//有参数为2
 41         //没出现在格式字符串中的为0
 42     }
 43 
 44     printf("%d\n", appear_from_box[1]);
 45 
 46 
 47 //    getchar();
 48     scanf("%d", &N);
 49     getchar();
 50     for (int i = 0; i < N; i++)
 51     {
 52         int appeared_nopar[30];//给最后的for用的
 53         memset(appeared_nopar, 0, sizeof(appeared_nopar));
 54 
 55         memset(save, 0, sizeof(save));//二维数组初始化   格式字符串的空间
 56         memset(str, 0, sizeof(str));//二维数组初始化    待处理字符串的空间
 57 
 58         struct node appeared_par[30];
 59         memset(appeared_par, 0, sizeof(appeared_par));//怎样初始值空的  结构体？？？？？？？？？？？这样就算赋值成功了？？？？？？？怎么感觉成员没有赋呢
 60 
 61 
 62         gets(save);
 63         int x = 0;
 64         int y = 0;
 65         int p = 3;
 66         int number_option = 1;//一行当中选项的个数
 67         while(save[p] != '\0') //重要！！！这里我一开始用的是'\n'我认为最后的结束符是回车，但其实是字符串结束符'\0'，一开始的'\n'就导致了下一行是无限循环的输出
 68         {
 69             str[x][y ++] = save[p ++];
 70             if(save[p] == ' ' && save[p + 1] != '-' && (str[x][1] - 97) >= 0)//有参数
 71                 actual_input_have_parameters[str[x][1] - 97] = 2;
 72             if(save[p] == ' ' && save[p + 1] == '-' && (str[x][1] - 97) >= 0)//无参数
 73             {
 74                 actual_input_have_parameters[str[x][1] - 97] = 1;
 75 //            printf("$$$%s\n" ,str[x]);
 76                 x ++;
 77                 number_option ++;
 78                 p ++;
 79 //                printf("%s\n", str[x - 1]);
 80                 y = 0;
 81             }
 82             if(save[p] == '\0' && save[p + 1] == '\0' && actual_input_have_parameters[str[x][1] - 97] == 0 && (str[x][1] - 97) >= 0)
 83                 actual_input_have_parameters[str[x][1] - 97] = 1;
 84         }
 85 printf("$%d$\n", actual_input_have_parameters[1]);
 86         //提取有参数的最后一个
 87         for(int j = number_option - 1; j >= 0; j --){
 88             int p = 0;
 89             if(appear_from_box[str[j][1] - 97] == 2 && appeared_par[str[j][1] - 97].is_appeared1 == 0){
 90                 appeared_par[str[j][1] - 97].is_appeared1 = 1;
 91 //                strncpy(appeared_nopar[str[j][1] - 97].s, str[j]);//指针不能赋值给字符串
 92 //                appeared_nopar[str[j][1] - 97].s =  ;
 93                 while(str[j][p] != '\0'){
 94                     appeared_par[str[j][1] - 97].s[p] = str[j][p];
 95                     p ++;
 96                 }
 97 //                printf("__%s__\n", appeared_par[str[j][1] - 97].s);
 98             }
 99         }
100 
101         qsort(str, number_option, sizeof(char)*len, cmp1);
102 
103         for(int j = 0; j < number_option; j ++){
104             printf("###%s %d###\n", str[j], actual_input_have_parameters[str[j][1] - 97]);
105         }
106 
107 //for(int j = 0; j < number_option; j ++)
108 //    printf("%s\n", str[j]);
109 //
110         printf("Case %d:", i+1);
111 //        printf("##%d\n", appear_from_box[1]);
112         for(int j = 0; j < number_option; j ++)
113         {
114 
115             if(appear_from_box[str[j][1] - 97] == 0){//遇到没出现过的选项，停止分析
116                 j = number_option;
117                 continue;
118             }//                       printf("__%c:%d   %c:%d__\n", str[j][1], appear_from_box[str[j][1] - 97], str[x][1], actual_input_have_parameters[str[j][1] - 97]);
119 
120             if(appear_from_box[str[j][1] - 97] != actual_input_have_parameters[str[j][1] - 97])//选项不对，跳过
121                 continue;
122 
123             if(appear_from_box[str[j][1] - 97] == 1 && appeared_nopar[str[j][1] - 97] == 0){//无参数则只输出一次
124                 appeared_nopar[str[j][1] - 97] = 1;
125                 printf(" %s", str[j]);
126 
127             }
128             if(appear_from_box[str[j][1] - 97] == 2 && appeared_par[str[j][1] - 97].is_appeared2 == 0){//有参数输出最后的一个！！！！！！写到这里卡住了，最后快结束了，发现
129                     //如果一个带参数的选项在命令行中出 现了多次,只输出最后一次出现时所带的参数。
130                     //那我不应该对有参数的排序。
131                 appeared_par[str[j][1] - 97].is_appeared2 = 1;
132                     printf(" %s", appeared_par[str[j][1] - 97].s);
133             }
134         }
135         printf("\n");
136     }
137 }
138 //上述代码问题注释用到的是下面的输入
139 //albw:x
140 //4
141 //ls -a -l -a documents -b
142 
143 
144 //albw:x
145 //7
146 //ls -a -l -a documents -b
147 //ls
148 //ls -w 10 -x -w 15
149 //ls -a -b -c -d -e -l
150 //ls -a -l -a documents -b
151 //ls
152 //ls -w 10 -x -w 15

输入

albw:x
4
ls -a -l -a documents -b

输出：↓

 

 

主要看 $1$ ， 这是为了区分，含义是对于输入最后一个-b，我存入的b选项是有参数还是无参数（有参数这个值为2，无参数为1，选项在格式字符串中未出现过则值为0）

如果82行的'\0'写成' '，则值为0，会输出$0$

 

 

我这里读错题目了。

 

 

 

按照重新理解后的题意思，重新修改一下就是

  1 #include<algorithm>
  2 #include<cstring>
  3 #include<cstdio>
  4 
  5 #define M 130//最多差不多130个选项（256/2）
  6 #define len 260//每个选项最长260
  7 
  8 using namespace std;
  9 char box[53];//格式字符串不超过52
 10 
 11 int appear_from_box[30];//26个字母，作为一个标记记号,格式字符串用的
 12 int actual_input_have_parameters[30];//实际输入有参数的，每个待处理命令行用的
 13 char save[len];
 14 char str[M][len];//将一行存入二维数组
 15 
 16 int cmp1(const void *a, const void*b)
 17 {
 18     char *s1 = (char *)a;
 19     char *s2 = (char *)b;
 20     return strcmp(s1, s2);
 21 }
 22 struct node{
 23     int is_appeared1;//倒数第二个for用来确认是不是第一次遇见有参数的选项
 24     int is_appeared2;//最后一个for确认是不是第一次遇见有参数的选项
 25     char s[260];
 26 };
 27 
 28 int main()
 29 {
 30     memset(appear_from_box, 0, sizeof(appear_from_box));
 31     memset(actual_input_have_parameters, 0, sizeof(actual_input_have_parameters));
 32     int N;
 33     scanf("%s", &box);
 34     int boxlen = strlen(box);
 35     for(int i = 0; i < boxlen; i ++)
 36     {
 37         if(box[i] != ':' && (box[i] - 97) >= 0)
 38             appear_from_box[box[i] - 97] = 1;//无参数为1
 39         if(box[i + 1] == ':' && (box[i] - 97) >= 0)
 40             appear_from_box[box[i] - 97] = 2;//有参数为2
 41         //没出现在格式字符串中的为0
 42     }
 43 
 44     printf("%d\n", appear_from_box[1]);
 45 
 46 
 47 //    getchar();
 48     scanf("%d", &N);
 49     getchar();
 50     for (int i = 0; i < N; i++)
 51     {
 52         int appeared_nopar[30];//给最后的for用的
 53         memset(appeared_nopar, 0, sizeof(appeared_nopar));
 54 
 55         memset(save, 0, sizeof(save));//二维数组初始化   格式字符串的空间
 56         memset(str, 0, sizeof(str));//二维数组初始化    待处理字符串的空间
 57 
 58         struct node appeared_par[30];
 59         memset(appeared_par, 0, sizeof(appeared_par));//怎样初始值空的  结构体？？？？？？？？？？？这样就算赋值成功了？？？？？？？怎么感觉成员没有赋呢
 60 
 61 
 62         gets(save);
 63         int x = 0;
 64         int y = 0;
 65         int p = 3;
 66         int number_option = 1;//一行当中选项的个数
 67         while(save[p] != '\0') //重要！！！这里我一开始用的是'\n'我认为最后的结束符是回车，但其实是字符串结束符'\0'，一开始的'\n'就导致了下一行是无限循环的输出
 68         {
 69             str[x][y ++] = save[p ++];
 70             if(save[p] == ' ' && save[p + 1] != '-' && (str[x][1] - 97) >= 0)//有参数
 71                 actual_input_have_parameters[str[x][1] - 97] = 2;
 72             if(save[p] == ' ' && save[p + 1] == '-' && (str[x][1] - 97) >= 0)//无参数
 73             {
 74                 actual_input_have_parameters[str[x][1] - 97] = 1;
 75 //            printf("$$$%s\n" ,str[x]);
 76                 x ++;
 77                 number_option ++;
 78                 p ++;
 79 //                printf("%s\n", str[x - 1]);
 80                 y = 0;
 81             }
 82             if(save[p] == '\0' && save[p + 1] == '\0' && actual_input_have_parameters[str[x][1] - 97] == 0 && (str[x][1] - 97) >= 0)
 83                 actual_input_have_parameters[str[x][1] - 97] = 1;
 84         }
 85 //printf("$%d$\n", actual_input_have_parameters[1]);
 86         //提取有参数的最后一个
 87         for(int j = number_option - 1; j >= 0; j --){
 88             int p = 0;
 89             if(appear_from_box[str[j][1] - 97] == 2 && appeared_par[str[j][1] - 97].is_appeared1 == 0){
 90                 appeared_par[str[j][1] - 97].is_appeared1 = 1;
 91 //                strncpy(appeared_nopar[str[j][1] - 97].s, str[j]);//指针不能赋值给字符串
 92 //                appeared_nopar[str[j][1] - 97].s =  ;
 93                 while(str[j][p] != '\0'){
 94                     appeared_par[str[j][1] - 97].s[p] = str[j][p];
 95                     p ++;
 96                 }
 97 //                printf("__%s__\n", appeared_par[str[j][1] - 97].s);
 98             }
 99         }
100 
101 //        qsort(str, number_option, sizeof(char)*len, cmp1);
102 
103 //        for(int j = 0; j < number_option; j ++){
104 //            printf("###%s %d###\n", str[j], actual_input_have_parameters[str[j][1] - 97]);
105 //        }
106 
107 //for(int j = 0; j < number_option; j ++)
108 //    printf("%s\n", str[j]);
109 //
110         printf("Case %d:", i+1);
111 //        printf("##%d\n", appear_from_box[1]);
112         for(int j = 0; j < number_option; j ++)
113         {
114 
115             if(appear_from_box[str[j][1] - 97] == 0){//遇到没出现过的选项，停止分析
116                 j = number_option;
117                 continue;
118             }//                       printf("__%c:%d   %c:%d__\n", str[j][1], appear_from_box[str[j][1] - 97], str[x][1], actual_input_have_parameters[str[j][1] - 97]);
119 
120             if(appear_from_box[str[j][1] - 97] != actual_input_have_parameters[str[j][1] - 97])//选项不对，跳过
121                 continue;
122 
123             if(str[j][1] < str[j - 1][1])
124                 break;
125 
126             if(appear_from_box[str[j][1] - 97] == 1 && appeared_nopar[str[j][1] - 97] == 0){//无参数则只输出一次
127                 appeared_nopar[str[j][1] - 97] = 1;
128                 printf(" %s", str[j]);
129 
130             }
131             if(appear_from_box[str[j][1] - 97] == 2 && appeared_par[str[j][1] - 97].is_appeared2 == 0){//有参数输出最后的一个！！！！！！写到这里卡住了，最后快结束了，发现
132                     //如果一个带参数的选项在命令行中出 现了多次,只输出最后一次出现时所带的参数。
133                     //那我不应该对有参数的排序。
134                 appeared_par[str[j][1] - 97].is_appeared2 = 1;
135                     printf(" %s", appeared_par[str[j][1] - 97].s);
136             }
137         }
138         printf("\n");
139     }
140 }
141 //上述代码问题注释用到的是下面的输入
142 //albw:x
143 //4
144 //ls -a -l -a documents -b
145 
146 
147 //albw:x
148 //7
149 //ls -a -l -a documents -b
150 //ls
151 //ls -w 10 -x -w 15
152 //ls -a -b -c -d -e -l
153 //ls -a -l -a documents -b
154 //ls
155 //ls -w 10 -x -w 15

可是还不对。0分？？？

 

 

 

这道题把我逼疯了！*10

出去溜达一圈，好害怕，夜市周围全是人，没有我的空间，傻乎乎， 从出去21：11-21:50到回到家，一直在思考，和兴三和头还有中兴文兴。。我的脑子真的费了。。在意别人，，，眼神杀人。。哎，。终究还是不行

 

渴望有一个昨晚的女朋友，灵气，pooklook、陈梓璇，忘记了jsh和lrw和djy，只是我不配。。。垃圾，不堪

 

父母养活我。。。衣来张口饭来伸手。。。废物

 

一个一星难度的题目叫你写了一天。都没写完。。。。等你他妈的有点成就和资本了再来bb吧，再来幻想这那的吧，再内心想法的吧。傻逼废物垃圾废人！

 

第一天，克服所有困难，不躺床，脑子晕，闷，屋子小，家里的凳子腰疼背疼。。。。克服！！！我别无选择！！！父母全力支持我，你还要怎样，好吃好喝活不要你干，家虽小，但是基本父母做到了最好。

希望我能不记录，195天，度过，改变，大一！！重回，，，，追回！！！

 

 

 

CCF不能看提交记录。

还有，挺多挺好的题目因为数据水，导致全是水题解，思路扰乱，提交都不知道是真正对了还是。。一个是无线网络，一个是这个题目的描述！！！

 

从来没有好好刷过题。

 

 

 

 

 

 

看了一下 http://www.luyixian.cn/news_show_312489.aspx

 

 

 

这里错了。没有这个样例我是想不出这个问题的

和上一个题目无线网络一样，用一个固定属性来规定一个选项，这里w一个合法，一个不合法。而我只用了一个变量来表示一个选项字，也就是w要么合法，要么不合法，这也就导致，两个w，一个合法，一个不合法。，我却给判断成w选项都不合法

 

 

 

确实写崩了，

  1 #include<algorithm>
  2 #include<cstring>
  3 #include<cstdio>
  4 
  5 #define M 130//最多差不多130个选项（256/2）
  6 #define len 260//每个选项最长260
  7 
  8 using namespace std;
  9 char box[53];//格式字符串不超过52
 10 
 11 int appear_from_box[30];//26个字母，作为一个标记记号,格式字符串用的
 12 int actual_input_have_parameters[30];//实际输入有参数的，每个待处理命令行用的
 13 char save[len];
 14 char str[M][len];//将一行存入二维数组
 15 
 16 int cmp1(const void *a, const void*b)
 17 {
 18     char *s1 = (char *)a;
 19     char *s2 = (char *)b;
 20     return strcmp(s1, s2);
 21 }
 22 struct node{
 23     int is_appeared1;//倒数第二个for用来确认是不是第一次遇见有参数的选项
 24     int is_appeared2;//最后一个for确认是不是第一次遇见有参数的选项
 25     char s[260];
 26 };
 27 
 28 int main()
 29 {
 30     memset(appear_from_box, 0, sizeof(appear_from_box));
 31     memset(actual_input_have_parameters, 0, sizeof(actual_input_have_parameters));
 32     int N;
 33     scanf("%s", &box);
 34     int boxlen = strlen(box);
 35     for(int i = 0; i < boxlen; i ++)
 36     {
 37         if(box[i] != ':' && (box[i] - 97) >= 0)
 38             appear_from_box[box[i] - 97] = 1;//无参数为1
 39         if(box[i + 1] == ':' && (box[i] - 97) >= 0)
 40             appear_from_box[box[i] - 97] = 2;//有参数为2
 41         //没出现在格式字符串中的为0
 42     }
 43 
 44 //    printf("%d\n", appear_from_box[1]);
 45 
 46 
 47 //    getchar();
 48     scanf("%d", &N);
 49     getchar();
 50     for (int i = 0; i < N; i++)
 51     {
 52         int appeared_nopar[30];//给最后的for用的
 53         memset(appeared_nopar, 0, sizeof(appeared_nopar));
 54 
 55         memset(save, 0, sizeof(save));//二维数组初始化   格式字符串的空间
 56         memset(str, 0, sizeof(str));//二维数组初始化    待处理字符串的空间
 57 
 58         struct node appeared_par[30];
 59         memset(appeared_par, 0, sizeof(appeared_par));//怎样初始值空的  结构体？？？？？？？？？？？这样就算赋值成功了？？？？？？？怎么感觉成员没有赋呢
 60 
 61 
 62         gets(save);
 63         int x = 0;
 64         int y = 0;
 65         int p = 3;
 66         int number_option = 1;//一行当中选项的个数
 67         while(save[p] != '\0') //重要！！！这里我一开始用的是'\n'我认为最后的结束符是回车，但其实是字符串结束符'\0'，一开始的'\n'就导致了下一行是无限循环的输出
 68         {
 69             str[x][y ++] = save[p ++];
 70             if(save[p] == ' ' && save[p + 1] != '-' && (str[x][1] - 97) >= 0)//有参数
 71                 actual_input_have_parameters[str[x][1] - 97] = 2;
 72             if(save[p] == ' ' && save[p + 1] == '-' && (str[x][1] - 97) >= 0)//无参数
 73             {
 74                 actual_input_have_parameters[str[x][1] - 97] = 1;
 75 //            printf("$$$%s\n" ,str[x]);
 76                 x ++;
 77                 number_option ++;
 78                 p ++;
 79 //                printf("%s\n", str[x - 1]);
 80                 y = 0;
 81             }
 82             if(save[p] == '\0' && save[p + 1] == '\0' && actual_input_have_parameters[str[x][1] - 97] == 0 && (str[x][1] - 97) >= 0)
 83                 actual_input_have_parameters[str[x][1] - 97] = 1;
 84         }
 85 //        for(int j = 0; j < number_option; j ++){
 86 //            printf("##%s##\n", str[j]);
 87 //        }
 88 printf("$%d$\n", actual_input_have_parameters[22]);
 89         //提取有参数的最后一个
 90         for(int j = number_option - 1; j >= 0; j --){
 91             int p = 0;
 92             if(appear_from_box[str[j][1] - 97] == 2 && appeared_par[str[j][1] - 97].is_appeared1 == 0){
 93                 appeared_par[str[j][1] - 97].is_appeared1 = 1;
 94 //                strncpy(appeared_nopar[str[j][1] - 97].s, str[j]);//指针不能赋值给字符串
 95 //                appeared_nopar[str[j][1] - 97].s =  ;
 96                 while(str[j][p] != '\0'){
 97                     appeared_par[str[j][1] - 97].s[p] = str[j][p];
 98                     p ++;
 99                 }
100 //                printf("__%s__\n", appeared_par[str[j][1] - 97].s);
101             }
102         }
103 
104 //        qsort(str, number_option, sizeof(char)*len, cmp1);
105 
106 //        for(int j = 0; j < number_option; j ++){
107 //            printf("###%s %d###\n", str[j], actual_input_have_parameters[str[j][1] - 97]);
108 //        }
109 
110 for(int j = 0; j < number_option; j ++)
111     printf("%s\n", str[j]);
112 //
113         printf("Case %d:", i+1);
114 //        printf("##%d\n", appear_from_box[1]);
115         for(int j = 0; j < number_option; j ++)
116         {
117 
118             if(appear_from_box[str[j][1] - 97] == 0){//遇到没出现过的选项，停止分析
119                 j = number_option;
120                 continue;
121             }//                       printf("__%c:%d   %c:%d__\n", str[j][1], appear_from_box[str[j][1] - 97], str[x][1], actual_input_have_parameters[str[j][1] - 97]);
122 
123             if(appear_from_box[str[j][1] - 97] != actual_input_have_parameters[str[j][1] - 97])//选项不对，跳过
124                 continue;
125 
126             if(j >= 1 &&  str[j][1] < str[j - 1][1])//？？？？？？？？这里不会运行错误么？？？？？？？负数了，那97那个也不会有事啊？？？？？？？？？？？？？？？？
127                 break;
128 
129             if(appear_from_box[str[j][1] - 97] == 1 && appeared_nopar[str[j][1] - 97] == 0){//无参数则只输出一次
130                 appeared_nopar[str[j][1] - 97] = 1;
131                 printf(" %s", str[j]);
132 
133             }
134             if(appear_from_box[str[j][1] - 97] == 2 && appeared_par[str[j][1] - 97].is_appeared2 == 0){//有参数输出最后的一个！！！！！！写到这里卡住了，最后快结束了，发现
135                     //如果一个带参数的选项在命令行中出 现了多次,只输出最后一次出现时所带的参数。
136                     //那我不应该对有参数的排序。
137                 appeared_par[str[j][1] - 97].is_appeared2 = 1;
138                     printf(" %s", appeared_par[str[j][1] - 97].s);
139             }
140         }
141         printf("\n");
142     }
143 }
144 //上述代码问题注释用到的是下面的输入
145 //albw:x
146 //4
147 //ls -a -l -a documents -b
148 
149 
150 //albw:x
151 //7
152 //ls -a -l -a documents -b
153 //ls
154 //ls -w 10 -x -w 15
155 //ls -a -b -c -d -e -l
156 //ls -a -l -a documents -b
157 //ls
158 //ls -w 10 -x -w 15
159 
160 
161 
162 
163 //albw:x
164 //1
165 //ls -w 10 -w
166 
167 //albw:x
168 //4
169 //ls -w 10 -w

 

 

 按照前面说的70行加一个判断，但似乎-w 10的10又存不进去了，最后$1$相当于无参数，然后-w不合法不输出，跳过。PS：看题解，这里合法和我理解的合法不一样，应该是终止分析的。本来82/83行是为了弥补第一个输入-b结尾不被判断为的问题，可是这里又给这个数据挖了个坑。。。。反而。进去了。。。

 

 

这个题后台数据应该是没有样例的数据

重点改了72行，导致$1$的主要原因

 

 

 

出问题了

 

 

 

 

 

 

 。-b结尾的修改，坑进入-w -w 10固定属性，现在，↑。。。。。。

 

 

 

 

 

 

 

 

 

 

 

好奇怪啊，我复制了一个题解

 

 

 这也能对？？？？我真怀疑是不是CCF测评机坏了啊，为啥我的是0分，他这个居然能是满分？？？？？？？？？？卧槽！！

 

 

 

其实说到底应该是这题没有描述清楚题意！！

 

 

！不想写了，放弃！

 

 

 

 亏我还认为acm>>>pat顶>ccf>pat甲>>>（pat乙>）蓝桥杯（>pat乙）

 

 

 

知乎回复骂8000年的服务器。中山：pat浙大刷的，不考浙大不用刷，何况ccf

 

 

 

好几回了，手机搜索出来的题解比电脑上搜索接地气，比如这个https://blog.csdn.net/sunandstarws/article/details/98054258?utm_medium=distribute.wap_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-4.nonecase&depth_1-utm_source=distribute.wap_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-4.nonecase

 

再比如https://blog.csdn.net/qq_38831220/article/details/103848800

 

 

收到上述题解的启发，可能会出现这种情况，

 

 

 

 

 

这里贴一下我目前的代码吧，想重新写了，感觉细枝末节的错误导致代码稀碎，牵一发而动全身，拆东墙补西墙。

  1 #include<algorithm>
  2 #include<cstring>
  3 #include<cstdio>
  4 
  5 #define M 130//最多差不多130个选项（256/2）
  6 #define len 260//每个选项最长260
  7 
  8 using namespace std;
  9 char box[53];//格式字符串不超过52
 10 
 11 int appear_from_box[30];//26个字母，作为一个标记记号,格式字符串用的
 12 int actual_input_have_parameters[30];//实际输入有参数的，每个待处理命令行用的
 13 char save[len];
 14 char str[M][len];//将一行存入二维数组
 15 
 16 int cmp1(const void *a, const void*b)
 17 {
 18     char *s1 = (char *)a;
 19     char *s2 = (char *)b;
 20     return strcmp(s1, s2);
 21 }
 22 struct node{
 23     int is_appeared1;//倒数第二个for用来确认是不是第一次遇见有参数的选项
 24     int is_appeared2;//最后一个for确认是不是第一次遇见有参数的选项
 25     char s[260];
 26 };
 27 
 28 int main()
 29 {
 30     memset(appear_from_box, 0, sizeof(appear_from_box));
 31     memset(actual_input_have_parameters, 0, sizeof(actual_input_have_parameters));
 32     int N;
 33     scanf("%s", &box);
 34     int boxlen = strlen(box);
 35     for(int i = 0; i < boxlen; i ++)
 36     {
 37         if(box[i] != ':' && (box[i] - 97) >= 0)
 38             appear_from_box[box[i] - 97] = 1;//无参数为1
 39         if(box[i + 1] == ':' && (box[i] - 97) >= 0)
 40             appear_from_box[box[i] - 97] = 2;//有参数为2
 41         //没出现在格式字符串中的为0
 42     }
 43 
 44 //    printf("%d\n", appear_from_box[1]);
 45 
 46 //    getchar();
 47     scanf("%d", &N);
 48     getchar();
 49     for (int i = 0; i < N; i++)
 50     {
 51         int appeared_nopar[30];//给最后的for用的
 52         memset(appeared_nopar, 0, sizeof(appeared_nopar));
 53 
 54         memset(save, 0, sizeof(save));//二维数组初始化   格式字符串的空间
 55         memset(str, 0, sizeof(str));//二维数组初始化    待处理字符串的空间
 56 
 57         struct node appeared_par[30];
 58         memset(appeared_par, 0, sizeof(appeared_par));//怎样初始值空的  结构体？？？？？？？？？？？这样就算赋值成功了？？？？？？？怎么感觉成员没有赋呢
 59 
 60 
 61         gets(save);
 62         int x = 0;
 63         int y = 0;
 64         int p = 3;
 65         int number_option = 1;//一行当中选项的个数
 66 //        printf("^^%d^^\n", appear_from_box[22]);
 67         while(save[p] != '\0') //重要！！！这里我一开始用的是'\n'我认为最后的结束符是回车，但其实是字符串结束符'\0'，一开始的'\n'就导致了下一行是无限循环的输出
 68         {
 69             str[x][y ++] = save[p ++];
 70 
 71 //            printf("!#%c# #%c# %d %d %c!\n", save[p], save[p + 1], (str[x][1] - 97), appear_from_box[str[x][1] - 97], str[x][1]);
 72             if(save[p] == ' ' && save[p + 1] != '-' && (str[x][1] - 97) >= 0 && appear_from_box[str[x][1] - 97] == 2){//有参数//大改1
 73 //                printf("TEST");
 74                 actual_input_have_parameters[str[x][1] - 97] = 2;
 75 //                printf("——————————%d^^\n", actual_input_have_parameters[22]);
 76             }
 77 
 78             if(save[p] == ' ' && save[p + 1] == '-' && (str[x][1] - 97) >= 0 )//无参数
 79             {
 80                 if(actual_input_have_parameters[str[x][1] - 97] == 2)
 81                     ;
 82                 else
 83                     actual_input_have_parameters[str[x][1] - 97] = 1;
 84 //printf("$%d$\n", actual_input_have_parameters[22]);
 85 //            printf("$$$%s\n" ,str[x]);
 86                 x ++;
 87                 number_option ++;
 88                 p ++;
 89 //                printf("%s\n", str[x - 1]);
 90                 y = 0;
 91             }
 92             if(save[p] == '\0' && save[p + 1] == '\0' && actual_input_have_parameters[str[x][1] - 97] == 0 && (str[x][1] - 97) >= 0 )
 93                 if(save[p - 2] == '-')
 94                     actual_input_have_parameters[str[x][1] - 97] = 1;
 95                 else
 96                     actual_input_have_parameters[str[x][1] - 97] = 2;
 97 
 98         }
 99 
100 
101 //printf("$%d$\n", actual_input_have_parameters[22]);
102         //提取有参数的最后一个
103         for(int j = number_option - 1; j >= 0; j --){
104             int p = 0;
105             if(appear_from_box[str[j][1] - 97] == 2 && str[j][3] != '\0' && appeared_par[str[j][1] - 97].is_appeared1 == 0){//改动2
106                 appeared_par[str[j][1] - 97].is_appeared1 = 1;
107 //                strncpy(appeared_nopar[str[j][1] - 97].s, str[j]);//指针不能赋值给字符串
108 //                appeared_nopar[str[j][1] - 97].s =  ;
109                 while(str[j][p] != '\0'){
110                     appeared_par[str[j][1] - 97].s[p] = str[j][p];
111                     p ++;
112                 }
113 //                printf("__%s__\n", appeared_par[str[j][1] - 97].s);
114             }
115         }
116 
117 //for(int j = 0; j < number_option; j ++)
118 //    printf("##%s##\n", str[j]);
119 //printf("#%d#\n", appear_from_box[0]);
120 //printf("#%d#\n", actual_input_have_parameters[0]);
121 
122 
123 //        qsort(str, number_option, sizeof(char)*len, cmp1);
124 
125 //        for(int j = 0; j < number_option; j ++){
126 //            printf("###%s %d###\n", str[j], actual_input_have_parameters[str[j][1] - 97]);
127 //        }
128 
129 //for(int j = 0; j < number_option; j ++)
130 //    printf("%s\n", str[j]);
131 //
132         printf("Case %d:", i+1);
133 //        printf("##%d\n", appear_from_box[1]);
134         for(int j = 0; j < number_option; j ++){
135             if(appear_from_box[str[j][1] - 97] == 0){//遇到没出现过的选项，停止分析
136 //                j = number_option;
137 //                continue;
138                 break;
139             }//                       printf("__%c:%d   %c:%d__\n", str[j][1], appear_from_box[str[j][1] - 97], str[x][1], actual_input_have_parameters[str[j][1] - 97]);
140 
141             if(appear_from_box[str[j][1] - 97] != actual_input_have_parameters[str[j][1] - 97])//选项不对，跳过
142                 break;//按照题解说的理解，不合法就结束
143 
144             if(j >= 1 &&  str[j][1] < str[j - 1][1])//？？？？？？？？这里不会运行错误么？？？？？？？负数了，那97那个也不会有事啊？？？？？？？？？？？？？？？？
145                 break;
146 
147             if(appear_from_box[str[j][1] - 97] == 1 && appeared_nopar[str[j][1] - 97] == 0){//无参数则只输出一次
148                 appeared_nopar[str[j][1] - 97] = 1;
149                 printf(" %s", str[j]);
150 
151             }
152             if(appear_from_box[str[j][1] - 97] == 2 && appeared_par[str[j][1] - 97].is_appeared2 == 0){//有参数输出最后的一个！！！！！！写到这里卡住了，最后快结束了，发现
153                     //如果一个带参数的选项在命令行中出 现了多次,只输出最后一次出现时所带的参数。
154                     //那我不应该对有参数的排序。
155                 appeared_par[str[j][1] - 97].is_appeared2 = 1;
156                     printf(" %s", appeared_par[str[j][1] - 97].s);
157             }
158         }
159         printf("\n");
160     }
161 }
162 //上述代码问题注释用到的是下面的输入
163 //albw:x
164 //4
165 //ls -a -l -a documents -b
166 
167 
168 //albw:x
169 //7
170 //ls -a -l -a documents -b
171 //ls
172 //ls -w 10 -x -w 15
173 //ls -a -b -c -d -e -l
174 //ls -a -l -a documents -b
175 //ls
176 //ls -w 10 -x -w 15
177 
178 
179 
180 
181 //albw:x
182 //1
183 //ls -w 10 -w
184 
185 //albw:x
186 //4
187 //ls -w 10 -w

 

 

。截图那个错误貌似是缓存没清理干净一样。

 

 

 

 

 

最后截个图收工吧。感觉就差一步，但是这一步是死路，已经写死了， 没法改动了

 

https://www.one-tab.com/page/3ExAOHhRSCCmG_WhzshLvA

 

 

  1 #include<algorithm>
  2 #include<cstring>
  3 #include<cstdio>
  4 
  5 #define M 130//最多差不多130个选项（256/2）
  6 #define len 260//每个选项最长260
  7 
  8 using namespace std;
  9 char box[53];//格式字符串不超过52
 10 
 11 int appear_from_box[30];//26个字母，作为一个标记记号,格式字符串用的
 12 int actual_input_have_parameters[30];//实际输入有参数的，每个待处理命令行用的
 13 char save[len];
 14 char str[M][len];//将一行存入二维数组
 15 
 16 int cmp1(const void *a, const void*b)
 17 {
 18     char *s1 = (char *)a;
 19     char *s2 = (char *)b;
 20     return strcmp(s1, s2);
 21 }
 22 struct node{
 23     int is_appeared1;//倒数第二个for用来确认是不是第一次遇见有参数的选项
 24     int is_appeared2;//最后一个for确认是不是第一次遇见有参数的选项
 25     char s[260];
 26 };
 27 
 28 int main()
 29 {
 30     memset(appear_from_box, 0, sizeof(appear_from_box));
 31     memset(actual_input_have_parameters, 0, sizeof(actual_input_have_parameters));
 32     int N;
 33     scanf("%s", &box);
 34     int boxlen = strlen(box);
 35     for(int i = 0; i < boxlen; i ++)
 36     {
 37         if(box[i] != ':' && (box[i] - 97) >= 0)
 38             appear_from_box[box[i] - 97] = 1;//无参数为1
 39         if(box[i + 1] == ':' && (box[i] - 97) >= 0)
 40             appear_from_box[box[i] - 97] = 2;//有参数为2
 41         //没出现在格式字符串中的为0
 42     }
 43 
 44 //    printf("%d\n", appear_from_box[1]);
 45 
 46 //    getchar();
 47     scanf("%d", &N);
 48     getchar();
 49     for (int i = 0; i < N; i++)
 50     {
 51         int appeared_nopar[30];//给最后的for用的
 52         memset(appeared_nopar, 0, sizeof(appeared_nopar));
 53 
 54         memset(save, 0, sizeof(save));//二维数组初始化   格式字符串的空间
 55         memset(str, 0, sizeof(str));//二维数组初始化    待处理字符串的空间
 56 
 57         struct node appeared_par[30];
 58         memset(appeared_par, 0, sizeof(appeared_par));//怎样初始值空的  结构体？？？？？？？？？？？这样就算赋值成功了？？？？？？？怎么感觉成员没有赋呢
 59 
 60 
 61         gets(save);
 62         int x = 0;
 63         int y = 0;
 64         int p = 3;
 65         int number_option = 1;//一行当中选项的个数
 66 //        printf("^^%d^^\n", appear_from_box[22]);
 67         while(save[p] != '\0') //重要！！！这里我一开始用的是'\n'我认为最后的结束符是回车，但其实是字符串结束符'\0'，一开始的'\n'就导致了下一行是无限循环的输出
 68 //        for(;save[p] != '\0';)
 69         {
 70             if(save[p] == '-' && (save[p + 1] >= 'a' && save[p + 1] <= 'z' ) )
 71                     if(save[p + 2] != ' ' || save[p + 2] != '\0'){
 72                         p ++;
 73                         continue;
 74                     }
 75             str[x][y ++] = save[p ++];
 76 
 77 //            printf("!#%c# #%c# %d %d %c!\n", save[p], save[p + 1], (str[x][1] - 97), appear_from_box[str[x][1] - 97], str[x][1]);
 78             if(save[p] == ' ' && save[p + 1] != '-' && (str[x][1] - 97) >= 0 && appear_from_box[str[x][1] - 97] == 2){//有参数//大改1
 79 //                printf("TEST");
 80                 actual_input_have_parameters[str[x][1] - 97] = 2;
 81 //                printf("——————————%d^^\n", actual_input_have_parameters[22]);
 82             }
 83             if(save[p] == ' ' && save[p + 1] == '-' && (str[x][1] - 97) >= 0 )//无参数
 84             {
 85                 if(actual_input_have_parameters[str[x][1] - 97] == 2)
 86                     ;
 87                 else
 88                     actual_input_have_parameters[str[x][1] - 97] = 1;
 89 //printf("$%d$\n", actual_input_have_parameters[22]);
 90 //            printf("$$$%s\n" ,str[x]);
 91                 x ++;
 92                 number_option ++;
 93                 p ++;
 94 //                printf("%s\n", str[x - 1]);
 95                 y = 0;
 96             }
 97             if(save[p] == '\0' && save[p + 1] == '\0' && actual_input_have_parameters[str[x][1] - 97] == 0 && (str[x][1] - 97) >= 0 )
 98                 if(save[p - 2] == '-')
 99                     actual_input_have_parameters[str[x][1] - 97] = 1;
100                 else
101                     actual_input_have_parameters[str[x][1] - 97] = 2;
102         }
103 
104 
105 //printf("$%d$\n", actual_input_have_parameters[22]);
106         //提取有参数的最后一个
107         for(int j = number_option - 1; j >= 0; j --){
108             int p = 0;
109             if(appear_from_box[str[j][1] - 97] == 2 && str[j][3] != '\0' && appeared_par[str[j][1] - 97].is_appeared1 == 0){//改动2
110                 appeared_par[str[j][1] - 97].is_appeared1 = 1;
111 //                strncpy(appeared_nopar[str[j][1] - 97].s, str[j]);//指针不能赋值给字符串
112 //                appeared_nopar[str[j][1] - 97].s =  ;
113                 while(str[j][p] != '\0'){
114                     appeared_par[str[j][1] - 97].s[p] = str[j][p];
115                     p ++;
116                 }
117 //                printf("__%s__\n", appeared_par[str[j][1] - 97].s);
118             }
119         }
120 for(int j = 0; j < number_option; j ++)
121     printf("##%s##\n", str[j]);
122 
123 //printf("#%d#\n", appear_from_box[0]);
124 //printf("#%d#\n", actual_input_have_parameters[0]);
125 
126 
127 //        qsort(str, number_option, sizeof(char)*len, cmp1);
128 
129 //        for(int j = 0; j < number_option; j ++){
130 //            printf("###%s %d###\n", str[j], actual_input_have_parameters[str[j][1] - 97]);
131 //        }
132 
133 //for(int j = 0; j < number_option; j ++)
134 //    printf("%s\n", str[j]);
135 //
136         printf("Case %d:", i+1);
137 //        printf("##%d\n", appear_from_box[1]);
138         for(int j = 0; j < number_option; j ++){
139             if(appear_from_box[str[j][1] - 97] == 0){//遇到没出现过的选项，停止分析
140 //                j = number_option;
141 //                continue;
142                 break;
143             }//                       printf("__%c:%d   %c:%d__\n", str[j][1], appear_from_box[str[j][1] - 97], str[x][1], actual_input_have_parameters[str[j][1] - 97]);
144 
145             if(appear_from_box[str[j][1] - 97] != actual_input_have_parameters[str[j][1] - 97])//选项不对，跳过
146                 break;//按照题解说的理解，不合法就结束
147 
148             if(j >= 1 &&  str[j][1] < str[j - 1][1])//？？？？？？？？这里不会运行错误么？？？？？？？负数了，那97那个也不会有事啊？？？？？？？？？？？？？？？？
149                 break;
150 
151             if(appear_from_box[str[j][1] - 97] == 1 && appeared_nopar[str[j][1] - 97] == 0){//无参数则只输出一次
152                 appeared_nopar[str[j][1] - 97] = 1;
153                 printf(" %s", str[j]);
154 
155             }
156             if(appear_from_box[str[j][1] - 97] == 2 && appeared_par[str[j][1] - 97].is_appeared2 == 0){//有参数输出最后的一个！！！！！！写到这里卡住了，最后快结束了，发现
157                     //如果一个带参数的选项在命令行中出 现了多次,只输出最后一次出现时所带的参数。
158                     //那我不应该对有参数的排序。
159                 appeared_par[str[j][1] - 97].is_appeared2 = 1;
160                     printf(" %s", appeared_par[str[j][1] - 97].s);
161             }
162         }
163         printf("\n");
164     }
165 }
166 //上述代码问题注释用到的是下面的输入
167 //albw:x
168 //4
169 //ls -a -l -a documents -b
170 
171 
172 //albw:x
173 //7
174 //ls -a -l -a documents -b
175 //ls
176 //ls -w 10 -x -w 15
177 //ls -a -b -c -d -e -l
178 //ls -a -l -a documents -b
179 //ls
180 //ls -w 10 -x -w 15
181 
182 
183 
184 
185 //albw:x
186 //1
187 //ls -w 10 -w
188 
189 //albw:x
190 //4
191 //ls -w 10 -w

 

 

。放弃了，学一下map之类的）

 

posted @ 2020-06-07 16:02  GerJCS  阅读(367)  评论(0)  编辑  收藏  举报