Problem:
Problem C:
ラミー
あなたの友達は最近 UT-Rummy というカードゲームを思いついた．
このゲームで使うカードには赤・緑・青のいずれかの色と1から9までのいずれかの番号が
    つけられている．
    このゲームのプレイヤーはそれぞれ9枚の手札を持ち，
    自分のターンに手札から1枚選んで捨てて，
    代わりに山札から1枚引いてくるということを繰り返す．
    このように順番にターンを進めていき，
    最初に手持ちのカードに3枚ずつ3つの「セット」を作ったプレイヤーが勝ちとなる．
    セットとは，同じ色の3枚のカードからなる組で，すべて同じ数を持っているか
    連番をなしているもののことを言う．
    連番に関しては，番号の巡回は認められない．
    例えば，7, 8, 9は連番であるが 9, 1, 2は連番ではない．
あなたの友達はこのゲームをコンピュータゲームとして売り出すという計画を立てて，
    その一環としてあなたに勝利条件の判定部分を作成して欲しいと頼んできた．
    あなたの仕事は，手札が勝利条件を満たしているかどうかを判定する
    プログラムを書くことである．
Input
入力の1行目にはデータセット数を表す数
T
(0 <
T
≤ 50) が与えられる．
    この行に引き続き
T
個のデータセットが与えられる．
各データセットは2行からなり，
    1行目には
i
番目
    (
i
= 1, 2, ..., 9)
    のカードの数字
n
i
がそれぞれスペースで区切られて与えられ，
    2行目には
i
番目のカードの色を表す文字
c
i
がそれぞれスペースで区切られて与えられる．
    カードの数字
n
i
は 1 ≤
n
i
≤ 9
    を満たす整数であり，
    カードの色
c
i
はそれぞれ “
R
”, “
G
”,
    “
B
”
    のいずれかの文字である．
1つのデータセット内に色と数字がともに同じカードが5枚以上出現することはない．
Output
各データセットにつき，勝利条件を満たしていれば
    “
1
”，
    そうでなければ “
0
” と出力せよ．
Sample Input
5
1 2 3 3 4 5 7 7 7
R R R R R R G G G
1 2 2 3 4 4 4 4 5
R R R R R R R R R
1 2 3 4 4 4 5 5 5
R R B R R R R R R
1 1 1 3 4 5 6 6 6
R R B G G G R R R
2 2 2 3 3 3 1 1 1
R G B R G B R G B
Output for the Sample Input
1
0
0
0
1

Submitted solutions:

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

using P = pair<int, char>;

int main() {
    int n;
    cin >> n;
    while(n--) {
        vector<P> v(9);
        for(int i=0; i<9; ++i) {
            cin >> v[i].first;
        }
        for(int i=0; i<9; ++i) {
            cin >> v[i].second;
        }
        sort(v.begin(), v.end());
        bool ok = false;
        do {
            bool f = true;
            for(int i=0; i<3; ++i) {
                if(v[3*i].second != v[3*i+1].second || v[3*i].second != v[3*i+2].second || v[3*i+1].second != v[3*i+2].second) {
                    f = false;
                }
                int t1 = v[3*i+1].first - v[3*i].first;
                int t2 = v[3*i+2].first - v[3*i+1].first;
                if((t1 != 0 || t2 != 0) && (t2 != 1 || t1 != 1)) {
                    f = false;
                }
            }
            ok |= f;
        } while(next_permutation(v.begin(), v.end()));
        cout << ok << endl;
    }
}
accuracy: 1
time_ms: 90
memory_kb: 3340
final_rank: 15

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>

using namespace std;


#if 0
-コマンド
./a.out
5
1 2 3 3 4 5 7 7 7
R R R R R R G G G
1
1 2 2 3 4 4 4 4 5
R R R R R R R R R
0
1 2 3 4 4 4 5 5 5
R R B R R R R R R
0
1 1 1 3 4 5 6 6 6
R R B G G G R R R
0
2 2 2 3 3 3 1 1 1
R G B R G B R G B
1


