1003. 我要通过！(20)

#include<stdio.h>
#include<string.h>
int main()
{
    char s[1001];
    int i,n,a,b,c;
    char *p;
    scanf("%d",&n); 
    for(i=0;i<n;i++)
    {
        scanf("%s",&s);
        if(!strcmp(s,"PAT")){printf("YES\n");continue;}   //条件一
 
                a=b=c=0;
                p=s;
                while(*p=='A'){a++;p++;}   //a为第一个p前a的个数
                if(*p=='P'){
                        p++;
                        while(*p=='A'){b++;p++;}   //b为夹在p和t之间的a的个数
                        if(*p=='T'){
                                p++;
                                while(*p=='A'){c++;p++;}   //c为t之后的a的个数
                                if(!(*p) && b>0 && c==a*b){printf("YES\n");continue;}  //条件三
                        }
                }
                printf("NO\n");
         
    }
    return 0;
}

def isOK(string):
    na = [0]*3; idx = 0; np = 0; nt = 0
    for i in string:
        if i == 'A':
            na[idx] += 1
        elif i == 'P':
            if np > 0:
                return False
            np += 1; idx += 1
        elif i == 'T':
            if np == 0 or nt > 0:
                return False    
            nt += 1; idx += 1
        else:
            return False
    if na[0]*na[1] == na[2] and na[1] > 0:
        return True
    return False

n = int(raw_input())
for i in range(n):
    string = raw_input().strip()
    if isOK(string):
        print('YES')
    else:
        print('NO') 

用正则匹配应该最简单了吧！

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        Pattern pattern = Pattern.compile("(A*)P(A+)T(A*)");
        boolean flag;
        while (n-- > 0) {
            String s = in.next();
            Matcher matcher = pattern.matcher(s);
            flag = matcher.matches()
                    && matcher.group(1).length() * matcher.group(2).length() == matcher.group(3).length();
            System.out.println(flag ? "YES" : "NO");
        }
    }
}

