Ejercicio resuelto del documento java-e003.pdf

Generala.java

+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+import java.io.File;
+import java.util.Scanner;
+public class Generala
+{
+    // ESTA ES LA FUNCIÓN QUE HAY QUE IMPLEMENTAR
+    // TAMBIÉN PUEDEN AGREGAR OTRAS FUNCIONES y/o CLASES
+    // QUE NECESITEN PARA RESOLVER EL EJERCICIO DE LA
+    // MANERA MÁS ORDENADA POSIBLE
+    String jugada(String dados){
+        try{
+            //Comprueba si se recibio un numero y si el numero es negativo o igual a cero
+            if(Integer.parseInt(dados)<=0){
+                return "INVALIDO";
+            }
+            //Comprobamos si tiene el tamano de caracteres correspondientes
+            if(dados.length()!=5){
+                return "INVALIDO";
+            }
+            //Comprobamos si cada digito de la cadena es entre 1 y 6
+            if(!comprobarDigitos(dados)){
+                return "INVALIDO";
+            }
+            //Convertimos a array de enteros para facilitar el proceso
+            int[] convertido = convertirAArray(dados);
+            //Ordenamos los dados para facilitar el resultado
+            convertido = ordenar(convertido);
+            //Analizamos la jugada
+            if(generala(convertido)){
+                return "GENERALA";
+            }else if(poker(convertido)){
+                return "POKER";
+            }else if(full(convertido)){
+                return "FULL";
+            }else if(escalera(convertido)){
+                return "ESCALERA";
+            }
+        }catch(Exception e){
+            return "INVALIDO";
+        }
+        return "NADA";
+    }
+
+    boolean comprobarDigitos(String dados){
+        for(int i = 0;i<dados.length();i++){
+            if(Integer.parseInt("" + dados.charAt(i))>6 || Integer.parseInt("" + dados.charAt(i))==0){
+                return false;
+            }
+        }
+        return true;
+    }
+
+    //Convierte la cadena de dados en un array para asi trabajar mejor
+    int[] convertirAArray(String dados){
+        int[] resultado = new int[5];
+        for(int i = 0;i<dados.length();i++){
+            resultado[i] = Integer.parseInt("" + dados.charAt(i));
+        }
+        return resultado;
+    }
+
+    //Ordena la secuencia de dados para facilitar el proceso del resultado
+    int[] ordenar(int[] dados){
+        int menor = 0;
+        int pos_menor = 0;
+        //Realizamos el ordenamiento
+        for(int i=0;i<dados.length-1;i++){
+            menor = dados[i];
+            pos_menor = i;
+            for(int j = i+1;j<dados.length;j++){
+                if(dados[j]<menor){
+                    menor = dados[j];
+                    pos_menor = j;
+                }
+            }
+            if(menor!=dados[i]){
+                int aux = dados[i];
+                dados[i] = dados[pos_menor];
+                dados[pos_menor] = aux;
+            }
+        }
+        return dados;
+    }
+
+    boolean generala(int[] dados){
+        int comparar = dados[0];
+        for(int i = 1;i<dados.length;i++){
+            if(comparar != dados[i]){
+                return false;
+            }
+        }
+        return true;
+    }
+
+    boolean poker(int[] dados){
+        boolean oportunidad1 = true;
+        boolean oportunidad2 = true;
+        //Esto es si el unico numero está en el extremo izquierdo
+        for(int i = 1;i<dados.length-1;i++){
+            if(dados[i]!=dados[i+1]){
+                oportunidad1 = false;
+                break;
+            }
+        }
+        //Esto es si el unico numero está en el extremo derecho
+        for(int i = 0;i<dados.length-2;i++){
+            if(dados[i]!=dados[i+1]){
+                oportunidad2 = false;
+                break;
+            }
+        }
+        if(oportunidad1 || oportunidad2){
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    boolean full(int[] dados){
+        //Esto es si los dos numeros iguales están en el extremo derecho
+        boolean parte1 = dados[0] == dados[1];
+        boolean parte2 = dados[2] == dados[3] && dados[3] == dados[4];
+        if(parte1 && parte2){
+            return true;
+        }
+        //Esto es si los dos numeros iguales están en el extremo izquierdo
+        parte1 = dados[0] == dados[1] && dados[1] == dados[2];
+        parte2 = dados[3] == dados[4];
+        if(parte1 && parte2){
+            return true;
+        }
+        return false;
+    }
+
+    boolean escalera(int[] dados){
+        boolean oportunidad1 = true;
+        boolean oportunidad2 = true;
+        boolean suboportunidad2 = true;
+        //Hallar si es escalera sin el comodin
+        for(int i = 0;i<dados.length-1;i++){
+            if(dados[i]!=dados[i+1]-1){
+                oportunidad1 = false;
+                break;
+            }
+        }
+        //Hallar si es escalera con el comodin
+        //Si el valor uno está en el extremo izquierdo
+        for(int i = 1;i<dados.length-1;i++){
+            if(dados[i]!=dados[i+1]-1){
+                oportunidad2 = false;
+                break;
+            }
+        }
+        //Si el valor uno está en el extremo izquierdo
+        for(int i = 0;i<dados.length-2;i++){
+            if(dados[i]!=dados[i+1]-1){
+                suboportunidad2 = false;
+                break;
+            }
+        }
+        //Analizamos si ocurrio uno de los siguientes casos
+        if(oportunidad1 || oportunidad2 || suboportunidad2){
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    // Ustedes pueden ignorar esto
+    String[] jugadas(String[] losdados){
+        String[] ret = new String[losdados.length];
+        int i = 0;
+        for (String dados : losdados)
+        {
+            ret[i] = this.jugada(dados);
+            i++;
+        }
+        return ret;
+    }
+    // Ustedes pueden ignorar esto
+    static String[] processBatch(String fileName) throws Exception{
+        Scanner sc = new Scanner(new File(fileName));
+        List<String> lines = new ArrayList<String>();
+        while (sc.hasNextLine()) {
+            lines.add(sc.nextLine());
+        }
+        return lines.toArray(new String[0]);
+    }
+    public static void main(String[] args) throws Exception{
+        Generala g = new Generala();
+        Scanner teclado = new Scanner(System.in);
+        /* IGNORAR PORQUE ESTO NO SE VA A EJECUTAR PARA USTEDES */
+        if (args.length > 0) {
+            String[] jugadas = processBatch(args[0]);
+            String resultados[] = g.jugadas(jugadas);
+            for(String res : resultados) {
+                System.out.println(res);
+            }
+            return;
+        }
+        System.out.println("Ingrese la secuencia");
+        String secuencia = teclado.nextLine();
+        // ESTO SI SE EJECUTA PARA USTEDES
+        System.out.println(g.jugada(secuencia));
+    }
+}
+
+/*
+
+2. Responder a las siguientes preguntas (30 puntos)
+2.1. Cuál es la probabilidad de sacar generala en un tiro
+    Utilizando la regla de laplace
+    La probabilidad es 6 / (6^5). Es decir, 6 aciertos de (6^5) combinaciones posibles.
+    El numero 6 del 6^5 es la cantidad de valores que soporta el dado.
+    El numero 5 del 6^5 es la cantidad de dados que existe.
+2.2. Cuál es la probabilidad de sacar poker en un tiro
+    Utilizando la regla de laplace
+    La probabilidad es (6*6)/(6^5).
+    El mismo concepto que el anterior para el 6^5.
+    Para el 6*6, existen 6 valores posibles para que exista 4 dados de mismo valor, sin tomar en cuenta el 5to dado.
+    Para el 5to dado, hay 6 valores posibles.
+    Por lo tanto, cada valor del 5to dado hay seis valores posibles.
+    Multiplicando la cantidad de valores posibles del 5to dado con la cantidad de valores posibles para 4 dados iguales
+    se obtiene el número de aciertos posibles.
+2.3. Cuál es la probabilidad de sacar full en un tiro
+    Utilizando la regla de laplace
+    La probabilidad es (6*6)/(6^5).
+    Lo mismo que el de sacar poker, con diferencia que hacemos que, en vez de 4 dados iguales, sean 3 dados iguales,
+    y, en vez de un 5to dado, hacemos que sea 2 dados iguales.
+    La cantidad de valores del 5to dado y a la cantidad de valores de 2 dados iguales tienen la misma cantidad en este caso.
+    La cantidad de valores de 4 dados iguales y a la cantidad de 3 dados iguales tienen la misma cantidad en este caso.
+2.4. Cuál es la probabilidad de sacar escalera en un tiro
+    Para el resultado 12345, podemos obtener 4 * 4 combinaciones posibles.
+    Para el resultado 23456, podemos obtener 4 * 4 combinaciones posibles.
+    Para el resultado 23451, podemos obtener 4 * 4 combinaciones posibles.
+    Para el resultado 34561, podemos obtener 4 * 4 combinaciones posibles.
+    Para el resultado 12341, podemos obtener 4 * 4 combinaciones posibles.
+    4 * 4 significa 4 numeros que se pueden ubicar en 4 lugares distintos.
+    Por ejemplo, 12345, 21345, 23145, ....
+    En total son: 5 * (4 * 4) aciertos, donde el 5 es la cantidad de combinaciones base.
+    Utilizando la regla de laplace, la probabilidad es: 
+    Probalidad_escalera = (5*(4*4)) / (6^5).
+2.5. Cuál es la probabilidad de sacar nada en un tiro
+    Hallando la probabilidad del complemento, en donde el complemento es "no quitar una combinación", se tiene.
+    La probabilidad de sacar nada es: 
+    Probabilidad_Nada = 1 - Probabilidad_Generala - Probabilidad_Poker - Probabilidad_Full - Probabilidad_Escalera.
+
+3. BONUS: (hasta 10 puntos)
+3.1. Cuál es la probabilidad de sacar generala en dos tiros 
+    Utilizando la probabilidad condicionada, se obtiene:
+    Probabilidad_dos_tiros = [6 / (6^5)] * [6 / (6^5)].
+    Donde la cantidad de valores que se multiplica (en este caso son dos) es igual a la cantidad de tiros.
+    Que significa esto? Significa que para cada acierto de una generala, puede o no puede haber de nuevo una generala, y 
+    de este esta nueva generala, puede o no haber una generala, asi sicesivamente.
+3.2. Cuál es la probabilidad de sacar generala en tres tiros:
+    Utilizando la probabilidad condicionada, se obtiene:
+    Donde la cantidad de valores que se multiplica (en este caso son tres) es igual a la cantidad de tiros.
+    Probabilidad_tres_tiros = [6 / (6^5)] * [6 / (6^5)] * [6 / (6^5)].
+    Que significa esto? Significa que para cada acierto de una generala, puede o no puede haber de nuevo una generala, y 
+    de este esta nueva generala, puede o no haber una generala, asi sicesivamente.
+
+*/
\ No newline at end of file

README.md

+# Indicaciones
+El programa pide al usuario que ingrese por el teclado el resultado de la tirada de los dados.
+Retorna la jugada de la tirada en la pantalla, como se indica en el ejercicio.
+
+Las respuestas de las preguntas de probabilidad están al final de codigo de java como comentario, dentro del archivo Generala.java.
+
+ 
\ No newline at end of file