#endif

bool is_same_number(int a,int b,int c){
    return a == b && b == c;
}

bool is_sequence(int a,int b,int c){
    return a+1  == b && b+1 == c;
}

bool is_good_set(int a,int b,int c){
    return is_same_number(a,b,c) || is_sequence(a,b,c);
}


bool solve(vector<int>& cards){
    sort(cards.begin(),cards.end());
    do {
        if (is_good_set(cards[0], cards[1], cards[2]) &&
            is_good_set(cards[3], cards[4], cards[5]) &&
            is_good_set(cards[6], cards[7], cards[8])) {
            return true;
        }
    } while (next_permutation(cards.begin(), cards.end()));
    return false;

}

int main(){
    vector<int> colors(256, 0);
    colors['R'] = 0;
    colors['G'] = 20;
    colors['B'] = 40;

    int T;
    cin >> T;
    vector<int> cards(9);

    for(int t=0; t<T; ++t){
        for(int i=0; i<9;++i) cin >> cards[i];
        char c;
        for(int i=0;i<9;++i) cin >> c,cards[i] += colors[c];
        //vector<int> pure_numbers(9);
        //for (int i = 0; i < 9; ++i) {
        //    pure_numbers[i] = cards[i] % 10; 
        //}

        cout << (solve(cards) ? '1' : '0') << endl;
    }

    return 0;

}
accuracy: 1
time_ms: 10
memory_kb: 3428
final_rank: 14

code_snippet: #include<bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<n;i++)
#define all(a) a.begin(),a.end()
using namespace std;
typedef long long ll;

int solve(vector<int>&num, vector<char>&color){
    vector<int>p;
    rep(i,9)p.push_back(i);
    do{
        int flg=0;
        for(int i=0;i<9;i+=3){
            if(!(color[p[i]]==color[p[i+1]]&&color[p[i+1]]==color[p[i+2]])){
                flg++;
            }
            if(!((num[p[i+1]]-num[p[i]]==1&&num[p[i+2]]-num[p[i+1]]==1)||(num[p[i+1]]==num[p[i]]&&num[p[i+2]]==num[p[i+1]]))){
                flg++;
            }
        }
        if(!flg){
            return 1;
        }
    }while(next_permutation(all(p)));
    return 0;
}

int main(){
    int T;cin>>T;
    while(T){
        T--;
        vector<int>num(9);
        vector<char>color(9);
        rep(i,9)cin>>num[i];
        rep(i,9)cin>>color[i];
        cout<<solve(num,color)<<endl;
    }

}
accuracy: 1
time_ms: 130
memory_kb: 3052
final_rank: 13

