请各位大神帮忙看下我的代码哪里有问题

Christopher.

1003 我要通过！ (20 分)
“答案正确”是自动判题系统给出的最令人欢喜的回复。本题属于 PAT 的“答案正确”大派送 —— 只要读入的字符串满足下列条件，系统就输出“答案正确”，否则输出“答案错误”。

得到“答案正确”的条件是：

字符串中必须仅有 P、 A、 T这三种字符，不可以包含其它字符；
任意形如 xPATx 的字符串都可以获得“答案正确”，其中 x 或者是空字符串，或者是仅由字母 A 组成的字符串；
如果 aPbTc 是正确的，那么 aPbATca 也是正确的，其中 a、 b、 c 均或者是空字符串，或者是仅由字母 A 组成的字符串。
现在就请你为 PAT 写一个自动裁判程序，判定哪些字符串是可以获得“答案正确”的。

输入格式：
每个测试输入包含 1 个测试用例。第 1 行给出一个正整数 n (<10)，是需要检测的字符串个数。接下来每个字符串占一行，字符串长度不超过 100，且不包含空格。

输出格式：
每个字符串的检测结果占一行，如果该字符串可以获得“答案正确”，则输出 YES，否则输出 NO。

输入样例：
8
PAT
PAAT
AAPATAA
AAPAATAAAA
xPATx
PT
Whatever
APAAATAA
输出样例：
YES
YES
YES
YES
NO
NO
NO
NO



源代码
#include<stdio.h>

int main(void)
{
        int n;
        int i;
        int result[10] = {0};
    char ch;

        scanf("%d", &n);
    getchar();

        for (i = 0; i < n; i++)
        {
                int p = 0, t = 0, a = 0;
                int flag = 1;     //judge if p a t
                int count0 = 0, count1 = 0, count2 = 0;   //the number of A of different position
                int position = 0;       //the position of A,initial 0,front of P

                while ((ch = getchar()) != '\n')
                {
                        if (ch == 'P')
                        {
                                p++;
                                position = 1;   //A between P and T
                        }
                        else if (ch == 'T')
                        {
                                t++;
                                position = 2;   //A is back of T
                        }
                        else if (ch == 'A')
                        {
                                a++;
                        }
                        else
                        {
                                flag = 0;
                                break;
                        }

                        switch (position)
                        {
                        case 0:count0++; break;
                        case 1:if (ch != 'P') count1++; break;
                        case 2:if (ch != 'T') count2++; break;
                        }
                }

                if (flag && p==1 && t==1 && (a != 0) && (count0 * count1 == count2))
                {
                        result[i] = 1;
                }
        }

        for (i = 0; i < n; i++)
        {
                if (result[i])
                {
                        printf("YES\n");
                }
                else
                {
                        printf("NO\n");
                }
        }

        return 0;
}

我最后只能输入六个字符串，找了好半天不知道是哪里错了，麻烦各位大神帮忙debug一下

wp231957

上一贴你都没解释第⑤个和第八个为啥是错的
又重复发贴
告诉你，重复发贴不但没用，反而容易招来反感

Christopher.

wp231957 发表于 2021-5-2 07:03
上一贴你都没解释第⑤个和第八个为啥是错的
又重复发贴
告诉你，重复发贴不但没用，反而容易招来反感

大哥，我给你解释了啊，我说规律判断错了，具体解释的话就是正确的规律应该是，p之前的A*p和t之间的A=T后面的A的数量，才是正确的

wp231957

Christopher. 发表于 2021-5-2 17:28
大哥，我给你解释了啊，我说规律判断错了，具体解释的话就是正确的规律应该是，p之前的A*p和t之间的A=T后 ...

那这个为啥又正确呢
AAPAATAAAA

Christopher.

wp231957 发表于 2021-5-2 07:03
上一贴你都没解释第⑤个和第八个为啥是错的
又重复发贴
告诉你，重复发贴不但没用，反而容易招来反感

可能招你反感了，也可能是没有回答你的问题，抑或是说你也不知道这题是怎么回事，但是，你不想回答可以不回答，我也可以自己琢磨，没必要在这当圣母，你回不回答是你的权力，我回不回答你也同样是我的权利，请你有时间帮别人多看两道题，当然不用看我的，别在这当上帝

