EjercutarPrograma es la clase principal

Readme.md

+## Indicaciones
+
+	- El proyecto fue creado en la aplicaciones "Eclipse"
+
+	- El programa genera una combinacion de 7 cartas, y de ella genera la mejor combinación de 5.
+
+	- La clase Combinaciones es el que genera todas las combinaciones posibles, con el metodo "generarCombinaciones".
+	
+	- En el paquete "mejorCombinacion" está la clase "EjecutarPrograma", y la misma es la clase principal.
\ No newline at end of file

java-e007/.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

java-e007/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>java-e007</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

java-e007/src/com/roshka/bootcamp004/mano/Carta.java

+/*
+ * En esta clase se genera las cartas. 
+ * Por predeterminado genera la carta de forma aleatoria, pero se puede cargar manualmente 
+ * */
+
+package com.roshka.bootcamp004.mano;
+
+public class Carta {
+	final char valores[] = {'A','2','3','4','5','6','7','8','9','T','J','Q','K'};
+	final char palos[] = {'S','C','H','D'};
+	char valor;
+	char palo;
+	boolean otraCarta;
+	
+	
+	public Carta(){
+		//Genera la primera carta
+		int temporalPosValor = (int)(13*Math.random());
+		int temporalPosPalo = (int)(4*Math.random());
+		int pos_valores = Integer.parseInt(""+temporalPosValor);
+		int pos_palo = Integer.parseInt(""+temporalPosPalo);
+		this.palo = palos[pos_palo];
+		this.valor = valores[pos_valores];
+	}
+	
+	//Este metodo sirve para cargar las cartas de forma manual
+	public Carta(String completo)
+    {
+        this.valor = completo.charAt(0);
+        this.palo = completo.charAt(1);
+    }
+    
+	/**
+	 * Se obtiene la carta en formato String
+	 * @return La carta en formato String
+	 */
+    public String obtenerCarta(){
+    	return ""+this.valor+this.palo;
+    }
+    
+    /**
+     * Comprueba si el valor de la otra carta es superior, igual o inferior al valor de
+     * la carta actual
+     * @param valorE El valor de la otra carta en formato 'char'.
+     * @return 0: son iguales, 1: la carta es superior a la otra carta, -1: lo contrario al valor 1
+     */
+    //Funcion que nos permite comparar con otra carta
+    public int compararValorCon(char valorE) {
+    	int numValor1 = 0;
+		int numValor2 = 0;
+		//Buscamos en que posición está cada valor
+		//Valor1
+		for(int i=0;i<valores.length;i++) {
+			if(this.valor == valores[i]) {
+				numValor1 = i;
+				break;
+			}
+		}
+		//Valor2
+		for(int i=0;i<valores.length;i++) {
+			if(valorE == valores[i]) {
+				numValor2 = i;
+				break;
+			}
+		}
+		//Realizamos la comparación
+		if(numValor1 == numValor2) {
+			return 0;
+		}else if(numValor1 > numValor2) {
+			return 1;
+		}else {
+			return -1;
+		}
+    }
+    /**
+     * Retorna un boolean si la otra carta es un paso superior a la carta actual
+     * @param otraCarta La otra carta
+     * @return Si es o no es cierto
+     */
+    public boolean esSuAnterior(Carta otraCarta) {
+    	int valor1 = 0;
+    	int valor2 = 0;
+    	//Buscamos la posicion del valor de la otra carta
+    	for(int i=0;i<valores.length;i++) {
+			if(otraCarta.obtenerCarta().charAt(0) == valores[i]) {
+				valor1 = i;
+				break;
+			}
+		}
+    	//Buscamos la posicion del valor de esta carta
+    	for(int i=0;i<valores.length;i++) {
+			if(this.valor == valores[i]) {
+				valor2 = i;
+				break;
+			}
+		}
+    	//averiguamos si es el siguiente
+    	if(valor2 != (valor1+1)) {
+    		return false;
+    	}
+    	return true;
+    }
+    
+}

java-e007/src/com/roshka/bootcamp004/mano/Mano.java

