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)
のカードの数字 ni
がそれぞれスペースで区切られて与えられ，
2行目には i 番目のカードの色を表す文字
ci
がそれぞれスペースで区切られて与えられる．
カードの数字
ni
は 1 ≤ ni ≤ 9
を満たす整数であり，
カードの色 ci
はそれぞれ “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

Solution in JAVA (judge verdict: Accepted)

import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

                int player = sc.nextInt();

        int []number = new int[9];
        String []color = new String[9];

        for(int playerNum = 0; playerNum < player; playerNum++) {

                //セット数
                int setCount = 0;

                List<Integer> R = new ArrayList<Integer>();
            List<Integer> G = new ArrayList<Integer>();
            List<Integer> B = new ArrayList<Integer>();

                //カードの番号を格納
                for(int cardNum = 0; cardNum < 9; cardNum++) {
                        number[cardNum] = sc.nextInt();
                }
                //カードの色を格納
                for(int cardnum = 0; cardnum < 9; cardnum++) {
                        color[cardnum] = sc.next();
                }

                //RGBそれぞれのリストにカードの数字を格納
                for(int CardNum = 0; CardNum < 9; CardNum++) {
                        if(color[CardNum].equals("R")) {
                                R.add(number[CardNum]);
                        }
                        if(color[CardNum].equals("G")) {
                                G.add(number[CardNum]);
                        }
                        if(color[CardNum].equals("B")) {
                                B.add(number[CardNum]);
                        }

            }

            //降順に並び替える
            Collections.sort(R);
            Collections.sort(G);
            Collections.sort(B);

            int origin = 0;

            //Rリスト(連番)
            for(int r = 0; r < R.size()-2; r++) {
                origin = R.get(r);

                if(origin != 0) {
                        if(R.contains(origin + 1) && R.contains(origin + 2)) {
                                setCount ++;
                                R.set(R.indexOf(origin), 0);
                                R.set(R.indexOf(origin + 1), 0);
                                R.set(R.indexOf(origin + 2), 0);
                        }
                }
            }

            //Rリスト（同数字）
            for(int r = 0; r < R.size()-2; r++) {
                if(R.get(r) != 0) {
                        origin = R.get(r);

                        if(R.get(r + 1) == origin && R.get(r + 2) == origin) {
                                setCount++;
                                R.set(r, 0);
                                R.set(r + 1, 0);
                                R.set(r + 2, 0);
                        }
                }
            }

            //Gリスト(連番)
            for(int g = 0; g < G.size()-2; g++) {
                origin = G.get(g);

                //連番確認
                if(origin != 0) {
                        if(G.contains(origin + 1) && G.contains(origin + 2)) {
                                setCount ++;
                                G.set(G.indexOf(origin), 0);
                                G.set(G.indexOf(origin + 1), 0);
                                G.set(G.indexOf(origin + 2), 0);
                        }
                }
            }

            //Gリスト（同数字）
            for(int g = 0; g < G.size()-2; g++) {
                if(G.get(g) != 0) {
                        origin = G.get(g);

                        if(G.get(g + 1) == origin && G.get(g + 2) == origin) {
                                setCount++;
                                G.set(g, 0);
                                G.set(g + 1, 0);
                                G.set(g + 2, 0);
                        }
                }
            }

            //Bリスト(連番)
            for(int b = 0; b < B.size()-2; b++) {
                origin = B.get(b);

                //連番確認
                if(origin != 0) {
                        if(B.contains(origin + 1) && B.contains(origin + 2)) {
                                setCount ++;
                                B.set(B.indexOf(origin), 0);
                                B.set(B.indexOf(origin + 1), 0);
                                B.set(B.indexOf(origin + 2), 0);
                        }
                }
            }

            //Bリスト（同数字）
            for(int b = 0; b < B.size()-2; b++) {
                if(B.get(b) != 0) {
                        origin = B.get(b);

                        if(B.get(b + 1) == origin && B.get(b + 2) == origin) {
                                setCount++;
                                B.set(b, 0);
                                B.set(b + 1, 0);
                                B.set(b + 2, 0);
                        }
                }
            }

            if(setCount == 3) {
                System.out.println("1");
            }
            else {
                System.out.println("0");
            }
        }
    }
}