[Tachikomaia]

Código: [Seleccionar]

0   1   2   3
4   5   6   7
-------------
8   9   10  11
12  13  14  15
Cuando señalo el 0, necesito que P sea 12.
1 --> 13
2 --> 14
3 --> 15
4 --> 8
...
7 --> 11

S=Señalado
P=Opuesto

P=¿?

Algo como S+12-(fila de S*4)

Pero fila puede variar, así que quisiera que la fórmula implique F.

Creo que es algo como S+F*(F-1)-(Fila de S*F)

Este código incluye un método para averiguar el opuesto pero con espejo vertical:

Código: [Seleccionar]

function RepintarCuadrosAzarrazA () {
NroDelCuadroaRepintar = 0;
do {
NroDelCuadraditoaRepintar = 0;
// p representa un ".", "punto".
Cuadro_pCuadradito = "Cuadro"+NroDelCuadroaRepintar+".Cuadradito";
do {
// trace("NroDelCuadraditoaRepintar: "+NroDelCuadraditoaRepintar);
Cuadro_pCuadradito_ = Cuadro_pCuadradito+NroDelCuadraditoaRepintar;
ParaColorDeCuadradito = new Color(Cuadro_pCuadradito_);
ColumnaDeCuadradito = NroDelCuadraditoaRepintar%CuadraditosPorFila;
// trace("ColumnaDeCuadradito: "+ColumnaDeCuadradito);
// trace("ColumnaCentral: "+ColumnaCentral);
if (ColumnaDeCuadradito < ColumnaCentral) {
// trace("ColumnaDeCuadradito < ColumnaCentral");
ColorElegido = PosiblesColores[random(PosiblesColores.length)];
ParaColorDeCuadradito.setRGB(ColorElegido);
// Pintar igual el cuadradito opuesto:
NroDelCuadraditoOpuesto = Math.floor(NroDelCuadraditoaRepintar/CuadraditosPorFila)*CuadraditosPorFila+CuadraditosPorFila-1-(NroDelCuadraditoaRepintar%CuadraditosPorFila);
CuadraditoOpuesto = Cuadro_pCuadradito+NroDelCuadraditoOpuesto;
// trace("NroDelCuadraditoOpuesto: "+NroDelCuadraditoOpuesto);
ParaColorDeCuadradito = new Color(CuadraditoOpuesto);
ParaColorDeCuadradito.setRGB(ColorElegido);
NroDelCuadraditoaRepintar++;
} else if (ColumnaDeCuadradito == ColumnaCentral) {
// trace("ColumnaDeCuadradito == ColumnaCentral");
// No se pinta el opuesto:
ParaColorDeCuadradito.setRGB(PosiblesColores[random(PosiblesColores.length)]);
NroDelCuadraditoaRepintar++;
} else {
// El cuadradito está a la derecha de ColumnaCentral,
// se analizará el 1ero de abajo, si hay, sino termina el loop:
NroDelCuadraditoaRepintar = CuadraditosPorFila*(Math.floor(NroDelCuadraditoaRepintar/CuadraditosPorFila)+1);
}
} while (NroDelCuadraditoaRepintar<Cuadraditos);
NroDelCuadroaRepintar++;
} while (NroDelCuadroaRepintar<Cuadros);
}
Intento hacer lo mismo pero con espejo horizontal:

Código: [Seleccionar]

function RepintarCuadrosAzarAzar () {
NroDelCuadroaRepintar = 0;
do {
NroDelCuadraditoaRepintar = 0;
// p representa un ".", "punto".
Cuadro_pCuadradito = "Cuadro"+NroDelCuadroaRepintar+".Cuadradito";
do {
// trace("NroDelCuadraditoaRepintar: "+NroDelCuadraditoaRepintar);
Cuadro_pCuadradito_ = Cuadro_pCuadradito+NroDelCuadraditoaRepintar;
ParaColorDeCuadradito = new Color(Cuadro_pCuadradito_);
FilaDeCuadradito = Math.floor(NroDelCuadraditoaRepintar/CuadraditosPorFila);
// ColumnaCentral == FilaCentral.
if (FilaDeCuadradito < ColumnaCentral) {
ColorElegido = PosiblesColores[random(PosiblesColores.length)];
ParaColorDeCuadradito.setRGB(ColorElegido);
// Pintar igual el cuadradito opuesto:
NroDelCuadraditoOpuesto = Math.floor(NroDelCuadraditoaRepintar/CuadraditosPorFila)*CuadraditosPorFila+CuadraditosPorFila-1-(NroDelCuadraditoaRepintar%CuadraditosPorFila);
CuadraditoOpuesto = Cuadro_pCuadradito+NroDelCuadraditoOpuesto;
ParaColorDeCuadradito = new Color(CuadraditoOpuesto);
ParaColorDeCuadradito.setRGB(ColorElegido);
} else {
// No se pinta el opuesto:
ParaColorDeCuadradito.setRGB(PosiblesColores[random(PosiblesColores.length)]);
}
NroDelCuadraditoaRepintar++;
} while (FilaDeCuadradito <= ColumnaCentral);
NroDelCuadroaRepintar++;
} while (NroDelCuadroaRepintar<Cuadros);
}