wp231957

Christopher. 发表于 2021-5-2 17:31
可能招你反感了，也可能是没有回答你的问题，抑或是说你也不知道这题是怎么回事，但是，你不想回答可以不 ...

你牛

Christopher.

wp231957 发表于 2021-5-2 17:31
那这个为啥又正确呢
AAPAATAAAA

2*2！=4？

Christopher.

Christopher. 发表于 2021-5-2 17:33
2*2！=4？

P前面有两个A，P,T中间有两个A，T后面有四个A，满足2*2=4

Christopher.

wp231957 发表于 2021-5-2 17:32
你牛

我是垃圾，也正因为我太垃圾，才会在这和你喋喋不休

人造人

这两行是怎么回事？

人造人

你的代码有两个语法问题，所以逻辑问题我就没有看
我自己写了一个给你参考

1. #include <stdio.h>
   
2. #include <stdbool.h>
   
3. #include <string.h>
   
4. 
   
5. bool a(int ch_next) {
   
6.     char ch;
   
7.     size_t count = 0;
   
8.     while(scanf("%c", &ch), ch == 'A') ++count;
   
9.     ungetc(ch, stdin);
   
10.     return ch == ch_next;
    
11. }
    
12. 
    
13. bool b(int ch_next) {
    
14.     char ch;
    
15.     size_t count = 0;
    
16.     while(scanf("%c", &ch), ch == 'A') ++count;
    
17.     ungetc(ch, stdin);
    
18.     return ch == ch_next;
    
19. }
    
20. 
    
21. bool c(int ch_next) {
    
22.     char ch;
    
23.     size_t count = 0;
    
24.     while(scanf("%c", &ch), ch == 'A') ++count;
    
25.     ungetc(ch, stdin);
    
26.     return ch == ch_next;
    
27. }
    
28. 
    
29. bool P(int ch_next) {
    
30.     char ch;
    
31.     size_t count = 0;
    
32.     while(scanf("%c", &ch), ch == 'P') ++count;
    
33.     ungetc(ch, stdin);
    
34.     return count == 1 ? (ch == ch_next) : false;
    
35. }
    
36. 
    
37. bool A(int ch_next) {
    
38.     char ch;
    
39.     size_t count = 0;
    
40.     while(scanf("%c", &ch), ch == 'A') ++count;
    
41.     ungetc(ch, stdin);
    
42.     return count == 1 ? (ch == ch_next) : false;
    
43. }
    
44. 
    
45. bool T(int ch_next) {
    
46.     char ch;
    
47.     size_t count = 0;
    
48.     while(scanf("%c", &ch), ch == 'T') ++count;
    
49.     ungetc(ch, stdin);
    
50.     return count == 1 ? (ch == ch_next) : false;
    
51. }
    
52. 
    
53. int main(void) {
    
54.     size_t n;
    
55.     char ch;
    
56.     scanf("%lu", &n);
    
57.     while(scanf("%c", &ch), ch != '\n');
    
58.     bool result[n];
    
59.     memset(result, false, sizeof(bool) * n);
    
60.     for(size_t i = 0; i < n; ++i) {
    
61.         if(a('T')) result[i] = true;
    
62.         if(P('A')) result[i] = true;
    
63.         if(b('A')) result[i] = true;
    
64.         if(A('T')) result[i] = true;
    
65.         if(T(-1)) result[i] = true;
    
66.         if(c(-1)) result[i] = true;
    
67.         if(a(-1)) result[i] = true;
    
68.         while(scanf("%c", &ch), ch != '\n');
    
69.     }
    
70.     for(size_t i = 0; i < n; ++i) {
    
71.         result[i] ? puts("YES") : puts("NO");
    
72.     }
    
73.     return 0;
    
74. }
    

复制代码

1. 8
   
2. PAT
   
3. PAAT
   
4. AAPATAA
   
5. AAPAATAAAA
   
6. xPATx
   
7. PT
   
8. Whatever
   
