Según recuerdo, el programa averigua de cuántas maneras se pueden pintar X*X cuadraditos.
Luego, a partir del 1er dibujo que cumple ciertas condiciones, averigua cuántas maneras quedan, o sea, son posibles dibujos, numerados de un modo, pero empieza a contar desde ese dibujo. Es así:
NN...
N
.
.
Me refiero a que lo único pintado de negro es la parte de arriba y la izquierda. En el video que puse, el cuadro de arriba izquierda, ven que siempre tiene un dibujo así.
Entonces, esa cantidad de posibles dibujos, la divide en la cantidad de cuadros, que están separados por una zona gris.
Entonces si son 500 dibujos supongamos, pero empieza desde el nro 10, serán 490. Supongamos que hay 49 cuadros, entonces se hace 490/49, y entonces cada cuadro mostrará 10 dibujos, aunque eso el video no lo muestra, pero el cuadro nro 0 (arriba izquierda) empezará mostrando el nro 10, el cuadro nro 1 mostrará 1ero el dibujo nro 20, el cuadro nro 2 mostrará 1ero el dibujo nro 30, y así sucesivamente.
Funciona bien cuando pongo que sean 2 cuadros por fila (y por columna) y 3 cuadraditos por fila y columna en cada cuadro. Vean que cada cuadro, dibujo, tiene 3*3 cuadraditos. Pueden ser blancos o negros.
Lo mismo si pongo 3 y 4. Lo mismo 4 y 5. Lo mismo 5 y 6. Pero 6 y 7 falla. No sé por qué, me resulta complicado averiguarlo, hay mucha Matemática en el proceso, que no recuerdo (últimamente estuve resolviendo otro problema) ¿cómo podría averiguar cual es el problema? ¿qué necesitan uds?
El código, pongo sólo lo relevante, puede que me equivoque y no esté poniendo algo importante, me avisan:
// Generador de dibujos.
//
// Se insertarán cuadros numerados así:
// 0 1
// 2 3
// En cada uno se insertarán cuadraditos numerados al revés (ver...
// Por qué cuadraditos numerados inversamente.txt por detalles).
//
// Usada en InsertarCuadros sólo 1 vez
// (ergo podría no ser una función, pero por ahora simplifica):
function AjustarVariables () {
Cuadros = CuadrosPorFila*CuadrosPorFila;
MaxCuadro = Cuadros-1;
Cuadraditos = CuadraditosPorFila*CuadraditosPorFila;
MaxCuadradito = Cuadraditos-1;
LargoDeCuadraditos = 384/(CuadraditosPorFila*CuadrosPorFila+CuadrosPorFila-1);
LargoDeCuadros = CuadraditosPorFila*LargoDeCuadraditos;
// Esto es para que el 1er dibujo sea una L al revés...
// porque es de número más alto que tiene algún...
// cuadradito pintado en cada fila y columna (en realidad
// el 1ero es el que tiene despintado el punto de unión,
// pero hay poca diferencia) esto es para evitar que...
// se salteén montones de dibujos.
// Se averigua su número representante en binario:
// Para formar la _
DibujoEnBinario = String(Math.pow(10, CuadraditosPorFila));
// Quitar el 1:
DibujoEnBinario = DibujoEnBinario.substring(1, CuadraditosPorFila+1);
// Esto forma las filas siguientes, con el 1ero pintado:
NroDelCaracter = Cuadraditos-CuadraditosPorFila;
AnterioraPintar = MaxCuadradito-CuadraditosPorFila;
do {
NroDelCaracter--;
if (NroDelCaracter != AnterioraPintar) {
DibujoEnBinario = 1+DibujoEnBinario;
} else {
DibujoEnBinario = 0+DibujoEnBinario;
AnterioraPintar = AnterioraPintar-CuadraditosPorFila;
}
} while (NroDelCaracter>0);
// trace("DibujoEnBinario que hace la L invertida: "+DibujoEnBinario);
// Convertirlo en decimal:
DibujoaMostrar = 0;
do {
DibujoaMostrar = DibujoaMostrar+(Number(DibujoEnBinario.charat(NroDelCaracter))*Math.pow(2, DibujoEnBinario.length-1-NroDelCaracter));
NroDelCaracter++;
} while (NroDelCaracter<Cuadraditos);
DibujoaMostrar = Number(DibujoaMostrar);
// Esa cantidad se dividirá según la cantidad de cuadros,
// de modo que cada cuadro mostrará la misma cantidad de...
// dibujos, pero distintos a los de otros cuadros
// (le llamo Disminucion porque se comenzará mostrando...
// el dibujo que según el modo conque los numero
// es el último, y se irá disminuyendo):
Disminucion = Math.floor(DibujoaMostrar/Cuadros);
// trace("DibujoaMostrar calculado desde la L invertida: "+DibujoaMostrar);
MaxCuadraditosAislados = CuadraditosPorFila/2;
}
// Usada en InsertarCuadros una vez (ergo mismo comentario de...
// AjustarVariables):
function ConvertiraBinario (numero) {
// trace("Convirtiendo a binario esto: "+numero);
// Averiguar cómo es en binario:
DibujoEnBinario = "";
while (numero>0) {
DibujoEnBinario = numero%2+DibujoEnBinario;
numero = Math.floor(numero/2);
}
// Agregar 0s a DibujoEnBinario si hacen falta:
while (DibujoEnBinario.length<Cuadraditos) {
DibujoEnBinario = 0+DibujoEnBinario;
}
// trace("DibujoEnBinario: "+DibujoEnBinario);
}
// Usada al inicio y cuando aumenta la cantidad de cuadraditos por fila:
function InsertarCuadros () {
AjustarVariables();
NroDelCuadro = 0;
// Sus columnas y filas se cuentan desde 0 también:
ColumnaDeCuadro = 0;
FilaDeCuadro = 0;
do {
// trace("Se insertará el Cuadro "+NroDelCuadro);
NombreDelCuadro = "Cuadro"+NroDelCuadro;
attachMovie("sCuadro", NombreDelCuadro, NroDelCuadro);
setProperty (NombreDelCuadro, _x, LargoDeCuadros*ColumnaDeCuadro+ColumnaDeCuadro*LargoDeCuadraditos);
setProperty (NombreDelCuadro, _y, LargoDeCuadros*FilaDeCuadro+FilaDeCuadro*LargoDeCuadraditos);
ColumnaDeCuadro++;
if (ColumnaDeCuadro == CuadrosPorFila) {
ColumnaDeCuadro = 0;
FilaDeCuadro++;
}
// Se agregarán y distribuirán cuadraditos en el cuadro...
// recién agregado, numerándolos del modo opuesto:
NroDelCuadradito = MaxCuadradito;
// Sus columnas y filas se cuentan desde 0:
ColumnaDeCuadradito = 0;
FilaDeCuadradito = 0;
// Se pintarán de modo que muestren el dibujo...
// acorde a la división de dibujos; averiguarlo:
ConvertiraBinario(DibujoaMostrar);
// Para luego saber si hay demasiados cuadraditos aislados:
set (NombreDelCuadro+"CuadraditosAislados", 0);
// Para luego saber si hay filas o columnas sin algún pintado:
Puntero = 0;
do {
set (NombreDelCuadro+".PintadosenC"+Puntero, 0);
set (NombreDelCuadro+".PintadosenF"+Puntero, 0);
Puntero++;
} while (Puntero<CuadraditosPorFila);
ColumnaDeCuadradito = 0;
FilaDeCuadradito = 0;
do {
// trace("Se insertará el cuadradito "+NroDelCuadradito);
// trace("ColumnaDeCuadradito: "+ColumnaDeCuadradito);
// trace("FilaDeCuadradito: "+FilaDeCuadradito);
eval(NombreDelCuadro).attachMovie("sCuadradito", "Cuadradito"+NroDelCuadradito, NroDelCuadradito);
NombreDelCuadraditoSinNum = NombreDelCuadro+".Cuadradito";
NombreDelCuadradito = NombreDelCuadraditoSinNum+NroDelCuadradito;
setProperty (NombreDelCuadradito, _x, ColumnaDeCuadradito*LargoDeCuadraditos);
setProperty (NombreDelCuadradito, _y, FilaDeCuadradito*LargoDeCuadraditos);
setProperty (NombreDelCuadradito, _width, LargoDeCuadraditos);
setProperty (NombreDelCuadradito, _height, LargoDeCuadraditos);
ParaColorDelCuadradito = new Color(NombreDelCuadradito);
NroDeColor = Number(DibujoEnBinario.charat(NroDelCuadradito));
// Esto es para modificar con más practicidad el color:
set (NombreDelCuadro+".ColordeCuadradito"+NroDelCuadradito, NroDeColor);
// Esto es la misma variable pero definida de modo que...
// facilita contar el aislamiento del cuadradito
// (y posiblemente otras cosas):
set (NombreDelCuadraditoSinNum+FilaDeCuadradito+"_"+ColumnaDeCuadradito, NroDeColor);
if (NroDeColor == 0) {
ParaColorDelCuadradito.setRGB(0);
// Para evitar repetición de código:
ColumnaRelevante = NombreDelCuadro+".PintadosenC"+ColumnaDeCuadradito;
FilaRelevante = NombreDelCuadro+".PintadosenF"+FilaDeCuadradito;
set (ColumnaRelevante, eval(ColumnaRelevante)+1);
set (FilaRelevante, eval(FilaRelevante)+1);
// Para evitar pasar parámetros repetidamente y...
// no generar caos en los nombres,
// esto se usa en ActualizarConteoDeAisladosPorPinte y ActualizarConteoDeAisladosPorDespinte:
NombreDelCuadroaActualizar = NombreDelCuadro;
ActualizarConteoDeAisladosPorPinte();
} else {
ParaColorDelCuadradito.setRGB(0xFFFFFF);
}
ColumnaDeCuadradito++;
if (ColumnaDeCuadradito == CuadraditosPorFila) {
ColumnaDeCuadradito = 0;
FilaDeCuadradito++;
}
NroDelCuadradito--;
} while (NroDelCuadradito>-1);
// Esto es un indicador que se hará visible cuando...
// un dibujo no cumpla las condiciones:
eval(NombreDelCuadro).attachMovie("sFlecha", "Flecha", Cuadraditos);
NombreDeFlecha = NombreDelCuadro+".Flecha";
setProperty (NombreDeFlecha, _x, LargoDeCuadraditos*CuadraditosPorFila);
setProperty (NombreDeFlecha, _y, LargoDeCuadraditos*CuadraditosPorFila);
setProperty (NombreDeFlecha, _visible, false);
NroDelCuadro++;
DibujoaMostrar = DibujoaMostrar-Disminucion;
// trace("DibujoaMostrar: "+DibujoaMostrar);
// Para que se muestre la cantidad de aislados:
eval(NombreDelCuadro).attachMovie("sShowerDeAislados", "ShowerDeAislados", Cuadraditos+1000);
setProperty (NombreDelCuadro+".ShowerDeAislados", _x, LargoDeCuadraditos*CuadraditosPorFila+33);
setProperty (NombreDelCuadro+".ShowerDeAislados", _y, LargoDeCuadraditos*CuadraditosPorFila-33);
set (NombreDelCuadro+".Aislados", eval(NombreDelCuadro+"CuadraditosAislados"));
} while (NroDelCuadro<Cuadros);
}
// PorFila es también por columna:
CuadrosPorFila = 2;
// Debido a que en cierto chequeo se asume que...
// si el cuadradito no está en la parte inferior ni...
// superior entonces está en una fila intermedia,
// conviene que CuadraditosPorFila comience siendo >2:
CuadraditosPorFila = 3;O sea, se hacen los cálculos con AjustarVariables, y se insertan los cuadros y cuadraditos, y se pintan, todo eso con InsertarCuadros.
Pongo algunos valores:
Con CuadrosPorFila siendo 2 y CuadraditosPorFila siendo 3:
Variable _level0.Cuadros = 4
Variable _level0.MaxCuadro = 3
Variable _level0.Cuadraditos = 9
Variable _level0.MaxCuadradito = 8
Variable _level0.LargoDeCuadraditos = 54.8571428571429
Variable _level0.LargoDeCuadros = 164.571428571429
Variable _level0.DibujoEnBinario = "001101100"
Variable _level0.NroDelCaracter = 9
Variable _level0.AnterioraPintar = -1
Variable _level0.DibujoaMostrar = 0
Variable _level0.Disminucion = 108
Con CuadrosPorFila siendo 3 y CuadraditosPorFila siendo 4:
Variable _level0.Cuadros = 9
Variable _level0.MaxCuadro = 8
Variable _level0.Cuadraditos = 16
Variable _level0.MaxCuadradito = 15
Variable _level0.LargoDeCuadraditos = 27.4285714285714
Variable _level0.LargoDeCuadros = 109.714285714286
Variable _level0.DibujoEnBinario = "0001101010010000"
Variable _level0.NroDelCaracter = 16
Variable _level0.AnterioraPintar = -1
Variable _level0.DibujoaMostrar = 6
Variable _level0.Disminucion = 6794
4 y 5:
Variable _level0.LargoDeCuadraditos = 16.695652173913
Variable _level0.LargoDeCuadros = 83.4782608695652
Variable _level0.DibujoEnBinario = "0000111101111011110111100"
Variable _level0.NroDelCaracter = 25
Variable _level0.AnterioraPintar = -1
Variable _level0.DibujoaMostrar = 0
Variable _level0.Disminucion = 2029500
5 y 6:
Variable _level0.LargoDeCuadraditos = 11.2941176470588
Variable _level0.LargoDeCuadros = 67.7647058823529
Variable _level0.DibujoEnBinario = "000010100001001111010100011100001000"
Variable _level0.NroDelCaracter = 36
Variable _level0.AnterioraPintar = -1
Variable _level0.DibujoaMostrar = 3
Variable _level0.Disminucion = 2705147653
6 y 7:
Variable _level0.LargoDeCuadraditos = 8.17021276595745
Variable _level0.LargoDeCuadros = 57.1914893617021
Variable _level0.DibujoEnBinario = "0000000000000000000000000000000000000000000000000"
Variable _level0.NroDelCaracter = 49
Variable _level0.AnterioraPintar = -1
Variable _level0.DibujoaMostrar = 1.#QNAN
Variable _level0.Disminucion = 1.#QNAN
No sé si será que son números muy grandes o algo falla porque algún número no queda bien dividido.
Parece que esto
DibujoEnBinario = String(Math.pow(10, CuadraditosPorFila));
me da 9999999.99999999
es que Flash hace mal algunas cuentas.
Solucionado así:
DibujoEnBinario = String(Math.round(Math.pow(10, CuadraditosPorFila)));
aunque poniendo números más altos no queda bien el 1er dibujo:
7 y 8:
Variable _level0.LargoDeCuadraditos = 6.19354838709677
Variable _level0.LargoDeCuadros = 49.5483870967742
Variable _level0.DibujoEnBinario = "0000010100110100001110010111001011101011000101001111101001000000"
Variable _level0.NroDelCaracter = 64
Variable _level0.AnterioraPintar = -1
Variable _level0.DibujoaMostrar = 6528
Variable _level0.Disminucion = 3.74987834711663e+017
Esa disminución es un número demasiado grande quizá. En fin, solucioné lo que quería, dejo el tema igual a quien le interese. Otro día intento solucionar este otro problema.
