No es preciso enviar un mensaje personal para estas cosas... pués para eso está precisamente el foro, y así cualquier respuesta sirve para todos.
Los mensajes privados son para cosas que no concierne a nadie más...
Hola NEBIRE, sigo teniendo dudas con la función de generar huecos; podrías ayudarme a incluirla en este código:
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
int filas, columnas; // iteradores
void generar(int matriz[3][9]);
void imprimir(int matriz[3][9]);
void huecos(int matriz[3][9]);
int main()
{
SetConsoleOutputCP(1252);
int matriz[3][9];
printf("Este es su Cartón de Bingo: \n"); generar(matriz);
huecos(matriz);
imprimir(matriz);
{
int opcion;
do
{
printf( "\n Si desea cambiar su cartón pulse 1: \n"); printf( "\n Si le ha gustado su cartón y no desea cambiarlo pulse 2: "); switch ( opcion )
{
case 1: generar(matriz);
imprimir(matriz);
printf("\n Suerte con su juego\n"); break;
case 2: printf("\nSuerte con su juego\n"); break;
}
} while ( opcion !=2 );
}
}
void generar(int matriz[3][9])
{
for(columnas=0;columnas<9;columnas++)
{
do{
for(filas=0;filas<3;filas++)
{
switch (columnas)
{
case 0:
matriz
[filas
][columnas
] = 1 + rand() % (10 + 1 - 1); break;
case 1:
matriz
[filas
][columnas
] = 11 + rand() % (20 + 1 - 11); break;
case 2:
matriz
[filas
][columnas
] = 21 + rand() % (30 + 1 - 21); break;
case 3:
matriz
[filas
][columnas
] = 31 + rand() % (40 + 1 - 31); break;
case 4:
matriz
[filas
][columnas
] = 41 + rand() % (50 + 1 - 41); break;
case 5:
matriz
[filas
][columnas
] = 51 + rand() % (60 + 1 - 51); break;
case 6:
matriz
[filas
][columnas
] = 61 + rand() % (70 + 1 - 61); break;
case 7:
matriz
[filas
][columnas
] = 71 + rand() % (80 + 1 - 71); break;
case 8:
matriz
[filas
][columnas
] = 81 + rand() % (90 + 1 - 81); break;
}//final del switch
}
}while((matriz[0][columnas]== matriz[1][columnas]) ||
(matriz[0][columnas]==matriz[2][columnas]) ||
(matriz[1][columnas]== matriz[2][columnas])||
(matriz[0][columnas]>matriz[1][columnas])||
(matriz[1][columnas]>matriz[2][columnas]));
}
}
void imprimir(int matriz[3][9])
{
for(filas=0;filas<3;filas++)
{
for(columnas=0;columnas<9;columnas++)
{
if (columnas == 0 && matriz[filas][0]!=10)
printf("[ %i ]", matriz
[filas
][columnas
]); else
printf("[ %i ]", matriz
[filas
][columnas
]); }
}
void huecos(int matriz[3][9])
{
do{
generar(matriz);
}while();
}
En el siguiente hilo di una amplia respuesta a otro usuario que preguntaba por un bingo:
https://foro.elhacker.net/buscador2-t472516.0.html;msg2134435#msg2134435Si bien algunos detalles no quedaron concretados (como tampoco haces tú). Antes de responderte con más precisión sobre el tema es preciso concretar detalles... de otro modo uno refiere cosas genéricas, que luego resulta más difícil adaptar al caso específico que uno precisa.
Por ejemplo, yo recuerdo en mis tiempos de discotecas (allá a mediados de los 80s), se puso de moda que con la entrada a la discoteca, de regalo, te daban un cartón de bingo (válido para un sorteo, esa noche en el propio local), y a veces, por superar cierto valor en las consumiciones, te daban otro, luego de medianoche en adelante paraban la música un rato y se sorteaba el bingo... recuerdo que aquellos cartones eran de 80 bolas, eran 4 líneas con 5 valores, luego cantar bingo exigía acertar 20 bolas. Sin embargo duraba mucho tiempo y al parecer las consumiciones se 'congelaban' mientras todo el mundo estaba atento al trascurrir del bingo... así que pronto cambiaron a cartones de 90 bolas, con solo 3 líneas asi solo se requerían 15 bolas para alcanzar el bingo. Aunque hay más tamaños de cartones, éste de 90 bolas es el más habitual, así que conviene aclarar los detalles de como es...
Bolas: 90
Lineas: 3
Valores por linea: 9, de los cuales 4 son 'huecos'.
Cantar linea: 5 bolas en línea
Cantar bingo: 15 bolas (3lineas x 5bolas).
Más detalles:
El cartón se reparte en columnas, cada columna acoge a los valores de una decena, así es fácil hallar el valor recién extraído del bombo.
Además, el cartón está 'equilibrado', es decir tiene bolas en todas las decenas. Para que se cumpla esto, ninguna columna debe tener 3 bolas...
Mirándolo bien entonces hay 3 columnas con solo 1 valor y 6 columnas con 2 valores.
Los cartones tienes valores comenzando en 1 y acaban en 90, esto implica que los valores acabados en 0, están en la columna anterior de la decena de la que forma parte... en las explicaciones subsiguientes, en cambio he optado por valores en el rango 0-89 y así, los valores 0,10,20,30...80 están en la misma columna que el resto de valores de la decena.
Otro detalle, es que para que el juego sea equitativo con todos, no puede haber más bolas de un valor que otro en los cartones, esto implica que todas las bolas de un bingo, deben ser alojadas en sendos cartones... así el bingo de 80 bolas se ajusta en 4 cartones (20bolas por cartón x 4cartones = las 80 bolas del bingo).
... y de igual modo para éste: 90bolas de bingo / 15bolas por cartón = 6 cartones...
Es decir las 90 bolas deben repartirse en 6 cartones, y para generar más cartones siempre deben ser de 6 en 6... luego eso que tienes en tu código de 'te gusta este cartón?'... no vale... los jugadores/apostantes/bingueros, no pueden elegir cartón, al menos no debe elegirse un cartón creado al efecto, si no en todo caso, entre los generados (igual que un jugador real, no podría elegir ningún cartón que físicamente no existe, y los que existen, han sido generados siempre en secuencias de 6 en 6...)
Y por último, los cartones deben estar bien proporcionados, con un reparto de valores equilibrado. Al caso, de cada decena debe existir valores. Los jugadores se quejarían de situaciones similares a éstas:
-- 31 32 -- 33 -- 34 35 -- (números consecutivos)
ó una como esta, (en este caso perfectamente válida)
-- 27 -- 47 67 -- -- 87 17 (números con la misma terminación)
Incluso una línea que sin ser consecutivos tuvieran varios de la misma decena alguien se quejaría:
-- -- 43 -- 48 -- 40 42 45 (todos en la misma decena)
Tampoco se libran situaciones como esta:
03 -- 06 -- -- 09 -- 85 -- 87 (unos muy bajos y otros muy altos).
Esto aunque fuera mejor, quedaría feo:
-- -- -- -- 15 31 55 62 84 (todos los huecos juntos por un lado y los valores por otro).
Se puede considerar dos formas de abordarlo, simple o complejo, según ignoremos ciertas condiciones expresadas más arriba.
Ignoro si todo esto es una tarea escolar, para la Universidad o si es algo más 'profesional', si es un trabajo para la 'Uni', quizás sea mejor obviar muchas cosas, y simplemente repartir las bolas entre los cartones sin molestarse en las otras consideraciones (obviamos mantener no más de 2 valores por decena y para 3 decenas solo 1 valor, además de constatar ordenadas las bolas en el cartón, etc...).
Si es un tarea de la 'Uni',
posiblemente sea suficiente la forma simple: repartir los números entre los cartones y alojar los huecos, sin entrar a valorar más consideraciones. Por tanto voy a considerar este útimo caso, como el tuyo, y el pseudocódigo que sigue se ajusta a esto, si luego resulta que es para un trabajo más profesional, pués avisa... es un poco más complejo, pero tampoco excesivamente, aunque si lleva más texto explicativo, para terminar de comprenderlo todo bien...
----------------------------------------
Tu primer trabajo, por tanto es barajar las 90 bolas y repartirlas entre los 6 cartones. Al caso, tras barajar el array él mismo basta inicialmente para contener los 6 cartones en crudo, considerando que cada cartón empieza en los índices múltiplos de 15 ... (cartón 1ª índices del 0 al 14, 2ª índices del 15 al 29, etc... cada 15 se alojan en un nuevo cartón).
El pseudocódigo para esto, ya te lo puse más arriba, copio y pego:
Array de bytes = funcion CrearYRellenarArray(byte cantidad)
byte k
array de bytes Bolas(0 a cantidad-1)
bucle para k desde 0 a cantidad-1
Bolas(k) = k
fin bucle
devolver Bolas
fin funcion
//Y luego se barajan, así el reparto es aleatorio:
funcion Barajar(Array de bytes Bolas, byte Cantidad)
byte i, j
entero k
Bucle para k desde cantidad-1 hasta 1 retrocediendo
i = random(ente 0 y k)
j = Bolas(i)
Bolas(i) = Bolas(k)
Bolas(k) = j
fin bucle
fin funcion
He obviado ordenar los valores de cada cartón, porque aquí la forma (simple del bingo) seguida aquí, los desordena de nuevo... al final si lo deseas puedes ordenar los valores de cada línea... a medida que se crea la línea
La 2ª tarea es generar los cartones. Una función invoca en bucle a otra que mete los huecos en cada línea de 1 cartón
// esta función manda meter los números de cada 'cartón' del array bolas en el array de cartón definitivo, con sus respectivos huecos.
// o un array de arrays...
coleccion de arrays = funcion Crear6Cartones(array de bytes Bolas, byte cantidad)
byte k
array de bytes carton
//coleccion col = nueva coleccion
bucle para k desde 0 a 5 // 6 cartones
carton = MeterHuecos(bolas, k, )
//col.Add(carton)
llamada a ImprimirEnPantalla (carton) ' si solo se ha de probar, que funciona bien, no es preciso devolver una colección, podría bastar con pasarlo por pantalla...
fin bucle
//devolver col
fin funcion
La 3ª tarea finalmente es generar un array individual para cada cartón. con sus 27 casillas (3 líneas de 9) generando los huecos...
Para ello primero se crea un array con los 27 elementos que ha de tener.
Se considera subdividido en 3 series de 9, en cada serie de ellas introduce al comienzo, 5 valores procedentes del array bolas, luego se añaden detrás los 4 'huecos' (con valor 255) ... y se baraja esa línea, así quedan repartidos los valores y los huecos...
Array de bytes = Funcion MeterHuecos(array de bytes Bolas, entero NumeroCarton)
array de bytes Carton(0 a 26)
byte i, j, n, indice, ix, v
entero k
indice = (NumeroCarton * 15) // indice en el array donde comienza este cartón...
i = 0
bucle para j desde 1 a 3 // 3 líneas
// en este bucle metemos 5 valores en una línea.
bucle para k desde indice a (indice + 4)
carton(n) = Bolas(k)
n +=1
fin bucle
indice = k
// metemos los 4 huecos (valor 255)
bucle para n desde n a n+3
carton(n) = 255
fin bucle
// Resta barajar esta línea del cartón, que es lo que hace el siguiente bucle:
bucle para k desde n-1 hasta i+1 retrocediendo
ix= random(entre i y k) // OJO: entre i y k, no entre 0 y k
v = carton(k)
carton(k) = carton(ix)
carton(ix) = v
fin bucle
i = n
fin bucle
devolver carton
fin funcion
Solo resta las llamadas a cada función...
funcion Main()
array de bytes Bolas
// coleccion col
Bolas = CrearYRellenarArray(90)
llamada a Barajar(Bolas, 90)
llamada a Crear6Cartones(Bolas, 90) ' y los imprime, para ver le resultado de cada uno.
// coleccion = Crear6Cartones(Bolas, 90)
fin funcion
...y listo, es plenamente funcional... cuando lo pases a código... como está escrito de un plumazo, quizás precise alguna pequeña corrección...
La función ImprimirEnPantalla(array de bytes Carton) queda a tu esfuerzo, no creo que tengas problemas (solo recuerda que los huecos contiene valor 255, imprime 2 espacios, o 2 guiones y para valores menores de 10, añade un 0 delante, para cuadrar bien las líneas).
Este método, puede ser suficienbtemente válido para una tarea de estudiante , ya que lo que se persigue es cumplir una funcionalidad, y que el alumno se esfuerce en entender y ser capaz de darle solución, pero no es válido para usar de forma real, los cartones resultantes podrían tener situaciones por las que un jugador tendría 'quejas', tal como te señalaba más arriba...
Si necesitas algo más 'profesional' avisa y me extiendo en los detalles de la 'forma compleja'... no lo es tanto, pero ciertamente tiene más trabajo que esto...
Aquí un resultado al ejectuarlo... Nota como siendo la forma simple, aparecen los fallos descritos al comienzo: columnas con 3 valores, o con 3 huecos, más de 3 valores seguidos, valores desordenados, más de 2 valores de la misma decena, valores de algunas decenas ausentes, etc...
Sin embargo cada línea contiene 5 valores y 4 huecos y los 6 cartones contienen todas las bolas de la 0 a la 89.
-- -- 29 15 -- 10 77 -- 02
----------------------------------------
75 70 84 -- -- -- 07 46 --
----------------------------------------
-- 21 -- 76 45 -- 24 22 --
----------------------------------------
06 42 -- 87 18 -- -- 23 --
----------------------------------------
-- 43 62 31 -- -- -- 13 33
----------------------------------------
53 -- -- -- -- 73 71 08 61
----------------------------------------
09 -- -- 88 -- 59 -- 20 38
----------------------------------------
82 14 -- -- -- -- 35 41 69
----------------------------------------
-- -- 44 -- 83 11 74 80 --
----------------------------------------
-- -- 05 26 -- -- 58 00 78
----------------------------------------
37 -- 27 55 54 -- -- 12 --
----------------------------------------
49 34 -- 56 -- -- 51 -- 48
----------------------------------------
-- 19 81 40 -- -- 17 -- 16
----------------------------------------
79 30 39 -- -- 36 -- -- 52
----------------------------------------
72 85 -- -- -- 04 68 -- 64
----------------------------------------
-- 28 -- -- 32 67 -- 60 03
----------------------------------------
-- 57 65 -- -- -- 01 66 89
----------------------------------------
-- 63 50 86 -- 47 -- -- 25
----------------------------------------
La banca para sacar las bolas usa las dos primeras funciones, esto es, crea el array y lo rellena y luego lo baraja...
Una tercera función sería un bucle que va 'cantando' las bolas que señala el bucle... el bucle va recorriendo dicho array barajado...
Autor
En línea
