Rummikub

import static java.lang.Math.*;
import java.util.*;
import java.util.stream.*;
import java.util.regex.*;
class RummikubGame{
    public static void main(String[] args){
        RummikubBag deck= new RummikubBag();
        RummikubPlayer p1=new RummikubPlayer();
        StringBuilder firstHand=new StringBuilder("p1 picked: ");
        /*picks 14 cards*/
        for(int i=0;i<14;i++){
            String a=deck.pick();
            p1.addCard(a);
            firstHand.append(a+" ");
        }
        System.out.println(firstHand);
        p1.firstMove();
    }
}
class RummikubPlayer{
    public final static int OPEN_NUM=30;
    private final static String NONE="none";
    private final static String REGEX_GROUP="[BRPY]{3,4}#\\d{1,2}";
    private final static String REGEX_RUN="\\d{1,2}[_]\\d{1,2}";
    HashMap<Character,List<Integer>> hand;
    RummikubPlayer(){
        hand= new HashMap<>();
        for(int i=0;i<4;i++)
            hand.put(getChar(i),new ArrayList<Integer>());
    }
    void firstMove(){
        sortHand();
        StringBuilder out=new StringBuilder("rack:[ ");
        String groups=tryGroups();
        String runs=tryRuns();
        int currVal=0;
        if(runs.length()==0&&groups.length()==0){
            System.out.println("no run or group possible");
        }
        else if(runs.length()==0){
            Matcher m=Pattern.compile(REGEX_GROUP).matcher(groups);
            while(m.find()){
                String r=groups.substring(m.start(),m.end());
                int mul=r.substring(0,r.indexOf("#")).length();
                int n=Integer.parseInt(r.substring(r.indexOf("#")+1));
                currVal+=(mul*n);
            }
        }
        else if(groups.length()==0){
            Matcher m=Pattern.compile(REGEX_RUN).matcher(runs);
            while(m.find()){
                String t=runs.substring(m.start(),m.end());
                int a=Integer.parseInt(t.substring(0,t.indexOf("_")));
                int b=Integer.parseInt(t.substring(t.indexOf("_")+1));
                currVal+=(a*(a+1))/2-((b-1)*b)/2;
            }
        }
        else{
            Matcher m=Pattern.compile(REGEX_GROUP).matcher(groups);
            while(m.find()){
                String r=groups.substring(m.start(),m.end());
                int mul=r.substring(0,r.indexOf("#")).length();
                int n=Integer.parseInt(r.substring(r.indexOf("#")+1));
                currVal+=(mul*n);
            }
            m=Pattern.compile(REGEX_RUN).matcher(runs);
            while(m.find()){
                String t=runs.substring(m.start(),m.end());
                int a=Integer.parseInt(t.substring(0,t.indexOf("_")));
                int b=Integer.parseInt(t.substring(t.indexOf("_")+1));
                currVal+=(a*(a+1))/2-((b-1)*b)/2;
            }
        }
        if(currVal<OPEN_NUM){
            System.out.println("IMPOSSIBLE");
        }
        else{
            System.out.println(runs+"\n"+groups);
        }

    }
    void addCard(String card){
        if(!card.equals("EMPTY")){
            Integer num=Integer.valueOf(card.substring(1));
            hand.get(card.charAt(0)).add(num);
        }
    }
    /*returns possible groups
     *format used e.g. "BYP#13 RYP#2 " */
    private String tryGroups(){
        StringBuilder out=new StringBuilder();
        ArrayList<Integer> alreadyPicked=new ArrayList<>();
        boolean r=false,y=false,p=false,b=false;
        //Looks for group a looping B list
        for(Integer s:hand.get('B')){
            if(!alreadyPicked.contains(s)){
                r=hand.get('R').contains(s);
                y=hand.get('Y').contains(s);
                p=hand.get('P').contains(s);
                if(r&&y||r&&p||p&&y){
                    alreadyPicked.add(s);
                    out.append("B");
                    if(r)out.append('R');
                    if(y)out.append('Y');
                    if(p)out.append('P');
                    out.append("#").append(s).append(" ");
                }
            }
        }
        //Looks for a group looping R list
        for(Integer s:hand.get('R')){
            if(!alreadyPicked.contains(s)){
                b=hand.get('B').contains(s);
                y=hand.get('Y').contains(s);
                p=hand.get('P').contains(s);
                if(b&&y||b&&p||y&&p){
                    alreadyPicked.add(s);
                    out.append("R");
                    if(b)out.append('B');
                    if(y)out.append('Y');
                    if(p)out.append('P');
                    out.append("#").append(s).append(" ");
                }
            }
        }
        return out.toString();
    }
    /*Looks for every possible run
     *(3 cards abc same suit / b=a-1 c=a-2)*/
    private String tryRuns(){
        StringBuilder out=new StringBuilder();
        String b=findRunsOfSuit('B');
        String r=findRunsOfSuit('R');
        String y=findRunsOfSuit('Y');
        String p=findRunsOfSuit('P');

        if(!b.equals(NONE))out.append(b);
        if(!r.equals(NONE))out.append(r);
        if(!y.equals(NONE))out.append(y);
        if(!p.equals(NONE))out.append(p);

        return out.toString();
    }
    /*finds every possible run of a v suit
     * and returns in a String with this format:
     * "B>13_10#5_3/"*/
    private String findRunsOfSuit(char v){
        ArrayList<Integer> copy=new ArrayList<>(hand.get(v));

        boolean b=false,c=false;
        StringBuilder out=new StringBuilder().append(v).append(">");
        if(copy.size()<3)
            return NONE;
        int s=copy.get(copy.size()-1);
        while(s>=2){
            if(copy.contains(s)){
                b=copy.contains(s-1);
                c=copy.contains(s-2);
                if(b&&c){
                    copy.remove(new Integer(s-1));
                    int t=s-2;
                    while(copy.contains(t)){
                        copy.remove(new Integer(t));
                        t--;
                    }
                    out.append(s).append("_").append(t+1).append("#");
                }
            }
            s--;
        }
        if(out.toString().matches("[BRYP][>]"))
            return NONE;
        else
            return out.append("/").toString();
    }
    private int getIndex(char v){
        return (v=='B')?0:(v=='R')?1:(v=='Y')?2:3;
    }
    private char getChar(int v){
        return (v==0)?'B':(v==1)?'R':(v==2)?'Y':'P';
    }
    private void sortHand(){
        for(int i=0;i<hand.size();i++)
            Collections.sort(hand.get(getChar(i)));
    }
}
class RummikubBag{
    StringBuilder bag;
    RummikubBag(){
        bag=new StringBuilder(104);
        char max=105;
        for(char i=1;i<max;i++)
            bag.append(i);
    }
    boolean isEmpty(){
        return bag.length()==0;
    }
    int getTilesLeft(){
        return bag.length();
    }
    String pick(){
        if(isEmpty())
            return "EMPTY";

        StringBuilder out=new StringBuilder();
        int index=(int)rint((bag.length()-1)*random());
        int tile=bag.charAt(index);
        int num=tile%13;

        bag.deleteCharAt(index);
        //suit
        if(tile<=26)
            out.append("B");
        else if(tile<=52)
            out.append("R");
        else if(tile<=78)
            out.append("Y");
        else
            out.append("P");
        //tile number
        if(num==0)
            out.append(13);
        else
            out.append(num);
        return out.toString();
    }
}