9. APAAATAA
   
10. YES
    
11. YES
    
12. YES
    
13. YES
    
14. NO
    
15. NO
    
16. NO
    
17. YES
    

复制代码

有一个问题，APAAATAA 这个为什么输出的是 NO
aPbATca 这个规则中的b可以是0个或多个A，应该输出YES吧？

人造人

我发现上面的代码有一个逻辑问题，不应该设置true，应该是默认true，设置false
这一次最后一个输出的是 NO，有点奇怪，我再研究研究

1. #include <stdio.h>
   
2. #include <stdbool.h>
   
3. #include <string.h>
   
4. 
   
5. bool a(int ch_next) {
   
6.     char ch;
   
7.     size_t count = 0;
   
8.     while(scanf("%c", &ch), ch == 'A') ++count;
   
9.     ungetc(ch, stdin);
   
10.     return ch == ch_next;
    
11. }
    
12. 
    
13. bool b(int ch_next) {
    
14.     char ch;
    
15.     size_t count = 0;
    
16.     while(scanf("%c", &ch), ch == 'A') ++count;
    
17.     ungetc(ch, stdin);
    
18.     return ch == ch_next;
    
19. }
    
20. 
    
21. bool c(int ch_next) {
    
22.     char ch;
    
23.     size_t count = 0;
    
24.     while(scanf("%c", &ch), ch == 'A') ++count;
    
25.     ungetc(ch, stdin);
    
26.     return ch == ch_next;
    
27. }
    
28. 
    
29. bool P(int ch_next) {
    
30.     char ch;
    
31.     size_t count = 0;
    
32.     while(scanf("%c", &ch), ch == 'P') ++count;
    
33.     ungetc(ch, stdin);
    
34.     return count == 1 ? (ch == ch_next) : false;
    
35. }
    
36. 
    
37. bool A(int ch_next) {
    
38.     char ch;
    
39.     size_t count = 0;
    
40.     while(scanf("%c", &ch), ch == 'A') ++count;
    
41.     ungetc(ch, stdin);
    
42.     return count == 1 ? (ch == ch_next) : false;
    
43. }
    
44. 
    
45. bool T(int ch_next) {
    
46.     char ch;
    
47.     size_t count = 0;
    
48.     while(scanf("%c", &ch), ch == 'T') ++count;
    
49.     ungetc(ch, stdin);
    
50.     return count == 1 ? (ch == ch_next) : false;
    
51. }
    
52. 
    
53. int main(void) {
    
54.     size_t n;
    
55.     char ch;
    
56.     scanf("%lu", &n);
    
57.     while(scanf("%c", &ch), ch != '\n');
    
58.     bool result[n];
    
59.     for(size_t i = 0; i < n; ++i) result[i] = true;
    
60.     for(size_t i = 0; i < n; ++i) {
    
61.         do {
    
62.             if((result[i] = a('T')) == false) break;
    
63.             if((result[i] = P('A')) == false) break;
    
64.             if((result[i] = b('A')) == false) break;
    
65.             if((result[i] = A('T')) == false) break;
    
66.             if((result[i] = T(EOF)) == false) break;
    
67.             if((result[i] = c(EOF)) == false) break;
    
68.             if((result[i] = a(EOF)) == false) break;
    
69.         } while(0);
    
70.         while(scanf("%c", &ch), ch != '\n');
    
71.     }
    
72.     for(size_t i = 0; i < n; ++i) {
    
73.         result[i] ? puts("YES") : puts("NO");
    
74.     }
    
75.     return 0;
    
76. }
    

复制代码

1. 8
   
2. PAT
   
3. PAAT
   
4. AAPATAA
   
5. AAPAATAAAA
   
6. xPATx
   
7. PT
   
8. Whatever
   
9. APAAATAA
   
10. NO
    
11. NO
    
12. NO
    
13. NO
    
14. NO
    
15. NO
    
16. NO
    
17. NO
    

复制代码

人造人

P和T中间有几个A？我的理解是1个或多个

Christopher.

人造人 发表于 2021-5-2 19:20
P和T中间有几个A？我的理解是1个或多个

