Poker.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
/**Asigno un valor a cada mazo de poker en el siguiente orden
 * carta alta - la mayor carta (AS=13 king=12...)
 * Pareja de dos = valor*15+
 */
public class Poker {
	// TH, TC, 5S, 5H, AD, AH, 2S  
	public int igual=-1;
	public String mejorJugada( ArrayList<Carta[]> manos)
	{	
		//creamos un vector numerico que representara el peso de la mano( 1 (escalera color) es la de mayor peso)
		ArrayList<Integer> mejorMano = new ArrayList<Integer>();
		int menor=9;//variable para insertar solo las manos mas pesadas y evitar trabajo de mas 
		for (int i = 0; i < manos.size(); i++) {
			if (escaleraColor(manos.get(i))) {
				mejorMano.add(1);
				menor=1;
				continue;
			}
			if (esPoker(manos.get(i)) && 2<=menor) {
				mejorMano.add(2);
				menor=2;
				continue;
			}
			if (fullHouse(manos.get(i)) && 3<=menor) {
				mejorMano.add(3);
				menor=3;
				continue;
			}
			if (color(manos.get(i)) && 4<=menor) {
				mejorMano.add(4);
				menor=4;
				continue;
			}
			if (escalera(manos.get(i)) && 5<=menor) {
				mejorMano.add(5);
				menor=5;
				continue;
			}
			if (esTriple(manos.get(i))  && 6<=menor) {
				mejorMano.add(6);
				menor=6;
				continue;
			}
			if (esDobleDoble(manos.get(i))  && 7<=menor) {
				mejorMano.add(7);
				menor=7;
				continue;
			}
			if (esDoble(manos.get(i)) && 8<=menor) {
				mejorMano.add(8);
				menor=8;
				continue;
			}
			//si llego aqui es solo carta alta
			if(menor==9)
				mejorMano.add(9);
			
		}

		//LUEGO ordenamos el vector y la lista recibida 
		for (int i = 0; i < mejorMano.size()-1; i++) {	
			for (int j = 0; j < mejorMano.size()-1-i; j++) {
				if (mejorMano.get(j)>mejorMano.get(j+1)) {
					//se cambia el vector
					int aux = mejorMano.get(j);
					mejorMano.set(j,mejorMano.get(j+1));
					mejorMano.set(j+1, aux);
					//se cambia la lista
					Carta[] auxCarta= manos.get(j);
					manos.set(j, manos.get(j+1));
					manos.set(j+1, auxCarta);
				}
			}
		}
		
		
		return obtenerGanador(mejorMano, manos);
	}
	public String obtenerGanador(ArrayList<Integer> vec, ArrayList<Carta[]> manos){
		
		//obtenemos un vector numerico con los elementos de mayor peso iguales para poder separar sus casos
		int mayorPeso[]=obtenerIguales(vec);
		int caso = mayorPeso[0];
		int tam= mayorPeso.length;//sirve para saber hasta donde debe comparar el vector manos
		int i=-1;
		
		int tipoAux=0;
		switch (caso) {
			case 1://mejor escalera color
				i=mejorEscalera(manos, tam);
				tipoAux=1;
				break;
			case 2:
				i=mejorPoker(manos, tam);
				tipoAux=2;
				break;
			case 3:
				i=mejorFullHouse(manos, tam);
				tipoAux=3;
				break;
			case 4://mejor color
				i=mejorColor(manos, tam);
				tipoAux=4;
				break;
			case 5://mejor escalera
				i=mejorEscalera(manos, tam);
				tipoAux=5;
				break;
			case 6:
				i=mejorTriple(manos, tam);
				tipoAux=6;
				break;
			case 7:
				i=mejorDobleDoble(manos, tam);
				tipoAux=7;
				break;
			case 8:
				i=0;//pareja simple
				tipoAux=8;
			case 9:
				i=mejorCartaAlta(manos, tam);
				tipoAux=9;
			default:
				break;
		}
		if (igual!=-2) {
			String cadena = manos.get(i)[0].valorPalo()+","+ manos.get(i)[1].valorPalo()+","+ manos.get(i)[2].valorPalo()+","+ manos.get(i)[3].valorPalo()+","+ manos.get(i)[4].valorPalo();
			return "La mano ganadora es "+tipoMano(tipoAux)+cadena;
		}else{
			igual=-1;
			return "Hay un empate entre "+tipoMano(tipoAux);
		}
	
	}
	public int mejorCartaAlta(ArrayList<Carta[]> manos, int k){
		if (k==1) {
			return 0;
		}
		int max=0;
		//verificamos la carta alta mayor
		for (int i = 0; i < k-1; i++) {
			int[] array = ordenarValor(manos.get(i));
			int []aux= ordenarValor(manos.get(i+1));
			if (array[0]==1  && aux[0]!=1) {
				return i;
			}else if(array[0]!=1  && aux[0]==1){
				return i+1;
			}
			for (int j = 0; j < aux.length; j++) {
				if (array[j]<aux[j]) {
					return i;
				}else if(array[j]>aux[j]){
					return i+1;
				}
			}
			igual=-2;
		}
		return 0;
	}
	public int mejorDobleDoble(ArrayList<Carta[]> manos, int k){
		if (k==1) {
			return 0;
		}
		//guardamos la primera mano ordenada
		int[] array = ordenarValor(manos.get(0));
		int max=0;
		int kicker[][]=new int[2][3];
		for (int i = 0; i < k-1; i++) {
			int[] arrayAux = ordenarValor(manos.get(i+1));
			//primero obtenemos las dos parejas de cada mazo y su kicker
			if (array[0]==array[1] && array[2]==array[3]){
				kicker[0][0]=array[2];
				kicker[0][1]=array[0];
				kicker[0][2]=array[4];
			}else if (array[1]==array[2] && array[3]==array[4]){
				kicker[0][0]=array[3];
				kicker[0][1]=array[1];
				kicker[0][2]=array[0];
			}else{
				kicker[0][0]=array[4];
				kicker[0][1]=array[1];
				kicker[0][2]=array[2];
			}
			if (arrayAux[0]==arrayAux[1] && arrayAux[2]==arrayAux[3]){
				kicker[1][0]=arrayAux[2];
				kicker[1][1]=arrayAux[0];
				kicker[1][2]=arrayAux[4];
			}else if (arrayAux[1]==arrayAux[2] && arrayAux[3]==arrayAux[4]){
				kicker[1][0]=arrayAux[3];
				kicker[1][1]=arrayAux[1];
				kicker[1][2]=arrayAux[0];
			}else{
				kicker[1][0]=arrayAux[4];
				kicker[1][1]=arrayAux[1];
				kicker[1][2]=arrayAux[2];
			}
			//primero comparamos si son iguales 
			if(kicker[0][0]==kicker[1][0] && kicker[0][1]==kicker[1][1] && kicker[0][2]==kicker[1][2] ){
				igual=-2;
				continue;
			}
		}
		return max;
	}
	public int mejorColor(ArrayList<Carta[]> manos, int k){
		if (k==1) {
			return 0;
		}
		//guardamos la primera mano ordenada
		int[] array = ordenarValor(manos.get(0));
		int max=-1;
		int kicker[]=new int[2];
		for (int i = 0; i < k-1; i++) {
			int[] arrayAux = ordenarValor(manos.get(i+1));
			if(array[0]!=1 && arrayAux[0]==1 ){
				max =i+1;
				array =arrayAux;
				continue;
			}
			if(array[4]<arrayAux[4] && array[0]!=1){
				max =i+1;
				array =arrayAux;
			}
		}
		if (max==-1) {
			max=0;
			igual=-2;
		}
		return max;
	}
	public int mejorTriple(ArrayList<Carta[]> manos, int k){
		if (k==1) {
			return 0;
		}
			//guardamos la primera mano ordenada
			int[] array = ordenarValor(manos.get(0));
			int max=0;
			int kicker[]=new int[2];
			for (int i = 0; i < k-1; i++) {
				int[] arrayAux = ordenarValor(manos.get(i+1));

				if (array[0]==array[1]) {
					kicker[0]=array[0];
				}else
					kicker[0]=array[4];
				
				if (arrayAux[0]==arrayAux[1]) {
					kicker[1]=arrayAux[0];
				}else
					kicker[1]=arrayAux[4];
					
				if (kicker[0]<kicker[1] && kicker[0]!=1 || kicker[0]>kicker[1] && kicker[1]==1) {
					max=i+1;
					array=arrayAux;
				}
			}
		return max;
	}
	public int mejorFullHouse(ArrayList<Carta[]> manos, int k){
		if (k==1) {
			return 0;
		}
			//guardamos la primera mano ordenada
			int[] array = ordenarValor(manos.get(0));
			int max=0;
			int kicker[][]=new int[2][2];//guarda en la primera casilla el valor del trio y en el segundo el valor del duo
			//buscamos el kicker del trio y doble(solo hay dos posibilidades en un vector ordenado)
			for (int i = 0; i < k-1; i++) {
				int[] arrayAux = ordenarValor(manos.get(i+1));
				//las primeras tres cartas son el trio
				if(array[0]==array[1] && array[0]==array[2]){
					kicker[0][0]=array[0];
					kicker[0][1]=array[4];
				}else{
					kicker[0][0]=array[4];
					kicker[0][1]=array[0];
				}
				if(arrayAux[0]==arrayAux[1] && arrayAux[0]==arrayAux[2]){
					kicker[1][0]=arrayAux[0];
					kicker[1][1]=arrayAux[4];
				}else{
					kicker[1][0]=arrayAux[4];
					kicker[1][1]=arrayAux[0];
				}
				if(kicker[0][0]<kicker[1][0] && kicker[0][0]!=1 || kicker[0][0]>kicker[1][0] && kicker[1][0]==1){
					max=i+1;
					array=arrayAux;
					igual=-1;
					continue;
				}
				if(kicker[0][0]==kicker[1][0] ){
					if (kicker[0][1]<kicker[1][1] && kicker[0][1]!=1 || kicker[0][1]>kicker[1][1] && kicker[1][1]==1) {
						max=i+1;
						array=arrayAux;
						igual=-1;
						continue;
					}
					if(kicker[0][1]==kicker[1][1])
						igual=-2;
				}		
			}


		return max;
	}
	public int mejorPoker(ArrayList<Carta[]> manos, int k){
		if (k==1) {
			return 0;
		}
			//guardamos la primera mano ordenada
			int[] array = ordenarValor(manos.get(0));
			int max=0;
			for (int i = 0; i < k-1; i++) {
				//buscamos los dos elementos distintos 
				int[] kicker= new int[2];//el primer espacio es el poker y el segundo el kicker
				int[] arrayAux = ordenarValor(manos.get(i+1));//guardamos la segunda mano de poker a comparar
				//buscamos el kicker
					if(array[0]!=array[1] && (array[1]+array[2]-array[3]-array[4])==0)
						kicker[0]=array[1];
					else
						kicker[0]=array[0];
					
					if(arrayAux[0]!=arrayAux[1] && (arrayAux[1]+arrayAux[2]-arrayAux[3]-arrayAux[4])==0)
						kicker[1]=arrayAux[1];
					else
						kicker[1]=arrayAux[0];
					
				if (kicker[0]<kicker[1] && kicker[0]!=1 || kicker[0]>kicker[1] && kicker[1]==1) {
					array=arrayAux;
					max=i+1;
				}

			}
			
		return max;
	}
	public String tipoMano(int i){
		switch (i) {
			case 1:
				return "Escalera color ";
			case 2:
				return "Poker ";
			case 3:
				return "Full House ";
			case 4:
				return "Color";
			case 5:
				return "Escalera ";
			case 6: 
				return "Triple ";
			case 7:
				return "Doble pareja ";
			case 8:
				return "Pareja ";
			case 9:
				return "Carta alta ";
			default:
				break;
		}
		return "";
	}
	/**
	 * 
	 * @param manos
	 * @param k
	 * @return retorna el indice de la escaleraColor de mayor valor
	 */
	public int mejorEscalera( ArrayList<Carta[]> manos, int k){
		if (k==1) {
			return 0;
		}
			//guardamos la primera mano ordenada
			int[] array = ordenarValor(manos.get(0));
			
			int max=0;//guarda el indice de la mayor mano
			
			for (int i = 0; i < k-1; i++) {
				int [] aux = ordenarValor(manos.get(i+1));
				if (aux[4]>array[4]) {
					array=aux;
					max=i+1;
				}else if(aux[4]==array[4]){
					//si el primer elemento de ambos es igual a 1 =AS entonces ambos son escaleras reales
					if(aux[0]==1 && array[0]!=1){
						max=i+1;
						array =aux;
					}else if(aux[0]==1 && array[0]==1 || aux[0]==array[0]){
						igual=-2;
					}

				}

			}

			return max;
		
	}
	public int[] obtenerIguales(ArrayList<Integer>  vec){

		//buscamos el indice en donde dejan de ser iguales
		int indiceMax=0;
		for (int i = 0; i < vec.size()-1; i++) 
			if (vec.get(i)==vec.get(i+1)) 
				indiceMax=i+1;
			 else 
				break;
		//ahora creamos un vector con ese indice
		int vectorAux[] =new int[indiceMax+1];
		//cargamos los numeros
		for (int i = 0; i < vectorAux.length; i++) 
			vectorAux[i]=vec.get(i);
		
		return vectorAux;
	}
	public boolean color(Carta[] cartas){
		//obtenemos el vector ordenado
		int ordenado[]=ordenarValor(cartas);
			//comprobamos si son del mismo palo
			char valor1= cartas[0].palo.charAt(0);
			char valor2= cartas[1].palo.charAt(0);
			char valor3= cartas[2].palo.charAt(0);
			char valor4= cartas[3].palo.charAt(0);
			char valor5= cartas[4].palo.charAt(0);
			if (valor1==valor2 &&  valor1==valor3 && valor4==valor1 && valor1==valor5) 
				return true;
		return false;
	}
	public boolean esDobleDoble(Carta [] carta){
		//obtenemos el vector ordenado
		int vec[]=ordenarValor(carta);
		//si son dos numeros iguales entonces es una pareja de dos
		if (vec[0]==vec[1] && vec[2]==vec[3] || vec[0]==vec[1] && vec[3]==vec[4] )   
			return true;
		if (vec[1]==vec[2] && vec[3]==vec[4] )   
			return true;
		return false;
	}
	public boolean esDoble(Carta [] carta){
		//obtenemos el vector ordenado
		int vec[]=ordenarValor(carta);
		//si son dos numeros iguales entonces es una pareja de dos
		if (vec[0]==vec[1] || vec[1]==vec[2] || vec[2]==vec[3] || vec[3]==vec[4])   
			return true;
		
		return false;
	}
	public boolean esTriple(Carta [] carta){
		//obtenemos el vector ordenado
		int vec[]=ordenarValor(carta);
		//si son tres numeros iguales entonces es un triple
		if (vec[0]==vec[1] && vec[1]==vec[2] || vec[1]==vec[2] && vec[2]==vec[3])   
				return true;
		if (vec[2]==vec[3] && vec[3]==vec[4])   
			return true;
		return false;
	}
	public boolean escalera(Carta [] carta){
		//obtenemos el vector ordenado
		int ordenado[]=ordenarValor(carta);
		//si son numeros sucesivos entonces es una escalera
		if (ordenado[0]+1==ordenado[1] && ordenado[1]+1==ordenado[2] && ordenado[2]+1==ordenado[3] && ordenado[3]+1==ordenado[4] )   
				return true;
		return false;
		
	}
	public boolean escaleraColor(Carta[] cartas){
		//obtenemos el vector ordenado
		int ordenado[]=ordenarValor(cartas);
		
		//si son numeros sucesivos entonces es una escalera
		if (ordenado[0]+1==ordenado[1] && ordenado[1]+1==ordenado[2] && ordenado[2]+1==ordenado[3] && ordenado[3]+1==ordenado[4] )   {
			//comprobamos si son del mismo palo
			char valor1= cartas[0].palo.charAt(0);
			char valor2= cartas[1].palo.charAt(0);
			char valor3= cartas[2].palo.charAt(0);
			char valor4= cartas[3].palo.charAt(0);
			char valor5= cartas[4].palo.charAt(0);
			if (valor1==valor2 &&  valor1==valor3 && valor4==valor1 && valor1==valor5) {
				return true;
			}
		}
		return false;
	}
	public boolean esPoker(Carta [] carta){
		//obtenemos el vector ordenado
		int vec[] = ordenarValor(carta);
		if (vec[0]==vec[1] && vec[0]==vec[2] && vec[0]==vec[3] || vec[1]==vec[2] && vec[1]==vec[3] && vec[1]==vec[4] ) {
			return true;
		}
		return false;
	}