+/*
+ * Esta clase sirve para generar de forma aleatoria las 7 cartas en la mesa
+ * */
+
+package com.roshka.bootcamp004.mano;
+
+public class Mano {
+Carta[] mano;
+	
+	public Mano() {
+		this.obtenerMano();
+	}
+	
+	private void obtenerMano() {
+		//Creamos un lugar donde cargar las cartas
+		this.mano = new Carta[7];
+		//Generamos las combinaciones de cartas
+		for(int i = 0;i<7;i++) {
+			mano[i] = new Carta();
+		}
+		//Comprobamos que no se existe cartas iguales
+		this.verificarManoCartasNoIguales();
+	}
+	
+	private void verificarManoCartasNoIguales() {
+		for(int i = 0;i<6;i++) {
+			for(int j = i + 1;j<7;j++) {
+				if(this.mano[i].obtenerCarta().compareTo(this.mano[j].obtenerCarta())==0) {
+					this.mano = null;
+					this.obtenerMano();
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Entrega una mano de carta
+	 * @return La mano en formato cadena
+	 */
+	public String aCadena() {
+		String resultado = "";
+		for(int i = 0;i<7;i++) {
+			resultado = resultado + mano[i].obtenerCarta() + " ";
+		}
+		return resultado;
+	}
+	
+	/**
+	 * Entrega una mano de carta
+	 * @return Array de objeto tipo 'Carta'
+	 */
+	public Carta[] aArrayTipoCarta() {
+		return this.mano;
+	}
+
+}

java-e007/src/com/roshka/bootcamp004/poker/Poker.java

+package com.roshka.bootcamp004.poker;
+
+import com.roshka.bootcamp004.mano.*;
+
+public class Poker {
+	public final String[] jugadas = {
+			"Escalera Color",
+			"Poker",
+			"Full",
+			"Color",
+			"Escalera",
+			"Trio",
+			"Par doble",
+			"Par",
+			"Carta alta"
+	};
+	
+	public Carta[] ordenarCartasPalo(Carta[] mano) {
+		for(int i=0;i<mano.length-1;i++) {
+			char menor = mano[i].obtenerCarta().charAt(1);
+			int pos_menor = i;
+			for(int j=i+1;j<mano.length;j++) {
+				if(mano[j].obtenerCarta().charAt(1)>menor) {
+					menor = mano[j].obtenerCarta().charAt(1);
+					pos_menor = j;
+				}
+			}
+			//Realizamos el intercambio
+			if(pos_menor !=i) {
+				Carta aux = mano[i];
+				mano[i] = mano[pos_menor];
+				mano[pos_menor] = aux;
+			}
+		}
+		return mano;
+	}
+	
+	public Carta[] ordenarCartasValor(Carta[] mano) {
+		for(int i=0;i<mano.length-1;i++) {
+			char menor = mano[i].obtenerCarta().charAt(0);
+			int pos_menor = i;
+			for(int j=i+1;j<mano.length;j++) {
+				if(mano[j].compararValorCon(menor) == -1) {
+					menor = mano[j].obtenerCarta().charAt(0);
+					pos_menor = j;
+				}
+			}
+			//Realizamos el intercambio
+			if(pos_menor !=i) {
+				Carta aux = mano[i];
+				mano[i] = mano[pos_menor];
+				mano[pos_menor] = aux;
+			}
+		}
+		return mano;
+	}
+	
+	protected boolean esEscaleraColor(Carta[] mano) {
+		//Primero comprobamos que tengan todas las cartas el mismo palo
+		if(esColor(mano)) {
+			if(this.esEscalera(mano)) {
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	protected boolean esPoker(Carta[] mano) {
+		char[] valores = new char[5];
+		//Ordenamos las cartas por valor
+		mano = this.ordenarCartasValor(mano);
+		//Cargamos los valores de la mano
+		for(int i = 0;i<mano.length;i++) {
+			valores[i] = mano[i].obtenerCarta().charAt(0);
+		}
+		//Primer caso
+		if(valores[0] == valores[1]) {
+			if(valores[1]==valores[2]) {
+				if(valores[2] == valores[3]) {
+					return true;
+				}
+			}
+		}
+		//Segundo caso
+		if(valores[1] == valores[2]) {
+			if(valores[2]==valores[3]) {
+				if(valores[3] == valores[4]) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+	
+	protected boolean esFull(Carta[] mano) {
+		char[] valores = new char[5];
+		//Ordenamos las cartas por valor
+		mano = this.ordenarCartasValor(mano);
+		//Cargamos los valores de la mano
+		for(int i = 0;i<mano.length;i++) {
+			valores[i] = mano[i].obtenerCarta().charAt(0);
+		}
+		//Existen 2 casos
+		//Caso 1
+		if(valores[0] == valores[1]) {
+			if(valores[1]==valores[2]) {
+				if(valores[3]==valores[4]) {
+					return true;
+				}
+			}
+		}
+		//Caso 2
+		if(valores[2] == valores[3]) {
+			if(valores[3]==valores[4]) {
+				if(valores[0]==valores[1]) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+	
+	protected boolean esColor(Carta[] mano){
+		//Primero comprobamos que tengan todas las cartas el mismo palo
+		char palo = mano[0].obtenerCarta().charAt(1);
+		for(int i=1;i<5;i++) {
+			if(mano[i].obtenerCarta().charAt(1) != palo) {
+				return false;
+			}
+		}
+		return true;
+	}
+	
+	protected boolean esEscalera(Carta[] mano) {
+		boolean resultado = true;
+		char esR1 = 'p';
+		char esR2 = 'p';
+		//Ordenamos las cartas por valor
+		mano = this.ordenarCartasValor(mano);
+		//Obtenemos el valor de la primera carta y segunda carta
+		//para saber si se obtiene escalera real
+		esR1 = mano[0].obtenerCarta().charAt(0);
+		esR2 = mano[1].obtenerCarta().charAt(0);
+		//Existen dos casos, escalera real o no escalera real
+		//Caso 1: Escalera real
+		if(esR1 =='A' && esR2 == 'T') {
+			for(int i = 1;i<mano.length-1 && resultado;i++) {
+				if(!mano[i+1].esSuAnterior(mano[i])) {
+					resultado = false;
+				}
+			}
+		//Caso 2: No escalera real
+		}else{
+			for(int i = 0;i<mano.length-1 && resultado;i++) {
+				if(!mano[i+1].esSuAnterior(mano[i])) {
+					resultado = false;
+				}
+			}
+		}
+		return resultado;
+	}
+	
+	protected boolean esTrio(Carta[] mano) {
+		char[] valores = new char[5];
+		//Ordenamos las cartas por valor
+		mano = this.ordenarCartasValor(mano);
+		//Cargamos los valores de la mano
+		for(int i = 0;i<mano.length;i++) {
+			valores[i] = mano[i].obtenerCarta().charAt(0);
+		}
+		//Existen 3 casos
+		//Caso 1
+		if(valores[0] == valores[1]) {
+			if(valores[1]==valores[2]) {
+				return true;
+			}
+		}
+		//Caso 2
+		if(valores[1] == valores[2]) {
+			if(valores[2]==valores[3]) {
+				return true;
+			}
+		}
+		//Caso 3
+		if(valores[2] == valores[3]) {
+			if(valores[3]==valores[4]) {
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	protected boolean esParDoble(Carta[] mano) {
+		char[] valores = new char[5];
+		//Ordenamos las cartas por valor
+		mano = this.ordenarCartasValor(mano);
+		//Cargamos los valores de la mano
+		for(int i = 0;i<mano.length;i++) {
+			valores[i] = mano[i].obtenerCarta().charAt(0);
+		}
+		//Existen 2 casos
+		//Caso 1
+		if(valores[0] == valores[1]) {
+			if(valores[2]==valores[3]) {
+				return true;
+			}else if(valores[3]==valores[4]) {
+				return true;
+			}
+		}
+		//Caso 2
+		if(valores[1] == valores[2]) {
+			if(valores[3]==valores[4]) {
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	protected boolean esPar(Carta[] mano) {
+		char[] valores = new char[5];
+		//Ordenamos las cartas por valor
+		mano = this.ordenarCartasValor(mano);
+		//Cargamos los valores de la mano
+		for(int i = 0;i<mano.length;i++) {
+			valores[i] = mano[i].obtenerCarta().charAt(0);
+		}
+		//Realizamos las comprobaciones
+		for(int i = 0;i<mano.length-1;i++) {
+			if(valores[i]==valores[i+1]) {
+				return true;
+			}
+		}
+		return false;
+	}
+	/**
+	 * Entrega el tipo de mano que tiene el jugador
+	 * @param mano El conjunto de objeto de tipo 'Carta'
+	 * @return El tipo de mano
+	 */
+	public String mejorJugada(Carta[] mano)
+	{
+		//Ponemos como predeterminado que la mano es Carta Alta
+		int resultado = 8;
+		//Realizamos la comprobaciones
+		if(this.esEscaleraColor(mano)) {
+			resultado = 0;
+		}else if(this.esPoker(mano)) {
+			resultado = 1;
+		}else if(this.esFull(mano)) {
+			resultado = 2;
+		}else if(this.esColor(mano)) {
+			resultado = 3;
+		}else if(this.esEscalera(mano)) {
+			resultado = 4;
+		}else if(this.esTrio(mano)) {
+			resultado = 5;
+		}else if(this.esParDoble(mano)) {
+			resultado = 6;
+		}else if(this.esPar(mano)){
+			resultado = 7;
+		}
+		return jugadas[resultado];
+	}
+
+}

java-e007/src/mejorCombinacion/ClasificadorMano.java

+/*
+ * Esta clase sirve para clasificar las manos
+ * */
+
+package mejorCombinacion;
+
+import com.roshka.bootcamp004.mano.Carta;
+import com.roshka.bootcamp004.poker.*;
+
+public class ClasificadorMano extends Poker{
+	
+	
+	public int mejorJugadaNumero(Carta[] mano)
+	{
+		//Ponemos como predeterminado que la mano es Carta Alta
+		int resultado = 8;
+		//Realizamos la comprobaciones
+		if(this.esEscaleraColor(mano)) {
+			resultado = 0;
+		}else if(this.esPoker(mano)) {
+			resultado = 1;
+		}else if(this.esFull(mano)) {
+			resultado = 2;
+		}else if(this.esColor(mano)) {
+			resultado = 3;
+		}else if(this.esEscalera(mano)) {
+			resultado = 4;
+		}else if(this.esTrio(mano)) {
+			resultado = 5;
+		}else if(this.esParDoble(mano)) {
+			resultado = 6;
+		}else if(this.esPar(mano)){
+			resultado = 7;
+		}
+		return resultado;
+	}
+	
+	public String obtenerStringMano(int entrada) {
+		return this.jugadas[entrada];
+	}
+}

java-e007/src/mejorCombinacion/ClsOrdena.java

+package mejorCombinacion;
+
+import com.roshka.bootcamp004.mano.*;
+
+public class ClsOrdena {
+	final char valores[] = {'A','2','3','4','5','6','7','8','9','T','J','Q','K'};
+	final char palos[] = {'S','C','H','D'};
+	
+	/**
+     * Comprueba si el valor de la otra carta es superior, igual o inferior al valor de
+     * la carta actual
+     * @param valorE El valor de la otra carta en formato 'char'.
+     * @return 0: son iguales, 1: la carta es superior a la otra carta, -1: lo contrario al valor 1
+     */
+    //Funcion que nos permite comparar con otra carta
+    public int compararValor(char valor1,char valor2) {
+    	int numValor1 = 0;
+		int numValor2 = 0;
+		//Buscamos en que posición está cada valor
+		//Valor1
+		for(int i=0;i<valores.length;i++) {
+			if(valor1 == valores[i]) {
+				numValor1 = i;
+				break;
+			}
+		}
+		//Valor2
+		for(int i=0;i<valores.length;i++) {
+			if(valor2 == valores[i]) {
+				numValor2 = i;
+				break;
+			}
+		}
+		//Realizamos la comparación
+		if(numValor1 == numValor2) {
+			return 0;
+		}else if(numValor1 > numValor2) {
+			return 1;
+		}else {
+			return -1;
+		}
+    }
+    /**
+     * Retorna un boolean si la otra carta es un paso superior a la carta actual
+     * @param otraCarta La otra carta
+     * @return Si es o no es cierto
+     */
+    public boolean esAnterior(Carta carta1,Carta carta2) {
+    	int valor1 = 0;
+    	int valor2 = 0;
+    	//Buscamos la posicion del valor de la otra carta
+    	for(int i=0;i<valores.length;i++) {
+			if(carta1.obtenerCarta().charAt(0) == valores[i]) {
+				valor1 = i;
+				break;
+			}
+		}
+    	//Buscamos la posicion del valor de esta carta
+    	for(int i=0;i<valores.length;i++) {
+			if(carta2.obtenerCarta().charAt(0) == valores[i]) {
+				valor2 = i;
+				break;
+			}
+		}
+    	//averiguamos si es el siguiente
+    	if(valor1 != (valor2+1)) {
+    		return false;
+    	}
+    	return true;
+    }
+}

java-e007/src/mejorCombinacion/Combinaciones.java

+/*
+ * En esta clase se generan todas las manos de cartas posibles.
+ * Obtiene un conjunto de 7 cartas (llamado "cartas en la mesa"), y genera combinaciones de 5 cartas
+ * El conjunto de cartas tambien se carga manualmente (cargar cartas en la mesa manual)
+ * */
+
+package mejorCombinacion;
+
+import java.util.ArrayList;
+
+import com.roshka.bootcamp004.mano.*;
+
+public class Combinaciones {
+	Carta [][] combinaciones;
+	Carta[] cartasEnlaMesa;
+	
+	public Combinaciones() {
+		this.combinaciones = new Carta[2520][5];//Variable donde carga todas las combinaciones de carta
+		Mano mano = new Mano();
+		this.cartasEnlaMesa = (new ClasificadorMano()).ordenarCartasValor(mano.aArrayTipoCarta());
+		//Imprime las cartas
+		System.out.println("Las cartas de la mesa son:");
+		System.out.println(mano.aCadena());
+		//Cargamos las combinaciones
+		this.cargarManosPosibles();
+	}
+	
+	//Este metodo carga las manos de cartas
+	private void cargarManosPosibles() {
+		ArrayList<ArrayList<Integer>> pos_combinaciones = this.generarCombinaciones();
+		//Ahora vamos a cargar las cartas
+		for(int i=0;i<this.combinaciones.length;i++) {
+			for(int j=0;j<this.combinaciones[i].length;j++) {
+				this.combinaciones[i][j] = this.cartasEnlaMesa[pos_combinaciones.get(i).get(j)];
+			}
+		}
+	}
+	
+	//Este metodo carga las "cartas en la mesa" de forma manual
+	public void cargarCartasEnLaMesaManual(Carta[] cargar) {
+		if(cargar.length==7) {
+			this.cartasEnlaMesa = cargar;
+			this.combinaciones = new Carta[2520][21];
+			this.cargarManosPosibles();
+		}else {
+			System.out.println("Se necesita solo 7 cartas");
+		}
+	}
+	
+	//Esto te genera todas las posiciones posibles, basado en la permutacion
+	private  ArrayList<ArrayList<Integer>> generarCombinaciones() {
+		//Carga la combinacion actual
+		ArrayList<Integer> combinacion;
+		//Carga las combinaciones posibles
+        ArrayList<ArrayList<Integer>> resultado = new ArrayList<>();
+        //Numero base para hallar la combinacion por medio de la division
+        int numero = 16806;
+        //Numero necesario para hallar todas las combinaciones posibles
+        int numero_base = numero;
+        //Actua mientras exista combinaciones posibles
+        while(numero_base>=0) {
+            combinacion = new ArrayList<>();//Creamos una carga de combinacion
+            while(numero>=7) {//Carga las combinaciones mientras la dividendo sea mayor a 7
+                combinacion.add(numero%7);//Carga el resto
+                numero = numero/7;//Realiza la division
+            }
+            combinacion.add(numero);//Carga el numero menor al 7
+            while(combinacion.size()<5) {//Comprueba si aun hay lugar en el bloque, y los carga con cero
+                combinacion.add(0);
+            }
+            resultado.add(combinacion);//Carga la combinacion
+            numero_base = numero_base -1;//Creamos la base para la siguiente combinacion
+            numero = numero_base;
+        }
+        //Esto sirve para simplificar las combinaciones
+        //Se coloca 2521, porque la permutacion de 7 elementos que se desea armar 5 combinaciones sin importar la posicion
+        //da como resultado 2520
+        while(resultado.size()>2521){
+	        for(int k = 0;k<resultado.size();k++){
+	            ArrayList<Integer> indice = resultado.get(k);
+	            boolean valido = true;
+	            for(int i = 0;i<indice.size()-1 && valido;i++){
+	                for(int j=i+1;j<indice.size() && valido;j++){
+	                    if(indice.get(i)==indice.get(j)){
+	                        // System.out.println("Borrado: "+indice.toString());
+	                        valido = false;
+	                    }
+	                }
+	            }
+	            if(!valido){
+	                resultado.remove(k);
+	            }
+	        }
+        }
+        //Ahora vamos a ordenar para despues hallar las lista con permutacion
+        for(int i = 0;i<resultado.size();i++){
+            //Recorre la combinacion
+            for(int j = 0;j<resultado.get(i).size()-1;j++){
+                int menor = resultado.get(i).get(j);
+                int pos_menor = j;
+                for(int k = j+1;k<resultado.get(i).size();k++){
+                    if(resultado.get(i).get(k)<menor){
+                        menor = resultado.get(i).get(k);
+                        pos_menor = k;
+                    }
+                }
+                if(pos_menor!=j){
+                    int aux = resultado.get(i).get(j);
+                    resultado.get(i).set(j,resultado.get(i).get(pos_menor));
+                    resultado.get(i).set(pos_menor,aux);
+                }
+            }
+        }
+		return resultado;
+	}
+	
+	
+	public Carta[][] obtenerCombinaciones(){
+//		for(int i=0;i<this.combinaciones.length;i++) {
+//			String cartas="";
+//			for(int j=0;j<this.combinaciones[i].length;j++) {
+//				cartas=cartas+this.combinaciones[i][j].obtenerCarta() + " ";
+//			}
+//			System.out.println(cartas);
+//		}
+		return this.combinaciones;
+	}
+}

java-e007/src/mejorCombinacion/EjecutarPrograma.java

+package mejorCombinacion;
+
+import com.roshka.bootcamp004.mano.Carta;
+
+public class EjecutarPrograma {
+
+	public static void main(String[] args) {
+		MejoresCombinaciones mejorCombinacion = new MejoresCombinaciones();
+		Carta[] resultado = mejorCombinacion.ganador();
+		String mano = "";
+		System.out.println("La mano ganadora es: ");
+		for(int i=0;i<resultado.length;i++) {
+			mano = mano + resultado[i].obtenerCarta()+" ";
+		}
+		System.out.println(mano);
+	}
+
+}

java-e007/src/mejorCombinacion/MejoresCombinaciones.java

+package mejorCombinacion;
+
+import java.util.ArrayList;
+import com.roshka.bootcamp004.mano.*;
+import com.roshka.bootcamp004.poker.*;
+
+public class MejoresCombinaciones {
+	int[] jugadas;//Carga los tipos de manos
+	int mejorJugada;//Carga el mejor tipo de mano
+	Carta[][] combinaciones;//Donde se almacenan todas las manos
+	ArrayList<Carta[]> mejoresJugadas;
+	
+	public MejoresCombinaciones() {
+		Combinaciones combinaciones = new Combinaciones();
+		this.combinaciones = combinaciones.obtenerCombinaciones();
+		this.mejorJugada = 8;
+		this.mejoresJugadas = new ArrayList<>();
+	}
+	
+	//Establecemos quien es el ganador
+	public Carta[] ganador() {
+		Carta[] resultado = null;
+		//Primero vamos a clasificar las combinaciones
+		this.clasificarJugadas();
+		//Despues establece cual es la mejor jugada
+		this.mejorJugada();
+		//Cargamos en un array las mejores jugadas
+		for(int i=0;i<this.jugadas.length;i++){
+			if(this.jugadas[i] == this.mejorJugada) {
+				this.mejoresJugadas.add(this.combinaciones[i]);
+			}
+		}
+		//obtenemos la mejor jugada
+		if(this.mejoresJugadas.size()==1) {
+			System.out.println("Mejor Jugada: "+this.mejoresJugadas.get(0));
+			resultado = this.mejoresJugadas.get(0);
+		}else {
+			System.out.println("Mejor Jugada: "+(new Poker()).jugadas[this.mejorJugada]);
+			//Clasificamos cual de las mejores jugadas, es la mejor jugada
+			resultado = (new SelectorGanador(this.mejoresJugadas,this.mejorJugada)).procesar();
+		}
+		return resultado;
+	}
+	
+	//Crea la lista de tipos de jugadas
+	private void clasificarJugadas() {
+		this.jugadas = new int[this.combinaciones.length];
+		ClasificadorMano clasifica = new ClasificadorMano();
+		for(int i=0;i<this.jugadas.length;i++) {
+			this.jugadas[i] = clasifica.mejorJugadaNumero(combinaciones[i]);
+		}
+	}
+	
+	//Halla la mejor jugada
+	private void mejorJugada() {
+		for(int i = 0;i<jugadas.length;i++) {
+			if(this.mejorJugada>jugadas[i]) {
+				this.mejorJugada = jugadas[i];
+			}
+		}
+	}
+}