要是前后都没有的A的话，可以有大于0个，你的理解是正确的

Christopher.

#include<stdio.h>

int main(void)
{
        int n;
        int i;
        int result[10] = {0};
    char ch;

        scanf("%d", &n);
    getchar();

        for (i = 0; i < n; i++)
        {
                int p = 0, t = 0, a = 0;
                int flag = 1;     //judge if p a t
                int count0 = 0, count1 = 0, count2 = 0;   //the number of A of different position
                int position = 0;       //the position of A,initial 0,front of P

                while ((ch = getchar()) != '\n')
                {
                        if (ch == 'P')
                        {
                                p++;
                                position = 1;   //A between P and T
                        }
                        else if (ch == 'T')
                        {
                                t++;
                                position = 2;   //A is back of T
                        }
                        else if (ch == 'A')
                        {
                                a++;
                        }
                        else
                        {
                                flag = 0;
                        }

                        switch (position)
                        {
                        case 0:count0++; break;
                        case 1:if (ch != 'P') count1++; break;
                        case 2:if (ch != 'T') count2++; break;
                        }
                }

                if (flag && p==1 && t==1 && (a != 0) && (count0 * count1 == count2))
                {
                        result[i] = 1;
                }
        }

        for (i = 0; i < n; i++)
        {
                if (result[i])
                {
                        printf("YES\n");
                }
                else
                {
                        printf("NO\n");
                }
        }

        return 0;
}

Christopher.

最后我改出来了，是flag判断的那个地方，不能有break，否则的话，跳出循环，后面输入的被视为下一组输入，表达能力有限，见谅见谅

Christopher.

人造人 发表于 2021-5-2 19:15
我发现上面的代码有一个逻辑问题，不应该设置true，应该是默认true，设置false
这一次最后一个输出的是 NO ...

谢谢你啦

Christopher.

人造人 发表于 2021-5-2 18:55
你的代码有两个语法问题，所以逻辑问题我就没有看
我自己写了一个给你参考

这个规律就是我上面说的那个，你可以把他给的例子带入，我的那个公式是完全符合的

Christopher.

人造人 发表于 2021-5-2 18:09
这两行是怎么回事？

