[Tachikomaia]

No entiendo bien el problema 

Escribí esto:

Código: [Seleccionar]

// Generador de cuadrados.
//
// Se colocarán cuadros numerados así:
// 0 1 2
// 3 4 5
// 6 7 8
// El usuario puede modificar la cantidad por fila.
// La cantidad por columna será igul a por fila.
//
// Todo se cuenta desde 0 (ej: el cuadro 0 es el 1ero),
// excepto lo que diga 1 al final (salvo el Cuadro1, etc.
// nombres de cosas numeradas generadas semiautomáticamente).
function AjustarVariables () {
MaxCuadro1 = CuadrosPorFila*CuadrosPorFila;
MaxCuadro = MaxCuadro1-1;
Lo que intento expresar es que en algunos casos el 1er elemento que se ve se representa con 0. Muchas cosas de las computadoras están hechas de ese modo, y varios cálculos son más fáciles así.

Pero tampoco es anormal que algo se cuente "normal", por ejemplo CuadrosPorFila, casilleros por fila o lo que sea, se cuenta normal, es un total, el 0 representa 0. Parece un disparate agregarle 1 al nombre para indicar que eso se cuenta desde 1.

Pero no es que tantas cosas se cuenten desde 1. El 1er valor de una posible distancia es 0.

En fin, yo puedo agregar un 0 a algunos nombres o un 1 a otros, me pregunto qué sería lo más sensato, o qué alternativa hay.

Ahora se me ocurre que si algo es +1 de lo que dice ser, le puedo poner 1 al final del nombre, pero no... porque por ejemplo si tengo:
Objeto0
Objeto1
etc
no le puedo poner un 1 al final o se cambia a 01, 11, etc. Le puedo poner:
Objeto1_0
Objeto1_1
pero ese estilo lo usaba para otra cosa.

¿Podrían orientarme sobre cómo es esto, cómo describir las cosas y/o qué hacer para evitar confusiones?

Otro ejemplo: Si mal no recuerdo, en cierto punto 512 dibujos son posibles, pero si quiero traducir el dibujo a binario, como 9 cuadraditos pintados o despintados, le tengo que restar 1, porque en binario el dibujo 000... es decir todo pintado (0 es pintado en mi caso, porque el color negro es 000000 y se entiende mejor como el mínimo valor entonces), es el dibujo nro 1. Al dibujo nro 1 lo representa el 0. Al 512 lo representa el 511 convertido a binario. Yo que sé 

[Richard R Richard]

En fin, yo puedo agregar un 0 a algunos nombres o un 1 a otros, me pregunto qué sería lo más sensato, o qué alternativa hay.

Hola, todo depende el idioma que usas, es muy relativo a ello, lo normal es entender cómo ese lenguaje trata a las enumeraciones, , si empieza del 0 o si empieza del 1, eso está en los manuales.
La mayoría de los lenguaje modernos, enumera y puedes acceder al primer elemento de una lista con el subíndice cero, así que te recomiendo que siempre uses contadores que arranquen en ese número.

Cuando usas bucles para recorrerlos usa limites como  $$ (0,n^2)$$ , esto recorre los $$n^2$$ elementos , empezando por el $$0$$ y termina sin ejecutar el bucle cuando lee $$n^2$$, así que el último elemento será $$n^2-1$$

Si persistes en mantener contadores que arranquen en 1,(porque te gusta o la razón que fuera) me parece muy inteligente ponerle la aclaración al nombre con un último carácter , para que no se te olvide como llamar a las cadenas utilizando esas variables.

Pd :512 no es un cuadrado(es 2 elevado a exponente impar), serán 256 o 1024 cuadrados.

Que ej  0000 sea todo pintado (para n=4 cifras), lo decides tu, puedes siempre hacer el dibujo inverso restándoselo en binario al numero máximo $$(2^n-1)=7\equiv 1111 $$ entonces siguiendo el ejemplo  $$1111 - 0000 =1111$$  y este sería todo pintado

$$1111-0001 =1110$$   observa que de esa forma se cambia un cero por uno y viceversa.

Saludos

[feriva]

¿Podrían orientarme sobre cómo es esto, cómo describir las cosas y/o qué hacer para evitar confusiones?

Es que hay dos cuestiones distintas. Quizá el matiz es muy sutil, pero una cosa es “enumerar” (poner una etiqueta a lo que vas distinguiendo) y otra cosa, añadida al proceso de enumerar, es “contar”. El hecho de contar implica obtener una información sobre la cantidad que has enumerado, saber cuántas cosas hay hasta donde has enumerado. Si tienes dos lápices y, al contarlos, primero dices “cero” y después “uno”, la última etiqueta con coincide con la cantidad, en realidad, cuando dices “uno”, esa etiqueta está distinguiendo la cantidad “dos”. Cuando haces un bucle en el ordenador, normalmente, el “cero” quiere decir el “primer paso”, no quiere decir que hayas dado cero pasos; no cuenta los pasos de forma directa según lo que significa la cantidad, los enumera desde cero. Y eso es lo que tienes que tener en presente, nada más; si cuentas, por ejemplo, 10 desde cero, entonces llegas a 9, que quiere decir que has contado 10.

Si cuentas los bits totales de un byte, o sea, los unos y los ceros, pues en cada celda se mete un 1 ó un 0, pero a cada cero le corresponde asignarlo a una celda, a una unidad, con lo que en un byte cuentas 8 unidades; no tiene nada que ver con la “cantidad cero”, que no es ninguna cantidad, es un número, pero no una cantidad.

Saludos.

[Tachikomaia]

Puede ser que cuando algo se mide, cada valor se representa tal cual es.

Pero cuando se hace una lista de cosas, la 1era cosa o el 1er elemento suele representarse como la/el nro 0, o en cálculos conviene que lo sea.

Por ahora pondré esto (quisiera que lo mejoren):

Código: [Seleccionar]

// Hay 2 tipos de representaciones, referencias,
// conteos, nombramientos o no sé bien qué,
// que es importante poder distinguir:
// Por ejemplo la cantidad de píxeles en una fila de...
// una hoja se representa tal cual es: Por ejemplo...
// el valor 8 significa que son 8. Es como "lo normal".
// En los array, en cambio, el 1er elemento se...
// representa o se le considera como el nro 0,
// y así para nombrar a un elemento que realmente...
// es el nro X, hay que usar X-1.
// Debido a que muchos cálculos son más eficientes...
// "contando" así, así lo haré en muchos casos.
// Pero para distinguir de cual se trata, se pondrá...
// una minúscula al inicio de una variable:
// Una mínúscula n significa que su valor tiene...
// traducción normal o literal (no uso la l porque no...
// la vería bien).
// Y una minúscula u significa que representa +uno...
// de lo que dice, y que para referirse a un valor que...
// normalmente sería X, hay que hacerle -uno.
Menudo lío

Cuando usas bucles para recorrerlos usa limites como  $$ (0,n^2)$$ , esto recorre los $$n^2$$ elementos , empezando por el $$0$$ y termina sin ejecutar el bucle cuando lee $$n^2$$, así que el último elemento será $$n^2-1$$

Me gusta poner "<" o ">" en vez de "<=" o ">=", ya que lo considero más eficiente, la PC sólo tiene que mirar si es "<", no si es "< o ==".
También prefiero el bucle que inicia y luego mira si debe terminar, porque si quieres que inicie, siempre, entonces es en vano hacer mirar la condición cuando empieza, pero quizá esto sea cuestión de gustos.
Suelo hacerlo así:

Código: [Seleccionar]

Repeticion = -1
do
   Repeticion++
   // proceso.
mientras Repeticion < LimiteEso aplica el proceso hasta que Repetición es igual que Límite, inclusive.
Creo que me dices que lo haga así:

Código: [Seleccionar]

Repeticion = 0
do
   // proceso.
   Repeticion++
mientras Repeticion < Limite De ese modo no hace el inclusive. Bien, aunque no sé si esto era mi problema. Capaz que me evito tener que crear ciertas variables "iguales" que son -1 o +1.

512 es 2^9 según vi ¿cuántos dibujos posibles de 2 colores puede haber en una hoja de 3*3?
2*2*2... 9 veces. 2^9.
No dije que fuera basado en una cantidad par... Par es la cantidad de colores o valores de los píxeles, pero la cantidad de píxeles en el cálculo que hice, es impar.
Esto creo que ya lo resolví, pero te lo explico. De esos 512 dibujos, 1/4 quiero que se muestren un en cuadro, otro 1/4 en otro cuadro, y así sucesivamente, son 4 cuadros. Y se muestran "hacia atrás", así:
Cuadro0 muestra el nro 512, luego el nro 511, etc.
Cuadro1 muestra el nro 386 (creo), luego el nro 385...
Cuadro2 y 3, te imaginas.
¿Cómo es el dibujo 512? Le pedí a Deepseek que lo conviera a binario y me dijo 1000... un número de 10 cifras. ¡Pero son 9 píxeles, no 10! La solución es que aunque sean 512 dibujos, se considere que el máximo es el 511, uno menos, porque en binario el valor 0 representa el dibujo nro 1. Sé que está un poco enredada la explicación, pero comprenderás que no lo entiendo del todo, por eso está así.

Los dibujos los modifico apuntando a distintos píxeles, si se puede disminuir (pintar) ya esta y sino se aumenta (despinta) y se mira el anterior hasta poder pintar uno o hasta que no haya más.
Si modifico valores como dices ¿podría saber fácil desde dónde se modificaron? Desde qué posición, digo. Sino habría que actualizar todos los colores cada vez, cuando bastaría con actualizar los que se modificaron.
Modificar como dices puede que sea más fácil pero a estas alturas, para mí, implementarlo creo que no, ya lo tengo del otro modo. Lo malo de mi modo es que hay un proceso que se repite. Bueno, lo anoto en la lista de posibles mejoras.

[Richard R Richard]

Cuando usas bucles para recorrerlos usa limites como  $$ (0,n^2)$$ , esto recorre los $$n^2$$ elementos , empezando por el $$0$$ y termina sin ejecutar el bucle cuando lee $$n^2$$, así que el último elemento será $$n^2-1$$

Me gusta poner "<" o ">" en vez de "<=" o ">=", ya que lo considero más eficiente, la PC sólo tiene que mirar si es "<", no si es "< o ==".
También prefiero el bucle que inicia y luego mira si debe terminar, porque si quieres que inicie, siempre, entonces es en vano hacer mirar la condición cuando empieza, pero quizá esto sea cuestión de gustos.
Suelo hacerlo así:

Código: [Seleccionar]

Repeticion = -1
do
   Repeticion++
   // proceso.
mientras Repeticion < Limite

Hola aqui limite es el numero de veces que quieres que el loop se ejecute, en el caso que quieras que n=1  osea se ejecuta una sola vez

Al sumar 1 previo al proceso  la variable Repetición se pone en cero, y puedes usar esta variable para traer el primer elemento de una lista, cuando se evalúa posteriormente , evalúa 0<1 que es verdadero y vuelve a la instrucción  do , ejecuta el proceso y evalúa 1<1 allí corta, pero ejecutó 2 veces el proceso , así que así no te funciona, tiene que ser

Código: [Seleccionar]

Repeticion = -1
do while Repeticion < Limite
   Repeticion++
   // proceso.


Eso aplica el proceso hasta que Repetición es igual que Límite, inclusive.
Creo que me dices que lo haga así:

Código: [Seleccionar]

Repeticion = 0
do
   // proceso.
   Repeticion++
mientras Repeticion < Limite

Así si funciona, pero tambien te funciona esto

Código: [Seleccionar]

Repeticion = 0
do while Repeticion < Limite
   // proceso.
   Repeticion++


512 es 2^9 según vi ¿cuántos dibujos posibles de 2 colores puede haber en una hoja de 3*3?
2*2*2... 9 veces. 2^9.

Ahora entendí lo que decias , desestima lo que te dije antes porque me refería a otra cosa...

Si cada pixel o cuadradito puede tener $$x$$ colores y son n^2 cuadraditos para formar una imagen entonces puedes formar

$$x^{n^2}$$ imagenes diferentes , la primera la llamas con el 0, (toda del mismo color que elijas que represente el cero) y la ultima será $$x^{n^2}-1$$
así que sí, si tienes dos colores , negro y blanco para 0 y 1, en un cuadrado de 3x3 pixeles o cuadraditos entonces puedes formar $$2^{3^2}=2^9=512$$ imágenes diferentes. 
luego si quieres presentar en pantalla varias de esas imágenes a la vez en una pantalla de m x m cuadrados , deberás pasar de pantalla  de alguna forma para presentar los siguientes m x m imágenes
tendras $$y=int(\dfrac{x^{n^2}}{m^2})+1$$ pantallas diferentes para visualizar todas las imágenes diferentes que puedes crear con esos parámetros.

¿Cómo es el dibujo 512? Le pedí a Deepseek que lo conviera a binario y me dijo 1000...

tantas veces  adivina que alguna vez acertará,

El 512 en binario es 1000000000 , pero tu tienes que representar del 0 al 511 que son 512 imágenes , y no tienes porque usar el 512 convertido a binario es decir vas del 000000000 al 111111111 , si cuentas son 512 imágenes diferentes pero ninguna la llamas con el número 512, ni su dibujo es la representación del 512.

ejemplo sencillo  un cuadrado de 2x2 y 2 colores  son $$x^{n^2}=2^{2^2}=2^4= 16$$ opciones , el 16 seria 10000 pero no lo usas  vas del

00   00   00   00   01   01   01   01   10   10   10   10   11   11   11   11
00   01   10   11   00   01   10   11   00   01   10   11   00   01   10   11   

osea enumeras desde el 0000 hasta el 1111 (del 0 al 15) pero nunca usas el 10000 o (16)


Saludos 

[Tachikomaia]

Luego continúo respondiendo, simplemente quería avisar que aparentemente ya logré lo que quería. Le pregunté a GPT cómo mejorar mi descripción pero yo inspirado por lo que me dijeron, bueno, así está:

Código: [Seleccionar]

// Generador de dibujos.
//
// Se insertarán cuadros numerados así:
// 0 1
// 2 3
// En cada uno se insertarán cuadraditos numerados del mismo modo.
function AjustarVariables () {
Cuadros = CuadrosPorFila*CuadrosPorFila;
MaxCuadro = Cuadros-1;
Cuadraditos = CuadraditosPorFila*CuadraditosPorFila;
MaxCuadradito = Cuadraditos-1;
LargoDeCuadraditos = 384/(CuadraditosPorFila*CuadrosPorFila+CuadrosPorFila-1);
LargoDeCuadros = CuadraditosPorFila*LargoDeCuadraditos;
// Si cada cuadradito tuviera 2 colores posibles:
DibujosPosibles = Math.pow(2, Cuadraditos);
// 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:
Disminucion = DibujosPosibles/Cuadros;
// Se llama disminución porque se comenzará mostrando...
// el dibujo que según el modo conque los numero,
// es el último, y se irá disminuyendo:
DibujoaMostrar = DibujosPosibles-1;
}
function InsertarCuadros () {
AjustarVariables();
NroDelCuadroaColocar = 0;
// Sus columnas y filas se cuentan desde 0 también:
Columna = 0;
Fila = 0;
do {
NombreDelCuadro = "Cuadro"+NroDelCuadroaColocar;
attachMovie("sCuadro", NombreDelCuadro, NroDelCuadroaColocar);
setProperty (NombreDelCuadro, _x, LargoDeCuadros*Columna+Columna*LargoDeCuadraditos);
setProperty (NombreDelCuadro, _y, LargoDeCuadros*Fila+Fila*LargoDeCuadraditos);
Columna++;
if (Columna == CuadrosPorFila) {
Columna = 0;
Fila++;
}
// Se agregarán y distribuirán cuadraditos en el cuadro...
// recién agregado, numerándolos del mismo modo:
NroDelCuadraditoaColocar = 0;
// 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:
// Averiguar cómo es en binario:
DibujoEnBinario = "";
Resto = DibujoaMostrar;
while (Resto>0) {
DibujoEnBinario = Resto%2+DibujoEnBinario;
Resto = Math.floor(Resto/2);
}
// Agregar 0s a DibujoEnBinario si hacen falta:
while (DibujoEnBinario.length<Cuadraditos) {
DibujoEnBinario = 0+DibujoEnBinario;
}
trace("DibujoEnBinario: "+DibujoEnBinario);
do {
eval(NombreDelCuadro).attachMovie("sCuadradito", "Cuadradito"+NroDelCuadraditoaColocar, NroDelCuadraditoaColocar);
NombreDelCuadradito = NombreDelCuadro+".Cuadradito"+NroDelCuadraditoaColocar;
setProperty (NombreDelCuadradito, _x, ColumnaDeCuadradito*LargoDeCuadraditos);
setProperty (NombreDelCuadradito, _y, FilaDeCuadradito*LargoDeCuadraditos);
setProperty (NombreDelCuadradito, _width, LargoDeCuadraditos);
setProperty (NombreDelCuadradito, _height, LargoDeCuadraditos);
ColorDelCuadradito = new Color(NombreDelCuadradito);
NroDeColor = Number(DibujoEnBinario.charat(NroDelCuadraditoaColocar));
if (NroDeColor == 0) {
ColorDelCuadradito.setRGB(0);
} else {
ColorDelCuadradito.setRGB(0xFFFFFF);
}
// Esto es para modificar con más practicidad el color:
set (NombreDelCuadro+".ColordeCuadradito"+NroDelCuadraditoaColocar, NroDeColor);
// Esto es la misma variable pero definida de modo que...
// facilita contar el aislamiento del cuadradito:
set (NombreDelCuadro+".ColordeCuadradito"+FilaDeCuadradito+"_"+ColumnaDeCuadradito, 1);
ColumnaDeCuadradito++;
if (ColumnaDeCuadradito == CuadraditosPorFila) {
ColumnaDeCuadradito = 0;
FilaDeCuadradito++;
}
NroDelCuadraditoaColocar++;
} while (NroDelCuadraditoaColocar<Cuadraditos);
NroDelCuadroaColocar++;
DibujoaMostrar = DibujoaMostrar-Disminucion;
} while (NroDelCuadroaColocar<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;
InsertarCuadros();


Separadas con gris, 4 hojas que muestran los dibujos:
DibujoEnBinario: 111111111
DibujoEnBinario: 101111111
DibujoEnBinario: 011111111
DibujoEnBinario: 001111111

Que son (contando desde 0):
el nro 511
nro 383
255
127

Luego haré que esos dibujos varíen.

Por otro lado tengo el programa que generaría cuadrados, pero su código es un lío debido a la situación que comenté al inicio. Ahora que tengo un código más claro, supongo que lo podré continuar bien.