Poker.java

import java.util.Arrays;
import java.util.HashMap;

public class Poker{
    final static int MANO_CAPACIDAD = 5;
    final static int PALO_CAPACIDAD = Carta.valores.length;//13
    static int nroJugadas = 0;
    static HashMap<String, Integer> cadaJugada = new HashMap<>();
    public static void main(String[] args) {
        Carta [] mazo = new Carta[PALO_CAPACIDAD * Color.values().length];
        int c = 0;
        for (Color color : Color.values()) {
            for (int i = 1; i <= PALO_CAPACIDAD; i++) {
                mazo[c] = new Carta(i,color);
                c++;
            }
        }
        Carta [] mano = new Carta[MANO_CAPACIDAD];
        jugadasPosibles(0,0,mazo,mano);
        System.out.println(nroJugadas);
        cadaJugada.entrySet().forEach(k -> System.out.printf("%s : %.5f%%\n",k.getKey(),100*k.getValue()/(float)nroJugadas));
    }

    public static String comprobarJugada(Carta [] mano) {
        Carta [] mano1 = mano.clone();
        Arrays.sort(mano1);
        if (esEscaleraColor(mano1)) return "Escalera color"; 
        if (esPoker(mano1)) return "Poker"; 
        if (esFull(mano1)) return "Full"; 
        if (esColor(mano1)) return "Color"; 
        if (esEscalera(mano1)) return "Escalera";
        if (esTrio(mano1)) return "Trio";
        if (esDoblePareja(mano1)) return "Doble Pareja";
        if (esDoble(mano1)) return "Doble";
        
        return "Carta Alta";
    }

    public static boolean esPoker(Carta[] mano) {
        
        return mano[0].getValor()==mano[mano.length-2].getValor()||mano[1].getValor()==mano[mano.length-1].getValor();
    }

    public static boolean esFull(Carta[] mano) {
        int conta = 0;
        int contb = 0;
        int i;
        for (i = 0; i < mano.length-1; i++) {
            if(mano[i].getValor() == mano[i+1].getValor()){
                conta++;
            }
            else{
                break;    
            }
        }
        for (i=i+1 ;i < mano.length-1; i++) {
            if(mano[i].getValor() == mano[i+1].getValor()){
                contb++;
            }
            else{
                break;    
            }
        }
        

        return conta*contb==2;
    }

    public static boolean esTrio(Carta[] mano) {
        int conta = 0;
        int i;
        for (i = 0; i < mano.length-1; i++) {
            if(mano[i].getValor() == mano[i+1].getValor()){
                conta++;
            }
            else{
                break;    
            }
        }
        return (conta)==2;
    }
    
    public static boolean esDoblePareja(Carta[] mano) {
        int conta = 0;
        int contb = 0;
        int i;
        for (i = 0; i < mano.length-1; i++) {
            if(mano[i].getValor() == mano[i+1].getValor()){
                conta++;
            }
            else{
                break;    
            }
        }
        for (i=i+1 ;i < mano.length-1; i++) {
            if(mano[i].getValor() == mano[i+1].getValor()){
                contb++;
            }
            else{
                break;    
            }
        }
        

        return conta==contb&&conta==1;
    }
    
    public static boolean esDoble(Carta[] mano) {
        int conta = 0;
        int i;
        for (i = 0; i < mano.length-1; i++) {
            if(mano[i].getValor() == mano[i+1].getValor()){
                conta++;
            }
            else{
                break;    
            }
        }
        return (conta)==1;
    }

    public static boolean esColor(Carta[] mano) {
        for (int i = 0; i < mano.length-1; i++) {
            if(mano[i].getColor() != mano[i+1].getColor()) return false;
        }
        return true;
    }
    
    public static boolean esEscalera(Carta[] mano) {
        int cont=0;
        for (int i = 1; i < mano.length-1; i++) {
            if(mano[i+1].getValor()==mano[i].getValor()+1){
                cont++;
            }
            else{
                break;
            }
        }
        return cont==3&&(mano[0].getValor()+12==mano[mano.length-1].getValor()||mano[1].getValor()==mano[0].getValor()+1);
        
    }
    
    
    public static boolean esEscaleraColor(Carta[] mano) {
        for (int i = 1; i < mano.length-1; i++) {
            if(mano[i+1].getColor()!= mano[i].getColor()){
                return false;
            }
        }
        return mano[mano.length-1].getValor()-mano[1].getValor()==3&&(mano[0].esElSiguienteDe(mano[mano.length-1])||mano[1].esElSiguienteDe(mano[0]));
    }



    public static void jugadasPosibles(int cartaNro, int posicion, Carta [] mazo, Carta [] mano) {
        if(posicion < MANO_CAPACIDAD && cartaNro <= (PALO_CAPACIDAD * Color.values().length - (MANO_CAPACIDAD-posicion))){
            mano[posicion] = mazo[cartaNro];
            if (posicion==MANO_CAPACIDAD-1) {
                //comprobar_jugada
                //System.out.printf("%d %d\n",cartaNro,posicion);
                String tipo = comprobarJugada(mano);
                int cant = cadaJugada.get(tipo)==null?0:cadaJugada.get(tipo);
                cadaJugada.put(tipo, cant+1);  
                nroJugadas++;
            }
            jugadasPosibles(cartaNro+1, posicion+1, mazo, mano);//siguiente carta en la siguiente posicion
            jugadasPosibles(cartaNro+1, posicion, mazo, mano);//siguiente carta en esta posicion
        }
    }


}

class Carta implements Comparable<Carta>{
    private int valor;//del 1 al 13
    private Color color;
    public final static String [] valores = {"A","2","3","4","5","6","7","8","9","T","J","Q","K"};

    public Carta(int valor, Color color) {
        this.valor = valor;
        this.color = color;
    }

    public Color getColor() {
        return color;
    }
    public int getValor() {
        return valor;
    }
    public void setColor(Color color) {
        this.color = color;
    }
    public void setValor(int valor) {
        this.valor = valor;
    }

    /**
     * Comprueba si la carta actual es la siguiente carta con respecto a la otra carta
     * @param otro la carta anterior supuestamente
     * @return
     */
    public boolean esElSiguienteDe(Carta otro){
        if(otro.getColor()!=this.getColor()) return false;
        if(otro.valor+1==valor || (otro.valor==13&&this.valor==1)) return true;
        return false;
    }

    @Override
    public String toString() {
        return valores[valor-1] + this.color;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Carta other = (Carta) obj;
        if (color != other.color)
            return false;
        if (valor != other.valor)
            return false;
        return true;
    }

    @Override
    public int compareTo(Carta o) {
        return this.getValor() - o.getValor();

    }


}


enum Color{
    S,C,H,D;
    
    

}