[Richard R Richard]

Hola cada casillero tiene dos coordenadas una es la fila y la otra es la columna, lo único que estas necesitando es cambiar la coordenada de fila, 

Si la primera fila es la 1, le asigna del valor de fila a fila_vieja, si tienes en total  $$f$$ filas (o sea $$f^2$$ casilleros) en este caso $$f=4$$ entonces  el nuevo número de fila es $$fila\_nueva=  f-fila\_vieja+1$$ , cambia la 1 x4 y la 2x3 y viceversa

Si la primera fila es la 0, le asigna del valor de fila a fila_vieja, si tienes en total  $$f$$ filas (o sea $$f^2$$ casilleros) en este caso $$f=4$$ entonces  el nuevo número de fila es $$fila\_nueva=  f-fila\_vieja-1$$, cambia la 0 x 3 y la 1 x 2 y viceversa

Por las dudas  para sacar el número de fila viejo empezando por el 1 para el esquema que presentaste donde N es el numero representado en el casilla, su fila_vieja será $$fila\_vieja=N//f+1$$  es decir la parte entera de la división del numero del casillero entre el número total de filas +1.
y si empieza en 0 simplemente $$fila\_vieja=N//f$$

El numero de columna no se altera  según lo que dices, entonces  siempre $$columna=(N)\% f+1$$  que es el resto de la división entre $$N$$ y $$f$$ mas 1 ,  si es que empieza en 1   y si empieza en 0 entonces  solo es $$columna=(N)\% f$$