code_snippet: //#pragma GCC optimize(2)
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define N 200005
//#define mod 998244353
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define ld long double
#define ls (rt<<1)
#define rs ((rt<<1)|1)
#define SZ(x) (int)(x.size())
#define debug cout<<endl<<"ff"<<endl
#define YES cout<<"YES"<<endl
#define NO cout<<"NO"<<endl
#define fi first
#define se second
#define INF 1e9
#define pq priority_queue
#define rep(x,a,b) for(int x=a;x<=b;x++)
/*int qpow(int a,int b){
	int res=1;
	for(;b;b>>=1){
		if(b&1) res=res*a%mod;
		a=a*a%mod;
	}
	return res;
}
int fac[N],ifac[N];
int C(int n,int m){
	if(m>n||m<0||n<0) return 0;
	return fac[n]*ifac[n-m]%mod*ifac[m]%mod;
}
void init(){
	fac[0]=1;
	for(int i=1;i<N;i++) fac[i]=fac[i-1]*i%mod;
	ifac[N-1]=qpow(fac[N-1],mod-2);
	for(int i=N-2;i>=0;i--) ifac[i]=ifac[i+1]*(i+1)%mod;
}*/
/*struct node{
	int nxt,to;
}e[N<<1];
int cnt,head[N];
inline void add(int x,int y){
	e[++cnt].nxt=head[x];
	head[x]=cnt;
	e[cnt].to=y;
}*/
inline int lowbit(int x){return x&(-x);}
inline int read(){
    int x=0,t=1;char ch=getchar();
    while(ch<'0'||ch>'9'){
        if(ch=='-') t=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9'){
        x=(x<<1)+(x<<3)+(ch-'0');
        ch=getchar();
    }
    return x*t;
}
inline void write(int x){
	if(x<0) putchar('-'),x=-x;
	if(x>=10) write(x/10);
	putchar(x%10+'0');
}
int T,n,a[N],c[N],p[N],t[N];
signed main(){
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	cin>>T;
	p[0]=1;
	for(int i=1;i<=8;i++) p[i]=p[i-1]*3;
	while(T--){
		for(int i=1;i<=9;i++) cin>>a[i];
		for(int i=1;i<=9;i++){
			char t;cin>>t;
			if(t=='G') c[i]=1;
			else if(t=='B') c[i]=2;
			else c[i]=0;
		}
		int siz[4],fl=0;
		vector<int>y[4],col[4];
		for(int i=0;i<(p[8]*3);i++){
			memset(siz,0,sizeof(siz));
			for(int j=0;j<=2;j++) col[j].clear(),y[j].clear();
			for(int j=0;j<=8;j++) t[j]=(i/p[j])%3,siz[t[j]]++,y[t[j]].pb(a[j+1]),col[t[j]].pb(c[j+1]);
			int bj=0;
			for(int j=0;j<=2;j++) if(siz[j]!=3) bj=1;
			if(bj) continue;
			for(int j=0;j<=2;j++) sort(y[j].begin(),y[j].end());
			for(int j=0;j<=2;j++){
				for(int k=1;k<3;k++)
					if(col[j][k]!=col[j][k-1]){
						bj=1;
						break;
					}
				if((!(y[j][2]==y[j][1]&&y[j][1]==y[j][0]))&&(!(y[j][2]==y[j][1]+1&&y[j][1]==y[j][0]+1))) bj=1;
			}
			if(!bj){
				fl=1;
				break;
			}
		}
		cout<<fl<<endl;
	} 
	return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 7548
final_rank: 19

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <queue>
#include <set>
#include <cmath>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)

template<class T>
using vi = vector<T>;

template<class T>
using vii = vector<vi<T>>;

template<class T>
using viii = vector<vii<T>>;

const int mx = 9;
int num[mx], suit[mx];

bool calc(vi<int> &rot, int idx) {
    rep(i, 2) {
        if (suit[rot[idx + i]] != suit[rot[idx + i + 1]]) return false;
    }

    vi<int> d(3);
    rep(i, 3) d[i] = num[rot[idx + i]];
    sort(d.begin(), d.end());
    if (d[0] == d[1] && d[1] == d[2]) return true;
    if (d[0] + 1 == d[1] && d[1] + 1 == d[2]) return true;
    return false;
}

int main()
{
    std::cin.tie(nullptr);
    std::ios_base::sync_with_stdio(false);
    int t;
    cin >> t;
    while (t--) {
        rep(i, mx) cin >> num[i];
        rep(i, mx) {
            char c;
            cin >> c;
            if (c == 'R') suit[i] = 0;
            else if (c == 'G') suit[i] = 1;
            else if (c == 'B') suit[i] = 2;
        }

        vi<int> rot(mx);
        rep(i, mx) rot[i] = i;
        bool ng = false;

        rep(idx, 3) {
            int cnt = 0;
            rep(i, mx) if (suit[i] == idx) cnt++;
            if (cnt % 3) ng = true;
        }
        if (ng) {
            cout << 0 << endl;
            continue;
        }

        ng = true;
        do {
            bool check = true;
            for (int idx = 0; idx < mx; idx += 3) {
                if (calc(rot, idx)) continue;
                check = false;
            }
            if (check) {
                ng = false;
                break;
            }
        } while (next_permutation(rot.begin(), rot.end()));
        cout << (ng ? 0 : 1) << endl;
    }
    
    return 0;
}
accuracy: 1
time_ms: 260
memory_kb: 3392
final_rank: 17

code_snippet: #include <bits/stdc++.h>
using namespace std;
typedef pair<int, char> P;
int t;


bool is_same_color(P a, P b, P c){
    return a.second == b.second && b.second == c.second;
}
bool is_same_number(P a, P b, P c){
    return is_same_color(a,b,c) && a.first == b.first && b.first == c.first;
}
bool is_sequence(P a, P b, P c){
    return is_same_color(a,b,c) && a.first + 1 == b.first && b.first + 1 == c.first;
}
bool is_good_set(P a, P b, P c){
    return is_same_number(a,b,c) || is_sequence(a,b,c);
}
int main(){
    cin >> t;
    for(int test = 0; test < t; test++){
        vector <P> v(9);
        for(int i = 0; i < 9; i++){
            int x;
            cin >> x;
            v[i].first = x;
        }
        for(int i = 0; i < 9; i++){
            char c;
            cin >> c;
            v[i].second = c;
        }
        vector <int> a(9);
        for(int i = 0; i < 9; i++)a[i] = i;
        bool flag = false;
        do{
            bool f = true;
            f &= is_good_set(v[a[0]],v[a[1]],v[a[2]]);
            f &= is_good_set(v[a[3]],v[a[4]],v[a[5]]);
            f &= is_good_set(v[a[6]],v[a[7]],v[a[8]]);
            if(f){
                flag = true;
                cout << 1 << endl;
                break;
            }

        }while(next_permutation(a.begin(),a.end()));
        if(!flag)cout << 0 << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 100
memory_kb: 3096
final_rank: 12

code_snippet: /**
 *  author: hanyu
**/
#include <bits/stdc++.h>
using namespace std;

int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);

  int t;
  cin >> t;
  int n = 9;

  while (t--) {
    vector<pair<int, char>> x(n);
    for (int i = 0; i < n; i++) cin >> x[i].first;
    for (int i = 0; i < n; i++) cin >> x[i].second;
    sort(x.begin(), x.end());

    bool ok = false;
    do {
      vector<int> y(n);
      vector<char> z(n);
      for (int i = 0; i < n; i++) y[i] = x[i].first;
      for (int i = 0; i < n; i++) z[i] = x[i].second;
      bool ok2 = true;
      for (int i = 0; i <= 6; i += 3) {
        sort(y.begin() + i, y.begin() + i + 3);
        if (!(y[i] == y[i + 2] || (y[i] + 1 == y[i + 1] && y[i + 1] + 1 == y[i + 2]))) ok2 = false;
        sort(z.begin() + i, z.begin() + i + 3);
        if (z[i] != z[i + 2]) ok2 = false;
      }
      if (ok2) {
        ok = true;
        break;
      }
    } while (next_permutation(x.begin(), x.end()));

    cout << ok << '\n';
  }
}
accuracy: 1
time_ms: 410
memory_kb: 3364
final_rank: 18

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

int main ()
{
     int t, mentu;
     string s;
     cin >> t;
     bool isMentu(int, int, int);
          int a[9] = {};
     for (int i = 0; i < t; i++)
     {
          for (int j = 0; j < 9; j++)
          {
               cin >> a[j];
          }
          for (int j = 0; j < 9; j++)
          {
               cin >> s;
               if (s == "G") a[j] += 10;
               else if (s == "B") a[j] += 20;
          }
          sort(a, a + 9);
          do {
               mentu = isMentu(a[0], a[1], a[2]) &&
                       isMentu(a[3], a[4], a[5]) &&
                       isMentu(a[6], a[7], a[8]);
               if (mentu) break;
          } while (next_permutation(a, a + 9));
          cout << mentu << endl;
     }    
}

bool isMentu(int a, int b, int c) {
     return (a == b && b == c) || ((a + 1) == b && (b + 1) == c);
}
accuracy: 1
time_ms: 10
memory_kb: 3128
final_rank: 7

code_snippet: #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
using ll =  long long ;
using P = pair<int,int> ;
const int INF = 1e9;
const int MOD = 1000000007;

vector<int> num(9);
vector<char> color(9);

bool ok(int i,int j,int k){
    if(color[i] != color[j] || color[j] != color[k]) return false;
    if(num[i] == num[j] && num[j] == num[k]) return true;
    if(num[i]+2 == num[j]+1 && num[j]+1 == num[k]) return true;
    return false;
}


int main(){
    int t;
    cin >> t;
    vector<int> idx(9);
    iota(idx.begin(),idx.end(),0);
    while(t--){
        bool ans = false;
        rep(i,9) cin >> num[i];
        rep(i,9) cin >> color[i];
        do{
            bool res = true;
            rep(i,3){
                res = res && ok(idx[i*3],idx[3*i+1],idx[3*i+2]);
            }
            ans = ans || res;
        }while(next_permutation(idx.begin(),idx.end()));
        cout << (ans ? 1 : 0 ) << endl;
    }
    return 0;
}

/*
Rummy
できるだけ関数化しようと思って連番または全て同じ番号になっているものかどうかを判定する関数を作ろうと思った。
結局ok関数の中身は汚くなったので全体としてはわかりやすくなったと思う。
*/
accuracy: 1
time_ms: 90
memory_kb: 3056
final_rank: 11

code_snippet: #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
using ll =  long long ;
using P = pair<int,int> ;
const int INF = 1e9;
const int MOD = 1000000007;

vector<int> num(9);
vector<char> color(9);

bool ok(int i,int j,int k){
    if(color[i] != color[j] || color[j] != color[k]) return false;
    if(num[i] == num[j] && num[j] == num[k]) return true;
    vector<int> now = {num[i],num[j], num[k]};
    sort(now.begin(),now.end());
    if(now[2] - now[1] == 1 && now[1] - now[0] == 1) return true;
    return false;
}


int main(){
    int t;
    cin >> t;
    vector<int> idx(9);
    iota(idx.begin(),idx.end(),0);
    while(t--){
        bool ans = false;
        rep(i,9) cin >> num[i];
        rep(i,9) cin >> color[i];
        do{
            bool res = true;
            rep(i,3){
                res = res && ok(idx[i*3],idx[3*i+1],idx[3*i+2]);
            }
            ans = ans || res;
        }while(next_permutation(idx.begin(),idx.end()));
        cout << (ans ? 1 : 0 ) << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 310
memory_kb: 3084
final_rank: 16

code_snippet: // 問題名:　Square Route
// URL: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2015&lang=jp
// 所要時間: 20分
// --感想--
// intの配列は今までfor文を用いて1個ずつ0を代入して初期化していたので、今後は"= {}"などを用いて簡略化するようにしたい。

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

int main(){
    int T;
    cin >> T;
    for (; T > 0; T--){
        int n[11];
        char c[11];
        for (int i = 0; i < 9;i++)
            cin >> n[i];
        for (int i = 0; i < 9; i++)
            cin >> c[i];
        pair<int,char> card[11];
        for (int i = 0; i < 9;i++)
            card[i] = make_pair(n[i], c[i]);
        sort(card, card + 9);
        int ans = 0;
        // 勝てる手札なら、左から綺麗に3セット並ぶような並べ方が存在する
        do{
            bool flag = true;
            for (int i = 0; i < 3;i++){
                // カードの色が違う
                if (card[i * 3].second != card[i * 3 + 1].second || card[i * 3 + 1].second != card[i * 3 + 2].second)
                    flag = false;
                // 連番や同じ数字でない
                if (!((card[i * 3].first == card[i * 3 + 1].first && card[i * 3 + 1].first == card[i * 3 + 2].first)
                    ||(card[i * 3].first + 1 == card[i * 3 + 1].first && card[i * 3 + 1].first + 1 == card[i * 3 + 2].first)))
                    flag = false;
            }
            if(flag)
                ans = 1;
        } while (next_permutation(card, card + 9));
        cout << ans << endl;
    }
}
accuracy: 1
time_ms: 90
memory_kb: 3004
final_rank: 9

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

int n[10];
char c[10];

bool check(vector<pair<int,char>> v){
    for (int i=0;i<2;++i)
        if (v[i+1].second!=v[i].second)
            return false;
    if (v[0].first==v[1].first&&v[1].first==v[2].first) return true;
    for (int i=0;i<2;++i)
        if (v[i+1].first-v[i].first!=1)
            return false;
    return true;
}

void solve(){
    bool ans=false;
    vector<int> perm(9);
    iota(perm.begin(),perm.end(),0);
    do {
        for (int i=0;i<3;++i){
            vector<pair<int,char>> v;
            for (int j=0;j<3;++j)
                v.emplace_back(n[perm[3*i+j]],c[perm[3*i+j]]);
            sort(v.begin(),v.end());
            if (!check(v)) break;
            if (i==2) ans=true;
        }
    } while(next_permutation(perm.begin(),perm.end()));
    cout << (ans?1:0) << '\n';
}

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    int T; cin >> T;
    for (;T--;){
        for (int i=0;i<9;++i) cin >> n[i];
        for (int i=0;i<9;++i) cin >> c[i];
        solve();
    }
}
accuracy: 1
time_ms: 2020
memory_kb: 3124
final_rank: 20

code_snippet: #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

bool is_good_set(int a, int b, int c) {
    auto is_same_card = [](int a, int b, int c) {
        return a == b and b == c;
    };
    auto is_sequence = [](int a, int b, int c) {
        return a + 1 == b and b + 1 == c;
    };
    return is_same_card(a, b, c) or is_sequence(a, b, c);
}

bool is_all_good_set(vector<int> &cc) {
    return is_good_set(cc[0], cc[1], cc[2])
        && is_good_set(cc[3], cc[4], cc[5])
        && is_good_set(cc[6], cc[7], cc[8]);
}

int win(vector<int> &cards) {
    sort(cards.begin(), cards.end());
    do {
        if (is_all_good_set(cards)) return 1;
    } while (next_permutation(cards.begin(), cards.end()));
    return 0;
}

int main() {
    int T; cin >> T;
    while (T--) {
        vector<int> cards(9);
        for (auto &card: cards) cin >> card;
        for (auto &card: cards) {
            string color; cin >> color;
            if (color == "G") card += 10;
            if (color == "B") card += 20;
        }
        cout << win(cards) << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3028
final_rank: 3

code_snippet: #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0;i < n;i++)
#define repr(i, n) for(int i = n;i >= 0;i--)
#define frep(i, m, n) for(int i = m;i < n;i++)
#define frepr(i, m, n) for(int i = m;i >= n;i--)
#define vsort(v) sort(v.begin(),v.end())
#define ll long long
#define inf 999999999
typedef vector<vector<int>> vvi;
typedef vector<int> vi;
typedef vector<string> vst;
typedef pair<int,int> P;
typedef pair<ll,ll> LP;
typedef pair<int,P> PP;
typedef pair<ll,LP> LPP;

int change(char color){
    switch(color){
        case 'R':return 0;break;
        case 'G':return 10;break;
        case 'B':return 20;break;
        default:return 30;break;
    }
}

int main(){
    int t;
    while(cin >> t && t!=0){
        rep(i,t){
            vi card(9,0);
            int cl=0;
            rep(j,9){
                cin >> card[j];
            }
            rep(j,9){
                char color;
                cin >> color;
                card[j]+=change(color);
            }
            vsort(card);
            do {
                // cout << "card:";
                // rep(j,9){
                //     cout << card[j] << ",";
                // }
                int f=0;
                rep(j,3){
                    if(card[j*3]/10==card[j*3+1]/10 && card[j*3+2]/10==card[j*3+1]/10){
                        if((card[j*3]==card[j*3+1] && card[j*3+2]==card[j*3+1])||(card[j*3]+1==card[j*3+1] && card[j*3+2]==card[j*3+1]+1)){
                            f++;
                        }
                    }
                }
                if(f==3){
                    cl=1;
                    break;
                }
                // cout << "    f:" << f << endl;
            } while (next_permutation(card.begin(),card.end()));
            cout << cl << endl;
        }
    }

    return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3028
final_rank: 4

code_snippet: #include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int T, card[16];

bool is_same_number(int a, int b, int c){
  return (a == b && b == c);
}

bool is_sequence(int a, int b, int c){
  return (a + 2 == c && a + 1 == b);
}

bool is_good_set(int a, int b, int c){
  return is_same_number(a, b, c) || is_sequence(a, b, c);
}

bool is_all_good_set(int a[]){
  return is_good_set(a[0], a[1], a[2]) && is_good_set(a[3], a[4], a[5]) && is_good_set(a[6], a[7], a[8]);
}

int win(int a[]){
  sort(a, a+9);
  do {
    if (is_all_good_set(a)) return 1;
  } while (next_permutation(a, a+9));
  return 0;
}

int main(){
  cin >> T;
  for (int t=0; t<T; ++t){

    for (int i = 0; i<9; i++){
      cin >> card[i];
    }

    string color;
    for (int i = 0; i < 9; i++){
      cin >> color;
      if (color == "G") card[i] += 10;
      else if (color == "B") card[i] += 20;
    }

    cout << win(card) << endl;

  }

  return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3176
final_rank: 10

code_snippet: #include <iostream>
#include <algorithm>
#include <string>
using namespace std;

int T, card[10];

bool is_same_number(int a, int b, int c){
    //同色同数値かどうか
    if(a == b && a == c) return true;
    else return false;
}
bool is_sequence(int a, int b, int c){
    //同色連番かどうか
    if(a + 2 == c && b + 1 == c) return true;
    else return false;
}
bool is_good_set(int a, int b, int c){
    //同色同数値である　または　同色連番である
    return ((is_same_number(a, b, c))|| is_sequence(a, b, c));
}
bool is_all_good_set(){
    //勝利状態の判定
    return is_good_set(card[0], card[1], card[2]) && is_good_set(card[3], card[4], card[5]) && is_good_set(card[6], card[7], card[8]);
}
int win(){
        sort(card, card + 9);
        do{
            if(is_all_good_set()) return 1;
        }while(next_permutation(card, card + 9));
        return 0;
    }
int main(){
    //cout << is_same_number(3, 4, 5) << endl;
    //cout << is_sequence(3, 4, 5) << endl;
    cin >> T;

    //入力の処理
    for(int i = 0; i < T; i++){
        for(int j = 0; j < 9; j++){
            cin >> card[j];
        }
        string color;
        for(int j = 0; j < 9; j++){
            cin >> color;
            /*各カードは色と数の２つの情報の組み合わせなので、
            これを整数で表現するための処理*/
            if(color == "G") card[j] += 10;
            else if(color == "B") card[j] += 20;
        }
        cout << win() << endl; 
    }
}
accuracy: 1
time_ms: 20
memory_kb: 3052
final_rank: 5

code_snippet: #include <bits/stdc++.h>
using namespace std;
#define int long long
bool f;
int n, i, j;
int card[9];

bool judge (int a, int b, int c){
        if (a == b && b == c) return true;
        else if (a + 1 == b && a + 2 == c) return true;
        return false;
}
int win(){
        sort(card, card + 9);
        do{
                f = 1;
                f = judge(card[0], card[1], card[2]);
                if (f == true) f = judge(card[3], card[4], card[5]);
                if (f == true) f = judge(card[6], card[7], card[8]);
                if (f == 1) return 1;
        }while (next_permutation(card, card+9));
        return 0;
}

signed main(){
        cin >> n;
        string color;
        for (i = 0; i < n; i++){
                for (j = 0; j < 9; j++){
                        cin >> card[j];
                }
                for (j = 0; j < 9; j++){
                        cin >> color;
                        if (color == "G") card[j] += 10;
                        else if (color == "B") card[j] += 20;
                }
                int ans = win();
                cout << ans << endl;
                /*sort(card, card + 9);
                f = true;
                f = judge(card[0], card[1], card[2]);
                if (f == true) f = judge(card[3], card[4], card[5]);
                if (f == true) f = judge(card[6], card[7], card[8]);
                cout << (f ? 1 : 0) << endl;*/
        }
        return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3008
final_rank: 1

code_snippet: #include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int T, card[16];


bool is_same_number(int a, int b, int c){
    return (a==b && b==c);
}

bool is_sequence(int a, int b, int c){
    return (a+2==b+1 && b+1==c);
}

bool is_good_set(int a, int b, int c){
    return (is_same_number(a, b, c) || is_sequence(a, b, c));
}

bool is_all_good_set(){
    return (is_good_set(card[0],card[1],card[2]) && is_good_set(card[3],card[4],card[5]) && is_good_set(card[6],card[7],card[8]));
}

int win() {
    sort(card, card+9);
    do{
        if (is_all_good_set()) return 1;
    }
    while (next_permutation(card, card+9));
    return 0;
}

int main() {
    cin >> T;
    for (int t=0; t<T; ++t) {
        for (int i=0; i<9; ++i) cin >> card[i];
        string color;
        for (int i=0; i<9; ++i) {
            cin >> color;
            if (color=="G") card[i] += 10;
            else if (color=="B") card[i] += 20;
        }
        cout << win() << endl;
    }
}
accuracy: 1
time_ms: 20
memory_kb: 3144
final_rank: 8

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

using i32 = std::int_fast32_t;
using i64 = std::int_fast64_t;

#define REP(i, stop) FOR(i, 0, stop)
#define FOR(i, start, stop) for (int i = start, i##_len = stop; i < i##_len; ++i)

struct InitCpp { InitCpp() { cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(10); } } initCpp;

bool is_same_number(i32 a[3]) {
  return a[0] == a[1] && a[1] == a[2];
}

bool is_sequence(i32 a[3]) {
  return a[0] + 2 == a[1] + 1 && a[1] + 1 == a[2];
}

bool is_good_set(i32 a[3]) {
  return is_same_number(a) || is_sequence(a);
}

bool is_all_good_set(i32 hand[9]) {
  return is_good_set(hand) && is_good_set(hand + 3) && is_good_set(hand + 6);
}

i32 solve() {
  i32 hand[9];
  REP(i, 9) cin >> hand[i];
  REP(i, 9) {
    string color;
    cin >> color;
    if (color == "G") hand[i] += 10;
    else if (color == "B") hand[i] += 20;
  }
  sort(hand, hand + 9);
  do {
    if (is_all_good_set(hand)) return 1;
  } while (next_permutation(hand, hand + 9));
  return 0;
}

signed main() {
  i32 T;
  cin >> T;
  REP(_, T) {
    cout << solve() << endl;
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3024
final_rank: 2

code_snippet: #include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<map>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, st, n) for (int i = st; i < n; ++i)

int main() {
    int n; cin >> n;
    rep(i, n) {
        vector<pair<int, char> > v(9);
        rep(i, 9) cin >> v[i].first;
        rep(i, 9) cin >> v[i].second;
        sort(v.begin(), v.end());
        int flg = 0;
        do { //9!
            int cnt = 0;
            for (int i = 0; i < 9; i += 3) {
                bool a = v[i].first == v[i + 1].first && v[i + 1].first == v[i + 2].first;
                bool b = v[i].second == v[i + 1].second && v[i + 1].second == v[i + 2].second;
                if (a && b) cnt++;
                bool c = v[i].first + 1 == v[i + 1].first && v[i + 1].first  + 1 == v[i + 2].first;
                if (c && b) cnt++;
            }
            if (cnt == 3) {
                flg = 1;
                cout << 1 << endl;
                break;
            }
        } while (next_permutation(v.begin(), v.end()));
        if (flg == 0) cout << 0 << endl;
    }
    
}
accuracy: 1
time_ms: 50
memory_kb: 2984
final_rank: 6