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/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之类的）
CCF 命令行选项的更多相关文章
- Maven学习（四）Maven 命令行选项
说明: 1.使用-选项时,和后面的参数之间可以不要空格.而使用--选项时,和后面的参数之 间必须有空格.如下面的例子: $ mvn help:describe -Dcmd=compiler:co ...
- 学习笔记——Maven 命令行选项
2014-10-09:更新裁剪反应堆具体用法 说明: 1.使用-选项时,和后面的参数之间可以不要空格.而使用--选项时,和后面的参数之 间必须有空格.如下面的例子: $ mvn help:des ...
- Microsoft Windows Installer 工具 Msiexec.exe 的命令行选项
摘自:http://support.microsoft.com/kb/314881/zh-cn 概要 本文列出了 Windows Installer 工具 Msiexec.exe 的命令行选项.Msi ...
- make的命令行选项
make的命令行选项 -b -m 忽略,提供其它版本make兼容性. -B --always-make 强制重建所有规则的目标,不根据规则的依赖描述决定是否重建目标文件. -C DIR --direc ...
- PhantomJS命令行选项
支持命令行选项有: --help或-h列出所有可能的命令行选项.立即停止,不会运行一个脚本作为参数传递. --version或-v打印的版本PhantomJS.立即停止,不会运行一个脚本作为参数传递. ...
- 【Python】【自动化测试】【pytest】【常用命令行选项】
https://www.cnblogs.com/cnkemi/p/9989019.html http://www.cnblogs.com/cnkemi/p/10002788.html pytest 常 ...
- python 解析命令行选项
问题: 程序如何能够解析命令行选项 解决方案 argparse 模块可被用来解析命令行选项 argparse 模块 argparse 模块是标准库中最大的模块之一,拥有大量的配置选项 dest 参数指 ...
- Ruby 命令行选项
Ruby 命令行选项 Ruby 一般是从命令行运行,方式如下: $ ruby [ options ] [.] [ programfile ] [ arguments ... ] 解释器可以通过下列选项 ...
- CCF CSP 201403-3 命令行选项
CCF计算机职业资格认证考试题解系列文章为meelo原创,请务必以链接形式注明本文地址 CCF CSP 201403-3 命令行选项 问题描述 请你写一个命令行分析程序,用以分析给定的命令行里包含哪些 ...
- CCF真题之命令行选项
201403-3 问题描述 请你写一个命令行分析程序,用以分析给定的命令行里包含哪些选项.每个命令行由若干个字符串组成,它们之间恰好由一个空格分隔.这些字符串中的第一个为该命令行工具的名字,由小写字母 ...
随机推荐
- fabric compose文件解读（Orderer篇）
orderer在fabric中的作用是排序,另外orderer有点像是管理节点一样,通道之类的都是在orderer的基础之上建立的,有点像比特币,以太坊上面的全节点一样,不过责任比全节点少很多,甚至都 ...
- 关于 CSDN 的恶臭嘴脸
我有段时间确实希望通过 CSDN 增加我文章的阅读量.但是我怎么使用 CSDN,我想要的大概也就 cnblogs 相对符合预期,CSDN 真是垃圾. 为了钱真是什么都不要了,让我们这种没有自主经济来源 ...
- C#.NET ASP.NET IIS 加载.pfx私钥证书时报错“出现了内部错误。”
C#.NET ASP.NET IIS 加载.pfx私钥证书时报错"出现了内部错误." 原始代码报错: X509Certificate2 x509cer = new X509Cert ...
- 透过 node-exporter 彻底弄懂机器监控：01. node-exporter 框架讲解
前言 Prometheus 生态里有很多采集器负责各类监控数据的采集,其中使用最广泛的,显然是 node-exporter,负责 Linux.BSD 等系统的常规监控指标的采集,比如 CPU.内存.硬 ...
- 20 套监控平台统一成 1 套 Flashcat，国泰君安监控选型提效之路
author:宋庆羽-国泰君安期货 运维工作最重要的就是维护系统的稳定性,其中监控是保证系统稳定性很重要的一环.通过监控可以了解系统的运行状态,及时发现问题和系统隐患,有助于一线人员快速解决问题,提高 ...
- PI规划会，研发团队价值聚焦的一剂良方
随着数字化建设如火如荼地推进,中大型企业的数字化建设团队规模也越来越大,团队规模的扩大一方面带来了更多产能与可能性,另一方面,不同的角色在不同的业务场景也带来了一些现实问题,例如: 作为CIO 或产品 ...
- 哎，被这个叫做at least once的玩意坑麻了。
你好呀,我是歪歪. 前几天遇到一个生产问题,同一个数据在数据库里面被插入了两次,导致后续处理出现了一些问题. 当时我们首先检讨了自己,没有做好幂等校验.甚至还发现了一个低级错误:对应的表,针对订单号, ...
- tempcode排序
package com.hsy;import com.alibaba.fastjson.JSON;import org.springframework.util.CollectionUtils;imp ...
- 苹果应用商店上传应用卡在了“Authenticating with the iTunes Store”
在终端中依次运行下面代码 cd ~ mv .itmstransporter/ .old_itmstransporter/ "/Applications/Xcode.app/Contents/ ...
- Java面试知识点（二）super 和 this 关键字
this this 是自身的一个对象,代表对象本身,可以理解为:指向对象本身的一个指针. this 的用法在 java 中大体可以分为 3 种: 普通的直接引用 这种就不用讲了,this 相当于是指向 ...