Hola a todos, hoy os voy a explicar como podemos generar un cartón de bingo con Java.
Seguro que alguna vez has jugado al bingo en tu vida, tenemos unos cartones con una serie de números y de huecos, pero ¿Cómo podríamos generarlos? Vamos a verlo.
Formato y reglas de un cartón de bingo
El cartón de bingo tiene unas reglas especificas que se deben cumplir:
- Cada fila tiene 5 números y 4 huecos vacíos.
- Cada columna tiene 1 número y 2 huecos o 2 números y 1 hueco vacío.
- Las columnas están ordenadas de menor a mayor, siendo el menor el que mas arriba este.
- Cada columna tiene un rango de números:
- Columna 1: 1-9
- Columna 2: 10-19
- Columna 3: 20-29
- Columna 4: 30-39
- Columna 5: 40-49
- Columna 6: 50-59
- Columna 7: 60-69
- Columna 8: 70-79
- Columna 9: 80-90
Analiza esta foto y comprueba que se cumple todo lo anterior:
Te dejo un PDF con más ejemplos.
Pasos a realizar para crear un cartón de bingo
¿Cómo lo representamos? El cartón de bingo lo vamos a representar como una matriz de números de 3 filas y 9 columnas. Los huecos los representaremos como un -1.
Tenemos una serie de pasos que tenemos que realizar para generarlo:
- Rellenar nuestra matriz de números.
- Ordenar números por cada columna.
- Poner los huecos.
- Mostrar el cartón, sustituyendo -1 por el carácter deseado.
Seguramente, te estés preguntado que porque no marco los huecos antes de rellenar todo si luego lo voy a sustituir por -1, la razón es simple, por la ordenación de columnas, ya que puede afectar a la ordenación, se puede hacer, pero implica más código.
Código base para nuestro cartón de bingo
Para cada paso, utilizaremos una función pero tendremos un código inicial que es este:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
package ejercicio_matrices_ddr_14; import java.util.Arrays; public class Ejercicio_matrices_DDR_14 { public static void main(String[] args) { int[][] carton = new int[3][9]; // Rellenar numeros en el carton // Ordena cada columna del carton // Marca los huecos del cartón // Mostramos el cartón } public static int generaNumeroAleatorio(int minimo, int maximo) { return (int) (Math.random() * (maximo - minimo + 1) + (minimo)); } } |
Si te interesa saber más como generar números aleatorios lo puedes ver en este tutorial:
Como generar números aleatorios con el método Math.random de Java
Rellenar números de nuestro cartón de bingo
Nuestro primer paso, será rellenar la matriz de números aleatorios, este seria el código para rellenar los números:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
public static void rellenarNumerosCarton(int[][] carton) { // Declaramos las variables necesarias int numAleatorio; boolean repetido; // Recorre los números for (int j = 0; j < carton[0].length; j++) { for (int i = 0; i < carton.length; i++) { do { repetido = false; // Genera un número aleatorio // En la columna 0, el numero estará entre 1 y 9 // Entre las columnas 1 y 7, el numero estará entre (10 * j) y ((10 * j) + 9) // En la columna 8, el numero estará entre 80 y 90 switch (j) { case 0: numAleatorio = generaNumeroAleatorio(1, 9); break; case 8: numAleatorio = generaNumeroAleatorio(80, 90); break; default: numAleatorio = generaNumeroAleatorio(10 * j, (10 * j) + 9); break; } // Se puede hacer con un bucle // Comprobamos si se repite el primero if (i == 1 && carton[0][j] == numAleatorio) { repetido = true; // Comprobamos si se repite el primero o el segungo } else if (i == 2 && (carton[0][j] == numAleatorio || carton[1][j] == numAleatorio)) { repetido = true; } } while (repetido); // Añadimos el número carton[i][j] = numAleatorio; } } } |
Ordenar números por cada columna de nuestro cartón de bingo
El siguiente paso es ordenar cada una de las columnas. Este es el código:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
public static void ordenarColumnasCarton(int[][] carton) { int[] numeros = new int[3]; for (int j = 0; j < carton[0].length; j++) { // Obtengo los numeros de la columna x for (int i = 0; i < carton.length; i++) { numeros[i] = carton[i][j]; } // Ordeno los numeros Arrays.sort(numeros); // Vuelvo a asignar los valores, ya ordenados for (int i = 0; i < numeros.length; i++) { carton[i][j] = numeros[i]; } } } |
Poner los huecos en nuestro cartón
Esta parte es la más difícil de todas, ya que hay ciertas cosas que debemos tener en cuenta.
Lo primero que podemos pensar, es que si ponemos aleatoriamente los huecos en cada fila ya estaría, el problema de esto es que es muy probable es que se queden columnas sin huecos o que se repartan mal los huecos.
Mi consejo es generar grupos de huecos por cada columna, habiendo 6 grupos de 1 hueco vacío y 3 grupos de 2 huecos vacíos, revisa la foto del inicio y veras que se cumple. Por lo que cuando estemos en una columna que tenga dos huecos, recorreremos de nuevo la columna.
La estrategia es la siguiente, debemos «nivelar» el numero de huecos, es decir, si tenemos 3 huecos en la fila 0 y 1 y en la fila 2 hay 2 huecos, debemos darle prioridad a este ultimo, para que estén nivelados. En caso de empate, elegiremos un hueco al azar. Tendremos un array para indicar si una posición de la columna esta o no disponible para poner un hueco vacio.
Resumen
- Generar un array con 6 unos y 3 doses.
- Recorrer las columnas.
- Marcar todos los huecos disponibles.
- Comprobar si el numero de huecos vacíos son iguales.
- Sino son iguales, buscamos la fila con menores huecos e indicamos que el resto no están disponibles.
- Coloco el hueco vacío en una posición aleatoria disponible.
- Si es una columna en la que tengo que poner 2 huecos vacíos, compruebo el numero de posiciones ocupadas y si es menor que 2, restamos en uno el índice de la columna para que vuelva a hacer todo el proceso.
- Volvemos al paso 3.
Te muestro el código explicado paso a paso:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 |
public static void marcarHuecosCarton(int[][] carton) { // generar un array de 9 posiciones con 6 unos y 3 doses int[] distribucion = {1, 1, 1, 1, 1, 1, 1, 1, 1}; int posicionAleatoria; // Solo generamos 3 doses for (int i = 0; i < 3; i++) { do { posicionAleatoria = generaNumeroAleatorio(0, distribucion.length - 1); } while (distribucion[posicionAleatoria] == 2); // Colocamos un 2 distribucion[posicionAleatoria] = 2; } // Recorrer array e ir llevando una cuenta del numero de huecos de cada fila, no puede superar 4 int numHuecos[] = new int[3]; boolean huecoDisponible[] = new boolean[3]; int menor, filaAleatoria, posOcupadas; boolean iguales; for (int j = 0; j < carton[0].length; j++) { // Marco las posiciones como disponible Arrays.fill(huecoDisponible, true); // Compruebo si son iguales iguales = true; for (int i = 0; i < numHuecos.length - 1 && iguales; i++) { if (numHuecos[i] != numHuecos[i + 1]) { iguales = false; } } // Sino son iguales, debo descartar aquellos que distintos al menor hueco if (!iguales) { // Busco el menor hueco menor = numHuecos[0]; for (int i = 1; i < numHuecos.length; i++) { if (numHuecos[i] < menor) { menor = numHuecos[i]; } } // Marco como no disponible los huecos diferentes al menor for (int i = 0; i < huecoDisponible.length; i++) { if (numHuecos[i] != menor) { huecoDisponible[i] = false; } } } // Compruebo donde colocar los huecos do { // Genero una fila aleatoria filaAleatoria = generaNumeroAleatorio(0, carton.length - 1); // Salgo si el hueco esta disponible y no esta repetido } while (!huecoDisponible[filaAleatoria] || carton[filaAleatoria][j] == -1); // Coloco el hueco carton[filaAleatoria][j] = -1; // Incremento en 1 el numero de huecos de esa fila numHuecos[filaAleatoria]++; // Solo compruebo las posiciones ocupadas si tengo que poner dos huecos if (distribucion[j] == 2) { // Compruebo cuantos huecos hay en la columna posOcupadas = 0; for (int i = 0; i < carton.length; i++) { if (carton[i][j] == -1) { posOcupadas++; } } // Si hay menos posiciones ocupadas que el de la distribucion de la columna, repetimos if (posOcupadas < distribucion[j]) { j--; } } } } |
Mostrar el cartón
Y ya por fin, el último paso que es mostrar nuestro cartón. Recuerda que los huecos los hemos marcado como -1, este es el código:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
public static void mostrarCarton(int[][] carton) { // Recorremos el carton for (int i = 0; i < carton.length; i++) { for (int j = 0; j < carton[i].length; j++) { // Si es -1, ponemos un * o **, segun la columna if (carton[i][j] == -1) { // Si es la primera columna, pongo un * y sino pongo 2 * if (j == 0) { System.out.print("* "); } else { System.out.print("** "); } } else { // Muestro el valor tal cual System.out.print(carton[i][j] + " "); } } // Salto de linea System.out.println(""); } } |
Resultado
El código final es el siguiente:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 |
package ejercicio_matrices_ddr_14; import java.util.Arrays; public class Ejercicio_matrices_DDR_14 { public static void main(String[] args) { int[][] carton = new int[3][9]; // Rellenar numeros en el carton rellenarNumerosCarton(carton); // Ordena cada columna del carton ordenarColumnasCarton(carton); // Marca los huecos del cartón marcarHuecosCarton(carton); // Mostramos el cartón mostrarCarton(carton); } public static void rellenarNumerosCarton(int[][] carton) { // Declaramos las variables necesarias int numAleatorio; boolean repetido; // Recorre los números for (int j = 0; j < carton[0].length; j++) { for (int i = 0; i < carton.length; i++) { do { repetido = false; // Genera un número aleatorio // En la columna 0, el numero estará entre 1 y 9 // Entre las columnas 1 y 7, el numero estará entre (10 * j) y ((10 * j) + 9) // En la columna 8, el numero estará entre 80 y 90 switch (j) { case 0: numAleatorio = generaNumeroAleatorio(1, 9); break; case 8: numAleatorio = generaNumeroAleatorio(80, 90); break; default: numAleatorio = generaNumeroAleatorio(10 * j, (10 * j) + 9); break; } // Se puede hacer con un bucle // Comprobamos si se repite el primero if (i == 1 && carton[0][j] == numAleatorio) { repetido = true; // Comprobamos si se repite el primero o el segungo } else if (i == 2 && (carton[0][j] == numAleatorio || carton[1][j] == numAleatorio)) { repetido = true; } } while (repetido); // Añadimos el número carton[i][j] = numAleatorio; } } } public static void ordenarColumnasCarton(int[][] carton) { int[] numeros = new int[3]; for (int j = 0; j < carton[0].length; j++) { // Obtengo los numeros de la columna x for (int i = 0; i < carton.length; i++) { numeros[i] = carton[i][j]; } // Ordeno los numeros Arrays.sort(numeros); // Vuelvo a asignar los valores, ya ordenados for (int i = 0; i < numeros.length; i++) { carton[i][j] = numeros[i]; } } } public static void marcarHuecosCarton(int[][] carton) { // generar un array de 9 posiciones con 6 unos y 3 doses int[] distribucion = {1, 1, 1, 1, 1, 1, 1, 1, 1}; int posicionAleatoria; // Solo generamos 3 doses for (int i = 0; i < 3; i++) { do { posicionAleatoria = generaNumeroAleatorio(0, distribucion.length - 1); } while (distribucion[posicionAleatoria] == 2); // Colocamos un 2 distribucion[posicionAleatoria] = 2; } // Recorrer array e ir llevando una cuenta del numero de huecos de cada fila, no puede superar 4 int numHuecos[] = new int[3]; boolean huecoDisponible[] = new boolean[3]; int menor, filaAleatoria, posOcupadas; boolean iguales; for (int j = 0; j < carton[0].length; j++) { // Marco las posiciones como disponible Arrays.fill(huecoDisponible, true); // Compruebo si son iguales iguales = true; for (int i = 0; i < numHuecos.length - 1 && iguales; i++) { if (numHuecos[i] != numHuecos[i + 1]) { iguales = false; } } // Sino son iguales, debo descartar aquellos que distintos al menor hueco if (!iguales) { // Busco el menor hueco menor = numHuecos[0]; for (int i = 1; i < numHuecos.length; i++) { if (numHuecos[i] < menor) { menor = numHuecos[i]; } } // Marco como no disponible los huecos diferentes al menor for (int i = 0; i < huecoDisponible.length; i++) { if (numHuecos[i] != menor) { huecoDisponible[i] = false; } } } // Compruebo donde colocar los huecos do { // Genero una fila aleatoria filaAleatoria = generaNumeroAleatorio(0, carton.length - 1); // Salgo si el hueco esta disponible y no esta repetido } while (!huecoDisponible[filaAleatoria] || carton[filaAleatoria][j] == -1); // Coloco el hueco carton[filaAleatoria][j] = -1; // Incremento en 1 el numero de huecos de esa fila numHuecos[filaAleatoria]++; // Solo compruebo las posiciones ocupadas si tengo que poner dos huecos if (distribucion[j] == 2) { // Compruebo cuantos huecos hay en la columna posOcupadas = 0; for (int i = 0; i < carton.length; i++) { if (carton[i][j] == -1) { posOcupadas++; } } // Si hay menos posiciones ocupadas que el de la distribucion de la columna, repetimos if (posOcupadas < distribucion[j]) { j--; } } } } public static void mostrarCarton(int[][] carton) { // Recorremos el carton for (int i = 0; i < carton.length; i++) { for (int j = 0; j < carton[i].length; j++) { // Si es -1, ponemos un * o **, segun la columna if (carton[i][j] == -1) { // Si es la primera columna, pongo un * y sino pongo 2 * if (j == 0) { System.out.print("* "); } else { System.out.print("** "); } } else { // Muestro el valor tal cual System.out.print(carton[i][j] + " "); } } // Salto de linea System.out.println(""); } } public static int generaNumeroAleatorio(int minimo, int maximo) { return (int) (Math.random() * (maximo - minimo + 1) + (minimo)); } } |
Veamos algunos ejemplos:
Espero que os sea de ayuda. Si tenéis dudas, preguntad. Estamos para ayudarte.
Deja una respuesta