#include <iostream>
using namespace std;
int main(){
    char s[110];
    int n;cin>>n;
    while(n--){
        int str=0,aleft=0,amid=0,aright=0;
        cin>>s;
        for(int i=0;s[i];i++){
            if(s[i]=='P'&&str==0)            //P前面只能有A
                str=1;
            else if(s[i]=='A'){
                if(str==0) aleft++;         //统计P左边的A
                else if(str==1){            //统计P T中间的A
                    str=2;
                    amid++;
                }
                else if(str==2) amid++;
                else aright++;             //统计T右边的A
            }
            else if(s[i]=='T'&&str==2)     //T只能在A右边
                str=3;
            else break;
        }
        if(str==3 && aright==aleft*amid)   //中间有多少个A，右边就必须有多少倍左边A的数量
            cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
int main(){
	int N;
	while(cin>>N){
		for(int i=0;i<N;++i){
			string s;
			cin>>s;
			int sign = 0;
			int P = 0,PA = 0,PAT = 0;
			int Pi,Ai,Ti;
			map<char,bool>mp = {{'P',1},{'A',1},{'T',1}};
			for(int i=0;i<s.size();++i){
				if(!mp[s[i]])break;//不能包含其他字符
				if(s[i] == 'P'){
					Pi = i;
					P++;
				}
				if(s[i] == 'A'){
					if(!PAT)Ai = i;
					PA = P&1;
				}
				if(s[i] == 'T'){
					Ti = i;
					PAT = (PAT > 0)?PAT+1:PA&1;
				}
				if(P>1||PAT>1)break;//P、T数超过1
				if(PAT == 1&&i==s.size()-1){//满足条件1
					sign = 1;
					break;
				}
			}
			if(!sign){
				cout<<"NO"<<endl;
				continue;
			}
			string a,b,c;
			a = s.substr(0,Pi);
			b = s.substr(Pi+1,Ai-Pi-1);
			c = s.substr(Ti+1);
			if(a.size()*(b.size()+1) == c.size()){//满足条件2、3
				cout<<"YES"<<endl;
			}else cout<<"NO"<<endl;
		}
	}
}

#include<cstdio>
#include<cstring>


void isTrue(char b[]){
    int p = 0, a = 0, t = 0;    // 确定P,A,T各个字符的个数 
    int len, weip, weit;  
    len = strlen(b);
    for(int i = 0; i < len; i++){
        if(b[i] == 'P'){
            p++                                                        ;
            weip = i;             //确定字符P的位置 
        }
        if(b[i] == 'A') a++;
        if(b[i] == 'T') {        //确定字符T的位置 
            t++;
            weit = i;
        }
     }
     int zuo = weip, you = len - weit - 1;    //zuo，you分别为左侧与右侧A字符个数
     if(p + a +t == len && p == 1 && t == 1 && a != 0) {   // 确保只含有P，A，T，三个字符，且排除只含PT的情况 
         if(zuo == you && weit - weip - 1 == 1){    //条件1。 weit - weip - 1为夹在PT之间A的个数 
             printf("YES\n");
        }else if(zuo == 0){                          //为了确保下一个elseif不会出现分母为零的情况 
            if(you == 0)  printf("YES\n");    
            else printf("NO\n");
        }else if(you % zuo == 0 && weit - weip - 1 == you / zuo){  //条件3 
            printf("YES\n");
        }else{
            printf("NO\n");
        }
    }else{
        printf("NO\n");
    }
     
}

int main(){
    int n;
    char s[200] = "";
    scanf("%d", &n);
    for(int i = 0; i < n; i++){
        scanf("%s", s);
        isTrue(s);
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;

int main() {
	int n;
	cin>>n;
	while(n--) {
		string str;
		cin>>str;
		int loc_P,loc_T,other=0,numP=0,numT=0,m=str.size();
		for(int i=0; i<m; i++) {
			if(str[i]=='P') {
				numP++;
				loc_P=i;
			} else if(str[i]=='T') {
				numT++;
				loc_T=i;
			} else if(str[i]!='A') {
				other++;
			}
		}
		if(numP>1||numT>1||other>0||loc_T-loc_P<=1) {
			cout<<"NO"<<endl;
		} else {
			int x=loc_P,y=loc_T-loc_P-1,z=m-1-loc_T;
			if(z-(y-1)*x==x) {
				cout<<"YES"<<endl;
			} else {
				cout<<"NO"<<endl;
			}
		}
	}
	return 0;
}

#include<stdio.h>
#include<iostream>
using namespace std;

int main(){
    int i,n,len; string s;
    int count_x;//记录P之前A的数量
    int count_b;//记录PT中间A的数量
    int count_c;
    cin>>n;
    while(n--){
        cin>>s; len = s.length();
        count_x = 0; count_b = 0; count_c=0;
        for(i=0;i<len&&s[i]=='A';i++) count_x++;
        if(len==i||s[i]!='P') {cout<<"NO"<<endl;continue;}
        for(i=i+1;i<len&&s[i]=='A';i++) count_b++;
        if(len==i||s[i]!='T') {cout<<"NO"<<endl;continue;}
        for(i=i+1;i<len&&s[i]=='A';i++) count_c++;
        if(i<len) cout<<"NO"<<endl;
        else if(count_b>0&&count_b*count_x==count_c) cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
    }
    return 0;
}

import re


def judge(s: str):
    lt = list(s)
    l = [x for x in lt if x != 'P' and x != 'A' and x != 'T']
    if len(l) > 0:
        return False
    if s == 'PAT':
        return True
    if re.match('A*PATA*', s) is not None:
        t1, t2 = s.split("PAT")
        if t1 == t2:
            return True

    if re.match('A*PA*ATA*', s) is not None and len(s) > 3:
        num = s.find('P')
        lst = list(s[:len(s)-num])
        i_T = s.find('T')
        del lst[i_T - 1]
        t3 = "".join(lst)
        if judge(t3):
            return True
    return False


n = int(input())
for i in range(n):
    x = str(input())
    if judge(x):
        print("YES")
    else:
        print("NO")

这道题关键切入点是统计字符'P'、‘T'前后、中间的字符’A‘的个数。

首先由条件2 “xPATx”，x是空白字符串或者是由字符’A‘组成的字符串。
==总的来说就是"PAT"字符串的’A'字符数相等。==
形如“PAT”、“APATA”等都是正确的。

再看条件3，如果“aPbTc”是正确的，根据规则2可知b = ‘A'，a = c = x（x是空白字符串或者是由字符’A‘组成的字符串），那么aPbATca也是正确的，我们再递推一次得到aPbAATcaa，肯定也是正确的。

仔细对比“aPbTc”、aPbATca、aPbAATcaa，不难发现，当在b后面加一个字符'A'时，就得在c的后面增加一个a。

由于b = ’A'，==假设aPbATca字符串中P、T之间A的个数k，那么字符T之后的A个数是字符P之前A的个数的k倍。==

#include <iostream>
(720)#include <cstring>
using namespace std;

int main() {
    int n = 0;
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
        char str[101] = {'\0'};
        scanf("%s", str);
        //分别统计字符P之前、字符P与字符T之间、字符T之后的A字符个数
        int j = 0, beforeACount = 0, centerACount = 0, afterACount = 0, strLength = (int)strlen(str);
        //统计字符P之前的A字符个数
        while (j < strLength && str[j] == 'A') {
            j += 1;
            beforeACount += 1;
        }
        //如果没遇到字符P就到结尾，或者其他字符，该字符串都是错误的
        if (j >= strLength || str[j++] != 'P') {
            printf("NO\n");
            continue;
        }
        //统计字字符P与字符T之间的A字符个数
        while (j < strLength && str[j] == 'A') {
            j += 1;
            centerACount += 1;
        }
        //如果没遇到字符T就到结尾，或者其他字符，该字符串都是错误的
        if (j >= strLength || str[j++] != 'T') {
            printf("NO\n");
            continue;
        }
        //统计字符T之后的A字符个数
        while (j < strLength && str[j] == 'A') {
            j += 1;
            afterACount += 1;
        }
        //如果没有达到结尾，说明遇到了其他字符，如果字符P与字符T之间A字符数为0，也是错误的
        if (j != strLength || centerACount == 0) {
            printf("NO\n");
            continue;
        }
        //如果centerACount == 1，则beforeACount == afterACount
        //假设`aPbATca`字符串中P、T之间A的个数k，那么字符T之后的A个数是字符P之前A的个数的k倍。
        //如果centerACount > 1,则centerACount * beforeACount == afterACount
        //合并之后的条件就是判断 centerACount * beforeACount != afterACount
        if (centerACount * beforeACount != afterACount) {
            printf("NO\n");
            continue;
        }
        printf("YES\n");
    }
    return 0;
}
————————————————
版权声明：本文为CSDN博主「hestyle」的原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://hestyle.blog.csdn.net/article/details/104753529

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
/**
 * 1. 字符串中必须仅有P, A, T这三种字符，不可以包含其它字符；
 * 2. 任意形如 xPATx 的字符串都可以获得“答案正确”，其中 x 或者是空字符串，或者是仅由字母 A 组成的字符串；
 * 3. 如果 aPbTc 是正确的，那么 aPbATca 也是正确的，其中 a, b, c 均或者是空字符串，或者是仅由字母 A 组成的字符串。
 **/
 
////A(m)PA(i)TA(m*i)
int main()
{
    int n;
    while(~scanf("%d", &n))
    {
        for(int z = 0; z < n; z++)
        {
            char pat[100];
            scanf("%s", pat);
            int count1 = 0, count2 = 0, count3 = 0;
            int c1_end = 0, c2_end = 0;
            int j = 0;
            int tj = 1;
            while(pat[j] != '\0')
            {
                if(pat[j] != 'P' && pat[j] != 'A' && pat[j] != 'T')
                {
                    tj = 0;
                    break;
                }
                j++;
            }
            if(!tj)
            {
                printf("NO\n");
                continue;
            }
            //只有pat三个字母，tj = 1
            j = 0;
            int p_count = 0, t_count = 0;
            while(pat[j] != '\0')
            {
                if(p_count < t_count || p_count > 1 || t_count > 1)
                {
                    tj = 0;
                    break;
                }
                if(pat[j] == 'P')
                    p_count++;
                else if(pat[j] == 'T')
                    t_count++;
                j++;
            }
            if(!tj || p_count != 1 || t_count != 1)
            {
                printf("NO\n");
                continue;
            }
            //p和t只有一个，且p在t前， tj = 1
            j = 0;
            while(pat[j] != '\0')
            {
                if(pat[j] == 'P')
                    c1_end = 1;//第一坨A计数完毕
                else if(pat[j] == 'T')
                    c2_end = 1;//第二坨A计数完毕
                else if(pat[j] == 'A')
                {
                    if(c1_end == 0)
                    {
                        count1++;
                    }
                    else if(c2_end == 0)
                    {
                        count2++;
                    }
                    else
                    {
                        count3++;
                    }
                }
                j++;
            }
            if(count3 == count1 * count2 && count2 != 0)
                printf("YES\n");
            else
                printf("NO\n");
        }
    }
    return 0;
}

• 贴个C++ 的regex
  (a)P(b)T(c)
  子匹配(b)每增加一个A，
  子匹配(c)增加len(a)个A，

  #include<bits/stdc++.h>
  using namespace std;
  int main()
  {
  ios::sync_with_stdio(0);
  int n;
  string t = "";
  regex e("(A*)P(A+)T(A*)");
  cin >> n;
  cin.ignore();
  for(int i = 0; i < n; i++)
  {
      cmatch cm;
      getline(cin, t);
      if(regex_match(t.c_str(), cm, e, regex_constants::match_default))
      {
          if(cm[2].length()>0 && cm[1].length()*cm[2].length()==cm[3].length())
              puts("YES");
          else
              puts("NO");
      }
      else
          puts("NO");
  }
  return 0;
  }
  

```