Se agregaron los archivos correspondientes a la tarea!

Carta.java

+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

MyClass.java

+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<Carta[]> jugadas)
+    {
+        //System.out.println("Cantidad de jugadas: " + jugadas.size());
+        ArrayList<Carta[]> ganadores = new ArrayList<Carta[]>();
+        //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<Integer> indices = new ArrayList<Integer>();
+        //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<Integer> calificacionMayor= calificacion(ganadores.get(ganadores.size()-1));
+                ArrayList<Integer> calificacionActual= calificacion(mano);
+                if(calificacionMayor.get(0)<calificacionActual.get(0)){
+                    ganadores.clear();
+                    indices.clear();
+                    indices.add(index);
+                    ganadores.add(mano);
+                }
+                else if(calificacionMayor.get(0)==calificacionActual.get(0)){
+                    for (int i = 1; i < calificacionMayor.size(); i++) {
+                        if(calificacionMayor.get(i)<calificacionActual.get(i)){
+                            ganadores.clear();
+                            indices.clear();
+                            indices.add(index);
+                            ganadores.add(mano);
+                            huboNuevo=true;
+                            break;
+                        }
+                    }
+                    if(!huboNuevo){
+                        //Si no hubo nuevo, quiere decir que es igual al ganador, por lo tanto, se debe agregar
+                        //a la lista de ganadores sin eliminar ningún otro elemento.
+                        ganadores.add(mano);
+                        indices.add(index);
+                        huboNuevo=false;
+                    }
+                }
+            } 
+            index++;
+        }
+
+        //imprimirGanadores(ganadores);
+        String stringGanadores="";
+        for (int i = 0; i < indices.size(); i++) {
+            stringGanadores += " "+indices.get(i);
+        }
+        return stringGanadores;
+    }
+
+    private ArrayList<Integer> calificacion(Carta[] mano){
+        ArrayList<Integer> calificacion= new ArrayList<Integer>();
+        /**
+         * 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<Carta[]> 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<Carta[]> jugadas = new ArrayList<Carta[]>();
+
+        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

README.md

+# 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