si quieres saber el número que queda en un casillero en el que estaba el numero N  es $$N(nuevo)=(f-N//f) \cdot 4+(N)\%f+1$$ si  la numeración empieza en 1
si quieres saber el número que queda en un casillero en el que estaba el numero N  es $$N(nuevo)=(f-N//f-1) \cdot 4+(N)\%f$$ si  la numeración empieza en 0

[Luis Fuentes]

Hola

 En general si tu tablero es de \( m \) filas y \( n \) columnas al número \( S \) le corresponde:

\(  S\to S+(m-1-2[S/n])\cdot n \)

 donde \( [S/n] \) es la función parte entera.

 Por ejemplo para el tablero \( 4\times 4 \) que has puesto:

\(  S\to S+(3-2[S/4])\cdot 4 \)

Saludos.

[Tachikomaia]

Me expresé mal acá
"Pero fila puede variar, así que quisiera que la fórmula implique F."
quise decir "Pero la cantidad de filas (F) puede variar, así que quisiera que la fórmula implique F."
La cantidad de filas siempre es igual a la cantidad de columnas.

Si la primera fila es la 0, le asigna del valor de fila a fila_vieja, si tienes en total  $$f$$ filas (o sea $$f^2$$ casilleros) en este caso $$f=4$$ entonces  el nuevo número de fila es $$fila\_nueva=  f-fila\_vieja-1$$, cambia la 0 x 3 y la 1 x 2 y viceversa

A ver...

Filas es 4.
Si fila pintándose es 0, la opuesta es 4-0-1 = 3. Correcto.
Si fila pintándose es 1, la opuesta es 4-1-1 = 2.
Muy bien.

Filas es 5.
0 -> 5-0-1 = 4. Ok.
1 -> 5-1-1 = 3. Ok.
2 -> 5-2-1 = 2. En realidad este caso de "la mitad" creo que no lo necesito, sólo estaba probando.

 

si quieres saber el número que queda en un casillero en el que estaba el numero N  es $$N(nuevo)=(f-N//f-1) \cdot 4+(N)\%f$$ si  la numeración empieza en 0

Si filas es 4:
Si el casillero es el nro 0:
No estoy seguro de poder hacer bien las operaciones:
(4-0/4-1)*4+0%4 =
(4-0-1)*4+0 =
(3)*4+0 = 12, bien.

Si el casillero es el nro 1:
(4-1/4-1)*4+1%4 =
(4-0.25-1)*4+1 =
(2.75)*4+1 =
8 + 3 + 1 = 12 ¿hice algo mal?

Pruebo la fórmula en el programa.

No me funciona bien.

Se supone que dices esto:
(filas-casillero/filas-1)*4+casillero%filas

Puse:
NroDelCuadraditoOpuesto = (CuadraditosPorFila-NroDelCuadraditoaRepintar/CuadraditosPorFila-1)*4+NroDelCuadraditoaRepintar%CuadraditosPorFila;

Con 6 filas, dice:
El opuesto del cuadradito 0 es 20
El opuesto del cuadradito 1 es 20.3333333333333
El opuesto del cuadradito 2 es 20.6666666666667
El opuesto del cuadradito 3 es 21
etc

Pruebo cambiar el 4 por filas.

El opuesto del cuadradito 0 es 30
El opuesto del cuadradito 1 es 30
etc

No sirvió.

Hola

 En general si tu tablero es de \( m \) filas y \( n \) columnas al número \( S \) le corresponde:

\(  S\to S+(m-1-2[S/n])\cdot n \)

Lo interpreto así
casillero+(filas-1-2*(casillero/filas)*filas

Puse esto:
NroDelCuadraditoOpuesto = NroDelCuadraditoaRepintar+(CuadraditosPorFila-1-2*(NroDelCuadraditoaRepintar/CuadraditosPorFila))*CuadraditosPorFila;

Con filas 6 me da:
El opuesto del cuadradito 0 es 30
El opuesto del cuadradito 1 es 29
El opuesto del cuadradito 2 es 28
El opuesto del cuadradito 3 es 27
El opuesto del cuadradito 4 es 26
El opuesto del cuadradito 5 es 25
El opuesto del cuadradito 6 es 24
El opuesto del cuadradito 7 es 23
El opuesto del cuadradito 8 es 22
etc, algo está mal, tiene que aumentar hasta 35 creo, luego bajar, aumentar...

Con filas 4:
El opuesto del cuadradito 0 es 12
El opuesto del cuadradito 1 es 11
El opuesto del cuadradito 2 es 10
El opuesto del cuadradito 3 es 9
El opuesto del cuadradito 4 es 8
Ves que no, tiene que ir aumentando y bajar recién en 4, 4 está bien.

---------------------------------------------------------------

Fijense que yo haya aplicado bien las fórmulas, capáz que copié mal.

[Richard R Richard]

Si el casillero es el nro 1:
(4-1/4-1)*4+1%4 =
(4-0.25-1)*4+1 =
(2.75)*4+1 =
8 + 3 + 1 = 12 ¿hice algo mal?

A ver $$N(nuevo)=(f-N//f-1) \cdot \color{red}f\color{black}+(N)\%f$$  corregido generalizado
si $$N=1$$ y $$f=4$$

$$N(nuevo)=(4-1//4-1) \cdot 4+(1)\%4$$

$$N(nuevo)=(4-0-1) \cdot 4+1$$

$$N(nuevo)=3\cdot 4+1=13$$


recuerda // te devuelve  la parte entera(puedes usar la función int())  y % el resto de la división   

$$1//4=0$$  y otros  ejemplos como $$5//4=1$$ o $$ 11//4=2$$
$$1\%4=1$$ y luego  $$5\%4=1$$ o $$11\%4=3$$


entonces de ahí puedes ver  que se cumple $$1=0\cdot4+1$$   o  $$ 5=1\cdot 4+1$$   o $$ 11=2\cdot 4+3$$

[Tachikomaia]

Me parecía raro que pusieras //, por lo que veo significa división sin agregar decimales.

Lo pruebo más tarde, que estoy liado con unos malware de unos discos antiguos.

Hace rato ya que está así...

[Tachikomaia]

Tardé porque anduve mucho en Youtube, supongo.

Estoy un poco confundido con los // porque me lo dijiste como si fuese lo más normal del mundo pero en google no lo encontré y GPT me dijo

No es exclusivo de Python, pero sí es donde más se popularizó con ese significado. Varios lenguajes lo usan, aunque no todos con exactamente el mismo comportamiento:

- Python: // es floor division matemática. Ej.: -2 // 3 = -1.
- Dart: // es integer division que trunca hacia 0. Ej.: -2 // 3 = 0.
- Julia: div(a, b) es la función; el operador // existe pero crea racionales (2//3 es un Rational), no división entera.
- Kotlin: no tiene //; usa / con Int y Long (trunca hacia 0). Para floor real: floorDiv(a, b).
- Java: no tiene //; / con enteros trunca hacia 0. Para piso euclidiano: Math.floorDiv(a, b).
- C/C++/Go/Rust: no tienen //; / con enteros trunca hacia 0. En Rust existe div_euclid para división euclidiana (similar a floor para signos positivos).
- Ruby/PHP/JavaScript: no tienen // con ese sentido. En JS // es comentario; en PHP existe intdiv(a, b); en Ruby / con enteros suele truncar hacia 0 (y hay métodos como div, fdiv, etc.).

Resumen:
- Como operador // con “división entera”: común en Python y Dart (pero ojo: Python hace floor matemático; Dart trunca hacia 0).
- En la mayoría de otros lenguajes, no existe //; la división entera se hace con / sobre tipos enteros o con funciones utilitarias.

Si me dices el lenguaje, te digo exactamente cómo hacer la división tipo floor allí.

No sé a qué llama "division matemática." El Ej.: -2 // 3 = -1.
tampoco ayuda, no sé si redondea hacia arriba o eleva hacia arriba. No, hacia abajo porque -0.666... redondeado hacia abajo es -1. No estoy seguro.

Pruebo reducir hacia abajo, que se supone es floor.

El opuesto del cuadradito 0 es 12
El opuesto del cuadradito 1 es 13
El opuesto del cuadradito 2 es 14
El opuesto del cuadradito 3 es 15
El opuesto del cuadradito 4 es 8
El opuesto del cuadradito 5 es 9
El opuesto del cuadradito 6 es 10
El opuesto del cuadradito 7 es 11

Bien  pero los colores no se están transmitiendo bien, tendré que ver por qué.

[Tachikomaia]

Corregí mi problema creo, la fórmula me sirvió con 4x4 pero falla con más, por ejemplo con 5x5:
El opuesto del cuadradito 0 es 16
El opuesto del cuadradito 1 es 17
El opuesto del cuadradito 2 es 18
El opuesto del cuadradito 3 es 19
El opuesto del cuadradito 4 es 20
El opuesto del cuadradito 5 es 12
El opuesto del cuadradito 6 es 13
El opuesto del cuadradito 7 es 14
El opuesto del cuadradito 8 es 15
El opuesto del cuadradito 9 es 16

Debería ser
0 - 20
1 - 21
etc
0 1 2 3 4
5 6 7 8 9
10 11 12 13 14
15 16 17 18 19
20 21 22 23 24

Fijate si puse algo mal

Código: [Seleccionar]

function RepintarCuadrosAzarAzar () {
NroDelCuadroaRepintar = 0;
do {
NroDelCuadraditoaRepintar = 0;
// p representa un ".", "punto".
Cuadro_pCuadradito = "Cuadro"+NroDelCuadroaRepintar+".Cuadradito";
do {
// trace("NroDelCuadraditoaRepintar: "+NroDelCuadraditoaRepintar);
Cuadro_pCuadradito_ = Cuadro_pCuadradito+NroDelCuadraditoaRepintar;
ParaColorDeCuadradito = new Color(Cuadro_pCuadradito_);
FilaDeCuadradito = Math.floor(NroDelCuadraditoaRepintar/CuadraditosPorFila);
// ColumnaCentral == FilaCentral.
if (FilaDeCuadradito < ColumnaCentral) {
ColorElegido = PosiblesColores[random(PosiblesColores.length)];
ParaColorDeCuadradito.setRGB(ColorElegido);
// Pintar igual el cuadradito opuesto:
NroDelCuadraditoOpuesto = (CuadraditosPorFila-Math.floor(NroDelCuadraditoaRepintar/CuadraditosPorFila)-1)*4+NroDelCuadraditoaRepintar%CuadraditosPorFila;
trace("El opuesto del cuadradito "+NroDelCuadraditoaRepintar+" es "+NroDelCuadraditoOpuesto);
// trace("ColorElegido: "+ColorElegido);
CuadraditoOpuesto = Cuadro_pCuadradito+NroDelCuadraditoOpuesto;
ParaColorDeCuadradito = new Color(CuadraditoOpuesto);
ParaColorDeCuadradito.setRGB(ColorElegido);
} else if (FilaDeCuadradito == ColumnaCentral) {
// trace("El opuesto del cuadradito "+NroDelCuadraditoaRepintar+" no existe");
// No se pinta el opuesto:
ParaColorDeCuadradito.setRGB(PosiblesColores[random(PosiblesColores.length)]);
}
NroDelCuadraditoaRepintar++;
// trace(FilaDeCuadradito+" <= "+ColumnaCentral);
} while (FilaDeCuadradito <= ColumnaCentral);
NroDelCuadroaRepintar++;
} while (NroDelCuadroaRepintar<Cuadros);
}
En resumen:
NroDelCuadraditoOpuesto = (CuadraditosPorFila-Math.floor(NroDelCuadraditoaRepintar/CuadraditosPorFila)-1)*4+NroDelCuadraditoaRepintar%CuadraditosPorFila;

Probablemente hay que cambiar el 4 por CuadraditosPorFila.

Pero probé algo que había pensado y funcionó:
NroDelCuadraditoOpuesto = CuadraditosPorFila*(CuadraditosPorFila-1)+NroDelCuadraditoaRepintar%CuadraditosPorFila-FilaDeCuadradito*CuadraditosPorFila;

Primero obtenemos el mínimo casillero de abajo. En el caso de 5x5 es 20. Eso se logra así:
CuadraditosPorFila*(CuadraditosPorFila-1)

2ndo: Sabemos que cuanto mayor sea la columna del casillero, mayor será el opuesto.
Y la fila hace lo contrario, reduce el valor.
Bueno, con esto sumamos la columna:
NroDelCuadraditoaRepintar%CuadraditosPorFila

Y con esto restamos lo que corresponde de la fila:
FilaDeCuadradito*CuadraditosPorFila

En resumen:
Mínimo cuadradito inferior
+
Columna del cuadradito señalado
-
Fila del cuadradito señalado * total de filas

Es:
CuadraditosPorFila*(CuadraditosPorFila-1)
+
NroDelCuadraditoaRepintar%CuadraditosPorFila
-
FilaDeCuadradito*CuadraditosPorFila

FilaDeCuadradito ya lo habíamos definido:
FilaDeCuadradito = Math.floor(NroDelCuadraditoaRepintar/CuadraditosPorFila);

Muestra:

[Luis Fuentes]

Hola

 En general si tu tablero es de \( m \) filas y \( n \) columnas al número \( S \) le corresponde:

\(  S\to S+(m-1-2[S/n])\cdot n \)

Lo interpreto así
casillero+(filas-1-2*(casillero/filas)*filas

Puse esto:
NroDelCuadraditoOpuesto = NroDelCuadraditoaRepintar+(CuadraditosPorFila-1-2*(NroDelCuadraditoaRepintar/CuadraditosPorFila))*CuadraditosPorFila;

Con filas 6 me da:
El opuesto del cuadradito 0 es 30
El opuesto del cuadradito 1 es 29
El opuesto del cuadradito 2 es 28
El opuesto del cuadradito 3 es 27
El opuesto del cuadradito 4 es 26
El opuesto del cuadradito 5 es 25
El opuesto del cuadradito 6 es 24
El opuesto del cuadradito 7 es 23
El opuesto del cuadradito 8 es 22
etc, algo está mal, tiene que aumentar hasta 35 creo, luego bajar, aumentar...

Tienes que prestar atención a los detalles. 

Parece que has despreciado esta frase:

En general si tu tablero es de \( m \) filas y \( n \) columnas al número \( S \) le corresponde:

\(  S\to S+(m-1-2[S/n])\cdot n \)

donde \( [S/n] \) es la función parte entera.

 Tú estas tomando la división \( S/n \); pero es la PARTE ENTERA DE ESA DIVISIÓN.

 En algunos lenguajes es floor(S/n) ó Math.floor(S/n). No sé en el que usas tú. Algo así:

NroDelCuadraditoOpuesto = NroDelCuadraditoaRepintar+(CuadraditosPorFila-1-2*floor(NroDelCuadraditoaRepintar/CuadraditosPorFila))*CuadraditosPorFila;

Saludos.

[Richard R Richard]

Hola, de la forma que te lo he presentado,  si tienes un cuadrado de $$f$$ por $$f$$ casilleros numerados desde $$0$$ hasta $$f^2-1$$ empezando  de arriba a la izquierda,  siguiendo  a derecha, entonces vale


$$N(nuevo)=(f-N//f-1) \cdot f+(N)\%f$$
Recuerda // es una funcion que te devuelve la parte entera de una división
y % te devuelve el resto  de una división.

Saludos