From 1d4844262d56263ac86b3c0747f0beafa6251fa2 Mon Sep 17 00:00:00 2001 From: Pedro Rolon Date: Mon, 29 Oct 2018 15:35:19 -0300 Subject: [PATCH] Se agregaron los archivos correspondientes a la tarea! --- Carta.java | 16 ++++++++++++++++ MyClass.java | 514 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ README.md | 2 ++ 3 files changed, 532 insertions(+) create mode 100644 Carta.java create mode 100644 MyClass.java create mode 100644 README.md diff --git a/Carta.java b/Carta.java new file mode 100644 index 0000000..4e1e47c --- /dev/null +++ b/Carta.java @@ -0,0 +1,16 @@ +import java.util.*; +class Carta +{ + Carta(String completo){ + + this.valor = String.valueOf(completo.charAt(0)); + this.palo = String.valueOf(completo.charAt(1)); + } + + String valorPalo(){ + return this.valor + this.palo; + } + + String valor; + String palo; +} \ No newline at end of file diff --git a/MyClass.java b/MyClass.java new file mode 100644 index 0000000..a373908 --- /dev/null +++ b/MyClass.java @@ -0,0 +1,514 @@ +import Carta; +import java.util.List; +import java.util.concurrent.ForkJoinPool; +import java.util.ArrayList; +import java.util.Arrays; + + +public class MyClass { +// este es el único método que tienen que desarrollar +// para hacerlo, pueden hacer uso de otras clases (si es necesario), +// pero la corrección del ejercicio será automática en base a este +// método que está acá + public String ganadores(List jugadas) + { + //System.out.println("Cantidad de jugadas: " + jugadas.size()); + ArrayList ganadores = new ArrayList(); + //Indica que es la primera mano + boolean esPrimero=true; + //Para contrar si hubo un nuevo valor mayor + boolean huboNuevo=false; + //Array para almacenar los índices + ArrayList indices = new ArrayList(); + //Contador que mantiene el valor del indice + int index=0; + + for (Carta[] mano : jugadas) { + // System.out.println("JUGADA ======================"); + + if(esPrimero){ + ganadores.add(mano); + indices.add(index); + esPrimero=false; + } + else{ + ArrayList calificacionMayor= calificacion(ganadores.get(ganadores.size()-1)); + ArrayList calificacionActual= calificacion(mano); + if(calificacionMayor.get(0) calificacion(Carta[] mano){ + ArrayList calificacion= new ArrayList(); + /** + * La calificacion numérica de cada carta estará en el lugar 0 del array retornado + * Escalera color -> 9 + * Poker -> 8 + * Full -> 7 + * Color -> 6 + * Escalera -> 5 + * Trio -> 4 + * Par Doble -> 3 + * Par -> 2 + * Carta alta -> 1 + */ + + //Array para almacenar la cantidad de apariciones de cada número + int[] valores = new int[13]; + //Array para almacenar la cantidad de apariciones de cada palo + int[] palos = new int[4]; + inicializarArrays(valores, palos, mano); + + //Si es escalera, solo basta ver el valor de la escalera + if(esEscaleraColor(valores, palos)){ + int[] ordenado = ordenarMano(mano); + calificacion.add(9); + if(ordenado[4]==13 && ordenado[0]==1){ + calificacion.add(14); + } + else{ + calificacion.add(ordenado[4]); + } + } + else if(esPoker(valores)){ + //Si es poker, se envia la calificacion en el primer elemento, seguido del + //valor que hizo que sea poker, seguido del valor diferente + calificacion.add(8); + calificacion.add(indiceDe(4,valores)); + calificacion.add(indiceDe(1,valores)); + } + else if(esFull(valores)){ + //No hay empate en full, por lo tanto solo hace falta + //el valor de la mano + calificacion.add(7); + calificacion.add(indiceDe(3, valores)); + } + else if(esColor(palos)){ + int aux=0; + calificacion.add(6); + + //Si hay un AS, se coloca directamente después de la + //calificación + if(indiceDe(1, valores)!=-1){ + calificacion.add(14); + //si ya se encontró el 1, entonces este ya no se + //debe agregar al array de calificacion + aux=1; + } + int[] ordenado = ordenarMano(mano); + + for (int i = 4; i >= aux; i--) { + calificacion.add(ordenado[i]); + } + } + else if(esEscalera(valores)){ + int[] ordenado = ordenarMano(mano); + calificacion.add(5); + if(ordenado[4]==13 && ordenado[0]==1){ + calificacion.add(14); + } + else{ + calificacion.add(ordenado[4]); + } + } + else if(esTrio(valores)){ + calificacion.add(4); + calificacion.add(indiceDe(3, valores)); + int[] ordenado = ordenarMano(mano); + + for (int i = 4; i >=0; i--) { + if(calificacion.get(0)!=ordenado[i]){ + calificacion.add(ordenado[i]); + } + } + } + else if(esParDoble(valores)){ + calificacion.add(3); + calificacion.add(indiceDeReversa(2, valores)); + calificacion.add(indiceDe(2, valores)); + calificacion.add(indiceDe(1,valores)); + } + else if(esPar(valores)){ + calificacion.add(2); + calificacion.add(indiceDe(2, valores)); + int[] ordenado = ordenarMano(mano); + + + for (int i = 4; i >=0; i--) { + if(calificacion.get(0)!=ordenado[i]){ + calificacion.add(ordenado[i]); + } + } + } + else{ + int aux=0; + calificacion.add(1); + //Si hay un AS, se coloca directamente después de la + //calificación + if(indiceDe(1, valores)!=-1){ + calificacion.add(14); + //si ya se encontró el 1, entonces este ya no se + //debe agregar al array de calificacion + aux=1; + } + int[] ordenado = ordenarMano(mano); + + for (int i = 4; i >= aux; i--) { + calificacion.add(ordenado[i]); + } + } + + + return calificacion; + } + + private int indiceDe(int elemento, int[] vector){ + + for (int i = 0; i < vector.length; i++) { + if(vector[i]==elemento) return i; + } + + //retorna -1 si no encuentra; + return -1; + } + private int indiceDeReversa(int elemento, int[] vector){ + + for (int i = vector.length-1; i <=0; i--) { + if(vector[i]==elemento) return i; + } + + //retorna -1 si no encuentra; + return -1; + } + + private int[] ordenarMano(Carta[] mano){ + int[] ordenado = new int[5]; + + for (int i = 0; i < 5; i++) { + + String valorString= mano[i].valor; + if(valorString.equals("A") || valorString.equals("a")){ + ordenado[i]=1; + } + else if(valorString.equals("T") || valorString.equals("t")){ + ordenado[i]=10; + } + else if(valorString.equals("J") || valorString.equals("j")){ + ordenado[i]=11; + } + else if(valorString.equals("Q") || valorString.equals("q")){ + ordenado[i]=12; + } + else if(valorString.equals("K") || valorString.equals("k")){ + ordenado[i]=13; + } + else{ + ordenado[i] = Integer.parseInt(valorString); + } + } + return ordenado; + } + + private boolean esEscaleraColor(int[] valores, int[] palos){ + /** + * Funcionamiento: recorre el vector de valores y cuando encuentra un 1 + * enciende una bandera para comenzar a contar. + * Termina el ciclo cuando ya no quedan elementos o cuando encuentra un número + * distinto a 1. Si este número es mayor a 1, entonces termina el ciclo. + * Si el contador termina en 5, se comprueba que todos los palos sean iguales. + * esto se consigue revisando si en el vector de palos hay un 5, porque esto significa + * que todos fueron iguales + * O si hay un 4 en el contador y una A presente, también es verdadero + */ + + //bandera para activar sumador + boolean sumadorActivo=false; + + //Sumador de números contiguos + int sumador=0; + + //no se comprueba si existe A, porque despues se comprueba + //si el contador llegó a 4 y existe una A, entonces es una + //escalera + for (int i = 1; i < 13; i++) { + //Si la cantidad de aparición de un valor fue mayor a 1, + //no es posible que sea una escalera + if(valores[i]>1){ + return false; + } + + if(valores[i]==1){ + sumadorActivo=true; + } + + if(valores[i]==0 && sumadorActivo){ + break; + } + if(sumadorActivo){ + sumador++; + } + } + + //Si el sumador llegó a 5 entra al ciclo que comprueba + //o si llegó a 4 y existe una A + //si alguno de los palos vino 5 veces + if(sumador==5 || (sumador==4 && valores[0]==1)){ + for (int i = 0; i < 4; i++) { + if(palos[i]==5){ + return true; + } + } + } + return false; + } + + //Comprueba si la mano es póker + private boolean esPoker(int[] valores){ + /** + * Funcionamiento: Ordena el array de valores de forma ascendente. + * Para comprobar si existe poker, basta con mirar el último elemento del array, + * donde debería encontrarse un 4 + */ + + //Clona el array de valores + int [] ordenado = valores.clone(); + //Ordena la copia + Arrays.sort(ordenado); + + if(ordenado[12]==4){ + return true; + } + + return false; + } + + private boolean esFull(int[] valores){ + //Clona el array de valores + int [] ordenado = valores.clone(); + //Ordena la copia + Arrays.sort(ordenado); + + if(ordenado[12]==3 && ordenado[11]==2) + return true; + + return false; + } + + private boolean esColor(int[] palos){ + //Clona el array de valores + int [] ordenado = palos.clone(); + //Ordena la copia + Arrays.sort(ordenado); + + if(ordenado[3]==5) + return true; + + return false; + } + + private boolean esEscalera(int[] valores){ + //bandera para activar sumador + boolean sumadorActivo=false; + + //Sumador de números contiguos + int sumador=0; + + //no se comprueba si existe A, porque despues se comprueba + //si el contador llegó a 4 y existe una A, entonces es una + //escalera + for (int i = 1; i < 13; i++) { + + //Si la cantidad de aparición de un valor fue mayor a 1, + //no es posible que sea una escalera + if(valores[i]>1){ + return false; + } + + if(valores[i]==1){ + sumadorActivo=true; + } + + if(valores[i]==0 && sumadorActivo){ + break; + } + if(sumadorActivo){ + sumador++; + } + } + + //Si el sumador llegó a 5 entra al ciclo que comprueba + //o si llegó a 4 y existe una A + if(sumador==5 || (sumador==4 && valores[0]==1)){ + return true; + } + + return false; + } + + private boolean esTrio(int[] valores){ + //Clona el array de valores + int [] ordenado = valores.clone(); + //Ordena la copia + Arrays.sort(ordenado); + + if(ordenado[12]==3 && ordenado[11]==1 && ordenado[10]==1) + return true; + + return false; + } + + private boolean esParDoble(int[] valores){ + //Clona el array de valores + int [] ordenado = valores.clone(); + //Ordena la copia + Arrays.sort(ordenado); + + if(ordenado[12]==2 && ordenado[11]==2 && ordenado[10]==1) + return true; + return false; + } + + private boolean esPar(int[] valores){ + //Clona el array de valores + int [] ordenado = valores.clone(); + //Ordena la copia + Arrays.sort(ordenado); + + if(ordenado[12]==2 && ordenado[11]==1 && ordenado[10]==1 && ordenado[10]==1) + return true; + + return false; + } + + private static void inicializarArrays(int[] valores, int[] palos, Carta[] mano){ + //Se coloca 1 y 14 para que sea mas facil controlar las Escaleras + for (int i = 0; i < 13; i++) { + valores[i]=0; + } + for (int i = 0; i < 4; i++) { + palos[i] = 0; + } + + //carga los vectores de cantidades de aparición + for (int i = 0; i < 5; i++) { + String valorString = mano[i].valor; + String paloString = mano[i].palo; + + if(valorString.equals("A") || valorString.equals("a")){ + valores[0]++; + } + else if(valorString.equals("T") || valorString.equals("t")){ + valores[9]++; + } + else if(valorString.equals("J") || valorString.equals("j")){ + valores[10]++; + } + else if(valorString.equals("Q") || valorString.equals("q")){ + valores[11]++; + } + else if(valorString.equals("K") || valorString.equals("k")){ + valores[12]++; + } + else if(valorString.equals("J") || valorString.equals("j")){ + valores[10]++; + } + else{ + int index = Integer.parseInt(valorString); + valores[index-1]++; + } + + //Para el array de cantidades de palos + //S -> 0 + //C -> 1 + //H -> 2 + //D -> 3 + if(paloString.equals("S") || paloString.equals("s")){ + palos[0]++; + } + else if(paloString.equals("C") || paloString.equals("c")){ + palos[1]++; + } + else if(paloString.equals("H") || paloString.equals("h")){ + palos[2]++; + } + else if(paloString.equals("D") || paloString.equals("d")){ + palos[3]++; + } + } + } + + private void imprimirGanadores(ArrayList ganadores){ + //System.out.println(ganadores.size()); + for (int i = 0; i < ganadores.size(); i++) { + for (int j = 0; j < 5; j++) { + System.out.print(ganadores.get(i)[j].valorPalo()); + } + System.out.println(); + } + } + + public static void main(String args[]) { + int x=10; + int y=25; + int z=x+y; + + MyClass mc = new MyClass(); + + List jugadas = new ArrayList(); + + Carta[] m1 = new Carta[5]; + m1[0] = new Carta("AH"); + m1[1] = new Carta("AD"); + m1[2] = new Carta("TH"); + m1[3] = new Carta("TC"); + m1[4] = new Carta("6S"); + + Carta[] m2 = new Carta[5]; + m2[0] = new Carta("AH"); + m2[1] = new Carta("KD"); + m2[2] = new Carta("QH"); + m2[3] = new Carta("3C"); + m2[4] = new Carta("3S"); + + jugadas.add(m1); + jugadas.add(m2); + + String ganadores = mc.ganadores(jugadas); + + System.out.println("Sum of x+y = " + z); + System.out.println("Ganadores = " + ganadores); + } +} \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..bddb087 --- /dev/null +++ b/README.md @@ -0,0 +1,2 @@ +# Documentación +* Él método **ganadores()** de la clase **MyClass** retorna un string que está compuesto por el índice de él o los ganadores separados por un espacio. \ No newline at end of file -- libgit2 0.26.0