七星不靠-研发

#include <iostream>
#include <set>
using namespace std;

int main() {
    int N;
    while(cin >> N){
        while(N--){
            int n = 7;
            set<string> st1;
            set<string> st2;
            set<string> st3;
            set<string> st4;
            set<string> st5;
            set<string> st6;
            while(n--){
                string str;
                cin >> str;
                if(str == "1W" || str == "4W" || str == "7W" || str == "2T" || str == "5T" || str == "8T" || str == "3B" || str == "6B" || str == "9B"){
                    st1.insert(str);
                }
                if(str == "1W" || str == "4W" || str == "7W" || str == "2B" || str == "5B" || str == "8B" || str == "3T" || str == "6T" || str == "9T"){
                    st2.insert(str);
                }
                if(str == "1T" || str == "4T" || str == "7T" || str == "2W" || str == "5W" || str == "8W" || str == "3B" || str == "6B" || str == "9B"){
                    st3.insert(str);
                }
                if(str == "1T" || str == "4T" || str == "7T" || str == "2B" || str == "5B" || str == "8B" || str == "3W" || str == "6W" || str == "9W"){
                    st4.insert(str);
                }
                if(str == "1B" || str == "4B" || str == "7B" || str == "2W" || str == "5W" || str == "8W" || str == "3T" || str == "6T" || str == "9T"){
                    st5.insert(str);
                }
                if(str == "1B" || str == "4B" || str == "7B" || str == "2T" || str == "5T" || str == "8T" || str == "3W" || str == "6W" || str == "9W"){
                    st6.insert(str);
                }
            }
            if(st1.size() < 7 && st2.size() < 7 && st3.size() < 7 && st4.size() < 7 && st5.size() < 7 && st6.size() < 7) cout << "NO" << endl;
            else cout << "YES" << endl;
        }
    }
    return 0;
}

T=int(input().strip())
for j in range(T):
    A=input().strip().split()
    unum=[]
    ualpha=[]
    for i in range(7):
        for j in range(2):
            if A[i][j]>='1' and A[i][j]<='9':
                if A[i][j] not in unum:
                    unum.append(A[i][j])
            else:
                if A[i][j] not in ualpha:
                    ualpha.append(A[i][j])
    if len(unum)>=7 and len(ualpha)>=3:
        print('YES')
    else:
        print('NO')

#include<iostream>
#include<unordered_map>
#include<vector>
#include<sstream>
#include<cmath>
using namespace std;

int main(){
    int n;
    cin >> n;
    cin.get();
    while(n){
        unordered_map<char, vector<int>> pai;
        int flag = 1;
        string line, word;
        getline(cin, line);
        stringstream ss;
        ss << line;
        while(ss >> word){
            pai[word[1]].push_back(word[0] - '0');
            if(pai[word[1]].size() > 3){
                flag = 0;
                break;
            }
        }
        if(flag){
            int tempflag = 0;
            for(auto &x : pai){
                int i = x.second[0] % 3;
                for(auto y : x.second){
                    if(y % 3 != i){
                        flag = 0;
                        break;
                    }
                }
                if(flag) tempflag += pow(2, i);
            }
            if(tempflag != 7)flag = 0;
        }
        if(flag) cout << "YES" << endl;
        else{
            cout << "NO" << endl;
        }
        --n;
    }
}

import java.util.*;

public class Main{
 public static void main(String []args){
        Scanner s=new Scanner(System.in);
        int len=s.nextInt();
        s.nextLine();

        String inNumber;
        Map<Character, ArrayList<Integer>> map=new HashMap<>();
        int i=0;
      
        while(i<len){
              String uu=s.nextLine();
            boolean chufuFlag=false;
            String[]hang=uu.split(" ");
            for(int j=0;j<hang.length;j++){
                inNumber=hang[j];
                if(inNumber.length()!=2){
                    chufuFlag=true;
                }
                if(!chufuFlag){
                    if(!map.containsKey(inNumber.charAt(1))){
                        map.put(inNumber.charAt(1),new ArrayList<>());
                    }
                    if(map.get(inNumber.charAt(1)).contains(Integer.parseInt(String.valueOf(inNumber.charAt(0))))){
                        chufuFlag=true;
                    }
                    map.get(inNumber.charAt(1)).add(Integer.parseInt(String.valueOf(inNumber.charAt(0))));
                }
            }
            i++;
            if(!chufuFlag){
                assertTrue(map);
            }else{
                System.out.println("NO");
            }
            map.clear();
        }
    }

    private static void assertTrue(Map<Character,ArrayList<Integer>> map){
        if(map.size()>3) {
            System.out.println("NO");
            return;
        }
        for(Map.Entry<Character,ArrayList<Integer>>entry:map.entrySet()){
            int count=0,flag=0;
            boolean flagRe=false;
            for(Integer num:entry.getValue()){
                if(count==0){
                    flag=num%3;
                }else{
                    if((num%3)!=flag){
                        System.out.println("NO");
                        return;
                    }
                }
                count++;
            }

        }
        System.out.println("YES");
    }

#include<bits/stdc++.h>
using namespace std;
int main() {
	int n;
	cin >> n;
	while (n--) {
		string s;
		set<char>w,t,b;
		for(int i=0;i<7;i++){
			cin>>s;
			if(s[1]=='W'){
				w.insert(s[0]);
			}
			else if(s[1]=='T'){
				t.insert(s[0]);
			}
			else{
				b.insert(s[0]);
			}
		}
		if(w.size()>3||w.size()>3||b.size()>3||w.size()+t.size()+b.size()<7)cout<<"NO"<<'\n';
		else cout<<"YES"<<'\n';
	}
	return 0;
}

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;

bool nodep(string s,int size){
        if(size == 1){
            return true;
        }else if(size == 2){
           return s[0]==s[1]?false:true;
        }else{
            if(s[0]==s[1]||s[1]==s[2]||s[2]==s[0]){
                return false;
            }else{
                return true;
            }
            
        }
    }

bool nocmm(string B,string T,string W){
    string con = B+T+W;
    sort(con.begin(),con.end());
    int low = 0;
    int fast = 1;
    while(fast<con.size()){
        if(con[low]==con[fast]){
            return false;
        }
        low++;
        fast++;
    }
    return true;
    
}
int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        string B = "";
        string T = "";
        string W = "";
        for(int k=0;k<7;k++){
            string temp="";
            cin>>temp;
            char nums = temp[0];
            if(temp.back()=='B'){
                B.push_back(nums);
            }else if(temp.back()=='T'){
                T.push_back(nums);
            }else{
                W.push_back(nums);
            }
        }
        //一组数据接收完成 数据接收正常
        int B_size = B.size();
        int T_size = T.size();
        int W_size = W.size();
        if(B_size>=4||B_size<=0||T_size>=4||T_size<=0||W_size>=4||W_size<=0){
            cout<<"NO"<<endl;
        }else{
            //不能有重复元素
            if(nodep(B,B_size)&&nodep(T,T_size)&&nodep(W,W_size)&&nocmm(B,T,W)){
                cout<<"YES"<<endl;
            }else{
                //cout<<"----";
                cout<<"NO"<<endl;
            }
             
        }
        
    }
    return 0;
}