抱歉，这个是笔误，不好意思(笑哭）

人造人

我也改完了，这是最终版本
具体实现思路可以参考编译原理中的递归下降分析算法

1. #include <stdio.h>
   
2. #include <stdbool.h>
   
3. #include <string.h>
   
4. 
   
5. /*
   
6. * aPbATca
   
7. * aPAbTc
   
8. * a: (first: ('A', '\0'), follow: ('P'))
   
9. * P: (first: ('P'), follow: ('A'))
   
10. * A: (first: ('A'), follow: ('A', 'T'))
    
11. * b: (first: ('A', '\0'), follow: ('T'))
    
12. * T: (first: ('T'), follow: ('A', '\n'))
    
13. * c: (first: ('A', '\0'), follow: ('\n'))
    
14. */
    
15. 
    
16. bool exist(int ch, int data[], size_t size) {
    
17.     for(size_t i = 0; i < size; ++i) {
    
18.         if(ch == data[i]) return true;
    
19.     }
    
20.     return false;
    
21. }
    
22. 
    
23. bool a(int first[], size_t first_size, int follow[], size_t follow_size, size_t depth) {
    
24.     int ch = getchar();
    
25.     if(exist(ch, first, first_size)) {
    
26.         return a(first, first_size, follow, follow_size, depth + 1);
    
27.     }
    
28.     if(depth == 0) {
    
29.         if(!exist('\0', first, first_size)) return false;
    
30.     }
    
31.     if(!exist(ch, follow, follow_size)) return false;
    
32.     ungetc(ch, stdin);
    
33.     return true;
    
34. }
    
35. 
    
36. bool P(int first[], size_t first_size, int follow[], size_t follow_size, size_t depth) {
    
37.     if(depth == 2) return false;
    
38.     int ch = getchar();
    
39.     if(exist(ch, first, first_size)) {
    
40.         return a(first, first_size, follow, follow_size, depth + 1);
    
41.     }
    
42.     if(depth == 0) {
    
43.         if(!exist('\0', first, first_size)) return false;
    
44.     }
    
45.     if(!exist(ch, follow, follow_size)) return false;
    
46.     ungetc(ch, stdin);
    
47.     return true;
    
48. }
    
49. 
    
50. bool A(int first[], size_t first_size, int follow[], size_t follow_size, size_t depth) {
    
51.     if(depth == 2) return false;
    
52.     int ch = getchar();
    
53.     if(exist(ch, first, first_size)) {
    
54.         return a(first, first_size, follow, follow_size, depth + 1);
    
55.     }
    
56.     if(depth == 0) {
    
57.         if(!exist('\0', first, first_size)) return false;
    
58.     }
    
59.     if(!exist(ch, follow, follow_size)) return false;
    
60.     ungetc(ch, stdin);
    
61.     return true;
    
62. }
    
63. 
    
64. bool b(int first[], size_t first_size, int follow[], size_t follow_size, size_t depth) {
    
65.     int ch = getchar();
    
66.     if(exist(ch, first, first_size)) {
    
67.         return a(first, first_size, follow, follow_size, depth + 1);
    
68.     }
    
69.     if(depth == 0) {
    
70.         if(!exist('\0', first, first_size)) return false;
    
71.     }
    
72.     if(!exist(ch, follow, follow_size)) return false;
    
73.     ungetc(ch, stdin);
    
74.     return true;
    
75. }
    
76. 
    
77. bool T(int first[], size_t first_size, int follow[], size_t follow_size, size_t depth) {
    
78.     if(depth == 2) return false;
    
79.     int ch = getchar();
    
80.     if(exist(ch, first, first_size)) {
    
81.         return a(first, first_size, follow, follow_size, depth + 1);
    
82.     }
    
83.     if(depth == 0) {
    
84.         if(!exist('\0', first, first_size)) return false;
    
85.     }
    
86.     if(!exist(ch, follow, follow_size)) return false;
    
87.     ungetc(ch, stdin);
    
88.     return true;
    
89. }
    
90. 
    
91. bool c(int first[], size_t first_size, int follow[], size_t follow_size, size_t depth) {
    
92.     int ch = getchar();
    
93.     if(exist(ch, first, first_size)) {
    
94.         return a(first, first_size, follow, follow_size, depth + 1);
    
95.     }
    
96.     if(depth == 0) {
    
97.         if(!exist('\0', first, first_size)) return false;
    
98.     }
    
99.     if(!exist(ch, follow, follow_size)) return false;
    
100.     ungetc(ch, stdin);
     
101.     return true;
     
102. }
     
103. 
     
104. int main(void) {
     
105.     size_t n;
     
106.     char ch;
     
107.     scanf("%lu", &n);
     
108.     while(scanf("%c", &ch), ch != '\n');
     
109.     bool result[n];
     
110.     for(size_t i = 0; i < n; ++i) result[i] = true;
     
111.     for(size_t i = 0; i < n; ++i) {
     
112.         do {
     
113.             if((result[i] = a((int []){'A', '\0'}, 2, (int []){'P'}, 1, 0)) == false) break;
     
114.             if((result[i] = P((int []){'P'}, 1, (int []){'A'}, 1, 0)) == false) break;
     
115.             if((result[i] = A((int []){'A'}, 1, (int []){'A', 'T'}, 2, 0)) == false) break;
     
116.             if((result[i] = b((int []){'A', '\0'}, 2, (int []){'T'}, 1, 0)) == false) break;
     
117.             if((result[i] = T((int []){'T', '\0'}, 2, (int []){'A', '\n'}, 2, 0)) == false) break;
     
118.             if((result[i] = c((int []){'A', '\0'}, 2, (int []){'\n'}, 1, 0)) == false) break;
     
119.         } while(0);
     
120.         while(scanf("%c", &ch), ch != '\n');
     
121.     }
     
122.     for(size_t i = 0; i < n; ++i) {
     
123.         result[i] ? puts("YES") : puts("NO");
     
124.     }
     
125.     return 0;
     
126. }
     

复制代码