	public boolean fullHouse(Carta[] mano){
		//obtenemos el vector ordenado
		int vec[] = ordenarValor(mano);
		if (vec[0]==vec[1] && vec[0]==vec[2] && vec[3]==vec[4] ) 
			return true;
		if (vec[0]==vec[1] && vec[2]==vec[3] && vec[3]==vec[4] ) 
			return true;
		return false;
	}
	/**
	 * 
	 * @param cartas
	 * @return retorna un vector ordenado por el valor del vector de cartas
	 */
	public int[] ordenarValor(Carta[] cartas){
		//ordenamos por palo
		int cambio=0;
		int ordenado[]=new int[5];
		for (int i = 0; i < cartas.length; i++) {
			char aux = cartas[i].valor.charAt(0);
			switch (aux) {
				case 'A':
					ordenado[i]=1;
					break;
				case 'J':
					ordenado[i]=11;
					break;
				case 'Q':
					ordenado[i]=12;
					break;
				case 'K':
					ordenado[i]=13;
					break;
				case 'T':
					ordenado[i]=10;
					break;
				default:
					ordenado[i]=Integer.parseInt(aux+"");
					break;
			}
		}
		Arrays.sort(ordenado);
		return ordenado;
	}
	
	public boolean escaleraReal(Carta[] cartas){
		//obtenemos el vector ordenado
		int ordenado[]=ordenarValor(cartas);
		if (ordenado[0]==1 && ordenado[1]==10 && ordenado[2]==11 && ordenado[3]==12 && ordenado[4]==13 ) {
			//si entra entonces es una escalera, comprobamos si son del mismo palo
			char valor1= cartas[0].palo.charAt(0);
			char valor2= cartas[1].palo.charAt(0);
			char valor3= cartas[2].palo.charAt(0);
			char valor4= cartas[3].palo.charAt(0);
			char valor5= cartas[4].palo.charAt(0);
			if (valor1==valor2 &&  valor1==valor3 && valor4==valor1 && valor1==valor5) {
				return true;
			}
		}
		return false;
	}

}