Se subio el archivo

Carta.java

+
+public class Carta {
+	public String valor;
+	public String palo;
+	public Carta()
+	{
+		
+	}
+	
+	public Carta(String completo)
+    {
+        this.valor = String.valueOf(completo.charAt(0));
+        this.palo = String.valueOf(completo.charAt(1));
+    }
+    
+    String valorPalo()
+    {
+        return this.valor + this.palo;
+    }
+    
+	
+}

Mano.java

+

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;
+	}
+
+}

PokerIdDeRoshka.java

+import java.util.ArrayList;
+import java.util.LinkedList;
+
+public class PokerIdDeRoshka {
+    public static void main(String[] args) {
+        // Creamos 5 objetos de carta
+      
+        Poker juego = new Poker();
+        /***Creamos una lista de array de cartas */
+        
+        ArrayList<Carta[]> manos = new ArrayList<Carta[]>();
+        int cantidadDeManos =3;//cambie aqui de acuerdo al numero de manos que poseera la lista de cartas
+        //inicializamos los valores
+        for (int i = 0; i < cantidadDeManos; i++) 
+            manos.add(new Carta[5]);
+            
+            
+        /*********************Pruebas*************** */
+        //carta alta
+        // manos.get(0)[0]= new Carta("AD");
+        // manos.get(0)[1]= new Carta("3C");
+        // manos.get(0)[2]= new Carta("5H");
+        // manos.get(0)[3]= new Carta("7S");
+        // manos.get(0)[4]= new Carta("JD");
+        
+        // //escalera color
+        // manos.get(1)[0]= new Carta("6C");
+        // manos.get(1)[1]= new Carta("5C");
+        // manos.get(1)[2]= new Carta("4C");
+        // manos.get(1)[3]= new Carta("3C");
+        // manos.get(1)[4]= new Carta("7C");
+        // //   escalera color
+        //   manos.get(2)[0]= new Carta("6C");
+        //   manos.get(2)[1]= new Carta("5C");
+        //   manos.get(2)[2]= new Carta("4C");
+        //   manos.get(2)[3]= new Carta("3C");
+        //   manos.get(2)[4]= new Carta("2C");
+        
+        
+        
+        // Full House
+        // manos.get(0)[0]= new Carta("3D");
+        // manos.get(0)[1]= new Carta("3H");
+        // manos.get(0)[2]= new Carta("2C");
+        // manos.get(0)[3]= new Carta("3C");
+        // manos.get(0)[4]= new Carta("2D");
+
+        // manos.get(1)[0]= new Carta("4D");
+        // manos.get(1)[1]= new Carta("4H");
+        // manos.get(1)[2]= new Carta("2C");
+        // manos.get(1)[3]= new Carta("4C");
+        // manos.get(1)[4]= new Carta("2D");
+
+        // manos.get(2)[0]= new Carta("3D");
+        // manos.get(2)[1]= new Carta("3H");
+        // manos.get(2)[2]= new Carta("5C");
+        // manos.get(2)[3]= new Carta("3C");
+        // manos.get(2)[4]= new Carta("5D");
+        
+        //poker
+        // manos.get(0)[0]= new Carta("6D");
+        // manos.get(0)[1]= new Carta("6S");
+        // manos.get(0)[2]= new Carta("6C");
+        // manos.get(0)[3]= new Carta("3H");
+        // manos.get(0)[4]= new Carta("6H");
+
+        // manos.get(1)[0]= new Carta("AD");
+        // manos.get(1)[1]= new Carta("AS");
+        // manos.get(1)[2]= new Carta("AH");
+        // manos.get(1)[3]= new Carta("2C");
+        // manos.get(1)[4]= new Carta("AC");
+
+        // manos.get(2)[0]= new Carta("TD");
+        // manos.get(2)[1]= new Carta("TS");
+        // manos.get(2)[2]= new Carta("TH");
+        // manos.get(2)[3]= new Carta("2C");
+        // manos.get(2)[4]= new Carta("TC");
+
+        //Triple
+        // manos.get(0)[0]= new Carta("3D");
+        // manos.get(0)[1]= new Carta("3H");
+        // manos.get(0)[2]= new Carta("AC");
+        // manos.get(0)[3]= new Carta("3C");
+        // manos.get(0)[4]= new Carta("2D");
+
+        // manos.get(1)[0]= new Carta("4D");
+        // manos.get(1)[1]= new Carta("4H");
+        // manos.get(1)[2]= new Carta("2C");
+        // manos.get(1)[3]= new Carta("4C");
+        // manos.get(1)[4]= new Carta("5D");
+
+        // manos.get(2)[0]= new Carta("AD");
+        // manos.get(2)[1]= new Carta("AH");
+        // manos.get(2)[2]= new Carta("4C");
+        // manos.get(2)[3]= new Carta("AC");
+        // manos.get(2)[4]= new Carta("5D");
+    
+        //COLOR
+        // manos.get(0)[0]= new Carta("6C");
+        // manos.get(0)[1]= new Carta("AC");
+        // manos.get(0)[2]= new Carta("9C");
+        // manos.get(0)[3]= new Carta("3C");
+        // manos.get(0)[4]= new Carta("7C");
+
+        // manos.get(1)[0]= new Carta("6C");
+        // manos.get(1)[1]= new Carta("AC");
+        // manos.get(1)[2]= new Carta("9C");
+        // manos.get(1)[3]= new Carta("3C");
+        // manos.get(1)[4]= new Carta("7C");
+
+        // manos.get(2)[0]= new Carta("6C");
+        // manos.get(2)[1]= new Carta("7C");
+        // manos.get(2)[2]= new Carta("4C");
+        // manos.get(2)[3]= new Carta("TC");
+        // manos.get(2)[4]= new Carta("2C");
+
+        //cartaalta
+        manos.get(0)[0]= new Carta("AD");
+        manos.get(0)[1]= new Carta("3C");
+        manos.get(0)[2]= new Carta("5H");
+        manos.get(0)[3]= new Carta("7S");
+        manos.get(0)[4]= new Carta("JD");
+        
+        manos.get(1)[0]= new Carta("AD");
+        manos.get(1)[1]= new Carta("3C");
+        manos.get(1)[2]= new Carta("5H");
+        manos.get(1)[3]= new Carta("7S");
+        manos.get(1)[4]= new Carta("JD");
+        
+        manos.get(2)[0]= new Carta("AD");
+        manos.get(2)[1]= new Carta("3C");
+        manos.get(2)[2]= new Carta("5H");
+        manos.get(2)[3]= new Carta("7S");
+        manos.get(2)[4]= new Carta("JD");
+        
+        System.out.println(juego.mejorJugada(manos));
+    }
+}

README.md

+COSAS A TENER EN CUENTA EN EL EJERCICIO DESARROLLADO 
+No logre concretar el desempate entre una doble pareja, pareja simple. El resto de los desempates logre hacerlo sin embargo
+no de una manera muy facil de entender ya que a mi parecer me complique mucho en el ejercicio
+por lo que me llevo demasiado tiempo el terminarlo.
+
+
+Instrucciones
+1)Compilar el archivo con javac PokerldDeRoshka.java
+2)Ejecutar el archivo con javaPokerldDeRoshka
+3)Algunos ejemplos estan implementados en el main
+
+Considerar 
+S=ESPADAS
+D=DIAMANTES
+H=CORAZONES
+C=TREBOL
+
+A=AS
+T=10
+Q=QUEEN
+J=JACK
+K=KING
+
+EJEMPLO 
+DIEZ DE ESPADAS SERIA : TS
+